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