drivers/media/dvb-frontends/drx39xyj/drxj.c

   1 /*
   2   Copyright (c), 2004-2005,2007-2010 Trident Microsystems, Inc.
   3   All rights reserved.
   4
   5   Redistribution and use in source and binary forms, with or without
   6   modification, are permitted provided that the following conditions are met:
   7
   8   * Redistributions of source code must retain the above copyright notice,
   9     this list of conditions and the following disclaimer.
  10   * Redistributions in binary form must reproduce the above copyright notice,
  11     this list of conditions and the following disclaimer in the documentation
  12         and/or other materials provided with the distribution.
  13   * Neither the name of Trident Microsystems nor Hauppauge Computer Works
  14     nor the names of its contributors may be used to endorse or promote
  15         products derived from this software without specific prior written
  16         permission.
  17
  18   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  22   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28   POSSIBILITY OF SUCH DAMAGE.
  29
  30   DRXJ specific implementation of DRX driver
  31   authors: Dragan Savic, Milos Nikolic, Mihajlo Katona, Tao Ding, Paul Janssen
  32
  33   The Linux DVB Driver for Micronas DRX39xx family (drx3933j) was
  34   written by Devin Heitmueller <devin.heitmueller@kernellabs.com>
  35
  36   This program is free software; you can redistribute it and/or modify
  37   it under the terms of the GNU General Public License as published by
  38   the Free Software Foundation; either version 2 of the License, or
  39   (at your option) any later version.
  40
  41   This program is distributed in the hope that it will be useful,
  42   but WITHOUT ANY WARRANTY; without even the implied warranty of
  43   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  44
  45   GNU General Public License for more details.
  46
  47   You should have received a copy of the GNU General Public License
  48   along with this program; if not, write to the Free Software
  49   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  50 */
  51
  52 /*-----------------------------------------------------------------------------
  53 INCLUDE FILES
  54 ----------------------------------------------------------------------------*/
  55
  56 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
  57
  58 #include <linux/module.h>
  59 #include <linux/init.h>
  60 #include <linux/string.h>
  61 #include <linux/slab.h>
  62 #include <asm/div64.h>
  63
  64 #include "dvb_frontend.h"
  65 #include "drx39xxj.h"
  66
  67 #include "drxj.h"
  68 #include "drxj_map.h"
  69
  70 /*============================================================================*/
  71 /*=== DEFINES ================================================================*/
  72 /*============================================================================*/
  73
  74 #define DRX39XX_MAIN_FIRMWARE "dvb-fe-drxj-mc-1.0.8.fw"
  75
  76 /**
  77 * \brief Maximum u32 value.
  78 */
  79 #ifndef MAX_U32
  80 #define MAX_U32  ((u32) (0xFFFFFFFFL))
  81 #endif
  82
  83 /* Customer configurable hardware settings, etc */
  84 #ifndef MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH
  85 #define MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH 0x02
  86 #endif
  87
  88 #ifndef MPEG_PARALLEL_OUTPUT_PIN_DRIVE_STRENGTH
  89 #define MPEG_PARALLEL_OUTPUT_PIN_DRIVE_STRENGTH 0x02
  90 #endif
  91
  92 #ifndef MPEG_OUTPUT_CLK_DRIVE_STRENGTH
  93 #define MPEG_OUTPUT_CLK_DRIVE_STRENGTH 0x06
  94 #endif
  95
  96 #ifndef OOB_CRX_DRIVE_STRENGTH
  97 #define OOB_CRX_DRIVE_STRENGTH 0x02
  98 #endif
  99
 100 #ifndef OOB_DRX_DRIVE_STRENGTH
 101 #define OOB_DRX_DRIVE_STRENGTH 0x02
 102 #endif
 103 /**** START DJCOMBO patches to DRXJ registermap constants *********************/
 104 /**** registermap 200706071303 from drxj **************************************/
 105 #define   ATV_TOP_CR_AMP_TH_FM                                              0x0
 106 #define   ATV_TOP_CR_AMP_TH_L                                               0xA
 107 #define   ATV_TOP_CR_AMP_TH_LP                                              0xA
 108 #define   ATV_TOP_CR_AMP_TH_BG                                              0x8
 109 #define   ATV_TOP_CR_AMP_TH_DK                                              0x8
 110 #define   ATV_TOP_CR_AMP_TH_I                                               0x8
 111 #define     ATV_TOP_CR_CONT_CR_D_MN                                         0x18
 112 #define     ATV_TOP_CR_CONT_CR_D_FM                                         0x0
 113 #define     ATV_TOP_CR_CONT_CR_D_L                                          0x20
 114 #define     ATV_TOP_CR_CONT_CR_D_LP                                         0x20
 115 #define     ATV_TOP_CR_CONT_CR_D_BG                                         0x18
 116 #define     ATV_TOP_CR_CONT_CR_D_DK                                         0x18
 117 #define     ATV_TOP_CR_CONT_CR_D_I                                          0x18
 118 #define     ATV_TOP_CR_CONT_CR_I_MN                                         0x80
 119 #define     ATV_TOP_CR_CONT_CR_I_FM                                         0x0
 120 #define     ATV_TOP_CR_CONT_CR_I_L                                          0x80
 121 #define     ATV_TOP_CR_CONT_CR_I_LP                                         0x80
 122 #define     ATV_TOP_CR_CONT_CR_I_BG                                         0x80
 123 #define     ATV_TOP_CR_CONT_CR_I_DK                                         0x80
 124 #define     ATV_TOP_CR_CONT_CR_I_I                                          0x80
 125 #define     ATV_TOP_CR_CONT_CR_P_MN                                         0x4
 126 #define     ATV_TOP_CR_CONT_CR_P_FM                                         0x0
 127 #define     ATV_TOP_CR_CONT_CR_P_L                                          0x4
 128 #define     ATV_TOP_CR_CONT_CR_P_LP                                         0x4
 129 #define     ATV_TOP_CR_CONT_CR_P_BG                                         0x4
 130 #define     ATV_TOP_CR_CONT_CR_P_DK                                         0x4
 131 #define     ATV_TOP_CR_CONT_CR_P_I                                          0x4
 132 #define   ATV_TOP_CR_OVM_TH_MN                                              0xA0
 133 #define   ATV_TOP_CR_OVM_TH_FM                                              0x0
 134 #define   ATV_TOP_CR_OVM_TH_L                                               0xA0
 135 #define   ATV_TOP_CR_OVM_TH_LP                                              0xA0
 136 #define   ATV_TOP_CR_OVM_TH_BG                                              0xA0
 137 #define   ATV_TOP_CR_OVM_TH_DK                                              0xA0
 138 #define   ATV_TOP_CR_OVM_TH_I                                               0xA0
 139 #define     ATV_TOP_EQU0_EQU_C0_FM                                          0x0
 140 #define     ATV_TOP_EQU0_EQU_C0_L                                           0x3
 141 #define     ATV_TOP_EQU0_EQU_C0_LP                                          0x3
 142 #define     ATV_TOP_EQU0_EQU_C0_BG                                          0x7
 143 #define     ATV_TOP_EQU0_EQU_C0_DK                                          0x0
 144 #define     ATV_TOP_EQU0_EQU_C0_I                                           0x3
 145 #define     ATV_TOP_EQU1_EQU_C1_FM                                          0x0
 146 #define     ATV_TOP_EQU1_EQU_C1_L                                           0x1F6
 147 #define     ATV_TOP_EQU1_EQU_C1_LP                                          0x1F6
 148 #define     ATV_TOP_EQU1_EQU_C1_BG                                          0x197
 149 #define     ATV_TOP_EQU1_EQU_C1_DK                                          0x198
 150 #define     ATV_TOP_EQU1_EQU_C1_I                                           0x1F6
 151 #define     ATV_TOP_EQU2_EQU_C2_FM                                          0x0
 152 #define     ATV_TOP_EQU2_EQU_C2_L                                           0x28
 153 #define     ATV_TOP_EQU2_EQU_C2_LP                                          0x28
 154 #define     ATV_TOP_EQU2_EQU_C2_BG                                          0xC5
 155 #define     ATV_TOP_EQU2_EQU_C2_DK                                          0xB0
 156 #define     ATV_TOP_EQU2_EQU_C2_I                                           0x28
 157 #define     ATV_TOP_EQU3_EQU_C3_FM                                          0x0
 158 #define     ATV_TOP_EQU3_EQU_C3_L                                           0x192
 159 #define     ATV_TOP_EQU3_EQU_C3_LP                                          0x192
 160 #define     ATV_TOP_EQU3_EQU_C3_BG                                          0x12E
 161 #define     ATV_TOP_EQU3_EQU_C3_DK                                          0x18E
 162 #define     ATV_TOP_EQU3_EQU_C3_I                                           0x192
 163 #define     ATV_TOP_STD_MODE_MN                                             0x0
 164 #define     ATV_TOP_STD_MODE_FM                                             0x1
 165 #define     ATV_TOP_STD_MODE_L                                              0x0
 166 #define     ATV_TOP_STD_MODE_LP                                             0x0
 167 #define     ATV_TOP_STD_MODE_BG                                             0x0
 168 #define     ATV_TOP_STD_MODE_DK                                             0x0
 169 #define     ATV_TOP_STD_MODE_I                                              0x0
 170 #define     ATV_TOP_STD_VID_POL_MN                                          0x0
 171 #define     ATV_TOP_STD_VID_POL_FM                                          0x0
 172 #define     ATV_TOP_STD_VID_POL_L                                           0x2
 173 #define     ATV_TOP_STD_VID_POL_LP                                          0x2
 174 #define     ATV_TOP_STD_VID_POL_BG                                          0x0
 175 #define     ATV_TOP_STD_VID_POL_DK                                          0x0
 176 #define     ATV_TOP_STD_VID_POL_I                                           0x0
 177 #define   ATV_TOP_VID_AMP_MN                                                0x380
 178 #define   ATV_TOP_VID_AMP_FM                                                0x0
 179 #define   ATV_TOP_VID_AMP_L                                                 0xF50
 180 #define   ATV_TOP_VID_AMP_LP                                                0xF50
 181 #define   ATV_TOP_VID_AMP_BG                                                0x380
 182 #define   ATV_TOP_VID_AMP_DK                                                0x394
 183 #define   ATV_TOP_VID_AMP_I                                                 0x3D8
 184 #define   IQM_CF_OUT_ENA_OFDM__M                                            0x4
 185 #define     IQM_FS_ADJ_SEL_B_QAM                                            0x1
 186 #define     IQM_FS_ADJ_SEL_B_OFF                                            0x0
 187 #define     IQM_FS_ADJ_SEL_B_VSB                                            0x2
 188 #define     IQM_RC_ADJ_SEL_B_OFF                                            0x0
 189 #define     IQM_RC_ADJ_SEL_B_QAM                                            0x1
 190 #define     IQM_RC_ADJ_SEL_B_VSB                                            0x2
 191 /**** END DJCOMBO patches to DRXJ registermap *********************************/
 192
 193 #include "drx_driver_version.h"
 194
 195 /* #define DRX_DEBUG */
 196 #ifdef DRX_DEBUG
 197 #include <stdio.h>
 198 #endif
 199
 200 /*-----------------------------------------------------------------------------
 201 ENUMS
 202 ----------------------------------------------------------------------------*/
 203
 204 /*-----------------------------------------------------------------------------
 205 DEFINES
 206 ----------------------------------------------------------------------------*/
 207 #ifndef DRXJ_WAKE_UP_KEY
 208 #define DRXJ_WAKE_UP_KEY (demod->my_i2c_dev_addr->i2c_addr)
 209 #endif
 210
 211 /**
 212 * \def DRXJ_DEF_I2C_ADDR
 213 * \brief Default I2C address of a demodulator instance.
 214 */
 215 #define DRXJ_DEF_I2C_ADDR (0x52)
 216
 217 /**
 218 * \def DRXJ_DEF_DEMOD_DEV_ID
 219 * \brief Default device identifier of a demodultor instance.
 220 */
 221 #define DRXJ_DEF_DEMOD_DEV_ID      (1)
 222
 223 /**
 224 * \def DRXJ_SCAN_TIMEOUT
 225 * \brief Timeout value for waiting on demod lock during channel scan (millisec).
 226 */
 227 #define DRXJ_SCAN_TIMEOUT    1000
 228
 229 /**
 230 * \def HI_I2C_DELAY
 231 * \brief HI timing delay for I2C timing (in nano seconds)
 232 *
 233 *  Used to compute HI_CFG_DIV
 234 */
 235 #define HI_I2C_DELAY    42
 236
 237 /**
 238 * \def HI_I2C_BRIDGE_DELAY
 239 * \brief HI timing delay for I2C timing (in nano seconds)
 240 *
 241 *  Used to compute HI_CFG_BDL
 242 */
 243 #define HI_I2C_BRIDGE_DELAY   750
 244
 245 /**
 246 * \brief Time Window for MER and SER Measurement in Units of Segment duration.
 247 */
 248 #define VSB_TOP_MEASUREMENT_PERIOD  64
 249 #define SYMBOLS_PER_SEGMENT         832
 250
 251 /**
 252 * \brief bit rate and segment rate constants used for SER and BER.
 253 */
 254 /* values taken from the QAM microcode */
 255 #define DRXJ_QAM_SL_SIG_POWER_QAM_UNKNOWN 0
 256 #define DRXJ_QAM_SL_SIG_POWER_QPSK        32768
 257 #define DRXJ_QAM_SL_SIG_POWER_QAM8        24576
 258 #define DRXJ_QAM_SL_SIG_POWER_QAM16       40960
 259 #define DRXJ_QAM_SL_SIG_POWER_QAM32       20480
 260 #define DRXJ_QAM_SL_SIG_POWER_QAM64       43008
 261 #define DRXJ_QAM_SL_SIG_POWER_QAM128      20992
 262 #define DRXJ_QAM_SL_SIG_POWER_QAM256      43520
 263 /**
 264 * \brief Min supported symbolrates.
 265 */
 266 #ifndef DRXJ_QAM_SYMBOLRATE_MIN
 267 #define DRXJ_QAM_SYMBOLRATE_MIN          (520000)
 268 #endif
 269
 270 /**
 271 * \brief Max supported symbolrates.
 272 */
 273 #ifndef DRXJ_QAM_SYMBOLRATE_MAX
 274 #define DRXJ_QAM_SYMBOLRATE_MAX         (7233000)
 275 #endif
 276
 277 /**
 278 * \def DRXJ_QAM_MAX_WAITTIME
 279 * \brief Maximal wait time for QAM auto constellation in ms
 280 */
 281 #ifndef DRXJ_QAM_MAX_WAITTIME
 282 #define DRXJ_QAM_MAX_WAITTIME 900
 283 #endif
 284
 285 #ifndef DRXJ_QAM_FEC_LOCK_WAITTIME
 286 #define DRXJ_QAM_FEC_LOCK_WAITTIME 150
 287 #endif
 288
 289 #ifndef DRXJ_QAM_DEMOD_LOCK_EXT_WAITTIME
 290 #define DRXJ_QAM_DEMOD_LOCK_EXT_WAITTIME 200
 291 #endif
 292
 293 /**
 294 * \def SCU status and results
 295 * \brief SCU
 296 */
 297 #define DRX_SCU_READY               0
 298 #define DRXJ_MAX_WAITTIME           100 /* ms */
 299 #define FEC_RS_MEASUREMENT_PERIOD   12894       /* 1 sec */
 300 #define FEC_RS_MEASUREMENT_PRESCALE 1   /* n sec */
 301
 302 /**
 303 * \def DRX_AUD_MAX_DEVIATION
 304 * \brief Needed for calculation of prescale feature in AUD
 305 */
 306 #ifndef DRXJ_AUD_MAX_FM_DEVIATION
 307 #define DRXJ_AUD_MAX_FM_DEVIATION  100  /* kHz */
 308 #endif
 309
 310 /**
 311 * \brief Needed for calculation of NICAM prescale feature in AUD
 312 */
 313 #ifndef DRXJ_AUD_MAX_NICAM_PRESCALE
 314 #define DRXJ_AUD_MAX_NICAM_PRESCALE  (9)        /* dB */
 315 #endif
 316
 317 /**
 318 * \brief Needed for calculation of NICAM prescale feature in AUD
 319 */
 320 #ifndef DRXJ_AUD_MAX_WAITTIME
 321 #define DRXJ_AUD_MAX_WAITTIME  250      /* ms */
 322 #endif
 323
 324 /* ATV config changed flags */
 325 #define DRXJ_ATV_CHANGED_COEF          (0x00000001UL)
 326 #define DRXJ_ATV_CHANGED_PEAK_FLT      (0x00000008UL)
 327 #define DRXJ_ATV_CHANGED_NOISE_FLT     (0x00000010UL)
 328 #define DRXJ_ATV_CHANGED_OUTPUT        (0x00000020UL)
 329 #define DRXJ_ATV_CHANGED_SIF_ATT       (0x00000040UL)
 330
 331 /* UIO define */
 332 #define DRX_UIO_MODE_FIRMWARE_SMA DRX_UIO_MODE_FIRMWARE0
 333 #define DRX_UIO_MODE_FIRMWARE_SAW DRX_UIO_MODE_FIRMWARE1
 334
 335 /*
 336  * MICROCODE RELATED DEFINES
 337  */
 338
 339 /* Magic word for checking correct Endianness of microcode data */
 340 #define DRX_UCODE_MAGIC_WORD         ((((u16)'H')<<8)+((u16)'L'))
 341
 342 /* CRC flag in ucode header, flags field. */
 343 #define DRX_UCODE_CRC_FLAG           (0x0001)
 344
 345 /*
 346  * Maximum size of buffer used to verify the microcode.
 347  * Must be an even number
 348  */
 349 #define DRX_UCODE_MAX_BUF_SIZE       (DRXDAP_MAX_RCHUNKSIZE)
 350
 351 #if DRX_UCODE_MAX_BUF_SIZE & 1
 352 #error DRX_UCODE_MAX_BUF_SIZE must be an even number
 353 #endif
 354
 355 /*
 356  * Power mode macros
 357  */
 358
 359 #define DRX_ISPOWERDOWNMODE(mode) ((mode == DRX_POWER_MODE_9) || \
 360                                        (mode == DRX_POWER_MODE_10) || \
 361                                        (mode == DRX_POWER_MODE_11) || \
 362                                        (mode == DRX_POWER_MODE_12) || \
 363                                        (mode == DRX_POWER_MODE_13) || \
 364                                        (mode == DRX_POWER_MODE_14) || \
 365                                        (mode == DRX_POWER_MODE_15) || \
 366                                        (mode == DRX_POWER_MODE_16) || \
 367                                        (mode == DRX_POWER_DOWN))
 368
 369 /* Pin safe mode macro */
 370 #define DRXJ_PIN_SAFE_MODE 0x0000
 371 /*============================================================================*/
 372 /*=== GLOBAL VARIABLEs =======================================================*/
 373 /*============================================================================*/
 374 /**
 375 */
 376
 377 /**
 378 * \brief Temporary register definitions.
 379 *        (register definitions that are not yet available in register master)
 380 */
 381
 382 /******************************************************************************/
 383 /* Audio block 0x103 is write only. To avoid shadowing in driver accessing    */
 384 /* RAM adresses directly. This must be READ ONLY to avoid problems.           */
 385 /* Writing to the interface adresses is more than only writing the RAM        */
 386 /* locations                                                                  */
 387 /******************************************************************************/
 388 /**
 389 * \brief RAM location of MODUS registers
 390 */
 391 #define AUD_DEM_RAM_MODUS_HI__A              0x10204A3
 392 #define AUD_DEM_RAM_MODUS_HI__M              0xF000
 393
 394 #define AUD_DEM_RAM_MODUS_LO__A              0x10204A4
 395 #define AUD_DEM_RAM_MODUS_LO__M              0x0FFF
 396
 397 /**
 398 * \brief RAM location of I2S config registers
 399 */
 400 #define AUD_DEM_RAM_I2S_CONFIG1__A           0x10204B1
 401 #define AUD_DEM_RAM_I2S_CONFIG2__A           0x10204B2
 402
 403 /**
 404 * \brief RAM location of DCO config registers
 405 */
 406 #define AUD_DEM_RAM_DCO_B_HI__A              0x1020461
 407 #define AUD_DEM_RAM_DCO_B_LO__A              0x1020462
 408 #define AUD_DEM_RAM_DCO_A_HI__A              0x1020463
 409 #define AUD_DEM_RAM_DCO_A_LO__A              0x1020464
 410
 411 /**
 412 * \brief RAM location of Threshold registers
 413 */
 414 #define AUD_DEM_RAM_NICAM_THRSHLD__A         0x102045A
 415 #define AUD_DEM_RAM_A2_THRSHLD__A            0x10204BB
 416 #define AUD_DEM_RAM_BTSC_THRSHLD__A          0x10204A6
 417
 418 /**
 419 * \brief RAM location of Carrier Threshold registers
 420 */
 421 #define AUD_DEM_RAM_CM_A_THRSHLD__A          0x10204AF
 422 #define AUD_DEM_RAM_CM_B_THRSHLD__A          0x10204B0
 423
 424 /**
 425 * \brief FM Matrix register fix
 426 */
 427 #ifdef AUD_DEM_WR_FM_MATRIX__A
 428 #undef  AUD_DEM_WR_FM_MATRIX__A
 429 #endif
 430 #define AUD_DEM_WR_FM_MATRIX__A              0x105006F
 431
 432 /*============================================================================*/
 433 /**
 434 * \brief Defines required for audio
 435 */
 436 #define AUD_VOLUME_ZERO_DB                      115
 437 #define AUD_VOLUME_DB_MIN                       -60
 438 #define AUD_VOLUME_DB_MAX                       12
 439 #define AUD_CARRIER_STRENGTH_QP_0DB             0x4000
 440 #define AUD_CARRIER_STRENGTH_QP_0DB_LOG10T100   421
 441 #define AUD_MAX_AVC_REF_LEVEL                   15
 442 #define AUD_I2S_FREQUENCY_MAX                   48000UL
 443 #define AUD_I2S_FREQUENCY_MIN                   12000UL
 444 #define AUD_RDS_ARRAY_SIZE                      18
 445
 446 /**
 447 * \brief Needed for calculation of prescale feature in AUD
 448 */
 449 #ifndef DRX_AUD_MAX_FM_DEVIATION
 450 #define DRX_AUD_MAX_FM_DEVIATION  (100) /* kHz */
 451 #endif
 452
 453 /**
 454 * \brief Needed for calculation of NICAM prescale feature in AUD
 455 */
 456 #ifndef DRX_AUD_MAX_NICAM_PRESCALE
 457 #define DRX_AUD_MAX_NICAM_PRESCALE  (9) /* dB */
 458 #endif
 459
 460 /*============================================================================*/
 461 /* Values for I2S Master/Slave pin configurations */
 462 #define SIO_PDR_I2S_CL_CFG_MODE__MASTER      0x0004
 463 #define SIO_PDR_I2S_CL_CFG_DRIVE__MASTER     0x0008
 464 #define SIO_PDR_I2S_CL_CFG_MODE__SLAVE       0x0004
 465 #define SIO_PDR_I2S_CL_CFG_DRIVE__SLAVE      0x0000
 466
 467 #define SIO_PDR_I2S_DA_CFG_MODE__MASTER      0x0003
 468 #define SIO_PDR_I2S_DA_CFG_DRIVE__MASTER     0x0008
 469 #define SIO_PDR_I2S_DA_CFG_MODE__SLAVE       0x0003
 470 #define SIO_PDR_I2S_DA_CFG_DRIVE__SLAVE      0x0008
 471
 472 #define SIO_PDR_I2S_WS_CFG_MODE__MASTER      0x0004
 473 #define SIO_PDR_I2S_WS_CFG_DRIVE__MASTER     0x0008
 474 #define SIO_PDR_I2S_WS_CFG_MODE__SLAVE       0x0004
 475 #define SIO_PDR_I2S_WS_CFG_DRIVE__SLAVE      0x0000
 476
 477 /*============================================================================*/
 478 /*=== REGISTER ACCESS MACROS =================================================*/
 479 /*============================================================================*/
 480
 481 /**
 482 * This macro is used to create byte arrays for block writes.
 483 * Block writes speed up I2C traffic between host and demod.
 484 * The macro takes care of the required byte order in a 16 bits word.
 485 * x -> lowbyte(x), highbyte(x)
 486 */
 487 #define DRXJ_16TO8(x) ((u8) (((u16)x) & 0xFF)), \
 488                        ((u8)((((u16)x)>>8)&0xFF))
 489 /**
 490 * This macro is used to convert byte array to 16 bit register value for block read.
 491 * Block read speed up I2C traffic between host and demod.
 492 * The macro takes care of the required byte order in a 16 bits word.
 493 */
 494 #define DRXJ_8TO16(x) ((u16) (x[0] | (x[1] << 8)))
 495
 496 /*============================================================================*/
 497 /*=== MISC DEFINES ===========================================================*/
 498 /*============================================================================*/
 499
 500 /*============================================================================*/
 501 /*=== HI COMMAND RELATED DEFINES =============================================*/
 502 /*============================================================================*/
 503
 504 /**
 505 * \brief General maximum number of retries for ucode command interfaces
 506 */
 507 #define DRXJ_MAX_RETRIES (100)
 508
 509 /*============================================================================*/
 510 /*=== STANDARD RELATED MACROS ================================================*/
 511 /*============================================================================*/
 512
 513 #define DRXJ_ISATVSTD(std) ((std == DRX_STANDARD_PAL_SECAM_BG) || \
 514                                (std == DRX_STANDARD_PAL_SECAM_DK) || \
 515                                (std == DRX_STANDARD_PAL_SECAM_I) || \
 516                                (std == DRX_STANDARD_PAL_SECAM_L) || \
 517                                (std == DRX_STANDARD_PAL_SECAM_LP) || \
 518                                (std == DRX_STANDARD_NTSC) || \
 519                                (std == DRX_STANDARD_FM))
 520
 521 #define DRXJ_ISQAMSTD(std) ((std == DRX_STANDARD_ITU_A) || \
 522                                (std == DRX_STANDARD_ITU_B) || \
 523                                (std == DRX_STANDARD_ITU_C) || \
 524                                (std == DRX_STANDARD_ITU_D))
 525
 526 /*-----------------------------------------------------------------------------
 527 GLOBAL VARIABLES
 528 ----------------------------------------------------------------------------*/
 529 /*
 530  * DRXJ DAP structures
 531  */
 532
 533 static int drxdap_fasi_read_block(struct i2c_device_addr *dev_addr,
 534                                       u32 addr,
 535                                       u16 datasize,
 536                                       u8 *data, u32 flags);
 537
 538
 539 static int drxj_dap_read_modify_write_reg16(struct i2c_device_addr *dev_addr,
 540                                                  u32 waddr,
 541                                                  u32 raddr,
 542                                                  u16 wdata, u16 *rdata);
 543
 544 static int drxj_dap_read_reg16(struct i2c_device_addr *dev_addr,
 545                                       u32 addr,
 546                                       u16 *data, u32 flags);
 547
 548 static int drxdap_fasi_read_reg32(struct i2c_device_addr *dev_addr,
 549                                       u32 addr,
 550                                       u32 *data, u32 flags);
 551
 552 static int drxdap_fasi_write_block(struct i2c_device_addr *dev_addr,
 553                                        u32 addr,
 554                                        u16 datasize,
 555                                        u8 *data, u32 flags);
 556
 557 static int drxj_dap_write_reg16(struct i2c_device_addr *dev_addr,
 558                                        u32 addr,
 559                                        u16 data, u32 flags);
 560
 561 static int drxdap_fasi_write_reg32(struct i2c_device_addr *dev_addr,
 562                                        u32 addr,
 563                                        u32 data, u32 flags);
 564
 565 static struct drxj_data drxj_data_g = {
 566         false,                  /* has_lna : true if LNA (aka PGA) present      */
 567         false,                  /* has_oob : true if OOB supported              */
 568         false,                  /* has_ntsc: true if NTSC supported             */
 569         false,                  /* has_btsc: true if BTSC supported             */
 570         false,                  /* has_smatx: true if SMA_TX pin is available   */
 571         false,                  /* has_smarx: true if SMA_RX pin is available   */
 572         false,                  /* has_gpio : true if GPIO pin is available     */
 573         false,                  /* has_irqn : true if IRQN pin is available     */
 574         0,                      /* mfx A1/A2/A... */
 575
 576         /* tuner settings */
 577         false,                  /* tuner mirrors RF signal    */
 578         /* standard/channel settings */
 579         DRX_STANDARD_UNKNOWN,   /* current standard           */
 580         DRX_CONSTELLATION_AUTO, /* constellation              */
 581         0,                      /* frequency in KHz           */
 582         DRX_BANDWIDTH_UNKNOWN,  /* curr_bandwidth              */
 583         DRX_MIRROR_NO,          /* mirror                     */
 584
 585         /* signal quality information: */
 586         /* default values taken from the QAM Programming guide */
 587         /*   fec_bits_desired should not be less than 4000000    */
 588         4000000,                /* fec_bits_desired    */
 589         5,                      /* fec_vd_plen         */
 590         4,                      /* qam_vd_prescale     */
 591         0xFFFF,                 /* qamVDPeriod       */
 592         204 * 8,                /* fec_rs_plen annex A */
 593         1,                      /* fec_rs_prescale     */
 594         FEC_RS_MEASUREMENT_PERIOD,      /* fec_rs_period     */
 595         true,                   /* reset_pkt_err_acc    */
 596         0,                      /* pkt_err_acc_start    */
 597
 598         /* HI configuration */
 599         0,                      /* hi_cfg_timing_div    */
 600         0,                      /* hi_cfg_bridge_delay  */
 601         0,                      /* hi_cfg_wake_up_key    */
 602         0,                      /* hi_cfg_ctrl         */
 603         0,                      /* HICfgTimeout      */
 604         /* UIO configuartion */
 605         DRX_UIO_MODE_DISABLE,   /* uio_sma_rx_mode      */
 606         DRX_UIO_MODE_DISABLE,   /* uio_sma_tx_mode      */
 607         DRX_UIO_MODE_DISABLE,   /* uioASELMode       */
 608         DRX_UIO_MODE_DISABLE,   /* uio_irqn_mode       */
 609         /* FS setting */
 610         0UL,                    /* iqm_fs_rate_ofs      */
 611         false,                  /* pos_image          */
 612         /* RC setting */
 613         0UL,                    /* iqm_rc_rate_ofs      */
 614         /* AUD information */
 615 /*   false,                  * flagSetAUDdone    */
 616 /*   false,                  * detectedRDS       */
 617 /*   true,                   * flagASDRequest    */
 618 /*   false,                  * flagHDevClear     */
 619 /*   false,                  * flagHDevSet       */
 620 /*   (u16) 0xFFF,          * rdsLastCount      */
 621
 622         /* ATV configuartion */
 623         0UL,                    /* flags cfg changes */
 624         /* shadow of ATV_TOP_EQU0__A */
 625         {-5,
 626          ATV_TOP_EQU0_EQU_C0_FM,
 627          ATV_TOP_EQU0_EQU_C0_L,
 628          ATV_TOP_EQU0_EQU_C0_LP,
 629          ATV_TOP_EQU0_EQU_C0_BG,
 630          ATV_TOP_EQU0_EQU_C0_DK,
 631          ATV_TOP_EQU0_EQU_C0_I},
 632         /* shadow of ATV_TOP_EQU1__A */
 633         {-50,
 634          ATV_TOP_EQU1_EQU_C1_FM,
 635          ATV_TOP_EQU1_EQU_C1_L,
 636          ATV_TOP_EQU1_EQU_C1_LP,
 637          ATV_TOP_EQU1_EQU_C1_BG,
 638          ATV_TOP_EQU1_EQU_C1_DK,
 639          ATV_TOP_EQU1_EQU_C1_I},
 640         /* shadow of ATV_TOP_EQU2__A */
 641         {210,
 642          ATV_TOP_EQU2_EQU_C2_FM,
 643          ATV_TOP_EQU2_EQU_C2_L,
 644          ATV_TOP_EQU2_EQU_C2_LP,
 645          ATV_TOP_EQU2_EQU_C2_BG,
 646          ATV_TOP_EQU2_EQU_C2_DK,
 647          ATV_TOP_EQU2_EQU_C2_I},
 648         /* shadow of ATV_TOP_EQU3__A */
 649         {-160,
 650          ATV_TOP_EQU3_EQU_C3_FM,
 651          ATV_TOP_EQU3_EQU_C3_L,
 652          ATV_TOP_EQU3_EQU_C3_LP,
 653          ATV_TOP_EQU3_EQU_C3_BG,
 654          ATV_TOP_EQU3_EQU_C3_DK,
 655          ATV_TOP_EQU3_EQU_C3_I},
 656         false,                  /* flag: true=bypass             */
 657         ATV_TOP_VID_PEAK__PRE,  /* shadow of ATV_TOP_VID_PEAK__A */
 658         ATV_TOP_NOISE_TH__PRE,  /* shadow of ATV_TOP_NOISE_TH__A */
 659         true,                   /* flag CVBS ouput enable        */
 660         false,                  /* flag SIF ouput enable         */
 661         DRXJ_SIF_ATTENUATION_0DB,       /* current SIF att setting       */
 662         {                       /* qam_rf_agc_cfg */
 663          DRX_STANDARD_ITU_B,    /* standard            */
 664          DRX_AGC_CTRL_AUTO,     /* ctrl_mode            */
 665          0,                     /* output_level         */
 666          0,                     /* min_output_level      */
 667          0xFFFF,                /* max_output_level      */
 668          0x0000,                /* speed               */
 669          0x0000,                /* top                 */
 670          0x0000                 /* c.o.c.              */
 671          },
 672         {                       /* qam_if_agc_cfg */
 673          DRX_STANDARD_ITU_B,    /* standard            */
 674          DRX_AGC_CTRL_AUTO,     /* ctrl_mode            */
 675          0,                     /* output_level         */
 676          0,                     /* min_output_level      */
 677          0xFFFF,                /* max_output_level      */
 678          0x0000,                /* speed               */
 679          0x0000,                /* top    (don't care) */
 680          0x0000                 /* c.o.c. (don't care) */
 681          },
 682         {                       /* vsb_rf_agc_cfg */
 683          DRX_STANDARD_8VSB,     /* standard       */
 684          DRX_AGC_CTRL_AUTO,     /* ctrl_mode       */
 685          0,                     /* output_level    */
 686          0,                     /* min_output_level */
 687          0xFFFF,                /* max_output_level */
 688          0x0000,                /* speed          */
 689          0x0000,                /* top    (don't care) */
 690          0x0000                 /* c.o.c. (don't care) */
 691          },
 692         {                       /* vsb_if_agc_cfg */
 693          DRX_STANDARD_8VSB,     /* standard       */
 694          DRX_AGC_CTRL_AUTO,     /* ctrl_mode       */
 695          0,                     /* output_level    */
 696          0,                     /* min_output_level */
 697          0xFFFF,                /* max_output_level */
 698          0x0000,                /* speed          */
 699          0x0000,                /* top    (don't care) */
 700          0x0000                 /* c.o.c. (don't care) */
 701          },
 702         0,                      /* qam_pga_cfg */
 703         0,                      /* vsb_pga_cfg */
 704         {                       /* qam_pre_saw_cfg */
 705          DRX_STANDARD_ITU_B,    /* standard  */
 706          0,                     /* reference */
 707          false                  /* use_pre_saw */
 708          },
 709         {                       /* vsb_pre_saw_cfg */
 710          DRX_STANDARD_8VSB,     /* standard  */
 711          0,                     /* reference */
 712          false                  /* use_pre_saw */
 713          },
 714
 715         /* Version information */
 716 #ifndef _CH_
 717         {
 718          "01234567890",         /* human readable version microcode             */
 719          "01234567890"          /* human readable version device specific code  */
 720          },
 721         {
 722          {                      /* struct drx_version for microcode                   */
 723           DRX_MODULE_UNKNOWN,
 724           (char *)(NULL),
 725           0,
 726           0,
 727           0,
 728           (char *)(NULL)
 729           },
 730          {                      /* struct drx_version for device specific code */
 731           DRX_MODULE_UNKNOWN,
 732           (char *)(NULL),
 733           0,
 734           0,
 735           0,
 736           (char *)(NULL)
 737           }
 738          },
 739         {
 740          {                      /* struct drx_version_list for microcode */
 741           (struct drx_version *) (NULL),
 742           (struct drx_version_list *) (NULL)
 743           },
 744          {                      /* struct drx_version_list for device specific code */
 745           (struct drx_version *) (NULL),
 746           (struct drx_version_list *) (NULL)
 747           }
 748          },
 749 #endif
 750         false,                  /* smart_ant_inverted */
 751         /* Tracking filter setting for OOB  */
 752         {
 753          12000,
 754          9300,
 755          6600,
 756          5280,
 757          3700,
 758          3000,
 759          2000,
 760          0},
 761         false,                  /* oob_power_on           */
 762         0,                      /* mpeg_ts_static_bitrate  */
 763         false,                  /* disable_te_ihandling   */
 764         false,                  /* bit_reverse_mpeg_outout */
 765         DRXJ_MPEGOUTPUT_CLOCK_RATE_AUTO,        /* mpeg_output_clock_rate */
 766         DRXJ_MPEG_START_WIDTH_1CLKCYC,  /* mpeg_start_width */
 767
 768         /* Pre SAW & Agc configuration for ATV */
 769         {
 770          DRX_STANDARD_NTSC,     /* standard     */
 771          7,                     /* reference    */
 772          true                   /* use_pre_saw    */
 773          },
 774         {                       /* ATV RF-AGC */
 775          DRX_STANDARD_NTSC,     /* standard              */
 776          DRX_AGC_CTRL_AUTO,     /* ctrl_mode              */
 777          0,                     /* output_level           */
 778          0,                     /* min_output_level (d.c.) */
 779          0,                     /* max_output_level (d.c.) */
 780          3,                     /* speed                 */
 781          9500,                  /* top                   */
 782          4000                   /* cut-off current       */
 783          },
 784         {                       /* ATV IF-AGC */
 785          DRX_STANDARD_NTSC,     /* standard              */
 786          DRX_AGC_CTRL_AUTO,     /* ctrl_mode              */
 787          0,                     /* output_level           */
 788          0,                     /* min_output_level (d.c.) */
 789          0,                     /* max_output_level (d.c.) */
 790          3,                     /* speed                 */
 791          2400,                  /* top                   */
 792          0                      /* c.o.c.         (d.c.) */
 793          },
 794         140,                    /* ATV PGA config */
 795         0,                      /* curr_symbol_rate */
 796
 797         false,                  /* pdr_safe_mode     */
 798         SIO_PDR_GPIO_CFG__PRE,  /* pdr_safe_restore_val_gpio  */
 799         SIO_PDR_VSYNC_CFG__PRE, /* pdr_safe_restore_val_v_sync */
 800         SIO_PDR_SMA_RX_CFG__PRE,        /* pdr_safe_restore_val_sma_rx */
 801         SIO_PDR_SMA_TX_CFG__PRE,        /* pdr_safe_restore_val_sma_tx */
 802
 803         4,                      /* oob_pre_saw            */
 804         DRXJ_OOB_LO_POW_MINUS10DB,      /* oob_lo_pow             */
 805         {
 806          false                  /* aud_data, only first member */
 807          },
 808 };
 809
 810 /**
 811 * \var drxj_default_addr_g
 812 * \brief Default I2C address and device identifier.
 813 */
 814 static struct i2c_device_addr drxj_default_addr_g = {
 815         DRXJ_DEF_I2C_ADDR,      /* i2c address */
 816         DRXJ_DEF_DEMOD_DEV_ID   /* device id */
 817 };
 818
 819 /**
 820 * \var drxj_default_comm_attr_g
 821 * \brief Default common attributes of a drxj demodulator instance.
 822 */
 823 static struct drx_common_attr drxj_default_comm_attr_g = {
 824         NULL,                   /* ucode file           */
 825         true,                   /* ucode verify switch  */
 826         {0},                    /* version record       */
 827
 828         44000,                  /* IF in kHz in case no tuner instance is used  */
 829         (151875 - 0),           /* system clock frequency in kHz                */
 830         0,                      /* oscillator frequency kHz                     */
 831         0,                      /* oscillator deviation in ppm, signed          */
 832         false,                  /* If true mirror frequency spectrum            */
 833         {
 834          /* MPEG output configuration */
 835          true,                  /* If true, enable MPEG ouput    */
 836          false,                 /* If true, insert RS byte       */
 837          false,                 /* If true, parallel out otherwise serial */
 838          false,                 /* If true, invert DATA signals  */
 839          false,                 /* If true, invert ERR signal    */
 840          false,                 /* If true, invert STR signals   */
 841          false,                 /* If true, invert VAL signals   */
 842          false,                 /* If true, invert CLK signals   */
 843          true,                  /* If true, static MPEG clockrate will
 844                                    be used, otherwise clockrate will
 845                                    adapt to the bitrate of the TS */
 846          19392658UL,            /* Maximum bitrate in b/s in case
 847                                    static clockrate is selected */
 848          DRX_MPEG_STR_WIDTH_1   /* MPEG Start width in clock cycles */
 849          },
 850         /* Initilisations below can be omitted, they require no user input and
 851            are initialy 0, NULL or false. The compiler will initialize them to these
 852            values when omitted.  */
 853         false,                  /* is_opened */
 854
 855         /* SCAN */
 856         NULL,                   /* no scan params yet               */
 857         0,                      /* current scan index               */
 858         0,                      /* next scan frequency              */
 859         false,                  /* scan ready flag                  */
 860         0,                      /* max channels to scan             */
 861         0,                      /* nr of channels scanned           */
 862         NULL,                   /* default scan function            */
 863         NULL,                   /* default context pointer          */
 864         0,                      /* millisec to wait for demod lock  */
 865         DRXJ_DEMOD_LOCK,        /* desired lock               */
 866         false,
 867
 868         /* Power management */
 869         DRX_POWER_UP,
 870
 871         /* Tuner */
 872         1,                      /* nr of I2C port to wich tuner is     */
 873         0L,                     /* minimum RF input frequency, in kHz  */
 874         0L,                     /* maximum RF input frequency, in kHz  */
 875         false,                  /* Rf Agc Polarity                     */
 876         false,                  /* If Agc Polarity                     */
 877         false,                  /* tuner slow mode                     */
 878
 879         {                       /* current channel (all 0)             */
 880          0UL                    /* channel.frequency */
 881          },
 882         DRX_STANDARD_UNKNOWN,   /* current standard */
 883         DRX_STANDARD_UNKNOWN,   /* previous standard */
 884         DRX_STANDARD_UNKNOWN,   /* di_cache_standard   */
 885         false,                  /* use_bootloader */
 886         0UL,                    /* capabilities */
 887         0                       /* mfx */
 888 };
 889
 890 /**
 891 * \var drxj_default_demod_g
 892 * \brief Default drxj demodulator instance.
 893 */
 894 static struct drx_demod_instance drxj_default_demod_g = {
 895         &drxj_default_addr_g,   /* i2c address & device id */
 896         &drxj_default_comm_attr_g,      /* demod common attributes */
 897         &drxj_data_g            /* demod device specific attributes */
 898 };
 899
 900 /**
 901 * \brief Default audio data structure for DRK demodulator instance.
 902 *
 903 * This structure is DRXK specific.
 904 *
 905 */
 906 static struct drx_aud_data drxj_default_aud_data_g = {
 907         false,                  /* audio_is_active */
 908         DRX_AUD_STANDARD_AUTO,  /* audio_standard  */
 909
 910         /* i2sdata */
 911         {
 912          false,                 /* output_enable   */
 913          48000,                 /* frequency      */
 914          DRX_I2S_MODE_MASTER,   /* mode           */
 915          DRX_I2S_WORDLENGTH_32, /* word_length     */
 916          DRX_I2S_POLARITY_RIGHT,        /* polarity       */
 917          DRX_I2S_FORMAT_WS_WITH_DATA    /* format         */
 918          },
 919         /* volume            */
 920         {
 921          true,                  /* mute;          */
 922          0,                     /* volume         */
 923          DRX_AUD_AVC_OFF,       /* avc_mode        */
 924          0,                     /* avc_ref_level    */
 925          DRX_AUD_AVC_MAX_GAIN_12DB,     /* avc_max_gain     */
 926          DRX_AUD_AVC_MAX_ATTEN_24DB,    /* avc_max_atten    */
 927          0,                     /* strength_left   */
 928          0                      /* strength_right  */
 929          },
 930         DRX_AUD_AUTO_SOUND_SELECT_ON_CHANGE_ON, /* auto_sound */
 931         /*  ass_thresholds */
 932         {
 933          440,                   /* A2    */
 934          12,                    /* BTSC  */
 935          700,                   /* NICAM */
 936          },
 937         /* carrier */
 938         {
 939          /* a */
 940          {
 941           42,                   /* thres */
 942           DRX_NO_CARRIER_NOISE, /* opt   */
 943           0,                    /* shift */
 944           0                     /* dco   */
 945           },
 946          /* b */
 947          {
 948           42,                   /* thres */
 949           DRX_NO_CARRIER_MUTE,  /* opt   */
 950           0,                    /* shift */
 951           0                     /* dco   */
 952           },
 953
 954          },
 955         /* mixer */
 956         {
 957          DRX_AUD_SRC_STEREO_OR_A,       /* source_i2s */
 958          DRX_AUD_I2S_MATRIX_STEREO,     /* matrix_i2s */
 959          DRX_AUD_FM_MATRIX_SOUND_A      /* matrix_fm  */
 960          },
 961         DRX_AUD_DEVIATION_NORMAL,       /* deviation */
 962         DRX_AUD_AVSYNC_OFF,     /* av_sync */
 963
 964         /* prescale */
 965         {
 966          DRX_AUD_MAX_FM_DEVIATION,      /* fm_deviation */
 967          DRX_AUD_MAX_NICAM_PRESCALE     /* nicam_gain */
 968          },
 969         DRX_AUD_FM_DEEMPH_75US, /* deemph */
 970         DRX_BTSC_STEREO,        /* btsc_detect */
 971         0,                      /* rds_data_counter */
 972         false                   /* rds_data_present */
 973 };
 974
 975 /*-----------------------------------------------------------------------------
 976 STRUCTURES
 977 ----------------------------------------------------------------------------*/
 978 struct drxjeq_stat {
 979         u16 eq_mse;
 980         u8 eq_mode;
 981         u8 eq_ctrl;
 982         u8 eq_stat;
 983 };
 984
 985 /* HI command */
 986 struct drxj_hi_cmd {
 987         u16 cmd;
 988         u16 param1;
 989         u16 param2;
 990         u16 param3;
 991         u16 param4;
 992         u16 param5;
 993         u16 param6;
 994 };
 995
 996 /*============================================================================*/
 997 /*=== MICROCODE RELATED STRUCTURES ===========================================*/
 998 /*============================================================================*/
 999
1000 /**
1001  * struct drxu_code_block_hdr - Structure of the microcode block headers
1002  *
1003  * @addr:       Destination address of the data in this block
1004  * @size:       Size of the block data following this header counted in
1005  *              16 bits words
1006  * @CRC:        CRC value of the data block, only valid if CRC flag is
1007  *              set.
1008  */
1009 struct drxu_code_block_hdr {
1010         u32 addr;
1011         u16 size;
1012         u16 flags;
1013         u16 CRC;
1014 };
1015
1016 /*-----------------------------------------------------------------------------
1017 FUNCTIONS
1018 ----------------------------------------------------------------------------*/
1019 /* Some prototypes */
1020 static int
1021 hi_command(struct i2c_device_addr *dev_addr,
1022            const struct drxj_hi_cmd *cmd, u16 *result);
1023
1024 static int
1025 ctrl_lock_status(struct drx_demod_instance *demod, enum drx_lock_status *lock_stat);
1026
1027 static int
1028 ctrl_power_mode(struct drx_demod_instance *demod, enum drx_power_mode *mode);
1029
1030 static int power_down_aud(struct drx_demod_instance *demod);
1031
1032 static int
1033 ctrl_set_cfg_pre_saw(struct drx_demod_instance *demod, struct drxj_cfg_pre_saw *pre_saw);
1034
1035 static int
1036 ctrl_set_cfg_afe_gain(struct drx_demod_instance *demod, struct drxj_cfg_afe_gain *afe_gain);
1037
1038 /*============================================================================*/
1039 /*============================================================================*/
1040 /*==                          HELPER FUNCTIONS                              ==*/
1041 /*============================================================================*/
1042 /*============================================================================*/
1043
1044
1045 /*============================================================================*/
1046
1047 /*
1048 * \fn u32 frac28(u32 N, u32 D)
1049 * \brief Compute: (1<<28)*N/D
1050 * \param N 32 bits
1051 * \param D 32 bits
1052 * \return (1<<28)*N/D
1053 * This function is used to avoid floating-point calculations as they may
1054 * not be present on the target platform.
1055
1056 * frac28 performs an unsigned 28/28 bits division to 32-bit fixed point
1057 * fraction used for setting the Frequency Shifter registers.
1058 * N and D can hold numbers up to width: 28-bits.
1059 * The 4 bits integer part and the 28 bits fractional part are calculated.
1060
1061 * Usage condition: ((1<<28)*n)/d < ((1<<32)-1) => (n/d) < 15.999
1062
1063 * N: 0...(1<<28)-1 = 268435454
1064 * D: 0...(1<<28)-1
1065 * Q: 0...(1<<32)-1
1066 */
1067 static u32 frac28(u32 N, u32 D)
1068 {
1069         int i = 0;
1070         u32 Q1 = 0;
1071         u32 R0 = 0;
1072
1073         R0 = (N % D) << 4;      /* 32-28 == 4 shifts possible at max */
1074         Q1 = N / D;             /* integer part, only the 4 least significant bits
1075                                    will be visible in the result */
1076
1077         /* division using radix 16, 7 nibbles in the result */
1078         for (i = 0; i < 7; i++) {
1079                 Q1 = (Q1 << 4) | R0 / D;
1080                 R0 = (R0 % D) << 4;
1081         }
1082         /* rounding */
1083         if ((R0 >> 3) >= D)
1084                 Q1++;
1085
1086         return Q1;
1087 }
1088
1089 /**
1090 * \fn u32 log1_times100( u32 x)
1091 * \brief Compute: 100*log10(x)
1092 * \param x 32 bits
1093 * \return 100*log10(x)
1094 *
1095 * 100*log10(x)
1096 * = 100*(log2(x)/log2(10)))
1097 * = (100*(2^15)*log2(x))/((2^15)*log2(10))
1098 * = ((200*(2^15)*log2(x))/((2^15)*log2(10)))/2
1099 * = ((200*(2^15)*(log2(x/y)+log2(y)))/((2^15)*log2(10)))/2
1100 * = ((200*(2^15)*log2(x/y))+(200*(2^15)*log2(y)))/((2^15)*log2(10)))/2
1101 *
1102 * where y = 2^k and 1<= (x/y) < 2
1103 */
1104
1105 static u32 log1_times100(u32 x)
1106 {
1107         static const u8 scale = 15;
1108         static const u8 index_width = 5;
1109         /*
1110            log2lut[n] = (1<<scale) * 200 * log2( 1.0 + ( (1.0/(1<<INDEXWIDTH)) * n ))
1111            0 <= n < ((1<<INDEXWIDTH)+1)
1112          */
1113
1114         static const u32 log2lut[] = {
1115                 0,              /* 0.000000 */
1116                 290941,         /* 290941.300628 */
1117                 573196,         /* 573196.476418 */
1118                 847269,         /* 847269.179851 */
1119                 1113620,        /* 1113620.489452 */
1120                 1372674,        /* 1372673.576986 */
1121                 1624818,        /* 1624817.752104 */
1122                 1870412,        /* 1870411.981536 */
1123                 2109788,        /* 2109787.962654 */
1124                 2343253,        /* 2343252.817465 */
1125                 2571091,        /* 2571091.461923 */
1126                 2793569,        /* 2793568.696416 */
1127                 3010931,        /* 3010931.055901 */
1128                 3223408,        /* 3223408.452106 */
1129                 3431216,        /* 3431215.635215 */
1130                 3634553,        /* 3634553.498355 */
1131                 3833610,        /* 3833610.244726 */
1132                 4028562,        /* 4028562.434393 */
1133                 4219576,        /* 4219575.925308 */
1134                 4406807,        /* 4406806.721144 */
1135                 4590402,        /* 4590401.736809 */
1136                 4770499,        /* 4770499.491025 */
1137                 4947231,        /* 4947230.734179 */
1138                 5120719,        /* 5120719.018555 */
1139                 5291081,        /* 5291081.217197 */
1140                 5458428,        /* 5458427.996830 */
1141                 5622864,        /* 5622864.249668 */
1142                 5784489,        /* 5784489.488298 */
1143                 5943398,        /* 5943398.207380 */
1144                 6099680,        /* 6099680.215452 */
1145                 6253421,        /* 6253420.939751 */
1146                 6404702,        /* 6404701.706649 */
1147                 6553600,        /* 6553600.000000 */
1148         };
1149
1150         u8 i = 0;
1151         u32 y = 0;
1152         u32 d = 0;
1153         u32 k = 0;
1154         u32 r = 0;
1155
1156         if (x == 0)
1157                 return 0;
1158
1159         /* Scale x (normalize) */
1160         /* computing y in log(x/y) = log(x) - log(y) */
1161         if ((x & (((u32) (-1)) << (scale + 1))) == 0) {
1162                 for (k = scale; k > 0; k--) {
1163                         if (x & (((u32) 1) << scale))
1164                                 break;
1165                         x <<= 1;
1166                 }
1167         } else {
1168                 for (k = scale; k < 31; k++) {
1169                         if ((x & (((u32) (-1)) << (scale + 1))) == 0)
1170                                 break;
1171                         x >>= 1;
1172                 }
1173         }
1174         /*
1175            Now x has binary point between bit[scale] and bit[scale-1]
1176            and 1.0 <= x < 2.0 */
1177
1178         /* correction for division: log(x) = log(x/y)+log(y) */
1179         y = k * ((((u32) 1) << scale) * 200);
1180
1181         /* remove integer part */
1182         x &= ((((u32) 1) << scale) - 1);
1183         /* get index */
1184         i = (u8) (x >> (scale - index_width));
1185         /* compute delta (x-a) */
1186         d = x & ((((u32) 1) << (scale - index_width)) - 1);
1187         /* compute log, multiplication ( d* (.. )) must be within range ! */
1188         y += log2lut[i] +
1189             ((d * (log2lut[i + 1] - log2lut[i])) >> (scale - index_width));
1190         /* Conver to log10() */
1191         y /= 108853;            /* (log2(10) << scale) */
1192         r = (y >> 1);
1193         /* rounding */
1194         if (y & ((u32)1))
1195                 r++;
1196
1197         return r;
1198
1199 }
1200
1201 /**
1202 * \fn u32 frac_times1e6( u16 N, u32 D)
1203 * \brief Compute: (N/D) * 1000000.
1204 * \param N nominator 16-bits.
1205 * \param D denominator 32-bits.
1206 * \return u32
1207 * \retval ((N/D) * 1000000), 32 bits
1208 *
1209 * No check on D=0!
1210 */
1211 static u32 frac_times1e6(u32 N, u32 D)
1212 {
1213         u32 remainder = 0;
1214         u32 frac = 0;
1215
1216         /*
1217            frac = (N * 1000000) / D
1218            To let it fit in a 32 bits computation:
1219            frac = (N * (1000000 >> 4)) / (D >> 4)
1220            This would result in a problem in case D < 16 (div by 0).
1221            So we do it more elaborate as shown below.
1222          */
1223         frac = (((u32) N) * (1000000 >> 4)) / D;
1224         frac <<= 4;
1225         remainder = (((u32) N) * (1000000 >> 4)) % D;
1226         remainder <<= 4;
1227         frac += remainder / D;
1228         remainder = remainder % D;
1229         if ((remainder * 2) > D)
1230                 frac++;
1231
1232         return frac;
1233 }
1234
1235 /*============================================================================*/
1236
1237
1238 /**
1239 * \brief Values for NICAM prescaler gain. Computed from dB to integer
1240 *        and rounded. For calc used formula: 16*10^(prescaleGain[dB]/20).
1241 *
1242 */
1243 static const u16 nicam_presc_table_val[43] = {
1244         1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4,
1245         5, 5, 6, 6, 7, 8, 9, 10, 11, 13, 14, 16,
1246         18, 20, 23, 25, 28, 32, 36, 40, 45,
1247         51, 57, 64, 71, 80, 90, 101, 113, 127
1248 };
1249
1250 /*============================================================================*/
1251 /*==                        END HELPER FUNCTIONS                            ==*/
1252 /*============================================================================*/
1253
1254 /*============================================================================*/
1255 /*============================================================================*/
1256 /*==                      DRXJ DAP FUNCTIONS                                ==*/
1257 /*============================================================================*/
1258 /*============================================================================*/
1259
1260 /*
1261    This layer takes care of some device specific register access protocols:
1262    -conversion to short address format
1263    -access to audio block
1264    This layer is placed between the drx_dap_fasi and the rest of the drxj
1265    specific implementation. This layer can use address map knowledge whereas
1266    dap_fasi may not use memory map knowledge.
1267
1268    * For audio currently only 16 bits read and write register access is
1269      supported. More is not needed. RMW and 32 or 8 bit access on audio
1270      registers will have undefined behaviour. Flags (RMW, CRC reset, broadcast
1271      single/multi master) will be ignored.
1272
1273    TODO: check ignoring single/multimaster is ok for AUD access ?
1274 */
1275
1276 #define DRXJ_ISAUDWRITE(addr) (((((addr)>>16)&1) == 1) ? true : false)
1277 #define DRXJ_DAP_AUDTRIF_TIMEOUT 80     /* millisec */
1278 /*============================================================================*/
1279
1280 /**
1281 * \fn bool is_handled_by_aud_tr_if( u32 addr )
1282 * \brief Check if this address is handled by the audio token ring interface.
1283 * \param addr
1284 * \return bool
1285 * \retval true  Yes, handled by audio token ring interface
1286 * \retval false No, not handled by audio token ring interface
1287 *
1288 */
1289 static
1290 bool is_handled_by_aud_tr_if(u32 addr)
1291 {
1292         bool retval = false;
1293
1294         if ((DRXDAP_FASI_ADDR2BLOCK(addr) == 4) &&
1295             (DRXDAP_FASI_ADDR2BANK(addr) > 1) &&
1296             (DRXDAP_FASI_ADDR2BANK(addr) < 6)) {
1297                 retval = true;
1298         }
1299
1300         return retval;
1301 }
1302
1303 /*============================================================================*/
1304
1305 int drxbsp_i2c_write_read(struct i2c_device_addr *w_dev_addr,
1306                                  u16 w_count,
1307                                  u8 *wData,
1308                                  struct i2c_device_addr *r_dev_addr,
1309                                  u16 r_count, u8 *r_data)
1310 {
1311         struct drx39xxj_state *state;
1312         struct i2c_msg msg[2];
1313         unsigned int num_msgs;
1314
1315         if (w_dev_addr == NULL) {
1316                 /* Read only */
1317                 state = r_dev_addr->user_data;
1318                 msg[0].addr = r_dev_addr->i2c_addr >> 1;
1319                 msg[0].flags = I2C_M_RD;
1320                 msg[0].buf = r_data;
1321                 msg[0].len = r_count;
1322                 num_msgs = 1;
1323         } else if (r_dev_addr == NULL) {
1324                 /* Write only */
1325                 state = w_dev_addr->user_data;
1326                 msg[0].addr = w_dev_addr->i2c_addr >> 1;
1327                 msg[0].flags = 0;
1328                 msg[0].buf = wData;
1329                 msg[0].len = w_count;
1330                 num_msgs = 1;
1331         } else {
1332                 /* Both write and read */
1333                 state = w_dev_addr->user_data;
1334                 msg[0].addr = w_dev_addr->i2c_addr >> 1;
1335                 msg[0].flags = 0;
1336                 msg[0].buf = wData;
1337                 msg[0].len = w_count;
1338                 msg[1].addr = r_dev_addr->i2c_addr >> 1;
1339                 msg[1].flags = I2C_M_RD;
1340                 msg[1].buf = r_data;
1341                 msg[1].len = r_count;
1342                 num_msgs = 2;
1343         }
1344
1345         if (state->i2c == NULL) {
1346                 pr_err("i2c was zero, aborting\n");
1347                 return 0;
1348         }
1349         if (i2c_transfer(state->i2c, msg, num_msgs) != num_msgs) {
1350                 pr_warn("drx3933: I2C write/read failed\n");
1351                 return -EREMOTEIO;
1352         }
1353
1354 #ifdef DJH_DEBUG
1355         if (w_dev_addr == NULL || r_dev_addr == NULL)
1356                 return 0;
1357
1358         state = w_dev_addr->user_data;
1359
1360         if (state->i2c == NULL)
1361                 return 0;
1362
1363         msg[0].addr = w_dev_addr->i2c_addr;
1364         msg[0].flags = 0;
1365         msg[0].buf = wData;
1366         msg[0].len = w_count;
1367         msg[1].addr = r_dev_addr->i2c_addr;
1368         msg[1].flags = I2C_M_RD;
1369         msg[1].buf = r_data;
1370         msg[1].len = r_count;
1371         num_msgs = 2;
1372
1373         pr_debug("drx3933 i2c operation addr=%x i2c=%p, wc=%x rc=%x\n",
1374                w_dev_addr->i2c_addr, state->i2c, w_count, r_count);
1375
1376         if (i2c_transfer(state->i2c, msg, 2) != 2) {
1377                 pr_warn("drx3933: I2C write/read failed\n");
1378                 return -EREMOTEIO;
1379         }
1380 #endif
1381         return 0;
1382 }
1383
1384 /*============================================================================*/
1385
1386 /******************************
1387 *
1388 * int drxdap_fasi_read_block (
1389 *      struct i2c_device_addr *dev_addr,      -- address of I2C device
1390 *      u32 addr,         -- address of chip register/memory
1391 *      u16            datasize,     -- number of bytes to read
1392 *      u8 *data,         -- data to receive
1393 *      u32 flags)        -- special device flags
1394 *
1395 * Read block data from chip address. Because the chip is word oriented,
1396 * the number of bytes to read must be even.
1397 *
1398 * Make sure that the buffer to receive the data is large enough.
1399 *
1400 * Although this function expects an even number of bytes, it is still byte
1401 * oriented, and the data read back is NOT translated to the endianness of
1402 * the target platform.
1403 *
1404 * Output:
1405 * - 0     if reading was successful
1406 *                  in that case: data read is in *data.
1407 * - -EIO  if anything went wrong
1408 *
1409 ******************************/
1410
1411 static int drxdap_fasi_read_block(struct i2c_device_addr *dev_addr,
1412                                          u32 addr,
1413                                          u16 datasize,
1414                                          u8 *data, u32 flags)
1415 {
1416         u8 buf[4];
1417         u16 bufx;
1418         int rc;
1419         u16 overhead_size = 0;
1420
1421         /* Check parameters ******************************************************* */
1422         if (dev_addr == NULL)
1423                 return -EINVAL;
1424
1425         overhead_size = (IS_I2C_10BIT(dev_addr->i2c_addr) ? 2 : 1) +
1426             (DRXDAP_FASI_LONG_FORMAT(addr) ? 4 : 2);
1427
1428         if ((DRXDAP_FASI_OFFSET_TOO_LARGE(addr)) ||
1429             ((!(DRXDAPFASI_LONG_ADDR_ALLOWED)) &&
1430              DRXDAP_FASI_LONG_FORMAT(addr)) ||
1431             (overhead_size > (DRXDAP_MAX_WCHUNKSIZE)) ||
1432             ((datasize != 0) && (data == NULL)) || ((datasize & 1) == 1)) {
1433                 return -EINVAL;
1434         }
1435
1436         /* ReadModifyWrite & mode flag bits are not allowed */
1437         flags &= (~DRXDAP_FASI_RMW & ~DRXDAP_FASI_MODEFLAGS);
1438 #if DRXDAP_SINGLE_MASTER
1439         flags |= DRXDAP_FASI_SINGLE_MASTER;
1440 #endif
1441
1442         /* Read block from I2C **************************************************** */
1443         do {
1444                 u16 todo = (datasize < DRXDAP_MAX_RCHUNKSIZE ?
1445                               datasize : DRXDAP_MAX_RCHUNKSIZE);
1446
1447                 bufx = 0;
1448
1449                 addr &= ~DRXDAP_FASI_FLAGS;
1450                 addr |= flags;
1451
1452 #if ((DRXDAPFASI_LONG_ADDR_ALLOWED == 1) && (DRXDAPFASI_SHORT_ADDR_ALLOWED == 1))
1453                 /* short format address preferred but long format otherwise */
1454                 if (DRXDAP_FASI_LONG_FORMAT(addr)) {
1455 #endif
1456 #if (DRXDAPFASI_LONG_ADDR_ALLOWED == 1)
1457                         buf[bufx++] = (u8) (((addr << 1) & 0xFF) | 0x01);
1458                         buf[bufx++] = (u8) ((addr >> 16) & 0xFF);
1459                         buf[bufx++] = (u8) ((addr >> 24) & 0xFF);
1460                         buf[bufx++] = (u8) ((addr >> 7) & 0xFF);
1461 #endif
1462 #if ((DRXDAPFASI_LONG_ADDR_ALLOWED == 1) && (DRXDAPFASI_SHORT_ADDR_ALLOWED == 1))
1463                 } else {
1464 #endif
1465 #if (DRXDAPFASI_SHORT_ADDR_ALLOWED == 1)
1466                         buf[bufx++] = (u8) ((addr << 1) & 0xFF);
1467                         buf[bufx++] =
1468                             (u8) (((addr >> 16) & 0x0F) |
1469                                     ((addr >> 18) & 0xF0));
1470 #endif
1471 #if ((DRXDAPFASI_LONG_ADDR_ALLOWED == 1) && (DRXDAPFASI_SHORT_ADDR_ALLOWED == 1))
1472                 }
1473 #endif
1474
1475 #if DRXDAP_SINGLE_MASTER
1476                 /*
1477                  * In single master mode, split the read and write actions.
1478                  * No special action is needed for write chunks here.
1479                  */
1480                 rc = drxbsp_i2c_write_read(dev_addr, bufx, buf,
1481                                            NULL, 0, NULL);
1482                 if (rc == 0)
1483                         rc = drxbsp_i2c_write_read(NULL, 0, NULL, dev_addr, todo, data);
1484 #else
1485                 /* In multi master mode, do everything in one RW action */
1486                 rc = drxbsp_i2c_write_read(dev_addr, bufx, buf, dev_addr, todo,
1487                                           data);
1488 #endif
1489                 data += todo;
1490                 addr += (todo >> 1);
1491                 datasize -= todo;
1492         } while (datasize && rc == 0);
1493
1494         return rc;
1495 }
1496
1497
1498 /******************************
1499 *
1500 * int drxdap_fasi_read_reg16 (
1501 *     struct i2c_device_addr *dev_addr, -- address of I2C device
1502 *     u32 addr,    -- address of chip register/memory
1503 *     u16 *data,    -- data to receive
1504 *     u32 flags)   -- special device flags
1505 *
1506 * Read one 16-bit register or memory location. The data received back is
1507 * converted back to the target platform's endianness.
1508 *
1509 * Output:
1510 * - 0     if reading was successful
1511 *                  in that case: read data is at *data
1512 * - -EIO  if anything went wrong
1513 *
1514 ******************************/
1515
1516 static int drxdap_fasi_read_reg16(struct i2c_device_addr *dev_addr,
1517                                          u32 addr,
1518                                          u16 *data, u32 flags)
1519 {
1520         u8 buf[sizeof(*data)];
1521         int rc;
1522
1523         if (!data)
1524                 return -EINVAL;
1525
1526         rc = drxdap_fasi_read_block(dev_addr, addr, sizeof(*data), buf, flags);
1527         *data = buf[0] + (((u16) buf[1]) << 8);
1528         return rc;
1529 }
1530
1531 /******************************
1532 *
1533 * int drxdap_fasi_read_reg32 (
1534 *     struct i2c_device_addr *dev_addr, -- address of I2C device
1535 *     u32 addr,    -- address of chip register/memory
1536 *     u32 *data,    -- data to receive
1537 *     u32 flags)   -- special device flags
1538 *
1539 * Read one 32-bit register or memory location. The data received back is
1540 * converted back to the target platform's endianness.
1541 *
1542 * Output:
1543 * - 0     if reading was successful
1544 *                  in that case: read data is at *data
1545 * - -EIO  if anything went wrong
1546 *
1547 ******************************/
1548
1549 static int drxdap_fasi_read_reg32(struct i2c_device_addr *dev_addr,
1550                                          u32 addr,
1551                                          u32 *data, u32 flags)
1552 {
1553         u8 buf[sizeof(*data)];
1554         int rc;
1555
1556         if (!data)
1557                 return -EINVAL;
1558
1559         rc = drxdap_fasi_read_block(dev_addr, addr, sizeof(*data), buf, flags);
1560         *data = (((u32) buf[0]) << 0) +
1561             (((u32) buf[1]) << 8) +
1562             (((u32) buf[2]) << 16) + (((u32) buf[3]) << 24);
1563         return rc;
1564 }
1565
1566 /******************************
1567 *
1568 * int drxdap_fasi_write_block (
1569 *      struct i2c_device_addr *dev_addr,    -- address of I2C device
1570 *      u32 addr,       -- address of chip register/memory
1571 *      u16            datasize,   -- number of bytes to read
1572 *      u8 *data,       -- data to receive
1573 *      u32 flags)      -- special device flags
1574 *
1575 * Write block data to chip address. Because the chip is word oriented,
1576 * the number of bytes to write must be even.
1577 *
1578 * Although this function expects an even number of bytes, it is still byte
1579 * oriented, and the data being written is NOT translated from the endianness of
1580 * the target platform.
1581 *
1582 * Output:
1583 * - 0     if writing was successful
1584 * - -EIO  if anything went wrong
1585 *
1586 ******************************/
1587
1588 static int drxdap_fasi_write_block(struct i2c_device_addr *dev_addr,
1589                                           u32 addr,
1590                                           u16 datasize,
1591                                           u8 *data, u32 flags)
1592 {
1593         u8 buf[DRXDAP_MAX_WCHUNKSIZE];
1594         int st = -EIO;
1595         int first_err = 0;
1596         u16 overhead_size = 0;
1597         u16 block_size = 0;
1598
1599         /* Check parameters ******************************************************* */
1600         if (dev_addr == NULL)
1601                 return -EINVAL;
1602
1603         overhead_size = (IS_I2C_10BIT(dev_addr->i2c_addr) ? 2 : 1) +
1604             (DRXDAP_FASI_LONG_FORMAT(addr) ? 4 : 2);
1605
1606         if ((DRXDAP_FASI_OFFSET_TOO_LARGE(addr)) ||
1607             ((!(DRXDAPFASI_LONG_ADDR_ALLOWED)) &&
1608              DRXDAP_FASI_LONG_FORMAT(addr)) ||
1609             (overhead_size > (DRXDAP_MAX_WCHUNKSIZE)) ||
1610             ((datasize != 0) && (data == NULL)) || ((datasize & 1) == 1))
1611                 return -EINVAL;
1612
1613         flags &= DRXDAP_FASI_FLAGS;
1614         flags &= ~DRXDAP_FASI_MODEFLAGS;
1615 #if DRXDAP_SINGLE_MASTER
1616         flags |= DRXDAP_FASI_SINGLE_MASTER;
1617 #endif
1618
1619         /* Write block to I2C ***************************************************** */
1620         block_size = ((DRXDAP_MAX_WCHUNKSIZE) - overhead_size) & ~1;
1621         do {
1622                 u16 todo = 0;
1623                 u16 bufx = 0;
1624
1625                 /* Buffer device address */
1626                 addr &= ~DRXDAP_FASI_FLAGS;
1627                 addr |= flags;
1628 #if (((DRXDAPFASI_LONG_ADDR_ALLOWED) == 1) && ((DRXDAPFASI_SHORT_ADDR_ALLOWED) == 1))
1629                 /* short format address preferred but long format otherwise */
1630                 if (DRXDAP_FASI_LONG_FORMAT(addr)) {
1631 #endif
1632 #if ((DRXDAPFASI_LONG_ADDR_ALLOWED) == 1)
1633                         buf[bufx++] = (u8) (((addr << 1) & 0xFF) | 0x01);
1634                         buf[bufx++] = (u8) ((addr >> 16) & 0xFF);
1635                         buf[bufx++] = (u8) ((addr >> 24) & 0xFF);
1636                         buf[bufx++] = (u8) ((addr >> 7) & 0xFF);
1637 #endif
1638 #if (((DRXDAPFASI_LONG_ADDR_ALLOWED) == 1) && ((DRXDAPFASI_SHORT_ADDR_ALLOWED) == 1))
1639                 } else {
1640 #endif
1641 #if ((DRXDAPFASI_SHORT_ADDR_ALLOWED) == 1)
1642                         buf[bufx++] = (u8) ((addr << 1) & 0xFF);
1643                         buf[bufx++] =
1644                             (u8) (((addr >> 16) & 0x0F) |
1645                                     ((addr >> 18) & 0xF0));
1646 #endif
1647 #if (((DRXDAPFASI_LONG_ADDR_ALLOWED) == 1) && ((DRXDAPFASI_SHORT_ADDR_ALLOWED) == 1))
1648                 }
1649 #endif
1650
1651                 /*
1652                    In single master mode block_size can be 0. In such a case this I2C
1653                    sequense will be visible: (1) write address {i2c addr,
1654                    4 bytes chip address} (2) write data {i2c addr, 4 bytes data }
1655                    (3) write address (4) write data etc...
1656                    Address must be rewriten because HI is reset after data transport and
1657                    expects an address.
1658                  */
1659                 todo = (block_size < datasize ? block_size : datasize);
1660                 if (todo == 0) {
1661                         u16 overhead_size_i2c_addr = 0;
1662                         u16 data_block_size = 0;
1663
1664                         overhead_size_i2c_addr =
1665                             (IS_I2C_10BIT(dev_addr->i2c_addr) ? 2 : 1);
1666                         data_block_size =
1667                             (DRXDAP_MAX_WCHUNKSIZE - overhead_size_i2c_addr) & ~1;
1668
1669                         /* write device address */
1670                         st = drxbsp_i2c_write_read(dev_addr,
1671                                                   (u16) (bufx),
1672                                                   buf,
1673                                                   (struct i2c_device_addr *)(NULL),
1674                                                   0, (u8 *)(NULL));
1675
1676                         if ((st != 0) && (first_err == 0)) {
1677                                 /* at the end, return the first error encountered */
1678                                 first_err = st;
1679                         }
1680                         bufx = 0;
1681                         todo =
1682                             (data_block_size <
1683                              datasize ? data_block_size : datasize);
1684                 }
1685                 memcpy(&buf[bufx], data, todo);
1686                 /* write (address if can do and) data */
1687                 st = drxbsp_i2c_write_read(dev_addr,
1688                                           (u16) (bufx + todo),
1689                                           buf,
1690                                           (struct i2c_device_addr *)(NULL),
1691                                           0, (u8 *)(NULL));
1692
1693                 if ((st != 0) && (first_err == 0)) {
1694                         /* at the end, return the first error encountered */
1695                         first_err = st;
1696                 }
1697                 datasize -= todo;
1698                 data += todo;
1699                 addr += (todo >> 1);
1700         } while (datasize);
1701
1702         return first_err;
1703 }
1704
1705 /******************************
1706 *
1707 * int drxdap_fasi_write_reg16 (
1708 *     struct i2c_device_addr *dev_addr, -- address of I2C device
1709 *     u32 addr,    -- address of chip register/memory
1710 *     u16            data,    -- data to send
1711 *     u32 flags)   -- special device flags
1712 *
1713 * Write one 16-bit register or memory location. The data being written is
1714 * converted from the target platform's endianness to little endian.
1715 *
1716 * Output:
1717 * - 0     if writing was successful
1718 * - -EIO  if anything went wrong
1719 *
1720 ******************************/
1721
1722 static int drxdap_fasi_write_reg16(struct i2c_device_addr *dev_addr,
1723                                           u32 addr,
1724                                           u16 data, u32 flags)
1725 {
1726         u8 buf[sizeof(data)];
1727
1728         buf[0] = (u8) ((data >> 0) & 0xFF);
1729         buf[1] = (u8) ((data >> 8) & 0xFF);
1730
1731         return drxdap_fasi_write_block(dev_addr, addr, sizeof(data), buf, flags);
1732 }
1733
1734 /******************************
1735 *
1736 * int drxdap_fasi_read_modify_write_reg16 (
1737 *      struct i2c_device_addr *dev_addr,   -- address of I2C device
1738 *      u32 waddr,     -- address of chip register/memory
1739 *      u32 raddr,     -- chip address to read back from
1740 *      u16            wdata,     -- data to send
1741 *      u16 *rdata)     -- data to receive back
1742 *
1743 * Write 16-bit data, then read back the original contents of that location.
1744 * Requires long addressing format to be allowed.
1745 *
1746 * Before sending data, the data is converted to little endian. The
1747 * data received back is converted back to the target platform's endianness.
1748 *
1749 * WARNING: This function is only guaranteed to work if there is one
1750 * master on the I2C bus.
1751 *
1752 * Output:
1753 * - 0     if reading was successful
1754 *                  in that case: read back data is at *rdata
1755 * - -EIO  if anything went wrong
1756 *
1757 ******************************/
1758
1759 static int drxdap_fasi_read_modify_write_reg16(struct i2c_device_addr *dev_addr,
1760                                                     u32 waddr,
1761                                                     u32 raddr,
1762                                                     u16 wdata, u16 *rdata)
1763 {
1764         int rc = -EIO;
1765
1766 #if (DRXDAPFASI_LONG_ADDR_ALLOWED == 1)
1767         if (rdata == NULL)
1768                 return -EINVAL;
1769
1770         rc = drxdap_fasi_write_reg16(dev_addr, waddr, wdata, DRXDAP_FASI_RMW);
1771         if (rc == 0)
1772                 rc = drxdap_fasi_read_reg16(dev_addr, raddr, rdata, 0);
1773 #endif
1774
1775         return rc;
1776 }
1777
1778 /******************************
1779 *
1780 * int drxdap_fasi_write_reg32 (
1781 *     struct i2c_device_addr *dev_addr, -- address of I2C device
1782 *     u32 addr,    -- address of chip register/memory
1783 *     u32            data,    -- data to send
1784 *     u32 flags)   -- special device flags
1785 *
1786 * Write one 32-bit register or memory location. The data being written is
1787 * converted from the target platform's endianness to little endian.
1788 *
1789 * Output:
1790 * - 0     if writing was successful
1791 * - -EIO  if anything went wrong
1792 *
1793 ******************************/
1794
1795 static int drxdap_fasi_write_reg32(struct i2c_device_addr *dev_addr,
1796                                           u32 addr,
1797                                           u32 data, u32 flags)
1798 {
1799         u8 buf[sizeof(data)];
1800
1801         buf[0] = (u8) ((data >> 0) & 0xFF);
1802         buf[1] = (u8) ((data >> 8) & 0xFF);
1803         buf[2] = (u8) ((data >> 16) & 0xFF);
1804         buf[3] = (u8) ((data >> 24) & 0xFF);
1805
1806         return drxdap_fasi_write_block(dev_addr, addr, sizeof(data), buf, flags);
1807 }
1808
1809 /*============================================================================*/
1810
1811 /**
1812 * \fn int drxj_dap_rm_write_reg16short
1813 * \brief Read modify write 16 bits audio register using short format only.
1814 * \param dev_addr
1815 * \param waddr    Address to write to
1816 * \param raddr    Address to read from (usually SIO_HI_RA_RAM_S0_RMWBUF__A)
1817 * \param wdata    Data to write
1818 * \param rdata    Buffer for data to read
1819 * \return int
1820 * \retval 0 Succes
1821 * \retval -EIO Timeout, I2C error, illegal bank
1822 *
1823 * 16 bits register read modify write access using short addressing format only.
1824 * Requires knowledge of the registermap, thus device dependent.
1825 * Using DAP FASI directly to avoid endless recursion of RMWs to audio registers.
1826 *
1827 */
1828
1829 /* TODO correct define should be #if ( DRXDAPFASI_SHORT_ADDR_ALLOWED==1 )
1830    See comments drxj_dap_read_modify_write_reg16 */
1831 #if (DRXDAPFASI_LONG_ADDR_ALLOWED == 0)
1832 static int drxj_dap_rm_write_reg16short(struct i2c_device_addr *dev_addr,
1833                                               u32 waddr,
1834                                               u32 raddr,
1835                                               u16 wdata, u16 *rdata)
1836 {
1837         int rc;
1838
1839         if (rdata == NULL)
1840                 return -EINVAL;
1841
1842         /* Set RMW flag */
1843         rc = drxdap_fasi_write_reg16(dev_addr,
1844                                               SIO_HI_RA_RAM_S0_FLG_ACC__A,
1845                                               SIO_HI_RA_RAM_S0_FLG_ACC_S0_RWM__M,
1846                                               0x0000);
1847         if (rc == 0) {
1848                 /* Write new data: triggers RMW */
1849                 rc = drxdap_fasi_write_reg16(dev_addr, waddr, wdata,
1850                                                       0x0000);
1851         }
1852         if (rc == 0) {
1853                 /* Read old data */
1854                 rc = drxdap_fasi_read_reg16(dev_addr, raddr, rdata,
1855                                                      0x0000);
1856         }
1857         if (rc == 0) {
1858                 /* Reset RMW flag */
1859                 rc = drxdap_fasi_write_reg16(dev_addr,
1860                                                       SIO_HI_RA_RAM_S0_FLG_ACC__A,
1861                                                       0, 0x0000);
1862         }
1863
1864         return rc;
1865 }
1866 #endif
1867
1868 /*============================================================================*/
1869
1870 static int drxj_dap_read_modify_write_reg16(struct i2c_device_addr *dev_addr,
1871                                                  u32 waddr,
1872                                                  u32 raddr,
1873                                                  u16 wdata, u16 *rdata)
1874 {
1875         /* TODO: correct short/long addressing format decision,
1876            now long format has higher prio then short because short also
1877            needs virt bnks (not impl yet) for certain audio registers */
1878 #if (DRXDAPFASI_LONG_ADDR_ALLOWED == 1)
1879         return drxdap_fasi_read_modify_write_reg16(dev_addr,
1880                                                           waddr,
1881                                                           raddr, wdata, rdata);
1882 #else
1883         return drxj_dap_rm_write_reg16short(dev_addr, waddr, raddr, wdata, rdata);
1884 #endif
1885 }
1886
1887
1888 /*============================================================================*/
1889
1890 /**
1891 * \fn int drxj_dap_read_aud_reg16
1892 * \brief Read 16 bits audio register
1893 * \param dev_addr
1894 * \param addr
1895 * \param data
1896 * \return int
1897 * \retval 0 Succes
1898 * \retval -EIO Timeout, I2C error, illegal bank
1899 *
1900 * 16 bits register read access via audio token ring interface.
1901 *
1902 */
1903 static int drxj_dap_read_aud_reg16(struct i2c_device_addr *dev_addr,
1904                                          u32 addr, u16 *data)
1905 {
1906         u32 start_timer = 0;
1907         u32 current_timer = 0;
1908         u32 delta_timer = 0;
1909         u16 tr_status = 0;
1910         int stat = -EIO;
1911
1912         /* No read possible for bank 3, return with error */
1913         if (DRXDAP_FASI_ADDR2BANK(addr) == 3) {
1914                 stat = -EINVAL;
1915         } else {
1916                 const u32 write_bit = ((dr_xaddr_t) 1) << 16;
1917
1918                 /* Force reset write bit */
1919                 addr &= (~write_bit);
1920
1921                 /* Set up read */
1922                 start_timer = jiffies_to_msecs(jiffies);
1923                 do {
1924                         /* RMW to aud TR IF until request is granted or timeout */
1925                         stat = drxj_dap_read_modify_write_reg16(dev_addr,
1926                                                              addr,
1927                                                              SIO_HI_RA_RAM_S0_RMWBUF__A,
1928                                                              0x0000, &tr_status);
1929
1930                         if (stat != 0)
1931                                 break;
1932
1933                         current_timer = jiffies_to_msecs(jiffies);
1934                         delta_timer = current_timer - start_timer;
1935                         if (delta_timer > DRXJ_DAP_AUDTRIF_TIMEOUT) {
1936                                 stat = -EIO;
1937                                 break;
1938                         }
1939
1940                 } while (((tr_status & AUD_TOP_TR_CTR_FIFO_LOCK__M) ==
1941                           AUD_TOP_TR_CTR_FIFO_LOCK_LOCKED) ||
1942                          ((tr_status & AUD_TOP_TR_CTR_FIFO_FULL__M) ==
1943                           AUD_TOP_TR_CTR_FIFO_FULL_FULL));
1944         }                       /* if ( DRXDAP_FASI_ADDR2BANK(addr)!=3 ) */
1945
1946         /* Wait for read ready status or timeout */
1947         if (stat == 0) {
1948                 start_timer = jiffies_to_msecs(jiffies);
1949
1950                 while ((tr_status & AUD_TOP_TR_CTR_FIFO_RD_RDY__M) !=
1951                        AUD_TOP_TR_CTR_FIFO_RD_RDY_READY) {
1952                         stat = drxj_dap_read_reg16(dev_addr,
1953                                                   AUD_TOP_TR_CTR__A,
1954                                                   &tr_status, 0x0000);
1955                         if (stat != 0)
1956                                 break;
1957
1958                         current_timer = jiffies_to_msecs(jiffies);
1959                         delta_timer = current_timer - start_timer;
1960                         if (delta_timer > DRXJ_DAP_AUDTRIF_TIMEOUT) {
1961                                 stat = -EIO;
1962                                 break;
1963                         }
1964                 }               /* while ( ... ) */
1965         }
1966
1967         /* Read value */
1968         if (stat == 0)
1969                 stat = drxj_dap_read_modify_write_reg16(dev_addr,
1970                                                      AUD_TOP_TR_RD_REG__A,
1971                                                      SIO_HI_RA_RAM_S0_RMWBUF__A,
1972                                                      0x0000, data);
1973         return stat;
1974 }
1975
1976 /*============================================================================*/
1977
1978 static int drxj_dap_read_reg16(struct i2c_device_addr *dev_addr,
1979                                       u32 addr,
1980                                       u16 *data, u32 flags)
1981 {
1982         int stat = -EIO;
1983
1984         /* Check param */
1985         if ((dev_addr == NULL) || (data == NULL))
1986                 return -EINVAL;
1987
1988         if (is_handled_by_aud_tr_if(addr))
1989                 stat = drxj_dap_read_aud_reg16(dev_addr, addr, data);
1990         else
1991                 stat = drxdap_fasi_read_reg16(dev_addr, addr, data, flags);
1992
1993         return stat;
1994 }
1995 /*============================================================================*/
1996
1997 /**
1998 * \fn int drxj_dap_write_aud_reg16
1999 * \brief Write 16 bits audio register
2000 * \param dev_addr
2001 * \param addr
2002 * \param data
2003 * \return int
2004 * \retval 0 Succes
2005 * \retval -EIO Timeout, I2C error, illegal bank
2006 *
2007 * 16 bits register write access via audio token ring interface.
2008 *
2009 */
2010 static int drxj_dap_write_aud_reg16(struct i2c_device_addr *dev_addr,
2011                                           u32 addr, u16 data)
2012 {
2013         int stat = -EIO;
2014
2015         /* No write possible for bank 2, return with error */
2016         if (DRXDAP_FASI_ADDR2BANK(addr) == 2) {
2017                 stat = -EINVAL;
2018         } else {
2019                 u32 start_timer = 0;
2020                 u32 current_timer = 0;
2021                 u32 delta_timer = 0;
2022                 u16 tr_status = 0;
2023                 const u32 write_bit = ((dr_xaddr_t) 1) << 16;
2024
2025                 /* Force write bit */
2026                 addr |= write_bit;
2027                 start_timer = jiffies_to_msecs(jiffies);
2028                 do {
2029                         /* RMW to aud TR IF until request is granted or timeout */
2030                         stat = drxj_dap_read_modify_write_reg16(dev_addr,
2031                                                              addr,
2032                                                              SIO_HI_RA_RAM_S0_RMWBUF__A,
2033                                                              data, &tr_status);
2034                         if (stat != 0)
2035                                 break;
2036
2037                         current_timer = jiffies_to_msecs(jiffies);
2038                         delta_timer = current_timer - start_timer;
2039                         if (delta_timer > DRXJ_DAP_AUDTRIF_TIMEOUT) {
2040                                 stat = -EIO;
2041                                 break;
2042                         }
2043
2044                 } while (((tr_status & AUD_TOP_TR_CTR_FIFO_LOCK__M) ==
2045                           AUD_TOP_TR_CTR_FIFO_LOCK_LOCKED) ||
2046                          ((tr_status & AUD_TOP_TR_CTR_FIFO_FULL__M) ==
2047                           AUD_TOP_TR_CTR_FIFO_FULL_FULL));
2048
2049         }                       /* if ( DRXDAP_FASI_ADDR2BANK(addr)!=2 ) */
2050
2051         return stat;
2052 }
2053
2054 /*============================================================================*/
2055
2056 static int drxj_dap_write_reg16(struct i2c_device_addr *dev_addr,
2057                                        u32 addr,
2058                                        u16 data, u32 flags)
2059 {
2060         int stat = -EIO;
2061
2062         /* Check param */
2063         if (dev_addr == NULL)
2064                 return -EINVAL;
2065
2066         if (is_handled_by_aud_tr_if(addr))
2067                 stat = drxj_dap_write_aud_reg16(dev_addr, addr, data);
2068         else
2069                 stat = drxdap_fasi_write_reg16(dev_addr,
2070                                                             addr, data, flags);
2071
2072         return stat;
2073 }
2074
2075 /*============================================================================*/
2076
2077 /* Free data ram in SIO HI */
2078 #define SIO_HI_RA_RAM_USR_BEGIN__A 0x420040
2079 #define SIO_HI_RA_RAM_USR_END__A   0x420060
2080
2081 #define DRXJ_HI_ATOMIC_BUF_START (SIO_HI_RA_RAM_USR_BEGIN__A)
2082 #define DRXJ_HI_ATOMIC_BUF_END   (SIO_HI_RA_RAM_USR_BEGIN__A + 7)
2083 #define DRXJ_HI_ATOMIC_READ      SIO_HI_RA_RAM_PAR_3_ACP_RW_READ
2084 #define DRXJ_HI_ATOMIC_WRITE     SIO_HI_RA_RAM_PAR_3_ACP_RW_WRITE
2085
2086 /**
2087 * \fn int drxj_dap_atomic_read_write_block()
2088 * \brief Basic access routine for atomic read or write access
2089 * \param dev_addr  pointer to i2c dev address
2090 * \param addr     destination/source address
2091 * \param datasize size of data buffer in bytes
2092 * \param data     pointer to data buffer
2093 * \return int
2094 * \retval 0 Succes
2095 * \retval -EIO Timeout, I2C error, illegal bank
2096 *
2097 */
2098 static
2099 int drxj_dap_atomic_read_write_block(struct i2c_device_addr *dev_addr,
2100                                           u32 addr,
2101                                           u16 datasize,
2102                                           u8 *data, bool read_flag)
2103 {
2104         struct drxj_hi_cmd hi_cmd;
2105         int rc;
2106         u16 word;
2107         u16 dummy = 0;
2108         u16 i = 0;
2109
2110         /* Parameter check */
2111         if (!data || !dev_addr || ((datasize % 2)) || ((datasize / 2) > 8))
2112                 return -EINVAL;
2113
2114         /* Set up HI parameters to read or write n bytes */
2115         hi_cmd.cmd = SIO_HI_RA_RAM_CMD_ATOMIC_COPY;
2116         hi_cmd.param1 =
2117             (u16) ((DRXDAP_FASI_ADDR2BLOCK(DRXJ_HI_ATOMIC_BUF_START) << 6) +
2118                      DRXDAP_FASI_ADDR2BANK(DRXJ_HI_ATOMIC_BUF_START));
2119         hi_cmd.param2 =
2120             (u16) DRXDAP_FASI_ADDR2OFFSET(DRXJ_HI_ATOMIC_BUF_START);
2121         hi_cmd.param3 = (u16) ((datasize / 2) - 1);
2122         if (!read_flag)
2123                 hi_cmd.param3 |= DRXJ_HI_ATOMIC_WRITE;
2124         else
2125                 hi_cmd.param3 |= DRXJ_HI_ATOMIC_READ;
2126         hi_cmd.param4 = (u16) ((DRXDAP_FASI_ADDR2BLOCK(addr) << 6) +
2127                                 DRXDAP_FASI_ADDR2BANK(addr));
2128         hi_cmd.param5 = (u16) DRXDAP_FASI_ADDR2OFFSET(addr);
2129
2130         if (!read_flag) {
2131                 /* write data to buffer */
2132                 for (i = 0; i < (datasize / 2); i++) {
2133
2134                         word = ((u16) data[2 * i]);
2135                         word += (((u16) data[(2 * i) + 1]) << 8);
2136                         drxj_dap_write_reg16(dev_addr,
2137                                              (DRXJ_HI_ATOMIC_BUF_START + i),
2138                                             word, 0);
2139                 }
2140         }
2141
2142         rc = hi_command(dev_addr, &hi_cmd, &dummy);
2143         if (rc != 0) {
2144                 pr_err("error %d\n", rc);
2145                 goto rw_error;
2146         }
2147
2148         if (read_flag) {
2149                 /* read data from buffer */
2150                 for (i = 0; i < (datasize / 2); i++) {
2151                         drxj_dap_read_reg16(dev_addr,
2152                                             (DRXJ_HI_ATOMIC_BUF_START + i),
2153                                            &word, 0);
2154                         data[2 * i] = (u8) (word & 0xFF);
2155                         data[(2 * i) + 1] = (u8) (word >> 8);
2156                 }
2157         }
2158
2159         return 0;
2160
2161 rw_error:
2162         return rc;
2163
2164 }
2165
2166 /*============================================================================*/
2167
2168 /**
2169 * \fn int drxj_dap_atomic_read_reg32()
2170 * \brief Atomic read of 32 bits words
2171 */
2172 static
2173 int drxj_dap_atomic_read_reg32(struct i2c_device_addr *dev_addr,
2174                                      u32 addr,
2175                                      u32 *data, u32 flags)
2176 {
2177         u8 buf[sizeof(*data)] = { 0 };
2178         int rc = -EIO;
2179         u32 word = 0;
2180
2181         if (!data)
2182                 return -EINVAL;
2183
2184         rc = drxj_dap_atomic_read_write_block(dev_addr, addr,
2185                                               sizeof(*data), buf, true);
2186
2187         if (rc < 0)
2188                 return 0;
2189
2190         word = (u32) buf[3];
2191         word <<= 8;
2192         word |= (u32) buf[2];
2193         word <<= 8;
2194         word |= (u32) buf[1];
2195         word <<= 8;
2196         word |= (u32) buf[0];
2197
2198         *data = word;
2199
2200         return rc;
2201 }
2202
2203 /*============================================================================*/
2204
2205 /*============================================================================*/
2206 /*==                        END DRXJ DAP FUNCTIONS                          ==*/
2207 /*============================================================================*/
2208
2209 /*============================================================================*/
2210 /*============================================================================*/
2211 /*==                      HOST INTERFACE FUNCTIONS                          ==*/
2212 /*============================================================================*/
2213 /*============================================================================*/
2214
2215 /**
2216 * \fn int hi_cfg_command()
2217 * \brief Configure HI with settings stored in the demod structure.
2218 * \param demod Demodulator.
2219 * \return int.
2220 *
2221 * This routine was created because to much orthogonal settings have
2222 * been put into one HI API function (configure). Especially the I2C bridge
2223 * enable/disable should not need re-configuration of the HI.
2224 *
2225 */
2226 static int hi_cfg_command(const struct drx_demod_instance *demod)
2227 {
2228         struct drxj_data *ext_attr = (struct drxj_data *) (NULL);
2229         struct drxj_hi_cmd hi_cmd;
2230         u16 result = 0;
2231         int rc;
2232
2233         ext_attr = (struct drxj_data *) demod->my_ext_attr;
2234
2235         hi_cmd.cmd = SIO_HI_RA_RAM_CMD_CONFIG;
2236         hi_cmd.param1 = SIO_HI_RA_RAM_PAR_1_PAR1_SEC_KEY;
2237         hi_cmd.param2 = ext_attr->hi_cfg_timing_div;
2238         hi_cmd.param3 = ext_attr->hi_cfg_bridge_delay;
2239         hi_cmd.param4 = ext_attr->hi_cfg_wake_up_key;
2240         hi_cmd.param5 = ext_attr->hi_cfg_ctrl;
2241         hi_cmd.param6 = ext_attr->hi_cfg_transmit;
2242
2243         rc = hi_command(demod->my_i2c_dev_addr, &hi_cmd, &result);
2244         if (rc != 0) {
2245                 pr_err("error %d\n", rc);
2246                 goto rw_error;
2247         }
2248
2249         /* Reset power down flag (set one call only) */
2250         ext_attr->hi_cfg_ctrl &= (~(SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ));
2251
2252         return 0;
2253
2254 rw_error:
2255         return rc;
2256 }
2257
2258 /**
2259 * \fn int hi_command()
2260 * \brief Configure HI with settings stored in the demod structure.
2261 * \param dev_addr I2C address.
2262 * \param cmd HI command.
2263 * \param result HI command result.
2264 * \return int.
2265 *
2266 * Sends command to HI
2267 *
2268 */
2269 static int
2270 hi_command(struct i2c_device_addr *dev_addr, const struct drxj_hi_cmd *cmd, u16 *result)
2271 {
2272         u16 wait_cmd = 0;
2273         u16 nr_retries = 0;
2274         bool powerdown_cmd = false;
2275         int rc;
2276
2277         /* Write parameters */
2278         switch (cmd->cmd) {
2279
2280         case SIO_HI_RA_RAM_CMD_CONFIG:
2281         case SIO_HI_RA_RAM_CMD_ATOMIC_COPY:
2282                 rc = drxj_dap_write_reg16(dev_addr, SIO_HI_RA_RAM_PAR_6__A, cmd->param6, 0);
2283                 if (rc != 0) {
2284                         pr_err("error %d\n", rc);
2285                         goto rw_error;
2286                 }
2287                 rc = drxj_dap_write_reg16(dev_addr, SIO_HI_RA_RAM_PAR_5__A, cmd->param5, 0);
2288                 if (rc != 0) {
2289                         pr_err("error %d\n", rc);
2290                         goto rw_error;
2291                 }
2292                 rc = drxj_dap_write_reg16(dev_addr, SIO_HI_RA_RAM_PAR_4__A, cmd->param4, 0);
2293                 if (rc != 0) {
2294                         pr_err("error %d\n", rc);
2295                         goto rw_error;
2296                 }
2297                 rc = drxj_dap_write_reg16(dev_addr, SIO_HI_RA_RAM_PAR_3__A, cmd->param3, 0);
2298                 if (rc != 0) {
2299                         pr_err("error %d\n", rc);
2300                         goto rw_error;
2301                 }
2302                 /* fallthrough */
2303         case SIO_HI_RA_RAM_CMD_BRDCTRL:
2304                 rc = drxj_dap_write_reg16(dev_addr, SIO_HI_RA_RAM_PAR_2__A, cmd->param2, 0);
2305                 if (rc != 0) {
2306                         pr_err("error %d\n", rc);
2307                         goto rw_error;
2308                 }
2309                 rc = drxj_dap_write_reg16(dev_addr, SIO_HI_RA_RAM_PAR_1__A, cmd->param1, 0);
2310                 if (rc != 0) {
2311                         pr_err("error %d\n", rc);
2312                         goto rw_error;
2313                 }
2314                 /* fallthrough */
2315         case SIO_HI_RA_RAM_CMD_NULL:
2316                 /* No parameters */
2317                 break;
2318
2319         default:
2320                 return -EINVAL;
2321                 break;
2322         }
2323
2324         /* Write command */
2325         rc = drxj_dap_write_reg16(dev_addr, SIO_HI_RA_RAM_CMD__A, cmd->cmd, 0);
2326         if (rc != 0) {
2327                 pr_err("error %d\n", rc);
2328                 goto rw_error;
2329         }
2330
2331         if ((cmd->cmd) == SIO_HI_RA_RAM_CMD_RESET)
2332                 msleep(1);
2333
2334         /* Detect power down to ommit reading result */
2335         powerdown_cmd = (bool) ((cmd->cmd == SIO_HI_RA_RAM_CMD_CONFIG) &&
2336                                   (((cmd->
2337                                      param5) & SIO_HI_RA_RAM_PAR_5_CFG_SLEEP__M)
2338                                    == SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ));
2339         if (!powerdown_cmd) {
2340                 /* Wait until command rdy */
2341                 do {
2342                         nr_retries++;
2343                         if (nr_retries > DRXJ_MAX_RETRIES) {
2344                                 pr_err("timeout\n");
2345                                 goto rw_error;
2346                         }
2347
2348                         rc = drxj_dap_read_reg16(dev_addr, SIO_HI_RA_RAM_CMD__A, &wait_cmd, 0);
2349                         if (rc != 0) {
2350                                 pr_err("error %d\n", rc);
2351                                 goto rw_error;
2352                         }
2353                 } while (wait_cmd != 0);
2354
2355                 /* Read result */
2356                 rc = drxj_dap_read_reg16(dev_addr, SIO_HI_RA_RAM_RES__A, result, 0);
2357                 if (rc != 0) {
2358                         pr_err("error %d\n", rc);
2359                         goto rw_error;
2360                 }
2361
2362         }
2363         /* if ( powerdown_cmd == true ) */
2364         return 0;
2365 rw_error:
2366         return rc;
2367 }
2368
2369 /**
2370 * \fn int init_hi( const struct drx_demod_instance *demod )
2371 * \brief Initialise and configurate HI.
2372 * \param demod pointer to demod data.
2373 * \return int Return status.
2374 * \retval 0 Success.
2375 * \retval -EIO Failure.
2376 *
2377 * Needs to know Psys (System Clock period) and Posc (Osc Clock period)
2378 * Need to store configuration in driver because of the way I2C
2379 * bridging is controlled.
2380 *
2381 */
2382 static int init_hi(const struct drx_demod_instance *demod)
2383 {
2384         struct drxj_data *ext_attr = (struct drxj_data *) (NULL);
2385         struct drx_common_attr *common_attr = (struct drx_common_attr *) (NULL);
2386         struct i2c_device_addr *dev_addr = (struct i2c_device_addr *)(NULL);
2387         int rc;
2388
2389         ext_attr = (struct drxj_data *) demod->my_ext_attr;
2390         common_attr = (struct drx_common_attr *) demod->my_common_attr;
2391         dev_addr = demod->my_i2c_dev_addr;
2392
2393         /* PATCH for bug 5003, HI ucode v3.1.0 */
2394         rc = drxj_dap_write_reg16(dev_addr, 0x4301D7, 0x801, 0);
2395         if (rc != 0) {
2396                 pr_err("error %d\n", rc);
2397                 goto rw_error;
2398         }
2399
2400         /* Timing div, 250ns/Psys */
2401         /* Timing div, = ( delay (nano seconds) * sysclk (kHz) )/ 1000 */
2402         ext_attr->hi_cfg_timing_div =
2403             (u16) ((common_attr->sys_clock_freq / 1000) * HI_I2C_DELAY) / 1000;
2404         /* Clipping */
2405         if ((ext_attr->hi_cfg_timing_div) > SIO_HI_RA_RAM_PAR_2_CFG_DIV__M)
2406                 ext_attr->hi_cfg_timing_div = SIO_HI_RA_RAM_PAR_2_CFG_DIV__M;
2407         /* Bridge delay, uses oscilator clock */
2408         /* Delay = ( delay (nano seconds) * oscclk (kHz) )/ 1000 */
2409         /* SDA brdige delay */
2410         ext_attr->hi_cfg_bridge_delay =
2411             (u16) ((common_attr->osc_clock_freq / 1000) * HI_I2C_BRIDGE_DELAY) /
2412             1000;
2413         /* Clipping */
2414         if ((ext_attr->hi_cfg_bridge_delay) > SIO_HI_RA_RAM_PAR_3_CFG_DBL_SDA__M)
2415                 ext_attr->hi_cfg_bridge_delay = SIO_HI_RA_RAM_PAR_3_CFG_DBL_SDA__M;
2416         /* SCL bridge delay, same as SDA for now */
2417         ext_attr->hi_cfg_bridge_delay += ((ext_attr->hi_cfg_bridge_delay) <<
2418                                       SIO_HI_RA_RAM_PAR_3_CFG_DBL_SCL__B);
2419         /* Wakeup key, setting the read flag (as suggest in the documentation) does
2420            not always result into a working solution (barebones worked VI2C failed).
2421            Not setting the bit works in all cases . */
2422         ext_attr->hi_cfg_wake_up_key = DRXJ_WAKE_UP_KEY;
2423         /* port/bridge/power down ctrl */
2424         ext_attr->hi_cfg_ctrl = (SIO_HI_RA_RAM_PAR_5_CFG_SLV0_SLAVE);
2425         /* transit mode time out delay and watch dog divider */
2426         ext_attr->hi_cfg_transmit = SIO_HI_RA_RAM_PAR_6__PRE;
2427
2428         rc = hi_cfg_command(demod);
2429         if (rc != 0) {
2430                 pr_err("error %d\n", rc);
2431                 goto rw_error;
2432         }
2433
2434         return 0;
2435
2436 rw_error:
2437         return rc;
2438 }
2439
2440 /*============================================================================*/
2441 /*==                   END HOST INTERFACE FUNCTIONS                         ==*/
2442 /*============================================================================*/
2443
2444 /*============================================================================*/
2445 /*============================================================================*/
2446 /*==                        AUXILIARY FUNCTIONS                             ==*/
2447 /*============================================================================*/
2448 /*============================================================================*/
2449
2450 /**
2451 * \fn int get_device_capabilities()
2452 * \brief Get and store device capabilities.
2453 * \param demod  Pointer to demodulator instance.
2454 * \return int.
2455 * \return 0    Success
2456 * \retval -EIO Failure
2457 *
2458 * Depending on pulldowns on MDx pins the following internals are set:
2459 *  * common_attr->osc_clock_freq
2460 *  * ext_attr->has_lna
2461 *  * ext_attr->has_ntsc
2462 *  * ext_attr->has_btsc
2463 *  * ext_attr->has_oob
2464 *
2465 */
2466 static int get_device_capabilities(struct drx_demod_instance *demod)
2467 {
2468         struct drx_common_attr *common_attr = (struct drx_common_attr *) (NULL);
2469         struct drxj_data *ext_attr = (struct drxj_data *) NULL;
2470         struct i2c_device_addr *dev_addr = (struct i2c_device_addr *)(NULL);
2471         u16 sio_pdr_ohw_cfg = 0;
2472         u32 sio_top_jtagid_lo = 0;
2473         u16 bid = 0;
2474         int rc;
2475
2476         common_attr = (struct drx_common_attr *) demod->my_common_attr;
2477         ext_attr = (struct drxj_data *) demod->my_ext_attr;
2478         dev_addr = demod->my_i2c_dev_addr;
2479
2480         rc = drxj_dap_write_reg16(dev_addr, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY, 0);
2481         if (rc != 0) {
2482                 pr_err("error %d\n", rc);
2483                 goto rw_error;
2484         }
2485         rc = drxj_dap_read_reg16(dev_addr, SIO_PDR_OHW_CFG__A, &sio_pdr_ohw_cfg, 0);
2486         if (rc != 0) {
2487                 pr_err("error %d\n", rc);
2488                 goto rw_error;
2489         }
2490         rc = drxj_dap_write_reg16(dev_addr, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY__PRE, 0);
2491         if (rc != 0) {
2492                 pr_err("error %d\n", rc);
2493                 goto rw_error;
2494         }
2495
2496         switch ((sio_pdr_ohw_cfg & SIO_PDR_OHW_CFG_FREF_SEL__M)) {
2497         case 0:
2498                 /* ignore (bypass ?) */
2499                 break;
2500         case 1:
2501                 /* 27 MHz */
2502                 common_attr->osc_clock_freq = 27000;
2503                 break;
2504         case 2:
2505                 /* 20.25 MHz */
2506                 common_attr->osc_clock_freq = 20250;
2507                 break;
2508         case 3:
2509                 /* 4 MHz */
2510                 common_attr->osc_clock_freq = 4000;
2511                 break;
2512         default:
2513                 return -EIO;
2514         }
2515
2516         /*
2517            Determine device capabilities
2518            Based on pinning v47
2519          */
2520         rc = drxdap_fasi_read_reg32(dev_addr, SIO_TOP_JTAGID_LO__A, &sio_top_jtagid_lo, 0);
2521         if (rc != 0) {
2522                 pr_err("error %d\n", rc);
2523                 goto rw_error;
2524         }
2525         ext_attr->mfx = (u8) ((sio_top_jtagid_lo >> 29) & 0xF);
2526
2527         switch ((sio_top_jtagid_lo >> 12) & 0xFF) {
2528         case 0x31:
2529                 rc = drxj_dap_write_reg16(dev_addr, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY, 0);
2530                 if (rc != 0) {
2531                         pr_err("error %d\n", rc);
2532                         goto rw_error;
2533                 }
2534                 rc = drxj_dap_read_reg16(dev_addr, SIO_PDR_UIO_IN_HI__A, &bid, 0);
2535                 if (rc != 0) {
2536                         pr_err("error %d\n", rc);
2537                         goto rw_error;
2538                 }
2539                 bid = (bid >> 10) & 0xf;
2540                 rc = drxj_dap_write_reg16(dev_addr, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY__PRE, 0);
2541                 if (rc != 0) {
2542                         pr_err("error %d\n", rc);
2543                         goto rw_error;
2544                 }
2545
2546                 ext_attr->has_lna = true;
2547                 ext_attr->has_ntsc = false;
2548                 ext_attr->has_btsc = false;
2549                 ext_attr->has_oob = false;
2550                 ext_attr->has_smatx = true;
2551                 ext_attr->has_smarx = false;
2552                 ext_attr->has_gpio = false;
2553                 ext_attr->has_irqn = false;
2554                 break;
2555         case 0x33:
2556                 ext_attr->has_lna = false;
2557                 ext_attr->has_ntsc = false;
2558                 ext_attr->has_btsc = false;
2559                 ext_attr->has_oob = false;
2560                 ext_attr->has_smatx = true;
2561                 ext_attr->has_smarx = false;
2562                 ext_attr->has_gpio = false;
2563                 ext_attr->has_irqn = false;
2564                 break;
2565         case 0x45:
2566                 ext_attr->has_lna = true;
2567                 ext_attr->has_ntsc = true;
2568                 ext_attr->has_btsc = false;
2569                 ext_attr->has_oob = false;
2570                 ext_attr->has_smatx = true;
2571                 ext_attr->has_smarx = true;
2572                 ext_attr->has_gpio = true;
2573                 ext_attr->has_irqn = false;
2574                 break;
2575         case 0x46:
2576                 ext_attr->has_lna = false;
2577                 ext_attr->has_ntsc = true;
2578                 ext_attr->has_btsc = false;
2579                 ext_attr->has_oob = false;
2580                 ext_attr->has_smatx = true;
2581                 ext_attr->has_smarx = true;
2582                 ext_attr->has_gpio = true;
2583                 ext_attr->has_irqn = false;
2584                 break;
2585         case 0x41:
2586                 ext_attr->has_lna = true;
2587                 ext_attr->has_ntsc = true;
2588                 ext_attr->has_btsc = true;
2589                 ext_attr->has_oob = false;
2590                 ext_attr->has_smatx = true;
2591                 ext_attr->has_smarx = true;
2592                 ext_attr->has_gpio = true;
2593                 ext_attr->has_irqn = false;
2594                 break;
2595         case 0x43:
2596                 ext_attr->has_lna = false;
2597                 ext_attr->has_ntsc = true;
2598                 ext_attr->has_btsc = true;
2599                 ext_attr->has_oob = false;
2600                 ext_attr->has_smatx = true;
2601                 ext_attr->has_smarx = true;
2602                 ext_attr->has_gpio = true;
2603                 ext_attr->has_irqn = false;
2604                 break;
2605         case 0x32:
2606                 ext_attr->has_lna = true;
2607                 ext_attr->has_ntsc = false;
2608                 ext_attr->has_btsc = false;
2609                 ext_attr->has_oob = true;
2610                 ext_attr->has_smatx = true;
2611                 ext_attr->has_smarx = true;
2612                 ext_attr->has_gpio = true;
2613                 ext_attr->has_irqn = true;
2614                 break;
2615         case 0x34:
2616                 ext_attr->has_lna = false;
2617                 ext_attr->has_ntsc = true;
2618                 ext_attr->has_btsc = true;
2619                 ext_attr->has_oob = true;
2620                 ext_attr->has_smatx = true;
2621                 ext_attr->has_smarx = true;
2622                 ext_attr->has_gpio = true;
2623                 ext_attr->has_irqn = true;
2624                 break;
2625         case 0x42:
2626                 ext_attr->has_lna = true;
2627                 ext_attr->has_ntsc = true;
2628                 ext_attr->has_btsc = true;
2629                 ext_attr->has_oob = true;
2630                 ext_attr->has_smatx = true;
2631                 ext_attr->has_smarx = true;
2632                 ext_attr->has_gpio = true;
2633                 ext_attr->has_irqn = true;
2634                 break;
2635         case 0x44:
2636                 ext_attr->has_lna = false;
2637                 ext_attr->has_ntsc = true;
2638                 ext_attr->has_btsc = true;
2639                 ext_attr->has_oob = true;
2640                 ext_attr->has_smatx = true;
2641                 ext_attr->has_smarx = true;
2642                 ext_attr->has_gpio = true;
2643                 ext_attr->has_irqn = true;
2644                 break;
2645         default:
2646                 /* Unknown device variant */
2647                 return -EIO;
2648                 break;
2649         }
2650
2651         return 0;
2652 rw_error:
2653         return rc;
2654 }
2655
2656 /**
2657 * \fn int power_up_device()
2658 * \brief Power up device.
2659 * \param demod  Pointer to demodulator instance.
2660 * \return int.
2661 * \return 0    Success
2662 * \retval -EIO Failure, I2C or max retries reached
2663 *
2664 */
2665
2666 #ifndef DRXJ_MAX_RETRIES_POWERUP
2667 #define DRXJ_MAX_RETRIES_POWERUP 10
2668 #endif
2669
2670 static int power_up_device(struct drx_demod_instance *demod)
2671 {
2672         struct i2c_device_addr *dev_addr = (struct i2c_device_addr *)(NULL);
2673         u8 data = 0;
2674         u16 retry_count = 0;
2675         struct i2c_device_addr wake_up_addr;
2676
2677         dev_addr = demod->my_i2c_dev_addr;
2678         wake_up_addr.i2c_addr = DRXJ_WAKE_UP_KEY;
2679         wake_up_addr.i2c_dev_id = dev_addr->i2c_dev_id;
2680         wake_up_addr.user_data = dev_addr->user_data;
2681         /*
2682          * I2C access may fail in this case: no ack
2683          * dummy write must be used to wake uop device, dummy read must be used to
2684          * reset HI state machine (avoiding actual writes)
2685          */
2686         do {
2687                 data = 0;
2688                 drxbsp_i2c_write_read(&wake_up_addr, 1, &data,
2689                                       (struct i2c_device_addr *)(NULL), 0,
2690                                      (u8 *)(NULL));
2691                 msleep(10);
2692                 retry_count++;
2693         } while ((drxbsp_i2c_write_read
2694                   ((struct i2c_device_addr *) (NULL), 0, (u8 *)(NULL), dev_addr, 1,
2695                    &data)
2696                   != 0) && (retry_count < DRXJ_MAX_RETRIES_POWERUP));
2697
2698         /* Need some recovery time .... */
2699         msleep(10);
2700
2701         if (retry_count == DRXJ_MAX_RETRIES_POWERUP)
2702                 return -EIO;
2703
2704         return 0;
2705 }
2706
2707 /*----------------------------------------------------------------------------*/
2708 /* MPEG Output Configuration Functions - begin                                */
2709 /*----------------------------------------------------------------------------*/
2710 /**
2711 * \fn int ctrl_set_cfg_mpeg_output()
2712 * \brief Set MPEG output configuration of the device.
2713 * \param devmod  Pointer to demodulator instance.
2714 * \param cfg_data Pointer to mpeg output configuaration.
2715 * \return int.
2716 *
2717 *  Configure MPEG output parameters.
2718 *
2719 */
2720 static int
2721 ctrl_set_cfg_mpeg_output(struct drx_demod_instance *demod, struct drx_cfg_mpeg_output *cfg_data)
2722 {
2723         struct i2c_device_addr *dev_addr = (struct i2c_device_addr *)(NULL);
2724         struct drxj_data *ext_attr = (struct drxj_data *) (NULL);
2725         struct drx_common_attr *common_attr = (struct drx_common_attr *) (NULL);
2726         int rc;
2727         u16 fec_oc_reg_mode = 0;
2728         u16 fec_oc_reg_ipr_mode = 0;
2729         u16 fec_oc_reg_ipr_invert = 0;
2730         u32 max_bit_rate = 0;
2731         u32 rcn_rate = 0;
2732         u32 nr_bits = 0;
2733         u16 sio_pdr_md_cfg = 0;
2734         /* data mask for the output data byte */
2735         u16 invert_data_mask =
2736             FEC_OC_IPR_INVERT_MD7__M | FEC_OC_IPR_INVERT_MD6__M |
2737             FEC_OC_IPR_INVERT_MD5__M | FEC_OC_IPR_INVERT_MD4__M |
2738             FEC_OC_IPR_INVERT_MD3__M | FEC_OC_IPR_INVERT_MD2__M |
2739             FEC_OC_IPR_INVERT_MD1__M | FEC_OC_IPR_INVERT_MD0__M;
2740
2741         /* check arguments */
2742         if ((demod == NULL) || (cfg_data == NULL))
2743                 return -EINVAL;
2744
2745         dev_addr = demod->my_i2c_dev_addr;
2746         ext_attr = (struct drxj_data *) demod->my_ext_attr;
2747         common_attr = (struct drx_common_attr *) demod->my_common_attr;
2748
2749         if (cfg_data->enable_mpeg_output == true) {
2750                 /* quick and dirty patch to set MPEG incase current std is not
2751                    producing MPEG */
2752                 switch (ext_attr->standard) {
2753                 case DRX_STANDARD_8VSB:
2754                 case DRX_STANDARD_ITU_A:
2755                 case DRX_STANDARD_ITU_B:
2756                 case DRX_STANDARD_ITU_C:
2757                         break;
2758                 default:
2759                         return 0;
2760                 }
2761
2762                 rc = drxj_dap_write_reg16(dev_addr, FEC_OC_OCR_INVERT__A, 0, 0);
2763                 if (rc != 0) {
2764                         pr_err("error %d\n", rc);
2765                         goto rw_error;
2766                 }
2767                 switch (ext_attr->standard) {
2768                 case DRX_STANDARD_8VSB:
2769                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_FCT_USAGE__A, 7, 0);
2770                         if (rc != 0) {
2771                                 pr_err("error %d\n", rc);
2772                                 goto rw_error;
2773                         }       /* 2048 bytes fifo ram */
2774                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_TMD_CTL_UPD_RATE__A, 10, 0);
2775                         if (rc != 0) {
2776                                 pr_err("error %d\n", rc);
2777                                 goto rw_error;
2778                         }
2779                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_TMD_INT_UPD_RATE__A, 10, 0);
2780                         if (rc != 0) {
2781                                 pr_err("error %d\n", rc);
2782                                 goto rw_error;
2783                         }
2784                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_AVR_PARM_A__A, 5, 0);
2785                         if (rc != 0) {
2786                                 pr_err("error %d\n", rc);
2787                                 goto rw_error;
2788                         }
2789                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_AVR_PARM_B__A, 7, 0);
2790                         if (rc != 0) {
2791                                 pr_err("error %d\n", rc);
2792                                 goto rw_error;
2793                         }
2794                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_RCN_GAIN__A, 10, 0);
2795                         if (rc != 0) {
2796                                 pr_err("error %d\n", rc);
2797                                 goto rw_error;
2798                         }
2799                         /* Low Water Mark for synchronization  */
2800                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_SNC_LWM__A, 3, 0);
2801                         if (rc != 0) {
2802                                 pr_err("error %d\n", rc);
2803                                 goto rw_error;
2804                         }
2805                         /* High Water Mark for synchronization */
2806                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_SNC_HWM__A, 5, 0);
2807                         if (rc != 0) {
2808                                 pr_err("error %d\n", rc);
2809                                 goto rw_error;
2810                         }
2811                         break;
2812                 case DRX_STANDARD_ITU_A:
2813                 case DRX_STANDARD_ITU_C:
2814                         switch (ext_attr->constellation) {
2815                         case DRX_CONSTELLATION_QAM256:
2816                                 nr_bits = 8;
2817                                 break;
2818                         case DRX_CONSTELLATION_QAM128:
2819                                 nr_bits = 7;
2820                                 break;
2821                         case DRX_CONSTELLATION_QAM64:
2822                                 nr_bits = 6;
2823                                 break;
2824                         case DRX_CONSTELLATION_QAM32:
2825                                 nr_bits = 5;
2826                                 break;
2827                         case DRX_CONSTELLATION_QAM16:
2828                                 nr_bits = 4;
2829                                 break;
2830                         default:
2831                                 return -EIO;
2832                         }       /* ext_attr->constellation */
2833                         /* max_bit_rate = symbol_rate * nr_bits * coef */
2834                         /* coef = 188/204                          */
2835                         max_bit_rate =
2836                             (ext_attr->curr_symbol_rate / 8) * nr_bits * 188;
2837                         /* pass through b/c Annex A/c need following settings */
2838                 case DRX_STANDARD_ITU_B:
2839                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_FCT_USAGE__A, FEC_OC_FCT_USAGE__PRE, 0);
2840                         if (rc != 0) {
2841                                 pr_err("error %d\n", rc);
2842                                 goto rw_error;
2843                         }
2844                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_TMD_CTL_UPD_RATE__A, FEC_OC_TMD_CTL_UPD_RATE__PRE, 0);
2845                         if (rc != 0) {
2846                                 pr_err("error %d\n", rc);
2847                                 goto rw_error;
2848                         }
2849                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_TMD_INT_UPD_RATE__A, 5, 0);
2850                         if (rc != 0) {
2851                                 pr_err("error %d\n", rc);
2852                                 goto rw_error;
2853                         }
2854                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_AVR_PARM_A__A, FEC_OC_AVR_PARM_A__PRE, 0);
2855                         if (rc != 0) {
2856                                 pr_err("error %d\n", rc);
2857                                 goto rw_error;
2858                         }
2859                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_AVR_PARM_B__A, FEC_OC_AVR_PARM_B__PRE, 0);
2860                         if (rc != 0) {
2861                                 pr_err("error %d\n", rc);
2862                                 goto rw_error;
2863                         }
2864                         if (cfg_data->static_clk == true) {
2865                                 rc = drxj_dap_write_reg16(dev_addr, FEC_OC_RCN_GAIN__A, 0xD, 0);
2866                                 if (rc != 0) {
2867                                         pr_err("error %d\n", rc);
2868                                         goto rw_error;
2869                                 }
2870                         } else {
2871                                 rc = drxj_dap_write_reg16(dev_addr, FEC_OC_RCN_GAIN__A, FEC_OC_RCN_GAIN__PRE, 0);
2872                                 if (rc != 0) {
2873                                         pr_err("error %d\n", rc);
2874                                         goto rw_error;
2875                                 }
2876                         }
2877                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_SNC_LWM__A, 2, 0);
2878                         if (rc != 0) {
2879                                 pr_err("error %d\n", rc);
2880                                 goto rw_error;
2881                         }
2882                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_SNC_HWM__A, 12, 0);
2883                         if (rc != 0) {
2884                                 pr_err("error %d\n", rc);
2885                                 goto rw_error;
2886                         }
2887                         break;
2888                 default:
2889                         break;
2890                 }               /* swtich (standard) */
2891
2892                 /* Check insertion of the Reed-Solomon parity bytes */
2893                 rc = drxj_dap_read_reg16(dev_addr, FEC_OC_MODE__A, &fec_oc_reg_mode, 0);
2894                 if (rc != 0) {
2895                         pr_err("error %d\n", rc);
2896                         goto rw_error;
2897                 }
2898                 rc = drxj_dap_read_reg16(dev_addr, FEC_OC_IPR_MODE__A, &fec_oc_reg_ipr_mode, 0);
2899                 if (rc != 0) {
2900                         pr_err("error %d\n", rc);
2901                         goto rw_error;
2902                 }
2903                 if (cfg_data->insert_rs_byte == true) {
2904                         /* enable parity symbol forward */
2905                         fec_oc_reg_mode |= FEC_OC_MODE_PARITY__M;
2906                         /* MVAL disable during parity bytes */
2907                         fec_oc_reg_ipr_mode |= FEC_OC_IPR_MODE_MVAL_DIS_PAR__M;
2908                         switch (ext_attr->standard) {
2909                         case DRX_STANDARD_8VSB:
2910                                 rcn_rate = 0x004854D3;
2911                                 break;
2912                         case DRX_STANDARD_ITU_B:
2913                                 fec_oc_reg_mode |= FEC_OC_MODE_TRANSPARENT__M;
2914                                 switch (ext_attr->constellation) {
2915                                 case DRX_CONSTELLATION_QAM256:
2916                                         rcn_rate = 0x008945E7;
2917                                         break;
2918                                 case DRX_CONSTELLATION_QAM64:
2919                                         rcn_rate = 0x005F64D4;
2920                                         break;
2921                                 default:
2922                                         return -EIO;
2923                                 }
2924                                 break;
2925                         case DRX_STANDARD_ITU_A:
2926                         case DRX_STANDARD_ITU_C:
2927                                 /* insert_rs_byte = true -> coef = 188/188 -> 1, RS bits are in MPEG output */
2928                                 rcn_rate =
2929                                     (frac28
2930                                      (max_bit_rate,
2931                                       (u32) (common_attr->sys_clock_freq / 8))) /
2932                                     188;
2933                                 break;
2934                         default:
2935                                 return -EIO;
2936                         }       /* ext_attr->standard */
2937                 } else {        /* insert_rs_byte == false */
2938
2939                         /* disable parity symbol forward */
2940                         fec_oc_reg_mode &= (~FEC_OC_MODE_PARITY__M);
2941                         /* MVAL enable during parity bytes */
2942                         fec_oc_reg_ipr_mode &= (~FEC_OC_IPR_MODE_MVAL_DIS_PAR__M);
2943                         switch (ext_attr->standard) {
2944                         case DRX_STANDARD_8VSB:
2945                                 rcn_rate = 0x0041605C;
2946                                 break;
2947                         case DRX_STANDARD_ITU_B:
2948                                 fec_oc_reg_mode &= (~FEC_OC_MODE_TRANSPARENT__M);
2949                                 switch (ext_attr->constellation) {
2950                                 case DRX_CONSTELLATION_QAM256:
2951                                         rcn_rate = 0x0082D6A0;
2952                                         break;
2953                                 case DRX_CONSTELLATION_QAM64:
2954                                         rcn_rate = 0x005AEC1A;
2955                                         break;
2956                                 default:
2957                                         return -EIO;
2958                                 }
2959                                 break;
2960                         case DRX_STANDARD_ITU_A:
2961                         case DRX_STANDARD_ITU_C:
2962                                 /* insert_rs_byte = false -> coef = 188/204, RS bits not in MPEG output */
2963                                 rcn_rate =
2964                                     (frac28
2965                                      (max_bit_rate,
2966                                       (u32) (common_attr->sys_clock_freq / 8))) /
2967                                     204;
2968                                 break;
2969                         default:
2970                                 return -EIO;
2971                         }       /* ext_attr->standard */
2972                 }
2973
2974                 if (cfg_data->enable_parallel == true) {        /* MPEG data output is parallel -> clear ipr_mode[0] */
2975                         fec_oc_reg_ipr_mode &= (~(FEC_OC_IPR_MODE_SERIAL__M));
2976                 } else {        /* MPEG data output is serial -> set ipr_mode[0] */
2977                         fec_oc_reg_ipr_mode |= FEC_OC_IPR_MODE_SERIAL__M;
2978                 }
2979
2980                 /* Control slective inversion of output bits */
2981                 if (cfg_data->invert_data == true)
2982                         fec_oc_reg_ipr_invert |= invert_data_mask;
2983                 else
2984                         fec_oc_reg_ipr_invert &= (~(invert_data_mask));
2985
2986                 if (cfg_data->invert_err == true)
2987                         fec_oc_reg_ipr_invert |= FEC_OC_IPR_INVERT_MERR__M;
2988                 else
2989                         fec_oc_reg_ipr_invert &= (~(FEC_OC_IPR_INVERT_MERR__M));
2990
2991                 if (cfg_data->invert_str == true)
2992                         fec_oc_reg_ipr_invert |= FEC_OC_IPR_INVERT_MSTRT__M;
2993                 else
2994                         fec_oc_reg_ipr_invert &= (~(FEC_OC_IPR_INVERT_MSTRT__M));
2995
2996                 if (cfg_data->invert_val == true)
2997                         fec_oc_reg_ipr_invert |= FEC_OC_IPR_INVERT_MVAL__M;
2998                 else
2999                         fec_oc_reg_ipr_invert &= (~(FEC_OC_IPR_INVERT_MVAL__M));
3000
3001                 if (cfg_data->invert_clk == true)
3002                         fec_oc_reg_ipr_invert |= FEC_OC_IPR_INVERT_MCLK__M;
3003                 else
3004                         fec_oc_reg_ipr_invert &= (~(FEC_OC_IPR_INVERT_MCLK__M));
3005
3006
3007                 if (cfg_data->static_clk == true) {     /* Static mode */
3008                         u32 dto_rate = 0;
3009                         u32 bit_rate = 0;
3010                         u16 fec_oc_dto_burst_len = 0;
3011                         u16 fec_oc_dto_period = 0;
3012
3013                         fec_oc_dto_burst_len = FEC_OC_DTO_BURST_LEN__PRE;
3014
3015                         switch (ext_attr->standard) {
3016                         case DRX_STANDARD_8VSB:
3017                                 fec_oc_dto_period = 4;
3018                                 if (cfg_data->insert_rs_byte == true)
3019                                         fec_oc_dto_burst_len = 208;
3020                                 break;
3021                         case DRX_STANDARD_ITU_A:
3022                                 {
3023                                         u32 symbol_rate_th = 6400000;
3024                                         if (cfg_data->insert_rs_byte == true) {
3025                                                 fec_oc_dto_burst_len = 204;
3026                                                 symbol_rate_th = 5900000;
3027                                         }
3028                                         if (ext_attr->curr_symbol_rate >=
3029                                             symbol_rate_th) {
3030                                                 fec_oc_dto_period = 0;
3031                                         } else {
3032                                                 fec_oc_dto_period = 1;
3033                                         }
3034                                 }
3035                                 break;
3036                         case DRX_STANDARD_ITU_B:
3037                                 fec_oc_dto_period = 1;
3038                                 if (cfg_data->insert_rs_byte == true)
3039                                         fec_oc_dto_burst_len = 128;
3040                                 break;
3041                         case DRX_STANDARD_ITU_C:
3042                                 fec_oc_dto_period = 1;
3043                                 if (cfg_data->insert_rs_byte == true)
3044                                         fec_oc_dto_burst_len = 204;
3045                                 break;
3046                         default:
3047                                 return -EIO;
3048                         }
3049                         bit_rate =
3050                             common_attr->sys_clock_freq * 1000 / (fec_oc_dto_period +
3051                                                                2);
3052                         dto_rate =
3053                             frac28(bit_rate, common_attr->sys_clock_freq * 1000);
3054                         dto_rate >>= 3;
3055                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_DTO_RATE_HI__A, (u16)((dto_rate >> 16) & FEC_OC_DTO_RATE_HI__M), 0);
3056                         if (rc != 0) {
3057                                 pr_err("error %d\n", rc);
3058                                 goto rw_error;
3059                         }
3060                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_DTO_RATE_LO__A, (u16)(dto_rate & FEC_OC_DTO_RATE_LO_RATE_LO__M), 0);
3061                         if (rc != 0) {
3062                                 pr_err("error %d\n", rc);
3063                                 goto rw_error;
3064                         }
3065                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_DTO_MODE__A, FEC_OC_DTO_MODE_DYNAMIC__M | FEC_OC_DTO_MODE_OFFSET_ENABLE__M, 0);
3066                         if (rc != 0) {
3067                                 pr_err("error %d\n", rc);
3068                                 goto rw_error;
3069                         }
3070                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_FCT_MODE__A, FEC_OC_FCT_MODE_RAT_ENA__M | FEC_OC_FCT_MODE_VIRT_ENA__M, 0);
3071                         if (rc != 0) {
3072                                 pr_err("error %d\n", rc);
3073                                 goto rw_error;
3074                         }
3075                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_DTO_BURST_LEN__A, fec_oc_dto_burst_len, 0);
3076                         if (rc != 0) {
3077                                 pr_err("error %d\n", rc);
3078                                 goto rw_error;
3079                         }
3080                         if (ext_attr->mpeg_output_clock_rate != DRXJ_MPEGOUTPUT_CLOCK_RATE_AUTO)
3081                                 fec_oc_dto_period = ext_attr->mpeg_output_clock_rate - 1;
3082                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_DTO_PERIOD__A, fec_oc_dto_period, 0);
3083                         if (rc != 0) {
3084                                 pr_err("error %d\n", rc);
3085                                 goto rw_error;
3086                         }
3087                 } else {        /* Dynamic mode */
3088
3089                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_DTO_MODE__A, FEC_OC_DTO_MODE_DYNAMIC__M, 0);
3090                         if (rc != 0) {
3091                                 pr_err("error %d\n", rc);
3092                                 goto rw_error;
3093                         }
3094                         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_FCT_MODE__A, 0, 0);
3095                         if (rc != 0) {
3096                                 pr_err("error %d\n", rc);
3097                                 goto rw_error;
3098                         }
3099                 }
3100
3101                 rc = drxdap_fasi_write_reg32(dev_addr, FEC_OC_RCN_CTL_RATE_LO__A, rcn_rate, 0);
3102                 if (rc != 0) {
3103                         pr_err("error %d\n", rc);
3104                         goto rw_error;
3105                 }
3106
3107                 /* Write appropriate registers with requested configuration */
3108                 rc = drxj_dap_write_reg16(dev_addr, FEC_OC_MODE__A, fec_oc_reg_mode, 0);
3109                 if (rc != 0) {
3110                         pr_err("error %d\n", rc);
3111                         goto rw_error;
3112                 }
3113                 rc = drxj_dap_write_reg16(dev_addr, FEC_OC_IPR_MODE__A, fec_oc_reg_ipr_mode, 0);
3114                 if (rc != 0) {
3115                         pr_err("error %d\n", rc);
3116                         goto rw_error;
3117                 }
3118                 rc = drxj_dap_write_reg16(dev_addr, FEC_OC_IPR_INVERT__A, fec_oc_reg_ipr_invert, 0);
3119                 if (rc != 0) {
3120                         pr_err("error %d\n", rc);
3121                         goto rw_error;
3122                 }
3123
3124                 /* enabling for both parallel and serial now */
3125                 /*  Write magic word to enable pdr reg write */
3126                 rc = drxj_dap_write_reg16(dev_addr, SIO_TOP_COMM_KEY__A, 0xFABA, 0);
3127                 if (rc != 0) {
3128                         pr_err("error %d\n", rc);
3129                         goto rw_error;
3130                 }
3131                 /*  Set MPEG TS pads to outputmode */
3132                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MSTRT_CFG__A, 0x0013, 0);
3133                 if (rc != 0) {
3134                         pr_err("error %d\n", rc);
3135                         goto rw_error;
3136                 }
3137                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MERR_CFG__A, 0x0013, 0);
3138                 if (rc != 0) {
3139                         pr_err("error %d\n", rc);
3140                         goto rw_error;
3141                 }
3142                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MCLK_CFG__A, MPEG_OUTPUT_CLK_DRIVE_STRENGTH << SIO_PDR_MCLK_CFG_DRIVE__B | 0x03 << SIO_PDR_MCLK_CFG_MODE__B, 0);
3143                 if (rc != 0) {
3144                         pr_err("error %d\n", rc);
3145                         goto rw_error;
3146                 }
3147                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MVAL_CFG__A, 0x0013, 0);
3148                 if (rc != 0) {
3149                         pr_err("error %d\n", rc);
3150                         goto rw_error;
3151                 }
3152                 sio_pdr_md_cfg =
3153                     MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH <<
3154                     SIO_PDR_MD0_CFG_DRIVE__B | 0x03 << SIO_PDR_MD0_CFG_MODE__B;
3155                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD0_CFG__A, sio_pdr_md_cfg, 0);
3156                 if (rc != 0) {
3157                         pr_err("error %d\n", rc);
3158                         goto rw_error;
3159                 }
3160                 if (cfg_data->enable_parallel == true) {        /* MPEG data output is parallel -> set MD1 to MD7 to output mode */
3161                         sio_pdr_md_cfg =
3162                             MPEG_PARALLEL_OUTPUT_PIN_DRIVE_STRENGTH <<
3163                             SIO_PDR_MD0_CFG_DRIVE__B | 0x03 <<
3164                             SIO_PDR_MD0_CFG_MODE__B;
3165                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD0_CFG__A, sio_pdr_md_cfg, 0);
3166                         if (rc != 0) {
3167                                 pr_err("error %d\n", rc);
3168                                 goto rw_error;
3169                         }
3170                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD1_CFG__A, sio_pdr_md_cfg, 0);
3171                         if (rc != 0) {
3172                                 pr_err("error %d\n", rc);
3173                                 goto rw_error;
3174                         }
3175                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD2_CFG__A, sio_pdr_md_cfg, 0);
3176                         if (rc != 0) {
3177                                 pr_err("error %d\n", rc);
3178                                 goto rw_error;
3179                         }
3180                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD3_CFG__A, sio_pdr_md_cfg, 0);
3181                         if (rc != 0) {
3182                                 pr_err("error %d\n", rc);
3183                                 goto rw_error;
3184                         }
3185                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD4_CFG__A, sio_pdr_md_cfg, 0);
3186                         if (rc != 0) {
3187                                 pr_err("error %d\n", rc);
3188                                 goto rw_error;
3189                         }
3190                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD5_CFG__A, sio_pdr_md_cfg, 0);
3191                         if (rc != 0) {
3192                                 pr_err("error %d\n", rc);
3193                                 goto rw_error;
3194                         }
3195                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD6_CFG__A, sio_pdr_md_cfg, 0);
3196                         if (rc != 0) {
3197                                 pr_err("error %d\n", rc);
3198                                 goto rw_error;
3199                         }
3200                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD7_CFG__A, sio_pdr_md_cfg, 0);
3201                         if (rc != 0) {
3202                                 pr_err("error %d\n", rc);
3203                                 goto rw_error;
3204                         }
3205                 } else {        /* MPEG data output is serial -> set MD1 to MD7 to tri-state */
3206                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD1_CFG__A, 0x0000, 0);
3207                         if (rc != 0) {
3208                                 pr_err("error %d\n", rc);
3209                                 goto rw_error;
3210                         }
3211                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD2_CFG__A, 0x0000, 0);
3212                         if (rc != 0) {
3213                                 pr_err("error %d\n", rc);
3214                                 goto rw_error;
3215                         }
3216                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD3_CFG__A, 0x0000, 0);
3217                         if (rc != 0) {
3218                                 pr_err("error %d\n", rc);
3219                                 goto rw_error;
3220                         }
3221                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD4_CFG__A, 0x0000, 0);
3222                         if (rc != 0) {
3223                                 pr_err("error %d\n", rc);
3224                                 goto rw_error;
3225                         }
3226                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD5_CFG__A, 0x0000, 0);
3227                         if (rc != 0) {
3228                                 pr_err("error %d\n", rc);
3229                                 goto rw_error;
3230                         }
3231                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD6_CFG__A, 0x0000, 0);
3232                         if (rc != 0) {
3233                                 pr_err("error %d\n", rc);
3234                                 goto rw_error;
3235                         }
3236                         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD7_CFG__A, 0x0000, 0);
3237                         if (rc != 0) {
3238                                 pr_err("error %d\n", rc);
3239                                 goto rw_error;
3240                         }
3241                 }
3242                 /*  Enable Monitor Bus output over MPEG pads and ctl input */
3243                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MON_CFG__A, 0x0000, 0);
3244                 if (rc != 0) {
3245                         pr_err("error %d\n", rc);
3246                         goto rw_error;
3247                 }
3248                 /*  Write nomagic word to enable pdr reg write */
3249                 rc = drxj_dap_write_reg16(dev_addr, SIO_TOP_COMM_KEY__A, 0x0000, 0);
3250                 if (rc != 0) {
3251                         pr_err("error %d\n", rc);
3252                         goto rw_error;
3253                 }
3254         } else {
3255                 /*  Write magic word to enable pdr reg write */
3256                 rc = drxj_dap_write_reg16(dev_addr, SIO_TOP_COMM_KEY__A, 0xFABA, 0);
3257                 if (rc != 0) {
3258                         pr_err("error %d\n", rc);
3259                         goto rw_error;
3260                 }
3261                 /*  Set MPEG TS pads to inputmode */
3262                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MSTRT_CFG__A, 0x0000, 0);
3263                 if (rc != 0) {
3264                         pr_err("error %d\n", rc);
3265                         goto rw_error;
3266                 }
3267                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MERR_CFG__A, 0x0000, 0);
3268                 if (rc != 0) {
3269                         pr_err("error %d\n", rc);
3270                         goto rw_error;
3271                 }
3272                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MCLK_CFG__A, 0x0000, 0);
3273                 if (rc != 0) {
3274                         pr_err("error %d\n", rc);
3275                         goto rw_error;
3276                 }
3277                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MVAL_CFG__A, 0x0000, 0);
3278                 if (rc != 0) {
3279                         pr_err("error %d\n", rc);
3280                         goto rw_error;
3281                 }
3282                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD0_CFG__A, 0x0000, 0);
3283                 if (rc != 0) {
3284                         pr_err("error %d\n", rc);
3285                         goto rw_error;
3286                 }
3287                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD1_CFG__A, 0x0000, 0);
3288                 if (rc != 0) {
3289                         pr_err("error %d\n", rc);
3290                         goto rw_error;
3291                 }
3292                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD2_CFG__A, 0x0000, 0);
3293                 if (rc != 0) {
3294                         pr_err("error %d\n", rc);
3295                         goto rw_error;
3296                 }
3297                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD3_CFG__A, 0x0000, 0);
3298                 if (rc != 0) {
3299                         pr_err("error %d\n", rc);
3300                         goto rw_error;
3301                 }
3302                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD4_CFG__A, 0x0000, 0);
3303                 if (rc != 0) {
3304                         pr_err("error %d\n", rc);
3305                         goto rw_error;
3306                 }
3307                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD5_CFG__A, 0x0000, 0);
3308                 if (rc != 0) {
3309                         pr_err("error %d\n", rc);
3310                         goto rw_error;
3311                 }
3312                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD6_CFG__A, 0x0000, 0);
3313                 if (rc != 0) {
3314                         pr_err("error %d\n", rc);
3315                         goto rw_error;
3316                 }
3317                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MD7_CFG__A, 0x0000, 0);
3318                 if (rc != 0) {
3319                         pr_err("error %d\n", rc);
3320                         goto rw_error;
3321                 }
3322                 /* Enable Monitor Bus output over MPEG pads and ctl input */
3323                 rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_MON_CFG__A, 0x0000, 0);
3324                 if (rc != 0) {
3325                         pr_err("error %d\n", rc);
3326                         goto rw_error;
3327                 }
3328                 /* Write nomagic word to enable pdr reg write */
3329                 rc = drxj_dap_write_reg16(dev_addr, SIO_TOP_COMM_KEY__A, 0x0000, 0);
3330                 if (rc != 0) {
3331                         pr_err("error %d\n", rc);
3332                         goto rw_error;
3333                 }
3334         }
3335
3336         /* save values for restore after re-acquire */
3337         common_attr->mpeg_cfg.enable_mpeg_output = cfg_data->enable_mpeg_output;
3338
3339         return 0;
3340 rw_error:
3341         return rc;
3342 }
3343
3344 /*----------------------------------------------------------------------------*/
3345
3346
3347 /*----------------------------------------------------------------------------*/
3348 /* MPEG Output Configuration Functions - end                                  */
3349 /*----------------------------------------------------------------------------*/
3350
3351 /*----------------------------------------------------------------------------*/
3352 /* miscellaneous configuartions - begin                           */
3353 /*----------------------------------------------------------------------------*/
3354
3355 /**
3356 * \fn int set_mpegtei_handling()
3357 * \brief Activate MPEG TEI handling settings.
3358 * \param devmod  Pointer to demodulator instance.
3359 * \return int.
3360 *
3361 * This routine should be called during a set channel of QAM/VSB
3362 *
3363 */
3364 static int set_mpegtei_handling(struct drx_demod_instance *demod)
3365 {
3366         struct drxj_data *ext_attr = (struct drxj_data *) (NULL);
3367         struct i2c_device_addr *dev_addr = (struct i2c_device_addr *)(NULL);
3368         int rc;
3369         u16 fec_oc_dpr_mode = 0;
3370         u16 fec_oc_snc_mode = 0;
3371         u16 fec_oc_ems_mode = 0;
3372
3373         dev_addr = demod->my_i2c_dev_addr;
3374         ext_attr = (struct drxj_data *) demod->my_ext_attr;
3375
3376         rc = drxj_dap_read_reg16(dev_addr, FEC_OC_DPR_MODE__A, &fec_oc_dpr_mode, 0);
3377         if (rc != 0) {
3378                 pr_err("error %d\n", rc);
3379                 goto rw_error;
3380         }
3381         rc = drxj_dap_read_reg16(dev_addr, FEC_OC_SNC_MODE__A, &fec_oc_snc_mode, 0);
3382         if (rc != 0) {
3383                 pr_err("error %d\n", rc);
3384                 goto rw_error;
3385         }
3386         rc = drxj_dap_read_reg16(dev_addr, FEC_OC_EMS_MODE__A, &fec_oc_ems_mode, 0);
3387         if (rc != 0) {
3388                 pr_err("error %d\n", rc);
3389                 goto rw_error;
3390         }
3391
3392         /* reset to default, allow TEI bit to be changed */
3393         fec_oc_dpr_mode &= (~FEC_OC_DPR_MODE_ERR_DISABLE__M);
3394         fec_oc_snc_mode &= (~(FEC_OC_SNC_MODE_ERROR_CTL__M |
3395                            FEC_OC_SNC_MODE_CORR_DISABLE__M));
3396         fec_oc_ems_mode &= (~FEC_OC_EMS_MODE_MODE__M);
3397
3398         if (ext_attr->disable_te_ihandling) {
3399                 /* do not change TEI bit */
3400                 fec_oc_dpr_mode |= FEC_OC_DPR_MODE_ERR_DISABLE__M;
3401                 fec_oc_snc_mode |= FEC_OC_SNC_MODE_CORR_DISABLE__M |
3402                     ((0x2) << (FEC_OC_SNC_MODE_ERROR_CTL__B));
3403                 fec_oc_ems_mode |= ((0x01) << (FEC_OC_EMS_MODE_MODE__B));
3404         }
3405
3406         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_DPR_MODE__A, fec_oc_dpr_mode, 0);
3407         if (rc != 0) {
3408                 pr_err("error %d\n", rc);
3409                 goto rw_error;
3410         }
3411         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_SNC_MODE__A, fec_oc_snc_mode, 0);
3412         if (rc != 0) {
3413                 pr_err("error %d\n", rc);
3414                 goto rw_error;
3415         }
3416         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_EMS_MODE__A, fec_oc_ems_mode, 0);
3417         if (rc != 0) {
3418                 pr_err("error %d\n", rc);
3419                 goto rw_error;
3420         }
3421
3422         return 0;
3423 rw_error:
3424         return rc;
3425 }
3426
3427 /*----------------------------------------------------------------------------*/
3428 /**
3429 * \fn int bit_reverse_mpeg_output()
3430 * \brief Set MPEG output bit-endian settings.
3431 * \param devmod  Pointer to demodulator instance.
3432 * \return int.
3433 *
3434 * This routine should be called during a set channel of QAM/VSB
3435 *
3436 */
3437 static int bit_reverse_mpeg_output(struct drx_demod_instance *demod)
3438 {
3439         struct drxj_data *ext_attr = (struct drxj_data *) (NULL);
3440         struct i2c_device_addr *dev_addr = (struct i2c_device_addr *)(NULL);
3441         int rc;
3442         u16 fec_oc_ipr_mode = 0;
3443
3444         dev_addr = demod->my_i2c_dev_addr;
3445         ext_attr = (struct drxj_data *) demod->my_ext_attr;
3446
3447         rc = drxj_dap_read_reg16(dev_addr, FEC_OC_IPR_MODE__A, &fec_oc_ipr_mode, 0);
3448         if (rc != 0) {
3449                 pr_err("error %d\n", rc);
3450                 goto rw_error;
3451         }
3452
3453         /* reset to default (normal bit order) */
3454         fec_oc_ipr_mode &= (~FEC_OC_IPR_MODE_REVERSE_ORDER__M);
3455
3456         if (ext_attr->bit_reverse_mpeg_outout)
3457                 fec_oc_ipr_mode |= FEC_OC_IPR_MODE_REVERSE_ORDER__M;
3458
3459         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_IPR_MODE__A, fec_oc_ipr_mode, 0);
3460         if (rc != 0) {
3461                 pr_err("error %d\n", rc);
3462                 goto rw_error;
3463         }
3464
3465         return 0;
3466 rw_error:
3467         return rc;
3468 }
3469
3470 /*----------------------------------------------------------------------------*/
3471 /**
3472 * \fn int set_mpeg_start_width()
3473 * \brief Set MPEG start width.
3474 * \param devmod  Pointer to demodulator instance.
3475 * \return int.
3476 *
3477 * This routine should be called during a set channel of QAM/VSB
3478 *
3479 */
3480 static int set_mpeg_start_width(struct drx_demod_instance *demod)
3481 {
3482         struct drxj_data *ext_attr = (struct drxj_data *) (NULL);
3483         struct i2c_device_addr *dev_addr = (struct i2c_device_addr *)(NULL);
3484         struct drx_common_attr *common_attr = (struct drx_common_attr *) NULL;
3485         int rc;
3486         u16 fec_oc_comm_mb = 0;
3487
3488         dev_addr = demod->my_i2c_dev_addr;
3489         ext_attr = (struct drxj_data *) demod->my_ext_attr;
3490         common_attr = demod->my_common_attr;
3491
3492         if ((common_attr->mpeg_cfg.static_clk == true)
3493             && (common_attr->mpeg_cfg.enable_parallel == false)) {
3494                 rc = drxj_dap_read_reg16(dev_addr, FEC_OC_COMM_MB__A, &fec_oc_comm_mb, 0);
3495                 if (rc != 0) {
3496                         pr_err("error %d\n", rc);
3497                         goto rw_error;
3498                 }
3499                 fec_oc_comm_mb &= ~FEC_OC_COMM_MB_CTL_ON;
3500                 if (ext_attr->mpeg_start_width == DRXJ_MPEG_START_WIDTH_8CLKCYC)
3501                         fec_oc_comm_mb |= FEC_OC_COMM_MB_CTL_ON;
3502                 rc = drxj_dap_write_reg16(dev_addr, FEC_OC_COMM_MB__A, fec_oc_comm_mb, 0);
3503                 if (rc != 0) {
3504                         pr_err("error %d\n", rc);
3505                         goto rw_error;
3506                 }
3507         }
3508
3509         return 0;
3510 rw_error:
3511         return rc;
3512 }
3513
3514 /*----------------------------------------------------------------------------*/
3515 /* miscellaneous configuartions - end                             */
3516 /*----------------------------------------------------------------------------*/
3517
3518 /*----------------------------------------------------------------------------*/
3519 /* UIO Configuration Functions - begin                                        */
3520 /*----------------------------------------------------------------------------*/
3521 /**
3522 * \fn int ctrl_set_uio_cfg()
3523 * \brief Configure modus oprandi UIO.
3524 * \param demod Pointer to demodulator instance.
3525 * \param uio_cfg Pointer to a configuration setting for a certain UIO.
3526 * \return int.
3527 */
3528 static int ctrl_set_uio_cfg(struct drx_demod_instance *demod, struct drxuio_cfg *uio_cfg)
3529 {
3530         struct drxj_data *ext_attr = (struct drxj_data *) (NULL);
3531         int rc;
3532
3533         if ((uio_cfg == NULL) || (demod == NULL))
3534                 return -EINVAL;
3535
3536         ext_attr = (struct drxj_data *) demod->my_ext_attr;
3537
3538         /*  Write magic word to enable pdr reg write               */
3539         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY, 0);
3540         if (rc != 0) {
3541                 pr_err("error %d\n", rc);
3542                 goto rw_error;
3543         }
3544         switch (uio_cfg->uio) {
3545       /*====================================================================*/
3546         case DRX_UIO1:
3547                 /* DRX_UIO1: SMA_TX UIO-1 */
3548                 if (!ext_attr->has_smatx)
3549                         return -EIO;
3550                 switch (uio_cfg->mode) {
3551                 case DRX_UIO_MODE_FIRMWARE_SMA: /* falltrough */
3552                 case DRX_UIO_MODE_FIRMWARE_SAW: /* falltrough */
3553                 case DRX_UIO_MODE_READWRITE:
3554                         ext_attr->uio_sma_tx_mode = uio_cfg->mode;
3555                         break;
3556                 case DRX_UIO_MODE_DISABLE:
3557                         ext_attr->uio_sma_tx_mode = uio_cfg->mode;
3558                         /* pad configuration register is set 0 - input mode */
3559                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_SMA_TX_CFG__A, 0, 0);
3560                         if (rc != 0) {
3561                                 pr_err("error %d\n", rc);
3562                                 goto rw_error;
3563                         }
3564                         break;
3565                 default:
3566                         return -EINVAL;
3567                 }               /* switch ( uio_cfg->mode ) */
3568                 break;
3569       /*====================================================================*/
3570         case DRX_UIO2:
3571                 /* DRX_UIO2: SMA_RX UIO-2 */
3572                 if (!ext_attr->has_smarx)
3573                         return -EIO;
3574                 switch (uio_cfg->mode) {
3575                 case DRX_UIO_MODE_FIRMWARE0:    /* falltrough */
3576                 case DRX_UIO_MODE_READWRITE:
3577                         ext_attr->uio_sma_rx_mode = uio_cfg->mode;
3578                         break;
3579                 case DRX_UIO_MODE_DISABLE:
3580                         ext_attr->uio_sma_rx_mode = uio_cfg->mode;
3581                         /* pad configuration register is set 0 - input mode */
3582                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_SMA_RX_CFG__A, 0, 0);
3583                         if (rc != 0) {
3584                                 pr_err("error %d\n", rc);
3585                                 goto rw_error;
3586                         }
3587                         break;
3588                 default:
3589                         return -EINVAL;
3590                         break;
3591                 }               /* switch ( uio_cfg->mode ) */
3592                 break;
3593       /*====================================================================*/
3594         case DRX_UIO3:
3595                 /* DRX_UIO3: GPIO UIO-3 */
3596                 if (!ext_attr->has_gpio)
3597                         return -EIO;
3598                 switch (uio_cfg->mode) {
3599                 case DRX_UIO_MODE_FIRMWARE0:    /* falltrough */
3600                 case DRX_UIO_MODE_READWRITE:
3601                         ext_attr->uio_gpio_mode = uio_cfg->mode;
3602                         break;
3603                 case DRX_UIO_MODE_DISABLE:
3604                         ext_attr->uio_gpio_mode = uio_cfg->mode;
3605                         /* pad configuration register is set 0 - input mode */
3606                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_GPIO_CFG__A, 0, 0);
3607                         if (rc != 0) {
3608                                 pr_err("error %d\n", rc);
3609                                 goto rw_error;
3610                         }
3611                         break;
3612                 default:
3613                         return -EINVAL;
3614                         break;
3615                 }               /* switch ( uio_cfg->mode ) */
3616                 break;
3617       /*====================================================================*/
3618         case DRX_UIO4:
3619                 /* DRX_UIO4: IRQN UIO-4 */
3620                 if (!ext_attr->has_irqn)
3621                         return -EIO;
3622                 switch (uio_cfg->mode) {
3623                 case DRX_UIO_MODE_READWRITE:
3624                         ext_attr->uio_irqn_mode = uio_cfg->mode;
3625                         break;
3626                 case DRX_UIO_MODE_DISABLE:
3627                         /* pad configuration register is set 0 - input mode */
3628                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_IRQN_CFG__A, 0, 0);
3629                         if (rc != 0) {
3630                                 pr_err("error %d\n", rc);
3631                                 goto rw_error;
3632                         }
3633                         ext_attr->uio_irqn_mode = uio_cfg->mode;
3634                         break;
3635                 case DRX_UIO_MODE_FIRMWARE0:    /* falltrough */
3636                 default:
3637                         return -EINVAL;
3638                         break;
3639                 }               /* switch ( uio_cfg->mode ) */
3640                 break;
3641       /*====================================================================*/
3642         default:
3643                 return -EINVAL;
3644         }                       /* switch ( uio_cfg->uio ) */
3645
3646         /*  Write magic word to disable pdr reg write               */
3647         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_TOP_COMM_KEY__A, 0x0000, 0);
3648         if (rc != 0) {
3649                 pr_err("error %d\n", rc);
3650                 goto rw_error;
3651         }
3652
3653         return 0;
3654 rw_error:
3655         return rc;
3656 }
3657
3658 /**
3659 * \fn int ctrl_uio_write()
3660 * \brief Write to a UIO.
3661 * \param demod Pointer to demodulator instance.
3662 * \param uio_data Pointer to data container for a certain UIO.
3663 * \return int.
3664 */
3665 static int
3666 ctrl_uio_write(struct drx_demod_instance *demod, struct drxuio_data *uio_data)
3667 {
3668         struct drxj_data *ext_attr = (struct drxj_data *) (NULL);
3669         int rc;
3670         u16 pin_cfg_value = 0;
3671         u16 value = 0;
3672
3673         if ((uio_data == NULL) || (demod == NULL))
3674                 return -EINVAL;
3675
3676         ext_attr = (struct drxj_data *) demod->my_ext_attr;
3677
3678         /*  Write magic word to enable pdr reg write               */
3679         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY, 0);
3680         if (rc != 0) {
3681                 pr_err("error %d\n", rc);
3682                 goto rw_error;
3683         }
3684         switch (uio_data->uio) {
3685       /*====================================================================*/
3686         case DRX_UIO1:
3687                 /* DRX_UIO1: SMA_TX UIO-1 */
3688                 if (!ext_attr->has_smatx)
3689                         return -EIO;
3690                 if ((ext_attr->uio_sma_tx_mode != DRX_UIO_MODE_READWRITE)
3691                     && (ext_attr->uio_sma_tx_mode != DRX_UIO_MODE_FIRMWARE_SAW)) {
3692                         return -EIO;
3693                 }
3694                 pin_cfg_value = 0;
3695                 /* io_pad_cfg register (8 bit reg.) MSB bit is 1 (default value) */
3696                 pin_cfg_value |= 0x0113;
3697                 /* io_pad_cfg_mode output mode is drive always */
3698                 /* io_pad_cfg_drive is set to power 2 (23 mA) */
3699
3700                 /* write to io pad configuration register - output mode */
3701                 rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_SMA_TX_CFG__A, pin_cfg_value, 0);
3702                 if (rc != 0) {
3703                         pr_err("error %d\n", rc);
3704                         goto rw_error;
3705                 }
3706
3707                 /* use corresponding bit in io data output registar */
3708                 rc = drxj_dap_read_reg16(demod->my_i2c_dev_addr, SIO_PDR_UIO_OUT_LO__A, &value, 0);
3709                 if (rc != 0) {
3710                         pr_err("error %d\n", rc);
3711                         goto rw_error;
3712                 }
3713                 if (!uio_data->value)
3714                         value &= 0x7FFF;        /* write zero to 15th bit - 1st UIO */
3715                 else
3716                         value |= 0x8000;        /* write one to 15th bit - 1st UIO */
3717
3718                 /* write back to io data output register */
3719                 rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_UIO_OUT_LO__A, value, 0);
3720                 if (rc != 0) {
3721                         pr_err("error %d\n", rc);
3722                         goto rw_error;
3723                 }
3724                 break;
3725    /*======================================================================*/
3726         case DRX_UIO2:
3727                 /* DRX_UIO2: SMA_RX UIO-2 */
3728                 if (!ext_attr->has_smarx)
3729                         return -EIO;
3730                 if (ext_attr->uio_sma_rx_mode != DRX_UIO_MODE_READWRITE)
3731                         return -EIO;
3732
3733                 pin_cfg_value = 0;
3734                 /* io_pad_cfg register (8 bit reg.) MSB bit is 1 (default value) */
3735                 pin_cfg_value |= 0x0113;
3736                 /* io_pad_cfg_mode output mode is drive always */
3737                 /* io_pad_cfg_drive is set to power 2 (23 mA) */
3738
3739                 /* write to io pad configuration register - output mode */
3740                 rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_SMA_RX_CFG__A, pin_cfg_value, 0);
3741                 if (rc != 0) {
3742                         pr_err("error %d\n", rc);
3743                         goto rw_error;
3744                 }
3745
3746                 /* use corresponding bit in io data output registar */
3747                 rc = drxj_dap_read_reg16(demod->my_i2c_dev_addr, SIO_PDR_UIO_OUT_LO__A, &value, 0);
3748                 if (rc != 0) {
3749                         pr_err("error %d\n", rc);
3750                         goto rw_error;
3751                 }
3752                 if (!uio_data->value)
3753                         value &= 0xBFFF;        /* write zero to 14th bit - 2nd UIO */
3754                 else
3755                         value |= 0x4000;        /* write one to 14th bit - 2nd UIO */
3756
3757                 /* write back to io data output register */
3758                 rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_UIO_OUT_LO__A, value, 0);
3759                 if (rc != 0) {
3760                         pr_err("error %d\n", rc);
3761                         goto rw_error;
3762                 }
3763                 break;
3764    /*====================================================================*/
3765         case DRX_UIO3:
3766                 /* DRX_UIO3: ASEL UIO-3 */
3767                 if (!ext_attr->has_gpio)
3768                         return -EIO;
3769                 if (ext_attr->uio_gpio_mode != DRX_UIO_MODE_READWRITE)
3770                         return -EIO;
3771
3772                 pin_cfg_value = 0;
3773                 /* io_pad_cfg register (8 bit reg.) MSB bit is 1 (default value) */
3774                 pin_cfg_value |= 0x0113;
3775                 /* io_pad_cfg_mode output mode is drive always */
3776                 /* io_pad_cfg_drive is set to power 2 (23 mA) */
3777
3778                 /* write to io pad configuration register - output mode */
3779                 rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_GPIO_CFG__A, pin_cfg_value, 0);
3780                 if (rc != 0) {
3781                         pr_err("error %d\n", rc);
3782                         goto rw_error;
3783                 }
3784
3785                 /* use corresponding bit in io data output registar */
3786                 rc = drxj_dap_read_reg16(demod->my_i2c_dev_addr, SIO_PDR_UIO_OUT_HI__A, &value, 0);
3787                 if (rc != 0) {
3788                         pr_err("error %d\n", rc);
3789                         goto rw_error;
3790                 }
3791                 if (!uio_data->value)
3792                         value &= 0xFFFB;        /* write zero to 2nd bit - 3rd UIO */
3793                 else
3794                         value |= 0x0004;        /* write one to 2nd bit - 3rd UIO */
3795
3796                 /* write back to io data output register */
3797                 rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_UIO_OUT_HI__A, value, 0);
3798                 if (rc != 0) {
3799                         pr_err("error %d\n", rc);
3800                         goto rw_error;
3801                 }
3802                 break;
3803    /*=====================================================================*/
3804         case DRX_UIO4:
3805                 /* DRX_UIO4: IRQN UIO-4 */
3806                 if (!ext_attr->has_irqn)
3807                         return -EIO;
3808
3809                 if (ext_attr->uio_irqn_mode != DRX_UIO_MODE_READWRITE)
3810                         return -EIO;
3811
3812                 pin_cfg_value = 0;
3813                 /* io_pad_cfg register (8 bit reg.) MSB bit is 1 (default value) */
3814                 pin_cfg_value |= 0x0113;
3815                 /* io_pad_cfg_mode output mode is drive always */
3816                 /* io_pad_cfg_drive is set to power 2 (23 mA) */
3817
3818                 /* write to io pad configuration register - output mode */
3819                 rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_IRQN_CFG__A, pin_cfg_value, 0);
3820                 if (rc != 0) {
3821                         pr_err("error %d\n", rc);
3822                         goto rw_error;
3823                 }
3824
3825                 /* use corresponding bit in io data output registar */
3826                 rc = drxj_dap_read_reg16(demod->my_i2c_dev_addr, SIO_PDR_UIO_OUT_LO__A, &value, 0);
3827                 if (rc != 0) {
3828                         pr_err("error %d\n", rc);
3829                         goto rw_error;
3830                 }
3831                 if (uio_data->value == false)
3832                         value &= 0xEFFF;        /* write zero to 12th bit - 4th UIO */
3833                 else
3834                         value |= 0x1000;        /* write one to 12th bit - 4th UIO */
3835
3836                 /* write back to io data output register */
3837                 rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_UIO_OUT_LO__A, value, 0);
3838                 if (rc != 0) {
3839                         pr_err("error %d\n", rc);
3840                         goto rw_error;
3841                 }
3842                 break;
3843       /*=====================================================================*/
3844         default:
3845                 return -EINVAL;
3846         }                       /* switch ( uio_data->uio ) */
3847
3848         /*  Write magic word to disable pdr reg write               */
3849         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_TOP_COMM_KEY__A, 0x0000, 0);
3850         if (rc != 0) {
3851                 pr_err("error %d\n", rc);
3852                 goto rw_error;
3853         }
3854
3855         return 0;
3856 rw_error:
3857         return rc;
3858 }
3859
3860 /*---------------------------------------------------------------------------*/
3861 /* UIO Configuration Functions - end                                         */
3862 /*---------------------------------------------------------------------------*/
3863
3864 /*----------------------------------------------------------------------------*/
3865 /* I2C Bridge Functions - begin                                               */
3866 /*----------------------------------------------------------------------------*/
3867 /**
3868 * \fn int ctrl_i2c_bridge()
3869 * \brief Open or close the I2C switch to tuner.
3870 * \param demod Pointer to demodulator instance.
3871 * \param bridge_closed Pointer to bool indication if bridge is closed not.
3872 * \return int.
3873
3874 */
3875 static int
3876 ctrl_i2c_bridge(struct drx_demod_instance *demod, bool *bridge_closed)
3877 {
3878         struct drxj_hi_cmd hi_cmd;
3879         u16 result = 0;
3880
3881         /* check arguments */
3882         if (bridge_closed == NULL)
3883                 return -EINVAL;
3884
3885         hi_cmd.cmd = SIO_HI_RA_RAM_CMD_BRDCTRL;
3886         hi_cmd.param1 = SIO_HI_RA_RAM_PAR_1_PAR1_SEC_KEY;
3887         if (*bridge_closed)
3888                 hi_cmd.param2 = SIO_HI_RA_RAM_PAR_2_BRD_CFG_CLOSED;
3889         else
3890                 hi_cmd.param2 = SIO_HI_RA_RAM_PAR_2_BRD_CFG_OPEN;
3891
3892         return hi_command(demod->my_i2c_dev_addr, &hi_cmd, &result);
3893 }
3894
3895 /*----------------------------------------------------------------------------*/
3896 /* I2C Bridge Functions - end                                                 */
3897 /*----------------------------------------------------------------------------*/
3898
3899 /*----------------------------------------------------------------------------*/
3900 /* Smart antenna Functions - begin                                            */
3901 /*----------------------------------------------------------------------------*/
3902 /**
3903 * \fn int smart_ant_init()
3904 * \brief Initialize Smart Antenna.
3905 * \param pointer to struct drx_demod_instance.
3906 * \return int.
3907 *
3908 */
3909 static int smart_ant_init(struct drx_demod_instance *demod)
3910 {
3911         struct drxj_data *ext_attr = NULL;
3912         struct i2c_device_addr *dev_addr = NULL;
3913         struct drxuio_cfg uio_cfg = { DRX_UIO1, DRX_UIO_MODE_FIRMWARE_SMA };
3914         int rc;
3915         u16 data = 0;
3916
3917         dev_addr = demod->my_i2c_dev_addr;
3918         ext_attr = (struct drxj_data *) demod->my_ext_attr;
3919
3920         /*  Write magic word to enable pdr reg write               */
3921         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY, 0);
3922         if (rc != 0) {
3923                 pr_err("error %d\n", rc);
3924                 goto rw_error;
3925         }
3926         /* init smart antenna */
3927         rc = drxj_dap_read_reg16(dev_addr, SIO_SA_TX_COMMAND__A, &data, 0);
3928         if (rc != 0) {
3929                 pr_err("error %d\n", rc);
3930                 goto rw_error;
3931         }
3932         if (ext_attr->smart_ant_inverted) {
3933                 rc = drxj_dap_write_reg16(dev_addr, SIO_SA_TX_COMMAND__A, (data | SIO_SA_TX_COMMAND_TX_INVERT__M) | SIO_SA_TX_COMMAND_TX_ENABLE__M, 0);
3934                 if (rc != 0) {
3935                         pr_err("error %d\n", rc);
3936                         goto rw_error;
3937                 }
3938         } else {
3939                 rc = drxj_dap_write_reg16(dev_addr, SIO_SA_TX_COMMAND__A, (data & (~SIO_SA_TX_COMMAND_TX_INVERT__M)) | SIO_SA_TX_COMMAND_TX_ENABLE__M, 0);
3940                 if (rc != 0) {
3941                         pr_err("error %d\n", rc);
3942                         goto rw_error;
3943                 }
3944         }
3945
3946         /* config SMA_TX pin to smart antenna mode */
3947         rc = ctrl_set_uio_cfg(demod, &uio_cfg);
3948         if (rc != 0) {
3949                 pr_err("error %d\n", rc);
3950                 goto rw_error;
3951         }
3952         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_SMA_TX_CFG__A, 0x13, 0);
3953         if (rc != 0) {
3954                 pr_err("error %d\n", rc);
3955                 goto rw_error;
3956         }
3957         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_PDR_SMA_TX_GPIO_FNC__A, 0x03, 0);
3958         if (rc != 0) {
3959                 pr_err("error %d\n", rc);
3960                 goto rw_error;
3961         }
3962
3963         /*  Write magic word to disable pdr reg write               */
3964         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, SIO_TOP_COMM_KEY__A, 0x0000, 0);
3965         if (rc != 0) {
3966                 pr_err("error %d\n", rc);
3967                 goto rw_error;
3968         }
3969
3970         return 0;
3971 rw_error:
3972         return rc;
3973 }
3974
3975 static int scu_command(struct i2c_device_addr *dev_addr, struct drxjscu_cmd *cmd)
3976 {
3977         int rc;
3978         u16 cur_cmd = 0;
3979         unsigned long timeout;
3980
3981         /* Check param */
3982         if (cmd == NULL)
3983                 return -EINVAL;
3984
3985         /* Wait until SCU command interface is ready to receive command */
3986         rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_COMMAND__A, &cur_cmd, 0);
3987         if (rc != 0) {
3988                 pr_err("error %d\n", rc);
3989                 goto rw_error;
3990         }
3991         if (cur_cmd != DRX_SCU_READY)
3992                 return -EIO;
3993
3994         switch (cmd->parameter_len) {
3995         case 5:
3996                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_PARAM_4__A, *(cmd->parameter + 4), 0);
3997                 if (rc != 0) {
3998                         pr_err("error %d\n", rc);
3999                         goto rw_error;
4000                 }       /* fallthrough */
4001         case 4:
4002                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_PARAM_3__A, *(cmd->parameter + 3), 0);
4003                 if (rc != 0) {
4004                         pr_err("error %d\n", rc);
4005                         goto rw_error;
4006                 }       /* fallthrough */
4007         case 3:
4008                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_PARAM_2__A, *(cmd->parameter + 2), 0);
4009                 if (rc != 0) {
4010                         pr_err("error %d\n", rc);
4011                         goto rw_error;
4012                 }       /* fallthrough */
4013         case 2:
4014                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_PARAM_1__A, *(cmd->parameter + 1), 0);
4015                 if (rc != 0) {
4016                         pr_err("error %d\n", rc);
4017                         goto rw_error;
4018                 }       /* fallthrough */
4019         case 1:
4020                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_PARAM_0__A, *(cmd->parameter + 0), 0);
4021                 if (rc != 0) {
4022                         pr_err("error %d\n", rc);
4023                         goto rw_error;
4024                 }       /* fallthrough */
4025         case 0:
4026                 /* do nothing */
4027                 break;
4028         default:
4029                 /* this number of parameters is not supported */
4030                 return -EIO;
4031         }
4032         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_COMMAND__A, cmd->command, 0);
4033         if (rc != 0) {
4034                 pr_err("error %d\n", rc);
4035                 goto rw_error;
4036         }
4037
4038         /* Wait until SCU has processed command */
4039         timeout = jiffies + msecs_to_jiffies(DRXJ_MAX_WAITTIME);
4040         while (time_is_after_jiffies(timeout)) {
4041                 rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_COMMAND__A, &cur_cmd, 0);
4042                 if (rc != 0) {
4043                         pr_err("error %d\n", rc);
4044                         goto rw_error;
4045                 }
4046                 if (cur_cmd == DRX_SCU_READY)
4047                         break;
4048                 usleep_range(1000, 2000);
4049         }
4050
4051         if (cur_cmd != DRX_SCU_READY)
4052                 return -EIO;
4053
4054         /* read results */
4055         if ((cmd->result_len > 0) && (cmd->result != NULL)) {
4056                 s16 err;
4057
4058                 switch (cmd->result_len) {
4059                 case 4:
4060                         rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_PARAM_3__A, cmd->result + 3, 0);
4061                         if (rc != 0) {
4062                                 pr_err("error %d\n", rc);
4063                                 goto rw_error;
4064                         }       /* fallthrough */
4065                 case 3:
4066                         rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_PARAM_2__A, cmd->result + 2, 0);
4067                         if (rc != 0) {
4068                                 pr_err("error %d\n", rc);
4069                                 goto rw_error;
4070                         }       /* fallthrough */
4071                 case 2:
4072                         rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_PARAM_1__A, cmd->result + 1, 0);
4073                         if (rc != 0) {
4074                                 pr_err("error %d\n", rc);
4075                                 goto rw_error;
4076                         }       /* fallthrough */
4077                 case 1:
4078                         rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_PARAM_0__A, cmd->result + 0, 0);
4079                         if (rc != 0) {
4080                                 pr_err("error %d\n", rc);
4081                                 goto rw_error;
4082                         }       /* fallthrough */
4083                 case 0:
4084                         /* do nothing */
4085                         break;
4086                 default:
4087                         /* this number of parameters is not supported */
4088                         return -EIO;
4089                 }
4090
4091                 /* Check if an error was reported by SCU */
4092                 err = cmd->result[0];
4093
4094                 /* check a few fixed error codes */
4095                 if ((err == (s16) SCU_RAM_PARAM_0_RESULT_UNKSTD)
4096                     || (err == (s16) SCU_RAM_PARAM_0_RESULT_UNKCMD)
4097                     || (err == (s16) SCU_RAM_PARAM_0_RESULT_INVPAR)
4098                     || (err == (s16) SCU_RAM_PARAM_0_RESULT_SIZE)
4099                     ) {
4100                         return -EINVAL;
4101                 }
4102                 /* here it is assumed that negative means error, and positive no error */
4103                 else if (err < 0)
4104                         return -EIO;
4105                 else
4106                         return 0;
4107         }
4108
4109         return 0;
4110
4111 rw_error:
4112         return rc;
4113 }
4114
4115 /**
4116 * \fn int DRXJ_DAP_SCUAtomicReadWriteBlock()
4117 * \brief Basic access routine for SCU atomic read or write access
4118 * \param dev_addr  pointer to i2c dev address
4119 * \param addr     destination/source address
4120 * \param datasize size of data buffer in bytes
4121 * \param data     pointer to data buffer
4122 * \return int
4123 * \retval 0 Succes
4124 * \retval -EIO Timeout, I2C error, illegal bank
4125 *
4126 */
4127 #define ADDR_AT_SCU_SPACE(x) ((x - 0x82E000) * 2)
4128 static
4129 int drxj_dap_scu_atomic_read_write_block(struct i2c_device_addr *dev_addr, u32 addr, u16 datasize,      /* max 30 bytes because the limit of SCU parameter */
4130                                               u8 *data, bool read_flag)
4131 {
4132         struct drxjscu_cmd scu_cmd;
4133         int rc;
4134         u16 set_param_parameters[18];
4135         u16 cmd_result[15];
4136
4137         /* Parameter check */
4138         if (!data || !dev_addr || (datasize % 2) || ((datasize / 2) > 16))
4139                 return -EINVAL;
4140
4141         set_param_parameters[1] = (u16) ADDR_AT_SCU_SPACE(addr);
4142         if (read_flag) {                /* read */
4143                 set_param_parameters[0] = ((~(0x0080)) & datasize);
4144                 scu_cmd.parameter_len = 2;
4145                 scu_cmd.result_len = datasize / 2 + 2;
4146         } else {
4147                 int i = 0;
4148
4149                 set_param_parameters[0] = 0x0080 | datasize;
4150                 for (i = 0; i < (datasize / 2); i++) {
4151                         set_param_parameters[i + 2] =
4152                             (data[2 * i] | (data[(2 * i) + 1] << 8));
4153                 }
4154                 scu_cmd.parameter_len = datasize / 2 + 2;
4155                 scu_cmd.result_len = 1;
4156         }
4157
4158         scu_cmd.command =
4159             SCU_RAM_COMMAND_STANDARD_TOP |
4160             SCU_RAM_COMMAND_CMD_AUX_SCU_ATOMIC_ACCESS;
4161         scu_cmd.result = cmd_result;
4162         scu_cmd.parameter = set_param_parameters;
4163         rc = scu_command(dev_addr, &scu_cmd);
4164         if (rc != 0) {
4165                 pr_err("error %d\n", rc);
4166                 goto rw_error;
4167         }
4168
4169         if (read_flag) {
4170                 int i = 0;
4171                 /* read data from buffer */
4172                 for (i = 0; i < (datasize / 2); i++) {
4173                         data[2 * i] = (u8) (scu_cmd.result[i + 2] & 0xFF);
4174                         data[(2 * i) + 1] = (u8) (scu_cmd.result[i + 2] >> 8);
4175                 }
4176         }
4177
4178         return 0;
4179
4180 rw_error:
4181         return rc;
4182
4183 }
4184
4185 /*============================================================================*/
4186
4187 /**
4188 * \fn int DRXJ_DAP_AtomicReadReg16()
4189 * \brief Atomic read of 16 bits words
4190 */
4191 static
4192 int drxj_dap_scu_atomic_read_reg16(struct i2c_device_addr *dev_addr,
4193                                          u32 addr,
4194                                          u16 *data, u32 flags)
4195 {
4196         u8 buf[2] = { 0 };
4197         int rc = -EIO;
4198         u16 word = 0;
4199
4200         if (!data)
4201                 return -EINVAL;
4202
4203         rc = drxj_dap_scu_atomic_read_write_block(dev_addr, addr, 2, buf, true);
4204         if (rc < 0)
4205                 return rc;
4206
4207         word = (u16) (buf[0] + (buf[1] << 8));
4208
4209         *data = word;
4210
4211         return rc;
4212 }
4213
4214 /*============================================================================*/
4215 /**
4216 * \fn int drxj_dap_scu_atomic_write_reg16()
4217 * \brief Atomic read of 16 bits words
4218 */
4219 static
4220 int drxj_dap_scu_atomic_write_reg16(struct i2c_device_addr *dev_addr,
4221                                           u32 addr,
4222                                           u16 data, u32 flags)
4223 {
4224         u8 buf[2];
4225         int rc = -EIO;
4226
4227         buf[0] = (u8) (data & 0xff);
4228         buf[1] = (u8) ((data >> 8) & 0xff);
4229
4230         rc = drxj_dap_scu_atomic_read_write_block(dev_addr, addr, 2, buf, false);
4231
4232         return rc;
4233 }
4234
4235 /* -------------------------------------------------------------------------- */
4236 /**
4237 * \brief Measure result of ADC synchronisation
4238 * \param demod demod instance
4239 * \param count (returned) count
4240 * \return int.
4241 * \retval 0    Success
4242 * \retval -EIO Failure: I2C error
4243 *
4244 */
4245 static int adc_sync_measurement(struct drx_demod_instance *demod, u16 *count)
4246 {
4247         struct i2c_device_addr *dev_addr = NULL;
4248         int rc;
4249         u16 data = 0;
4250
4251         dev_addr = demod->my_i2c_dev_addr;
4252
4253         /* Start measurement */
4254         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_COMM_EXEC__A, IQM_AF_COMM_EXEC_ACTIVE, 0);
4255         if (rc != 0) {
4256                 pr_err("error %d\n", rc);
4257                 goto rw_error;
4258         }
4259         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_START_LOCK__A, 1, 0);
4260         if (rc != 0) {
4261                 pr_err("error %d\n", rc);
4262                 goto rw_error;
4263         }
4264
4265         /* Wait at least 3*128*(1/sysclk) <<< 1 millisec */
4266         msleep(1);
4267
4268         *count = 0;
4269         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_PHASE0__A, &data, 0);
4270         if (rc != 0) {
4271                 pr_err("error %d\n", rc);
4272                 goto rw_error;
4273         }
4274         if (data == 127)
4275                 *count = *count + 1;
4276         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_PHASE1__A, &data, 0);
4277         if (rc != 0) {
4278                 pr_err("error %d\n", rc);
4279                 goto rw_error;
4280         }
4281         if (data == 127)
4282                 *count = *count + 1;
4283         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_PHASE2__A, &data, 0);
4284         if (rc != 0) {
4285                 pr_err("error %d\n", rc);
4286                 goto rw_error;
4287         }
4288         if (data == 127)
4289                 *count = *count + 1;
4290
4291         return 0;
4292 rw_error:
4293         return rc;
4294 }
4295
4296 /**
4297 * \brief Synchronize analog and digital clock domains
4298 * \param demod demod instance
4299 * \return int.
4300 * \retval 0    Success
4301 * \retval -EIO Failure: I2C error or failure to synchronize
4302 *
4303 * An IQM reset will also reset the results of this synchronization.
4304 * After an IQM reset this routine needs to be called again.
4305 *
4306 */
4307
4308 static int adc_synchronization(struct drx_demod_instance *demod)
4309 {
4310         struct i2c_device_addr *dev_addr = NULL;
4311         int rc;
4312         u16 count = 0;
4313
4314         dev_addr = demod->my_i2c_dev_addr;
4315
4316         rc = adc_sync_measurement(demod, &count);
4317         if (rc != 0) {
4318                 pr_err("error %d\n", rc);
4319                 goto rw_error;
4320         }
4321
4322         if (count == 1) {
4323                 /* Try sampling on a different edge */
4324                 u16 clk_neg = 0;
4325
4326                 rc = drxj_dap_read_reg16(dev_addr, IQM_AF_CLKNEG__A, &clk_neg, 0);
4327                 if (rc != 0) {
4328                         pr_err("error %d\n", rc);
4329                         goto rw_error;
4330                 }
4331
4332                 clk_neg ^= IQM_AF_CLKNEG_CLKNEGDATA__M;
4333                 rc = drxj_dap_write_reg16(dev_addr, IQM_AF_CLKNEG__A, clk_neg, 0);
4334                 if (rc != 0) {
4335                         pr_err("error %d\n", rc);
4336                         goto rw_error;
4337                 }
4338
4339                 rc = adc_sync_measurement(demod, &count);
4340                 if (rc != 0) {
4341                         pr_err("error %d\n", rc);
4342                         goto rw_error;
4343                 }
4344         }
4345
4346         /* TODO: implement fallback scenarios */
4347         if (count < 2)
4348                 return -EIO;
4349
4350         return 0;
4351 rw_error:
4352         return rc;
4353 }
4354
4355 /*============================================================================*/
4356 /*==                      END AUXILIARY FUNCTIONS                           ==*/
4357 /*============================================================================*/
4358
4359 /*============================================================================*/
4360 /*============================================================================*/
4361 /*==                8VSB & QAM COMMON DATAPATH FUNCTIONS                    ==*/
4362 /*============================================================================*/
4363 /*============================================================================*/
4364 /**
4365 * \fn int init_agc ()
4366 * \brief Initialize AGC for all standards.
4367 * \param demod instance of demodulator.
4368 * \param channel pointer to channel data.
4369 * \return int.
4370 */
4371 static int init_agc(struct drx_demod_instance *demod)
4372 {
4373         struct i2c_device_addr *dev_addr = NULL;
4374         struct drx_common_attr *common_attr = NULL;
4375         struct drxj_data *ext_attr = NULL;
4376         struct drxj_cfg_agc *p_agc_rf_settings = NULL;
4377         struct drxj_cfg_agc *p_agc_if_settings = NULL;
4378         int rc;
4379         u16 ingain_tgt_max = 0;
4380         u16 clp_dir_to = 0;
4381         u16 sns_sum_max = 0;
4382         u16 clp_sum_max = 0;
4383         u16 sns_dir_to = 0;
4384         u16 ki_innergain_min = 0;
4385         u16 agc_ki = 0;
4386         u16 ki_max = 0;
4387         u16 if_iaccu_hi_tgt_min = 0;
4388         u16 data = 0;
4389         u16 agc_ki_dgain = 0;
4390         u16 ki_min = 0;
4391         u16 clp_ctrl_mode = 0;
4392         u16 agc_rf = 0;
4393         u16 agc_if = 0;
4394
4395         dev_addr = demod->my_i2c_dev_addr;
4396         common_attr = (struct drx_common_attr *) demod->my_common_attr;
4397         ext_attr = (struct drxj_data *) demod->my_ext_attr;
4398
4399         switch (ext_attr->standard) {
4400         case DRX_STANDARD_8VSB:
4401                 clp_sum_max = 1023;
4402                 clp_dir_to = (u16) (-9);
4403                 sns_sum_max = 1023;
4404                 sns_dir_to = (u16) (-9);
4405                 ki_innergain_min = (u16) (-32768);
4406                 ki_max = 0x032C;
4407                 agc_ki_dgain = 0xC;
4408                 if_iaccu_hi_tgt_min = 2047;
4409                 ki_min = 0x0117;
4410                 ingain_tgt_max = 16383;
4411                 clp_ctrl_mode = 0;
4412                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI_MINGAIN__A, 0x7fff, 0);
4413                 if (rc != 0) {
4414                         pr_err("error %d\n", rc);
4415                         goto rw_error;
4416                 }
4417                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI_MAXGAIN__A, 0x0, 0);
4418                 if (rc != 0) {
4419                         pr_err("error %d\n", rc);
4420                         goto rw_error;
4421                 }
4422                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_SUM__A, 0, 0);
4423                 if (rc != 0) {
4424                         pr_err("error %d\n", rc);
4425                         goto rw_error;
4426                 }
4427                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_CYCCNT__A, 0, 0);
4428                 if (rc != 0) {
4429                         pr_err("error %d\n", rc);
4430                         goto rw_error;
4431                 }
4432                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_DIR_WD__A, 0, 0);
4433                 if (rc != 0) {
4434                         pr_err("error %d\n", rc);
4435                         goto rw_error;
4436                 }
4437                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_DIR_STP__A, 1, 0);
4438                 if (rc != 0) {
4439                         pr_err("error %d\n", rc);
4440                         goto rw_error;
4441                 }
4442                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_SUM__A, 0, 0);
4443                 if (rc != 0) {
4444                         pr_err("error %d\n", rc);
4445                         goto rw_error;
4446                 }
4447                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_CYCCNT__A, 0, 0);
4448                 if (rc != 0) {
4449                         pr_err("error %d\n", rc);
4450                         goto rw_error;
4451                 }
4452                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_DIR_WD__A, 0, 0);
4453                 if (rc != 0) {
4454                         pr_err("error %d\n", rc);
4455                         goto rw_error;
4456                 }
4457                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_DIR_STP__A, 1, 0);
4458                 if (rc != 0) {
4459                         pr_err("error %d\n", rc);
4460                         goto rw_error;
4461                 }
4462                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_INGAIN__A, 1024, 0);
4463                 if (rc != 0) {
4464                         pr_err("error %d\n", rc);
4465                         goto rw_error;
4466                 }
4467                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_VSB_AGC_POW_TGT__A, 22600, 0);
4468                 if (rc != 0) {
4469                         pr_err("error %d\n", rc);
4470                         goto rw_error;
4471                 }
4472                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_INGAIN_TGT__A, 13200, 0);
4473                 if (rc != 0) {
4474                         pr_err("error %d\n", rc);
4475                         goto rw_error;
4476                 }
4477                 p_agc_if_settings = &(ext_attr->vsb_if_agc_cfg);
4478                 p_agc_rf_settings = &(ext_attr->vsb_rf_agc_cfg);
4479                 break;
4480 #ifndef DRXJ_VSB_ONLY
4481         case DRX_STANDARD_ITU_A:
4482         case DRX_STANDARD_ITU_C:
4483         case DRX_STANDARD_ITU_B:
4484                 ingain_tgt_max = 5119;
4485                 clp_sum_max = 1023;
4486                 clp_dir_to = (u16) (-5);
4487                 sns_sum_max = 127;
4488                 sns_dir_to = (u16) (-3);
4489                 ki_innergain_min = 0;
4490                 ki_max = 0x0657;
4491                 if_iaccu_hi_tgt_min = 2047;
4492                 agc_ki_dgain = 0x7;
4493                 ki_min = 0x0117;
4494                 clp_ctrl_mode = 0;
4495                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI_MINGAIN__A, 0x7fff, 0);
4496                 if (rc != 0) {
4497                         pr_err("error %d\n", rc);
4498                         goto rw_error;
4499                 }
4500                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI_MAXGAIN__A, 0x0, 0);
4501                 if (rc != 0) {
4502                         pr_err("error %d\n", rc);
4503                         goto rw_error;
4504                 }
4505                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_SUM__A, 0, 0);
4506                 if (rc != 0) {
4507                         pr_err("error %d\n", rc);
4508                         goto rw_error;
4509                 }
4510                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_CYCCNT__A, 0, 0);
4511                 if (rc != 0) {
4512                         pr_err("error %d\n", rc);
4513                         goto rw_error;
4514                 }
4515                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_DIR_WD__A, 0, 0);
4516                 if (rc != 0) {
4517                         pr_err("error %d\n", rc);
4518                         goto rw_error;
4519                 }
4520                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_DIR_STP__A, 1, 0);
4521                 if (rc != 0) {
4522                         pr_err("error %d\n", rc);
4523                         goto rw_error;
4524                 }
4525                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_SUM__A, 0, 0);
4526                 if (rc != 0) {
4527                         pr_err("error %d\n", rc);
4528                         goto rw_error;
4529                 }
4530                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_CYCCNT__A, 0, 0);
4531                 if (rc != 0) {
4532                         pr_err("error %d\n", rc);
4533                         goto rw_error;
4534                 }
4535                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_DIR_WD__A, 0, 0);
4536                 if (rc != 0) {
4537                         pr_err("error %d\n", rc);
4538                         goto rw_error;
4539                 }
4540                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_DIR_STP__A, 1, 0);
4541                 if (rc != 0) {
4542                         pr_err("error %d\n", rc);
4543                         goto rw_error;
4544                 }
4545                 p_agc_if_settings = &(ext_attr->qam_if_agc_cfg);
4546                 p_agc_rf_settings = &(ext_attr->qam_rf_agc_cfg);
4547                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_INGAIN_TGT__A, p_agc_if_settings->top, 0);
4548                 if (rc != 0) {
4549                         pr_err("error %d\n", rc);
4550                         goto rw_error;
4551                 }
4552
4553                 rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_AGC_KI__A, &agc_ki, 0);
4554                 if (rc != 0) {
4555                         pr_err("error %d\n", rc);
4556                         goto rw_error;
4557                 }
4558                 agc_ki &= 0xf000;
4559                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI__A, agc_ki, 0);
4560                 if (rc != 0) {
4561                         pr_err("error %d\n", rc);
4562                         goto rw_error;
4563                 }
4564                 break;
4565 #endif
4566         default:
4567                 return -EINVAL;
4568         }
4569
4570         /* for new AGC interface */
4571         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_INGAIN_TGT_MIN__A, p_agc_if_settings->top, 0);
4572         if (rc != 0) {
4573                 pr_err("error %d\n", rc);
4574                 goto rw_error;
4575         }
4576         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_INGAIN__A, p_agc_if_settings->top, 0);
4577         if (rc != 0) {
4578                 pr_err("error %d\n", rc);
4579                 goto rw_error;
4580         }       /* Gain fed from inner to outer AGC */
4581         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_INGAIN_TGT_MAX__A, ingain_tgt_max, 0);
4582         if (rc != 0) {
4583                 pr_err("error %d\n", rc);
4584                 goto rw_error;
4585         }
4586         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_IF_IACCU_HI_TGT_MIN__A, if_iaccu_hi_tgt_min, 0);
4587         if (rc != 0) {
4588                 pr_err("error %d\n", rc);
4589                 goto rw_error;
4590         }
4591         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_IF_IACCU_HI__A, 0, 0);
4592         if (rc != 0) {
4593                 pr_err("error %d\n", rc);
4594                 goto rw_error;
4595         }       /* set to p_agc_settings->top before */
4596         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_IF_IACCU_LO__A, 0, 0);
4597         if (rc != 0) {
4598                 pr_err("error %d\n", rc);
4599                 goto rw_error;
4600         }
4601         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_RF_IACCU_HI__A, 0, 0);
4602         if (rc != 0) {
4603                 pr_err("error %d\n", rc);
4604                 goto rw_error;
4605         }
4606         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_RF_IACCU_LO__A, 0, 0);
4607         if (rc != 0) {
4608                 pr_err("error %d\n", rc);
4609                 goto rw_error;
4610         }
4611         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_RF_MAX__A, 32767, 0);
4612         if (rc != 0) {
4613                 pr_err("error %d\n", rc);
4614                 goto rw_error;
4615         }
4616         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_SUM_MAX__A, clp_sum_max, 0);
4617         if (rc != 0) {
4618                 pr_err("error %d\n", rc);
4619                 goto rw_error;
4620         }
4621         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_SUM_MAX__A, sns_sum_max, 0);
4622         if (rc != 0) {
4623                 pr_err("error %d\n", rc);
4624                 goto rw_error;
4625         }
4626         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI_INNERGAIN_MIN__A, ki_innergain_min, 0);
4627         if (rc != 0) {
4628                 pr_err("error %d\n", rc);
4629                 goto rw_error;
4630         }
4631         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_FAST_SNS_CTRL_DELAY__A, 50, 0);
4632         if (rc != 0) {
4633                 pr_err("error %d\n", rc);
4634                 goto rw_error;
4635         }
4636         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI_CYCLEN__A, 500, 0);
4637         if (rc != 0) {
4638                 pr_err("error %d\n", rc);
4639                 goto rw_error;
4640         }
4641         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_CYCLEN__A, 500, 0);
4642         if (rc != 0) {
4643                 pr_err("error %d\n", rc);
4644                 goto rw_error;
4645         }
4646         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI_MAXMINGAIN_TH__A, 20, 0);
4647         if (rc != 0) {
4648                 pr_err("error %d\n", rc);
4649                 goto rw_error;
4650         }
4651         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI_MIN__A, ki_min, 0);
4652         if (rc != 0) {
4653                 pr_err("error %d\n", rc);
4654                 goto rw_error;
4655         }
4656         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI_MAX__A, ki_max, 0);
4657         if (rc != 0) {
4658                 pr_err("error %d\n", rc);
4659                 goto rw_error;
4660         }
4661         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI_RED__A, 0, 0);
4662         if (rc != 0) {
4663                 pr_err("error %d\n", rc);
4664                 goto rw_error;
4665         }
4666         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_SUM_MIN__A, 8, 0);
4667         if (rc != 0) {
4668                 pr_err("error %d\n", rc);
4669                 goto rw_error;
4670         }
4671         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_CYCLEN__A, 500, 0);
4672         if (rc != 0) {
4673                 pr_err("error %d\n", rc);
4674                 goto rw_error;
4675         }
4676         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_DIR_TO__A, clp_dir_to, 0);
4677         if (rc != 0) {
4678                 pr_err("error %d\n", rc);
4679                 goto rw_error;
4680         }
4681         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_SUM_MIN__A, 8, 0);
4682         if (rc != 0) {
4683                 pr_err("error %d\n", rc);
4684                 goto rw_error;
4685         }
4686         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_SNS_DIR_TO__A, sns_dir_to, 0);
4687         if (rc != 0) {
4688                 pr_err("error %d\n", rc);
4689                 goto rw_error;
4690         }
4691         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_FAST_CLP_CTRL_DELAY__A, 50, 0);
4692         if (rc != 0) {
4693                 pr_err("error %d\n", rc);
4694                 goto rw_error;
4695         }
4696         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_CLP_CTRL_MODE__A, clp_ctrl_mode, 0);
4697         if (rc != 0) {
4698                 pr_err("error %d\n", rc);
4699                 goto rw_error;
4700         }
4701
4702         agc_rf = 0x800 + p_agc_rf_settings->cut_off_current;
4703         if (common_attr->tuner_rf_agc_pol == true)
4704                 agc_rf = 0x87ff - agc_rf;
4705
4706         agc_if = 0x800;
4707         if (common_attr->tuner_if_agc_pol == true)
4708                 agc_rf = 0x87ff - agc_rf;
4709
4710         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_AGC_RF__A, agc_rf, 0);
4711         if (rc != 0) {
4712                 pr_err("error %d\n", rc);
4713                 goto rw_error;
4714         }
4715         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_AGC_IF__A, agc_if, 0);
4716         if (rc != 0) {
4717                 pr_err("error %d\n", rc);
4718                 goto rw_error;
4719         }
4720
4721         /* Set/restore Ki DGAIN factor */
4722         rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_AGC_KI__A, &data, 0);
4723         if (rc != 0) {
4724                 pr_err("error %d\n", rc);
4725                 goto rw_error;
4726         }
4727         data &= ~SCU_RAM_AGC_KI_DGAIN__M;
4728         data |= (agc_ki_dgain << SCU_RAM_AGC_KI_DGAIN__B);
4729         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_AGC_KI__A, data, 0);
4730         if (rc != 0) {
4731                 pr_err("error %d\n", rc);
4732                 goto rw_error;
4733         }
4734
4735         return 0;
4736 rw_error:
4737         return rc;
4738 }
4739
4740 /**
4741 * \fn int set_frequency ()
4742 * \brief Set frequency shift.
4743 * \param demod instance of demodulator.
4744 * \param channel pointer to channel data.
4745 * \param tuner_freq_offset residual frequency from tuner.
4746 * \return int.
4747 */
4748 static int
4749 set_frequency(struct drx_demod_instance *demod,
4750               struct drx_channel *channel, s32 tuner_freq_offset)
4751 {
4752         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
4753         struct drxj_data *ext_attr = demod->my_ext_attr;
4754         int rc;
4755         s32 sampling_frequency = 0;
4756         s32 frequency_shift = 0;
4757         s32 if_freq_actual = 0;
4758         s32 rf_freq_residual = -1 * tuner_freq_offset;
4759         s32 adc_freq = 0;
4760         s32 intermediate_freq = 0;
4761         u32 iqm_fs_rate_ofs = 0;
4762         bool adc_flip = true;
4763         bool select_pos_image = false;
4764         bool rf_mirror;
4765         bool tuner_mirror;
4766         bool image_to_select = true;
4767         s32 fm_frequency_shift = 0;
4768
4769         rf_mirror = (ext_attr->mirror == DRX_MIRROR_YES) ? true : false;
4770         tuner_mirror = demod->my_common_attr->mirror_freq_spect ? false : true;
4771         /*
4772            Program frequency shifter
4773            No need to account for mirroring on RF
4774          */
4775         switch (ext_attr->standard) {
4776         case DRX_STANDARD_ITU_A:        /* fallthrough */
4777         case DRX_STANDARD_ITU_C:        /* fallthrough */
4778         case DRX_STANDARD_PAL_SECAM_LP: /* fallthrough */
4779         case DRX_STANDARD_8VSB:
4780                 select_pos_image = true;
4781                 break;
4782         case DRX_STANDARD_FM:
4783                 /* After IQM FS sound carrier must appear at 4 Mhz in spect.
4784                    Sound carrier is already 3Mhz above centre frequency due
4785                    to tuner setting so now add an extra shift of 1MHz... */
4786                 fm_frequency_shift = 1000;
4787         case DRX_STANDARD_ITU_B:        /* fallthrough */
4788         case DRX_STANDARD_NTSC: /* fallthrough */
4789         case DRX_STANDARD_PAL_SECAM_BG: /* fallthrough */
4790         case DRX_STANDARD_PAL_SECAM_DK: /* fallthrough */
4791         case DRX_STANDARD_PAL_SECAM_I:  /* fallthrough */
4792         case DRX_STANDARD_PAL_SECAM_L:
4793                 select_pos_image = false;
4794                 break;
4795         default:
4796                 return -EINVAL;
4797         }
4798         intermediate_freq = demod->my_common_attr->intermediate_freq;
4799         sampling_frequency = demod->my_common_attr->sys_clock_freq / 3;
4800         if (tuner_mirror)
4801                 if_freq_actual = intermediate_freq + rf_freq_residual + fm_frequency_shift;
4802         else
4803                 if_freq_actual = intermediate_freq - rf_freq_residual - fm_frequency_shift;
4804         if (if_freq_actual > sampling_frequency / 2) {
4805                 /* adc mirrors */
4806                 adc_freq = sampling_frequency - if_freq_actual;
4807                 adc_flip = true;
4808         } else {
4809                 /* adc doesn't mirror */
4810                 adc_freq = if_freq_actual;
4811                 adc_flip = false;
4812         }
4813
4814         frequency_shift = adc_freq;
4815         image_to_select =
4816             (bool) (rf_mirror ^ tuner_mirror ^ adc_flip ^ select_pos_image);
4817         iqm_fs_rate_ofs = frac28(frequency_shift, sampling_frequency);
4818
4819         if (image_to_select)
4820                 iqm_fs_rate_ofs = ~iqm_fs_rate_ofs + 1;
4821
4822         /* Program frequency shifter with tuner offset compensation */
4823         /* frequency_shift += tuner_freq_offset; TODO */
4824         rc = drxdap_fasi_write_reg32(dev_addr, IQM_FS_RATE_OFS_LO__A, iqm_fs_rate_ofs, 0);
4825         if (rc != 0) {
4826                 pr_err("error %d\n", rc);
4827                 goto rw_error;
4828         }
4829         ext_attr->iqm_fs_rate_ofs = iqm_fs_rate_ofs;
4830         ext_attr->pos_image = (bool) (rf_mirror ^ tuner_mirror ^ select_pos_image);
4831
4832         return 0;
4833 rw_error:
4834         return rc;
4835 }
4836
4837 /**
4838 * \fn int get_acc_pkt_err()
4839 * \brief Retrieve signal strength for VSB and QAM.
4840 * \param demod Pointer to demod instance
4841 * \param packet_err Pointer to packet error
4842 * \return int.
4843 * \retval 0 sig_strength contains valid data.
4844 * \retval -EINVAL sig_strength is NULL.
4845 * \retval -EIO Erroneous data, sig_strength contains invalid data.
4846 */
4847 #ifdef DRXJ_SIGNAL_ACCUM_ERR
4848 static int get_acc_pkt_err(struct drx_demod_instance *demod, u16 *packet_err)
4849 {
4850         int rc;
4851         static u16 pkt_err;
4852         static u16 last_pkt_err;
4853         u16 data = 0;
4854         struct drxj_data *ext_attr = NULL;
4855         struct i2c_device_addr *dev_addr = NULL;
4856
4857         ext_attr = (struct drxj_data *) demod->my_ext_attr;
4858         dev_addr = demod->my_i2c_dev_addr;
4859
4860         rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_FEC_ACCUM_PKT_FAILURES__A, &data, 0);
4861         if (rc != 0) {
4862                 pr_err("error %d\n", rc);
4863                 goto rw_error;
4864         }
4865         if (ext_attr->reset_pkt_err_acc) {
4866                 last_pkt_err = data;
4867                 pkt_err = 0;
4868                 ext_attr->reset_pkt_err_acc = false;
4869         }
4870
4871         if (data < last_pkt_err) {
4872                 pkt_err += 0xffff - last_pkt_err;
4873                 pkt_err += data;
4874         } else {
4875                 pkt_err += (data - last_pkt_err);
4876         }
4877         *packet_err = pkt_err;
4878         last_pkt_err = data;
4879
4880         return 0;
4881 rw_error:
4882         return rc;
4883 }
4884 #endif
4885
4886
4887 /*============================================================================*/
4888
4889 /**
4890 * \fn int set_agc_rf ()
4891 * \brief Configure RF AGC
4892 * \param demod instance of demodulator.
4893 * \param agc_settings AGC configuration structure
4894 * \return int.
4895 */
4896 static int
4897 set_agc_rf(struct drx_demod_instance *demod, struct drxj_cfg_agc *agc_settings, bool atomic)
4898 {
4899         struct i2c_device_addr *dev_addr = NULL;
4900         struct drxj_data *ext_attr = NULL;
4901         struct drxj_cfg_agc *p_agc_settings = NULL;
4902         struct drx_common_attr *common_attr = NULL;
4903         int rc;
4904         drx_write_reg16func_t scu_wr16 = NULL;
4905         drx_read_reg16func_t scu_rr16 = NULL;
4906
4907         common_attr = (struct drx_common_attr *) demod->my_common_attr;
4908         dev_addr = demod->my_i2c_dev_addr;
4909         ext_attr = (struct drxj_data *) demod->my_ext_attr;
4910
4911         if (atomic) {
4912                 scu_rr16 = drxj_dap_scu_atomic_read_reg16;
4913                 scu_wr16 = drxj_dap_scu_atomic_write_reg16;
4914         } else {
4915                 scu_rr16 = drxj_dap_read_reg16;
4916                 scu_wr16 = drxj_dap_write_reg16;
4917         }
4918
4919         /* Configure AGC only if standard is currently active */
4920         if ((ext_attr->standard == agc_settings->standard) ||
4921             (DRXJ_ISQAMSTD(ext_attr->standard) &&
4922              DRXJ_ISQAMSTD(agc_settings->standard)) ||
4923             (DRXJ_ISATVSTD(ext_attr->standard) &&
4924              DRXJ_ISATVSTD(agc_settings->standard))) {
4925                 u16 data = 0;
4926
4927                 switch (agc_settings->ctrl_mode) {
4928                 case DRX_AGC_CTRL_AUTO:
4929
4930                         /* Enable RF AGC DAC */
4931                         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_STDBY__A, &data, 0);
4932                         if (rc != 0) {
4933                                 pr_err("error %d\n", rc);
4934                                 goto rw_error;
4935                         }
4936                         data |= IQM_AF_STDBY_STDBY_TAGC_RF_A2_ACTIVE;
4937                         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_STDBY__A, data, 0);
4938                         if (rc != 0) {
4939                                 pr_err("error %d\n", rc);
4940                                 goto rw_error;
4941                         }
4942
4943                         /* Enable SCU RF AGC loop */
4944                         rc = (*scu_rr16)(dev_addr, SCU_RAM_AGC_KI__A, &data, 0);
4945                         if (rc != 0) {
4946                                 pr_err("error %d\n", rc);
4947                                 goto rw_error;
4948                         }
4949                         data &= ~SCU_RAM_AGC_KI_RF__M;
4950                         if (ext_attr->standard == DRX_STANDARD_8VSB)
4951                                 data |= (2 << SCU_RAM_AGC_KI_RF__B);
4952                         else if (DRXJ_ISQAMSTD(ext_attr->standard))
4953                                 data |= (5 << SCU_RAM_AGC_KI_RF__B);
4954                         else
4955                                 data |= (4 << SCU_RAM_AGC_KI_RF__B);
4956
4957                         if (common_attr->tuner_rf_agc_pol)
4958                                 data |= SCU_RAM_AGC_KI_INV_RF_POL__M;
4959                         else
4960                                 data &= ~SCU_RAM_AGC_KI_INV_RF_POL__M;
4961                         rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_KI__A, data, 0);
4962                         if (rc != 0) {
4963                                 pr_err("error %d\n", rc);
4964                                 goto rw_error;
4965                         }
4966
4967                         /* Set speed ( using complementary reduction value ) */
4968                         rc = (*scu_rr16)(dev_addr, SCU_RAM_AGC_KI_RED__A, &data, 0);
4969                         if (rc != 0) {
4970                                 pr_err("error %d\n", rc);
4971                                 goto rw_error;
4972                         }
4973                         data &= ~SCU_RAM_AGC_KI_RED_RAGC_RED__M;
4974                         rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_KI_RED__A, (~(agc_settings->speed << SCU_RAM_AGC_KI_RED_RAGC_RED__B) & SCU_RAM_AGC_KI_RED_RAGC_RED__M) | data, 0);
4975                         if (rc != 0) {
4976                                 pr_err("error %d\n", rc);
4977                                 goto rw_error;
4978                         }
4979
4980                         if (agc_settings->standard == DRX_STANDARD_8VSB)
4981                                 p_agc_settings = &(ext_attr->vsb_if_agc_cfg);
4982                         else if (DRXJ_ISQAMSTD(agc_settings->standard))
4983                                 p_agc_settings = &(ext_attr->qam_if_agc_cfg);
4984                         else if (DRXJ_ISATVSTD(agc_settings->standard))
4985                                 p_agc_settings = &(ext_attr->atv_if_agc_cfg);
4986                         else
4987                                 return -EINVAL;
4988
4989                         /* Set TOP, only if IF-AGC is in AUTO mode */
4990                         if (p_agc_settings->ctrl_mode == DRX_AGC_CTRL_AUTO) {
4991                                 rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, agc_settings->top, 0);
4992                                 if (rc != 0) {
4993                                         pr_err("error %d\n", rc);
4994                                         goto rw_error;
4995                                 }
4996                                 rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_IF_IACCU_HI_TGT__A, agc_settings->top, 0);
4997                                 if (rc != 0) {
4998                                         pr_err("error %d\n", rc);
4999                                         goto rw_error;
5000                                 }
5001                         }
5002
5003                         /* Cut-Off current */
5004                         rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_RF_IACCU_HI_CO__A, agc_settings->cut_off_current, 0);
5005                         if (rc != 0) {
5006                                 pr_err("error %d\n", rc);
5007                                 goto rw_error;
5008                         }
5009                         break;
5010                 case DRX_AGC_CTRL_USER:
5011
5012                         /* Enable RF AGC DAC */
5013                         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_STDBY__A, &data, 0);
5014                         if (rc != 0) {
5015                                 pr_err("error %d\n", rc);
5016                                 goto rw_error;
5017                         }
5018                         data |= IQM_AF_STDBY_STDBY_TAGC_RF_A2_ACTIVE;
5019                         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_STDBY__A, data, 0);
5020                         if (rc != 0) {
5021                                 pr_err("error %d\n", rc);
5022                                 goto rw_error;
5023                         }
5024
5025                         /* Disable SCU RF AGC loop */
5026                         rc = (*scu_rr16)(dev_addr, SCU_RAM_AGC_KI__A, &data, 0);
5027                         if (rc != 0) {
5028                                 pr_err("error %d\n", rc);
5029                                 goto rw_error;
5030                         }
5031                         data &= ~SCU_RAM_AGC_KI_RF__M;
5032                         if (common_attr->tuner_rf_agc_pol)
5033                                 data |= SCU_RAM_AGC_KI_INV_RF_POL__M;
5034                         else
5035                                 data &= ~SCU_RAM_AGC_KI_INV_RF_POL__M;
5036                         rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_KI__A, data, 0);
5037                         if (rc != 0) {
5038                                 pr_err("error %d\n", rc);
5039                                 goto rw_error;
5040                         }
5041
5042                         /* Write value to output pin */
5043                         rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_RF_IACCU_HI__A, agc_settings->output_level, 0);
5044                         if (rc != 0) {
5045                                 pr_err("error %d\n", rc);
5046                                 goto rw_error;
5047                         }
5048                         break;
5049                 case DRX_AGC_CTRL_OFF:
5050
5051                         /* Disable RF AGC DAC */
5052                         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_STDBY__A, &data, 0);
5053                         if (rc != 0) {
5054                                 pr_err("error %d\n", rc);
5055                                 goto rw_error;
5056                         }
5057                         data &= (~IQM_AF_STDBY_STDBY_TAGC_RF_A2_ACTIVE);
5058                         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_STDBY__A, data, 0);
5059                         if (rc != 0) {
5060                                 pr_err("error %d\n", rc);
5061                                 goto rw_error;
5062                         }
5063
5064                         /* Disable SCU RF AGC loop */
5065                         rc = (*scu_rr16)(dev_addr, SCU_RAM_AGC_KI__A, &data, 0);
5066                         if (rc != 0) {
5067                                 pr_err("error %d\n", rc);
5068                                 goto rw_error;
5069                         }
5070                         data &= ~SCU_RAM_AGC_KI_RF__M;
5071                         rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_KI__A, data, 0);
5072                         if (rc != 0) {
5073                                 pr_err("error %d\n", rc);
5074                                 goto rw_error;
5075                         }
5076                         break;
5077                 default:
5078                         return -EINVAL;
5079                 }               /* switch ( agcsettings->ctrl_mode ) */
5080         }
5081
5082         /* Store rf agc settings */
5083         switch (agc_settings->standard) {
5084         case DRX_STANDARD_8VSB:
5085                 ext_attr->vsb_rf_agc_cfg = *agc_settings;
5086                 break;
5087 #ifndef DRXJ_VSB_ONLY
5088         case DRX_STANDARD_ITU_A:
5089         case DRX_STANDARD_ITU_B:
5090         case DRX_STANDARD_ITU_C:
5091                 ext_attr->qam_rf_agc_cfg = *agc_settings;
5092                 break;
5093 #endif
5094         default:
5095                 return -EIO;
5096         }
5097
5098         return 0;
5099 rw_error:
5100         return rc;
5101 }
5102
5103 /**
5104 * \fn int set_agc_if ()
5105 * \brief Configure If AGC
5106 * \param demod instance of demodulator.
5107 * \param agc_settings AGC configuration structure
5108 * \return int.
5109 */
5110 static int
5111 set_agc_if(struct drx_demod_instance *demod, struct drxj_cfg_agc *agc_settings, bool atomic)
5112 {
5113         struct i2c_device_addr *dev_addr = NULL;
5114         struct drxj_data *ext_attr = NULL;
5115         struct drxj_cfg_agc *p_agc_settings = NULL;
5116         struct drx_common_attr *common_attr = NULL;
5117         drx_write_reg16func_t scu_wr16 = NULL;
5118         drx_read_reg16func_t scu_rr16 = NULL;
5119         int rc;
5120
5121         common_attr = (struct drx_common_attr *) demod->my_common_attr;
5122         dev_addr = demod->my_i2c_dev_addr;
5123         ext_attr = (struct drxj_data *) demod->my_ext_attr;
5124
5125         if (atomic) {
5126                 scu_rr16 = drxj_dap_scu_atomic_read_reg16;
5127                 scu_wr16 = drxj_dap_scu_atomic_write_reg16;
5128         } else {
5129                 scu_rr16 = drxj_dap_read_reg16;
5130                 scu_wr16 = drxj_dap_write_reg16;
5131         }
5132
5133         /* Configure AGC only if standard is currently active */
5134         if ((ext_attr->standard == agc_settings->standard) ||
5135             (DRXJ_ISQAMSTD(ext_attr->standard) &&
5136              DRXJ_ISQAMSTD(agc_settings->standard)) ||
5137             (DRXJ_ISATVSTD(ext_attr->standard) &&
5138              DRXJ_ISATVSTD(agc_settings->standard))) {
5139                 u16 data = 0;
5140
5141                 switch (agc_settings->ctrl_mode) {
5142                 case DRX_AGC_CTRL_AUTO:
5143                         /* Enable IF AGC DAC */
5144                         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_STDBY__A, &data, 0);
5145                         if (rc != 0) {
5146                                 pr_err("error %d\n", rc);
5147                                 goto rw_error;
5148                         }
5149                         data |= IQM_AF_STDBY_STDBY_TAGC_IF_A2_ACTIVE;
5150                         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_STDBY__A, data, 0);
5151                         if (rc != 0) {
5152                                 pr_err("error %d\n", rc);
5153                                 goto rw_error;
5154                         }
5155
5156                         /* Enable SCU IF AGC loop */
5157                         rc = (*scu_rr16)(dev_addr, SCU_RAM_AGC_KI__A, &data, 0);
5158                         if (rc != 0) {
5159                                 pr_err("error %d\n", rc);
5160                                 goto rw_error;
5161                         }
5162                         data &= ~SCU_RAM_AGC_KI_IF_AGC_DISABLE__M;
5163                         data &= ~SCU_RAM_AGC_KI_IF__M;
5164                         if (ext_attr->standard == DRX_STANDARD_8VSB)
5165                                 data |= (3 << SCU_RAM_AGC_KI_IF__B);
5166                         else if (DRXJ_ISQAMSTD(ext_attr->standard))
5167                                 data |= (6 << SCU_RAM_AGC_KI_IF__B);
5168                         else
5169                                 data |= (5 << SCU_RAM_AGC_KI_IF__B);
5170
5171                         if (common_attr->tuner_if_agc_pol)
5172                                 data |= SCU_RAM_AGC_KI_INV_IF_POL__M;
5173                         else
5174                                 data &= ~SCU_RAM_AGC_KI_INV_IF_POL__M;
5175                         rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_KI__A, data, 0);
5176                         if (rc != 0) {
5177                                 pr_err("error %d\n", rc);
5178                                 goto rw_error;
5179                         }
5180
5181                         /* Set speed (using complementary reduction value) */
5182                         rc = (*scu_rr16)(dev_addr, SCU_RAM_AGC_KI_RED__A, &data, 0);
5183                         if (rc != 0) {
5184                                 pr_err("error %d\n", rc);
5185                                 goto rw_error;
5186                         }
5187                         data &= ~SCU_RAM_AGC_KI_RED_IAGC_RED__M;
5188                         rc = (*scu_wr16) (dev_addr, SCU_RAM_AGC_KI_RED__A, (~(agc_settings->speed << SCU_RAM_AGC_KI_RED_IAGC_RED__B) & SCU_RAM_AGC_KI_RED_IAGC_RED__M) | data, 0);
5189                         if (rc != 0) {
5190                                 pr_err("error %d\n", rc);
5191                                 goto rw_error;
5192                         }
5193
5194                         if (agc_settings->standard == DRX_STANDARD_8VSB)
5195                                 p_agc_settings = &(ext_attr->vsb_rf_agc_cfg);
5196                         else if (DRXJ_ISQAMSTD(agc_settings->standard))
5197                                 p_agc_settings = &(ext_attr->qam_rf_agc_cfg);
5198                         else if (DRXJ_ISATVSTD(agc_settings->standard))
5199                                 p_agc_settings = &(ext_attr->atv_rf_agc_cfg);
5200                         else
5201                                 return -EINVAL;
5202
5203                         /* Restore TOP */
5204                         if (p_agc_settings->ctrl_mode == DRX_AGC_CTRL_AUTO) {
5205                                 rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, p_agc_settings->top, 0);
5206                                 if (rc != 0) {
5207                                         pr_err("error %d\n", rc);
5208                                         goto rw_error;
5209                                 }
5210                                 rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_IF_IACCU_HI_TGT__A, p_agc_settings->top, 0);
5211                                 if (rc != 0) {
5212                                         pr_err("error %d\n", rc);
5213                                         goto rw_error;
5214                                 }
5215                         } else {
5216                                 rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, 0, 0);
5217                                 if (rc != 0) {
5218                                         pr_err("error %d\n", rc);
5219                                         goto rw_error;
5220                                 }
5221                                 rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_IF_IACCU_HI_TGT__A, 0, 0);
5222                                 if (rc != 0) {
5223                                         pr_err("error %d\n", rc);
5224                                         goto rw_error;
5225                                 }
5226                         }
5227                         break;
5228
5229                 case DRX_AGC_CTRL_USER:
5230
5231                         /* Enable IF AGC DAC */
5232                         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_STDBY__A, &data, 0);
5233                         if (rc != 0) {
5234                                 pr_err("error %d\n", rc);
5235                                 goto rw_error;
5236                         }
5237                         data |= IQM_AF_STDBY_STDBY_TAGC_IF_A2_ACTIVE;
5238                         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_STDBY__A, data, 0);
5239                         if (rc != 0) {
5240                                 pr_err("error %d\n", rc);
5241                                 goto rw_error;
5242                         }
5243
5244                         /* Disable SCU IF AGC loop */
5245                         rc = (*scu_rr16)(dev_addr, SCU_RAM_AGC_KI__A, &data, 0);
5246                         if (rc != 0) {
5247                                 pr_err("error %d\n", rc);
5248                                 goto rw_error;
5249                         }
5250                         data &= ~SCU_RAM_AGC_KI_IF_AGC_DISABLE__M;
5251                         data |= SCU_RAM_AGC_KI_IF_AGC_DISABLE__M;
5252                         if (common_attr->tuner_if_agc_pol)
5253                                 data |= SCU_RAM_AGC_KI_INV_IF_POL__M;
5254                         else
5255                                 data &= ~SCU_RAM_AGC_KI_INV_IF_POL__M;
5256                         rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_KI__A, data, 0);
5257                         if (rc != 0) {
5258                                 pr_err("error %d\n", rc);
5259                                 goto rw_error;
5260                         }
5261
5262                         /* Write value to output pin */
5263                         rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, agc_settings->output_level, 0);
5264                         if (rc != 0) {
5265                                 pr_err("error %d\n", rc);
5266                                 goto rw_error;
5267                         }
5268                         break;
5269
5270                 case DRX_AGC_CTRL_OFF:
5271
5272                         /* Disable If AGC DAC */
5273                         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_STDBY__A, &data, 0);
5274                         if (rc != 0) {
5275                                 pr_err("error %d\n", rc);
5276                                 goto rw_error;
5277                         }
5278                         data &= (~IQM_AF_STDBY_STDBY_TAGC_IF_A2_ACTIVE);
5279                         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_STDBY__A, data, 0);
5280                         if (rc != 0) {
5281                                 pr_err("error %d\n", rc);
5282                                 goto rw_error;
5283                         }
5284
5285                         /* Disable SCU IF AGC loop */
5286                         rc = (*scu_rr16)(dev_addr, SCU_RAM_AGC_KI__A, &data, 0);
5287                         if (rc != 0) {
5288                                 pr_err("error %d\n", rc);
5289                                 goto rw_error;
5290                         }
5291                         data &= ~SCU_RAM_AGC_KI_IF_AGC_DISABLE__M;
5292                         data |= SCU_RAM_AGC_KI_IF_AGC_DISABLE__M;
5293                         rc = (*scu_wr16)(dev_addr, SCU_RAM_AGC_KI__A, data, 0);
5294                         if (rc != 0) {
5295                                 pr_err("error %d\n", rc);
5296                                 goto rw_error;
5297                         }
5298                         break;
5299                 default:
5300                         return -EINVAL;
5301                 }               /* switch ( agcsettings->ctrl_mode ) */
5302
5303                 /* always set the top to support configurations without if-loop */
5304                 rc = (*scu_wr16) (dev_addr, SCU_RAM_AGC_INGAIN_TGT_MIN__A, agc_settings->top, 0);
5305                 if (rc != 0) {
5306                         pr_err("error %d\n", rc);
5307                         goto rw_error;
5308                 }
5309         }
5310
5311         /* Store if agc settings */
5312         switch (agc_settings->standard) {
5313         case DRX_STANDARD_8VSB:
5314                 ext_attr->vsb_if_agc_cfg = *agc_settings;
5315                 break;
5316 #ifndef DRXJ_VSB_ONLY
5317         case DRX_STANDARD_ITU_A:
5318         case DRX_STANDARD_ITU_B:
5319         case DRX_STANDARD_ITU_C:
5320                 ext_attr->qam_if_agc_cfg = *agc_settings;
5321                 break;
5322 #endif
5323         default:
5324                 return -EIO;
5325         }
5326
5327         return 0;
5328 rw_error:
5329         return rc;
5330 }
5331
5332 /**
5333 * \fn int set_iqm_af ()
5334 * \brief Configure IQM AF registers
5335 * \param demod instance of demodulator.
5336 * \param active
5337 * \return int.
5338 */
5339 static int set_iqm_af(struct drx_demod_instance *demod, bool active)
5340 {
5341         u16 data = 0;
5342         struct i2c_device_addr *dev_addr = NULL;
5343         int rc;
5344
5345         dev_addr = demod->my_i2c_dev_addr;
5346
5347         /* Configure IQM */
5348         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_STDBY__A, &data, 0);
5349         if (rc != 0) {
5350                 pr_err("error %d\n", rc);
5351                 goto rw_error;
5352         }
5353         if (!active)
5354                 data &= ((~IQM_AF_STDBY_STDBY_ADC_A2_ACTIVE) & (~IQM_AF_STDBY_STDBY_AMP_A2_ACTIVE) & (~IQM_AF_STDBY_STDBY_PD_A2_ACTIVE) & (~IQM_AF_STDBY_STDBY_TAGC_IF_A2_ACTIVE) & (~IQM_AF_STDBY_STDBY_TAGC_RF_A2_ACTIVE));
5355         else
5356                 data |= (IQM_AF_STDBY_STDBY_ADC_A2_ACTIVE | IQM_AF_STDBY_STDBY_AMP_A2_ACTIVE | IQM_AF_STDBY_STDBY_PD_A2_ACTIVE | IQM_AF_STDBY_STDBY_TAGC_IF_A2_ACTIVE | IQM_AF_STDBY_STDBY_TAGC_RF_A2_ACTIVE);
5357         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_STDBY__A, data, 0);
5358         if (rc != 0) {
5359                 pr_err("error %d\n", rc);
5360                 goto rw_error;
5361         }
5362
5363         return 0;
5364 rw_error:
5365         return rc;
5366 }
5367
5368 /*============================================================================*/
5369 /*==              END 8VSB & QAM COMMON DATAPATH FUNCTIONS                  ==*/
5370 /*============================================================================*/
5371
5372 /*============================================================================*/
5373 /*============================================================================*/
5374 /*==                       8VSB DATAPATH FUNCTIONS                          ==*/
5375 /*============================================================================*/
5376 /*============================================================================*/
5377
5378 /**
5379 * \fn int power_down_vsb ()
5380 * \brief Powr down QAM related blocks.
5381 * \param demod instance of demodulator.
5382 * \param channel pointer to channel data.
5383 * \return int.
5384 */
5385 static int power_down_vsb(struct drx_demod_instance *demod, bool primary)
5386 {
5387         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
5388         struct drxjscu_cmd cmd_scu = { /* command     */ 0,
5389                 /* parameter_len */ 0,
5390                 /* result_len    */ 0,
5391                 /* *parameter   */ NULL,
5392                 /* *result      */ NULL
5393         };
5394         struct drx_cfg_mpeg_output cfg_mpeg_output;
5395         int rc;
5396         u16 cmd_result = 0;
5397
5398         /*
5399            STOP demodulator
5400            reset of FEC and VSB HW
5401          */
5402         cmd_scu.command = SCU_RAM_COMMAND_STANDARD_VSB |
5403             SCU_RAM_COMMAND_CMD_DEMOD_STOP;
5404         cmd_scu.parameter_len = 0;
5405         cmd_scu.result_len = 1;
5406         cmd_scu.parameter = NULL;
5407         cmd_scu.result = &cmd_result;
5408         rc = scu_command(dev_addr, &cmd_scu);
5409         if (rc != 0) {
5410                 pr_err("error %d\n", rc);
5411                 goto rw_error;
5412         }
5413
5414         /* stop all comm_exec */
5415         rc = drxj_dap_write_reg16(dev_addr, FEC_COMM_EXEC__A, FEC_COMM_EXEC_STOP, 0);
5416         if (rc != 0) {
5417                 pr_err("error %d\n", rc);
5418                 goto rw_error;
5419         }
5420         rc = drxj_dap_write_reg16(dev_addr, VSB_COMM_EXEC__A, VSB_COMM_EXEC_STOP, 0);
5421         if (rc != 0) {
5422                 pr_err("error %d\n", rc);
5423                 goto rw_error;
5424         }
5425         if (primary) {
5426                 rc = drxj_dap_write_reg16(dev_addr, IQM_COMM_EXEC__A, IQM_COMM_EXEC_STOP, 0);
5427                 if (rc != 0) {
5428                         pr_err("error %d\n", rc);
5429                         goto rw_error;
5430                 }
5431                 rc = set_iqm_af(demod, false);
5432                 if (rc != 0) {
5433                         pr_err("error %d\n", rc);
5434                         goto rw_error;
5435                 }
5436         } else {
5437                 rc = drxj_dap_write_reg16(dev_addr, IQM_FS_COMM_EXEC__A, IQM_FS_COMM_EXEC_STOP, 0);
5438                 if (rc != 0) {
5439                         pr_err("error %d\n", rc);
5440                         goto rw_error;
5441                 }
5442                 rc = drxj_dap_write_reg16(dev_addr, IQM_FD_COMM_EXEC__A, IQM_FD_COMM_EXEC_STOP, 0);
5443                 if (rc != 0) {
5444                         pr_err("error %d\n", rc);
5445                         goto rw_error;
5446                 }
5447                 rc = drxj_dap_write_reg16(dev_addr, IQM_RC_COMM_EXEC__A, IQM_RC_COMM_EXEC_STOP, 0);
5448                 if (rc != 0) {
5449                         pr_err("error %d\n", rc);
5450                         goto rw_error;
5451                 }
5452                 rc = drxj_dap_write_reg16(dev_addr, IQM_RT_COMM_EXEC__A, IQM_RT_COMM_EXEC_STOP, 0);
5453                 if (rc != 0) {
5454                         pr_err("error %d\n", rc);
5455                         goto rw_error;
5456                 }
5457                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_COMM_EXEC__A, IQM_CF_COMM_EXEC_STOP, 0);
5458                 if (rc != 0) {
5459                         pr_err("error %d\n", rc);
5460                         goto rw_error;
5461                 }
5462         }
5463
5464         cfg_mpeg_output.enable_mpeg_output = false;
5465         rc = ctrl_set_cfg_mpeg_output(demod, &cfg_mpeg_output);
5466         if (rc != 0) {
5467                 pr_err("error %d\n", rc);
5468                 goto rw_error;
5469         }
5470
5471         return 0;
5472 rw_error:
5473         return rc;
5474 }
5475
5476 /**
5477 * \fn int set_vsb_leak_n_gain ()
5478 * \brief Set ATSC demod.
5479 * \param demod instance of demodulator.
5480 * \return int.
5481 */
5482 static int set_vsb_leak_n_gain(struct drx_demod_instance *demod)
5483 {
5484         struct i2c_device_addr *dev_addr = NULL;
5485         int rc;
5486
5487         const u8 vsb_ffe_leak_gain_ram0[] = {
5488                 DRXJ_16TO8(0x8),        /* FFETRAINLKRATIO1  */
5489                 DRXJ_16TO8(0x8),        /* FFETRAINLKRATIO2  */
5490                 DRXJ_16TO8(0x8),        /* FFETRAINLKRATIO3  */
5491                 DRXJ_16TO8(0xf),        /* FFETRAINLKRATIO4  */
5492                 DRXJ_16TO8(0xf),        /* FFETRAINLKRATIO5  */
5493                 DRXJ_16TO8(0xf),        /* FFETRAINLKRATIO6  */
5494                 DRXJ_16TO8(0xf),        /* FFETRAINLKRATIO7  */
5495                 DRXJ_16TO8(0xf),        /* FFETRAINLKRATIO8  */
5496                 DRXJ_16TO8(0xf),        /* FFETRAINLKRATIO9  */
5497                 DRXJ_16TO8(0x8),        /* FFETRAINLKRATIO10  */
5498                 DRXJ_16TO8(0x8),        /* FFETRAINLKRATIO11 */
5499                 DRXJ_16TO8(0x8),        /* FFETRAINLKRATIO12 */
5500                 DRXJ_16TO8(0x10),       /* FFERCA1TRAINLKRATIO1 */
5501                 DRXJ_16TO8(0x10),       /* FFERCA1TRAINLKRATIO2 */
5502                 DRXJ_16TO8(0x10),       /* FFERCA1TRAINLKRATIO3 */
5503                 DRXJ_16TO8(0x20),       /* FFERCA1TRAINLKRATIO4 */
5504                 DRXJ_16TO8(0x20),       /* FFERCA1TRAINLKRATIO5 */
5505                 DRXJ_16TO8(0x20),       /* FFERCA1TRAINLKRATIO6 */
5506                 DRXJ_16TO8(0x20),       /* FFERCA1TRAINLKRATIO7 */
5507                 DRXJ_16TO8(0x20),       /* FFERCA1TRAINLKRATIO8 */
5508                 DRXJ_16TO8(0x20),       /* FFERCA1TRAINLKRATIO9 */
5509                 DRXJ_16TO8(0x10),       /* FFERCA1TRAINLKRATIO10 */
5510                 DRXJ_16TO8(0x10),       /* FFERCA1TRAINLKRATIO11 */
5511                 DRXJ_16TO8(0x10),       /* FFERCA1TRAINLKRATIO12 */
5512                 DRXJ_16TO8(0x10),       /* FFERCA1DATALKRATIO1 */
5513                 DRXJ_16TO8(0x10),       /* FFERCA1DATALKRATIO2 */
5514                 DRXJ_16TO8(0x10),       /* FFERCA1DATALKRATIO3 */
5515                 DRXJ_16TO8(0x20),       /* FFERCA1DATALKRATIO4 */
5516                 DRXJ_16TO8(0x20),       /* FFERCA1DATALKRATIO5 */
5517                 DRXJ_16TO8(0x20),       /* FFERCA1DATALKRATIO6 */
5518                 DRXJ_16TO8(0x20),       /* FFERCA1DATALKRATIO7 */
5519                 DRXJ_16TO8(0x20),       /* FFERCA1DATALKRATIO8 */
5520                 DRXJ_16TO8(0x20),       /* FFERCA1DATALKRATIO9 */
5521                 DRXJ_16TO8(0x10),       /* FFERCA1DATALKRATIO10 */
5522                 DRXJ_16TO8(0x10),       /* FFERCA1DATALKRATIO11 */
5523                 DRXJ_16TO8(0x10),       /* FFERCA1DATALKRATIO12 */
5524                 DRXJ_16TO8(0x10),       /* FFERCA2TRAINLKRATIO1 */
5525                 DRXJ_16TO8(0x10),       /* FFERCA2TRAINLKRATIO2 */
5526                 DRXJ_16TO8(0x10),       /* FFERCA2TRAINLKRATIO3 */
5527                 DRXJ_16TO8(0x20),       /* FFERCA2TRAINLKRATIO4 */
5528                 DRXJ_16TO8(0x20),       /* FFERCA2TRAINLKRATIO5 */
5529                 DRXJ_16TO8(0x20),       /* FFERCA2TRAINLKRATIO6 */
5530                 DRXJ_16TO8(0x20),       /* FFERCA2TRAINLKRATIO7 */
5531                 DRXJ_16TO8(0x20),       /* FFERCA2TRAINLKRATIO8 */
5532                 DRXJ_16TO8(0x20),       /* FFERCA2TRAINLKRATIO9 */
5533                 DRXJ_16TO8(0x10),       /* FFERCA2TRAINLKRATIO10 */
5534                 DRXJ_16TO8(0x10),       /* FFERCA2TRAINLKRATIO11 */
5535                 DRXJ_16TO8(0x10),       /* FFERCA2TRAINLKRATIO12 */
5536                 DRXJ_16TO8(0x10),       /* FFERCA2DATALKRATIO1 */
5537                 DRXJ_16TO8(0x10),       /* FFERCA2DATALKRATIO2 */
5538                 DRXJ_16TO8(0x10),       /* FFERCA2DATALKRATIO3 */
5539                 DRXJ_16TO8(0x20),       /* FFERCA2DATALKRATIO4 */
5540                 DRXJ_16TO8(0x20),       /* FFERCA2DATALKRATIO5 */
5541                 DRXJ_16TO8(0x20),       /* FFERCA2DATALKRATIO6 */
5542                 DRXJ_16TO8(0x20),       /* FFERCA2DATALKRATIO7 */
5543                 DRXJ_16TO8(0x20),       /* FFERCA2DATALKRATIO8 */
5544                 DRXJ_16TO8(0x20),       /* FFERCA2DATALKRATIO9 */
5545                 DRXJ_16TO8(0x10),       /* FFERCA2DATALKRATIO10 */
5546                 DRXJ_16TO8(0x10),       /* FFERCA2DATALKRATIO11 */
5547                 DRXJ_16TO8(0x10),       /* FFERCA2DATALKRATIO12 */
5548                 DRXJ_16TO8(0x07),       /* FFEDDM1TRAINLKRATIO1 */
5549                 DRXJ_16TO8(0x07),       /* FFEDDM1TRAINLKRATIO2 */
5550                 DRXJ_16TO8(0x07),       /* FFEDDM1TRAINLKRATIO3 */
5551                 DRXJ_16TO8(0x0e),       /* FFEDDM1TRAINLKRATIO4 */
5552                 DRXJ_16TO8(0x0e),       /* FFEDDM1TRAINLKRATIO5 */
5553                 DRXJ_16TO8(0x0e),       /* FFEDDM1TRAINLKRATIO6 */
5554                 DRXJ_16TO8(0x0e),       /* FFEDDM1TRAINLKRATIO7 */
5555                 DRXJ_16TO8(0x0e),       /* FFEDDM1TRAINLKRATIO8 */
5556                 DRXJ_16TO8(0x0e),       /* FFEDDM1TRAINLKRATIO9 */
5557                 DRXJ_16TO8(0x07),       /* FFEDDM1TRAINLKRATIO10 */
5558                 DRXJ_16TO8(0x07),       /* FFEDDM1TRAINLKRATIO11 */
5559                 DRXJ_16TO8(0x07),       /* FFEDDM1TRAINLKRATIO12 */
5560                 DRXJ_16TO8(0x07),       /* FFEDDM1DATALKRATIO1 */
5561                 DRXJ_16TO8(0x07),       /* FFEDDM1DATALKRATIO2 */
5562                 DRXJ_16TO8(0x07),       /* FFEDDM1DATALKRATIO3 */
5563                 DRXJ_16TO8(0x0e),       /* FFEDDM1DATALKRATIO4 */
5564                 DRXJ_16TO8(0x0e),       /* FFEDDM1DATALKRATIO5 */
5565                 DRXJ_16TO8(0x0e),       /* FFEDDM1DATALKRATIO6 */
5566                 DRXJ_16TO8(0x0e),       /* FFEDDM1DATALKRATIO7 */
5567                 DRXJ_16TO8(0x0e),       /* FFEDDM1DATALKRATIO8 */
5568                 DRXJ_16TO8(0x0e),       /* FFEDDM1DATALKRATIO9 */
5569                 DRXJ_16TO8(0x07),       /* FFEDDM1DATALKRATIO10 */
5570                 DRXJ_16TO8(0x07),       /* FFEDDM1DATALKRATIO11 */
5571                 DRXJ_16TO8(0x07),       /* FFEDDM1DATALKRATIO12 */
5572                 DRXJ_16TO8(0x06),       /* FFEDDM2TRAINLKRATIO1 */
5573                 DRXJ_16TO8(0x06),       /* FFEDDM2TRAINLKRATIO2 */
5574                 DRXJ_16TO8(0x06),       /* FFEDDM2TRAINLKRATIO3 */
5575                 DRXJ_16TO8(0x0c),       /* FFEDDM2TRAINLKRATIO4 */
5576                 DRXJ_16TO8(0x0c),       /* FFEDDM2TRAINLKRATIO5 */
5577                 DRXJ_16TO8(0x0c),       /* FFEDDM2TRAINLKRATIO6 */
5578                 DRXJ_16TO8(0x0c),       /* FFEDDM2TRAINLKRATIO7 */
5579                 DRXJ_16TO8(0x0c),       /* FFEDDM2TRAINLKRATIO8 */
5580                 DRXJ_16TO8(0x0c),       /* FFEDDM2TRAINLKRATIO9 */
5581                 DRXJ_16TO8(0x06),       /* FFEDDM2TRAINLKRATIO10 */
5582                 DRXJ_16TO8(0x06),       /* FFEDDM2TRAINLKRATIO11 */
5583                 DRXJ_16TO8(0x06),       /* FFEDDM2TRAINLKRATIO12 */
5584                 DRXJ_16TO8(0x06),       /* FFEDDM2DATALKRATIO1 */
5585                 DRXJ_16TO8(0x06),       /* FFEDDM2DATALKRATIO2 */
5586                 DRXJ_16TO8(0x06),       /* FFEDDM2DATALKRATIO3 */
5587                 DRXJ_16TO8(0x0c),       /* FFEDDM2DATALKRATIO4 */
5588                 DRXJ_16TO8(0x0c),       /* FFEDDM2DATALKRATIO5 */
5589                 DRXJ_16TO8(0x0c),       /* FFEDDM2DATALKRATIO6 */
5590                 DRXJ_16TO8(0x0c),       /* FFEDDM2DATALKRATIO7 */
5591                 DRXJ_16TO8(0x0c),       /* FFEDDM2DATALKRATIO8 */
5592                 DRXJ_16TO8(0x0c),       /* FFEDDM2DATALKRATIO9 */
5593                 DRXJ_16TO8(0x06),       /* FFEDDM2DATALKRATIO10 */
5594                 DRXJ_16TO8(0x06),       /* FFEDDM2DATALKRATIO11 */
5595                 DRXJ_16TO8(0x06),       /* FFEDDM2DATALKRATIO12 */
5596                 DRXJ_16TO8(0x2020),     /* FIRTRAINGAIN1 */
5597                 DRXJ_16TO8(0x2020),     /* FIRTRAINGAIN2 */
5598                 DRXJ_16TO8(0x2020),     /* FIRTRAINGAIN3 */
5599                 DRXJ_16TO8(0x4040),     /* FIRTRAINGAIN4 */
5600                 DRXJ_16TO8(0x4040),     /* FIRTRAINGAIN5 */
5601                 DRXJ_16TO8(0x4040),     /* FIRTRAINGAIN6 */
5602                 DRXJ_16TO8(0x4040),     /* FIRTRAINGAIN7 */
5603                 DRXJ_16TO8(0x4040),     /* FIRTRAINGAIN8 */
5604                 DRXJ_16TO8(0x4040),     /* FIRTRAINGAIN9 */
5605                 DRXJ_16TO8(0x2020),     /* FIRTRAINGAIN10 */
5606                 DRXJ_16TO8(0x2020),     /* FIRTRAINGAIN11 */
5607                 DRXJ_16TO8(0x2020),     /* FIRTRAINGAIN12 */
5608                 DRXJ_16TO8(0x0808),     /* FIRRCA1GAIN1 */
5609                 DRXJ_16TO8(0x0808),     /* FIRRCA1GAIN2 */
5610                 DRXJ_16TO8(0x0808),     /* FIRRCA1GAIN3 */
5611                 DRXJ_16TO8(0x1010),     /* FIRRCA1GAIN4 */
5612                 DRXJ_16TO8(0x1010),     /* FIRRCA1GAIN5 */
5613                 DRXJ_16TO8(0x1010),     /* FIRRCA1GAIN6 */
5614                 DRXJ_16TO8(0x1010),     /* FIRRCA1GAIN7 */
5615                 DRXJ_16TO8(0x1010)      /* FIRRCA1GAIN8 */
5616         };
5617
5618         const u8 vsb_ffe_leak_gain_ram1[] = {
5619                 DRXJ_16TO8(0x1010),     /* FIRRCA1GAIN9 */
5620                 DRXJ_16TO8(0x0808),     /* FIRRCA1GAIN10 */
5621                 DRXJ_16TO8(0x0808),     /* FIRRCA1GAIN11 */
5622                 DRXJ_16TO8(0x0808),     /* FIRRCA1GAIN12 */
5623                 DRXJ_16TO8(0x0808),     /* FIRRCA2GAIN1 */
5624                 DRXJ_16TO8(0x0808),     /* FIRRCA2GAIN2 */
5625                 DRXJ_16TO8(0x0808),     /* FIRRCA2GAIN3 */
5626                 DRXJ_16TO8(0x1010),     /* FIRRCA2GAIN4 */
5627                 DRXJ_16TO8(0x1010),     /* FIRRCA2GAIN5 */
5628                 DRXJ_16TO8(0x1010),     /* FIRRCA2GAIN6 */
5629                 DRXJ_16TO8(0x1010),     /* FIRRCA2GAIN7 */
5630                 DRXJ_16TO8(0x1010),     /* FIRRCA2GAIN8 */
5631                 DRXJ_16TO8(0x1010),     /* FIRRCA2GAIN9 */
5632                 DRXJ_16TO8(0x0808),     /* FIRRCA2GAIN10 */
5633                 DRXJ_16TO8(0x0808),     /* FIRRCA2GAIN11 */
5634                 DRXJ_16TO8(0x0808),     /* FIRRCA2GAIN12 */
5635                 DRXJ_16TO8(0x0303),     /* FIRDDM1GAIN1 */
5636                 DRXJ_16TO8(0x0303),     /* FIRDDM1GAIN2 */
5637                 DRXJ_16TO8(0x0303),     /* FIRDDM1GAIN3 */
5638                 DRXJ_16TO8(0x0606),     /* FIRDDM1GAIN4 */
5639                 DRXJ_16TO8(0x0606),     /* FIRDDM1GAIN5 */
5640                 DRXJ_16TO8(0x0606),     /* FIRDDM1GAIN6 */
5641                 DRXJ_16TO8(0x0606),     /* FIRDDM1GAIN7 */
5642                 DRXJ_16TO8(0x0606),     /* FIRDDM1GAIN8 */
5643                 DRXJ_16TO8(0x0606),     /* FIRDDM1GAIN9 */
5644                 DRXJ_16TO8(0x0303),     /* FIRDDM1GAIN10 */
5645                 DRXJ_16TO8(0x0303),     /* FIRDDM1GAIN11 */
5646                 DRXJ_16TO8(0x0303),     /* FIRDDM1GAIN12 */
5647                 DRXJ_16TO8(0x0303),     /* FIRDDM2GAIN1 */
5648                 DRXJ_16TO8(0x0303),     /* FIRDDM2GAIN2 */
5649                 DRXJ_16TO8(0x0303),     /* FIRDDM2GAIN3 */
5650                 DRXJ_16TO8(0x0505),     /* FIRDDM2GAIN4 */
5651                 DRXJ_16TO8(0x0505),     /* FIRDDM2GAIN5 */
5652                 DRXJ_16TO8(0x0505),     /* FIRDDM2GAIN6 */
5653                 DRXJ_16TO8(0x0505),     /* FIRDDM2GAIN7 */
5654                 DRXJ_16TO8(0x0505),     /* FIRDDM2GAIN8 */
5655                 DRXJ_16TO8(0x0505),     /* FIRDDM2GAIN9 */
5656                 DRXJ_16TO8(0x0303),     /* FIRDDM2GAIN10 */
5657                 DRXJ_16TO8(0x0303),     /* FIRDDM2GAIN11 */
5658                 DRXJ_16TO8(0x0303),     /* FIRDDM2GAIN12 */
5659                 DRXJ_16TO8(0x001f),     /* DFETRAINLKRATIO */
5660                 DRXJ_16TO8(0x01ff),     /* DFERCA1TRAINLKRATIO */
5661                 DRXJ_16TO8(0x01ff),     /* DFERCA1DATALKRATIO */
5662                 DRXJ_16TO8(0x004f),     /* DFERCA2TRAINLKRATIO */
5663                 DRXJ_16TO8(0x004f),     /* DFERCA2DATALKRATIO */
5664                 DRXJ_16TO8(0x01ff),     /* DFEDDM1TRAINLKRATIO */
5665                 DRXJ_16TO8(0x01ff),     /* DFEDDM1DATALKRATIO */
5666                 DRXJ_16TO8(0x0352),     /* DFEDDM2TRAINLKRATIO */
5667                 DRXJ_16TO8(0x0352),     /* DFEDDM2DATALKRATIO */
5668                 DRXJ_16TO8(0x0000),     /* DFETRAINGAIN */
5669                 DRXJ_16TO8(0x2020),     /* DFERCA1GAIN */
5670                 DRXJ_16TO8(0x1010),     /* DFERCA2GAIN */
5671                 DRXJ_16TO8(0x1818),     /* DFEDDM1GAIN */
5672                 DRXJ_16TO8(0x1212)      /* DFEDDM2GAIN */
5673         };
5674
5675         dev_addr = demod->my_i2c_dev_addr;
5676         rc = drxdap_fasi_write_block(dev_addr, VSB_SYSCTRL_RAM0_FFETRAINLKRATIO1__A, sizeof(vsb_ffe_leak_gain_ram0), ((u8 *)vsb_ffe_leak_gain_ram0), 0);
5677         if (rc != 0) {
5678                 pr_err("error %d\n", rc);
5679                 goto rw_error;
5680         }
5681         rc = drxdap_fasi_write_block(dev_addr, VSB_SYSCTRL_RAM1_FIRRCA1GAIN9__A, sizeof(vsb_ffe_leak_gain_ram1), ((u8 *)vsb_ffe_leak_gain_ram1), 0);
5682         if (rc != 0) {
5683                 pr_err("error %d\n", rc);
5684                 goto rw_error;
5685         }
5686
5687         return 0;
5688 rw_error:
5689         return rc;
5690 }
5691
5692 /**
5693 * \fn int set_vsb()
5694 * \brief Set 8VSB demod.
5695 * \param demod instance of demodulator.
5696 * \return int.
5697 *
5698 */
5699 static int set_vsb(struct drx_demod_instance *demod)
5700 {
5701         struct i2c_device_addr *dev_addr = NULL;
5702         int rc;
5703         struct drx_common_attr *common_attr = NULL;
5704         struct drxjscu_cmd cmd_scu;
5705         struct drxj_data *ext_attr = NULL;
5706         u16 cmd_result = 0;
5707         u16 cmd_param = 0;
5708         const u8 vsb_taps_re[] = {
5709                 DRXJ_16TO8(-2), /* re0  */
5710                 DRXJ_16TO8(4),  /* re1  */
5711                 DRXJ_16TO8(1),  /* re2  */
5712                 DRXJ_16TO8(-4), /* re3  */
5713                 DRXJ_16TO8(1),  /* re4  */
5714                 DRXJ_16TO8(4),  /* re5  */
5715                 DRXJ_16TO8(-3), /* re6  */
5716                 DRXJ_16TO8(-3), /* re7  */
5717                 DRXJ_16TO8(6),  /* re8  */
5718                 DRXJ_16TO8(1),  /* re9  */
5719                 DRXJ_16TO8(-9), /* re10 */
5720                 DRXJ_16TO8(3),  /* re11 */
5721                 DRXJ_16TO8(12), /* re12 */
5722                 DRXJ_16TO8(-9), /* re13 */
5723                 DRXJ_16TO8(-15),        /* re14 */
5724                 DRXJ_16TO8(17), /* re15 */
5725                 DRXJ_16TO8(19), /* re16 */
5726                 DRXJ_16TO8(-29),        /* re17 */
5727                 DRXJ_16TO8(-22),        /* re18 */
5728                 DRXJ_16TO8(45), /* re19 */
5729                 DRXJ_16TO8(25), /* re20 */
5730                 DRXJ_16TO8(-70),        /* re21 */
5731                 DRXJ_16TO8(-28),        /* re22 */
5732                 DRXJ_16TO8(111),        /* re23 */
5733                 DRXJ_16TO8(30), /* re24 */
5734                 DRXJ_16TO8(-201),       /* re25 */
5735                 DRXJ_16TO8(-31),        /* re26 */
5736                 DRXJ_16TO8(629) /* re27 */
5737         };
5738
5739         dev_addr = demod->my_i2c_dev_addr;
5740         common_attr = (struct drx_common_attr *) demod->my_common_attr;
5741         ext_attr = (struct drxj_data *) demod->my_ext_attr;
5742
5743         /* stop all comm_exec */
5744         rc = drxj_dap_write_reg16(dev_addr, FEC_COMM_EXEC__A, FEC_COMM_EXEC_STOP, 0);
5745         if (rc != 0) {
5746                 pr_err("error %d\n", rc);
5747                 goto rw_error;
5748         }
5749         rc = drxj_dap_write_reg16(dev_addr, VSB_COMM_EXEC__A, VSB_COMM_EXEC_STOP, 0);
5750         if (rc != 0) {
5751                 pr_err("error %d\n", rc);
5752                 goto rw_error;
5753         }
5754         rc = drxj_dap_write_reg16(dev_addr, IQM_FS_COMM_EXEC__A, IQM_FS_COMM_EXEC_STOP, 0);
5755         if (rc != 0) {
5756                 pr_err("error %d\n", rc);
5757                 goto rw_error;
5758         }
5759         rc = drxj_dap_write_reg16(dev_addr, IQM_FD_COMM_EXEC__A, IQM_FD_COMM_EXEC_STOP, 0);
5760         if (rc != 0) {
5761                 pr_err("error %d\n", rc);
5762                 goto rw_error;
5763         }
5764         rc = drxj_dap_write_reg16(dev_addr, IQM_RC_COMM_EXEC__A, IQM_RC_COMM_EXEC_STOP, 0);
5765         if (rc != 0) {
5766                 pr_err("error %d\n", rc);
5767                 goto rw_error;
5768         }
5769         rc = drxj_dap_write_reg16(dev_addr, IQM_RT_COMM_EXEC__A, IQM_RT_COMM_EXEC_STOP, 0);
5770         if (rc != 0) {
5771                 pr_err("error %d\n", rc);
5772                 goto rw_error;
5773         }
5774         rc = drxj_dap_write_reg16(dev_addr, IQM_CF_COMM_EXEC__A, IQM_CF_COMM_EXEC_STOP, 0);
5775         if (rc != 0) {
5776                 pr_err("error %d\n", rc);
5777                 goto rw_error;
5778         }
5779
5780         /* reset demodulator */
5781         cmd_scu.command = SCU_RAM_COMMAND_STANDARD_VSB
5782             | SCU_RAM_COMMAND_CMD_DEMOD_RESET;
5783         cmd_scu.parameter_len = 0;
5784         cmd_scu.result_len = 1;
5785         cmd_scu.parameter = NULL;
5786         cmd_scu.result = &cmd_result;
5787         rc = scu_command(dev_addr, &cmd_scu);
5788         if (rc != 0) {
5789                 pr_err("error %d\n", rc);
5790                 goto rw_error;
5791         }
5792
5793         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_DCF_BYPASS__A, 1, 0);
5794         if (rc != 0) {
5795                 pr_err("error %d\n", rc);
5796                 goto rw_error;
5797         }
5798         rc = drxj_dap_write_reg16(dev_addr, IQM_FS_ADJ_SEL__A, IQM_FS_ADJ_SEL_B_VSB, 0);
5799         if (rc != 0) {
5800                 pr_err("error %d\n", rc);
5801                 goto rw_error;
5802         }
5803         rc = drxj_dap_write_reg16(dev_addr, IQM_RC_ADJ_SEL__A, IQM_RC_ADJ_SEL_B_VSB, 0);
5804         if (rc != 0) {
5805                 pr_err("error %d\n", rc);
5806                 goto rw_error;
5807         }
5808         ext_attr->iqm_rc_rate_ofs = 0x00AD0D79;
5809         rc = drxdap_fasi_write_reg32(dev_addr, IQM_RC_RATE_OFS_LO__A, ext_attr->iqm_rc_rate_ofs, 0);
5810         if (rc != 0) {
5811                 pr_err("error %d\n", rc);
5812                 goto rw_error;
5813         }
5814         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_CFAGC_GAINSHIFT__A, 4, 0);
5815         if (rc != 0) {
5816                 pr_err("error %d\n", rc);
5817                 goto rw_error;
5818         }
5819         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_CYGN1TRK__A, 1, 0);
5820         if (rc != 0) {
5821                 pr_err("error %d\n", rc);
5822                 goto rw_error;
5823         }
5824
5825         rc = drxj_dap_write_reg16(dev_addr, IQM_RC_CROUT_ENA__A, 1, 0);
5826         if (rc != 0) {
5827                 pr_err("error %d\n", rc);
5828                 goto rw_error;
5829         }
5830         rc = drxj_dap_write_reg16(dev_addr, IQM_RC_STRETCH__A, 28, 0);
5831         if (rc != 0) {
5832                 pr_err("error %d\n", rc);
5833                 goto rw_error;
5834         }
5835         rc = drxj_dap_write_reg16(dev_addr, IQM_RT_ACTIVE__A, 0, 0);
5836         if (rc != 0) {
5837                 pr_err("error %d\n", rc);
5838                 goto rw_error;
5839         }
5840         rc = drxj_dap_write_reg16(dev_addr, IQM_CF_SYMMETRIC__A, 0, 0);
5841         if (rc != 0) {
5842                 pr_err("error %d\n", rc);
5843                 goto rw_error;
5844         }
5845         rc = drxj_dap_write_reg16(dev_addr, IQM_CF_MIDTAP__A, 3, 0);
5846         if (rc != 0) {
5847                 pr_err("error %d\n", rc);
5848                 goto rw_error;
5849         }
5850         rc = drxj_dap_write_reg16(dev_addr, IQM_CF_OUT_ENA__A, IQM_CF_OUT_ENA_VSB__M, 0);
5851         if (rc != 0) {
5852                 pr_err("error %d\n", rc);
5853                 goto rw_error;
5854         }
5855         rc = drxj_dap_write_reg16(dev_addr, IQM_CF_SCALE__A, 1393, 0);
5856         if (rc != 0) {
5857                 pr_err("error %d\n", rc);
5858                 goto rw_error;
5859         }
5860         rc = drxj_dap_write_reg16(dev_addr, IQM_CF_SCALE_SH__A, 0, 0);
5861         if (rc != 0) {
5862                 pr_err("error %d\n", rc);
5863                 goto rw_error;
5864         }
5865         rc = drxj_dap_write_reg16(dev_addr, IQM_CF_POW_MEAS_LEN__A, 1, 0);
5866         if (rc != 0) {
5867                 pr_err("error %d\n", rc);
5868                 goto rw_error;
5869         }
5870
5871         rc = drxdap_fasi_write_block(dev_addr, IQM_CF_TAP_RE0__A, sizeof(vsb_taps_re), ((u8 *)vsb_taps_re), 0);
5872         if (rc != 0) {
5873                 pr_err("error %d\n", rc);
5874                 goto rw_error;
5875         }
5876         rc = drxdap_fasi_write_block(dev_addr, IQM_CF_TAP_IM0__A, sizeof(vsb_taps_re), ((u8 *)vsb_taps_re), 0);
5877         if (rc != 0) {
5878                 pr_err("error %d\n", rc);
5879                 goto rw_error;
5880         }
5881
5882         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_BNTHRESH__A, 330, 0);
5883         if (rc != 0) {
5884                 pr_err("error %d\n", rc);
5885                 goto rw_error;
5886         }       /* set higher threshold */
5887         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_CLPLASTNUM__A, 90, 0);
5888         if (rc != 0) {
5889                 pr_err("error %d\n", rc);
5890                 goto rw_error;
5891         }       /* burst detection on   */
5892         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_SNRTH_RCA1__A, 0x0042, 0);
5893         if (rc != 0) {
5894                 pr_err("error %d\n", rc);
5895                 goto rw_error;
5896         }       /* drop thresholds by 1 dB */
5897         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_SNRTH_RCA2__A, 0x0053, 0);
5898         if (rc != 0) {
5899                 pr_err("error %d\n", rc);
5900                 goto rw_error;
5901         }       /* drop thresholds by 2 dB */
5902         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_EQCTRL__A, 0x1, 0);
5903         if (rc != 0) {
5904                 pr_err("error %d\n", rc);
5905                 goto rw_error;
5906         }       /* cma on               */
5907         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_GPIO__A, 0, 0);
5908         if (rc != 0) {
5909                 pr_err("error %d\n", rc);
5910                 goto rw_error;
5911         }       /* GPIO               */
5912
5913         /* Initialize the FEC Subsystem */
5914         rc = drxj_dap_write_reg16(dev_addr, FEC_TOP_ANNEX__A, FEC_TOP_ANNEX_D, 0);
5915         if (rc != 0) {
5916                 pr_err("error %d\n", rc);
5917                 goto rw_error;
5918         }
5919         {
5920                 u16 fec_oc_snc_mode = 0;
5921                 rc = drxj_dap_read_reg16(dev_addr, FEC_OC_SNC_MODE__A, &fec_oc_snc_mode, 0);
5922                 if (rc != 0) {
5923                         pr_err("error %d\n", rc);
5924                         goto rw_error;
5925                 }
5926                 /* output data even when not locked */
5927                 rc = drxj_dap_write_reg16(dev_addr, FEC_OC_SNC_MODE__A, fec_oc_snc_mode | FEC_OC_SNC_MODE_UNLOCK_ENABLE__M, 0);
5928                 if (rc != 0) {
5929                         pr_err("error %d\n", rc);
5930                         goto rw_error;
5931                 }
5932         }
5933
5934         /* set clip */
5935         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_CLP_LEN__A, 0, 0);
5936         if (rc != 0) {
5937                 pr_err("error %d\n", rc);
5938                 goto rw_error;
5939         }
5940         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_CLP_TH__A, 470, 0);
5941         if (rc != 0) {
5942                 pr_err("error %d\n", rc);
5943                 goto rw_error;
5944         }
5945         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_SNS_LEN__A, 0, 0);
5946         if (rc != 0) {
5947                 pr_err("error %d\n", rc);
5948                 goto rw_error;
5949         }
5950         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_SNRTH_PT__A, 0xD4, 0);
5951         if (rc != 0) {
5952                 pr_err("error %d\n", rc);
5953                 goto rw_error;
5954         }
5955         /* no transparent, no A&C framing; parity is set in mpegoutput */
5956         {
5957                 u16 fec_oc_reg_mode = 0;
5958                 rc = drxj_dap_read_reg16(dev_addr, FEC_OC_MODE__A, &fec_oc_reg_mode, 0);
5959                 if (rc != 0) {
5960                         pr_err("error %d\n", rc);
5961                         goto rw_error;
5962                 }
5963                 rc = drxj_dap_write_reg16(dev_addr, FEC_OC_MODE__A, fec_oc_reg_mode & (~(FEC_OC_MODE_TRANSPARENT__M | FEC_OC_MODE_CLEAR__M | FEC_OC_MODE_RETAIN_FRAMING__M)), 0);
5964                 if (rc != 0) {
5965                         pr_err("error %d\n", rc);
5966                         goto rw_error;
5967                 }
5968         }
5969
5970         rc = drxj_dap_write_reg16(dev_addr, FEC_DI_TIMEOUT_LO__A, 0, 0);
5971         if (rc != 0) {
5972                 pr_err("error %d\n", rc);
5973                 goto rw_error;
5974         }       /* timeout counter for restarting */
5975         rc = drxj_dap_write_reg16(dev_addr, FEC_DI_TIMEOUT_HI__A, 3, 0);
5976         if (rc != 0) {
5977                 pr_err("error %d\n", rc);
5978                 goto rw_error;
5979         }
5980         rc = drxj_dap_write_reg16(dev_addr, FEC_RS_MODE__A, 0, 0);
5981         if (rc != 0) {
5982                 pr_err("error %d\n", rc);
5983                 goto rw_error;
5984         }       /* bypass disabled */
5985         /* initialize RS packet error measurement parameters */
5986         rc = drxj_dap_write_reg16(dev_addr, FEC_RS_MEASUREMENT_PERIOD__A, FEC_RS_MEASUREMENT_PERIOD, 0);
5987         if (rc != 0) {
5988                 pr_err("error %d\n", rc);
5989                 goto rw_error;
5990         }
5991         rc = drxj_dap_write_reg16(dev_addr, FEC_RS_MEASUREMENT_PRESCALE__A, FEC_RS_MEASUREMENT_PRESCALE, 0);
5992         if (rc != 0) {
5993                 pr_err("error %d\n", rc);
5994                 goto rw_error;
5995         }
5996
5997         /* init measurement period of MER/SER */
5998         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_MEASUREMENT_PERIOD__A, VSB_TOP_MEASUREMENT_PERIOD, 0);
5999         if (rc != 0) {
6000                 pr_err("error %d\n", rc);
6001                 goto rw_error;
6002         }
6003         rc = drxdap_fasi_write_reg32(dev_addr, SCU_RAM_FEC_ACCUM_CW_CORRECTED_LO__A, 0, 0);
6004         if (rc != 0) {
6005                 pr_err("error %d\n", rc);
6006                 goto rw_error;
6007         }
6008         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_FEC_MEAS_COUNT__A, 0, 0);
6009         if (rc != 0) {
6010                 pr_err("error %d\n", rc);
6011                 goto rw_error;
6012         }
6013         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_FEC_ACCUM_PKT_FAILURES__A, 0, 0);
6014         if (rc != 0) {
6015                 pr_err("error %d\n", rc);
6016                 goto rw_error;
6017         }
6018
6019         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_CKGN1TRK__A, 128, 0);
6020         if (rc != 0) {
6021                 pr_err("error %d\n", rc);
6022                 goto rw_error;
6023         }
6024         /* B-Input to ADC, PGA+filter in standby */
6025         if (!ext_attr->has_lna) {
6026                 rc = drxj_dap_write_reg16(dev_addr, IQM_AF_AMUX__A, 0x02, 0);
6027                 if (rc != 0) {
6028                         pr_err("error %d\n", rc);
6029                         goto rw_error;
6030                 }
6031         }
6032
6033         /* turn on IQMAF. It has to be in front of setAgc**() */
6034         rc = set_iqm_af(demod, true);
6035         if (rc != 0) {
6036                 pr_err("error %d\n", rc);
6037                 goto rw_error;
6038         }
6039         rc = adc_synchronization(demod);
6040         if (rc != 0) {
6041                 pr_err("error %d\n", rc);
6042                 goto rw_error;
6043         }
6044
6045         rc = init_agc(demod);
6046         if (rc != 0) {
6047                 pr_err("error %d\n", rc);
6048                 goto rw_error;
6049         }
6050         rc = set_agc_if(demod, &(ext_attr->vsb_if_agc_cfg), false);
6051         if (rc != 0) {
6052                 pr_err("error %d\n", rc);
6053                 goto rw_error;
6054         }
6055         rc = set_agc_rf(demod, &(ext_attr->vsb_rf_agc_cfg), false);
6056         if (rc != 0) {
6057                 pr_err("error %d\n", rc);
6058                 goto rw_error;
6059         }
6060         {
6061                 /* TODO fix this, store a struct drxj_cfg_afe_gain structure in struct drxj_data instead
6062                    of only the gain */
6063                 struct drxj_cfg_afe_gain vsb_pga_cfg = { DRX_STANDARD_8VSB, 0 };
6064
6065                 vsb_pga_cfg.gain = ext_attr->vsb_pga_cfg;
6066                 rc = ctrl_set_cfg_afe_gain(demod, &vsb_pga_cfg);
6067                 if (rc != 0) {
6068                         pr_err("error %d\n", rc);
6069                         goto rw_error;
6070                 }
6071         }
6072         rc = ctrl_set_cfg_pre_saw(demod, &(ext_attr->vsb_pre_saw_cfg));
6073         if (rc != 0) {
6074                 pr_err("error %d\n", rc);
6075                 goto rw_error;
6076         }
6077
6078         /* Mpeg output has to be in front of FEC active */
6079         rc = set_mpegtei_handling(demod);
6080         if (rc != 0) {
6081                 pr_err("error %d\n", rc);
6082                 goto rw_error;
6083         }
6084         rc = bit_reverse_mpeg_output(demod);
6085         if (rc != 0) {
6086                 pr_err("error %d\n", rc);
6087                 goto rw_error;
6088         }
6089         rc = set_mpeg_start_width(demod);
6090         if (rc != 0) {
6091                 pr_err("error %d\n", rc);
6092                 goto rw_error;
6093         }
6094         {
6095                 /* TODO: move to set_standard after hardware reset value problem is solved */
6096                 /* Configure initial MPEG output */
6097                 struct drx_cfg_mpeg_output cfg_mpeg_output;
6098
6099                 memcpy(&cfg_mpeg_output, &common_attr->mpeg_cfg, sizeof(cfg_mpeg_output));
6100                 cfg_mpeg_output.enable_mpeg_output = true;
6101
6102                 rc = ctrl_set_cfg_mpeg_output(demod, &cfg_mpeg_output);
6103                 if (rc != 0) {
6104                         pr_err("error %d\n", rc);
6105                         goto rw_error;
6106                 }
6107         }
6108
6109         /* TBD: what parameters should be set */
6110         cmd_param = 0x00;       /* Default mode AGC on, etc */
6111         cmd_scu.command = SCU_RAM_COMMAND_STANDARD_VSB
6112             | SCU_RAM_COMMAND_CMD_DEMOD_SET_PARAM;
6113         cmd_scu.parameter_len = 1;
6114         cmd_scu.result_len = 1;
6115         cmd_scu.parameter = &cmd_param;
6116         cmd_scu.result = &cmd_result;
6117         rc = scu_command(dev_addr, &cmd_scu);
6118         if (rc != 0) {
6119                 pr_err("error %d\n", rc);
6120                 goto rw_error;
6121         }
6122
6123         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_BEAGC_GAINSHIFT__A, 0x0004, 0);
6124         if (rc != 0) {
6125                 pr_err("error %d\n", rc);
6126                 goto rw_error;
6127         }
6128         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_SNRTH_PT__A, 0x00D2, 0);
6129         if (rc != 0) {
6130                 pr_err("error %d\n", rc);
6131                 goto rw_error;
6132         }
6133         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_SYSSMTRNCTRL__A, VSB_TOP_SYSSMTRNCTRL__PRE | VSB_TOP_SYSSMTRNCTRL_NCOTIMEOUTCNTEN__M, 0);
6134         if (rc != 0) {
6135                 pr_err("error %d\n", rc);
6136                 goto rw_error;
6137         }
6138         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_BEDETCTRL__A, 0x142, 0);
6139         if (rc != 0) {
6140                 pr_err("error %d\n", rc);
6141                 goto rw_error;
6142         }
6143         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_LBAGCREFLVL__A, 640, 0);
6144         if (rc != 0) {
6145                 pr_err("error %d\n", rc);
6146                 goto rw_error;
6147         }
6148         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_CYGN1ACQ__A, 4, 0);
6149         if (rc != 0) {
6150                 pr_err("error %d\n", rc);
6151                 goto rw_error;
6152         }
6153         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_CYGN1TRK__A, 2, 0);
6154         if (rc != 0) {
6155                 pr_err("error %d\n", rc);
6156                 goto rw_error;
6157         }
6158         rc = drxj_dap_write_reg16(dev_addr, VSB_TOP_CYGN2TRK__A, 3, 0);
6159         if (rc != 0) {
6160                 pr_err("error %d\n", rc);
6161                 goto rw_error;
6162         }
6163
6164         /* start demodulator */
6165         cmd_scu.command = SCU_RAM_COMMAND_STANDARD_VSB
6166             | SCU_RAM_COMMAND_CMD_DEMOD_START;
6167         cmd_scu.parameter_len = 0;
6168         cmd_scu.result_len = 1;
6169         cmd_scu.parameter = NULL;
6170         cmd_scu.result = &cmd_result;
6171         rc = scu_command(dev_addr, &cmd_scu);
6172         if (rc != 0) {
6173                 pr_err("error %d\n", rc);
6174                 goto rw_error;
6175         }
6176
6177         rc = drxj_dap_write_reg16(dev_addr, IQM_COMM_EXEC__A, IQM_COMM_EXEC_ACTIVE, 0);
6178         if (rc != 0) {
6179                 pr_err("error %d\n", rc);
6180                 goto rw_error;
6181         }
6182         rc = drxj_dap_write_reg16(dev_addr, VSB_COMM_EXEC__A, VSB_COMM_EXEC_ACTIVE, 0);
6183         if (rc != 0) {
6184                 pr_err("error %d\n", rc);
6185                 goto rw_error;
6186         }
6187         rc = drxj_dap_write_reg16(dev_addr, FEC_COMM_EXEC__A, FEC_COMM_EXEC_ACTIVE, 0);
6188         if (rc != 0) {
6189                 pr_err("error %d\n", rc);
6190                 goto rw_error;
6191         }
6192
6193         return 0;
6194 rw_error:
6195         return rc;
6196 }
6197
6198 /**
6199 * \fn static short get_vsb_post_rs_pck_err(struct i2c_device_addr *dev_addr, u16 *PckErrs)
6200 * \brief Get the values of packet error in 8VSB mode
6201 * \return Error code
6202 */
6203 static int get_vsb_post_rs_pck_err(struct i2c_device_addr *dev_addr,
6204                                    u32 *pck_errs, u32 *pck_count)
6205 {
6206         int rc;
6207         u16 data = 0;
6208         u16 period = 0;
6209         u16 prescale = 0;
6210         u16 packet_errors_mant = 0;
6211         u16 packet_errors_exp = 0;
6212
6213         rc = drxj_dap_read_reg16(dev_addr, FEC_RS_NR_FAILURES__A, &data, 0);
6214         if (rc != 0) {
6215                 pr_err("error %d\n", rc);
6216                 goto rw_error;
6217         }
6218         packet_errors_mant = data & FEC_RS_NR_FAILURES_FIXED_MANT__M;
6219         packet_errors_exp = (data & FEC_RS_NR_FAILURES_EXP__M)
6220             >> FEC_RS_NR_FAILURES_EXP__B;
6221         period = FEC_RS_MEASUREMENT_PERIOD;
6222         prescale = FEC_RS_MEASUREMENT_PRESCALE;
6223         /* packet error rate = (error packet number) per second */
6224         /* 77.3 us is time for per packet */
6225         if (period * prescale == 0) {
6226                 pr_err("error: period and/or prescale is zero!\n");
6227                 return -EIO;
6228         }
6229         *pck_errs = packet_errors_mant * (1 << packet_errors_exp);
6230         *pck_count = period * prescale * 77;
6231
6232         return 0;
6233 rw_error:
6234         return rc;
6235 }
6236
6237 /**
6238 * \fn static short GetVSBBer(struct i2c_device_addr *dev_addr, u32 *ber)
6239 * \brief Get the values of ber in VSB mode
6240 * \return Error code
6241 */
6242 static int get_vs_bpost_viterbi_ber(struct i2c_device_addr *dev_addr,
6243                                     u32 *ber, u32 *cnt)
6244 {
6245         int rc;
6246         u16 data = 0;
6247         u16 period = 0;
6248         u16 prescale = 0;
6249         u16 bit_errors_mant = 0;
6250         u16 bit_errors_exp = 0;
6251
6252         rc = drxj_dap_read_reg16(dev_addr, FEC_RS_NR_BIT_ERRORS__A, &data, 0);
6253         if (rc != 0) {
6254                 pr_err("error %d\n", rc);
6255                 goto rw_error;
6256         }
6257         period = FEC_RS_MEASUREMENT_PERIOD;
6258         prescale = FEC_RS_MEASUREMENT_PRESCALE;
6259
6260         bit_errors_mant = data & FEC_RS_NR_BIT_ERRORS_FIXED_MANT__M;
6261         bit_errors_exp = (data & FEC_RS_NR_BIT_ERRORS_EXP__M)
6262             >> FEC_RS_NR_BIT_ERRORS_EXP__B;
6263
6264         *cnt = period * prescale * 207 * ((bit_errors_exp > 2) ? 1 : 8);
6265
6266         if (((bit_errors_mant << bit_errors_exp) >> 3) > 68700)
6267                 *ber = (*cnt) * 26570;
6268         else {
6269                 if (period * prescale == 0) {
6270                         pr_err("error: period and/or prescale is zero!\n");
6271                         return -EIO;
6272                 }
6273                 *ber = bit_errors_mant << ((bit_errors_exp > 2) ?
6274                         (bit_errors_exp - 3) : bit_errors_exp);
6275         }
6276
6277         return 0;
6278 rw_error:
6279         return rc;
6280 }
6281
6282 /**
6283 * \fn static short get_vs_bpre_viterbi_ber(struct i2c_device_addr *dev_addr, u32 *ber)
6284 * \brief Get the values of ber in VSB mode
6285 * \return Error code
6286 */
6287 static int get_vs_bpre_viterbi_ber(struct i2c_device_addr *dev_addr,
6288                                    u32 *ber, u32 *cnt)
6289 {
6290         u16 data = 0;
6291         int rc;
6292
6293         rc = drxj_dap_read_reg16(dev_addr, VSB_TOP_NR_SYM_ERRS__A, &data, 0);
6294         if (rc != 0) {
6295                 pr_err("error %d\n", rc);
6296                 return -EIO;
6297         }
6298         *ber = data;
6299         *cnt = VSB_TOP_MEASUREMENT_PERIOD * SYMBOLS_PER_SEGMENT;
6300
6301         return 0;
6302 }
6303
6304 /**
6305 * \fn static int get_vsbmer(struct i2c_device_addr *dev_addr, u16 *mer)
6306 * \brief Get the values of MER
6307 * \return Error code
6308 */
6309 static int get_vsbmer(struct i2c_device_addr *dev_addr, u16 *mer)
6310 {
6311         int rc;
6312         u16 data_hi = 0;
6313
6314         rc = drxj_dap_read_reg16(dev_addr, VSB_TOP_ERR_ENERGY_H__A, &data_hi, 0);
6315         if (rc != 0) {
6316                 pr_err("error %d\n", rc);
6317                 goto rw_error;
6318         }
6319         *mer =
6320             (u16) (log1_times100(21504) - log1_times100((data_hi << 6) / 52));
6321
6322         return 0;
6323 rw_error:
6324         return rc;
6325 }
6326
6327
6328 /*============================================================================*/
6329 /*==                     END 8VSB DATAPATH FUNCTIONS                        ==*/
6330 /*============================================================================*/
6331
6332 /*============================================================================*/
6333 /*============================================================================*/
6334 /*==                       QAM DATAPATH FUNCTIONS                           ==*/
6335 /*============================================================================*/
6336 /*============================================================================*/
6337
6338 /**
6339 * \fn int power_down_qam ()
6340 * \brief Powr down QAM related blocks.
6341 * \param demod instance of demodulator.
6342 * \param channel pointer to channel data.
6343 * \return int.
6344 */
6345 static int power_down_qam(struct drx_demod_instance *demod, bool primary)
6346 {
6347         struct drxjscu_cmd cmd_scu = { /* command      */ 0,
6348                 /* parameter_len */ 0,
6349                 /* result_len    */ 0,
6350                 /* *parameter   */ NULL,
6351                 /* *result      */ NULL
6352         };
6353         int rc;
6354         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
6355         struct drx_cfg_mpeg_output cfg_mpeg_output;
6356         struct drx_common_attr *common_attr = demod->my_common_attr;
6357         u16 cmd_result = 0;
6358
6359         /*
6360            STOP demodulator
6361            resets IQM, QAM and FEC HW blocks
6362          */
6363         /* stop all comm_exec */
6364         rc = drxj_dap_write_reg16(dev_addr, FEC_COMM_EXEC__A, FEC_COMM_EXEC_STOP, 0);
6365         if (rc != 0) {
6366                 pr_err("error %d\n", rc);
6367                 goto rw_error;
6368         }
6369         rc = drxj_dap_write_reg16(dev_addr, QAM_COMM_EXEC__A, QAM_COMM_EXEC_STOP, 0);
6370         if (rc != 0) {
6371                 pr_err("error %d\n", rc);
6372                 goto rw_error;
6373         }
6374
6375         cmd_scu.command = SCU_RAM_COMMAND_STANDARD_QAM |
6376             SCU_RAM_COMMAND_CMD_DEMOD_STOP;
6377         cmd_scu.parameter_len = 0;
6378         cmd_scu.result_len = 1;
6379         cmd_scu.parameter = NULL;
6380         cmd_scu.result = &cmd_result;
6381         rc = scu_command(dev_addr, &cmd_scu);
6382         if (rc != 0) {
6383                 pr_err("error %d\n", rc);
6384                 goto rw_error;
6385         }
6386
6387         if (primary) {
6388                 rc = drxj_dap_write_reg16(dev_addr, IQM_COMM_EXEC__A, IQM_COMM_EXEC_STOP, 0);
6389                 if (rc != 0) {
6390                         pr_err("error %d\n", rc);
6391                         goto rw_error;
6392                 }
6393                 rc = set_iqm_af(demod, false);
6394                 if (rc != 0) {
6395                         pr_err("error %d\n", rc);
6396                         goto rw_error;
6397                 }
6398         } else {
6399                 rc = drxj_dap_write_reg16(dev_addr, IQM_FS_COMM_EXEC__A, IQM_FS_COMM_EXEC_STOP, 0);
6400                 if (rc != 0) {
6401                         pr_err("error %d\n", rc);
6402                         goto rw_error;
6403                 }
6404                 rc = drxj_dap_write_reg16(dev_addr, IQM_FD_COMM_EXEC__A, IQM_FD_COMM_EXEC_STOP, 0);
6405                 if (rc != 0) {
6406                         pr_err("error %d\n", rc);
6407                         goto rw_error;
6408                 }
6409                 rc = drxj_dap_write_reg16(dev_addr, IQM_RC_COMM_EXEC__A, IQM_RC_COMM_EXEC_STOP, 0);
6410                 if (rc != 0) {
6411                         pr_err("error %d\n", rc);
6412                         goto rw_error;
6413                 }
6414                 rc = drxj_dap_write_reg16(dev_addr, IQM_RT_COMM_EXEC__A, IQM_RT_COMM_EXEC_STOP, 0);
6415                 if (rc != 0) {
6416                         pr_err("error %d\n", rc);
6417                         goto rw_error;
6418                 }
6419                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_COMM_EXEC__A, IQM_CF_COMM_EXEC_STOP, 0);
6420                 if (rc != 0) {
6421                         pr_err("error %d\n", rc);
6422                         goto rw_error;
6423                 }
6424         }
6425
6426         memcpy(&cfg_mpeg_output, &common_attr->mpeg_cfg, sizeof(cfg_mpeg_output));
6427         cfg_mpeg_output.enable_mpeg_output = false;
6428
6429         rc = ctrl_set_cfg_mpeg_output(demod, &cfg_mpeg_output);
6430         if (rc != 0) {
6431                 pr_err("error %d\n", rc);
6432                 goto rw_error;
6433         }
6434
6435         return 0;
6436 rw_error:
6437         return rc;
6438 }
6439
6440 /*============================================================================*/
6441
6442 /**
6443 * \fn int set_qam_measurement ()
6444 * \brief Setup of the QAM Measuremnt intervals for signal quality
6445 * \param demod instance of demod.
6446 * \param constellation current constellation.
6447 * \return int.
6448 *
6449 *  NOTE:
6450 *  Take into account that for certain settings the errorcounters can overflow.
6451 *  The implementation does not check this.
6452 *
6453 *  TODO: overriding the ext_attr->fec_bits_desired by constellation dependent
6454 *  constants to get a measurement period of approx. 1 sec. Remove fec_bits_desired
6455 *  field ?
6456 *
6457 */
6458 #ifndef DRXJ_VSB_ONLY
6459 static int
6460 set_qam_measurement(struct drx_demod_instance *demod,
6461                     enum drx_modulation constellation, u32 symbol_rate)
6462 {
6463         struct i2c_device_addr *dev_addr = NULL;        /* device address for I2C writes */
6464         struct drxj_data *ext_attr = NULL;      /* Global data container for DRXJ specific data */
6465         int rc;
6466         u32 fec_bits_desired = 0;       /* BER accounting period */
6467         u16 fec_rs_plen = 0;    /* defines RS BER measurement period */
6468         u16 fec_rs_prescale = 0;        /* ReedSolomon Measurement Prescale */
6469         u32 fec_rs_period = 0;  /* Value for corresponding I2C register */
6470         u32 fec_rs_bit_cnt = 0; /* Actual precise amount of bits */
6471         u32 fec_oc_snc_fail_period = 0; /* Value for corresponding I2C register */
6472         u32 qam_vd_period = 0;  /* Value for corresponding I2C register */
6473         u32 qam_vd_bit_cnt = 0; /* Actual precise amount of bits */
6474         u16 fec_vd_plen = 0;    /* no of trellis symbols: VD SER measur period */
6475         u16 qam_vd_prescale = 0;        /* Viterbi Measurement Prescale */
6476
6477         dev_addr = demod->my_i2c_dev_addr;
6478         ext_attr = (struct drxj_data *) demod->my_ext_attr;
6479
6480         fec_bits_desired = ext_attr->fec_bits_desired;
6481         fec_rs_prescale = ext_attr->fec_rs_prescale;
6482
6483         switch (constellation) {
6484         case DRX_CONSTELLATION_QAM16:
6485                 fec_bits_desired = 4 * symbol_rate;
6486                 break;
6487         case DRX_CONSTELLATION_QAM32:
6488                 fec_bits_desired = 5 * symbol_rate;
6489                 break;
6490         case DRX_CONSTELLATION_QAM64:
6491                 fec_bits_desired = 6 * symbol_rate;
6492                 break;
6493         case DRX_CONSTELLATION_QAM128:
6494                 fec_bits_desired = 7 * symbol_rate;
6495                 break;
6496         case DRX_CONSTELLATION_QAM256:
6497                 fec_bits_desired = 8 * symbol_rate;
6498                 break;
6499         default:
6500                 return -EINVAL;
6501         }
6502
6503         /* Parameters for Reed-Solomon Decoder */
6504         /* fecrs_period = (int)ceil(FEC_BITS_DESIRED/(fecrs_prescale*plen)) */
6505         /* rs_bit_cnt   = fecrs_period*fecrs_prescale*plen                  */
6506         /*     result is within 32 bit arithmetic ->                        */
6507         /*     no need for mult or frac functions                           */
6508
6509         /* TODO: use constant instead of calculation and remove the fec_rs_plen in ext_attr */
6510         switch (ext_attr->standard) {
6511         case DRX_STANDARD_ITU_A:
6512         case DRX_STANDARD_ITU_C:
6513                 fec_rs_plen = 204 * 8;
6514                 break;
6515         case DRX_STANDARD_ITU_B:
6516                 fec_rs_plen = 128 * 7;
6517                 break;
6518         default:
6519                 return -EINVAL;
6520         }
6521
6522         ext_attr->fec_rs_plen = fec_rs_plen;    /* for getSigQual */
6523         fec_rs_bit_cnt = fec_rs_prescale * fec_rs_plen; /* temp storage   */
6524         if (fec_rs_bit_cnt == 0) {
6525                 pr_err("error: fec_rs_bit_cnt is zero!\n");
6526                 return -EIO;
6527         }
6528         fec_rs_period = fec_bits_desired / fec_rs_bit_cnt + 1;  /* ceil */
6529         if (ext_attr->standard != DRX_STANDARD_ITU_B)
6530                 fec_oc_snc_fail_period = fec_rs_period;
6531
6532         /* limit to max 16 bit value (I2C register width) if needed */
6533         if (fec_rs_period > 0xFFFF)
6534                 fec_rs_period = 0xFFFF;
6535
6536         /* write corresponding registers */
6537         switch (ext_attr->standard) {
6538         case DRX_STANDARD_ITU_A:
6539         case DRX_STANDARD_ITU_C:
6540                 break;
6541         case DRX_STANDARD_ITU_B:
6542                 switch (constellation) {
6543                 case DRX_CONSTELLATION_QAM64:
6544                         fec_rs_period = 31581;
6545                         fec_oc_snc_fail_period = 17932;
6546                         break;
6547                 case DRX_CONSTELLATION_QAM256:
6548                         fec_rs_period = 45446;
6549                         fec_oc_snc_fail_period = 25805;
6550                         break;
6551                 default:
6552                         return -EINVAL;
6553                 }
6554                 break;
6555         default:
6556                 return -EINVAL;
6557         }
6558
6559         rc = drxj_dap_write_reg16(dev_addr, FEC_OC_SNC_FAIL_PERIOD__A, (u16)fec_oc_snc_fail_period, 0);
6560         if (rc != 0) {
6561                 pr_err("error %d\n", rc);
6562                 goto rw_error;
6563         }
6564         rc = drxj_dap_write_reg16(dev_addr, FEC_RS_MEASUREMENT_PERIOD__A, (u16)fec_rs_period, 0);
6565         if (rc != 0) {
6566                 pr_err("error %d\n", rc);
6567                 goto rw_error;
6568         }
6569         rc = drxj_dap_write_reg16(dev_addr, FEC_RS_MEASUREMENT_PRESCALE__A, fec_rs_prescale, 0);
6570         if (rc != 0) {
6571                 pr_err("error %d\n", rc);
6572                 goto rw_error;
6573         }
6574         ext_attr->fec_rs_period = (u16) fec_rs_period;
6575         ext_attr->fec_rs_prescale = fec_rs_prescale;
6576         rc = drxdap_fasi_write_reg32(dev_addr, SCU_RAM_FEC_ACCUM_CW_CORRECTED_LO__A, 0, 0);
6577         if (rc != 0) {
6578                 pr_err("error %d\n", rc);
6579                 goto rw_error;
6580         }
6581         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_FEC_MEAS_COUNT__A, 0, 0);
6582         if (rc != 0) {
6583                 pr_err("error %d\n", rc);
6584                 goto rw_error;
6585         }
6586         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_FEC_ACCUM_PKT_FAILURES__A, 0, 0);
6587         if (rc != 0) {
6588                 pr_err("error %d\n", rc);
6589                 goto rw_error;
6590         }
6591
6592         if (ext_attr->standard == DRX_STANDARD_ITU_B) {
6593                 /* Parameters for Viterbi Decoder */
6594                 /* qamvd_period = (int)ceil(FEC_BITS_DESIRED/                      */
6595                 /*                    (qamvd_prescale*plen*(qam_constellation+1))) */
6596                 /* vd_bit_cnt   = qamvd_period*qamvd_prescale*plen                 */
6597                 /*     result is within 32 bit arithmetic ->                       */
6598                 /*     no need for mult or frac functions                          */
6599
6600                 /* a(8 bit) * b(8 bit) = 16 bit result => mult32 not needed */
6601                 fec_vd_plen = ext_attr->fec_vd_plen;
6602                 qam_vd_prescale = ext_attr->qam_vd_prescale;
6603                 qam_vd_bit_cnt = qam_vd_prescale * fec_vd_plen; /* temp storage */
6604
6605                 switch (constellation) {
6606                 case DRX_CONSTELLATION_QAM64:
6607                         /* a(16 bit) * b(4 bit) = 20 bit result => mult32 not needed */
6608                         qam_vd_period =
6609                             qam_vd_bit_cnt * (QAM_TOP_CONSTELLATION_QAM64 + 1)
6610                             * (QAM_TOP_CONSTELLATION_QAM64 + 1);
6611                         break;
6612                 case DRX_CONSTELLATION_QAM256:
6613                         /* a(16 bit) * b(5 bit) = 21 bit result => mult32 not needed */
6614                         qam_vd_period =
6615                             qam_vd_bit_cnt * (QAM_TOP_CONSTELLATION_QAM256 + 1)
6616                             * (QAM_TOP_CONSTELLATION_QAM256 + 1);
6617                         break;
6618                 default:
6619                         return -EINVAL;
6620                 }
6621                 if (qam_vd_period == 0) {
6622                         pr_err("error: qam_vd_period is zero!\n");
6623                         return -EIO;
6624                 }
6625                 qam_vd_period = fec_bits_desired / qam_vd_period;
6626                 /* limit to max 16 bit value (I2C register width) if needed */
6627                 if (qam_vd_period > 0xFFFF)
6628                         qam_vd_period = 0xFFFF;
6629
6630                 /* a(16 bit) * b(16 bit) = 32 bit result => mult32 not needed */
6631                 qam_vd_bit_cnt *= qam_vd_period;
6632
6633                 rc = drxj_dap_write_reg16(dev_addr, QAM_VD_MEASUREMENT_PERIOD__A, (u16)qam_vd_period, 0);
6634                 if (rc != 0) {
6635                         pr_err("error %d\n", rc);
6636                         goto rw_error;
6637                 }
6638                 rc = drxj_dap_write_reg16(dev_addr, QAM_VD_MEASUREMENT_PRESCALE__A, qam_vd_prescale, 0);
6639                 if (rc != 0) {
6640                         pr_err("error %d\n", rc);
6641                         goto rw_error;
6642                 }
6643                 ext_attr->qam_vd_period = (u16) qam_vd_period;
6644                 ext_attr->qam_vd_prescale = qam_vd_prescale;
6645         }
6646
6647         return 0;
6648 rw_error:
6649         return rc;
6650 }
6651
6652 /*============================================================================*/
6653
6654 /**
6655 * \fn int set_qam16 ()
6656 * \brief QAM16 specific setup
6657 * \param demod instance of demod.
6658 * \return int.
6659 */
6660 static int set_qam16(struct drx_demod_instance *demod)
6661 {
6662         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
6663         int rc;
6664         const u8 qam_dq_qual_fun[] = {
6665                 DRXJ_16TO8(2),  /* fun0  */
6666                 DRXJ_16TO8(2),  /* fun1  */
6667                 DRXJ_16TO8(2),  /* fun2  */
6668                 DRXJ_16TO8(2),  /* fun3  */
6669                 DRXJ_16TO8(3),  /* fun4  */
6670                 DRXJ_16TO8(3),  /* fun5  */
6671         };
6672         const u8 qam_eq_cma_rad[] = {
6673                 DRXJ_16TO8(13517),      /* RAD0  */
6674                 DRXJ_16TO8(13517),      /* RAD1  */
6675                 DRXJ_16TO8(13517),      /* RAD2  */
6676                 DRXJ_16TO8(13517),      /* RAD3  */
6677                 DRXJ_16TO8(13517),      /* RAD4  */
6678                 DRXJ_16TO8(13517),      /* RAD5  */
6679         };
6680
6681         rc = drxdap_fasi_write_block(dev_addr, QAM_DQ_QUAL_FUN0__A, sizeof(qam_dq_qual_fun), ((u8 *)qam_dq_qual_fun), 0);
6682         if (rc != 0) {
6683                 pr_err("error %d\n", rc);
6684                 goto rw_error;
6685         }
6686         rc = drxdap_fasi_write_block(dev_addr, SCU_RAM_QAM_EQ_CMA_RAD0__A, sizeof(qam_eq_cma_rad), ((u8 *)qam_eq_cma_rad), 0);
6687         if (rc != 0) {
6688                 pr_err("error %d\n", rc);
6689                 goto rw_error;
6690         }
6691
6692         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RTH__A, 140, 0);
6693         if (rc != 0) {
6694                 pr_err("error %d\n", rc);
6695                 goto rw_error;
6696         }
6697         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_FTH__A, 50, 0);
6698         if (rc != 0) {
6699                 pr_err("error %d\n", rc);
6700                 goto rw_error;
6701         }
6702         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_PTH__A, 120, 0);
6703         if (rc != 0) {
6704                 pr_err("error %d\n", rc);
6705                 goto rw_error;
6706         }
6707         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_QTH__A, 230, 0);
6708         if (rc != 0) {
6709                 pr_err("error %d\n", rc);
6710                 goto rw_error;
6711         }
6712         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_CTH__A, 95, 0);
6713         if (rc != 0) {
6714                 pr_err("error %d\n", rc);
6715                 goto rw_error;
6716         }
6717         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_MTH__A, 105, 0);
6718         if (rc != 0) {
6719                 pr_err("error %d\n", rc);
6720                 goto rw_error;
6721         }
6722
6723         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RATE_LIM__A, 40, 0);
6724         if (rc != 0) {
6725                 pr_err("error %d\n", rc);
6726                 goto rw_error;
6727         }
6728         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_FREQ_LIM__A, 56, 0);
6729         if (rc != 0) {
6730                 pr_err("error %d\n", rc);
6731                 goto rw_error;
6732         }
6733         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_COUNT_LIM__A, 3, 0);
6734         if (rc != 0) {
6735                 pr_err("error %d\n", rc);
6736                 goto rw_error;
6737         }
6738
6739         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, 16, 0);
6740         if (rc != 0) {
6741                 pr_err("error %d\n", rc);
6742                 goto rw_error;
6743         }
6744         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, 220, 0);
6745         if (rc != 0) {
6746                 pr_err("error %d\n", rc);
6747                 goto rw_error;
6748         }
6749         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, 25, 0);
6750         if (rc != 0) {
6751                 pr_err("error %d\n", rc);
6752                 goto rw_error;
6753         }
6754         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, 6, 0);
6755         if (rc != 0) {
6756                 pr_err("error %d\n", rc);
6757                 goto rw_error;
6758         }
6759         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16)(-24), 0);
6760         if (rc != 0) {
6761                 pr_err("error %d\n", rc);
6762                 goto rw_error;
6763         }
6764         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16)(-65), 0);
6765         if (rc != 0) {
6766                 pr_err("error %d\n", rc);
6767                 goto rw_error;
6768         }
6769         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16)(-127), 0);
6770         if (rc != 0) {
6771                 pr_err("error %d\n", rc);
6772                 goto rw_error;
6773         }
6774
6775         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CA_FINE__A, 15, 0);
6776         if (rc != 0) {
6777                 pr_err("error %d\n", rc);
6778                 goto rw_error;
6779         }
6780         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CA_COARSE__A, 40, 0);
6781         if (rc != 0) {
6782                 pr_err("error %d\n", rc);
6783                 goto rw_error;
6784         }
6785         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_FINE__A, 2, 0);
6786         if (rc != 0) {
6787                 pr_err("error %d\n", rc);
6788                 goto rw_error;
6789         }
6790         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_MEDIUM__A, 20, 0);
6791         if (rc != 0) {
6792                 pr_err("error %d\n", rc);
6793                 goto rw_error;
6794         }
6795         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_COARSE__A, 255, 0);
6796         if (rc != 0) {
6797                 pr_err("error %d\n", rc);
6798                 goto rw_error;
6799         }
6800         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_FINE__A, 2, 0);
6801         if (rc != 0) {
6802                 pr_err("error %d\n", rc);
6803                 goto rw_error;
6804         }
6805         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_MEDIUM__A, 10, 0);
6806         if (rc != 0) {
6807                 pr_err("error %d\n", rc);
6808                 goto rw_error;
6809         }
6810         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_COARSE__A, 50, 0);
6811         if (rc != 0) {
6812                 pr_err("error %d\n", rc);
6813                 goto rw_error;
6814         }
6815         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_FINE__A, 12, 0);
6816         if (rc != 0) {
6817                 pr_err("error %d\n", rc);
6818                 goto rw_error;
6819         }
6820         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24, 0);
6821         if (rc != 0) {
6822                 pr_err("error %d\n", rc);
6823                 goto rw_error;
6824         }
6825         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_COARSE__A, 24, 0);
6826         if (rc != 0) {
6827                 pr_err("error %d\n", rc);
6828                 goto rw_error;
6829         }
6830         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_FINE__A, 12, 0);
6831         if (rc != 0) {
6832                 pr_err("error %d\n", rc);
6833                 goto rw_error;
6834         }
6835         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16, 0);
6836         if (rc != 0) {
6837                 pr_err("error %d\n", rc);
6838                 goto rw_error;
6839         }
6840         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_COARSE__A, 16, 0);
6841         if (rc != 0) {
6842                 pr_err("error %d\n", rc);
6843                 goto rw_error;
6844         }
6845         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_FINE__A, 16, 0);
6846         if (rc != 0) {
6847                 pr_err("error %d\n", rc);
6848                 goto rw_error;
6849         }
6850         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_MEDIUM__A, 32, 0);
6851         if (rc != 0) {
6852                 pr_err("error %d\n", rc);
6853                 goto rw_error;
6854         }
6855         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_COARSE__A, 240, 0);
6856         if (rc != 0) {
6857                 pr_err("error %d\n", rc);
6858                 goto rw_error;
6859         }
6860         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_FINE__A, 5, 0);
6861         if (rc != 0) {
6862                 pr_err("error %d\n", rc);
6863                 goto rw_error;
6864         }
6865         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 15, 0);
6866         if (rc != 0) {
6867                 pr_err("error %d\n", rc);
6868                 goto rw_error;
6869         }
6870         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_COARSE__A, 32, 0);
6871         if (rc != 0) {
6872                 pr_err("error %d\n", rc);
6873                 goto rw_error;
6874         }
6875
6876         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_SL_SIG_POWER__A, 40960, 0);
6877         if (rc != 0) {
6878                 pr_err("error %d\n", rc);
6879                 goto rw_error;
6880         }
6881
6882         return 0;
6883 rw_error:
6884         return rc;
6885 }
6886
6887 /*============================================================================*/
6888
6889 /**
6890 * \fn int set_qam32 ()
6891 * \brief QAM32 specific setup
6892 * \param demod instance of demod.
6893 * \return int.
6894 */
6895 static int set_qam32(struct drx_demod_instance *demod)
6896 {
6897         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
6898         int rc;
6899         const u8 qam_dq_qual_fun[] = {
6900                 DRXJ_16TO8(3),  /* fun0  */
6901                 DRXJ_16TO8(3),  /* fun1  */
6902                 DRXJ_16TO8(3),  /* fun2  */
6903                 DRXJ_16TO8(3),  /* fun3  */
6904                 DRXJ_16TO8(4),  /* fun4  */
6905                 DRXJ_16TO8(4),  /* fun5  */
6906         };
6907         const u8 qam_eq_cma_rad[] = {
6908                 DRXJ_16TO8(6707),       /* RAD0  */
6909                 DRXJ_16TO8(6707),       /* RAD1  */
6910                 DRXJ_16TO8(6707),       /* RAD2  */
6911                 DRXJ_16TO8(6707),       /* RAD3  */
6912                 DRXJ_16TO8(6707),       /* RAD4  */
6913                 DRXJ_16TO8(6707),       /* RAD5  */
6914         };
6915
6916         rc = drxdap_fasi_write_block(dev_addr, QAM_DQ_QUAL_FUN0__A, sizeof(qam_dq_qual_fun), ((u8 *)qam_dq_qual_fun), 0);
6917         if (rc != 0) {
6918                 pr_err("error %d\n", rc);
6919                 goto rw_error;
6920         }
6921         rc = drxdap_fasi_write_block(dev_addr, SCU_RAM_QAM_EQ_CMA_RAD0__A, sizeof(qam_eq_cma_rad), ((u8 *)qam_eq_cma_rad), 0);
6922         if (rc != 0) {
6923                 pr_err("error %d\n", rc);
6924                 goto rw_error;
6925         }
6926
6927         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RTH__A, 90, 0);
6928         if (rc != 0) {
6929                 pr_err("error %d\n", rc);
6930                 goto rw_error;
6931         }
6932         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_FTH__A, 50, 0);
6933         if (rc != 0) {
6934                 pr_err("error %d\n", rc);
6935                 goto rw_error;
6936         }
6937         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_PTH__A, 100, 0);
6938         if (rc != 0) {
6939                 pr_err("error %d\n", rc);
6940                 goto rw_error;
6941         }
6942         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_QTH__A, 170, 0);
6943         if (rc != 0) {
6944                 pr_err("error %d\n", rc);
6945                 goto rw_error;
6946         }
6947         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_CTH__A, 80, 0);
6948         if (rc != 0) {
6949                 pr_err("error %d\n", rc);
6950                 goto rw_error;
6951         }
6952         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_MTH__A, 100, 0);
6953         if (rc != 0) {
6954                 pr_err("error %d\n", rc);
6955                 goto rw_error;
6956         }
6957
6958         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RATE_LIM__A, 40, 0);
6959         if (rc != 0) {
6960                 pr_err("error %d\n", rc);
6961                 goto rw_error;
6962         }
6963         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_FREQ_LIM__A, 56, 0);
6964         if (rc != 0) {
6965                 pr_err("error %d\n", rc);
6966                 goto rw_error;
6967         }
6968         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_COUNT_LIM__A, 3, 0);
6969         if (rc != 0) {
6970                 pr_err("error %d\n", rc);
6971                 goto rw_error;
6972         }
6973
6974         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, 12, 0);
6975         if (rc != 0) {
6976                 pr_err("error %d\n", rc);
6977                 goto rw_error;
6978         }
6979         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, 140, 0);
6980         if (rc != 0) {
6981                 pr_err("error %d\n", rc);
6982                 goto rw_error;
6983         }
6984         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16)(-8), 0);
6985         if (rc != 0) {
6986                 pr_err("error %d\n", rc);
6987                 goto rw_error;
6988         }
6989         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16)(-16), 0);
6990         if (rc != 0) {
6991                 pr_err("error %d\n", rc);
6992                 goto rw_error;
6993         }
6994         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16)(-26), 0);
6995         if (rc != 0) {
6996                 pr_err("error %d\n", rc);
6997                 goto rw_error;
6998         }
6999         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16)(-56), 0);
7000         if (rc != 0) {
7001                 pr_err("error %d\n", rc);
7002                 goto rw_error;
7003         }
7004         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16)(-86), 0);
7005         if (rc != 0) {
7006                 pr_err("error %d\n", rc);
7007                 goto rw_error;
7008         }
7009
7010         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CA_FINE__A, 15, 0);
7011         if (rc != 0) {
7012                 pr_err("error %d\n", rc);
7013                 goto rw_error;
7014         }
7015         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CA_COARSE__A, 40, 0);
7016         if (rc != 0) {
7017                 pr_err("error %d\n", rc);
7018                 goto rw_error;
7019         }
7020         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_FINE__A, 2, 0);
7021         if (rc != 0) {
7022                 pr_err("error %d\n", rc);
7023                 goto rw_error;
7024         }
7025         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_MEDIUM__A, 20, 0);
7026         if (rc != 0) {
7027                 pr_err("error %d\n", rc);
7028                 goto rw_error;
7029         }
7030         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_COARSE__A, 255, 0);
7031         if (rc != 0) {
7032                 pr_err("error %d\n", rc);
7033                 goto rw_error;
7034         }
7035         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_FINE__A, 2, 0);
7036         if (rc != 0) {
7037                 pr_err("error %d\n", rc);
7038                 goto rw_error;
7039         }
7040         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_MEDIUM__A, 10, 0);
7041         if (rc != 0) {
7042                 pr_err("error %d\n", rc);
7043                 goto rw_error;
7044         }
7045         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_COARSE__A, 50, 0);
7046         if (rc != 0) {
7047                 pr_err("error %d\n", rc);
7048                 goto rw_error;
7049         }
7050         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_FINE__A, 12, 0);
7051         if (rc != 0) {
7052                 pr_err("error %d\n", rc);
7053                 goto rw_error;
7054         }
7055         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24, 0);
7056         if (rc != 0) {
7057                 pr_err("error %d\n", rc);
7058                 goto rw_error;
7059         }
7060         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_COARSE__A, 24, 0);
7061         if (rc != 0) {
7062                 pr_err("error %d\n", rc);
7063                 goto rw_error;
7064         }
7065         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_FINE__A, 12, 0);
7066         if (rc != 0) {
7067                 pr_err("error %d\n", rc);
7068                 goto rw_error;
7069         }
7070         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16, 0);
7071         if (rc != 0) {
7072                 pr_err("error %d\n", rc);
7073                 goto rw_error;
7074         }
7075         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_COARSE__A, 16, 0);
7076         if (rc != 0) {
7077                 pr_err("error %d\n", rc);
7078                 goto rw_error;
7079         }
7080         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_FINE__A, 16, 0);
7081         if (rc != 0) {
7082                 pr_err("error %d\n", rc);
7083                 goto rw_error;
7084         }
7085         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_MEDIUM__A, 32, 0);
7086         if (rc != 0) {
7087                 pr_err("error %d\n", rc);
7088                 goto rw_error;
7089         }
7090         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_COARSE__A, 176, 0);
7091         if (rc != 0) {
7092                 pr_err("error %d\n", rc);
7093                 goto rw_error;
7094         }
7095         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_FINE__A, 5, 0);
7096         if (rc != 0) {
7097                 pr_err("error %d\n", rc);
7098                 goto rw_error;
7099         }
7100         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 15, 0);
7101         if (rc != 0) {
7102                 pr_err("error %d\n", rc);
7103                 goto rw_error;
7104         }
7105         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_COARSE__A, 8, 0);
7106         if (rc != 0) {
7107                 pr_err("error %d\n", rc);
7108                 goto rw_error;
7109         }
7110
7111         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_SL_SIG_POWER__A, 20480, 0);
7112         if (rc != 0) {
7113                 pr_err("error %d\n", rc);
7114                 goto rw_error;
7115         }
7116
7117         return 0;
7118 rw_error:
7119         return rc;
7120 }
7121
7122 /*============================================================================*/
7123
7124 /**
7125 * \fn int set_qam64 ()
7126 * \brief QAM64 specific setup
7127 * \param demod instance of demod.
7128 * \return int.
7129 */
7130 static int set_qam64(struct drx_demod_instance *demod)
7131 {
7132         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
7133         int rc;
7134         const u8 qam_dq_qual_fun[] = {  /* this is hw reset value. no necessary to re-write */
7135                 DRXJ_16TO8(4),  /* fun0  */
7136                 DRXJ_16TO8(4),  /* fun1  */
7137                 DRXJ_16TO8(4),  /* fun2  */
7138                 DRXJ_16TO8(4),  /* fun3  */
7139                 DRXJ_16TO8(6),  /* fun4  */
7140                 DRXJ_16TO8(6),  /* fun5  */
7141         };
7142         const u8 qam_eq_cma_rad[] = {
7143                 DRXJ_16TO8(13336),      /* RAD0  */
7144                 DRXJ_16TO8(12618),      /* RAD1  */
7145                 DRXJ_16TO8(11988),      /* RAD2  */
7146                 DRXJ_16TO8(13809),      /* RAD3  */
7147                 DRXJ_16TO8(13809),      /* RAD4  */
7148                 DRXJ_16TO8(15609),      /* RAD5  */
7149         };
7150
7151         rc = drxdap_fasi_write_block(dev_addr, QAM_DQ_QUAL_FUN0__A, sizeof(qam_dq_qual_fun), ((u8 *)qam_dq_qual_fun), 0);
7152         if (rc != 0) {
7153                 pr_err("error %d\n", rc);
7154                 goto rw_error;
7155         }
7156         rc = drxdap_fasi_write_block(dev_addr, SCU_RAM_QAM_EQ_CMA_RAD0__A, sizeof(qam_eq_cma_rad), ((u8 *)qam_eq_cma_rad), 0);
7157         if (rc != 0) {
7158                 pr_err("error %d\n", rc);
7159                 goto rw_error;
7160         }
7161
7162         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RTH__A, 105, 0);
7163         if (rc != 0) {
7164                 pr_err("error %d\n", rc);
7165                 goto rw_error;
7166         }
7167         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_FTH__A, 60, 0);
7168         if (rc != 0) {
7169                 pr_err("error %d\n", rc);
7170                 goto rw_error;
7171         }
7172         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_PTH__A, 100, 0);
7173         if (rc != 0) {
7174                 pr_err("error %d\n", rc);
7175                 goto rw_error;
7176         }
7177         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_QTH__A, 195, 0);
7178         if (rc != 0) {
7179                 pr_err("error %d\n", rc);
7180                 goto rw_error;
7181         }
7182         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_CTH__A, 80, 0);
7183         if (rc != 0) {
7184                 pr_err("error %d\n", rc);
7185                 goto rw_error;
7186         }
7187         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_MTH__A, 84, 0);
7188         if (rc != 0) {
7189                 pr_err("error %d\n", rc);
7190                 goto rw_error;
7191         }
7192
7193         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RATE_LIM__A, 40, 0);
7194         if (rc != 0) {
7195                 pr_err("error %d\n", rc);
7196                 goto rw_error;
7197         }
7198         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_FREQ_LIM__A, 32, 0);
7199         if (rc != 0) {
7200                 pr_err("error %d\n", rc);
7201                 goto rw_error;
7202         }
7203         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_COUNT_LIM__A, 3, 0);
7204         if (rc != 0) {
7205                 pr_err("error %d\n", rc);
7206                 goto rw_error;
7207         }
7208
7209         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, 12, 0);
7210         if (rc != 0) {
7211                 pr_err("error %d\n", rc);
7212                 goto rw_error;
7213         }
7214         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, 141, 0);
7215         if (rc != 0) {
7216                 pr_err("error %d\n", rc);
7217                 goto rw_error;
7218         }
7219         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, 7, 0);
7220         if (rc != 0) {
7221                 pr_err("error %d\n", rc);
7222                 goto rw_error;
7223         }
7224         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, 0, 0);
7225         if (rc != 0) {
7226                 pr_err("error %d\n", rc);
7227                 goto rw_error;
7228         }
7229         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16)(-15), 0);
7230         if (rc != 0) {
7231                 pr_err("error %d\n", rc);
7232                 goto rw_error;
7233         }
7234         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16)(-45), 0);
7235         if (rc != 0) {
7236                 pr_err("error %d\n", rc);
7237                 goto rw_error;
7238         }
7239         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16)(-80), 0);
7240         if (rc != 0) {
7241                 pr_err("error %d\n", rc);
7242                 goto rw_error;
7243         }
7244
7245         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CA_FINE__A, 15, 0);
7246         if (rc != 0) {
7247                 pr_err("error %d\n", rc);
7248                 goto rw_error;
7249         }
7250         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CA_COARSE__A, 40, 0);
7251         if (rc != 0) {
7252                 pr_err("error %d\n", rc);
7253                 goto rw_error;
7254         }
7255         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_FINE__A, 2, 0);
7256         if (rc != 0) {
7257                 pr_err("error %d\n", rc);
7258                 goto rw_error;
7259         }
7260         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_MEDIUM__A, 30, 0);
7261         if (rc != 0) {
7262                 pr_err("error %d\n", rc);
7263                 goto rw_error;
7264         }
7265         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_COARSE__A, 255, 0);
7266         if (rc != 0) {
7267                 pr_err("error %d\n", rc);
7268                 goto rw_error;
7269         }
7270         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_FINE__A, 2, 0);
7271         if (rc != 0) {
7272                 pr_err("error %d\n", rc);
7273                 goto rw_error;
7274         }
7275         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_MEDIUM__A, 15, 0);
7276         if (rc != 0) {
7277                 pr_err("error %d\n", rc);
7278                 goto rw_error;
7279         }
7280         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_COARSE__A, 80, 0);
7281         if (rc != 0) {
7282                 pr_err("error %d\n", rc);
7283                 goto rw_error;
7284         }
7285         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_FINE__A, 12, 0);
7286         if (rc != 0) {
7287                 pr_err("error %d\n", rc);
7288                 goto rw_error;
7289         }
7290         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24, 0);
7291         if (rc != 0) {
7292                 pr_err("error %d\n", rc);
7293                 goto rw_error;
7294         }
7295         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_COARSE__A, 24, 0);
7296         if (rc != 0) {
7297                 pr_err("error %d\n", rc);
7298                 goto rw_error;
7299         }
7300         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_FINE__A, 12, 0);
7301         if (rc != 0) {
7302                 pr_err("error %d\n", rc);
7303                 goto rw_error;
7304         }
7305         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16, 0);
7306         if (rc != 0) {
7307                 pr_err("error %d\n", rc);
7308                 goto rw_error;
7309         }
7310         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_COARSE__A, 16, 0);
7311         if (rc != 0) {
7312                 pr_err("error %d\n", rc);
7313                 goto rw_error;
7314         }
7315         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_FINE__A, 16, 0);
7316         if (rc != 0) {
7317                 pr_err("error %d\n", rc);
7318                 goto rw_error;
7319         }
7320         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_MEDIUM__A, 48, 0);
7321         if (rc != 0) {
7322                 pr_err("error %d\n", rc);
7323                 goto rw_error;
7324         }
7325         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_COARSE__A, 160, 0);
7326         if (rc != 0) {
7327                 pr_err("error %d\n", rc);
7328                 goto rw_error;
7329         }
7330         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_FINE__A, 5, 0);
7331         if (rc != 0) {
7332                 pr_err("error %d\n", rc);
7333                 goto rw_error;
7334         }
7335         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 15, 0);
7336         if (rc != 0) {
7337                 pr_err("error %d\n", rc);
7338                 goto rw_error;
7339         }
7340         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_COARSE__A, 32, 0);
7341         if (rc != 0) {
7342                 pr_err("error %d\n", rc);
7343                 goto rw_error;
7344         }
7345
7346         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_SL_SIG_POWER__A, 43008, 0);
7347         if (rc != 0) {
7348                 pr_err("error %d\n", rc);
7349                 goto rw_error;
7350         }
7351
7352         return 0;
7353 rw_error:
7354         return rc;
7355 }
7356
7357 /*============================================================================*/
7358
7359 /**
7360 * \fn int set_qam128 ()
7361 * \brief QAM128 specific setup
7362 * \param demod: instance of demod.
7363 * \return int.
7364 */
7365 static int set_qam128(struct drx_demod_instance *demod)
7366 {
7367         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
7368         int rc;
7369         const u8 qam_dq_qual_fun[] = {
7370                 DRXJ_16TO8(6),  /* fun0  */
7371                 DRXJ_16TO8(6),  /* fun1  */
7372                 DRXJ_16TO8(6),  /* fun2  */
7373                 DRXJ_16TO8(6),  /* fun3  */
7374                 DRXJ_16TO8(9),  /* fun4  */
7375                 DRXJ_16TO8(9),  /* fun5  */
7376         };
7377         const u8 qam_eq_cma_rad[] = {
7378                 DRXJ_16TO8(6164),       /* RAD0  */
7379                 DRXJ_16TO8(6598),       /* RAD1  */
7380                 DRXJ_16TO8(6394),       /* RAD2  */
7381                 DRXJ_16TO8(6409),       /* RAD3  */
7382                 DRXJ_16TO8(6656),       /* RAD4  */
7383                 DRXJ_16TO8(7238),       /* RAD5  */
7384         };
7385
7386         rc = drxdap_fasi_write_block(dev_addr, QAM_DQ_QUAL_FUN0__A, sizeof(qam_dq_qual_fun), ((u8 *)qam_dq_qual_fun), 0);
7387         if (rc != 0) {
7388                 pr_err("error %d\n", rc);
7389                 goto rw_error;
7390         }
7391         rc = drxdap_fasi_write_block(dev_addr, SCU_RAM_QAM_EQ_CMA_RAD0__A, sizeof(qam_eq_cma_rad), ((u8 *)qam_eq_cma_rad), 0);
7392         if (rc != 0) {
7393                 pr_err("error %d\n", rc);
7394                 goto rw_error;
7395         }
7396
7397         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RTH__A, 50, 0);
7398         if (rc != 0) {
7399                 pr_err("error %d\n", rc);
7400                 goto rw_error;
7401         }
7402         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_FTH__A, 60, 0);
7403         if (rc != 0) {
7404                 pr_err("error %d\n", rc);
7405                 goto rw_error;
7406         }
7407         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_PTH__A, 100, 0);
7408         if (rc != 0) {
7409                 pr_err("error %d\n", rc);
7410                 goto rw_error;
7411         }
7412         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_QTH__A, 140, 0);
7413         if (rc != 0) {
7414                 pr_err("error %d\n", rc);
7415                 goto rw_error;
7416         }
7417         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_CTH__A, 80, 0);
7418         if (rc != 0) {
7419                 pr_err("error %d\n", rc);
7420                 goto rw_error;
7421         }
7422         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_MTH__A, 100, 0);
7423         if (rc != 0) {
7424                 pr_err("error %d\n", rc);
7425                 goto rw_error;
7426         }
7427
7428         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RATE_LIM__A, 40, 0);
7429         if (rc != 0) {
7430                 pr_err("error %d\n", rc);
7431                 goto rw_error;
7432         }
7433         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_FREQ_LIM__A, 32, 0);
7434         if (rc != 0) {
7435                 pr_err("error %d\n", rc);
7436                 goto rw_error;
7437         }
7438         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_COUNT_LIM__A, 3, 0);
7439         if (rc != 0) {
7440                 pr_err("error %d\n", rc);
7441                 goto rw_error;
7442         }
7443
7444         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, 8, 0);
7445         if (rc != 0) {
7446                 pr_err("error %d\n", rc);
7447                 goto rw_error;
7448         }
7449         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, 65, 0);
7450         if (rc != 0) {
7451                 pr_err("error %d\n", rc);
7452                 goto rw_error;
7453         }
7454         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, 5, 0);
7455         if (rc != 0) {
7456                 pr_err("error %d\n", rc);
7457                 goto rw_error;
7458         }
7459         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, 3, 0);
7460         if (rc != 0) {
7461                 pr_err("error %d\n", rc);
7462                 goto rw_error;
7463         }
7464         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16)(-1), 0);
7465         if (rc != 0) {
7466                 pr_err("error %d\n", rc);
7467                 goto rw_error;
7468         }
7469         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, 12, 0);
7470         if (rc != 0) {
7471                 pr_err("error %d\n", rc);
7472                 goto rw_error;
7473         }
7474         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16)(-23), 0);
7475         if (rc != 0) {
7476                 pr_err("error %d\n", rc);
7477                 goto rw_error;
7478         }
7479
7480         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CA_FINE__A, 15, 0);
7481         if (rc != 0) {
7482                 pr_err("error %d\n", rc);
7483                 goto rw_error;
7484         }
7485         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CA_COARSE__A, 40, 0);
7486         if (rc != 0) {
7487                 pr_err("error %d\n", rc);
7488                 goto rw_error;
7489         }
7490         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_FINE__A, 2, 0);
7491         if (rc != 0) {
7492                 pr_err("error %d\n", rc);
7493                 goto rw_error;
7494         }
7495         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_MEDIUM__A, 40, 0);
7496         if (rc != 0) {
7497                 pr_err("error %d\n", rc);
7498                 goto rw_error;
7499         }
7500         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_COARSE__A, 255, 0);
7501         if (rc != 0) {
7502                 pr_err("error %d\n", rc);
7503                 goto rw_error;
7504         }
7505         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_FINE__A, 2, 0);
7506         if (rc != 0) {
7507                 pr_err("error %d\n", rc);
7508                 goto rw_error;
7509         }
7510         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_MEDIUM__A, 20, 0);
7511         if (rc != 0) {
7512                 pr_err("error %d\n", rc);
7513                 goto rw_error;
7514         }
7515         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_COARSE__A, 80, 0);
7516         if (rc != 0) {
7517                 pr_err("error %d\n", rc);
7518                 goto rw_error;
7519         }
7520         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_FINE__A, 12, 0);
7521         if (rc != 0) {
7522                 pr_err("error %d\n", rc);
7523                 goto rw_error;
7524         }
7525         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24, 0);
7526         if (rc != 0) {
7527                 pr_err("error %d\n", rc);
7528                 goto rw_error;
7529         }
7530         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_COARSE__A, 24, 0);
7531         if (rc != 0) {
7532                 pr_err("error %d\n", rc);
7533                 goto rw_error;
7534         }
7535         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_FINE__A, 12, 0);
7536         if (rc != 0) {
7537                 pr_err("error %d\n", rc);
7538                 goto rw_error;
7539         }
7540         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16, 0);
7541         if (rc != 0) {
7542                 pr_err("error %d\n", rc);
7543                 goto rw_error;
7544         }
7545         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_COARSE__A, 16, 0);
7546         if (rc != 0) {
7547                 pr_err("error %d\n", rc);
7548                 goto rw_error;
7549         }
7550         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_FINE__A, 16, 0);
7551         if (rc != 0) {
7552                 pr_err("error %d\n", rc);
7553                 goto rw_error;
7554         }
7555         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_MEDIUM__A, 32, 0);
7556         if (rc != 0) {
7557                 pr_err("error %d\n", rc);
7558                 goto rw_error;
7559         }
7560         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_COARSE__A, 144, 0);
7561         if (rc != 0) {
7562                 pr_err("error %d\n", rc);
7563                 goto rw_error;
7564         }
7565         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_FINE__A, 5, 0);
7566         if (rc != 0) {
7567                 pr_err("error %d\n", rc);
7568                 goto rw_error;
7569         }
7570         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 15, 0);
7571         if (rc != 0) {
7572                 pr_err("error %d\n", rc);
7573                 goto rw_error;
7574         }
7575         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_COARSE__A, 16, 0);
7576         if (rc != 0) {
7577                 pr_err("error %d\n", rc);
7578                 goto rw_error;
7579         }
7580
7581         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_SL_SIG_POWER__A, 20992, 0);
7582         if (rc != 0) {
7583                 pr_err("error %d\n", rc);
7584                 goto rw_error;
7585         }
7586
7587         return 0;
7588 rw_error:
7589         return rc;
7590 }
7591
7592 /*============================================================================*/
7593
7594 /**
7595 * \fn int set_qam256 ()
7596 * \brief QAM256 specific setup
7597 * \param demod: instance of demod.
7598 * \return int.
7599 */
7600 static int set_qam256(struct drx_demod_instance *demod)
7601 {
7602         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
7603         int rc;
7604         const u8 qam_dq_qual_fun[] = {
7605                 DRXJ_16TO8(8),  /* fun0  */
7606                 DRXJ_16TO8(8),  /* fun1  */
7607                 DRXJ_16TO8(8),  /* fun2  */
7608                 DRXJ_16TO8(8),  /* fun3  */
7609                 DRXJ_16TO8(12), /* fun4  */
7610                 DRXJ_16TO8(12), /* fun5  */
7611         };
7612         const u8 qam_eq_cma_rad[] = {
7613                 DRXJ_16TO8(12345),      /* RAD0  */
7614                 DRXJ_16TO8(12345),      /* RAD1  */
7615                 DRXJ_16TO8(13626),      /* RAD2  */
7616                 DRXJ_16TO8(12931),      /* RAD3  */
7617                 DRXJ_16TO8(14719),      /* RAD4  */
7618                 DRXJ_16TO8(15356),      /* RAD5  */
7619         };
7620
7621         rc = drxdap_fasi_write_block(dev_addr, QAM_DQ_QUAL_FUN0__A, sizeof(qam_dq_qual_fun), ((u8 *)qam_dq_qual_fun), 0);
7622         if (rc != 0) {
7623                 pr_err("error %d\n", rc);
7624                 goto rw_error;
7625         }
7626         rc = drxdap_fasi_write_block(dev_addr, SCU_RAM_QAM_EQ_CMA_RAD0__A, sizeof(qam_eq_cma_rad), ((u8 *)qam_eq_cma_rad), 0);
7627         if (rc != 0) {
7628                 pr_err("error %d\n", rc);
7629                 goto rw_error;
7630         }
7631
7632         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RTH__A, 50, 0);
7633         if (rc != 0) {
7634                 pr_err("error %d\n", rc);
7635                 goto rw_error;
7636         }
7637         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_FTH__A, 60, 0);
7638         if (rc != 0) {
7639                 pr_err("error %d\n", rc);
7640                 goto rw_error;
7641         }
7642         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_PTH__A, 100, 0);
7643         if (rc != 0) {
7644                 pr_err("error %d\n", rc);
7645                 goto rw_error;
7646         }
7647         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_QTH__A, 150, 0);
7648         if (rc != 0) {
7649                 pr_err("error %d\n", rc);
7650                 goto rw_error;
7651         }
7652         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_CTH__A, 80, 0);
7653         if (rc != 0) {
7654                 pr_err("error %d\n", rc);
7655                 goto rw_error;
7656         }
7657         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_MTH__A, 110, 0);
7658         if (rc != 0) {
7659                 pr_err("error %d\n", rc);
7660                 goto rw_error;
7661         }
7662
7663         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RATE_LIM__A, 40, 0);
7664         if (rc != 0) {
7665                 pr_err("error %d\n", rc);
7666                 goto rw_error;
7667         }
7668         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_FREQ_LIM__A, 16, 0);
7669         if (rc != 0) {
7670                 pr_err("error %d\n", rc);
7671                 goto rw_error;
7672         }
7673         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_COUNT_LIM__A, 3, 0);
7674         if (rc != 0) {
7675                 pr_err("error %d\n", rc);
7676                 goto rw_error;
7677         }
7678
7679         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, 8, 0);
7680         if (rc != 0) {
7681                 pr_err("error %d\n", rc);
7682                 goto rw_error;
7683         }
7684         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, 74, 0);
7685         if (rc != 0) {
7686                 pr_err("error %d\n", rc);
7687                 goto rw_error;
7688         }
7689         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, 18, 0);
7690         if (rc != 0) {
7691                 pr_err("error %d\n", rc);
7692                 goto rw_error;
7693         }
7694         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, 13, 0);
7695         if (rc != 0) {
7696                 pr_err("error %d\n", rc);
7697                 goto rw_error;
7698         }
7699         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, 7, 0);
7700         if (rc != 0) {
7701                 pr_err("error %d\n", rc);
7702                 goto rw_error;
7703         }
7704         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, 0, 0);
7705         if (rc != 0) {
7706                 pr_err("error %d\n", rc);
7707                 goto rw_error;
7708         }
7709         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16)(-8), 0);
7710         if (rc != 0) {
7711                 pr_err("error %d\n", rc);
7712                 goto rw_error;
7713         }
7714
7715         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CA_FINE__A, 15, 0);
7716         if (rc != 0) {
7717                 pr_err("error %d\n", rc);
7718                 goto rw_error;
7719         }
7720         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CA_COARSE__A, 40, 0);
7721         if (rc != 0) {
7722                 pr_err("error %d\n", rc);
7723                 goto rw_error;
7724         }
7725         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_FINE__A, 2, 0);
7726         if (rc != 0) {
7727                 pr_err("error %d\n", rc);
7728                 goto rw_error;
7729         }
7730         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_MEDIUM__A, 50, 0);
7731         if (rc != 0) {
7732                 pr_err("error %d\n", rc);
7733                 goto rw_error;
7734         }
7735         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CP_COARSE__A, 255, 0);
7736         if (rc != 0) {
7737                 pr_err("error %d\n", rc);
7738                 goto rw_error;
7739         }
7740         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_FINE__A, 2, 0);
7741         if (rc != 0) {
7742                 pr_err("error %d\n", rc);
7743                 goto rw_error;
7744         }
7745         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_MEDIUM__A, 25, 0);
7746         if (rc != 0) {
7747                 pr_err("error %d\n", rc);
7748                 goto rw_error;
7749         }
7750         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CI_COARSE__A, 80, 0);
7751         if (rc != 0) {
7752                 pr_err("error %d\n", rc);
7753                 goto rw_error;
7754         }
7755         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_FINE__A, 12, 0);
7756         if (rc != 0) {
7757                 pr_err("error %d\n", rc);
7758                 goto rw_error;
7759         }
7760         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24, 0);
7761         if (rc != 0) {
7762                 pr_err("error %d\n", rc);
7763                 goto rw_error;
7764         }
7765         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EP_COARSE__A, 24, 0);
7766         if (rc != 0) {
7767                 pr_err("error %d\n", rc);
7768                 goto rw_error;
7769         }
7770         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_FINE__A, 12, 0);
7771         if (rc != 0) {
7772                 pr_err("error %d\n", rc);
7773                 goto rw_error;
7774         }
7775         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16, 0);
7776         if (rc != 0) {
7777                 pr_err("error %d\n", rc);
7778                 goto rw_error;
7779         }
7780         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_EI_COARSE__A, 16, 0);
7781         if (rc != 0) {
7782                 pr_err("error %d\n", rc);
7783                 goto rw_error;
7784         }
7785         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_FINE__A, 16, 0);
7786         if (rc != 0) {
7787                 pr_err("error %d\n", rc);
7788                 goto rw_error;
7789         }
7790         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_MEDIUM__A, 48, 0);
7791         if (rc != 0) {
7792                 pr_err("error %d\n", rc);
7793                 goto rw_error;
7794         }
7795         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF_COARSE__A, 80, 0);
7796         if (rc != 0) {
7797                 pr_err("error %d\n", rc);
7798                 goto rw_error;
7799         }
7800         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_FINE__A, 5, 0);
7801         if (rc != 0) {
7802                 pr_err("error %d\n", rc);
7803                 goto rw_error;
7804         }
7805         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 15, 0);
7806         if (rc != 0) {
7807                 pr_err("error %d\n", rc);
7808                 goto rw_error;
7809         }
7810         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_LC_CF1_COARSE__A, 16, 0);
7811         if (rc != 0) {
7812                 pr_err("error %d\n", rc);
7813                 goto rw_error;
7814         }
7815
7816         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_SL_SIG_POWER__A, 43520, 0);
7817         if (rc != 0) {
7818                 pr_err("error %d\n", rc);
7819                 goto rw_error;
7820         }
7821
7822         return 0;
7823 rw_error:
7824         return rc;
7825 }
7826
7827 /*============================================================================*/
7828 #define QAM_SET_OP_ALL 0x1
7829 #define QAM_SET_OP_CONSTELLATION 0x2
7830 #define QAM_SET_OP_SPECTRUM 0X4
7831
7832 /**
7833 * \fn int set_qam ()
7834 * \brief Set QAM demod.
7835 * \param demod:   instance of demod.
7836 * \param channel: pointer to channel data.
7837 * \return int.
7838 */
7839 static int
7840 set_qam(struct drx_demod_instance *demod,
7841         struct drx_channel *channel, s32 tuner_freq_offset, u32 op)
7842 {
7843         struct i2c_device_addr *dev_addr = NULL;
7844         struct drxj_data *ext_attr = NULL;
7845         struct drx_common_attr *common_attr = NULL;
7846         int rc;
7847         u32 adc_frequency = 0;
7848         u32 iqm_rc_rate = 0;
7849         u16 cmd_result = 0;
7850         u16 lc_symbol_freq = 0;
7851         u16 iqm_rc_stretch = 0;
7852         u16 set_env_parameters = 0;
7853         u16 set_param_parameters[2] = { 0 };
7854         struct drxjscu_cmd cmd_scu = { /* command      */ 0,
7855                 /* parameter_len */ 0,
7856                 /* result_len    */ 0,
7857                 /* parameter    */ NULL,
7858                 /* result       */ NULL
7859         };
7860         const u8 qam_a_taps[] = {
7861                 DRXJ_16TO8(-1), /* re0  */
7862                 DRXJ_16TO8(1),  /* re1  */
7863                 DRXJ_16TO8(1),  /* re2  */
7864                 DRXJ_16TO8(-1), /* re3  */
7865                 DRXJ_16TO8(-1), /* re4  */
7866                 DRXJ_16TO8(2),  /* re5  */
7867                 DRXJ_16TO8(1),  /* re6  */
7868                 DRXJ_16TO8(-2), /* re7  */
7869                 DRXJ_16TO8(0),  /* re8  */
7870                 DRXJ_16TO8(3),  /* re9  */
7871                 DRXJ_16TO8(-1), /* re10 */
7872                 DRXJ_16TO8(-3), /* re11 */
7873                 DRXJ_16TO8(4),  /* re12 */
7874                 DRXJ_16TO8(1),  /* re13 */
7875                 DRXJ_16TO8(-8), /* re14 */
7876                 DRXJ_16TO8(4),  /* re15 */
7877                 DRXJ_16TO8(13), /* re16 */
7878                 DRXJ_16TO8(-13),        /* re17 */
7879                 DRXJ_16TO8(-19),        /* re18 */
7880                 DRXJ_16TO8(28), /* re19 */
7881                 DRXJ_16TO8(25), /* re20 */
7882                 DRXJ_16TO8(-53),        /* re21 */
7883                 DRXJ_16TO8(-31),        /* re22 */
7884                 DRXJ_16TO8(96), /* re23 */
7885                 DRXJ_16TO8(37), /* re24 */
7886                 DRXJ_16TO8(-190),       /* re25 */
7887                 DRXJ_16TO8(-40),        /* re26 */
7888                 DRXJ_16TO8(619) /* re27 */
7889         };
7890         const u8 qam_b64_taps[] = {
7891                 DRXJ_16TO8(0),  /* re0  */
7892                 DRXJ_16TO8(-2), /* re1  */
7893                 DRXJ_16TO8(1),  /* re2  */
7894                 DRXJ_16TO8(2),  /* re3  */
7895                 DRXJ_16TO8(-2), /* re4  */
7896                 DRXJ_16TO8(0),  /* re5  */
7897                 DRXJ_16TO8(4),  /* re6  */
7898                 DRXJ_16TO8(-2), /* re7  */
7899                 DRXJ_16TO8(-4), /* re8  */
7900                 DRXJ_16TO8(4),  /* re9  */
7901                 DRXJ_16TO8(3),  /* re10 */
7902                 DRXJ_16TO8(-6), /* re11 */
7903                 DRXJ_16TO8(0),  /* re12 */
7904                 DRXJ_16TO8(6),  /* re13 */
7905                 DRXJ_16TO8(-5), /* re14 */
7906                 DRXJ_16TO8(-3), /* re15 */
7907                 DRXJ_16TO8(11), /* re16 */
7908                 DRXJ_16TO8(-4), /* re17 */
7909                 DRXJ_16TO8(-19),        /* re18 */
7910                 DRXJ_16TO8(19), /* re19 */
7911                 DRXJ_16TO8(28), /* re20 */
7912                 DRXJ_16TO8(-45),        /* re21 */
7913                 DRXJ_16TO8(-36),        /* re22 */
7914                 DRXJ_16TO8(90), /* re23 */
7915                 DRXJ_16TO8(42), /* re24 */
7916                 DRXJ_16TO8(-185),       /* re25 */
7917                 DRXJ_16TO8(-46),        /* re26 */
7918                 DRXJ_16TO8(614) /* re27 */
7919         };
7920         const u8 qam_b256_taps[] = {
7921                 DRXJ_16TO8(-2), /* re0  */
7922                 DRXJ_16TO8(4),  /* re1  */
7923                 DRXJ_16TO8(1),  /* re2  */
7924                 DRXJ_16TO8(-4), /* re3  */
7925                 DRXJ_16TO8(0),  /* re4  */
7926                 DRXJ_16TO8(4),  /* re5  */
7927                 DRXJ_16TO8(-2), /* re6  */
7928                 DRXJ_16TO8(-4), /* re7  */
7929                 DRXJ_16TO8(5),  /* re8  */
7930                 DRXJ_16TO8(2),  /* re9  */
7931                 DRXJ_16TO8(-8), /* re10 */
7932                 DRXJ_16TO8(2),  /* re11 */
7933                 DRXJ_16TO8(11), /* re12 */
7934                 DRXJ_16TO8(-8), /* re13 */
7935                 DRXJ_16TO8(-15),        /* re14 */
7936                 DRXJ_16TO8(16), /* re15 */
7937                 DRXJ_16TO8(19), /* re16 */
7938                 DRXJ_16TO8(-27),        /* re17 */
7939                 DRXJ_16TO8(-22),        /* re18 */
7940                 DRXJ_16TO8(44), /* re19 */
7941                 DRXJ_16TO8(26), /* re20 */
7942                 DRXJ_16TO8(-69),        /* re21 */
7943                 DRXJ_16TO8(-28),        /* re22 */
7944                 DRXJ_16TO8(110),        /* re23 */
7945                 DRXJ_16TO8(31), /* re24 */
7946                 DRXJ_16TO8(-201),       /* re25 */
7947                 DRXJ_16TO8(-32),        /* re26 */
7948                 DRXJ_16TO8(628) /* re27 */
7949         };
7950         const u8 qam_c_taps[] = {
7951                 DRXJ_16TO8(-3), /* re0  */
7952                 DRXJ_16TO8(3),  /* re1  */
7953                 DRXJ_16TO8(2),  /* re2  */
7954                 DRXJ_16TO8(-4), /* re3  */
7955                 DRXJ_16TO8(0),  /* re4  */
7956                 DRXJ_16TO8(4),  /* re5  */
7957                 DRXJ_16TO8(-1), /* re6  */
7958                 DRXJ_16TO8(-4), /* re7  */
7959                 DRXJ_16TO8(3),  /* re8  */
7960                 DRXJ_16TO8(3),  /* re9  */
7961                 DRXJ_16TO8(-5), /* re10 */
7962                 DRXJ_16TO8(0),  /* re11 */
7963                 DRXJ_16TO8(9),  /* re12 */
7964                 DRXJ_16TO8(-4), /* re13 */
7965                 DRXJ_16TO8(-12),        /* re14 */
7966                 DRXJ_16TO8(10), /* re15 */
7967                 DRXJ_16TO8(16), /* re16 */
7968                 DRXJ_16TO8(-21),        /* re17 */
7969                 DRXJ_16TO8(-20),        /* re18 */
7970                 DRXJ_16TO8(37), /* re19 */
7971                 DRXJ_16TO8(25), /* re20 */
7972                 DRXJ_16TO8(-62),        /* re21 */
7973                 DRXJ_16TO8(-28),        /* re22 */
7974                 DRXJ_16TO8(105),        /* re23 */
7975                 DRXJ_16TO8(31), /* re24 */
7976                 DRXJ_16TO8(-197),       /* re25 */
7977                 DRXJ_16TO8(-33),        /* re26 */
7978                 DRXJ_16TO8(626) /* re27 */
7979         };
7980
7981         dev_addr = demod->my_i2c_dev_addr;
7982         ext_attr = (struct drxj_data *) demod->my_ext_attr;
7983         common_attr = (struct drx_common_attr *) demod->my_common_attr;
7984
7985         if ((op & QAM_SET_OP_ALL) || (op & QAM_SET_OP_CONSTELLATION)) {
7986                 if (ext_attr->standard == DRX_STANDARD_ITU_B) {
7987                         switch (channel->constellation) {
7988                         case DRX_CONSTELLATION_QAM256:
7989                                 iqm_rc_rate = 0x00AE3562;
7990                                 lc_symbol_freq =
7991                                     QAM_LC_SYMBOL_FREQ_FREQ_QAM_B_256;
7992                                 channel->symbolrate = 5360537;
7993                                 iqm_rc_stretch = IQM_RC_STRETCH_QAM_B_256;
7994                                 break;
7995                         case DRX_CONSTELLATION_QAM64:
7996                                 iqm_rc_rate = 0x00C05A0E;
7997                                 lc_symbol_freq = 409;
7998                                 channel->symbolrate = 5056941;
7999                                 iqm_rc_stretch = IQM_RC_STRETCH_QAM_B_64;
8000                                 break;
8001                         default:
8002                                 return -EINVAL;
8003                         }
8004                 } else {
8005                         adc_frequency = (common_attr->sys_clock_freq * 1000) / 3;
8006                         if (channel->symbolrate == 0) {
8007                                 pr_err("error: channel symbolrate is zero!\n");
8008                                 return -EIO;
8009                         }
8010                         iqm_rc_rate =
8011                             (adc_frequency / channel->symbolrate) * (1 << 21) +
8012                             (frac28
8013                              ((adc_frequency % channel->symbolrate),
8014                               channel->symbolrate) >> 7) - (1 << 23);
8015                         lc_symbol_freq =
8016                             (u16) (frac28
8017                                      (channel->symbolrate +
8018                                       (adc_frequency >> 13),
8019                                       adc_frequency) >> 16);
8020                         if (lc_symbol_freq > 511)
8021                                 lc_symbol_freq = 511;
8022
8023                         iqm_rc_stretch = 21;
8024                 }
8025
8026                 if (ext_attr->standard == DRX_STANDARD_ITU_A) {
8027                         set_env_parameters = QAM_TOP_ANNEX_A;   /* annex             */
8028                         set_param_parameters[0] = channel->constellation;       /* constellation     */
8029                         set_param_parameters[1] = DRX_INTERLEAVEMODE_I12_J17;   /* interleave mode   */
8030                 } else if (ext_attr->standard == DRX_STANDARD_ITU_B) {
8031                         set_env_parameters = QAM_TOP_ANNEX_B;   /* annex             */
8032                         set_param_parameters[0] = channel->constellation;       /* constellation     */
8033                         set_param_parameters[1] = channel->interleavemode;      /* interleave mode   */
8034                 } else if (ext_attr->standard == DRX_STANDARD_ITU_C) {
8035                         set_env_parameters = QAM_TOP_ANNEX_C;   /* annex             */
8036                         set_param_parameters[0] = channel->constellation;       /* constellation     */
8037                         set_param_parameters[1] = DRX_INTERLEAVEMODE_I12_J17;   /* interleave mode   */
8038                 } else {
8039                         return -EINVAL;
8040                 }
8041         }
8042
8043         if (op & QAM_SET_OP_ALL) {
8044                 /*
8045                    STEP 1: reset demodulator
8046                    resets IQM, QAM and FEC HW blocks
8047                    resets SCU variables
8048                  */
8049                 /* stop all comm_exec */
8050                 rc = drxj_dap_write_reg16(dev_addr, FEC_COMM_EXEC__A, FEC_COMM_EXEC_STOP, 0);
8051                 if (rc != 0) {
8052                         pr_err("error %d\n", rc);
8053                         goto rw_error;
8054                 }
8055                 rc = drxj_dap_write_reg16(dev_addr, QAM_COMM_EXEC__A, QAM_COMM_EXEC_STOP, 0);
8056                 if (rc != 0) {
8057                         pr_err("error %d\n", rc);
8058                         goto rw_error;
8059                 }
8060                 rc = drxj_dap_write_reg16(dev_addr, IQM_FS_COMM_EXEC__A, IQM_FS_COMM_EXEC_STOP, 0);
8061                 if (rc != 0) {
8062                         pr_err("error %d\n", rc);
8063                         goto rw_error;
8064                 }
8065                 rc = drxj_dap_write_reg16(dev_addr, IQM_FD_COMM_EXEC__A, IQM_FD_COMM_EXEC_STOP, 0);
8066                 if (rc != 0) {
8067                         pr_err("error %d\n", rc);
8068                         goto rw_error;
8069                 }
8070                 rc = drxj_dap_write_reg16(dev_addr, IQM_RC_COMM_EXEC__A, IQM_RC_COMM_EXEC_STOP, 0);
8071                 if (rc != 0) {
8072                         pr_err("error %d\n", rc);
8073                         goto rw_error;
8074                 }
8075                 rc = drxj_dap_write_reg16(dev_addr, IQM_RT_COMM_EXEC__A, IQM_RT_COMM_EXEC_STOP, 0);
8076                 if (rc != 0) {
8077                         pr_err("error %d\n", rc);
8078                         goto rw_error;
8079                 }
8080                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_COMM_EXEC__A, IQM_CF_COMM_EXEC_STOP, 0);
8081                 if (rc != 0) {
8082                         pr_err("error %d\n", rc);
8083                         goto rw_error;
8084                 }
8085
8086                 cmd_scu.command = SCU_RAM_COMMAND_STANDARD_QAM |
8087                     SCU_RAM_COMMAND_CMD_DEMOD_RESET;
8088                 cmd_scu.parameter_len = 0;
8089                 cmd_scu.result_len = 1;
8090                 cmd_scu.parameter = NULL;
8091                 cmd_scu.result = &cmd_result;
8092                 rc = scu_command(dev_addr, &cmd_scu);
8093                 if (rc != 0) {
8094                         pr_err("error %d\n", rc);
8095                         goto rw_error;
8096                 }
8097         }
8098
8099         if ((op & QAM_SET_OP_ALL) || (op & QAM_SET_OP_CONSTELLATION)) {
8100                 /*
8101                    STEP 2: configure demodulator
8102                    -set env
8103                    -set params (resets IQM,QAM,FEC HW; initializes some SCU variables )
8104                  */
8105                 cmd_scu.command = SCU_RAM_COMMAND_STANDARD_QAM |
8106                     SCU_RAM_COMMAND_CMD_DEMOD_SET_ENV;
8107                 cmd_scu.parameter_len = 1;
8108                 cmd_scu.result_len = 1;
8109                 cmd_scu.parameter = &set_env_parameters;
8110                 cmd_scu.result = &cmd_result;
8111                 rc = scu_command(dev_addr, &cmd_scu);
8112                 if (rc != 0) {
8113                         pr_err("error %d\n", rc);
8114                         goto rw_error;
8115                 }
8116
8117                 cmd_scu.command = SCU_RAM_COMMAND_STANDARD_QAM |
8118                     SCU_RAM_COMMAND_CMD_DEMOD_SET_PARAM;
8119                 cmd_scu.parameter_len = 2;
8120                 cmd_scu.result_len = 1;
8121                 cmd_scu.parameter = set_param_parameters;
8122                 cmd_scu.result = &cmd_result;
8123                 rc = scu_command(dev_addr, &cmd_scu);
8124                 if (rc != 0) {
8125                         pr_err("error %d\n", rc);
8126                         goto rw_error;
8127                 }
8128                 /* set symbol rate */
8129                 rc = drxdap_fasi_write_reg32(dev_addr, IQM_RC_RATE_OFS_LO__A, iqm_rc_rate, 0);
8130                 if (rc != 0) {
8131                         pr_err("error %d\n", rc);
8132                         goto rw_error;
8133                 }
8134                 ext_attr->iqm_rc_rate_ofs = iqm_rc_rate;
8135                 rc = set_qam_measurement(demod, channel->constellation, channel->symbolrate);
8136                 if (rc != 0) {
8137                         pr_err("error %d\n", rc);
8138                         goto rw_error;
8139                 }
8140         }
8141         /* STEP 3: enable the system in a mode where the ADC provides valid signal
8142            setup constellation independent registers */
8143         /* from qam_cmd.py script (qam_driver_b) */
8144         /* TODO: remove re-writes of HW reset values */
8145         if ((op & QAM_SET_OP_ALL) || (op & QAM_SET_OP_SPECTRUM)) {
8146                 rc = set_frequency(demod, channel, tuner_freq_offset);
8147                 if (rc != 0) {
8148                         pr_err("error %d\n", rc);
8149                         goto rw_error;
8150                 }
8151         }
8152
8153         if ((op & QAM_SET_OP_ALL) || (op & QAM_SET_OP_CONSTELLATION)) {
8154
8155                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_SYMBOL_FREQ__A, lc_symbol_freq, 0);
8156                 if (rc != 0) {
8157                         pr_err("error %d\n", rc);
8158                         goto rw_error;
8159                 }
8160                 rc = drxj_dap_write_reg16(dev_addr, IQM_RC_STRETCH__A, iqm_rc_stretch, 0);
8161                 if (rc != 0) {
8162                         pr_err("error %d\n", rc);
8163                         goto rw_error;
8164                 }
8165         }
8166
8167         if (op & QAM_SET_OP_ALL) {
8168                 if (!ext_attr->has_lna) {
8169                         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_AMUX__A, 0x02, 0);
8170                         if (rc != 0) {
8171                                 pr_err("error %d\n", rc);
8172                                 goto rw_error;
8173                         }
8174                 }
8175                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_SYMMETRIC__A, 0, 0);
8176                 if (rc != 0) {
8177                         pr_err("error %d\n", rc);
8178                         goto rw_error;
8179                 }
8180                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_MIDTAP__A, 3, 0);
8181                 if (rc != 0) {
8182                         pr_err("error %d\n", rc);
8183                         goto rw_error;
8184                 }
8185                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_OUT_ENA__A, IQM_CF_OUT_ENA_QAM__M, 0);
8186                 if (rc != 0) {
8187                         pr_err("error %d\n", rc);
8188                         goto rw_error;
8189                 }
8190
8191                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_WR_RSV_0__A, 0x5f, 0);
8192                 if (rc != 0) {
8193                         pr_err("error %d\n", rc);
8194                         goto rw_error;
8195                 }       /* scu temporary shut down agc */
8196
8197                 rc = drxj_dap_write_reg16(dev_addr, IQM_AF_SYNC_SEL__A, 3, 0);
8198                 if (rc != 0) {
8199                         pr_err("error %d\n", rc);
8200                         goto rw_error;
8201                 }
8202                 rc = drxj_dap_write_reg16(dev_addr, IQM_AF_CLP_LEN__A, 0, 0);
8203                 if (rc != 0) {
8204                         pr_err("error %d\n", rc);
8205                         goto rw_error;
8206                 }
8207                 rc = drxj_dap_write_reg16(dev_addr, IQM_AF_CLP_TH__A, 448, 0);
8208                 if (rc != 0) {
8209                         pr_err("error %d\n", rc);
8210                         goto rw_error;
8211                 }
8212                 rc = drxj_dap_write_reg16(dev_addr, IQM_AF_SNS_LEN__A, 0, 0);
8213                 if (rc != 0) {
8214                         pr_err("error %d\n", rc);
8215                         goto rw_error;
8216                 }
8217                 rc = drxj_dap_write_reg16(dev_addr, IQM_AF_PDREF__A, 4, 0);
8218                 if (rc != 0) {
8219                         pr_err("error %d\n", rc);
8220                         goto rw_error;
8221                 }
8222                 rc = drxj_dap_write_reg16(dev_addr, IQM_AF_STDBY__A, 0x10, 0);
8223                 if (rc != 0) {
8224                         pr_err("error %d\n", rc);
8225                         goto rw_error;
8226                 }
8227                 rc = drxj_dap_write_reg16(dev_addr, IQM_AF_PGA_GAIN__A, 11, 0);
8228                 if (rc != 0) {
8229                         pr_err("error %d\n", rc);
8230                         goto rw_error;
8231                 }
8232
8233                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_POW_MEAS_LEN__A, 1, 0);
8234                 if (rc != 0) {
8235                         pr_err("error %d\n", rc);
8236                         goto rw_error;
8237                 }
8238                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_SCALE_SH__A, IQM_CF_SCALE_SH__PRE, 0);
8239                 if (rc != 0) {
8240                         pr_err("error %d\n", rc);
8241                         goto rw_error;
8242                 }       /*! reset default val ! */
8243
8244                 rc = drxj_dap_write_reg16(dev_addr, QAM_SY_TIMEOUT__A, QAM_SY_TIMEOUT__PRE, 0);
8245                 if (rc != 0) {
8246                         pr_err("error %d\n", rc);
8247                         goto rw_error;
8248                 }       /*! reset default val ! */
8249                 if (ext_attr->standard == DRX_STANDARD_ITU_B) {
8250                         rc = drxj_dap_write_reg16(dev_addr, QAM_SY_SYNC_LWM__A, QAM_SY_SYNC_LWM__PRE, 0);
8251                         if (rc != 0) {
8252                                 pr_err("error %d\n", rc);
8253                                 goto rw_error;
8254                         }       /*! reset default val ! */
8255                         rc = drxj_dap_write_reg16(dev_addr, QAM_SY_SYNC_AWM__A, QAM_SY_SYNC_AWM__PRE, 0);
8256                         if (rc != 0) {
8257                                 pr_err("error %d\n", rc);
8258                                 goto rw_error;
8259                         }       /*! reset default val ! */
8260                         rc = drxj_dap_write_reg16(dev_addr, QAM_SY_SYNC_HWM__A, QAM_SY_SYNC_HWM__PRE, 0);
8261                         if (rc != 0) {
8262                                 pr_err("error %d\n", rc);
8263                                 goto rw_error;
8264                         }       /*! reset default val ! */
8265                 } else {
8266                         switch (channel->constellation) {
8267                         case DRX_CONSTELLATION_QAM16:
8268                         case DRX_CONSTELLATION_QAM64:
8269                         case DRX_CONSTELLATION_QAM256:
8270                                 rc = drxj_dap_write_reg16(dev_addr, QAM_SY_SYNC_LWM__A, 0x03, 0);
8271                                 if (rc != 0) {
8272                                         pr_err("error %d\n", rc);
8273                                         goto rw_error;
8274                                 }
8275                                 rc = drxj_dap_write_reg16(dev_addr, QAM_SY_SYNC_AWM__A, 0x04, 0);
8276                                 if (rc != 0) {
8277                                         pr_err("error %d\n", rc);
8278                                         goto rw_error;
8279                                 }
8280                                 rc = drxj_dap_write_reg16(dev_addr, QAM_SY_SYNC_HWM__A, QAM_SY_SYNC_HWM__PRE, 0);
8281                                 if (rc != 0) {
8282                                         pr_err("error %d\n", rc);
8283                                         goto rw_error;
8284                                 }       /*! reset default val ! */
8285                                 break;
8286                         case DRX_CONSTELLATION_QAM32:
8287                         case DRX_CONSTELLATION_QAM128:
8288                                 rc = drxj_dap_write_reg16(dev_addr, QAM_SY_SYNC_LWM__A, 0x03, 0);
8289                                 if (rc != 0) {
8290                                         pr_err("error %d\n", rc);
8291                                         goto rw_error;
8292                                 }
8293                                 rc = drxj_dap_write_reg16(dev_addr, QAM_SY_SYNC_AWM__A, 0x05, 0);
8294                                 if (rc != 0) {
8295                                         pr_err("error %d\n", rc);
8296                                         goto rw_error;
8297                                 }
8298                                 rc = drxj_dap_write_reg16(dev_addr, QAM_SY_SYNC_HWM__A, 0x06, 0);
8299                                 if (rc != 0) {
8300                                         pr_err("error %d\n", rc);
8301                                         goto rw_error;
8302                                 }
8303                                 break;
8304                         default:
8305                                 return -EIO;
8306                         }       /* switch */
8307                 }
8308
8309                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_MODE__A, QAM_LC_MODE__PRE, 0);
8310                 if (rc != 0) {
8311                         pr_err("error %d\n", rc);
8312                         goto rw_error;
8313                 }       /*! reset default val ! */
8314                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_RATE_LIMIT__A, 3, 0);
8315                 if (rc != 0) {
8316                         pr_err("error %d\n", rc);
8317                         goto rw_error;
8318                 }
8319                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_LPF_FACTORP__A, 4, 0);
8320                 if (rc != 0) {
8321                         pr_err("error %d\n", rc);
8322                         goto rw_error;
8323                 }
8324                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_LPF_FACTORI__A, 4, 0);
8325                 if (rc != 0) {
8326                         pr_err("error %d\n", rc);
8327                         goto rw_error;
8328                 }
8329                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_MODE__A, 7, 0);
8330                 if (rc != 0) {
8331                         pr_err("error %d\n", rc);
8332                         goto rw_error;
8333                 }
8334                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB0__A, 1, 0);
8335                 if (rc != 0) {
8336                         pr_err("error %d\n", rc);
8337                         goto rw_error;
8338                 }
8339                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB1__A, 1, 0);
8340                 if (rc != 0) {
8341                         pr_err("error %d\n", rc);
8342                         goto rw_error;
8343                 }
8344                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB2__A, 1, 0);
8345                 if (rc != 0) {
8346                         pr_err("error %d\n", rc);
8347                         goto rw_error;
8348                 }
8349                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB3__A, 1, 0);
8350                 if (rc != 0) {
8351                         pr_err("error %d\n", rc);
8352                         goto rw_error;
8353                 }
8354                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB4__A, 2, 0);
8355                 if (rc != 0) {
8356                         pr_err("error %d\n", rc);
8357                         goto rw_error;
8358                 }
8359                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB5__A, 2, 0);
8360                 if (rc != 0) {
8361                         pr_err("error %d\n", rc);
8362                         goto rw_error;
8363                 }
8364                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB6__A, 2, 0);
8365                 if (rc != 0) {
8366                         pr_err("error %d\n", rc);
8367                         goto rw_error;
8368                 }
8369                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB8__A, 2, 0);
8370                 if (rc != 0) {
8371                         pr_err("error %d\n", rc);
8372                         goto rw_error;
8373                 }
8374                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB9__A, 2, 0);
8375                 if (rc != 0) {
8376                         pr_err("error %d\n", rc);
8377                         goto rw_error;
8378                 }
8379                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB10__A, 2, 0);
8380                 if (rc != 0) {
8381                         pr_err("error %d\n", rc);
8382                         goto rw_error;
8383                 }
8384                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB12__A, 2, 0);
8385                 if (rc != 0) {
8386                         pr_err("error %d\n", rc);
8387                         goto rw_error;
8388                 }
8389                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB15__A, 3, 0);
8390                 if (rc != 0) {
8391                         pr_err("error %d\n", rc);
8392                         goto rw_error;
8393                 }
8394                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB16__A, 3, 0);
8395                 if (rc != 0) {
8396                         pr_err("error %d\n", rc);
8397                         goto rw_error;
8398                 }
8399                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB20__A, 4, 0);
8400                 if (rc != 0) {
8401                         pr_err("error %d\n", rc);
8402                         goto rw_error;
8403                 }
8404                 rc = drxj_dap_write_reg16(dev_addr, QAM_LC_QUAL_TAB25__A, 4, 0);
8405                 if (rc != 0) {
8406                         pr_err("error %d\n", rc);
8407                         goto rw_error;
8408                 }
8409
8410                 rc = drxj_dap_write_reg16(dev_addr, IQM_FS_ADJ_SEL__A, 1, 0);
8411                 if (rc != 0) {
8412                         pr_err("error %d\n", rc);
8413                         goto rw_error;
8414                 }
8415                 rc = drxj_dap_write_reg16(dev_addr, IQM_RC_ADJ_SEL__A, 1, 0);
8416                 if (rc != 0) {
8417                         pr_err("error %d\n", rc);
8418                         goto rw_error;
8419                 }
8420                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_ADJ_SEL__A, 1, 0);
8421                 if (rc != 0) {
8422                         pr_err("error %d\n", rc);
8423                         goto rw_error;
8424                 }
8425                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_POW_MEAS_LEN__A, 0, 0);
8426                 if (rc != 0) {
8427                         pr_err("error %d\n", rc);
8428                         goto rw_error;
8429                 }
8430                 rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_GPIO__A, 0, 0);
8431                 if (rc != 0) {
8432                         pr_err("error %d\n", rc);
8433                         goto rw_error;
8434                 }
8435
8436                 /* No more resets of the IQM, current standard correctly set =>
8437                    now AGCs can be configured. */
8438                 /* turn on IQMAF. It has to be in front of setAgc**() */
8439                 rc = set_iqm_af(demod, true);
8440                 if (rc != 0) {
8441                         pr_err("error %d\n", rc);
8442                         goto rw_error;
8443                 }
8444                 rc = adc_synchronization(demod);
8445                 if (rc != 0) {
8446                         pr_err("error %d\n", rc);
8447                         goto rw_error;
8448                 }
8449
8450                 rc = init_agc(demod);
8451                 if (rc != 0) {
8452                         pr_err("error %d\n", rc);
8453                         goto rw_error;
8454                 }
8455                 rc = set_agc_if(demod, &(ext_attr->qam_if_agc_cfg), false);
8456                 if (rc != 0) {
8457                         pr_err("error %d\n", rc);
8458                         goto rw_error;
8459                 }
8460                 rc = set_agc_rf(demod, &(ext_attr->qam_rf_agc_cfg), false);
8461                 if (rc != 0) {
8462                         pr_err("error %d\n", rc);
8463                         goto rw_error;
8464                 }
8465                 {
8466                         /* TODO fix this, store a struct drxj_cfg_afe_gain structure in struct drxj_data instead
8467                            of only the gain */
8468                         struct drxj_cfg_afe_gain qam_pga_cfg = { DRX_STANDARD_ITU_B, 0 };
8469
8470                         qam_pga_cfg.gain = ext_attr->qam_pga_cfg;
8471                         rc = ctrl_set_cfg_afe_gain(demod, &qam_pga_cfg);
8472                         if (rc != 0) {
8473                                 pr_err("error %d\n", rc);
8474                                 goto rw_error;
8475                         }
8476                 }
8477                 rc = ctrl_set_cfg_pre_saw(demod, &(ext_attr->qam_pre_saw_cfg));
8478                 if (rc != 0) {
8479                         pr_err("error %d\n", rc);
8480                         goto rw_error;
8481                 }
8482         }
8483
8484         if ((op & QAM_SET_OP_ALL) || (op & QAM_SET_OP_CONSTELLATION)) {
8485                 if (ext_attr->standard == DRX_STANDARD_ITU_A) {
8486                         rc = drxdap_fasi_write_block(dev_addr, IQM_CF_TAP_RE0__A, sizeof(qam_a_taps), ((u8 *)qam_a_taps), 0);
8487                         if (rc != 0) {
8488                                 pr_err("error %d\n", rc);
8489                                 goto rw_error;
8490                         }
8491                         rc = drxdap_fasi_write_block(dev_addr, IQM_CF_TAP_IM0__A, sizeof(qam_a_taps), ((u8 *)qam_a_taps), 0);
8492                         if (rc != 0) {
8493                                 pr_err("error %d\n", rc);
8494                                 goto rw_error;
8495                         }
8496                 } else if (ext_attr->standard == DRX_STANDARD_ITU_B) {
8497                         switch (channel->constellation) {
8498                         case DRX_CONSTELLATION_QAM64:
8499                                 rc = drxdap_fasi_write_block(dev_addr, IQM_CF_TAP_RE0__A, sizeof(qam_b64_taps), ((u8 *)qam_b64_taps), 0);
8500                                 if (rc != 0) {
8501                                         pr_err("error %d\n", rc);
8502                                         goto rw_error;
8503                                 }
8504                                 rc = drxdap_fasi_write_block(dev_addr, IQM_CF_TAP_IM0__A, sizeof(qam_b64_taps), ((u8 *)qam_b64_taps), 0);
8505                                 if (rc != 0) {
8506                                         pr_err("error %d\n", rc);
8507                                         goto rw_error;
8508                                 }
8509                                 break;
8510                         case DRX_CONSTELLATION_QAM256:
8511                                 rc = drxdap_fasi_write_block(dev_addr, IQM_CF_TAP_RE0__A, sizeof(qam_b256_taps), ((u8 *)qam_b256_taps), 0);
8512                                 if (rc != 0) {
8513                                         pr_err("error %d\n", rc);
8514                                         goto rw_error;
8515                                 }
8516                                 rc = drxdap_fasi_write_block(dev_addr, IQM_CF_TAP_IM0__A, sizeof(qam_b256_taps), ((u8 *)qam_b256_taps), 0);
8517                                 if (rc != 0) {
8518                                         pr_err("error %d\n", rc);
8519                                         goto rw_error;
8520                                 }
8521                                 break;
8522                         default:
8523                                 return -EIO;
8524                         }
8525                 } else if (ext_attr->standard == DRX_STANDARD_ITU_C) {
8526                         rc = drxdap_fasi_write_block(dev_addr, IQM_CF_TAP_RE0__A, sizeof(qam_c_taps), ((u8 *)qam_c_taps), 0);
8527                         if (rc != 0) {
8528                                 pr_err("error %d\n", rc);
8529                                 goto rw_error;
8530                         }
8531                         rc = drxdap_fasi_write_block(dev_addr, IQM_CF_TAP_IM0__A, sizeof(qam_c_taps), ((u8 *)qam_c_taps), 0);
8532                         if (rc != 0) {
8533                                 pr_err("error %d\n", rc);
8534                                 goto rw_error;
8535                         }
8536                 }
8537
8538                 /* SETP 4: constellation specific setup */
8539                 switch (channel->constellation) {
8540                 case DRX_CONSTELLATION_QAM16:
8541                         rc = set_qam16(demod);
8542                         if (rc != 0) {
8543                                 pr_err("error %d\n", rc);
8544                                 goto rw_error;
8545                         }
8546                         break;
8547                 case DRX_CONSTELLATION_QAM32:
8548                         rc = set_qam32(demod);
8549                         if (rc != 0) {
8550                                 pr_err("error %d\n", rc);
8551                                 goto rw_error;
8552                         }
8553                         break;
8554                 case DRX_CONSTELLATION_QAM64:
8555                         rc = set_qam64(demod);
8556                         if (rc != 0) {
8557                                 pr_err("error %d\n", rc);
8558                                 goto rw_error;
8559                         }
8560                         break;
8561                 case DRX_CONSTELLATION_QAM128:
8562                         rc = set_qam128(demod);
8563                         if (rc != 0) {
8564                                 pr_err("error %d\n", rc);
8565                                 goto rw_error;
8566                         }
8567                         break;
8568                 case DRX_CONSTELLATION_QAM256:
8569                         rc = set_qam256(demod);
8570                         if (rc != 0) {
8571                                 pr_err("error %d\n", rc);
8572                                 goto rw_error;
8573                         }
8574                         break;
8575                 default:
8576                         return -EIO;
8577                 }               /* switch */
8578         }
8579
8580         if ((op & QAM_SET_OP_ALL)) {
8581                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_SCALE_SH__A, 0, 0);
8582                 if (rc != 0) {
8583                         pr_err("error %d\n", rc);
8584                         goto rw_error;
8585                 }
8586
8587                 /* Mpeg output has to be in front of FEC active */
8588                 rc = set_mpegtei_handling(demod);
8589                 if (rc != 0) {
8590                         pr_err("error %d\n", rc);
8591                         goto rw_error;
8592                 }
8593                 rc = bit_reverse_mpeg_output(demod);
8594                 if (rc != 0) {
8595                         pr_err("error %d\n", rc);
8596                         goto rw_error;
8597                 }
8598                 rc = set_mpeg_start_width(demod);
8599                 if (rc != 0) {
8600                         pr_err("error %d\n", rc);
8601                         goto rw_error;
8602                 }
8603                 {
8604                         /* TODO: move to set_standard after hardware reset value problem is solved */
8605                         /* Configure initial MPEG output */
8606                         struct drx_cfg_mpeg_output cfg_mpeg_output;
8607
8608                         memcpy(&cfg_mpeg_output, &common_attr->mpeg_cfg, sizeof(cfg_mpeg_output));
8609                         cfg_mpeg_output.enable_mpeg_output = true;
8610
8611                         rc = ctrl_set_cfg_mpeg_output(demod, &cfg_mpeg_output);
8612                         if (rc != 0) {
8613                                 pr_err("error %d\n", rc);
8614                                 goto rw_error;
8615                         }
8616                 }
8617         }
8618
8619         if ((op & QAM_SET_OP_ALL) || (op & QAM_SET_OP_CONSTELLATION)) {
8620
8621                 /* STEP 5: start QAM demodulator (starts FEC, QAM and IQM HW) */
8622                 cmd_scu.command = SCU_RAM_COMMAND_STANDARD_QAM |
8623                     SCU_RAM_COMMAND_CMD_DEMOD_START;
8624                 cmd_scu.parameter_len = 0;
8625                 cmd_scu.result_len = 1;
8626                 cmd_scu.parameter = NULL;
8627                 cmd_scu.result = &cmd_result;
8628                 rc = scu_command(dev_addr, &cmd_scu);
8629                 if (rc != 0) {
8630                         pr_err("error %d\n", rc);
8631                         goto rw_error;
8632                 }
8633         }
8634
8635         rc = drxj_dap_write_reg16(dev_addr, IQM_COMM_EXEC__A, IQM_COMM_EXEC_ACTIVE, 0);
8636         if (rc != 0) {
8637                 pr_err("error %d\n", rc);
8638                 goto rw_error;
8639         }
8640         rc = drxj_dap_write_reg16(dev_addr, QAM_COMM_EXEC__A, QAM_COMM_EXEC_ACTIVE, 0);
8641         if (rc != 0) {
8642                 pr_err("error %d\n", rc);
8643                 goto rw_error;
8644         }
8645         rc = drxj_dap_write_reg16(dev_addr, FEC_COMM_EXEC__A, FEC_COMM_EXEC_ACTIVE, 0);
8646         if (rc != 0) {
8647                 pr_err("error %d\n", rc);
8648                 goto rw_error;
8649         }
8650
8651         return 0;
8652 rw_error:
8653         return rc;
8654 }
8655
8656 /*============================================================================*/
8657 static int ctrl_get_qam_sig_quality(struct drx_demod_instance *demod);
8658
8659 static int qam_flip_spec(struct drx_demod_instance *demod, struct drx_channel *channel)
8660 {
8661         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
8662         struct drxj_data *ext_attr = demod->my_ext_attr;
8663         int rc;
8664         u32 iqm_fs_rate_ofs = 0;
8665         u32 iqm_fs_rate_lo = 0;
8666         u16 qam_ctl_ena = 0;
8667         u16 data = 0;
8668         u16 equ_mode = 0;
8669         u16 fsm_state = 0;
8670         int i = 0;
8671         int ofsofs = 0;
8672
8673         /* Silence the controlling of lc, equ, and the acquisition state machine */
8674         rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_QAM_CTL_ENA__A, &qam_ctl_ena, 0);
8675         if (rc != 0) {
8676                 pr_err("error %d\n", rc);
8677                 goto rw_error;
8678         }
8679         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_CTL_ENA__A, qam_ctl_ena & ~(SCU_RAM_QAM_CTL_ENA_ACQ__M | SCU_RAM_QAM_CTL_ENA_EQU__M | SCU_RAM_QAM_CTL_ENA_LC__M), 0);
8680         if (rc != 0) {
8681                 pr_err("error %d\n", rc);
8682                 goto rw_error;
8683         }
8684
8685         /* freeze the frequency control loop */
8686         rc = drxj_dap_write_reg16(dev_addr, QAM_LC_CF__A, 0, 0);
8687         if (rc != 0) {
8688                 pr_err("error %d\n", rc);
8689                 goto rw_error;
8690         }
8691         rc = drxj_dap_write_reg16(dev_addr, QAM_LC_CF1__A, 0, 0);
8692         if (rc != 0) {
8693                 pr_err("error %d\n", rc);
8694                 goto rw_error;
8695         }
8696
8697         rc = drxj_dap_atomic_read_reg32(dev_addr, IQM_FS_RATE_OFS_LO__A, &iqm_fs_rate_ofs, 0);
8698         if (rc != 0) {
8699                 pr_err("error %d\n", rc);
8700                 goto rw_error;
8701         }
8702         rc = drxj_dap_atomic_read_reg32(dev_addr, IQM_FS_RATE_LO__A, &iqm_fs_rate_lo, 0);
8703         if (rc != 0) {
8704                 pr_err("error %d\n", rc);
8705                 goto rw_error;
8706         }
8707         ofsofs = iqm_fs_rate_lo - iqm_fs_rate_ofs;
8708         iqm_fs_rate_ofs = ~iqm_fs_rate_ofs + 1;
8709         iqm_fs_rate_ofs -= 2 * ofsofs;
8710
8711         /* freeze dq/fq updating */
8712         rc = drxj_dap_read_reg16(dev_addr, QAM_DQ_MODE__A, &data, 0);
8713         if (rc != 0) {
8714                 pr_err("error %d\n", rc);
8715                 goto rw_error;
8716         }
8717         data = (data & 0xfff9);
8718         rc = drxj_dap_write_reg16(dev_addr, QAM_DQ_MODE__A, data, 0);
8719         if (rc != 0) {
8720                 pr_err("error %d\n", rc);
8721                 goto rw_error;
8722         }
8723         rc = drxj_dap_write_reg16(dev_addr, QAM_FQ_MODE__A, data, 0);
8724         if (rc != 0) {
8725                 pr_err("error %d\n", rc);
8726                 goto rw_error;
8727         }
8728
8729         /* lc_cp / _ci / _ca */
8730         rc = drxj_dap_write_reg16(dev_addr, QAM_LC_CI__A, 0, 0);
8731         if (rc != 0) {
8732                 pr_err("error %d\n", rc);
8733                 goto rw_error;
8734         }
8735         rc = drxj_dap_write_reg16(dev_addr, QAM_LC_EP__A, 0, 0);
8736         if (rc != 0) {
8737                 pr_err("error %d\n", rc);
8738                 goto rw_error;
8739         }
8740         rc = drxj_dap_write_reg16(dev_addr, QAM_FQ_LA_FACTOR__A, 0, 0);
8741         if (rc != 0) {
8742                 pr_err("error %d\n", rc);
8743                 goto rw_error;
8744         }
8745
8746         /* flip the spec */
8747         rc = drxdap_fasi_write_reg32(dev_addr, IQM_FS_RATE_OFS_LO__A, iqm_fs_rate_ofs, 0);
8748         if (rc != 0) {
8749                 pr_err("error %d\n", rc);
8750                 goto rw_error;
8751         }
8752         ext_attr->iqm_fs_rate_ofs = iqm_fs_rate_ofs;
8753         ext_attr->pos_image = (ext_attr->pos_image) ? false : true;
8754
8755         /* freeze dq/fq updating */
8756         rc = drxj_dap_read_reg16(dev_addr, QAM_DQ_MODE__A, &data, 0);
8757         if (rc != 0) {
8758                 pr_err("error %d\n", rc);
8759                 goto rw_error;
8760         }
8761         equ_mode = data;
8762         data = (data & 0xfff9);
8763         rc = drxj_dap_write_reg16(dev_addr, QAM_DQ_MODE__A, data, 0);
8764         if (rc != 0) {
8765                 pr_err("error %d\n", rc);
8766                 goto rw_error;
8767         }
8768         rc = drxj_dap_write_reg16(dev_addr, QAM_FQ_MODE__A, data, 0);
8769         if (rc != 0) {
8770                 pr_err("error %d\n", rc);
8771                 goto rw_error;
8772         }
8773
8774         for (i = 0; i < 28; i++) {
8775                 rc = drxj_dap_read_reg16(dev_addr, QAM_DQ_TAP_IM_EL0__A + (2 * i), &data, 0);
8776                 if (rc != 0) {
8777                         pr_err("error %d\n", rc);
8778                         goto rw_error;
8779                 }
8780                 rc = drxj_dap_write_reg16(dev_addr, QAM_DQ_TAP_IM_EL0__A + (2 * i), -data, 0);
8781                 if (rc != 0) {
8782                         pr_err("error %d\n", rc);
8783                         goto rw_error;
8784                 }
8785         }
8786
8787         for (i = 0; i < 24; i++) {
8788                 rc = drxj_dap_read_reg16(dev_addr, QAM_FQ_TAP_IM_EL0__A + (2 * i), &data, 0);
8789                 if (rc != 0) {
8790                         pr_err("error %d\n", rc);
8791                         goto rw_error;
8792                 }
8793                 rc = drxj_dap_write_reg16(dev_addr, QAM_FQ_TAP_IM_EL0__A + (2 * i), -data, 0);
8794                 if (rc != 0) {
8795                         pr_err("error %d\n", rc);
8796                         goto rw_error;
8797                 }
8798         }
8799
8800         data = equ_mode;
8801         rc = drxj_dap_write_reg16(dev_addr, QAM_DQ_MODE__A, data, 0);
8802         if (rc != 0) {
8803                 pr_err("error %d\n", rc);
8804                 goto rw_error;
8805         }
8806         rc = drxj_dap_write_reg16(dev_addr, QAM_FQ_MODE__A, data, 0);
8807         if (rc != 0) {
8808                 pr_err("error %d\n", rc);
8809                 goto rw_error;
8810         }
8811
8812         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_FSM_STATE_TGT__A, 4, 0);
8813         if (rc != 0) {
8814                 pr_err("error %d\n", rc);
8815                 goto rw_error;
8816         }
8817
8818         i = 0;
8819         while ((fsm_state != 4) && (i++ < 100)) {
8820                 rc = drxj_dap_read_reg16(dev_addr, SCU_RAM_QAM_FSM_STATE__A, &fsm_state, 0);
8821                 if (rc != 0) {
8822                         pr_err("error %d\n", rc);
8823                         goto rw_error;
8824                 }
8825         }
8826         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_QAM_CTL_ENA__A, (qam_ctl_ena | 0x0016), 0);
8827         if (rc != 0) {
8828                 pr_err("error %d\n", rc);
8829                 goto rw_error;
8830         }
8831
8832         return 0;
8833 rw_error:
8834         return rc;
8835
8836 }
8837
8838 #define  NO_LOCK        0x0
8839 #define  DEMOD_LOCKED   0x1
8840 #define  SYNC_FLIPPED   0x2
8841 #define  SPEC_MIRRORED  0x4
8842 /**
8843 * \fn int qam64auto ()
8844 * \brief auto do sync pattern switching and mirroring.
8845 * \param demod:   instance of demod.
8846 * \param channel: pointer to channel data.
8847 * \param tuner_freq_offset: tuner frequency offset.
8848 * \param lock_status: pointer to lock status.
8849 * \return int.
8850 */
8851 static int
8852 qam64auto(struct drx_demod_instance *demod,
8853           struct drx_channel *channel,
8854           s32 tuner_freq_offset, enum drx_lock_status *lock_status)
8855 {
8856         struct drxj_data *ext_attr = demod->my_ext_attr;
8857         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
8858         struct drx39xxj_state *state = dev_addr->user_data;
8859         struct dtv_frontend_properties *p = &state->frontend.dtv_property_cache;
8860         int rc;
8861         u32 lck_state = NO_LOCK;
8862         u32 start_time = 0;
8863         u32 d_locked_time = 0;
8864         u32 timeout_ofs = 0;
8865         u16 data = 0;
8866
8867         /* external attributes for storing acquired channel constellation */
8868         *lock_status = DRX_NOT_LOCKED;
8869         start_time = jiffies_to_msecs(jiffies);
8870         lck_state = NO_LOCK;
8871         do {
8872                 rc = ctrl_lock_status(demod, lock_status);
8873                 if (rc != 0) {
8874                         pr_err("error %d\n", rc);
8875                         goto rw_error;
8876                 }
8877
8878                 switch (lck_state) {
8879                 case NO_LOCK:
8880                         if (*lock_status == DRXJ_DEMOD_LOCK) {
8881                                 rc = ctrl_get_qam_sig_quality(demod);
8882                                 if (rc != 0) {
8883                                         pr_err("error %d\n", rc);
8884                                         goto rw_error;
8885                                 }
8886                                 if (p->cnr.stat[0].svalue > 20800) {
8887                                         lck_state = DEMOD_LOCKED;
8888                                         /* some delay to see if fec_lock possible TODO find the right value */
8889                                         timeout_ofs += DRXJ_QAM_DEMOD_LOCK_EXT_WAITTIME;        /* see something, waiting longer */
8890                                         d_locked_time = jiffies_to_msecs(jiffies);
8891                                 }
8892                         }
8893                         break;
8894                 case DEMOD_LOCKED:
8895                         if ((*lock_status == DRXJ_DEMOD_LOCK) &&        /* still demod_lock in 150ms */
8896                             ((jiffies_to_msecs(jiffies) - d_locked_time) >
8897                              DRXJ_QAM_FEC_LOCK_WAITTIME)) {
8898                                 rc = drxj_dap_read_reg16(demod->my_i2c_dev_addr, QAM_SY_TIMEOUT__A, &data, 0);
8899                                 if (rc != 0) {
8900                                         pr_err("error %d\n", rc);
8901                                         goto rw_error;
8902                                 }
8903                                 rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, QAM_SY_TIMEOUT__A, data | 0x1, 0);
8904                                 if (rc != 0) {
8905                                         pr_err("error %d\n", rc);
8906                                         goto rw_error;
8907                                 }
8908                                 lck_state = SYNC_FLIPPED;
8909                                 msleep(10);
8910                         }
8911                         break;
8912                 case SYNC_FLIPPED:
8913                         if (*lock_status == DRXJ_DEMOD_LOCK) {
8914                                 if (channel->mirror == DRX_MIRROR_AUTO) {
8915                                         /* flip sync pattern back */
8916                                         rc = drxj_dap_read_reg16(demod->my_i2c_dev_addr, QAM_SY_TIMEOUT__A, &data, 0);
8917                                         if (rc != 0) {
8918                                                 pr_err("error %d\n", rc);
8919                                                 goto rw_error;
8920                                         }
8921                                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, QAM_SY_TIMEOUT__A, data & 0xFFFE, 0);
8922                                         if (rc != 0) {
8923                                                 pr_err("error %d\n", rc);
8924                                                 goto rw_error;
8925                                         }
8926                                         /* flip spectrum */
8927                                         ext_attr->mirror = DRX_MIRROR_YES;
8928                                         rc = qam_flip_spec(demod, channel);
8929                                         if (rc != 0) {
8930                                                 pr_err("error %d\n", rc);
8931                                                 goto rw_error;
8932                                         }
8933                                         lck_state = SPEC_MIRRORED;
8934                                         /* reset timer TODO: still need 500ms? */
8935                                         start_time = d_locked_time =
8936                                             jiffies_to_msecs(jiffies);
8937                                         timeout_ofs = 0;
8938                                 } else {        /* no need to wait lock */
8939
8940                                         start_time =
8941                                             jiffies_to_msecs(jiffies) -
8942                                             DRXJ_QAM_MAX_WAITTIME - timeout_ofs;
8943                                 }
8944                         }
8945                         break;
8946                 case SPEC_MIRRORED:
8947                         if ((*lock_status == DRXJ_DEMOD_LOCK) &&        /* still demod_lock in 150ms */
8948                             ((jiffies_to_msecs(jiffies) - d_locked_time) >
8949                              DRXJ_QAM_FEC_LOCK_WAITTIME)) {
8950                                 rc = ctrl_get_qam_sig_quality(demod);
8951                                 if (rc != 0) {
8952                                         pr_err("error %d\n", rc);
8953                                         goto rw_error;
8954                                 }
8955                                 if (p->cnr.stat[0].svalue > 20800) {
8956                                         rc = drxj_dap_read_reg16(demod->my_i2c_dev_addr, QAM_SY_TIMEOUT__A, &data, 0);
8957                                         if (rc != 0) {
8958                                                 pr_err("error %d\n", rc);
8959                                                 goto rw_error;
8960                                         }
8961                                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr, QAM_SY_TIMEOUT__A, data | 0x1, 0);
8962                                         if (rc != 0) {
8963                                                 pr_err("error %d\n", rc);
8964                                                 goto rw_error;
8965                                         }
8966                                         /* no need to wait lock */
8967                                         start_time =
8968                                             jiffies_to_msecs(jiffies) -
8969                                             DRXJ_QAM_MAX_WAITTIME - timeout_ofs;
8970                                 }
8971                         }
8972                         break;
8973                 default:
8974                         break;
8975                 }
8976                 msleep(10);
8977         } while
8978             ((*lock_status != DRX_LOCKED) &&
8979              (*lock_status != DRX_NEVER_LOCK) &&
8980              ((jiffies_to_msecs(jiffies) - start_time) <
8981               (DRXJ_QAM_MAX_WAITTIME + timeout_ofs))
8982             );
8983         /* Returning control to apllication ... */
8984
8985         return 0;
8986 rw_error:
8987         return rc;
8988 }
8989
8990 /**
8991 * \fn int qam256auto ()
8992 * \brief auto do sync pattern switching and mirroring.
8993 * \param demod:   instance of demod.
8994 * \param channel: pointer to channel data.
8995 * \param tuner_freq_offset: tuner frequency offset.
8996 * \param lock_status: pointer to lock status.
8997 * \return int.
8998 */
8999 static int
9000 qam256auto(struct drx_demod_instance *demod,
9001            struct drx_channel *channel,
9002            s32 tuner_freq_offset, enum drx_lock_status *lock_status)
9003 {
9004         struct drxj_data *ext_attr = demod->my_ext_attr;
9005         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
9006         struct drx39xxj_state *state = dev_addr->user_data;
9007         struct dtv_frontend_properties *p = &state->frontend.dtv_property_cache;
9008         int rc;
9009         u32 lck_state = NO_LOCK;
9010         u32 start_time = 0;
9011         u32 d_locked_time = 0;
9012         u32 timeout_ofs = DRXJ_QAM_DEMOD_LOCK_EXT_WAITTIME;
9013
9014         /* external attributes for storing acquired channel constellation */
9015         *lock_status = DRX_NOT_LOCKED;
9016         start_time = jiffies_to_msecs(jiffies);
9017         lck_state = NO_LOCK;
9018         do {
9019                 rc = ctrl_lock_status(demod, lock_status);
9020                 if (rc != 0) {
9021                         pr_err("error %d\n", rc);
9022                         goto rw_error;
9023                 }
9024                 switch (lck_state) {
9025                 case NO_LOCK:
9026                         if (*lock_status == DRXJ_DEMOD_LOCK) {
9027                                 rc = ctrl_get_qam_sig_quality(demod);
9028                                 if (rc != 0) {
9029                                         pr_err("error %d\n", rc);
9030                                         goto rw_error;
9031                                 }
9032                                 if (p->cnr.stat[0].svalue > 26800) {
9033                                         lck_state = DEMOD_LOCKED;
9034                                         timeout_ofs += DRXJ_QAM_DEMOD_LOCK_EXT_WAITTIME;        /* see something, wait longer */
9035                                         d_locked_time = jiffies_to_msecs(jiffies);
9036                                 }
9037                         }
9038                         break;
9039                 case DEMOD_LOCKED:
9040                         if (*lock_status == DRXJ_DEMOD_LOCK) {
9041                                 if ((channel->mirror == DRX_MIRROR_AUTO) &&
9042                                     ((jiffies_to_msecs(jiffies) - d_locked_time) >
9043                                      DRXJ_QAM_FEC_LOCK_WAITTIME)) {
9044                                         ext_attr->mirror = DRX_MIRROR_YES;
9045                                         rc = qam_flip_spec(demod, channel);
9046                                         if (rc != 0) {
9047                                                 pr_err("error %d\n", rc);
9048                                                 goto rw_error;
9049                                         }
9050                                         lck_state = SPEC_MIRRORED;
9051                                         /* reset timer TODO: still need 300ms? */
9052                                         start_time = jiffies_to_msecs(jiffies);
9053                                         timeout_ofs = -DRXJ_QAM_MAX_WAITTIME / 2;
9054                                 }
9055                         }
9056                         break;
9057                 case SPEC_MIRRORED:
9058                         break;
9059                 default:
9060                         break;
9061                 }
9062                 msleep(10);
9063         } while
9064             ((*lock_status < DRX_LOCKED) &&
9065              (*lock_status != DRX_NEVER_LOCK) &&
9066              ((jiffies_to_msecs(jiffies) - start_time) <
9067               (DRXJ_QAM_MAX_WAITTIME + timeout_ofs)));
9068
9069         return 0;
9070 rw_error:
9071         return rc;
9072 }
9073
9074 /**
9075 * \fn int set_qam_channel ()
9076 * \brief Set QAM channel according to the requested constellation.
9077 * \param demod:   instance of demod.
9078 * \param channel: pointer to channel data.
9079 * \return int.
9080 */
9081 static int
9082 set_qam_channel(struct drx_demod_instance *demod,
9083                struct drx_channel *channel, s32 tuner_freq_offset)
9084 {
9085         struct drxj_data *ext_attr = NULL;
9086         int rc;
9087         enum drx_lock_status lock_status = DRX_NOT_LOCKED;
9088         bool auto_flag = false;
9089
9090         /* external attributes for storing acquired channel constellation */
9091         ext_attr = (struct drxj_data *) demod->my_ext_attr;
9092
9093         /* set QAM channel constellation */
9094         switch (channel->constellation) {
9095         case DRX_CONSTELLATION_QAM16:
9096         case DRX_CONSTELLATION_QAM32:
9097         case DRX_CONSTELLATION_QAM128:
9098                 return -EINVAL;
9099         case DRX_CONSTELLATION_QAM64:
9100         case DRX_CONSTELLATION_QAM256:
9101                 if (ext_attr->standard != DRX_STANDARD_ITU_B)
9102                         return -EINVAL;
9103
9104                 ext_attr->constellation = channel->constellation;
9105                 if (channel->mirror == DRX_MIRROR_AUTO)
9106                         ext_attr->mirror = DRX_MIRROR_NO;
9107                 else
9108                         ext_attr->mirror = channel->mirror;
9109
9110                 rc = set_qam(demod, channel, tuner_freq_offset, QAM_SET_OP_ALL);
9111                 if (rc != 0) {
9112                         pr_err("error %d\n", rc);
9113                         goto rw_error;
9114                 }
9115
9116                 if (channel->constellation == DRX_CONSTELLATION_QAM64)
9117                         rc = qam64auto(demod, channel, tuner_freq_offset,
9118                                        &lock_status);
9119                 else
9120                         rc = qam256auto(demod, channel, tuner_freq_offset,
9121                                         &lock_status);
9122                 if (rc != 0) {
9123                         pr_err("error %d\n", rc);
9124                         goto rw_error;
9125                 }
9126                 break;
9127         case DRX_CONSTELLATION_AUTO:    /* for channel scan */
9128                 if (ext_attr->standard == DRX_STANDARD_ITU_B) {
9129                         u16 qam_ctl_ena = 0;
9130
9131                         auto_flag = true;
9132
9133                         /* try to lock default QAM constellation: QAM256 */
9134                         channel->constellation = DRX_CONSTELLATION_QAM256;
9135                         ext_attr->constellation = DRX_CONSTELLATION_QAM256;
9136                         if (channel->mirror == DRX_MIRROR_AUTO)
9137                                 ext_attr->mirror = DRX_MIRROR_NO;
9138                         else
9139                                 ext_attr->mirror = channel->mirror;
9140                         rc = set_qam(demod, channel, tuner_freq_offset,
9141                                      QAM_SET_OP_ALL);
9142                         if (rc != 0) {
9143                                 pr_err("error %d\n", rc);
9144                                 goto rw_error;
9145                         }
9146                         rc = qam256auto(demod, channel, tuner_freq_offset,
9147                                         &lock_status);
9148                         if (rc != 0) {
9149                                 pr_err("error %d\n", rc);
9150                                 goto rw_error;
9151                         }
9152
9153                         if (lock_status >= DRX_LOCKED) {
9154                                 channel->constellation = DRX_CONSTELLATION_AUTO;
9155                                 break;
9156                         }
9157
9158                         /* QAM254 not locked. Try QAM64 constellation */
9159                         channel->constellation = DRX_CONSTELLATION_QAM64;
9160                         ext_attr->constellation = DRX_CONSTELLATION_QAM64;
9161                         if (channel->mirror == DRX_MIRROR_AUTO)
9162                                 ext_attr->mirror = DRX_MIRROR_NO;
9163                         else
9164                                 ext_attr->mirror = channel->mirror;
9165
9166                         rc = drxj_dap_read_reg16(demod->my_i2c_dev_addr,
9167                                                      SCU_RAM_QAM_CTL_ENA__A,
9168                                                      &qam_ctl_ena, 0);
9169                         if (rc != 0) {
9170                                 pr_err("error %d\n", rc);
9171                                 goto rw_error;
9172                         }
9173                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr,
9174                                                       SCU_RAM_QAM_CTL_ENA__A,
9175                                                       qam_ctl_ena & ~SCU_RAM_QAM_CTL_ENA_ACQ__M, 0);
9176                         if (rc != 0) {
9177                                 pr_err("error %d\n", rc);
9178                                 goto rw_error;
9179                         }
9180                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr,
9181                                                       SCU_RAM_QAM_FSM_STATE_TGT__A,
9182                                                       0x2, 0);
9183                         if (rc != 0) {
9184                                 pr_err("error %d\n", rc);
9185                                 goto rw_error;
9186                         }       /* force to rate hunting */
9187
9188                         rc = set_qam(demod, channel, tuner_freq_offset,
9189                                      QAM_SET_OP_CONSTELLATION);
9190                         if (rc != 0) {
9191                                 pr_err("error %d\n", rc);
9192                                 goto rw_error;
9193                         }
9194                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr,
9195                                                       SCU_RAM_QAM_CTL_ENA__A,
9196                                                       qam_ctl_ena, 0);
9197                         if (rc != 0) {
9198                                 pr_err("error %d\n", rc);
9199                                 goto rw_error;
9200                         }
9201
9202                         rc = qam64auto(demod, channel, tuner_freq_offset,
9203                                        &lock_status);
9204                         if (rc != 0) {
9205                                 pr_err("error %d\n", rc);
9206                                 goto rw_error;
9207                         }
9208
9209                         channel->constellation = DRX_CONSTELLATION_AUTO;
9210                 } else if (ext_attr->standard == DRX_STANDARD_ITU_C) {
9211                         u16 qam_ctl_ena = 0;
9212
9213                         channel->constellation = DRX_CONSTELLATION_QAM64;
9214                         ext_attr->constellation = DRX_CONSTELLATION_QAM64;
9215                         auto_flag = true;
9216
9217                         if (channel->mirror == DRX_MIRROR_AUTO)
9218                                 ext_attr->mirror = DRX_MIRROR_NO;
9219                         else
9220                                 ext_attr->mirror = channel->mirror;
9221                         rc = drxj_dap_read_reg16(demod->my_i2c_dev_addr,
9222                                                      SCU_RAM_QAM_CTL_ENA__A,
9223                                                      &qam_ctl_ena, 0);
9224                         if (rc != 0) {
9225                                 pr_err("error %d\n", rc);
9226                                 goto rw_error;
9227                         }
9228                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr,
9229                                                       SCU_RAM_QAM_CTL_ENA__A,
9230                                                       qam_ctl_ena & ~SCU_RAM_QAM_CTL_ENA_ACQ__M, 0);
9231                         if (rc != 0) {
9232                                 pr_err("error %d\n", rc);
9233                                 goto rw_error;
9234                         }
9235                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr,
9236                                                       SCU_RAM_QAM_FSM_STATE_TGT__A,
9237                                                       0x2, 0);
9238                         if (rc != 0) {
9239                                 pr_err("error %d\n", rc);
9240                                 goto rw_error;
9241                         }       /* force to rate hunting */
9242
9243                         rc = set_qam(demod, channel, tuner_freq_offset,
9244                                      QAM_SET_OP_CONSTELLATION);
9245                         if (rc != 0) {
9246                                 pr_err("error %d\n", rc);
9247                                 goto rw_error;
9248                         }
9249                         rc = drxj_dap_write_reg16(demod->my_i2c_dev_addr,
9250                                                       SCU_RAM_QAM_CTL_ENA__A,
9251                                                       qam_ctl_ena, 0);
9252                         if (rc != 0) {
9253                                 pr_err("error %d\n", rc);
9254                                 goto rw_error;
9255                         }
9256                         rc = qam64auto(demod, channel, tuner_freq_offset,
9257                                        &lock_status);
9258                         if (rc != 0) {
9259                                 pr_err("error %d\n", rc);
9260                                 goto rw_error;
9261                         }
9262                         channel->constellation = DRX_CONSTELLATION_AUTO;
9263                 } else {
9264                         return -EINVAL;
9265                 }
9266                 break;
9267         default:
9268                 return -EINVAL;
9269         }
9270
9271         return 0;
9272 rw_error:
9273         /* restore starting value */
9274         if (auto_flag)
9275                 channel->constellation = DRX_CONSTELLATION_AUTO;
9276         return rc;
9277 }
9278
9279 /*============================================================================*/
9280
9281 /**
9282 * \fn static short get_qamrs_err_count(struct i2c_device_addr *dev_addr)
9283 * \brief Get RS error count in QAM mode (used for post RS BER calculation)
9284 * \return Error code
9285 *
9286 * precondition: measurement period & measurement prescale must be set
9287 *
9288 */
9289 static int
9290 get_qamrs_err_count(struct i2c_device_addr *dev_addr,
9291                     struct drxjrs_errors *rs_errors)
9292 {
9293         int rc;
9294         u16 nr_bit_errors = 0,
9295             nr_symbol_errors = 0,
9296             nr_packet_errors = 0, nr_failures = 0, nr_snc_par_fail_count = 0;
9297
9298         /* check arguments */
9299         if (dev_addr == NULL)
9300                 return -EINVAL;
9301
9302         /* all reported errors are received in the  */
9303         /* most recently finished measurment period */
9304         /*   no of pre RS bit errors */
9305         rc = drxj_dap_read_reg16(dev_addr, FEC_RS_NR_BIT_ERRORS__A, &nr_bit_errors, 0);
9306         if (rc != 0) {
9307                 pr_err("error %d\n", rc);
9308                 goto rw_error;
9309         }
9310         /*   no of symbol errors      */
9311         rc = drxj_dap_read_reg16(dev_addr, FEC_RS_NR_SYMBOL_ERRORS__A, &nr_symbol_errors, 0);
9312         if (rc != 0) {
9313                 pr_err("error %d\n", rc);
9314                 goto rw_error;
9315         }
9316         /*   no of packet errors      */
9317         rc = drxj_dap_read_reg16(dev_addr, FEC_RS_NR_PACKET_ERRORS__A, &nr_packet_errors, 0);
9318         if (rc != 0) {
9319                 pr_err("error %d\n", rc);
9320                 goto rw_error;
9321         }
9322         /*   no of failures to decode */
9323         rc = drxj_dap_read_reg16(dev_addr, FEC_RS_NR_FAILURES__A, &nr_failures, 0);
9324         if (rc != 0) {
9325                 pr_err("error %d\n", rc);
9326                 goto rw_error;
9327         }
9328         /*   no of post RS bit erros  */
9329         rc = drxj_dap_read_reg16(dev_addr, FEC_OC_SNC_FAIL_COUNT__A, &nr_snc_par_fail_count, 0);
9330         if (rc != 0) {
9331                 pr_err("error %d\n", rc);
9332                 goto rw_error;
9333         }
9334         /* TODO: NOTE */
9335         /* These register values are fetched in non-atomic fashion           */
9336         /* It is possible that the read values contain unrelated information */
9337
9338         rs_errors->nr_bit_errors = nr_bit_errors & FEC_RS_NR_BIT_ERRORS__M;
9339         rs_errors->nr_symbol_errors = nr_symbol_errors & FEC_RS_NR_SYMBOL_ERRORS__M;
9340         rs_errors->nr_packet_errors = nr_packet_errors & FEC_RS_NR_PACKET_ERRORS__M;
9341         rs_errors->nr_failures = nr_failures & FEC_RS_NR_FAILURES__M;
9342         rs_errors->nr_snc_par_fail_count =
9343             nr_snc_par_fail_count & FEC_OC_SNC_FAIL_COUNT__M;
9344
9345         return 0;
9346 rw_error:
9347         return rc;
9348 }
9349
9350 /*============================================================================*/
9351
9352 /**
9353  * \fn int get_sig_strength()
9354  * \brief Retrieve signal strength for VSB and QAM.
9355  * \param demod Pointer to demod instance
9356  * \param u16-t Pointer to signal strength data; range 0, .. , 100.
9357  * \return int.
9358  * \retval 0 sig_strength contains valid data.
9359  * \retval -EINVAL sig_strength is NULL.
9360  * \retval -EIO Erroneous data, sig_strength contains invalid data.
9361  */
9362 #define DRXJ_AGC_TOP    0x2800
9363 #define DRXJ_AGC_SNS    0x1600
9364 #define DRXJ_RFAGC_MAX  0x3fff
9365 #define DRXJ_RFAGC_MIN  0x800
9366
9367 static int get_sig_strength(struct drx_demod_instance *demod, u16 *sig_strength)
9368 {
9369         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
9370         int rc;
9371         u16 rf_gain = 0;
9372         u16 if_gain = 0;
9373         u16 if_agc_sns = 0;
9374         u16 if_agc_top = 0;
9375         u16 rf_agc_max = 0;
9376         u16 rf_agc_min = 0;
9377
9378         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_AGC_IF__A, &if_gain, 0);
9379         if (rc != 0) {
9380                 pr_err("error %d\n", rc);
9381                 goto rw_error;
9382         }
9383         if_gain &= IQM_AF_AGC_IF__M;
9384         rc = drxj_dap_read_reg16(dev_addr, IQM_AF_AGC_RF__A, &rf_gain, 0);
9385         if (rc != 0) {
9386                 pr_err("error %d\n", rc);
9387                 goto rw_error;
9388         }
9389         rf_gain &= IQM_AF_AGC_RF__M;
9390
9391         if_agc_sns = DRXJ_AGC_SNS;
9392         if_agc_top = DRXJ_AGC_TOP;
9393         rf_agc_max = DRXJ_RFAGC_MAX;
9394         rf_agc_min = DRXJ_RFAGC_MIN;
9395
9396         if (if_gain > if_agc_top) {
9397                 if (rf_gain > rf_agc_max)
9398                         *sig_strength = 100;
9399                 else if (rf_gain > rf_agc_min) {
9400                         if (rf_agc_max == rf_agc_min) {
9401                                 pr_err("error: rf_agc_max == rf_agc_min\n");
9402                                 return -EIO;
9403                         }
9404                         *sig_strength =
9405                         75 + 25 * (rf_gain - rf_agc_min) / (rf_agc_max -
9406                                                                 rf_agc_min);
9407                 } else
9408                         *sig_strength = 75;
9409         } else if (if_gain > if_agc_sns) {
9410                 if (if_agc_top == if_agc_sns) {
9411                         pr_err("error: if_agc_top == if_agc_sns\n");
9412                         return -EIO;
9413                 }
9414                 *sig_strength =
9415                 20 + 55 * (if_gain - if_agc_sns) / (if_agc_top - if_agc_sns);
9416         } else {
9417                 if (!if_agc_sns) {
9418                         pr_err("error: if_agc_sns is zero!\n");
9419                         return -EIO;
9420                 }
9421                 *sig_strength = (20 * if_gain / if_agc_sns);
9422         }
9423
9424         if (*sig_strength <= 7)
9425                 *sig_strength = 0;
9426
9427         return 0;
9428 rw_error:
9429         return rc;
9430 }
9431
9432 /**
9433 * \fn int ctrl_get_qam_sig_quality()
9434 * \brief Retrieve QAM signal quality from device.
9435 * \param devmod Pointer to demodulator instance.
9436 * \param sig_quality Pointer to signal quality data.
9437 * \return int.
9438 * \retval 0 sig_quality contains valid data.
9439 * \retval -EINVAL sig_quality is NULL.
9440 * \retval -EIO Erroneous data, sig_quality contains invalid data.
9441
9442 *  Pre-condition: Device must be started and in lock.
9443 */
9444 static int
9445 ctrl_get_qam_sig_quality(struct drx_demod_instance *demod)
9446 {
9447         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
9448         struct drxj_data *ext_attr = demod->my_ext_attr;
9449         struct drx39xxj_state *state = dev_addr->user_data;
9450         struct dtv_frontend_properties *p = &state->frontend.dtv_property_cache;
9451         struct drxjrs_errors measuredrs_errors = { 0, 0, 0, 0, 0 };
9452         enum drx_modulation constellation = ext_attr->constellation;
9453         int rc;
9454
9455         u32 pre_bit_err_rs = 0; /* pre RedSolomon Bit Error Rate */
9456         u32 post_bit_err_rs = 0;        /* post RedSolomon Bit Error Rate */
9457         u32 pkt_errs = 0;       /* no of packet errors in RS */
9458         u16 qam_sl_err_power = 0;       /* accumulated error between raw and sliced symbols */
9459         u16 qsym_err_vd = 0;    /* quadrature symbol errors in QAM_VD */
9460         u16 fec_oc_period = 0;  /* SNC sync failure measurement period */
9461         u16 fec_rs_prescale = 0;        /* ReedSolomon Measurement Prescale */
9462         u16 fec_rs_period = 0;  /* Value for corresponding I2C register */
9463         /* calculation constants */
9464         u32 rs_bit_cnt = 0;     /* RedSolomon Bit Count */
9465         u32 qam_sl_sig_power = 0;       /* used for MER, depends of QAM constellation */
9466         /* intermediate results */
9467         u32 e = 0;              /* exponent value used for QAM BER/SER */
9468         u32 m = 0;              /* mantisa value used for QAM BER/SER */
9469         u32 ber_cnt = 0;        /* BER count */
9470         /* signal quality info */
9471         u32 qam_sl_mer = 0;     /* QAM MER */
9472         u32 qam_pre_rs_ber = 0; /* Pre RedSolomon BER */
9473         u32 qam_post_rs_ber = 0;        /* Post RedSolomon BER */
9474         u32 qam_vd_ser = 0;     /* ViterbiDecoder SER */
9475         u16 qam_vd_prescale = 0;        /* Viterbi Measurement Prescale */
9476         u16 qam_vd_period = 0;  /* Viterbi Measurement period */
9477         u32 vd_bit_cnt = 0;     /* ViterbiDecoder Bit Count */
9478
9479         p->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
9480
9481         /* read the physical registers */
9482         /*   Get the RS error data */
9483         rc = get_qamrs_err_count(dev_addr, &measuredrs_errors);
9484         if (rc != 0) {
9485                 pr_err("error %d\n", rc);
9486                 goto rw_error;
9487         }
9488         /* get the register value needed for MER */
9489         rc = drxj_dap_read_reg16(dev_addr, QAM_SL_ERR_POWER__A, &qam_sl_err_power, 0);
9490         if (rc != 0) {
9491                 pr_err("error %d\n", rc);
9492                 goto rw_error;
9493         }
9494         /* get the register value needed for post RS BER */
9495         rc = drxj_dap_read_reg16(dev_addr, FEC_OC_SNC_FAIL_PERIOD__A, &fec_oc_period, 0);
9496         if (rc != 0) {
9497                 pr_err("error %d\n", rc);
9498                 goto rw_error;
9499         }
9500
9501         /* get constants needed for signal quality calculation */
9502         fec_rs_period = ext_attr->fec_rs_period;
9503         fec_rs_prescale = ext_attr->fec_rs_prescale;
9504         rs_bit_cnt = fec_rs_period * fec_rs_prescale * ext_attr->fec_rs_plen;
9505         qam_vd_period = ext_attr->qam_vd_period;
9506         qam_vd_prescale = ext_attr->qam_vd_prescale;
9507         vd_bit_cnt = qam_vd_period * qam_vd_prescale * ext_attr->fec_vd_plen;
9508
9509         /* DRXJ_QAM_SL_SIG_POWER_QAMxxx  * 4     */
9510         switch (constellation) {
9511         case DRX_CONSTELLATION_QAM16:
9512                 qam_sl_sig_power = DRXJ_QAM_SL_SIG_POWER_QAM16 << 2;
9513                 break;
9514         case DRX_CONSTELLATION_QAM32:
9515                 qam_sl_sig_power = DRXJ_QAM_SL_SIG_POWER_QAM32 << 2;
9516                 break;
9517         case DRX_CONSTELLATION_QAM64:
9518                 qam_sl_sig_power = DRXJ_QAM_SL_SIG_POWER_QAM64 << 2;
9519                 break;
9520         case DRX_CONSTELLATION_QAM128:
9521                 qam_sl_sig_power = DRXJ_QAM_SL_SIG_POWER_QAM128 << 2;
9522                 break;
9523         case DRX_CONSTELLATION_QAM256:
9524                 qam_sl_sig_power = DRXJ_QAM_SL_SIG_POWER_QAM256 << 2;
9525                 break;
9526         default:
9527                 return -EIO;
9528         }
9529
9530         /* ------------------------------ */
9531         /* MER Calculation                */
9532         /* ------------------------------ */
9533         /* MER is good if it is above 27.5 for QAM256 or 21.5 for QAM64 */
9534
9535         /* 10.0*log10(qam_sl_sig_power * 4.0 / qam_sl_err_power); */
9536         if (qam_sl_err_power == 0)
9537                 qam_sl_mer = 0;
9538         else
9539                 qam_sl_mer = log1_times100(qam_sl_sig_power) - log1_times100((u32)qam_sl_err_power);
9540
9541         /* ----------------------------------------- */
9542         /* Pre Viterbi Symbol Error Rate Calculation */
9543         /* ----------------------------------------- */
9544         /* pre viterbi SER is good if it is below 0.025 */
9545
9546         /* get the register value */
9547         /*   no of quadrature symbol errors */
9548         rc = drxj_dap_read_reg16(dev_addr, QAM_VD_NR_QSYM_ERRORS__A, &qsym_err_vd, 0);
9549         if (rc != 0) {
9550                 pr_err("error %d\n", rc);
9551                 goto rw_error;
9552         }
9553         /* Extract the Exponent and the Mantisa  */
9554         /* of number of quadrature symbol errors */
9555         e = (qsym_err_vd & QAM_VD_NR_QSYM_ERRORS_EXP__M) >>
9556             QAM_VD_NR_QSYM_ERRORS_EXP__B;
9557         m = (qsym_err_vd & QAM_VD_NR_SYMBOL_ERRORS_FIXED_MANT__M) >>
9558             QAM_VD_NR_SYMBOL_ERRORS_FIXED_MANT__B;
9559
9560         if ((m << e) >> 3 > 549752)
9561                 qam_vd_ser = 500000 * vd_bit_cnt * ((e > 2) ? 1 : 8) / 8;
9562         else
9563                 qam_vd_ser = m << ((e > 2) ? (e - 3) : e);
9564
9565         /* --------------------------------------- */
9566         /* pre and post RedSolomon BER Calculation */
9567         /* --------------------------------------- */
9568         /* pre RS BER is good if it is below 3.5e-4 */
9569
9570         /* get the register values */
9571         pre_bit_err_rs = (u32) measuredrs_errors.nr_bit_errors;
9572         pkt_errs = post_bit_err_rs = (u32) measuredrs_errors.nr_snc_par_fail_count;
9573
9574         /* Extract the Exponent and the Mantisa of the */
9575         /* pre Reed-Solomon bit error count            */
9576         e = (pre_bit_err_rs & FEC_RS_NR_BIT_ERRORS_EXP__M) >>
9577             FEC_RS_NR_BIT_ERRORS_EXP__B;
9578         m = (pre_bit_err_rs & FEC_RS_NR_BIT_ERRORS_FIXED_MANT__M) >>
9579             FEC_RS_NR_BIT_ERRORS_FIXED_MANT__B;
9580
9581         ber_cnt = m << e;
9582
9583         /*qam_pre_rs_ber = frac_times1e6( ber_cnt, rs_bit_cnt ); */
9584         if (m > (rs_bit_cnt >> (e + 1)) || (rs_bit_cnt >> e) == 0)
9585                 qam_pre_rs_ber = 500000 * rs_bit_cnt >> e;
9586         else
9587                 qam_pre_rs_ber = ber_cnt;
9588
9589         /* post RS BER = 1000000* (11.17 * FEC_OC_SNC_FAIL_COUNT__A) /  */
9590         /*               (1504.0 * FEC_OC_SNC_FAIL_PERIOD__A)  */
9591         /*
9592            => c = (1000000*100*11.17)/1504 =
9593            post RS BER = (( c* FEC_OC_SNC_FAIL_COUNT__A) /
9594            (100 * FEC_OC_SNC_FAIL_PERIOD__A)
9595            *100 and /100 is for more precision.
9596            => (20 bits * 12 bits) /(16 bits * 7 bits)  => safe in 32 bits computation
9597
9598            Precision errors still possible.
9599          */
9600         if (!fec_oc_period) {
9601                 qam_post_rs_ber = 0xFFFFFFFF;
9602         } else {
9603                 e = post_bit_err_rs * 742686;
9604                 m = fec_oc_period * 100;
9605                 qam_post_rs_ber = e / m;
9606         }
9607
9608         /* fill signal quality data structure */
9609         p->pre_bit_count.stat[0].scale = FE_SCALE_COUNTER;
9610         p->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
9611         p->pre_bit_error.stat[0].scale = FE_SCALE_COUNTER;
9612         p->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
9613         p->block_error.stat[0].scale = FE_SCALE_COUNTER;
9614         p->cnr.stat[0].scale = FE_SCALE_DECIBEL;
9615
9616         p->cnr.stat[0].svalue = ((u16) qam_sl_mer) * 100;
9617         if (ext_attr->standard == DRX_STANDARD_ITU_B) {
9618                 p->pre_bit_error.stat[0].uvalue += qam_vd_ser;
9619                 p->pre_bit_count.stat[0].uvalue += vd_bit_cnt * ((e > 2) ? 1 : 8) / 8;
9620         } else {
9621                 p->pre_bit_error.stat[0].uvalue += qam_pre_rs_ber;
9622                 p->pre_bit_count.stat[0].uvalue += rs_bit_cnt >> e;
9623         }
9624
9625         p->post_bit_error.stat[0].uvalue += qam_post_rs_ber;
9626         p->post_bit_count.stat[0].uvalue += rs_bit_cnt >> e;
9627
9628         p->block_error.stat[0].uvalue += pkt_errs;
9629
9630 #ifdef DRXJ_SIGNAL_ACCUM_ERR
9631         rc = get_acc_pkt_err(demod, &sig_quality->packet_error);
9632         if (rc != 0) {
9633                 pr_err("error %d\n", rc);
9634                 goto rw_error;
9635         }
9636 #endif
9637
9638         return 0;
9639 rw_error:
9640         p->pre_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
9641         p->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
9642         p->pre_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
9643         p->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
9644         p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
9645         p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
9646
9647         return rc;
9648 }
9649
9650 #endif /* #ifndef DRXJ_VSB_ONLY */
9651
9652 /*============================================================================*/
9653 /*==                     END QAM DATAPATH FUNCTIONS                         ==*/
9654 /*============================================================================*/
9655
9656 /*============================================================================*/
9657 /*============================================================================*/
9658 /*==                       ATV DATAPATH FUNCTIONS                           ==*/
9659 /*============================================================================*/
9660 /*============================================================================*/
9661
9662 /*
9663    Implementation notes.
9664
9665    NTSC/FM AGCs
9666
9667       Four AGCs are used for NTSC:
9668       (1) RF (used to attenuate the input signal in case of to much power)
9669       (2) IF (used to attenuate the input signal in case of to much power)
9670       (3) Video AGC (used to amplify the output signal in case input to low)
9671       (4) SIF AGC (used to amplify the output signal in case input to low)
9672
9673       Video AGC is coupled to RF and IF. SIF AGC is not coupled. It is assumed
9674       that the coupling between Video AGC and the RF and IF AGCs also works in
9675       favor of the SIF AGC.
9676
9677       Three AGCs are used for FM:
9678       (1) RF (used to attenuate the input signal in case of to much power)
9679       (2) IF (used to attenuate the input signal in case of to much power)
9680       (3) SIF AGC (used to amplify the output signal in case input to low)
9681
9682       The SIF AGC is now coupled to the RF/IF AGCs.
9683       The SIF AGC is needed for both SIF ouput and the internal SIF signal to
9684       the AUD block.
9685
9686       RF and IF AGCs DACs are part of AFE, Video and SIF AGC DACs are part of
9687       the ATV block. The AGC control algorithms are all implemented in
9688       microcode.
9689
9690    ATV SETTINGS
9691
9692       (Shadow settings will not be used for now, they will be implemented
9693        later on because of the schedule)
9694
9695       Several HW/SCU "settings" can be used for ATV. The standard selection
9696       will reset most of these settings. To avoid that the end user apllication
9697       has to perform these settings each time the ATV or FM standards is
9698       selected the driver will shadow these settings. This enables the end user
9699       to perform the settings only once after a drx_open(). The driver must
9700       write the shadow settings to HW/SCU incase:
9701          ( setstandard FM/ATV) ||
9702          ( settings have changed && FM/ATV standard is active)
9703       The shadow settings will be stored in the device specific data container.
9704       A set of flags will be defined to flag changes in shadow settings.
9705       A routine will be implemented to write all changed shadow settings to
9706       HW/SCU.
9707
9708       The "settings" will consist of: AGC settings, filter settings etc.
9709
9710       Disadvantage of use of shadow settings:
9711       Direct changes in HW/SCU registers will not be reflected in the
9712       shadow settings and these changes will be overwritten during a next
9713       update. This can happen during evaluation. This will not be a problem
9714       for normal customer usage.
9715 */
9716 /* -------------------------------------------------------------------------- */
9717
9718 /**
9719 * \fn int power_down_atv ()
9720 * \brief Power down ATV.
9721 * \param demod instance of demodulator
9722 * \param standard either NTSC or FM (sub strandard for ATV )
9723 * \return int.
9724 *
9725 *  Stops and thus resets ATV and IQM block
9726 *  SIF and CVBS ADC are powered down
9727 *  Calls audio power down
9728 */
9729 static int
9730 power_down_atv(struct drx_demod_instance *demod, enum drx_standard standard, bool primary)
9731 {
9732         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
9733         struct drxjscu_cmd cmd_scu = { /* command      */ 0,
9734                 /* parameter_len */ 0,
9735                 /* result_len    */ 0,
9736                 /* *parameter   */ NULL,
9737                 /* *result      */ NULL
9738         };
9739         int rc;
9740         u16 cmd_result = 0;
9741
9742         /* ATV NTSC */
9743
9744         /* Stop ATV SCU (will reset ATV and IQM hardware */
9745         cmd_scu.command = SCU_RAM_COMMAND_STANDARD_ATV |
9746             SCU_RAM_COMMAND_CMD_DEMOD_STOP;
9747         cmd_scu.parameter_len = 0;
9748         cmd_scu.result_len = 1;
9749         cmd_scu.parameter = NULL;
9750         cmd_scu.result = &cmd_result;
9751         rc = scu_command(dev_addr, &cmd_scu);
9752         if (rc != 0) {
9753                 pr_err("error %d\n", rc);
9754                 goto rw_error;
9755         }
9756         /* Disable ATV outputs (ATV reset enables CVBS, undo this) */
9757         rc = drxj_dap_write_reg16(dev_addr, ATV_TOP_STDBY__A, (ATV_TOP_STDBY_SIF_STDBY_STANDBY & (~ATV_TOP_STDBY_CVBS_STDBY_A2_ACTIVE)), 0);
9758         if (rc != 0) {
9759                 pr_err("error %d\n", rc);
9760                 goto rw_error;
9761         }
9762
9763         rc = drxj_dap_write_reg16(dev_addr, ATV_COMM_EXEC__A, ATV_COMM_EXEC_STOP, 0);
9764         if (rc != 0) {
9765                 pr_err("error %d\n", rc);
9766                 goto rw_error;
9767         }
9768         if (primary) {
9769                 rc = drxj_dap_write_reg16(dev_addr, IQM_COMM_EXEC__A, IQM_COMM_EXEC_STOP, 0);
9770                 if (rc != 0) {
9771                         pr_err("error %d\n", rc);
9772                         goto rw_error;
9773                 }
9774                 rc = set_iqm_af(demod, false);
9775                 if (rc != 0) {
9776                         pr_err("error %d\n", rc);
9777                         goto rw_error;
9778                 }
9779         } else {
9780                 rc = drxj_dap_write_reg16(dev_addr, IQM_FS_COMM_EXEC__A, IQM_FS_COMM_EXEC_STOP, 0);
9781                 if (rc != 0) {
9782                         pr_err("error %d\n", rc);
9783                         goto rw_error;
9784                 }
9785                 rc = drxj_dap_write_reg16(dev_addr, IQM_FD_COMM_EXEC__A, IQM_FD_COMM_EXEC_STOP, 0);
9786                 if (rc != 0) {
9787                         pr_err("error %d\n", rc);
9788                         goto rw_error;
9789                 }
9790                 rc = drxj_dap_write_reg16(dev_addr, IQM_RC_COMM_EXEC__A, IQM_RC_COMM_EXEC_STOP, 0);
9791                 if (rc != 0) {
9792                         pr_err("error %d\n", rc);
9793                         goto rw_error;
9794                 }
9795                 rc = drxj_dap_write_reg16(dev_addr, IQM_RT_COMM_EXEC__A, IQM_RT_COMM_EXEC_STOP, 0);
9796                 if (rc != 0) {
9797                         pr_err("error %d\n", rc);
9798                         goto rw_error;
9799                 }
9800                 rc = drxj_dap_write_reg16(dev_addr, IQM_CF_COMM_EXEC__A, IQM_CF_COMM_EXEC_STOP, 0);
9801                 if (rc != 0) {
9802                         pr_err("error %d\n", rc);
9803                         goto rw_error;
9804                 }
9805         }
9806         rc = power_down_aud(demod);
9807         if (rc != 0) {
9808                 pr_err("error %d\n", rc);
9809                 goto rw_error;
9810         }
9811
9812         return 0;
9813 rw_error:
9814         return rc;
9815 }
9816
9817 /*============================================================================*/
9818
9819 /**
9820 * \brief Power up AUD.
9821 * \param demod instance of demodulator
9822 * \return int.
9823 *
9824 */
9825 static int power_down_aud(struct drx_demod_instance *demod)
9826 {
9827         struct i2c_device_addr *dev_addr = NULL;
9828         struct drxj_data *ext_attr = NULL;
9829         int rc;
9830
9831         dev_addr = (struct i2c_device_addr *)demod->my_i2c_dev_addr;
9832         ext_attr = (struct drxj_data *) demod->my_ext_attr;
9833
9834         rc = drxj_dap_write_reg16(dev_addr, AUD_COMM_EXEC__A, AUD_COMM_EXEC_STOP, 0);
9835         if (rc != 0) {
9836                 pr_err("error %d\n", rc);
9837                 goto rw_error;
9838         }
9839
9840         ext_attr->aud_data.audio_is_active = false;
9841
9842         return 0;
9843 rw_error:
9844         return rc;
9845 }
9846
9847 /**
9848 * \fn int set_orx_nsu_aox()
9849 * \brief Configure OrxNsuAox for OOB
9850 * \param demod instance of demodulator.
9851 * \param active
9852 * \return int.
9853 */
9854 static int set_orx_nsu_aox(struct drx_demod_instance *demod, bool active)
9855 {
9856         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
9857         int rc;
9858         u16 data = 0;
9859
9860         /* Configure NSU_AOX */
9861         rc = drxj_dap_read_reg16(dev_addr, ORX_NSU_AOX_STDBY_W__A, &data, 0);
9862         if (rc != 0) {
9863                 pr_err("error %d\n", rc);
9864                 goto rw_error;
9865         }
9866         if (!active)
9867                 data &= ((~ORX_NSU_AOX_STDBY_W_STDBYADC_A2_ON) & (~ORX_NSU_AOX_STDBY_W_STDBYAMP_A2_ON) & (~ORX_NSU_AOX_STDBY_W_STDBYBIAS_A2_ON) & (~ORX_NSU_AOX_STDBY_W_STDBYPLL_A2_ON) & (~ORX_NSU_AOX_STDBY_W_STDBYPD_A2_ON) & (~ORX_NSU_AOX_STDBY_W_STDBYTAGC_IF_A2_ON) & (~ORX_NSU_AOX_STDBY_W_STDBYTAGC_RF_A2_ON) & (~ORX_NSU_AOX_STDBY_W_STDBYFLT_A2_ON));
9868         else
9869                 data |= (ORX_NSU_AOX_STDBY_W_STDBYADC_A2_ON | ORX_NSU_AOX_STDBY_W_STDBYAMP_A2_ON | ORX_NSU_AOX_STDBY_W_STDBYBIAS_A2_ON | ORX_NSU_AOX_STDBY_W_STDBYPLL_A2_ON | ORX_NSU_AOX_STDBY_W_STDBYPD_A2_ON | ORX_NSU_AOX_STDBY_W_STDBYTAGC_IF_A2_ON | ORX_NSU_AOX_STDBY_W_STDBYTAGC_RF_A2_ON | ORX_NSU_AOX_STDBY_W_STDBYFLT_A2_ON);
9870         rc = drxj_dap_write_reg16(dev_addr, ORX_NSU_AOX_STDBY_W__A, data, 0);
9871         if (rc != 0) {
9872                 pr_err("error %d\n", rc);
9873                 goto rw_error;
9874         }
9875
9876         return 0;
9877 rw_error:
9878         return rc;
9879 }
9880
9881 /**
9882 * \fn int ctrl_set_oob()
9883 * \brief Set OOB channel to be used.
9884 * \param demod instance of demodulator
9885 * \param oob_param OOB parameters for channel setting.
9886 * \frequency should be in KHz
9887 * \return int.
9888 *
9889 * Accepts  only. Returns error otherwise.
9890 * Demapper value is written after scu_command START
9891 * because START command causes COMM_EXEC transition
9892 * from 0 to 1 which causes all registers to be
9893 * overwritten with initial value
9894 *
9895 */
9896
9897 /* Nyquist filter impulse response */
9898 #define IMPULSE_COSINE_ALPHA_0_3    {-3, -4, -1, 6, 10, 7, -5, -20, -25, -10, 29, 79, 123, 140} /*sqrt raised-cosine filter with alpha=0.3 */
9899 #define IMPULSE_COSINE_ALPHA_0_5    { 2, 0, -2, -2, 2, 5, 2, -10, -20, -14, 20, 74, 125, 145}   /*sqrt raised-cosine filter with alpha=0.5 */
9900 #define IMPULSE_COSINE_ALPHA_RO_0_5 { 0, 0, 1, 2, 3, 0, -7, -15, -16,  0, 34, 77, 114, 128}     /*full raised-cosine filter with alpha=0.5 (receiver only) */
9901
9902 /* Coefficients for the nyquist fitler (total: 27 taps) */
9903 #define NYQFILTERLEN 27
9904
9905 static int ctrl_set_oob(struct drx_demod_instance *demod, struct drxoob *oob_param)
9906 {
9907         int rc;
9908         s32 freq = 0;   /* KHz */
9909         struct i2c_device_addr *dev_addr = NULL;
9910         struct drxj_data *ext_attr = NULL;
9911         u16 i = 0;
9912         bool mirror_freq_spect_oob = false;
9913         u16 trk_filter_value = 0;
9914         struct drxjscu_cmd scu_cmd;
9915         u16 set_param_parameters[3];
9916         u16 cmd_result[2] = { 0, 0 };
9917         s16 nyquist_coeffs[4][(NYQFILTERLEN + 1) / 2] = {
9918                 IMPULSE_COSINE_ALPHA_0_3,       /* Target Mode 0 */
9919                 IMPULSE_COSINE_ALPHA_0_3,       /* Target Mode 1 */
9920                 IMPULSE_COSINE_ALPHA_0_5,       /* Target Mode 2 */
9921                 IMPULSE_COSINE_ALPHA_RO_0_5     /* Target Mode 3 */
9922         };
9923         u8 mode_val[4] = { 2, 2, 0, 1 };
9924         u8 pfi_coeffs[4][6] = {
9925                 {DRXJ_16TO8(-92), DRXJ_16TO8(-108), DRXJ_16TO8(100)},   /* TARGET_MODE = 0:     PFI_A = -23/32; PFI_B = -54/32;  PFI_C = 25/32; fg = 0.5 MHz (Att=26dB) */
9926                 {DRXJ_16TO8(-64), DRXJ_16TO8(-80), DRXJ_16TO8(80)},     /* TARGET_MODE = 1:     PFI_A = -16/32; PFI_B = -40/32;  PFI_C = 20/32; fg = 1.0 MHz (Att=28dB) */
9927                 {DRXJ_16TO8(-80), DRXJ_16TO8(-98), DRXJ_16TO8(92)},     /* TARGET_MODE = 2, 3:  PFI_A = -20/32; PFI_B = -49/32;  PFI_C = 23/32; fg = 0.8 MHz (Att=25dB) */
9928                 {DRXJ_16TO8(-80), DRXJ_16TO8(-98), DRXJ_16TO8(92)}      /* TARGET_MODE = 2, 3:  PFI_A = -20/32; PFI_B = -49/32;  PFI_C = 23/32; fg = 0.8 MHz (Att=25dB) */
9929         };
9930         u16 mode_index;
9931
9932         dev_addr = demod->my_i2c_dev_addr;
9933         ext_attr = (struct drxj_data *) demod->my_ext_attr;
9934         mirror_freq_spect_oob = ext_attr->mirror_freq_spect_oob;
9935
9936         /* Check parameters */
9937         if (oob_param == NULL) {
9938                 /* power off oob module  */
9939                 scu_cmd.command = SCU_RAM_COMMAND_STANDARD_OOB
9940                     | SCU_RAM_COMMAND_CMD_DEMOD_STOP;
9941                 scu_cmd.parameter_len = 0;
9942                 scu_cmd.result_len = 1;
9943                 scu_cmd.result = cmd_result;
9944                 rc = scu_command(dev_addr, &scu_cmd);
9945                 if (rc != 0) {
9946                         pr_err("error %d\n", rc);
9947                         goto rw_error;
9948                 }
9949                 rc = set_orx_nsu_aox(demod, false);
9950                 if (rc != 0) {
9951                         pr_err("error %d\n", rc);
9952                         goto rw_error;
9953                 }
9954                 rc = drxj_dap_write_reg16(dev_addr, ORX_COMM_EXEC__A, ORX_COMM_EXEC_STOP, 0);
9955                 if (rc != 0) {
9956                         pr_err("error %d\n", rc);
9957                         goto rw_error;
9958                 }
9959
9960                 ext_attr->oob_power_on = false;
9961                 return 0;
9962         }
9963
9964         freq = oob_param->frequency;
9965         if ((freq < 70000) || (freq > 130000))
9966                 return -EIO;
9967         freq = (freq - 50000) / 50;
9968
9969         {
9970                 u16 index = 0;
9971                 u16 remainder = 0;
9972                 u16 *trk_filtercfg = ext_attr->oob_trk_filter_cfg;
9973
9974                 index = (u16) ((freq - 400) / 200);
9975                 remainder = (u16) ((freq - 400) % 200);
9976                 trk_filter_value =
9977                     trk_filtercfg[index] - (trk_filtercfg[index] -
9978                                            trk_filtercfg[index +
9979                                                         1]) / 10 * remainder /
9980                     20;
9981         }
9982
9983    /*********/
9984         /* Stop  */
9985    /*********/
9986         rc = drxj_dap_write_reg16(dev_addr, ORX_COMM_EXEC__A, ORX_COMM_EXEC_STOP, 0);
9987         if (rc != 0) {
9988                 pr_err("error %d\n", rc);
9989                 goto rw_error;
9990         }
9991         scu_cmd.command = SCU_RAM_COMMAND_STANDARD_OOB
9992             | SCU_RAM_COMMAND_CMD_DEMOD_STOP;
9993         scu_cmd.parameter_len = 0;
9994         scu_cmd.result_len = 1;
9995         scu_cmd.result = cmd_result;
9996         rc = scu_command(dev_addr, &scu_cmd);
9997         if (rc != 0) {
9998                 pr_err("error %d\n", rc);
9999                 goto rw_error;
10000         }
10001    /*********/
10002         /* Reset */
10003    /*********/
10004         scu_cmd.command = SCU_RAM_COMMAND_STANDARD_OOB
10005             | SCU_RAM_COMMAND_CMD_DEMOD_RESET;
10006         scu_cmd.parameter_len = 0;
10007         scu_cmd.result_len = 1;
10008         scu_cmd.result = cmd_result;
10009         rc = scu_command(dev_addr, &scu_cmd);
10010         if (rc != 0) {
10011                 pr_err("error %d\n", rc);
10012                 goto rw_error;
10013         }
10014    /***********/
10015         /* SET_ENV */
10016    /***********/
10017         /* set frequency, spectrum inversion and data rate */
10018         scu_cmd.command = SCU_RAM_COMMAND_STANDARD_OOB
10019             | SCU_RAM_COMMAND_CMD_DEMOD_SET_ENV;
10020         scu_cmd.parameter_len = 3;
10021         /* 1-data rate;2-frequency */
10022         switch (oob_param->standard) {
10023         case DRX_OOB_MODE_A:
10024                 if (
10025                            /* signal is transmitted inverted */
10026                            ((oob_param->spectrum_inverted == true) &&
10027                             /* and tuner is not mirroring the signal */
10028                             (!mirror_freq_spect_oob)) |
10029                            /* or */
10030                            /* signal is transmitted noninverted */
10031                            ((oob_param->spectrum_inverted == false) &&
10032                             /* and tuner is mirroring the signal */
10033                             (mirror_freq_spect_oob))
10034                     )
10035                         set_param_parameters[0] =
10036                             SCU_RAM_ORX_RF_RX_DATA_RATE_2048KBPS_INVSPEC;
10037                 else
10038                         set_param_parameters[0] =
10039                             SCU_RAM_ORX_RF_RX_DATA_RATE_2048KBPS_REGSPEC;
10040                 break;
10041         case DRX_OOB_MODE_B_GRADE_A:
10042                 if (
10043                            /* signal is transmitted inverted */
10044                            ((oob_param->spectrum_inverted == true) &&
10045                             /* and tuner is not mirroring the signal */
10046                             (!mirror_freq_spect_oob)) |
10047                            /* or */
10048                            /* signal is transmitted noninverted */
10049                            ((oob_param->spectrum_inverted == false) &&
10050                             /* and tuner is mirroring the signal */
10051                             (mirror_freq_spect_oob))
10052                     )
10053                         set_param_parameters[0] =
10054                             SCU_RAM_ORX_RF_RX_DATA_RATE_1544KBPS_INVSPEC;
10055                 else
10056                         set_param_parameters[0] =
10057                             SCU_RAM_ORX_RF_RX_DATA_RATE_1544KBPS_REGSPEC;
10058                 break;
10059         case DRX_OOB_MODE_B_GRADE_B:
10060         default:
10061                 if (
10062                            /* signal is transmitted inverted */
10063                            ((oob_param->spectrum_inverted == true) &&
10064                             /* and tuner is not mirroring the signal */
10065                             (!mirror_freq_spect_oob)) |
10066                            /* or */
10067                            /* signal is transmitted noninverted */
10068                            ((oob_param->spectrum_inverted == false) &&
10069                             /* and tuner is mirroring the signal */
10070                             (mirror_freq_spect_oob))
10071                     )
10072                         set_param_parameters[0] =
10073                             SCU_RAM_ORX_RF_RX_DATA_RATE_3088KBPS_INVSPEC;
10074                 else
10075                         set_param_parameters[0] =
10076                             SCU_RAM_ORX_RF_RX_DATA_RATE_3088KBPS_REGSPEC;
10077                 break;
10078         }
10079         set_param_parameters[1] = (u16) (freq & 0xFFFF);
10080         set_param_parameters[2] = trk_filter_value;
10081         scu_cmd.parameter = set_param_parameters;
10082         scu_cmd.result_len = 1;
10083         scu_cmd.result = cmd_result;
10084         mode_index = mode_val[(set_param_parameters[0] & 0xC0) >> 6];
10085         rc = scu_command(dev_addr, &scu_cmd);
10086         if (rc != 0) {
10087                 pr_err("error %d\n", rc);
10088                 goto rw_error;
10089         }
10090
10091         rc = drxj_dap_write_reg16(dev_addr, SIO_TOP_COMM_KEY__A, 0xFABA, 0);
10092         if (rc != 0) {
10093                 pr_err("error %d\n", rc);
10094                 goto rw_error;
10095         }       /*  Write magic word to enable pdr reg write  */
10096         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_OOB_CRX_CFG__A, OOB_CRX_DRIVE_STRENGTH << SIO_PDR_OOB_CRX_CFG_DRIVE__B | 0x03 << SIO_PDR_OOB_CRX_CFG_MODE__B, 0);
10097         if (rc != 0) {
10098                 pr_err("error %d\n", rc);
10099                 goto rw_error;
10100         }
10101         rc = drxj_dap_write_reg16(dev_addr, SIO_PDR_OOB_DRX_CFG__A, OOB_DRX_DRIVE_STRENGTH << SIO_PDR_OOB_DRX_CFG_DRIVE__B | 0x03 << SIO_PDR_OOB_DRX_CFG_MODE__B, 0);
10102         if (rc != 0) {
10103                 pr_err("error %d\n", rc);
10104                 goto rw_error;
10105         }
10106         rc = drxj_dap_write_reg16(dev_addr, SIO_TOP_COMM_KEY__A, 0x0000, 0);
10107         if (rc != 0) {
10108                 pr_err("error %d\n", rc);
10109                 goto rw_error;
10110         }       /*  Write magic word to disable pdr reg write */
10111
10112         rc = drxj_dap_write_reg16(dev_addr, ORX_TOP_COMM_KEY__A, 0, 0);
10113         if (rc != 0) {
10114                 pr_err("error %d\n", rc);
10115                 goto rw_error;
10116         }
10117         rc = drxj_dap_write_reg16(dev_addr, ORX_FWP_AAG_LEN_W__A, 16000, 0);
10118         if (rc != 0) {
10119                 pr_err("error %d\n", rc);
10120                 goto rw_error;
10121         }
10122         rc = drxj_dap_write_reg16(dev_addr, ORX_FWP_AAG_THR_W__A, 40, 0);
10123         if (rc != 0) {
10124                 pr_err("error %d\n", rc);
10125                 goto rw_error;
10126         }
10127
10128         /* ddc */
10129         rc = drxj_dap_write_reg16(dev_addr, ORX_DDC_OFO_SET_W__A, ORX_DDC_OFO_SET_W__PRE, 0);
10130         if (rc != 0) {
10131                 pr_err("error %d\n", rc);
10132                 goto rw_error;
10133         }
10134
10135         /* nsu */
10136         rc = drxj_dap_write_reg16(dev_addr, ORX_NSU_AOX_LOPOW_W__A, ext_attr->oob_lo_pow, 0);
10137         if (rc != 0) {
10138                 pr_err("error %d\n", rc);
10139                 goto rw_error;
10140         }
10141
10142         /* initialization for target mode */
10143         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_TARGET_MODE__A, SCU_RAM_ORX_TARGET_MODE_2048KBPS_SQRT, 0);
10144         if (rc != 0) {
10145                 pr_err("error %d\n", rc);
10146                 goto rw_error;
10147         }
10148         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_FREQ_GAIN_CORR__A, SCU_RAM_ORX_FREQ_GAIN_CORR_2048KBPS, 0);
10149         if (rc != 0) {
10150                 pr_err("error %d\n", rc);
10151                 goto rw_error;
10152         }
10153
10154         /* Reset bits for timing and freq. recovery */
10155         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_RST_CPH__A, 0x0001, 0);
10156         if (rc != 0) {
10157                 pr_err("error %d\n", rc);
10158                 goto rw_error;
10159         }
10160         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_RST_CTI__A, 0x0002, 0);
10161         if (rc != 0) {
10162                 pr_err("error %d\n", rc);
10163                 goto rw_error;
10164         }
10165         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_RST_KRN__A, 0x0004, 0);
10166         if (rc != 0) {
10167                 pr_err("error %d\n", rc);
10168                 goto rw_error;
10169         }
10170         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_RST_KRP__A, 0x0008, 0);
10171         if (rc != 0) {
10172                 pr_err("error %d\n", rc);
10173                 goto rw_error;
10174         }
10175
10176         /* AGN_LOCK = {2048>>3, -2048, 8, -8, 0, 1}; */
10177         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_AGN_LOCK_TH__A, 2048 >> 3, 0);
10178         if (rc != 0) {
10179                 pr_err("error %d\n", rc);
10180                 goto rw_error;
10181         }
10182         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_AGN_LOCK_TOTH__A, (u16)(-2048), 0);
10183         if (rc != 0) {
10184                 pr_err("error %d\n", rc);
10185                 goto rw_error;
10186         }
10187         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_AGN_ONLOCK_TTH__A, 8, 0);
10188         if (rc != 0) {
10189                 pr_err("error %d\n", rc);
10190                 goto rw_error;
10191         }
10192         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_AGN_UNLOCK_TTH__A, (u16)(-8), 0);
10193         if (rc != 0) {
10194                 pr_err("error %d\n", rc);
10195                 goto rw_error;
10196         }
10197         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_AGN_LOCK_MASK__A, 1, 0);
10198         if (rc != 0) {
10199                 pr_err("error %d\n", rc);
10200                 goto rw_error;
10201         }
10202
10203         /* DGN_LOCK = {10, -2048, 8, -8, 0, 1<<1}; */
10204         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_DGN_LOCK_TH__A, 10, 0);
10205         if (rc != 0) {
10206                 pr_err("error %d\n", rc);
10207                 goto rw_error;
10208         }
10209         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_DGN_LOCK_TOTH__A, (u16)(-2048), 0);
10210         if (rc != 0) {
10211                 pr_err("error %d\n", rc);
10212                 goto rw_error;
10213         }
10214         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_DGN_ONLOCK_TTH__A, 8, 0);
10215         if (rc != 0) {
10216                 pr_err("error %d\n", rc);
10217                 goto rw_error;
10218         }
10219         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_DGN_UNLOCK_TTH__A, (u16)(-8), 0);
10220         if (rc != 0) {
10221                 pr_err("error %d\n", rc);
10222                 goto rw_error;
10223         }
10224         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_DGN_LOCK_MASK__A, 1 << 1, 0);
10225         if (rc != 0) {
10226                 pr_err("error %d\n", rc);
10227                 goto rw_error;
10228         }
10229
10230         /* FRQ_LOCK = {15,-2048, 8, -8, 0, 1<<2}; */
10231         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_FRQ_LOCK_TH__A, 17, 0);
10232         if (rc != 0) {
10233                 pr_err("error %d\n", rc);
10234                 goto rw_error;
10235         }
10236         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_FRQ_LOCK_TOTH__A, (u16)(-2048), 0);
10237         if (rc != 0) {
10238                 pr_err("error %d\n", rc);
10239                 goto rw_error;
10240         }
10241         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_FRQ_ONLOCK_TTH__A, 8, 0);
10242         if (rc != 0) {
10243                 pr_err("error %d\n", rc);
10244                 goto rw_error;
10245         }
10246         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_FRQ_UNLOCK_TTH__A, (u16)(-8), 0);
10247         if (rc != 0) {
10248                 pr_err("error %d\n", rc);
10249                 goto rw_error;
10250         }
10251         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_FRQ_LOCK_MASK__A, 1 << 2, 0);
10252         if (rc != 0) {
10253                 pr_err("error %d\n", rc);
10254                 goto rw_error;
10255         }
10256
10257         /* PHA_LOCK = {5000, -2048, 8, -8, 0, 1<<3}; */
10258         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_PHA_LOCK_TH__A, 3000, 0);
10259         if (rc != 0) {
10260                 pr_err("error %d\n", rc);
10261                 goto rw_error;
10262         }
10263         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_PHA_LOCK_TOTH__A, (u16)(-2048), 0);
10264         if (rc != 0) {
10265                 pr_err("error %d\n", rc);
10266                 goto rw_error;
10267         }
10268         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_PHA_ONLOCK_TTH__A, 8, 0);
10269         if (rc != 0) {
10270                 pr_err("error %d\n", rc);
10271                 goto rw_error;
10272         }
10273         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_PHA_UNLOCK_TTH__A, (u16)(-8), 0);
10274         if (rc != 0) {
10275                 pr_err("error %d\n", rc);
10276                 goto rw_error;
10277         }
10278         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_PHA_LOCK_MASK__A, 1 << 3, 0);
10279         if (rc != 0) {
10280                 pr_err("error %d\n", rc);
10281                 goto rw_error;
10282         }
10283
10284         /* TIM_LOCK = {300,      -2048, 8, -8, 0, 1<<4}; */
10285         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_TIM_LOCK_TH__A, 400, 0);
10286         if (rc != 0) {
10287                 pr_err("error %d\n", rc);
10288                 goto rw_error;
10289         }
10290         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_TIM_LOCK_TOTH__A, (u16)(-2048), 0);
10291         if (rc != 0) {
10292                 pr_err("error %d\n", rc);
10293                 goto rw_error;
10294         }
10295         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_TIM_ONLOCK_TTH__A, 8, 0);
10296         if (rc != 0) {
10297                 pr_err("error %d\n", rc);
10298                 goto rw_error;
10299         }
10300         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_TIM_UNLOCK_TTH__A, (u16)(-8), 0);
10301         if (rc != 0) {
10302                 pr_err("error %d\n", rc);
10303                 goto rw_error;
10304         }
10305         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_TIM_LOCK_MASK__A, 1 << 4, 0);
10306         if (rc != 0) {
10307                 pr_err("error %d\n", rc);
10308                 goto rw_error;
10309         }
10310
10311         /* EQU_LOCK = {20,      -2048, 8, -8, 0, 1<<5}; */
10312         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_EQU_LOCK_TH__A, 20, 0);
10313         if (rc != 0) {
10314                 pr_err("error %d\n", rc);
10315                 goto rw_error;
10316         }
10317         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_EQU_LOCK_TOTH__A, (u16)(-2048), 0);
10318         if (rc != 0) {
10319                 pr_err("error %d\n", rc);
10320                 goto rw_error;
10321         }
10322         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_EQU_ONLOCK_TTH__A, 4, 0);
10323         if (rc != 0) {
10324                 pr_err("error %d\n", rc);
10325                 goto rw_error;
10326         }
10327         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_EQU_UNLOCK_TTH__A, (u16)(-4), 0);
10328         if (rc != 0) {
10329                 pr_err("error %d\n", rc);
10330                 goto rw_error;
10331         }
10332         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_ORX_EQU_LOCK_MASK__A, 1 << 5, 0);
10333         if (rc != 0) {
10334                 pr_err("error %d\n", rc);
10335                 goto rw_error;
10336         }
10337
10338         /* PRE-Filter coefficients (PFI) */
10339         rc = drxdap_fasi_write_block(dev_addr, ORX_FWP_PFI_A_W__A, sizeof(pfi_coeffs[mode_index]), ((u8 *)pfi_coeffs[mode_index]), 0);
10340         if (rc != 0) {
10341                 pr_err("error %d\n", rc);
10342                 goto rw_error;
10343         }
10344         rc = drxj_dap_write_reg16(dev_addr, ORX_TOP_MDE_W__A, mode_index, 0);
10345         if (rc != 0) {
10346                 pr_err("error %d\n", rc);
10347                 goto rw_error;
10348         }
10349
10350         /* NYQUIST-Filter coefficients (NYQ) */
10351         for (i = 0; i < (NYQFILTERLEN + 1) / 2; i++) {
10352                 rc = drxj_dap_write_reg16(dev_addr, ORX_FWP_NYQ_ADR_W__A, i, 0);
10353                 if (rc != 0) {
10354                         pr_err("error %d\n", rc);
10355                         goto rw_error;
10356                 }
10357                 rc = drxj_dap_write_reg16(dev_addr, ORX_FWP_NYQ_COF_RW__A, nyquist_coeffs[mode_index][i], 0);
10358                 if (rc != 0) {
10359                         pr_err("error %d\n", rc);
10360                         goto rw_error;
10361                 }
10362         }
10363         rc = drxj_dap_write_reg16(dev_addr, ORX_FWP_NYQ_ADR_W__A, 31, 0);
10364         if (rc != 0) {
10365                 pr_err("error %d\n", rc);
10366                 goto rw_error;
10367         }
10368         rc = drxj_dap_write_reg16(dev_addr, ORX_COMM_EXEC__A, ORX_COMM_EXEC_ACTIVE, 0);
10369         if (rc != 0) {
10370                 pr_err("error %d\n", rc);
10371                 goto rw_error;
10372         }
10373         /*********/
10374         /* Start */
10375         /*********/
10376         scu_cmd.command = SCU_RAM_COMMAND_STANDARD_OOB
10377             | SCU_RAM_COMMAND_CMD_DEMOD_START;
10378         scu_cmd.parameter_len = 0;
10379         scu_cmd.result_len = 1;
10380         scu_cmd.result = cmd_result;
10381         rc = scu_command(dev_addr, &scu_cmd);
10382         if (rc != 0) {
10383                 pr_err("error %d\n", rc);
10384                 goto rw_error;
10385         }
10386
10387         rc = set_orx_nsu_aox(demod, true);
10388         if (rc != 0) {
10389                 pr_err("error %d\n", rc);
10390                 goto rw_error;
10391         }
10392         rc = drxj_dap_write_reg16(dev_addr, ORX_NSU_AOX_STHR_W__A, ext_attr->oob_pre_saw, 0);
10393         if (rc != 0) {
10394                 pr_err("error %d\n", rc);
10395                 goto rw_error;
10396         }
10397
10398         ext_attr->oob_power_on = true;
10399
10400         return 0;
10401 rw_error:
10402         return rc;
10403 }
10404
10405 /*============================================================================*/
10406 /*==                     END OOB DATAPATH FUNCTIONS                         ==*/
10407 /*============================================================================*/
10408
10409 /*=============================================================================
10410   ===== MC command related functions ==========================================
10411   ===========================================================================*/
10412
10413 /*=============================================================================
10414   ===== ctrl_set_channel() ==========================================================
10415   ===========================================================================*/
10416 /**
10417 * \fn int ctrl_set_channel()
10418 * \brief Select a new transmission channel.
10419 * \param demod instance of demod.
10420 * \param channel Pointer to channel data.
10421 * \return int.
10422 *
10423 * In case the tuner module is not used and in case of NTSC/FM the pogrammer
10424 * must tune the tuner to the centre frequency of the NTSC/FM channel.
10425 *
10426 */
10427 static int
10428 ctrl_set_channel(struct drx_demod_instance *demod, struct drx_channel *channel)
10429 {
10430         int rc;
10431         s32 tuner_freq_offset = 0;
10432         struct drxj_data *ext_attr = NULL;
10433         struct i2c_device_addr *dev_addr = NULL;
10434         enum drx_standard standard = DRX_STANDARD_UNKNOWN;
10435 #ifndef DRXJ_VSB_ONLY
10436         u32 min_symbol_rate = 0;
10437         u32 max_symbol_rate = 0;
10438         int bandwidth_temp = 0;
10439         int bandwidth = 0;
10440 #endif
10441    /*== check arguments ======================================================*/
10442         if ((demod == NULL) || (channel == NULL))
10443                 return -EINVAL;
10444
10445         dev_addr = demod->my_i2c_dev_addr;
10446         ext_attr = (struct drxj_data *) demod->my_ext_attr;
10447         standard = ext_attr->standard;
10448
10449         /* check valid standards */
10450         switch (standard) {
10451         case DRX_STANDARD_8VSB:
10452 #ifndef DRXJ_VSB_ONLY
10453         case DRX_STANDARD_ITU_A:
10454         case DRX_STANDARD_ITU_B:
10455         case DRX_STANDARD_ITU_C:
10456 #endif /* DRXJ_VSB_ONLY */
10457                 break;
10458         case DRX_STANDARD_UNKNOWN:
10459         default:
10460                 return -EINVAL;
10461         }
10462
10463         /* check bandwidth QAM annex B, NTSC and 8VSB */
10464         if ((standard == DRX_STANDARD_ITU_B) ||
10465             (standard == DRX_STANDARD_8VSB) ||
10466             (standard == DRX_STANDARD_NTSC)) {
10467                 switch (channel->bandwidth) {
10468                 case DRX_BANDWIDTH_6MHZ:
10469                 case DRX_BANDWIDTH_UNKNOWN:     /* fall through */
10470                         channel->bandwidth = DRX_BANDWIDTH_6MHZ;
10471                         break;
10472                 case DRX_BANDWIDTH_8MHZ:        /* fall through */
10473                 case DRX_BANDWIDTH_7MHZ:        /* fall through */
10474                 default:
10475                         return -EINVAL;
10476                 }
10477         }
10478
10479         /* For QAM annex A and annex C:
10480            -check symbolrate and constellation
10481            -derive bandwidth from symbolrate (input bandwidth is ignored)
10482          */
10483 #ifndef DRXJ_VSB_ONLY
10484         if ((standard == DRX_STANDARD_ITU_A) ||
10485             (standard == DRX_STANDARD_ITU_C)) {
10486                 struct drxuio_cfg uio_cfg = { DRX_UIO1, DRX_UIO_MODE_FIRMWARE_SAW };
10487                 int bw_rolloff_factor = 0;
10488
10489                 bw_rolloff_factor = (standard == DRX_STANDARD_ITU_A) ? 115 : 113;
10490                 min_symbol_rate = DRXJ_QAM_SYMBOLRATE_MIN;
10491                 max_symbol_rate = DRXJ_QAM_SYMBOLRATE_MAX;
10492                 /* config SMA_TX pin to SAW switch mode */
10493                 rc = ctrl_set_uio_cfg(demod, &uio_cfg);
10494                 if (rc != 0) {
10495                         pr_err("error %d\n", rc);
10496                         goto rw_error;
10497                 }
10498
10499                 if (channel->symbolrate < min_symbol_rate ||
10500                     channel->symbolrate > max_symbol_rate) {
10501                         return -EINVAL;
10502                 }
10503
10504                 switch (channel->constellation) {
10505                 case DRX_CONSTELLATION_QAM16:   /* fall through */
10506                 case DRX_CONSTELLATION_QAM32:   /* fall through */
10507                 case DRX_CONSTELLATION_QAM64:   /* fall through */
10508                 case DRX_CONSTELLATION_QAM128:  /* fall through */
10509                 case DRX_CONSTELLATION_QAM256:
10510                         bandwidth_temp = channel->symbolrate * bw_rolloff_factor;
10511                         bandwidth = bandwidth_temp / 100;
10512
10513                         if ((bandwidth_temp % 100) >= 50)
10514                                 bandwidth++;
10515
10516                         if (bandwidth <= 6100000) {
10517                                 channel->bandwidth = DRX_BANDWIDTH_6MHZ;
10518                         } else if ((bandwidth > 6100000)
10519                                    && (bandwidth <= 7100000)) {
10520                                 channel->bandwidth = DRX_BANDWIDTH_7MHZ;
10521                         } else if (bandwidth > 7100000) {
10522                                 channel->bandwidth = DRX_BANDWIDTH_8MHZ;
10523                         }
10524                         break;
10525                 default:
10526                         return -EINVAL;
10527                 }
10528         }
10529
10530         /* For QAM annex B:
10531            -check constellation
10532          */
10533         if (standard == DRX_STANDARD_ITU_B) {
10534                 switch (channel->constellation) {
10535                 case DRX_CONSTELLATION_AUTO:
10536                 case DRX_CONSTELLATION_QAM256:
10537                 case DRX_CONSTELLATION_QAM64:
10538                         break;
10539                 default:
10540                         return -EINVAL;
10541                 }
10542
10543                 switch (channel->interleavemode) {
10544                 case DRX_INTERLEAVEMODE_I128_J1:
10545                 case DRX_INTERLEAVEMODE_I128_J1_V2:
10546                 case DRX_INTERLEAVEMODE_I128_J2:
10547                 case DRX_INTERLEAVEMODE_I64_J2:
10548                 case DRX_INTERLEAVEMODE_I128_J3:
10549                 case DRX_INTERLEAVEMODE_I32_J4:
10550                 case DRX_INTERLEAVEMODE_I128_J4:
10551                 case DRX_INTERLEAVEMODE_I16_J8:
10552                 case DRX_INTERLEAVEMODE_I128_J5:
10553                 case DRX_INTERLEAVEMODE_I8_J16:
10554                 case DRX_INTERLEAVEMODE_I128_J6:
10555                 case DRX_INTERLEAVEMODE_I128_J7:
10556                 case DRX_INTERLEAVEMODE_I128_J8:
10557                 case DRX_INTERLEAVEMODE_I12_J17:
10558                 case DRX_INTERLEAVEMODE_I5_J4:
10559                 case DRX_INTERLEAVEMODE_B52_M240:
10560                 case DRX_INTERLEAVEMODE_B52_M720:
10561                 case DRX_INTERLEAVEMODE_UNKNOWN:
10562                 case DRX_INTERLEAVEMODE_AUTO:
10563                         break;
10564                 default:
10565                         return -EINVAL;
10566                 }
10567         }
10568
10569         if ((ext_attr->uio_sma_tx_mode) == DRX_UIO_MODE_FIRMWARE_SAW) {
10570                 /* SAW SW, user UIO is used for switchable SAW */
10571                 struct drxuio_data uio1 = { DRX_UIO1, false };
10572
10573                 switch (channel->bandwidth) {
10574                 case DRX_BANDWIDTH_8MHZ:
10575                         uio1.value = true;
10576                         break;
10577                 case DRX_BANDWIDTH_7MHZ:
10578                         uio1.value = false;
10579                         break;
10580                 case DRX_BANDWIDTH_6MHZ:
10581                         uio1.value = false;
10582                         break;
10583                 case DRX_BANDWIDTH_UNKNOWN:
10584                 default:
10585                         return -EINVAL;
10586                 }
10587
10588                 rc = ctrl_uio_write(demod, &uio1);
10589                 if (rc != 0) {
10590                         pr_err("error %d\n", rc);
10591                         goto rw_error;
10592                 }
10593         }
10594 #endif /* DRXJ_VSB_ONLY */
10595         rc = drxj_dap_write_reg16(dev_addr, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE, 0);
10596         if (rc != 0) {
10597                 pr_err("error %d\n", rc);
10598                 goto rw_error;
10599         }
10600
10601         tuner_freq_offset = 0;
10602
10603    /*== Setup demod for specific standard ====================================*/
10604         switch (standard) {
10605         case DRX_STANDARD_8VSB:
10606                 if (channel->mirror == DRX_MIRROR_AUTO)
10607                         ext_attr->mirror = DRX_MIRROR_NO;
10608                 else
10609                         ext_attr->mirror = channel->mirror;
10610                 rc = set_vsb(demod);
10611                 if (rc != 0) {
10612                         pr_err("error %d\n", rc);
10613                         goto rw_error;
10614                 }
10615                 rc = set_frequency(demod, channel, tuner_freq_offset);
10616                 if (rc != 0) {
10617                         pr_err("error %d\n", rc);
10618                         goto rw_error;
10619                 }
10620                 break;
10621 #ifndef DRXJ_VSB_ONLY
10622         case DRX_STANDARD_ITU_A:        /* fallthrough */
10623         case DRX_STANDARD_ITU_B:        /* fallthrough */
10624         case DRX_STANDARD_ITU_C:
10625                 rc = set_qam_channel(demod, channel, tuner_freq_offset);
10626                 if (rc != 0) {
10627                         pr_err("error %d\n", rc);
10628                         goto rw_error;
10629                 }
10630                 break;
10631 #endif
10632         case DRX_STANDARD_UNKNOWN:
10633         default:
10634                 return -EIO;
10635         }
10636
10637         /* flag the packet error counter reset */
10638         ext_attr->reset_pkt_err_acc = true;
10639
10640         return 0;
10641 rw_error:
10642         return rc;
10643 }
10644
10645 /*=============================================================================
10646   ===== SigQuality() ==========================================================
10647   ===========================================================================*/
10648
10649 /**
10650 * \fn int ctrl_sig_quality()
10651 * \brief Retrieve signal quality form device.
10652 * \param devmod Pointer to demodulator instance.
10653 * \param sig_quality Pointer to signal quality data.
10654 * \return int.
10655 * \retval 0 sig_quality contains valid data.
10656 * \retval -EINVAL sig_quality is NULL.
10657 * \retval -EIO Erroneous data, sig_quality contains invalid data.
10658
10659 */
10660 static int
10661 ctrl_sig_quality(struct drx_demod_instance *demod,
10662                  enum drx_lock_status lock_status)
10663 {
10664         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
10665         struct drxj_data *ext_attr = demod->my_ext_attr;
10666         struct drx39xxj_state *state = dev_addr->user_data;
10667         struct dtv_frontend_properties *p = &state->frontend.dtv_property_cache;
10668         enum drx_standard standard = ext_attr->standard;
10669         int rc;
10670         u32 ber, cnt, err, pkt;
10671         u16 mer, strength = 0;
10672
10673         rc = get_sig_strength(demod, &strength);
10674         if (rc < 0) {
10675                 pr_err("error getting signal strength %d\n", rc);
10676                 p->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10677         } else {
10678                 p->strength.stat[0].scale = FE_SCALE_RELATIVE;
10679                 p->strength.stat[0].uvalue = 65535UL *  strength/ 100;
10680         }
10681
10682         switch (standard) {
10683         case DRX_STANDARD_8VSB:
10684 #ifdef DRXJ_SIGNAL_ACCUM_ERR
10685                 rc = get_acc_pkt_err(demod, &pkt);
10686                 if (rc != 0) {
10687                         pr_err("error %d\n", rc);
10688                         goto rw_error;
10689                 }
10690 #endif
10691                 if (lock_status != DRXJ_DEMOD_LOCK && lock_status != DRX_LOCKED) {
10692                         p->pre_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10693                         p->pre_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10694                         p->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10695                         p->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10696                         p->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10697                         p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10698                         p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10699                 } else {
10700                         rc = get_vsb_post_rs_pck_err(dev_addr, &err, &pkt);
10701                         if (rc != 0) {
10702                                 pr_err("error %d getting UCB\n", rc);
10703                                 p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10704                         } else {
10705                                 p->block_error.stat[0].scale = FE_SCALE_COUNTER;
10706                                 p->block_error.stat[0].uvalue += err;
10707                                 p->block_count.stat[0].scale = FE_SCALE_COUNTER;
10708                                 p->block_count.stat[0].uvalue += pkt;
10709                         }
10710
10711                         /* PostViterbi is compute in steps of 10^(-6) */
10712                         rc = get_vs_bpre_viterbi_ber(dev_addr, &ber, &cnt);
10713                         if (rc != 0) {
10714                                 pr_err("error %d getting pre-ber\n", rc);
10715                                 p->pre_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10716                         } else {
10717                                 p->pre_bit_error.stat[0].scale = FE_SCALE_COUNTER;
10718                                 p->pre_bit_error.stat[0].uvalue += ber;
10719                                 p->pre_bit_count.stat[0].scale = FE_SCALE_COUNTER;
10720                                 p->pre_bit_count.stat[0].uvalue += cnt;
10721                         }
10722
10723                         rc = get_vs_bpost_viterbi_ber(dev_addr, &ber, &cnt);
10724                         if (rc != 0) {
10725                                 pr_err("error %d getting post-ber\n", rc);
10726                                 p->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10727                         } else {
10728                                 p->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
10729                                 p->post_bit_error.stat[0].uvalue += ber;
10730                                 p->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
10731                                 p->post_bit_count.stat[0].uvalue += cnt;
10732                         }
10733                         rc = get_vsbmer(dev_addr, &mer);
10734                         if (rc != 0) {
10735                                 pr_err("error %d getting MER\n", rc);
10736                                 p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
10737                         } else {
10738                                 p->cnr.stat[0].svalue = mer * 100;
10739                                 p->cnr.stat[0].scale = FE_SCALE_DECIBEL;
10740                         }
10741                 }
10742                 break;
10743 #ifndef DRXJ_VSB_ONLY
10744         case DRX_STANDARD_ITU_A:
10745         case DRX_STANDARD_ITU_B:
10746         case DRX_STANDARD_ITU_C:
10747                 rc = ctrl_get_qam_sig_quality(demod);
10748                 if (rc != 0) {
10749                         pr_err("error %d\n", rc);
10750                         goto rw_error;
10751                 }
10752                 break;
10753 #endif
10754         default:
10755                 return -EIO;
10756         }
10757
10758         return 0;
10759 rw_error:
10760         return rc;
10761 }
10762
10763 /*============================================================================*/
10764
10765 /**
10766 * \fn int ctrl_lock_status()
10767 * \brief Retrieve lock status .
10768 * \param dev_addr Pointer to demodulator device address.
10769 * \param lock_stat Pointer to lock status structure.
10770 * \return int.
10771 *
10772 */
10773 static int
10774 ctrl_lock_status(struct drx_demod_instance *demod, enum drx_lock_status *lock_stat)
10775 {
10776         enum drx_standard standard = DRX_STANDARD_UNKNOWN;
10777         struct drxj_data *ext_attr = NULL;
10778         struct i2c_device_addr *dev_addr = NULL;
10779         struct drxjscu_cmd cmd_scu = { /* command      */ 0,
10780                 /* parameter_len */ 0,
10781                 /* result_len    */ 0,
10782                 /* *parameter   */ NULL,
10783                 /* *result      */ NULL
10784         };
10785         int rc;
10786         u16 cmd_result[2] = { 0, 0 };
10787         u16 demod_lock = SCU_RAM_PARAM_1_RES_DEMOD_GET_LOCK_DEMOD_LOCKED;
10788
10789         /* check arguments */
10790         if ((demod == NULL) || (lock_stat == NULL))
10791                 return -EINVAL;
10792
10793         dev_addr = demod->my_i2c_dev_addr;
10794         ext_attr = (struct drxj_data *) demod->my_ext_attr;
10795         standard = ext_attr->standard;
10796
10797         *lock_stat = DRX_NOT_LOCKED;
10798
10799         /* define the SCU command code */
10800         switch (standard) {
10801         case DRX_STANDARD_8VSB:
10802                 cmd_scu.command = SCU_RAM_COMMAND_STANDARD_VSB |
10803                     SCU_RAM_COMMAND_CMD_DEMOD_GET_LOCK;
10804                 demod_lock |= 0x6;
10805                 break;
10806 #ifndef DRXJ_VSB_ONLY
10807         case DRX_STANDARD_ITU_A:
10808         case DRX_STANDARD_ITU_B:
10809         case DRX_STANDARD_ITU_C:
10810                 cmd_scu.command = SCU_RAM_COMMAND_STANDARD_QAM |
10811                     SCU_RAM_COMMAND_CMD_DEMOD_GET_LOCK;
10812                 break;
10813 #endif
10814         case DRX_STANDARD_UNKNOWN:      /* fallthrough */
10815         default:
10816                 return -EIO;
10817         }
10818
10819         /* define the SCU command parameters and execute the command */
10820         cmd_scu.parameter_len = 0;
10821         cmd_scu.result_len = 2;
10822         cmd_scu.parameter = NULL;
10823         cmd_scu.result = cmd_result;
10824         rc = scu_command(dev_addr, &cmd_scu);
10825         if (rc != 0) {
10826                 pr_err("error %d\n", rc);
10827                 goto rw_error;
10828         }
10829
10830         /* set the lock status */
10831         if (cmd_scu.result[1] < demod_lock) {
10832                 /* 0x0000 NOT LOCKED */
10833                 *lock_stat = DRX_NOT_LOCKED;
10834         } else if (cmd_scu.result[1] < SCU_RAM_PARAM_1_RES_DEMOD_GET_LOCK_LOCKED) {
10835                 *lock_stat = DRXJ_DEMOD_LOCK;
10836         } else if (cmd_scu.result[1] <
10837                    SCU_RAM_PARAM_1_RES_DEMOD_GET_LOCK_NEVER_LOCK) {
10838                 /* 0x8000 DEMOD + FEC LOCKED (system lock) */
10839                 *lock_stat = DRX_LOCKED;
10840         } else {
10841                 /* 0xC000 NEVER LOCKED */
10842                 /* (system will never be able to lock to the signal) */
10843                 *lock_stat = DRX_NEVER_LOCK;
10844         }
10845
10846         return 0;
10847 rw_error:
10848         return rc;
10849 }
10850
10851 /*============================================================================*/
10852
10853 /**
10854 * \fn int ctrl_set_standard()
10855 * \brief Set modulation standard to be used.
10856 * \param standard Modulation standard.
10857 * \return int.
10858 *
10859 * Setup stuff for the desired demodulation standard.
10860 * Disable and power down the previous selected demodulation standard
10861 *
10862 */
10863 static int
10864 ctrl_set_standard(struct drx_demod_instance *demod, enum drx_standard *standard)
10865 {
10866         struct drxj_data *ext_attr = NULL;
10867         int rc;
10868         enum drx_standard prev_standard;
10869
10870         /* check arguments */
10871         if ((standard == NULL) || (demod == NULL))
10872                 return -EINVAL;
10873
10874         ext_attr = (struct drxj_data *) demod->my_ext_attr;
10875         prev_standard = ext_attr->standard;
10876
10877         /*
10878            Stop and power down previous standard
10879          */
10880         switch (prev_standard) {
10881 #ifndef DRXJ_VSB_ONLY
10882         case DRX_STANDARD_ITU_A:        /* fallthrough */
10883         case DRX_STANDARD_ITU_B:        /* fallthrough */
10884         case DRX_STANDARD_ITU_C:
10885                 rc = power_down_qam(demod, false);
10886                 if (rc != 0) {
10887                         pr_err("error %d\n", rc);
10888                         goto rw_error;
10889                 }
10890                 break;
10891 #endif
10892         case DRX_STANDARD_8VSB:
10893                 rc = power_down_vsb(demod, false);
10894                 if (rc != 0) {
10895                         pr_err("error %d\n", rc);
10896                         goto rw_error;
10897                 }
10898                 break;
10899         case DRX_STANDARD_UNKNOWN:
10900                 /* Do nothing */
10901                 break;
10902         case DRX_STANDARD_AUTO: /* fallthrough */
10903         default:
10904                 return -EINVAL;
10905         }
10906
10907         /*
10908            Initialize channel independent registers
10909            Power up new standard
10910          */
10911         ext_attr->standard = *standard;
10912
10913         switch (*standard) {
10914 #ifndef DRXJ_VSB_ONLY
10915         case DRX_STANDARD_ITU_A:        /* fallthrough */
10916         case DRX_STANDARD_ITU_B:        /* fallthrough */
10917         case DRX_STANDARD_ITU_C:
10918                 do {
10919                         u16 dummy;
10920                         rc = drxj_dap_read_reg16(demod->my_i2c_dev_addr, SCU_RAM_VERSION_HI__A, &dummy, 0);
10921                         if (rc != 0) {
10922                                 pr_err("error %d\n", rc);
10923                                 goto rw_error;
10924                         }
10925                 } while (0);
10926                 break;
10927 #endif
10928         case DRX_STANDARD_8VSB:
10929                 rc = set_vsb_leak_n_gain(demod);
10930                 if (rc != 0) {
10931                         pr_err("error %d\n", rc);
10932                         goto rw_error;
10933                 }
10934                 break;
10935         default:
10936                 ext_attr->standard = DRX_STANDARD_UNKNOWN;
10937                 return -EINVAL;
10938                 break;
10939         }
10940
10941         return 0;
10942 rw_error:
10943         /* Don't know what the standard is now ... try again */
10944         ext_attr->standard = DRX_STANDARD_UNKNOWN;
10945         return rc;
10946 }
10947
10948 /*============================================================================*/
10949
10950 static void drxj_reset_mode(struct drxj_data *ext_attr)
10951 {
10952         /* Initialize default AFE configuartion for QAM */
10953         if (ext_attr->has_lna) {
10954                 /* IF AGC off, PGA active */
10955 #ifndef DRXJ_VSB_ONLY
10956                 ext_attr->qam_if_agc_cfg.standard = DRX_STANDARD_ITU_B;
10957                 ext_attr->qam_if_agc_cfg.ctrl_mode = DRX_AGC_CTRL_OFF;
10958                 ext_attr->qam_pga_cfg = 140 + (11 * 13);
10959 #endif
10960                 ext_attr->vsb_if_agc_cfg.standard = DRX_STANDARD_8VSB;
10961                 ext_attr->vsb_if_agc_cfg.ctrl_mode = DRX_AGC_CTRL_OFF;
10962                 ext_attr->vsb_pga_cfg = 140 + (11 * 13);
10963         } else {
10964                 /* IF AGC on, PGA not active */
10965 #ifndef DRXJ_VSB_ONLY
10966                 ext_attr->qam_if_agc_cfg.standard = DRX_STANDARD_ITU_B;
10967                 ext_attr->qam_if_agc_cfg.ctrl_mode = DRX_AGC_CTRL_AUTO;
10968                 ext_attr->qam_if_agc_cfg.min_output_level = 0;
10969                 ext_attr->qam_if_agc_cfg.max_output_level = 0x7FFF;
10970                 ext_attr->qam_if_agc_cfg.speed = 3;
10971                 ext_attr->qam_if_agc_cfg.top = 1297;
10972                 ext_attr->qam_pga_cfg = 140;
10973 #endif
10974                 ext_attr->vsb_if_agc_cfg.standard = DRX_STANDARD_8VSB;
10975                 ext_attr->vsb_if_agc_cfg.ctrl_mode = DRX_AGC_CTRL_AUTO;
10976                 ext_attr->vsb_if_agc_cfg.min_output_level = 0;
10977                 ext_attr->vsb_if_agc_cfg.max_output_level = 0x7FFF;
10978                 ext_attr->vsb_if_agc_cfg.speed = 3;
10979                 ext_attr->vsb_if_agc_cfg.top = 1024;
10980                 ext_attr->vsb_pga_cfg = 140;
10981         }
10982         /* TODO: remove min_output_level and max_output_level for both QAM and VSB after */
10983         /* mc has not used them */
10984 #ifndef DRXJ_VSB_ONLY
10985         ext_attr->qam_rf_agc_cfg.standard = DRX_STANDARD_ITU_B;
10986         ext_attr->qam_rf_agc_cfg.ctrl_mode = DRX_AGC_CTRL_AUTO;
10987         ext_attr->qam_rf_agc_cfg.min_output_level = 0;
10988         ext_attr->qam_rf_agc_cfg.max_output_level = 0x7FFF;
10989         ext_attr->qam_rf_agc_cfg.speed = 3;
10990         ext_attr->qam_rf_agc_cfg.top = 9500;
10991         ext_attr->qam_rf_agc_cfg.cut_off_current = 4000;
10992         ext_attr->qam_pre_saw_cfg.standard = DRX_STANDARD_ITU_B;
10993         ext_attr->qam_pre_saw_cfg.reference = 0x07;
10994         ext_attr->qam_pre_saw_cfg.use_pre_saw = true;
10995 #endif
10996         /* Initialize default AFE configuartion for VSB */
10997         ext_attr->vsb_rf_agc_cfg.standard = DRX_STANDARD_8VSB;
10998         ext_attr->vsb_rf_agc_cfg.ctrl_mode = DRX_AGC_CTRL_AUTO;
10999         ext_attr->vsb_rf_agc_cfg.min_output_level = 0;
11000         ext_attr->vsb_rf_agc_cfg.max_output_level = 0x7FFF;
11001         ext_attr->vsb_rf_agc_cfg.speed = 3;
11002         ext_attr->vsb_rf_agc_cfg.top = 9500;
11003         ext_attr->vsb_rf_agc_cfg.cut_off_current = 4000;
11004         ext_attr->vsb_pre_saw_cfg.standard = DRX_STANDARD_8VSB;
11005         ext_attr->vsb_pre_saw_cfg.reference = 0x07;
11006         ext_attr->vsb_pre_saw_cfg.use_pre_saw = true;
11007 }
11008
11009 /**
11010 * \fn int ctrl_power_mode()
11011 * \brief Set the power mode of the device to the specified power mode
11012 * \param demod Pointer to demodulator instance.
11013 * \param mode  Pointer to new power mode.
11014 * \return int.
11015 * \retval 0          Success
11016 * \retval -EIO       I2C error or other failure
11017 * \retval -EINVAL Invalid mode argument.
11018 *
11019 *
11020 */
11021 static int
11022 ctrl_power_mode(struct drx_demod_instance *demod, enum drx_power_mode *mode)
11023 {
11024         struct drx_common_attr *common_attr = (struct drx_common_attr *) NULL;
11025         struct drxj_data *ext_attr = (struct drxj_data *) NULL;
11026         struct i2c_device_addr *dev_addr = (struct i2c_device_addr *)NULL;
11027         int rc;
11028         u16 sio_cc_pwd_mode = 0;
11029
11030         common_attr = (struct drx_common_attr *) demod->my_common_attr;
11031         ext_attr = (struct drxj_data *) demod->my_ext_attr;
11032         dev_addr = demod->my_i2c_dev_addr;
11033
11034         /* Check arguments */
11035         if (mode == NULL)
11036                 return -EINVAL;
11037
11038         /* If already in requested power mode, do nothing */
11039         if (common_attr->current_power_mode == *mode)
11040                 return 0;
11041
11042         switch (*mode) {
11043         case DRX_POWER_UP:
11044         case DRXJ_POWER_DOWN_MAIN_PATH:
11045                 sio_cc_pwd_mode = SIO_CC_PWD_MODE_LEVEL_NONE;
11046                 break;
11047         case DRXJ_POWER_DOWN_CORE:
11048                 sio_cc_pwd_mode = SIO_CC_PWD_MODE_LEVEL_CLOCK;
11049                 break;
11050         case DRXJ_POWER_DOWN_PLL:
11051                 sio_cc_pwd_mode = SIO_CC_PWD_MODE_LEVEL_PLL;
11052                 break;
11053         case DRX_POWER_DOWN:
11054                 sio_cc_pwd_mode = SIO_CC_PWD_MODE_LEVEL_OSC;
11055                 break;
11056         default:
11057                 /* Unknow sleep mode */
11058                 return -EINVAL;
11059                 break;
11060         }
11061
11062         /* Check if device needs to be powered up */
11063         if ((common_attr->current_power_mode != DRX_POWER_UP)) {
11064                 rc = power_up_device(demod);
11065                 if (rc != 0) {
11066                         pr_err("error %d\n", rc);
11067                         goto rw_error;
11068                 }
11069         }
11070
11071         if ((*mode == DRX_POWER_UP)) {
11072                 /* Restore analog & pin configuartion */
11073
11074                 /* Initialize default AFE configuartion for VSB */
11075                 drxj_reset_mode(ext_attr);
11076         } else {
11077                 /* Power down to requested mode */
11078                 /* Backup some register settings */
11079                 /* Set pins with possible pull-ups connected to them in input mode */
11080                 /* Analog power down */
11081                 /* ADC power down */
11082                 /* Power down device */
11083                 /* stop all comm_exec */
11084                 /*
11085                    Stop and power down previous standard
11086                  */
11087
11088                 switch (ext_attr->standard) {
11089                 case DRX_STANDARD_ITU_A:
11090                 case DRX_STANDARD_ITU_B:
11091                 case DRX_STANDARD_ITU_C:
11092                         rc = power_down_qam(demod, true);
11093                         if (rc != 0) {
11094                                 pr_err("error %d\n", rc);
11095                                 goto rw_error;
11096                         }
11097                         break;
11098                 case DRX_STANDARD_8VSB:
11099                         rc = power_down_vsb(demod, true);
11100                         if (rc != 0) {
11101                                 pr_err("error %d\n", rc);
11102                                 goto rw_error;
11103                         }
11104                         break;
11105                 case DRX_STANDARD_PAL_SECAM_BG: /* fallthrough */
11106                 case DRX_STANDARD_PAL_SECAM_DK: /* fallthrough */
11107                 case DRX_STANDARD_PAL_SECAM_I:  /* fallthrough */
11108                 case DRX_STANDARD_PAL_SECAM_L:  /* fallthrough */
11109                 case DRX_STANDARD_PAL_SECAM_LP: /* fallthrough */
11110                 case DRX_STANDARD_NTSC: /* fallthrough */
11111                 case DRX_STANDARD_FM:
11112                         rc = power_down_atv(demod, ext_attr->standard, true);
11113                         if (rc != 0) {
11114                                 pr_err("error %d\n", rc);
11115                                 goto rw_error;
11116                         }
11117                         break;
11118                 case DRX_STANDARD_UNKNOWN:
11119                         /* Do nothing */
11120                         break;
11121                 case DRX_STANDARD_AUTO: /* fallthrough */
11122                 default:
11123                         return -EIO;
11124                 }
11125                 ext_attr->standard = DRX_STANDARD_UNKNOWN;
11126         }
11127
11128         if (*mode != DRXJ_POWER_DOWN_MAIN_PATH) {
11129                 rc = drxj_dap_write_reg16(dev_addr, SIO_CC_PWD_MODE__A, sio_cc_pwd_mode, 0);
11130                 if (rc != 0) {
11131                         pr_err("error %d\n", rc);
11132                         goto rw_error;
11133                 }
11134                 rc = drxj_dap_write_reg16(dev_addr, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY, 0);
11135                 if (rc != 0) {
11136                         pr_err("error %d\n", rc);
11137                         goto rw_error;
11138                 }
11139
11140                 if ((*mode != DRX_POWER_UP)) {
11141                         /* Initialize HI, wakeup key especially before put IC to sleep */
11142                         rc = init_hi(demod);
11143                         if (rc != 0) {
11144                                 pr_err("error %d\n", rc);
11145                                 goto rw_error;
11146                         }
11147
11148                         ext_attr->hi_cfg_ctrl |= SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ;
11149                         rc = hi_cfg_command(demod);
11150                         if (rc != 0) {
11151                                 pr_err("error %d\n", rc);
11152                                 goto rw_error;
11153                         }
11154                 }
11155         }
11156
11157         common_attr->current_power_mode = *mode;
11158
11159         return 0;
11160 rw_error:
11161         return rc;
11162 }
11163
11164 /*============================================================================*/
11165 /*== CTRL Set/Get Config related functions ===================================*/
11166 /*============================================================================*/
11167
11168 /**
11169 * \fn int ctrl_set_cfg_pre_saw()
11170 * \brief Set Pre-saw reference.
11171 * \param demod demod instance
11172 * \param u16 *
11173 * \return int.
11174 *
11175 * Check arguments
11176 * Dispatch handling to standard specific function.
11177 *
11178 */
11179 static int
11180 ctrl_set_cfg_pre_saw(struct drx_demod_instance *demod, struct drxj_cfg_pre_saw *pre_saw)
11181 {
11182         struct i2c_device_addr *dev_addr = NULL;
11183         struct drxj_data *ext_attr = NULL;
11184         int rc;
11185
11186         dev_addr = demod->my_i2c_dev_addr;
11187         ext_attr = (struct drxj_data *) demod->my_ext_attr;
11188
11189         /* check arguments */
11190         if ((pre_saw == NULL) || (pre_saw->reference > IQM_AF_PDREF__M)
11191             ) {
11192                 return -EINVAL;
11193         }
11194
11195         /* Only if standard is currently active */
11196         if ((ext_attr->standard == pre_saw->standard) ||
11197             (DRXJ_ISQAMSTD(ext_attr->standard) &&
11198              DRXJ_ISQAMSTD(pre_saw->standard)) ||
11199             (DRXJ_ISATVSTD(ext_attr->standard) &&
11200              DRXJ_ISATVSTD(pre_saw->standard))) {
11201                 rc = drxj_dap_write_reg16(dev_addr, IQM_AF_PDREF__A, pre_saw->reference, 0);
11202                 if (rc != 0) {
11203                         pr_err("error %d\n", rc);
11204                         goto rw_error;
11205                 }
11206         }
11207
11208         /* Store pre-saw settings */
11209         switch (pre_saw->standard) {
11210         case DRX_STANDARD_8VSB:
11211                 ext_attr->vsb_pre_saw_cfg = *pre_saw;
11212                 break;
11213 #ifndef DRXJ_VSB_ONLY
11214         case DRX_STANDARD_ITU_A:        /* fallthrough */
11215         case DRX_STANDARD_ITU_B:        /* fallthrough */
11216         case DRX_STANDARD_ITU_C:
11217                 ext_attr->qam_pre_saw_cfg = *pre_saw;
11218                 break;
11219 #endif
11220         default:
11221                 return -EINVAL;
11222         }
11223
11224         return 0;
11225 rw_error:
11226         return rc;
11227 }
11228
11229 /*============================================================================*/
11230
11231 /**
11232 * \fn int ctrl_set_cfg_afe_gain()
11233 * \brief Set AFE Gain.
11234 * \param demod demod instance
11235 * \param u16 *
11236 * \return int.
11237 *
11238 * Check arguments
11239 * Dispatch handling to standard specific function.
11240 *
11241 */
11242 static int
11243 ctrl_set_cfg_afe_gain(struct drx_demod_instance *demod, struct drxj_cfg_afe_gain *afe_gain)
11244 {
11245         struct i2c_device_addr *dev_addr = NULL;
11246         struct drxj_data *ext_attr = NULL;
11247         int rc;
11248         u8 gain = 0;
11249
11250         /* check arguments */
11251         if (afe_gain == NULL)
11252                 return -EINVAL;
11253
11254         dev_addr = demod->my_i2c_dev_addr;
11255         ext_attr = (struct drxj_data *) demod->my_ext_attr;
11256
11257         switch (afe_gain->standard) {
11258         case DRX_STANDARD_8VSB: /* fallthrough */
11259 #ifndef DRXJ_VSB_ONLY
11260         case DRX_STANDARD_ITU_A:        /* fallthrough */
11261         case DRX_STANDARD_ITU_B:        /* fallthrough */
11262         case DRX_STANDARD_ITU_C:
11263 #endif
11264                 /* Do nothing */
11265                 break;
11266         default:
11267                 return -EINVAL;
11268         }
11269
11270         /* TODO PGA gain is also written by microcode (at least by QAM and VSB)
11271            So I (PJ) think interface requires choice between auto, user mode */
11272
11273         if (afe_gain->gain >= 329)
11274                 gain = 15;
11275         else if (afe_gain->gain <= 147)
11276                 gain = 0;
11277         else
11278                 gain = (afe_gain->gain - 140 + 6) / 13;
11279
11280         /* Only if standard is currently active */
11281         if (ext_attr->standard == afe_gain->standard) {
11282                         rc = drxj_dap_write_reg16(dev_addr, IQM_AF_PGA_GAIN__A, gain, 0);
11283                         if (rc != 0) {
11284                                 pr_err("error %d\n", rc);
11285                                 goto rw_error;
11286                         }
11287                 }
11288
11289         /* Store AFE Gain settings */
11290         switch (afe_gain->standard) {
11291         case DRX_STANDARD_8VSB:
11292                 ext_attr->vsb_pga_cfg = gain * 13 + 140;
11293                 break;
11294 #ifndef DRXJ_VSB_ONLY
11295         case DRX_STANDARD_ITU_A:        /* fallthrough */
11296         case DRX_STANDARD_ITU_B:        /* fallthrough */
11297         case DRX_STANDARD_ITU_C:
11298                 ext_attr->qam_pga_cfg = gain * 13 + 140;
11299                 break;
11300 #endif
11301         default:
11302                 return -EIO;
11303         }
11304
11305         return 0;
11306 rw_error:
11307         return rc;
11308 }
11309
11310 /*============================================================================*/
11311
11312
11313 /*=============================================================================
11314 ===== EXPORTED FUNCTIONS ====================================================*/
11315
11316 static int drx_ctrl_u_code(struct drx_demod_instance *demod,
11317                        struct drxu_code_info *mc_info,
11318                        enum drxu_code_action action);
11319 static int drxj_set_lna_state(struct drx_demod_instance *demod, bool state);
11320
11321 /**
11322 * \fn drxj_open()
11323 * \brief Open the demod instance, configure device, configure drxdriver
11324 * \return Status_t Return status.
11325 *
11326 * drxj_open() can be called with a NULL ucode image => no ucode upload.
11327 * This means that drxj_open() must NOT contain SCU commands or, in general,
11328 * rely on SCU or AUD ucode to be present.
11329 *
11330 */
11331
11332 static int drxj_open(struct drx_demod_instance *demod)
11333 {
11334         struct i2c_device_addr *dev_addr = NULL;
11335         struct drxj_data *ext_attr = NULL;
11336         struct drx_common_attr *common_attr = NULL;
11337         u32 driver_version = 0;
11338         struct drxu_code_info ucode_info;
11339         struct drx_cfg_mpeg_output cfg_mpeg_output;
11340         int rc;
11341         enum drx_power_mode power_mode = DRX_POWER_UP;
11342
11343         if ((demod == NULL) ||
11344             (demod->my_common_attr == NULL) ||
11345             (demod->my_ext_attr == NULL) ||
11346             (demod->my_i2c_dev_addr == NULL) ||
11347             (demod->my_common_attr->is_opened)) {
11348                 return -EINVAL;
11349         }
11350
11351         /* Check arguments */
11352         if (demod->my_ext_attr == NULL)
11353                 return -EINVAL;
11354
11355         dev_addr = demod->my_i2c_dev_addr;
11356         ext_attr = (struct drxj_data *) demod->my_ext_attr;
11357         common_attr = (struct drx_common_attr *) demod->my_common_attr;
11358
11359         rc = ctrl_power_mode(demod, &power_mode);
11360         if (rc != 0) {
11361                 pr_err("error %d\n", rc);
11362                 goto rw_error;
11363         }
11364         if (power_mode != DRX_POWER_UP) {
11365                 rc = -EINVAL;
11366                 pr_err("failed to powerup device\n");
11367                 goto rw_error;
11368         }
11369
11370         /* has to be in front of setIqmAf and setOrxNsuAox */
11371         rc = get_device_capabilities(demod);
11372         if (rc != 0) {
11373                 pr_err("error %d\n", rc);
11374                 goto rw_error;
11375         }
11376
11377         /*
11378          * Soft reset of sys- and osc-clockdomain
11379          *
11380          * HACK: On windows, it writes a 0x07 here, instead of just 0x03.
11381          * As we didn't load the firmware here yet, we should do the same.
11382          * Btw, this is coherent with DRX-K, where we send reset codes
11383          * for modulation (OFTM, in DRX-k), SYS and OSC clock domains.
11384          */
11385         rc = drxj_dap_write_reg16(dev_addr, SIO_CC_SOFT_RST__A, (0x04 | SIO_CC_SOFT_RST_SYS__M | SIO_CC_SOFT_RST_OSC__M), 0);
11386         if (rc != 0) {
11387                 pr_err("error %d\n", rc);
11388                 goto rw_error;
11389         }
11390         rc = drxj_dap_write_reg16(dev_addr, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY, 0);
11391         if (rc != 0) {
11392                 pr_err("error %d\n", rc);
11393                 goto rw_error;
11394         }
11395         msleep(1);
11396
11397         /* TODO first make sure that everything keeps working before enabling this */
11398         /* PowerDownAnalogBlocks() */
11399         rc = drxj_dap_write_reg16(dev_addr, ATV_TOP_STDBY__A, (~ATV_TOP_STDBY_CVBS_STDBY_A2_ACTIVE) | ATV_TOP_STDBY_SIF_STDBY_STANDBY, 0);
11400         if (rc != 0) {
11401                 pr_err("error %d\n", rc);
11402                 goto rw_error;
11403         }
11404
11405         rc = set_iqm_af(demod, false);
11406         if (rc != 0) {
11407                 pr_err("error %d\n", rc);
11408                 goto rw_error;
11409         }
11410         rc = set_orx_nsu_aox(demod, false);
11411         if (rc != 0) {
11412                 pr_err("error %d\n", rc);
11413                 goto rw_error;
11414         }
11415
11416         rc = init_hi(demod);
11417         if (rc != 0) {
11418                 pr_err("error %d\n", rc);
11419                 goto rw_error;
11420         }
11421
11422         /* disable mpegoutput pins */
11423         memcpy(&cfg_mpeg_output, &common_attr->mpeg_cfg, sizeof(cfg_mpeg_output));
11424         cfg_mpeg_output.enable_mpeg_output = false;
11425
11426         rc = ctrl_set_cfg_mpeg_output(demod, &cfg_mpeg_output);
11427         if (rc != 0) {
11428                 pr_err("error %d\n", rc);
11429                 goto rw_error;
11430         }
11431         /* Stop AUD Inform SetAudio it will need to do all setting */
11432         rc = power_down_aud(demod);
11433         if (rc != 0) {
11434                 pr_err("error %d\n", rc);
11435                 goto rw_error;
11436         }
11437         /* Stop SCU */
11438         rc = drxj_dap_write_reg16(dev_addr, SCU_COMM_EXEC__A, SCU_COMM_EXEC_STOP, 0);
11439         if (rc != 0) {
11440                 pr_err("error %d\n", rc);
11441                 goto rw_error;
11442         }
11443
11444         /* Upload microcode */
11445         if (common_attr->microcode_file != NULL) {
11446                 /* Dirty trick to use common ucode upload & verify,
11447                    pretend device is already open */
11448                 common_attr->is_opened = true;
11449                 ucode_info.mc_file = common_attr->microcode_file;
11450
11451                 if (DRX_ISPOWERDOWNMODE(demod->my_common_attr->current_power_mode)) {
11452                         pr_err("Should powerup before loading the firmware.");
11453                         return -EINVAL;
11454                 }
11455
11456                 rc = drx_ctrl_u_code(demod, &ucode_info, UCODE_UPLOAD);
11457                 if (rc != 0) {
11458                         pr_err("error %d while uploading the firmware\n", rc);
11459                         goto rw_error;
11460                 }
11461                 if (common_attr->verify_microcode == true) {
11462                         rc = drx_ctrl_u_code(demod, &ucode_info, UCODE_VERIFY);
11463                         if (rc != 0) {
11464                                 pr_err("error %d while verifying the firmware\n",
11465                                        rc);
11466                                 goto rw_error;
11467                         }
11468                 }
11469                 common_attr->is_opened = false;
11470         }
11471
11472         /* Run SCU for a little while to initialize microcode version numbers */
11473         rc = drxj_dap_write_reg16(dev_addr, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE, 0);
11474         if (rc != 0) {
11475                 pr_err("error %d\n", rc);
11476                 goto rw_error;
11477         }
11478
11479         /* Initialize scan timeout */
11480         common_attr->scan_demod_lock_timeout = DRXJ_SCAN_TIMEOUT;
11481         common_attr->scan_desired_lock = DRX_LOCKED;
11482
11483         drxj_reset_mode(ext_attr);
11484         ext_attr->standard = DRX_STANDARD_UNKNOWN;
11485
11486         rc = smart_ant_init(demod);
11487         if (rc != 0) {
11488                 pr_err("error %d\n", rc);
11489                 goto rw_error;
11490         }
11491
11492         /* Stamp driver version number in SCU data RAM in BCD code
11493            Done to enable field application engineers to retrieve drxdriver version
11494            via I2C from SCU RAM
11495          */
11496         driver_version = (VERSION_MAJOR / 100) % 10;
11497         driver_version <<= 4;
11498         driver_version += (VERSION_MAJOR / 10) % 10;
11499         driver_version <<= 4;
11500         driver_version += (VERSION_MAJOR % 10);
11501         driver_version <<= 4;
11502         driver_version += (VERSION_MINOR % 10);
11503         driver_version <<= 4;
11504         driver_version += (VERSION_PATCH / 1000) % 10;
11505         driver_version <<= 4;
11506         driver_version += (VERSION_PATCH / 100) % 10;
11507         driver_version <<= 4;
11508         driver_version += (VERSION_PATCH / 10) % 10;
11509         driver_version <<= 4;
11510         driver_version += (VERSION_PATCH % 10);
11511         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_DRIVER_VER_HI__A, (u16)(driver_version >> 16), 0);
11512         if (rc != 0) {
11513                 pr_err("error %d\n", rc);
11514                 goto rw_error;
11515         }
11516         rc = drxj_dap_write_reg16(dev_addr, SCU_RAM_DRIVER_VER_LO__A, (u16)(driver_version & 0xFFFF), 0);
11517         if (rc != 0) {
11518                 pr_err("error %d\n", rc);
11519                 goto rw_error;
11520         }
11521
11522         rc = ctrl_set_oob(demod, NULL);
11523         if (rc != 0) {
11524                 pr_err("error %d\n", rc);
11525                 goto rw_error;
11526         }
11527
11528         /* refresh the audio data structure with default */
11529         ext_attr->aud_data = drxj_default_aud_data_g;
11530
11531         demod->my_common_attr->is_opened = true;
11532         drxj_set_lna_state(demod, false);
11533         return 0;
11534 rw_error:
11535         common_attr->is_opened = false;
11536         return rc;
11537 }
11538
11539 /*============================================================================*/
11540 /**
11541 * \fn drxj_close()
11542 * \brief Close the demod instance, power down the device
11543 * \return Status_t Return status.
11544 *
11545 */
11546 static int drxj_close(struct drx_demod_instance *demod)
11547 {
11548         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
11549         int rc;
11550         enum drx_power_mode power_mode = DRX_POWER_UP;
11551
11552         if ((demod->my_common_attr == NULL) ||
11553             (demod->my_ext_attr == NULL) ||
11554             (demod->my_i2c_dev_addr == NULL) ||
11555             (!demod->my_common_attr->is_opened)) {
11556                 return -EINVAL;
11557         }
11558
11559         /* power up */
11560         rc = ctrl_power_mode(demod, &power_mode);
11561         if (rc != 0) {
11562                 pr_err("error %d\n", rc);
11563                 goto rw_error;
11564         }
11565
11566         rc = drxj_dap_write_reg16(dev_addr, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE, 0);
11567         if (rc != 0) {
11568                 pr_err("error %d\n", rc);
11569                 goto rw_error;
11570         }
11571         power_mode = DRX_POWER_DOWN;
11572         rc = ctrl_power_mode(demod, &power_mode);
11573         if (rc != 0) {
11574                 pr_err("error %d\n", rc);
11575                 goto rw_error;
11576         }
11577
11578         DRX_ATTR_ISOPENED(demod) = false;
11579
11580         return 0;
11581 rw_error:
11582         DRX_ATTR_ISOPENED(demod) = false;
11583
11584         return rc;
11585 }
11586
11587 /*
11588  * Microcode related functions
11589  */
11590
11591 /**
11592  * drx_u_code_compute_crc       - Compute CRC of block of microcode data.
11593  * @block_data: Pointer to microcode data.
11594  * @nr_words:   Size of microcode block (number of 16 bits words).
11595  *
11596  * returns The computed CRC residue.
11597  */
11598 static u16 drx_u_code_compute_crc(u8 *block_data, u16 nr_words)
11599 {
11600         u16 i = 0;
11601         u16 j = 0;
11602         u32 crc_word = 0;
11603         u32 carry = 0;
11604
11605         while (i < nr_words) {
11606                 crc_word |= (u32)be16_to_cpu(*(__be16 *)(block_data));
11607                 for (j = 0; j < 16; j++) {
11608                         crc_word <<= 1;
11609                         if (carry != 0)
11610                                 crc_word ^= 0x80050000UL;
11611                         carry = crc_word & 0x80000000UL;
11612                 }
11613                 i++;
11614                 block_data += (sizeof(u16));
11615         }
11616         return (u16)(crc_word >> 16);
11617 }
11618
11619 /**
11620  * drx_check_firmware - checks if the loaded firmware is valid
11621  *
11622  * @demod:      demod structure
11623  * @mc_data:    pointer to the start of the firmware
11624  * @size:       firmware size
11625  */
11626 static int drx_check_firmware(struct drx_demod_instance *demod, u8 *mc_data,
11627                           unsigned size)
11628 {
11629         struct drxu_code_block_hdr block_hdr;
11630         int i;
11631         unsigned count = 2 * sizeof(u16);
11632         u32 mc_dev_type, mc_version, mc_base_version;
11633         u16 mc_nr_of_blks = be16_to_cpu(*(__be16 *)(mc_data + sizeof(u16)));
11634
11635         /*
11636          * Scan microcode blocks first for version info
11637          * and firmware check
11638          */
11639
11640         /* Clear version block */
11641         DRX_ATTR_MCRECORD(demod).aux_type = 0;
11642         DRX_ATTR_MCRECORD(demod).mc_dev_type = 0;
11643         DRX_ATTR_MCRECORD(demod).mc_version = 0;
11644         DRX_ATTR_MCRECORD(demod).mc_base_version = 0;
11645
11646         for (i = 0; i < mc_nr_of_blks; i++) {
11647                 if (count + 3 * sizeof(u16) + sizeof(u32) > size)
11648                         goto eof;
11649
11650                 /* Process block header */
11651                 block_hdr.addr = be32_to_cpu(*(__be32 *)(mc_data + count));
11652                 count += sizeof(u32);
11653                 block_hdr.size = be16_to_cpu(*(__be16 *)(mc_data + count));
11654                 count += sizeof(u16);
11655                 block_hdr.flags = be16_to_cpu(*(__be16 *)(mc_data + count));
11656                 count += sizeof(u16);
11657                 block_hdr.CRC = be16_to_cpu(*(__be16 *)(mc_data + count));
11658                 count += sizeof(u16);
11659
11660                 pr_debug("%u: addr %u, size %u, flags 0x%04x, CRC 0x%04x\n",
11661                         count, block_hdr.addr, block_hdr.size, block_hdr.flags,
11662                         block_hdr.CRC);
11663
11664                 if (block_hdr.flags & 0x8) {
11665                         u8 *auxblk = ((void *)mc_data) + block_hdr.addr;
11666                         u16 auxtype;
11667
11668                         if (block_hdr.addr + sizeof(u16) > size)
11669                                 goto eof;
11670
11671                         auxtype = be16_to_cpu(*(__be16 *)(auxblk));
11672
11673                         /* Aux block. Check type */
11674                         if (DRX_ISMCVERTYPE(auxtype)) {
11675                                 if (block_hdr.addr + 2 * sizeof(u16) + 2 * sizeof (u32) > size)
11676                                         goto eof;
11677
11678                                 auxblk += sizeof(u16);
11679                                 mc_dev_type = be32_to_cpu(*(__be32 *)(auxblk));
11680                                 auxblk += sizeof(u32);
11681                                 mc_version = be32_to_cpu(*(__be32 *)(auxblk));
11682                                 auxblk += sizeof(u32);
11683                                 mc_base_version = be32_to_cpu(*(__be32 *)(auxblk));
11684
11685                                 DRX_ATTR_MCRECORD(demod).aux_type = auxtype;
11686                                 DRX_ATTR_MCRECORD(demod).mc_dev_type = mc_dev_type;
11687                                 DRX_ATTR_MCRECORD(demod).mc_version = mc_version;
11688                                 DRX_ATTR_MCRECORD(demod).mc_base_version = mc_base_version;
11689
11690                                 pr_info("Firmware dev %x, ver %x, base ver %x\n",
11691                                         mc_dev_type, mc_version, mc_base_version);
11692
11693                         }
11694                 } else if (count + block_hdr.size * sizeof(u16) > size)
11695                         goto eof;
11696
11697                 count += block_hdr.size * sizeof(u16);
11698         }
11699         return 0;
11700 eof:
11701         pr_err("Firmware is truncated at pos %u/%u\n", count, size);
11702         return -EINVAL;
11703 }
11704
11705 /**
11706  * drx_ctrl_u_code - Handle microcode upload or verify.
11707  * @dev_addr: Address of device.
11708  * @mc_info:  Pointer to information about microcode data.
11709  * @action:  Either UCODE_UPLOAD or UCODE_VERIFY
11710  *
11711  * This function returns:
11712  *      0:
11713  *              - In case of UCODE_UPLOAD: code is successfully uploaded.
11714  *               - In case of UCODE_VERIFY: image on device is equal to
11715  *                image provided to this control function.
11716  *      -EIO:
11717  *              - In case of UCODE_UPLOAD: I2C error.
11718  *              - In case of UCODE_VERIFY: I2C error or image on device
11719  *                is not equal to image provided to this control function.
11720  *      -EINVAL:
11721  *              - Invalid arguments.
11722  *              - Provided image is corrupt
11723  */
11724 static int drx_ctrl_u_code(struct drx_demod_instance *demod,
11725                        struct drxu_code_info *mc_info,
11726                        enum drxu_code_action action)
11727 {
11728         struct i2c_device_addr *dev_addr = demod->my_i2c_dev_addr;
11729         int rc;
11730         u16 i = 0;
11731         u16 mc_nr_of_blks = 0;
11732         u16 mc_magic_word = 0;
11733         const u8 *mc_data_init = NULL;
11734         u8 *mc_data = NULL;
11735         unsigned size;
11736         char *mc_file;
11737
11738         /* Check arguments */
11739         if (!mc_info || !mc_info->mc_file)
11740                 return -EINVAL;
11741
11742         mc_file = mc_info->mc_file;
11743
11744         if (!demod->firmware) {
11745                 const struct firmware *fw = NULL;
11746
11747                 rc = request_firmware(&fw, mc_file, demod->i2c->dev.parent);
11748                 if (rc < 0) {
11749                         pr_err("Couldn't read firmware %s\n", mc_file);
11750                         return rc;
11751                 }
11752                 demod->firmware = fw;
11753
11754                 if (demod->firmware->size < 2 * sizeof(u16)) {
11755                         rc = -EINVAL;
11756                         pr_err("Firmware is too short!\n");
11757                         goto release;
11758                 }
11759
11760                 pr_info("Firmware %s, size %zu\n",
11761                         mc_file, demod->firmware->size);
11762         }
11763
11764         mc_data_init = demod->firmware->data;
11765         size = demod->firmware->size;
11766
11767         mc_data = (void *)mc_data_init;
11768         /* Check data */
11769         mc_magic_word = be16_to_cpu(*(__be16 *)(mc_data));
11770         mc_data += sizeof(u16);
11771         mc_nr_of_blks = be16_to_cpu(*(__be16 *)(mc_data));
11772         mc_data += sizeof(u16);
11773
11774         if ((mc_magic_word != DRX_UCODE_MAGIC_WORD) || (mc_nr_of_blks == 0)) {
11775                 rc = -EINVAL;
11776                 pr_err("Firmware magic word doesn't match\n");
11777                 goto release;
11778         }
11779
11780         if (action == UCODE_UPLOAD) {
11781                 rc = drx_check_firmware(demod, (u8 *)mc_data_init, size);
11782                 if (rc)
11783                         goto release;
11784                 pr_info("Uploading firmware %s\n", mc_file);
11785         } else {
11786                 pr_info("Verifying if firmware upload was ok.\n");
11787         }
11788
11789         /* Process microcode blocks */
11790         for (i = 0; i < mc_nr_of_blks; i++) {
11791                 struct drxu_code_block_hdr block_hdr;
11792                 u16 mc_block_nr_bytes = 0;
11793
11794                 /* Process block header */
11795                 block_hdr.addr = be32_to_cpu(*(__be32 *)(mc_data));
11796                 mc_data += sizeof(u32);
11797                 block_hdr.size = be16_to_cpu(*(__be16 *)(mc_data));
11798                 mc_data += sizeof(u16);
11799                 block_hdr.flags = be16_to_cpu(*(__be16 *)(mc_data));
11800                 mc_data += sizeof(u16);
11801                 block_hdr.CRC = be16_to_cpu(*(__be16 *)(mc_data));
11802                 mc_data += sizeof(u16);
11803
11804                 pr_debug("%u: addr %u, size %u, flags 0x%04x, CRC 0x%04x\n",
11805                         (unsigned)(mc_data - mc_data_init), block_hdr.addr,
11806                          block_hdr.size, block_hdr.flags, block_hdr.CRC);
11807
11808                 /* Check block header on:
11809                    - data larger than 64Kb
11810                    - if CRC enabled check CRC
11811                  */
11812                 if ((block_hdr.size > 0x7FFF) ||
11813                     (((block_hdr.flags & DRX_UCODE_CRC_FLAG) != 0) &&
11814                      (block_hdr.CRC != drx_u_code_compute_crc(mc_data, block_hdr.size)))
11815                     ) {
11816                         /* Wrong data ! */
11817                         rc = -EINVAL;
11818                         pr_err("firmware CRC is wrong\n");
11819                         goto release;
11820                 }
11821
11822                 if (!block_hdr.size)
11823                         continue;
11824
11825                 mc_block_nr_bytes = block_hdr.size * ((u16) sizeof(u16));
11826
11827                 /* Perform the desired action */
11828                 switch (action) {
11829                 case UCODE_UPLOAD:      /* Upload microcode */
11830                         if (drxdap_fasi_write_block(dev_addr,
11831                                                         block_hdr.addr,
11832                                                         mc_block_nr_bytes,
11833                                                         mc_data, 0x0000)) {
11834                                 rc = -EIO;
11835                                 pr_err("error writing firmware at pos %u\n",
11836                                        (unsigned)(mc_data - mc_data_init));
11837                                 goto release;
11838                         }
11839                         break;
11840                 case UCODE_VERIFY: {    /* Verify uploaded microcode */
11841                         int result = 0;
11842                         u8 mc_data_buffer[DRX_UCODE_MAX_BUF_SIZE];
11843                         u32 bytes_to_comp = 0;
11844                         u32 bytes_left = mc_block_nr_bytes;
11845                         u32 curr_addr = block_hdr.addr;
11846                         u8 *curr_ptr = mc_data;
11847
11848                         while (bytes_left != 0) {
11849                                 if (bytes_left > DRX_UCODE_MAX_BUF_SIZE)
11850                                         bytes_to_comp = DRX_UCODE_MAX_BUF_SIZE;
11851                                 else
11852                                         bytes_to_comp = bytes_left;
11853
11854                                 if (drxdap_fasi_read_block(dev_addr,
11855                                                     curr_addr,
11856                                                     (u16)bytes_to_comp,
11857                                                     (u8 *)mc_data_buffer,
11858                                                     0x0000)) {
11859                                         pr_err("error reading firmware at pos %u\n",
11860                                                (unsigned)(mc_data - mc_data_init));
11861                                         return -EIO;
11862                                 }
11863
11864                                 result = memcmp(curr_ptr, mc_data_buffer,
11865                                                 bytes_to_comp);
11866
11867                                 if (result) {
11868                                         pr_err("error verifying firmware at pos %u\n",
11869                                                (unsigned)(mc_data - mc_data_init));
11870                                         return -EIO;
11871                                 }
11872
11873                                 curr_addr += ((dr_xaddr_t)(bytes_to_comp / 2));
11874                                 curr_ptr =&(curr_ptr[bytes_to_comp]);
11875                                 bytes_left -=((u32) bytes_to_comp);
11876                         }
11877                         break;
11878                 }
11879                 default:
11880                         return -EINVAL;
11881                         break;
11882
11883                 }
11884                 mc_data += mc_block_nr_bytes;
11885         }
11886
11887         return 0;
11888
11889 release:
11890         release_firmware(demod->firmware);
11891         demod->firmware = NULL;
11892
11893         return rc;
11894 }
11895
11896 /* caller is expected to check if lna is supported before enabling */
11897 static int drxj_set_lna_state(struct drx_demod_instance *demod, bool state)
11898 {
11899         struct drxuio_cfg uio_cfg;
11900         struct drxuio_data uio_data;
11901         int result;
11902
11903         uio_cfg.uio = DRX_UIO1;
11904         uio_cfg.mode = DRX_UIO_MODE_READWRITE;
11905         /* Configure user-I/O #3: enable read/write */
11906         result = ctrl_set_uio_cfg(demod, &uio_cfg);
11907         if (result) {
11908                 pr_err("Failed to setup LNA GPIO!\n");
11909                 return result;
11910         }
11911
11912         uio_data.uio = DRX_UIO1;
11913         uio_data.value = state;
11914         result = ctrl_uio_write(demod, &uio_data);
11915         if (result != 0) {
11916                 pr_err("Failed to %sable LNA!\n",
11917                        state ? "en" : "dis");
11918                 return result;
11919         }
11920         return 0;
11921 }
11922
11923 /*
11924  * The Linux DVB Driver for Micronas DRX39xx family (drx3933j)
11925  *
11926  * Written by Devin Heitmueller <devin.heitmueller@kernellabs.com>
11927  */
11928
11929 static int drx39xxj_set_powerstate(struct dvb_frontend *fe, int enable)
11930 {
11931         struct drx39xxj_state *state = fe->demodulator_priv;
11932         struct drx_demod_instance *demod = state->demod;
11933         int result;
11934         enum drx_power_mode power_mode;
11935
11936         if (enable)
11937                 power_mode = DRX_POWER_UP;
11938         else
11939                 power_mode = DRX_POWER_DOWN;
11940
11941         result = ctrl_power_mode(demod, &power_mode);
11942         if (result != 0) {
11943                 pr_err("Power state change failed\n");
11944                 return 0;
11945         }
11946
11947         return 0;
11948 }
11949
11950 static int drx39xxj_read_status(struct dvb_frontend *fe, enum fe_status *status)
11951 {
11952         struct drx39xxj_state *state = fe->demodulator_priv;
11953         struct drx_demod_instance *demod = state->demod;
11954         int result;
11955         enum drx_lock_status lock_status;
11956
11957         *status = 0;
11958
11959         result = ctrl_lock_status(demod, &lock_status);
11960         if (result != 0) {
11961                 pr_err("drx39xxj: could not get lock status!\n");
11962                 *status = 0;
11963         }
11964
11965         switch (lock_status) {
11966         case DRX_NEVER_LOCK:
11967                 *status = 0;
11968                 pr_err("drx says NEVER_LOCK\n");
11969                 break;
11970         case DRX_NOT_LOCKED:
11971                 *status = 0;
11972                 break;
11973         case DRX_LOCK_STATE_1:
11974         case DRX_LOCK_STATE_2:
11975         case DRX_LOCK_STATE_3:
11976         case DRX_LOCK_STATE_4:
11977         case DRX_LOCK_STATE_5:
11978         case DRX_LOCK_STATE_6:
11979         case DRX_LOCK_STATE_7:
11980         case DRX_LOCK_STATE_8:
11981         case DRX_LOCK_STATE_9:
11982                 *status = FE_HAS_SIGNAL
11983                     | FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC;
11984                 break;
11985         case DRX_LOCKED:
11986                 *status = FE_HAS_SIGNAL
11987                     | FE_HAS_CARRIER
11988                     | FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
11989                 break;
11990         default:
11991                 pr_err("Lock state unknown %d\n", lock_status);
11992         }
11993         ctrl_sig_quality(demod, lock_status);
11994
11995         return 0;
11996 }
11997
11998 static int drx39xxj_read_ber(struct dvb_frontend *fe, u32 *ber)
11999 {
12000         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
12001
12002         if (p->pre_bit_error.stat[0].scale == FE_SCALE_NOT_AVAILABLE) {
12003                 *ber = 0;
12004                 return 0;
12005         }
12006
12007         if (!p->pre_bit_count.stat[0].uvalue) {
12008                 if (!p->pre_bit_error.stat[0].uvalue)
12009                         *ber = 0;
12010                 else
12011                         *ber = 1000000;
12012         } else {
12013                 *ber = frac_times1e6(p->pre_bit_error.stat[0].uvalue,
12014                                      p->pre_bit_count.stat[0].uvalue);
12015         }
12016         return 0;
12017 }
12018
12019 static int drx39xxj_read_signal_strength(struct dvb_frontend *fe,
12020                                          u16 *strength)
12021 {
12022         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
12023
12024         if (p->strength.stat[0].scale == FE_SCALE_NOT_AVAILABLE) {
12025                 *strength = 0;
12026                 return 0;
12027         }
12028
12029         *strength = p->strength.stat[0].uvalue;
12030         return 0;
12031 }
12032
12033 static int drx39xxj_read_snr(struct dvb_frontend *fe, u16 *snr)
12034 {
12035         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
12036         u64 tmp64;
12037
12038         if (p->cnr.stat[0].scale == FE_SCALE_NOT_AVAILABLE) {
12039                 *snr = 0;
12040                 return 0;
12041         }
12042
12043         tmp64 = p->cnr.stat[0].svalue;
12044         do_div(tmp64, 10);
12045         *snr = tmp64;
12046         return 0;
12047 }
12048
12049 static int drx39xxj_read_ucblocks(struct dvb_frontend *fe, u32 *ucb)
12050 {
12051         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
12052
12053         if (p->block_error.stat[0].scale == FE_SCALE_NOT_AVAILABLE) {
12054                 *ucb = 0;
12055                 return 0;
12056         }
12057
12058         *ucb = p->block_error.stat[0].uvalue;
12059         return 0;
12060 }
12061
12062 static int drx39xxj_set_frontend(struct dvb_frontend *fe)
12063 {
12064 #ifdef DJH_DEBUG
12065         int i;
12066 #endif
12067         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
12068         struct drx39xxj_state *state = fe->demodulator_priv;
12069         struct drx_demod_instance *demod = state->demod;
12070         enum drx_standard standard = DRX_STANDARD_8VSB;
12071         struct drx_channel channel;
12072         int result;
12073         static const struct drx_channel def_channel = {
12074                 /* frequency      */ 0,
12075                 /* bandwidth      */ DRX_BANDWIDTH_6MHZ,
12076                 /* mirror         */ DRX_MIRROR_NO,
12077                 /* constellation  */ DRX_CONSTELLATION_AUTO,
12078                 /* hierarchy      */ DRX_HIERARCHY_UNKNOWN,
12079                 /* priority       */ DRX_PRIORITY_UNKNOWN,
12080                 /* coderate       */ DRX_CODERATE_UNKNOWN,
12081                 /* guard          */ DRX_GUARD_UNKNOWN,
12082                 /* fftmode        */ DRX_FFTMODE_UNKNOWN,
12083                 /* classification */ DRX_CLASSIFICATION_AUTO,
12084                 /* symbolrate     */ 5057000,
12085                 /* interleavemode */ DRX_INTERLEAVEMODE_UNKNOWN,
12086                 /* ldpc           */ DRX_LDPC_UNKNOWN,
12087                 /* carrier        */ DRX_CARRIER_UNKNOWN,
12088                 /* frame mode     */ DRX_FRAMEMODE_UNKNOWN
12089         };
12090         u32 constellation = DRX_CONSTELLATION_AUTO;
12091
12092         /* Bring the demod out of sleep */
12093         drx39xxj_set_powerstate(fe, 1);
12094
12095         if (fe->ops.tuner_ops.set_params) {
12096                 u32 int_freq;
12097
12098                 if (fe->ops.i2c_gate_ctrl)
12099                         fe->ops.i2c_gate_ctrl(fe, 1);
12100
12101                 /* Set tuner to desired frequency and standard */
12102                 fe->ops.tuner_ops.set_params(fe);
12103
12104                 /* Use the tuner's IF */
12105                 if (fe->ops.tuner_ops.get_if_frequency) {
12106                         fe->ops.tuner_ops.get_if_frequency(fe, &int_freq);
12107                         demod->my_common_attr->intermediate_freq = int_freq / 1000;
12108                 }
12109
12110                 if (fe->ops.i2c_gate_ctrl)
12111                         fe->ops.i2c_gate_ctrl(fe, 0);
12112         }
12113
12114         switch (p->delivery_system) {
12115         case SYS_ATSC:
12116                 standard = DRX_STANDARD_8VSB;
12117                 break;
12118         case SYS_DVBC_ANNEX_B:
12119                 standard = DRX_STANDARD_ITU_B;
12120
12121                 switch (p->modulation) {
12122                 case QAM_64:
12123                         constellation = DRX_CONSTELLATION_QAM64;
12124                         break;
12125                 case QAM_256:
12126                         constellation = DRX_CONSTELLATION_QAM256;
12127                         break;
12128                 default:
12129                         constellation = DRX_CONSTELLATION_AUTO;
12130                         break;
12131                 }
12132                 break;
12133         default:
12134                 return -EINVAL;
12135         }
12136         /* Set the standard (will be powered up if necessary */
12137         result = ctrl_set_standard(demod, &standard);
12138         if (result != 0) {
12139                 pr_err("Failed to set standard! result=%02x\n",
12140                         result);
12141                 return -EINVAL;
12142         }
12143
12144         /* set channel parameters */
12145         channel = def_channel;
12146         channel.frequency = p->frequency / 1000;
12147         channel.bandwidth = DRX_BANDWIDTH_6MHZ;
12148         channel.constellation = constellation;
12149
12150         /* program channel */
12151         result = ctrl_set_channel(demod, &channel);
12152         if (result != 0) {
12153                 pr_err("Failed to set channel!\n");
12154                 return -EINVAL;
12155         }
12156         /* Just for giggles, let's shut off the LNA again.... */
12157         drxj_set_lna_state(demod, false);
12158
12159         /* After set_frontend, except for strength, stats aren't available */
12160         p->strength.stat[0].scale = FE_SCALE_RELATIVE;
12161
12162         return 0;
12163 }
12164
12165 static int drx39xxj_sleep(struct dvb_frontend *fe)
12166 {
12167         /* power-down the demodulator */
12168         return drx39xxj_set_powerstate(fe, 0);
12169 }
12170
12171 static int drx39xxj_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
12172 {
12173         struct drx39xxj_state *state = fe->demodulator_priv;
12174         struct drx_demod_instance *demod = state->demod;
12175         bool i2c_gate_state;
12176         int result;
12177
12178 #ifdef DJH_DEBUG
12179         pr_debug("i2c gate call: enable=%d state=%d\n", enable,
12180                state->i2c_gate_open);
12181 #endif
12182
12183         if (enable)
12184                 i2c_gate_state = true;
12185         else
12186                 i2c_gate_state = false;
12187
12188         if (state->i2c_gate_open == enable) {
12189                 /* We're already in the desired state */
12190                 return 0;
12191         }
12192
12193         result = ctrl_i2c_bridge(demod, &i2c_gate_state);
12194         if (result != 0) {
12195                 pr_err("drx39xxj: could not open i2c gate [%d]\n",
12196                        result);
12197                 dump_stack();
12198         } else {
12199                 state->i2c_gate_open = enable;
12200         }
12201         return 0;
12202 }
12203
12204 static int drx39xxj_init(struct dvb_frontend *fe)
12205 {
12206         struct drx39xxj_state *state = fe->demodulator_priv;
12207         struct drx_demod_instance *demod = state->demod;
12208         int rc = 0;
12209
12210         if (fe->exit == DVB_FE_DEVICE_RESUME) {
12211                 /* so drxj_open() does what it needs to do */
12212                 demod->my_common_attr->is_opened = false;
12213                 rc = drxj_open(demod);
12214                 if (rc != 0)
12215                         pr_err("drx39xxj_init(): DRX open failed rc=%d!\n", rc);
12216         } else
12217                 drx39xxj_set_powerstate(fe, 1);
12218
12219         return rc;
12220 }
12221
12222 static int drx39xxj_set_lna(struct dvb_frontend *fe)
12223 {
12224         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
12225         struct drx39xxj_state *state = fe->demodulator_priv;
12226         struct drx_demod_instance *demod = state->demod;
12227         struct drxj_data *ext_attr = demod->my_ext_attr;
12228
12229         if (c->lna) {
12230                 if (!ext_attr->has_lna) {
12231                         pr_err("LNA is not supported on this device!\n");
12232                         return -EINVAL;
12233
12234                 }
12235         }
12236
12237         return drxj_set_lna_state(demod, c->lna);
12238 }
12239
12240 static int drx39xxj_get_tune_settings(struct dvb_frontend *fe,
12241                                       struct dvb_frontend_tune_settings *tune)
12242 {
12243         tune->min_delay_ms = 1000;
12244         return 0;
12245 }
12246
12247 static void drx39xxj_release(struct dvb_frontend *fe)
12248 {
12249         struct drx39xxj_state *state = fe->demodulator_priv;
12250         struct drx_demod_instance *demod = state->demod;
12251
12252         /* if device is removed don't access it */
12253         if (fe->exit != DVB_FE_DEVICE_REMOVED)
12254                 drxj_close(demod);
12255
12256         kfree(demod->my_ext_attr);
12257         kfree(demod->my_common_attr);
12258         kfree(demod->my_i2c_dev_addr);
12259         release_firmware(demod->firmware);
12260         kfree(demod);
12261         kfree(state);
12262 }
12263
12264 static struct dvb_frontend_ops drx39xxj_ops;
12265
12266 struct dvb_frontend *drx39xxj_attach(struct i2c_adapter *i2c)
12267 {
12268         struct drx39xxj_state *state = NULL;
12269         struct i2c_device_addr *demod_addr = NULL;
12270         struct drx_common_attr *demod_comm_attr = NULL;
12271         struct drxj_data *demod_ext_attr = NULL;
12272         struct drx_demod_instance *demod = NULL;
12273         struct dtv_frontend_properties *p;
12274         int result;
12275
12276         /* allocate memory for the internal state */
12277         state = kzalloc(sizeof(struct drx39xxj_state), GFP_KERNEL);
12278         if (state == NULL)
12279                 goto error;
12280
12281         demod = kmalloc(sizeof(struct drx_demod_instance), GFP_KERNEL);
12282         if (demod == NULL)
12283                 goto error;
12284
12285         demod_addr = kmemdup(&drxj_default_addr_g,
12286                              sizeof(struct i2c_device_addr), GFP_KERNEL);
12287         if (demod_addr == NULL)
12288                 goto error;
12289
12290         demod_comm_attr = kmemdup(&drxj_default_comm_attr_g,
12291                                   sizeof(struct drx_common_attr), GFP_KERNEL);
12292         if (demod_comm_attr == NULL)
12293                 goto error;
12294
12295         demod_ext_attr = kmemdup(&drxj_data_g, sizeof(struct drxj_data),
12296                                  GFP_KERNEL);
12297         if (demod_ext_attr == NULL)
12298                 goto error;
12299
12300         /* setup the state */
12301         state->i2c = i2c;
12302         state->demod = demod;
12303
12304         /* setup the demod data */
12305         memcpy(demod, &drxj_default_demod_g, sizeof(struct drx_demod_instance));
12306
12307         demod->my_i2c_dev_addr = demod_addr;
12308         demod->my_common_attr = demod_comm_attr;
12309         demod->my_i2c_dev_addr->user_data = state;
12310         demod->my_common_attr->microcode_file = DRX39XX_MAIN_FIRMWARE;
12311         demod->my_common_attr->verify_microcode = true;
12312         demod->my_common_attr->intermediate_freq = 5000;
12313         demod->my_common_attr->current_power_mode = DRX_POWER_DOWN;
12314         demod->my_ext_attr = demod_ext_attr;
12315         ((struct drxj_data *)demod_ext_attr)->uio_sma_tx_mode = DRX_UIO_MODE_READWRITE;
12316         demod->i2c = i2c;
12317
12318         result = drxj_open(demod);
12319         if (result != 0) {
12320                 pr_err("DRX open failed!  Aborting\n");
12321                 goto error;
12322         }
12323
12324         /* create dvb_frontend */
12325         memcpy(&state->frontend.ops, &drx39xxj_ops,
12326                sizeof(struct dvb_frontend_ops));
12327
12328         state->frontend.demodulator_priv = state;
12329
12330         /* Initialize stats - needed for DVBv5 stats to work */
12331         p = &state->frontend.dtv_property_cache;
12332         p->strength.len = 1;
12333         p->pre_bit_count.len = 1;
12334         p->pre_bit_error.len = 1;
12335         p->post_bit_count.len = 1;
12336         p->post_bit_error.len = 1;
12337         p->block_count.len = 1;
12338         p->block_error.len = 1;
12339         p->cnr.len = 1;
12340
12341         p->strength.stat[0].scale = FE_SCALE_RELATIVE;
12342         p->pre_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
12343         p->pre_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
12344         p->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
12345         p->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
12346         p->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
12347         p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
12348         p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
12349
12350         return &state->frontend;
12351
12352 error:
12353         kfree(demod_ext_attr);
12354         kfree(demod_comm_attr);
12355         kfree(demod_addr);
12356         kfree(demod);
12357         kfree(state);
12358
12359         return NULL;
12360 }
12361 EXPORT_SYMBOL(drx39xxj_attach);
12362
12363 static struct dvb_frontend_ops drx39xxj_ops = {
12364         .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
12365         .info = {
12366                  .name = "Micronas DRX39xxj family Frontend",
12367                  .frequency_stepsize = 62500,
12368                  .frequency_min = 51000000,
12369                  .frequency_max = 858000000,
12370                  .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
12371         },
12372
12373         .init = drx39xxj_init,
12374         .i2c_gate_ctrl = drx39xxj_i2c_gate_ctrl,
12375         .sleep = drx39xxj_sleep,
12376         .set_frontend = drx39xxj_set_frontend,
12377         .get_tune_settings = drx39xxj_get_tune_settings,
12378         .read_status = drx39xxj_read_status,
12379         .read_ber = drx39xxj_read_ber,
12380         .read_signal_strength = drx39xxj_read_signal_strength,
12381         .read_snr = drx39xxj_read_snr,
12382         .read_ucblocks = drx39xxj_read_ucblocks,
12383         .release = drx39xxj_release,
12384         .set_lna = drx39xxj_set_lna,
12385 };
12386
12387 MODULE_DESCRIPTION("Micronas DRX39xxj Frontend");
12388 MODULE_AUTHOR("Devin Heitmueller");
12389 MODULE_LICENSE("GPL");
12390 MODULE_FIRMWARE(DRX39XX_MAIN_FIRMWARE);