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