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