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