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_DVBT:
 721         case SYS_DVBT2:
 722                 dprintk(1, "%s() OFDM\n", __func__);
 723                 switch (bw) {
 724                 case 6000000:
 725                         priv->video_standard = DTV6;
 726                         priv->freq_hz = freq - 1750000;
 727                         break;
 728                 case 7000000:
 729                         priv->video_standard = DTV7;
 730                         priv->freq_hz = freq - 2250000;
 731                         break;
 732                 case 8000000:
 733                         priv->video_standard = DTV8;
 734                         priv->freq_hz = freq - 2750000;
 735                         break;
 736                 default:
 737                         printk(KERN_ERR "xc5000 bandwidth not set!\n");
 738                         return -EINVAL;
 739                 }
 740                 priv->rf_mode = XC_RF_MODE_AIR;
 741         case SYS_DVBC_ANNEX_A:
 742         case SYS_DVBC_ANNEX_C:
 743                 dprintk(1, "%s() QAM modulation\n", __func__);
 744                 priv->rf_mode = XC_RF_MODE_CABLE;
 745                 if (bw <= 6000000) {
 746                         priv->video_standard = DTV6;
 747                         priv->freq_hz = freq - 1750000;
 748                         b = 6;
 749                 } else if (bw <= 7000000) {
 750                         priv->video_standard = DTV7;
 751                         priv->freq_hz = freq - 2250000;
 752                         b = 7;
 753                 } else {
 754                         priv->video_standard = DTV7_8;
 755                         priv->freq_hz = freq - 2750000;
 756                         b = 8;
 757                 }
 758                 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
 759                         b, bw);
 760                 break;
 761         default:
 762                 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
 763                 return -EINVAL;
 764         }
 765
 766         dprintk(1, "%s() frequency=%d (compensated to %d)\n",
 767                 __func__, freq, priv->freq_hz);
 768
 769         ret = xc_SetSignalSource(priv, priv->rf_mode);
 770         if (ret != XC_RESULT_SUCCESS) {
 771                 printk(KERN_ERR
 772                         "xc5000: xc_SetSignalSource(%d) failed\n",
 773                         priv->rf_mode);
 774                 return -EREMOTEIO;
 775         }
 776
 777         ret = xc_SetTVStandard(priv,
 778                 XC5000_Standard[priv->video_standard].VideoMode,
 779                 XC5000_Standard[priv->video_standard].AudioMode);
 780         if (ret != XC_RESULT_SUCCESS) {
 781                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 782                 return -EREMOTEIO;
 783         }
 784
 785         ret = xc_set_IF_frequency(priv, priv->if_khz);
 786         if (ret != XC_RESULT_SUCCESS) {
 787                 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
 788                        priv->if_khz);
 789                 return -EIO;
 790         }
 791
 792         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
 793
 794         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
 795
 796         if (debug)
 797                 xc_debug_dump(priv);
 798
 799         priv->bandwidth = bw;
 800
 801         return 0;
 802 }
 803
 804 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
 805 {
 806         struct xc5000_priv *priv = fe->tuner_priv;
 807         int ret;
 808         u16 id;
 809
 810         ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
 811         if (ret == XC_RESULT_SUCCESS) {
 812                 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
 813                         ret = XC_RESULT_RESET_FAILURE;
 814                 else
 815                         ret = XC_RESULT_SUCCESS;
 816         }
 817
 818         dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
 819                 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
 820         return ret;
 821 }
 822
 823 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
 824         struct analog_parameters *params)
 825 {
 826         struct xc5000_priv *priv = fe->tuner_priv;
 827         int ret;
 828
 829         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
 830                 __func__, params->frequency);
 831
 832         /* Fix me: it could be air. */
 833         priv->rf_mode = params->mode;
 834         if (params->mode > XC_RF_MODE_CABLE)
 835                 priv->rf_mode = XC_RF_MODE_CABLE;
 836
 837         /* params->frequency is in units of 62.5khz */
 838         priv->freq_hz = params->frequency * 62500;
 839
 840         /* FIX ME: Some video standards may have several possible audio
 841                    standards. We simply default to one of them here.
 842          */
 843         if (params->std & V4L2_STD_MN) {
 844                 /* default to BTSC audio standard */
 845                 priv->video_standard = MN_NTSC_PAL_BTSC;
 846                 goto tune_channel;
 847         }
 848
 849         if (params->std & V4L2_STD_PAL_BG) {
 850                 /* default to NICAM audio standard */
 851                 priv->video_standard = BG_PAL_NICAM;
 852                 goto tune_channel;
 853         }
 854
 855         if (params->std & V4L2_STD_PAL_I) {
 856                 /* default to NICAM audio standard */
 857                 priv->video_standard = I_PAL_NICAM;
 858                 goto tune_channel;
 859         }
 860
 861         if (params->std & V4L2_STD_PAL_DK) {
 862                 /* default to NICAM audio standard */
 863                 priv->video_standard = DK_PAL_NICAM;
 864                 goto tune_channel;
 865         }
 866
 867         if (params->std & V4L2_STD_SECAM_DK) {
 868                 /* default to A2 DK1 audio standard */
 869                 priv->video_standard = DK_SECAM_A2DK1;
 870                 goto tune_channel;
 871         }
 872
 873         if (params->std & V4L2_STD_SECAM_L) {
 874                 priv->video_standard = L_SECAM_NICAM;
 875                 goto tune_channel;
 876         }
 877
 878         if (params->std & V4L2_STD_SECAM_LC) {
 879                 priv->video_standard = LC_SECAM_NICAM;
 880                 goto tune_channel;
 881         }
 882
 883 tune_channel:
 884         ret = xc_SetSignalSource(priv, priv->rf_mode);
 885         if (ret != XC_RESULT_SUCCESS) {
 886                 printk(KERN_ERR
 887                         "xc5000: xc_SetSignalSource(%d) failed\n",
 888                         priv->rf_mode);
 889                 return -EREMOTEIO;
 890         }
 891
 892         ret = xc_SetTVStandard(priv,
 893                 XC5000_Standard[priv->video_standard].VideoMode,
 894                 XC5000_Standard[priv->video_standard].AudioMode);
 895         if (ret != XC_RESULT_SUCCESS) {
 896                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 897                 return -EREMOTEIO;
 898         }
 899
 900         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
 901
 902         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 903
 904         if (debug)
 905                 xc_debug_dump(priv);
 906
 907         return 0;
 908 }
 909
 910 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
 911         struct analog_parameters *params)
 912 {
 913         struct xc5000_priv *priv = fe->tuner_priv;
 914         int ret = -EINVAL;
 915         u8 radio_input;
 916
 917         dprintk(1, "%s() frequency=%d (in units of khz)\n",
 918                 __func__, params->frequency);
 919
 920         if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
 921                 dprintk(1, "%s() radio input not configured\n", __func__);
 922                 return -EINVAL;
 923         }
 924
 925         if (priv->radio_input == XC5000_RADIO_FM1)
 926                 radio_input = FM_Radio_INPUT1;
 927         else if  (priv->radio_input == XC5000_RADIO_FM2)
 928                 radio_input = FM_Radio_INPUT2;
 929         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
 930                 radio_input = FM_Radio_INPUT1_MONO;
 931         else {
 932                 dprintk(1, "%s() unknown radio input %d\n", __func__,
 933                         priv->radio_input);
 934                 return -EINVAL;
 935         }
 936
 937         priv->freq_hz = params->frequency * 125 / 2;
 938
 939         priv->rf_mode = XC_RF_MODE_AIR;
 940
 941         ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
 942                                XC5000_Standard[radio_input].AudioMode);
 943
 944         if (ret != XC_RESULT_SUCCESS) {
 945                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 946                 return -EREMOTEIO;
 947         }
 948
 949         ret = xc_SetSignalSource(priv, priv->rf_mode);
 950         if (ret != XC_RESULT_SUCCESS) {
 951                 printk(KERN_ERR
 952                         "xc5000: xc_SetSignalSource(%d) failed\n",
 953                         priv->rf_mode);
 954                 return -EREMOTEIO;
 955         }
 956
 957         if ((priv->radio_input == XC5000_RADIO_FM1) ||
 958                                 (priv->radio_input == XC5000_RADIO_FM2))
 959                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
 960         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
 961                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
 962
 963         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 964
 965         return 0;
 966 }
 967
 968 static int xc5000_set_analog_params(struct dvb_frontend *fe,
 969                              struct analog_parameters *params)
 970 {
 971         struct xc5000_priv *priv = fe->tuner_priv;
 972         int ret = -EINVAL;
 973
 974         if (priv->i2c_props.adap == NULL)
 975                 return -EINVAL;
 976
 977         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
 978                 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
 979                         dprintk(1, "Unable to load firmware and init tuner\n");
 980                         return -EINVAL;
 981                 }
 982         }
 983
 984         switch (params->mode) {
 985         case V4L2_TUNER_RADIO:
 986                 ret = xc5000_set_radio_freq(fe, params);
 987                 break;
 988         case V4L2_TUNER_ANALOG_TV:
 989         case V4L2_TUNER_DIGITAL_TV:
 990                 ret = xc5000_set_tv_freq(fe, params);
 991                 break;
 992         }
 993
 994         return ret;
 995 }
 996
 997
 998 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
 999 {
1000         struct xc5000_priv *priv = fe->tuner_priv;
1001         dprintk(1, "%s()\n", __func__);
1002         *freq = priv->freq_hz;
1003         return 0;
1004 }
1005
1006 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1007 {
1008         struct xc5000_priv *priv = fe->tuner_priv;
1009         dprintk(1, "%s()\n", __func__);
1010         *freq = priv->if_khz * 1000;
1011         return 0;
1012 }
1013
1014 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1015 {
1016         struct xc5000_priv *priv = fe->tuner_priv;
1017         dprintk(1, "%s()\n", __func__);
1018
1019         *bw = priv->bandwidth;
1020         return 0;
1021 }
1022
1023 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1024 {
1025         struct xc5000_priv *priv = fe->tuner_priv;
1026         u16 lock_status = 0;
1027
1028         xc_get_lock_status(priv, &lock_status);
1029
1030         dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1031
1032         *status = lock_status;
1033
1034         return 0;
1035 }
1036
1037 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
1038 {
1039         struct xc5000_priv *priv = fe->tuner_priv;
1040         int ret = 0;
1041
1042         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
1043                 ret = xc5000_fwupload(fe);
1044                 if (ret != XC_RESULT_SUCCESS)
1045                         return ret;
1046         }
1047
1048         /* Start the tuner self-calibration process */
1049         ret |= xc_initialize(priv);
1050
1051         /* Wait for calibration to complete.
1052          * We could continue but XC5000 will clock stretch subsequent
1053          * I2C transactions until calibration is complete.  This way we
1054          * don't have to rely on clock stretching working.
1055          */
1056         xc_wait(100);
1057
1058         /* Default to "CABLE" mode */
1059         ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1060
1061         return ret;
1062 }
1063
1064 static int xc5000_sleep(struct dvb_frontend *fe)
1065 {
1066         int ret;
1067
1068         dprintk(1, "%s()\n", __func__);
1069
1070         /* Avoid firmware reload on slow devices */
1071         if (no_poweroff)
1072                 return 0;
1073
1074         /* According to Xceive technical support, the "powerdown" register
1075            was removed in newer versions of the firmware.  The "supported"
1076            way to sleep the tuner is to pull the reset pin low for 10ms */
1077         ret = xc5000_TunerReset(fe);
1078         if (ret != XC_RESULT_SUCCESS) {
1079                 printk(KERN_ERR
1080                         "xc5000: %s() unable to shutdown tuner\n",
1081                         __func__);
1082                 return -EREMOTEIO;
1083         } else
1084                 return XC_RESULT_SUCCESS;
1085 }
1086
1087 static int xc5000_init(struct dvb_frontend *fe)
1088 {
1089         struct xc5000_priv *priv = fe->tuner_priv;
1090         dprintk(1, "%s()\n", __func__);
1091
1092         if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1093                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1094                 return -EREMOTEIO;
1095         }
1096
1097         if (debug)
1098                 xc_debug_dump(priv);
1099
1100         return 0;
1101 }
1102
1103 static int xc5000_release(struct dvb_frontend *fe)
1104 {
1105         struct xc5000_priv *priv = fe->tuner_priv;
1106
1107         dprintk(1, "%s()\n", __func__);
1108
1109         mutex_lock(&xc5000_list_mutex);
1110
1111         if (priv)
1112                 hybrid_tuner_release_state(priv);
1113
1114         mutex_unlock(&xc5000_list_mutex);
1115
1116         fe->tuner_priv = NULL;
1117
1118         return 0;
1119 }
1120
1121 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1122 {
1123         struct xc5000_priv *priv = fe->tuner_priv;
1124         struct xc5000_config *p = priv_cfg;
1125
1126         dprintk(1, "%s()\n", __func__);
1127
1128         if (p->if_khz)
1129                 priv->if_khz = p->if_khz;
1130
1131         if (p->radio_input)
1132                 priv->radio_input = p->radio_input;
1133
1134         return 0;
1135 }
1136
1137
1138 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1139         .info = {
1140                 .name           = "Xceive XC5000",
1141                 .frequency_min  =    1000000,
1142                 .frequency_max  = 1023000000,
1143                 .frequency_step =      50000,
1144         },
1145
1146         .release           = xc5000_release,
1147         .init              = xc5000_init,
1148         .sleep             = xc5000_sleep,
1149
1150         .set_config        = xc5000_set_config,
1151         .set_params        = xc5000_set_params,
1152         .set_analog_params = xc5000_set_analog_params,
1153         .get_frequency     = xc5000_get_frequency,
1154         .get_if_frequency  = xc5000_get_if_frequency,
1155         .get_bandwidth     = xc5000_get_bandwidth,
1156         .get_status        = xc5000_get_status
1157 };
1158
1159 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1160                                    struct i2c_adapter *i2c,
1161                                    const struct xc5000_config *cfg)
1162 {
1163         struct xc5000_priv *priv = NULL;
1164         int instance;
1165         u16 id = 0;
1166
1167         dprintk(1, "%s(%d-%04x)\n", __func__,
1168                 i2c ? i2c_adapter_id(i2c) : -1,
1169                 cfg ? cfg->i2c_address : -1);
1170
1171         mutex_lock(&xc5000_list_mutex);
1172
1173         instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1174                                               hybrid_tuner_instance_list,
1175                                               i2c, cfg->i2c_address, "xc5000");
1176         switch (instance) {
1177         case 0:
1178                 goto fail;
1179                 break;
1180         case 1:
1181                 /* new tuner instance */
1182                 priv->bandwidth = 6000000;
1183                 fe->tuner_priv = priv;
1184                 break;
1185         default:
1186                 /* existing tuner instance */
1187                 fe->tuner_priv = priv;
1188                 break;
1189         }
1190
1191         if (priv->if_khz == 0) {
1192                 /* If the IF hasn't been set yet, use the value provided by
1193                    the caller (occurs in hybrid devices where the analog
1194                    call to xc5000_attach occurs before the digital side) */
1195                 priv->if_khz = cfg->if_khz;
1196         }
1197
1198         if (priv->xtal_khz == 0)
1199                 priv->xtal_khz = cfg->xtal_khz;
1200
1201         if (priv->radio_input == 0)
1202                 priv->radio_input = cfg->radio_input;
1203
1204         /* don't override chip id if it's already been set
1205            unless explicitly specified */
1206         if ((priv->chip_id == 0) || (cfg->chip_id))
1207                 /* use default chip id if none specified, set to 0 so
1208                    it can be overridden if this is a hybrid driver */
1209                 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1210
1211         /* Check if firmware has been loaded. It is possible that another
1212            instance of the driver has loaded the firmware.
1213          */
1214         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1215                 goto fail;
1216
1217         switch (id) {
1218         case XC_PRODUCT_ID_FW_LOADED:
1219                 printk(KERN_INFO
1220                         "xc5000: Successfully identified at address 0x%02x\n",
1221                         cfg->i2c_address);
1222                 printk(KERN_INFO
1223                         "xc5000: Firmware has been loaded previously\n");
1224                 break;
1225         case XC_PRODUCT_ID_FW_NOT_LOADED:
1226                 printk(KERN_INFO
1227                         "xc5000: Successfully identified at address 0x%02x\n",
1228                         cfg->i2c_address);
1229                 printk(KERN_INFO
1230                         "xc5000: Firmware has not been loaded previously\n");
1231                 break;
1232         default:
1233                 printk(KERN_ERR
1234                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1235                         cfg->i2c_address, id);
1236                 goto fail;
1237         }
1238
1239         mutex_unlock(&xc5000_list_mutex);
1240
1241         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1242                 sizeof(struct dvb_tuner_ops));
1243
1244         return fe;
1245 fail:
1246         mutex_unlock(&xc5000_list_mutex);
1247
1248         xc5000_release(fe);
1249         return NULL;
1250 }
1251 EXPORT_SYMBOL(xc5000_attach);
1252
1253 MODULE_AUTHOR("Steven Toth");
1254 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1255 MODULE_LICENSE("GPL");