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