drivers/media/common/tuners/xc4000.c

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