drivers/media/common/tuners/xc5000.c

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