drivers/media/tuners/xc5000.c

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