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_tv_freq(struct dvb_frontend *fe,
 743         struct analog_parameters *params)
 744 {
 745         struct xc5000_priv *priv = fe->tuner_priv;
 746         int ret;
 747
 748         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
 749                 __func__, params->frequency);
 750
 751         /* Fix me: it could be air. */
 752         priv->rf_mode = params->mode;
 753         if (params->mode > XC_RF_MODE_CABLE)
 754                 priv->rf_mode = XC_RF_MODE_CABLE;
 755
 756         /* params->frequency is in units of 62.5khz */
 757         priv->freq_hz = params->frequency * 62500;
 758
 759         /* FIX ME: Some video standards may have several possible audio
 760                    standards. We simply default to one of them here.
 761          */
 762         if (params->std & V4L2_STD_MN) {
 763                 /* default to BTSC audio standard */
 764                 priv->video_standard = MN_NTSC_PAL_BTSC;
 765                 goto tune_channel;
 766         }
 767
 768         if (params->std & V4L2_STD_PAL_BG) {
 769                 /* default to NICAM audio standard */
 770                 priv->video_standard = BG_PAL_NICAM;
 771                 goto tune_channel;
 772         }
 773
 774         if (params->std & V4L2_STD_PAL_I) {
 775                 /* default to NICAM audio standard */
 776                 priv->video_standard = I_PAL_NICAM;
 777                 goto tune_channel;
 778         }
 779
 780         if (params->std & V4L2_STD_PAL_DK) {
 781                 /* default to NICAM audio standard */
 782                 priv->video_standard = DK_PAL_NICAM;
 783                 goto tune_channel;
 784         }
 785
 786         if (params->std & V4L2_STD_SECAM_DK) {
 787                 /* default to A2 DK1 audio standard */
 788                 priv->video_standard = DK_SECAM_A2DK1;
 789                 goto tune_channel;
 790         }
 791
 792         if (params->std & V4L2_STD_SECAM_L) {
 793                 priv->video_standard = L_SECAM_NICAM;
 794                 goto tune_channel;
 795         }
 796
 797         if (params->std & V4L2_STD_SECAM_LC) {
 798                 priv->video_standard = LC_SECAM_NICAM;
 799                 goto tune_channel;
 800         }
 801
 802 tune_channel:
 803         ret = xc_SetSignalSource(priv, priv->rf_mode);
 804         if (ret != XC_RESULT_SUCCESS) {
 805                 printk(KERN_ERR
 806                         "xc5000: xc_SetSignalSource(%d) failed\n",
 807                         priv->rf_mode);
 808                 return -EREMOTEIO;
 809         }
 810
 811         ret = xc_SetTVStandard(priv,
 812                 XC5000_Standard[priv->video_standard].VideoMode,
 813                 XC5000_Standard[priv->video_standard].AudioMode);
 814         if (ret != XC_RESULT_SUCCESS) {
 815                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 816                 return -EREMOTEIO;
 817         }
 818
 819         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 820
 821         if (debug)
 822                 xc_debug_dump(priv);
 823
 824         return 0;
 825 }
 826
 827 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
 828         struct analog_parameters *params)
 829 {
 830         struct xc5000_priv *priv = fe->tuner_priv;
 831         int ret = -EINVAL;
 832
 833         dprintk(1, "%s() frequency=%d (in units of khz)\n",
 834                 __func__, params->frequency);
 835
 836         priv->freq_hz = params->frequency * 125 / 2;
 837
 838         priv->rf_mode = XC_RF_MODE_AIR;
 839
 840         ret = xc_SetTVStandard(priv,
 841                 XC5000_Standard[FM_Radio_INPUT1].VideoMode,
 842                 XC5000_Standard[FM_Radio_INPUT1].AudioMode);
 843
 844         if (ret != XC_RESULT_SUCCESS) {
 845                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 846                 return -EREMOTEIO;
 847         }
 848
 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         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 858
 859         return 0;
 860 }
 861
 862 static int xc5000_set_analog_params(struct dvb_frontend *fe,
 863                              struct analog_parameters *params)
 864 {
 865         struct xc5000_priv *priv = fe->tuner_priv;
 866         int ret = -EINVAL;
 867
 868         if (priv->i2c_props.adap == NULL)
 869                 return -EINVAL;
 870
 871         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS)
 872                 xc_load_fw_and_init_tuner(fe);
 873
 874         switch (params->mode) {
 875         case V4L2_TUNER_RADIO:
 876                 ret = xc5000_set_radio_freq(fe, params);
 877                 break;
 878         case V4L2_TUNER_ANALOG_TV:
 879         case V4L2_TUNER_DIGITAL_TV:
 880                 ret = xc5000_set_tv_freq(fe, params);
 881                 break;
 882         }
 883
 884         return ret;
 885 }
 886
 887
 888 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
 889 {
 890         struct xc5000_priv *priv = fe->tuner_priv;
 891         dprintk(1, "%s()\n", __func__);
 892         *freq = priv->freq_hz;
 893         return 0;
 894 }
 895
 896 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
 897 {
 898         struct xc5000_priv *priv = fe->tuner_priv;
 899         dprintk(1, "%s()\n", __func__);
 900
 901         *bw = priv->bandwidth;
 902         return 0;
 903 }
 904
 905 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
 906 {
 907         struct xc5000_priv *priv = fe->tuner_priv;
 908         u16 lock_status = 0;
 909
 910         xc_get_lock_status(priv, &lock_status);
 911
 912         dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
 913
 914         *status = lock_status;
 915
 916         return 0;
 917 }
 918
 919 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
 920 {
 921         struct xc5000_priv *priv = fe->tuner_priv;
 922         int ret = 0;
 923
 924         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
 925                 ret = xc5000_fwupload(fe);
 926                 if (ret != XC_RESULT_SUCCESS)
 927                         return ret;
 928         }
 929
 930         /* Start the tuner self-calibration process */
 931         ret |= xc_initialize(priv);
 932
 933         /* Wait for calibration to complete.
 934          * We could continue but XC5000 will clock stretch subsequent
 935          * I2C transactions until calibration is complete.  This way we
 936          * don't have to rely on clock stretching working.
 937          */
 938         xc_wait(100);
 939
 940         /* Default to "CABLE" mode */
 941         ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
 942
 943         return ret;
 944 }
 945
 946 static int xc5000_sleep(struct dvb_frontend *fe)
 947 {
 948         int ret;
 949
 950         dprintk(1, "%s()\n", __func__);
 951
 952         /* Avoid firmware reload on slow devices */
 953         if (no_poweroff)
 954                 return 0;
 955
 956         /* According to Xceive technical support, the "powerdown" register
 957            was removed in newer versions of the firmware.  The "supported"
 958            way to sleep the tuner is to pull the reset pin low for 10ms */
 959         ret = xc5000_TunerReset(fe);
 960         if (ret != XC_RESULT_SUCCESS) {
 961                 printk(KERN_ERR
 962                         "xc5000: %s() unable to shutdown tuner\n",
 963                         __func__);
 964                 return -EREMOTEIO;
 965         } else
 966                 return XC_RESULT_SUCCESS;
 967 }
 968
 969 static int xc5000_init(struct dvb_frontend *fe)
 970 {
 971         struct xc5000_priv *priv = fe->tuner_priv;
 972         dprintk(1, "%s()\n", __func__);
 973
 974         if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
 975                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
 976                 return -EREMOTEIO;
 977         }
 978
 979         if (debug)
 980                 xc_debug_dump(priv);
 981
 982         return 0;
 983 }
 984
 985 static int xc5000_release(struct dvb_frontend *fe)
 986 {
 987         struct xc5000_priv *priv = fe->tuner_priv;
 988
 989         dprintk(1, "%s()\n", __func__);
 990
 991         mutex_lock(&xc5000_list_mutex);
 992
 993         if (priv)
 994                 hybrid_tuner_release_state(priv);
 995
 996         mutex_unlock(&xc5000_list_mutex);
 997
 998         fe->tuner_priv = NULL;
 999
1000         return 0;
1001 }
1002
1003 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1004         .info = {
1005                 .name           = "Xceive XC5000",
1006                 .frequency_min  =    1000000,
1007                 .frequency_max  = 1023000000,
1008                 .frequency_step =      50000,
1009         },
1010
1011         .release           = xc5000_release,
1012         .init              = xc5000_init,
1013         .sleep             = xc5000_sleep,
1014
1015         .set_params        = xc5000_set_params,
1016         .set_analog_params = xc5000_set_analog_params,
1017         .get_frequency     = xc5000_get_frequency,
1018         .get_bandwidth     = xc5000_get_bandwidth,
1019         .get_status        = xc5000_get_status
1020 };
1021
1022 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1023                                    struct i2c_adapter *i2c,
1024                                    struct xc5000_config *cfg)
1025 {
1026         struct xc5000_priv *priv = NULL;
1027         int instance;
1028         u16 id = 0;
1029
1030         dprintk(1, "%s(%d-%04x)\n", __func__,
1031                 i2c ? i2c_adapter_id(i2c) : -1,
1032                 cfg ? cfg->i2c_address : -1);
1033
1034         mutex_lock(&xc5000_list_mutex);
1035
1036         instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1037                                               hybrid_tuner_instance_list,
1038                                               i2c, cfg->i2c_address, "xc5000");
1039         switch (instance) {
1040         case 0:
1041                 goto fail;
1042                 break;
1043         case 1:
1044                 /* new tuner instance */
1045                 priv->bandwidth = BANDWIDTH_6_MHZ;
1046                 fe->tuner_priv = priv;
1047                 break;
1048         default:
1049                 /* existing tuner instance */
1050                 fe->tuner_priv = priv;
1051                 break;
1052         }
1053
1054         if (priv->if_khz == 0) {
1055                 /* If the IF hasn't been set yet, use the value provided by
1056                    the caller (occurs in hybrid devices where the analog
1057                    call to xc5000_attach occurs before the digital side) */
1058                 priv->if_khz = cfg->if_khz;
1059         }
1060
1061         /* Check if firmware has been loaded. It is possible that another
1062            instance of the driver has loaded the firmware.
1063          */
1064         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1065                 goto fail;
1066
1067         switch (id) {
1068         case XC_PRODUCT_ID_FW_LOADED:
1069                 printk(KERN_INFO
1070                         "xc5000: Successfully identified at address 0x%02x\n",
1071                         cfg->i2c_address);
1072                 printk(KERN_INFO
1073                         "xc5000: Firmware has been loaded previously\n");
1074                 break;
1075         case XC_PRODUCT_ID_FW_NOT_LOADED:
1076                 printk(KERN_INFO
1077                         "xc5000: Successfully identified at address 0x%02x\n",
1078                         cfg->i2c_address);
1079                 printk(KERN_INFO
1080                         "xc5000: Firmware has not been loaded previously\n");
1081                 break;
1082         default:
1083                 printk(KERN_ERR
1084                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1085                         cfg->i2c_address, id);
1086                 goto fail;
1087         }
1088
1089         mutex_unlock(&xc5000_list_mutex);
1090
1091         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1092                 sizeof(struct dvb_tuner_ops));
1093
1094         return fe;
1095 fail:
1096         mutex_unlock(&xc5000_list_mutex);
1097
1098         xc5000_release(fe);
1099         return NULL;
1100 }
1101 EXPORT_SYMBOL(xc5000_attach);
1102
1103 MODULE_AUTHOR("Steven Toth");
1104 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1105 MODULE_LICENSE("GPL");