linux/drivers/media/tuners/xc4000.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  Driver for Xceive XC4000 "QAM/8VSB single chip tuner"
   4 *
   5 *  Copyright (c) 2007 Xceive Corporation
   6 *  Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
   7 *  Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
   8 *  Copyright (c) 2009 Davide Ferri <d.ferri@zero11.it>
   9 *  Copyright (c) 2010 Istvan Varga <istvan_v@mailbox.hu>
  10 */
  11
  12#include <linux/module.h>
  13#include <linux/moduleparam.h>
  14#include <linux/videodev2.h>
  15#include <linux/delay.h>
  16#include <linux/dvb/frontend.h>
  17#include <linux/i2c.h>
  18#include <linux/mutex.h>
  19#include <asm/unaligned.h>
  20
  21#include <media/dvb_frontend.h>
  22
  23#include "xc4000.h"
  24#include "tuner-i2c.h"
  25#include "tuner-xc2028-types.h"
  26
  27static int debug;
  28module_param(debug, int, 0644);
  29MODULE_PARM_DESC(debug, "Debugging level (0 to 2, default: 0 (off)).");
  30
  31static int no_poweroff;
  32module_param(no_poweroff, int, 0644);
  33MODULE_PARM_DESC(no_poweroff, "Power management (1: disabled, 2: enabled, 0 (default): use device-specific default mode).");
  34
  35static int audio_std;
  36module_param(audio_std, int, 0644);
  37MODULE_PARM_DESC(audio_std, "Audio standard. XC4000 audio decoder explicitly needs to know what audio standard is needed for some video standards with audio A2 or NICAM. The valid settings are a sum of:\n"
  38        " 1: use NICAM/B or A2/B instead of NICAM/A or A2/A\n"
  39        " 2: use A2 instead of NICAM or BTSC\n"
  40        " 4: use SECAM/K3 instead of K1\n"
  41        " 8: use PAL-D/K audio for SECAM-D/K\n"
  42        "16: use FM radio input 1 instead of input 2\n"
  43        "32: use mono audio (the lower three bits are ignored)");
  44
  45static char firmware_name[30];
  46module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
  47MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the default firmware name.");
  48
  49static DEFINE_MUTEX(xc4000_list_mutex);
  50static LIST_HEAD(hybrid_tuner_instance_list);
  51
  52#define dprintk(level, fmt, arg...) if (debug >= level) \
  53        printk(KERN_INFO "%s: " fmt, "xc4000", ## arg)
  54
  55/* struct for storing firmware table */
  56struct firmware_description {
  57        unsigned int  type;
  58        v4l2_std_id   id;
  59        __u16         int_freq;
  60        unsigned char *ptr;
  61        unsigned int  size;
  62};
  63
  64struct firmware_properties {
  65        unsigned int    type;
  66        v4l2_std_id     id;
  67        v4l2_std_id     std_req;
  68        __u16           int_freq;
  69        unsigned int    scode_table;
  70        int             scode_nr;
  71};
  72
  73struct xc4000_priv {
  74        struct tuner_i2c_props i2c_props;
  75        struct list_head hybrid_tuner_instance_list;
  76        struct firmware_description *firm;
  77        int     firm_size;
  78        u32     if_khz;
  79        u32     freq_hz, freq_offset;
  80        u32     bandwidth;
  81        u8      video_standard;
  82        u8      rf_mode;
  83        u8      default_pm;
  84        u8      dvb_amplitude;
  85        u8      set_smoothedcvbs;
  86        u8      ignore_i2c_write_errors;
  87        __u16   firm_version;
  88        struct firmware_properties cur_fw;
  89        __u16   hwmodel;
  90        __u16   hwvers;
  91        struct mutex    lock;
  92};
  93
  94#define XC4000_AUDIO_STD_B               1
  95#define XC4000_AUDIO_STD_A2              2
  96#define XC4000_AUDIO_STD_K3              4
  97#define XC4000_AUDIO_STD_L               8
  98#define XC4000_AUDIO_STD_INPUT1         16
  99#define XC4000_AUDIO_STD_MONO           32
 100
 101#define XC4000_DEFAULT_FIRMWARE "dvb-fe-xc4000-1.4.fw"
 102#define XC4000_DEFAULT_FIRMWARE_NEW "dvb-fe-xc4000-1.4.1.fw"
 103
 104/* Misc Defines */
 105#define MAX_TV_STANDARD                 24
 106#define XC_MAX_I2C_WRITE_LENGTH         64
 107#define XC_POWERED_DOWN                 0x80000000U
 108
 109/* Signal Types */
 110#define XC_RF_MODE_AIR                  0
 111#define XC_RF_MODE_CABLE                1
 112
 113/* Product id */
 114#define XC_PRODUCT_ID_FW_NOT_LOADED     0x2000
 115#define XC_PRODUCT_ID_XC4000            0x0FA0
 116#define XC_PRODUCT_ID_XC4100            0x1004
 117
 118/* Registers (Write-only) */
 119#define XREG_INIT         0x00
 120#define XREG_VIDEO_MODE   0x01
 121#define XREG_AUDIO_MODE   0x02
 122#define XREG_RF_FREQ      0x03
 123#define XREG_D_CODE       0x04
 124#define XREG_DIRECTSITTING_MODE 0x05
 125#define XREG_SEEK_MODE    0x06
 126#define XREG_POWER_DOWN   0x08
 127#define XREG_SIGNALSOURCE 0x0A
 128#define XREG_SMOOTHEDCVBS 0x0E
 129#define XREG_AMPLITUDE    0x10
 130
 131/* Registers (Read-only) */
 132#define XREG_ADC_ENV      0x00
 133#define XREG_QUALITY      0x01
 134#define XREG_FRAME_LINES  0x02
 135#define XREG_HSYNC_FREQ   0x03
 136#define XREG_LOCK         0x04
 137#define XREG_FREQ_ERROR   0x05
 138#define XREG_SNR          0x06
 139#define XREG_VERSION      0x07
 140#define XREG_PRODUCT_ID   0x08
 141#define XREG_SIGNAL_LEVEL 0x0A
 142#define XREG_NOISE_LEVEL  0x0B
 143
 144/*
 145   Basic firmware description. This will remain with
 146   the driver for documentation purposes.
 147
 148   This represents an I2C firmware file encoded as a
 149   string of unsigned char. Format is as follows:
 150
 151   char[0  ]=len0_MSB  -> len = len_MSB * 256 + len_LSB
 152   char[1  ]=len0_LSB  -> length of first write transaction
 153   char[2  ]=data0 -> first byte to be sent
 154   char[3  ]=data1
 155   char[4  ]=data2
 156   char[   ]=...
 157   char[M  ]=dataN  -> last byte to be sent
 158   char[M+1]=len1_MSB  -> len = len_MSB * 256 + len_LSB
 159   char[M+2]=len1_LSB  -> length of second write transaction
 160   char[M+3]=data0
 161   char[M+4]=data1
 162   ...
 163   etc.
 164
 165   The [len] value should be interpreted as follows:
 166
 167   len= len_MSB _ len_LSB
 168   len=1111_1111_1111_1111   : End of I2C_SEQUENCE
 169   len=0000_0000_0000_0000   : Reset command: Do hardware reset
 170   len=0NNN_NNNN_NNNN_NNNN   : Normal transaction: number of bytes = {1:32767)
 171   len=1WWW_WWWW_WWWW_WWWW   : Wait command: wait for {1:32767} ms
 172
 173   For the RESET and WAIT commands, the two following bytes will contain
 174   immediately the length of the following transaction.
 175*/
 176
 177struct XC_TV_STANDARD {
 178        const char  *Name;
 179        u16         audio_mode;
 180        u16         video_mode;
 181        u16         int_freq;
 182};
 183
 184/* Tuner standards */
 185#define XC4000_MN_NTSC_PAL_BTSC         0
 186#define XC4000_MN_NTSC_PAL_A2           1
 187#define XC4000_MN_NTSC_PAL_EIAJ         2
 188#define XC4000_MN_NTSC_PAL_Mono         3
 189#define XC4000_BG_PAL_A2                4
 190#define XC4000_BG_PAL_NICAM             5
 191#define XC4000_BG_PAL_MONO              6
 192#define XC4000_I_PAL_NICAM              7
 193#define XC4000_I_PAL_NICAM_MONO         8
 194#define XC4000_DK_PAL_A2                9
 195#define XC4000_DK_PAL_NICAM             10
 196#define XC4000_DK_PAL_MONO              11
 197#define XC4000_DK_SECAM_A2DK1           12
 198#define XC4000_DK_SECAM_A2LDK3          13
 199#define XC4000_DK_SECAM_A2MONO          14
 200#define XC4000_DK_SECAM_NICAM           15
 201#define XC4000_L_SECAM_NICAM            16
 202#define XC4000_LC_SECAM_NICAM           17
 203#define XC4000_DTV6                     18
 204#define XC4000_DTV8                     19
 205#define XC4000_DTV7_8                   20
 206#define XC4000_DTV7                     21
 207#define XC4000_FM_Radio_INPUT2          22
 208#define XC4000_FM_Radio_INPUT1          23
 209
 210static struct XC_TV_STANDARD xc4000_standard[MAX_TV_STANDARD] = {
 211        {"M/N-NTSC/PAL-BTSC",   0x0000, 0x80A0, 4500},
 212        {"M/N-NTSC/PAL-A2",     0x0000, 0x80A0, 4600},
 213        {"M/N-NTSC/PAL-EIAJ",   0x0040, 0x80A0, 4500},
 214        {"M/N-NTSC/PAL-Mono",   0x0078, 0x80A0, 4500},
 215        {"B/G-PAL-A2",          0x0000, 0x8159, 5640},
 216        {"B/G-PAL-NICAM",       0x0004, 0x8159, 5740},
 217        {"B/G-PAL-MONO",        0x0078, 0x8159, 5500},
 218        {"I-PAL-NICAM",         0x0080, 0x8049, 6240},
 219        {"I-PAL-NICAM-MONO",    0x0078, 0x8049, 6000},
 220        {"D/K-PAL-A2",          0x0000, 0x8049, 6380},
 221        {"D/K-PAL-NICAM",       0x0080, 0x8049, 6200},
 222        {"D/K-PAL-MONO",        0x0078, 0x8049, 6500},
 223        {"D/K-SECAM-A2 DK1",    0x0000, 0x8049, 6340},
 224        {"D/K-SECAM-A2 L/DK3",  0x0000, 0x8049, 6000},
 225        {"D/K-SECAM-A2 MONO",   0x0078, 0x8049, 6500},
 226        {"D/K-SECAM-NICAM",     0x0080, 0x8049, 6200},
 227        {"L-SECAM-NICAM",       0x8080, 0x0009, 6200},
 228        {"L'-SECAM-NICAM",      0x8080, 0x4009, 6200},
 229        {"DTV6",                0x00C0, 0x8002,    0},
 230        {"DTV8",                0x00C0, 0x800B,    0},
 231        {"DTV7/8",              0x00C0, 0x801B,    0},
 232        {"DTV7",                0x00C0, 0x8007,    0},
 233        {"FM Radio-INPUT2",     0x0008, 0x9800, 10700},
 234        {"FM Radio-INPUT1",     0x0008, 0x9000, 10700}
 235};
 236
 237static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val);
 238static int xc4000_tuner_reset(struct dvb_frontend *fe);
 239static void xc_debug_dump(struct xc4000_priv *priv);
 240
 241static int xc_send_i2c_data(struct xc4000_priv *priv, u8 *buf, int len)
 242{
 243        struct i2c_msg msg = { .addr = priv->i2c_props.addr,
 244                               .flags = 0, .buf = buf, .len = len };
 245        if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
 246                if (priv->ignore_i2c_write_errors == 0) {
 247                        printk(KERN_ERR "xc4000: I2C write failed (len=%i)\n",
 248                               len);
 249                        if (len == 4) {
 250                                printk(KERN_ERR "bytes %*ph\n", 4, buf);
 251                        }
 252                        return -EREMOTEIO;
 253                }
 254        }
 255        return 0;
 256}
 257
 258static int xc4000_tuner_reset(struct dvb_frontend *fe)
 259{
 260        struct xc4000_priv *priv = fe->tuner_priv;
 261        int ret;
 262
 263        dprintk(1, "%s()\n", __func__);
 264
 265        if (fe->callback) {
 266                ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
 267                                           fe->dvb->priv :
 268                                           priv->i2c_props.adap->algo_data,
 269                                           DVB_FRONTEND_COMPONENT_TUNER,
 270                                           XC4000_TUNER_RESET, 0);
 271                if (ret) {
 272                        printk(KERN_ERR "xc4000: reset failed\n");
 273                        return -EREMOTEIO;
 274                }
 275        } else {
 276                printk(KERN_ERR "xc4000: no tuner reset callback function, fatal\n");
 277                return -EINVAL;
 278        }
 279        return 0;
 280}
 281
 282static int xc_write_reg(struct xc4000_priv *priv, u16 regAddr, u16 i2cData)
 283{
 284        u8 buf[4];
 285        int result;
 286
 287        buf[0] = (regAddr >> 8) & 0xFF;
 288        buf[1] = regAddr & 0xFF;
 289        buf[2] = (i2cData >> 8) & 0xFF;
 290        buf[3] = i2cData & 0xFF;
 291        result = xc_send_i2c_data(priv, buf, 4);
 292
 293        return result;
 294}
 295
 296static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
 297{
 298        struct xc4000_priv *priv = fe->tuner_priv;
 299
 300        int i, nbytes_to_send, result;
 301        unsigned int len, pos, index;
 302        u8 buf[XC_MAX_I2C_WRITE_LENGTH];
 303
 304        index = 0;
 305        while ((i2c_sequence[index] != 0xFF) ||
 306                (i2c_sequence[index + 1] != 0xFF)) {
 307                len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
 308                if (len == 0x0000) {
 309                        /* RESET command */
 310                        /* NOTE: this is ignored, as the reset callback was */
 311                        /* already called by check_firmware() */
 312                        index += 2;
 313                } else if (len & 0x8000) {
 314                        /* WAIT command */
 315                        msleep(len & 0x7FFF);
 316                        index += 2;
 317                } else {
 318                        /* Send i2c data whilst ensuring individual transactions
 319                         * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
 320                         */
 321                        index += 2;
 322                        buf[0] = i2c_sequence[index];
 323                        buf[1] = i2c_sequence[index + 1];
 324                        pos = 2;
 325                        while (pos < len) {
 326                                if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
 327                                        nbytes_to_send =
 328                                                XC_MAX_I2C_WRITE_LENGTH;
 329                                else
 330                                        nbytes_to_send = (len - pos + 2);
 331                                for (i = 2; i < nbytes_to_send; i++) {
 332                                        buf[i] = i2c_sequence[index + pos +
 333                                                i - 2];
 334                                }
 335                                result = xc_send_i2c_data(priv, buf,
 336                                        nbytes_to_send);
 337
 338                                if (result != 0)
 339                                        return result;
 340
 341                                pos += nbytes_to_send - 2;
 342                        }
 343                        index += len;
 344                }
 345        }
 346        return 0;
 347}
 348
 349static int xc_set_tv_standard(struct xc4000_priv *priv,
 350        u16 video_mode, u16 audio_mode)
 351{
 352        int ret;
 353        dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode);
 354        dprintk(1, "%s() Standard = %s\n",
 355                __func__,
 356                xc4000_standard[priv->video_standard].Name);
 357
 358        /* Don't complain when the request fails because of i2c stretching */
 359        priv->ignore_i2c_write_errors = 1;
 360
 361        ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode);
 362        if (ret == 0)
 363                ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode);
 364
 365        priv->ignore_i2c_write_errors = 0;
 366
 367        return ret;
 368}
 369
 370static int xc_set_signal_source(struct xc4000_priv *priv, u16 rf_mode)
 371{
 372        dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
 373                rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
 374
 375        if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
 376                rf_mode = XC_RF_MODE_CABLE;
 377                printk(KERN_ERR
 378                        "%s(), Invalid mode, defaulting to CABLE",
 379                        __func__);
 380        }
 381        return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
 382}
 383
 384static const struct dvb_tuner_ops xc4000_tuner_ops;
 385
 386static int xc_set_rf_frequency(struct xc4000_priv *priv, u32 freq_hz)
 387{
 388        u16 freq_code;
 389
 390        dprintk(1, "%s(%u)\n", __func__, freq_hz);
 391
 392        if ((freq_hz > xc4000_tuner_ops.info.frequency_max_hz) ||
 393            (freq_hz < xc4000_tuner_ops.info.frequency_min_hz))
 394                return -EINVAL;
 395
 396        freq_code = (u16)(freq_hz / 15625);
 397
 398        /* WAS: Starting in firmware version 1.1.44, Xceive recommends using the
 399           FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
 400           only be used for fast scanning for channel lock) */
 401        /* WAS: XREG_FINERFREQ */
 402        return xc_write_reg(priv, XREG_RF_FREQ, freq_code);
 403}
 404
 405static int xc_get_adc_envelope(struct xc4000_priv *priv, u16 *adc_envelope)
 406{
 407        return xc4000_readreg(priv, XREG_ADC_ENV, adc_envelope);
 408}
 409
 410static int xc_get_frequency_error(struct xc4000_priv *priv, u32 *freq_error_hz)
 411{
 412        int result;
 413        u16 regData;
 414        u32 tmp;
 415
 416        result = xc4000_readreg(priv, XREG_FREQ_ERROR, &regData);
 417        if (result != 0)
 418                return result;
 419
 420        tmp = (u32)regData & 0xFFFFU;
 421        tmp = (tmp < 0x8000U ? tmp : 0x10000U - tmp);
 422        (*freq_error_hz) = tmp * 15625;
 423        return result;
 424}
 425
 426static int xc_get_lock_status(struct xc4000_priv *priv, u16 *lock_status)
 427{
 428        return xc4000_readreg(priv, XREG_LOCK, lock_status);
 429}
 430
 431static int xc_get_version(struct xc4000_priv *priv,
 432        u8 *hw_majorversion, u8 *hw_minorversion,
 433        u8 *fw_majorversion, u8 *fw_minorversion)
 434{
 435        u16 data;
 436        int result;
 437
 438        result = xc4000_readreg(priv, XREG_VERSION, &data);
 439        if (result != 0)
 440                return result;
 441
 442        (*hw_majorversion) = (data >> 12) & 0x0F;
 443        (*hw_minorversion) = (data >>  8) & 0x0F;
 444        (*fw_majorversion) = (data >>  4) & 0x0F;
 445        (*fw_minorversion) = data & 0x0F;
 446
 447        return 0;
 448}
 449
 450static int xc_get_hsync_freq(struct xc4000_priv *priv, u32 *hsync_freq_hz)
 451{
 452        u16 regData;
 453        int result;
 454
 455        result = xc4000_readreg(priv, XREG_HSYNC_FREQ, &regData);
 456        if (result != 0)
 457                return result;
 458
 459        (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
 460        return result;
 461}
 462
 463static int xc_get_frame_lines(struct xc4000_priv *priv, u16 *frame_lines)
 464{
 465        return xc4000_readreg(priv, XREG_FRAME_LINES, frame_lines);
 466}
 467
 468static int xc_get_quality(struct xc4000_priv *priv, u16 *quality)
 469{
 470        return xc4000_readreg(priv, XREG_QUALITY, quality);
 471}
 472
 473static int xc_get_signal_level(struct xc4000_priv *priv, u16 *signal)
 474{
 475        return xc4000_readreg(priv, XREG_SIGNAL_LEVEL, signal);
 476}
 477
 478static int xc_get_noise_level(struct xc4000_priv *priv, u16 *noise)
 479{
 480        return xc4000_readreg(priv, XREG_NOISE_LEVEL, noise);
 481}
 482
 483static u16 xc_wait_for_lock(struct xc4000_priv *priv)
 484{
 485        u16     lock_state = 0;
 486        int     watchdog_count = 40;
 487
 488        while ((lock_state == 0) && (watchdog_count > 0)) {
 489                xc_get_lock_status(priv, &lock_state);
 490                if (lock_state != 1) {
 491                        msleep(5);
 492                        watchdog_count--;
 493                }
 494        }
 495        return lock_state;
 496}
 497
 498static int xc_tune_channel(struct xc4000_priv *priv, u32 freq_hz)
 499{
 500        int     found = 1;
 501        int     result;
 502
 503        dprintk(1, "%s(%u)\n", __func__, freq_hz);
 504
 505        /* Don't complain when the request fails because of i2c stretching */
 506        priv->ignore_i2c_write_errors = 1;
 507        result = xc_set_rf_frequency(priv, freq_hz);
 508        priv->ignore_i2c_write_errors = 0;
 509
 510        if (result != 0)
 511                return 0;
 512
 513        /* wait for lock only in analog TV mode */
 514        if ((priv->cur_fw.type & (FM | DTV6 | DTV7 | DTV78 | DTV8)) == 0) {
 515                if (xc_wait_for_lock(priv) != 1)
 516                        found = 0;
 517        }
 518
 519        /* Wait for stats to stabilize.
 520         * Frame Lines needs two frame times after initial lock
 521         * before it is valid.
 522         */
 523        msleep(debug ? 100 : 10);
 524
 525        if (debug)
 526                xc_debug_dump(priv);
 527
 528        return found;
 529}
 530
 531static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val)
 532{
 533        u8 buf[2] = { reg >> 8, reg & 0xff };
 534        u8 bval[2] = { 0, 0 };
 535        struct i2c_msg msg[2] = {
 536                { .addr = priv->i2c_props.addr,
 537                        .flags = 0, .buf = &buf[0], .len = 2 },
 538                { .addr = priv->i2c_props.addr,
 539                        .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
 540        };
 541
 542        if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
 543                printk(KERN_ERR "xc4000: I2C read failed\n");
 544                return -EREMOTEIO;
 545        }
 546
 547        *val = (bval[0] << 8) | bval[1];
 548        return 0;
 549}
 550
 551#define dump_firm_type(t)       dump_firm_type_and_int_freq(t, 0)
 552static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq)
 553{
 554        if (type & BASE)
 555                printk(KERN_CONT "BASE ");
 556        if (type & INIT1)
 557                printk(KERN_CONT "INIT1 ");
 558        if (type & F8MHZ)
 559                printk(KERN_CONT "F8MHZ ");
 560        if (type & MTS)
 561                printk(KERN_CONT "MTS ");
 562        if (type & D2620)
 563                printk(KERN_CONT "D2620 ");
 564        if (type & D2633)
 565                printk(KERN_CONT "D2633 ");
 566        if (type & DTV6)
 567                printk(KERN_CONT "DTV6 ");
 568        if (type & QAM)
 569                printk(KERN_CONT "QAM ");
 570        if (type & DTV7)
 571                printk(KERN_CONT "DTV7 ");
 572        if (type & DTV78)
 573                printk(KERN_CONT "DTV78 ");
 574        if (type & DTV8)
 575                printk(KERN_CONT "DTV8 ");
 576        if (type & FM)
 577                printk(KERN_CONT "FM ");
 578        if (type & INPUT1)
 579                printk(KERN_CONT "INPUT1 ");
 580        if (type & LCD)
 581                printk(KERN_CONT "LCD ");
 582        if (type & NOGD)
 583                printk(KERN_CONT "NOGD ");
 584        if (type & MONO)
 585                printk(KERN_CONT "MONO ");
 586        if (type & ATSC)
 587                printk(KERN_CONT "ATSC ");
 588        if (type & IF)
 589                printk(KERN_CONT "IF ");
 590        if (type & LG60)
 591                printk(KERN_CONT "LG60 ");
 592        if (type & ATI638)
 593                printk(KERN_CONT "ATI638 ");
 594        if (type & OREN538)
 595                printk(KERN_CONT "OREN538 ");
 596        if (type & OREN36)
 597                printk(KERN_CONT "OREN36 ");
 598        if (type & TOYOTA388)
 599                printk(KERN_CONT "TOYOTA388 ");
 600        if (type & TOYOTA794)
 601                printk(KERN_CONT "TOYOTA794 ");
 602        if (type & DIBCOM52)
 603                printk(KERN_CONT "DIBCOM52 ");
 604        if (type & ZARLINK456)
 605                printk(KERN_CONT "ZARLINK456 ");
 606        if (type & CHINA)
 607                printk(KERN_CONT "CHINA ");
 608        if (type & F6MHZ)
 609                printk(KERN_CONT "F6MHZ ");
 610        if (type & INPUT2)
 611                printk(KERN_CONT "INPUT2 ");
 612        if (type & SCODE)
 613                printk(KERN_CONT "SCODE ");
 614        if (type & HAS_IF)
 615                printk(KERN_CONT "HAS_IF_%d ", int_freq);
 616}
 617
 618static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
 619                         v4l2_std_id *id)
 620{
 621        struct xc4000_priv *priv = fe->tuner_priv;
 622        int             i, best_i = -1;
 623        unsigned int    best_nr_diffs = 255U;
 624
 625        if (!priv->firm) {
 626                printk(KERN_ERR "Error! firmware not loaded\n");
 627                return -EINVAL;
 628        }
 629
 630        if (((type & ~SCODE) == 0) && (*id == 0))
 631                *id = V4L2_STD_PAL;
 632
 633        /* Seek for generic video standard match */
 634        for (i = 0; i < priv->firm_size; i++) {
 635                v4l2_std_id     id_diff_mask =
 636                        (priv->firm[i].id ^ (*id)) & (*id);
 637                unsigned int    type_diff_mask =
 638                        (priv->firm[i].type ^ type)
 639                        & (BASE_TYPES | DTV_TYPES | LCD | NOGD | MONO | SCODE);
 640                unsigned int    nr_diffs;
 641
 642                if (type_diff_mask
 643                    & (BASE | INIT1 | FM | DTV6 | DTV7 | DTV78 | DTV8 | SCODE))
 644                        continue;
 645
 646                nr_diffs = hweight64(id_diff_mask) + hweight32(type_diff_mask);
 647                if (!nr_diffs)  /* Supports all the requested standards */
 648                        goto found;
 649
 650                if (nr_diffs < best_nr_diffs) {
 651                        best_nr_diffs = nr_diffs;
 652                        best_i = i;
 653                }
 654        }
 655
 656        /* FIXME: Would make sense to seek for type "hint" match ? */
 657        if (best_i < 0) {
 658                i = -ENOENT;
 659                goto ret;
 660        }
 661
 662        if (best_nr_diffs > 0U) {
 663                printk(KERN_WARNING
 664                       "Selecting best matching firmware (%u bits differ) for type=(%x), id %016llx:\n",
 665                       best_nr_diffs, type, (unsigned long long)*id);
 666                i = best_i;
 667        }
 668
 669found:
 670        *id = priv->firm[i].id;
 671
 672ret:
 673        if (debug) {
 674                printk(KERN_DEBUG "%s firmware for type=",
 675                       (i < 0) ? "Can't find" : "Found");
 676                dump_firm_type(type);
 677                printk(KERN_DEBUG "(%x), id %016llx.\n", type, (unsigned long long)*id);
 678        }
 679        return i;
 680}
 681
 682static int load_firmware(struct dvb_frontend *fe, unsigned int type,
 683                         v4l2_std_id *id)
 684{
 685        struct xc4000_priv *priv = fe->tuner_priv;
 686        int                pos, rc;
 687        unsigned char      *p;
 688
 689        pos = seek_firmware(fe, type, id);
 690        if (pos < 0)
 691                return pos;
 692
 693        p = priv->firm[pos].ptr;
 694
 695        /* Don't complain when the request fails because of i2c stretching */
 696        priv->ignore_i2c_write_errors = 1;
 697
 698        rc = xc_load_i2c_sequence(fe, p);
 699
 700        priv->ignore_i2c_write_errors = 0;
 701
 702        return rc;
 703}
 704
 705static int xc4000_fwupload(struct dvb_frontend *fe)
 706{
 707        struct xc4000_priv *priv = fe->tuner_priv;
 708        const struct firmware *fw   = NULL;
 709        const unsigned char   *p, *endp;
 710        int                   rc = 0;
 711        int                   n, n_array;
 712        char                  name[33];
 713        const char            *fname;
 714
 715        if (firmware_name[0] != '\0') {
 716                fname = firmware_name;
 717
 718                dprintk(1, "Reading custom firmware %s\n", fname);
 719                rc = request_firmware(&fw, fname,
 720                                      priv->i2c_props.adap->dev.parent);
 721        } else {
 722                fname = XC4000_DEFAULT_FIRMWARE_NEW;
 723                dprintk(1, "Trying to read firmware %s\n", fname);
 724                rc = request_firmware(&fw, fname,
 725                                      priv->i2c_props.adap->dev.parent);
 726                if (rc == -ENOENT) {
 727                        fname = XC4000_DEFAULT_FIRMWARE;
 728                        dprintk(1, "Trying to read firmware %s\n", fname);
 729                        rc = request_firmware(&fw, fname,
 730                                              priv->i2c_props.adap->dev.parent);
 731                }
 732        }
 733
 734        if (rc < 0) {
 735                if (rc == -ENOENT)
 736                        printk(KERN_ERR "Error: firmware %s not found.\n", fname);
 737                else
 738                        printk(KERN_ERR "Error %d while requesting firmware %s\n",
 739                               rc, fname);
 740
 741                return rc;
 742        }
 743        dprintk(1, "Loading Firmware: %s\n", fname);
 744
 745        p = fw->data;
 746        endp = p + fw->size;
 747
 748        if (fw->size < sizeof(name) - 1 + 2 + 2) {
 749                printk(KERN_ERR "Error: firmware file %s has invalid size!\n",
 750                       fname);
 751                goto corrupt;
 752        }
 753
 754        memcpy(name, p, sizeof(name) - 1);
 755        name[sizeof(name) - 1] = '\0';
 756        p += sizeof(name) - 1;
 757
 758        priv->firm_version = get_unaligned_le16(p);
 759        p += 2;
 760
 761        n_array = get_unaligned_le16(p);
 762        p += 2;
 763
 764        dprintk(1, "Loading %d firmware images from %s, type: %s, ver %d.%d\n",
 765                n_array, fname, name,
 766                priv->firm_version >> 8, priv->firm_version & 0xff);
 767
 768        priv->firm = kcalloc(n_array, sizeof(*priv->firm), GFP_KERNEL);
 769        if (priv->firm == NULL) {
 770                printk(KERN_ERR "Not enough memory to load firmware file.\n");
 771                rc = -ENOMEM;
 772                goto done;
 773        }
 774        priv->firm_size = n_array;
 775
 776        n = -1;
 777        while (p < endp) {
 778                __u32 type, size;
 779                v4l2_std_id id;
 780                __u16 int_freq = 0;
 781
 782                n++;
 783                if (n >= n_array) {
 784                        printk(KERN_ERR "More firmware images in file than were expected!\n");
 785                        goto corrupt;
 786                }
 787
 788                /* Checks if there's enough bytes to read */
 789                if (endp - p < sizeof(type) + sizeof(id) + sizeof(size))
 790                        goto header;
 791
 792                type = get_unaligned_le32(p);
 793                p += sizeof(type);
 794
 795                id = get_unaligned_le64(p);
 796                p += sizeof(id);
 797
 798                if (type & HAS_IF) {
 799                        int_freq = get_unaligned_le16(p);
 800                        p += sizeof(int_freq);
 801                        if (endp - p < sizeof(size))
 802                                goto header;
 803                }
 804
 805                size = get_unaligned_le32(p);
 806                p += sizeof(size);
 807
 808                if (!size || size > endp - p) {
 809                        printk(KERN_ERR "Firmware type (%x), id %llx is corrupted (size=%zd, expected %d)\n",
 810                               type, (unsigned long long)id,
 811                               endp - p, size);
 812                        goto corrupt;
 813                }
 814
 815                priv->firm[n].ptr = kmemdup(p, size, GFP_KERNEL);
 816                if (priv->firm[n].ptr == NULL) {
 817                        printk(KERN_ERR "Not enough memory to load firmware file.\n");
 818                        rc = -ENOMEM;
 819                        goto done;
 820                }
 821
 822                if (debug) {
 823                        printk(KERN_DEBUG "Reading firmware type ");
 824                        dump_firm_type_and_int_freq(type, int_freq);
 825                        printk(KERN_DEBUG "(%x), id %llx, size=%d.\n",
 826                               type, (unsigned long long)id, size);
 827                }
 828
 829                priv->firm[n].type = type;
 830                priv->firm[n].id   = id;
 831                priv->firm[n].size = size;
 832                priv->firm[n].int_freq = int_freq;
 833
 834                p += size;
 835        }
 836
 837        if (n + 1 != priv->firm_size) {
 838                printk(KERN_ERR "Firmware file is incomplete!\n");
 839                goto corrupt;
 840        }
 841
 842        goto done;
 843
 844header:
 845        printk(KERN_ERR "Firmware header is incomplete!\n");
 846corrupt:
 847        rc = -EINVAL;
 848        printk(KERN_ERR "Error: firmware file is corrupted!\n");
 849
 850done:
 851        release_firmware(fw);
 852        if (rc == 0)
 853                dprintk(1, "Firmware files loaded.\n");
 854
 855        return rc;
 856}
 857
 858static int load_scode(struct dvb_frontend *fe, unsigned int type,
 859                         v4l2_std_id *id, __u16 int_freq, int scode)
 860{
 861        struct xc4000_priv *priv = fe->tuner_priv;
 862        int             pos, rc;
 863        unsigned char   *p;
 864        u8              scode_buf[13];
 865        u8              indirect_mode[5];
 866
 867        dprintk(1, "%s called int_freq=%d\n", __func__, int_freq);
 868
 869        if (!int_freq) {
 870                pos = seek_firmware(fe, type, id);
 871                if (pos < 0)
 872                        return pos;
 873        } else {
 874                for (pos = 0; pos < priv->firm_size; pos++) {
 875                        if ((priv->firm[pos].int_freq == int_freq) &&
 876                            (priv->firm[pos].type & HAS_IF))
 877                                break;
 878                }
 879                if (pos == priv->firm_size)
 880                        return -ENOENT;
 881        }
 882
 883        p = priv->firm[pos].ptr;
 884
 885        if (priv->firm[pos].size != 12 * 16 || scode >= 16)
 886                return -EINVAL;
 887        p += 12 * scode;
 888
 889        if (debug) {
 890                tuner_info("Loading SCODE for type=");
 891                dump_firm_type_and_int_freq(priv->firm[pos].type,
 892                                            priv->firm[pos].int_freq);
 893                printk(KERN_CONT "(%x), id %016llx.\n", priv->firm[pos].type,
 894                       (unsigned long long)*id);
 895        }
 896
 897        scode_buf[0] = 0x00;
 898        memcpy(&scode_buf[1], p, 12);
 899
 900        /* Enter direct-mode */
 901        rc = xc_write_reg(priv, XREG_DIRECTSITTING_MODE, 0);
 902        if (rc < 0) {
 903                printk(KERN_ERR "failed to put device into direct mode!\n");
 904                return -EIO;
 905        }
 906
 907        rc = xc_send_i2c_data(priv, scode_buf, 13);
 908        if (rc != 0) {
 909                /* Even if the send failed, make sure we set back to indirect
 910                   mode */
 911                printk(KERN_ERR "Failed to set scode %d\n", rc);
 912        }
 913
 914        /* Switch back to indirect-mode */
 915        memset(indirect_mode, 0, sizeof(indirect_mode));
 916        indirect_mode[4] = 0x88;
 917        xc_send_i2c_data(priv, indirect_mode, sizeof(indirect_mode));
 918        msleep(10);
 919
 920        return 0;
 921}
 922
 923static int check_firmware(struct dvb_frontend *fe, unsigned int type,
 924                          v4l2_std_id std, __u16 int_freq)
 925{
 926        struct xc4000_priv         *priv = fe->tuner_priv;
 927        struct firmware_properties new_fw;
 928        int                        rc = 0, is_retry = 0;
 929        u16                        hwmodel;
 930        v4l2_std_id                std0;
 931        u8                         hw_major = 0, hw_minor = 0, fw_major = 0, fw_minor = 0;
 932
 933        dprintk(1, "%s called\n", __func__);
 934
 935        if (!priv->firm) {
 936                rc = xc4000_fwupload(fe);
 937                if (rc < 0)
 938                        return rc;
 939        }
 940
 941retry:
 942        new_fw.type = type;
 943        new_fw.id = std;
 944        new_fw.std_req = std;
 945        new_fw.scode_table = SCODE;
 946        new_fw.scode_nr = 0;
 947        new_fw.int_freq = int_freq;
 948
 949        dprintk(1, "checking firmware, user requested type=");
 950        if (debug) {
 951                dump_firm_type(new_fw.type);
 952                printk(KERN_CONT "(%x), id %016llx, ", new_fw.type,
 953                       (unsigned long long)new_fw.std_req);
 954                if (!int_freq)
 955                        printk(KERN_CONT "scode_tbl ");
 956                else
 957                        printk(KERN_CONT "int_freq %d, ", new_fw.int_freq);
 958                printk(KERN_CONT "scode_nr %d\n", new_fw.scode_nr);
 959        }
 960
 961        /* No need to reload base firmware if it matches */
 962        if (priv->cur_fw.type & BASE) {
 963                dprintk(1, "BASE firmware not changed.\n");
 964                goto skip_base;
 965        }
 966
 967        /* Updating BASE - forget about all currently loaded firmware */
 968        memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
 969
 970        /* Reset is needed before loading firmware */
 971        rc = xc4000_tuner_reset(fe);
 972        if (rc < 0)
 973                goto fail;
 974
 975        /* BASE firmwares are all std0 */
 976        std0 = 0;
 977        rc = load_firmware(fe, BASE, &std0);
 978        if (rc < 0) {
 979                printk(KERN_ERR "Error %d while loading base firmware\n", rc);
 980                goto fail;
 981        }
 982
 983        /* Load INIT1, if needed */
 984        dprintk(1, "Load init1 firmware, if exists\n");
 985
 986        rc = load_firmware(fe, BASE | INIT1, &std0);
 987        if (rc == -ENOENT)
 988                rc = load_firmware(fe, BASE | INIT1, &std0);
 989        if (rc < 0 && rc != -ENOENT) {
 990                tuner_err("Error %d while loading init1 firmware\n",
 991                          rc);
 992                goto fail;
 993        }
 994
 995skip_base:
 996        /*
 997         * No need to reload standard specific firmware if base firmware
 998         * was not reloaded and requested video standards have not changed.
 999         */
1000        if (priv->cur_fw.type == (BASE | new_fw.type) &&
1001            priv->cur_fw.std_req == std) {
1002                dprintk(1, "Std-specific firmware already loaded.\n");
1003                goto skip_std_specific;
1004        }
1005
1006        /* Reloading std-specific firmware forces a SCODE update */
1007        priv->cur_fw.scode_table = 0;
1008
1009        /* Load the standard firmware */
1010        rc = load_firmware(fe, new_fw.type, &new_fw.id);
1011
1012        if (rc < 0)
1013                goto fail;
1014
1015skip_std_specific:
1016        if (priv->cur_fw.scode_table == new_fw.scode_table &&
1017            priv->cur_fw.scode_nr == new_fw.scode_nr) {
1018                dprintk(1, "SCODE firmware already loaded.\n");
1019                goto check_device;
1020        }
1021
1022        /* Load SCODE firmware, if exists */
1023        rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
1024                        new_fw.int_freq, new_fw.scode_nr);
1025        if (rc != 0)
1026                dprintk(1, "load scode failed %d\n", rc);
1027
1028check_device:
1029        if (xc4000_readreg(priv, XREG_PRODUCT_ID, &hwmodel) < 0) {
1030                printk(KERN_ERR "Unable to read tuner registers.\n");
1031                goto fail;
1032        }
1033
1034        if (xc_get_version(priv, &hw_major, &hw_minor, &fw_major,
1035                           &fw_minor) != 0) {
1036                printk(KERN_ERR "Unable to read tuner registers.\n");
1037                goto fail;
1038        }
1039
1040        dprintk(1, "Device is Xceive %d version %d.%d, firmware version %d.%d\n",
1041                hwmodel, hw_major, hw_minor, fw_major, fw_minor);
1042
1043        /* Check firmware version against what we downloaded. */
1044        if (priv->firm_version != ((fw_major << 8) | fw_minor)) {
1045                printk(KERN_WARNING
1046                       "Incorrect readback of firmware version %d.%d.\n",
1047                       fw_major, fw_minor);
1048                goto fail;
1049        }
1050
1051        /* Check that the tuner hardware model remains consistent over time. */
1052        if (priv->hwmodel == 0 &&
1053            (hwmodel == XC_PRODUCT_ID_XC4000 ||
1054             hwmodel == XC_PRODUCT_ID_XC4100)) {
1055                priv->hwmodel = hwmodel;
1056                priv->hwvers = (hw_major << 8) | hw_minor;
1057        } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
1058                   priv->hwvers != ((hw_major << 8) | hw_minor)) {
1059                printk(KERN_WARNING
1060                       "Read invalid device hardware information - tuner hung?\n");
1061                goto fail;
1062        }
1063
1064        priv->cur_fw = new_fw;
1065
1066        /*
1067         * By setting BASE in cur_fw.type only after successfully loading all
1068         * firmwares, we can:
1069         * 1. Identify that BASE firmware with type=0 has been loaded;
1070         * 2. Tell whether BASE firmware was just changed the next time through.
1071         */
1072        priv->cur_fw.type |= BASE;
1073
1074        return 0;
1075
1076fail:
1077        memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
1078        if (!is_retry) {
1079                msleep(50);
1080                is_retry = 1;
1081                dprintk(1, "Retrying firmware load\n");
1082                goto retry;
1083        }
1084
1085        if (rc == -ENOENT)
1086                rc = -EINVAL;
1087        return rc;
1088}
1089
1090static void xc_debug_dump(struct xc4000_priv *priv)
1091{
1092        u16     adc_envelope;
1093        u32     freq_error_hz = 0;
1094        u16     lock_status;
1095        u32     hsync_freq_hz = 0;
1096        u16     frame_lines;
1097        u16     quality;
1098        u16     signal = 0;
1099        u16     noise = 0;
1100        u8      hw_majorversion = 0, hw_minorversion = 0;
1101        u8      fw_majorversion = 0, fw_minorversion = 0;
1102
1103        xc_get_adc_envelope(priv, &adc_envelope);
1104        dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
1105
1106        xc_get_frequency_error(priv, &freq_error_hz);
1107        dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
1108
1109        xc_get_lock_status(priv, &lock_status);
1110        dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
1111                lock_status);
1112
1113        xc_get_version(priv, &hw_majorversion, &hw_minorversion,
1114                       &fw_majorversion, &fw_minorversion);
1115        dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
1116                hw_majorversion, hw_minorversion,
1117                fw_majorversion, fw_minorversion);
1118
1119        if (priv->video_standard < XC4000_DTV6) {
1120                xc_get_hsync_freq(priv, &hsync_freq_hz);
1121                dprintk(1, "*** Horizontal sync frequency = %d Hz\n",
1122                        hsync_freq_hz);
1123
1124                xc_get_frame_lines(priv, &frame_lines);
1125                dprintk(1, "*** Frame lines = %d\n", frame_lines);
1126        }
1127
1128        xc_get_quality(priv, &quality);
1129        dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
1130
1131        xc_get_signal_level(priv, &signal);
1132        dprintk(1, "*** Signal level = -%ddB (%d)\n", signal >> 8, signal);
1133
1134        xc_get_noise_level(priv, &noise);
1135        dprintk(1, "*** Noise level = %ddB (%d)\n", noise >> 8, noise);
1136}
1137
1138static int xc4000_set_params(struct dvb_frontend *fe)
1139{
1140        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1141        u32 delsys = c->delivery_system;
1142        u32 bw = c->bandwidth_hz;
1143        struct xc4000_priv *priv = fe->tuner_priv;
1144        unsigned int type;
1145        int     ret = -EREMOTEIO;
1146
1147        dprintk(1, "%s() frequency=%d (Hz)\n", __func__, c->frequency);
1148
1149        mutex_lock(&priv->lock);
1150
1151        switch (delsys) {
1152        case SYS_ATSC:
1153                dprintk(1, "%s() VSB modulation\n", __func__);
1154                priv->rf_mode = XC_RF_MODE_AIR;
1155                priv->freq_offset = 1750000;
1156                priv->video_standard = XC4000_DTV6;
1157                type = DTV6;
1158                break;
1159        case SYS_DVBC_ANNEX_B:
1160                dprintk(1, "%s() QAM modulation\n", __func__);
1161                priv->rf_mode = XC_RF_MODE_CABLE;
1162                priv->freq_offset = 1750000;
1163                priv->video_standard = XC4000_DTV6;
1164                type = DTV6;
1165                break;
1166        case SYS_DVBT:
1167        case SYS_DVBT2:
1168                dprintk(1, "%s() OFDM\n", __func__);
1169                if (bw == 0) {
1170                        if (c->frequency < 400000000) {
1171                                priv->freq_offset = 2250000;
1172                        } else {
1173                                priv->freq_offset = 2750000;
1174                        }
1175                        priv->video_standard = XC4000_DTV7_8;
1176                        type = DTV78;
1177                } else if (bw <= 6000000) {
1178                        priv->video_standard = XC4000_DTV6;
1179                        priv->freq_offset = 1750000;
1180                        type = DTV6;
1181                } else if (bw <= 7000000) {
1182                        priv->video_standard = XC4000_DTV7;
1183                        priv->freq_offset = 2250000;
1184                        type = DTV7;
1185                } else {
1186                        priv->video_standard = XC4000_DTV8;
1187                        priv->freq_offset = 2750000;
1188                        type = DTV8;
1189                }
1190                priv->rf_mode = XC_RF_MODE_AIR;
1191                break;
1192        default:
1193                printk(KERN_ERR "xc4000 delivery system not supported!\n");
1194                ret = -EINVAL;
1195                goto fail;
1196        }
1197
1198        priv->freq_hz = c->frequency - priv->freq_offset;
1199
1200        dprintk(1, "%s() frequency=%d (compensated)\n",
1201                __func__, priv->freq_hz);
1202
1203        /* Make sure the correct firmware type is loaded */
1204        if (check_firmware(fe, type, 0, priv->if_khz) != 0)
1205                goto fail;
1206
1207        priv->bandwidth = c->bandwidth_hz;
1208
1209        ret = xc_set_signal_source(priv, priv->rf_mode);
1210        if (ret != 0) {
1211                printk(KERN_ERR "xc4000: xc_set_signal_source(%d) failed\n",
1212                       priv->rf_mode);
1213                goto fail;
1214        } else {
1215                u16     video_mode, audio_mode;
1216                video_mode = xc4000_standard[priv->video_standard].video_mode;
1217                audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1218                if (type == DTV6 && priv->firm_version != 0x0102)
1219                        video_mode |= 0x0001;
1220                ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1221                if (ret != 0) {
1222                        printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1223                        /* DJH - do not return when it fails... */
1224                        /* goto fail; */
1225                }
1226        }
1227
1228        if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1229                ret = 0;
1230        if (priv->dvb_amplitude != 0) {
1231                if (xc_write_reg(priv, XREG_AMPLITUDE,
1232                                 (priv->firm_version != 0x0102 ||
1233                                  priv->dvb_amplitude != 134 ?
1234                                  priv->dvb_amplitude : 132)) != 0)
1235                        ret = -EREMOTEIO;
1236        }
1237        if (priv->set_smoothedcvbs != 0) {
1238                if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1239                        ret = -EREMOTEIO;
1240        }
1241        if (ret != 0) {
1242                printk(KERN_ERR "xc4000: setting registers failed\n");
1243                /* goto fail; */
1244        }
1245
1246        xc_tune_channel(priv, priv->freq_hz);
1247
1248        ret = 0;
1249
1250fail:
1251        mutex_unlock(&priv->lock);
1252
1253        return ret;
1254}
1255
1256static int xc4000_set_analog_params(struct dvb_frontend *fe,
1257        struct analog_parameters *params)
1258{
1259        struct xc4000_priv *priv = fe->tuner_priv;
1260        unsigned int type = 0;
1261        int     ret = -EREMOTEIO;
1262
1263        if (params->mode == V4L2_TUNER_RADIO) {
1264                dprintk(1, "%s() frequency=%d (in units of 62.5Hz)\n",
1265                        __func__, params->frequency);
1266
1267                mutex_lock(&priv->lock);
1268
1269                params->std = 0;
1270                priv->freq_hz = params->frequency * 125L / 2;
1271
1272                if (audio_std & XC4000_AUDIO_STD_INPUT1) {
1273                        priv->video_standard = XC4000_FM_Radio_INPUT1;
1274                        type = FM | INPUT1;
1275                } else {
1276                        priv->video_standard = XC4000_FM_Radio_INPUT2;
1277                        type = FM | INPUT2;
1278                }
1279
1280                goto tune_channel;
1281        }
1282
1283        dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
1284                __func__, params->frequency);
1285
1286        mutex_lock(&priv->lock);
1287
1288        /* params->frequency is in units of 62.5khz */
1289        priv->freq_hz = params->frequency * 62500;
1290
1291        params->std &= V4L2_STD_ALL;
1292        /* if std is not defined, choose one */
1293        if (!params->std)
1294                params->std = V4L2_STD_PAL_BG;
1295
1296        if (audio_std & XC4000_AUDIO_STD_MONO)
1297                type = MONO;
1298
1299        if (params->std & V4L2_STD_MN) {
1300                params->std = V4L2_STD_MN;
1301                if (audio_std & XC4000_AUDIO_STD_MONO) {
1302                        priv->video_standard = XC4000_MN_NTSC_PAL_Mono;
1303                } else if (audio_std & XC4000_AUDIO_STD_A2) {
1304                        params->std |= V4L2_STD_A2;
1305                        priv->video_standard = XC4000_MN_NTSC_PAL_A2;
1306                } else {
1307                        params->std |= V4L2_STD_BTSC;
1308                        priv->video_standard = XC4000_MN_NTSC_PAL_BTSC;
1309                }
1310                goto tune_channel;
1311        }
1312
1313        if (params->std & V4L2_STD_PAL_BG) {
1314                params->std = V4L2_STD_PAL_BG;
1315                if (audio_std & XC4000_AUDIO_STD_MONO) {
1316                        priv->video_standard = XC4000_BG_PAL_MONO;
1317                } else if (!(audio_std & XC4000_AUDIO_STD_A2)) {
1318                        if (!(audio_std & XC4000_AUDIO_STD_B)) {
1319                                params->std |= V4L2_STD_NICAM_A;
1320                                priv->video_standard = XC4000_BG_PAL_NICAM;
1321                        } else {
1322                                params->std |= V4L2_STD_NICAM_B;
1323                                priv->video_standard = XC4000_BG_PAL_NICAM;
1324                        }
1325                } else {
1326                        if (!(audio_std & XC4000_AUDIO_STD_B)) {
1327                                params->std |= V4L2_STD_A2_A;
1328                                priv->video_standard = XC4000_BG_PAL_A2;
1329                        } else {
1330                                params->std |= V4L2_STD_A2_B;
1331                                priv->video_standard = XC4000_BG_PAL_A2;
1332                        }
1333                }
1334                goto tune_channel;
1335        }
1336
1337        if (params->std & V4L2_STD_PAL_I) {
1338                /* default to NICAM audio standard */
1339                params->std = V4L2_STD_PAL_I | V4L2_STD_NICAM;
1340                if (audio_std & XC4000_AUDIO_STD_MONO)
1341                        priv->video_standard = XC4000_I_PAL_NICAM_MONO;
1342                else
1343                        priv->video_standard = XC4000_I_PAL_NICAM;
1344                goto tune_channel;
1345        }
1346
1347        if (params->std & V4L2_STD_PAL_DK) {
1348                params->std = V4L2_STD_PAL_DK;
1349                if (audio_std & XC4000_AUDIO_STD_MONO) {
1350                        priv->video_standard = XC4000_DK_PAL_MONO;
1351                } else if (audio_std & XC4000_AUDIO_STD_A2) {
1352                        params->std |= V4L2_STD_A2;
1353                        priv->video_standard = XC4000_DK_PAL_A2;
1354                } else {
1355                        params->std |= V4L2_STD_NICAM;
1356                        priv->video_standard = XC4000_DK_PAL_NICAM;
1357                }
1358                goto tune_channel;
1359        }
1360
1361        if (params->std & V4L2_STD_SECAM_DK) {
1362                /* default to A2 audio standard */
1363                params->std = V4L2_STD_SECAM_DK | V4L2_STD_A2;
1364                if (audio_std & XC4000_AUDIO_STD_L) {
1365                        type = 0;
1366                        priv->video_standard = XC4000_DK_SECAM_NICAM;
1367                } else if (audio_std & XC4000_AUDIO_STD_MONO) {
1368                        priv->video_standard = XC4000_DK_SECAM_A2MONO;
1369                } else if (audio_std & XC4000_AUDIO_STD_K3) {
1370                        params->std |= V4L2_STD_SECAM_K3;
1371                        priv->video_standard = XC4000_DK_SECAM_A2LDK3;
1372                } else {
1373                        priv->video_standard = XC4000_DK_SECAM_A2DK1;
1374                }
1375                goto tune_channel;
1376        }
1377
1378        if (params->std & V4L2_STD_SECAM_L) {
1379                /* default to NICAM audio standard */
1380                type = 0;
1381                params->std = V4L2_STD_SECAM_L | V4L2_STD_NICAM;
1382                priv->video_standard = XC4000_L_SECAM_NICAM;
1383                goto tune_channel;
1384        }
1385
1386        if (params->std & V4L2_STD_SECAM_LC) {
1387                /* default to NICAM audio standard */
1388                type = 0;
1389                params->std = V4L2_STD_SECAM_LC | V4L2_STD_NICAM;
1390                priv->video_standard = XC4000_LC_SECAM_NICAM;
1391                goto tune_channel;
1392        }
1393
1394tune_channel:
1395        /* FIXME: it could be air. */
1396        priv->rf_mode = XC_RF_MODE_CABLE;
1397
1398        if (check_firmware(fe, type, params->std,
1399                           xc4000_standard[priv->video_standard].int_freq) != 0)
1400                goto fail;
1401
1402        ret = xc_set_signal_source(priv, priv->rf_mode);
1403        if (ret != 0) {
1404                printk(KERN_ERR
1405                       "xc4000: xc_set_signal_source(%d) failed\n",
1406                       priv->rf_mode);
1407                goto fail;
1408        } else {
1409                u16     video_mode, audio_mode;
1410                video_mode = xc4000_standard[priv->video_standard].video_mode;
1411                audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1412                if (priv->video_standard < XC4000_BG_PAL_A2) {
1413                        if (type & NOGD)
1414                                video_mode &= 0xFF7F;
1415                } else if (priv->video_standard < XC4000_I_PAL_NICAM) {
1416                        if (priv->firm_version == 0x0102)
1417                                video_mode &= 0xFEFF;
1418                        if (audio_std & XC4000_AUDIO_STD_B)
1419                                video_mode |= 0x0080;
1420                }
1421                ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1422                if (ret != 0) {
1423                        printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1424                        goto fail;
1425                }
1426        }
1427
1428        if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1429                ret = 0;
1430        if (xc_write_reg(priv, XREG_AMPLITUDE, 1) != 0)
1431                ret = -EREMOTEIO;
1432        if (priv->set_smoothedcvbs != 0) {
1433                if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1434                        ret = -EREMOTEIO;
1435        }
1436        if (ret != 0) {
1437                printk(KERN_ERR "xc4000: setting registers failed\n");
1438                goto fail;
1439        }
1440
1441        xc_tune_channel(priv, priv->freq_hz);
1442
1443        ret = 0;
1444
1445fail:
1446        mutex_unlock(&priv->lock);
1447
1448        return ret;
1449}
1450
1451static int xc4000_get_signal(struct dvb_frontend *fe, u16 *strength)
1452{
1453        struct xc4000_priv *priv = fe->tuner_priv;
1454        u16 value = 0;
1455        int rc;
1456
1457        mutex_lock(&priv->lock);
1458        rc = xc4000_readreg(priv, XREG_SIGNAL_LEVEL, &value);
1459        mutex_unlock(&priv->lock);
1460
1461        if (rc < 0)
1462                goto ret;
1463
1464        /* Information from real testing of DVB-T and radio part,
1465           coefficient for one dB is 0xff.
1466         */
1467        tuner_dbg("Signal strength: -%ddB (%05d)\n", value >> 8, value);
1468
1469        /* all known digital modes */
1470        if ((priv->video_standard == XC4000_DTV6) ||
1471            (priv->video_standard == XC4000_DTV7) ||
1472            (priv->video_standard == XC4000_DTV7_8) ||
1473            (priv->video_standard == XC4000_DTV8))
1474                goto digital;
1475
1476        /* Analog mode has NOISE LEVEL important, signal
1477           depends only on gain of antenna and amplifiers,
1478           but it doesn't tell anything about real quality
1479           of reception.
1480         */
1481        mutex_lock(&priv->lock);
1482        rc = xc4000_readreg(priv, XREG_NOISE_LEVEL, &value);
1483        mutex_unlock(&priv->lock);
1484
1485        tuner_dbg("Noise level: %ddB (%05d)\n", value >> 8, value);
1486
1487        /* highest noise level: 32dB */
1488        if (value >= 0x2000) {
1489                value = 0;
1490        } else {
1491                value = (~value << 3) & 0xffff;
1492        }
1493
1494        goto ret;
1495
1496        /* Digital mode has SIGNAL LEVEL important and real
1497           noise level is stored in demodulator registers.
1498         */
1499digital:
1500        /* best signal: -50dB */
1501        if (value <= 0x3200) {
1502                value = 0xffff;
1503        /* minimum: -114dB - should be 0x7200 but real zero is 0x713A */
1504        } else if (value >= 0x713A) {
1505                value = 0;
1506        } else {
1507                value = ~(value - 0x3200) << 2;
1508        }
1509
1510ret:
1511        *strength = value;
1512
1513        return rc;
1514}
1515
1516static int xc4000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1517{
1518        struct xc4000_priv *priv = fe->tuner_priv;
1519
1520        *freq = priv->freq_hz + priv->freq_offset;
1521
1522        if (debug) {
1523                mutex_lock(&priv->lock);
1524                if ((priv->cur_fw.type
1525                     & (BASE | FM | DTV6 | DTV7 | DTV78 | DTV8)) == BASE) {
1526                        u16     snr = 0;
1527                        if (xc4000_readreg(priv, XREG_SNR, &snr) == 0) {
1528                                mutex_unlock(&priv->lock);
1529                                dprintk(1, "%s() freq = %u, SNR = %d\n",
1530                                        __func__, *freq, snr);
1531                                return 0;
1532                        }
1533                }
1534                mutex_unlock(&priv->lock);
1535        }
1536
1537        dprintk(1, "%s()\n", __func__);
1538
1539        return 0;
1540}
1541
1542static int xc4000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1543{
1544        struct xc4000_priv *priv = fe->tuner_priv;
1545        dprintk(1, "%s()\n", __func__);
1546
1547        *bw = priv->bandwidth;
1548        return 0;
1549}
1550
1551static int xc4000_get_status(struct dvb_frontend *fe, u32 *status)
1552{
1553        struct xc4000_priv *priv = fe->tuner_priv;
1554        u16     lock_status = 0;
1555
1556        mutex_lock(&priv->lock);
1557
1558        if (priv->cur_fw.type & BASE)
1559                xc_get_lock_status(priv, &lock_status);
1560
1561        *status = (lock_status == 1 ?
1562                   TUNER_STATUS_LOCKED | TUNER_STATUS_STEREO : 0);
1563        if (priv->cur_fw.type & (DTV6 | DTV7 | DTV78 | DTV8))
1564                *status &= (~TUNER_STATUS_STEREO);
1565
1566        mutex_unlock(&priv->lock);
1567
1568        dprintk(2, "%s() lock_status = %d\n", __func__, lock_status);
1569
1570        return 0;
1571}
1572
1573static int xc4000_sleep(struct dvb_frontend *fe)
1574{
1575        struct xc4000_priv *priv = fe->tuner_priv;
1576        int     ret = 0;
1577
1578        dprintk(1, "%s()\n", __func__);
1579
1580        mutex_lock(&priv->lock);
1581
1582        /* Avoid firmware reload on slow devices */
1583        if ((no_poweroff == 2 ||
1584             (no_poweroff == 0 && priv->default_pm != 0)) &&
1585            (priv->cur_fw.type & BASE) != 0) {
1586                /* force reset and firmware reload */
1587                priv->cur_fw.type = XC_POWERED_DOWN;
1588
1589                if (xc_write_reg(priv, XREG_POWER_DOWN, 0) != 0) {
1590                        printk(KERN_ERR
1591                               "xc4000: %s() unable to shutdown tuner\n",
1592                               __func__);
1593                        ret = -EREMOTEIO;
1594                }
1595                msleep(20);
1596        }
1597
1598        mutex_unlock(&priv->lock);
1599
1600        return ret;
1601}
1602
1603static int xc4000_init(struct dvb_frontend *fe)
1604{
1605        dprintk(1, "%s()\n", __func__);
1606
1607        return 0;
1608}
1609
1610static void xc4000_release(struct dvb_frontend *fe)
1611{
1612        struct xc4000_priv *priv = fe->tuner_priv;
1613
1614        dprintk(1, "%s()\n", __func__);
1615
1616        mutex_lock(&xc4000_list_mutex);
1617
1618        if (priv)
1619                hybrid_tuner_release_state(priv);
1620
1621        mutex_unlock(&xc4000_list_mutex);
1622
1623        fe->tuner_priv = NULL;
1624}
1625
1626static const struct dvb_tuner_ops xc4000_tuner_ops = {
1627        .info = {
1628                .name              = "Xceive XC4000",
1629                .frequency_min_hz  =    1 * MHz,
1630                .frequency_max_hz  = 1023 * MHz,
1631                .frequency_step_hz =   50 * kHz,
1632        },
1633
1634        .release           = xc4000_release,
1635        .init              = xc4000_init,
1636        .sleep             = xc4000_sleep,
1637
1638        .set_params        = xc4000_set_params,
1639        .set_analog_params = xc4000_set_analog_params,
1640        .get_frequency     = xc4000_get_frequency,
1641        .get_rf_strength   = xc4000_get_signal,
1642        .get_bandwidth     = xc4000_get_bandwidth,
1643        .get_status        = xc4000_get_status
1644};
1645
1646struct dvb_frontend *xc4000_attach(struct dvb_frontend *fe,
1647                                   struct i2c_adapter *i2c,
1648                                   struct xc4000_config *cfg)
1649{
1650        struct xc4000_priv *priv = NULL;
1651        int     instance;
1652        u16     id = 0;
1653
1654        dprintk(1, "%s(%d-%04x)\n", __func__,
1655                i2c ? i2c_adapter_id(i2c) : -1,
1656                cfg ? cfg->i2c_address : -1);
1657
1658        mutex_lock(&xc4000_list_mutex);
1659
1660        instance = hybrid_tuner_request_state(struct xc4000_priv, priv,
1661                                              hybrid_tuner_instance_list,
1662                                              i2c, cfg->i2c_address, "xc4000");
1663        switch (instance) {
1664        case 0:
1665                goto fail;
1666        case 1:
1667                /* new tuner instance */
1668                priv->bandwidth = 6000000;
1669                /* set default configuration */
1670                priv->if_khz = 4560;
1671                priv->default_pm = 0;
1672                priv->dvb_amplitude = 134;
1673                priv->set_smoothedcvbs = 1;
1674                mutex_init(&priv->lock);
1675                fe->tuner_priv = priv;
1676                break;
1677        default:
1678                /* existing tuner instance */
1679                fe->tuner_priv = priv;
1680                break;
1681        }
1682
1683        if (cfg->if_khz != 0) {
1684                /* copy configuration if provided by the caller */
1685                priv->if_khz = cfg->if_khz;
1686                priv->default_pm = cfg->default_pm;
1687                priv->dvb_amplitude = cfg->dvb_amplitude;
1688                priv->set_smoothedcvbs = cfg->set_smoothedcvbs;
1689        }
1690
1691        /* Check if firmware has been loaded. It is possible that another
1692           instance of the driver has loaded the firmware.
1693         */
1694
1695        if (instance == 1) {
1696                if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1697                        goto fail;
1698        } else {
1699                id = ((priv->cur_fw.type & BASE) != 0 ?
1700                      priv->hwmodel : XC_PRODUCT_ID_FW_NOT_LOADED);
1701        }
1702
1703        switch (id) {
1704        case XC_PRODUCT_ID_XC4000:
1705        case XC_PRODUCT_ID_XC4100:
1706                printk(KERN_INFO
1707                        "xc4000: Successfully identified at address 0x%02x\n",
1708                        cfg->i2c_address);
1709                printk(KERN_INFO
1710                        "xc4000: Firmware has been loaded previously\n");
1711                break;
1712        case XC_PRODUCT_ID_FW_NOT_LOADED:
1713                printk(KERN_INFO
1714                        "xc4000: Successfully identified at address 0x%02x\n",
1715                        cfg->i2c_address);
1716                printk(KERN_INFO
1717                        "xc4000: Firmware has not been loaded previously\n");
1718                break;
1719        default:
1720                printk(KERN_ERR
1721                        "xc4000: Device not found at addr 0x%02x (0x%x)\n",
1722                        cfg->i2c_address, id);
1723                goto fail;
1724        }
1725
1726        mutex_unlock(&xc4000_list_mutex);
1727
1728        memcpy(&fe->ops.tuner_ops, &xc4000_tuner_ops,
1729                sizeof(struct dvb_tuner_ops));
1730
1731        if (instance == 1) {
1732                int     ret;
1733                mutex_lock(&priv->lock);
1734                ret = xc4000_fwupload(fe);
1735                mutex_unlock(&priv->lock);
1736                if (ret != 0)
1737                        goto fail2;
1738        }
1739
1740        return fe;
1741fail:
1742        mutex_unlock(&xc4000_list_mutex);
1743fail2:
1744        xc4000_release(fe);
1745        return NULL;
1746}
1747EXPORT_SYMBOL(xc4000_attach);
1748
1749MODULE_AUTHOR("Steven Toth, Davide Ferri");
1750MODULE_DESCRIPTION("Xceive xc4000 silicon tuner driver");
1751MODULE_LICENSE("GPL");
1752MODULE_FIRMWARE(XC4000_DEFAULT_FIRMWARE_NEW);
1753MODULE_FIRMWARE(XC4000_DEFAULT_FIRMWARE);
1754