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