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
  20 #include <linux/module.h>
  21 #include <linux/moduleparam.h>
  22 #include <linux/videodev2.h>
  23 #include <linux/delay.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/dvb/frontend.h>
  26 #include <linux/i2c.h>
  27
  28 #include "dvb_frontend.h"
  29
  30 #include "xc5000.h"
  31 #include "tuner-i2c.h"
  32
  33 static int debug;
  34 module_param(debug, int, 0644);
  35 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
  36
  37 static int no_poweroff;
  38 module_param(no_poweroff, int, 0644);
  39 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
  40         "\t\t1 keep device energized and with tuner ready all the times.\n"
  41         "\t\tFaster, but consumes more power and keeps the device hotter");
  42
  43 static DEFINE_MUTEX(xc5000_list_mutex);
  44 static LIST_HEAD(hybrid_tuner_instance_list);
  45
  46 #define dprintk(level, fmt, arg...) if (debug >= level) \
  47         printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
  48
  49 struct xc5000_priv {
  50         struct tuner_i2c_props i2c_props;
  51         struct list_head hybrid_tuner_instance_list;
  52
  53         u32 if_khz;
  54         u16 xtal_khz;
  55         u32 freq_hz, freq_offset;
  56         u32 bandwidth;
  57         u8  video_standard;
  58         unsigned int mode;
  59         u8  rf_mode;
  60         u8  radio_input;
  61         u16  output_amp;
  62
  63         int chip_id;
  64         u16 pll_register_no;
  65         u8 init_status_supported;
  66         u8 fw_checksum_supported;
  67
  68         struct dvb_frontend *fe;
  69         struct delayed_work timer_sleep;
  70
  71         const struct firmware   *firmware;
  72 };
  73
  74 /* Misc Defines */
  75 #define MAX_TV_STANDARD                 24
  76 #define XC_MAX_I2C_WRITE_LENGTH         64
  77
  78 /* Time to suspend after the .sleep callback is called */
  79 #define XC5000_SLEEP_TIME               5000 /* ms */
  80
  81 /* Signal Types */
  82 #define XC_RF_MODE_AIR                  0
  83 #define XC_RF_MODE_CABLE                1
  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 audio_mode;
 157         u16 video_mode;
 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_tuner_reset(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 -EREMOTEIO;
 262         }
 263         return 0;
 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 0;
 301 }
 302
 303 static int xc5000_tuner_reset(struct dvb_frontend *fe)
 304 {
 305         struct xc5000_priv *priv = fe->tuner_priv;
 306         int ret;
 307
 308         dprintk(1, "%s()\n", __func__);
 309
 310         if (fe->callback) {
 311                 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
 312                                            fe->dvb->priv :
 313                                            priv->i2c_props.adap->algo_data,
 314                                            DVB_FRONTEND_COMPONENT_TUNER,
 315                                            XC5000_TUNER_RESET, 0);
 316                 if (ret) {
 317                         printk(KERN_ERR "xc5000: reset failed\n");
 318                         return ret;
 319                 }
 320         } else {
 321                 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
 322                 return -EINVAL;
 323         }
 324         return 0;
 325 }
 326
 327 static int xc_write_reg(struct xc5000_priv *priv, u16 reg_addr, u16 i2c_data)
 328 {
 329         u8 buf[4];
 330         int watch_dog_timer = 100;
 331         int result;
 332
 333         buf[0] = (reg_addr >> 8) & 0xFF;
 334         buf[1] = reg_addr & 0xFF;
 335         buf[2] = (i2c_data >> 8) & 0xFF;
 336         buf[3] = i2c_data & 0xFF;
 337         result = xc_send_i2c_data(priv, buf, 4);
 338         if (result == 0) {
 339                 /* wait for busy flag to clear */
 340                 while ((watch_dog_timer > 0) && (result == 0)) {
 341                         result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
 342                         if (result == 0) {
 343                                 if ((buf[0] == 0) && (buf[1] == 0)) {
 344                                         /* busy flag cleared */
 345                                         break;
 346                                 } else {
 347                                         msleep(5); /* wait 5 ms */
 348                                         watch_dog_timer--;
 349                                 }
 350                         }
 351                 }
 352         }
 353         if (watch_dog_timer <= 0)
 354                 result = -EREMOTEIO;
 355
 356         return result;
 357 }
 358
 359 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
 360 {
 361         struct xc5000_priv *priv = fe->tuner_priv;
 362
 363         int i, nbytes_to_send, result;
 364         unsigned int len, pos, index;
 365         u8 buf[XC_MAX_I2C_WRITE_LENGTH];
 366
 367         index = 0;
 368         while ((i2c_sequence[index] != 0xFF) ||
 369                 (i2c_sequence[index + 1] != 0xFF)) {
 370                 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
 371                 if (len == 0x0000) {
 372                         /* RESET command */
 373                         result = xc5000_tuner_reset(fe);
 374                         index += 2;
 375                         if (result != 0)
 376                                 return result;
 377                 } else if (len & 0x8000) {
 378                         /* WAIT command */
 379                         msleep(len & 0x7FFF);
 380                         index += 2;
 381                 } else {
 382                         /* Send i2c data whilst ensuring individual transactions
 383                          * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
 384                          */
 385                         index += 2;
 386                         buf[0] = i2c_sequence[index];
 387                         buf[1] = i2c_sequence[index + 1];
 388                         pos = 2;
 389                         while (pos < len) {
 390                                 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
 391                                         nbytes_to_send =
 392                                                 XC_MAX_I2C_WRITE_LENGTH;
 393                                 else
 394                                         nbytes_to_send = (len - pos + 2);
 395                                 for (i = 2; i < nbytes_to_send; i++) {
 396                                         buf[i] = i2c_sequence[index + pos +
 397                                                 i - 2];
 398                                 }
 399                                 result = xc_send_i2c_data(priv, buf,
 400                                         nbytes_to_send);
 401
 402                                 if (result != 0)
 403                                         return result;
 404
 405                                 pos += nbytes_to_send - 2;
 406                         }
 407                         index += len;
 408                 }
 409         }
 410         return 0;
 411 }
 412
 413 static int xc_initialize(struct xc5000_priv *priv)
 414 {
 415         dprintk(1, "%s()\n", __func__);
 416         return xc_write_reg(priv, XREG_INIT, 0);
 417 }
 418
 419 static int xc_set_tv_standard(struct xc5000_priv *priv,
 420         u16 video_mode, u16 audio_mode, u8 radio_mode)
 421 {
 422         int ret;
 423         dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode);
 424         if (radio_mode) {
 425                 dprintk(1, "%s() Standard = %s\n",
 426                         __func__,
 427                         xc5000_standard[radio_mode].name);
 428         } else {
 429                 dprintk(1, "%s() Standard = %s\n",
 430                         __func__,
 431                         xc5000_standard[priv->video_standard].name);
 432         }
 433
 434         ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode);
 435         if (ret == 0)
 436                 ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode);
 437
 438         return ret;
 439 }
 440
 441 static int xc_set_signal_source(struct xc5000_priv *priv, u16 rf_mode)
 442 {
 443         dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
 444                 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
 445
 446         if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
 447                 rf_mode = XC_RF_MODE_CABLE;
 448                 printk(KERN_ERR
 449                         "%s(), Invalid mode, defaulting to CABLE",
 450                         __func__);
 451         }
 452         return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
 453 }
 454
 455 static const struct dvb_tuner_ops xc5000_tuner_ops;
 456
 457 static int xc_set_rf_frequency(struct xc5000_priv *priv, u32 freq_hz)
 458 {
 459         u16 freq_code;
 460
 461         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 462
 463         if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
 464                 (freq_hz < xc5000_tuner_ops.info.frequency_min))
 465                 return -EINVAL;
 466
 467         freq_code = (u16)(freq_hz / 15625);
 468
 469         /* Starting in firmware version 1.1.44, Xceive recommends using the
 470            FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
 471            only be used for fast scanning for channel lock) */
 472         return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
 473 }
 474
 475
 476 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
 477 {
 478         u32 freq_code = (freq_khz * 1024)/1000;
 479         dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
 480                 __func__, freq_khz, freq_code);
 481
 482         return xc_write_reg(priv, XREG_IF_OUT, freq_code);
 483 }
 484
 485
 486 static int xc_get_adc_envelope(struct xc5000_priv *priv, u16 *adc_envelope)
 487 {
 488         return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
 489 }
 490
 491 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
 492 {
 493         int result;
 494         u16 reg_data;
 495         u32 tmp;
 496
 497         result = xc5000_readreg(priv, XREG_FREQ_ERROR, &reg_data);
 498         if (result != 0)
 499                 return result;
 500
 501         tmp = (u32)reg_data;
 502         (*freq_error_hz) = (tmp * 15625) / 1000;
 503         return result;
 504 }
 505
 506 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
 507 {
 508         return xc5000_readreg(priv, XREG_LOCK, lock_status);
 509 }
 510
 511 static int xc_get_version(struct xc5000_priv *priv,
 512         u8 *hw_majorversion, u8 *hw_minorversion,
 513         u8 *fw_majorversion, u8 *fw_minorversion)
 514 {
 515         u16 data;
 516         int result;
 517
 518         result = xc5000_readreg(priv, XREG_VERSION, &data);
 519         if (result != 0)
 520                 return result;
 521
 522         (*hw_majorversion) = (data >> 12) & 0x0F;
 523         (*hw_minorversion) = (data >>  8) & 0x0F;
 524         (*fw_majorversion) = (data >>  4) & 0x0F;
 525         (*fw_minorversion) = data & 0x0F;
 526
 527         return 0;
 528 }
 529
 530 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
 531 {
 532         return xc5000_readreg(priv, XREG_BUILD, buildrev);
 533 }
 534
 535 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
 536 {
 537         u16 reg_data;
 538         int result;
 539
 540         result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &reg_data);
 541         if (result != 0)
 542                 return result;
 543
 544         (*hsync_freq_hz) = ((reg_data & 0x0fff) * 763)/100;
 545         return result;
 546 }
 547
 548 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
 549 {
 550         return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
 551 }
 552
 553 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
 554 {
 555         return xc5000_readreg(priv, XREG_QUALITY, quality);
 556 }
 557
 558 static int xc_get_analogsnr(struct xc5000_priv *priv, u16 *snr)
 559 {
 560         return xc5000_readreg(priv, XREG_SNR, snr);
 561 }
 562
 563 static int xc_get_totalgain(struct xc5000_priv *priv, u16 *totalgain)
 564 {
 565         return xc5000_readreg(priv, XREG_TOTALGAIN, totalgain);
 566 }
 567
 568 static u16 wait_for_lock(struct xc5000_priv *priv)
 569 {
 570         u16 lock_state = 0;
 571         int watch_dog_count = 40;
 572
 573         while ((lock_state == 0) && (watch_dog_count > 0)) {
 574                 xc_get_lock_status(priv, &lock_state);
 575                 if (lock_state != 1) {
 576                         msleep(5);
 577                         watch_dog_count--;
 578                 }
 579         }
 580         return lock_state;
 581 }
 582
 583 #define XC_TUNE_ANALOG  0
 584 #define XC_TUNE_DIGITAL 1
 585 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
 586 {
 587         int found = 0;
 588
 589         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 590
 591         if (xc_set_rf_frequency(priv, freq_hz) != 0)
 592                 return 0;
 593
 594         if (mode == XC_TUNE_ANALOG) {
 595                 if (wait_for_lock(priv) == 1)
 596                         found = 1;
 597         }
 598
 599         return found;
 600 }
 601
 602 static int xc_set_xtal(struct dvb_frontend *fe)
 603 {
 604         struct xc5000_priv *priv = fe->tuner_priv;
 605         int ret = 0;
 606
 607         switch (priv->chip_id) {
 608         default:
 609         case XC5000A:
 610                 /* 32.000 MHz xtal is default */
 611                 break;
 612         case XC5000C:
 613                 switch (priv->xtal_khz) {
 614                 default:
 615                 case 32000:
 616                         /* 32.000 MHz xtal is default */
 617                         break;
 618                 case 31875:
 619                         /* 31.875 MHz xtal configuration */
 620                         ret = xc_write_reg(priv, 0x000f, 0x8081);
 621                         break;
 622                 }
 623                 break;
 624         }
 625         return ret;
 626 }
 627
 628 static int xc5000_fwupload(struct dvb_frontend *fe,
 629                            const struct xc5000_fw_cfg *desired_fw,
 630                            const struct firmware *fw)
 631 {
 632         struct xc5000_priv *priv = fe->tuner_priv;
 633         int ret;
 634
 635         /* request the firmware, this will block and timeout */
 636         dprintk(1, "waiting for firmware upload (%s)...\n",
 637                 desired_fw->name);
 638
 639         priv->pll_register_no = desired_fw->pll_reg;
 640         priv->init_status_supported = desired_fw->init_status_supported;
 641         priv->fw_checksum_supported = desired_fw->fw_checksum_supported;
 642
 643
 644         dprintk(1, "firmware uploading...\n");
 645         ret = xc_load_i2c_sequence(fe,  fw->data);
 646         if (!ret) {
 647                 ret = xc_set_xtal(fe);
 648                 dprintk(1, "Firmware upload complete...\n");
 649         } else
 650                 printk(KERN_ERR "xc5000: firmware upload failed...\n");
 651
 652         return ret;
 653 }
 654
 655 static void xc_debug_dump(struct xc5000_priv *priv)
 656 {
 657         u16 adc_envelope;
 658         u32 freq_error_hz = 0;
 659         u16 lock_status;
 660         u32 hsync_freq_hz = 0;
 661         u16 frame_lines;
 662         u16 quality;
 663         u16 snr;
 664         u16 totalgain;
 665         u8 hw_majorversion = 0, hw_minorversion = 0;
 666         u8 fw_majorversion = 0, fw_minorversion = 0;
 667         u16 fw_buildversion = 0;
 668         u16 regval;
 669
 670         /* Wait for stats to stabilize.
 671          * Frame Lines needs two frame times after initial lock
 672          * before it is valid.
 673          */
 674         msleep(100);
 675
 676         xc_get_adc_envelope(priv,  &adc_envelope);
 677         dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
 678
 679         xc_get_frequency_error(priv, &freq_error_hz);
 680         dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
 681
 682         xc_get_lock_status(priv,  &lock_status);
 683         dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
 684                 lock_status);
 685
 686         xc_get_version(priv,  &hw_majorversion, &hw_minorversion,
 687                 &fw_majorversion, &fw_minorversion);
 688         xc_get_buildversion(priv,  &fw_buildversion);
 689         dprintk(1, "*** HW: V%d.%d, FW: V %d.%d.%d\n",
 690                 hw_majorversion, hw_minorversion,
 691                 fw_majorversion, fw_minorversion, fw_buildversion);
 692
 693         xc_get_hsync_freq(priv,  &hsync_freq_hz);
 694         dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
 695
 696         xc_get_frame_lines(priv,  &frame_lines);
 697         dprintk(1, "*** Frame lines = %d\n", frame_lines);
 698
 699         xc_get_quality(priv,  &quality);
 700         dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality & 0x07);
 701
 702         xc_get_analogsnr(priv,  &snr);
 703         dprintk(1, "*** Unweighted analog SNR = %d dB\n", snr & 0x3f);
 704
 705         xc_get_totalgain(priv,  &totalgain);
 706         dprintk(1, "*** Total gain = %d.%d dB\n", totalgain / 256,
 707                 (totalgain % 256) * 100 / 256);
 708
 709         if (priv->pll_register_no) {
 710                 xc5000_readreg(priv, priv->pll_register_no, &regval);
 711                 dprintk(1, "*** PLL lock status = 0x%04x\n", regval);
 712         }
 713 }
 714
 715 static int xc5000_tune_digital(struct dvb_frontend *fe)
 716 {
 717         struct xc5000_priv *priv = fe->tuner_priv;
 718         int ret;
 719         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 720
 721         ret = xc_set_signal_source(priv, priv->rf_mode);
 722         if (ret != 0) {
 723                 printk(KERN_ERR
 724                         "xc5000: xc_set_signal_source(%d) failed\n",
 725                         priv->rf_mode);
 726                 return -EREMOTEIO;
 727         }
 728
 729         ret = xc_set_tv_standard(priv,
 730                 xc5000_standard[priv->video_standard].video_mode,
 731                 xc5000_standard[priv->video_standard].audio_mode, 0);
 732         if (ret != 0) {
 733                 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
 734                 return -EREMOTEIO;
 735         }
 736
 737         ret = xc_set_IF_frequency(priv, priv->if_khz);
 738         if (ret != 0) {
 739                 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
 740                        priv->if_khz);
 741                 return -EIO;
 742         }
 743
 744         dprintk(1, "%s() setting OUTPUT_AMP to 0x%x\n",
 745                 __func__, priv->output_amp);
 746         xc_write_reg(priv, XREG_OUTPUT_AMP, priv->output_amp);
 747
 748         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
 749
 750         if (debug)
 751                 xc_debug_dump(priv);
 752
 753         priv->bandwidth = bw;
 754
 755         return 0;
 756 }
 757
 758 static int xc5000_set_digital_params(struct dvb_frontend *fe)
 759 {
 760         int b;
 761         struct xc5000_priv *priv = fe->tuner_priv;
 762         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 763         u32 freq = fe->dtv_property_cache.frequency;
 764         u32 delsys  = fe->dtv_property_cache.delivery_system;
 765
 766         if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
 767                 dprintk(1, "Unable to load firmware and init tuner\n");
 768                 return -EINVAL;
 769         }
 770
 771         dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
 772
 773         switch (delsys) {
 774         case SYS_ATSC:
 775                 dprintk(1, "%s() VSB modulation\n", __func__);
 776                 priv->rf_mode = XC_RF_MODE_AIR;
 777                 priv->freq_offset = 1750000;
 778                 priv->video_standard = DTV6;
 779                 break;
 780         case SYS_DVBC_ANNEX_B:
 781                 dprintk(1, "%s() QAM modulation\n", __func__);
 782                 priv->rf_mode = XC_RF_MODE_CABLE;
 783                 priv->freq_offset = 1750000;
 784                 priv->video_standard = DTV6;
 785                 break;
 786         case SYS_ISDBT:
 787                 /* All ISDB-T are currently for 6 MHz bw */
 788                 if (!bw)
 789                         bw = 6000000;
 790                 /* fall to OFDM handling */
 791         case SYS_DMBTH:
 792         case SYS_DVBT:
 793         case SYS_DVBT2:
 794                 dprintk(1, "%s() OFDM\n", __func__);
 795                 switch (bw) {
 796                 case 6000000:
 797                         priv->video_standard = DTV6;
 798                         priv->freq_offset = 1750000;
 799                         break;
 800                 case 7000000:
 801                         priv->video_standard = DTV7;
 802                         priv->freq_offset = 2250000;
 803                         break;
 804                 case 8000000:
 805                         priv->video_standard = DTV8;
 806                         priv->freq_offset = 2750000;
 807                         break;
 808                 default:
 809                         printk(KERN_ERR "xc5000 bandwidth not set!\n");
 810                         return -EINVAL;
 811                 }
 812                 priv->rf_mode = XC_RF_MODE_AIR;
 813                 break;
 814         case SYS_DVBC_ANNEX_A:
 815         case SYS_DVBC_ANNEX_C:
 816                 dprintk(1, "%s() QAM modulation\n", __func__);
 817                 priv->rf_mode = XC_RF_MODE_CABLE;
 818                 if (bw <= 6000000) {
 819                         priv->video_standard = DTV6;
 820                         priv->freq_offset = 1750000;
 821                         b = 6;
 822                 } else if (bw <= 7000000) {
 823                         priv->video_standard = DTV7;
 824                         priv->freq_offset = 2250000;
 825                         b = 7;
 826                 } else {
 827                         priv->video_standard = DTV7_8;
 828                         priv->freq_offset = 2750000;
 829                         b = 8;
 830                 }
 831                 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
 832                         b, bw);
 833                 break;
 834         default:
 835                 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
 836                 return -EINVAL;
 837         }
 838
 839         priv->freq_hz = freq - priv->freq_offset;
 840         priv->mode = V4L2_TUNER_DIGITAL_TV;
 841
 842         dprintk(1, "%s() frequency=%d (compensated to %d)\n",
 843                 __func__, freq, priv->freq_hz);
 844
 845         return xc5000_tune_digital(fe);
 846 }
 847
 848 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
 849 {
 850         struct xc5000_priv *priv = fe->tuner_priv;
 851         int ret;
 852         u16 id;
 853
 854         ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
 855         if (ret == 0) {
 856                 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
 857                         ret = -ENOENT;
 858                 else
 859                         ret = 0;
 860         }
 861
 862         dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
 863                 ret == 0 ? "True" : "False", id);
 864         return ret;
 865 }
 866
 867 static void xc5000_config_tv(struct dvb_frontend *fe,
 868                              struct analog_parameters *params)
 869 {
 870         struct xc5000_priv *priv = fe->tuner_priv;
 871
 872         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
 873                 __func__, params->frequency);
 874
 875         /* Fix me: it could be air. */
 876         priv->rf_mode = params->mode;
 877         if (params->mode > XC_RF_MODE_CABLE)
 878                 priv->rf_mode = XC_RF_MODE_CABLE;
 879
 880         /* params->frequency is in units of 62.5khz */
 881         priv->freq_hz = params->frequency * 62500;
 882
 883         /* FIX ME: Some video standards may have several possible audio
 884                    standards. We simply default to one of them here.
 885          */
 886         if (params->std & V4L2_STD_MN) {
 887                 /* default to BTSC audio standard */
 888                 priv->video_standard = MN_NTSC_PAL_BTSC;
 889                 return;
 890         }
 891
 892         if (params->std & V4L2_STD_PAL_BG) {
 893                 /* default to NICAM audio standard */
 894                 priv->video_standard = BG_PAL_NICAM;
 895                 return;
 896         }
 897
 898         if (params->std & V4L2_STD_PAL_I) {
 899                 /* default to NICAM audio standard */
 900                 priv->video_standard = I_PAL_NICAM;
 901                 return;
 902         }
 903
 904         if (params->std & V4L2_STD_PAL_DK) {
 905                 /* default to NICAM audio standard */
 906                 priv->video_standard = DK_PAL_NICAM;
 907                 return;
 908         }
 909
 910         if (params->std & V4L2_STD_SECAM_DK) {
 911                 /* default to A2 DK1 audio standard */
 912                 priv->video_standard = DK_SECAM_A2DK1;
 913                 return;
 914         }
 915
 916         if (params->std & V4L2_STD_SECAM_L) {
 917                 priv->video_standard = L_SECAM_NICAM;
 918                 return;
 919         }
 920
 921         if (params->std & V4L2_STD_SECAM_LC) {
 922                 priv->video_standard = LC_SECAM_NICAM;
 923                 return;
 924         }
 925 }
 926
 927 static int xc5000_set_tv_freq(struct dvb_frontend *fe)
 928 {
 929         struct xc5000_priv *priv = fe->tuner_priv;
 930         u16 pll_lock_status;
 931         int ret;
 932
 933 tune_channel:
 934         ret = xc_set_signal_source(priv, priv->rf_mode);
 935         if (ret != 0) {
 936                 printk(KERN_ERR
 937                         "xc5000: xc_set_signal_source(%d) failed\n",
 938                         priv->rf_mode);
 939                 return -EREMOTEIO;
 940         }
 941
 942         ret = xc_set_tv_standard(priv,
 943                 xc5000_standard[priv->video_standard].video_mode,
 944                 xc5000_standard[priv->video_standard].audio_mode, 0);
 945         if (ret != 0) {
 946                 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
 947                 return -EREMOTEIO;
 948         }
 949
 950         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
 951
 952         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 953
 954         if (debug)
 955                 xc_debug_dump(priv);
 956
 957         if (priv->pll_register_no != 0) {
 958                 msleep(20);
 959                 xc5000_readreg(priv, priv->pll_register_no, &pll_lock_status);
 960                 if (pll_lock_status > 63) {
 961                         /* PLL is unlocked, force reload of the firmware */
 962                         dprintk(1, "xc5000: PLL not locked (0x%x).  Reloading...\n",
 963                                 pll_lock_status);
 964                         if (xc_load_fw_and_init_tuner(fe, 1) != 0) {
 965                                 printk(KERN_ERR "xc5000: Unable to reload fw\n");
 966                                 return -EREMOTEIO;
 967                         }
 968                         goto tune_channel;
 969                 }
 970         }
 971
 972         return 0;
 973 }
 974
 975 static int xc5000_config_radio(struct dvb_frontend *fe,
 976                                struct analog_parameters *params)
 977
 978 {
 979         struct xc5000_priv *priv = fe->tuner_priv;
 980
 981         dprintk(1, "%s() frequency=%d (in units of khz)\n",
 982                 __func__, params->frequency);
 983
 984         if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
 985                 dprintk(1, "%s() radio input not configured\n", __func__);
 986                 return -EINVAL;
 987         }
 988
 989         priv->freq_hz = params->frequency * 125 / 2;
 990         priv->rf_mode = XC_RF_MODE_AIR;
 991
 992         return 0;
 993 }
 994
 995 static int xc5000_set_radio_freq(struct dvb_frontend *fe)
 996 {
 997         struct xc5000_priv *priv = fe->tuner_priv;
 998         int ret;
 999         u8 radio_input;
1000
1001         if (priv->radio_input == XC5000_RADIO_FM1)
1002                 radio_input = FM_RADIO_INPUT1;
1003         else if  (priv->radio_input == XC5000_RADIO_FM2)
1004                 radio_input = FM_RADIO_INPUT2;
1005         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
1006                 radio_input = FM_RADIO_INPUT1_MONO;
1007         else {
1008                 dprintk(1, "%s() unknown radio input %d\n", __func__,
1009                         priv->radio_input);
1010                 return -EINVAL;
1011         }
1012
1013         ret = xc_set_tv_standard(priv, xc5000_standard[radio_input].video_mode,
1014                                xc5000_standard[radio_input].audio_mode, radio_input);
1015
1016         if (ret != 0) {
1017                 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
1018                 return -EREMOTEIO;
1019         }
1020
1021         ret = xc_set_signal_source(priv, priv->rf_mode);
1022         if (ret != 0) {
1023                 printk(KERN_ERR
1024                         "xc5000: xc_set_signal_source(%d) failed\n",
1025                         priv->rf_mode);
1026                 return -EREMOTEIO;
1027         }
1028
1029         if ((priv->radio_input == XC5000_RADIO_FM1) ||
1030                                 (priv->radio_input == XC5000_RADIO_FM2))
1031                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
1032         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
1033                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
1034
1035         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
1036
1037         return 0;
1038 }
1039
1040 static int xc5000_set_params(struct dvb_frontend *fe)
1041 {
1042         struct xc5000_priv *priv = fe->tuner_priv;
1043
1044         if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1045                 dprintk(1, "Unable to load firmware and init tuner\n");
1046                 return -EINVAL;
1047         }
1048
1049         switch (priv->mode) {
1050         case V4L2_TUNER_RADIO:
1051                 return xc5000_set_radio_freq(fe);
1052         case V4L2_TUNER_ANALOG_TV:
1053                 return xc5000_set_tv_freq(fe);
1054         case V4L2_TUNER_DIGITAL_TV:
1055                 return xc5000_tune_digital(fe);
1056         }
1057
1058         return 0;
1059 }
1060
1061 static int xc5000_set_analog_params(struct dvb_frontend *fe,
1062                              struct analog_parameters *params)
1063 {
1064         struct xc5000_priv *priv = fe->tuner_priv;
1065         int ret;
1066
1067         if (priv->i2c_props.adap == NULL)
1068                 return -EINVAL;
1069
1070         switch (params->mode) {
1071         case V4L2_TUNER_RADIO:
1072                 ret = xc5000_config_radio(fe, params);
1073                 if (ret)
1074                         return ret;
1075                 break;
1076         case V4L2_TUNER_ANALOG_TV:
1077                 xc5000_config_tv(fe, params);
1078                 break;
1079         default:
1080                 break;
1081         }
1082         priv->mode = params->mode;
1083
1084         return xc5000_set_params(fe);
1085 }
1086
1087 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1088 {
1089         struct xc5000_priv *priv = fe->tuner_priv;
1090         dprintk(1, "%s()\n", __func__);
1091         *freq = priv->freq_hz + priv->freq_offset;
1092         return 0;
1093 }
1094
1095 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1096 {
1097         struct xc5000_priv *priv = fe->tuner_priv;
1098         dprintk(1, "%s()\n", __func__);
1099         *freq = priv->if_khz * 1000;
1100         return 0;
1101 }
1102
1103 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1104 {
1105         struct xc5000_priv *priv = fe->tuner_priv;
1106         dprintk(1, "%s()\n", __func__);
1107
1108         *bw = priv->bandwidth;
1109         return 0;
1110 }
1111
1112 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1113 {
1114         struct xc5000_priv *priv = fe->tuner_priv;
1115         u16 lock_status = 0;
1116
1117         xc_get_lock_status(priv, &lock_status);
1118
1119         dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1120
1121         *status = lock_status;
1122
1123         return 0;
1124 }
1125
1126 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force)
1127 {
1128         struct xc5000_priv *priv = fe->tuner_priv;
1129         const struct xc5000_fw_cfg *desired_fw = xc5000_assign_firmware(priv->chip_id);
1130         const struct firmware *fw;
1131         int ret, i;
1132         u16 pll_lock_status;
1133         u16 fw_ck;
1134
1135         cancel_delayed_work(&priv->timer_sleep);
1136
1137         if (!force && xc5000_is_firmware_loaded(fe) == 0)
1138                 return 0;
1139
1140         if (!priv->firmware) {
1141                 ret = request_firmware(&fw, desired_fw->name,
1142                                         priv->i2c_props.adap->dev.parent);
1143                 if (ret) {
1144                         pr_err("xc5000: Upload failed. rc %d\n", ret);
1145                         return ret;
1146                 }
1147                 dprintk(1, "firmware read %zu bytes.\n", fw->size);
1148
1149                 if (fw->size != desired_fw->size) {
1150                         pr_err("xc5000: Firmware file with incorrect size\n");
1151                         release_firmware(fw);
1152                         return -EINVAL;
1153                 }
1154                 priv->firmware = fw;
1155         } else
1156                 fw = priv->firmware;
1157
1158         /* Try up to 5 times to load firmware */
1159         for (i = 0; i < 5; i++) {
1160                 if (i)
1161                         printk(KERN_CONT " - retrying to upload firmware.\n");
1162
1163                 ret = xc5000_fwupload(fe, desired_fw, fw);
1164                 if (ret != 0)
1165                         goto err;
1166
1167                 msleep(20);
1168
1169                 if (priv->fw_checksum_supported) {
1170                         if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck)) {
1171                                 printk(KERN_ERR
1172                                        "xc5000: FW checksum reading failed.");
1173                                 continue;
1174                         }
1175
1176                         if (!fw_ck) {
1177                                 printk(KERN_ERR
1178                                        "xc5000: FW checksum failed = 0x%04x.",
1179                                        fw_ck);
1180                                 continue;
1181                         }
1182                 }
1183
1184                 /* Start the tuner self-calibration process */
1185                 ret = xc_initialize(priv);
1186                 if (ret) {
1187                         printk(KERN_ERR
1188                                "xc5000: Can't request Self-callibration.");
1189                         continue;
1190                 }
1191
1192                 /* Wait for calibration to complete.
1193                  * We could continue but XC5000 will clock stretch subsequent
1194                  * I2C transactions until calibration is complete.  This way we
1195                  * don't have to rely on clock stretching working.
1196                  */
1197                 msleep(100);
1198
1199                 if (priv->init_status_supported) {
1200                         if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck)) {
1201                                 printk(KERN_ERR
1202                                        "xc5000: FW failed reading init status.");
1203                                 continue;
1204                         }
1205
1206                         if (!fw_ck) {
1207                                 printk(KERN_ERR
1208                                        "xc5000: FW init status failed = 0x%04x.",
1209                                        fw_ck);
1210                                 continue;
1211                         }
1212                 }
1213
1214                 if (priv->pll_register_no) {
1215                         xc5000_readreg(priv, priv->pll_register_no,
1216                                        &pll_lock_status);
1217                         if (pll_lock_status > 63) {
1218                                 /* PLL is unlocked, force reload of the firmware */
1219                                 printk(KERN_ERR
1220                                        "xc5000: PLL not running after fwload.");
1221                                 continue;
1222                         }
1223                 }
1224
1225                 /* Default to "CABLE" mode */
1226                 ret = xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1227                 if (!ret)
1228                         break;
1229                 printk(KERN_ERR "xc5000: can't set to cable mode.");
1230         }
1231
1232 err:
1233         if (!ret)
1234                 printk(KERN_INFO "xc5000: Firmware %s loaded and running.\n",
1235                        desired_fw->name);
1236         else
1237                 printk(KERN_CONT " - too many retries. Giving up\n");
1238
1239         return ret;
1240 }
1241
1242 static void xc5000_do_timer_sleep(struct work_struct *timer_sleep)
1243 {
1244         struct xc5000_priv *priv =container_of(timer_sleep, struct xc5000_priv,
1245                                                timer_sleep.work);
1246         struct dvb_frontend *fe = priv->fe;
1247         int ret;
1248
1249         dprintk(1, "%s()\n", __func__);
1250
1251         /* According to Xceive technical support, the "powerdown" register
1252            was removed in newer versions of the firmware.  The "supported"
1253            way to sleep the tuner is to pull the reset pin low for 10ms */
1254         ret = xc5000_tuner_reset(fe);
1255         if (ret != 0)
1256                 printk(KERN_ERR
1257                         "xc5000: %s() unable to shutdown tuner\n",
1258                         __func__);
1259 }
1260
1261 static int xc5000_sleep(struct dvb_frontend *fe)
1262 {
1263         struct xc5000_priv *priv = fe->tuner_priv;
1264
1265         dprintk(1, "%s()\n", __func__);
1266
1267         /* Avoid firmware reload on slow devices */
1268         if (no_poweroff)
1269                 return 0;
1270
1271         schedule_delayed_work(&priv->timer_sleep,
1272                               msecs_to_jiffies(XC5000_SLEEP_TIME));
1273
1274         return 0;
1275 }
1276
1277 static int xc5000_suspend(struct dvb_frontend *fe)
1278 {
1279         struct xc5000_priv *priv = fe->tuner_priv;
1280         int ret;
1281
1282         dprintk(1, "%s()\n", __func__);
1283
1284         cancel_delayed_work(&priv->timer_sleep);
1285
1286         ret = xc5000_tuner_reset(fe);
1287         if (ret != 0)
1288                 printk(KERN_ERR
1289                         "xc5000: %s() unable to shutdown tuner\n",
1290                         __func__);
1291
1292         return 0;
1293 }
1294
1295 static int xc5000_resume(struct dvb_frontend *fe)
1296 {
1297         struct xc5000_priv *priv = fe->tuner_priv;
1298
1299         dprintk(1, "%s()\n", __func__);
1300
1301         /* suspended before firmware is loaded.
1302            Avoid firmware load in resume path. */
1303         if (!priv->firmware)
1304                 return 0;
1305
1306         return xc5000_set_params(fe);
1307 }
1308
1309 static int xc5000_init(struct dvb_frontend *fe)
1310 {
1311         struct xc5000_priv *priv = fe->tuner_priv;
1312         dprintk(1, "%s()\n", __func__);
1313
1314         if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1315                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1316                 return -EREMOTEIO;
1317         }
1318
1319         if (debug)
1320                 xc_debug_dump(priv);
1321
1322         return 0;
1323 }
1324
1325 static void xc5000_release(struct dvb_frontend *fe)
1326 {
1327         struct xc5000_priv *priv = fe->tuner_priv;
1328
1329         dprintk(1, "%s()\n", __func__);
1330
1331         mutex_lock(&xc5000_list_mutex);
1332
1333         if (priv) {
1334                 cancel_delayed_work(&priv->timer_sleep);
1335                 if (priv->firmware) {
1336                         release_firmware(priv->firmware);
1337                         priv->firmware = NULL;
1338                 }
1339                 hybrid_tuner_release_state(priv);
1340         }
1341
1342         mutex_unlock(&xc5000_list_mutex);
1343
1344         fe->tuner_priv = NULL;
1345 }
1346
1347 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1348 {
1349         struct xc5000_priv *priv = fe->tuner_priv;
1350         struct xc5000_config *p = priv_cfg;
1351
1352         dprintk(1, "%s()\n", __func__);
1353
1354         if (p->if_khz)
1355                 priv->if_khz = p->if_khz;
1356
1357         if (p->radio_input)
1358                 priv->radio_input = p->radio_input;
1359
1360         if (p->output_amp)
1361                 priv->output_amp = p->output_amp;
1362
1363         return 0;
1364 }
1365
1366
1367 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1368         .info = {
1369                 .name           = "Xceive XC5000",
1370                 .frequency_min  =    1000000,
1371                 .frequency_max  = 1023000000,
1372                 .frequency_step =      50000,
1373         },
1374
1375         .release           = xc5000_release,
1376         .init              = xc5000_init,
1377         .sleep             = xc5000_sleep,
1378         .suspend           = xc5000_suspend,
1379         .resume            = xc5000_resume,
1380
1381         .set_config        = xc5000_set_config,
1382         .set_params        = xc5000_set_digital_params,
1383         .set_analog_params = xc5000_set_analog_params,
1384         .get_frequency     = xc5000_get_frequency,
1385         .get_if_frequency  = xc5000_get_if_frequency,
1386         .get_bandwidth     = xc5000_get_bandwidth,
1387         .get_status        = xc5000_get_status
1388 };
1389
1390 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1391                                    struct i2c_adapter *i2c,
1392                                    const struct xc5000_config *cfg)
1393 {
1394         struct xc5000_priv *priv = NULL;
1395         int instance;
1396         u16 id = 0;
1397
1398         dprintk(1, "%s(%d-%04x)\n", __func__,
1399                 i2c ? i2c_adapter_id(i2c) : -1,
1400                 cfg ? cfg->i2c_address : -1);
1401
1402         mutex_lock(&xc5000_list_mutex);
1403
1404         instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1405                                               hybrid_tuner_instance_list,
1406                                               i2c, cfg->i2c_address, "xc5000");
1407         switch (instance) {
1408         case 0:
1409                 goto fail;
1410         case 1:
1411                 /* new tuner instance */
1412                 priv->bandwidth = 6000000;
1413                 fe->tuner_priv = priv;
1414                 priv->fe = fe;
1415                 INIT_DELAYED_WORK(&priv->timer_sleep, xc5000_do_timer_sleep);
1416                 break;
1417         default:
1418                 /* existing tuner instance */
1419                 fe->tuner_priv = priv;
1420                 break;
1421         }
1422
1423         if (priv->if_khz == 0) {
1424                 /* If the IF hasn't been set yet, use the value provided by
1425                    the caller (occurs in hybrid devices where the analog
1426                    call to xc5000_attach occurs before the digital side) */
1427                 priv->if_khz = cfg->if_khz;
1428         }
1429
1430         if (priv->xtal_khz == 0)
1431                 priv->xtal_khz = cfg->xtal_khz;
1432
1433         if (priv->radio_input == 0)
1434                 priv->radio_input = cfg->radio_input;
1435
1436         /* don't override chip id if it's already been set
1437            unless explicitly specified */
1438         if ((priv->chip_id == 0) || (cfg->chip_id))
1439                 /* use default chip id if none specified, set to 0 so
1440                    it can be overridden if this is a hybrid driver */
1441                 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1442
1443         /* don't override output_amp if it's already been set
1444            unless explicitly specified */
1445         if ((priv->output_amp == 0) || (cfg->output_amp))
1446                 /* use default output_amp value if none specified */
1447                 priv->output_amp = (cfg->output_amp) ? cfg->output_amp : 0x8a;
1448
1449         /* Check if firmware has been loaded. It is possible that another
1450            instance of the driver has loaded the firmware.
1451          */
1452         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1453                 goto fail;
1454
1455         switch (id) {
1456         case XC_PRODUCT_ID_FW_LOADED:
1457                 printk(KERN_INFO
1458                         "xc5000: Successfully identified at address 0x%02x\n",
1459                         cfg->i2c_address);
1460                 printk(KERN_INFO
1461                         "xc5000: Firmware has been loaded previously\n");
1462                 break;
1463         case XC_PRODUCT_ID_FW_NOT_LOADED:
1464                 printk(KERN_INFO
1465                         "xc5000: Successfully identified at address 0x%02x\n",
1466                         cfg->i2c_address);
1467                 printk(KERN_INFO
1468                         "xc5000: Firmware has not been loaded previously\n");
1469                 break;
1470         default:
1471                 printk(KERN_ERR
1472                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1473                         cfg->i2c_address, id);
1474                 goto fail;
1475         }
1476
1477         mutex_unlock(&xc5000_list_mutex);
1478
1479         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1480                 sizeof(struct dvb_tuner_ops));
1481
1482         return fe;
1483 fail:
1484         mutex_unlock(&xc5000_list_mutex);
1485
1486         xc5000_release(fe);
1487         return NULL;
1488 }
1489 EXPORT_SYMBOL(xc5000_attach);
1490
1491 MODULE_AUTHOR("Steven Toth");
1492 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1493 MODULE_LICENSE("GPL");
1494 MODULE_FIRMWARE(XC5000A_FIRMWARE);
1495 MODULE_FIRMWARE(XC5000C_FIRMWARE);