linux/drivers/media/common/tuners/xc5000.c
<<
>>
Prefs
   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
  36static int debug;
  37module_param(debug, int, 0644);
  38MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
  39
  40static int no_poweroff;
  41module_param(no_poweroff, int, 0644);
  42MODULE_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
  46static DEFINE_MUTEX(xc5000_list_mutex);
  47static 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
  55struct 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*/
 146struct 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
 177static 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
 203static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
 204static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
 205static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
 206static int xc5000_TunerReset(struct dvb_frontend *fe);
 207
 208static 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 */
 223static 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
 235static void xc_wait(int wait_ms)
 236{
 237        msleep(wait_ms);
 238}
 239
 240static 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
 264static 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
 302static 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
 356static 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
 362static 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
 378static 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
 392static const struct dvb_tuner_ops xc5000_tuner_ops;
 393
 394static 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
 413static 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
 423static 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
 428static 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
 443static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
 444{
 445        return xc5000_readreg(priv, XREG_LOCK, lock_status);
 446}
 447
 448static 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
 467static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
 468{
 469        return xc5000_readreg(priv, XREG_BUILD, buildrev);
 470}
 471
 472static 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
 485static 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
 490static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
 491{
 492        return xc5000_readreg(priv, XREG_QUALITY, quality);
 493}
 494
 495static 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
 512static 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
 529static 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
 549static 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
 580out:
 581        release_firmware(fw);
 582        return ret;
 583}
 584
 585static 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
 630static 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
 728static 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
 747static 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
 807tune_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
 832static 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
 882static 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
 912static 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
 920static 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
 929static 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
 943static 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
 970static 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
 993static 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
1009static 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
1027static 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
1046struct 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;
1122fail:
1123        mutex_unlock(&xc5000_list_mutex);
1124
1125        xc5000_release(fe);
1126        return NULL;
1127}
1128EXPORT_SYMBOL(xc5000_attach);
1129
1130MODULE_AUTHOR("Steven Toth");
1131MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1132MODULE_LICENSE("GPL");
1133