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 <media/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_hz) ||
 464                 (freq_hz < xc5000_tuner_ops.info.frequency_min_hz))
 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 #define XC_TUNE_ANALOG  0
 569 #define XC_TUNE_DIGITAL 1
 570 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
 571 {
 572         dprintk(1, "%s(%u)\n", __func__, freq_hz);
 573
 574         if (xc_set_rf_frequency(priv, freq_hz) != 0)
 575                 return -EREMOTEIO;
 576
 577         return 0;
 578 }
 579
 580 static int xc_set_xtal(struct dvb_frontend *fe)
 581 {
 582         struct xc5000_priv *priv = fe->tuner_priv;
 583         int ret = 0;
 584
 585         switch (priv->chip_id) {
 586         default:
 587         case XC5000A:
 588                 /* 32.000 MHz xtal is default */
 589                 break;
 590         case XC5000C:
 591                 switch (priv->xtal_khz) {
 592                 default:
 593                 case 32000:
 594                         /* 32.000 MHz xtal is default */
 595                         break;
 596                 case 31875:
 597                         /* 31.875 MHz xtal configuration */
 598                         ret = xc_write_reg(priv, 0x000f, 0x8081);
 599                         break;
 600                 }
 601                 break;
 602         }
 603         return ret;
 604 }
 605
 606 static int xc5000_fwupload(struct dvb_frontend *fe,
 607                            const struct xc5000_fw_cfg *desired_fw,
 608                            const struct firmware *fw)
 609 {
 610         struct xc5000_priv *priv = fe->tuner_priv;
 611         int ret;
 612
 613         /* request the firmware, this will block and timeout */
 614         dprintk(1, "waiting for firmware upload (%s)...\n",
 615                 desired_fw->name);
 616
 617         priv->pll_register_no = desired_fw->pll_reg;
 618         priv->init_status_supported = desired_fw->init_status_supported;
 619         priv->fw_checksum_supported = desired_fw->fw_checksum_supported;
 620
 621
 622         dprintk(1, "firmware uploading...\n");
 623         ret = xc_load_i2c_sequence(fe,  fw->data);
 624         if (!ret) {
 625                 ret = xc_set_xtal(fe);
 626                 dprintk(1, "Firmware upload complete...\n");
 627         } else
 628                 printk(KERN_ERR "xc5000: firmware upload failed...\n");
 629
 630         return ret;
 631 }
 632
 633 static void xc_debug_dump(struct xc5000_priv *priv)
 634 {
 635         u16 adc_envelope;
 636         u32 freq_error_hz = 0;
 637         u16 lock_status;
 638         u32 hsync_freq_hz = 0;
 639         u16 frame_lines;
 640         u16 quality;
 641         u16 snr;
 642         u16 totalgain;
 643         u8 hw_majorversion = 0, hw_minorversion = 0;
 644         u8 fw_majorversion = 0, fw_minorversion = 0;
 645         u16 fw_buildversion = 0;
 646         u16 regval;
 647
 648         /* Wait for stats to stabilize.
 649          * Frame Lines needs two frame times after initial lock
 650          * before it is valid.
 651          */
 652         msleep(100);
 653
 654         xc_get_adc_envelope(priv,  &adc_envelope);
 655         dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
 656
 657         xc_get_frequency_error(priv, &freq_error_hz);
 658         dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
 659
 660         xc_get_lock_status(priv,  &lock_status);
 661         dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
 662                 lock_status);
 663
 664         xc_get_version(priv,  &hw_majorversion, &hw_minorversion,
 665                 &fw_majorversion, &fw_minorversion);
 666         xc_get_buildversion(priv,  &fw_buildversion);
 667         dprintk(1, "*** HW: V%d.%d, FW: V %d.%d.%d\n",
 668                 hw_majorversion, hw_minorversion,
 669                 fw_majorversion, fw_minorversion, fw_buildversion);
 670
 671         xc_get_hsync_freq(priv,  &hsync_freq_hz);
 672         dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
 673
 674         xc_get_frame_lines(priv,  &frame_lines);
 675         dprintk(1, "*** Frame lines = %d\n", frame_lines);
 676
 677         xc_get_quality(priv,  &quality);
 678         dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality & 0x07);
 679
 680         xc_get_analogsnr(priv,  &snr);
 681         dprintk(1, "*** Unweighted analog SNR = %d dB\n", snr & 0x3f);
 682
 683         xc_get_totalgain(priv,  &totalgain);
 684         dprintk(1, "*** Total gain = %d.%d dB\n", totalgain / 256,
 685                 (totalgain % 256) * 100 / 256);
 686
 687         if (priv->pll_register_no) {
 688                 if (!xc5000_readreg(priv, priv->pll_register_no, &regval))
 689                         dprintk(1, "*** PLL lock status = 0x%04x\n", regval);
 690         }
 691 }
 692
 693 static int xc5000_tune_digital(struct dvb_frontend *fe)
 694 {
 695         struct xc5000_priv *priv = fe->tuner_priv;
 696         int ret;
 697         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 698
 699         ret = xc_set_signal_source(priv, priv->rf_mode);
 700         if (ret != 0) {
 701                 printk(KERN_ERR
 702                         "xc5000: xc_set_signal_source(%d) failed\n",
 703                         priv->rf_mode);
 704                 return -EREMOTEIO;
 705         }
 706
 707         ret = xc_set_tv_standard(priv,
 708                 xc5000_standard[priv->video_standard].video_mode,
 709                 xc5000_standard[priv->video_standard].audio_mode, 0);
 710         if (ret != 0) {
 711                 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
 712                 return -EREMOTEIO;
 713         }
 714
 715         ret = xc_set_IF_frequency(priv, priv->if_khz);
 716         if (ret != 0) {
 717                 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
 718                        priv->if_khz);
 719                 return -EIO;
 720         }
 721
 722         dprintk(1, "%s() setting OUTPUT_AMP to 0x%x\n",
 723                 __func__, priv->output_amp);
 724         xc_write_reg(priv, XREG_OUTPUT_AMP, priv->output_amp);
 725
 726         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
 727
 728         if (debug)
 729                 xc_debug_dump(priv);
 730
 731         priv->bandwidth = bw;
 732
 733         return 0;
 734 }
 735
 736 static int xc5000_set_digital_params(struct dvb_frontend *fe)
 737 {
 738         int b;
 739         struct xc5000_priv *priv = fe->tuner_priv;
 740         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 741         u32 freq = fe->dtv_property_cache.frequency;
 742         u32 delsys  = fe->dtv_property_cache.delivery_system;
 743
 744         if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
 745                 dprintk(1, "Unable to load firmware and init tuner\n");
 746                 return -EINVAL;
 747         }
 748
 749         dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
 750
 751         switch (delsys) {
 752         case SYS_ATSC:
 753                 dprintk(1, "%s() VSB modulation\n", __func__);
 754                 priv->rf_mode = XC_RF_MODE_AIR;
 755                 priv->freq_offset = 1750000;
 756                 priv->video_standard = DTV6;
 757                 break;
 758         case SYS_DVBC_ANNEX_B:
 759                 dprintk(1, "%s() QAM modulation\n", __func__);
 760                 priv->rf_mode = XC_RF_MODE_CABLE;
 761                 priv->freq_offset = 1750000;
 762                 priv->video_standard = DTV6;
 763                 break;
 764         case SYS_ISDBT:
 765                 /* All ISDB-T are currently for 6 MHz bw */
 766                 if (!bw)
 767                         bw = 6000000;
 768                 /* fall to OFDM handling */
 769                 /* fall through */
 770         case SYS_DMBTH:
 771         case SYS_DVBT:
 772         case SYS_DVBT2:
 773                 dprintk(1, "%s() OFDM\n", __func__);
 774                 switch (bw) {
 775                 case 6000000:
 776                         priv->video_standard = DTV6;
 777                         priv->freq_offset = 1750000;
 778                         break;
 779                 case 7000000:
 780                         priv->video_standard = DTV7;
 781                         priv->freq_offset = 2250000;
 782                         break;
 783                 case 8000000:
 784                         priv->video_standard = DTV8;
 785                         priv->freq_offset = 2750000;
 786                         break;
 787                 default:
 788                         printk(KERN_ERR "xc5000 bandwidth not set!\n");
 789                         return -EINVAL;
 790                 }
 791                 priv->rf_mode = XC_RF_MODE_AIR;
 792                 break;
 793         case SYS_DVBC_ANNEX_A:
 794         case SYS_DVBC_ANNEX_C:
 795                 dprintk(1, "%s() QAM modulation\n", __func__);
 796                 priv->rf_mode = XC_RF_MODE_CABLE;
 797                 if (bw <= 6000000) {
 798                         priv->video_standard = DTV6;
 799                         priv->freq_offset = 1750000;
 800                         b = 6;
 801                 } else if (bw <= 7000000) {
 802                         priv->video_standard = DTV7;
 803                         priv->freq_offset = 2250000;
 804                         b = 7;
 805                 } else {
 806                         priv->video_standard = DTV7_8;
 807                         priv->freq_offset = 2750000;
 808                         b = 8;
 809                 }
 810                 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
 811                         b, bw);
 812                 break;
 813         default:
 814                 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
 815                 return -EINVAL;
 816         }
 817
 818         priv->freq_hz = freq - priv->freq_offset;
 819         priv->mode = V4L2_TUNER_DIGITAL_TV;
 820
 821         dprintk(1, "%s() frequency=%d (compensated to %d)\n",
 822                 __func__, freq, priv->freq_hz);
 823
 824         return xc5000_tune_digital(fe);
 825 }
 826
 827 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
 828 {
 829         struct xc5000_priv *priv = fe->tuner_priv;
 830         int ret;
 831         u16 id;
 832
 833         ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
 834         if (!ret) {
 835                 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
 836                         ret = -ENOENT;
 837                 else
 838                         ret = 0;
 839                 dprintk(1, "%s() returns id = 0x%x\n", __func__, id);
 840         } else {
 841                 dprintk(1, "%s() returns error %d\n", __func__, ret);
 842         }
 843
 844         return ret;
 845 }
 846
 847 static void xc5000_config_tv(struct dvb_frontend *fe,
 848                              struct analog_parameters *params)
 849 {
 850         struct xc5000_priv *priv = fe->tuner_priv;
 851
 852         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
 853                 __func__, params->frequency);
 854
 855         /* Fix me: it could be air. */
 856         priv->rf_mode = params->mode;
 857         if (params->mode > XC_RF_MODE_CABLE)
 858                 priv->rf_mode = XC_RF_MODE_CABLE;
 859
 860         /* params->frequency is in units of 62.5khz */
 861         priv->freq_hz = params->frequency * 62500;
 862
 863         /* FIX ME: Some video standards may have several possible audio
 864                    standards. We simply default to one of them here.
 865          */
 866         if (params->std & V4L2_STD_MN) {
 867                 /* default to BTSC audio standard */
 868                 priv->video_standard = MN_NTSC_PAL_BTSC;
 869                 return;
 870         }
 871
 872         if (params->std & V4L2_STD_PAL_BG) {
 873                 /* default to NICAM audio standard */
 874                 priv->video_standard = BG_PAL_NICAM;
 875                 return;
 876         }
 877
 878         if (params->std & V4L2_STD_PAL_I) {
 879                 /* default to NICAM audio standard */
 880                 priv->video_standard = I_PAL_NICAM;
 881                 return;
 882         }
 883
 884         if (params->std & V4L2_STD_PAL_DK) {
 885                 /* default to NICAM audio standard */
 886                 priv->video_standard = DK_PAL_NICAM;
 887                 return;
 888         }
 889
 890         if (params->std & V4L2_STD_SECAM_DK) {
 891                 /* default to A2 DK1 audio standard */
 892                 priv->video_standard = DK_SECAM_A2DK1;
 893                 return;
 894         }
 895
 896         if (params->std & V4L2_STD_SECAM_L) {
 897                 priv->video_standard = L_SECAM_NICAM;
 898                 return;
 899         }
 900
 901         if (params->std & V4L2_STD_SECAM_LC) {
 902                 priv->video_standard = LC_SECAM_NICAM;
 903                 return;
 904         }
 905 }
 906
 907 static int xc5000_set_tv_freq(struct dvb_frontend *fe)
 908 {
 909         struct xc5000_priv *priv = fe->tuner_priv;
 910         u16 pll_lock_status;
 911         int ret;
 912
 913 tune_channel:
 914         ret = xc_set_signal_source(priv, priv->rf_mode);
 915         if (ret != 0) {
 916                 printk(KERN_ERR
 917                         "xc5000: xc_set_signal_source(%d) failed\n",
 918                         priv->rf_mode);
 919                 return -EREMOTEIO;
 920         }
 921
 922         ret = xc_set_tv_standard(priv,
 923                 xc5000_standard[priv->video_standard].video_mode,
 924                 xc5000_standard[priv->video_standard].audio_mode, 0);
 925         if (ret != 0) {
 926                 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
 927                 return -EREMOTEIO;
 928         }
 929
 930         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
 931
 932         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
 933
 934         if (debug)
 935                 xc_debug_dump(priv);
 936
 937         if (priv->pll_register_no != 0) {
 938                 msleep(20);
 939                 ret = xc5000_readreg(priv, priv->pll_register_no,
 940                                      &pll_lock_status);
 941                 if (ret)
 942                         return ret;
 943                 if (pll_lock_status > 63) {
 944                         /* PLL is unlocked, force reload of the firmware */
 945                         dprintk(1, "xc5000: PLL not locked (0x%x).  Reloading...\n",
 946                                 pll_lock_status);
 947                         if (xc_load_fw_and_init_tuner(fe, 1) != 0) {
 948                                 printk(KERN_ERR "xc5000: Unable to reload fw\n");
 949                                 return -EREMOTEIO;
 950                         }
 951                         goto tune_channel;
 952                 }
 953         }
 954
 955         return 0;
 956 }
 957
 958 static int xc5000_config_radio(struct dvb_frontend *fe,
 959                                struct analog_parameters *params)
 960
 961 {
 962         struct xc5000_priv *priv = fe->tuner_priv;
 963
 964         dprintk(1, "%s() frequency=%d (in units of khz)\n",
 965                 __func__, params->frequency);
 966
 967         if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
 968                 dprintk(1, "%s() radio input not configured\n", __func__);
 969                 return -EINVAL;
 970         }
 971
 972         priv->freq_hz = params->frequency * 125 / 2;
 973         priv->rf_mode = XC_RF_MODE_AIR;
 974
 975         return 0;
 976 }
 977
 978 static int xc5000_set_radio_freq(struct dvb_frontend *fe)
 979 {
 980         struct xc5000_priv *priv = fe->tuner_priv;
 981         int ret;
 982         u8 radio_input;
 983
 984         if (priv->radio_input == XC5000_RADIO_FM1)
 985                 radio_input = FM_RADIO_INPUT1;
 986         else if  (priv->radio_input == XC5000_RADIO_FM2)
 987                 radio_input = FM_RADIO_INPUT2;
 988         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
 989                 radio_input = FM_RADIO_INPUT1_MONO;
 990         else {
 991                 dprintk(1, "%s() unknown radio input %d\n", __func__,
 992                         priv->radio_input);
 993                 return -EINVAL;
 994         }
 995
 996         ret = xc_set_tv_standard(priv, xc5000_standard[radio_input].video_mode,
 997                                xc5000_standard[radio_input].audio_mode, radio_input);
 998
 999         if (ret != 0) {
1000                 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
1001                 return -EREMOTEIO;
1002         }
1003
1004         ret = xc_set_signal_source(priv, priv->rf_mode);
1005         if (ret != 0) {
1006                 printk(KERN_ERR
1007                         "xc5000: xc_set_signal_source(%d) failed\n",
1008                         priv->rf_mode);
1009                 return -EREMOTEIO;
1010         }
1011
1012         if ((priv->radio_input == XC5000_RADIO_FM1) ||
1013                                 (priv->radio_input == XC5000_RADIO_FM2))
1014                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
1015         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
1016                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
1017
1018         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
1019
1020         return 0;
1021 }
1022
1023 static int xc5000_set_params(struct dvb_frontend *fe)
1024 {
1025         struct xc5000_priv *priv = fe->tuner_priv;
1026
1027         if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1028                 dprintk(1, "Unable to load firmware and init tuner\n");
1029                 return -EINVAL;
1030         }
1031
1032         switch (priv->mode) {
1033         case V4L2_TUNER_RADIO:
1034                 return xc5000_set_radio_freq(fe);
1035         case V4L2_TUNER_ANALOG_TV:
1036                 return xc5000_set_tv_freq(fe);
1037         case V4L2_TUNER_DIGITAL_TV:
1038                 return xc5000_tune_digital(fe);
1039         }
1040
1041         return 0;
1042 }
1043
1044 static int xc5000_set_analog_params(struct dvb_frontend *fe,
1045                              struct analog_parameters *params)
1046 {
1047         struct xc5000_priv *priv = fe->tuner_priv;
1048         int ret;
1049
1050         if (priv->i2c_props.adap == NULL)
1051                 return -EINVAL;
1052
1053         switch (params->mode) {
1054         case V4L2_TUNER_RADIO:
1055                 ret = xc5000_config_radio(fe, params);
1056                 if (ret)
1057                         return ret;
1058                 break;
1059         case V4L2_TUNER_ANALOG_TV:
1060                 xc5000_config_tv(fe, params);
1061                 break;
1062         default:
1063                 break;
1064         }
1065         priv->mode = params->mode;
1066
1067         return xc5000_set_params(fe);
1068 }
1069
1070 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1071 {
1072         struct xc5000_priv *priv = fe->tuner_priv;
1073         dprintk(1, "%s()\n", __func__);
1074         *freq = priv->freq_hz + priv->freq_offset;
1075         return 0;
1076 }
1077
1078 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1079 {
1080         struct xc5000_priv *priv = fe->tuner_priv;
1081         dprintk(1, "%s()\n", __func__);
1082         *freq = priv->if_khz * 1000;
1083         return 0;
1084 }
1085
1086 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1087 {
1088         struct xc5000_priv *priv = fe->tuner_priv;
1089         dprintk(1, "%s()\n", __func__);
1090
1091         *bw = priv->bandwidth;
1092         return 0;
1093 }
1094
1095 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1096 {
1097         struct xc5000_priv *priv = fe->tuner_priv;
1098         u16 lock_status = 0;
1099
1100         xc_get_lock_status(priv, &lock_status);
1101
1102         dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1103
1104         *status = lock_status;
1105
1106         return 0;
1107 }
1108
1109 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force)
1110 {
1111         struct xc5000_priv *priv = fe->tuner_priv;
1112         const struct xc5000_fw_cfg *desired_fw = xc5000_assign_firmware(priv->chip_id);
1113         const struct firmware *fw;
1114         int ret, i;
1115         u16 pll_lock_status;
1116         u16 fw_ck;
1117
1118         cancel_delayed_work(&priv->timer_sleep);
1119
1120         if (!force && xc5000_is_firmware_loaded(fe) == 0)
1121                 return 0;
1122
1123         if (!priv->firmware) {
1124                 ret = request_firmware(&fw, desired_fw->name,
1125                                         priv->i2c_props.adap->dev.parent);
1126                 if (ret) {
1127                         pr_err("xc5000: Upload failed. rc %d\n", ret);
1128                         return ret;
1129                 }
1130                 dprintk(1, "firmware read %zu bytes.\n", fw->size);
1131
1132                 if (fw->size != desired_fw->size) {
1133                         pr_err("xc5000: Firmware file with incorrect size\n");
1134                         release_firmware(fw);
1135                         return -EINVAL;
1136                 }
1137                 priv->firmware = fw;
1138         } else
1139                 fw = priv->firmware;
1140
1141         /* Try up to 5 times to load firmware */
1142         for (i = 0; i < 5; i++) {
1143                 if (i)
1144                         printk(KERN_CONT " - retrying to upload firmware.\n");
1145
1146                 ret = xc5000_fwupload(fe, desired_fw, fw);
1147                 if (ret != 0)
1148                         goto err;
1149
1150                 msleep(20);
1151
1152                 if (priv->fw_checksum_supported) {
1153                         if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck)) {
1154                                 printk(KERN_ERR
1155                                        "xc5000: FW checksum reading failed.");
1156                                 continue;
1157                         }
1158
1159                         if (!fw_ck) {
1160                                 printk(KERN_ERR
1161                                        "xc5000: FW checksum failed = 0x%04x.",
1162                                        fw_ck);
1163                                 continue;
1164                         }
1165                 }
1166
1167                 /* Start the tuner self-calibration process */
1168                 ret = xc_initialize(priv);
1169                 if (ret) {
1170                         printk(KERN_ERR "xc5000: Can't request self-calibration.");
1171                         continue;
1172                 }
1173
1174                 /* Wait for calibration to complete.
1175                  * We could continue but XC5000 will clock stretch subsequent
1176                  * I2C transactions until calibration is complete.  This way we
1177                  * don't have to rely on clock stretching working.
1178                  */
1179                 msleep(100);
1180
1181                 if (priv->init_status_supported) {
1182                         if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck)) {
1183                                 printk(KERN_ERR
1184                                        "xc5000: FW failed reading init status.");
1185                                 continue;
1186                         }
1187
1188                         if (!fw_ck) {
1189                                 printk(KERN_ERR
1190                                        "xc5000: FW init status failed = 0x%04x.",
1191                                        fw_ck);
1192                                 continue;
1193                         }
1194                 }
1195
1196                 if (priv->pll_register_no) {
1197                         ret = xc5000_readreg(priv, priv->pll_register_no,
1198                                              &pll_lock_status);
1199                         if (ret)
1200                                 continue;
1201                         if (pll_lock_status > 63) {
1202                                 /* PLL is unlocked, force reload of the firmware */
1203                                 printk(KERN_ERR
1204                                        "xc5000: PLL not running after fwload.");
1205                                 continue;
1206                         }
1207                 }
1208
1209                 /* Default to "CABLE" mode */
1210                 ret = xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1211                 if (!ret)
1212                         break;
1213                 printk(KERN_ERR "xc5000: can't set to cable mode.");
1214         }
1215
1216 err:
1217         if (!ret)
1218                 printk(KERN_INFO "xc5000: Firmware %s loaded and running.\n",
1219                        desired_fw->name);
1220         else
1221                 printk(KERN_CONT " - too many retries. Giving up\n");
1222
1223         return ret;
1224 }
1225
1226 static void xc5000_do_timer_sleep(struct work_struct *timer_sleep)
1227 {
1228         struct xc5000_priv *priv =container_of(timer_sleep, struct xc5000_priv,
1229                                                timer_sleep.work);
1230         struct dvb_frontend *fe = priv->fe;
1231         int ret;
1232
1233         dprintk(1, "%s()\n", __func__);
1234
1235         /* According to Xceive technical support, the "powerdown" register
1236            was removed in newer versions of the firmware.  The "supported"
1237            way to sleep the tuner is to pull the reset pin low for 10ms */
1238         ret = xc5000_tuner_reset(fe);
1239         if (ret != 0)
1240                 printk(KERN_ERR
1241                         "xc5000: %s() unable to shutdown tuner\n",
1242                         __func__);
1243 }
1244
1245 static int xc5000_sleep(struct dvb_frontend *fe)
1246 {
1247         struct xc5000_priv *priv = fe->tuner_priv;
1248
1249         dprintk(1, "%s()\n", __func__);
1250
1251         /* Avoid firmware reload on slow devices */
1252         if (no_poweroff)
1253                 return 0;
1254
1255         schedule_delayed_work(&priv->timer_sleep,
1256                               msecs_to_jiffies(XC5000_SLEEP_TIME));
1257
1258         return 0;
1259 }
1260
1261 static int xc5000_suspend(struct dvb_frontend *fe)
1262 {
1263         struct xc5000_priv *priv = fe->tuner_priv;
1264         int ret;
1265
1266         dprintk(1, "%s()\n", __func__);
1267
1268         cancel_delayed_work(&priv->timer_sleep);
1269
1270         ret = xc5000_tuner_reset(fe);
1271         if (ret != 0)
1272                 printk(KERN_ERR
1273                         "xc5000: %s() unable to shutdown tuner\n",
1274                         __func__);
1275
1276         return 0;
1277 }
1278
1279 static int xc5000_resume(struct dvb_frontend *fe)
1280 {
1281         struct xc5000_priv *priv = fe->tuner_priv;
1282
1283         dprintk(1, "%s()\n", __func__);
1284
1285         /* suspended before firmware is loaded.
1286            Avoid firmware load in resume path. */
1287         if (!priv->firmware)
1288                 return 0;
1289
1290         return xc5000_set_params(fe);
1291 }
1292
1293 static int xc5000_init(struct dvb_frontend *fe)
1294 {
1295         struct xc5000_priv *priv = fe->tuner_priv;
1296         dprintk(1, "%s()\n", __func__);
1297
1298         if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1299                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1300                 return -EREMOTEIO;
1301         }
1302
1303         if (debug)
1304                 xc_debug_dump(priv);
1305
1306         return 0;
1307 }
1308
1309 static void xc5000_release(struct dvb_frontend *fe)
1310 {
1311         struct xc5000_priv *priv = fe->tuner_priv;
1312
1313         dprintk(1, "%s()\n", __func__);
1314
1315         mutex_lock(&xc5000_list_mutex);
1316
1317         if (priv) {
1318                 cancel_delayed_work(&priv->timer_sleep);
1319                 if (priv->firmware) {
1320                         release_firmware(priv->firmware);
1321                         priv->firmware = NULL;
1322                 }
1323                 hybrid_tuner_release_state(priv);
1324         }
1325
1326         mutex_unlock(&xc5000_list_mutex);
1327
1328         fe->tuner_priv = NULL;
1329 }
1330
1331 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1332 {
1333         struct xc5000_priv *priv = fe->tuner_priv;
1334         struct xc5000_config *p = priv_cfg;
1335
1336         dprintk(1, "%s()\n", __func__);
1337
1338         if (p->if_khz)
1339                 priv->if_khz = p->if_khz;
1340
1341         if (p->radio_input)
1342                 priv->radio_input = p->radio_input;
1343
1344         if (p->output_amp)
1345                 priv->output_amp = p->output_amp;
1346
1347         return 0;
1348 }
1349
1350
1351 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1352         .info = {
1353                 .name              = "Xceive XC5000",
1354                 .frequency_min_hz  =    1 * MHz,
1355                 .frequency_max_hz  = 1023 * MHz,
1356                 .frequency_step_hz =   50 * kHz,
1357         },
1358
1359         .release           = xc5000_release,
1360         .init              = xc5000_init,
1361         .sleep             = xc5000_sleep,
1362         .suspend           = xc5000_suspend,
1363         .resume            = xc5000_resume,
1364
1365         .set_config        = xc5000_set_config,
1366         .set_params        = xc5000_set_digital_params,
1367         .set_analog_params = xc5000_set_analog_params,
1368         .get_frequency     = xc5000_get_frequency,
1369         .get_if_frequency  = xc5000_get_if_frequency,
1370         .get_bandwidth     = xc5000_get_bandwidth,
1371         .get_status        = xc5000_get_status
1372 };
1373
1374 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1375                                    struct i2c_adapter *i2c,
1376                                    const struct xc5000_config *cfg)
1377 {
1378         struct xc5000_priv *priv = NULL;
1379         int instance;
1380         u16 id = 0;
1381
1382         dprintk(1, "%s(%d-%04x)\n", __func__,
1383                 i2c ? i2c_adapter_id(i2c) : -1,
1384                 cfg ? cfg->i2c_address : -1);
1385
1386         mutex_lock(&xc5000_list_mutex);
1387
1388         instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1389                                               hybrid_tuner_instance_list,
1390                                               i2c, cfg->i2c_address, "xc5000");
1391         switch (instance) {
1392         case 0:
1393                 goto fail;
1394         case 1:
1395                 /* new tuner instance */
1396                 priv->bandwidth = 6000000;
1397                 fe->tuner_priv = priv;
1398                 priv->fe = fe;
1399                 INIT_DELAYED_WORK(&priv->timer_sleep, xc5000_do_timer_sleep);
1400                 break;
1401         default:
1402                 /* existing tuner instance */
1403                 fe->tuner_priv = priv;
1404                 break;
1405         }
1406
1407         if (priv->if_khz == 0) {
1408                 /* If the IF hasn't been set yet, use the value provided by
1409                    the caller (occurs in hybrid devices where the analog
1410                    call to xc5000_attach occurs before the digital side) */
1411                 priv->if_khz = cfg->if_khz;
1412         }
1413
1414         if (priv->xtal_khz == 0)
1415                 priv->xtal_khz = cfg->xtal_khz;
1416
1417         if (priv->radio_input == 0)
1418                 priv->radio_input = cfg->radio_input;
1419
1420         /* don't override chip id if it's already been set
1421            unless explicitly specified */
1422         if ((priv->chip_id == 0) || (cfg->chip_id))
1423                 /* use default chip id if none specified, set to 0 so
1424                    it can be overridden if this is a hybrid driver */
1425                 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1426
1427         /* don't override output_amp if it's already been set
1428            unless explicitly specified */
1429         if ((priv->output_amp == 0) || (cfg->output_amp))
1430                 /* use default output_amp value if none specified */
1431                 priv->output_amp = (cfg->output_amp) ? cfg->output_amp : 0x8a;
1432
1433         /* Check if firmware has been loaded. It is possible that another
1434            instance of the driver has loaded the firmware.
1435          */
1436         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1437                 goto fail;
1438
1439         switch (id) {
1440         case XC_PRODUCT_ID_FW_LOADED:
1441                 printk(KERN_INFO
1442                         "xc5000: Successfully identified at address 0x%02x\n",
1443                         cfg->i2c_address);
1444                 printk(KERN_INFO
1445                         "xc5000: Firmware has been loaded previously\n");
1446                 break;
1447         case XC_PRODUCT_ID_FW_NOT_LOADED:
1448                 printk(KERN_INFO
1449                         "xc5000: Successfully identified at address 0x%02x\n",
1450                         cfg->i2c_address);
1451                 printk(KERN_INFO
1452                         "xc5000: Firmware has not been loaded previously\n");
1453                 break;
1454         default:
1455                 printk(KERN_ERR
1456                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1457                         cfg->i2c_address, id);
1458                 goto fail;
1459         }
1460
1461         mutex_unlock(&xc5000_list_mutex);
1462
1463         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1464                 sizeof(struct dvb_tuner_ops));
1465
1466         return fe;
1467 fail:
1468         mutex_unlock(&xc5000_list_mutex);
1469
1470         xc5000_release(fe);
1471         return NULL;
1472 }
1473 EXPORT_SYMBOL(xc5000_attach);
1474
1475 MODULE_AUTHOR("Steven Toth");
1476 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1477 MODULE_LICENSE("GPL");
1478 MODULE_FIRMWARE(XC5000A_FIRMWARE);
1479 MODULE_FIRMWARE(XC5000C_FIRMWARE);