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