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