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 <linux/version.h>
  32 #include <asm/div64.h>
  33
  34 #include "dvb_frontend.h"
  35 #include "drxk.h"
  36 #include "drxk_hard.h"
  37
  38 static int PowerDownDVBT(struct drxk_state *state, bool setPowerMode);
  39 static int PowerDownQAM(struct drxk_state *state);
  40 static int SetDVBTStandard(struct drxk_state *state,
  41                            enum OperationMode oMode);
  42 static int SetQAMStandard(struct drxk_state *state,
  43                           enum OperationMode oMode);
  44 static int SetQAM(struct drxk_state *state, u16 IntermediateFreqkHz,
  45                   s32 tunerFreqOffset);
  46 static int SetDVBTStandard(struct drxk_state *state,
  47                            enum OperationMode oMode);
  48 static int DVBTStart(struct drxk_state *state);
  49 static int SetDVBT(struct drxk_state *state, u16 IntermediateFreqkHz,
  50                    s32 tunerFreqOffset);
  51 static int GetQAMLockStatus(struct drxk_state *state, u32 *pLockStatus);
  52 static int GetDVBTLockStatus(struct drxk_state *state, u32 *pLockStatus);
  53 static int SwitchAntennaToQAM(struct drxk_state *state);
  54 static int SwitchAntennaToDVBT(struct drxk_state *state);
  55
  56 static bool IsDVBT(struct drxk_state *state)
  57 {
  58         return state->m_OperationMode == OM_DVBT;
  59 }
  60
  61 static bool IsQAM(struct drxk_state *state)
  62 {
  63         return state->m_OperationMode == OM_QAM_ITU_A ||
  64             state->m_OperationMode == OM_QAM_ITU_B ||
  65             state->m_OperationMode == OM_QAM_ITU_C;
  66 }
  67
  68 bool IsA1WithPatchCode(struct drxk_state *state)
  69 {
  70         return state->m_DRXK_A1_PATCH_CODE;
  71 }
  72
  73 bool IsA1WithRomCode(struct drxk_state *state)
  74 {
  75         return state->m_DRXK_A1_ROM_CODE;
  76 }
  77
  78 #define NOA1ROM 0
  79
  80 #define DRXDAP_FASI_SHORT_FORMAT(addr) (((addr) & 0xFC30FF80) == 0)
  81 #define DRXDAP_FASI_LONG_FORMAT(addr)  (((addr) & 0xFC30FF80) != 0)
  82
  83 #define DEFAULT_MER_83  165
  84 #define DEFAULT_MER_93  250
  85
  86 #ifndef DRXK_MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH
  87 #define DRXK_MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH (0x02)
  88 #endif
  89
  90 #ifndef DRXK_MPEG_PARALLEL_OUTPUT_PIN_DRIVE_STRENGTH
  91 #define DRXK_MPEG_PARALLEL_OUTPUT_PIN_DRIVE_STRENGTH (0x03)
  92 #endif
  93
  94 #ifndef DRXK_MPEG_OUTPUT_CLK_DRIVE_STRENGTH
  95 #define DRXK_MPEG_OUTPUT_CLK_DRIVE_STRENGTH (0x06)
  96 #endif
  97
  98 #define DEFAULT_DRXK_MPEG_LOCK_TIMEOUT 700
  99 #define DEFAULT_DRXK_DEMOD_LOCK_TIMEOUT 500
 100
 101 #ifndef DRXK_KI_RAGC_ATV
 102 #define DRXK_KI_RAGC_ATV   4
 103 #endif
 104 #ifndef DRXK_KI_IAGC_ATV
 105 #define DRXK_KI_IAGC_ATV   6
 106 #endif
 107 #ifndef DRXK_KI_DAGC_ATV
 108 #define DRXK_KI_DAGC_ATV   7
 109 #endif
 110
 111 #ifndef DRXK_KI_RAGC_QAM
 112 #define DRXK_KI_RAGC_QAM   3
 113 #endif
 114 #ifndef DRXK_KI_IAGC_QAM
 115 #define DRXK_KI_IAGC_QAM   4
 116 #endif
 117 #ifndef DRXK_KI_DAGC_QAM
 118 #define DRXK_KI_DAGC_QAM   7
 119 #endif
 120 #ifndef DRXK_KI_RAGC_DVBT
 121 #define DRXK_KI_RAGC_DVBT  (IsA1WithPatchCode(state) ? 3 : 2)
 122 #endif
 123 #ifndef DRXK_KI_IAGC_DVBT
 124 #define DRXK_KI_IAGC_DVBT  (IsA1WithPatchCode(state) ? 4 : 2)
 125 #endif
 126 #ifndef DRXK_KI_DAGC_DVBT
 127 #define DRXK_KI_DAGC_DVBT  (IsA1WithPatchCode(state) ? 10 : 7)
 128 #endif
 129
 130 #ifndef DRXK_AGC_DAC_OFFSET
 131 #define DRXK_AGC_DAC_OFFSET (0x800)
 132 #endif
 133
 134 #ifndef DRXK_BANDWIDTH_8MHZ_IN_HZ
 135 #define DRXK_BANDWIDTH_8MHZ_IN_HZ  (0x8B8249L)
 136 #endif
 137
 138 #ifndef DRXK_BANDWIDTH_7MHZ_IN_HZ
 139 #define DRXK_BANDWIDTH_7MHZ_IN_HZ  (0x7A1200L)
 140 #endif
 141
 142 #ifndef DRXK_BANDWIDTH_6MHZ_IN_HZ
 143 #define DRXK_BANDWIDTH_6MHZ_IN_HZ  (0x68A1B6L)
 144 #endif
 145
 146 #ifndef DRXK_QAM_SYMBOLRATE_MAX
 147 #define DRXK_QAM_SYMBOLRATE_MAX         (7233000)
 148 #endif
 149
 150 #define DRXK_BL_ROM_OFFSET_TAPS_DVBT    56
 151 #define DRXK_BL_ROM_OFFSET_TAPS_ITU_A   64
 152 #define DRXK_BL_ROM_OFFSET_TAPS_ITU_C   0x5FE0
 153 #define DRXK_BL_ROM_OFFSET_TAPS_BG      24
 154 #define DRXK_BL_ROM_OFFSET_TAPS_DKILLP  32
 155 #define DRXK_BL_ROM_OFFSET_TAPS_NTSC    40
 156 #define DRXK_BL_ROM_OFFSET_TAPS_FM      48
 157 #define DRXK_BL_ROM_OFFSET_UCODE        0
 158
 159 #define DRXK_BLC_TIMEOUT                100
 160
 161 #define DRXK_BLCC_NR_ELEMENTS_TAPS      2
 162 #define DRXK_BLCC_NR_ELEMENTS_UCODE     6
 163
 164 #define DRXK_BLDC_NR_ELEMENTS_TAPS      28
 165
 166 #ifndef DRXK_OFDM_NE_NOTCH_WIDTH
 167 #define DRXK_OFDM_NE_NOTCH_WIDTH             (4)
 168 #endif
 169
 170 #define DRXK_QAM_SL_SIG_POWER_QAM16       (40960)
 171 #define DRXK_QAM_SL_SIG_POWER_QAM32       (20480)
 172 #define DRXK_QAM_SL_SIG_POWER_QAM64       (43008)
 173 #define DRXK_QAM_SL_SIG_POWER_QAM128      (20992)
 174 #define DRXK_QAM_SL_SIG_POWER_QAM256      (43520)
 175
 176 static unsigned int debug;
 177 module_param(debug, int, 0644);
 178 MODULE_PARM_DESC(debug, "enable debug messages");
 179
 180 #define dprintk(level, fmt, arg...) do {                        \
 181 if (debug >= level)                                             \
 182         printk(KERN_DEBUG "drxk: %s" fmt, __func__, ## arg);    \
 183 } while (0)
 184
 185
 186 static inline u32 MulDiv32(u32 a, u32 b, u32 c)
 187 {
 188         u64 tmp64;
 189
 190         tmp64 = (u64) a * (u64) b;
 191         do_div(tmp64, c);
 192
 193         return (u32) tmp64;
 194 }
 195
 196 inline u32 Frac28a(u32 a, u32 c)
 197 {
 198         int i = 0;
 199         u32 Q1 = 0;
 200         u32 R0 = 0;
 201
 202         R0 = (a % c) << 4;      /* 32-28 == 4 shifts possible at max */
 203         Q1 = a / c;             /* integer part, only the 4 least significant bits
 204                                    will be visible in the result */
 205
 206         /* division using radix 16, 7 nibbles in the result */
 207         for (i = 0; i < 7; i++) {
 208                 Q1 = (Q1 << 4) | (R0 / c);
 209                 R0 = (R0 % c) << 4;
 210         }
 211         /* rounding */
 212         if ((R0 >> 3) >= c)
 213                 Q1++;
 214
 215         return Q1;
 216 }
 217
 218 static u32 Log10Times100(u32 x)
 219 {
 220         static const u8 scale = 15;
 221         static const u8 indexWidth = 5;
 222         u8 i = 0;
 223         u32 y = 0;
 224         u32 d = 0;
 225         u32 k = 0;
 226         u32 r = 0;
 227         /*
 228            log2lut[n] = (1<<scale) * 200 * log2(1.0 + ((1.0/(1<<INDEXWIDTH)) * n))
 229            0 <= n < ((1<<INDEXWIDTH)+1)
 230          */
 231
 232         static const u32 log2lut[] = {
 233                 0,              /* 0.000000 */
 234                 290941,         /* 290941.300628 */
 235                 573196,         /* 573196.476418 */
 236                 847269,         /* 847269.179851 */
 237                 1113620,        /* 1113620.489452 */
 238                 1372674,        /* 1372673.576986 */
 239                 1624818,        /* 1624817.752104 */
 240                 1870412,        /* 1870411.981536 */
 241                 2109788,        /* 2109787.962654 */
 242                 2343253,        /* 2343252.817465 */
 243                 2571091,        /* 2571091.461923 */
 244                 2793569,        /* 2793568.696416 */
 245                 3010931,        /* 3010931.055901 */
 246                 3223408,        /* 3223408.452106 */
 247                 3431216,        /* 3431215.635215 */
 248                 3634553,        /* 3634553.498355 */
 249                 3833610,        /* 3833610.244726 */
 250                 4028562,        /* 4028562.434393 */
 251                 4219576,        /* 4219575.925308 */
 252                 4406807,        /* 4406806.721144 */
 253                 4590402,        /* 4590401.736809 */
 254                 4770499,        /* 4770499.491025 */
 255                 4947231,        /* 4947230.734179 */
 256                 5120719,        /* 5120719.018555 */
 257                 5291081,        /* 5291081.217197 */
 258                 5458428,        /* 5458427.996830 */
 259                 5622864,        /* 5622864.249668 */
 260                 5784489,        /* 5784489.488298 */
 261                 5943398,        /* 5943398.207380 */
 262                 6099680,        /* 6099680.215452 */
 263                 6253421,        /* 6253420.939751 */
 264                 6404702,        /* 6404701.706649 */
 265                 6553600,        /* 6553600.000000 */
 266         };
 267
 268
 269         if (x == 0)
 270                 return 0;
 271
 272         /* Scale x (normalize) */
 273         /* computing y in log(x/y) = log(x) - log(y) */
 274         if ((x & ((0xffffffff) << (scale + 1))) == 0) {
 275                 for (k = scale; k > 0; k--) {
 276                         if (x & (((u32) 1) << scale))
 277                                 break;
 278                         x <<= 1;
 279                 }
 280         } else {
 281                 for (k = scale; k < 31; k++) {
 282                         if ((x & (((u32) (-1)) << (scale + 1))) == 0)
 283                                 break;
 284                         x >>= 1;
 285                 }
 286         }
 287         /*
 288            Now x has binary point between bit[scale] and bit[scale-1]
 289            and 1.0 <= x < 2.0 */
 290
 291         /* correction for divison: log(x) = log(x/y)+log(y) */
 292         y = k * ((((u32) 1) << scale) * 200);
 293
 294         /* remove integer part */
 295         x &= ((((u32) 1) << scale) - 1);
 296         /* get index */
 297         i = (u8) (x >> (scale - indexWidth));
 298         /* compute delta (x - a) */
 299         d = x & ((((u32) 1) << (scale - indexWidth)) - 1);
 300         /* compute log, multiplication (d* (..)) must be within range ! */
 301         y += log2lut[i] +
 302             ((d * (log2lut[i + 1] - log2lut[i])) >> (scale - indexWidth));
 303         /* Conver to log10() */
 304         y /= 108853;            /* (log2(10) << scale) */
 305         r = (y >> 1);
 306         /* rounding */
 307         if (y & ((u32) 1))
 308                 r++;
 309         return r;
 310 }
 311
 312 /****************************************************************************/
 313 /* I2C **********************************************************************/
 314 /****************************************************************************/
 315
 316 static int i2c_read1(struct i2c_adapter *adapter, u8 adr, u8 *val)
 317 {
 318         struct i2c_msg msgs[1] = { {.addr = adr, .flags = I2C_M_RD,
 319                                     .buf = val, .len = 1}
 320         };
 321
 322         return i2c_transfer(adapter, msgs, 1);
 323 }
 324
 325 static int i2c_write(struct i2c_adapter *adap, u8 adr, u8 *data, int len)
 326 {
 327         int status;
 328         struct i2c_msg msg = {
 329             .addr = adr, .flags = 0, .buf = data, .len = len };
 330
 331         dprintk(3, ":");
 332         if (debug > 2) {
 333                 int i;
 334                 for (i = 0; i < len; i++)
 335                         printk(KERN_CONT " %02x", data[i]);
 336                 printk(KERN_CONT "\n");
 337         }
 338         status = i2c_transfer(adap, &msg, 1);
 339         if (status >= 0 && status != 1)
 340                 status = -EIO;
 341
 342         if (status < 0)
 343                 printk(KERN_ERR "drxk: i2c write error at addr 0x%02x\n", adr);
 344
 345         return status;
 346 }
 347
 348 static int i2c_read(struct i2c_adapter *adap,
 349                     u8 adr, u8 *msg, int len, u8 *answ, int alen)
 350 {
 351         int status;
 352         struct i2c_msg msgs[2] = {
 353                 {.addr = adr, .flags = 0,
 354                                     .buf = msg, .len = len},
 355                 {.addr = adr, .flags = I2C_M_RD,
 356                  .buf = answ, .len = alen}
 357         };
 358
 359         status = i2c_transfer(adap, msgs, 2);
 360         if (status != 2) {
 361                 if (debug > 2)
 362                         printk(KERN_CONT ": ERROR!\n");
 363                 if (status >= 0)
 364                         status = -EIO;
 365
 366                 printk(KERN_ERR "drxk: i2c read error at addr 0x%02x\n", adr);
 367                 return status;
 368         }
 369         if (debug > 2) {
 370                 int i;
 371                 dprintk(2, ": read from ");
 372                 for (i = 0; i < len; i++)
 373                         printk(KERN_CONT " %02x", msg[i]);
 374                 printk(KERN_CONT "Value = ");
 375                 for (i = 0; i < alen; i++)
 376                         printk(KERN_CONT " %02x", answ[i]);
 377                 printk(KERN_CONT "\n");
 378         }
 379         return 0;
 380 }
 381
 382 static int read16_flags(struct drxk_state *state, u32 reg, u16 *data, u8 flags)
 383 {
 384         int status;
 385         u8 adr = state->demod_address, mm1[4], mm2[2], len;
 386
 387         if (state->single_master)
 388                 flags |= 0xC0;
 389
 390         if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
 391                 mm1[0] = (((reg << 1) & 0xFF) | 0x01);
 392                 mm1[1] = ((reg >> 16) & 0xFF);
 393                 mm1[2] = ((reg >> 24) & 0xFF) | flags;
 394                 mm1[3] = ((reg >> 7) & 0xFF);
 395                 len = 4;
 396         } else {
 397                 mm1[0] = ((reg << 1) & 0xFF);
 398                 mm1[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
 399                 len = 2;
 400         }
 401         dprintk(2, "(0x%08x, 0x%02x)\n", reg, flags);
 402         status = i2c_read(state->i2c, adr, mm1, len, mm2, 2);
 403         if (status < 0)
 404                 return status;
 405         if (data)
 406                 *data = mm2[0] | (mm2[1] << 8);
 407
 408         return 0;
 409 }
 410
 411 static int read16(struct drxk_state *state, u32 reg, u16 *data)
 412 {
 413         return read16_flags(state, reg, data, 0);
 414 }
 415
 416 static int read32_flags(struct drxk_state *state, u32 reg, u32 *data, u8 flags)
 417 {
 418         int status;
 419         u8 adr = state->demod_address, mm1[4], mm2[4], len;
 420
 421         if (state->single_master)
 422                 flags |= 0xC0;
 423
 424         if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
 425                 mm1[0] = (((reg << 1) & 0xFF) | 0x01);
 426                 mm1[1] = ((reg >> 16) & 0xFF);
 427                 mm1[2] = ((reg >> 24) & 0xFF) | flags;
 428                 mm1[3] = ((reg >> 7) & 0xFF);
 429                 len = 4;
 430         } else {
 431                 mm1[0] = ((reg << 1) & 0xFF);
 432                 mm1[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
 433                 len = 2;
 434         }
 435         dprintk(2, "(0x%08x, 0x%02x)\n", reg, flags);
 436         status = i2c_read(state->i2c, adr, mm1, len, mm2, 4);
 437         if (status < 0)
 438                 return status;
 439         if (data)
 440                 *data = mm2[0] | (mm2[1] << 8) |
 441                     (mm2[2] << 16) | (mm2[3] << 24);
 442
 443         return 0;
 444 }
 445
 446 static int read32(struct drxk_state *state, u32 reg, u32 *data)
 447 {
 448         return read32_flags(state, reg, data, 0);
 449 }
 450
 451 static int write16_flags(struct drxk_state *state, u32 reg, u16 data, u8 flags)
 452 {
 453         u8 adr = state->demod_address, mm[6], len;
 454
 455         if (state->single_master)
 456                 flags |= 0xC0;
 457         if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
 458                 mm[0] = (((reg << 1) & 0xFF) | 0x01);
 459                 mm[1] = ((reg >> 16) & 0xFF);
 460                 mm[2] = ((reg >> 24) & 0xFF) | flags;
 461                 mm[3] = ((reg >> 7) & 0xFF);
 462                 len = 4;
 463         } else {
 464                 mm[0] = ((reg << 1) & 0xFF);
 465                 mm[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
 466                 len = 2;
 467         }
 468         mm[len] = data & 0xff;
 469         mm[len + 1] = (data >> 8) & 0xff;
 470
 471         dprintk(2, "(0x%08x, 0x%04x, 0x%02x)\n", reg, data, flags);
 472         return i2c_write(state->i2c, adr, mm, len + 2);
 473 }
 474
 475 static int write16(struct drxk_state *state, u32 reg, u16 data)
 476 {
 477         return write16_flags(state, reg, data, 0);
 478 }
 479
 480 static int write32_flags(struct drxk_state *state, u32 reg, u32 data, u8 flags)
 481 {
 482         u8 adr = state->demod_address, mm[8], len;
 483
 484         if (state->single_master)
 485                 flags |= 0xC0;
 486         if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
 487                 mm[0] = (((reg << 1) & 0xFF) | 0x01);
 488                 mm[1] = ((reg >> 16) & 0xFF);
 489                 mm[2] = ((reg >> 24) & 0xFF) | flags;
 490                 mm[3] = ((reg >> 7) & 0xFF);
 491                 len = 4;
 492         } else {
 493                 mm[0] = ((reg << 1) & 0xFF);
 494                 mm[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
 495                 len = 2;
 496         }
 497         mm[len] = data & 0xff;
 498         mm[len + 1] = (data >> 8) & 0xff;
 499         mm[len + 2] = (data >> 16) & 0xff;
 500         mm[len + 3] = (data >> 24) & 0xff;
 501         dprintk(2, "(0x%08x, 0x%08x, 0x%02x)\n", reg, data, flags);
 502
 503         return i2c_write(state->i2c, adr, mm, len + 4);
 504 }
 505
 506 static int write32(struct drxk_state *state, u32 reg, u32 data)
 507 {
 508         return write32_flags(state, reg, data, 0);
 509 }
 510
 511 static int write_block(struct drxk_state *state, u32 Address,
 512                       const int BlockSize, const u8 pBlock[])
 513 {
 514         int status = 0, BlkSize = BlockSize;
 515         u8 Flags = 0;
 516
 517         if (state->single_master)
 518                 Flags |= 0xC0;
 519
 520         while (BlkSize > 0) {
 521                 int Chunk = BlkSize > state->m_ChunkSize ?
 522                     state->m_ChunkSize : BlkSize;
 523                 u8 *AdrBuf = &state->Chunk[0];
 524                 u32 AdrLength = 0;
 525
 526                 if (DRXDAP_FASI_LONG_FORMAT(Address) || (Flags != 0)) {
 527                         AdrBuf[0] = (((Address << 1) & 0xFF) | 0x01);
 528                         AdrBuf[1] = ((Address >> 16) & 0xFF);
 529                         AdrBuf[2] = ((Address >> 24) & 0xFF);
 530                         AdrBuf[3] = ((Address >> 7) & 0xFF);
 531                         AdrBuf[2] |= Flags;
 532                         AdrLength = 4;
 533                         if (Chunk == state->m_ChunkSize)
 534                                 Chunk -= 2;
 535                 } else {
 536                         AdrBuf[0] = ((Address << 1) & 0xFF);
 537                         AdrBuf[1] = (((Address >> 16) & 0x0F) |
 538                                      ((Address >> 18) & 0xF0));
 539                         AdrLength = 2;
 540                 }
 541                 memcpy(&state->Chunk[AdrLength], pBlock, Chunk);
 542                 dprintk(2, "(0x%08x, 0x%02x)\n", Address, Flags);
 543                 if (debug > 1) {
 544                         int i;
 545                         if (pBlock)
 546                                 for (i = 0; i < Chunk; i++)
 547                                         printk(KERN_CONT " %02x", pBlock[i]);
 548                         printk(KERN_CONT "\n");
 549                 }
 550                 status = i2c_write(state->i2c, state->demod_address,
 551                                    &state->Chunk[0], Chunk + AdrLength);
 552                 if (status < 0) {
 553                         printk(KERN_ERR "drxk: %s: i2c write error at addr 0x%02x\n",
 554                                __func__, Address);
 555                         break;
 556                 }
 557                 pBlock += Chunk;
 558                 Address += (Chunk >> 1);
 559                 BlkSize -= Chunk;
 560         }
 561         return status;
 562 }
 563
 564 #ifndef DRXK_MAX_RETRIES_POWERUP
 565 #define DRXK_MAX_RETRIES_POWERUP 20
 566 #endif
 567
 568 int PowerUpDevice(struct drxk_state *state)
 569 {
 570         int status;
 571         u8 data = 0;
 572         u16 retryCount = 0;
 573
 574         dprintk(1, "\n");
 575
 576         status = i2c_read1(state->i2c, state->demod_address, &data);
 577         if (status < 0) {
 578                 do {
 579                         data = 0;
 580                         status = i2c_write(state->i2c, state->demod_address,
 581                                            &data, 1);
 582                         msleep(10);
 583                         retryCount++;
 584                         if (status < 0)
 585                                 continue;
 586                         status = i2c_read1(state->i2c, state->demod_address,
 587                                            &data);
 588                 } while (status < 0 &&
 589                          (retryCount < DRXK_MAX_RETRIES_POWERUP));
 590                 if (status < 0 && retryCount >= DRXK_MAX_RETRIES_POWERUP)
 591                         goto error;
 592         }
 593
 594         /* Make sure all clk domains are active */
 595         status = write16(state, SIO_CC_PWD_MODE__A, SIO_CC_PWD_MODE_LEVEL_NONE);
 596         if (status < 0)
 597                 goto error;
 598         status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
 599         if (status < 0)
 600                 goto error;
 601         /* Enable pll lock tests */
 602         status = write16(state, SIO_CC_PLL_LOCK__A, 1);
 603         if (status < 0)
 604                 goto error;
 605
 606         state->m_currentPowerMode = DRX_POWER_UP;
 607
 608 error:
 609         if (status < 0)
 610                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
 611
 612         return status;
 613 }
 614
 615
 616 static int init_state(struct drxk_state *state)
 617 {
 618         /*
 619          * FIXME: most (all?) of the values bellow should be moved into
 620          * struct drxk_config, as they are probably board-specific
 621          */
 622         u32 ulVSBIfAgcMode = DRXK_AGC_CTRL_AUTO;
 623         u32 ulVSBIfAgcOutputLevel = 0;
 624         u32 ulVSBIfAgcMinLevel = 0;
 625         u32 ulVSBIfAgcMaxLevel = 0x7FFF;
 626         u32 ulVSBIfAgcSpeed = 3;
 627
 628         u32 ulVSBRfAgcMode = DRXK_AGC_CTRL_AUTO;
 629         u32 ulVSBRfAgcOutputLevel = 0;
 630         u32 ulVSBRfAgcMinLevel = 0;
 631         u32 ulVSBRfAgcMaxLevel = 0x7FFF;
 632         u32 ulVSBRfAgcSpeed = 3;
 633         u32 ulVSBRfAgcTop = 9500;
 634         u32 ulVSBRfAgcCutOffCurrent = 4000;
 635
 636         u32 ulATVIfAgcMode = DRXK_AGC_CTRL_AUTO;
 637         u32 ulATVIfAgcOutputLevel = 0;
 638         u32 ulATVIfAgcMinLevel = 0;
 639         u32 ulATVIfAgcMaxLevel = 0;
 640         u32 ulATVIfAgcSpeed = 3;
 641
 642         u32 ulATVRfAgcMode = DRXK_AGC_CTRL_OFF;
 643         u32 ulATVRfAgcOutputLevel = 0;
 644         u32 ulATVRfAgcMinLevel = 0;
 645         u32 ulATVRfAgcMaxLevel = 0;
 646         u32 ulATVRfAgcTop = 9500;
 647         u32 ulATVRfAgcCutOffCurrent = 4000;
 648         u32 ulATVRfAgcSpeed = 3;
 649
 650         u32 ulQual83 = DEFAULT_MER_83;
 651         u32 ulQual93 = DEFAULT_MER_93;
 652
 653         u32 ulDVBTStaticTSClock = 1;
 654         u32 ulDVBCStaticTSClock = 1;
 655
 656         u32 ulMpegLockTimeOut = DEFAULT_DRXK_MPEG_LOCK_TIMEOUT;
 657         u32 ulDemodLockTimeOut = DEFAULT_DRXK_DEMOD_LOCK_TIMEOUT;
 658
 659         /* io_pad_cfg register (8 bit reg.) MSB bit is 1 (default value) */
 660         /* io_pad_cfg_mode output mode is drive always */
 661         /* io_pad_cfg_drive is set to power 2 (23 mA) */
 662         u32 ulGPIOCfg = 0x0113;
 663         u32 ulSerialMode = 1;
 664         u32 ulInvertTSClock = 0;
 665         u32 ulTSDataStrength = DRXK_MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH;
 666         u32 ulTSClockkStrength = DRXK_MPEG_OUTPUT_CLK_DRIVE_STRENGTH;
 667         u32 ulDVBTBitrate = 50000000;
 668         u32 ulDVBCBitrate = DRXK_QAM_SYMBOLRATE_MAX * 8;
 669
 670         u32 ulInsertRSByte = 0;
 671
 672         u32 ulRfMirror = 1;
 673         u32 ulPowerDown = 0;
 674
 675         dprintk(1, "\n");
 676
 677         state->m_hasLNA = false;
 678         state->m_hasDVBT = false;
 679         state->m_hasDVBC = false;
 680         state->m_hasATV = false;
 681         state->m_hasOOB = false;
 682         state->m_hasAudio = false;
 683
 684         if (!state->m_ChunkSize)
 685                 state->m_ChunkSize = 124;
 686
 687         state->m_oscClockFreq = 0;
 688         state->m_smartAntInverted = false;
 689         state->m_bPDownOpenBridge = false;
 690
 691         /* real system clock frequency in kHz */
 692         state->m_sysClockFreq = 151875;
 693         /* Timing div, 250ns/Psys */
 694         /* Timing div, = (delay (nano seconds) * sysclk (kHz))/ 1000 */
 695         state->m_HICfgTimingDiv = ((state->m_sysClockFreq / 1000) *
 696                                    HI_I2C_DELAY) / 1000;
 697         /* Clipping */
 698         if (state->m_HICfgTimingDiv > SIO_HI_RA_RAM_PAR_2_CFG_DIV__M)
 699                 state->m_HICfgTimingDiv = SIO_HI_RA_RAM_PAR_2_CFG_DIV__M;
 700         state->m_HICfgWakeUpKey = (state->demod_address << 1);
 701         /* port/bridge/power down ctrl */
 702         state->m_HICfgCtrl = SIO_HI_RA_RAM_PAR_5_CFG_SLV0_SLAVE;
 703
 704         state->m_bPowerDown = (ulPowerDown != 0);
 705
 706         state->m_DRXK_A1_PATCH_CODE = false;
 707         state->m_DRXK_A1_ROM_CODE = false;
 708         state->m_DRXK_A2_ROM_CODE = false;
 709         state->m_DRXK_A3_ROM_CODE = false;
 710         state->m_DRXK_A2_PATCH_CODE = false;
 711         state->m_DRXK_A3_PATCH_CODE = false;
 712
 713         /* Init AGC and PGA parameters */
 714         /* VSB IF */
 715         state->m_vsbIfAgcCfg.ctrlMode = (ulVSBIfAgcMode);
 716         state->m_vsbIfAgcCfg.outputLevel = (ulVSBIfAgcOutputLevel);
 717         state->m_vsbIfAgcCfg.minOutputLevel = (ulVSBIfAgcMinLevel);
 718         state->m_vsbIfAgcCfg.maxOutputLevel = (ulVSBIfAgcMaxLevel);
 719         state->m_vsbIfAgcCfg.speed = (ulVSBIfAgcSpeed);
 720         state->m_vsbPgaCfg = 140;
 721
 722         /* VSB RF */
 723         state->m_vsbRfAgcCfg.ctrlMode = (ulVSBRfAgcMode);
 724         state->m_vsbRfAgcCfg.outputLevel = (ulVSBRfAgcOutputLevel);
 725         state->m_vsbRfAgcCfg.minOutputLevel = (ulVSBRfAgcMinLevel);
 726         state->m_vsbRfAgcCfg.maxOutputLevel = (ulVSBRfAgcMaxLevel);
 727         state->m_vsbRfAgcCfg.speed = (ulVSBRfAgcSpeed);
 728         state->m_vsbRfAgcCfg.top = (ulVSBRfAgcTop);
 729         state->m_vsbRfAgcCfg.cutOffCurrent = (ulVSBRfAgcCutOffCurrent);
 730         state->m_vsbPreSawCfg.reference = 0x07;
 731         state->m_vsbPreSawCfg.usePreSaw = true;
 732
 733         state->m_Quality83percent = DEFAULT_MER_83;
 734         state->m_Quality93percent = DEFAULT_MER_93;
 735         if (ulQual93 <= 500 && ulQual83 < ulQual93) {
 736                 state->m_Quality83percent = ulQual83;
 737                 state->m_Quality93percent = ulQual93;
 738         }
 739
 740         /* ATV IF */
 741         state->m_atvIfAgcCfg.ctrlMode = (ulATVIfAgcMode);
 742         state->m_atvIfAgcCfg.outputLevel = (ulATVIfAgcOutputLevel);
 743         state->m_atvIfAgcCfg.minOutputLevel = (ulATVIfAgcMinLevel);
 744         state->m_atvIfAgcCfg.maxOutputLevel = (ulATVIfAgcMaxLevel);
 745         state->m_atvIfAgcCfg.speed = (ulATVIfAgcSpeed);
 746
 747         /* ATV RF */
 748         state->m_atvRfAgcCfg.ctrlMode = (ulATVRfAgcMode);
 749         state->m_atvRfAgcCfg.outputLevel = (ulATVRfAgcOutputLevel);
 750         state->m_atvRfAgcCfg.minOutputLevel = (ulATVRfAgcMinLevel);
 751         state->m_atvRfAgcCfg.maxOutputLevel = (ulATVRfAgcMaxLevel);
 752         state->m_atvRfAgcCfg.speed = (ulATVRfAgcSpeed);
 753         state->m_atvRfAgcCfg.top = (ulATVRfAgcTop);
 754         state->m_atvRfAgcCfg.cutOffCurrent = (ulATVRfAgcCutOffCurrent);
 755         state->m_atvPreSawCfg.reference = 0x04;
 756         state->m_atvPreSawCfg.usePreSaw = true;
 757
 758
 759         /* DVBT RF */
 760         state->m_dvbtRfAgcCfg.ctrlMode = DRXK_AGC_CTRL_OFF;
 761         state->m_dvbtRfAgcCfg.outputLevel = 0;
 762         state->m_dvbtRfAgcCfg.minOutputLevel = 0;
 763         state->m_dvbtRfAgcCfg.maxOutputLevel = 0xFFFF;
 764         state->m_dvbtRfAgcCfg.top = 0x2100;
 765         state->m_dvbtRfAgcCfg.cutOffCurrent = 4000;
 766         state->m_dvbtRfAgcCfg.speed = 1;
 767
 768
 769         /* DVBT IF */
 770         state->m_dvbtIfAgcCfg.ctrlMode = DRXK_AGC_CTRL_AUTO;
 771         state->m_dvbtIfAgcCfg.outputLevel = 0;
 772         state->m_dvbtIfAgcCfg.minOutputLevel = 0;
 773         state->m_dvbtIfAgcCfg.maxOutputLevel = 9000;
 774         state->m_dvbtIfAgcCfg.top = 13424;
 775         state->m_dvbtIfAgcCfg.cutOffCurrent = 0;
 776         state->m_dvbtIfAgcCfg.speed = 3;
 777         state->m_dvbtIfAgcCfg.FastClipCtrlDelay = 30;
 778         state->m_dvbtIfAgcCfg.IngainTgtMax = 30000;
 779         /* state->m_dvbtPgaCfg = 140; */
 780
 781         state->m_dvbtPreSawCfg.reference = 4;
 782         state->m_dvbtPreSawCfg.usePreSaw = false;
 783
 784         /* QAM RF */
 785         state->m_qamRfAgcCfg.ctrlMode = DRXK_AGC_CTRL_OFF;
 786         state->m_qamRfAgcCfg.outputLevel = 0;
 787         state->m_qamRfAgcCfg.minOutputLevel = 6023;
 788         state->m_qamRfAgcCfg.maxOutputLevel = 27000;
 789         state->m_qamRfAgcCfg.top = 0x2380;
 790         state->m_qamRfAgcCfg.cutOffCurrent = 4000;
 791         state->m_qamRfAgcCfg.speed = 3;
 792
 793         /* QAM IF */
 794         state->m_qamIfAgcCfg.ctrlMode = DRXK_AGC_CTRL_AUTO;
 795         state->m_qamIfAgcCfg.outputLevel = 0;
 796         state->m_qamIfAgcCfg.minOutputLevel = 0;
 797         state->m_qamIfAgcCfg.maxOutputLevel = 9000;
 798         state->m_qamIfAgcCfg.top = 0x0511;
 799         state->m_qamIfAgcCfg.cutOffCurrent = 0;
 800         state->m_qamIfAgcCfg.speed = 3;
 801         state->m_qamIfAgcCfg.IngainTgtMax = 5119;
 802         state->m_qamIfAgcCfg.FastClipCtrlDelay = 50;
 803
 804         state->m_qamPgaCfg = 140;
 805         state->m_qamPreSawCfg.reference = 4;
 806         state->m_qamPreSawCfg.usePreSaw = false;
 807
 808         state->m_OperationMode = OM_NONE;
 809         state->m_DrxkState = DRXK_UNINITIALIZED;
 810
 811         /* MPEG output configuration */
 812         state->m_enableMPEGOutput = true;       /* If TRUE; enable MPEG ouput */
 813         state->m_insertRSByte = false;  /* If TRUE; insert RS byte */
 814         state->m_enableParallel = true; /* If TRUE;
 815                                            parallel out otherwise serial */
 816         state->m_invertDATA = false;    /* If TRUE; invert DATA signals */
 817         state->m_invertERR = false;     /* If TRUE; invert ERR signal */
 818         state->m_invertSTR = false;     /* If TRUE; invert STR signals */
 819         state->m_invertVAL = false;     /* If TRUE; invert VAL signals */
 820         state->m_invertCLK = (ulInvertTSClock != 0);    /* If TRUE; invert CLK signals */
 821         state->m_DVBTStaticCLK = (ulDVBTStaticTSClock != 0);
 822         state->m_DVBCStaticCLK = (ulDVBCStaticTSClock != 0);
 823         /* If TRUE; static MPEG clockrate will be used;
 824            otherwise clockrate will adapt to the bitrate of the TS */
 825
 826         state->m_DVBTBitrate = ulDVBTBitrate;
 827         state->m_DVBCBitrate = ulDVBCBitrate;
 828
 829         state->m_TSDataStrength = (ulTSDataStrength & 0x07);
 830         state->m_TSClockkStrength = (ulTSClockkStrength & 0x07);
 831
 832         /* Maximum bitrate in b/s in case static clockrate is selected */
 833         state->m_mpegTsStaticBitrate = 19392658;
 834         state->m_disableTEIhandling = false;
 835
 836         if (ulInsertRSByte)
 837                 state->m_insertRSByte = true;
 838
 839         state->m_MpegLockTimeOut = DEFAULT_DRXK_MPEG_LOCK_TIMEOUT;
 840         if (ulMpegLockTimeOut < 10000)
 841                 state->m_MpegLockTimeOut = ulMpegLockTimeOut;
 842         state->m_DemodLockTimeOut = DEFAULT_DRXK_DEMOD_LOCK_TIMEOUT;
 843         if (ulDemodLockTimeOut < 10000)
 844                 state->m_DemodLockTimeOut = ulDemodLockTimeOut;
 845
 846         /* QAM defaults */
 847         state->m_Constellation = DRX_CONSTELLATION_AUTO;
 848         state->m_qamInterleaveMode = DRXK_QAM_I12_J17;
 849         state->m_fecRsPlen = 204 * 8;   /* fecRsPlen  annex A */
 850         state->m_fecRsPrescale = 1;
 851
 852         state->m_sqiSpeed = DRXK_DVBT_SQI_SPEED_MEDIUM;
 853         state->m_agcFastClipCtrlDelay = 0;
 854
 855         state->m_GPIOCfg = (ulGPIOCfg);
 856
 857         state->m_bPowerDown = false;
 858         state->m_currentPowerMode = DRX_POWER_DOWN;
 859
 860         state->m_enableParallel = (ulSerialMode == 0);
 861
 862         state->m_rfmirror = (ulRfMirror == 0);
 863         state->m_IfAgcPol = false;
 864         return 0;
 865 }
 866
 867 static int DRXX_Open(struct drxk_state *state)
 868 {
 869         int status = 0;
 870         u32 jtag = 0;
 871         u16 bid = 0;
 872         u16 key = 0;
 873
 874         dprintk(1, "\n");
 875         /* stop lock indicator process */
 876         status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
 877         if (status < 0)
 878                 goto error;
 879         /* Check device id */
 880         status = read16(state, SIO_TOP_COMM_KEY__A, &key);
 881         if (status < 0)
 882                 goto error;
 883         status = write16(state, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY);
 884         if (status < 0)
 885                 goto error;
 886         status = read32(state, SIO_TOP_JTAGID_LO__A, &jtag);
 887         if (status < 0)
 888                 goto error;
 889         status = read16(state, SIO_PDR_UIO_IN_HI__A, &bid);
 890         if (status < 0)
 891                 goto error;
 892         status = write16(state, SIO_TOP_COMM_KEY__A, key);
 893 error:
 894         if (status < 0)
 895                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
 896         return status;
 897 }
 898
 899 static int GetDeviceCapabilities(struct drxk_state *state)
 900 {
 901         u16 sioPdrOhwCfg = 0;
 902         u32 sioTopJtagidLo = 0;
 903         int status;
 904         const char *spin = "";
 905
 906         dprintk(1, "\n");
 907
 908         /* driver 0.9.0 */
 909         /* stop lock indicator process */
 910         status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
 911         if (status < 0)
 912                 goto error;
 913         status = write16(state, SIO_TOP_COMM_KEY__A, 0xFABA);
 914         if (status < 0)
 915                 goto error;
 916         status = read16(state, SIO_PDR_OHW_CFG__A, &sioPdrOhwCfg);
 917         if (status < 0)
 918                 goto error;
 919         status = write16(state, SIO_TOP_COMM_KEY__A, 0x0000);
 920         if (status < 0)
 921                 goto error;
 922
 923         switch ((sioPdrOhwCfg & SIO_PDR_OHW_CFG_FREF_SEL__M)) {
 924         case 0:
 925                 /* ignore (bypass ?) */
 926                 break;
 927         case 1:
 928                 /* 27 MHz */
 929                 state->m_oscClockFreq = 27000;
 930                 break;
 931         case 2:
 932                 /* 20.25 MHz */
 933                 state->m_oscClockFreq = 20250;
 934                 break;
 935         case 3:
 936                 /* 4 MHz */
 937                 state->m_oscClockFreq = 20250;
 938                 break;
 939         default:
 940                 printk(KERN_ERR "drxk: Clock Frequency is unkonwn\n");
 941                 return -EINVAL;
 942         }
 943         /*
 944                 Determine device capabilities
 945                 Based on pinning v14
 946                 */
 947         status = read32(state, SIO_TOP_JTAGID_LO__A, &sioTopJtagidLo);
 948         if (status < 0)
 949                 goto error;
 950         /* driver 0.9.0 */
 951         switch ((sioTopJtagidLo >> 29) & 0xF) {
 952         case 0:
 953                 state->m_deviceSpin = DRXK_SPIN_A1;
 954                 spin = "A1";
 955                 break;
 956         case 2:
 957                 state->m_deviceSpin = DRXK_SPIN_A2;
 958                 spin = "A2";
 959                 break;
 960         case 3:
 961                 state->m_deviceSpin = DRXK_SPIN_A3;
 962                 spin = "A3";
 963                 break;
 964         default:
 965                 state->m_deviceSpin = DRXK_SPIN_UNKNOWN;
 966                 status = -EINVAL;
 967                 printk(KERN_ERR "drxk: Spin unknown\n");
 968                 goto error2;
 969         }
 970         switch ((sioTopJtagidLo >> 12) & 0xFF) {
 971         case 0x13:
 972                 /* typeId = DRX3913K_TYPE_ID */
 973                 state->m_hasLNA = false;
 974                 state->m_hasOOB = false;
 975                 state->m_hasATV = false;
 976                 state->m_hasAudio = false;
 977                 state->m_hasDVBT = true;
 978                 state->m_hasDVBC = true;
 979                 state->m_hasSAWSW = true;
 980                 state->m_hasGPIO2 = false;
 981                 state->m_hasGPIO1 = false;
 982                 state->m_hasIRQN = false;
 983                 break;
 984         case 0x15:
 985                 /* typeId = DRX3915K_TYPE_ID */
 986                 state->m_hasLNA = false;
 987                 state->m_hasOOB = false;
 988                 state->m_hasATV = true;
 989                 state->m_hasAudio = false;
 990                 state->m_hasDVBT = true;
 991                 state->m_hasDVBC = false;
 992                 state->m_hasSAWSW = true;
 993                 state->m_hasGPIO2 = true;
 994                 state->m_hasGPIO1 = true;
 995                 state->m_hasIRQN = false;
 996                 break;
 997         case 0x16:
 998                 /* typeId = DRX3916K_TYPE_ID */
 999                 state->m_hasLNA = false;
1000                 state->m_hasOOB = false;
1001                 state->m_hasATV = true;
1002                 state->m_hasAudio = false;
1003                 state->m_hasDVBT = true;
1004                 state->m_hasDVBC = false;
1005                 state->m_hasSAWSW = true;
1006                 state->m_hasGPIO2 = true;
1007                 state->m_hasGPIO1 = true;
1008                 state->m_hasIRQN = false;
1009                 break;
1010         case 0x18:
1011                 /* typeId = DRX3918K_TYPE_ID */
1012                 state->m_hasLNA = false;
1013                 state->m_hasOOB = false;
1014                 state->m_hasATV = true;
1015                 state->m_hasAudio = true;
1016                 state->m_hasDVBT = true;
1017                 state->m_hasDVBC = false;
1018                 state->m_hasSAWSW = true;
1019                 state->m_hasGPIO2 = true;
1020                 state->m_hasGPIO1 = true;
1021                 state->m_hasIRQN = false;
1022                 break;
1023         case 0x21:
1024                 /* typeId = DRX3921K_TYPE_ID */
1025                 state->m_hasLNA = false;
1026                 state->m_hasOOB = false;
1027                 state->m_hasATV = true;
1028                 state->m_hasAudio = true;
1029                 state->m_hasDVBT = true;
1030                 state->m_hasDVBC = true;
1031                 state->m_hasSAWSW = true;
1032                 state->m_hasGPIO2 = true;
1033                 state->m_hasGPIO1 = true;
1034                 state->m_hasIRQN = false;
1035                 break;
1036         case 0x23:
1037                 /* typeId = DRX3923K_TYPE_ID */
1038                 state->m_hasLNA = false;
1039                 state->m_hasOOB = false;
1040                 state->m_hasATV = true;
1041                 state->m_hasAudio = true;
1042                 state->m_hasDVBT = true;
1043                 state->m_hasDVBC = true;
1044                 state->m_hasSAWSW = true;
1045                 state->m_hasGPIO2 = true;
1046                 state->m_hasGPIO1 = true;
1047                 state->m_hasIRQN = false;
1048                 break;
1049         case 0x25:
1050                 /* typeId = DRX3925K_TYPE_ID */
1051                 state->m_hasLNA = false;
1052                 state->m_hasOOB = false;
1053                 state->m_hasATV = true;
1054                 state->m_hasAudio = true;
1055                 state->m_hasDVBT = true;
1056                 state->m_hasDVBC = true;
1057                 state->m_hasSAWSW = true;
1058                 state->m_hasGPIO2 = true;
1059                 state->m_hasGPIO1 = true;
1060                 state->m_hasIRQN = false;
1061                 break;
1062         case 0x26:
1063                 /* typeId = DRX3926K_TYPE_ID */
1064                 state->m_hasLNA = false;
1065                 state->m_hasOOB = false;
1066                 state->m_hasATV = true;
1067                 state->m_hasAudio = false;
1068                 state->m_hasDVBT = true;
1069                 state->m_hasDVBC = true;
1070                 state->m_hasSAWSW = true;
1071                 state->m_hasGPIO2 = true;
1072                 state->m_hasGPIO1 = true;
1073                 state->m_hasIRQN = false;
1074                 break;
1075         default:
1076                 printk(KERN_ERR "drxk: DeviceID 0x%02x not supported\n",
1077                         ((sioTopJtagidLo >> 12) & 0xFF));
1078                 status = -EINVAL;
1079                 goto error2;
1080         }
1081
1082         printk(KERN_INFO
1083                "drxk: detected a drx-39%02xk, spin %s, xtal %d.%03d MHz\n",
1084                ((sioTopJtagidLo >> 12) & 0xFF), spin,
1085                state->m_oscClockFreq / 1000,
1086                state->m_oscClockFreq % 1000);
1087
1088 error:
1089         if (status < 0)
1090                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1091
1092 error2:
1093         return status;
1094 }
1095
1096 static int HI_Command(struct drxk_state *state, u16 cmd, u16 *pResult)
1097 {
1098         int status;
1099         bool powerdown_cmd;
1100
1101         dprintk(1, "\n");
1102
1103         /* Write command */
1104         status = write16(state, SIO_HI_RA_RAM_CMD__A, cmd);
1105         if (status < 0)
1106                 goto error;
1107         if (cmd == SIO_HI_RA_RAM_CMD_RESET)
1108                 msleep(1);
1109
1110         powerdown_cmd =
1111             (bool) ((cmd == SIO_HI_RA_RAM_CMD_CONFIG) &&
1112                     ((state->m_HICfgCtrl) &
1113                      SIO_HI_RA_RAM_PAR_5_CFG_SLEEP__M) ==
1114                     SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ);
1115         if (powerdown_cmd == false) {
1116                 /* Wait until command rdy */
1117                 u32 retryCount = 0;
1118                 u16 waitCmd;
1119
1120                 do {
1121                         msleep(1);
1122                         retryCount += 1;
1123                         status = read16(state, SIO_HI_RA_RAM_CMD__A,
1124                                           &waitCmd);
1125                 } while ((status < 0) && (retryCount < DRXK_MAX_RETRIES)
1126                          && (waitCmd != 0));
1127                 if (status < 0)
1128                         goto error;
1129                 status = read16(state, SIO_HI_RA_RAM_RES__A, pResult);
1130         }
1131 error:
1132         if (status < 0)
1133                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1134
1135         return status;
1136 }
1137
1138 static int HI_CfgCommand(struct drxk_state *state)
1139 {
1140         int status;
1141
1142         dprintk(1, "\n");
1143
1144         mutex_lock(&state->mutex);
1145
1146         status = write16(state, SIO_HI_RA_RAM_PAR_6__A, state->m_HICfgTimeout);
1147         if (status < 0)
1148                 goto error;
1149         status = write16(state, SIO_HI_RA_RAM_PAR_5__A, state->m_HICfgCtrl);
1150         if (status < 0)
1151                 goto error;
1152         status = write16(state, SIO_HI_RA_RAM_PAR_4__A, state->m_HICfgWakeUpKey);
1153         if (status < 0)
1154                 goto error;
1155         status = write16(state, SIO_HI_RA_RAM_PAR_3__A, state->m_HICfgBridgeDelay);
1156         if (status < 0)
1157                 goto error;
1158         status = write16(state, SIO_HI_RA_RAM_PAR_2__A, state->m_HICfgTimingDiv);
1159         if (status < 0)
1160                 goto error;
1161         status = write16(state, SIO_HI_RA_RAM_PAR_1__A, SIO_HI_RA_RAM_PAR_1_PAR1_SEC_KEY);
1162         if (status < 0)
1163                 goto error;
1164         status = HI_Command(state, SIO_HI_RA_RAM_CMD_CONFIG, 0);
1165         if (status < 0)
1166                 goto error;
1167
1168         state->m_HICfgCtrl &= ~SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ;
1169 error:
1170         mutex_unlock(&state->mutex);
1171         if (status < 0)
1172                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1173         return status;
1174 }
1175
1176 static int InitHI(struct drxk_state *state)
1177 {
1178         dprintk(1, "\n");
1179
1180         state->m_HICfgWakeUpKey = (state->demod_address << 1);
1181         state->m_HICfgTimeout = 0x96FF;
1182         /* port/bridge/power down ctrl */
1183         state->m_HICfgCtrl = SIO_HI_RA_RAM_PAR_5_CFG_SLV0_SLAVE;
1184
1185         return HI_CfgCommand(state);
1186 }
1187
1188 static int MPEGTSConfigurePins(struct drxk_state *state, bool mpegEnable)
1189 {
1190         int status = -1;
1191         u16 sioPdrMclkCfg = 0;
1192         u16 sioPdrMdxCfg = 0;
1193
1194         dprintk(1, "\n");
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->param.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 constellation */
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->param.u.qam.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->param.u.qam.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->param.u.ofdm.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->param.u.ofdm.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->param.u.ofdm.hierarchy_information) {
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         /* constellation */
3875         switch (state->param.u.ofdm.constellation) {
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->param.u.ofdm.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->param.u.ofdm.bandwidth) {
3948         case BANDWIDTH_AUTO:
3949         case BANDWIDTH_8_MHZ:
3950                 bandwidth = DRXK_BANDWIDTH_8MHZ_IN_HZ;
3951                 status = write16(state, OFDM_SC_RA_RAM_SRMM_FIX_FACT_8K__A, 3052);
3952                 if (status < 0)
3953                         goto error;
3954                 /* cochannel protection for PAL 8 MHz */
3955                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_LEFT__A, 7);
3956                 if (status < 0)
3957                         goto error;
3958                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_RIGHT__A, 7);
3959                 if (status < 0)
3960                         goto error;
3961                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_LEFT__A, 7);
3962                 if (status < 0)
3963                         goto error;
3964                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_RIGHT__A, 1);
3965                 if (status < 0)
3966                         goto error;
3967                 break;
3968         case BANDWIDTH_7_MHZ:
3969                 bandwidth = DRXK_BANDWIDTH_7MHZ_IN_HZ;
3970                 status = write16(state, OFDM_SC_RA_RAM_SRMM_FIX_FACT_8K__A, 3491);
3971                 if (status < 0)
3972                         goto error;
3973                 /* cochannel protection for PAL 7 MHz */
3974                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_LEFT__A, 8);
3975                 if (status < 0)
3976                         goto error;
3977                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_RIGHT__A, 8);
3978                 if (status < 0)
3979                         goto error;
3980                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_LEFT__A, 4);
3981                 if (status < 0)
3982                         goto error;
3983                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_RIGHT__A, 1);
3984                 if (status < 0)
3985                         goto error;
3986                 break;
3987         case BANDWIDTH_6_MHZ:
3988                 bandwidth = DRXK_BANDWIDTH_6MHZ_IN_HZ;
3989                 status = write16(state, OFDM_SC_RA_RAM_SRMM_FIX_FACT_8K__A, 4073);
3990                 if (status < 0)
3991                         goto error;
3992                 /* cochannel protection for NTSC 6 MHz */
3993                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_LEFT__A, 19);
3994                 if (status < 0)
3995                         goto error;
3996                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_RIGHT__A, 19);
3997                 if (status < 0)
3998                         goto error;
3999                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_LEFT__A, 14);
4000                 if (status < 0)
4001                         goto error;
4002                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_RIGHT__A, 1);
4003                 if (status < 0)
4004                         goto error;
4005                 break;
4006         default:
4007                 status = -EINVAL;
4008                 goto error;
4009         }
4010
4011         if (iqmRcRateOfs == 0) {
4012                 /* Now compute IQM_RC_RATE_OFS
4013                         (((SysFreq/BandWidth)/2)/2) -1) * 2^23)
4014                         =>
4015                         ((SysFreq / BandWidth) * (2^21)) - (2^23)
4016                         */
4017                 /* (SysFreq / BandWidth) * (2^28)  */
4018                 /* assert (MAX(sysClk)/MIN(bandwidth) < 16)
4019                         => assert(MAX(sysClk) < 16*MIN(bandwidth))
4020                         => assert(109714272 > 48000000) = true so Frac 28 can be used  */
4021                 iqmRcRateOfs = Frac28a((u32)
4022                                         ((state->m_sysClockFreq *
4023                                                 1000) / 3), bandwidth);
4024                 /* (SysFreq / BandWidth) * (2^21), rounding before truncating  */
4025                 if ((iqmRcRateOfs & 0x7fL) >= 0x40)
4026                         iqmRcRateOfs += 0x80L;
4027                 iqmRcRateOfs = iqmRcRateOfs >> 7;
4028                 /* ((SysFreq / BandWidth) * (2^21)) - (2^23)  */
4029                 iqmRcRateOfs = iqmRcRateOfs - (1 << 23);
4030         }
4031
4032         iqmRcRateOfs &=
4033                 ((((u32) IQM_RC_RATE_OFS_HI__M) <<
4034                 IQM_RC_RATE_OFS_LO__W) | IQM_RC_RATE_OFS_LO__M);
4035         status = write32(state, IQM_RC_RATE_OFS_LO__A, iqmRcRateOfs);
4036         if (status < 0)
4037                 goto error;
4038
4039         /* Bandwidth setting done */
4040
4041 #if 0
4042         status = DVBTSetFrequencyShift(demod, channel, tunerOffset);
4043         if (status < 0)
4044                 goto error;
4045 #endif
4046         status = SetFrequencyShifter(state, IntermediateFreqkHz, tunerFreqOffset, true);
4047         if (status < 0)
4048                 goto error;
4049
4050         /*== Start SC, write channel settings to SC ===============================*/
4051
4052         /* Activate SCU to enable SCU commands */
4053         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
4054         if (status < 0)
4055                 goto error;
4056
4057         /* Enable SC after setting all other parameters */
4058         status = write16(state, OFDM_SC_COMM_STATE__A, 0);
4059         if (status < 0)
4060                 goto error;
4061         status = write16(state, OFDM_SC_COMM_EXEC__A, 1);
4062         if (status < 0)
4063                 goto error;
4064
4065
4066         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_START, 0, NULL, 1, &cmdResult);
4067         if (status < 0)
4068                 goto error;
4069
4070         /* Write SC parameter registers, set all AUTO flags in operation mode */
4071         param1 = (OFDM_SC_RA_RAM_OP_AUTO_MODE__M |
4072                         OFDM_SC_RA_RAM_OP_AUTO_GUARD__M |
4073                         OFDM_SC_RA_RAM_OP_AUTO_CONST__M |
4074                         OFDM_SC_RA_RAM_OP_AUTO_HIER__M |
4075                         OFDM_SC_RA_RAM_OP_AUTO_RATE__M);
4076         status = DVBTScCommand(state, OFDM_SC_RA_RAM_CMD_SET_PREF_PARAM,
4077                                 0, transmissionParams, param1, 0, 0, 0);
4078         if (status < 0)
4079                 goto error;
4080
4081         if (!state->m_DRXK_A3_ROM_CODE)
4082                 status = DVBTCtrlSetSqiSpeed(state, &state->m_sqiSpeed);
4083 error:
4084         if (status < 0)
4085                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4086
4087         return status;
4088 }
4089
4090
4091 /*============================================================================*/
4092
4093 /**
4094 * \brief Retreive lock status .
4095 * \param demod    Pointer to demodulator instance.
4096 * \param lockStat Pointer to lock status structure.
4097 * \return DRXStatus_t.
4098 *
4099 */
4100 static int GetDVBTLockStatus(struct drxk_state *state, u32 *pLockStatus)
4101 {
4102         int status;
4103         const u16 mpeg_lock_mask = (OFDM_SC_RA_RAM_LOCK_MPEG__M |
4104                                     OFDM_SC_RA_RAM_LOCK_FEC__M);
4105         const u16 fec_lock_mask = (OFDM_SC_RA_RAM_LOCK_FEC__M);
4106         const u16 demod_lock_mask = OFDM_SC_RA_RAM_LOCK_DEMOD__M;
4107
4108         u16 ScRaRamLock = 0;
4109         u16 ScCommExec = 0;
4110
4111         dprintk(1, "\n");
4112
4113         *pLockStatus = NOT_LOCKED;
4114         /* driver 0.9.0 */
4115         /* Check if SC is running */
4116         status = read16(state, OFDM_SC_COMM_EXEC__A, &ScCommExec);
4117         if (status < 0)
4118                 goto end;
4119         if (ScCommExec == OFDM_SC_COMM_EXEC_STOP)
4120                 goto end;
4121
4122         status = read16(state, OFDM_SC_RA_RAM_LOCK__A, &ScRaRamLock);
4123         if (status < 0)
4124                 goto end;
4125
4126         if ((ScRaRamLock & mpeg_lock_mask) == mpeg_lock_mask)
4127                 *pLockStatus = MPEG_LOCK;
4128         else if ((ScRaRamLock & fec_lock_mask) == fec_lock_mask)
4129                 *pLockStatus = FEC_LOCK;
4130         else if ((ScRaRamLock & demod_lock_mask) == demod_lock_mask)
4131                 *pLockStatus = DEMOD_LOCK;
4132         else if (ScRaRamLock & OFDM_SC_RA_RAM_LOCK_NODVBT__M)
4133                 *pLockStatus = NEVER_LOCK;
4134 end:
4135         if (status < 0)
4136                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4137
4138         return status;
4139 }
4140
4141 static int PowerUpQAM(struct drxk_state *state)
4142 {
4143         enum DRXPowerMode powerMode = DRXK_POWER_DOWN_OFDM;
4144         int status;
4145
4146         dprintk(1, "\n");
4147         status = CtrlPowerMode(state, &powerMode);
4148         if (status < 0)
4149                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4150
4151         return status;
4152 }
4153
4154
4155 /** Power Down QAM */
4156 static int PowerDownQAM(struct drxk_state *state)
4157 {
4158         u16 data = 0;
4159         u16 cmdResult;
4160         int status = 0;
4161
4162         dprintk(1, "\n");
4163         status = read16(state, SCU_COMM_EXEC__A, &data);
4164         if (status < 0)
4165                 goto error;
4166         if (data == SCU_COMM_EXEC_ACTIVE) {
4167                 /*
4168                         STOP demodulator
4169                         QAM and HW blocks
4170                         */
4171                 /* stop all comstate->m_exec */
4172                 status = write16(state, QAM_COMM_EXEC__A, QAM_COMM_EXEC_STOP);
4173                 if (status < 0)
4174                         goto error;
4175                 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_STOP, 0, NULL, 1, &cmdResult);
4176                 if (status < 0)
4177                         goto error;
4178         }
4179         /* powerdown AFE                   */
4180         status = SetIqmAf(state, false);
4181
4182 error:
4183         if (status < 0)
4184                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4185
4186         return status;
4187 }
4188
4189 /*============================================================================*/
4190
4191 /**
4192 * \brief Setup of the QAM Measurement intervals for signal quality
4193 * \param demod instance of demod.
4194 * \param constellation current constellation.
4195 * \return DRXStatus_t.
4196 *
4197 *  NOTE:
4198 *  Take into account that for certain settings the errorcounters can overflow.
4199 *  The implementation does not check this.
4200 *
4201 */
4202 static int SetQAMMeasurement(struct drxk_state *state,
4203                              enum EDrxkConstellation constellation,
4204                              u32 symbolRate)
4205 {
4206         u32 fecBitsDesired = 0; /* BER accounting period */
4207         u32 fecRsPeriodTotal = 0;       /* Total period */
4208         u16 fecRsPrescale = 0;  /* ReedSolomon Measurement Prescale */
4209         u16 fecRsPeriod = 0;    /* Value for corresponding I2C register */
4210         int status = 0;
4211
4212         dprintk(1, "\n");
4213
4214         fecRsPrescale = 1;
4215         /* fecBitsDesired = symbolRate [kHz] *
4216                 FrameLenght [ms] *
4217                 (constellation + 1) *
4218                 SyncLoss (== 1) *
4219                 ViterbiLoss (==1)
4220                 */
4221         switch (constellation) {
4222         case DRX_CONSTELLATION_QAM16:
4223                 fecBitsDesired = 4 * symbolRate;
4224                 break;
4225         case DRX_CONSTELLATION_QAM32:
4226                 fecBitsDesired = 5 * symbolRate;
4227                 break;
4228         case DRX_CONSTELLATION_QAM64:
4229                 fecBitsDesired = 6 * symbolRate;
4230                 break;
4231         case DRX_CONSTELLATION_QAM128:
4232                 fecBitsDesired = 7 * symbolRate;
4233                 break;
4234         case DRX_CONSTELLATION_QAM256:
4235                 fecBitsDesired = 8 * symbolRate;
4236                 break;
4237         default:
4238                 status = -EINVAL;
4239         }
4240         if (status < 0)
4241                 goto error;
4242
4243         fecBitsDesired /= 1000; /* symbolRate [Hz] -> symbolRate [kHz]  */
4244         fecBitsDesired *= 500;  /* meas. period [ms] */
4245
4246         /* Annex A/C: bits/RsPeriod = 204 * 8 = 1632 */
4247         /* fecRsPeriodTotal = fecBitsDesired / 1632 */
4248         fecRsPeriodTotal = (fecBitsDesired / 1632UL) + 1;       /* roughly ceil */
4249
4250         /* fecRsPeriodTotal =  fecRsPrescale * fecRsPeriod  */
4251         fecRsPrescale = 1 + (u16) (fecRsPeriodTotal >> 16);
4252         if (fecRsPrescale == 0) {
4253                 /* Divide by zero (though impossible) */
4254                 status = -EINVAL;
4255                 if (status < 0)
4256                         goto error;
4257         }
4258         fecRsPeriod =
4259                 ((u16) fecRsPeriodTotal +
4260                 (fecRsPrescale >> 1)) / fecRsPrescale;
4261
4262         /* write corresponding registers */
4263         status = write16(state, FEC_RS_MEASUREMENT_PERIOD__A, fecRsPeriod);
4264         if (status < 0)
4265                 goto error;
4266         status = write16(state, FEC_RS_MEASUREMENT_PRESCALE__A, fecRsPrescale);
4267         if (status < 0)
4268                 goto error;
4269         status = write16(state, FEC_OC_SNC_FAIL_PERIOD__A, fecRsPeriod);
4270 error:
4271         if (status < 0)
4272                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4273         return status;
4274 }
4275
4276 static int SetQAM16(struct drxk_state *state)
4277 {
4278         int status = 0;
4279
4280         dprintk(1, "\n");
4281         /* QAM Equalizer Setup */
4282         /* Equalizer */
4283         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 13517);
4284         if (status < 0)
4285                 goto error;
4286         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 13517);
4287         if (status < 0)
4288                 goto error;
4289         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 13517);
4290         if (status < 0)
4291                 goto error;
4292         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 13517);
4293         if (status < 0)
4294                 goto error;
4295         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 13517);
4296         if (status < 0)
4297                 goto error;
4298         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 13517);
4299         if (status < 0)
4300                 goto error;
4301         /* Decision Feedback Equalizer */
4302         status = write16(state, QAM_DQ_QUAL_FUN0__A, 2);
4303         if (status < 0)
4304                 goto error;
4305         status = write16(state, QAM_DQ_QUAL_FUN1__A, 2);
4306         if (status < 0)
4307                 goto error;
4308         status = write16(state, QAM_DQ_QUAL_FUN2__A, 2);
4309         if (status < 0)
4310                 goto error;
4311         status = write16(state, QAM_DQ_QUAL_FUN3__A, 2);
4312         if (status < 0)
4313                 goto error;
4314         status = write16(state, QAM_DQ_QUAL_FUN4__A, 2);
4315         if (status < 0)
4316                 goto error;
4317         status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4318         if (status < 0)
4319                 goto error;
4320
4321         status = write16(state, QAM_SY_SYNC_HWM__A, 5);
4322         if (status < 0)
4323                 goto error;
4324         status = write16(state, QAM_SY_SYNC_AWM__A, 4);
4325         if (status < 0)
4326                 goto error;
4327         status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4328         if (status < 0)
4329                 goto error;
4330
4331         /* QAM Slicer Settings */
4332         status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM16);
4333         if (status < 0)
4334                 goto error;
4335
4336         /* QAM Loop Controller Coeficients */
4337         status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4338         if (status < 0)
4339                 goto error;
4340         status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4341         if (status < 0)
4342                 goto error;
4343         status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4344         if (status < 0)
4345                 goto error;
4346         status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4347         if (status < 0)
4348                 goto error;
4349         status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4350         if (status < 0)
4351                 goto error;
4352         status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4353         if (status < 0)
4354                 goto error;
4355         status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4356         if (status < 0)
4357                 goto error;
4358         status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4359         if (status < 0)
4360                 goto error;
4361
4362         status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4363         if (status < 0)
4364                 goto error;
4365         status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 20);
4366         if (status < 0)
4367                 goto error;
4368         status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 80);
4369         if (status < 0)
4370                 goto error;
4371         status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4372         if (status < 0)
4373                 goto error;
4374         status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 20);
4375         if (status < 0)
4376                 goto error;
4377         status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 50);
4378         if (status < 0)
4379                 goto error;
4380         status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4381         if (status < 0)
4382                 goto error;
4383         status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 16);
4384         if (status < 0)
4385                 goto error;
4386         status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 32);
4387         if (status < 0)
4388                 goto error;
4389         status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4390         if (status < 0)
4391                 goto error;
4392         status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4393         if (status < 0)
4394                 goto error;
4395         status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 10);
4396         if (status < 0)
4397                 goto error;
4398
4399
4400         /* QAM State Machine (FSM) Thresholds */
4401
4402         status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 140);
4403         if (status < 0)
4404                 goto error;
4405         status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 50);
4406         if (status < 0)
4407                 goto error;
4408         status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 95);
4409         if (status < 0)
4410                 goto error;
4411         status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 120);
4412         if (status < 0)
4413                 goto error;
4414         status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 230);
4415         if (status < 0)
4416                 goto error;
4417         status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 105);
4418         if (status < 0)
4419                 goto error;
4420
4421         status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
4422         if (status < 0)
4423                 goto error;
4424         status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
4425         if (status < 0)
4426                 goto error;
4427         status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 24);
4428         if (status < 0)
4429                 goto error;
4430
4431
4432         /* QAM FSM Tracking Parameters */
4433
4434         status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 16);
4435         if (status < 0)
4436                 goto error;
4437         status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 220);
4438         if (status < 0)
4439                 goto error;
4440         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 25);
4441         if (status < 0)
4442                 goto error;
4443         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 6);
4444         if (status < 0)
4445                 goto error;
4446         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -24);
4447         if (status < 0)
4448                 goto error;
4449         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -65);
4450         if (status < 0)
4451                 goto error;
4452         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -127);
4453         if (status < 0)
4454                 goto error;
4455
4456 error:
4457         if (status < 0)
4458                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4459         return status;
4460 }
4461
4462 /*============================================================================*/
4463
4464 /**
4465 * \brief QAM32 specific setup
4466 * \param demod instance of demod.
4467 * \return DRXStatus_t.
4468 */
4469 static int SetQAM32(struct drxk_state *state)
4470 {
4471         int status = 0;
4472
4473         dprintk(1, "\n");
4474
4475         /* QAM Equalizer Setup */
4476         /* Equalizer */
4477         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 6707);
4478         if (status < 0)
4479                 goto error;
4480         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 6707);
4481         if (status < 0)
4482                 goto error;
4483         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 6707);
4484         if (status < 0)
4485                 goto error;
4486         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 6707);
4487         if (status < 0)
4488                 goto error;
4489         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 6707);
4490         if (status < 0)
4491                 goto error;
4492         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 6707);
4493         if (status < 0)
4494                 goto error;
4495
4496         /* Decision Feedback Equalizer */
4497         status = write16(state, QAM_DQ_QUAL_FUN0__A, 3);
4498         if (status < 0)
4499                 goto error;
4500         status = write16(state, QAM_DQ_QUAL_FUN1__A, 3);
4501         if (status < 0)
4502                 goto error;
4503         status = write16(state, QAM_DQ_QUAL_FUN2__A, 3);
4504         if (status < 0)
4505                 goto error;
4506         status = write16(state, QAM_DQ_QUAL_FUN3__A, 3);
4507         if (status < 0)
4508                 goto error;
4509         status = write16(state, QAM_DQ_QUAL_FUN4__A, 3);
4510         if (status < 0)
4511                 goto error;
4512         status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4513         if (status < 0)
4514                 goto error;
4515
4516         status = write16(state, QAM_SY_SYNC_HWM__A, 6);
4517         if (status < 0)
4518                 goto error;
4519         status = write16(state, QAM_SY_SYNC_AWM__A, 5);
4520         if (status < 0)
4521                 goto error;
4522         status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4523         if (status < 0)
4524                 goto error;
4525
4526         /* QAM Slicer Settings */
4527
4528         status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM32);
4529         if (status < 0)
4530                 goto error;
4531
4532
4533         /* QAM Loop Controller Coeficients */
4534
4535         status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4536         if (status < 0)
4537                 goto error;
4538         status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4539         if (status < 0)
4540                 goto error;
4541         status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4542         if (status < 0)
4543                 goto error;
4544         status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4545         if (status < 0)
4546                 goto error;
4547         status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4548         if (status < 0)
4549                 goto error;
4550         status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4551         if (status < 0)
4552                 goto error;
4553         status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4554         if (status < 0)
4555                 goto error;
4556         status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4557         if (status < 0)
4558                 goto error;
4559
4560         status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4561         if (status < 0)
4562                 goto error;
4563         status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 20);
4564         if (status < 0)
4565                 goto error;
4566         status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 80);
4567         if (status < 0)
4568                 goto error;
4569         status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4570         if (status < 0)
4571                 goto error;
4572         status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 20);
4573         if (status < 0)
4574                 goto error;
4575         status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 50);
4576         if (status < 0)
4577                 goto error;
4578         status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4579         if (status < 0)
4580                 goto error;
4581         status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 16);
4582         if (status < 0)
4583                 goto error;
4584         status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 16);
4585         if (status < 0)
4586                 goto error;
4587         status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4588         if (status < 0)
4589                 goto error;
4590         status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4591         if (status < 0)
4592                 goto error;
4593         status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 0);
4594         if (status < 0)
4595                 goto error;
4596
4597
4598         /* QAM State Machine (FSM) Thresholds */
4599
4600         status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 90);
4601         if (status < 0)
4602                 goto error;
4603         status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 50);
4604         if (status < 0)
4605                 goto error;
4606         status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
4607         if (status < 0)
4608                 goto error;
4609         status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 100);
4610         if (status < 0)
4611                 goto error;
4612         status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 170);
4613         if (status < 0)
4614                 goto error;
4615         status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 100);
4616         if (status < 0)
4617                 goto error;
4618
4619         status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
4620         if (status < 0)
4621                 goto error;
4622         status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
4623         if (status < 0)
4624                 goto error;
4625         status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 10);
4626         if (status < 0)
4627                 goto error;
4628
4629
4630         /* QAM FSM Tracking Parameters */
4631
4632         status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 12);
4633         if (status < 0)
4634                 goto error;
4635         status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 140);
4636         if (status < 0)
4637                 goto error;
4638         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) -8);
4639         if (status < 0)
4640                 goto error;
4641         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) -16);
4642         if (status < 0)
4643                 goto error;
4644         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -26);
4645         if (status < 0)
4646                 goto error;
4647         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -56);
4648         if (status < 0)
4649                 goto error;
4650         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -86);
4651 error:
4652         if (status < 0)
4653                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4654         return status;
4655 }
4656
4657 /*============================================================================*/
4658
4659 /**
4660 * \brief QAM64 specific setup
4661 * \param demod instance of demod.
4662 * \return DRXStatus_t.
4663 */
4664 static int SetQAM64(struct drxk_state *state)
4665 {
4666         int status = 0;
4667
4668         dprintk(1, "\n");
4669         /* QAM Equalizer Setup */
4670         /* Equalizer */
4671         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 13336);
4672         if (status < 0)
4673                 goto error;
4674         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 12618);
4675         if (status < 0)
4676                 goto error;
4677         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 11988);
4678         if (status < 0)
4679                 goto error;
4680         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 13809);
4681         if (status < 0)
4682                 goto error;
4683         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 13809);
4684         if (status < 0)
4685                 goto error;
4686         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 15609);
4687         if (status < 0)
4688                 goto error;
4689
4690         /* Decision Feedback Equalizer */
4691         status = write16(state, QAM_DQ_QUAL_FUN0__A, 4);
4692         if (status < 0)
4693                 goto error;
4694         status = write16(state, QAM_DQ_QUAL_FUN1__A, 4);
4695         if (status < 0)
4696                 goto error;
4697         status = write16(state, QAM_DQ_QUAL_FUN2__A, 4);
4698         if (status < 0)
4699                 goto error;
4700         status = write16(state, QAM_DQ_QUAL_FUN3__A, 4);
4701         if (status < 0)
4702                 goto error;
4703         status = write16(state, QAM_DQ_QUAL_FUN4__A, 3);
4704         if (status < 0)
4705                 goto error;
4706         status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4707         if (status < 0)
4708                 goto error;
4709
4710         status = write16(state, QAM_SY_SYNC_HWM__A, 5);
4711         if (status < 0)
4712                 goto error;
4713         status = write16(state, QAM_SY_SYNC_AWM__A, 4);
4714         if (status < 0)
4715                 goto error;
4716         status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4717         if (status < 0)
4718                 goto error;
4719
4720         /* QAM Slicer Settings */
4721         status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM64);
4722         if (status < 0)
4723                 goto error;
4724
4725
4726         /* QAM Loop Controller Coeficients */
4727
4728         status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4729         if (status < 0)
4730                 goto error;
4731         status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4732         if (status < 0)
4733                 goto error;
4734         status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4735         if (status < 0)
4736                 goto error;
4737         status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4738         if (status < 0)
4739                 goto error;
4740         status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4741         if (status < 0)
4742                 goto error;
4743         status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4744         if (status < 0)
4745                 goto error;
4746         status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4747         if (status < 0)
4748                 goto error;
4749         status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4750         if (status < 0)
4751                 goto error;
4752
4753         status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4754         if (status < 0)
4755                 goto error;
4756         status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 30);
4757         if (status < 0)
4758                 goto error;
4759         status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 100);
4760         if (status < 0)
4761                 goto error;
4762         status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4763         if (status < 0)
4764                 goto error;
4765         status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 30);
4766         if (status < 0)
4767                 goto error;
4768         status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 50);
4769         if (status < 0)
4770                 goto error;
4771         status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4772         if (status < 0)
4773                 goto error;
4774         status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 25);
4775         if (status < 0)
4776                 goto error;
4777         status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 48);
4778         if (status < 0)
4779                 goto error;
4780         status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4781         if (status < 0)
4782                 goto error;
4783         status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4784         if (status < 0)
4785                 goto error;
4786         status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 10);
4787         if (status < 0)
4788                 goto error;
4789
4790
4791         /* QAM State Machine (FSM) Thresholds */
4792
4793         status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 100);
4794         if (status < 0)
4795                 goto error;
4796         status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 60);
4797         if (status < 0)
4798                 goto error;
4799         status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
4800         if (status < 0)
4801                 goto error;
4802         status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 110);
4803         if (status < 0)
4804                 goto error;
4805         status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 200);
4806         if (status < 0)
4807                 goto error;
4808         status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 95);
4809         if (status < 0)
4810                 goto error;
4811
4812         status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
4813         if (status < 0)
4814                 goto error;
4815         status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
4816         if (status < 0)
4817                 goto error;
4818         status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 15);
4819         if (status < 0)
4820                 goto error;
4821
4822
4823         /* QAM FSM Tracking Parameters */
4824
4825         status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 12);
4826         if (status < 0)
4827                 goto error;
4828         status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 141);
4829         if (status < 0)
4830                 goto error;
4831         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 7);
4832         if (status < 0)
4833                 goto error;
4834         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 0);
4835         if (status < 0)
4836                 goto error;
4837         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -15);
4838         if (status < 0)
4839                 goto error;
4840         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -45);
4841         if (status < 0)
4842                 goto error;
4843         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -80);
4844 error:
4845         if (status < 0)
4846                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4847
4848         return status;
4849 }
4850
4851 /*============================================================================*/
4852
4853 /**
4854 * \brief QAM128 specific setup
4855 * \param demod: instance of demod.
4856 * \return DRXStatus_t.
4857 */
4858 static int SetQAM128(struct drxk_state *state)
4859 {
4860         int status = 0;
4861
4862         dprintk(1, "\n");
4863         /* QAM Equalizer Setup */
4864         /* Equalizer */
4865         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 6564);
4866         if (status < 0)
4867                 goto error;
4868         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 6598);
4869         if (status < 0)
4870                 goto error;
4871         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 6394);
4872         if (status < 0)
4873                 goto error;
4874         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 6409);
4875         if (status < 0)
4876                 goto error;
4877         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 6656);
4878         if (status < 0)
4879                 goto error;
4880         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 7238);
4881         if (status < 0)
4882                 goto error;
4883
4884         /* Decision Feedback Equalizer */
4885         status = write16(state, QAM_DQ_QUAL_FUN0__A, 6);
4886         if (status < 0)
4887                 goto error;
4888         status = write16(state, QAM_DQ_QUAL_FUN1__A, 6);
4889         if (status < 0)
4890                 goto error;
4891         status = write16(state, QAM_DQ_QUAL_FUN2__A, 6);
4892         if (status < 0)
4893                 goto error;
4894         status = write16(state, QAM_DQ_QUAL_FUN3__A, 6);
4895         if (status < 0)
4896                 goto error;
4897         status = write16(state, QAM_DQ_QUAL_FUN4__A, 5);
4898         if (status < 0)
4899                 goto error;
4900         status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4901         if (status < 0)
4902                 goto error;
4903
4904         status = write16(state, QAM_SY_SYNC_HWM__A, 6);
4905         if (status < 0)
4906                 goto error;
4907         status = write16(state, QAM_SY_SYNC_AWM__A, 5);
4908         if (status < 0)
4909                 goto error;
4910         status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4911         if (status < 0)
4912                 goto error;
4913
4914
4915         /* QAM Slicer Settings */
4916
4917         status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM128);
4918         if (status < 0)
4919                 goto error;
4920
4921
4922         /* QAM Loop Controller Coeficients */
4923
4924         status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4925         if (status < 0)
4926                 goto error;
4927         status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4928         if (status < 0)
4929                 goto error;
4930         status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4931         if (status < 0)
4932                 goto error;
4933         status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4934         if (status < 0)
4935                 goto error;
4936         status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4937         if (status < 0)
4938                 goto error;
4939         status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4940         if (status < 0)
4941                 goto error;
4942         status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4943         if (status < 0)
4944                 goto error;
4945         status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4946         if (status < 0)
4947                 goto error;
4948
4949         status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4950         if (status < 0)
4951                 goto error;
4952         status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 40);
4953         if (status < 0)
4954                 goto error;
4955         status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 120);
4956         if (status < 0)
4957                 goto error;
4958         status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4959         if (status < 0)
4960                 goto error;
4961         status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 40);
4962         if (status < 0)
4963                 goto error;
4964         status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 60);
4965         if (status < 0)
4966                 goto error;
4967         status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4968         if (status < 0)
4969                 goto error;
4970         status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 25);
4971         if (status < 0)
4972                 goto error;
4973         status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 64);
4974         if (status < 0)
4975                 goto error;
4976         status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4977         if (status < 0)
4978                 goto error;
4979         status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4980         if (status < 0)
4981                 goto error;
4982         status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 0);
4983         if (status < 0)
4984                 goto error;
4985
4986
4987         /* QAM State Machine (FSM) Thresholds */
4988
4989         status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 50);
4990         if (status < 0)
4991                 goto error;
4992         status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 60);
4993         if (status < 0)
4994                 goto error;
4995         status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
4996         if (status < 0)
4997                 goto error;
4998         status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 100);
4999         if (status < 0)
5000                 goto error;
5001         status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 140);
5002         if (status < 0)
5003                 goto error;
5004         status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 100);
5005         if (status < 0)
5006                 goto error;
5007
5008         status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
5009         if (status < 0)
5010                 goto error;
5011         status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 5);
5012         if (status < 0)
5013                 goto error;
5014
5015         status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 12);
5016         if (status < 0)
5017                 goto error;
5018
5019         /* QAM FSM Tracking Parameters */
5020
5021         status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 8);
5022         if (status < 0)
5023                 goto error;
5024         status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 65);
5025         if (status < 0)
5026                 goto error;
5027         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 5);
5028         if (status < 0)
5029                 goto error;
5030         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 3);
5031         if (status < 0)
5032                 goto error;
5033         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -1);
5034         if (status < 0)
5035                 goto error;
5036         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -12);
5037         if (status < 0)
5038                 goto error;
5039         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -23);
5040 error:
5041         if (status < 0)
5042                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5043
5044         return status;
5045 }
5046
5047 /*============================================================================*/
5048
5049 /**
5050 * \brief QAM256 specific setup
5051 * \param demod: instance of demod.
5052 * \return DRXStatus_t.
5053 */
5054 static int SetQAM256(struct drxk_state *state)
5055 {
5056         int status = 0;
5057
5058         dprintk(1, "\n");
5059         /* QAM Equalizer Setup */
5060         /* Equalizer */
5061         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 11502);
5062         if (status < 0)
5063                 goto error;
5064         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 12084);
5065         if (status < 0)
5066                 goto error;
5067         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 12543);
5068         if (status < 0)
5069                 goto error;
5070         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 12931);
5071         if (status < 0)
5072                 goto error;
5073         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 13629);
5074         if (status < 0)
5075                 goto error;
5076         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 15385);
5077         if (status < 0)
5078                 goto error;
5079
5080         /* Decision Feedback Equalizer */
5081         status = write16(state, QAM_DQ_QUAL_FUN0__A, 8);
5082         if (status < 0)
5083                 goto error;
5084         status = write16(state, QAM_DQ_QUAL_FUN1__A, 8);
5085         if (status < 0)
5086                 goto error;
5087         status = write16(state, QAM_DQ_QUAL_FUN2__A, 8);
5088         if (status < 0)
5089                 goto error;
5090         status = write16(state, QAM_DQ_QUAL_FUN3__A, 8);
5091         if (status < 0)
5092                 goto error;
5093         status = write16(state, QAM_DQ_QUAL_FUN4__A, 6);
5094         if (status < 0)
5095                 goto error;
5096         status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
5097         if (status < 0)
5098                 goto error;
5099
5100         status = write16(state, QAM_SY_SYNC_HWM__A, 5);
5101         if (status < 0)
5102                 goto error;
5103         status = write16(state, QAM_SY_SYNC_AWM__A, 4);
5104         if (status < 0)
5105                 goto error;
5106         status = write16(state, QAM_SY_SYNC_LWM__A, 3);
5107         if (status < 0)
5108                 goto error;
5109
5110         /* QAM Slicer Settings */
5111
5112         status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM256);
5113         if (status < 0)
5114                 goto error;
5115
5116
5117         /* QAM Loop Controller Coeficients */
5118
5119         status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
5120         if (status < 0)
5121                 goto error;
5122         status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
5123         if (status < 0)
5124                 goto error;
5125         status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
5126         if (status < 0)
5127                 goto error;
5128         status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
5129         if (status < 0)
5130                 goto error;
5131         status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
5132         if (status < 0)
5133                 goto error;
5134         status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
5135         if (status < 0)
5136                 goto error;
5137         status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
5138         if (status < 0)
5139                 goto error;
5140         status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
5141         if (status < 0)
5142                 goto error;
5143
5144         status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
5145         if (status < 0)
5146                 goto error;
5147         status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 50);
5148         if (status < 0)
5149                 goto error;
5150         status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 250);
5151         if (status < 0)
5152                 goto error;
5153         status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
5154         if (status < 0)
5155                 goto error;
5156         status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 50);
5157         if (status < 0)
5158                 goto error;
5159         status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 125);
5160         if (status < 0)
5161                 goto error;
5162         status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
5163         if (status < 0)
5164                 goto error;
5165         status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 25);
5166         if (status < 0)
5167                 goto error;
5168         status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 48);
5169         if (status < 0)
5170                 goto error;
5171         status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
5172         if (status < 0)
5173                 goto error;
5174         status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
5175         if (status < 0)
5176                 goto error;
5177         status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 10);
5178         if (status < 0)
5179                 goto error;
5180
5181
5182         /* QAM State Machine (FSM) Thresholds */
5183
5184         status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 50);
5185         if (status < 0)
5186                 goto error;
5187         status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 60);
5188         if (status < 0)
5189                 goto error;
5190         status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
5191         if (status < 0)
5192                 goto error;
5193         status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 100);
5194         if (status < 0)
5195                 goto error;
5196         status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 150);
5197         if (status < 0)
5198                 goto error;
5199         status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 110);
5200         if (status < 0)
5201                 goto error;
5202
5203         status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
5204         if (status < 0)
5205                 goto error;
5206         status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
5207         if (status < 0)
5208                 goto error;
5209         status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 12);
5210         if (status < 0)
5211                 goto error;
5212
5213
5214         /* QAM FSM Tracking Parameters */
5215
5216         status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 8);
5217         if (status < 0)
5218                 goto error;
5219         status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 74);
5220         if (status < 0)
5221                 goto error;
5222         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 18);
5223         if (status < 0)
5224                 goto error;
5225         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 13);
5226         if (status < 0)
5227                 goto error;
5228         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) 7);
5229         if (status < 0)
5230                 goto error;
5231         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) 0);
5232         if (status < 0)
5233                 goto error;
5234         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -8);
5235 error:
5236         if (status < 0)
5237                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5238         return status;
5239 }
5240
5241
5242 /*============================================================================*/
5243 /**
5244 * \brief Reset QAM block.
5245 * \param demod:   instance of demod.
5246 * \param channel: pointer to channel data.
5247 * \return DRXStatus_t.
5248 */
5249 static int QAMResetQAM(struct drxk_state *state)
5250 {
5251         int status;
5252         u16 cmdResult;
5253
5254         dprintk(1, "\n");
5255         /* Stop QAM comstate->m_exec */
5256         status = write16(state, QAM_COMM_EXEC__A, QAM_COMM_EXEC_STOP);
5257         if (status < 0)
5258                 goto error;
5259
5260         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_RESET, 0, NULL, 1, &cmdResult);
5261 error:
5262         if (status < 0)
5263                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5264         return status;
5265 }
5266
5267 /*============================================================================*/
5268
5269 /**
5270 * \brief Set QAM symbolrate.
5271 * \param demod:   instance of demod.
5272 * \param channel: pointer to channel data.
5273 * \return DRXStatus_t.
5274 */
5275 static int QAMSetSymbolrate(struct drxk_state *state)
5276 {
5277         u32 adcFrequency = 0;
5278         u32 symbFreq = 0;
5279         u32 iqmRcRate = 0;
5280         u16 ratesel = 0;
5281         u32 lcSymbRate = 0;
5282         int status;
5283
5284         dprintk(1, "\n");
5285         /* Select & calculate correct IQM rate */
5286         adcFrequency = (state->m_sysClockFreq * 1000) / 3;
5287         ratesel = 0;
5288         /* printk(KERN_DEBUG "drxk: SR %d\n", state->param.u.qam.symbol_rate); */
5289         if (state->param.u.qam.symbol_rate <= 1188750)
5290                 ratesel = 3;
5291         else if (state->param.u.qam.symbol_rate <= 2377500)
5292                 ratesel = 2;
5293         else if (state->param.u.qam.symbol_rate <= 4755000)
5294                 ratesel = 1;
5295         status = write16(state, IQM_FD_RATESEL__A, ratesel);
5296         if (status < 0)
5297                 goto error;
5298
5299         /*
5300                 IqmRcRate = ((Fadc / (symbolrate * (4<<ratesel))) - 1) * (1<<23)
5301                 */
5302         symbFreq = state->param.u.qam.symbol_rate * (1 << ratesel);
5303         if (symbFreq == 0) {
5304                 /* Divide by zero */
5305                 status = -EINVAL;
5306                 goto error;
5307         }
5308         iqmRcRate = (adcFrequency / symbFreq) * (1 << 21) +
5309                 (Frac28a((adcFrequency % symbFreq), symbFreq) >> 7) -
5310                 (1 << 23);
5311         status = write32(state, IQM_RC_RATE_OFS_LO__A, iqmRcRate);
5312         if (status < 0)
5313                 goto error;
5314         state->m_iqmRcRate = iqmRcRate;
5315         /*
5316                 LcSymbFreq = round (.125 *  symbolrate / adcFreq * (1<<15))
5317                 */
5318         symbFreq = state->param.u.qam.symbol_rate;
5319         if (adcFrequency == 0) {
5320                 /* Divide by zero */
5321                 status = -EINVAL;
5322                 goto error;
5323         }
5324         lcSymbRate = (symbFreq / adcFrequency) * (1 << 12) +
5325                 (Frac28a((symbFreq % adcFrequency), adcFrequency) >>
5326                 16);
5327         if (lcSymbRate > 511)
5328                 lcSymbRate = 511;
5329         status = write16(state, QAM_LC_SYMBOL_FREQ__A, (u16) lcSymbRate);
5330
5331 error:
5332         if (status < 0)
5333                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5334         return status;
5335 }
5336
5337 /*============================================================================*/
5338
5339 /**
5340 * \brief Get QAM lock status.
5341 * \param demod:   instance of demod.
5342 * \param channel: pointer to channel data.
5343 * \return DRXStatus_t.
5344 */
5345
5346 static int GetQAMLockStatus(struct drxk_state *state, u32 *pLockStatus)
5347 {
5348         int status;
5349         u16 Result[2] = { 0, 0 };
5350
5351         dprintk(1, "\n");
5352         *pLockStatus = NOT_LOCKED;
5353         status = scu_command(state,
5354                         SCU_RAM_COMMAND_STANDARD_QAM |
5355                         SCU_RAM_COMMAND_CMD_DEMOD_GET_LOCK, 0, NULL, 2,
5356                         Result);
5357         if (status < 0)
5358                 printk(KERN_ERR "drxk: %s status = %08x\n", __func__, status);
5359
5360         if (Result[1] < SCU_RAM_QAM_LOCKED_LOCKED_DEMOD_LOCKED) {
5361                 /* 0x0000 NOT LOCKED */
5362         } else if (Result[1] < SCU_RAM_QAM_LOCKED_LOCKED_LOCKED) {
5363                 /* 0x4000 DEMOD LOCKED */
5364                 *pLockStatus = DEMOD_LOCK;
5365         } else if (Result[1] < SCU_RAM_QAM_LOCKED_LOCKED_NEVER_LOCK) {
5366                 /* 0x8000 DEMOD + FEC LOCKED (system lock) */
5367                 *pLockStatus = MPEG_LOCK;
5368         } else {
5369                 /* 0xC000 NEVER LOCKED */
5370                 /* (system will never be able to lock to the signal) */
5371                 /* TODO: check this, intermediate & standard specific lock states are not
5372                    taken into account here */
5373                 *pLockStatus = NEVER_LOCK;
5374         }
5375         return status;
5376 }
5377
5378 #define QAM_MIRROR__M         0x03
5379 #define QAM_MIRROR_NORMAL     0x00
5380 #define QAM_MIRRORED          0x01
5381 #define QAM_MIRROR_AUTO_ON    0x02
5382 #define QAM_LOCKRANGE__M      0x10
5383 #define QAM_LOCKRANGE_NORMAL  0x10
5384
5385 static int SetQAM(struct drxk_state *state, u16 IntermediateFreqkHz,
5386                   s32 tunerFreqOffset)
5387 {
5388         int status;
5389         u16 setParamParameters[4] = { 0, 0, 0, 0 };
5390         u16 cmdResult;
5391
5392         dprintk(1, "\n");
5393         /*
5394          * STEP 1: reset demodulator
5395          *      resets FEC DI and FEC RS
5396          *      resets QAM block
5397          *      resets SCU variables
5398          */
5399         status = write16(state, FEC_DI_COMM_EXEC__A, FEC_DI_COMM_EXEC_STOP);
5400         if (status < 0)
5401                 goto error;
5402         status = write16(state, FEC_RS_COMM_EXEC__A, FEC_RS_COMM_EXEC_STOP);
5403         if (status < 0)
5404                 goto error;
5405         status = QAMResetQAM(state);
5406         if (status < 0)
5407                 goto error;
5408
5409         /*
5410          * STEP 2: configure demodulator
5411          *      -set params; resets IQM,QAM,FEC HW; initializes some
5412          *       SCU variables
5413          */
5414         status = QAMSetSymbolrate(state);
5415         if (status < 0)
5416                 goto error;
5417
5418         /* Set params */
5419         switch (state->param.u.qam.modulation) {
5420         case QAM_256:
5421                 state->m_Constellation = DRX_CONSTELLATION_QAM256;
5422                 break;
5423         case QAM_AUTO:
5424         case QAM_64:
5425                 state->m_Constellation = DRX_CONSTELLATION_QAM64;
5426                 break;
5427         case QAM_16:
5428                 state->m_Constellation = DRX_CONSTELLATION_QAM16;
5429                 break;
5430         case QAM_32:
5431                 state->m_Constellation = DRX_CONSTELLATION_QAM32;
5432                 break;
5433         case QAM_128:
5434                 state->m_Constellation = DRX_CONSTELLATION_QAM128;
5435                 break;
5436         default:
5437                 status = -EINVAL;
5438                 break;
5439         }
5440         if (status < 0)
5441                 goto error;
5442         setParamParameters[0] = state->m_Constellation; /* constellation     */
5443         setParamParameters[1] = DRXK_QAM_I12_J17;       /* interleave mode   */
5444         if (state->m_OperationMode == OM_QAM_ITU_C)
5445                 setParamParameters[2] = QAM_TOP_ANNEX_C;
5446         else
5447                 setParamParameters[2] = QAM_TOP_ANNEX_A;
5448         setParamParameters[3] |= (QAM_MIRROR_AUTO_ON);
5449         /* Env parameters */
5450         /* check for LOCKRANGE Extented */
5451         /* setParamParameters[3] |= QAM_LOCKRANGE_NORMAL; */
5452
5453         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_SET_PARAM, 4, setParamParameters, 1, &cmdResult);
5454         if (status < 0) {
5455                 /* Fall-back to the simpler call */
5456                 if (state->m_OperationMode == OM_QAM_ITU_C)
5457                         setParamParameters[0] = QAM_TOP_ANNEX_C;
5458                 else
5459                         setParamParameters[0] = QAM_TOP_ANNEX_A;
5460                 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_SET_ENV, 1, setParamParameters, 1, &cmdResult);
5461                 if (status < 0)
5462                         goto error;
5463
5464                 setParamParameters[0] = state->m_Constellation; /* constellation     */
5465                 setParamParameters[1] = DRXK_QAM_I12_J17;       /* interleave mode   */
5466                 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_SET_PARAM, 2, setParamParameters, 1, &cmdResult);
5467         }
5468         if (status < 0)
5469                 goto error;
5470
5471         /*
5472          * STEP 3: enable the system in a mode where the ADC provides valid
5473          * signal setup constellation independent registers
5474          */
5475 #if 0
5476         status = SetFrequency(channel, tunerFreqOffset));
5477         if (status < 0)
5478                 goto error;
5479 #endif
5480         status = SetFrequencyShifter(state, IntermediateFreqkHz, tunerFreqOffset, true);
5481         if (status < 0)
5482                 goto error;
5483
5484         /* Setup BER measurement */
5485         status = SetQAMMeasurement(state, state->m_Constellation, state->param.u. qam.symbol_rate);
5486         if (status < 0)
5487                 goto error;
5488
5489         /* Reset default values */
5490         status = write16(state, IQM_CF_SCALE_SH__A, IQM_CF_SCALE_SH__PRE);
5491         if (status < 0)
5492                 goto error;
5493         status = write16(state, QAM_SY_TIMEOUT__A, QAM_SY_TIMEOUT__PRE);
5494         if (status < 0)
5495                 goto error;
5496
5497         /* Reset default LC values */
5498         status = write16(state, QAM_LC_RATE_LIMIT__A, 3);
5499         if (status < 0)
5500                 goto error;
5501         status = write16(state, QAM_LC_LPF_FACTORP__A, 4);
5502         if (status < 0)
5503                 goto error;
5504         status = write16(state, QAM_LC_LPF_FACTORI__A, 4);
5505         if (status < 0)
5506                 goto error;
5507         status = write16(state, QAM_LC_MODE__A, 7);
5508         if (status < 0)
5509                 goto error;
5510
5511         status = write16(state, QAM_LC_QUAL_TAB0__A, 1);
5512         if (status < 0)
5513                 goto error;
5514         status = write16(state, QAM_LC_QUAL_TAB1__A, 1);
5515         if (status < 0)
5516                 goto error;
5517         status = write16(state, QAM_LC_QUAL_TAB2__A, 1);
5518         if (status < 0)
5519                 goto error;
5520         status = write16(state, QAM_LC_QUAL_TAB3__A, 1);
5521         if (status < 0)
5522                 goto error;
5523         status = write16(state, QAM_LC_QUAL_TAB4__A, 2);
5524         if (status < 0)
5525                 goto error;
5526         status = write16(state, QAM_LC_QUAL_TAB5__A, 2);
5527         if (status < 0)
5528                 goto error;
5529         status = write16(state, QAM_LC_QUAL_TAB6__A, 2);
5530         if (status < 0)
5531                 goto error;
5532         status = write16(state, QAM_LC_QUAL_TAB8__A, 2);
5533         if (status < 0)
5534                 goto error;
5535         status = write16(state, QAM_LC_QUAL_TAB9__A, 2);
5536         if (status < 0)
5537                 goto error;
5538         status = write16(state, QAM_LC_QUAL_TAB10__A, 2);
5539         if (status < 0)
5540                 goto error;
5541         status = write16(state, QAM_LC_QUAL_TAB12__A, 2);
5542         if (status < 0)
5543                 goto error;
5544         status = write16(state, QAM_LC_QUAL_TAB15__A, 3);
5545         if (status < 0)
5546                 goto error;
5547         status = write16(state, QAM_LC_QUAL_TAB16__A, 3);
5548         if (status < 0)
5549                 goto error;
5550         status = write16(state, QAM_LC_QUAL_TAB20__A, 4);
5551         if (status < 0)
5552                 goto error;
5553         status = write16(state, QAM_LC_QUAL_TAB25__A, 4);
5554         if (status < 0)
5555                 goto error;
5556
5557         /* Mirroring, QAM-block starting point not inverted */
5558         status = write16(state, QAM_SY_SP_INV__A, QAM_SY_SP_INV_SPECTRUM_INV_DIS);
5559         if (status < 0)
5560                 goto error;
5561
5562         /* Halt SCU to enable safe non-atomic accesses */
5563         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_HOLD);
5564         if (status < 0)
5565                 goto error;
5566
5567         /* STEP 4: constellation specific setup */
5568         switch (state->param.u.qam.modulation) {
5569         case QAM_16:
5570                 status = SetQAM16(state);
5571                 break;
5572         case QAM_32:
5573                 status = SetQAM32(state);
5574                 break;
5575         case QAM_AUTO:
5576         case QAM_64:
5577                 status = SetQAM64(state);
5578                 break;
5579         case QAM_128:
5580                 status = SetQAM128(state);
5581                 break;
5582         case QAM_256:
5583                 status = SetQAM256(state);
5584                 break;
5585         default:
5586                 status = -EINVAL;
5587                 break;
5588         }
5589         if (status < 0)
5590                 goto error;
5591
5592         /* Activate SCU to enable SCU commands */
5593         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
5594         if (status < 0)
5595                 goto error;
5596
5597         /* Re-configure MPEG output, requires knowledge of channel bitrate */
5598         /* extAttr->currentChannel.constellation = channel->constellation; */
5599         /* extAttr->currentChannel.symbolrate    = channel->symbolrate; */
5600         status = MPEGTSDtoSetup(state, state->m_OperationMode);
5601         if (status < 0)
5602                 goto error;
5603
5604         /* Start processes */
5605         status = MPEGTSStart(state);
5606         if (status < 0)
5607                 goto error;
5608         status = write16(state, FEC_COMM_EXEC__A, FEC_COMM_EXEC_ACTIVE);
5609         if (status < 0)
5610                 goto error;
5611         status = write16(state, QAM_COMM_EXEC__A, QAM_COMM_EXEC_ACTIVE);
5612         if (status < 0)
5613                 goto error;
5614         status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_ACTIVE);
5615         if (status < 0)
5616                 goto error;
5617
5618         /* STEP 5: start QAM demodulator (starts FEC, QAM and IQM HW) */
5619         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_START, 0, NULL, 1, &cmdResult);
5620         if (status < 0)
5621                 goto error;
5622
5623         /* update global DRXK data container */
5624 /*?     extAttr->qamInterleaveMode = DRXK_QAM_I12_J17; */
5625
5626 error:
5627         if (status < 0)
5628                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5629         return status;
5630 }
5631
5632 static int SetQAMStandard(struct drxk_state *state,
5633                           enum OperationMode oMode)
5634 {
5635         int status;
5636 #ifdef DRXK_QAM_TAPS
5637 #define DRXK_QAMA_TAPS_SELECT
5638 #include "drxk_filters.h"
5639 #undef DRXK_QAMA_TAPS_SELECT
5640 #endif
5641
5642         dprintk(1, "\n");
5643
5644         /* added antenna switch */
5645         SwitchAntennaToQAM(state);
5646
5647         /* Ensure correct power-up mode */
5648         status = PowerUpQAM(state);
5649         if (status < 0)
5650                 goto error;
5651         /* Reset QAM block */
5652         status = QAMResetQAM(state);
5653         if (status < 0)
5654                 goto error;
5655
5656         /* Setup IQM */
5657
5658         status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_STOP);
5659         if (status < 0)
5660                 goto error;
5661         status = write16(state, IQM_AF_AMUX__A, IQM_AF_AMUX_SIGNAL2ADC);
5662         if (status < 0)
5663                 goto error;
5664
5665         /* Upload IQM Channel Filter settings by
5666                 boot loader from ROM table */
5667         switch (oMode) {
5668         case OM_QAM_ITU_A:
5669                 status = BLChainCmd(state, DRXK_BL_ROM_OFFSET_TAPS_ITU_A, DRXK_BLCC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
5670                 break;
5671         case OM_QAM_ITU_C:
5672                 status = BLDirectCmd(state, IQM_CF_TAP_RE0__A, DRXK_BL_ROM_OFFSET_TAPS_ITU_C, DRXK_BLDC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
5673                 if (status < 0)
5674                         goto error;
5675                 status = BLDirectCmd(state, IQM_CF_TAP_IM0__A, DRXK_BL_ROM_OFFSET_TAPS_ITU_C, DRXK_BLDC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
5676                 break;
5677         default:
5678                 status = -EINVAL;
5679         }
5680         if (status < 0)
5681                 goto error;
5682
5683         status = write16(state, IQM_CF_OUT_ENA__A, (1 << IQM_CF_OUT_ENA_QAM__B));
5684         if (status < 0)
5685                 goto error;
5686         status = write16(state, IQM_CF_SYMMETRIC__A, 0);
5687         if (status < 0)
5688                 goto error;
5689         status = write16(state, IQM_CF_MIDTAP__A, ((1 << IQM_CF_MIDTAP_RE__B) | (1 << IQM_CF_MIDTAP_IM__B)));
5690         if (status < 0)
5691                 goto error;
5692
5693         status = write16(state, IQM_RC_STRETCH__A, 21);
5694         if (status < 0)
5695                 goto error;
5696         status = write16(state, IQM_AF_CLP_LEN__A, 0);
5697         if (status < 0)
5698                 goto error;
5699         status = write16(state, IQM_AF_CLP_TH__A, 448);
5700         if (status < 0)
5701                 goto error;
5702         status = write16(state, IQM_AF_SNS_LEN__A, 0);
5703         if (status < 0)
5704                 goto error;
5705         status = write16(state, IQM_CF_POW_MEAS_LEN__A, 0);
5706         if (status < 0)
5707                 goto error;
5708
5709         status = write16(state, IQM_FS_ADJ_SEL__A, 1);
5710         if (status < 0)
5711                 goto error;
5712         status = write16(state, IQM_RC_ADJ_SEL__A, 1);
5713         if (status < 0)
5714                 goto error;
5715         status = write16(state, IQM_CF_ADJ_SEL__A, 1);
5716         if (status < 0)
5717                 goto error;
5718         status = write16(state, IQM_AF_UPD_SEL__A, 0);
5719         if (status < 0)
5720                 goto error;
5721
5722         /* IQM Impulse Noise Processing Unit */
5723         status = write16(state, IQM_CF_CLP_VAL__A, 500);
5724         if (status < 0)
5725                 goto error;
5726         status = write16(state, IQM_CF_DATATH__A, 1000);
5727         if (status < 0)
5728                 goto error;
5729         status = write16(state, IQM_CF_BYPASSDET__A, 1);
5730         if (status < 0)
5731                 goto error;
5732         status = write16(state, IQM_CF_DET_LCT__A, 0);
5733         if (status < 0)
5734                 goto error;
5735         status = write16(state, IQM_CF_WND_LEN__A, 1);
5736         if (status < 0)
5737                 goto error;
5738         status = write16(state, IQM_CF_PKDTH__A, 1);
5739         if (status < 0)
5740                 goto error;
5741         status = write16(state, IQM_AF_INC_BYPASS__A, 1);
5742         if (status < 0)
5743                 goto error;
5744
5745         /* turn on IQMAF. Must be done before setAgc**() */
5746         status = SetIqmAf(state, true);
5747         if (status < 0)
5748                 goto error;
5749         status = write16(state, IQM_AF_START_LOCK__A, 0x01);
5750         if (status < 0)
5751                 goto error;
5752
5753         /* IQM will not be reset from here, sync ADC and update/init AGC */
5754         status = ADCSynchronization(state);
5755         if (status < 0)
5756                 goto error;
5757
5758         /* Set the FSM step period */
5759         status = write16(state, SCU_RAM_QAM_FSM_STEP_PERIOD__A, 2000);
5760         if (status < 0)
5761                 goto error;
5762
5763         /* Halt SCU to enable safe non-atomic accesses */
5764         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_HOLD);
5765         if (status < 0)
5766                 goto error;
5767
5768         /* No more resets of the IQM, current standard correctly set =>
5769                 now AGCs can be configured. */
5770
5771         status = InitAGC(state, true);
5772         if (status < 0)
5773                 goto error;
5774         status = SetPreSaw(state, &(state->m_qamPreSawCfg));
5775         if (status < 0)
5776                 goto error;
5777
5778         /* Configure AGC's */
5779         status = SetAgcRf(state, &(state->m_qamRfAgcCfg), true);
5780         if (status < 0)
5781                 goto error;
5782         status = SetAgcIf(state, &(state->m_qamIfAgcCfg), true);
5783         if (status < 0)
5784                 goto error;
5785
5786         /* Activate SCU to enable SCU commands */
5787         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
5788 error:
5789         if (status < 0)
5790                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5791         return status;
5792 }
5793
5794 static int WriteGPIO(struct drxk_state *state)
5795 {
5796         int status;
5797         u16 value = 0;
5798
5799         dprintk(1, "\n");
5800         /* stop lock indicator process */
5801         status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
5802         if (status < 0)
5803                 goto error;
5804
5805         /*  Write magic word to enable pdr reg write               */
5806         status = write16(state, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY);
5807         if (status < 0)
5808                 goto error;
5809
5810         if (state->m_hasSAWSW) {
5811                 if (state->UIO_mask & 0x0001) { /* UIO-1 */
5812                         /* write to io pad configuration register - output mode */
5813                         status = write16(state, SIO_PDR_SMA_TX_CFG__A, state->m_GPIOCfg);
5814                         if (status < 0)
5815                                 goto error;
5816
5817                         /* use corresponding bit in io data output registar */
5818                         status = read16(state, SIO_PDR_UIO_OUT_LO__A, &value);
5819                         if (status < 0)
5820                                 goto error;
5821                         if ((state->m_GPIO & 0x0001) == 0)
5822                                 value &= 0x7FFF;        /* write zero to 15th bit - 1st UIO */
5823                         else
5824                                 value |= 0x8000;        /* write one to 15th bit - 1st UIO */
5825                         /* write back to io data output register */
5826                         status = write16(state, SIO_PDR_UIO_OUT_LO__A, value);
5827                         if (status < 0)
5828                                 goto error;
5829                 }
5830                 if (state->UIO_mask & 0x0002) { /* UIO-2 */
5831                         /* write to io pad configuration register - output mode */
5832                         status = write16(state, SIO_PDR_SMA_TX_CFG__A, state->m_GPIOCfg);
5833                         if (status < 0)
5834                                 goto error;
5835
5836                         /* use corresponding bit in io data output registar */
5837                         status = read16(state, SIO_PDR_UIO_OUT_LO__A, &value);
5838                         if (status < 0)
5839                                 goto error;
5840                         if ((state->m_GPIO & 0x0002) == 0)
5841                                 value &= 0xBFFF;        /* write zero to 14th bit - 2st UIO */
5842                         else
5843                                 value |= 0x4000;        /* write one to 14th bit - 2st UIO */
5844                         /* write back to io data output register */
5845                         status = write16(state, SIO_PDR_UIO_OUT_LO__A, value);
5846                         if (status < 0)
5847                                 goto error;
5848                 }
5849                 if (state->UIO_mask & 0x0004) { /* UIO-3 */
5850                         /* write to io pad configuration register - output mode */
5851                         status = write16(state, SIO_PDR_SMA_TX_CFG__A, state->m_GPIOCfg);
5852                         if (status < 0)
5853                                 goto error;
5854
5855                         /* use corresponding bit in io data output registar */
5856                         status = read16(state, SIO_PDR_UIO_OUT_LO__A, &value);
5857                         if (status < 0)
5858                                 goto error;
5859                         if ((state->m_GPIO & 0x0004) == 0)
5860                                 value &= 0xFFFB;            /* write zero to 2nd bit - 3rd UIO */
5861                         else
5862                                 value |= 0x0004;            /* write one to 2nd bit - 3rd UIO */
5863                         /* write back to io data output register */
5864                         status = write16(state, SIO_PDR_UIO_OUT_LO__A, value);
5865                         if (status < 0)
5866                                 goto error;
5867                 }
5868         }
5869         /*  Write magic word to disable pdr reg write               */
5870         status = write16(state, SIO_TOP_COMM_KEY__A, 0x0000);
5871 error:
5872         if (status < 0)
5873                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5874         return status;
5875 }
5876
5877 static int SwitchAntennaToQAM(struct drxk_state *state)
5878 {
5879         int status = 0;
5880         bool gpio_state;
5881
5882         dprintk(1, "\n");
5883
5884         if (!state->antenna_gpio)
5885                 return 0;
5886
5887         gpio_state = state->m_GPIO & state->antenna_gpio;
5888
5889         if (state->antenna_dvbt ^ gpio_state) {
5890                 /* Antenna is on DVB-T mode. Switch */
5891                 if (state->antenna_dvbt)
5892                         state->m_GPIO &= ~state->antenna_gpio;
5893                 else
5894                         state->m_GPIO |= state->antenna_gpio;
5895                 status = WriteGPIO(state);
5896         }
5897         if (status < 0)
5898                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5899         return status;
5900 }
5901
5902 static int SwitchAntennaToDVBT(struct drxk_state *state)
5903 {
5904         int status = 0;
5905         bool gpio_state;
5906
5907         dprintk(1, "\n");
5908
5909         if (!state->antenna_gpio)
5910                 return 0;
5911
5912         gpio_state = state->m_GPIO & state->antenna_gpio;
5913
5914         if (!(state->antenna_dvbt ^ gpio_state)) {
5915                 /* Antenna is on DVB-C mode. Switch */
5916                 if (state->antenna_dvbt)
5917                         state->m_GPIO |= state->antenna_gpio;
5918                 else
5919                         state->m_GPIO &= ~state->antenna_gpio;
5920                 status = WriteGPIO(state);
5921         }
5922         if (status < 0)
5923                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5924         return status;
5925 }
5926
5927
5928 static int PowerDownDevice(struct drxk_state *state)
5929 {
5930         /* Power down to requested mode */
5931         /* Backup some register settings */
5932         /* Set pins with possible pull-ups connected to them in input mode */
5933         /* Analog power down */
5934         /* ADC power down */
5935         /* Power down device */
5936         int status;
5937
5938         dprintk(1, "\n");
5939         if (state->m_bPDownOpenBridge) {
5940                 /* Open I2C bridge before power down of DRXK */
5941                 status = ConfigureI2CBridge(state, true);
5942                 if (status < 0)
5943                         goto error;
5944         }
5945         /* driver 0.9.0 */
5946         status = DVBTEnableOFDMTokenRing(state, false);
5947         if (status < 0)
5948                 goto error;
5949
5950         status = write16(state, SIO_CC_PWD_MODE__A, SIO_CC_PWD_MODE_LEVEL_CLOCK);
5951         if (status < 0)
5952                 goto error;
5953         status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
5954         if (status < 0)
5955                 goto error;
5956         state->m_HICfgCtrl |= SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ;
5957         status = HI_CfgCommand(state);
5958 error:
5959         if (status < 0)
5960                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5961
5962         return status;
5963 }
5964
5965 static int load_microcode(struct drxk_state *state, const char *mc_name)
5966 {
5967         const struct firmware *fw = NULL;
5968         int err = 0;
5969
5970         dprintk(1, "\n");
5971
5972         err = request_firmware(&fw, mc_name, state->i2c->dev.parent);
5973         if (err < 0) {
5974                 printk(KERN_ERR
5975                        "drxk: Could not load firmware file %s.\n", mc_name);
5976                 printk(KERN_INFO
5977                        "drxk: Copy %s to your hotplug directory!\n", mc_name);
5978                 return err;
5979         }
5980         err = DownloadMicrocode(state, fw->data, fw->size);
5981         release_firmware(fw);
5982         return err;
5983 }
5984
5985 static int init_drxk(struct drxk_state *state)
5986 {
5987         int status = 0;
5988         enum DRXPowerMode powerMode = DRXK_POWER_DOWN_OFDM;
5989         u16 driverVersion;
5990
5991         dprintk(1, "\n");
5992         if ((state->m_DrxkState == DRXK_UNINITIALIZED)) {
5993                 status = PowerUpDevice(state);
5994                 if (status < 0)
5995                         goto error;
5996                 status = DRXX_Open(state);
5997                 if (status < 0)
5998                         goto error;
5999                 /* Soft reset of OFDM-, sys- and osc-clockdomain */
6000                 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);
6001                 if (status < 0)
6002                         goto error;
6003                 status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
6004                 if (status < 0)
6005                         goto error;
6006                 /* TODO is this needed, if yes how much delay in worst case scenario */
6007                 msleep(1);
6008                 state->m_DRXK_A3_PATCH_CODE = true;
6009                 status = GetDeviceCapabilities(state);
6010                 if (status < 0)
6011                         goto error;
6012
6013                 /* Bridge delay, uses oscilator clock */
6014                 /* Delay = (delay (nano seconds) * oscclk (kHz))/ 1000 */
6015                 /* SDA brdige delay */
6016                 state->m_HICfgBridgeDelay =
6017                         (u16) ((state->m_oscClockFreq / 1000) *
6018                                 HI_I2C_BRIDGE_DELAY) / 1000;
6019                 /* Clipping */
6020                 if (state->m_HICfgBridgeDelay >
6021                         SIO_HI_RA_RAM_PAR_3_CFG_DBL_SDA__M) {
6022                         state->m_HICfgBridgeDelay =
6023                                 SIO_HI_RA_RAM_PAR_3_CFG_DBL_SDA__M;
6024                 }
6025                 /* SCL bridge delay, same as SDA for now */
6026                 state->m_HICfgBridgeDelay +=
6027                         state->m_HICfgBridgeDelay <<
6028                         SIO_HI_RA_RAM_PAR_3_CFG_DBL_SCL__B;
6029
6030                 status = InitHI(state);
6031                 if (status < 0)
6032                         goto error;
6033                 /* disable various processes */
6034 #if NOA1ROM
6035                 if (!(state->m_DRXK_A1_ROM_CODE)
6036                         && !(state->m_DRXK_A2_ROM_CODE))
6037 #endif
6038                 {
6039                         status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
6040                         if (status < 0)
6041                                 goto error;
6042                 }
6043
6044                 /* disable MPEG port */
6045                 status = MPEGTSDisable(state);
6046                 if (status < 0)
6047                         goto error;
6048
6049                 /* Stop AUD and SCU */
6050                 status = write16(state, AUD_COMM_EXEC__A, AUD_COMM_EXEC_STOP);
6051                 if (status < 0)
6052                         goto error;
6053                 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_STOP);
6054                 if (status < 0)
6055                         goto error;
6056
6057                 /* enable token-ring bus through OFDM block for possible ucode upload */
6058                 status = write16(state, SIO_OFDM_SH_OFDM_RING_ENABLE__A, SIO_OFDM_SH_OFDM_RING_ENABLE_ON);
6059                 if (status < 0)
6060                         goto error;
6061
6062                 /* include boot loader section */
6063                 status = write16(state, SIO_BL_COMM_EXEC__A, SIO_BL_COMM_EXEC_ACTIVE);
6064                 if (status < 0)
6065                         goto error;
6066                 status = BLChainCmd(state, 0, 6, 100);
6067                 if (status < 0)
6068                         goto error;
6069
6070                 if (!state->microcode_name)
6071                         load_microcode(state, "drxk_a3.mc");
6072                 else
6073                         load_microcode(state, state->microcode_name);
6074
6075                 /* disable token-ring bus through OFDM block for possible ucode upload */
6076                 status = write16(state, SIO_OFDM_SH_OFDM_RING_ENABLE__A, SIO_OFDM_SH_OFDM_RING_ENABLE_OFF);
6077                 if (status < 0)
6078                         goto error;
6079
6080                 /* Run SCU for a little while to initialize microcode version numbers */
6081                 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
6082                 if (status < 0)
6083                         goto error;
6084                 status = DRXX_Open(state);
6085                 if (status < 0)
6086                         goto error;
6087                 /* added for test */
6088                 msleep(30);
6089
6090                 powerMode = DRXK_POWER_DOWN_OFDM;
6091                 status = CtrlPowerMode(state, &powerMode);
6092                 if (status < 0)
6093                         goto error;
6094
6095                 /* Stamp driver version number in SCU data RAM in BCD code
6096                         Done to enable field application engineers to retreive drxdriver version
6097                         via I2C from SCU RAM.
6098                         Not using SCU command interface for SCU register access since no
6099                         microcode may be present.
6100                         */
6101                 driverVersion =
6102                         (((DRXK_VERSION_MAJOR / 100) % 10) << 12) +
6103                         (((DRXK_VERSION_MAJOR / 10) % 10) << 8) +
6104                         ((DRXK_VERSION_MAJOR % 10) << 4) +
6105                         (DRXK_VERSION_MINOR % 10);
6106                 status = write16(state, SCU_RAM_DRIVER_VER_HI__A, driverVersion);
6107                 if (status < 0)
6108                         goto error;
6109                 driverVersion =
6110                         (((DRXK_VERSION_PATCH / 1000) % 10) << 12) +
6111                         (((DRXK_VERSION_PATCH / 100) % 10) << 8) +
6112                         (((DRXK_VERSION_PATCH / 10) % 10) << 4) +
6113                         (DRXK_VERSION_PATCH % 10);
6114                 status = write16(state, SCU_RAM_DRIVER_VER_LO__A, driverVersion);
6115                 if (status < 0)
6116                         goto error;
6117
6118                 printk(KERN_INFO "DRXK driver version %d.%d.%d\n",
6119                         DRXK_VERSION_MAJOR, DRXK_VERSION_MINOR,
6120                         DRXK_VERSION_PATCH);
6121
6122                 /* Dirty fix of default values for ROM/PATCH microcode
6123                         Dirty because this fix makes it impossible to setup suitable values
6124                         before calling DRX_Open. This solution requires changes to RF AGC speed
6125                         to be done via the CTRL function after calling DRX_Open */
6126
6127                 /* m_dvbtRfAgcCfg.speed = 3; */
6128
6129                 /* Reset driver debug flags to 0 */
6130                 status = write16(state, SCU_RAM_DRIVER_DEBUG__A, 0);
6131                 if (status < 0)
6132                         goto error;
6133                 /* driver 0.9.0 */
6134                 /* Setup FEC OC:
6135                         NOTE: No more full FEC resets allowed afterwards!! */
6136                 status = write16(state, FEC_COMM_EXEC__A, FEC_COMM_EXEC_STOP);
6137                 if (status < 0)
6138                         goto error;
6139                 /* MPEGTS functions are still the same */
6140                 status = MPEGTSDtoInit(state);
6141                 if (status < 0)
6142                         goto error;
6143                 status = MPEGTSStop(state);
6144                 if (status < 0)
6145                         goto error;
6146                 status = MPEGTSConfigurePolarity(state);
6147                 if (status < 0)
6148                         goto error;
6149                 status = MPEGTSConfigurePins(state, state->m_enableMPEGOutput);
6150                 if (status < 0)
6151                         goto error;
6152                 /* added: configure GPIO */
6153                 status = WriteGPIO(state);
6154                 if (status < 0)
6155                         goto error;
6156
6157                 state->m_DrxkState = DRXK_STOPPED;
6158
6159                 if (state->m_bPowerDown) {
6160                         status = PowerDownDevice(state);
6161                         if (status < 0)
6162                                 goto error;
6163                         state->m_DrxkState = DRXK_POWERED_DOWN;
6164                 } else
6165                         state->m_DrxkState = DRXK_STOPPED;
6166         }
6167 error:
6168         if (status < 0)
6169                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
6170
6171         return status;
6172 }
6173
6174 static void drxk_c_release(struct dvb_frontend *fe)
6175 {
6176         struct drxk_state *state = fe->demodulator_priv;
6177
6178         dprintk(1, "\n");
6179         kfree(state);
6180 }
6181
6182 static int drxk_c_init(struct dvb_frontend *fe)
6183 {
6184         struct drxk_state *state = fe->demodulator_priv;
6185
6186         dprintk(1, "\n");
6187         if (mutex_trylock(&state->ctlock) == 0)
6188                 return -EBUSY;
6189         if (state->m_itut_annex_c)
6190                 SetOperationMode(state, OM_QAM_ITU_C);
6191         else
6192                 SetOperationMode(state, OM_QAM_ITU_A);
6193         return 0;
6194 }
6195
6196 static int drxk_c_sleep(struct dvb_frontend *fe)
6197 {
6198         struct drxk_state *state = fe->demodulator_priv;
6199
6200         dprintk(1, "\n");
6201         ShutDown(state);
6202         mutex_unlock(&state->ctlock);
6203         return 0;
6204 }
6205
6206 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
6207 {
6208         struct drxk_state *state = fe->demodulator_priv;
6209
6210         dprintk(1, "%s\n", enable ? "enable" : "disable");
6211         return ConfigureI2CBridge(state, enable ? true : false);
6212 }
6213
6214 static int drxk_set_parameters(struct dvb_frontend *fe,
6215                                struct dvb_frontend_parameters *p)
6216 {
6217         struct drxk_state *state = fe->demodulator_priv;
6218         u32 delsys  = fe->dtv_property_cache.delivery_system;
6219         u32 IF;
6220
6221         dprintk(1, "\n");
6222
6223         if (!fe->ops.tuner_ops.get_if_frequency) {
6224                 printk(KERN_ERR
6225                        "drxk: Error: get_if_frequency() not defined at tuner. Can't work without it!\n");
6226                 return -EINVAL;
6227         }
6228
6229         switch (delsys) {
6230         case SYS_DVBC_ANNEX_A:
6231                 state->m_itut_annex_c = false;
6232                 break;
6233         case SYS_DVBC_ANNEX_C:
6234                 state->m_itut_annex_c = true;
6235                 break;
6236         default:
6237                 return -EINVAL;
6238         }
6239
6240         if (fe->ops.i2c_gate_ctrl)
6241                 fe->ops.i2c_gate_ctrl(fe, 1);
6242         if (fe->ops.tuner_ops.set_params)
6243                 fe->ops.tuner_ops.set_params(fe, p);
6244         if (fe->ops.i2c_gate_ctrl)
6245                 fe->ops.i2c_gate_ctrl(fe, 0);
6246         state->param = *p;
6247         fe->ops.tuner_ops.get_if_frequency(fe, &IF);
6248         Start(state, 0, IF);
6249
6250         /* printk(KERN_DEBUG "drxk: %s IF=%d done\n", __func__, IF); */
6251
6252         return 0;
6253 }
6254
6255 static int drxk_c_get_frontend(struct dvb_frontend *fe,
6256                                struct dvb_frontend_parameters *p)
6257 {
6258         dprintk(1, "\n");
6259         return 0;
6260 }
6261
6262 static int drxk_read_status(struct dvb_frontend *fe, fe_status_t *status)
6263 {
6264         struct drxk_state *state = fe->demodulator_priv;
6265         u32 stat;
6266
6267         dprintk(1, "\n");
6268         *status = 0;
6269         GetLockStatus(state, &stat, 0);
6270         if (stat == MPEG_LOCK)
6271                 *status |= 0x1f;
6272         if (stat == FEC_LOCK)
6273                 *status |= 0x0f;
6274         if (stat == DEMOD_LOCK)
6275                 *status |= 0x07;
6276         return 0;
6277 }
6278
6279 static int drxk_read_ber(struct dvb_frontend *fe, u32 *ber)
6280 {
6281         dprintk(1, "\n");
6282
6283         *ber = 0;
6284         return 0;
6285 }
6286
6287 static int drxk_read_signal_strength(struct dvb_frontend *fe,
6288                                      u16 *strength)
6289 {
6290         struct drxk_state *state = fe->demodulator_priv;
6291         u32 val = 0;
6292
6293         dprintk(1, "\n");
6294         ReadIFAgc(state, &val);
6295         *strength = val & 0xffff;
6296         return 0;
6297 }
6298
6299 static int drxk_read_snr(struct dvb_frontend *fe, u16 *snr)
6300 {
6301         struct drxk_state *state = fe->demodulator_priv;
6302         s32 snr2;
6303
6304         dprintk(1, "\n");
6305         GetSignalToNoise(state, &snr2);
6306         *snr = snr2 & 0xffff;
6307         return 0;
6308 }
6309
6310 static int drxk_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
6311 {
6312         struct drxk_state *state = fe->demodulator_priv;
6313         u16 err;
6314
6315         dprintk(1, "\n");
6316         DVBTQAMGetAccPktErr(state, &err);
6317         *ucblocks = (u32) err;
6318         return 0;
6319 }
6320
6321 static int drxk_c_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings
6322                                     *sets)
6323 {
6324         dprintk(1, "\n");
6325         sets->min_delay_ms = 3000;
6326         sets->max_drift = 0;
6327         sets->step_size = 0;
6328         return 0;
6329 }
6330
6331 static void drxk_t_release(struct dvb_frontend *fe)
6332 {
6333         /*
6334          * There's nothing to release here, as the state struct
6335          * is already freed by drxk_c_release.
6336          */
6337 }
6338
6339 static int drxk_t_init(struct dvb_frontend *fe)
6340 {
6341         struct drxk_state *state = fe->demodulator_priv;
6342
6343         dprintk(1, "\n");
6344         if (mutex_trylock(&state->ctlock) == 0)
6345                 return -EBUSY;
6346         SetOperationMode(state, OM_DVBT);
6347         return 0;
6348 }
6349
6350 static int drxk_t_sleep(struct dvb_frontend *fe)
6351 {
6352         struct drxk_state *state = fe->demodulator_priv;
6353
6354         dprintk(1, "\n");
6355         mutex_unlock(&state->ctlock);
6356         return 0;
6357 }
6358
6359 static int drxk_t_get_frontend(struct dvb_frontend *fe,
6360                                struct dvb_frontend_parameters *p)
6361 {
6362         dprintk(1, "\n");
6363
6364         return 0;
6365 }
6366
6367 static struct dvb_frontend_ops drxk_c_ops = {
6368         .info = {
6369                  .name = "DRXK DVB-C",
6370                  .type = FE_QAM,
6371                  .frequency_stepsize = 62500,
6372                  .frequency_min = 47000000,
6373                  .frequency_max = 862000000,
6374                  .symbol_rate_min = 870000,
6375                  .symbol_rate_max = 11700000,
6376                  .caps = FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 |
6377                  FE_CAN_QAM_128 | FE_CAN_QAM_256 | FE_CAN_FEC_AUTO},
6378         .release = drxk_c_release,
6379         .init = drxk_c_init,
6380         .sleep = drxk_c_sleep,
6381         .i2c_gate_ctrl = drxk_gate_ctrl,
6382
6383         .set_frontend = drxk_set_parameters,
6384         .get_frontend = drxk_c_get_frontend,
6385         .get_tune_settings = drxk_c_get_tune_settings,
6386
6387         .read_status = drxk_read_status,
6388         .read_ber = drxk_read_ber,
6389         .read_signal_strength = drxk_read_signal_strength,
6390         .read_snr = drxk_read_snr,
6391         .read_ucblocks = drxk_read_ucblocks,
6392 };
6393
6394 static struct dvb_frontend_ops drxk_t_ops = {
6395         .info = {
6396                  .name = "DRXK DVB-T",
6397                  .type = FE_OFDM,
6398                  .frequency_min = 47125000,
6399                  .frequency_max = 865000000,
6400                  .frequency_stepsize = 166667,
6401                  .frequency_tolerance = 0,
6402                  .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
6403                  FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
6404                  FE_CAN_FEC_AUTO |
6405                  FE_CAN_QAM_16 | FE_CAN_QAM_64 |
6406                  FE_CAN_QAM_AUTO |
6407                  FE_CAN_TRANSMISSION_MODE_AUTO |
6408                  FE_CAN_GUARD_INTERVAL_AUTO |
6409                  FE_CAN_HIERARCHY_AUTO | FE_CAN_RECOVER | FE_CAN_MUTE_TS},
6410         .release = drxk_t_release,
6411         .init = drxk_t_init,
6412         .sleep = drxk_t_sleep,
6413         .i2c_gate_ctrl = drxk_gate_ctrl,
6414
6415         .set_frontend = drxk_set_parameters,
6416         .get_frontend = drxk_t_get_frontend,
6417
6418         .read_status = drxk_read_status,
6419         .read_ber = drxk_read_ber,
6420         .read_signal_strength = drxk_read_signal_strength,
6421         .read_snr = drxk_read_snr,
6422         .read_ucblocks = drxk_read_ucblocks,
6423 };
6424
6425 struct dvb_frontend *drxk_attach(const struct drxk_config *config,
6426                                  struct i2c_adapter *i2c,
6427                                  struct dvb_frontend **fe_t)
6428 {
6429         struct drxk_state *state = NULL;
6430         u8 adr = config->adr;
6431
6432         dprintk(1, "\n");
6433         state = kzalloc(sizeof(struct drxk_state), GFP_KERNEL);
6434         if (!state)
6435                 return NULL;
6436
6437         state->i2c = i2c;
6438         state->demod_address = adr;
6439         state->single_master = config->single_master;
6440         state->microcode_name = config->microcode_name;
6441         state->no_i2c_bridge = config->no_i2c_bridge;
6442         state->antenna_gpio = config->antenna_gpio;
6443         state->antenna_dvbt = config->antenna_dvbt;
6444         state->m_ChunkSize = config->chunk_size;
6445
6446         /* NOTE: as more UIO bits will be used, add them to the mask */
6447         state->UIO_mask = config->antenna_gpio;
6448
6449         /* Default gpio to DVB-C */
6450         if (!state->antenna_dvbt && state->antenna_gpio)
6451                 state->m_GPIO |= state->antenna_gpio;
6452         else
6453                 state->m_GPIO &= ~state->antenna_gpio;
6454
6455         mutex_init(&state->mutex);
6456         mutex_init(&state->ctlock);
6457
6458         memcpy(&state->c_frontend.ops, &drxk_c_ops,
6459                sizeof(struct dvb_frontend_ops));
6460         memcpy(&state->t_frontend.ops, &drxk_t_ops,
6461                sizeof(struct dvb_frontend_ops));
6462         state->c_frontend.demodulator_priv = state;
6463         state->t_frontend.demodulator_priv = state;
6464
6465         init_state(state);
6466         if (init_drxk(state) < 0)
6467                 goto error;
6468         *fe_t = &state->t_frontend;
6469
6470         return &state->c_frontend;
6471
6472 error:
6473         printk(KERN_ERR "drxk: not found\n");
6474         kfree(state);
6475         return NULL;
6476 }
6477 EXPORT_SYMBOL(drxk_attach);
6478
6479 MODULE_DESCRIPTION("DRX-K driver");
6480 MODULE_AUTHOR("Ralph Metzler");
6481 MODULE_LICENSE("GPL");