drivers/media/tuners/xc5000.c

   1 /*
   2  *  Driver for Xceive XC5000 "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  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/videodev2.h>
  27 #include <linux/delay.h>
  28 #include <linux/dvb/frontend.h>
  29 #include <linux/i2c.h>
  30
  31 #include "dvb_frontend.h"
  32
  33 #include "xc5000.h"
  34 #include "tuner-i2c.h"
  35
  36 static int debug;
  37 module_param(debug, int, 0644);
  38 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
  39
  40 static int no_poweroff;
  41 module_param(no_poweroff, int, 0644);
  42 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
  43         "\t\t1 keep device energized and with tuner ready all the times.\n"
  44         "\t\tFaster, but consumes more power and keeps the device hotter");
  45
  46 static DEFINE_MUTEX(xc5000_list_mutex);
  47 static LIST_HEAD(hybrid_tuner_instance_list);
  48
  49 #define dprintk(level, fmt, arg...) if (debug >= level) \
  50         printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
  51
  52 struct xc5000_priv {
  53         struct tuner_i2c_props i2c_props;
  54         struct list_head hybrid_tuner_instance_list;
  55
  56         u32 if_khz;
  57         u16 xtal_khz;
  58         u32 freq_hz, freq_offset;
  59         u32 bandwidth;
  60         u8  video_standard;
  61         u8  rf_mode;
  62         u8  radio_input;
  63
  64         int chip_id;
  65         u16 pll_register_no;
  66         u8 init_status_supported;
  67         u8 fw_checksum_supported;
  68 };
  69
  70 /* Misc Defines */
  71 #define MAX_TV_STANDARD                 24
  72 #define XC_MAX_I2C_WRITE_LENGTH         64
  73
  74 /* Signal Types */
  75 #define XC_RF_MODE_AIR                  0
  76 #define XC_RF_MODE_CABLE                1
  77
  78 /* Result codes */
  79 #define XC_RESULT_SUCCESS               0
  80 #define XC_RESULT_RESET_FAILURE         1
  81 #define XC_RESULT_I2C_WRITE_FAILURE     2
  82 #define XC_RESULT_I2C_READ_FAILURE      3
  83 #define XC_RESULT_OUT_OF_RANGE          5
  84
  85 /* Product id */
  86 #define XC_PRODUCT_ID_FW_NOT_LOADED     0x2000
  87 #define XC_PRODUCT_ID_FW_LOADED         0x1388
  88
  89 /* Registers */
  90 #define XREG_INIT         0x00
  91 #define XREG_VIDEO_MODE   0x01
  92 #define XREG_AUDIO_MODE   0x02
  93 #define XREG_RF_FREQ      0x03
  94 #define XREG_D_CODE       0x04
  95 #define XREG_IF_OUT       0x05
  96 #define XREG_SEEK_MODE    0x07
  97 #define XREG_POWER_DOWN   0x0A /* Obsolete */
  98 /* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
  99 #define XREG_OUTPUT_AMP   0x0B
 100 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
 101 #define XREG_SMOOTHEDCVBS 0x0E
 102 #define XREG_XTALFREQ     0x0F
 103 #define XREG_FINERFREQ    0x10
 104 #define XREG_DDIMODE      0x11
 105
 106 #define XREG_ADC_ENV      0x00
 107 #define XREG_QUALITY      0x01
 108 #define XREG_FRAME_LINES  0x02
 109 #define XREG_HSYNC_FREQ   0x03
 110 #define XREG_LOCK         0x04
 111 #define XREG_FREQ_ERROR   0x05
 112 #define XREG_SNR          0x06
 113 #define XREG_VERSION      0x07
 114 #define XREG_PRODUCT_ID   0x08
 115 #define XREG_BUSY         0x09
 116 #define XREG_BUILD        0x0D
 117 #define XREG_TOTALGAIN    0x0F
 118 #define XREG_FW_CHECKSUM  0x12
 119 #define XREG_INIT_STATUS  0x13
 120
 121 /*
 122    Basic firmware description. This will remain with
 123    the driver for documentation purposes.
 124
 125    This represents an I2C firmware file encoded as a
 126    string of unsigned char. Format is as follows:
 127
 128    char[0  ]=len0_MSB  -> len = len_MSB * 256 + len_LSB
 129    char[1  ]=len0_LSB  -> length of first write transaction
 130    char[2  ]=data0 -> first byte to be sent
 131    char[3  ]=data1
 132    char[4  ]=data2
 133    char[   ]=...
 134    char[M  ]=dataN  -> last byte to be sent
 135    char[M+1]=len1_MSB  -> len = len_MSB * 256 + len_LSB
 136    char[M+2]=len1_LSB  -> length of second write transaction
 137    char[M+3]=data0
 138    char[M+4]=data1
 139    ...
 140    etc.
 141
 142    The [len] value should be interpreted as follows:
 143
 144    len= len_MSB _ len_LSB
 145    len=1111_1111_1111_1111   : End of I2C_SEQUENCE
 146    len=0000_0000_0000_0000   : Reset command: Do hardware reset
 147    len=0NNN_NNNN_NNNN_NNNN   : Normal transaction: number of bytes = {1:32767)
 148    len=1WWW_WWWW_WWWW_WWWW   : Wait command: wait for {1:32767} ms
 149
 150    For the RESET and WAIT commands, the two following bytes will contain
 151    immediately the length of the following transaction.
 152
 153 */
 154 struct XC_TV_STANDARD {
 155         char *Name;
 156         u16 AudioMode;
 157         u16 VideoMode;
 158 };
 159
 160 /* Tuner standards */
 161 #define MN_NTSC_PAL_BTSC        0
 162 #define MN_NTSC_PAL_A2          1
 163 #define MN_NTSC_PAL_EIAJ        2
 164 #define MN_NTSC_PAL_Mono        3
 165 #define BG_PAL_A2               4
 166 #define BG_PAL_NICAM            5
 167 #define BG_PAL_MONO             6
 168 #define I_PAL_NICAM             7
 169 #define I_PAL_NICAM_MONO        8
 170 #define DK_PAL_A2               9
 171 #define DK_PAL_NICAM            10
 172 #define DK_PAL_MONO             11
 173 #define DK_SECAM_A2DK1          12
 174 #define DK_SECAM_A2LDK3         13
 175 #define DK_SECAM_A2MONO         14
 176 #define L_SECAM_NICAM           15
 177 #define LC_SECAM_NICAM          16
 178 #define DTV6                    17
 179 #define DTV8                    18
 180 #define DTV7_8                  19
 181 #define DTV7                    20
 182 #define FM_Radio_INPUT2         21
 183 #define FM_Radio_INPUT1         22
 184 #define FM_Radio_INPUT1_MONO    23
 185
 186 static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
 187         {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
 188         {"M/N-NTSC/PAL-A2",   0x0600, 0x8020},
 189         {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
 190         {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
 191         {"B/G-PAL-A2",        0x0A00, 0x8049},
 192         {"B/G-PAL-NICAM",     0x0C04, 0x8049},
 193         {"B/G-PAL-MONO",      0x0878, 0x8059},
 194         {"I-PAL-NICAM",       0x1080, 0x8009},
 195         {"I-PAL-NICAM-MONO",  0x0E78, 0x8009},
 196         {"D/K-PAL-A2",        0x1600, 0x8009},
 197         {"D/K-PAL-NICAM",     0x0E80, 0x8009},
 198         {"D/K-PAL-MONO",      0x1478, 0x8009},
 199         {"D/K-SECAM-A2 DK1",  0x1200, 0x8009},
 200         {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
 201         {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
 202         {"L-SECAM-NICAM",     0x8E82, 0x0009},
 203         {"L'-SECAM-NICAM",    0x8E82, 0x4009},
 204         {"DTV6",              0x00C0, 0x8002},
 205         {"DTV8",              0x00C0, 0x800B},
 206         {"DTV7/8",            0x00C0, 0x801B},
 207         {"DTV7",              0x00C0, 0x8007},
 208         {"FM Radio-INPUT2",   0x9802, 0x9002},
 209         {"FM Radio-INPUT1",   0x0208, 0x9002},
 210         {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
 211 };
 212
 213
 214 struct xc5000_fw_cfg {
 215         char *name;
 216         u16 size;
 217         u16 pll_reg;
 218         u8 init_status_supported;
 219         u8 fw_checksum_supported;
 220 };
 221
 222 #define XC5000A_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
 223 static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
 224         .name = XC5000A_FIRMWARE,
 225         .size = 12401,
 226         .pll_reg = 0x806c,
 227 };
 228
 229 #define XC5000C_FIRMWARE "dvb-fe-xc5000c-4.1.30.7.fw"
 230 static const struct xc5000_fw_cfg xc5000c_41_024_5 = {
 231         .name = XC5000C_FIRMWARE,
 232         .size = 16497,
 233         .pll_reg = 0x13,
 234         .init_status_supported = 1,
 235         .fw_checksum_supported = 1,
 236 };
 237
 238 static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
 239 {
 240         switch (chip_id) {
 241         default:
 242         case XC5000A:
 243                 return &xc5000a_1_6_114;
 244         case XC5000C:
 245                 return &xc5000c_41_024_5;
 246         }
 247 }
 248
 249 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force);
 250 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
 251 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
 252 static int xc5000_TunerReset(struct dvb_frontend *fe);
 253
 254 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
 255 {
 256         struct i2c_msg msg = { .addr = priv->i2c_props.addr,
 257                                .flags = 0, .buf = buf, .len = len };
 258
 259         if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
 260                 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
 261                 return XC_RESULT_I2C_WRITE_FAILURE;
 262         }
 263         return XC_RESULT_SUCCESS;
 264 }
 265
 266 #if 0
 267 /* This routine is never used because the only time we read data from the
 268    i2c bus is when we read registers, and we want that to be an atomic i2c
 269    transaction in case we are on a multi-master bus */
 270 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
 271 {
 272         struct i2c_msg msg = { .addr = priv->i2c_props.addr,
 273                 .flags = I2C_M_RD, .buf = buf, .len = len };
 274
 275         if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
 276                 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
 277                 return -EREMOTEIO;
 278         }
 279         return 0;
 280 }
 281 #endif
 282
 283 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
 284 {
 285         u8 buf[2] = { reg >> 8, reg & 0xff };
 286         u8 bval[2] = { 0, 0 };
 287         struct i2c_msg msg[2] = {
 288                 { .addr = priv->i2c_props.addr,
 289                         .flags = 0, .buf = &buf[0], .len = 2 },
 290                 { .addr = priv->i2c_props.addr,
 291                         .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
 292         };
 293
 294         if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
 295                 printk(KERN_WARNING "xc5000: I2C read failed\n");
 296                 return -EREMOTEIO;
 297         }
 298
 299         *val = (bval[0] << 8) | bval[1];
 300         return XC_RESULT_SUCCESS;
 301 }
 302
 303 static void xc_wait(int wait_ms)
 304 {
 305         msleep(wait_ms);
 306 }
 307
 308 static int xc5000_TunerReset(struct dvb_frontend *fe)
 309 {
 310         struct xc5000_priv *priv = fe->tuner_priv;
 311         int ret;
 312
 313         dprintk(1, "%s()\n", __func__);
 314
 315         if (fe->callback) {
 316                 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
 317                                            fe->dvb->priv :
 318                                            priv->i2c_props.adap->algo_data,
 319                                            DVB_FRONTEND_COMPONENT_TUNER,
 320                                            XC5000_TUNER_RESET, 0);
 321                 if (ret) {
 322                         printk(KERN_ERR "xc5000: reset failed\n");
 323                         return XC_RESULT_RESET_FAILURE;
 324                 }
 325         } else {
 326                 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
 327                 return XC_RESULT_RESET_FAILURE;
 328         }
 329         return XC_RESULT_SUCCESS;
 330 }
 331
 332 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
 333 {
 334         u8 buf[4];
 335         int WatchDogTimer = 100;
 336         int result;
 337
 338         buf[0] = (regAddr >> 8) & 0xFF;
 339         buf[1] = regAddr & 0xFF;
 340         buf[2] = (i2cData >> 8) & 0xFF;
 341         buf[3] = i2cData & 0xFF;
 342         result = xc_send_i2c_data(priv, buf, 4);
 343         if (result == XC_RESULT_SUCCESS) {
 344                 /* wait for busy flag to clear */
 345                 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
 346                         result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
 347                         if (result == XC_RESULT_SUCCESS) {
 348                                 if ((buf[0] == 0) && (buf[1] == 0)) {
 349                                         /* busy flag cleared */
 350                                         break;
 351                                 } else {
 352                                         xc_wait(5); /* wait 5 ms */
 353                                         WatchDogTimer--;
 354                                 }
 355                         }
 356                 }
 357         }
 358         if (WatchDogTimer <= 0)
 359                 result = XC_RESULT_I2C_WRITE_FAILURE;
 360
 361         return result;
 362 }
 363
 364 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
 365 {
 366         struct xc5000_priv *priv = fe->tuner_priv;
 367
 368         int i, nbytes_to_send, result;
 369         unsigned int len, pos, index;
 370         u8 buf[XC_MAX_I2C_WRITE_LENGTH];
 371
 372         index = 0;
 373         while ((i2c_sequence[index] != 0xFF) ||
 374                 (i2c_sequence[index + 1] != 0xFF)) {
 375                 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
 376                 if (len == 0x0000) {
 377                         /* RESET command */
 378                         result = xc5000_TunerReset(fe);
 379                         index += 2;
 380                         if (result != XC_RESULT_SUCCESS)
 381                                 return result;
 382                 } else if (len & 0x8000) {
 383                         /* WAIT command */
 384                         xc_wait(len & 0x7FFF);
 385                         index += 2;
 386                 } else {
 387                         /* Send i2c data whilst ensuring individual transactions
 388                          * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
 389                          */
 390                         index += 2;
 391                         buf[0] = i2c_sequence[index];
 392                         buf[1] = i2c_sequence[index + 1];
 393                         pos = 2;
 394                         while (pos < len) {
 395                                 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
 396                                         nbytes_to_send =
 397                                                 XC_MAX_I2C_WRITE_LENGTH;
 398                                 else
 399                                         nbytes_to_send = (len - pos + 2);
 400                                 for (i = 2; i < nbytes_to_send; i++) {
 401                                         buf[i] = i2c_sequence[index + pos +
 402                                                 i - 2];
 403                                 }
 404                                 result = xc_send_i2c_data(priv, buf,
 405                                         nbytes_to_send);
 406
 407                                 if (result != XC_RESULT_SUCCESS)
 408                                         return result;
 409
 410                                 pos += nbytes_to_send - 2;
 411                         }
 412                         index += len;
 413                 }
 414         }
 415         return XC_RESULT_SUCCESS;
 416 }
 417
 418 static int xc_initialize(struct xc5000_priv *priv)
 419 {
 420         dprintk(1, "%s()\n", __func__);
 421         return xc_write_reg(priv, XREG_INIT, 0);
 422 }
 423
 424 static int xc_SetTVStandard(struct xc5000_priv *priv,
 425         u16 VideoMode, u16 AudioMode, u8 RadioMode)
 426 {
 427         int ret;
 428         dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
 429         if (RadioMode) {
 430                 dprintk(1, "%s() Standard = %s\n",
 431                         __func__,
 432                         XC5000_Standard[RadioMode].Name);
 433         } else {
 434                 dprintk(1, "%s() Standard = %s\n",
 435                         __func__,
 436                         XC5000_Standard[priv->video_standard].Name);
 437         }
 438
 439         ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
 440         if (ret == XC_RESULT_SUCCESS)
 441                 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
 442
 443         return ret;
 444 }
 445
 446 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
 447 {
 448         dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
 449                 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
 450
 451         if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
 452                 rf_mode = XC_RF_MODE_CABLE;
 453                 printk(KERN_ERR
 454                         "%s(), Invalid mode, defaulting to CABLE",
 455                         __func__);
 456         }
 457         return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
 458 }
 459
 460 static const struct dvb_tuner_ops xc5000_tuner_ops;
 461
 462 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
 463 {
 464         u16 freq_code;
 465
 466         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 467
 468         if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
 469                 (freq_hz < xc5000_tuner_ops.info.frequency_min))
 470                 return XC_RESULT_OUT_OF_RANGE;
 471
 472         freq_code = (u16)(freq_hz / 15625);
 473
 474         /* Starting in firmware version 1.1.44, Xceive recommends using the
 475            FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
 476            only be used for fast scanning for channel lock) */
 477         return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
 478 }
 479
 480
 481 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
 482 {
 483         u32 freq_code = (freq_khz * 1024)/1000;
 484         dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
 485                 __func__, freq_khz, freq_code);
 486
 487         return xc_write_reg(priv, XREG_IF_OUT, freq_code);
 488 }
 489
 490
 491 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
 492 {
 493         return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
 494 }
 495
 496 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
 497 {
 498         int result;
 499         u16 regData;
 500         u32 tmp;
 501
 502         result = xc5000_readreg(priv, XREG_FREQ_ERROR, &regData);
 503         if (result != XC_RESULT_SUCCESS)
 504                 return result;
 505
 506         tmp = (u32)regData;
 507         (*freq_error_hz) = (tmp * 15625) / 1000;
 508         return result;
 509 }
 510
 511 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
 512 {
 513         return xc5000_readreg(priv, XREG_LOCK, lock_status);
 514 }
 515
 516 static int xc_get_version(struct xc5000_priv *priv,
 517         u8 *hw_majorversion, u8 *hw_minorversion,
 518         u8 *fw_majorversion, u8 *fw_minorversion)
 519 {
 520         u16 data;
 521         int result;
 522
 523         result = xc5000_readreg(priv, XREG_VERSION, &data);
 524         if (result != XC_RESULT_SUCCESS)
 525                 return result;
 526
 527         (*hw_majorversion) = (data >> 12) & 0x0F;
 528         (*hw_minorversion) = (data >>  8) & 0x0F;
 529         (*fw_majorversion) = (data >>  4) & 0x0F;
 530         (*fw_minorversion) = data & 0x0F;
 531
 532         return 0;
 533 }
 534
 535 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
 536 {
 537         return xc5000_readreg(priv, XREG_BUILD, buildrev);
 538 }
 539
 540 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
 541 {
 542         u16 regData;
 543         int result;
 544
 545         result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &regData);
 546         if (result != XC_RESULT_SUCCESS)
 547                 return result;
 548
 549         (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
 550         return result;
 551 }
 552
 553 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
 554 {
 555         return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
 556 }
 557
 558 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
 559 {
 560         return xc5000_readreg(priv, XREG_QUALITY, quality);
 561 }
 562
 563 static int xc_get_analogsnr(struct xc5000_priv *priv, u16 *snr)
 564 {
 565         return xc5000_readreg(priv, XREG_SNR, snr);
 566 }
 567
 568 static int xc_get_totalgain(struct xc5000_priv *priv, u16 *totalgain)
 569 {
 570         return xc5000_readreg(priv, XREG_TOTALGAIN, totalgain);
 571 }
 572
 573 static u16 WaitForLock(struct xc5000_priv *priv)
 574 {
 575         u16 lockState = 0;
 576         int watchDogCount = 40;
 577
 578         while ((lockState == 0) && (watchDogCount > 0)) {
 579                 xc_get_lock_status(priv, &lockState);
 580                 if (lockState != 1) {
 581                         xc_wait(5);
 582                         watchDogCount--;
 583                 }
 584         }
 585         return lockState;
 586 }
 587
 588 #define XC_TUNE_ANALOG  0
 589 #define XC_TUNE_DIGITAL 1
 590 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
 591 {
 592         int found = 0;
 593
 594         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 595
 596         if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
 597                 return 0;
 598
 599         if (mode == XC_TUNE_ANALOG) {
 600                 if (WaitForLock(priv) == 1)
 601                         found = 1;
 602         }
 603
 604         return found;
 605 }
 606
 607 static int xc_set_xtal(struct dvb_frontend *fe)
 608 {
 609         struct xc5000_priv *priv = fe->tuner_priv;
 610         int ret = XC_RESULT_SUCCESS;
 611
 612         switch (priv->chip_id) {
 613         default:
 614         case XC5000A:
 615                 /* 32.000 MHz xtal is default */
 616                 break;
 617         case XC5000C:
 618                 switch (priv->xtal_khz) {
 619                 default:
 620                 case 32000:
 621                         /* 32.000 MHz xtal is default */
 622                         break;
 623                 case 31875:
 624                         /* 31.875 MHz xtal configuration */
 625                         ret = xc_write_reg(priv, 0x000f, 0x8081);
 626                         break;
 627                 }
 628                 break;
 629         }
 630         return ret;
 631 }
 632
 633 static int xc5000_fwupload(struct dvb_frontend *fe)
 634 {
 635         struct xc5000_priv *priv = fe->tuner_priv;
 636         const struct firmware *fw;
 637         int ret;
 638         const struct xc5000_fw_cfg *desired_fw =
 639                 xc5000_assign_firmware(priv->chip_id);
 640         priv->pll_register_no = desired_fw->pll_reg;
 641         priv->init_status_supported = desired_fw->init_status_supported;
 642         priv->fw_checksum_supported = desired_fw->fw_checksum_supported;
 643
 644         /* request the firmware, this will block and timeout */
 645         printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
 646                 desired_fw->name);
 647
 648         ret = request_firmware(&fw, desired_fw->name,
 649                 priv->i2c_props.adap->dev.parent);
 650         if (ret) {
 651                 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
 652                 ret = XC_RESULT_RESET_FAILURE;
 653                 goto out;
 654         } else {
 655                 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
 656                        fw->size);
 657                 ret = XC_RESULT_SUCCESS;
 658         }
 659
 660         if (fw->size != desired_fw->size) {
 661                 printk(KERN_ERR "xc5000: firmware incorrect size\n");
 662                 ret = XC_RESULT_RESET_FAILURE;
 663         } else {
 664                 printk(KERN_INFO "xc5000: firmware uploading...\n");
 665                 ret = xc_load_i2c_sequence(fe,  fw->data);
 666                 if (XC_RESULT_SUCCESS == ret)
 667                         ret = xc_set_xtal(fe);
 668                 if (XC_RESULT_SUCCESS == ret)
 669                         printk(KERN_INFO "xc5000: firmware upload complete...\n");
 670                 else
 671                         printk(KERN_ERR "xc5000: firmware upload failed...\n");
 672         }
 673
 674 out:
 675         release_firmware(fw);
 676         return ret;
 677 }
 678
 679 static void xc_debug_dump(struct xc5000_priv *priv)
 680 {
 681         u16 adc_envelope;
 682         u32 freq_error_hz = 0;
 683         u16 lock_status;
 684         u32 hsync_freq_hz = 0;
 685         u16 frame_lines;
 686         u16 quality;
 687         u16 snr;
 688         u16 totalgain;
 689         u8 hw_majorversion = 0, hw_minorversion = 0;
 690         u8 fw_majorversion = 0, fw_minorversion = 0;
 691         u16 fw_buildversion = 0;
 692         u16 regval;
 693
 694         /* Wait for stats to stabilize.
 695          * Frame Lines needs two frame times after initial lock
 696          * before it is valid.
 697          */
 698         xc_wait(100);
 699
 700         xc_get_ADC_Envelope(priv,  &adc_envelope);
 701         dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
 702
 703         xc_get_frequency_error(priv, &freq_error_hz);
 704         dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
 705
 706         xc_get_lock_status(priv,  &lock_status);
 707         dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
 708                 lock_status);
 709
 710         xc_get_version(priv,  &hw_majorversion, &hw_minorversion,
 711                 &fw_majorversion, &fw_minorversion);
 712         xc_get_buildversion(priv,  &fw_buildversion);
 713         dprintk(1, "*** HW: V%d.%d, FW: V %d.%d.%d\n",
 714                 hw_majorversion, hw_minorversion,
 715                 fw_majorversion, fw_minorversion, fw_buildversion);
 716
 717         xc_get_hsync_freq(priv,  &hsync_freq_hz);
 718         dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
 719
 720         xc_get_frame_lines(priv,  &frame_lines);
 721         dprintk(1, "*** Frame lines = %d\n", frame_lines);
 722
 723         xc_get_quality(priv,  &quality);
 724         dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality & 0x07);
 725
 726         xc_get_analogsnr(priv,  &snr);
 727         dprintk(1, "*** Unweighted analog SNR = %d dB\n", snr & 0x3f);
 728
 729         xc_get_totalgain(priv,  &totalgain);
 730         dprintk(1, "*** Total gain = %d.%d dB\n", totalgain / 256,
 731                 (totalgain % 256) * 100 / 256);
 732
 733         if (priv->pll_register_no) {
 734                 xc5000_readreg(priv, priv->pll_register_no, &regval);
 735                 dprintk(1, "*** PLL lock status = 0x%04x\n", regval);
 736         }
 737 }
 738
 739 static int xc5000_set_params(struct dvb_frontend *fe)
 740 {
 741         int ret, b;
 742         struct xc5000_priv *priv = fe->tuner_priv;
 743         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 744         u32 freq = fe->dtv_property_cache.frequency;
 745         u32 delsys  = fe->dtv_property_cache.delivery_system;
 746
 747         if (xc_load_fw_and_init_tuner(fe, 0) != XC_RESULT_SUCCESS) {
 748                 dprintk(1, "Unable to load firmware and init tuner\n");
 749                 return -EINVAL;
 750         }
 751
 752         dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
 753
 754         switch (delsys) {
 755         case SYS_ATSC:
 756                 dprintk(1, "%s() VSB modulation\n", __func__);
 757                 priv->rf_mode = XC_RF_MODE_AIR;
 758                 priv->freq_offset = 1750000;
 759                 priv->video_standard = DTV6;
 760                 break;
 761         case SYS_DVBC_ANNEX_B:
 762                 dprintk(1, "%s() QAM modulation\n", __func__);
 763                 priv->rf_mode = XC_RF_MODE_CABLE;
 764                 priv->freq_offset = 1750000;
 765                 priv->video_standard = DTV6;
 766                 break;
 767         case SYS_ISDBT:
 768                 /* All ISDB-T are currently for 6 MHz bw */
 769                 if (!bw)
 770                         bw = 6000000;
 771                 /* fall to OFDM handling */
 772         case SYS_DMBTH:
 773         case SYS_DVBT:
 774         case SYS_DVBT2:
 775                 dprintk(1, "%s() OFDM\n", __func__);
 776                 switch (bw) {
 777                 case 6000000:
 778                         priv->video_standard = DTV6;
 779                         priv->freq_offset = 1750000;
 780                         break;
 781                 case 7000000:
 782                         priv->video_standard = DTV7;
 783                         priv->freq_offset = 2250000;
 784                         break;
 785                 case 8000000:
 786                         priv->video_standard = DTV8;
 787                         priv->freq_offset = 2750000;
 788                         break;
 789                 default:
 790                         printk(KERN_ERR "xc5000 bandwidth not set!\n");
 791                         return -EINVAL;
 792                 }
 793                 priv->rf_mode = XC_RF_MODE_AIR;
 794                 break;
 795         case SYS_DVBC_ANNEX_A:
 796         case SYS_DVBC_ANNEX_C:
 797                 dprintk(1, "%s() QAM modulation\n", __func__);
 798                 priv->rf_mode = XC_RF_MODE_CABLE;
 799                 if (bw <= 6000000) {
 800                         priv->video_standard = DTV6;
 801                         priv->freq_offset = 1750000;
 802                         b = 6;
 803                 } else if (bw <= 7000000) {
 804                         priv->video_standard = DTV7;
 805                         priv->freq_offset = 2250000;
 806                         b = 7;
 807                 } else {
 808                         priv->video_standard = DTV7_8;
 809                         priv->freq_offset = 2750000;
 810                         b = 8;
 811                 }
 812                 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
 813                         b, bw);
 814                 break;
 815         default:
 816                 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
 817                 return -EINVAL;
 818         }
 819
 820         priv->freq_hz = freq - priv->freq_offset;
 821
 822         dprintk(1, "%s() frequency=%d (compensated to %d)\n",
 823                 __func__, freq, priv->freq_hz);
 824
 825         ret = xc_SetSignalSource(priv, priv->rf_mode);
 826         if (ret != XC_RESULT_SUCCESS) {
 827                 printk(KERN_ERR
 828                         "xc5000: xc_SetSignalSource(%d) failed\n",
 829                         priv->rf_mode);
 830                 return -EREMOTEIO;
 831         }
 832
 833         ret = xc_SetTVStandard(priv,
 834                 XC5000_Standard[priv->video_standard].VideoMode,
 835                 XC5000_Standard[priv->video_standard].AudioMode, 0);
 836         if (ret != XC_RESULT_SUCCESS) {
 837                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 838                 return -EREMOTEIO;
 839         }
 840
 841         ret = xc_set_IF_frequency(priv, priv->if_khz);
 842         if (ret != XC_RESULT_SUCCESS) {
 843                 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
 844                        priv->if_khz);
 845                 return -EIO;
 846         }
 847
 848         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
 849
 850         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
 851
 852         if (debug)
 853                 xc_debug_dump(priv);
 854
 855         priv->bandwidth = bw;
 856
 857         return 0;
 858 }
 859
 860 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
 861 {
 862         struct xc5000_priv *priv = fe->tuner_priv;
 863         int ret;
 864         u16 id;
 865
 866         ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
 867         if (ret == XC_RESULT_SUCCESS) {
 868                 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
 869                         ret = XC_RESULT_RESET_FAILURE;
 870                 else
 871                         ret = XC_RESULT_SUCCESS;
 872         }
 873
 874         dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
 875                 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
 876         return ret;
 877 }
 878
 879 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
 880         struct analog_parameters *params)
 881 {
 882         struct xc5000_priv *priv = fe->tuner_priv;
 883         u16 pll_lock_status;
 884         int ret;
 885
 886         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
 887                 __func__, params->frequency);
 888
 889         /* Fix me: it could be air. */
 890         priv->rf_mode = params->mode;
 891         if (params->mode > XC_RF_MODE_CABLE)
 892                 priv->rf_mode = XC_RF_MODE_CABLE;
 893
 894         /* params->frequency is in units of 62.5khz */
 895         priv->freq_hz = params->frequency * 62500;
 896
 897         /* FIX ME: Some video standards may have several possible audio
 898                    standards. We simply default to one of them here.
 899          */
 900         if (params->std & V4L2_STD_MN) {
 901                 /* default to BTSC audio standard */
 902                 priv->video_standard = MN_NTSC_PAL_BTSC;
 903                 goto tune_channel;
 904         }
 905
 906         if (params->std & V4L2_STD_PAL_BG) {
 907                 /* default to NICAM audio standard */
 908                 priv->video_standard = BG_PAL_NICAM;
 909                 goto tune_channel;
 910         }
 911
 912         if (params->std & V4L2_STD_PAL_I) {
 913                 /* default to NICAM audio standard */
 914                 priv->video_standard = I_PAL_NICAM;
 915                 goto tune_channel;
 916         }
 917
 918         if (params->std & V4L2_STD_PAL_DK) {
 919                 /* default to NICAM audio standard */
 920                 priv->video_standard = DK_PAL_NICAM;
 921                 goto tune_channel;
 922         }
 923
 924         if (params->std & V4L2_STD_SECAM_DK) {
 925                 /* default to A2 DK1 audio standard */
 926                 priv->video_standard = DK_SECAM_A2DK1;
 927                 goto tune_channel;
 928         }
 929
 930         if (params->std & V4L2_STD_SECAM_L) {
 931                 priv->video_standard = L_SECAM_NICAM;
 932                 goto tune_channel;
 933         }
 934
 935         if (params->std & V4L2_STD_SECAM_LC) {
 936                 priv->video_standard = LC_SECAM_NICAM;
 937                 goto tune_channel;
 938         }
 939
 940 tune_channel:
 941         ret = xc_SetSignalSource(priv, priv->rf_mode);
 942         if (ret != XC_RESULT_SUCCESS) {
 943                 printk(KERN_ERR
 944                         "xc5000: xc_SetSignalSource(%d) failed\n",
 945                         priv->rf_mode);
 946                 return -EREMOTEIO;
 947         }
 948
 949         ret = xc_SetTVStandard(priv,
 950                 XC5000_Standard[priv->video_standard].VideoMode,
 951                 XC5000_Standard[priv->video_standard].AudioMode, 0);
 952         if (ret != XC_RESULT_SUCCESS) {
 953                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 954                 return -EREMOTEIO;
 955         }
 956
 957         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
 958
 959         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 960
 961         if (debug)
 962                 xc_debug_dump(priv);
 963
 964         if (priv->pll_register_no != 0) {
 965                 msleep(20);
 966                 xc5000_readreg(priv, priv->pll_register_no, &pll_lock_status);
 967                 if (pll_lock_status > 63) {
 968                         /* PLL is unlocked, force reload of the firmware */
 969                         dprintk(1, "xc5000: PLL not locked (0x%x).  Reloading...\n",
 970                                 pll_lock_status);
 971                         if (xc_load_fw_and_init_tuner(fe, 1) != XC_RESULT_SUCCESS) {
 972                                 printk(KERN_ERR "xc5000: Unable to reload fw\n");
 973                                 return -EREMOTEIO;
 974                         }
 975                         goto tune_channel;
 976                 }
 977         }
 978
 979         return 0;
 980 }
 981
 982 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
 983         struct analog_parameters *params)
 984 {
 985         struct xc5000_priv *priv = fe->tuner_priv;
 986         int ret = -EINVAL;
 987         u8 radio_input;
 988
 989         dprintk(1, "%s() frequency=%d (in units of khz)\n",
 990                 __func__, params->frequency);
 991
 992         if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
 993                 dprintk(1, "%s() radio input not configured\n", __func__);
 994                 return -EINVAL;
 995         }
 996
 997         if (priv->radio_input == XC5000_RADIO_FM1)
 998                 radio_input = FM_Radio_INPUT1;
 999         else if  (priv->radio_input == XC5000_RADIO_FM2)
1000                 radio_input = FM_Radio_INPUT2;
1001         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
1002                 radio_input = FM_Radio_INPUT1_MONO;
1003         else {
1004                 dprintk(1, "%s() unknown radio input %d\n", __func__,
1005                         priv->radio_input);
1006                 return -EINVAL;
1007         }
1008
1009         priv->freq_hz = params->frequency * 125 / 2;
1010
1011         priv->rf_mode = XC_RF_MODE_AIR;
1012
1013         ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
1014                                XC5000_Standard[radio_input].AudioMode, radio_input);
1015
1016         if (ret != XC_RESULT_SUCCESS) {
1017                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
1018                 return -EREMOTEIO;
1019         }
1020
1021         ret = xc_SetSignalSource(priv, priv->rf_mode);
1022         if (ret != XC_RESULT_SUCCESS) {
1023                 printk(KERN_ERR
1024                         "xc5000: xc_SetSignalSource(%d) failed\n",
1025                         priv->rf_mode);
1026                 return -EREMOTEIO;
1027         }
1028
1029         if ((priv->radio_input == XC5000_RADIO_FM1) ||
1030                                 (priv->radio_input == XC5000_RADIO_FM2))
1031                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
1032         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
1033                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
1034
1035         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
1036
1037         return 0;
1038 }
1039
1040 static int xc5000_set_analog_params(struct dvb_frontend *fe,
1041                              struct analog_parameters *params)
1042 {
1043         struct xc5000_priv *priv = fe->tuner_priv;
1044         int ret = -EINVAL;
1045
1046         if (priv->i2c_props.adap == NULL)
1047                 return -EINVAL;
1048
1049         if (xc_load_fw_and_init_tuner(fe, 0) != XC_RESULT_SUCCESS) {
1050                 dprintk(1, "Unable to load firmware and init tuner\n");
1051                 return -EINVAL;
1052         }
1053
1054         switch (params->mode) {
1055         case V4L2_TUNER_RADIO:
1056                 ret = xc5000_set_radio_freq(fe, params);
1057                 break;
1058         case V4L2_TUNER_ANALOG_TV:
1059         case V4L2_TUNER_DIGITAL_TV:
1060                 ret = xc5000_set_tv_freq(fe, params);
1061                 break;
1062         }
1063
1064         return ret;
1065 }
1066
1067
1068 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1069 {
1070         struct xc5000_priv *priv = fe->tuner_priv;
1071         dprintk(1, "%s()\n", __func__);
1072         *freq = priv->freq_hz + priv->freq_offset;
1073         return 0;
1074 }
1075
1076 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1077 {
1078         struct xc5000_priv *priv = fe->tuner_priv;
1079         dprintk(1, "%s()\n", __func__);
1080         *freq = priv->if_khz * 1000;
1081         return 0;
1082 }
1083
1084 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1085 {
1086         struct xc5000_priv *priv = fe->tuner_priv;
1087         dprintk(1, "%s()\n", __func__);
1088
1089         *bw = priv->bandwidth;
1090         return 0;
1091 }
1092
1093 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1094 {
1095         struct xc5000_priv *priv = fe->tuner_priv;
1096         u16 lock_status = 0;
1097
1098         xc_get_lock_status(priv, &lock_status);
1099
1100         dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1101
1102         *status = lock_status;
1103
1104         return 0;
1105 }
1106
1107 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force)
1108 {
1109         struct xc5000_priv *priv = fe->tuner_priv;
1110         int ret = XC_RESULT_SUCCESS;
1111         u16 pll_lock_status;
1112         u16 fw_ck;
1113
1114         if (force || xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
1115
1116 fw_retry:
1117
1118                 ret = xc5000_fwupload(fe);
1119                 if (ret != XC_RESULT_SUCCESS)
1120                         return ret;
1121
1122                 msleep(20);
1123
1124                 if (priv->fw_checksum_supported) {
1125                         if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck)
1126                             != XC_RESULT_SUCCESS) {
1127                                 dprintk(1, "%s() FW checksum reading failed.\n",
1128                                         __func__);
1129                                 goto fw_retry;
1130                         }
1131
1132                         if (fw_ck == 0) {
1133                                 dprintk(1, "%s() FW checksum failed = 0x%04x\n",
1134                                         __func__, fw_ck);
1135                                 goto fw_retry;
1136                         }
1137                 }
1138
1139                 /* Start the tuner self-calibration process */
1140                 ret |= xc_initialize(priv);
1141
1142                 if (ret != XC_RESULT_SUCCESS)
1143                         goto fw_retry;
1144
1145                 /* Wait for calibration to complete.
1146                  * We could continue but XC5000 will clock stretch subsequent
1147                  * I2C transactions until calibration is complete.  This way we
1148                  * don't have to rely on clock stretching working.
1149                  */
1150                 xc_wait(100);
1151
1152                 if (priv->init_status_supported) {
1153                         if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck) != XC_RESULT_SUCCESS) {
1154                                 dprintk(1, "%s() FW failed reading init status.\n",
1155                                         __func__);
1156                                 goto fw_retry;
1157                         }
1158
1159                         if (fw_ck == 0) {
1160                                 dprintk(1, "%s() FW init status failed = 0x%04x\n", __func__, fw_ck);
1161                                 goto fw_retry;
1162                         }
1163                 }
1164
1165                 if (priv->pll_register_no) {
1166                         xc5000_readreg(priv, priv->pll_register_no,
1167                                        &pll_lock_status);
1168                         if (pll_lock_status > 63) {
1169                                 /* PLL is unlocked, force reload of the firmware */
1170                                 printk(KERN_ERR "xc5000: PLL not running after fwload.\n");
1171                                 goto fw_retry;
1172                         }
1173                 }
1174
1175                 /* Default to "CABLE" mode */
1176                 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1177         }
1178
1179         return ret;
1180 }
1181
1182 static int xc5000_sleep(struct dvb_frontend *fe)
1183 {
1184         int ret;
1185
1186         dprintk(1, "%s()\n", __func__);
1187
1188         /* Avoid firmware reload on slow devices */
1189         if (no_poweroff)
1190                 return 0;
1191
1192         /* According to Xceive technical support, the "powerdown" register
1193            was removed in newer versions of the firmware.  The "supported"
1194            way to sleep the tuner is to pull the reset pin low for 10ms */
1195         ret = xc5000_TunerReset(fe);
1196         if (ret != XC_RESULT_SUCCESS) {
1197                 printk(KERN_ERR
1198                         "xc5000: %s() unable to shutdown tuner\n",
1199                         __func__);
1200                 return -EREMOTEIO;
1201         } else
1202                 return XC_RESULT_SUCCESS;
1203 }
1204
1205 static int xc5000_init(struct dvb_frontend *fe)
1206 {
1207         struct xc5000_priv *priv = fe->tuner_priv;
1208         dprintk(1, "%s()\n", __func__);
1209
1210         if (xc_load_fw_and_init_tuner(fe, 0) != XC_RESULT_SUCCESS) {
1211                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1212                 return -EREMOTEIO;
1213         }
1214
1215         if (debug)
1216                 xc_debug_dump(priv);
1217
1218         return 0;
1219 }
1220
1221 static int xc5000_release(struct dvb_frontend *fe)
1222 {
1223         struct xc5000_priv *priv = fe->tuner_priv;
1224
1225         dprintk(1, "%s()\n", __func__);
1226
1227         mutex_lock(&xc5000_list_mutex);
1228
1229         if (priv)
1230                 hybrid_tuner_release_state(priv);
1231
1232         mutex_unlock(&xc5000_list_mutex);
1233
1234         fe->tuner_priv = NULL;
1235
1236         return 0;
1237 }
1238
1239 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1240 {
1241         struct xc5000_priv *priv = fe->tuner_priv;
1242         struct xc5000_config *p = priv_cfg;
1243
1244         dprintk(1, "%s()\n", __func__);
1245
1246         if (p->if_khz)
1247                 priv->if_khz = p->if_khz;
1248
1249         if (p->radio_input)
1250                 priv->radio_input = p->radio_input;
1251
1252         return 0;
1253 }
1254
1255
1256 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1257         .info = {
1258                 .name           = "Xceive XC5000",
1259                 .frequency_min  =    1000000,
1260                 .frequency_max  = 1023000000,
1261                 .frequency_step =      50000,
1262         },
1263
1264         .release           = xc5000_release,
1265         .init              = xc5000_init,
1266         .sleep             = xc5000_sleep,
1267
1268         .set_config        = xc5000_set_config,
1269         .set_params        = xc5000_set_params,
1270         .set_analog_params = xc5000_set_analog_params,
1271         .get_frequency     = xc5000_get_frequency,
1272         .get_if_frequency  = xc5000_get_if_frequency,
1273         .get_bandwidth     = xc5000_get_bandwidth,
1274         .get_status        = xc5000_get_status
1275 };
1276
1277 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1278                                    struct i2c_adapter *i2c,
1279                                    const struct xc5000_config *cfg)
1280 {
1281         struct xc5000_priv *priv = NULL;
1282         int instance;
1283         u16 id = 0;
1284
1285         dprintk(1, "%s(%d-%04x)\n", __func__,
1286                 i2c ? i2c_adapter_id(i2c) : -1,
1287                 cfg ? cfg->i2c_address : -1);
1288
1289         mutex_lock(&xc5000_list_mutex);
1290
1291         instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1292                                               hybrid_tuner_instance_list,
1293                                               i2c, cfg->i2c_address, "xc5000");
1294         switch (instance) {
1295         case 0:
1296                 goto fail;
1297                 break;
1298         case 1:
1299                 /* new tuner instance */
1300                 priv->bandwidth = 6000000;
1301                 fe->tuner_priv = priv;
1302                 break;
1303         default:
1304                 /* existing tuner instance */
1305                 fe->tuner_priv = priv;
1306                 break;
1307         }
1308
1309         if (priv->if_khz == 0) {
1310                 /* If the IF hasn't been set yet, use the value provided by
1311                    the caller (occurs in hybrid devices where the analog
1312                    call to xc5000_attach occurs before the digital side) */
1313                 priv->if_khz = cfg->if_khz;
1314         }
1315
1316         if (priv->xtal_khz == 0)
1317                 priv->xtal_khz = cfg->xtal_khz;
1318
1319         if (priv->radio_input == 0)
1320                 priv->radio_input = cfg->radio_input;
1321
1322         /* don't override chip id if it's already been set
1323            unless explicitly specified */
1324         if ((priv->chip_id == 0) || (cfg->chip_id))
1325                 /* use default chip id if none specified, set to 0 so
1326                    it can be overridden if this is a hybrid driver */
1327                 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1328
1329         /* Check if firmware has been loaded. It is possible that another
1330            instance of the driver has loaded the firmware.
1331          */
1332         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1333                 goto fail;
1334
1335         switch (id) {
1336         case XC_PRODUCT_ID_FW_LOADED:
1337                 printk(KERN_INFO
1338                         "xc5000: Successfully identified at address 0x%02x\n",
1339                         cfg->i2c_address);
1340                 printk(KERN_INFO
1341                         "xc5000: Firmware has been loaded previously\n");
1342                 break;
1343         case XC_PRODUCT_ID_FW_NOT_LOADED:
1344                 printk(KERN_INFO
1345                         "xc5000: Successfully identified at address 0x%02x\n",
1346                         cfg->i2c_address);
1347                 printk(KERN_INFO
1348                         "xc5000: Firmware has not been loaded previously\n");
1349                 break;
1350         default:
1351                 printk(KERN_ERR
1352                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1353                         cfg->i2c_address, id);
1354                 goto fail;
1355         }
1356
1357         mutex_unlock(&xc5000_list_mutex);
1358
1359         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1360                 sizeof(struct dvb_tuner_ops));
1361
1362         return fe;
1363 fail:
1364         mutex_unlock(&xc5000_list_mutex);
1365
1366         xc5000_release(fe);
1367         return NULL;
1368 }
1369 EXPORT_SYMBOL(xc5000_attach);
1370
1371 MODULE_AUTHOR("Steven Toth");
1372 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1373 MODULE_LICENSE("GPL");
1374 MODULE_FIRMWARE(XC5000A_FIRMWARE);
1375 MODULE_FIRMWARE(XC5000C_FIRMWARE);