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