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 #define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
  53 #define XC5000_DEFAULT_FIRMWARE_SIZE 12401
  54
  55 struct xc5000_priv {
  56         struct tuner_i2c_props i2c_props;
  57         struct list_head hybrid_tuner_instance_list;
  58
  59         u32 if_khz;
  60         u32 freq_hz;
  61         u32 bandwidth;
  62         u8  video_standard;
  63         u8  rf_mode;
  64         u8  radio_input;
  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 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
 208 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
 209 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
 210 static int xc5000_TunerReset(struct dvb_frontend *fe);
 211
 212 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
 213 {
 214         struct i2c_msg msg = { .addr = priv->i2c_props.addr,
 215                                .flags = 0, .buf = buf, .len = len };
 216
 217         if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
 218                 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
 219                 return XC_RESULT_I2C_WRITE_FAILURE;
 220         }
 221         return XC_RESULT_SUCCESS;
 222 }
 223
 224 #if 0
 225 /* This routine is never used because the only time we read data from the
 226    i2c bus is when we read registers, and we want that to be an atomic i2c
 227    transaction in case we are on a multi-master bus */
 228 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
 229 {
 230         struct i2c_msg msg = { .addr = priv->i2c_props.addr,
 231                 .flags = I2C_M_RD, .buf = buf, .len = len };
 232
 233         if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
 234                 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
 235                 return -EREMOTEIO;
 236         }
 237         return 0;
 238 }
 239 #endif
 240
 241 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
 242 {
 243         u8 buf[2] = { reg >> 8, reg & 0xff };
 244         u8 bval[2] = { 0, 0 };
 245         struct i2c_msg msg[2] = {
 246                 { .addr = priv->i2c_props.addr,
 247                         .flags = 0, .buf = &buf[0], .len = 2 },
 248                 { .addr = priv->i2c_props.addr,
 249                         .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
 250         };
 251
 252         if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
 253                 printk(KERN_WARNING "xc5000: I2C read failed\n");
 254                 return -EREMOTEIO;
 255         }
 256
 257         *val = (bval[0] << 8) | bval[1];
 258         return XC_RESULT_SUCCESS;
 259 }
 260
 261 static void xc_wait(int wait_ms)
 262 {
 263         msleep(wait_ms);
 264 }
 265
 266 static int xc5000_TunerReset(struct dvb_frontend *fe)
 267 {
 268         struct xc5000_priv *priv = fe->tuner_priv;
 269         int ret;
 270
 271         dprintk(1, "%s()\n", __func__);
 272
 273         if (fe->callback) {
 274                 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
 275                                            fe->dvb->priv :
 276                                            priv->i2c_props.adap->algo_data,
 277                                            DVB_FRONTEND_COMPONENT_TUNER,
 278                                            XC5000_TUNER_RESET, 0);
 279                 if (ret) {
 280                         printk(KERN_ERR "xc5000: reset failed\n");
 281                         return XC_RESULT_RESET_FAILURE;
 282                 }
 283         } else {
 284                 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
 285                 return XC_RESULT_RESET_FAILURE;
 286         }
 287         return XC_RESULT_SUCCESS;
 288 }
 289
 290 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
 291 {
 292         u8 buf[4];
 293         int WatchDogTimer = 100;
 294         int result;
 295
 296         buf[0] = (regAddr >> 8) & 0xFF;
 297         buf[1] = regAddr & 0xFF;
 298         buf[2] = (i2cData >> 8) & 0xFF;
 299         buf[3] = i2cData & 0xFF;
 300         result = xc_send_i2c_data(priv, buf, 4);
 301         if (result == XC_RESULT_SUCCESS) {
 302                 /* wait for busy flag to clear */
 303                 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
 304                         result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
 305                         if (result == XC_RESULT_SUCCESS) {
 306                                 if ((buf[0] == 0) && (buf[1] == 0)) {
 307                                         /* busy flag cleared */
 308                                         break;
 309                                 } else {
 310                                         xc_wait(5); /* wait 5 ms */
 311                                         WatchDogTimer--;
 312                                 }
 313                         }
 314                 }
 315         }
 316         if (WatchDogTimer < 0)
 317                 result = XC_RESULT_I2C_WRITE_FAILURE;
 318
 319         return result;
 320 }
 321
 322 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
 323 {
 324         struct xc5000_priv *priv = fe->tuner_priv;
 325
 326         int i, nbytes_to_send, result;
 327         unsigned int len, pos, index;
 328         u8 buf[XC_MAX_I2C_WRITE_LENGTH];
 329
 330         index = 0;
 331         while ((i2c_sequence[index] != 0xFF) ||
 332                 (i2c_sequence[index + 1] != 0xFF)) {
 333                 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
 334                 if (len == 0x0000) {
 335                         /* RESET command */
 336                         result = xc5000_TunerReset(fe);
 337                         index += 2;
 338                         if (result != XC_RESULT_SUCCESS)
 339                                 return result;
 340                 } else if (len & 0x8000) {
 341                         /* WAIT command */
 342                         xc_wait(len & 0x7FFF);
 343                         index += 2;
 344                 } else {
 345                         /* Send i2c data whilst ensuring individual transactions
 346                          * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
 347                          */
 348                         index += 2;
 349                         buf[0] = i2c_sequence[index];
 350                         buf[1] = i2c_sequence[index + 1];
 351                         pos = 2;
 352                         while (pos < len) {
 353                                 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
 354                                         nbytes_to_send =
 355                                                 XC_MAX_I2C_WRITE_LENGTH;
 356                                 else
 357                                         nbytes_to_send = (len - pos + 2);
 358                                 for (i = 2; i < nbytes_to_send; i++) {
 359                                         buf[i] = i2c_sequence[index + pos +
 360                                                 i - 2];
 361                                 }
 362                                 result = xc_send_i2c_data(priv, buf,
 363                                         nbytes_to_send);
 364
 365                                 if (result != XC_RESULT_SUCCESS)
 366                                         return result;
 367
 368                                 pos += nbytes_to_send - 2;
 369                         }
 370                         index += len;
 371                 }
 372         }
 373         return XC_RESULT_SUCCESS;
 374 }
 375
 376 static int xc_initialize(struct xc5000_priv *priv)
 377 {
 378         dprintk(1, "%s()\n", __func__);
 379         return xc_write_reg(priv, XREG_INIT, 0);
 380 }
 381
 382 static int xc_SetTVStandard(struct xc5000_priv *priv,
 383         u16 VideoMode, u16 AudioMode)
 384 {
 385         int ret;
 386         dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
 387         dprintk(1, "%s() Standard = %s\n",
 388                 __func__,
 389                 XC5000_Standard[priv->video_standard].Name);
 390
 391         ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
 392         if (ret == XC_RESULT_SUCCESS)
 393                 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
 394
 395         return ret;
 396 }
 397
 398 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
 399 {
 400         dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
 401                 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
 402
 403         if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
 404                 rf_mode = XC_RF_MODE_CABLE;
 405                 printk(KERN_ERR
 406                         "%s(), Invalid mode, defaulting to CABLE",
 407                         __func__);
 408         }
 409         return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
 410 }
 411
 412 static const struct dvb_tuner_ops xc5000_tuner_ops;
 413
 414 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
 415 {
 416         u16 freq_code;
 417
 418         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 419
 420         if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
 421                 (freq_hz < xc5000_tuner_ops.info.frequency_min))
 422                 return XC_RESULT_OUT_OF_RANGE;
 423
 424         freq_code = (u16)(freq_hz / 15625);
 425
 426         /* Starting in firmware version 1.1.44, Xceive recommends using the
 427            FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
 428            only be used for fast scanning for channel lock) */
 429         return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
 430 }
 431
 432
 433 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
 434 {
 435         u32 freq_code = (freq_khz * 1024)/1000;
 436         dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
 437                 __func__, freq_khz, freq_code);
 438
 439         return xc_write_reg(priv, XREG_IF_OUT, freq_code);
 440 }
 441
 442
 443 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
 444 {
 445         return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
 446 }
 447
 448 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
 449 {
 450         int result;
 451         u16 regData;
 452         u32 tmp;
 453
 454         result = xc5000_readreg(priv, XREG_FREQ_ERROR, &regData);
 455         if (result != XC_RESULT_SUCCESS)
 456                 return result;
 457
 458         tmp = (u32)regData;
 459         (*freq_error_hz) = (tmp * 15625) / 1000;
 460         return result;
 461 }
 462
 463 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
 464 {
 465         return xc5000_readreg(priv, XREG_LOCK, lock_status);
 466 }
 467
 468 static int xc_get_version(struct xc5000_priv *priv,
 469         u8 *hw_majorversion, u8 *hw_minorversion,
 470         u8 *fw_majorversion, u8 *fw_minorversion)
 471 {
 472         u16 data;
 473         int result;
 474
 475         result = xc5000_readreg(priv, XREG_VERSION, &data);
 476         if (result != XC_RESULT_SUCCESS)
 477                 return result;
 478
 479         (*hw_majorversion) = (data >> 12) & 0x0F;
 480         (*hw_minorversion) = (data >>  8) & 0x0F;
 481         (*fw_majorversion) = (data >>  4) & 0x0F;
 482         (*fw_minorversion) = data & 0x0F;
 483
 484         return 0;
 485 }
 486
 487 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
 488 {
 489         return xc5000_readreg(priv, XREG_BUILD, buildrev);
 490 }
 491
 492 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
 493 {
 494         u16 regData;
 495         int result;
 496
 497         result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &regData);
 498         if (result != XC_RESULT_SUCCESS)
 499                 return result;
 500
 501         (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
 502         return result;
 503 }
 504
 505 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
 506 {
 507         return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
 508 }
 509
 510 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
 511 {
 512         return xc5000_readreg(priv, XREG_QUALITY, quality);
 513 }
 514
 515 static u16 WaitForLock(struct xc5000_priv *priv)
 516 {
 517         u16 lockState = 0;
 518         int watchDogCount = 40;
 519
 520         while ((lockState == 0) && (watchDogCount > 0)) {
 521                 xc_get_lock_status(priv, &lockState);
 522                 if (lockState != 1) {
 523                         xc_wait(5);
 524                         watchDogCount--;
 525                 }
 526         }
 527         return lockState;
 528 }
 529
 530 #define XC_TUNE_ANALOG  0
 531 #define XC_TUNE_DIGITAL 1
 532 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
 533 {
 534         int found = 0;
 535
 536         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 537
 538         if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
 539                 return 0;
 540
 541         if (mode == XC_TUNE_ANALOG) {
 542                 if (WaitForLock(priv) == 1)
 543                         found = 1;
 544         }
 545
 546         return found;
 547 }
 548
 549
 550 static int xc5000_fwupload(struct dvb_frontend *fe)
 551 {
 552         struct xc5000_priv *priv = fe->tuner_priv;
 553         const struct firmware *fw;
 554         int ret;
 555
 556         /* request the firmware, this will block and timeout */
 557         printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
 558                 XC5000_DEFAULT_FIRMWARE);
 559
 560         ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE,
 561                 priv->i2c_props.adap->dev.parent);
 562         if (ret) {
 563                 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
 564                 ret = XC_RESULT_RESET_FAILURE;
 565                 goto out;
 566         } else {
 567                 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
 568                        fw->size);
 569                 ret = XC_RESULT_SUCCESS;
 570         }
 571
 572         if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
 573                 printk(KERN_ERR "xc5000: firmware incorrect size\n");
 574                 ret = XC_RESULT_RESET_FAILURE;
 575         } else {
 576                 printk(KERN_INFO "xc5000: firmware uploading...\n");
 577                 ret = xc_load_i2c_sequence(fe,  fw->data);
 578                 printk(KERN_INFO "xc5000: firmware upload complete...\n");
 579         }
 580
 581 out:
 582         release_firmware(fw);
 583         return ret;
 584 }
 585
 586 static void xc_debug_dump(struct xc5000_priv *priv)
 587 {
 588         u16 adc_envelope;
 589         u32 freq_error_hz = 0;
 590         u16 lock_status;
 591         u32 hsync_freq_hz = 0;
 592         u16 frame_lines;
 593         u16 quality;
 594         u8 hw_majorversion = 0, hw_minorversion = 0;
 595         u8 fw_majorversion = 0, fw_minorversion = 0;
 596         u16 fw_buildversion = 0;
 597
 598         /* Wait for stats to stabilize.
 599          * Frame Lines needs two frame times after initial lock
 600          * before it is valid.
 601          */
 602         xc_wait(100);
 603
 604         xc_get_ADC_Envelope(priv,  &adc_envelope);
 605         dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
 606
 607         xc_get_frequency_error(priv, &freq_error_hz);
 608         dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
 609
 610         xc_get_lock_status(priv,  &lock_status);
 611         dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
 612                 lock_status);
 613
 614         xc_get_version(priv,  &hw_majorversion, &hw_minorversion,
 615                 &fw_majorversion, &fw_minorversion);
 616         xc_get_buildversion(priv,  &fw_buildversion);
 617         dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
 618                 hw_majorversion, hw_minorversion,
 619                 fw_majorversion, fw_minorversion, fw_buildversion);
 620
 621         xc_get_hsync_freq(priv,  &hsync_freq_hz);
 622         dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
 623
 624         xc_get_frame_lines(priv,  &frame_lines);
 625         dprintk(1, "*** Frame lines = %d\n", frame_lines);
 626
 627         xc_get_quality(priv,  &quality);
 628         dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
 629 }
 630
 631 /*
 632  * As defined on EN 300 429, the DVB-C roll-off factor is 0.15.
 633  * So, the amount of the needed bandwith is given by:
 634  *      Bw = Symbol_rate * (1 + 0.15)
 635  * As such, the maximum symbol rate supported by 6 MHz is given by:
 636  *      max_symbol_rate = 6 MHz / 1.15 = 5217391 Bauds
 637  */
 638 #define MAX_SYMBOL_RATE_6MHz    5217391
 639
 640 static int xc5000_set_params(struct dvb_frontend *fe,
 641         struct dvb_frontend_parameters *params)
 642 {
 643         struct xc5000_priv *priv = fe->tuner_priv;
 644         int ret;
 645
 646         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
 647                 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
 648                         dprintk(1, "Unable to load firmware and init tuner\n");
 649                         return -EINVAL;
 650                 }
 651         }
 652
 653         dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
 654
 655         if (fe->ops.info.type == FE_ATSC) {
 656                 dprintk(1, "%s() ATSC\n", __func__);
 657                 switch (params->u.vsb.modulation) {
 658                 case VSB_8:
 659                 case VSB_16:
 660                         dprintk(1, "%s() VSB modulation\n", __func__);
 661                         priv->rf_mode = XC_RF_MODE_AIR;
 662                         priv->freq_hz = params->frequency - 1750000;
 663                         priv->bandwidth = BANDWIDTH_6_MHZ;
 664                         priv->video_standard = DTV6;
 665                         break;
 666                 case QAM_64:
 667                 case QAM_256:
 668                 case QAM_AUTO:
 669                         dprintk(1, "%s() QAM modulation\n", __func__);
 670                         priv->rf_mode = XC_RF_MODE_CABLE;
 671                         priv->freq_hz = params->frequency - 1750000;
 672                         priv->bandwidth = BANDWIDTH_6_MHZ;
 673                         priv->video_standard = DTV6;
 674                         break;
 675                 default:
 676                         return -EINVAL;
 677                 }
 678         } else if (fe->ops.info.type == FE_OFDM) {
 679                 dprintk(1, "%s() OFDM\n", __func__);
 680                 switch (params->u.ofdm.bandwidth) {
 681                 case BANDWIDTH_6_MHZ:
 682                         priv->bandwidth = BANDWIDTH_6_MHZ;
 683                         priv->video_standard = DTV6;
 684                         priv->freq_hz = params->frequency - 1750000;
 685                         break;
 686                 case BANDWIDTH_7_MHZ:
 687                         printk(KERN_ERR "xc5000 bandwidth 7MHz not supported\n");
 688                         return -EINVAL;
 689                 case BANDWIDTH_8_MHZ:
 690                         priv->bandwidth = BANDWIDTH_8_MHZ;
 691                         priv->video_standard = DTV8;
 692                         priv->freq_hz = params->frequency - 2750000;
 693                         break;
 694                 default:
 695                         printk(KERN_ERR "xc5000 bandwidth not set!\n");
 696                         return -EINVAL;
 697                 }
 698                 priv->rf_mode = XC_RF_MODE_AIR;
 699         } else if (fe->ops.info.type == FE_QAM) {
 700                 switch (params->u.qam.modulation) {
 701                 case QAM_256:
 702                 case QAM_AUTO:
 703                 case QAM_16:
 704                 case QAM_32:
 705                 case QAM_64:
 706                 case QAM_128:
 707                         dprintk(1, "%s() QAM modulation\n", __func__);
 708                         priv->rf_mode = XC_RF_MODE_CABLE;
 709                         /*
 710                          * Using a 8MHz bandwidth sometimes fail
 711                          * with 6MHz-spaced channels, due to inter-carrier
 712                          * interference. So, use DTV6 firmware
 713                          */
 714                         if (params->u.qam.symbol_rate <= MAX_SYMBOL_RATE_6MHz) {
 715                                 priv->bandwidth = BANDWIDTH_6_MHZ;
 716                                 priv->video_standard = DTV6;
 717                                 priv->freq_hz = params->frequency - 1750000;
 718                         } else {
 719                                 priv->bandwidth = BANDWIDTH_8_MHZ;
 720                                 priv->video_standard = DTV7_8;
 721                                 priv->freq_hz = params->frequency - 2750000;
 722                         }
 723                         break;
 724                 default:
 725                         dprintk(1, "%s() Unsupported QAM type\n", __func__);
 726                         return -EINVAL;
 727                 }
 728         } else {
 729                 printk(KERN_ERR "xc5000 modulation type not supported!\n");
 730                 return -EINVAL;
 731         }
 732
 733         dprintk(1, "%s() frequency=%d (compensated)\n",
 734                 __func__, priv->freq_hz);
 735
 736         ret = xc_SetSignalSource(priv, priv->rf_mode);
 737         if (ret != XC_RESULT_SUCCESS) {
 738                 printk(KERN_ERR
 739                         "xc5000: xc_SetSignalSource(%d) failed\n",
 740                         priv->rf_mode);
 741                 return -EREMOTEIO;
 742         }
 743
 744         ret = xc_SetTVStandard(priv,
 745                 XC5000_Standard[priv->video_standard].VideoMode,
 746                 XC5000_Standard[priv->video_standard].AudioMode);
 747         if (ret != XC_RESULT_SUCCESS) {
 748                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 749                 return -EREMOTEIO;
 750         }
 751
 752         ret = xc_set_IF_frequency(priv, priv->if_khz);
 753         if (ret != XC_RESULT_SUCCESS) {
 754                 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
 755                        priv->if_khz);
 756                 return -EIO;
 757         }
 758
 759         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
 760
 761         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
 762
 763         if (debug)
 764                 xc_debug_dump(priv);
 765
 766         return 0;
 767 }
 768
 769 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
 770 {
 771         struct xc5000_priv *priv = fe->tuner_priv;
 772         int ret;
 773         u16 id;
 774
 775         ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
 776         if (ret == XC_RESULT_SUCCESS) {
 777                 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
 778                         ret = XC_RESULT_RESET_FAILURE;
 779                 else
 780                         ret = XC_RESULT_SUCCESS;
 781         }
 782
 783         dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
 784                 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
 785         return ret;
 786 }
 787
 788 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
 789         struct analog_parameters *params)
 790 {
 791         struct xc5000_priv *priv = fe->tuner_priv;
 792         int ret;
 793
 794         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
 795                 __func__, params->frequency);
 796
 797         /* Fix me: it could be air. */
 798         priv->rf_mode = params->mode;
 799         if (params->mode > XC_RF_MODE_CABLE)
 800                 priv->rf_mode = XC_RF_MODE_CABLE;
 801
 802         /* params->frequency is in units of 62.5khz */
 803         priv->freq_hz = params->frequency * 62500;
 804
 805         /* FIX ME: Some video standards may have several possible audio
 806                    standards. We simply default to one of them here.
 807          */
 808         if (params->std & V4L2_STD_MN) {
 809                 /* default to BTSC audio standard */
 810                 priv->video_standard = MN_NTSC_PAL_BTSC;
 811                 goto tune_channel;
 812         }
 813
 814         if (params->std & V4L2_STD_PAL_BG) {
 815                 /* default to NICAM audio standard */
 816                 priv->video_standard = BG_PAL_NICAM;
 817                 goto tune_channel;
 818         }
 819
 820         if (params->std & V4L2_STD_PAL_I) {
 821                 /* default to NICAM audio standard */
 822                 priv->video_standard = I_PAL_NICAM;
 823                 goto tune_channel;
 824         }
 825
 826         if (params->std & V4L2_STD_PAL_DK) {
 827                 /* default to NICAM audio standard */
 828                 priv->video_standard = DK_PAL_NICAM;
 829                 goto tune_channel;
 830         }
 831
 832         if (params->std & V4L2_STD_SECAM_DK) {
 833                 /* default to A2 DK1 audio standard */
 834                 priv->video_standard = DK_SECAM_A2DK1;
 835                 goto tune_channel;
 836         }
 837
 838         if (params->std & V4L2_STD_SECAM_L) {
 839                 priv->video_standard = L_SECAM_NICAM;
 840                 goto tune_channel;
 841         }
 842
 843         if (params->std & V4L2_STD_SECAM_LC) {
 844                 priv->video_standard = LC_SECAM_NICAM;
 845                 goto tune_channel;
 846         }
 847
 848 tune_channel:
 849         ret = xc_SetSignalSource(priv, priv->rf_mode);
 850         if (ret != XC_RESULT_SUCCESS) {
 851                 printk(KERN_ERR
 852                         "xc5000: xc_SetSignalSource(%d) failed\n",
 853                         priv->rf_mode);
 854                 return -EREMOTEIO;
 855         }
 856
 857         ret = xc_SetTVStandard(priv,
 858                 XC5000_Standard[priv->video_standard].VideoMode,
 859                 XC5000_Standard[priv->video_standard].AudioMode);
 860         if (ret != XC_RESULT_SUCCESS) {
 861                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 862                 return -EREMOTEIO;
 863         }
 864
 865         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
 866
 867         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 868
 869         if (debug)
 870                 xc_debug_dump(priv);
 871
 872         return 0;
 873 }
 874
 875 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
 876         struct analog_parameters *params)
 877 {
 878         struct xc5000_priv *priv = fe->tuner_priv;
 879         int ret = -EINVAL;
 880         u8 radio_input;
 881
 882         dprintk(1, "%s() frequency=%d (in units of khz)\n",
 883                 __func__, params->frequency);
 884
 885         if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
 886                 dprintk(1, "%s() radio input not configured\n", __func__);
 887                 return -EINVAL;
 888         }
 889
 890         if (priv->radio_input == XC5000_RADIO_FM1)
 891                 radio_input = FM_Radio_INPUT1;
 892         else if  (priv->radio_input == XC5000_RADIO_FM2)
 893                 radio_input = FM_Radio_INPUT2;
 894         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
 895                 radio_input = FM_Radio_INPUT1_MONO;
 896         else {
 897                 dprintk(1, "%s() unknown radio input %d\n", __func__,
 898                         priv->radio_input);
 899                 return -EINVAL;
 900         }
 901
 902         priv->freq_hz = params->frequency * 125 / 2;
 903
 904         priv->rf_mode = XC_RF_MODE_AIR;
 905
 906         ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
 907                                XC5000_Standard[radio_input].AudioMode);
 908
 909         if (ret != XC_RESULT_SUCCESS) {
 910                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 911                 return -EREMOTEIO;
 912         }
 913
 914         ret = xc_SetSignalSource(priv, priv->rf_mode);
 915         if (ret != XC_RESULT_SUCCESS) {
 916                 printk(KERN_ERR
 917                         "xc5000: xc_SetSignalSource(%d) failed\n",
 918                         priv->rf_mode);
 919                 return -EREMOTEIO;
 920         }
 921
 922         if ((priv->radio_input == XC5000_RADIO_FM1) ||
 923                                 (priv->radio_input == XC5000_RADIO_FM2))
 924                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
 925         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
 926                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
 927
 928         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 929
 930         return 0;
 931 }
 932
 933 static int xc5000_set_analog_params(struct dvb_frontend *fe,
 934                              struct analog_parameters *params)
 935 {
 936         struct xc5000_priv *priv = fe->tuner_priv;
 937         int ret = -EINVAL;
 938
 939         if (priv->i2c_props.adap == NULL)
 940                 return -EINVAL;
 941
 942         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
 943                 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
 944                         dprintk(1, "Unable to load firmware and init tuner\n");
 945                         return -EINVAL;
 946                 }
 947         }
 948
 949         switch (params->mode) {
 950         case V4L2_TUNER_RADIO:
 951                 ret = xc5000_set_radio_freq(fe, params);
 952                 break;
 953         case V4L2_TUNER_ANALOG_TV:
 954         case V4L2_TUNER_DIGITAL_TV:
 955                 ret = xc5000_set_tv_freq(fe, params);
 956                 break;
 957         }
 958
 959         return ret;
 960 }
 961
 962
 963 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
 964 {
 965         struct xc5000_priv *priv = fe->tuner_priv;
 966         dprintk(1, "%s()\n", __func__);
 967         *freq = priv->freq_hz;
 968         return 0;
 969 }
 970
 971 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
 972 {
 973         struct xc5000_priv *priv = fe->tuner_priv;
 974         dprintk(1, "%s()\n", __func__);
 975
 976         *bw = priv->bandwidth;
 977         return 0;
 978 }
 979
 980 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
 981 {
 982         struct xc5000_priv *priv = fe->tuner_priv;
 983         u16 lock_status = 0;
 984
 985         xc_get_lock_status(priv, &lock_status);
 986
 987         dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
 988
 989         *status = lock_status;
 990
 991         return 0;
 992 }
 993
 994 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
 995 {
 996         struct xc5000_priv *priv = fe->tuner_priv;
 997         int ret = 0;
 998
 999         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
1000                 ret = xc5000_fwupload(fe);
1001                 if (ret != XC_RESULT_SUCCESS)
1002                         return ret;
1003         }
1004
1005         /* Start the tuner self-calibration process */
1006         ret |= xc_initialize(priv);
1007
1008         /* Wait for calibration to complete.
1009          * We could continue but XC5000 will clock stretch subsequent
1010          * I2C transactions until calibration is complete.  This way we
1011          * don't have to rely on clock stretching working.
1012          */
1013         xc_wait(100);
1014
1015         /* Default to "CABLE" mode */
1016         ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1017
1018         return ret;
1019 }
1020
1021 static int xc5000_sleep(struct dvb_frontend *fe)
1022 {
1023         int ret;
1024
1025         dprintk(1, "%s()\n", __func__);
1026
1027         /* Avoid firmware reload on slow devices */
1028         if (no_poweroff)
1029                 return 0;
1030
1031         /* According to Xceive technical support, the "powerdown" register
1032            was removed in newer versions of the firmware.  The "supported"
1033            way to sleep the tuner is to pull the reset pin low for 10ms */
1034         ret = xc5000_TunerReset(fe);
1035         if (ret != XC_RESULT_SUCCESS) {
1036                 printk(KERN_ERR
1037                         "xc5000: %s() unable to shutdown tuner\n",
1038                         __func__);
1039                 return -EREMOTEIO;
1040         } else
1041                 return XC_RESULT_SUCCESS;
1042 }
1043
1044 static int xc5000_init(struct dvb_frontend *fe)
1045 {
1046         struct xc5000_priv *priv = fe->tuner_priv;
1047         dprintk(1, "%s()\n", __func__);
1048
1049         if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1050                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1051                 return -EREMOTEIO;
1052         }
1053
1054         if (debug)
1055                 xc_debug_dump(priv);
1056
1057         return 0;
1058 }
1059
1060 static int xc5000_release(struct dvb_frontend *fe)
1061 {
1062         struct xc5000_priv *priv = fe->tuner_priv;
1063
1064         dprintk(1, "%s()\n", __func__);
1065
1066         mutex_lock(&xc5000_list_mutex);
1067
1068         if (priv)
1069                 hybrid_tuner_release_state(priv);
1070
1071         mutex_unlock(&xc5000_list_mutex);
1072
1073         fe->tuner_priv = NULL;
1074
1075         return 0;
1076 }
1077
1078 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1079 {
1080         struct xc5000_priv *priv = fe->tuner_priv;
1081         struct xc5000_config *p = priv_cfg;
1082
1083         dprintk(1, "%s()\n", __func__);
1084
1085         if (p->if_khz)
1086                 priv->if_khz = p->if_khz;
1087
1088         if (p->radio_input)
1089                 priv->radio_input = p->radio_input;
1090
1091         return 0;
1092 }
1093
1094
1095 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1096         .info = {
1097                 .name           = "Xceive XC5000",
1098                 .frequency_min  =    1000000,
1099                 .frequency_max  = 1023000000,
1100                 .frequency_step =      50000,
1101         },
1102
1103         .release           = xc5000_release,
1104         .init              = xc5000_init,
1105         .sleep             = xc5000_sleep,
1106
1107         .set_config        = xc5000_set_config,
1108         .set_params        = xc5000_set_params,
1109         .set_analog_params = xc5000_set_analog_params,
1110         .get_frequency     = xc5000_get_frequency,
1111         .get_bandwidth     = xc5000_get_bandwidth,
1112         .get_status        = xc5000_get_status
1113 };
1114
1115 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1116                                    struct i2c_adapter *i2c,
1117                                    const struct xc5000_config *cfg)
1118 {
1119         struct xc5000_priv *priv = NULL;
1120         int instance;
1121         u16 id = 0;
1122
1123         dprintk(1, "%s(%d-%04x)\n", __func__,
1124                 i2c ? i2c_adapter_id(i2c) : -1,
1125                 cfg ? cfg->i2c_address : -1);
1126
1127         mutex_lock(&xc5000_list_mutex);
1128
1129         instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1130                                               hybrid_tuner_instance_list,
1131                                               i2c, cfg->i2c_address, "xc5000");
1132         switch (instance) {
1133         case 0:
1134                 goto fail;
1135                 break;
1136         case 1:
1137                 /* new tuner instance */
1138                 priv->bandwidth = BANDWIDTH_6_MHZ;
1139                 fe->tuner_priv = priv;
1140                 break;
1141         default:
1142                 /* existing tuner instance */
1143                 fe->tuner_priv = priv;
1144                 break;
1145         }
1146
1147         if (priv->if_khz == 0) {
1148                 /* If the IF hasn't been set yet, use the value provided by
1149                    the caller (occurs in hybrid devices where the analog
1150                    call to xc5000_attach occurs before the digital side) */
1151                 priv->if_khz = cfg->if_khz;
1152         }
1153
1154         if (priv->radio_input == 0)
1155                 priv->radio_input = cfg->radio_input;
1156
1157         /* Check if firmware has been loaded. It is possible that another
1158            instance of the driver has loaded the firmware.
1159          */
1160         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1161                 goto fail;
1162
1163         switch (id) {
1164         case XC_PRODUCT_ID_FW_LOADED:
1165                 printk(KERN_INFO
1166                         "xc5000: Successfully identified at address 0x%02x\n",
1167                         cfg->i2c_address);
1168                 printk(KERN_INFO
1169                         "xc5000: Firmware has been loaded previously\n");
1170                 break;
1171         case XC_PRODUCT_ID_FW_NOT_LOADED:
1172                 printk(KERN_INFO
1173                         "xc5000: Successfully identified at address 0x%02x\n",
1174                         cfg->i2c_address);
1175                 printk(KERN_INFO
1176                         "xc5000: Firmware has not been loaded previously\n");
1177                 break;
1178         default:
1179                 printk(KERN_ERR
1180                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1181                         cfg->i2c_address, id);
1182                 goto fail;
1183         }
1184
1185         mutex_unlock(&xc5000_list_mutex);
1186
1187         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1188                 sizeof(struct dvb_tuner_ops));
1189
1190         return fe;
1191 fail:
1192         mutex_unlock(&xc5000_list_mutex);
1193
1194         xc5000_release(fe);
1195         return NULL;
1196 }
1197 EXPORT_SYMBOL(xc5000_attach);
1198
1199 MODULE_AUTHOR("Steven Toth");
1200 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1201 MODULE_LICENSE("GPL");