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