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