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