drivers/media/common/tuners/xc4000.c

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