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