drivers/media/common/tuners/xc5000.c

   1 /*
   2  *  Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
   3  *
   4  *  Copyright (c) 2007 Xceive Corporation
   5  *  Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
   6  *  Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/videodev2.h>
  27 #include <linux/delay.h>
  28 #include <linux/dvb/frontend.h>
  29 #include <linux/i2c.h>
  30
  31 #include "dvb_frontend.h"
  32
  33 #include "xc5000.h"
  34 #include "tuner-i2c.h"
  35
  36 static int debug;
  37 module_param(debug, int, 0644);
  38 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
  39
  40 static int no_poweroff;
  41 module_param(no_poweroff, int, 0644);
  42 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
  43         "\t\t1 keep device energized and with tuner ready all the times.\n"
  44         "\t\tFaster, but consumes more power and keeps the device hotter");
  45
  46 static DEFINE_MUTEX(xc5000_list_mutex);
  47 static LIST_HEAD(hybrid_tuner_instance_list);
  48
  49 #define dprintk(level, fmt, arg...) if (debug >= level) \
  50         printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
  51
  52 #define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
  53 #define XC5000_DEFAULT_FIRMWARE_SIZE 12401
  54
  55 struct xc5000_priv {
  56         struct tuner_i2c_props i2c_props;
  57         struct list_head hybrid_tuner_instance_list;
  58
  59         u32 if_khz;
  60         u32 freq_hz;
  61         u32 bandwidth;
  62         u8  video_standard;
  63         u8  rf_mode;
  64         u8  radio_input;
  65 };
  66
  67 /* Misc Defines */
  68 #define MAX_TV_STANDARD                 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 if (fe->ops.info.type == FE_QAM) {
 687                 dprintk(1, "%s() QAM\n", __func__);
 688                 switch (params->u.qam.modulation) {
 689                 case QAM_16:
 690                 case QAM_32:
 691                 case QAM_64:
 692                 case QAM_128:
 693                 case QAM_256:
 694                 case QAM_AUTO:
 695                         dprintk(1, "%s() QAM modulation\n", __func__);
 696                         priv->bandwidth = BANDWIDTH_8_MHZ;
 697                         priv->video_standard = DTV7_8;
 698                         priv->freq_hz = params->frequency - 2750000;
 699                         priv->rf_mode = XC_RF_MODE_CABLE;
 700                         break;
 701                 default:
 702                         return -EINVAL;
 703                 }
 704         } else {
 705                 printk(KERN_ERR "xc5000 modulation type not supported!\n");
 706                 return -EINVAL;
 707         }
 708
 709         dprintk(1, "%s() frequency=%d (compensated)\n",
 710                 __func__, priv->freq_hz);
 711
 712         ret = xc_SetSignalSource(priv, priv->rf_mode);
 713         if (ret != XC_RESULT_SUCCESS) {
 714                 printk(KERN_ERR
 715                         "xc5000: xc_SetSignalSource(%d) failed\n",
 716                         priv->rf_mode);
 717                 return -EREMOTEIO;
 718         }
 719
 720         ret = xc_SetTVStandard(priv,
 721                 XC5000_Standard[priv->video_standard].VideoMode,
 722                 XC5000_Standard[priv->video_standard].AudioMode);
 723         if (ret != XC_RESULT_SUCCESS) {
 724                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 725                 return -EREMOTEIO;
 726         }
 727
 728         ret = xc_set_IF_frequency(priv, priv->if_khz);
 729         if (ret != XC_RESULT_SUCCESS) {
 730                 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
 731                        priv->if_khz);
 732                 return -EIO;
 733         }
 734
 735         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
 736
 737         if (debug)
 738                 xc_debug_dump(priv);
 739
 740         return 0;
 741 }
 742
 743 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
 744 {
 745         struct xc5000_priv *priv = fe->tuner_priv;
 746         int ret;
 747         u16 id;
 748
 749         ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
 750         if (ret == XC_RESULT_SUCCESS) {
 751                 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
 752                         ret = XC_RESULT_RESET_FAILURE;
 753                 else
 754                         ret = XC_RESULT_SUCCESS;
 755         }
 756
 757         dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
 758                 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
 759         return ret;
 760 }
 761
 762 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
 763         struct analog_parameters *params)
 764 {
 765         struct xc5000_priv *priv = fe->tuner_priv;
 766         int ret;
 767
 768         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
 769                 __func__, params->frequency);
 770
 771         /* Fix me: it could be air. */
 772         priv->rf_mode = params->mode;
 773         if (params->mode > XC_RF_MODE_CABLE)
 774                 priv->rf_mode = XC_RF_MODE_CABLE;
 775
 776         /* params->frequency is in units of 62.5khz */
 777         priv->freq_hz = params->frequency * 62500;
 778
 779         /* FIX ME: Some video standards may have several possible audio
 780                    standards. We simply default to one of them here.
 781          */
 782         if (params->std & V4L2_STD_MN) {
 783                 /* default to BTSC audio standard */
 784                 priv->video_standard = MN_NTSC_PAL_BTSC;
 785                 goto tune_channel;
 786         }
 787
 788         if (params->std & V4L2_STD_PAL_BG) {
 789                 /* default to NICAM audio standard */
 790                 priv->video_standard = BG_PAL_NICAM;
 791                 goto tune_channel;
 792         }
 793
 794         if (params->std & V4L2_STD_PAL_I) {
 795                 /* default to NICAM audio standard */
 796                 priv->video_standard = I_PAL_NICAM;
 797                 goto tune_channel;
 798         }
 799
 800         if (params->std & V4L2_STD_PAL_DK) {
 801                 /* default to NICAM audio standard */
 802                 priv->video_standard = DK_PAL_NICAM;
 803                 goto tune_channel;
 804         }
 805
 806         if (params->std & V4L2_STD_SECAM_DK) {
 807                 /* default to A2 DK1 audio standard */
 808                 priv->video_standard = DK_SECAM_A2DK1;
 809                 goto tune_channel;
 810         }
 811
 812         if (params->std & V4L2_STD_SECAM_L) {
 813                 priv->video_standard = L_SECAM_NICAM;
 814                 goto tune_channel;
 815         }
 816
 817         if (params->std & V4L2_STD_SECAM_LC) {
 818                 priv->video_standard = LC_SECAM_NICAM;
 819                 goto tune_channel;
 820         }
 821
 822 tune_channel:
 823         ret = xc_SetSignalSource(priv, priv->rf_mode);
 824         if (ret != XC_RESULT_SUCCESS) {
 825                 printk(KERN_ERR
 826                         "xc5000: xc_SetSignalSource(%d) failed\n",
 827                         priv->rf_mode);
 828                 return -EREMOTEIO;
 829         }
 830
 831         ret = xc_SetTVStandard(priv,
 832                 XC5000_Standard[priv->video_standard].VideoMode,
 833                 XC5000_Standard[priv->video_standard].AudioMode);
 834         if (ret != XC_RESULT_SUCCESS) {
 835                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 836                 return -EREMOTEIO;
 837         }
 838
 839         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 840
 841         if (debug)
 842                 xc_debug_dump(priv);
 843
 844         return 0;
 845 }
 846
 847 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
 848         struct analog_parameters *params)
 849 {
 850         struct xc5000_priv *priv = fe->tuner_priv;
 851         int ret = -EINVAL;
 852         u8 radio_input;
 853
 854         dprintk(1, "%s() frequency=%d (in units of khz)\n",
 855                 __func__, params->frequency);
 856
 857         if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
 858                 dprintk(1, "%s() radio input not configured\n", __func__);
 859                 return -EINVAL;
 860         }
 861
 862         if (priv->radio_input == XC5000_RADIO_FM1)
 863                 radio_input = FM_Radio_INPUT1;
 864         else if  (priv->radio_input == XC5000_RADIO_FM2)
 865                 radio_input = FM_Radio_INPUT2;
 866         else {
 867                 dprintk(1, "%s() unknown radio input %d\n", __func__,
 868                         priv->radio_input);
 869                 return -EINVAL;
 870         }
 871
 872         priv->freq_hz = params->frequency * 125 / 2;
 873
 874         priv->rf_mode = XC_RF_MODE_AIR;
 875
 876         ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
 877                                XC5000_Standard[radio_input].AudioMode);
 878
 879         if (ret != XC_RESULT_SUCCESS) {
 880                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 881                 return -EREMOTEIO;
 882         }
 883
 884         ret = xc_SetSignalSource(priv, priv->rf_mode);
 885         if (ret != XC_RESULT_SUCCESS) {
 886                 printk(KERN_ERR
 887                         "xc5000: xc_SetSignalSource(%d) failed\n",
 888                         priv->rf_mode);
 889                 return -EREMOTEIO;
 890         }
 891
 892         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 893
 894         return 0;
 895 }
 896
 897 static int xc5000_set_analog_params(struct dvb_frontend *fe,
 898                              struct analog_parameters *params)
 899 {
 900         struct xc5000_priv *priv = fe->tuner_priv;
 901         int ret = -EINVAL;
 902
 903         if (priv->i2c_props.adap == NULL)
 904                 return -EINVAL;
 905
 906         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
 907                 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
 908                         dprintk(1, "Unable to load firmware and init tuner\n");
 909                         return -EINVAL;
 910                 }
 911         }
 912
 913         switch (params->mode) {
 914         case V4L2_TUNER_RADIO:
 915                 ret = xc5000_set_radio_freq(fe, params);
 916                 break;
 917         case V4L2_TUNER_ANALOG_TV:
 918         case V4L2_TUNER_DIGITAL_TV:
 919                 ret = xc5000_set_tv_freq(fe, params);
 920                 break;
 921         }
 922
 923         return ret;
 924 }
 925
 926
 927 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
 928 {
 929         struct xc5000_priv *priv = fe->tuner_priv;
 930         dprintk(1, "%s()\n", __func__);
 931         *freq = priv->freq_hz;
 932         return 0;
 933 }
 934
 935 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
 936 {
 937         struct xc5000_priv *priv = fe->tuner_priv;
 938         dprintk(1, "%s()\n", __func__);
 939
 940         *bw = priv->bandwidth;
 941         return 0;
 942 }
 943
 944 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
 945 {
 946         struct xc5000_priv *priv = fe->tuner_priv;
 947         u16 lock_status = 0;
 948
 949         xc_get_lock_status(priv, &lock_status);
 950
 951         dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
 952
 953         *status = lock_status;
 954
 955         return 0;
 956 }
 957
 958 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
 959 {
 960         struct xc5000_priv *priv = fe->tuner_priv;
 961         int ret = 0;
 962
 963         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
 964                 ret = xc5000_fwupload(fe);
 965                 if (ret != XC_RESULT_SUCCESS)
 966                         return ret;
 967         }
 968
 969         /* Start the tuner self-calibration process */
 970         ret |= xc_initialize(priv);
 971
 972         /* Wait for calibration to complete.
 973          * We could continue but XC5000 will clock stretch subsequent
 974          * I2C transactions until calibration is complete.  This way we
 975          * don't have to rely on clock stretching working.
 976          */
 977         xc_wait(100);
 978
 979         /* Default to "CABLE" mode */
 980         ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
 981
 982         return ret;
 983 }
 984
 985 static int xc5000_sleep(struct dvb_frontend *fe)
 986 {
 987         int ret;
 988
 989         dprintk(1, "%s()\n", __func__);
 990
 991         /* Avoid firmware reload on slow devices */
 992         if (no_poweroff)
 993                 return 0;
 994
 995         /* According to Xceive technical support, the "powerdown" register
 996            was removed in newer versions of the firmware.  The "supported"
 997            way to sleep the tuner is to pull the reset pin low for 10ms */
 998         ret = xc5000_TunerReset(fe);
 999         if (ret != XC_RESULT_SUCCESS) {
1000                 printk(KERN_ERR
1001                         "xc5000: %s() unable to shutdown tuner\n",
1002                         __func__);
1003                 return -EREMOTEIO;
1004         } else
1005                 return XC_RESULT_SUCCESS;
1006 }
1007
1008 static int xc5000_init(struct dvb_frontend *fe)
1009 {
1010         struct xc5000_priv *priv = fe->tuner_priv;
1011         dprintk(1, "%s()\n", __func__);
1012
1013         if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1014                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1015                 return -EREMOTEIO;
1016         }
1017
1018         if (debug)
1019                 xc_debug_dump(priv);
1020
1021         return 0;
1022 }
1023
1024 static int xc5000_release(struct dvb_frontend *fe)
1025 {
1026         struct xc5000_priv *priv = fe->tuner_priv;
1027
1028         dprintk(1, "%s()\n", __func__);
1029
1030         mutex_lock(&xc5000_list_mutex);
1031
1032         if (priv)
1033                 hybrid_tuner_release_state(priv);
1034
1035         mutex_unlock(&xc5000_list_mutex);
1036
1037         fe->tuner_priv = NULL;
1038
1039         return 0;
1040 }
1041
1042 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1043         .info = {
1044                 .name           = "Xceive XC5000",
1045                 .frequency_min  =    1000000,
1046                 .frequency_max  = 1023000000,
1047                 .frequency_step =      50000,
1048         },
1049
1050         .release           = xc5000_release,
1051         .init              = xc5000_init,
1052         .sleep             = xc5000_sleep,
1053
1054         .set_params        = xc5000_set_params,
1055         .set_analog_params = xc5000_set_analog_params,
1056         .get_frequency     = xc5000_get_frequency,
1057         .get_bandwidth     = xc5000_get_bandwidth,
1058         .get_status        = xc5000_get_status
1059 };
1060
1061 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1062                                    struct i2c_adapter *i2c,
1063                                    const struct xc5000_config *cfg)
1064 {
1065         struct xc5000_priv *priv = NULL;
1066         int instance;
1067         u16 id = 0;
1068
1069         dprintk(1, "%s(%d-%04x)\n", __func__,
1070                 i2c ? i2c_adapter_id(i2c) : -1,
1071                 cfg ? cfg->i2c_address : -1);
1072
1073         mutex_lock(&xc5000_list_mutex);
1074
1075         instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1076                                               hybrid_tuner_instance_list,
1077                                               i2c, cfg->i2c_address, "xc5000");
1078         switch (instance) {
1079         case 0:
1080                 goto fail;
1081                 break;
1082         case 1:
1083                 /* new tuner instance */
1084                 priv->bandwidth = BANDWIDTH_6_MHZ;
1085                 fe->tuner_priv = priv;
1086                 break;
1087         default:
1088                 /* existing tuner instance */
1089                 fe->tuner_priv = priv;
1090                 break;
1091         }
1092
1093         if (priv->if_khz == 0) {
1094                 /* If the IF hasn't been set yet, use the value provided by
1095                    the caller (occurs in hybrid devices where the analog
1096                    call to xc5000_attach occurs before the digital side) */
1097                 priv->if_khz = cfg->if_khz;
1098         }
1099
1100         if (priv->radio_input == 0)
1101                 priv->radio_input = cfg->radio_input;
1102
1103         /* Check if firmware has been loaded. It is possible that another
1104            instance of the driver has loaded the firmware.
1105          */
1106         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1107                 goto fail;
1108
1109         switch (id) {
1110         case XC_PRODUCT_ID_FW_LOADED:
1111                 printk(KERN_INFO
1112                         "xc5000: Successfully identified at address 0x%02x\n",
1113                         cfg->i2c_address);
1114                 printk(KERN_INFO
1115                         "xc5000: Firmware has been loaded previously\n");
1116                 break;
1117         case XC_PRODUCT_ID_FW_NOT_LOADED:
1118                 printk(KERN_INFO
1119                         "xc5000: Successfully identified at address 0x%02x\n",
1120                         cfg->i2c_address);
1121                 printk(KERN_INFO
1122                         "xc5000: Firmware has not been loaded previously\n");
1123                 break;
1124         default:
1125                 printk(KERN_ERR
1126                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1127                         cfg->i2c_address, id);
1128                 goto fail;
1129         }
1130
1131         mutex_unlock(&xc5000_list_mutex);
1132
1133         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1134                 sizeof(struct dvb_tuner_ops));
1135
1136         return fe;
1137 fail:
1138         mutex_unlock(&xc5000_list_mutex);
1139
1140         xc5000_release(fe);
1141         return NULL;
1142 }
1143 EXPORT_SYMBOL(xc5000_attach);
1144
1145 MODULE_AUTHOR("Steven Toth");
1146 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1147 MODULE_LICENSE("GPL");