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 = kcalloc(n_array, sizeof(*priv->firm), 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 {
1126         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1127         u32 delsys = c->delivery_system;
1128         u32 bw = c->bandwidth_hz;
1129         struct xc4000_priv *priv = fe->tuner_priv;
1130         unsigned int type;
1131         int     ret = -EREMOTEIO;
1132
1133         dprintk(1, "%s() frequency=%d (Hz)\n", __func__, c->frequency);
1134
1135         mutex_lock(&priv->lock);
1136
1137         switch (delsys) {
1138         case SYS_ATSC:
1139                 dprintk(1, "%s() VSB modulation\n", __func__);
1140                 priv->rf_mode = XC_RF_MODE_AIR;
1141                 priv->freq_hz = c->frequency - 1750000;
1142                 priv->video_standard = XC4000_DTV6;
1143                 type = DTV6;
1144                 break;
1145         case SYS_DVBC_ANNEX_B:
1146                 dprintk(1, "%s() QAM modulation\n", __func__);
1147                 priv->rf_mode = XC_RF_MODE_CABLE;
1148                 priv->freq_hz = c->frequency - 1750000;
1149                 priv->video_standard = XC4000_DTV6;
1150                 type = DTV6;
1151                 break;
1152         case SYS_DVBT:
1153         case SYS_DVBT2:
1154                 dprintk(1, "%s() OFDM\n", __func__);
1155                 if (bw == 0) {
1156                         if (c->frequency < 400000000) {
1157                                 priv->freq_hz = c->frequency - 2250000;
1158                         } else {
1159                                 priv->freq_hz = c->frequency - 2750000;
1160                         }
1161                         priv->video_standard = XC4000_DTV7_8;
1162                         type = DTV78;
1163                 } else if (bw <= 6000000) {
1164                         priv->video_standard = XC4000_DTV6;
1165                         priv->freq_hz = c->frequency - 1750000;
1166                         type = DTV6;
1167                 } else if (bw <= 7000000) {
1168                         priv->video_standard = XC4000_DTV7;
1169                         priv->freq_hz = c->frequency - 2250000;
1170                         type = DTV7;
1171                 } else {
1172                         priv->video_standard = XC4000_DTV8;
1173                         priv->freq_hz = c->frequency - 2750000;
1174                         type = DTV8;
1175                 }
1176                 priv->rf_mode = XC_RF_MODE_AIR;
1177                 break;
1178         default:
1179                 printk(KERN_ERR "xc4000 delivery system not supported!\n");
1180                 ret = -EINVAL;
1181                 goto fail;
1182         }
1183
1184         dprintk(1, "%s() frequency=%d (compensated)\n",
1185                 __func__, priv->freq_hz);
1186
1187         /* Make sure the correct firmware type is loaded */
1188         if (check_firmware(fe, type, 0, priv->if_khz) != 0)
1189                 goto fail;
1190
1191         priv->bandwidth = c->bandwidth_hz;
1192
1193         ret = xc_set_signal_source(priv, priv->rf_mode);
1194         if (ret != 0) {
1195                 printk(KERN_ERR "xc4000: xc_set_signal_source(%d) failed\n",
1196                        priv->rf_mode);
1197                 goto fail;
1198         } else {
1199                 u16     video_mode, audio_mode;
1200                 video_mode = xc4000_standard[priv->video_standard].video_mode;
1201                 audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1202                 if (type == DTV6 && priv->firm_version != 0x0102)
1203                         video_mode |= 0x0001;
1204                 ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1205                 if (ret != 0) {
1206                         printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1207                         /* DJH - do not return when it fails... */
1208                         /* goto fail; */
1209                 }
1210         }
1211
1212         if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1213                 ret = 0;
1214         if (priv->dvb_amplitude != 0) {
1215                 if (xc_write_reg(priv, XREG_AMPLITUDE,
1216                                  (priv->firm_version != 0x0102 ||
1217                                   priv->dvb_amplitude != 134 ?
1218                                   priv->dvb_amplitude : 132)) != 0)
1219                         ret = -EREMOTEIO;
1220         }
1221         if (priv->set_smoothedcvbs != 0) {
1222                 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1223                         ret = -EREMOTEIO;
1224         }
1225         if (ret != 0) {
1226                 printk(KERN_ERR "xc4000: setting registers failed\n");
1227                 /* goto fail; */
1228         }
1229
1230         xc_tune_channel(priv, priv->freq_hz);
1231
1232         ret = 0;
1233
1234 fail:
1235         mutex_unlock(&priv->lock);
1236
1237         return ret;
1238 }
1239
1240 static int xc4000_set_analog_params(struct dvb_frontend *fe,
1241         struct analog_parameters *params)
1242 {
1243         struct xc4000_priv *priv = fe->tuner_priv;
1244         unsigned int type = 0;
1245         int     ret = -EREMOTEIO;
1246
1247         if (params->mode == V4L2_TUNER_RADIO) {
1248                 dprintk(1, "%s() frequency=%d (in units of 62.5Hz)\n",
1249                         __func__, params->frequency);
1250
1251                 mutex_lock(&priv->lock);
1252
1253                 params->std = 0;
1254                 priv->freq_hz = params->frequency * 125L / 2;
1255
1256                 if (audio_std & XC4000_AUDIO_STD_INPUT1) {
1257                         priv->video_standard = XC4000_FM_Radio_INPUT1;
1258                         type = FM | INPUT1;
1259                 } else {
1260                         priv->video_standard = XC4000_FM_Radio_INPUT2;
1261                         type = FM | INPUT2;
1262                 }
1263
1264                 goto tune_channel;
1265         }
1266
1267         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
1268                 __func__, params->frequency);
1269
1270         mutex_lock(&priv->lock);
1271
1272         /* params->frequency is in units of 62.5khz */
1273         priv->freq_hz = params->frequency * 62500;
1274
1275         params->std &= V4L2_STD_ALL;
1276         /* if std is not defined, choose one */
1277         if (!params->std)
1278                 params->std = V4L2_STD_PAL_BG;
1279
1280         if (audio_std & XC4000_AUDIO_STD_MONO)
1281                 type = MONO;
1282
1283         if (params->std & V4L2_STD_MN) {
1284                 params->std = V4L2_STD_MN;
1285                 if (audio_std & XC4000_AUDIO_STD_MONO) {
1286                         priv->video_standard = XC4000_MN_NTSC_PAL_Mono;
1287                 } else if (audio_std & XC4000_AUDIO_STD_A2) {
1288                         params->std |= V4L2_STD_A2;
1289                         priv->video_standard = XC4000_MN_NTSC_PAL_A2;
1290                 } else {
1291                         params->std |= V4L2_STD_BTSC;
1292                         priv->video_standard = XC4000_MN_NTSC_PAL_BTSC;
1293                 }
1294                 goto tune_channel;
1295         }
1296
1297         if (params->std & V4L2_STD_PAL_BG) {
1298                 params->std = V4L2_STD_PAL_BG;
1299                 if (audio_std & XC4000_AUDIO_STD_MONO) {
1300                         priv->video_standard = XC4000_BG_PAL_MONO;
1301                 } else if (!(audio_std & XC4000_AUDIO_STD_A2)) {
1302                         if (!(audio_std & XC4000_AUDIO_STD_B)) {
1303                                 params->std |= V4L2_STD_NICAM_A;
1304                                 priv->video_standard = XC4000_BG_PAL_NICAM;
1305                         } else {
1306                                 params->std |= V4L2_STD_NICAM_B;
1307                                 priv->video_standard = XC4000_BG_PAL_NICAM;
1308                         }
1309                 } else {
1310                         if (!(audio_std & XC4000_AUDIO_STD_B)) {
1311                                 params->std |= V4L2_STD_A2_A;
1312                                 priv->video_standard = XC4000_BG_PAL_A2;
1313                         } else {
1314                                 params->std |= V4L2_STD_A2_B;
1315                                 priv->video_standard = XC4000_BG_PAL_A2;
1316                         }
1317                 }
1318                 goto tune_channel;
1319         }
1320
1321         if (params->std & V4L2_STD_PAL_I) {
1322                 /* default to NICAM audio standard */
1323                 params->std = V4L2_STD_PAL_I | V4L2_STD_NICAM;
1324                 if (audio_std & XC4000_AUDIO_STD_MONO)
1325                         priv->video_standard = XC4000_I_PAL_NICAM_MONO;
1326                 else
1327                         priv->video_standard = XC4000_I_PAL_NICAM;
1328                 goto tune_channel;
1329         }
1330
1331         if (params->std & V4L2_STD_PAL_DK) {
1332                 params->std = V4L2_STD_PAL_DK;
1333                 if (audio_std & XC4000_AUDIO_STD_MONO) {
1334                         priv->video_standard = XC4000_DK_PAL_MONO;
1335                 } else if (audio_std & XC4000_AUDIO_STD_A2) {
1336                         params->std |= V4L2_STD_A2;
1337                         priv->video_standard = XC4000_DK_PAL_A2;
1338                 } else {
1339                         params->std |= V4L2_STD_NICAM;
1340                         priv->video_standard = XC4000_DK_PAL_NICAM;
1341                 }
1342                 goto tune_channel;
1343         }
1344
1345         if (params->std & V4L2_STD_SECAM_DK) {
1346                 /* default to A2 audio standard */
1347                 params->std = V4L2_STD_SECAM_DK | V4L2_STD_A2;
1348                 if (audio_std & XC4000_AUDIO_STD_L) {
1349                         type = 0;
1350                         priv->video_standard = XC4000_DK_SECAM_NICAM;
1351                 } else if (audio_std & XC4000_AUDIO_STD_MONO) {
1352                         priv->video_standard = XC4000_DK_SECAM_A2MONO;
1353                 } else if (audio_std & XC4000_AUDIO_STD_K3) {
1354                         params->std |= V4L2_STD_SECAM_K3;
1355                         priv->video_standard = XC4000_DK_SECAM_A2LDK3;
1356                 } else {
1357                         priv->video_standard = XC4000_DK_SECAM_A2DK1;
1358                 }
1359                 goto tune_channel;
1360         }
1361
1362         if (params->std & V4L2_STD_SECAM_L) {
1363                 /* default to NICAM audio standard */
1364                 type = 0;
1365                 params->std = V4L2_STD_SECAM_L | V4L2_STD_NICAM;
1366                 priv->video_standard = XC4000_L_SECAM_NICAM;
1367                 goto tune_channel;
1368         }
1369
1370         if (params->std & V4L2_STD_SECAM_LC) {
1371                 /* default to NICAM audio standard */
1372                 type = 0;
1373                 params->std = V4L2_STD_SECAM_LC | V4L2_STD_NICAM;
1374                 priv->video_standard = XC4000_LC_SECAM_NICAM;
1375                 goto tune_channel;
1376         }
1377
1378 tune_channel:
1379         /* FIXME: it could be air. */
1380         priv->rf_mode = XC_RF_MODE_CABLE;
1381
1382         if (check_firmware(fe, type, params->std,
1383                            xc4000_standard[priv->video_standard].int_freq) != 0)
1384                 goto fail;
1385
1386         ret = xc_set_signal_source(priv, priv->rf_mode);
1387         if (ret != 0) {
1388                 printk(KERN_ERR
1389                        "xc4000: xc_set_signal_source(%d) failed\n",
1390                        priv->rf_mode);
1391                 goto fail;
1392         } else {
1393                 u16     video_mode, audio_mode;
1394                 video_mode = xc4000_standard[priv->video_standard].video_mode;
1395                 audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1396                 if (priv->video_standard < XC4000_BG_PAL_A2) {
1397                         if (type & NOGD)
1398                                 video_mode &= 0xFF7F;
1399                 } else if (priv->video_standard < XC4000_I_PAL_NICAM) {
1400                         if (priv->firm_version == 0x0102)
1401                                 video_mode &= 0xFEFF;
1402                         if (audio_std & XC4000_AUDIO_STD_B)
1403                                 video_mode |= 0x0080;
1404                 }
1405                 ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1406                 if (ret != 0) {
1407                         printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1408                         goto fail;
1409                 }
1410         }
1411
1412         if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1413                 ret = 0;
1414         if (xc_write_reg(priv, XREG_AMPLITUDE, 1) != 0)
1415                 ret = -EREMOTEIO;
1416         if (priv->set_smoothedcvbs != 0) {
1417                 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1418                         ret = -EREMOTEIO;
1419         }
1420         if (ret != 0) {
1421                 printk(KERN_ERR "xc4000: setting registers failed\n");
1422                 goto fail;
1423         }
1424
1425         xc_tune_channel(priv, priv->freq_hz);
1426
1427         ret = 0;
1428
1429 fail:
1430         mutex_unlock(&priv->lock);
1431
1432         return ret;
1433 }
1434
1435 static int xc4000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1436 {
1437         struct xc4000_priv *priv = fe->tuner_priv;
1438
1439         *freq = priv->freq_hz;
1440
1441         if (debug) {
1442                 mutex_lock(&priv->lock);
1443                 if ((priv->cur_fw.type
1444                      & (BASE | FM | DTV6 | DTV7 | DTV78 | DTV8)) == BASE) {
1445                         u16     snr = 0;
1446                         if (xc4000_readreg(priv, XREG_SNR, &snr) == 0) {
1447                                 mutex_unlock(&priv->lock);
1448                                 dprintk(1, "%s() freq = %u, SNR = %d\n",
1449                                         __func__, *freq, snr);
1450                                 return 0;
1451                         }
1452                 }
1453                 mutex_unlock(&priv->lock);
1454         }
1455
1456         dprintk(1, "%s()\n", __func__);
1457
1458         return 0;
1459 }
1460
1461 static int xc4000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1462 {
1463         struct xc4000_priv *priv = fe->tuner_priv;
1464         dprintk(1, "%s()\n", __func__);
1465
1466         *bw = priv->bandwidth;
1467         return 0;
1468 }
1469
1470 static int xc4000_get_status(struct dvb_frontend *fe, u32 *status)
1471 {
1472         struct xc4000_priv *priv = fe->tuner_priv;
1473         u16     lock_status = 0;
1474
1475         mutex_lock(&priv->lock);
1476
1477         if (priv->cur_fw.type & BASE)
1478                 xc_get_lock_status(priv, &lock_status);
1479
1480         *status = (lock_status == 1 ?
1481                    TUNER_STATUS_LOCKED | TUNER_STATUS_STEREO : 0);
1482         if (priv->cur_fw.type & (DTV6 | DTV7 | DTV78 | DTV8))
1483                 *status &= (~TUNER_STATUS_STEREO);
1484
1485         mutex_unlock(&priv->lock);
1486
1487         dprintk(2, "%s() lock_status = %d\n", __func__, lock_status);
1488
1489         return 0;
1490 }
1491
1492 static int xc4000_sleep(struct dvb_frontend *fe)
1493 {
1494         struct xc4000_priv *priv = fe->tuner_priv;
1495         int     ret = 0;
1496
1497         dprintk(1, "%s()\n", __func__);
1498
1499         mutex_lock(&priv->lock);
1500
1501         /* Avoid firmware reload on slow devices */
1502         if ((no_poweroff == 2 ||
1503              (no_poweroff == 0 && priv->default_pm != 0)) &&
1504             (priv->cur_fw.type & BASE) != 0) {
1505                 /* force reset and firmware reload */
1506                 priv->cur_fw.type = XC_POWERED_DOWN;
1507
1508                 if (xc_write_reg(priv, XREG_POWER_DOWN, 0) != 0) {
1509                         printk(KERN_ERR
1510                                "xc4000: %s() unable to shutdown tuner\n",
1511                                __func__);
1512                         ret = -EREMOTEIO;
1513                 }
1514                 msleep(20);
1515         }
1516
1517         mutex_unlock(&priv->lock);
1518
1519         return ret;
1520 }
1521
1522 static int xc4000_init(struct dvb_frontend *fe)
1523 {
1524         dprintk(1, "%s()\n", __func__);
1525
1526         return 0;
1527 }
1528
1529 static int xc4000_release(struct dvb_frontend *fe)
1530 {
1531         struct xc4000_priv *priv = fe->tuner_priv;
1532
1533         dprintk(1, "%s()\n", __func__);
1534
1535         mutex_lock(&xc4000_list_mutex);
1536
1537         if (priv)
1538                 hybrid_tuner_release_state(priv);
1539
1540         mutex_unlock(&xc4000_list_mutex);
1541
1542         fe->tuner_priv = NULL;
1543
1544         return 0;
1545 }
1546
1547 static const struct dvb_tuner_ops xc4000_tuner_ops = {
1548         .info = {
1549                 .name           = "Xceive XC4000",
1550                 .frequency_min  =    1000000,
1551                 .frequency_max  = 1023000000,
1552                 .frequency_step =      50000,
1553         },
1554
1555         .release           = xc4000_release,
1556         .init              = xc4000_init,
1557         .sleep             = xc4000_sleep,
1558
1559         .set_params        = xc4000_set_params,
1560         .set_analog_params = xc4000_set_analog_params,
1561         .get_frequency     = xc4000_get_frequency,
1562         .get_bandwidth     = xc4000_get_bandwidth,
1563         .get_status        = xc4000_get_status
1564 };
1565
1566 struct dvb_frontend *xc4000_attach(struct dvb_frontend *fe,
1567                                    struct i2c_adapter *i2c,
1568                                    struct xc4000_config *cfg)
1569 {
1570         struct xc4000_priv *priv = NULL;
1571         int     instance;
1572         u16     id = 0;
1573
1574         dprintk(1, "%s(%d-%04x)\n", __func__,
1575                 i2c ? i2c_adapter_id(i2c) : -1,
1576                 cfg ? cfg->i2c_address : -1);
1577
1578         mutex_lock(&xc4000_list_mutex);
1579
1580         instance = hybrid_tuner_request_state(struct xc4000_priv, priv,
1581                                               hybrid_tuner_instance_list,
1582                                               i2c, cfg->i2c_address, "xc4000");
1583         switch (instance) {
1584         case 0:
1585                 goto fail;
1586                 break;
1587         case 1:
1588                 /* new tuner instance */
1589                 priv->bandwidth = 6000000;
1590                 /* set default configuration */
1591                 priv->if_khz = 4560;
1592                 priv->default_pm = 0;
1593                 priv->dvb_amplitude = 134;
1594                 priv->set_smoothedcvbs = 1;
1595                 mutex_init(&priv->lock);
1596                 fe->tuner_priv = priv;
1597                 break;
1598         default:
1599                 /* existing tuner instance */
1600                 fe->tuner_priv = priv;
1601                 break;
1602         }
1603
1604         if (cfg->if_khz != 0) {
1605                 /* copy configuration if provided by the caller */
1606                 priv->if_khz = cfg->if_khz;
1607                 priv->default_pm = cfg->default_pm;
1608                 priv->dvb_amplitude = cfg->dvb_amplitude;
1609                 priv->set_smoothedcvbs = cfg->set_smoothedcvbs;
1610         }
1611
1612         /* Check if firmware has been loaded. It is possible that another
1613            instance of the driver has loaded the firmware.
1614          */
1615
1616         if (instance == 1) {
1617                 if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1618                         goto fail;
1619         } else {
1620                 id = ((priv->cur_fw.type & BASE) != 0 ?
1621                       priv->hwmodel : XC_PRODUCT_ID_FW_NOT_LOADED);
1622         }
1623
1624         switch (id) {
1625         case XC_PRODUCT_ID_XC4000:
1626         case XC_PRODUCT_ID_XC4100:
1627                 printk(KERN_INFO
1628                         "xc4000: Successfully identified at address 0x%02x\n",
1629                         cfg->i2c_address);
1630                 printk(KERN_INFO
1631                         "xc4000: Firmware has been loaded previously\n");
1632                 break;
1633         case XC_PRODUCT_ID_FW_NOT_LOADED:
1634                 printk(KERN_INFO
1635                         "xc4000: Successfully identified at address 0x%02x\n",
1636                         cfg->i2c_address);
1637                 printk(KERN_INFO
1638                         "xc4000: Firmware has not been loaded previously\n");
1639                 break;
1640         default:
1641                 printk(KERN_ERR
1642                         "xc4000: Device not found at addr 0x%02x (0x%x)\n",
1643                         cfg->i2c_address, id);
1644                 goto fail;
1645         }
1646
1647         mutex_unlock(&xc4000_list_mutex);
1648
1649         memcpy(&fe->ops.tuner_ops, &xc4000_tuner_ops,
1650                 sizeof(struct dvb_tuner_ops));
1651
1652         if (instance == 1) {
1653                 int     ret;
1654                 mutex_lock(&priv->lock);
1655                 ret = xc4000_fwupload(fe);
1656                 mutex_unlock(&priv->lock);
1657                 if (ret != 0)
1658                         goto fail2;
1659         }
1660
1661         return fe;
1662 fail:
1663         mutex_unlock(&xc4000_list_mutex);
1664 fail2:
1665         xc4000_release(fe);
1666         return NULL;
1667 }
1668 EXPORT_SYMBOL(xc4000_attach);
1669
1670 MODULE_AUTHOR("Steven Toth, Davide Ferri");
1671 MODULE_DESCRIPTION("Xceive xc4000 silicon tuner driver");
1672 MODULE_LICENSE("GPL");