drivers/media/tuners/xc5000.c

   1 /*
   2  *  Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
   3  *
   4  *  Copyright (c) 2007 Xceive Corporation
   5  *  Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
   6  *  Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/videodev2.h>
  27 #include <linux/delay.h>
  28 #include <linux/dvb/frontend.h>
  29 #include <linux/i2c.h>
  30
  31 #include "dvb_frontend.h"
  32
  33 #include "xc5000.h"
  34 #include "tuner-i2c.h"
  35
  36 static int debug;
  37 module_param(debug, int, 0644);
  38 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
  39
  40 static int no_poweroff;
  41 module_param(no_poweroff, int, 0644);
  42 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
  43         "\t\t1 keep device energized and with tuner ready all the times.\n"
  44         "\t\tFaster, but consumes more power and keeps the device hotter");
  45
  46 static DEFINE_MUTEX(xc5000_list_mutex);
  47 static LIST_HEAD(hybrid_tuner_instance_list);
  48
  49 #define dprintk(level, fmt, arg...) if (debug >= level) \
  50         printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
  51
  52 struct xc5000_priv {
  53         struct tuner_i2c_props i2c_props;
  54         struct list_head hybrid_tuner_instance_list;
  55
  56         u32 if_khz;
  57         u16 xtal_khz;
  58         u32 freq_hz;
  59         u32 bandwidth;
  60         u8  video_standard;
  61         u8  rf_mode;
  62         u8  radio_input;
  63
  64         int chip_id;
  65         u16 pll_register_no;
  66         u8 init_status_supported;
  67         u8 fw_checksum_supported;
  68 };
  69
  70 /* Misc Defines */
  71 #define MAX_TV_STANDARD                 24
  72 #define XC_MAX_I2C_WRITE_LENGTH         64
  73
  74 /* Signal Types */
  75 #define XC_RF_MODE_AIR                  0
  76 #define XC_RF_MODE_CABLE                1
  77
  78 /* Result codes */
  79 #define XC_RESULT_SUCCESS               0
  80 #define XC_RESULT_RESET_FAILURE         1
  81 #define XC_RESULT_I2C_WRITE_FAILURE     2
  82 #define XC_RESULT_I2C_READ_FAILURE      3
  83 #define XC_RESULT_OUT_OF_RANGE          5
  84
  85 /* Product id */
  86 #define XC_PRODUCT_ID_FW_NOT_LOADED     0x2000
  87 #define XC_PRODUCT_ID_FW_LOADED         0x1388
  88
  89 /* Registers */
  90 #define XREG_INIT         0x00
  91 #define XREG_VIDEO_MODE   0x01
  92 #define XREG_AUDIO_MODE   0x02
  93 #define XREG_RF_FREQ      0x03
  94 #define XREG_D_CODE       0x04
  95 #define XREG_IF_OUT       0x05
  96 #define XREG_SEEK_MODE    0x07
  97 #define XREG_POWER_DOWN   0x0A /* Obsolete */
  98 /* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
  99 #define XREG_OUTPUT_AMP   0x0B
 100 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
 101 #define XREG_SMOOTHEDCVBS 0x0E
 102 #define XREG_XTALFREQ     0x0F
 103 #define XREG_FINERFREQ    0x10
 104 #define XREG_DDIMODE      0x11
 105
 106 #define XREG_ADC_ENV      0x00
 107 #define XREG_QUALITY      0x01
 108 #define XREG_FRAME_LINES  0x02
 109 #define XREG_HSYNC_FREQ   0x03
 110 #define XREG_LOCK         0x04
 111 #define XREG_FREQ_ERROR   0x05
 112 #define XREG_SNR          0x06
 113 #define XREG_VERSION      0x07
 114 #define XREG_PRODUCT_ID   0x08
 115 #define XREG_BUSY         0x09
 116 #define XREG_BUILD        0x0D
 117 #define XREG_TOTALGAIN    0x0F
 118 #define XREG_FW_CHECKSUM  0x12
 119 #define XREG_INIT_STATUS  0x13
 120
 121 /*
 122    Basic firmware description. This will remain with
 123    the driver for documentation purposes.
 124
 125    This represents an I2C firmware file encoded as a
 126    string of unsigned char. Format is as follows:
 127
 128    char[0  ]=len0_MSB  -> len = len_MSB * 256 + len_LSB
 129    char[1  ]=len0_LSB  -> length of first write transaction
 130    char[2  ]=data0 -> first byte to be sent
 131    char[3  ]=data1
 132    char[4  ]=data2
 133    char[   ]=...
 134    char[M  ]=dataN  -> last byte to be sent
 135    char[M+1]=len1_MSB  -> len = len_MSB * 256 + len_LSB
 136    char[M+2]=len1_LSB  -> length of second write transaction
 137    char[M+3]=data0
 138    char[M+4]=data1
 139    ...
 140    etc.
 141
 142    The [len] value should be interpreted as follows:
 143
 144    len= len_MSB _ len_LSB
 145    len=1111_1111_1111_1111   : End of I2C_SEQUENCE
 146    len=0000_0000_0000_0000   : Reset command: Do hardware reset
 147    len=0NNN_NNNN_NNNN_NNNN   : Normal transaction: number of bytes = {1:32767)
 148    len=1WWW_WWWW_WWWW_WWWW   : Wait command: wait for {1:32767} ms
 149
 150    For the RESET and WAIT commands, the two following bytes will contain
 151    immediately the length of the following transaction.
 152
 153 */
 154 struct XC_TV_STANDARD {
 155         char *Name;
 156         u16 AudioMode;
 157         u16 VideoMode;
 158 };
 159
 160 /* Tuner standards */
 161 #define MN_NTSC_PAL_BTSC        0
 162 #define MN_NTSC_PAL_A2          1
 163 #define MN_NTSC_PAL_EIAJ        2
 164 #define MN_NTSC_PAL_Mono        3
 165 #define BG_PAL_A2               4
 166 #define BG_PAL_NICAM            5
 167 #define BG_PAL_MONO             6
 168 #define I_PAL_NICAM             7
 169 #define I_PAL_NICAM_MONO        8
 170 #define DK_PAL_A2               9
 171 #define DK_PAL_NICAM            10
 172 #define DK_PAL_MONO             11
 173 #define DK_SECAM_A2DK1          12
 174 #define DK_SECAM_A2LDK3         13
 175 #define DK_SECAM_A2MONO         14
 176 #define L_SECAM_NICAM           15
 177 #define LC_SECAM_NICAM          16
 178 #define DTV6                    17
 179 #define DTV8                    18
 180 #define DTV7_8                  19
 181 #define DTV7                    20
 182 #define FM_Radio_INPUT2         21
 183 #define FM_Radio_INPUT1         22
 184 #define FM_Radio_INPUT1_MONO    23
 185
 186 static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
 187         {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
 188         {"M/N-NTSC/PAL-A2",   0x0600, 0x8020},
 189         {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
 190         {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
 191         {"B/G-PAL-A2",        0x0A00, 0x8049},
 192         {"B/G-PAL-NICAM",     0x0C04, 0x8049},
 193         {"B/G-PAL-MONO",      0x0878, 0x8059},
 194         {"I-PAL-NICAM",       0x1080, 0x8009},
 195         {"I-PAL-NICAM-MONO",  0x0E78, 0x8009},
 196         {"D/K-PAL-A2",        0x1600, 0x8009},
 197         {"D/K-PAL-NICAM",     0x0E80, 0x8009},
 198         {"D/K-PAL-MONO",      0x1478, 0x8009},
 199         {"D/K-SECAM-A2 DK1",  0x1200, 0x8009},
 200         {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
 201         {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
 202         {"L-SECAM-NICAM",     0x8E82, 0x0009},
 203         {"L'-SECAM-NICAM",    0x8E82, 0x4009},
 204         {"DTV6",              0x00C0, 0x8002},
 205         {"DTV8",              0x00C0, 0x800B},
 206         {"DTV7/8",            0x00C0, 0x801B},
 207         {"DTV7",              0x00C0, 0x8007},
 208         {"FM Radio-INPUT2",   0x9802, 0x9002},
 209         {"FM Radio-INPUT1",   0x0208, 0x9002},
 210         {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
 211 };
 212
 213
 214 struct xc5000_fw_cfg {
 215         char *name;
 216         u16 size;
 217         u16 pll_reg;
 218         u8 init_status_supported;
 219         u8 fw_checksum_supported;
 220 };
 221
 222 #define XC5000A_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
 223 static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
 224         .name = XC5000A_FIRMWARE,
 225         .size = 12401,
 226         .pll_reg = 0x806c,
 227 };
 228
 229 #define XC5000C_FIRMWARE "dvb-fe-xc5000c-4.1.30.7.fw"
 230 static const struct xc5000_fw_cfg xc5000c_41_024_5 = {
 231         .name = XC5000C_FIRMWARE,
 232         .size = 16497,
 233         .pll_reg = 0x13,
 234         .init_status_supported = 1,
 235         .fw_checksum_supported = 1,
 236 };
 237
 238 static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
 239 {
 240         switch (chip_id) {
 241         default:
 242         case XC5000A:
 243                 return &xc5000a_1_6_114;
 244         case XC5000C:
 245                 return &xc5000c_41_024_5;
 246         }
 247 }
 248
 249 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force);
 250 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
 251 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
 252 static int xc5000_TunerReset(struct dvb_frontend *fe);
 253
 254 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
 255 {
 256         struct i2c_msg msg = { .addr = priv->i2c_props.addr,
 257                                .flags = 0, .buf = buf, .len = len };
 258
 259         if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
 260                 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
 261                 return XC_RESULT_I2C_WRITE_FAILURE;
 262         }
 263         return XC_RESULT_SUCCESS;
 264 }
 265
 266 #if 0
 267 /* This routine is never used because the only time we read data from the
 268    i2c bus is when we read registers, and we want that to be an atomic i2c
 269    transaction in case we are on a multi-master bus */
 270 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
 271 {
 272         struct i2c_msg msg = { .addr = priv->i2c_props.addr,
 273                 .flags = I2C_M_RD, .buf = buf, .len = len };
 274
 275         if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
 276                 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
 277                 return -EREMOTEIO;
 278         }
 279         return 0;
 280 }
 281 #endif
 282
 283 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
 284 {
 285         u8 buf[2] = { reg >> 8, reg & 0xff };
 286         u8 bval[2] = { 0, 0 };
 287         struct i2c_msg msg[2] = {
 288                 { .addr = priv->i2c_props.addr,
 289                         .flags = 0, .buf = &buf[0], .len = 2 },
 290                 { .addr = priv->i2c_props.addr,
 291                         .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
 292         };
 293
 294         if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
 295                 printk(KERN_WARNING "xc5000: I2C read failed\n");
 296                 return -EREMOTEIO;
 297         }
 298
 299         *val = (bval[0] << 8) | bval[1];
 300         return XC_RESULT_SUCCESS;
 301 }
 302
 303 static void xc_wait(int wait_ms)
 304 {
 305         msleep(wait_ms);
 306 }
 307
 308 static int xc5000_TunerReset(struct dvb_frontend *fe)
 309 {
 310         struct xc5000_priv *priv = fe->tuner_priv;
 311         int ret;
 312
 313         dprintk(1, "%s()\n", __func__);
 314
 315         if (fe->callback) {
 316                 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
 317                                            fe->dvb->priv :
 318                                            priv->i2c_props.adap->algo_data,
 319                                            DVB_FRONTEND_COMPONENT_TUNER,
 320                                            XC5000_TUNER_RESET, 0);
 321                 if (ret) {
 322                         printk(KERN_ERR "xc5000: reset failed\n");
 323                         return XC_RESULT_RESET_FAILURE;
 324                 }
 325         } else {
 326                 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
 327                 return XC_RESULT_RESET_FAILURE;
 328         }
 329         return XC_RESULT_SUCCESS;
 330 }
 331
 332 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
 333 {
 334         u8 buf[4];
 335         int WatchDogTimer = 100;
 336         int result;
 337
 338         buf[0] = (regAddr >> 8) & 0xFF;
 339         buf[1] = regAddr & 0xFF;
 340         buf[2] = (i2cData >> 8) & 0xFF;
 341         buf[3] = i2cData & 0xFF;
 342         result = xc_send_i2c_data(priv, buf, 4);
 343         if (result == XC_RESULT_SUCCESS) {
 344                 /* wait for busy flag to clear */
 345                 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
 346                         result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
 347                         if (result == XC_RESULT_SUCCESS) {
 348                                 if ((buf[0] == 0) && (buf[1] == 0)) {
 349                                         /* busy flag cleared */
 350                                         break;
 351                                 } else {
 352                                         xc_wait(5); /* wait 5 ms */
 353                                         WatchDogTimer--;
 354                                 }
 355                         }
 356                 }
 357         }
 358         if (WatchDogTimer <= 0)
 359                 result = XC_RESULT_I2C_WRITE_FAILURE;
 360
 361         return result;
 362 }
 363
 364 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
 365 {
 366         struct xc5000_priv *priv = fe->tuner_priv;
 367
 368         int i, nbytes_to_send, result;
 369         unsigned int len, pos, index;
 370         u8 buf[XC_MAX_I2C_WRITE_LENGTH];
 371
 372         index = 0;
 373         while ((i2c_sequence[index] != 0xFF) ||
 374                 (i2c_sequence[index + 1] != 0xFF)) {
 375                 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
 376                 if (len == 0x0000) {
 377                         /* RESET command */
 378                         result = xc5000_TunerReset(fe);
 379                         index += 2;
 380                         if (result != XC_RESULT_SUCCESS)
 381                                 return result;
 382                 } else if (len & 0x8000) {
 383                         /* WAIT command */
 384                         xc_wait(len & 0x7FFF);
 385                         index += 2;
 386                 } else {
 387                         /* Send i2c data whilst ensuring individual transactions
 388                          * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
 389                          */
 390                         index += 2;
 391                         buf[0] = i2c_sequence[index];
 392                         buf[1] = i2c_sequence[index + 1];
 393                         pos = 2;
 394                         while (pos < len) {
 395                                 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
 396                                         nbytes_to_send =
 397                                                 XC_MAX_I2C_WRITE_LENGTH;
 398                                 else
 399                                         nbytes_to_send = (len - pos + 2);
 400                                 for (i = 2; i < nbytes_to_send; i++) {
 401                                         buf[i] = i2c_sequence[index + pos +
 402                                                 i - 2];
 403                                 }
 404                                 result = xc_send_i2c_data(priv, buf,
 405                                         nbytes_to_send);
 406
 407                                 if (result != XC_RESULT_SUCCESS)
 408                                         return result;
 409
 410                                 pos += nbytes_to_send - 2;
 411                         }
 412                         index += len;
 413                 }
 414         }
 415         return XC_RESULT_SUCCESS;
 416 }
 417
 418 static int xc_initialize(struct xc5000_priv *priv)
 419 {
 420         dprintk(1, "%s()\n", __func__);
 421         return xc_write_reg(priv, XREG_INIT, 0);
 422 }
 423
 424 static int xc_SetTVStandard(struct xc5000_priv *priv,
 425         u16 VideoMode, u16 AudioMode)
 426 {
 427         int ret;
 428         dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
 429         dprintk(1, "%s() Standard = %s\n",
 430                 __func__,
 431                 XC5000_Standard[priv->video_standard].Name);
 432
 433         ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
 434         if (ret == XC_RESULT_SUCCESS)
 435                 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
 436
 437         return ret;
 438 }
 439
 440 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
 441 {
 442         dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
 443                 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
 444
 445         if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
 446                 rf_mode = XC_RF_MODE_CABLE;
 447                 printk(KERN_ERR
 448                         "%s(), Invalid mode, defaulting to CABLE",
 449                         __func__);
 450         }
 451         return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
 452 }
 453
 454 static const struct dvb_tuner_ops xc5000_tuner_ops;
 455
 456 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
 457 {
 458         u16 freq_code;
 459
 460         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 461
 462         if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
 463                 (freq_hz < xc5000_tuner_ops.info.frequency_min))
 464                 return XC_RESULT_OUT_OF_RANGE;
 465
 466         freq_code = (u16)(freq_hz / 15625);
 467
 468         /* Starting in firmware version 1.1.44, Xceive recommends using the
 469            FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
 470            only be used for fast scanning for channel lock) */
 471         return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
 472 }
 473
 474
 475 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
 476 {
 477         u32 freq_code = (freq_khz * 1024)/1000;
 478         dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
 479                 __func__, freq_khz, freq_code);
 480
 481         return xc_write_reg(priv, XREG_IF_OUT, freq_code);
 482 }
 483
 484
 485 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
 486 {
 487         return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
 488 }
 489
 490 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
 491 {
 492         int result;
 493         u16 regData;
 494         u32 tmp;
 495
 496         result = xc5000_readreg(priv, XREG_FREQ_ERROR, &regData);
 497         if (result != XC_RESULT_SUCCESS)
 498                 return result;
 499
 500         tmp = (u32)regData;
 501         (*freq_error_hz) = (tmp * 15625) / 1000;
 502         return result;
 503 }
 504
 505 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
 506 {
 507         return xc5000_readreg(priv, XREG_LOCK, lock_status);
 508 }
 509
 510 static int xc_get_version(struct xc5000_priv *priv,
 511         u8 *hw_majorversion, u8 *hw_minorversion,
 512         u8 *fw_majorversion, u8 *fw_minorversion)
 513 {
 514         u16 data;
 515         int result;
 516
 517         result = xc5000_readreg(priv, XREG_VERSION, &data);
 518         if (result != XC_RESULT_SUCCESS)
 519                 return result;
 520
 521         (*hw_majorversion) = (data >> 12) & 0x0F;
 522         (*hw_minorversion) = (data >>  8) & 0x0F;
 523         (*fw_majorversion) = (data >>  4) & 0x0F;
 524         (*fw_minorversion) = data & 0x0F;
 525
 526         return 0;
 527 }
 528
 529 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
 530 {
 531         return xc5000_readreg(priv, XREG_BUILD, buildrev);
 532 }
 533
 534 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
 535 {
 536         u16 regData;
 537         int result;
 538
 539         result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &regData);
 540         if (result != XC_RESULT_SUCCESS)
 541                 return result;
 542
 543         (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
 544         return result;
 545 }
 546
 547 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
 548 {
 549         return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
 550 }
 551
 552 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
 553 {
 554         return xc5000_readreg(priv, XREG_QUALITY, quality);
 555 }
 556
 557 static int xc_get_analogsnr(struct xc5000_priv *priv, u16 *snr)
 558 {
 559         return xc5000_readreg(priv, XREG_SNR, snr);
 560 }
 561
 562 static int xc_get_totalgain(struct xc5000_priv *priv, u16 *totalgain)
 563 {
 564         return xc5000_readreg(priv, XREG_TOTALGAIN, totalgain);
 565 }
 566
 567 static u16 WaitForLock(struct xc5000_priv *priv)
 568 {
 569         u16 lockState = 0;
 570         int watchDogCount = 40;
 571
 572         while ((lockState == 0) && (watchDogCount > 0)) {
 573                 xc_get_lock_status(priv, &lockState);
 574                 if (lockState != 1) {
 575                         xc_wait(5);
 576                         watchDogCount--;
 577                 }
 578         }
 579         return lockState;
 580 }
 581
 582 #define XC_TUNE_ANALOG  0
 583 #define XC_TUNE_DIGITAL 1
 584 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
 585 {
 586         int found = 0;
 587
 588         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 589
 590         if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
 591                 return 0;
 592
 593         if (mode == XC_TUNE_ANALOG) {
 594                 if (WaitForLock(priv) == 1)
 595                         found = 1;
 596         }
 597
 598         return found;
 599 }
 600
 601 static int xc_set_xtal(struct dvb_frontend *fe)
 602 {
 603         struct xc5000_priv *priv = fe->tuner_priv;
 604         int ret = XC_RESULT_SUCCESS;
 605
 606         switch (priv->chip_id) {
 607         default:
 608         case XC5000A:
 609                 /* 32.000 MHz xtal is default */
 610                 break;
 611         case XC5000C:
 612                 switch (priv->xtal_khz) {
 613                 default:
 614                 case 32000:
 615                         /* 32.000 MHz xtal is default */
 616                         break;
 617                 case 31875:
 618                         /* 31.875 MHz xtal configuration */
 619                         ret = xc_write_reg(priv, 0x000f, 0x8081);
 620                         break;
 621                 }
 622                 break;
 623         }
 624         return ret;
 625 }
 626
 627 static int xc5000_fwupload(struct dvb_frontend *fe)
 628 {
 629         struct xc5000_priv *priv = fe->tuner_priv;
 630         const struct firmware *fw;
 631         int ret;
 632         const struct xc5000_fw_cfg *desired_fw =
 633                 xc5000_assign_firmware(priv->chip_id);
 634         priv->pll_register_no = desired_fw->pll_reg;
 635         priv->init_status_supported = desired_fw->init_status_supported;
 636         priv->fw_checksum_supported = desired_fw->fw_checksum_supported;
 637
 638         /* request the firmware, this will block and timeout */
 639         printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
 640                 desired_fw->name);
 641
 642         ret = request_firmware(&fw, desired_fw->name,
 643                 priv->i2c_props.adap->dev.parent);
 644         if (ret) {
 645                 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
 646                 ret = XC_RESULT_RESET_FAILURE;
 647                 goto out;
 648         } else {
 649                 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
 650                        fw->size);
 651                 ret = XC_RESULT_SUCCESS;
 652         }
 653
 654         if (fw->size != desired_fw->size) {
 655                 printk(KERN_ERR "xc5000: firmware incorrect size\n");
 656                 ret = XC_RESULT_RESET_FAILURE;
 657         } else {
 658                 printk(KERN_INFO "xc5000: firmware uploading...\n");
 659                 ret = xc_load_i2c_sequence(fe,  fw->data);
 660                 if (XC_RESULT_SUCCESS == ret)
 661                         ret = xc_set_xtal(fe);
 662                 if (XC_RESULT_SUCCESS == ret)
 663                         printk(KERN_INFO "xc5000: firmware upload complete...\n");
 664                 else
 665                         printk(KERN_ERR "xc5000: firmware upload failed...\n");
 666         }
 667
 668 out:
 669         release_firmware(fw);
 670         return ret;
 671 }
 672
 673 static void xc_debug_dump(struct xc5000_priv *priv)
 674 {
 675         u16 adc_envelope;
 676         u32 freq_error_hz = 0;
 677         u16 lock_status;
 678         u32 hsync_freq_hz = 0;
 679         u16 frame_lines;
 680         u16 quality;
 681         u16 snr;
 682         u16 totalgain;
 683         u8 hw_majorversion = 0, hw_minorversion = 0;
 684         u8 fw_majorversion = 0, fw_minorversion = 0;
 685         u16 fw_buildversion = 0;
 686         u16 regval;
 687
 688         /* Wait for stats to stabilize.
 689          * Frame Lines needs two frame times after initial lock
 690          * before it is valid.
 691          */
 692         xc_wait(100);
 693
 694         xc_get_ADC_Envelope(priv,  &adc_envelope);
 695         dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
 696
 697         xc_get_frequency_error(priv, &freq_error_hz);
 698         dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
 699
 700         xc_get_lock_status(priv,  &lock_status);
 701         dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
 702                 lock_status);
 703
 704         xc_get_version(priv,  &hw_majorversion, &hw_minorversion,
 705                 &fw_majorversion, &fw_minorversion);
 706         xc_get_buildversion(priv,  &fw_buildversion);
 707         dprintk(1, "*** HW: V%d.%d, FW: V %d.%d.%d\n",
 708                 hw_majorversion, hw_minorversion,
 709                 fw_majorversion, fw_minorversion, fw_buildversion);
 710
 711         xc_get_hsync_freq(priv,  &hsync_freq_hz);
 712         dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
 713
 714         xc_get_frame_lines(priv,  &frame_lines);
 715         dprintk(1, "*** Frame lines = %d\n", frame_lines);
 716
 717         xc_get_quality(priv,  &quality);
 718         dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality & 0x07);
 719
 720         xc_get_analogsnr(priv,  &snr);
 721         dprintk(1, "*** Unweighted analog SNR = %d dB\n", snr & 0x3f);
 722
 723         xc_get_totalgain(priv,  &totalgain);
 724         dprintk(1, "*** Total gain = %d.%d dB\n", totalgain / 256,
 725                 (totalgain % 256) * 100 / 256);
 726
 727         if (priv->pll_register_no) {
 728                 xc5000_readreg(priv, priv->pll_register_no, &regval);
 729                 dprintk(1, "*** PLL lock status = 0x%04x\n", regval);
 730         }
 731 }
 732
 733 static int xc5000_set_params(struct dvb_frontend *fe)
 734 {
 735         int ret, b;
 736         struct xc5000_priv *priv = fe->tuner_priv;
 737         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 738         u32 freq = fe->dtv_property_cache.frequency;
 739         u32 delsys  = fe->dtv_property_cache.delivery_system;
 740
 741         if (xc_load_fw_and_init_tuner(fe, 0) != XC_RESULT_SUCCESS) {
 742                 dprintk(1, "Unable to load firmware and init tuner\n");
 743                 return -EINVAL;
 744         }
 745
 746         dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
 747
 748         switch (delsys) {
 749         case SYS_ATSC:
 750                 dprintk(1, "%s() VSB modulation\n", __func__);
 751                 priv->rf_mode = XC_RF_MODE_AIR;
 752                 priv->freq_hz = freq - 1750000;
 753                 priv->video_standard = DTV6;
 754                 break;
 755         case SYS_DVBC_ANNEX_B:
 756                 dprintk(1, "%s() QAM modulation\n", __func__);
 757                 priv->rf_mode = XC_RF_MODE_CABLE;
 758                 priv->freq_hz = freq - 1750000;
 759                 priv->video_standard = DTV6;
 760                 break;
 761         case SYS_ISDBT:
 762                 /* All ISDB-T are currently for 6 MHz bw */
 763                 if (!bw)
 764                         bw = 6000000;
 765                 /* fall to OFDM handling */
 766         case SYS_DMBTH:
 767         case SYS_DVBT:
 768         case SYS_DVBT2:
 769                 dprintk(1, "%s() OFDM\n", __func__);
 770                 switch (bw) {
 771                 case 6000000:
 772                         priv->video_standard = DTV6;
 773                         priv->freq_hz = freq - 1750000;
 774                         break;
 775                 case 7000000:
 776                         priv->video_standard = DTV7;
 777                         priv->freq_hz = freq - 2250000;
 778                         break;
 779                 case 8000000:
 780                         priv->video_standard = DTV8;
 781                         priv->freq_hz = freq - 2750000;
 782                         break;
 783                 default:
 784                         printk(KERN_ERR "xc5000 bandwidth not set!\n");
 785                         return -EINVAL;
 786                 }
 787                 priv->rf_mode = XC_RF_MODE_AIR;
 788         case SYS_DVBC_ANNEX_A:
 789         case SYS_DVBC_ANNEX_C:
 790                 dprintk(1, "%s() QAM modulation\n", __func__);
 791                 priv->rf_mode = XC_RF_MODE_CABLE;
 792                 if (bw <= 6000000) {
 793                         priv->video_standard = DTV6;
 794                         priv->freq_hz = freq - 1750000;
 795                         b = 6;
 796                 } else if (bw <= 7000000) {
 797                         priv->video_standard = DTV7;
 798                         priv->freq_hz = freq - 2250000;
 799                         b = 7;
 800                 } else {
 801                         priv->video_standard = DTV7_8;
 802                         priv->freq_hz = freq - 2750000;
 803                         b = 8;
 804                 }
 805                 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
 806                         b, bw);
 807                 break;
 808         default:
 809                 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
 810                 return -EINVAL;
 811         }
 812
 813         dprintk(1, "%s() frequency=%d (compensated to %d)\n",
 814                 __func__, freq, priv->freq_hz);
 815
 816         ret = xc_SetSignalSource(priv, priv->rf_mode);
 817         if (ret != XC_RESULT_SUCCESS) {
 818                 printk(KERN_ERR
 819                         "xc5000: xc_SetSignalSource(%d) failed\n",
 820                         priv->rf_mode);
 821                 return -EREMOTEIO;
 822         }
 823
 824         ret = xc_SetTVStandard(priv,
 825                 XC5000_Standard[priv->video_standard].VideoMode,
 826                 XC5000_Standard[priv->video_standard].AudioMode);
 827         if (ret != XC_RESULT_SUCCESS) {
 828                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 829                 return -EREMOTEIO;
 830         }
 831
 832         ret = xc_set_IF_frequency(priv, priv->if_khz);
 833         if (ret != XC_RESULT_SUCCESS) {
 834                 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
 835                        priv->if_khz);
 836                 return -EIO;
 837         }
 838
 839         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
 840
 841         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
 842
 843         if (debug)
 844                 xc_debug_dump(priv);
 845
 846         priv->bandwidth = bw;
 847
 848         return 0;
 849 }
 850
 851 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
 852 {
 853         struct xc5000_priv *priv = fe->tuner_priv;
 854         int ret;
 855         u16 id;
 856
 857         ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
 858         if (ret == XC_RESULT_SUCCESS) {
 859                 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
 860                         ret = XC_RESULT_RESET_FAILURE;
 861                 else
 862                         ret = XC_RESULT_SUCCESS;
 863         }
 864
 865         dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
 866                 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
 867         return ret;
 868 }
 869
 870 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
 871         struct analog_parameters *params)
 872 {
 873         struct xc5000_priv *priv = fe->tuner_priv;
 874         u16 pll_lock_status;
 875         int ret;
 876
 877         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
 878                 __func__, params->frequency);
 879
 880         /* Fix me: it could be air. */
 881         priv->rf_mode = params->mode;
 882         if (params->mode > XC_RF_MODE_CABLE)
 883                 priv->rf_mode = XC_RF_MODE_CABLE;
 884
 885         /* params->frequency is in units of 62.5khz */
 886         priv->freq_hz = params->frequency * 62500;
 887
 888         /* FIX ME: Some video standards may have several possible audio
 889                    standards. We simply default to one of them here.
 890          */
 891         if (params->std & V4L2_STD_MN) {
 892                 /* default to BTSC audio standard */
 893                 priv->video_standard = MN_NTSC_PAL_BTSC;
 894                 goto tune_channel;
 895         }
 896
 897         if (params->std & V4L2_STD_PAL_BG) {
 898                 /* default to NICAM audio standard */
 899                 priv->video_standard = BG_PAL_NICAM;
 900                 goto tune_channel;
 901         }
 902
 903         if (params->std & V4L2_STD_PAL_I) {
 904                 /* default to NICAM audio standard */
 905                 priv->video_standard = I_PAL_NICAM;
 906                 goto tune_channel;
 907         }
 908
 909         if (params->std & V4L2_STD_PAL_DK) {
 910                 /* default to NICAM audio standard */
 911                 priv->video_standard = DK_PAL_NICAM;
 912                 goto tune_channel;
 913         }
 914
 915         if (params->std & V4L2_STD_SECAM_DK) {
 916                 /* default to A2 DK1 audio standard */
 917                 priv->video_standard = DK_SECAM_A2DK1;
 918                 goto tune_channel;
 919         }
 920
 921         if (params->std & V4L2_STD_SECAM_L) {
 922                 priv->video_standard = L_SECAM_NICAM;
 923                 goto tune_channel;
 924         }
 925
 926         if (params->std & V4L2_STD_SECAM_LC) {
 927                 priv->video_standard = LC_SECAM_NICAM;
 928                 goto tune_channel;
 929         }
 930
 931 tune_channel:
 932         ret = xc_SetSignalSource(priv, priv->rf_mode);
 933         if (ret != XC_RESULT_SUCCESS) {
 934                 printk(KERN_ERR
 935                         "xc5000: xc_SetSignalSource(%d) failed\n",
 936                         priv->rf_mode);
 937                 return -EREMOTEIO;
 938         }
 939
 940         ret = xc_SetTVStandard(priv,
 941                 XC5000_Standard[priv->video_standard].VideoMode,
 942                 XC5000_Standard[priv->video_standard].AudioMode);
 943         if (ret != XC_RESULT_SUCCESS) {
 944                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
 945                 return -EREMOTEIO;
 946         }
 947
 948         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
 949
 950         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 951
 952         if (debug)
 953                 xc_debug_dump(priv);
 954
 955         if (priv->pll_register_no != 0) {
 956                 msleep(20);
 957                 xc5000_readreg(priv, priv->pll_register_no, &pll_lock_status);
 958                 if (pll_lock_status > 63) {
 959                         /* PLL is unlocked, force reload of the firmware */
 960                         dprintk(1, "xc5000: PLL not locked (0x%x).  Reloading...\n",
 961                                 pll_lock_status);
 962                         if (xc_load_fw_and_init_tuner(fe, 1) != XC_RESULT_SUCCESS) {
 963                                 printk(KERN_ERR "xc5000: Unable to reload fw\n");
 964                                 return -EREMOTEIO;
 965                         }
 966                         goto tune_channel;
 967                 }
 968         }
 969
 970         return 0;
 971 }
 972
 973 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
 974         struct analog_parameters *params)
 975 {
 976         struct xc5000_priv *priv = fe->tuner_priv;
 977         int ret = -EINVAL;
 978         u8 radio_input;
 979
 980         dprintk(1, "%s() frequency=%d (in units of khz)\n",
 981                 __func__, params->frequency);
 982
 983         if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
 984                 dprintk(1, "%s() radio input not configured\n", __func__);
 985                 return -EINVAL;
 986         }
 987
 988         if (priv->radio_input == XC5000_RADIO_FM1)
 989                 radio_input = FM_Radio_INPUT1;
 990         else if  (priv->radio_input == XC5000_RADIO_FM2)
 991                 radio_input = FM_Radio_INPUT2;
 992         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
 993                 radio_input = FM_Radio_INPUT1_MONO;
 994         else {
 995                 dprintk(1, "%s() unknown radio input %d\n", __func__,
 996                         priv->radio_input);
 997                 return -EINVAL;
 998         }
 999
1000         priv->freq_hz = params->frequency * 125 / 2;
1001
1002         priv->rf_mode = XC_RF_MODE_AIR;
1003
1004         ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
1005                                XC5000_Standard[radio_input].AudioMode);
1006
1007         if (ret != XC_RESULT_SUCCESS) {
1008                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
1009                 return -EREMOTEIO;
1010         }
1011
1012         ret = xc_SetSignalSource(priv, priv->rf_mode);
1013         if (ret != XC_RESULT_SUCCESS) {
1014                 printk(KERN_ERR
1015                         "xc5000: xc_SetSignalSource(%d) failed\n",
1016                         priv->rf_mode);
1017                 return -EREMOTEIO;
1018         }
1019
1020         if ((priv->radio_input == XC5000_RADIO_FM1) ||
1021                                 (priv->radio_input == XC5000_RADIO_FM2))
1022                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
1023         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
1024                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
1025
1026         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
1027
1028         return 0;
1029 }
1030
1031 static int xc5000_set_analog_params(struct dvb_frontend *fe,
1032                              struct analog_parameters *params)
1033 {
1034         struct xc5000_priv *priv = fe->tuner_priv;
1035         int ret = -EINVAL;
1036
1037         if (priv->i2c_props.adap == NULL)
1038                 return -EINVAL;
1039
1040         if (xc_load_fw_and_init_tuner(fe, 0) != XC_RESULT_SUCCESS) {
1041                 dprintk(1, "Unable to load firmware and init tuner\n");
1042                 return -EINVAL;
1043         }
1044
1045         switch (params->mode) {
1046         case V4L2_TUNER_RADIO:
1047                 ret = xc5000_set_radio_freq(fe, params);
1048                 break;
1049         case V4L2_TUNER_ANALOG_TV:
1050         case V4L2_TUNER_DIGITAL_TV:
1051                 ret = xc5000_set_tv_freq(fe, params);
1052                 break;
1053         }
1054
1055         return ret;
1056 }
1057
1058
1059 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1060 {
1061         struct xc5000_priv *priv = fe->tuner_priv;
1062         dprintk(1, "%s()\n", __func__);
1063         *freq = priv->freq_hz;
1064         return 0;
1065 }
1066
1067 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1068 {
1069         struct xc5000_priv *priv = fe->tuner_priv;
1070         dprintk(1, "%s()\n", __func__);
1071         *freq = priv->if_khz * 1000;
1072         return 0;
1073 }
1074
1075 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1076 {
1077         struct xc5000_priv *priv = fe->tuner_priv;
1078         dprintk(1, "%s()\n", __func__);
1079
1080         *bw = priv->bandwidth;
1081         return 0;
1082 }
1083
1084 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1085 {
1086         struct xc5000_priv *priv = fe->tuner_priv;
1087         u16 lock_status = 0;
1088
1089         xc_get_lock_status(priv, &lock_status);
1090
1091         dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1092
1093         *status = lock_status;
1094
1095         return 0;
1096 }
1097
1098 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force)
1099 {
1100         struct xc5000_priv *priv = fe->tuner_priv;
1101         int ret = XC_RESULT_SUCCESS;
1102         u16 pll_lock_status;
1103         u16 fw_ck;
1104
1105         if (force || xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
1106
1107 fw_retry:
1108
1109                 ret = xc5000_fwupload(fe);
1110                 if (ret != XC_RESULT_SUCCESS)
1111                         return ret;
1112
1113                 msleep(20);
1114
1115                 if (priv->fw_checksum_supported) {
1116                         if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck)
1117                             != XC_RESULT_SUCCESS) {
1118                                 dprintk(1, "%s() FW checksum reading failed.\n",
1119                                         __func__);
1120                                 goto fw_retry;
1121                         }
1122
1123                         if (fw_ck == 0) {
1124                                 dprintk(1, "%s() FW checksum failed = 0x%04x\n",
1125                                         __func__, fw_ck);
1126                                 goto fw_retry;
1127                         }
1128                 }
1129
1130                 /* Start the tuner self-calibration process */
1131                 ret |= xc_initialize(priv);
1132
1133                 if (ret != XC_RESULT_SUCCESS)
1134                         goto fw_retry;
1135
1136                 /* Wait for calibration to complete.
1137                  * We could continue but XC5000 will clock stretch subsequent
1138                  * I2C transactions until calibration is complete.  This way we
1139                  * don't have to rely on clock stretching working.
1140                  */
1141                 xc_wait(100);
1142
1143                 if (priv->init_status_supported) {
1144                         if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck) != XC_RESULT_SUCCESS) {
1145                                 dprintk(1, "%s() FW failed reading init status.\n",
1146                                         __func__);
1147                                 goto fw_retry;
1148                         }
1149
1150                         if (fw_ck == 0) {
1151                                 dprintk(1, "%s() FW init status failed = 0x%04x\n", __func__, fw_ck);
1152                                 goto fw_retry;
1153                         }
1154                 }
1155
1156                 if (priv->pll_register_no) {
1157                         xc5000_readreg(priv, priv->pll_register_no,
1158                                        &pll_lock_status);
1159                         if (pll_lock_status > 63) {
1160                                 /* PLL is unlocked, force reload of the firmware */
1161                                 printk(KERN_ERR "xc5000: PLL not running after fwload.\n");
1162                                 goto fw_retry;
1163                         }
1164                 }
1165
1166                 /* Default to "CABLE" mode */
1167                 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1168         }
1169
1170         return ret;
1171 }
1172
1173 static int xc5000_sleep(struct dvb_frontend *fe)
1174 {
1175         int ret;
1176
1177         dprintk(1, "%s()\n", __func__);
1178
1179         /* Avoid firmware reload on slow devices */
1180         if (no_poweroff)
1181                 return 0;
1182
1183         /* According to Xceive technical support, the "powerdown" register
1184            was removed in newer versions of the firmware.  The "supported"
1185            way to sleep the tuner is to pull the reset pin low for 10ms */
1186         ret = xc5000_TunerReset(fe);
1187         if (ret != XC_RESULT_SUCCESS) {
1188                 printk(KERN_ERR
1189                         "xc5000: %s() unable to shutdown tuner\n",
1190                         __func__);
1191                 return -EREMOTEIO;
1192         } else
1193                 return XC_RESULT_SUCCESS;
1194 }
1195
1196 static int xc5000_init(struct dvb_frontend *fe)
1197 {
1198         struct xc5000_priv *priv = fe->tuner_priv;
1199         dprintk(1, "%s()\n", __func__);
1200
1201         if (xc_load_fw_and_init_tuner(fe, 0) != XC_RESULT_SUCCESS) {
1202                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1203                 return -EREMOTEIO;
1204         }
1205
1206         if (debug)
1207                 xc_debug_dump(priv);
1208
1209         return 0;
1210 }
1211
1212 static int xc5000_release(struct dvb_frontend *fe)
1213 {
1214         struct xc5000_priv *priv = fe->tuner_priv;
1215
1216         dprintk(1, "%s()\n", __func__);
1217
1218         mutex_lock(&xc5000_list_mutex);
1219
1220         if (priv)
1221                 hybrid_tuner_release_state(priv);
1222
1223         mutex_unlock(&xc5000_list_mutex);
1224
1225         fe->tuner_priv = NULL;
1226
1227         return 0;
1228 }
1229
1230 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1231 {
1232         struct xc5000_priv *priv = fe->tuner_priv;
1233         struct xc5000_config *p = priv_cfg;
1234
1235         dprintk(1, "%s()\n", __func__);
1236
1237         if (p->if_khz)
1238                 priv->if_khz = p->if_khz;
1239
1240         if (p->radio_input)
1241                 priv->radio_input = p->radio_input;
1242
1243         return 0;
1244 }
1245
1246
1247 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1248         .info = {
1249                 .name           = "Xceive XC5000",
1250                 .frequency_min  =    1000000,
1251                 .frequency_max  = 1023000000,
1252                 .frequency_step =      50000,
1253         },
1254
1255         .release           = xc5000_release,
1256         .init              = xc5000_init,
1257         .sleep             = xc5000_sleep,
1258
1259         .set_config        = xc5000_set_config,
1260         .set_params        = xc5000_set_params,
1261         .set_analog_params = xc5000_set_analog_params,
1262         .get_frequency     = xc5000_get_frequency,
1263         .get_if_frequency  = xc5000_get_if_frequency,
1264         .get_bandwidth     = xc5000_get_bandwidth,
1265         .get_status        = xc5000_get_status
1266 };
1267
1268 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1269                                    struct i2c_adapter *i2c,
1270                                    const struct xc5000_config *cfg)
1271 {
1272         struct xc5000_priv *priv = NULL;
1273         int instance;
1274         u16 id = 0;
1275
1276         dprintk(1, "%s(%d-%04x)\n", __func__,
1277                 i2c ? i2c_adapter_id(i2c) : -1,
1278                 cfg ? cfg->i2c_address : -1);
1279
1280         mutex_lock(&xc5000_list_mutex);
1281
1282         instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1283                                               hybrid_tuner_instance_list,
1284                                               i2c, cfg->i2c_address, "xc5000");
1285         switch (instance) {
1286         case 0:
1287                 goto fail;
1288                 break;
1289         case 1:
1290                 /* new tuner instance */
1291                 priv->bandwidth = 6000000;
1292                 fe->tuner_priv = priv;
1293                 break;
1294         default:
1295                 /* existing tuner instance */
1296                 fe->tuner_priv = priv;
1297                 break;
1298         }
1299
1300         if (priv->if_khz == 0) {
1301                 /* If the IF hasn't been set yet, use the value provided by
1302                    the caller (occurs in hybrid devices where the analog
1303                    call to xc5000_attach occurs before the digital side) */
1304                 priv->if_khz = cfg->if_khz;
1305         }
1306
1307         if (priv->xtal_khz == 0)
1308                 priv->xtal_khz = cfg->xtal_khz;
1309
1310         if (priv->radio_input == 0)
1311                 priv->radio_input = cfg->radio_input;
1312
1313         /* don't override chip id if it's already been set
1314            unless explicitly specified */
1315         if ((priv->chip_id == 0) || (cfg->chip_id))
1316                 /* use default chip id if none specified, set to 0 so
1317                    it can be overridden if this is a hybrid driver */
1318                 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1319
1320         /* Check if firmware has been loaded. It is possible that another
1321            instance of the driver has loaded the firmware.
1322          */
1323         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1324                 goto fail;
1325
1326         switch (id) {
1327         case XC_PRODUCT_ID_FW_LOADED:
1328                 printk(KERN_INFO
1329                         "xc5000: Successfully identified at address 0x%02x\n",
1330                         cfg->i2c_address);
1331                 printk(KERN_INFO
1332                         "xc5000: Firmware has been loaded previously\n");
1333                 break;
1334         case XC_PRODUCT_ID_FW_NOT_LOADED:
1335                 printk(KERN_INFO
1336                         "xc5000: Successfully identified at address 0x%02x\n",
1337                         cfg->i2c_address);
1338                 printk(KERN_INFO
1339                         "xc5000: Firmware has not been loaded previously\n");
1340                 break;
1341         default:
1342                 printk(KERN_ERR
1343                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1344                         cfg->i2c_address, id);
1345                 goto fail;
1346         }
1347
1348         mutex_unlock(&xc5000_list_mutex);
1349
1350         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1351                 sizeof(struct dvb_tuner_ops));
1352
1353         return fe;
1354 fail:
1355         mutex_unlock(&xc5000_list_mutex);
1356
1357         xc5000_release(fe);
1358         return NULL;
1359 }
1360 EXPORT_SYMBOL(xc5000_attach);
1361
1362 MODULE_AUTHOR("Steven Toth");
1363 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1364 MODULE_LICENSE("GPL");
1365 MODULE_FIRMWARE(XC5000A_FIRMWARE);
1366 MODULE_FIRMWARE(XC5000C_FIRMWARE);