drivers/media/tuners/mt2063.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for mt2063 Micronas tuner
   4  *
   5  * Copyright (c) 2011 Mauro Carvalho Chehab
   6  *
   7  * This driver came from a driver originally written by:
   8  *              Henry Wang <Henry.wang@AzureWave.com>
   9  * Made publicly available by Terratec, at:
  10  *      http://linux.terratec.de/files/TERRATEC_H7/20110323_TERRATEC_H7_Linux.tar.gz
  11  */
  12
  13 #include <linux/init.h>
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/string.h>
  17 #include <linux/videodev2.h>
  18 #include <linux/gcd.h>
  19
  20 #include "mt2063.h"
  21
  22 static unsigned int debug;
  23 module_param(debug, int, 0644);
  24 MODULE_PARM_DESC(debug, "Set Verbosity level");
  25
  26 #define dprintk(level, fmt, arg...) do {                                \
  27 if (debug >= level)                                                     \
  28         printk(KERN_DEBUG "mt2063 %s: " fmt, __func__, ## arg); \
  29 } while (0)
  30
  31
  32 /* positive error codes used internally */
  33
  34 /*  Info: Unavoidable LO-related spur may be present in the output  */
  35 #define MT2063_SPUR_PRESENT_ERR             (0x00800000)
  36
  37 /*  Info: Mask of bits used for # of LO-related spurs that were avoided during tuning  */
  38 #define MT2063_SPUR_CNT_MASK                (0x001f0000)
  39 #define MT2063_SPUR_SHIFT                   (16)
  40
  41 /*  Info: Upconverter frequency is out of range (may be reason for MT_UPC_UNLOCK) */
  42 #define MT2063_UPC_RANGE                    (0x04000000)
  43
  44 /*  Info: Downconverter frequency is out of range (may be reason for MT_DPC_UNLOCK) */
  45 #define MT2063_DNC_RANGE                    (0x08000000)
  46
  47 /*
  48  *  Constant defining the version of the following structure
  49  *  and therefore the API for this code.
  50  *
  51  *  When compiling the tuner driver, the preprocessor will
  52  *  check against this version number to make sure that
  53  *  it matches the version that the tuner driver knows about.
  54  */
  55
  56 /* DECT Frequency Avoidance */
  57 #define MT2063_DECT_AVOID_US_FREQS      0x00000001
  58
  59 #define MT2063_DECT_AVOID_EURO_FREQS    0x00000002
  60
  61 #define MT2063_EXCLUDE_US_DECT_FREQUENCIES(s) (((s) & MT2063_DECT_AVOID_US_FREQS) != 0)
  62
  63 #define MT2063_EXCLUDE_EURO_DECT_FREQUENCIES(s) (((s) & MT2063_DECT_AVOID_EURO_FREQS) != 0)
  64
  65 enum MT2063_DECT_Avoid_Type {
  66         MT2063_NO_DECT_AVOIDANCE = 0,                           /* Do not create DECT exclusion zones.     */
  67         MT2063_AVOID_US_DECT = MT2063_DECT_AVOID_US_FREQS,      /* Avoid US DECT frequencies.              */
  68         MT2063_AVOID_EURO_DECT = MT2063_DECT_AVOID_EURO_FREQS,  /* Avoid European DECT frequencies.        */
  69         MT2063_AVOID_BOTH                                       /* Avoid both regions. Not typically used. */
  70 };
  71
  72 #define MT2063_MAX_ZONES 48
  73
  74 struct MT2063_ExclZone_t {
  75         u32 min_;
  76         u32 max_;
  77         struct MT2063_ExclZone_t *next_;
  78 };
  79
  80 /*
  81  *  Structure of data needed for Spur Avoidance
  82  */
  83 struct MT2063_AvoidSpursData_t {
  84         u32 f_ref;
  85         u32 f_in;
  86         u32 f_LO1;
  87         u32 f_if1_Center;
  88         u32 f_if1_Request;
  89         u32 f_if1_bw;
  90         u32 f_LO2;
  91         u32 f_out;
  92         u32 f_out_bw;
  93         u32 f_LO1_Step;
  94         u32 f_LO2_Step;
  95         u32 f_LO1_FracN_Avoid;
  96         u32 f_LO2_FracN_Avoid;
  97         u32 f_zif_bw;
  98         u32 f_min_LO_Separation;
  99         u32 maxH1;
 100         u32 maxH2;
 101         enum MT2063_DECT_Avoid_Type avoidDECT;
 102         u32 bSpurPresent;
 103         u32 bSpurAvoided;
 104         u32 nSpursFound;
 105         u32 nZones;
 106         struct MT2063_ExclZone_t *freeZones;
 107         struct MT2063_ExclZone_t *usedZones;
 108         struct MT2063_ExclZone_t MT2063_ExclZones[MT2063_MAX_ZONES];
 109 };
 110
 111 /*
 112  * Parameter for function MT2063_SetPowerMask that specifies the power down
 113  * of various sections of the MT2063.
 114  */
 115 enum MT2063_Mask_Bits {
 116         MT2063_REG_SD = 0x0040,         /* Shutdown regulator                 */
 117         MT2063_SRO_SD = 0x0020,         /* Shutdown SRO                       */
 118         MT2063_AFC_SD = 0x0010,         /* Shutdown AFC A/D                   */
 119         MT2063_PD_SD = 0x0002,          /* Enable power detector shutdown     */
 120         MT2063_PDADC_SD = 0x0001,       /* Enable power detector A/D shutdown */
 121         MT2063_VCO_SD = 0x8000,         /* Enable VCO shutdown                */
 122         MT2063_LTX_SD = 0x4000,         /* Enable LTX shutdown                */
 123         MT2063_LT1_SD = 0x2000,         /* Enable LT1 shutdown                */
 124         MT2063_LNA_SD = 0x1000,         /* Enable LNA shutdown                */
 125         MT2063_UPC_SD = 0x0800,         /* Enable upconverter shutdown        */
 126         MT2063_DNC_SD = 0x0400,         /* Enable downconverter shutdown      */
 127         MT2063_VGA_SD = 0x0200,         /* Enable VGA shutdown                */
 128         MT2063_AMP_SD = 0x0100,         /* Enable AMP shutdown                */
 129         MT2063_ALL_SD = 0xFF73,         /* All shutdown bits for this tuner   */
 130         MT2063_NONE_SD = 0x0000         /* No shutdown bits                   */
 131 };
 132
 133 /*
 134  *  Possible values for MT2063_DNC_OUTPUT
 135  */
 136 enum MT2063_DNC_Output_Enable {
 137         MT2063_DNC_NONE = 0,
 138         MT2063_DNC_1,
 139         MT2063_DNC_2,
 140         MT2063_DNC_BOTH
 141 };
 142
 143 /*
 144  *  Two-wire serial bus subaddresses of the tuner registers.
 145  *  Also known as the tuner's register addresses.
 146  */
 147 enum MT2063_Register_Offsets {
 148         MT2063_REG_PART_REV = 0,        /*  0x00: Part/Rev Code         */
 149         MT2063_REG_LO1CQ_1,             /*  0x01: LO1C Queued Byte 1    */
 150         MT2063_REG_LO1CQ_2,             /*  0x02: LO1C Queued Byte 2    */
 151         MT2063_REG_LO2CQ_1,             /*  0x03: LO2C Queued Byte 1    */
 152         MT2063_REG_LO2CQ_2,             /*  0x04: LO2C Queued Byte 2    */
 153         MT2063_REG_LO2CQ_3,             /*  0x05: LO2C Queued Byte 3    */
 154         MT2063_REG_RSVD_06,             /*  0x06: Reserved              */
 155         MT2063_REG_LO_STATUS,           /*  0x07: LO Status             */
 156         MT2063_REG_FIFFC,               /*  0x08: FIFF Center           */
 157         MT2063_REG_CLEARTUNE,           /*  0x09: ClearTune Filter      */
 158         MT2063_REG_ADC_OUT,             /*  0x0A: ADC_OUT               */
 159         MT2063_REG_LO1C_1,              /*  0x0B: LO1C Byte 1           */
 160         MT2063_REG_LO1C_2,              /*  0x0C: LO1C Byte 2           */
 161         MT2063_REG_LO2C_1,              /*  0x0D: LO2C Byte 1           */
 162         MT2063_REG_LO2C_2,              /*  0x0E: LO2C Byte 2           */
 163         MT2063_REG_LO2C_3,              /*  0x0F: LO2C Byte 3           */
 164         MT2063_REG_RSVD_10,             /*  0x10: Reserved              */
 165         MT2063_REG_PWR_1,               /*  0x11: PWR Byte 1            */
 166         MT2063_REG_PWR_2,               /*  0x12: PWR Byte 2            */
 167         MT2063_REG_TEMP_STATUS,         /*  0x13: Temp Status           */
 168         MT2063_REG_XO_STATUS,           /*  0x14: Crystal Status        */
 169         MT2063_REG_RF_STATUS,           /*  0x15: RF Attn Status        */
 170         MT2063_REG_FIF_STATUS,          /*  0x16: FIF Attn Status       */
 171         MT2063_REG_LNA_OV,              /*  0x17: LNA Attn Override     */
 172         MT2063_REG_RF_OV,               /*  0x18: RF Attn Override      */
 173         MT2063_REG_FIF_OV,              /*  0x19: FIF Attn Override     */
 174         MT2063_REG_LNA_TGT,             /*  0x1A: Reserved              */
 175         MT2063_REG_PD1_TGT,             /*  0x1B: Pwr Det 1 Target      */
 176         MT2063_REG_PD2_TGT,             /*  0x1C: Pwr Det 2 Target      */
 177         MT2063_REG_RSVD_1D,             /*  0x1D: Reserved              */
 178         MT2063_REG_RSVD_1E,             /*  0x1E: Reserved              */
 179         MT2063_REG_RSVD_1F,             /*  0x1F: Reserved              */
 180         MT2063_REG_RSVD_20,             /*  0x20: Reserved              */
 181         MT2063_REG_BYP_CTRL,            /*  0x21: Bypass Control        */
 182         MT2063_REG_RSVD_22,             /*  0x22: Reserved              */
 183         MT2063_REG_RSVD_23,             /*  0x23: Reserved              */
 184         MT2063_REG_RSVD_24,             /*  0x24: Reserved              */
 185         MT2063_REG_RSVD_25,             /*  0x25: Reserved              */
 186         MT2063_REG_RSVD_26,             /*  0x26: Reserved              */
 187         MT2063_REG_RSVD_27,             /*  0x27: Reserved              */
 188         MT2063_REG_FIFF_CTRL,           /*  0x28: FIFF Control          */
 189         MT2063_REG_FIFF_OFFSET,         /*  0x29: FIFF Offset           */
 190         MT2063_REG_CTUNE_CTRL,          /*  0x2A: Reserved              */
 191         MT2063_REG_CTUNE_OV,            /*  0x2B: Reserved              */
 192         MT2063_REG_CTRL_2C,             /*  0x2C: Reserved              */
 193         MT2063_REG_FIFF_CTRL2,          /*  0x2D: Fiff Control          */
 194         MT2063_REG_RSVD_2E,             /*  0x2E: Reserved              */
 195         MT2063_REG_DNC_GAIN,            /*  0x2F: DNC Control           */
 196         MT2063_REG_VGA_GAIN,            /*  0x30: VGA Gain Ctrl         */
 197         MT2063_REG_RSVD_31,             /*  0x31: Reserved              */
 198         MT2063_REG_TEMP_SEL,            /*  0x32: Temperature Selection */
 199         MT2063_REG_RSVD_33,             /*  0x33: Reserved              */
 200         MT2063_REG_RSVD_34,             /*  0x34: Reserved              */
 201         MT2063_REG_RSVD_35,             /*  0x35: Reserved              */
 202         MT2063_REG_RSVD_36,             /*  0x36: Reserved              */
 203         MT2063_REG_RSVD_37,             /*  0x37: Reserved              */
 204         MT2063_REG_RSVD_38,             /*  0x38: Reserved              */
 205         MT2063_REG_RSVD_39,             /*  0x39: Reserved              */
 206         MT2063_REG_RSVD_3A,             /*  0x3A: Reserved              */
 207         MT2063_REG_RSVD_3B,             /*  0x3B: Reserved              */
 208         MT2063_REG_RSVD_3C,             /*  0x3C: Reserved              */
 209         MT2063_REG_END_REGS
 210 };
 211
 212 struct mt2063_state {
 213         struct i2c_adapter *i2c;
 214
 215         bool init;
 216
 217         const struct mt2063_config *config;
 218         struct dvb_tuner_ops ops;
 219         struct dvb_frontend *frontend;
 220
 221         u32 frequency;
 222         u32 srate;
 223         u32 bandwidth;
 224         u32 reference;
 225
 226         u32 tuner_id;
 227         struct MT2063_AvoidSpursData_t AS_Data;
 228         u32 f_IF1_actual;
 229         u32 rcvr_mode;
 230         u32 ctfilt_sw;
 231         u32 CTFiltMax[31];
 232         u32 num_regs;
 233         u8 reg[MT2063_REG_END_REGS];
 234 };
 235
 236 /*
 237  * mt2063_write - Write data into the I2C bus
 238  */
 239 static int mt2063_write(struct mt2063_state *state, u8 reg, u8 *data, u32 len)
 240 {
 241         struct dvb_frontend *fe = state->frontend;
 242         int ret;
 243         u8 buf[60];
 244         struct i2c_msg msg = {
 245                 .addr = state->config->tuner_address,
 246                 .flags = 0,
 247                 .buf = buf,
 248                 .len = len + 1
 249         };
 250
 251         dprintk(2, "\n");
 252
 253         msg.buf[0] = reg;
 254         memcpy(msg.buf + 1, data, len);
 255
 256         if (fe->ops.i2c_gate_ctrl)
 257                 fe->ops.i2c_gate_ctrl(fe, 1);
 258         ret = i2c_transfer(state->i2c, &msg, 1);
 259         if (fe->ops.i2c_gate_ctrl)
 260                 fe->ops.i2c_gate_ctrl(fe, 0);
 261
 262         if (ret < 0)
 263                 printk(KERN_ERR "%s error ret=%d\n", __func__, ret);
 264
 265         return ret;
 266 }
 267
 268 /*
 269  * mt2063_write - Write register data into the I2C bus, caching the value
 270  */
 271 static int mt2063_setreg(struct mt2063_state *state, u8 reg, u8 val)
 272 {
 273         int status;
 274
 275         dprintk(2, "\n");
 276
 277         if (reg >= MT2063_REG_END_REGS)
 278                 return -ERANGE;
 279
 280         status = mt2063_write(state, reg, &val, 1);
 281         if (status < 0)
 282                 return status;
 283
 284         state->reg[reg] = val;
 285
 286         return 0;
 287 }
 288
 289 /*
 290  * mt2063_read - Read data from the I2C bus
 291  */
 292 static int mt2063_read(struct mt2063_state *state,
 293                            u8 subAddress, u8 *pData, u32 cnt)
 294 {
 295         int status = 0; /* Status to be returned        */
 296         struct dvb_frontend *fe = state->frontend;
 297         u32 i = 0;
 298
 299         dprintk(2, "addr 0x%02x, cnt %d\n", subAddress, cnt);
 300
 301         if (fe->ops.i2c_gate_ctrl)
 302                 fe->ops.i2c_gate_ctrl(fe, 1);
 303
 304         for (i = 0; i < cnt; i++) {
 305                 u8 b0[] = { subAddress + i };
 306                 struct i2c_msg msg[] = {
 307                         {
 308                                 .addr = state->config->tuner_address,
 309                                 .flags = 0,
 310                                 .buf = b0,
 311                                 .len = 1
 312                         }, {
 313                                 .addr = state->config->tuner_address,
 314                                 .flags = I2C_M_RD,
 315                                 .buf = pData + i,
 316                                 .len = 1
 317                         }
 318                 };
 319
 320                 status = i2c_transfer(state->i2c, msg, 2);
 321                 dprintk(2, "addr 0x%02x, ret = %d, val = 0x%02x\n",
 322                            subAddress + i, status, *(pData + i));
 323                 if (status < 0)
 324                         break;
 325         }
 326         if (fe->ops.i2c_gate_ctrl)
 327                 fe->ops.i2c_gate_ctrl(fe, 0);
 328
 329         if (status < 0)
 330                 printk(KERN_ERR "Can't read from address 0x%02x,\n",
 331                        subAddress + i);
 332
 333         return status;
 334 }
 335
 336 /*
 337  * FIXME: Is this really needed?
 338  */
 339 static int MT2063_Sleep(struct dvb_frontend *fe)
 340 {
 341         /*
 342          *  ToDo:  Add code here to implement a OS blocking
 343          */
 344         msleep(100);
 345
 346         return 0;
 347 }
 348
 349 /*
 350  * Microtune spur avoidance
 351  */
 352
 353 /*  Implement ceiling, floor functions.  */
 354 #define ceil(n, d) (((n) < 0) ? (-((-(n))/(d))) : (n)/(d) + ((n)%(d) != 0))
 355 #define floor(n, d) (((n) < 0) ? (-((-(n))/(d))) - ((n)%(d) != 0) : (n)/(d))
 356
 357 struct MT2063_FIFZone_t {
 358         s32 min_;
 359         s32 max_;
 360 };
 361
 362 static struct MT2063_ExclZone_t *InsertNode(struct MT2063_AvoidSpursData_t
 363                                             *pAS_Info,
 364                                             struct MT2063_ExclZone_t *pPrevNode)
 365 {
 366         struct MT2063_ExclZone_t *pNode;
 367
 368         dprintk(2, "\n");
 369
 370         /*  Check for a node in the free list  */
 371         if (pAS_Info->freeZones != NULL) {
 372                 /*  Use one from the free list  */
 373                 pNode = pAS_Info->freeZones;
 374                 pAS_Info->freeZones = pNode->next_;
 375         } else {
 376                 /*  Grab a node from the array  */
 377                 pNode = &pAS_Info->MT2063_ExclZones[pAS_Info->nZones];
 378         }
 379
 380         if (pPrevNode != NULL) {
 381                 pNode->next_ = pPrevNode->next_;
 382                 pPrevNode->next_ = pNode;
 383         } else {                /*  insert at the beginning of the list  */
 384
 385                 pNode->next_ = pAS_Info->usedZones;
 386                 pAS_Info->usedZones = pNode;
 387         }
 388
 389         pAS_Info->nZones++;
 390         return pNode;
 391 }
 392
 393 static struct MT2063_ExclZone_t *RemoveNode(struct MT2063_AvoidSpursData_t
 394                                             *pAS_Info,
 395                                             struct MT2063_ExclZone_t *pPrevNode,
 396                                             struct MT2063_ExclZone_t
 397                                             *pNodeToRemove)
 398 {
 399         struct MT2063_ExclZone_t *pNext = pNodeToRemove->next_;
 400
 401         dprintk(2, "\n");
 402
 403         /*  Make previous node point to the subsequent node  */
 404         if (pPrevNode != NULL)
 405                 pPrevNode->next_ = pNext;
 406
 407         /*  Add pNodeToRemove to the beginning of the freeZones  */
 408         pNodeToRemove->next_ = pAS_Info->freeZones;
 409         pAS_Info->freeZones = pNodeToRemove;
 410
 411         /*  Decrement node count  */
 412         pAS_Info->nZones--;
 413
 414         return pNext;
 415 }
 416
 417 /*
 418  * MT_AddExclZone()
 419  *
 420  * Add (and merge) an exclusion zone into the list.
 421  * If the range (f_min, f_max) is totally outside the
 422  * 1st IF BW, ignore the entry.
 423  * If the range (f_min, f_max) is negative, ignore the entry.
 424  */
 425 static void MT2063_AddExclZone(struct MT2063_AvoidSpursData_t *pAS_Info,
 426                                u32 f_min, u32 f_max)
 427 {
 428         struct MT2063_ExclZone_t *pNode = pAS_Info->usedZones;
 429         struct MT2063_ExclZone_t *pPrev = NULL;
 430         struct MT2063_ExclZone_t *pNext = NULL;
 431
 432         dprintk(2, "\n");
 433
 434         /*  Check to see if this overlaps the 1st IF filter  */
 435         if ((f_max > (pAS_Info->f_if1_Center - (pAS_Info->f_if1_bw / 2)))
 436             && (f_min < (pAS_Info->f_if1_Center + (pAS_Info->f_if1_bw / 2)))
 437             && (f_min < f_max)) {
 438                 /*
 439                  *                1        2         3      4       5        6
 440                  *
 441                  *   New entry:  |---|    |--|      |--|    |-|    |---|    |--|
 442                  *                or       or        or     or      or
 443                  *   Existing:  |--|      |--|      |--|    |---|  |-|      |--|
 444                  */
 445
 446                 /*  Check for our place in the list  */
 447                 while ((pNode != NULL) && (pNode->max_ < f_min)) {
 448                         pPrev = pNode;
 449                         pNode = pNode->next_;
 450                 }
 451
 452                 if ((pNode != NULL) && (pNode->min_ < f_max)) {
 453                         /*  Combine me with pNode  */
 454                         if (f_min < pNode->min_)
 455                                 pNode->min_ = f_min;
 456                         if (f_max > pNode->max_)
 457                                 pNode->max_ = f_max;
 458                 } else {
 459                         pNode = InsertNode(pAS_Info, pPrev);
 460                         pNode->min_ = f_min;
 461                         pNode->max_ = f_max;
 462                 }
 463
 464                 /*  Look for merging possibilities  */
 465                 pNext = pNode->next_;
 466                 while ((pNext != NULL) && (pNext->min_ < pNode->max_)) {
 467                         if (pNext->max_ > pNode->max_)
 468                                 pNode->max_ = pNext->max_;
 469                         /*  Remove pNext, return ptr to pNext->next  */
 470                         pNext = RemoveNode(pAS_Info, pNode, pNext);
 471                 }
 472         }
 473 }
 474
 475 /*
 476  *  Reset all exclusion zones.
 477  *  Add zones to protect the PLL FracN regions near zero
 478  */
 479 static void MT2063_ResetExclZones(struct MT2063_AvoidSpursData_t *pAS_Info)
 480 {
 481         u32 center;
 482
 483         dprintk(2, "\n");
 484
 485         pAS_Info->nZones = 0;   /*  this clears the used list  */
 486         pAS_Info->usedZones = NULL;     /*  reset ptr                  */
 487         pAS_Info->freeZones = NULL;     /*  reset ptr                  */
 488
 489         center =
 490             pAS_Info->f_ref *
 491             ((pAS_Info->f_if1_Center - pAS_Info->f_if1_bw / 2 +
 492               pAS_Info->f_in) / pAS_Info->f_ref) - pAS_Info->f_in;
 493         while (center <
 494                pAS_Info->f_if1_Center + pAS_Info->f_if1_bw / 2 +
 495                pAS_Info->f_LO1_FracN_Avoid) {
 496                 /*  Exclude LO1 FracN  */
 497                 MT2063_AddExclZone(pAS_Info,
 498                                    center - pAS_Info->f_LO1_FracN_Avoid,
 499                                    center - 1);
 500                 MT2063_AddExclZone(pAS_Info, center + 1,
 501                                    center + pAS_Info->f_LO1_FracN_Avoid);
 502                 center += pAS_Info->f_ref;
 503         }
 504
 505         center =
 506             pAS_Info->f_ref *
 507             ((pAS_Info->f_if1_Center - pAS_Info->f_if1_bw / 2 -
 508               pAS_Info->f_out) / pAS_Info->f_ref) + pAS_Info->f_out;
 509         while (center <
 510                pAS_Info->f_if1_Center + pAS_Info->f_if1_bw / 2 +
 511                pAS_Info->f_LO2_FracN_Avoid) {
 512                 /*  Exclude LO2 FracN  */
 513                 MT2063_AddExclZone(pAS_Info,
 514                                    center - pAS_Info->f_LO2_FracN_Avoid,
 515                                    center - 1);
 516                 MT2063_AddExclZone(pAS_Info, center + 1,
 517                                    center + pAS_Info->f_LO2_FracN_Avoid);
 518                 center += pAS_Info->f_ref;
 519         }
 520
 521         if (MT2063_EXCLUDE_US_DECT_FREQUENCIES(pAS_Info->avoidDECT)) {
 522                 /*  Exclude LO1 values that conflict with DECT channels */
 523                 MT2063_AddExclZone(pAS_Info, 1920836000 - pAS_Info->f_in, 1922236000 - pAS_Info->f_in); /* Ctr = 1921.536 */
 524                 MT2063_AddExclZone(pAS_Info, 1922564000 - pAS_Info->f_in, 1923964000 - pAS_Info->f_in); /* Ctr = 1923.264 */
 525                 MT2063_AddExclZone(pAS_Info, 1924292000 - pAS_Info->f_in, 1925692000 - pAS_Info->f_in); /* Ctr = 1924.992 */
 526                 MT2063_AddExclZone(pAS_Info, 1926020000 - pAS_Info->f_in, 1927420000 - pAS_Info->f_in); /* Ctr = 1926.720 */
 527                 MT2063_AddExclZone(pAS_Info, 1927748000 - pAS_Info->f_in, 1929148000 - pAS_Info->f_in); /* Ctr = 1928.448 */
 528         }
 529
 530         if (MT2063_EXCLUDE_EURO_DECT_FREQUENCIES(pAS_Info->avoidDECT)) {
 531                 MT2063_AddExclZone(pAS_Info, 1896644000 - pAS_Info->f_in, 1898044000 - pAS_Info->f_in); /* Ctr = 1897.344 */
 532                 MT2063_AddExclZone(pAS_Info, 1894916000 - pAS_Info->f_in, 1896316000 - pAS_Info->f_in); /* Ctr = 1895.616 */
 533                 MT2063_AddExclZone(pAS_Info, 1893188000 - pAS_Info->f_in, 1894588000 - pAS_Info->f_in); /* Ctr = 1893.888 */
 534                 MT2063_AddExclZone(pAS_Info, 1891460000 - pAS_Info->f_in, 1892860000 - pAS_Info->f_in); /* Ctr = 1892.16  */
 535                 MT2063_AddExclZone(pAS_Info, 1889732000 - pAS_Info->f_in, 1891132000 - pAS_Info->f_in); /* Ctr = 1890.432 */
 536                 MT2063_AddExclZone(pAS_Info, 1888004000 - pAS_Info->f_in, 1889404000 - pAS_Info->f_in); /* Ctr = 1888.704 */
 537                 MT2063_AddExclZone(pAS_Info, 1886276000 - pAS_Info->f_in, 1887676000 - pAS_Info->f_in); /* Ctr = 1886.976 */
 538                 MT2063_AddExclZone(pAS_Info, 1884548000 - pAS_Info->f_in, 1885948000 - pAS_Info->f_in); /* Ctr = 1885.248 */
 539                 MT2063_AddExclZone(pAS_Info, 1882820000 - pAS_Info->f_in, 1884220000 - pAS_Info->f_in); /* Ctr = 1883.52  */
 540                 MT2063_AddExclZone(pAS_Info, 1881092000 - pAS_Info->f_in, 1882492000 - pAS_Info->f_in); /* Ctr = 1881.792 */
 541         }
 542 }
 543
 544 /*
 545  * MT_ChooseFirstIF - Choose the best available 1st IF
 546  *                    If f_Desired is not excluded, choose that first.
 547  *                    Otherwise, return the value closest to f_Center that is
 548  *                    not excluded
 549  */
 550 static u32 MT2063_ChooseFirstIF(struct MT2063_AvoidSpursData_t *pAS_Info)
 551 {
 552         /*
 553          * Update "f_Desired" to be the nearest "combinational-multiple" of
 554          * "f_LO1_Step".
 555          * The resulting number, F_LO1 must be a multiple of f_LO1_Step.
 556          * And F_LO1 is the arithmetic sum of f_in + f_Center.
 557          * Neither f_in, nor f_Center must be a multiple of f_LO1_Step.
 558          * However, the sum must be.
 559          */
 560         const u32 f_Desired =
 561             pAS_Info->f_LO1_Step *
 562             ((pAS_Info->f_if1_Request + pAS_Info->f_in +
 563               pAS_Info->f_LO1_Step / 2) / pAS_Info->f_LO1_Step) -
 564             pAS_Info->f_in;
 565         const u32 f_Step =
 566             (pAS_Info->f_LO1_Step >
 567              pAS_Info->f_LO2_Step) ? pAS_Info->f_LO1_Step : pAS_Info->
 568             f_LO2_Step;
 569         u32 f_Center;
 570         s32 i;
 571         s32 j = 0;
 572         u32 bDesiredExcluded = 0;
 573         u32 bZeroExcluded = 0;
 574         s32 tmpMin, tmpMax;
 575         s32 bestDiff;
 576         struct MT2063_ExclZone_t *pNode = pAS_Info->usedZones;
 577         struct MT2063_FIFZone_t zones[MT2063_MAX_ZONES];
 578
 579         dprintk(2, "\n");
 580
 581         if (pAS_Info->nZones == 0)
 582                 return f_Desired;
 583
 584         /*
 585          *  f_Center needs to be an integer multiple of f_Step away
 586          *  from f_Desired
 587          */
 588         if (pAS_Info->f_if1_Center > f_Desired)
 589                 f_Center =
 590                     f_Desired +
 591                     f_Step *
 592                     ((pAS_Info->f_if1_Center - f_Desired +
 593                       f_Step / 2) / f_Step);
 594         else
 595                 f_Center =
 596                     f_Desired -
 597                     f_Step *
 598                     ((f_Desired - pAS_Info->f_if1_Center +
 599                       f_Step / 2) / f_Step);
 600
 601         /*
 602          * Take MT_ExclZones, center around f_Center and change the
 603          * resolution to f_Step
 604          */
 605         while (pNode != NULL) {
 606                 /*  floor function  */
 607                 tmpMin =
 608                     floor((s32) (pNode->min_ - f_Center), (s32) f_Step);
 609
 610                 /*  ceil function  */
 611                 tmpMax =
 612                     ceil((s32) (pNode->max_ - f_Center), (s32) f_Step);
 613
 614                 if ((pNode->min_ < f_Desired) && (pNode->max_ > f_Desired))
 615                         bDesiredExcluded = 1;
 616
 617                 if ((tmpMin < 0) && (tmpMax > 0))
 618                         bZeroExcluded = 1;
 619
 620                 /*  See if this zone overlaps the previous  */
 621                 if ((j > 0) && (tmpMin < zones[j - 1].max_))
 622                         zones[j - 1].max_ = tmpMax;
 623                 else {
 624                         /*  Add new zone  */
 625                         zones[j].min_ = tmpMin;
 626                         zones[j].max_ = tmpMax;
 627                         j++;
 628                 }
 629                 pNode = pNode->next_;
 630         }
 631
 632         /*
 633          *  If the desired is okay, return with it
 634          */
 635         if (bDesiredExcluded == 0)
 636                 return f_Desired;
 637
 638         /*
 639          *  If the desired is excluded and the center is okay, return with it
 640          */
 641         if (bZeroExcluded == 0)
 642                 return f_Center;
 643
 644         /*  Find the value closest to 0 (f_Center)  */
 645         bestDiff = zones[0].min_;
 646         for (i = 0; i < j; i++) {
 647                 if (abs(zones[i].min_) < abs(bestDiff))
 648                         bestDiff = zones[i].min_;
 649                 if (abs(zones[i].max_) < abs(bestDiff))
 650                         bestDiff = zones[i].max_;
 651         }
 652
 653         if (bestDiff < 0)
 654                 return f_Center - ((u32) (-bestDiff) * f_Step);
 655
 656         return f_Center + (bestDiff * f_Step);
 657 }
 658
 659 /**
 660  * IsSpurInBand() - Checks to see if a spur will be present within the IF's
 661  *                  bandwidth. (fIFOut +/- fIFBW, -fIFOut +/- fIFBW)
 662  *
 663  *                    ma   mb                                     mc   md
 664  *                  <--+-+-+-------------------+-------------------+-+-+-->
 665  *                     |   ^                   0                   ^   |
 666  *                     ^   b=-fIFOut+fIFBW/2      -b=+fIFOut-fIFBW/2   ^
 667  *                     a=-fIFOut-fIFBW/2              -a=+fIFOut+fIFBW/2
 668  *
 669  *                  Note that some equations are doubled to prevent round-off
 670  *                  problems when calculating fIFBW/2
 671  *
 672  * @pAS_Info:   Avoid Spurs information block
 673  * @fm:         If spur, amount f_IF1 has to move negative
 674  * @fp:         If spur, amount f_IF1 has to move positive
 675  *
 676  *  Returns 1 if an LO spur would be present, otherwise 0.
 677  */
 678 static u32 IsSpurInBand(struct MT2063_AvoidSpursData_t *pAS_Info,
 679                         u32 *fm, u32 * fp)
 680 {
 681         /*
 682          **  Calculate LO frequency settings.
 683          */
 684         u32 n, n0;
 685         const u32 f_LO1 = pAS_Info->f_LO1;
 686         const u32 f_LO2 = pAS_Info->f_LO2;
 687         const u32 d = pAS_Info->f_out + pAS_Info->f_out_bw / 2;
 688         const u32 c = d - pAS_Info->f_out_bw;
 689         const u32 f = pAS_Info->f_zif_bw / 2;
 690         const u32 f_Scale = (f_LO1 / (UINT_MAX / 2 / pAS_Info->maxH1)) + 1;
 691         s32 f_nsLO1, f_nsLO2;
 692         s32 f_Spur;
 693         u32 ma, mb, mc, md, me, mf;
 694         u32 lo_gcd, gd_Scale, gc_Scale, gf_Scale, hgds, hgfs, hgcs;
 695
 696         dprintk(2, "\n");
 697
 698         *fm = 0;
 699
 700         /*
 701          ** For each edge (d, c & f), calculate a scale, based on the gcd
 702          ** of f_LO1, f_LO2 and the edge value.  Use the larger of this
 703          ** gcd-based scale factor or f_Scale.
 704          */
 705         lo_gcd = gcd(f_LO1, f_LO2);
 706         gd_Scale = max((u32) gcd(lo_gcd, d), f_Scale);
 707         hgds = gd_Scale / 2;
 708         gc_Scale = max((u32) gcd(lo_gcd, c), f_Scale);
 709         hgcs = gc_Scale / 2;
 710         gf_Scale = max((u32) gcd(lo_gcd, f), f_Scale);
 711         hgfs = gf_Scale / 2;
 712
 713         n0 = DIV_ROUND_UP(f_LO2 - d, f_LO1 - f_LO2);
 714
 715         /*  Check out all multiples of LO1 from n0 to m_maxLOSpurHarmonic  */
 716         for (n = n0; n <= pAS_Info->maxH1; ++n) {
 717                 md = (n * ((f_LO1 + hgds) / gd_Scale) -
 718                       ((d + hgds) / gd_Scale)) / ((f_LO2 + hgds) / gd_Scale);
 719
 720                 /*  If # fLO2 harmonics > m_maxLOSpurHarmonic, then no spurs present  */
 721                 if (md >= pAS_Info->maxH1)
 722                         break;
 723
 724                 ma = (n * ((f_LO1 + hgds) / gd_Scale) +
 725                       ((d + hgds) / gd_Scale)) / ((f_LO2 + hgds) / gd_Scale);
 726
 727                 /*  If no spurs between +/- (f_out + f_IFBW/2), then try next harmonic  */
 728                 if (md == ma)
 729                         continue;
 730
 731                 mc = (n * ((f_LO1 + hgcs) / gc_Scale) -
 732                       ((c + hgcs) / gc_Scale)) / ((f_LO2 + hgcs) / gc_Scale);
 733                 if (mc != md) {
 734                         f_nsLO1 = (s32) (n * (f_LO1 / gc_Scale));
 735                         f_nsLO2 = (s32) (mc * (f_LO2 / gc_Scale));
 736                         f_Spur =
 737                             (gc_Scale * (f_nsLO1 - f_nsLO2)) +
 738                             n * (f_LO1 % gc_Scale) - mc * (f_LO2 % gc_Scale);
 739
 740                         *fp = ((f_Spur - (s32) c) / (mc - n)) + 1;
 741                         *fm = (((s32) d - f_Spur) / (mc - n)) + 1;
 742                         return 1;
 743                 }
 744
 745                 /*  Location of Zero-IF-spur to be checked  */
 746                 me = (n * ((f_LO1 + hgfs) / gf_Scale) +
 747                       ((f + hgfs) / gf_Scale)) / ((f_LO2 + hgfs) / gf_Scale);
 748                 mf = (n * ((f_LO1 + hgfs) / gf_Scale) -
 749                       ((f + hgfs) / gf_Scale)) / ((f_LO2 + hgfs) / gf_Scale);
 750                 if (me != mf) {
 751                         f_nsLO1 = n * (f_LO1 / gf_Scale);
 752                         f_nsLO2 = me * (f_LO2 / gf_Scale);
 753                         f_Spur =
 754                             (gf_Scale * (f_nsLO1 - f_nsLO2)) +
 755                             n * (f_LO1 % gf_Scale) - me * (f_LO2 % gf_Scale);
 756
 757                         *fp = ((f_Spur + (s32) f) / (me - n)) + 1;
 758                         *fm = (((s32) f - f_Spur) / (me - n)) + 1;
 759                         return 1;
 760                 }
 761
 762                 mb = (n * ((f_LO1 + hgcs) / gc_Scale) +
 763                       ((c + hgcs) / gc_Scale)) / ((f_LO2 + hgcs) / gc_Scale);
 764                 if (ma != mb) {
 765                         f_nsLO1 = n * (f_LO1 / gc_Scale);
 766                         f_nsLO2 = ma * (f_LO2 / gc_Scale);
 767                         f_Spur =
 768                             (gc_Scale * (f_nsLO1 - f_nsLO2)) +
 769                             n * (f_LO1 % gc_Scale) - ma * (f_LO2 % gc_Scale);
 770
 771                         *fp = (((s32) d + f_Spur) / (ma - n)) + 1;
 772                         *fm = (-(f_Spur + (s32) c) / (ma - n)) + 1;
 773                         return 1;
 774                 }
 775         }
 776
 777         /*  No spurs found  */
 778         return 0;
 779 }
 780
 781 /*
 782  * MT_AvoidSpurs() - Main entry point to avoid spurs.
 783  *                   Checks for existing spurs in present LO1, LO2 freqs
 784  *                   and if present, chooses spur-free LO1, LO2 combination
 785  *                   that tunes the same input/output frequencies.
 786  */
 787 static u32 MT2063_AvoidSpurs(struct MT2063_AvoidSpursData_t *pAS_Info)
 788 {
 789         int status = 0;
 790         u32 fm, fp;             /*  restricted range on LO's        */
 791         pAS_Info->bSpurAvoided = 0;
 792         pAS_Info->nSpursFound = 0;
 793
 794         dprintk(2, "\n");
 795
 796         if (pAS_Info->maxH1 == 0)
 797                 return 0;
 798
 799         /*
 800          * Avoid LO Generated Spurs
 801          *
 802          * Make sure that have no LO-related spurs within the IF output
 803          * bandwidth.
 804          *
 805          * If there is an LO spur in this band, start at the current IF1 frequency
 806          * and work out until we find a spur-free frequency or run up against the
 807          * 1st IF SAW band edge.  Use temporary copies of fLO1 and fLO2 so that they
 808          * will be unchanged if a spur-free setting is not found.
 809          */
 810         pAS_Info->bSpurPresent = IsSpurInBand(pAS_Info, &fm, &fp);
 811         if (pAS_Info->bSpurPresent) {
 812                 u32 zfIF1 = pAS_Info->f_LO1 - pAS_Info->f_in;   /*  current attempt at a 1st IF  */
 813                 u32 zfLO1 = pAS_Info->f_LO1;    /*  current attempt at an LO1 freq  */
 814                 u32 zfLO2 = pAS_Info->f_LO2;    /*  current attempt at an LO2 freq  */
 815                 u32 delta_IF1;
 816                 u32 new_IF1;
 817
 818                 /*
 819                  **  Spur was found, attempt to find a spur-free 1st IF
 820                  */
 821                 do {
 822                         pAS_Info->nSpursFound++;
 823
 824                         /*  Raise f_IF1_upper, if needed  */
 825                         MT2063_AddExclZone(pAS_Info, zfIF1 - fm, zfIF1 + fp);
 826
 827                         /*  Choose next IF1 that is closest to f_IF1_CENTER              */
 828                         new_IF1 = MT2063_ChooseFirstIF(pAS_Info);
 829
 830                         if (new_IF1 > zfIF1) {
 831                                 pAS_Info->f_LO1 += (new_IF1 - zfIF1);
 832                                 pAS_Info->f_LO2 += (new_IF1 - zfIF1);
 833                         } else {
 834                                 pAS_Info->f_LO1 -= (zfIF1 - new_IF1);
 835                                 pAS_Info->f_LO2 -= (zfIF1 - new_IF1);
 836                         }
 837                         zfIF1 = new_IF1;
 838
 839                         if (zfIF1 > pAS_Info->f_if1_Center)
 840                                 delta_IF1 = zfIF1 - pAS_Info->f_if1_Center;
 841                         else
 842                                 delta_IF1 = pAS_Info->f_if1_Center - zfIF1;
 843
 844                         pAS_Info->bSpurPresent = IsSpurInBand(pAS_Info, &fm, &fp);
 845                 /*
 846                  *  Continue while the new 1st IF is still within the 1st IF bandwidth
 847                  *  and there is a spur in the band (again)
 848                  */
 849                 } while ((2 * delta_IF1 + pAS_Info->f_out_bw <= pAS_Info->f_if1_bw) && pAS_Info->bSpurPresent);
 850
 851                 /*
 852                  * Use the LO-spur free values found.  If the search went all
 853                  * the way to the 1st IF band edge and always found spurs, just
 854                  * leave the original choice.  It's as "good" as any other.
 855                  */
 856                 if (pAS_Info->bSpurPresent == 1) {
 857                         status |= MT2063_SPUR_PRESENT_ERR;
 858                         pAS_Info->f_LO1 = zfLO1;
 859                         pAS_Info->f_LO2 = zfLO2;
 860                 } else
 861                         pAS_Info->bSpurAvoided = 1;
 862         }
 863
 864         status |=
 865             ((pAS_Info->
 866               nSpursFound << MT2063_SPUR_SHIFT) & MT2063_SPUR_CNT_MASK);
 867
 868         return status;
 869 }
 870
 871 /*
 872  * Constants used by the tuning algorithm
 873  */
 874 #define MT2063_REF_FREQ          (16000000UL)   /* Reference oscillator Frequency (in Hz) */
 875 #define MT2063_IF1_BW            (22000000UL)   /* The IF1 filter bandwidth (in Hz) */
 876 #define MT2063_TUNE_STEP_SIZE       (50000UL)   /* Tune in steps of 50 kHz */
 877 #define MT2063_SPUR_STEP_HZ        (250000UL)   /* Step size (in Hz) to move IF1 when avoiding spurs */
 878 #define MT2063_ZIF_BW             (2000000UL)   /* Zero-IF spur-free bandwidth (in Hz) */
 879 #define MT2063_MAX_HARMONICS_1         (15UL)   /* Highest intra-tuner LO Spur Harmonic to be avoided */
 880 #define MT2063_MAX_HARMONICS_2          (5UL)   /* Highest inter-tuner LO Spur Harmonic to be avoided */
 881 #define MT2063_MIN_LO_SEP         (1000000UL)   /* Minimum inter-tuner LO frequency separation */
 882 #define MT2063_LO1_FRACN_AVOID          (0UL)   /* LO1 FracN numerator avoid region (in Hz) */
 883 #define MT2063_LO2_FRACN_AVOID     (199999UL)   /* LO2 FracN numerator avoid region (in Hz) */
 884 #define MT2063_MIN_FIN_FREQ      (44000000UL)   /* Minimum input frequency (in Hz) */
 885 #define MT2063_MAX_FIN_FREQ    (1100000000UL)   /* Maximum input frequency (in Hz) */
 886 #define MT2063_MIN_FOUT_FREQ     (36000000UL)   /* Minimum output frequency (in Hz) */
 887 #define MT2063_MAX_FOUT_FREQ     (57000000UL)   /* Maximum output frequency (in Hz) */
 888 #define MT2063_MIN_DNC_FREQ    (1293000000UL)   /* Minimum LO2 frequency (in Hz) */
 889 #define MT2063_MAX_DNC_FREQ    (1614000000UL)   /* Maximum LO2 frequency (in Hz) */
 890 #define MT2063_MIN_UPC_FREQ    (1396000000UL)   /* Minimum LO1 frequency (in Hz) */
 891 #define MT2063_MAX_UPC_FREQ    (2750000000UL)   /* Maximum LO1 frequency (in Hz) */
 892
 893 /*
 894  *  Define the supported Part/Rev codes for the MT2063
 895  */
 896 #define MT2063_B0       (0x9B)
 897 #define MT2063_B1       (0x9C)
 898 #define MT2063_B2       (0x9D)
 899 #define MT2063_B3       (0x9E)
 900
 901 /**
 902  * mt2063_lockStatus - Checks to see if LO1 and LO2 are locked
 903  *
 904  * @state:      struct mt2063_state pointer
 905  *
 906  * This function returns 0, if no lock, 1 if locked and a value < 1 if error
 907  */
 908 static int mt2063_lockStatus(struct mt2063_state *state)
 909 {
 910         const u32 nMaxWait = 100;       /*  wait a maximum of 100 msec   */
 911         const u32 nPollRate = 2;        /*  poll status bits every 2 ms */
 912         const u32 nMaxLoops = nMaxWait / nPollRate;
 913         const u8 LO1LK = 0x80;
 914         u8 LO2LK = 0x08;
 915         int status;
 916         u32 nDelays = 0;
 917
 918         dprintk(2, "\n");
 919
 920         /*  LO2 Lock bit was in a different place for B0 version  */
 921         if (state->tuner_id == MT2063_B0)
 922                 LO2LK = 0x40;
 923
 924         do {
 925                 status = mt2063_read(state, MT2063_REG_LO_STATUS,
 926                                      &state->reg[MT2063_REG_LO_STATUS], 1);
 927
 928                 if (status < 0)
 929                         return status;
 930
 931                 if ((state->reg[MT2063_REG_LO_STATUS] & (LO1LK | LO2LK)) ==
 932                     (LO1LK | LO2LK)) {
 933                         return TUNER_STATUS_LOCKED | TUNER_STATUS_STEREO;
 934                 }
 935                 msleep(nPollRate);      /*  Wait between retries  */
 936         } while (++nDelays < nMaxLoops);
 937
 938         /*
 939          * Got no lock or partial lock
 940          */
 941         return 0;
 942 }
 943
 944 /*
 945  *  Constants for setting receiver modes.
 946  *  (6 modes defined at this time, enumerated by mt2063_delivery_sys)
 947  *  (DNC1GC & DNC2GC are the values, which are used, when the specific
 948  *   DNC Output is selected, the other is always off)
 949  *
 950  *                enum mt2063_delivery_sys
 951  * -------------+----------------------------------------------
 952  * Mode 0 :     | MT2063_CABLE_QAM
 953  * Mode 1 :     | MT2063_CABLE_ANALOG
 954  * Mode 2 :     | MT2063_OFFAIR_COFDM
 955  * Mode 3 :     | MT2063_OFFAIR_COFDM_SAWLESS
 956  * Mode 4 :     | MT2063_OFFAIR_ANALOG
 957  * Mode 5 :     | MT2063_OFFAIR_8VSB
 958  * --------------+----------------------------------------------
 959  *
 960  *                |<----------   Mode  -------------->|
 961  *    Reg Field   |  0  |  1  |  2  |  3  |  4  |  5  |
 962  *    ------------+-----+-----+-----+-----+-----+-----+
 963  *    RFAGCen     | OFF | OFF | OFF | OFF | OFF | OFF
 964  *    LNARin      |   0 |   0 |   3 |   3 |  3  |  3
 965  *    FIFFQen     |   1 |   1 |   1 |   1 |  1  |  1
 966  *    FIFFq       |   0 |   0 |   0 |   0 |  0  |  0
 967  *    DNC1gc      |   0 |   0 |   0 |   0 |  0  |  0
 968  *    DNC2gc      |   0 |   0 |   0 |   0 |  0  |  0
 969  *    GCU Auto    |   1 |   1 |   1 |   1 |  1  |  1
 970  *    LNA max Atn |  31 |  31 |  31 |  31 | 31  | 31
 971  *    LNA Target  |  44 |  43 |  43 |  43 | 43  | 43
 972  *    ign  RF Ovl |   0 |   0 |   0 |   0 |  0  |  0
 973  *    RF  max Atn |  31 |  31 |  31 |  31 | 31  | 31
 974  *    PD1 Target  |  36 |  36 |  38 |  38 | 36  | 38
 975  *    ign FIF Ovl |   0 |   0 |   0 |   0 |  0  |  0
 976  *    FIF max Atn |   5 |   5 |   5 |   5 |  5  |  5
 977  *    PD2 Target  |  40 |  33 |  42 |  42 | 33  | 42
 978  */
 979
 980 enum mt2063_delivery_sys {
 981         MT2063_CABLE_QAM = 0,
 982         MT2063_CABLE_ANALOG,
 983         MT2063_OFFAIR_COFDM,
 984         MT2063_OFFAIR_COFDM_SAWLESS,
 985         MT2063_OFFAIR_ANALOG,
 986         MT2063_OFFAIR_8VSB,
 987         MT2063_NUM_RCVR_MODES
 988 };
 989
 990 static const char *mt2063_mode_name[] = {
 991         [MT2063_CABLE_QAM]              = "digital cable",
 992         [MT2063_CABLE_ANALOG]           = "analog cable",
 993         [MT2063_OFFAIR_COFDM]           = "digital offair",
 994         [MT2063_OFFAIR_COFDM_SAWLESS]   = "digital offair without SAW",
 995         [MT2063_OFFAIR_ANALOG]          = "analog offair",
 996         [MT2063_OFFAIR_8VSB]            = "analog offair 8vsb",
 997 };
 998
 999 static const u8 RFAGCEN[]       = {  0,  0,  0,  0,  0,  0 };
1000 static const u8 LNARIN[]        = {  0,  0,  3,  3,  3,  3 };
1001 static const u8 FIFFQEN[]       = {  1,  1,  1,  1,  1,  1 };
1002 static const u8 FIFFQ[]         = {  0,  0,  0,  0,  0,  0 };
1003 static const u8 DNC1GC[]        = {  0,  0,  0,  0,  0,  0 };
1004 static const u8 DNC2GC[]        = {  0,  0,  0,  0,  0,  0 };
1005 static const u8 ACLNAMAX[]      = { 31, 31, 31, 31, 31, 31 };
1006 static const u8 LNATGT[]        = { 44, 43, 43, 43, 43, 43 };
1007 static const u8 RFOVDIS[]       = {  0,  0,  0,  0,  0,  0 };
1008 static const u8 ACRFMAX[]       = { 31, 31, 31, 31, 31, 31 };
1009 static const u8 PD1TGT[]        = { 36, 36, 38, 38, 36, 38 };
1010 static const u8 FIFOVDIS[]      = {  0,  0,  0,  0,  0,  0 };
1011 static const u8 ACFIFMAX[]      = { 29, 29, 29, 29, 29, 29 };
1012 static const u8 PD2TGT[]        = { 40, 33, 38, 42, 30, 38 };
1013
1014 /*
1015  * mt2063_set_dnc_output_enable()
1016  */
1017 static u32 mt2063_get_dnc_output_enable(struct mt2063_state *state,
1018                                         enum MT2063_DNC_Output_Enable *pValue)
1019 {
1020         dprintk(2, "\n");
1021
1022         if ((state->reg[MT2063_REG_DNC_GAIN] & 0x03) == 0x03) { /* if DNC1 is off */
1023                 if ((state->reg[MT2063_REG_VGA_GAIN] & 0x03) == 0x03)   /* if DNC2 is off */
1024                         *pValue = MT2063_DNC_NONE;
1025                 else
1026                         *pValue = MT2063_DNC_2;
1027         } else {        /* DNC1 is on */
1028                 if ((state->reg[MT2063_REG_VGA_GAIN] & 0x03) == 0x03)   /* if DNC2 is off */
1029                         *pValue = MT2063_DNC_1;
1030                 else
1031                         *pValue = MT2063_DNC_BOTH;
1032         }
1033         return 0;
1034 }
1035
1036 /*
1037  * mt2063_set_dnc_output_enable()
1038  */
1039 static u32 mt2063_set_dnc_output_enable(struct mt2063_state *state,
1040                                         enum MT2063_DNC_Output_Enable nValue)
1041 {
1042         int status = 0; /* Status to be returned        */
1043         u8 val = 0;
1044
1045         dprintk(2, "\n");
1046
1047         /* selects, which DNC output is used */
1048         switch (nValue) {
1049         case MT2063_DNC_NONE:
1050                 val = (state->reg[MT2063_REG_DNC_GAIN] & 0xFC) | 0x03;  /* Set DNC1GC=3 */
1051                 if (state->reg[MT2063_REG_DNC_GAIN] !=
1052                     val)
1053                         status |=
1054                             mt2063_setreg(state,
1055                                           MT2063_REG_DNC_GAIN,
1056                                           val);
1057
1058                 val = (state->reg[MT2063_REG_VGA_GAIN] & 0xFC) | 0x03;  /* Set DNC2GC=3 */
1059                 if (state->reg[MT2063_REG_VGA_GAIN] !=
1060                     val)
1061                         status |=
1062                             mt2063_setreg(state,
1063                                           MT2063_REG_VGA_GAIN,
1064                                           val);
1065
1066                 val = (state->reg[MT2063_REG_RSVD_20] & ~0x40); /* Set PD2MUX=0 */
1067                 if (state->reg[MT2063_REG_RSVD_20] !=
1068                     val)
1069                         status |=
1070                             mt2063_setreg(state,
1071                                           MT2063_REG_RSVD_20,
1072                                           val);
1073
1074                 break;
1075         case MT2063_DNC_1:
1076                 val = (state->reg[MT2063_REG_DNC_GAIN] & 0xFC) | (DNC1GC[state->rcvr_mode] & 0x03);     /* Set DNC1GC=x */
1077                 if (state->reg[MT2063_REG_DNC_GAIN] !=
1078                     val)
1079                         status |=
1080                             mt2063_setreg(state,
1081                                           MT2063_REG_DNC_GAIN,
1082                                           val);
1083
1084                 val = (state->reg[MT2063_REG_VGA_GAIN] & 0xFC) | 0x03;  /* Set DNC2GC=3 */
1085                 if (state->reg[MT2063_REG_VGA_GAIN] !=
1086                     val)
1087                         status |=
1088                             mt2063_setreg(state,
1089                                           MT2063_REG_VGA_GAIN,
1090                                           val);
1091
1092                 val = (state->reg[MT2063_REG_RSVD_20] & ~0x40); /* Set PD2MUX=0 */
1093                 if (state->reg[MT2063_REG_RSVD_20] !=
1094                     val)
1095                         status |=
1096                             mt2063_setreg(state,
1097                                           MT2063_REG_RSVD_20,
1098                                           val);
1099
1100                 break;
1101         case MT2063_DNC_2:
1102                 val = (state->reg[MT2063_REG_DNC_GAIN] & 0xFC) | 0x03;  /* Set DNC1GC=3 */
1103                 if (state->reg[MT2063_REG_DNC_GAIN] !=
1104                     val)
1105                         status |=
1106                             mt2063_setreg(state,
1107                                           MT2063_REG_DNC_GAIN,
1108                                           val);
1109
1110                 val = (state->reg[MT2063_REG_VGA_GAIN] & 0xFC) | (DNC2GC[state->rcvr_mode] & 0x03);     /* Set DNC2GC=x */
1111                 if (state->reg[MT2063_REG_VGA_GAIN] !=
1112                     val)
1113                         status |=
1114                             mt2063_setreg(state,
1115                                           MT2063_REG_VGA_GAIN,
1116                                           val);
1117
1118                 val = (state->reg[MT2063_REG_RSVD_20] | 0x40);  /* Set PD2MUX=1 */
1119                 if (state->reg[MT2063_REG_RSVD_20] !=
1120                     val)
1121                         status |=
1122                             mt2063_setreg(state,
1123                                           MT2063_REG_RSVD_20,
1124                                           val);
1125
1126                 break;
1127         case MT2063_DNC_BOTH:
1128                 val = (state->reg[MT2063_REG_DNC_GAIN] & 0xFC) | (DNC1GC[state->rcvr_mode] & 0x03);     /* Set DNC1GC=x */
1129                 if (state->reg[MT2063_REG_DNC_GAIN] !=
1130                     val)
1131                         status |=
1132                             mt2063_setreg(state,
1133                                           MT2063_REG_DNC_GAIN,
1134                                           val);
1135
1136                 val = (state->reg[MT2063_REG_VGA_GAIN] & 0xFC) | (DNC2GC[state->rcvr_mode] & 0x03);     /* Set DNC2GC=x */
1137                 if (state->reg[MT2063_REG_VGA_GAIN] !=
1138                     val)
1139                         status |=
1140                             mt2063_setreg(state,
1141                                           MT2063_REG_VGA_GAIN,
1142                                           val);
1143
1144                 val = (state->reg[MT2063_REG_RSVD_20] | 0x40);  /* Set PD2MUX=1 */
1145                 if (state->reg[MT2063_REG_RSVD_20] !=
1146                     val)
1147                         status |=
1148                             mt2063_setreg(state,
1149                                           MT2063_REG_RSVD_20,
1150                                           val);
1151
1152                 break;
1153         default:
1154                 break;
1155         }
1156
1157         return status;
1158 }
1159
1160 /*
1161  * MT2063_SetReceiverMode() - Set the MT2063 receiver mode, according with
1162  *                            the selected enum mt2063_delivery_sys type.
1163  *
1164  *  (DNC1GC & DNC2GC are the values, which are used, when the specific
1165  *   DNC Output is selected, the other is always off)
1166  *
1167  * @state:      ptr to mt2063_state structure
1168  * @Mode:       desired receiver delivery system
1169  *
1170  * Note: Register cache must be valid for it to work
1171  */
1172
1173 static u32 MT2063_SetReceiverMode(struct mt2063_state *state,
1174                                   enum mt2063_delivery_sys Mode)
1175 {
1176         int status = 0; /* Status to be returned        */
1177         u8 val;
1178         u32 longval;
1179
1180         dprintk(2, "\n");
1181
1182         if (Mode >= MT2063_NUM_RCVR_MODES)
1183                 status = -ERANGE;
1184
1185         /* RFAGCen */
1186         if (status >= 0) {
1187                 val =
1188                     (state->
1189                      reg[MT2063_REG_PD1_TGT] & ~0x40) | (RFAGCEN[Mode]
1190                                                                    ? 0x40 :
1191                                                                    0x00);
1192                 if (state->reg[MT2063_REG_PD1_TGT] != val)
1193                         status |= mt2063_setreg(state, MT2063_REG_PD1_TGT, val);
1194         }
1195
1196         /* LNARin */
1197         if (status >= 0) {
1198                 u8 val = (state->reg[MT2063_REG_CTRL_2C] & ~0x03) |
1199                          (LNARIN[Mode] & 0x03);
1200                 if (state->reg[MT2063_REG_CTRL_2C] != val)
1201                         status |= mt2063_setreg(state, MT2063_REG_CTRL_2C, val);
1202         }
1203
1204         /* FIFFQEN and FIFFQ */
1205         if (status >= 0) {
1206                 val =
1207                     (state->
1208                      reg[MT2063_REG_FIFF_CTRL2] & ~0xF0) |
1209                     (FIFFQEN[Mode] << 7) | (FIFFQ[Mode] << 4);
1210                 if (state->reg[MT2063_REG_FIFF_CTRL2] != val) {
1211                         status |=
1212                             mt2063_setreg(state, MT2063_REG_FIFF_CTRL2, val);
1213                         /* trigger FIFF calibration, needed after changing FIFFQ */
1214                         val =
1215                             (state->reg[MT2063_REG_FIFF_CTRL] | 0x01);
1216                         status |=
1217                             mt2063_setreg(state, MT2063_REG_FIFF_CTRL, val);
1218                         val =
1219                             (state->
1220                              reg[MT2063_REG_FIFF_CTRL] & ~0x01);
1221                         status |=
1222                             mt2063_setreg(state, MT2063_REG_FIFF_CTRL, val);
1223                 }
1224         }
1225
1226         /* DNC1GC & DNC2GC */
1227         status |= mt2063_get_dnc_output_enable(state, &longval);
1228         status |= mt2063_set_dnc_output_enable(state, longval);
1229
1230         /* acLNAmax */
1231         if (status >= 0) {
1232                 u8 val = (state->reg[MT2063_REG_LNA_OV] & ~0x1F) |
1233                          (ACLNAMAX[Mode] & 0x1F);
1234                 if (state->reg[MT2063_REG_LNA_OV] != val)
1235                         status |= mt2063_setreg(state, MT2063_REG_LNA_OV, val);
1236         }
1237
1238         /* LNATGT */
1239         if (status >= 0) {
1240                 u8 val = (state->reg[MT2063_REG_LNA_TGT] & ~0x3F) |
1241                          (LNATGT[Mode] & 0x3F);
1242                 if (state->reg[MT2063_REG_LNA_TGT] != val)
1243                         status |= mt2063_setreg(state, MT2063_REG_LNA_TGT, val);
1244         }
1245
1246         /* ACRF */
1247         if (status >= 0) {
1248                 u8 val = (state->reg[MT2063_REG_RF_OV] & ~0x1F) |
1249                          (ACRFMAX[Mode] & 0x1F);
1250                 if (state->reg[MT2063_REG_RF_OV] != val)
1251                         status |= mt2063_setreg(state, MT2063_REG_RF_OV, val);
1252         }
1253
1254         /* PD1TGT */
1255         if (status >= 0) {
1256                 u8 val = (state->reg[MT2063_REG_PD1_TGT] & ~0x3F) |
1257                          (PD1TGT[Mode] & 0x3F);
1258                 if (state->reg[MT2063_REG_PD1_TGT] != val)
1259                         status |= mt2063_setreg(state, MT2063_REG_PD1_TGT, val);
1260         }
1261
1262         /* FIFATN */
1263         if (status >= 0) {
1264                 u8 val = ACFIFMAX[Mode];
1265                 if (state->reg[MT2063_REG_PART_REV] != MT2063_B3 && val > 5)
1266                         val = 5;
1267                 val = (state->reg[MT2063_REG_FIF_OV] & ~0x1F) |
1268                       (val & 0x1F);
1269                 if (state->reg[MT2063_REG_FIF_OV] != val)
1270                         status |= mt2063_setreg(state, MT2063_REG_FIF_OV, val);
1271         }
1272
1273         /* PD2TGT */
1274         if (status >= 0) {
1275                 u8 val = (state->reg[MT2063_REG_PD2_TGT] & ~0x3F) |
1276                     (PD2TGT[Mode] & 0x3F);
1277                 if (state->reg[MT2063_REG_PD2_TGT] != val)
1278                         status |= mt2063_setreg(state, MT2063_REG_PD2_TGT, val);
1279         }
1280
1281         /* Ignore ATN Overload */
1282         if (status >= 0) {
1283                 val = (state->reg[MT2063_REG_LNA_TGT] & ~0x80) |
1284                       (RFOVDIS[Mode] ? 0x80 : 0x00);
1285                 if (state->reg[MT2063_REG_LNA_TGT] != val)
1286                         status |= mt2063_setreg(state, MT2063_REG_LNA_TGT, val);
1287         }
1288
1289         /* Ignore FIF Overload */
1290         if (status >= 0) {
1291                 val = (state->reg[MT2063_REG_PD1_TGT] & ~0x80) |
1292                       (FIFOVDIS[Mode] ? 0x80 : 0x00);
1293                 if (state->reg[MT2063_REG_PD1_TGT] != val)
1294                         status |= mt2063_setreg(state, MT2063_REG_PD1_TGT, val);
1295         }
1296
1297         if (status >= 0) {
1298                 state->rcvr_mode = Mode;
1299                 dprintk(1, "mt2063 mode changed to %s\n",
1300                         mt2063_mode_name[state->rcvr_mode]);
1301         }
1302
1303         return status;
1304 }
1305
1306 /*
1307  * MT2063_ClearPowerMaskBits () - Clears the power-down mask bits for various
1308  *                                sections of the MT2063
1309  *
1310  * @Bits:               Mask bits to be cleared.
1311  *
1312  * See definition of MT2063_Mask_Bits type for description
1313  * of each of the power bits.
1314  */
1315 static u32 MT2063_ClearPowerMaskBits(struct mt2063_state *state,
1316                                      enum MT2063_Mask_Bits Bits)
1317 {
1318         int status = 0;
1319
1320         dprintk(2, "\n");
1321         Bits = (enum MT2063_Mask_Bits)(Bits & MT2063_ALL_SD);   /* Only valid bits for this tuner */
1322         if ((Bits & 0xFF00) != 0) {
1323                 state->reg[MT2063_REG_PWR_2] &= ~(u8) (Bits >> 8);
1324                 status |=
1325                     mt2063_write(state,
1326                                     MT2063_REG_PWR_2,
1327                                     &state->reg[MT2063_REG_PWR_2], 1);
1328         }
1329         if ((Bits & 0xFF) != 0) {
1330                 state->reg[MT2063_REG_PWR_1] &= ~(u8) (Bits & 0xFF);
1331                 status |=
1332                     mt2063_write(state,
1333                                     MT2063_REG_PWR_1,
1334                                     &state->reg[MT2063_REG_PWR_1], 1);
1335         }
1336
1337         return status;
1338 }
1339
1340 /*
1341  * MT2063_SoftwareShutdown() - Enables or disables software shutdown function.
1342  *                             When Shutdown is 1, any section whose power
1343  *                             mask is set will be shutdown.
1344  */
1345 static u32 MT2063_SoftwareShutdown(struct mt2063_state *state, u8 Shutdown)
1346 {
1347         int status;
1348
1349         dprintk(2, "\n");
1350         if (Shutdown == 1)
1351                 state->reg[MT2063_REG_PWR_1] |= 0x04;
1352         else
1353                 state->reg[MT2063_REG_PWR_1] &= ~0x04;
1354
1355         status = mt2063_write(state,
1356                             MT2063_REG_PWR_1,
1357                             &state->reg[MT2063_REG_PWR_1], 1);
1358
1359         if (Shutdown != 1) {
1360                 state->reg[MT2063_REG_BYP_CTRL] =
1361                     (state->reg[MT2063_REG_BYP_CTRL] & 0x9F) | 0x40;
1362                 status |=
1363                     mt2063_write(state,
1364                                     MT2063_REG_BYP_CTRL,
1365                                     &state->reg[MT2063_REG_BYP_CTRL],
1366                                     1);
1367                 state->reg[MT2063_REG_BYP_CTRL] =
1368                     (state->reg[MT2063_REG_BYP_CTRL] & 0x9F);
1369                 status |=
1370                     mt2063_write(state,
1371                                     MT2063_REG_BYP_CTRL,
1372                                     &state->reg[MT2063_REG_BYP_CTRL],
1373                                     1);
1374         }
1375
1376         return status;
1377 }
1378
1379 static u32 MT2063_Round_fLO(u32 f_LO, u32 f_LO_Step, u32 f_ref)
1380 {
1381         return f_ref * (f_LO / f_ref)
1382             + f_LO_Step * (((f_LO % f_ref) + (f_LO_Step / 2)) / f_LO_Step);
1383 }
1384
1385 /**
1386  * fLO_FractionalTerm() - Calculates the portion contributed by FracN / denom.
1387  *                        This function preserves maximum precision without
1388  *                        risk of overflow.  It accurately calculates
1389  *                        f_ref * num / denom to within 1 HZ with fixed math.
1390  *
1391  * @f_ref:      SRO frequency.
1392  * @num:        Fractional portion of the multiplier
1393  * @denom:      denominator portion of the ratio
1394  *
1395  * This calculation handles f_ref as two separate 14-bit fields.
1396  * Therefore, a maximum value of 2^28-1 may safely be used for f_ref.
1397  * This is the genesis of the magic number "14" and the magic mask value of
1398  * 0x03FFF.
1399  *
1400  * This routine successfully handles denom values up to and including 2^18.
1401  *  Returns:        f_ref * num / denom
1402  */
1403 static u32 MT2063_fLO_FractionalTerm(u32 f_ref, u32 num, u32 denom)
1404 {
1405         u32 t1 = (f_ref >> 14) * num;
1406         u32 term1 = t1 / denom;
1407         u32 loss = t1 % denom;
1408         u32 term2 =
1409             (((f_ref & 0x00003FFF) * num + (loss << 14)) + (denom / 2)) / denom;
1410         return (term1 << 14) + term2;
1411 }
1412
1413 /*
1414  * CalcLO1Mult()- Calculates Integer divider value and the numerator
1415  *                value for a FracN PLL.
1416  *
1417  *                This function assumes that the f_LO and f_Ref are
1418  *                evenly divisible by f_LO_Step.
1419  *
1420  * @Div:        OUTPUT: Whole number portion of the multiplier
1421  * @FracN:      OUTPUT: Fractional portion of the multiplier
1422  * @f_LO:       desired LO frequency.
1423  * @f_LO_Step:  Minimum step size for the LO (in Hz).
1424  * @f_Ref:      SRO frequency.
1425  * @f_Avoid:    Range of PLL frequencies to avoid near integer multiples
1426  *              of f_Ref (in Hz).
1427  *
1428  * Returns:        Recalculated LO frequency.
1429  */
1430 static u32 MT2063_CalcLO1Mult(u32 *Div,
1431                               u32 *FracN,
1432                               u32 f_LO,
1433                               u32 f_LO_Step, u32 f_Ref)
1434 {
1435         /*  Calculate the whole number portion of the divider */
1436         *Div = f_LO / f_Ref;
1437
1438         /*  Calculate the numerator value (round to nearest f_LO_Step) */
1439         *FracN =
1440             (64 * (((f_LO % f_Ref) + (f_LO_Step / 2)) / f_LO_Step) +
1441              (f_Ref / f_LO_Step / 2)) / (f_Ref / f_LO_Step);
1442
1443         return (f_Ref * (*Div)) + MT2063_fLO_FractionalTerm(f_Ref, *FracN, 64);
1444 }
1445
1446 /**
1447  * CalcLO2Mult() - Calculates Integer divider value and the numerator
1448  *                 value for a FracN PLL.
1449  *
1450  *                  This function assumes that the f_LO and f_Ref are
1451  *                  evenly divisible by f_LO_Step.
1452  *
1453  * @Div:        OUTPUT: Whole number portion of the multiplier
1454  * @FracN:      OUTPUT: Fractional portion of the multiplier
1455  * @f_LO:       desired LO frequency.
1456  * @f_LO_Step:  Minimum step size for the LO (in Hz).
1457  * @f_Ref:      SRO frequency.
1458  *
1459  * Returns: Recalculated LO frequency.
1460  */
1461 static u32 MT2063_CalcLO2Mult(u32 *Div,
1462                               u32 *FracN,
1463                               u32 f_LO,
1464                               u32 f_LO_Step, u32 f_Ref)
1465 {
1466         /*  Calculate the whole number portion of the divider */
1467         *Div = f_LO / f_Ref;
1468
1469         /*  Calculate the numerator value (round to nearest f_LO_Step) */
1470         *FracN =
1471             (8191 * (((f_LO % f_Ref) + (f_LO_Step / 2)) / f_LO_Step) +
1472              (f_Ref / f_LO_Step / 2)) / (f_Ref / f_LO_Step);
1473
1474         return (f_Ref * (*Div)) + MT2063_fLO_FractionalTerm(f_Ref, *FracN,
1475                                                             8191);
1476 }
1477
1478 /*
1479  * FindClearTuneFilter() - Calculate the corrrect ClearTune filter to be
1480  *                         used for a given input frequency.
1481  *
1482  * @state:      ptr to tuner data structure
1483  * @f_in:       RF input center frequency (in Hz).
1484  *
1485  * Returns: ClearTune filter number (0-31)
1486  */
1487 static u32 FindClearTuneFilter(struct mt2063_state *state, u32 f_in)
1488 {
1489         u32 RFBand;
1490         u32 idx;                /*  index loop                      */
1491
1492         /*
1493          **  Find RF Band setting
1494          */
1495         RFBand = 31;            /*  def when f_in > all    */
1496         for (idx = 0; idx < 31; ++idx) {
1497                 if (state->CTFiltMax[idx] >= f_in) {
1498                         RFBand = idx;
1499                         break;
1500                 }
1501         }
1502         return RFBand;
1503 }
1504
1505 /*
1506  * MT2063_Tune() - Change the tuner's tuned frequency to RFin.
1507  */
1508 static u32 MT2063_Tune(struct mt2063_state *state, u32 f_in)
1509 {                               /* RF input center frequency   */
1510
1511         int status = 0;
1512         u32 LO1;                /*  1st LO register value           */
1513         u32 Num1;               /*  Numerator for LO1 reg. value    */
1514         u32 f_IF1;              /*  1st IF requested                */
1515         u32 LO2;                /*  2nd LO register value           */
1516         u32 Num2;               /*  Numerator for LO2 reg. value    */
1517         u32 ofLO1, ofLO2;       /*  last time's LO frequencies      */
1518         u8 fiffc = 0x80;        /*  FIFF center freq from tuner     */
1519         u32 fiffof;             /*  Offset from FIFF center freq    */
1520         const u8 LO1LK = 0x80;  /*  Mask for LO1 Lock bit           */
1521         u8 LO2LK = 0x08;        /*  Mask for LO2 Lock bit           */
1522         u8 val;
1523         u32 RFBand;
1524
1525         dprintk(2, "\n");
1526         /*  Check the input and output frequency ranges                   */
1527         if ((f_in < MT2063_MIN_FIN_FREQ) || (f_in > MT2063_MAX_FIN_FREQ))
1528                 return -EINVAL;
1529
1530         if ((state->AS_Data.f_out < MT2063_MIN_FOUT_FREQ)
1531             || (state->AS_Data.f_out > MT2063_MAX_FOUT_FREQ))
1532                 return -EINVAL;
1533
1534         /*
1535          * Save original LO1 and LO2 register values
1536          */
1537         ofLO1 = state->AS_Data.f_LO1;
1538         ofLO2 = state->AS_Data.f_LO2;
1539
1540         /*
1541          * Find and set RF Band setting
1542          */
1543         if (state->ctfilt_sw == 1) {
1544                 val = (state->reg[MT2063_REG_CTUNE_CTRL] | 0x08);
1545                 if (state->reg[MT2063_REG_CTUNE_CTRL] != val) {
1546                         status |=
1547                             mt2063_setreg(state, MT2063_REG_CTUNE_CTRL, val);
1548                 }
1549                 val = state->reg[MT2063_REG_CTUNE_OV];
1550                 RFBand = FindClearTuneFilter(state, f_in);
1551                 state->reg[MT2063_REG_CTUNE_OV] =
1552                     (u8) ((state->reg[MT2063_REG_CTUNE_OV] & ~0x1F)
1553                               | RFBand);
1554                 if (state->reg[MT2063_REG_CTUNE_OV] != val) {
1555                         status |=
1556                             mt2063_setreg(state, MT2063_REG_CTUNE_OV, val);
1557                 }
1558         }
1559
1560         /*
1561          * Read the FIFF Center Frequency from the tuner
1562          */
1563         if (status >= 0) {
1564                 status |=
1565                     mt2063_read(state,
1566                                    MT2063_REG_FIFFC,
1567                                    &state->reg[MT2063_REG_FIFFC], 1);
1568                 fiffc = state->reg[MT2063_REG_FIFFC];
1569         }
1570         /*
1571          * Assign in the requested values
1572          */
1573         state->AS_Data.f_in = f_in;
1574         /*  Request a 1st IF such that LO1 is on a step size */
1575         state->AS_Data.f_if1_Request =
1576             MT2063_Round_fLO(state->AS_Data.f_if1_Request + f_in,
1577                              state->AS_Data.f_LO1_Step,
1578                              state->AS_Data.f_ref) - f_in;
1579
1580         /*
1581          * Calculate frequency settings.  f_IF1_FREQ + f_in is the
1582          * desired LO1 frequency
1583          */
1584         MT2063_ResetExclZones(&state->AS_Data);
1585
1586         f_IF1 = MT2063_ChooseFirstIF(&state->AS_Data);
1587
1588         state->AS_Data.f_LO1 =
1589             MT2063_Round_fLO(f_IF1 + f_in, state->AS_Data.f_LO1_Step,
1590                              state->AS_Data.f_ref);
1591
1592         state->AS_Data.f_LO2 =
1593             MT2063_Round_fLO(state->AS_Data.f_LO1 - state->AS_Data.f_out - f_in,
1594                              state->AS_Data.f_LO2_Step, state->AS_Data.f_ref);
1595
1596         /*
1597          * Check for any LO spurs in the output bandwidth and adjust
1598          * the LO settings to avoid them if needed
1599          */
1600         status |= MT2063_AvoidSpurs(&state->AS_Data);
1601         /*
1602          * MT_AvoidSpurs spurs may have changed the LO1 & LO2 values.
1603          * Recalculate the LO frequencies and the values to be placed
1604          * in the tuning registers.
1605          */
1606         state->AS_Data.f_LO1 =
1607             MT2063_CalcLO1Mult(&LO1, &Num1, state->AS_Data.f_LO1,
1608                                state->AS_Data.f_LO1_Step, state->AS_Data.f_ref);
1609         state->AS_Data.f_LO2 =
1610             MT2063_Round_fLO(state->AS_Data.f_LO1 - state->AS_Data.f_out - f_in,
1611                              state->AS_Data.f_LO2_Step, state->AS_Data.f_ref);
1612         state->AS_Data.f_LO2 =
1613             MT2063_CalcLO2Mult(&LO2, &Num2, state->AS_Data.f_LO2,
1614                                state->AS_Data.f_LO2_Step, state->AS_Data.f_ref);
1615
1616         /*
1617          *  Check the upconverter and downconverter frequency ranges
1618          */
1619         if ((state->AS_Data.f_LO1 < MT2063_MIN_UPC_FREQ)
1620             || (state->AS_Data.f_LO1 > MT2063_MAX_UPC_FREQ))
1621                 status |= MT2063_UPC_RANGE;
1622         if ((state->AS_Data.f_LO2 < MT2063_MIN_DNC_FREQ)
1623             || (state->AS_Data.f_LO2 > MT2063_MAX_DNC_FREQ))
1624                 status |= MT2063_DNC_RANGE;
1625         /*  LO2 Lock bit was in a different place for B0 version  */
1626         if (state->tuner_id == MT2063_B0)
1627                 LO2LK = 0x40;
1628
1629         /*
1630          *  If we have the same LO frequencies and we're already locked,
1631          *  then skip re-programming the LO registers.
1632          */
1633         if ((ofLO1 != state->AS_Data.f_LO1)
1634             || (ofLO2 != state->AS_Data.f_LO2)
1635             || ((state->reg[MT2063_REG_LO_STATUS] & (LO1LK | LO2LK)) !=
1636                 (LO1LK | LO2LK))) {
1637                 /*
1638                  * Calculate the FIFFOF register value
1639                  *
1640                  *           IF1_Actual
1641                  * FIFFOF = ------------ - 8 * FIFFC - 4992
1642                  *            f_ref/64
1643                  */
1644                 fiffof =
1645                     (state->AS_Data.f_LO1 -
1646                      f_in) / (state->AS_Data.f_ref / 64) - 8 * (u32) fiffc -
1647                     4992;
1648                 if (fiffof > 0xFF)
1649                         fiffof = 0xFF;
1650
1651                 /*
1652                  * Place all of the calculated values into the local tuner
1653                  * register fields.
1654                  */
1655                 if (status >= 0) {
1656                         state->reg[MT2063_REG_LO1CQ_1] = (u8) (LO1 & 0xFF);     /* DIV1q */
1657                         state->reg[MT2063_REG_LO1CQ_2] = (u8) (Num1 & 0x3F);    /* NUM1q */
1658                         state->reg[MT2063_REG_LO2CQ_1] = (u8) (((LO2 & 0x7F) << 1)      /* DIV2q */
1659                                                                    |(Num2 >> 12));      /* NUM2q (hi) */
1660                         state->reg[MT2063_REG_LO2CQ_2] = (u8) ((Num2 & 0x0FF0) >> 4);   /* NUM2q (mid) */
1661                         state->reg[MT2063_REG_LO2CQ_3] = (u8) (0xE0 | (Num2 & 0x000F)); /* NUM2q (lo) */
1662
1663                         /*
1664                          * Now write out the computed register values
1665                          * IMPORTANT: There is a required order for writing
1666                          *            (0x05 must follow all the others).
1667                          */
1668                         status |= mt2063_write(state, MT2063_REG_LO1CQ_1, &state->reg[MT2063_REG_LO1CQ_1], 5);  /* 0x01 - 0x05 */
1669                         if (state->tuner_id == MT2063_B0) {
1670                                 /* Re-write the one-shot bits to trigger the tune operation */
1671                                 status |= mt2063_write(state, MT2063_REG_LO2CQ_3, &state->reg[MT2063_REG_LO2CQ_3], 1);  /* 0x05 */
1672                         }
1673                         /* Write out the FIFF offset only if it's changing */
1674                         if (state->reg[MT2063_REG_FIFF_OFFSET] !=
1675                             (u8) fiffof) {
1676                                 state->reg[MT2063_REG_FIFF_OFFSET] =
1677                                     (u8) fiffof;
1678                                 status |=
1679                                     mt2063_write(state,
1680                                                     MT2063_REG_FIFF_OFFSET,
1681                                                     &state->
1682                                                     reg[MT2063_REG_FIFF_OFFSET],
1683                                                     1);
1684                         }
1685                 }
1686
1687                 /*
1688                  * Check for LO's locking
1689                  */
1690
1691                 if (status < 0)
1692                         return status;
1693
1694                 status = mt2063_lockStatus(state);
1695                 if (status < 0)
1696                         return status;
1697                 if (!status)
1698                         return -EINVAL;         /* Couldn't lock */
1699
1700                 /*
1701                  * If we locked OK, assign calculated data to mt2063_state structure
1702                  */
1703                 state->f_IF1_actual = state->AS_Data.f_LO1 - f_in;
1704         }
1705
1706         return status;
1707 }
1708
1709 static const u8 MT2063B0_defaults[] = {
1710         /* Reg,  Value */
1711         0x19, 0x05,
1712         0x1B, 0x1D,
1713         0x1C, 0x1F,
1714         0x1D, 0x0F,
1715         0x1E, 0x3F,
1716         0x1F, 0x0F,
1717         0x20, 0x3F,
1718         0x22, 0x21,
1719         0x23, 0x3F,
1720         0x24, 0x20,
1721         0x25, 0x3F,
1722         0x27, 0xEE,
1723         0x2C, 0x27,     /*  bit at 0x20 is cleared below  */
1724         0x30, 0x03,
1725         0x2C, 0x07,     /*  bit at 0x20 is cleared here   */
1726         0x2D, 0x87,
1727         0x2E, 0xAA,
1728         0x28, 0xE1,     /*  Set the FIFCrst bit here      */
1729         0x28, 0xE0,     /*  Clear the FIFCrst bit here    */
1730         0x00
1731 };
1732
1733 /* writing 0x05 0xf0 sw-resets all registers, so we write only needed changes */
1734 static const u8 MT2063B1_defaults[] = {
1735         /* Reg,  Value */
1736         0x05, 0xF0,
1737         0x11, 0x10,     /* New Enable AFCsd */
1738         0x19, 0x05,
1739         0x1A, 0x6C,
1740         0x1B, 0x24,
1741         0x1C, 0x28,
1742         0x1D, 0x8F,
1743         0x1E, 0x14,
1744         0x1F, 0x8F,
1745         0x20, 0x57,
1746         0x22, 0x21,     /* New - ver 1.03 */
1747         0x23, 0x3C,     /* New - ver 1.10 */
1748         0x24, 0x20,     /* New - ver 1.03 */
1749         0x2C, 0x24,     /*  bit at 0x20 is cleared below  */
1750         0x2D, 0x87,     /*  FIFFQ=0  */
1751         0x2F, 0xF3,
1752         0x30, 0x0C,     /* New - ver 1.11 */
1753         0x31, 0x1B,     /* New - ver 1.11 */
1754         0x2C, 0x04,     /*  bit at 0x20 is cleared here  */
1755         0x28, 0xE1,     /*  Set the FIFCrst bit here      */
1756         0x28, 0xE0,     /*  Clear the FIFCrst bit here    */
1757         0x00
1758 };
1759
1760 /* writing 0x05 0xf0 sw-resets all registers, so we write only needed changes */
1761 static const u8 MT2063B3_defaults[] = {
1762         /* Reg,  Value */
1763         0x05, 0xF0,
1764         0x19, 0x3D,
1765         0x2C, 0x24,     /*  bit at 0x20 is cleared below  */
1766         0x2C, 0x04,     /*  bit at 0x20 is cleared here  */
1767         0x28, 0xE1,     /*  Set the FIFCrst bit here      */
1768         0x28, 0xE0,     /*  Clear the FIFCrst bit here    */
1769         0x00
1770 };
1771
1772 static int mt2063_init(struct dvb_frontend *fe)
1773 {
1774         int status;
1775         struct mt2063_state *state = fe->tuner_priv;
1776         u8 all_resets = 0xF0;   /* reset/load bits */
1777         const u8 *def = NULL;
1778         char *step;
1779         u32 FCRUN;
1780         s32 maxReads;
1781         u32 fcu_osc;
1782         u32 i;
1783
1784         dprintk(2, "\n");
1785
1786         state->rcvr_mode = MT2063_CABLE_QAM;
1787
1788         /*  Read the Part/Rev code from the tuner */
1789         status = mt2063_read(state, MT2063_REG_PART_REV,
1790                              &state->reg[MT2063_REG_PART_REV], 1);
1791         if (status < 0) {
1792                 printk(KERN_ERR "Can't read mt2063 part ID\n");
1793                 return status;
1794         }
1795
1796         /* Check the part/rev code */
1797         switch (state->reg[MT2063_REG_PART_REV]) {
1798         case MT2063_B0:
1799                 step = "B0";
1800                 break;
1801         case MT2063_B1:
1802                 step = "B1";
1803                 break;
1804         case MT2063_B2:
1805                 step = "B2";
1806                 break;
1807         case MT2063_B3:
1808                 step = "B3";
1809                 break;
1810         default:
1811                 printk(KERN_ERR "mt2063: Unknown mt2063 device ID (0x%02x)\n",
1812                        state->reg[MT2063_REG_PART_REV]);
1813                 return -ENODEV; /*  Wrong tuner Part/Rev code */
1814         }
1815
1816         /*  Check the 2nd byte of the Part/Rev code from the tuner */
1817         status = mt2063_read(state, MT2063_REG_RSVD_3B,
1818                              &state->reg[MT2063_REG_RSVD_3B], 1);
1819
1820         /* b7 != 0 ==> NOT MT2063 */
1821         if (status < 0 || ((state->reg[MT2063_REG_RSVD_3B] & 0x80) != 0x00)) {
1822                 printk(KERN_ERR "mt2063: Unknown part ID (0x%02x%02x)\n",
1823                        state->reg[MT2063_REG_PART_REV],
1824                        state->reg[MT2063_REG_RSVD_3B]);
1825                 return -ENODEV; /*  Wrong tuner Part/Rev code */
1826         }
1827
1828         printk(KERN_INFO "mt2063: detected a mt2063 %s\n", step);
1829
1830         /*  Reset the tuner  */
1831         status = mt2063_write(state, MT2063_REG_LO2CQ_3, &all_resets, 1);
1832         if (status < 0)
1833                 return status;
1834
1835         /* change all of the default values that vary from the HW reset values */
1836         /*  def = (state->reg[PART_REV] == MT2063_B0) ? MT2063B0_defaults : MT2063B1_defaults; */
1837         switch (state->reg[MT2063_REG_PART_REV]) {
1838         case MT2063_B3:
1839                 def = MT2063B3_defaults;
1840                 break;
1841
1842         case MT2063_B1:
1843                 def = MT2063B1_defaults;
1844                 break;
1845
1846         case MT2063_B0:
1847                 def = MT2063B0_defaults;
1848                 break;
1849
1850         default:
1851                 return -ENODEV;
1852                 break;
1853         }
1854
1855         while (status >= 0 && *def) {
1856                 u8 reg = *def++;
1857                 u8 val = *def++;
1858                 status = mt2063_write(state, reg, &val, 1);
1859         }
1860         if (status < 0)
1861                 return status;
1862
1863         /*  Wait for FIFF location to complete.  */
1864         FCRUN = 1;
1865         maxReads = 10;
1866         while (status >= 0 && (FCRUN != 0) && (maxReads-- > 0)) {
1867                 msleep(2);
1868                 status = mt2063_read(state,
1869                                          MT2063_REG_XO_STATUS,
1870                                          &state->
1871                                          reg[MT2063_REG_XO_STATUS], 1);
1872                 FCRUN = (state->reg[MT2063_REG_XO_STATUS] & 0x40) >> 6;
1873         }
1874
1875         if (FCRUN != 0 || status < 0)
1876                 return -ENODEV;
1877
1878         status = mt2063_read(state,
1879                            MT2063_REG_FIFFC,
1880                            &state->reg[MT2063_REG_FIFFC], 1);
1881         if (status < 0)
1882                 return status;
1883
1884         /* Read back all the registers from the tuner */
1885         status = mt2063_read(state,
1886                                 MT2063_REG_PART_REV,
1887                                 state->reg, MT2063_REG_END_REGS);
1888         if (status < 0)
1889                 return status;
1890
1891         /*  Initialize the tuner state.  */
1892         state->tuner_id = state->reg[MT2063_REG_PART_REV];
1893         state->AS_Data.f_ref = MT2063_REF_FREQ;
1894         state->AS_Data.f_if1_Center = (state->AS_Data.f_ref / 8) *
1895                                       ((u32) state->reg[MT2063_REG_FIFFC] + 640);
1896         state->AS_Data.f_if1_bw = MT2063_IF1_BW;
1897         state->AS_Data.f_out = 43750000UL;
1898         state->AS_Data.f_out_bw = 6750000UL;
1899         state->AS_Data.f_zif_bw = MT2063_ZIF_BW;
1900         state->AS_Data.f_LO1_Step = state->AS_Data.f_ref / 64;
1901         state->AS_Data.f_LO2_Step = MT2063_TUNE_STEP_SIZE;
1902         state->AS_Data.maxH1 = MT2063_MAX_HARMONICS_1;
1903         state->AS_Data.maxH2 = MT2063_MAX_HARMONICS_2;
1904         state->AS_Data.f_min_LO_Separation = MT2063_MIN_LO_SEP;
1905         state->AS_Data.f_if1_Request = state->AS_Data.f_if1_Center;
1906         state->AS_Data.f_LO1 = 2181000000UL;
1907         state->AS_Data.f_LO2 = 1486249786UL;
1908         state->f_IF1_actual = state->AS_Data.f_if1_Center;
1909         state->AS_Data.f_in = state->AS_Data.f_LO1 - state->f_IF1_actual;
1910         state->AS_Data.f_LO1_FracN_Avoid = MT2063_LO1_FRACN_AVOID;
1911         state->AS_Data.f_LO2_FracN_Avoid = MT2063_LO2_FRACN_AVOID;
1912         state->num_regs = MT2063_REG_END_REGS;
1913         state->AS_Data.avoidDECT = MT2063_AVOID_BOTH;
1914         state->ctfilt_sw = 0;
1915
1916         state->CTFiltMax[0] = 69230000;
1917         state->CTFiltMax[1] = 105770000;
1918         state->CTFiltMax[2] = 140350000;
1919         state->CTFiltMax[3] = 177110000;
1920         state->CTFiltMax[4] = 212860000;
1921         state->CTFiltMax[5] = 241130000;
1922         state->CTFiltMax[6] = 274370000;
1923         state->CTFiltMax[7] = 309820000;
1924         state->CTFiltMax[8] = 342450000;
1925         state->CTFiltMax[9] = 378870000;
1926         state->CTFiltMax[10] = 416210000;
1927         state->CTFiltMax[11] = 456500000;
1928         state->CTFiltMax[12] = 495790000;
1929         state->CTFiltMax[13] = 534530000;
1930         state->CTFiltMax[14] = 572610000;
1931         state->CTFiltMax[15] = 598970000;
1932         state->CTFiltMax[16] = 635910000;
1933         state->CTFiltMax[17] = 672130000;
1934         state->CTFiltMax[18] = 714840000;
1935         state->CTFiltMax[19] = 739660000;
1936         state->CTFiltMax[20] = 770410000;
1937         state->CTFiltMax[21] = 814660000;
1938         state->CTFiltMax[22] = 846950000;
1939         state->CTFiltMax[23] = 867820000;
1940         state->CTFiltMax[24] = 915980000;
1941         state->CTFiltMax[25] = 947450000;
1942         state->CTFiltMax[26] = 983110000;
1943         state->CTFiltMax[27] = 1021630000;
1944         state->CTFiltMax[28] = 1061870000;
1945         state->CTFiltMax[29] = 1098330000;
1946         state->CTFiltMax[30] = 1138990000;
1947
1948         /*
1949          **   Fetch the FCU osc value and use it and the fRef value to
1950          **   scale all of the Band Max values
1951          */
1952
1953         state->reg[MT2063_REG_CTUNE_CTRL] = 0x0A;
1954         status = mt2063_write(state, MT2063_REG_CTUNE_CTRL,
1955                               &state->reg[MT2063_REG_CTUNE_CTRL], 1);
1956         if (status < 0)
1957                 return status;
1958
1959         /*  Read the ClearTune filter calibration value  */
1960         status = mt2063_read(state, MT2063_REG_FIFFC,
1961                              &state->reg[MT2063_REG_FIFFC], 1);
1962         if (status < 0)
1963                 return status;
1964
1965         fcu_osc = state->reg[MT2063_REG_FIFFC];
1966
1967         state->reg[MT2063_REG_CTUNE_CTRL] = 0x00;
1968         status = mt2063_write(state, MT2063_REG_CTUNE_CTRL,
1969                               &state->reg[MT2063_REG_CTUNE_CTRL], 1);
1970         if (status < 0)
1971                 return status;
1972
1973         /*  Adjust each of the values in the ClearTune filter cross-over table  */
1974         for (i = 0; i < 31; i++)
1975                 state->CTFiltMax[i] = (state->CTFiltMax[i] / 768) * (fcu_osc + 640);
1976
1977         status = MT2063_SoftwareShutdown(state, 1);
1978         if (status < 0)
1979                 return status;
1980         status = MT2063_ClearPowerMaskBits(state, MT2063_ALL_SD);
1981         if (status < 0)
1982                 return status;
1983
1984         state->init = true;
1985
1986         return 0;
1987 }
1988
1989 static int mt2063_get_status(struct dvb_frontend *fe, u32 *tuner_status)
1990 {
1991         struct mt2063_state *state = fe->tuner_priv;
1992         int status;
1993
1994         dprintk(2, "\n");
1995
1996         if (!state->init)
1997                 return -ENODEV;
1998
1999         *tuner_status = 0;
2000         status = mt2063_lockStatus(state);
2001         if (status < 0)
2002                 return status;
2003         if (status)
2004                 *tuner_status = TUNER_STATUS_LOCKED;
2005
2006         dprintk(1, "Tuner status: %d", *tuner_status);
2007
2008         return 0;
2009 }
2010
2011 static void mt2063_release(struct dvb_frontend *fe)
2012 {
2013         struct mt2063_state *state = fe->tuner_priv;
2014
2015         dprintk(2, "\n");
2016
2017         fe->tuner_priv = NULL;
2018         kfree(state);
2019 }
2020
2021 static int mt2063_set_analog_params(struct dvb_frontend *fe,
2022                                     struct analog_parameters *params)
2023 {
2024         struct mt2063_state *state = fe->tuner_priv;
2025         s32 pict_car;
2026         s32 pict2chanb_vsb;
2027         s32 ch_bw;
2028         s32 if_mid;
2029         s32 rcvr_mode;
2030         int status;
2031
2032         dprintk(2, "\n");
2033
2034         if (!state->init) {
2035                 status = mt2063_init(fe);
2036                 if (status < 0)
2037                         return status;
2038         }
2039
2040         switch (params->mode) {
2041         case V4L2_TUNER_RADIO:
2042                 pict_car = 38900000;
2043                 ch_bw = 8000000;
2044                 pict2chanb_vsb = -(ch_bw / 2);
2045                 rcvr_mode = MT2063_OFFAIR_ANALOG;
2046                 break;
2047         case V4L2_TUNER_ANALOG_TV:
2048                 rcvr_mode = MT2063_CABLE_ANALOG;
2049                 if (params->std & ~V4L2_STD_MN) {
2050                         pict_car = 38900000;
2051                         ch_bw = 6000000;
2052                         pict2chanb_vsb = -1250000;
2053                 } else if (params->std & V4L2_STD_PAL_G) {
2054                         pict_car = 38900000;
2055                         ch_bw = 7000000;
2056                         pict2chanb_vsb = -1250000;
2057                 } else {                /* PAL/SECAM standards */
2058                         pict_car = 38900000;
2059                         ch_bw = 8000000;
2060                         pict2chanb_vsb = -1250000;
2061                 }
2062                 break;
2063         default:
2064                 return -EINVAL;
2065         }
2066         if_mid = pict_car - (pict2chanb_vsb + (ch_bw / 2));
2067
2068         state->AS_Data.f_LO2_Step = 125000;     /* FIXME: probably 5000 for FM */
2069         state->AS_Data.f_out = if_mid;
2070         state->AS_Data.f_out_bw = ch_bw + 750000;
2071         status = MT2063_SetReceiverMode(state, rcvr_mode);
2072         if (status < 0)
2073                 return status;
2074
2075         dprintk(1, "Tuning to frequency: %d, bandwidth %d, foffset %d\n",
2076                 params->frequency, ch_bw, pict2chanb_vsb);
2077
2078         status = MT2063_Tune(state, (params->frequency + (pict2chanb_vsb + (ch_bw / 2))));
2079         if (status < 0)
2080                 return status;
2081
2082         state->frequency = params->frequency;
2083         return 0;
2084 }
2085
2086 /*
2087  * As defined on EN 300 429, the DVB-C roll-off factor is 0.15.
2088  * So, the amount of the needed bandwidth is given by:
2089  *      Bw = Symbol_rate * (1 + 0.15)
2090  * As such, the maximum symbol rate supported by 6 MHz is given by:
2091  *      max_symbol_rate = 6 MHz / 1.15 = 5217391 Bauds
2092  */
2093 #define MAX_SYMBOL_RATE_6MHz    5217391
2094
2095 static int mt2063_set_params(struct dvb_frontend *fe)
2096 {
2097         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
2098         struct mt2063_state *state = fe->tuner_priv;
2099         int status;
2100         s32 pict_car;
2101         s32 pict2chanb_vsb;
2102         s32 ch_bw;
2103         s32 if_mid;
2104         s32 rcvr_mode;
2105
2106         if (!state->init) {
2107                 status = mt2063_init(fe);
2108                 if (status < 0)
2109                         return status;
2110         }
2111
2112         dprintk(2, "\n");
2113
2114         if (c->bandwidth_hz == 0)
2115                 return -EINVAL;
2116         if (c->bandwidth_hz <= 6000000)
2117                 ch_bw = 6000000;
2118         else if (c->bandwidth_hz <= 7000000)
2119                 ch_bw = 7000000;
2120         else
2121                 ch_bw = 8000000;
2122
2123         switch (c->delivery_system) {
2124         case SYS_DVBT:
2125                 rcvr_mode = MT2063_OFFAIR_COFDM;
2126                 pict_car = 36125000;
2127                 pict2chanb_vsb = -(ch_bw / 2);
2128                 break;
2129         case SYS_DVBC_ANNEX_A:
2130         case SYS_DVBC_ANNEX_C:
2131                 rcvr_mode = MT2063_CABLE_QAM;
2132                 pict_car = 36125000;
2133                 pict2chanb_vsb = -(ch_bw / 2);
2134                 break;
2135         default:
2136                 return -EINVAL;
2137         }
2138         if_mid = pict_car - (pict2chanb_vsb + (ch_bw / 2));
2139
2140         state->AS_Data.f_LO2_Step = 125000;     /* FIXME: probably 5000 for FM */
2141         state->AS_Data.f_out = if_mid;
2142         state->AS_Data.f_out_bw = ch_bw + 750000;
2143         status = MT2063_SetReceiverMode(state, rcvr_mode);
2144         if (status < 0)
2145                 return status;
2146
2147         dprintk(1, "Tuning to frequency: %d, bandwidth %d, foffset %d\n",
2148                 c->frequency, ch_bw, pict2chanb_vsb);
2149
2150         status = MT2063_Tune(state, (c->frequency + (pict2chanb_vsb + (ch_bw / 2))));
2151
2152         if (status < 0)
2153                 return status;
2154
2155         state->frequency = c->frequency;
2156         return 0;
2157 }
2158
2159 static int mt2063_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
2160 {
2161         struct mt2063_state *state = fe->tuner_priv;
2162
2163         dprintk(2, "\n");
2164
2165         if (!state->init)
2166                 return -ENODEV;
2167
2168         *freq = state->AS_Data.f_out;
2169
2170         dprintk(1, "IF frequency: %d\n", *freq);
2171
2172         return 0;
2173 }
2174
2175 static int mt2063_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
2176 {
2177         struct mt2063_state *state = fe->tuner_priv;
2178
2179         dprintk(2, "\n");
2180
2181         if (!state->init)
2182                 return -ENODEV;
2183
2184         *bw = state->AS_Data.f_out_bw - 750000;
2185
2186         dprintk(1, "bandwidth: %d\n", *bw);
2187
2188         return 0;
2189 }
2190
2191 static const struct dvb_tuner_ops mt2063_ops = {
2192         .info = {
2193                  .name = "MT2063 Silicon Tuner",
2194                  .frequency_min_hz  =  45 * MHz,
2195                  .frequency_max_hz  = 865 * MHz,
2196          },
2197
2198         .init = mt2063_init,
2199         .sleep = MT2063_Sleep,
2200         .get_status = mt2063_get_status,
2201         .set_analog_params = mt2063_set_analog_params,
2202         .set_params    = mt2063_set_params,
2203         .get_if_frequency = mt2063_get_if_frequency,
2204         .get_bandwidth = mt2063_get_bandwidth,
2205         .release = mt2063_release,
2206 };
2207
2208 struct dvb_frontend *mt2063_attach(struct dvb_frontend *fe,
2209                                    struct mt2063_config *config,
2210                                    struct i2c_adapter *i2c)
2211 {
2212         struct mt2063_state *state = NULL;
2213
2214         dprintk(2, "\n");
2215
2216         state = kzalloc(sizeof(struct mt2063_state), GFP_KERNEL);
2217         if (!state)
2218                 return NULL;
2219
2220         state->config = config;
2221         state->i2c = i2c;
2222         state->frontend = fe;
2223         state->reference = config->refclock / 1000;     /* kHz */
2224         fe->tuner_priv = state;
2225         fe->ops.tuner_ops = mt2063_ops;
2226
2227         printk(KERN_INFO "%s: Attaching MT2063\n", __func__);
2228         return fe;
2229 }
2230 EXPORT_SYMBOL_GPL(mt2063_attach);
2231
2232 #if 0
2233 /*
2234  * Ancillary routines visible outside mt2063
2235  * FIXME: Remove them in favor of using standard tuner callbacks
2236  */
2237 static int tuner_MT2063_SoftwareShutdown(struct dvb_frontend *fe)
2238 {
2239         struct mt2063_state *state = fe->tuner_priv;
2240         int err = 0;
2241
2242         dprintk(2, "\n");
2243
2244         err = MT2063_SoftwareShutdown(state, 1);
2245         if (err < 0)
2246                 printk(KERN_ERR "%s: Couldn't shutdown\n", __func__);
2247
2248         return err;
2249 }
2250
2251 static int tuner_MT2063_ClearPowerMaskBits(struct dvb_frontend *fe)
2252 {
2253         struct mt2063_state *state = fe->tuner_priv;
2254         int err = 0;
2255
2256         dprintk(2, "\n");
2257
2258         err = MT2063_ClearPowerMaskBits(state, MT2063_ALL_SD);
2259         if (err < 0)
2260                 printk(KERN_ERR "%s: Invalid parameter\n", __func__);
2261
2262         return err;
2263 }
2264 #endif
2265
2266 MODULE_AUTHOR("Mauro Carvalho Chehab");
2267 MODULE_DESCRIPTION("MT2063 Silicon tuner");
2268 MODULE_LICENSE("GPL");