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 {
 633         int ret, b;
 634         struct xc5000_priv *priv = fe->tuner_priv;
 635         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 636         u32 freq = fe->dtv_property_cache.frequency;
 637         u32 delsys  = fe->dtv_property_cache.delivery_system;
 638
 639         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
 640                 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
 641                         dprintk(1, "Unable to load firmware and init tuner\n");
 642                         return -EINVAL;
 643                 }
 644         }
 645
 646         dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
 647
 648         switch (delsys) {
 649         case SYS_ATSC:
 650                 dprintk(1, "%s() VSB modulation\n", __func__);
 651                 priv->rf_mode = XC_RF_MODE_AIR;
 652                 priv->freq_hz = freq - 1750000;
 653                 priv->video_standard = DTV6;
 654                 break;
 655         case SYS_DVBC_ANNEX_B:
 656                 dprintk(1, "%s() QAM modulation\n", __func__);
 657                 priv->rf_mode = XC_RF_MODE_CABLE;
 658                 priv->freq_hz = freq - 1750000;
 659                 priv->video_standard = DTV6;
 660                 break;
 661         case SYS_DVBT:
 662         case SYS_DVBT2:
 663                 dprintk(1, "%s() OFDM\n", __func__);
 664                 switch (bw) {
 665                 case 6000000:
 666                         priv->video_standard = DTV6;
 667                         priv->freq_hz = freq - 1750000;
 668                         break;
 669                 case 7000000:
 670                         priv->video_standard = DTV7;
 671                         priv->freq_hz = freq - 2250000;
 672                         break;
 673                 case 8000000:
 674                         priv->video_standard = DTV8;
 675                         priv->freq_hz = freq - 2750000;
 676                         break;
 677                 default:
 678                         printk(KERN_ERR "xc5000 bandwidth not set!\n");
 679                         return -EINVAL;
 680                 }
 681                 priv->rf_mode = XC_RF_MODE_AIR;
 682         case SYS_DVBC_ANNEX_A:
 683         case SYS_DVBC_ANNEX_C:
 684                 dprintk(1, "%s() QAM modulation\n", __func__);
 685                 priv->rf_mode = XC_RF_MODE_CABLE;
 686                 if (bw <= 6000000) {
 687                         priv->video_standard = DTV6;
 688                         priv->freq_hz = freq - 1750000;
 689                         b = 6;
 690                 } else if (bw <= 7000000) {
 691                         priv->video_standard = DTV7;
 692                         priv->freq_hz = freq - 2250000;
 693                         b = 7;
 694                 } else {
 695                         priv->video_standard = DTV7_8;
 696                         priv->freq_hz = freq - 2750000;
 697                         b = 8;
 698                 }
 699                 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
 700                         b, bw);
 701                 break;
 702         default:
 703                 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
 704                 return -EINVAL;
 705         }
 706
 707         dprintk(1, "%s() frequency=%d (compensated to %d)\n",
 708                 __func__, freq, priv->freq_hz);
 709
 710         ret = xc_SetSignalSource(priv, priv->rf_mode);
 711         if (ret != XC_RESULT_SUCCESS) {
 712                 printk(KERN_ERR
 713                         "xc5000: xc_SetSignalSource(%d) failed\n",
 714                         priv->rf_mode);
 715                 return -EREMOTEIO;
 716         }
 717
 718         ret = xc_SetTVStandard(priv,
 719                 XC5000_Standard[priv->video_standard].VideoMode,
 720                 XC5000_Standard[priv->video_standard].AudioMode);
 721         if (ret != XC_RESULT_SUCCESS) {
 722                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 723                 return -EREMOTEIO;
 724         }
 725
 726         ret = xc_set_IF_frequency(priv, priv->if_khz);
 727         if (ret != XC_RESULT_SUCCESS) {
 728                 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
 729                        priv->if_khz);
 730                 return -EIO;
 731         }
 732
 733         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
 734
 735         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
 736
 737         if (debug)
 738                 xc_debug_dump(priv);
 739
 740         priv->bandwidth = bw;
 741
 742         return 0;
 743 }
 744
 745 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
 746 {
 747         struct xc5000_priv *priv = fe->tuner_priv;
 748         int ret;
 749         u16 id;
 750
 751         ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
 752         if (ret == XC_RESULT_SUCCESS) {
 753                 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
 754                         ret = XC_RESULT_RESET_FAILURE;
 755                 else
 756                         ret = XC_RESULT_SUCCESS;
 757         }
 758
 759         dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
 760                 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
 761         return ret;
 762 }
 763
 764 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
 765         struct analog_parameters *params)
 766 {
 767         struct xc5000_priv *priv = fe->tuner_priv;
 768         int ret;
 769
 770         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
 771                 __func__, params->frequency);
 772
 773         /* Fix me: it could be air. */
 774         priv->rf_mode = params->mode;
 775         if (params->mode > XC_RF_MODE_CABLE)
 776                 priv->rf_mode = XC_RF_MODE_CABLE;
 777
 778         /* params->frequency is in units of 62.5khz */
 779         priv->freq_hz = params->frequency * 62500;
 780
 781         /* FIX ME: Some video standards may have several possible audio
 782                    standards. We simply default to one of them here.
 783          */
 784         if (params->std & V4L2_STD_MN) {
 785                 /* default to BTSC audio standard */
 786                 priv->video_standard = MN_NTSC_PAL_BTSC;
 787                 goto tune_channel;
 788         }
 789
 790         if (params->std & V4L2_STD_PAL_BG) {
 791                 /* default to NICAM audio standard */
 792                 priv->video_standard = BG_PAL_NICAM;
 793                 goto tune_channel;
 794         }
 795
 796         if (params->std & V4L2_STD_PAL_I) {
 797                 /* default to NICAM audio standard */
 798                 priv->video_standard = I_PAL_NICAM;
 799                 goto tune_channel;
 800         }
 801
 802         if (params->std & V4L2_STD_PAL_DK) {
 803                 /* default to NICAM audio standard */
 804                 priv->video_standard = DK_PAL_NICAM;
 805                 goto tune_channel;
 806         }
 807
 808         if (params->std & V4L2_STD_SECAM_DK) {
 809                 /* default to A2 DK1 audio standard */
 810                 priv->video_standard = DK_SECAM_A2DK1;
 811                 goto tune_channel;
 812         }
 813
 814         if (params->std & V4L2_STD_SECAM_L) {
 815                 priv->video_standard = L_SECAM_NICAM;
 816                 goto tune_channel;
 817         }
 818
 819         if (params->std & V4L2_STD_SECAM_LC) {
 820                 priv->video_standard = LC_SECAM_NICAM;
 821                 goto tune_channel;
 822         }
 823
 824 tune_channel:
 825         ret = xc_SetSignalSource(priv, priv->rf_mode);
 826         if (ret != XC_RESULT_SUCCESS) {
 827                 printk(KERN_ERR
 828                         "xc5000: xc_SetSignalSource(%d) failed\n",
 829                         priv->rf_mode);
 830                 return -EREMOTEIO;
 831         }
 832
 833         ret = xc_SetTVStandard(priv,
 834                 XC5000_Standard[priv->video_standard].VideoMode,
 835                 XC5000_Standard[priv->video_standard].AudioMode);
 836         if (ret != XC_RESULT_SUCCESS) {
 837                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 838                 return -EREMOTEIO;
 839         }
 840
 841         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
 842
 843         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 844
 845         if (debug)
 846                 xc_debug_dump(priv);
 847
 848         return 0;
 849 }
 850
 851 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
 852         struct analog_parameters *params)
 853 {
 854         struct xc5000_priv *priv = fe->tuner_priv;
 855         int ret = -EINVAL;
 856         u8 radio_input;
 857
 858         dprintk(1, "%s() frequency=%d (in units of khz)\n",
 859                 __func__, params->frequency);
 860
 861         if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
 862                 dprintk(1, "%s() radio input not configured\n", __func__);
 863                 return -EINVAL;
 864         }
 865
 866         if (priv->radio_input == XC5000_RADIO_FM1)
 867                 radio_input = FM_Radio_INPUT1;
 868         else if  (priv->radio_input == XC5000_RADIO_FM2)
 869                 radio_input = FM_Radio_INPUT2;
 870         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
 871                 radio_input = FM_Radio_INPUT1_MONO;
 872         else {
 873                 dprintk(1, "%s() unknown radio input %d\n", __func__,
 874                         priv->radio_input);
 875                 return -EINVAL;
 876         }
 877
 878         priv->freq_hz = params->frequency * 125 / 2;
 879
 880         priv->rf_mode = XC_RF_MODE_AIR;
 881
 882         ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
 883                                XC5000_Standard[radio_input].AudioMode);
 884
 885         if (ret != XC_RESULT_SUCCESS) {
 886                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 887                 return -EREMOTEIO;
 888         }
 889
 890         ret = xc_SetSignalSource(priv, priv->rf_mode);
 891         if (ret != XC_RESULT_SUCCESS) {
 892                 printk(KERN_ERR
 893                         "xc5000: xc_SetSignalSource(%d) failed\n",
 894                         priv->rf_mode);
 895                 return -EREMOTEIO;
 896         }
 897
 898         if ((priv->radio_input == XC5000_RADIO_FM1) ||
 899                                 (priv->radio_input == XC5000_RADIO_FM2))
 900                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
 901         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
 902                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
 903
 904         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 905
 906         return 0;
 907 }
 908
 909 static int xc5000_set_analog_params(struct dvb_frontend *fe,
 910                              struct analog_parameters *params)
 911 {
 912         struct xc5000_priv *priv = fe->tuner_priv;
 913         int ret = -EINVAL;
 914
 915         if (priv->i2c_props.adap == NULL)
 916                 return -EINVAL;
 917
 918         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
 919                 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
 920                         dprintk(1, "Unable to load firmware and init tuner\n");
 921                         return -EINVAL;
 922                 }
 923         }
 924
 925         switch (params->mode) {
 926         case V4L2_TUNER_RADIO:
 927                 ret = xc5000_set_radio_freq(fe, params);
 928                 break;
 929         case V4L2_TUNER_ANALOG_TV:
 930         case V4L2_TUNER_DIGITAL_TV:
 931                 ret = xc5000_set_tv_freq(fe, params);
 932                 break;
 933         }
 934
 935         return ret;
 936 }
 937
 938
 939 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
 940 {
 941         struct xc5000_priv *priv = fe->tuner_priv;
 942         dprintk(1, "%s()\n", __func__);
 943         *freq = priv->freq_hz;
 944         return 0;
 945 }
 946
 947 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
 948 {
 949         struct xc5000_priv *priv = fe->tuner_priv;
 950         dprintk(1, "%s()\n", __func__);
 951         *freq = priv->if_khz * 1000;
 952         return 0;
 953 }
 954
 955 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
 956 {
 957         struct xc5000_priv *priv = fe->tuner_priv;
 958         dprintk(1, "%s()\n", __func__);
 959
 960         *bw = priv->bandwidth;
 961         return 0;
 962 }
 963
 964 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
 965 {
 966         struct xc5000_priv *priv = fe->tuner_priv;
 967         u16 lock_status = 0;
 968
 969         xc_get_lock_status(priv, &lock_status);
 970
 971         dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
 972
 973         *status = lock_status;
 974
 975         return 0;
 976 }
 977
 978 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
 979 {
 980         struct xc5000_priv *priv = fe->tuner_priv;
 981         int ret = 0;
 982
 983         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
 984                 ret = xc5000_fwupload(fe);
 985                 if (ret != XC_RESULT_SUCCESS)
 986                         return ret;
 987         }
 988
 989         /* Start the tuner self-calibration process */
 990         ret |= xc_initialize(priv);
 991
 992         /* Wait for calibration to complete.
 993          * We could continue but XC5000 will clock stretch subsequent
 994          * I2C transactions until calibration is complete.  This way we
 995          * don't have to rely on clock stretching working.
 996          */
 997         xc_wait(100);
 998
 999         /* Default to "CABLE" mode */
1000         ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1001
1002         return ret;
1003 }
1004
1005 static int xc5000_sleep(struct dvb_frontend *fe)
1006 {
1007         int ret;
1008
1009         dprintk(1, "%s()\n", __func__);
1010
1011         /* Avoid firmware reload on slow devices */
1012         if (no_poweroff)
1013                 return 0;
1014
1015         /* According to Xceive technical support, the "powerdown" register
1016            was removed in newer versions of the firmware.  The "supported"
1017            way to sleep the tuner is to pull the reset pin low for 10ms */
1018         ret = xc5000_TunerReset(fe);
1019         if (ret != XC_RESULT_SUCCESS) {
1020                 printk(KERN_ERR
1021                         "xc5000: %s() unable to shutdown tuner\n",
1022                         __func__);
1023                 return -EREMOTEIO;
1024         } else
1025                 return XC_RESULT_SUCCESS;
1026 }
1027
1028 static int xc5000_init(struct dvb_frontend *fe)
1029 {
1030         struct xc5000_priv *priv = fe->tuner_priv;
1031         dprintk(1, "%s()\n", __func__);
1032
1033         if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1034                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1035                 return -EREMOTEIO;
1036         }
1037
1038         if (debug)
1039                 xc_debug_dump(priv);
1040
1041         return 0;
1042 }
1043
1044 static int xc5000_release(struct dvb_frontend *fe)
1045 {
1046         struct xc5000_priv *priv = fe->tuner_priv;
1047
1048         dprintk(1, "%s()\n", __func__);
1049
1050         mutex_lock(&xc5000_list_mutex);
1051
1052         if (priv)
1053                 hybrid_tuner_release_state(priv);
1054
1055         mutex_unlock(&xc5000_list_mutex);
1056
1057         fe->tuner_priv = NULL;
1058
1059         return 0;
1060 }
1061
1062 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1063 {
1064         struct xc5000_priv *priv = fe->tuner_priv;
1065         struct xc5000_config *p = priv_cfg;
1066
1067         dprintk(1, "%s()\n", __func__);
1068
1069         if (p->if_khz)
1070                 priv->if_khz = p->if_khz;
1071
1072         if (p->radio_input)
1073                 priv->radio_input = p->radio_input;
1074
1075         return 0;
1076 }
1077
1078
1079 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1080         .info = {
1081                 .name           = "Xceive XC5000",
1082                 .frequency_min  =    1000000,
1083                 .frequency_max  = 1023000000,
1084                 .frequency_step =      50000,
1085         },
1086
1087         .release           = xc5000_release,
1088         .init              = xc5000_init,
1089         .sleep             = xc5000_sleep,
1090
1091         .set_config        = xc5000_set_config,
1092         .set_params        = xc5000_set_params,
1093         .set_analog_params = xc5000_set_analog_params,
1094         .get_frequency     = xc5000_get_frequency,
1095         .get_if_frequency  = xc5000_get_if_frequency,
1096         .get_bandwidth     = xc5000_get_bandwidth,
1097         .get_status        = xc5000_get_status
1098 };
1099
1100 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1101                                    struct i2c_adapter *i2c,
1102                                    const struct xc5000_config *cfg)
1103 {
1104         struct xc5000_priv *priv = NULL;
1105         int instance;
1106         u16 id = 0;
1107
1108         dprintk(1, "%s(%d-%04x)\n", __func__,
1109                 i2c ? i2c_adapter_id(i2c) : -1,
1110                 cfg ? cfg->i2c_address : -1);
1111
1112         mutex_lock(&xc5000_list_mutex);
1113
1114         instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1115                                               hybrid_tuner_instance_list,
1116                                               i2c, cfg->i2c_address, "xc5000");
1117         switch (instance) {
1118         case 0:
1119                 goto fail;
1120                 break;
1121         case 1:
1122                 /* new tuner instance */
1123                 priv->bandwidth = 6000000;
1124                 fe->tuner_priv = priv;
1125                 break;
1126         default:
1127                 /* existing tuner instance */
1128                 fe->tuner_priv = priv;
1129                 break;
1130         }
1131
1132         if (priv->if_khz == 0) {
1133                 /* If the IF hasn't been set yet, use the value provided by
1134                    the caller (occurs in hybrid devices where the analog
1135                    call to xc5000_attach occurs before the digital side) */
1136                 priv->if_khz = cfg->if_khz;
1137         }
1138
1139         if (priv->radio_input == 0)
1140                 priv->radio_input = cfg->radio_input;
1141
1142         /* Check if firmware has been loaded. It is possible that another
1143            instance of the driver has loaded the firmware.
1144          */
1145         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1146                 goto fail;
1147
1148         switch (id) {
1149         case XC_PRODUCT_ID_FW_LOADED:
1150                 printk(KERN_INFO
1151                         "xc5000: Successfully identified at address 0x%02x\n",
1152                         cfg->i2c_address);
1153                 printk(KERN_INFO
1154                         "xc5000: Firmware has been loaded previously\n");
1155                 break;
1156         case XC_PRODUCT_ID_FW_NOT_LOADED:
1157                 printk(KERN_INFO
1158                         "xc5000: Successfully identified at address 0x%02x\n",
1159                         cfg->i2c_address);
1160                 printk(KERN_INFO
1161                         "xc5000: Firmware has not been loaded previously\n");
1162                 break;
1163         default:
1164                 printk(KERN_ERR
1165                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1166                         cfg->i2c_address, id);
1167                 goto fail;
1168         }
1169
1170         mutex_unlock(&xc5000_list_mutex);
1171
1172         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1173                 sizeof(struct dvb_tuner_ops));
1174
1175         return fe;
1176 fail:
1177         mutex_unlock(&xc5000_list_mutex);
1178
1179         xc5000_release(fe);
1180         return NULL;
1181 }
1182 EXPORT_SYMBOL(xc5000_attach);
1183
1184 MODULE_AUTHOR("Steven Toth");
1185 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1186 MODULE_LICENSE("GPL");