drivers/media/common/tuners/xc4000.c

   1 /*
   2  *  Driver for Xceive XC4000 "QAM/8VSB single chip tuner"
   3  *
   4  *  Copyright (c) 2007 Xceive Corporation
   5  *  Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
   6  *  Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
   7  *  Copyright (c) 2009 Davide Ferri <d.ferri@zero11.it>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/videodev2.h>
  28 #include <linux/delay.h>
  29 #include <linux/dvb/frontend.h>
  30 #include <linux/i2c.h>
  31 #include <linux/mutex.h>
  32 #include <asm/unaligned.h>
  33
  34 #include "dvb_frontend.h"
  35
  36 #include "xc4000.h"
  37 #include "tuner-i2c.h"
  38 #include "tuner-xc2028-types.h"
  39
  40 static int debug;
  41 module_param(debug, int, 0644);
  42 MODULE_PARM_DESC(debug, "\n\t\tDebugging level (0 to 2, default: 0 (off)).");
  43
  44 static int no_poweroff;
  45 module_param(no_poweroff, int, 0644);
  46 MODULE_PARM_DESC(no_poweroff, "\n\t\t1: keep device energized and with tuner "
  47         "ready all the times.\n"
  48         "\t\tFaster, but consumes more power and keeps the device hotter.\n"
  49         "\t\t2: powers device off when not used.\n"
  50         "\t\t0 (default): use device-specific default mode.");
  51
  52 #define XC4000_AUDIO_STD_B               1
  53 #define XC4000_AUDIO_STD_A2              2
  54 #define XC4000_AUDIO_STD_K3              4
  55 #define XC4000_AUDIO_STD_L               8
  56 #define XC4000_AUDIO_STD_INPUT1         16
  57 #define XC4000_AUDIO_STD_MONO           32
  58
  59 static int audio_std;
  60 module_param(audio_std, int, 0644);
  61 MODULE_PARM_DESC(audio_std, "\n\t\tAudio standard. XC4000 audio decoder "
  62         "explicitly needs to know\n"
  63         "\t\twhat audio standard is needed for some video standards with\n"
  64         "\t\taudio A2 or NICAM.\n"
  65         "\t\tThe valid settings are a sum of:\n"
  66         "\t\t 1: use NICAM/B or A2/B instead of NICAM/A or A2/A\n"
  67         "\t\t 2: use A2 instead of NICAM or BTSC\n"
  68         "\t\t 4: use SECAM/K3 instead of K1\n"
  69         "\t\t 8: use PAL-D/K audio for SECAM-D/K\n"
  70         "\t\t16: use FM radio input 1 instead of input 2\n"
  71         "\t\t32: use mono audio (the lower three bits are ignored)");
  72
  73 #define XC4000_DEFAULT_FIRMWARE "xc4000.fw"
  74
  75 static char firmware_name[30];
  76 module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
  77 MODULE_PARM_DESC(firmware_name, "\n\t\tFirmware file name. Allows overriding "
  78         "the default firmware\n"
  79         "\t\tname.");
  80
  81 static DEFINE_MUTEX(xc4000_list_mutex);
  82 static LIST_HEAD(hybrid_tuner_instance_list);
  83
  84 #define dprintk(level, fmt, arg...) if (debug >= level) \
  85         printk(KERN_INFO "%s: " fmt, "xc4000", ## arg)
  86
  87 /* struct for storing firmware table */
  88 struct firmware_description {
  89         unsigned int  type;
  90         v4l2_std_id   id;
  91         __u16         int_freq;
  92         unsigned char *ptr;
  93         unsigned int  size;
  94 };
  95
  96 struct firmware_properties {
  97         unsigned int    type;
  98         v4l2_std_id     id;
  99         v4l2_std_id     std_req;
 100         __u16           int_freq;
 101         unsigned int    scode_table;
 102         int             scode_nr;
 103 };
 104
 105 struct xc4000_priv {
 106         struct tuner_i2c_props i2c_props;
 107         struct list_head hybrid_tuner_instance_list;
 108         struct firmware_description *firm;
 109         int     firm_size;
 110         __u16   firm_version;
 111         u32     if_khz;
 112         u32     freq_hz;
 113         u32     bandwidth;
 114         u8      video_standard;
 115         u8      rf_mode;
 116         u8      card_type;
 117         u8      ignore_i2c_write_errors;
 118  /*     struct xc2028_ctrl      ctrl; */
 119         struct firmware_properties cur_fw;
 120         __u16   hwmodel;
 121         __u16   hwvers;
 122         struct mutex    lock;
 123 };
 124
 125 /* Misc Defines */
 126 #define MAX_TV_STANDARD                 24
 127 #define XC_MAX_I2C_WRITE_LENGTH         64
 128 #define XC_POWERED_DOWN                 0x80000000U
 129
 130 /* Signal Types */
 131 #define XC_RF_MODE_AIR                  0
 132 #define XC_RF_MODE_CABLE                1
 133
 134 /* Result codes */
 135 #define XC_RESULT_SUCCESS               0
 136 #define XC_RESULT_RESET_FAILURE         1
 137 #define XC_RESULT_I2C_WRITE_FAILURE     2
 138 #define XC_RESULT_I2C_READ_FAILURE      3
 139 #define XC_RESULT_OUT_OF_RANGE          5
 140
 141 /* Product id */
 142 #define XC_PRODUCT_ID_FW_NOT_LOADED     0x2000
 143 #define XC_PRODUCT_ID_FW_LOADED 0x0FA0
 144
 145 /* Registers (Write-only) */
 146 #define XREG_INIT         0x00
 147 #define XREG_VIDEO_MODE   0x01
 148 #define XREG_AUDIO_MODE   0x02
 149 #define XREG_RF_FREQ      0x03
 150 #define XREG_D_CODE       0x04
 151 #define XREG_DIRECTSITTING_MODE 0x05
 152 #define XREG_SEEK_MODE    0x06
 153 #define XREG_POWER_DOWN   0x08
 154 #define XREG_SIGNALSOURCE 0x0A
 155 #define XREG_SMOOTHEDCVBS 0x0E
 156 #define XREG_AMPLITUDE    0x10
 157
 158 /* Registers (Read-only) */
 159 #define XREG_ADC_ENV      0x00
 160 #define XREG_QUALITY      0x01
 161 #define XREG_FRAME_LINES  0x02
 162 #define XREG_HSYNC_FREQ   0x03
 163 #define XREG_LOCK         0x04
 164 #define XREG_FREQ_ERROR   0x05
 165 #define XREG_SNR          0x06
 166 #define XREG_VERSION      0x07
 167 #define XREG_PRODUCT_ID   0x08
 168
 169 /*
 170    Basic firmware description. This will remain with
 171    the driver for documentation purposes.
 172
 173    This represents an I2C firmware file encoded as a
 174    string of unsigned char. Format is as follows:
 175
 176    char[0  ]=len0_MSB  -> len = len_MSB * 256 + len_LSB
 177    char[1  ]=len0_LSB  -> length of first write transaction
 178    char[2  ]=data0 -> first byte to be sent
 179    char[3  ]=data1
 180    char[4  ]=data2
 181    char[   ]=...
 182    char[M  ]=dataN  -> last byte to be sent
 183    char[M+1]=len1_MSB  -> len = len_MSB * 256 + len_LSB
 184    char[M+2]=len1_LSB  -> length of second write transaction
 185    char[M+3]=data0
 186    char[M+4]=data1
 187    ...
 188    etc.
 189
 190    The [len] value should be interpreted as follows:
 191
 192    len= len_MSB _ len_LSB
 193    len=1111_1111_1111_1111   : End of I2C_SEQUENCE
 194    len=0000_0000_0000_0000   : Reset command: Do hardware reset
 195    len=0NNN_NNNN_NNNN_NNNN   : Normal transaction: number of bytes = {1:32767)
 196    len=1WWW_WWWW_WWWW_WWWW   : Wait command: wait for {1:32767} ms
 197
 198    For the RESET and WAIT commands, the two following bytes will contain
 199    immediately the length of the following transaction.
 200 */
 201
 202 struct XC_TV_STANDARD {
 203         const char  *Name;
 204         u16         AudioMode;
 205         u16         VideoMode;
 206         u16         int_freq;
 207 };
 208
 209 /* Tuner standards */
 210 #define XC4000_MN_NTSC_PAL_BTSC         0
 211 #define XC4000_MN_NTSC_PAL_A2           1
 212 #define XC4000_MN_NTSC_PAL_EIAJ         2
 213 #define XC4000_MN_NTSC_PAL_Mono         3
 214 #define XC4000_BG_PAL_A2                4
 215 #define XC4000_BG_PAL_NICAM             5
 216 #define XC4000_BG_PAL_MONO              6
 217 #define XC4000_I_PAL_NICAM              7
 218 #define XC4000_I_PAL_NICAM_MONO         8
 219 #define XC4000_DK_PAL_A2                9
 220 #define XC4000_DK_PAL_NICAM             10
 221 #define XC4000_DK_PAL_MONO              11
 222 #define XC4000_DK_SECAM_A2DK1           12
 223 #define XC4000_DK_SECAM_A2LDK3          13
 224 #define XC4000_DK_SECAM_A2MONO          14
 225 #define XC4000_DK_SECAM_NICAM           15
 226 #define XC4000_L_SECAM_NICAM            16
 227 #define XC4000_LC_SECAM_NICAM           17
 228 #define XC4000_DTV6                     18
 229 #define XC4000_DTV8                     19
 230 #define XC4000_DTV7_8                   20
 231 #define XC4000_DTV7                     21
 232 #define XC4000_FM_Radio_INPUT2          22
 233 #define XC4000_FM_Radio_INPUT1          23
 234
 235 static struct XC_TV_STANDARD XC4000_Standard[MAX_TV_STANDARD] = {
 236         {"M/N-NTSC/PAL-BTSC",   0x0000, 0x80A0, 4500},
 237         {"M/N-NTSC/PAL-A2",     0x0000, 0x80A0, 4600},
 238         {"M/N-NTSC/PAL-EIAJ",   0x0040, 0x80A0, 4500},
 239         {"M/N-NTSC/PAL-Mono",   0x0078, 0x80A0, 4500},
 240         {"B/G-PAL-A2",          0x0000, 0x8159, 5640},
 241         {"B/G-PAL-NICAM",       0x0004, 0x8159, 5740},
 242         {"B/G-PAL-MONO",        0x0078, 0x8159, 5500},
 243         {"I-PAL-NICAM",         0x0080, 0x8049, 6240},
 244         {"I-PAL-NICAM-MONO",    0x0078, 0x8049, 6000},
 245         {"D/K-PAL-A2",          0x0000, 0x8049, 6380},
 246         {"D/K-PAL-NICAM",       0x0080, 0x8049, 6200},
 247         {"D/K-PAL-MONO",        0x0078, 0x8049, 6500},
 248         {"D/K-SECAM-A2 DK1",    0x0000, 0x8049, 6340},
 249         {"D/K-SECAM-A2 L/DK3",  0x0000, 0x8049, 6000},
 250         {"D/K-SECAM-A2 MONO",   0x0078, 0x8049, 6500},
 251         {"D/K-SECAM-NICAM",     0x0080, 0x8049, 6200},
 252         {"L-SECAM-NICAM",       0x8080, 0x0009, 6200},
 253         {"L'-SECAM-NICAM",      0x8080, 0x4009, 6200},
 254         {"DTV6",                0x00C0, 0x8002,    0},
 255         {"DTV8",                0x00C0, 0x800B,    0},
 256         {"DTV7/8",              0x00C0, 0x801B,    0},
 257         {"DTV7",                0x00C0, 0x8007,    0},
 258         {"FM Radio-INPUT2",     0x0008, 0x9800,10700},
 259         {"FM Radio-INPUT1",     0x0008, 0x9000,10700}
 260 };
 261
 262 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val);
 263 static int xc4000_TunerReset(struct dvb_frontend *fe);
 264 static void xc_debug_dump(struct xc4000_priv *priv);
 265
 266 static int xc_send_i2c_data(struct xc4000_priv *priv, u8 *buf, int len)
 267 {
 268         struct i2c_msg msg = { .addr = priv->i2c_props.addr,
 269                                .flags = 0, .buf = buf, .len = len };
 270         if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
 271                 if (priv->ignore_i2c_write_errors == 0) {
 272                         printk(KERN_ERR "xc4000: I2C write failed (len=%i)\n",
 273                                len);
 274                         if (len == 4) {
 275                                 printk("bytes %02x %02x %02x %02x\n", buf[0],
 276                                        buf[1], buf[2], buf[3]);
 277                         }
 278                         return XC_RESULT_I2C_WRITE_FAILURE;
 279                 }
 280         }
 281         return XC_RESULT_SUCCESS;
 282 }
 283
 284 static void xc_wait(int wait_ms)
 285 {
 286         msleep(wait_ms);
 287 }
 288
 289 static int xc4000_TunerReset(struct dvb_frontend *fe)
 290 {
 291         struct xc4000_priv *priv = fe->tuner_priv;
 292         int ret;
 293
 294         dprintk(1, "%s()\n", __func__);
 295
 296         if (fe->callback) {
 297                 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
 298                                            fe->dvb->priv :
 299                                            priv->i2c_props.adap->algo_data,
 300                                            DVB_FRONTEND_COMPONENT_TUNER,
 301                                            XC4000_TUNER_RESET, 0);
 302                 if (ret) {
 303                         printk(KERN_ERR "xc4000: reset failed\n");
 304                         return XC_RESULT_RESET_FAILURE;
 305                 }
 306         } else {
 307                 printk(KERN_ERR "xc4000: no tuner reset callback function, fatal\n");
 308                 return XC_RESULT_RESET_FAILURE;
 309         }
 310         return XC_RESULT_SUCCESS;
 311 }
 312
 313 static int xc_write_reg(struct xc4000_priv *priv, u16 regAddr, u16 i2cData)
 314 {
 315         u8 buf[4];
 316         int result;
 317
 318         buf[0] = (regAddr >> 8) & 0xFF;
 319         buf[1] = regAddr & 0xFF;
 320         buf[2] = (i2cData >> 8) & 0xFF;
 321         buf[3] = i2cData & 0xFF;
 322         result = xc_send_i2c_data(priv, buf, 4);
 323
 324         return result;
 325 }
 326
 327 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
 328 {
 329         struct xc4000_priv *priv = fe->tuner_priv;
 330
 331         int i, nbytes_to_send, result;
 332         unsigned int len, pos, index;
 333         u8 buf[XC_MAX_I2C_WRITE_LENGTH];
 334
 335         index = 0;
 336         while ((i2c_sequence[index] != 0xFF) ||
 337                 (i2c_sequence[index + 1] != 0xFF)) {
 338                 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
 339                 if (len == 0x0000) {
 340                         /* RESET command */
 341                         index += 2;
 342 #if 0                   /* not needed, as already called by check_firmware() */
 343                         result = xc4000_TunerReset(fe);
 344                         if (result != XC_RESULT_SUCCESS)
 345                                 return result;
 346 #endif
 347                 } else if (len & 0x8000) {
 348                         /* WAIT command */
 349                         xc_wait(len & 0x7FFF);
 350                         index += 2;
 351                 } else {
 352                         /* Send i2c data whilst ensuring individual transactions
 353                          * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
 354                          */
 355                         index += 2;
 356                         buf[0] = i2c_sequence[index];
 357                         buf[1] = i2c_sequence[index + 1];
 358                         pos = 2;
 359                         while (pos < len) {
 360                                 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
 361                                         nbytes_to_send =
 362                                                 XC_MAX_I2C_WRITE_LENGTH;
 363                                 else
 364                                         nbytes_to_send = (len - pos + 2);
 365                                 for (i = 2; i < nbytes_to_send; i++) {
 366                                         buf[i] = i2c_sequence[index + pos +
 367                                                 i - 2];
 368                                 }
 369                                 result = xc_send_i2c_data(priv, buf,
 370                                         nbytes_to_send);
 371
 372                                 if (result != XC_RESULT_SUCCESS)
 373                                         return result;
 374
 375                                 pos += nbytes_to_send - 2;
 376                         }
 377                         index += len;
 378                 }
 379         }
 380         return XC_RESULT_SUCCESS;
 381 }
 382
 383 static int xc_SetTVStandard(struct xc4000_priv *priv,
 384         u16 VideoMode, u16 AudioMode)
 385 {
 386         int ret;
 387         dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
 388         dprintk(1, "%s() Standard = %s\n",
 389                 __func__,
 390                 XC4000_Standard[priv->video_standard].Name);
 391
 392         /* Don't complain when the request fails because of i2c stretching */
 393         priv->ignore_i2c_write_errors = 1;
 394
 395         ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
 396         if (ret == XC_RESULT_SUCCESS)
 397                 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
 398
 399         priv->ignore_i2c_write_errors = 0;
 400
 401         return ret;
 402 }
 403
 404 static int xc_SetSignalSource(struct xc4000_priv *priv, u16 rf_mode)
 405 {
 406         dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
 407                 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
 408
 409         if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
 410                 rf_mode = XC_RF_MODE_CABLE;
 411                 printk(KERN_ERR
 412                         "%s(), Invalid mode, defaulting to CABLE",
 413                         __func__);
 414         }
 415         return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
 416 }
 417
 418 static const struct dvb_tuner_ops xc4000_tuner_ops;
 419
 420 static int xc_set_RF_frequency(struct xc4000_priv *priv, u32 freq_hz)
 421 {
 422         u16 freq_code;
 423
 424         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 425
 426         if ((freq_hz > xc4000_tuner_ops.info.frequency_max) ||
 427                 (freq_hz < xc4000_tuner_ops.info.frequency_min))
 428                 return XC_RESULT_OUT_OF_RANGE;
 429
 430         freq_code = (u16)(freq_hz / 15625);
 431
 432         /* WAS: Starting in firmware version 1.1.44, Xceive recommends using the
 433            FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
 434            only be used for fast scanning for channel lock) */
 435         return xc_write_reg(priv, XREG_RF_FREQ, freq_code); /* WAS: XREG_FINERFREQ */
 436 }
 437
 438 static int xc_get_ADC_Envelope(struct xc4000_priv *priv, u16 *adc_envelope)
 439 {
 440         return xc4000_readreg(priv, XREG_ADC_ENV, adc_envelope);
 441 }
 442
 443 static int xc_get_frequency_error(struct xc4000_priv *priv, u32 *freq_error_hz)
 444 {
 445         int result;
 446         u16 regData;
 447         u32 tmp;
 448
 449         result = xc4000_readreg(priv, XREG_FREQ_ERROR, &regData);
 450         if (result != XC_RESULT_SUCCESS)
 451                 return result;
 452
 453         tmp = (u32)regData & 0xFFFFU;
 454         tmp = (tmp < 0x8000U ? tmp : 0x10000U - tmp);
 455         (*freq_error_hz) = tmp * 15625;
 456         return result;
 457 }
 458
 459 static int xc_get_lock_status(struct xc4000_priv *priv, u16 *lock_status)
 460 {
 461         return xc4000_readreg(priv, XREG_LOCK, lock_status);
 462 }
 463
 464 static int xc_get_version(struct xc4000_priv *priv,
 465         u8 *hw_majorversion, u8 *hw_minorversion,
 466         u8 *fw_majorversion, u8 *fw_minorversion)
 467 {
 468         u16 data;
 469         int result;
 470
 471         result = xc4000_readreg(priv, XREG_VERSION, &data);
 472         if (result != XC_RESULT_SUCCESS)
 473                 return result;
 474
 475         (*hw_majorversion) = (data >> 12) & 0x0F;
 476         (*hw_minorversion) = (data >>  8) & 0x0F;
 477         (*fw_majorversion) = (data >>  4) & 0x0F;
 478         (*fw_minorversion) = data & 0x0F;
 479
 480         return 0;
 481 }
 482
 483 static int xc_get_hsync_freq(struct xc4000_priv *priv, u32 *hsync_freq_hz)
 484 {
 485         u16 regData;
 486         int result;
 487
 488         result = xc4000_readreg(priv, XREG_HSYNC_FREQ, &regData);
 489         if (result != XC_RESULT_SUCCESS)
 490                 return result;
 491
 492         (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
 493         return result;
 494 }
 495
 496 static int xc_get_frame_lines(struct xc4000_priv *priv, u16 *frame_lines)
 497 {
 498         return xc4000_readreg(priv, XREG_FRAME_LINES, frame_lines);
 499 }
 500
 501 static int xc_get_quality(struct xc4000_priv *priv, u16 *quality)
 502 {
 503         return xc4000_readreg(priv, XREG_QUALITY, quality);
 504 }
 505
 506 static u16 WaitForLock(struct xc4000_priv *priv)
 507 {
 508         u16 lockState = 0;
 509         int watchDogCount = 40;
 510
 511         while ((lockState == 0) && (watchDogCount > 0)) {
 512                 xc_get_lock_status(priv, &lockState);
 513                 if (lockState != 1) {
 514                         xc_wait(5);
 515                         watchDogCount--;
 516                 }
 517         }
 518         return lockState;
 519 }
 520
 521 static int xc_tune_channel(struct xc4000_priv *priv, u32 freq_hz)
 522 {
 523         int     found = 1;
 524         int     result;
 525
 526         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 527
 528         /* Don't complain when the request fails because of i2c stretching */
 529         priv->ignore_i2c_write_errors = 1;
 530         result = xc_set_RF_frequency(priv, freq_hz);
 531         priv->ignore_i2c_write_errors = 0;
 532
 533         if (result != XC_RESULT_SUCCESS)
 534                 return 0;
 535
 536         /* wait for lock only in analog TV mode */
 537         if ((priv->cur_fw.type & (FM | DTV6 | DTV7 | DTV78 | DTV8)) == 0) {
 538                 if (WaitForLock(priv) != 1)
 539                         found = 0;
 540         }
 541
 542         /* Wait for stats to stabilize.
 543          * Frame Lines needs two frame times after initial lock
 544          * before it is valid.
 545          */
 546         xc_wait(debug ? 100 : 10);
 547
 548         if (debug)
 549                 xc_debug_dump(priv);
 550
 551         return found;
 552 }
 553
 554 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val)
 555 {
 556         u8 buf[2] = { reg >> 8, reg & 0xff };
 557         u8 bval[2] = { 0, 0 };
 558         struct i2c_msg msg[2] = {
 559                 { .addr = priv->i2c_props.addr,
 560                         .flags = 0, .buf = &buf[0], .len = 2 },
 561                 { .addr = priv->i2c_props.addr,
 562                         .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
 563         };
 564
 565         if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
 566                 printk(KERN_WARNING "xc4000: I2C read failed\n");
 567                 return -EREMOTEIO;
 568         }
 569
 570         *val = (bval[0] << 8) | bval[1];
 571         return XC_RESULT_SUCCESS;
 572 }
 573
 574 #define dump_firm_type(t)       dump_firm_type_and_int_freq(t, 0)
 575 static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq)
 576 {
 577          if (type & BASE)
 578                 printk("BASE ");
 579          if (type & INIT1)
 580                 printk("INIT1 ");
 581          if (type & F8MHZ)
 582                 printk("F8MHZ ");
 583          if (type & MTS)
 584                 printk("MTS ");
 585          if (type & D2620)
 586                 printk("D2620 ");
 587          if (type & D2633)
 588                 printk("D2633 ");
 589          if (type & DTV6)
 590                 printk("DTV6 ");
 591          if (type & QAM)
 592                 printk("QAM ");
 593          if (type & DTV7)
 594                 printk("DTV7 ");
 595          if (type & DTV78)
 596                 printk("DTV78 ");
 597          if (type & DTV8)
 598                 printk("DTV8 ");
 599          if (type & FM)
 600                 printk("FM ");
 601          if (type & INPUT1)
 602                 printk("INPUT1 ");
 603          if (type & LCD)
 604                 printk("LCD ");
 605          if (type & NOGD)
 606                 printk("NOGD ");
 607          if (type & MONO)
 608                 printk("MONO ");
 609          if (type & ATSC)
 610                 printk("ATSC ");
 611          if (type & IF)
 612                 printk("IF ");
 613          if (type & LG60)
 614                 printk("LG60 ");
 615          if (type & ATI638)
 616                 printk("ATI638 ");
 617          if (type & OREN538)
 618                 printk("OREN538 ");
 619          if (type & OREN36)
 620                 printk("OREN36 ");
 621          if (type & TOYOTA388)
 622                 printk("TOYOTA388 ");
 623          if (type & TOYOTA794)
 624                 printk("TOYOTA794 ");
 625          if (type & DIBCOM52)
 626                 printk("DIBCOM52 ");
 627          if (type & ZARLINK456)
 628                 printk("ZARLINK456 ");
 629          if (type & CHINA)
 630                 printk("CHINA ");
 631          if (type & F6MHZ)
 632                 printk("F6MHZ ");
 633          if (type & INPUT2)
 634                 printk("INPUT2 ");
 635          if (type & SCODE)
 636                 printk("SCODE ");
 637          if (type & HAS_IF)
 638                 printk("HAS_IF_%d ", int_freq);
 639 }
 640
 641 static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
 642                          v4l2_std_id *id)
 643 {
 644         struct xc4000_priv *priv = fe->tuner_priv;
 645         int             i, best_i = -1;
 646         unsigned int    best_nr_diffs = 255U;
 647
 648         if (!priv->firm) {
 649                 printk("Error! firmware not loaded\n");
 650                 return -EINVAL;
 651         }
 652
 653         if (((type & ~SCODE) == 0) && (*id == 0))
 654                 *id = V4L2_STD_PAL;
 655
 656         /* Seek for generic video standard match */
 657         for (i = 0; i < priv->firm_size; i++) {
 658                 v4l2_std_id     id_diff_mask =
 659                         (priv->firm[i].id ^ (*id)) & (*id);
 660                 unsigned int    type_diff_mask =
 661                         (priv->firm[i].type ^ type)
 662                         & (BASE_TYPES | DTV_TYPES | LCD | NOGD | MONO | SCODE);
 663                 unsigned int    nr_diffs;
 664
 665                 if (type_diff_mask
 666                     & (BASE | INIT1 | FM | DTV6 | DTV7 | DTV78 | DTV8 | SCODE))
 667                         continue;
 668
 669                 nr_diffs = hweight64(id_diff_mask) + hweight32(type_diff_mask);
 670                 if (!nr_diffs)  /* Supports all the requested standards */
 671                         goto found;
 672
 673                 if (nr_diffs < best_nr_diffs) {
 674                         best_nr_diffs = nr_diffs;
 675                         best_i = i;
 676                 }
 677         }
 678
 679         /* FIXME: Would make sense to seek for type "hint" match ? */
 680         if (best_i < 0) {
 681                 i = -ENOENT;
 682                 goto ret;
 683         }
 684
 685         if (best_nr_diffs > 0U) {
 686                 printk("Selecting best matching firmware (%u bits differ) for "
 687                        "type=", best_nr_diffs);
 688                 printk("(%x), id %016llx:\n", type, (unsigned long long)*id);
 689                 i = best_i;
 690         }
 691
 692 found:
 693         *id = priv->firm[i].id;
 694
 695 ret:
 696         if (debug) {
 697                 printk("%s firmware for type=", (i < 0) ? "Can't find" :
 698                        "Found");
 699                 dump_firm_type(type);
 700                 printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
 701         }
 702         return i;
 703 }
 704
 705 static int load_firmware(struct dvb_frontend *fe, unsigned int type,
 706                          v4l2_std_id *id)
 707 {
 708         struct xc4000_priv *priv = fe->tuner_priv;
 709         int                pos, rc;
 710         unsigned char      *p;
 711
 712         pos = seek_firmware(fe, type, id);
 713         if (pos < 0)
 714                 return pos;
 715
 716         p = priv->firm[pos].ptr;
 717
 718         /* Don't complain when the request fails because of i2c stretching */
 719         priv->ignore_i2c_write_errors = 1;
 720
 721         rc = xc_load_i2c_sequence(fe, p);
 722
 723         priv->ignore_i2c_write_errors = 0;
 724
 725         return rc;
 726 }
 727
 728 static int xc4000_fwupload(struct dvb_frontend *fe)
 729 {
 730         struct xc4000_priv *priv = fe->tuner_priv;
 731         const struct firmware *fw   = NULL;
 732         const unsigned char   *p, *endp;
 733         int                   rc = 0;
 734         int                   n, n_array;
 735         char                  name[33];
 736         const char            *fname;
 737
 738         if (firmware_name[0] != '\0')
 739                 fname = firmware_name;
 740         else
 741                 fname = XC4000_DEFAULT_FIRMWARE;
 742
 743         printk("Reading firmware %s\n",  fname);
 744         rc = request_firmware(&fw, fname, priv->i2c_props.adap->dev.parent);
 745         if (rc < 0) {
 746                 if (rc == -ENOENT)
 747                         printk("Error: firmware %s not found.\n",
 748                                    fname);
 749                 else
 750                         printk("Error %d while requesting firmware %s \n",
 751                                    rc, fname);
 752
 753                 return rc;
 754         }
 755         p = fw->data;
 756         endp = p + fw->size;
 757
 758         if (fw->size < sizeof(name) - 1 + 2 + 2) {
 759                 printk("Error: firmware file %s has invalid size!\n",
 760                        fname);
 761                 goto corrupt;
 762         }
 763
 764         memcpy(name, p, sizeof(name) - 1);
 765         name[sizeof(name) - 1] = 0;
 766         p += sizeof(name) - 1;
 767
 768         priv->firm_version = get_unaligned_le16(p);
 769         p += 2;
 770
 771         n_array = get_unaligned_le16(p);
 772         p += 2;
 773
 774         dprintk(1, "Loading %d firmware images from %s, type: %s, ver %d.%d\n",
 775                 n_array, fname, name,
 776                 priv->firm_version >> 8, priv->firm_version & 0xff);
 777
 778         priv->firm = kzalloc(sizeof(*priv->firm) * n_array, GFP_KERNEL);
 779         if (priv->firm == NULL) {
 780                 printk("Not enough memory to load firmware file.\n");
 781                 rc = -ENOMEM;
 782                 goto err;
 783         }
 784         priv->firm_size = n_array;
 785
 786         n = -1;
 787         while (p < endp) {
 788                 __u32 type, size;
 789                 v4l2_std_id id;
 790                 __u16 int_freq = 0;
 791
 792                 n++;
 793                 if (n >= n_array) {
 794                         printk("More firmware images in file than "
 795                                "were expected!\n");
 796                         goto corrupt;
 797                 }
 798
 799                 /* Checks if there's enough bytes to read */
 800                 if (endp - p < sizeof(type) + sizeof(id) + sizeof(size))
 801                         goto header;
 802
 803                 type = get_unaligned_le32(p);
 804                 p += sizeof(type);
 805
 806                 id = get_unaligned_le64(p);
 807                 p += sizeof(id);
 808
 809                 if (type & HAS_IF) {
 810                         int_freq = get_unaligned_le16(p);
 811                         p += sizeof(int_freq);
 812                         if (endp - p < sizeof(size))
 813                                 goto header;
 814                 }
 815
 816                 size = get_unaligned_le32(p);
 817                 p += sizeof(size);
 818
 819                 if (!size || size > endp - p) {
 820                         printk("Firmware type (%x), id %llx is corrupted "
 821                                "(size=%d, expected %d)\n",
 822                                type, (unsigned long long)id,
 823                                (unsigned)(endp - p), size);
 824                         goto corrupt;
 825                 }
 826
 827                 priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);
 828                 if (priv->firm[n].ptr == NULL) {
 829                         printk("Not enough memory to load firmware file.\n");
 830                         rc = -ENOMEM;
 831                         goto err;
 832                 }
 833
 834                 if (debug) {
 835                         printk("Reading firmware type ");
 836                         dump_firm_type_and_int_freq(type, int_freq);
 837                         printk("(%x), id %llx, size=%d.\n",
 838                                type, (unsigned long long)id, size);
 839                 }
 840
 841                 memcpy(priv->firm[n].ptr, p, size);
 842                 priv->firm[n].type = type;
 843                 priv->firm[n].id   = id;
 844                 priv->firm[n].size = size;
 845                 priv->firm[n].int_freq = int_freq;
 846
 847                 p += size;
 848         }
 849
 850         if (n + 1 != priv->firm_size) {
 851                 printk("Firmware file is incomplete!\n");
 852                 goto corrupt;
 853         }
 854
 855         goto done;
 856
 857 header:
 858         printk("Firmware header is incomplete!\n");
 859 corrupt:
 860         rc = -EINVAL;
 861         printk("Error: firmware file is corrupted!\n");
 862
 863 err:
 864         printk("Releasing partially loaded firmware file.\n");
 865
 866 done:
 867         release_firmware(fw);
 868         if (rc == 0)
 869                 dprintk(1, "Firmware files loaded.\n");
 870
 871         return rc;
 872 }
 873
 874 static int load_scode(struct dvb_frontend *fe, unsigned int type,
 875                          v4l2_std_id *id, __u16 int_freq, int scode)
 876 {
 877         struct xc4000_priv *priv = fe->tuner_priv;
 878         int             pos, rc;
 879         unsigned char   *p;
 880         u8              scode_buf[13];
 881         u8              indirect_mode[5];
 882
 883         dprintk(1, "%s called int_freq=%d\n", __func__, int_freq);
 884
 885         if (!int_freq) {
 886                 pos = seek_firmware(fe, type, id);
 887                 if (pos < 0)
 888                         return pos;
 889         } else {
 890                 for (pos = 0; pos < priv->firm_size; pos++) {
 891                         if ((priv->firm[pos].int_freq == int_freq) &&
 892                             (priv->firm[pos].type & HAS_IF))
 893                                 break;
 894                 }
 895                 if (pos == priv->firm_size)
 896                         return -ENOENT;
 897         }
 898
 899         p = priv->firm[pos].ptr;
 900
 901         if (priv->firm[pos].size != 12 * 16 || scode >= 16)
 902                 return -EINVAL;
 903         p += 12 * scode;
 904
 905         tuner_info("Loading SCODE for type=");
 906         dump_firm_type_and_int_freq(priv->firm[pos].type,
 907                                     priv->firm[pos].int_freq);
 908         printk("(%x), id %016llx.\n", priv->firm[pos].type,
 909                (unsigned long long)*id);
 910
 911         scode_buf[0] = 0x00;
 912         memcpy(&scode_buf[1], p, 12);
 913
 914         /* Enter direct-mode */
 915         rc = xc_write_reg(priv, XREG_DIRECTSITTING_MODE, 0);
 916         if (rc < 0) {
 917                 printk("failed to put device into direct mode!\n");
 918                 return -EIO;
 919         }
 920
 921         rc = xc_send_i2c_data(priv, scode_buf, 13);
 922         if (rc != XC_RESULT_SUCCESS) {
 923                 /* Even if the send failed, make sure we set back to indirect
 924                    mode */
 925                 printk("Failed to set scode %d\n", rc);
 926         }
 927
 928         /* Switch back to indirect-mode */
 929         memset(indirect_mode, 0, sizeof(indirect_mode));
 930         indirect_mode[4] = 0x88;
 931         xc_send_i2c_data(priv, indirect_mode, sizeof(indirect_mode));
 932         msleep(10);
 933
 934         return 0;
 935 }
 936
 937 static int check_firmware(struct dvb_frontend *fe, unsigned int type,
 938                           v4l2_std_id std, __u16 int_freq)
 939 {
 940         struct xc4000_priv         *priv = fe->tuner_priv;
 941         struct firmware_properties new_fw;
 942         int                        rc = 0, is_retry = 0;
 943         u16                        version = 0, hwmodel;
 944         v4l2_std_id                std0;
 945         u8                         hw_major, hw_minor, fw_major, fw_minor;
 946
 947         dprintk(1, "%s called\n", __func__);
 948
 949         if (!priv->firm) {
 950                 rc = xc4000_fwupload(fe);
 951                 if (rc < 0)
 952                         return rc;
 953         }
 954
 955 #ifdef DJH_DEBUG
 956         if (priv->ctrl.mts && !(type & FM))
 957                 type |= MTS;
 958 #endif
 959
 960 retry:
 961         new_fw.type = type;
 962         new_fw.id = std;
 963         new_fw.std_req = std;
 964         new_fw.scode_table = SCODE /* | priv->ctrl.scode_table */;
 965         new_fw.scode_nr = 0;
 966         new_fw.int_freq = int_freq;
 967
 968         dprintk(1, "checking firmware, user requested type=");
 969         if (debug) {
 970                 dump_firm_type(new_fw.type);
 971                 printk("(%x), id %016llx, ", new_fw.type,
 972                        (unsigned long long)new_fw.std_req);
 973                 if (!int_freq) {
 974                         printk("scode_tbl ");
 975 #ifdef DJH_DEBUG
 976                         dump_firm_type(priv->ctrl.scode_table);
 977                         printk("(%x), ", priv->ctrl.scode_table);
 978 #endif
 979                 } else
 980                         printk("int_freq %d, ", new_fw.int_freq);
 981                 printk("scode_nr %d\n", new_fw.scode_nr);
 982         }
 983
 984         /* No need to reload base firmware if it matches */
 985         if (priv->cur_fw.type & BASE) {
 986                 dprintk(1, "BASE firmware not changed.\n");
 987                 goto skip_base;
 988         }
 989
 990         /* Updating BASE - forget about all currently loaded firmware */
 991         memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
 992
 993         /* Reset is needed before loading firmware */
 994         rc = xc4000_TunerReset(fe);
 995         if (rc < 0)
 996                 goto fail;
 997
 998         /* BASE firmwares are all std0 */
 999         std0 = 0;
1000         rc = load_firmware(fe, BASE, &std0);
1001         if (rc < 0) {
1002                 printk("Error %d while loading base firmware\n", rc);
1003                 goto fail;
1004         }
1005
1006         /* Load INIT1, if needed */
1007         dprintk(1, "Load init1 firmware, if exists\n");
1008
1009         rc = load_firmware(fe, BASE | INIT1, &std0);
1010         if (rc == -ENOENT)
1011                 rc = load_firmware(fe, BASE | INIT1, &std0);
1012         if (rc < 0 && rc != -ENOENT) {
1013                 tuner_err("Error %d while loading init1 firmware\n",
1014                           rc);
1015                 goto fail;
1016         }
1017
1018 skip_base:
1019         /*
1020          * No need to reload standard specific firmware if base firmware
1021          * was not reloaded and requested video standards have not changed.
1022          */
1023         if (priv->cur_fw.type == (BASE | new_fw.type) &&
1024             priv->cur_fw.std_req == std) {
1025                 dprintk(1, "Std-specific firmware already loaded.\n");
1026                 goto skip_std_specific;
1027         }
1028
1029         /* Reloading std-specific firmware forces a SCODE update */
1030         priv->cur_fw.scode_table = 0;
1031
1032         /* Load the standard firmware */
1033         rc = load_firmware(fe, new_fw.type, &new_fw.id);
1034
1035         if (rc < 0)
1036                 goto fail;
1037
1038 skip_std_specific:
1039         if (priv->cur_fw.scode_table == new_fw.scode_table &&
1040             priv->cur_fw.scode_nr == new_fw.scode_nr) {
1041                 dprintk(1, "SCODE firmware already loaded.\n");
1042                 goto check_device;
1043         }
1044
1045         /* Load SCODE firmware, if exists */
1046         rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
1047                         new_fw.int_freq, new_fw.scode_nr);
1048         if (rc != XC_RESULT_SUCCESS)
1049                 dprintk(1, "load scode failed %d\n", rc);
1050
1051 check_device:
1052         rc = xc4000_readreg(priv, XREG_PRODUCT_ID, &hwmodel);
1053
1054         if (xc_get_version(priv, &hw_major, &hw_minor, &fw_major,
1055                            &fw_minor) != XC_RESULT_SUCCESS) {
1056                 printk("Unable to read tuner registers.\n");
1057                 goto fail;
1058         }
1059
1060         dprintk(1, "Device is Xceive %d version %d.%d, "
1061                 "firmware version %d.%d\n",
1062                 hwmodel, hw_major, hw_minor, fw_major, fw_minor);
1063
1064         /* Check firmware version against what we downloaded. */
1065 #ifdef DJH_DEBUG
1066         if (priv->firm_version != ((version & 0xf0) << 4 | (version & 0x0f))) {
1067                 printk("Incorrect readback of firmware version %x.\n",
1068                        (version & 0xff));
1069                 goto fail;
1070         }
1071 #endif
1072
1073         /* Check that the tuner hardware model remains consistent over time. */
1074         if (priv->hwmodel == 0 && hwmodel == 4000) {
1075                 priv->hwmodel = hwmodel;
1076                 priv->hwvers  = version & 0xff00;
1077         } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
1078                    priv->hwvers != (version & 0xff00)) {
1079                 printk("Read invalid device hardware information - tuner "
1080                        "hung?\n");
1081                 goto fail;
1082         }
1083
1084         memcpy(&priv->cur_fw, &new_fw, sizeof(priv->cur_fw));
1085
1086         /*
1087          * By setting BASE in cur_fw.type only after successfully loading all
1088          * firmwares, we can:
1089          * 1. Identify that BASE firmware with type=0 has been loaded;
1090          * 2. Tell whether BASE firmware was just changed the next time through.
1091          */
1092         priv->cur_fw.type |= BASE;
1093
1094         return 0;
1095
1096 fail:
1097         memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
1098         if (!is_retry) {
1099                 msleep(50);
1100                 is_retry = 1;
1101                 dprintk(1, "Retrying firmware load\n");
1102                 goto retry;
1103         }
1104
1105         if (rc == -ENOENT)
1106                 rc = -EINVAL;
1107         return rc;
1108 }
1109
1110 static void xc_debug_dump(struct xc4000_priv *priv)
1111 {
1112         u16     adc_envelope;
1113         u32     freq_error_hz = 0;
1114         u16     lock_status;
1115         u32     hsync_freq_hz = 0;
1116         u16     frame_lines;
1117         u16     quality;
1118         u8      hw_majorversion = 0, hw_minorversion = 0;
1119         u8      fw_majorversion = 0, fw_minorversion = 0;
1120
1121         xc_get_ADC_Envelope(priv, &adc_envelope);
1122         dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
1123
1124         xc_get_frequency_error(priv, &freq_error_hz);
1125         dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
1126
1127         xc_get_lock_status(priv, &lock_status);
1128         dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
1129                 lock_status);
1130
1131         xc_get_version(priv, &hw_majorversion, &hw_minorversion,
1132                        &fw_majorversion, &fw_minorversion);
1133         dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
1134                 hw_majorversion, hw_minorversion,
1135                 fw_majorversion, fw_minorversion);
1136
1137         if (priv->video_standard < XC4000_DTV6) {
1138                 xc_get_hsync_freq(priv, &hsync_freq_hz);
1139                 dprintk(1, "*** Horizontal sync frequency = %d Hz\n",
1140                         hsync_freq_hz);
1141
1142                 xc_get_frame_lines(priv, &frame_lines);
1143                 dprintk(1, "*** Frame lines = %d\n", frame_lines);
1144         }
1145
1146         xc_get_quality(priv, &quality);
1147         dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
1148 }
1149
1150 static int xc4000_set_params(struct dvb_frontend *fe,
1151         struct dvb_frontend_parameters *params)
1152 {
1153         struct xc4000_priv *priv = fe->tuner_priv;
1154         unsigned int type;
1155         int     ret = -EREMOTEIO;
1156
1157         dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
1158
1159         mutex_lock(&priv->lock);
1160
1161         if (fe->ops.info.type == FE_ATSC) {
1162                 dprintk(1, "%s() ATSC\n", __func__);
1163                 switch (params->u.vsb.modulation) {
1164                 case VSB_8:
1165                 case VSB_16:
1166                         dprintk(1, "%s() VSB modulation\n", __func__);
1167                         priv->rf_mode = XC_RF_MODE_AIR;
1168                         priv->freq_hz = params->frequency - 1750000;
1169                         priv->bandwidth = BANDWIDTH_6_MHZ;
1170                         priv->video_standard = XC4000_DTV6;
1171                         type = DTV6;
1172                         break;
1173                 case QAM_64:
1174                 case QAM_256:
1175                 case QAM_AUTO:
1176                         dprintk(1, "%s() QAM modulation\n", __func__);
1177                         priv->rf_mode = XC_RF_MODE_CABLE;
1178                         priv->freq_hz = params->frequency - 1750000;
1179                         priv->bandwidth = BANDWIDTH_6_MHZ;
1180                         priv->video_standard = XC4000_DTV6;
1181                         type = DTV6;
1182                         break;
1183                 default:
1184                         ret = -EINVAL;
1185                         goto fail;
1186                 }
1187         } else if (fe->ops.info.type == FE_OFDM) {
1188                 dprintk(1, "%s() OFDM\n", __func__);
1189                 switch (params->u.ofdm.bandwidth) {
1190                 case BANDWIDTH_6_MHZ:
1191                         priv->bandwidth = BANDWIDTH_6_MHZ;
1192                         priv->video_standard = XC4000_DTV6;
1193                         priv->freq_hz = params->frequency - 1750000;
1194                         type = DTV6;
1195                         break;
1196                 case BANDWIDTH_7_MHZ:
1197                         priv->bandwidth = BANDWIDTH_7_MHZ;
1198                         priv->video_standard = XC4000_DTV7;
1199                         priv->freq_hz = params->frequency - 2250000;
1200                         type = DTV7;
1201                         break;
1202                 case BANDWIDTH_8_MHZ:
1203                         priv->bandwidth = BANDWIDTH_8_MHZ;
1204                         priv->video_standard = XC4000_DTV8;
1205                         priv->freq_hz = params->frequency - 2750000;
1206                         type = DTV8;
1207                         break;
1208                 case BANDWIDTH_AUTO:
1209                         if (params->frequency < 400000000) {
1210                                 priv->bandwidth = BANDWIDTH_7_MHZ;
1211                                 priv->freq_hz = params->frequency - 2250000;
1212                         } else {
1213                                 priv->bandwidth = BANDWIDTH_8_MHZ;
1214                                 priv->freq_hz = params->frequency - 2750000;
1215                         }
1216                         priv->video_standard = XC4000_DTV7_8;
1217                         type = DTV78;
1218                         break;
1219                 default:
1220                         printk(KERN_ERR "xc4000 bandwidth not set!\n");
1221                         ret = -EINVAL;
1222                         goto fail;
1223                 }
1224                 priv->rf_mode = XC_RF_MODE_AIR;
1225         } else {
1226                 printk(KERN_ERR "xc4000 modulation type not supported!\n");
1227                 ret = -EINVAL;
1228                 goto fail;
1229         }
1230
1231         dprintk(1, "%s() frequency=%d (compensated)\n",
1232                 __func__, priv->freq_hz);
1233
1234         /* Make sure the correct firmware type is loaded */
1235         if (check_firmware(fe, type, 0, priv->if_khz) != XC_RESULT_SUCCESS)
1236                 goto fail;
1237
1238         ret = xc_SetSignalSource(priv, priv->rf_mode);
1239         if (ret != XC_RESULT_SUCCESS) {
1240                 printk(KERN_ERR
1241                        "xc4000: xc_SetSignalSource(%d) failed\n",
1242                        priv->rf_mode);
1243                 goto fail;
1244         } else {
1245                 u16     video_mode, audio_mode;
1246                 video_mode = XC4000_Standard[priv->video_standard].VideoMode;
1247                 audio_mode = XC4000_Standard[priv->video_standard].AudioMode;
1248                 if (type == DTV6 && priv->firm_version != 0x0102)
1249                         video_mode |= 0x0001;
1250                 ret = xc_SetTVStandard(priv, video_mode, audio_mode);
1251                 if (ret != XC_RESULT_SUCCESS) {
1252                         printk(KERN_ERR "xc4000: xc_SetTVStandard failed\n");
1253                         /* DJH - do not return when it fails... */
1254                         /* goto fail; */
1255                 }
1256         }
1257
1258         if (priv->card_type == XC4000_CARD_WINFAST_CX88) {
1259                 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1260                         ret = 0;
1261                 if (xc_write_reg(priv, XREG_AMPLITUDE,
1262                                  (priv->firm_version == 0x0102 ? 132 : 134))
1263                     != 0)
1264                         ret = -EREMOTEIO;
1265                 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1266                         ret = -EREMOTEIO;
1267                 if (ret != 0) {
1268                         printk(KERN_ERR "xc4000: setting registers failed\n");
1269                         /* goto fail; */
1270                 }
1271         }
1272
1273         xc_tune_channel(priv, priv->freq_hz);
1274
1275         ret = 0;
1276
1277 fail:
1278         mutex_unlock(&priv->lock);
1279
1280         return ret;
1281 }
1282
1283 static int xc4000_set_analog_params(struct dvb_frontend *fe,
1284         struct analog_parameters *params)
1285 {
1286         struct xc4000_priv *priv = fe->tuner_priv;
1287         unsigned int type = 0;
1288         int     ret = -EREMOTEIO;
1289
1290         if (params->mode == V4L2_TUNER_RADIO) {
1291                 dprintk(1, "%s() frequency=%d (in units of 62.5Hz)\n",
1292                         __func__, params->frequency);
1293
1294                 mutex_lock(&priv->lock);
1295
1296                 params->std = 0;
1297                 priv->freq_hz = params->frequency * 125L / 2;
1298
1299                 if (audio_std & XC4000_AUDIO_STD_INPUT1) {
1300                         priv->video_standard = XC4000_FM_Radio_INPUT1;
1301                         type = FM | INPUT1;
1302                 } else {
1303                         priv->video_standard = XC4000_FM_Radio_INPUT2;
1304                         type = FM | INPUT2;
1305                 }
1306
1307                 goto tune_channel;
1308         }
1309
1310         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
1311                 __func__, params->frequency);
1312
1313         mutex_lock(&priv->lock);
1314
1315         /* params->frequency is in units of 62.5khz */
1316         priv->freq_hz = params->frequency * 62500;
1317
1318         params->std &= V4L2_STD_ALL;
1319         /* if std is not defined, choose one */
1320         if (!params->std)
1321                 params->std = V4L2_STD_PAL_BG;
1322
1323         if (audio_std & XC4000_AUDIO_STD_MONO)
1324                 type = MONO;
1325
1326         if (params->std & V4L2_STD_MN) {
1327                 params->std = V4L2_STD_MN;
1328                 if (audio_std & XC4000_AUDIO_STD_MONO) {
1329                         priv->video_standard = XC4000_MN_NTSC_PAL_Mono;
1330                 } else if (audio_std & XC4000_AUDIO_STD_A2) {
1331                         params->std |= V4L2_STD_A2;
1332                         priv->video_standard = XC4000_MN_NTSC_PAL_A2;
1333                 } else {
1334                         params->std |= V4L2_STD_BTSC;
1335                         priv->video_standard = XC4000_MN_NTSC_PAL_BTSC;
1336                 }
1337                 goto tune_channel;
1338         }
1339
1340         if (params->std & V4L2_STD_PAL_BG) {
1341                 params->std = V4L2_STD_PAL_BG;
1342                 if (audio_std & XC4000_AUDIO_STD_MONO) {
1343                         priv->video_standard = XC4000_BG_PAL_MONO;
1344                 } else if (!(audio_std & XC4000_AUDIO_STD_A2)) {
1345                         if (!(audio_std & XC4000_AUDIO_STD_B)) {
1346                                 params->std |= V4L2_STD_NICAM_A;
1347                                 priv->video_standard = XC4000_BG_PAL_NICAM;
1348                         } else {
1349                                 params->std |= V4L2_STD_NICAM_B;
1350                                 priv->video_standard = XC4000_BG_PAL_NICAM;
1351                         }
1352                 } else {
1353                         if (!(audio_std & XC4000_AUDIO_STD_B)) {
1354                                 params->std |= V4L2_STD_A2_A;
1355                                 priv->video_standard = XC4000_BG_PAL_A2;
1356                         } else {
1357                                 params->std |= V4L2_STD_A2_B;
1358                                 priv->video_standard = XC4000_BG_PAL_A2;
1359                         }
1360                 }
1361                 goto tune_channel;
1362         }
1363
1364         if (params->std & V4L2_STD_PAL_I) {
1365                 /* default to NICAM audio standard */
1366                 params->std = V4L2_STD_PAL_I | V4L2_STD_NICAM;
1367                 if (audio_std & XC4000_AUDIO_STD_MONO) {
1368                         priv->video_standard = XC4000_I_PAL_NICAM_MONO;
1369                 } else {
1370                         priv->video_standard = XC4000_I_PAL_NICAM;
1371                 }
1372                 goto tune_channel;
1373         }
1374
1375         if (params->std & V4L2_STD_PAL_DK) {
1376                 params->std = V4L2_STD_PAL_DK;
1377                 if (audio_std & XC4000_AUDIO_STD_MONO) {
1378                         priv->video_standard = XC4000_DK_PAL_MONO;
1379                 } else if (audio_std & XC4000_AUDIO_STD_A2) {
1380                         params->std |= V4L2_STD_A2;
1381                         priv->video_standard = XC4000_DK_PAL_A2;
1382                 } else {
1383                         params->std |= V4L2_STD_NICAM;
1384                         priv->video_standard = XC4000_DK_PAL_NICAM;
1385                 }
1386                 goto tune_channel;
1387         }
1388
1389         if (params->std & V4L2_STD_SECAM_DK) {
1390                 /* default to A2 audio standard */
1391                 params->std = V4L2_STD_SECAM_DK | V4L2_STD_A2;
1392                 if (audio_std & XC4000_AUDIO_STD_L) {
1393                         type = 0;
1394                         priv->video_standard = XC4000_DK_SECAM_NICAM;
1395                 } else if (audio_std & XC4000_AUDIO_STD_MONO) {
1396                         priv->video_standard = XC4000_DK_SECAM_A2MONO;
1397                 } else if (audio_std & XC4000_AUDIO_STD_K3) {
1398                         params->std |= V4L2_STD_SECAM_K3;
1399                         priv->video_standard = XC4000_DK_SECAM_A2LDK3;
1400                 } else {
1401                         priv->video_standard = XC4000_DK_SECAM_A2DK1;
1402                 }
1403                 goto tune_channel;
1404         }
1405
1406         if (params->std & V4L2_STD_SECAM_L) {
1407                 /* default to NICAM audio standard */
1408                 type = 0;
1409                 params->std = V4L2_STD_SECAM_L | V4L2_STD_NICAM;
1410                 priv->video_standard = XC4000_L_SECAM_NICAM;
1411                 goto tune_channel;
1412         }
1413
1414         if (params->std & V4L2_STD_SECAM_LC) {
1415                 /* default to NICAM audio standard */
1416                 type = 0;
1417                 params->std = V4L2_STD_SECAM_LC | V4L2_STD_NICAM;
1418                 priv->video_standard = XC4000_LC_SECAM_NICAM;
1419                 goto tune_channel;
1420         }
1421
1422 tune_channel:
1423         /* Fix me: it could be air. */
1424         priv->rf_mode = XC_RF_MODE_CABLE;
1425
1426         if (check_firmware(fe, type, params->std,
1427                            XC4000_Standard[priv->video_standard].int_freq)
1428             != XC_RESULT_SUCCESS) {
1429                 goto fail;
1430         }
1431
1432         ret = xc_SetSignalSource(priv, priv->rf_mode);
1433         if (ret != XC_RESULT_SUCCESS) {
1434                 printk(KERN_ERR
1435                        "xc4000: xc_SetSignalSource(%d) failed\n",
1436                        priv->rf_mode);
1437                 goto fail;
1438         } else {
1439                 u16     video_mode, audio_mode;
1440                 video_mode = XC4000_Standard[priv->video_standard].VideoMode;
1441                 audio_mode = XC4000_Standard[priv->video_standard].AudioMode;
1442                 if (priv->video_standard < XC4000_BG_PAL_A2) {
1443                         if (0 /*type & NOGD*/)
1444                                 video_mode &= 0xFF7F;
1445                 } else if (priv->video_standard < XC4000_I_PAL_NICAM) {
1446                         if (priv->card_type == XC4000_CARD_WINFAST_CX88 &&
1447                             priv->firm_version == 0x0102)
1448                                 video_mode &= 0xFEFF;
1449                         if (audio_std & XC4000_AUDIO_STD_B)
1450                                 video_mode |= 0x0080;
1451                 }
1452                 ret = xc_SetTVStandard(priv, video_mode, audio_mode);
1453                 if (ret != XC_RESULT_SUCCESS) {
1454                         printk(KERN_ERR "xc4000: xc_SetTVStandard failed\n");
1455                         goto fail;
1456                 }
1457         }
1458
1459         if (priv->card_type == XC4000_CARD_WINFAST_CX88) {
1460                 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1461                         ret = 0;
1462                 if (xc_write_reg(priv, XREG_AMPLITUDE, 1) != 0)
1463                         ret = -EREMOTEIO;
1464                 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1465                         ret = -EREMOTEIO;
1466                 if (ret != 0) {
1467                         printk(KERN_ERR "xc4000: setting registers failed\n");
1468                         goto fail;
1469                 }
1470         }
1471
1472         xc_tune_channel(priv, priv->freq_hz);
1473
1474         ret = 0;
1475
1476 fail:
1477         mutex_unlock(&priv->lock);
1478
1479         return ret;
1480 }
1481
1482 static int xc4000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1483 {
1484         struct xc4000_priv *priv = fe->tuner_priv;
1485
1486         *freq = priv->freq_hz;
1487
1488         if (debug) {
1489                 mutex_lock(&priv->lock);
1490                 if ((priv->cur_fw.type
1491                      & (BASE | FM | DTV6 | DTV7 | DTV78 | DTV8)) == BASE) {
1492                         u16     snr = 0;
1493                         if (xc4000_readreg(priv, XREG_SNR, &snr) == 0) {
1494                                 mutex_unlock(&priv->lock);
1495                                 dprintk(1, "%s() freq = %u, SNR = %d\n",
1496                                         __func__, *freq, snr);
1497                                 return 0;
1498                         }
1499                 }
1500                 mutex_unlock(&priv->lock);
1501         }
1502
1503         dprintk(1, "%s()\n", __func__);
1504
1505         return 0;
1506 }
1507
1508 static int xc4000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1509 {
1510         struct xc4000_priv *priv = fe->tuner_priv;
1511         dprintk(1, "%s()\n", __func__);
1512
1513         *bw = priv->bandwidth;
1514         return 0;
1515 }
1516
1517 static int xc4000_get_status(struct dvb_frontend *fe, u32 *status)
1518 {
1519         struct xc4000_priv *priv = fe->tuner_priv;
1520         u16     lock_status = 0;
1521
1522         mutex_lock(&priv->lock);
1523
1524         if (priv->cur_fw.type & BASE)
1525                 xc_get_lock_status(priv, &lock_status);
1526
1527         *status = (lock_status == 1 ?
1528                    TUNER_STATUS_LOCKED | TUNER_STATUS_STEREO : 0);
1529         if (priv->cur_fw.type & (DTV6 | DTV7 | DTV78 | DTV8))
1530                 *status &= (~TUNER_STATUS_STEREO);
1531
1532         mutex_unlock(&priv->lock);
1533
1534         dprintk(2, "%s() lock_status = %d\n", __func__, lock_status);
1535
1536         return 0;
1537 }
1538
1539 static int xc4000_sleep(struct dvb_frontend *fe)
1540 {
1541         struct xc4000_priv *priv = fe->tuner_priv;
1542         int     ret = XC_RESULT_SUCCESS;
1543
1544         dprintk(1, "%s()\n", __func__);
1545
1546         mutex_lock(&priv->lock);
1547
1548         /* Avoid firmware reload on slow devices */
1549         if ((no_poweroff == 2 ||
1550              (no_poweroff == 0 &&
1551               priv->card_type != XC4000_CARD_WINFAST_CX88)) &&
1552             (priv->cur_fw.type & BASE) != 0) {
1553                 /* force reset and firmware reload */
1554                 priv->cur_fw.type = XC_POWERED_DOWN;
1555
1556                 if (xc_write_reg(priv, XREG_POWER_DOWN, 0)
1557                     != XC_RESULT_SUCCESS) {
1558                         printk(KERN_ERR
1559                                "xc4000: %s() unable to shutdown tuner\n",
1560                                __func__);
1561                         ret = -EREMOTEIO;
1562                 }
1563                 xc_wait(20);
1564         }
1565
1566         mutex_unlock(&priv->lock);
1567
1568         return ret;
1569 }
1570
1571 static int xc4000_init(struct dvb_frontend *fe)
1572 {
1573         dprintk(1, "%s()\n", __func__);
1574
1575         return 0;
1576 }
1577
1578 static int xc4000_release(struct dvb_frontend *fe)
1579 {
1580         struct xc4000_priv *priv = fe->tuner_priv;
1581
1582         dprintk(1, "%s()\n", __func__);
1583
1584         mutex_lock(&xc4000_list_mutex);
1585
1586         if (priv)
1587                 hybrid_tuner_release_state(priv);
1588
1589         mutex_unlock(&xc4000_list_mutex);
1590
1591         fe->tuner_priv = NULL;
1592
1593         return 0;
1594 }
1595
1596 static const struct dvb_tuner_ops xc4000_tuner_ops = {
1597         .info = {
1598                 .name           = "Xceive XC4000",
1599                 .frequency_min  =    1000000,
1600                 .frequency_max  = 1023000000,
1601                 .frequency_step =      50000,
1602         },
1603
1604         .release           = xc4000_release,
1605         .init              = xc4000_init,
1606         .sleep             = xc4000_sleep,
1607
1608         .set_params        = xc4000_set_params,
1609         .set_analog_params = xc4000_set_analog_params,
1610         .get_frequency     = xc4000_get_frequency,
1611         .get_bandwidth     = xc4000_get_bandwidth,
1612         .get_status        = xc4000_get_status
1613 };
1614
1615 struct dvb_frontend *xc4000_attach(struct dvb_frontend *fe,
1616                                    struct i2c_adapter *i2c,
1617                                    struct xc4000_config *cfg)
1618 {
1619         struct xc4000_priv *priv = NULL;
1620         int     instance;
1621         u16     id = 0;
1622
1623         if (cfg->card_type != XC4000_CARD_GENERIC) {
1624                 if (cfg->card_type == XC4000_CARD_WINFAST_CX88) {
1625                         cfg->i2c_address = 0x61;
1626                         cfg->if_khz = 4560;
1627                 } else {                        /* default to PCTV 340E */
1628                         cfg->i2c_address = 0x61;
1629                         cfg->if_khz = 5400;
1630                 }
1631         }
1632
1633         dprintk(1, "%s(%d-%04x)\n", __func__,
1634                 i2c ? i2c_adapter_id(i2c) : -1,
1635                 cfg ? cfg->i2c_address : -1);
1636
1637         mutex_lock(&xc4000_list_mutex);
1638
1639         instance = hybrid_tuner_request_state(struct xc4000_priv, priv,
1640                                               hybrid_tuner_instance_list,
1641                                               i2c, cfg->i2c_address, "xc4000");
1642         if (cfg->card_type != XC4000_CARD_GENERIC)
1643                 priv->card_type = cfg->card_type;
1644         switch (instance) {
1645         case 0:
1646                 goto fail;
1647                 break;
1648         case 1:
1649                 /* new tuner instance */
1650                 priv->bandwidth = BANDWIDTH_6_MHZ;
1651                 mutex_init(&priv->lock);
1652                 fe->tuner_priv = priv;
1653                 break;
1654         default:
1655                 /* existing tuner instance */
1656                 fe->tuner_priv = priv;
1657                 break;
1658         }
1659
1660         if (cfg->if_khz != 0) {
1661                 /* If the IF hasn't been set yet, use the value provided by
1662                    the caller (occurs in hybrid devices where the analog
1663                    call to xc4000_attach occurs before the digital side) */
1664                 priv->if_khz = cfg->if_khz;
1665         }
1666
1667         /* Check if firmware has been loaded. It is possible that another
1668            instance of the driver has loaded the firmware.
1669          */
1670
1671         if (instance == 1) {
1672                 if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id)
1673                     != XC_RESULT_SUCCESS)
1674                         goto fail;
1675         } else {
1676                 id = ((priv->cur_fw.type & BASE) != 0 ?
1677                       priv->hwmodel : XC_PRODUCT_ID_FW_NOT_LOADED);
1678         }
1679
1680         switch (id) {
1681         case XC_PRODUCT_ID_FW_LOADED:
1682                 printk(KERN_INFO
1683                         "xc4000: Successfully identified at address 0x%02x\n",
1684                         cfg->i2c_address);
1685                 printk(KERN_INFO
1686                         "xc4000: Firmware has been loaded previously\n");
1687                 break;
1688         case XC_PRODUCT_ID_FW_NOT_LOADED:
1689                 printk(KERN_INFO
1690                         "xc4000: Successfully identified at address 0x%02x\n",
1691                         cfg->i2c_address);
1692                 printk(KERN_INFO
1693                         "xc4000: Firmware has not been loaded previously\n");
1694                 break;
1695         default:
1696                 printk(KERN_ERR
1697                         "xc4000: Device not found at addr 0x%02x (0x%x)\n",
1698                         cfg->i2c_address, id);
1699                 goto fail;
1700         }
1701
1702         mutex_unlock(&xc4000_list_mutex);
1703
1704         memcpy(&fe->ops.tuner_ops, &xc4000_tuner_ops,
1705                 sizeof(struct dvb_tuner_ops));
1706
1707         if (instance == 1) {
1708                 int     ret;
1709                 mutex_lock(&priv->lock);
1710                 ret = xc4000_fwupload(fe);
1711                 mutex_unlock(&priv->lock);
1712                 if (ret != XC_RESULT_SUCCESS)
1713                         goto fail2;
1714         }
1715
1716         return fe;
1717 fail:
1718         mutex_unlock(&xc4000_list_mutex);
1719 fail2:
1720         xc4000_release(fe);
1721         return NULL;
1722 }
1723 EXPORT_SYMBOL(xc4000_attach);
1724
1725 MODULE_AUTHOR("Steven Toth, Davide Ferri");
1726 MODULE_DESCRIPTION("Xceive xc4000 silicon tuner driver");
1727 MODULE_LICENSE("GPL");