1 /* 2 * Driver for Xceive XC5000 "QAM/8VSB single chip tuner" 3 * 4 * Copyright (c) 2007 Xceive Corporation 5 * Copyright (c) 2007 Steven Toth <stoth@linuxtv.org> 6 * Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 */ 23 24 #include <linux/module.h> 25 #include <linux/moduleparam.h> 26 #include <linux/videodev2.h> 27 #include <linux/delay.h> 28 #include <linux/workqueue.h> 29 #include <linux/dvb/frontend.h> 30 #include <linux/i2c.h> 31 32 #include "dvb_frontend.h" 33 34 #include "xc5000.h" 35 #include "tuner-i2c.h" 36 37 static int debug; 38 module_param(debug, int, 0644); 39 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); 40 41 static int no_poweroff; 42 module_param(no_poweroff, int, 0644); 43 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n" 44 "\t\t1 keep device energized and with tuner ready all the times.\n" 45 "\t\tFaster, but consumes more power and keeps the device hotter"); 46 47 static DEFINE_MUTEX(xc5000_list_mutex); 48 static LIST_HEAD(hybrid_tuner_instance_list); 49 50 #define dprintk(level, fmt, arg...) if (debug >= level) \ 51 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg) 52 53 struct xc5000_priv { 54 struct tuner_i2c_props i2c_props; 55 struct list_head hybrid_tuner_instance_list; 56 57 u32 if_khz; 58 u16 xtal_khz; 59 u32 freq_hz; 60 u32 bandwidth; 61 u8 video_standard; 62 u8 rf_mode; 63 u8 radio_input; 64 65 int chip_id; 66 u16 pll_register_no; 67 u8 init_status_supported; 68 u8 fw_checksum_supported; 69 70 struct dvb_frontend *fe; 71 struct delayed_work timer_sleep; 72 }; 73 74 /* Misc Defines */ 75 #define MAX_TV_STANDARD 24 76 #define XC_MAX_I2C_WRITE_LENGTH 64 77 78 /* Time to suspend after the .sleep callback is called */ 79 #define XC5000_SLEEP_TIME 5000 /* ms */ 80 81 /* Signal Types */ 82 #define XC_RF_MODE_AIR 0 83 #define XC_RF_MODE_CABLE 1 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 audio_mode; 157 u16 video_mode; 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_tuner_reset(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 -EREMOTEIO; 262 } 263 return 0; 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 0; 301 } 302 303 static int xc5000_tuner_reset(struct dvb_frontend *fe) 304 { 305 struct xc5000_priv *priv = fe->tuner_priv; 306 int ret; 307 308 dprintk(1, "%s()\n", __func__); 309 310 if (fe->callback) { 311 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ? 312 fe->dvb->priv : 313 priv->i2c_props.adap->algo_data, 314 DVB_FRONTEND_COMPONENT_TUNER, 315 XC5000_TUNER_RESET, 0); 316 if (ret) { 317 printk(KERN_ERR "xc5000: reset failed\n"); 318 return ret; 319 } 320 } else { 321 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n"); 322 return -EINVAL; 323 } 324 return 0; 325 } 326 327 static int xc_write_reg(struct xc5000_priv *priv, u16 reg_addr, u16 i2c_data) 328 { 329 u8 buf[4]; 330 int watch_dog_timer = 100; 331 int result; 332 333 buf[0] = (reg_addr >> 8) & 0xFF; 334 buf[1] = reg_addr & 0xFF; 335 buf[2] = (i2c_data >> 8) & 0xFF; 336 buf[3] = i2c_data & 0xFF; 337 result = xc_send_i2c_data(priv, buf, 4); 338 if (result == 0) { 339 /* wait for busy flag to clear */ 340 while ((watch_dog_timer > 0) && (result == 0)) { 341 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf); 342 if (result == 0) { 343 if ((buf[0] == 0) && (buf[1] == 0)) { 344 /* busy flag cleared */ 345 break; 346 } else { 347 msleep(5); /* wait 5 ms */ 348 watch_dog_timer--; 349 } 350 } 351 } 352 } 353 if (watch_dog_timer <= 0) 354 result = -EREMOTEIO; 355 356 return result; 357 } 358 359 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence) 360 { 361 struct xc5000_priv *priv = fe->tuner_priv; 362 363 int i, nbytes_to_send, result; 364 unsigned int len, pos, index; 365 u8 buf[XC_MAX_I2C_WRITE_LENGTH]; 366 367 index = 0; 368 while ((i2c_sequence[index] != 0xFF) || 369 (i2c_sequence[index + 1] != 0xFF)) { 370 len = i2c_sequence[index] * 256 + i2c_sequence[index+1]; 371 if (len == 0x0000) { 372 /* RESET command */ 373 result = xc5000_tuner_reset(fe); 374 index += 2; 375 if (result != 0) 376 return result; 377 } else if (len & 0x8000) { 378 /* WAIT command */ 379 msleep(len & 0x7FFF); 380 index += 2; 381 } else { 382 /* Send i2c data whilst ensuring individual transactions 383 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes. 384 */ 385 index += 2; 386 buf[0] = i2c_sequence[index]; 387 buf[1] = i2c_sequence[index + 1]; 388 pos = 2; 389 while (pos < len) { 390 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2) 391 nbytes_to_send = 392 XC_MAX_I2C_WRITE_LENGTH; 393 else 394 nbytes_to_send = (len - pos + 2); 395 for (i = 2; i < nbytes_to_send; i++) { 396 buf[i] = i2c_sequence[index + pos + 397 i - 2]; 398 } 399 result = xc_send_i2c_data(priv, buf, 400 nbytes_to_send); 401 402 if (result != 0) 403 return result; 404 405 pos += nbytes_to_send - 2; 406 } 407 index += len; 408 } 409 } 410 return 0; 411 } 412 413 static int xc_initialize(struct xc5000_priv *priv) 414 { 415 dprintk(1, "%s()\n", __func__); 416 return xc_write_reg(priv, XREG_INIT, 0); 417 } 418 419 static int xc_set_tv_standard(struct xc5000_priv *priv, 420 u16 video_mode, u16 audio_mode, u8 radio_mode) 421 { 422 int ret; 423 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode); 424 if (radio_mode) { 425 dprintk(1, "%s() Standard = %s\n", 426 __func__, 427 xc5000_standard[radio_mode].name); 428 } else { 429 dprintk(1, "%s() Standard = %s\n", 430 __func__, 431 xc5000_standard[priv->video_standard].name); 432 } 433 434 ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode); 435 if (ret == 0) 436 ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode); 437 438 return ret; 439 } 440 441 static int xc_set_signal_source(struct xc5000_priv *priv, u16 rf_mode) 442 { 443 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode, 444 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE"); 445 446 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) { 447 rf_mode = XC_RF_MODE_CABLE; 448 printk(KERN_ERR 449 "%s(), Invalid mode, defaulting to CABLE", 450 __func__); 451 } 452 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode); 453 } 454 455 static const struct dvb_tuner_ops xc5000_tuner_ops; 456 457 static int xc_set_rf_frequency(struct xc5000_priv *priv, u32 freq_hz) 458 { 459 u16 freq_code; 460 461 dprintk(1, "%s(%u)\n", __func__, freq_hz); 462 463 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) || 464 (freq_hz < xc5000_tuner_ops.info.frequency_min)) 465 return -EINVAL; 466 467 freq_code = (u16)(freq_hz / 15625); 468 469 /* Starting in firmware version 1.1.44, Xceive recommends using the 470 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should 471 only be used for fast scanning for channel lock) */ 472 return xc_write_reg(priv, XREG_FINERFREQ, freq_code); 473 } 474 475 476 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz) 477 { 478 u32 freq_code = (freq_khz * 1024)/1000; 479 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n", 480 __func__, freq_khz, freq_code); 481 482 return xc_write_reg(priv, XREG_IF_OUT, freq_code); 483 } 484 485 486 static int xc_get_adc_envelope(struct xc5000_priv *priv, u16 *adc_envelope) 487 { 488 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope); 489 } 490 491 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz) 492 { 493 int result; 494 u16 reg_data; 495 u32 tmp; 496 497 result = xc5000_readreg(priv, XREG_FREQ_ERROR, ®_data); 498 if (result != 0) 499 return result; 500 501 tmp = (u32)reg_data; 502 (*freq_error_hz) = (tmp * 15625) / 1000; 503 return result; 504 } 505 506 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status) 507 { 508 return xc5000_readreg(priv, XREG_LOCK, lock_status); 509 } 510 511 static int xc_get_version(struct xc5000_priv *priv, 512 u8 *hw_majorversion, u8 *hw_minorversion, 513 u8 *fw_majorversion, u8 *fw_minorversion) 514 { 515 u16 data; 516 int result; 517 518 result = xc5000_readreg(priv, XREG_VERSION, &data); 519 if (result != 0) 520 return result; 521 522 (*hw_majorversion) = (data >> 12) & 0x0F; 523 (*hw_minorversion) = (data >> 8) & 0x0F; 524 (*fw_majorversion) = (data >> 4) & 0x0F; 525 (*fw_minorversion) = data & 0x0F; 526 527 return 0; 528 } 529 530 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev) 531 { 532 return xc5000_readreg(priv, XREG_BUILD, buildrev); 533 } 534 535 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz) 536 { 537 u16 reg_data; 538 int result; 539 540 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, ®_data); 541 if (result != 0) 542 return result; 543 544 (*hsync_freq_hz) = ((reg_data & 0x0fff) * 763)/100; 545 return result; 546 } 547 548 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines) 549 { 550 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines); 551 } 552 553 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality) 554 { 555 return xc5000_readreg(priv, XREG_QUALITY, quality); 556 } 557 558 static int xc_get_analogsnr(struct xc5000_priv *priv, u16 *snr) 559 { 560 return xc5000_readreg(priv, XREG_SNR, snr); 561 } 562 563 static int xc_get_totalgain(struct xc5000_priv *priv, u16 *totalgain) 564 { 565 return xc5000_readreg(priv, XREG_TOTALGAIN, totalgain); 566 } 567 568 static u16 wait_for_lock(struct xc5000_priv *priv) 569 { 570 u16 lock_state = 0; 571 int watch_dog_count = 40; 572 573 while ((lock_state == 0) && (watch_dog_count > 0)) { 574 xc_get_lock_status(priv, &lock_state); 575 if (lock_state != 1) { 576 msleep(5); 577 watch_dog_count--; 578 } 579 } 580 return lock_state; 581 } 582 583 #define XC_TUNE_ANALOG 0 584 #define XC_TUNE_DIGITAL 1 585 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode) 586 { 587 int found = 0; 588 589 dprintk(1, "%s(%u)\n", __func__, freq_hz); 590 591 if (xc_set_rf_frequency(priv, freq_hz) != 0) 592 return 0; 593 594 if (mode == XC_TUNE_ANALOG) { 595 if (wait_for_lock(priv) == 1) 596 found = 1; 597 } 598 599 return found; 600 } 601 602 static int xc_set_xtal(struct dvb_frontend *fe) 603 { 604 struct xc5000_priv *priv = fe->tuner_priv; 605 int ret = 0; 606 607 switch (priv->chip_id) { 608 default: 609 case XC5000A: 610 /* 32.000 MHz xtal is default */ 611 break; 612 case XC5000C: 613 switch (priv->xtal_khz) { 614 default: 615 case 32000: 616 /* 32.000 MHz xtal is default */ 617 break; 618 case 31875: 619 /* 31.875 MHz xtal configuration */ 620 ret = xc_write_reg(priv, 0x000f, 0x8081); 621 break; 622 } 623 break; 624 } 625 return ret; 626 } 627 628 static int xc5000_fwupload(struct dvb_frontend *fe) 629 { 630 struct xc5000_priv *priv = fe->tuner_priv; 631 const struct firmware *fw; 632 int ret; 633 const struct xc5000_fw_cfg *desired_fw = 634 xc5000_assign_firmware(priv->chip_id); 635 priv->pll_register_no = desired_fw->pll_reg; 636 priv->init_status_supported = desired_fw->init_status_supported; 637 priv->fw_checksum_supported = desired_fw->fw_checksum_supported; 638 639 /* request the firmware, this will block and timeout */ 640 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n", 641 desired_fw->name); 642 643 ret = request_firmware(&fw, desired_fw->name, 644 priv->i2c_props.adap->dev.parent); 645 if (ret) { 646 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n"); 647 goto out; 648 } else { 649 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n", 650 fw->size); 651 ret = 0; 652 } 653 654 if (fw->size != desired_fw->size) { 655 printk(KERN_ERR "xc5000: firmware incorrect size\n"); 656 ret = -EINVAL; 657 } else { 658 printk(KERN_INFO "xc5000: firmware uploading...\n"); 659 ret = xc_load_i2c_sequence(fe, fw->data); 660 if (0 == ret) 661 ret = xc_set_xtal(fe); 662 if (0 == 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 msleep(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) != 0) { 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 break; 789 case SYS_DVBC_ANNEX_A: 790 case SYS_DVBC_ANNEX_C: 791 dprintk(1, "%s() QAM modulation\n", __func__); 792 priv->rf_mode = XC_RF_MODE_CABLE; 793 if (bw <= 6000000) { 794 priv->video_standard = DTV6; 795 priv->freq_hz = freq - 1750000; 796 b = 6; 797 } else if (bw <= 7000000) { 798 priv->video_standard = DTV7; 799 priv->freq_hz = freq - 2250000; 800 b = 7; 801 } else { 802 priv->video_standard = DTV7_8; 803 priv->freq_hz = freq - 2750000; 804 b = 8; 805 } 806 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__, 807 b, bw); 808 break; 809 default: 810 printk(KERN_ERR "xc5000: delivery system is not supported!\n"); 811 return -EINVAL; 812 } 813 814 dprintk(1, "%s() frequency=%d (compensated to %d)\n", 815 __func__, freq, priv->freq_hz); 816 817 ret = xc_set_signal_source(priv, priv->rf_mode); 818 if (ret != 0) { 819 printk(KERN_ERR 820 "xc5000: xc_set_signal_source(%d) failed\n", 821 priv->rf_mode); 822 return -EREMOTEIO; 823 } 824 825 ret = xc_set_tv_standard(priv, 826 xc5000_standard[priv->video_standard].video_mode, 827 xc5000_standard[priv->video_standard].audio_mode, 0); 828 if (ret != 0) { 829 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n"); 830 return -EREMOTEIO; 831 } 832 833 ret = xc_set_IF_frequency(priv, priv->if_khz); 834 if (ret != 0) { 835 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n", 836 priv->if_khz); 837 return -EIO; 838 } 839 840 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a); 841 842 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL); 843 844 if (debug) 845 xc_debug_dump(priv); 846 847 priv->bandwidth = bw; 848 849 return 0; 850 } 851 852 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe) 853 { 854 struct xc5000_priv *priv = fe->tuner_priv; 855 int ret; 856 u16 id; 857 858 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id); 859 if (ret == 0) { 860 if (id == XC_PRODUCT_ID_FW_NOT_LOADED) 861 ret = -ENOENT; 862 else 863 ret = 0; 864 } 865 866 dprintk(1, "%s() returns %s id = 0x%x\n", __func__, 867 ret == 0 ? "True" : "False", id); 868 return ret; 869 } 870 871 static int xc5000_set_tv_freq(struct dvb_frontend *fe, 872 struct analog_parameters *params) 873 { 874 struct xc5000_priv *priv = fe->tuner_priv; 875 u16 pll_lock_status; 876 int ret; 877 878 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n", 879 __func__, params->frequency); 880 881 /* Fix me: it could be air. */ 882 priv->rf_mode = params->mode; 883 if (params->mode > XC_RF_MODE_CABLE) 884 priv->rf_mode = XC_RF_MODE_CABLE; 885 886 /* params->frequency is in units of 62.5khz */ 887 priv->freq_hz = params->frequency * 62500; 888 889 /* FIX ME: Some video standards may have several possible audio 890 standards. We simply default to one of them here. 891 */ 892 if (params->std & V4L2_STD_MN) { 893 /* default to BTSC audio standard */ 894 priv->video_standard = MN_NTSC_PAL_BTSC; 895 goto tune_channel; 896 } 897 898 if (params->std & V4L2_STD_PAL_BG) { 899 /* default to NICAM audio standard */ 900 priv->video_standard = BG_PAL_NICAM; 901 goto tune_channel; 902 } 903 904 if (params->std & V4L2_STD_PAL_I) { 905 /* default to NICAM audio standard */ 906 priv->video_standard = I_PAL_NICAM; 907 goto tune_channel; 908 } 909 910 if (params->std & V4L2_STD_PAL_DK) { 911 /* default to NICAM audio standard */ 912 priv->video_standard = DK_PAL_NICAM; 913 goto tune_channel; 914 } 915 916 if (params->std & V4L2_STD_SECAM_DK) { 917 /* default to A2 DK1 audio standard */ 918 priv->video_standard = DK_SECAM_A2DK1; 919 goto tune_channel; 920 } 921 922 if (params->std & V4L2_STD_SECAM_L) { 923 priv->video_standard = L_SECAM_NICAM; 924 goto tune_channel; 925 } 926 927 if (params->std & V4L2_STD_SECAM_LC) { 928 priv->video_standard = LC_SECAM_NICAM; 929 goto tune_channel; 930 } 931 932 tune_channel: 933 ret = xc_set_signal_source(priv, priv->rf_mode); 934 if (ret != 0) { 935 printk(KERN_ERR 936 "xc5000: xc_set_signal_source(%d) failed\n", 937 priv->rf_mode); 938 return -EREMOTEIO; 939 } 940 941 ret = xc_set_tv_standard(priv, 942 xc5000_standard[priv->video_standard].video_mode, 943 xc5000_standard[priv->video_standard].audio_mode, 0); 944 if (ret != 0) { 945 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n"); 946 return -EREMOTEIO; 947 } 948 949 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09); 950 951 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG); 952 953 if (debug) 954 xc_debug_dump(priv); 955 956 if (priv->pll_register_no != 0) { 957 msleep(20); 958 xc5000_readreg(priv, priv->pll_register_no, &pll_lock_status); 959 if (pll_lock_status > 63) { 960 /* PLL is unlocked, force reload of the firmware */ 961 dprintk(1, "xc5000: PLL not locked (0x%x). Reloading...\n", 962 pll_lock_status); 963 if (xc_load_fw_and_init_tuner(fe, 1) != 0) { 964 printk(KERN_ERR "xc5000: Unable to reload fw\n"); 965 return -EREMOTEIO; 966 } 967 goto tune_channel; 968 } 969 } 970 971 return 0; 972 } 973 974 static int xc5000_set_radio_freq(struct dvb_frontend *fe, 975 struct analog_parameters *params) 976 { 977 struct xc5000_priv *priv = fe->tuner_priv; 978 int ret = -EINVAL; 979 u8 radio_input; 980 981 dprintk(1, "%s() frequency=%d (in units of khz)\n", 982 __func__, params->frequency); 983 984 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) { 985 dprintk(1, "%s() radio input not configured\n", __func__); 986 return -EINVAL; 987 } 988 989 if (priv->radio_input == XC5000_RADIO_FM1) 990 radio_input = FM_RADIO_INPUT1; 991 else if (priv->radio_input == XC5000_RADIO_FM2) 992 radio_input = FM_RADIO_INPUT2; 993 else if (priv->radio_input == XC5000_RADIO_FM1_MONO) 994 radio_input = FM_RADIO_INPUT1_MONO; 995 else { 996 dprintk(1, "%s() unknown radio input %d\n", __func__, 997 priv->radio_input); 998 return -EINVAL; 999 } 1000 1001 priv->freq_hz = params->frequency * 125 / 2; 1002 1003 priv->rf_mode = XC_RF_MODE_AIR; 1004 1005 ret = xc_set_tv_standard(priv, xc5000_standard[radio_input].video_mode, 1006 xc5000_standard[radio_input].audio_mode, radio_input); 1007 1008 if (ret != 0) { 1009 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n"); 1010 return -EREMOTEIO; 1011 } 1012 1013 ret = xc_set_signal_source(priv, priv->rf_mode); 1014 if (ret != 0) { 1015 printk(KERN_ERR 1016 "xc5000: xc_set_signal_source(%d) failed\n", 1017 priv->rf_mode); 1018 return -EREMOTEIO; 1019 } 1020 1021 if ((priv->radio_input == XC5000_RADIO_FM1) || 1022 (priv->radio_input == XC5000_RADIO_FM2)) 1023 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09); 1024 else if (priv->radio_input == XC5000_RADIO_FM1_MONO) 1025 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06); 1026 1027 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG); 1028 1029 return 0; 1030 } 1031 1032 static int xc5000_set_analog_params(struct dvb_frontend *fe, 1033 struct analog_parameters *params) 1034 { 1035 struct xc5000_priv *priv = fe->tuner_priv; 1036 int ret = -EINVAL; 1037 1038 if (priv->i2c_props.adap == NULL) 1039 return -EINVAL; 1040 1041 if (xc_load_fw_and_init_tuner(fe, 0) != 0) { 1042 dprintk(1, "Unable to load firmware and init tuner\n"); 1043 return -EINVAL; 1044 } 1045 1046 switch (params->mode) { 1047 case V4L2_TUNER_RADIO: 1048 ret = xc5000_set_radio_freq(fe, params); 1049 break; 1050 case V4L2_TUNER_ANALOG_TV: 1051 case V4L2_TUNER_DIGITAL_TV: 1052 ret = xc5000_set_tv_freq(fe, params); 1053 break; 1054 } 1055 1056 return ret; 1057 } 1058 1059 1060 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq) 1061 { 1062 struct xc5000_priv *priv = fe->tuner_priv; 1063 dprintk(1, "%s()\n", __func__); 1064 *freq = priv->freq_hz; 1065 return 0; 1066 } 1067 1068 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq) 1069 { 1070 struct xc5000_priv *priv = fe->tuner_priv; 1071 dprintk(1, "%s()\n", __func__); 1072 *freq = priv->if_khz * 1000; 1073 return 0; 1074 } 1075 1076 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw) 1077 { 1078 struct xc5000_priv *priv = fe->tuner_priv; 1079 dprintk(1, "%s()\n", __func__); 1080 1081 *bw = priv->bandwidth; 1082 return 0; 1083 } 1084 1085 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status) 1086 { 1087 struct xc5000_priv *priv = fe->tuner_priv; 1088 u16 lock_status = 0; 1089 1090 xc_get_lock_status(priv, &lock_status); 1091 1092 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status); 1093 1094 *status = lock_status; 1095 1096 return 0; 1097 } 1098 1099 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force) 1100 { 1101 struct xc5000_priv *priv = fe->tuner_priv; 1102 int ret = 0; 1103 u16 pll_lock_status; 1104 u16 fw_ck; 1105 1106 cancel_delayed_work(&priv->timer_sleep); 1107 1108 if (force || xc5000_is_firmware_loaded(fe) != 0) { 1109 1110 fw_retry: 1111 1112 ret = xc5000_fwupload(fe); 1113 if (ret != 0) 1114 return ret; 1115 1116 msleep(20); 1117 1118 if (priv->fw_checksum_supported) { 1119 if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck) 1120 != 0) { 1121 dprintk(1, "%s() FW checksum reading failed.\n", 1122 __func__); 1123 goto fw_retry; 1124 } 1125 1126 if (fw_ck == 0) { 1127 dprintk(1, "%s() FW checksum failed = 0x%04x\n", 1128 __func__, fw_ck); 1129 goto fw_retry; 1130 } 1131 } 1132 1133 /* Start the tuner self-calibration process */ 1134 ret |= xc_initialize(priv); 1135 1136 if (ret != 0) 1137 goto fw_retry; 1138 1139 /* Wait for calibration to complete. 1140 * We could continue but XC5000 will clock stretch subsequent 1141 * I2C transactions until calibration is complete. This way we 1142 * don't have to rely on clock stretching working. 1143 */ 1144 msleep(100); 1145 1146 if (priv->init_status_supported) { 1147 if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck) != 0) { 1148 dprintk(1, "%s() FW failed reading init status.\n", 1149 __func__); 1150 goto fw_retry; 1151 } 1152 1153 if (fw_ck == 0) { 1154 dprintk(1, "%s() FW init status failed = 0x%04x\n", __func__, fw_ck); 1155 goto fw_retry; 1156 } 1157 } 1158 1159 if (priv->pll_register_no) { 1160 xc5000_readreg(priv, priv->pll_register_no, 1161 &pll_lock_status); 1162 if (pll_lock_status > 63) { 1163 /* PLL is unlocked, force reload of the firmware */ 1164 printk(KERN_ERR "xc5000: PLL not running after fwload.\n"); 1165 goto fw_retry; 1166 } 1167 } 1168 1169 /* Default to "CABLE" mode */ 1170 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE); 1171 } 1172 1173 return ret; 1174 } 1175 1176 static void xc5000_do_timer_sleep(struct work_struct *timer_sleep) 1177 { 1178 struct xc5000_priv *priv =container_of(timer_sleep, struct xc5000_priv, 1179 timer_sleep.work); 1180 struct dvb_frontend *fe = priv->fe; 1181 int ret; 1182 1183 dprintk(1, "%s()\n", __func__); 1184 1185 /* According to Xceive technical support, the "powerdown" register 1186 was removed in newer versions of the firmware. The "supported" 1187 way to sleep the tuner is to pull the reset pin low for 10ms */ 1188 ret = xc5000_tuner_reset(fe); 1189 if (ret != 0) 1190 printk(KERN_ERR 1191 "xc5000: %s() unable to shutdown tuner\n", 1192 __func__); 1193 } 1194 1195 static int xc5000_sleep(struct dvb_frontend *fe) 1196 { 1197 struct xc5000_priv *priv = fe->tuner_priv; 1198 1199 dprintk(1, "%s()\n", __func__); 1200 1201 /* Avoid firmware reload on slow devices */ 1202 if (no_poweroff) 1203 return 0; 1204 1205 schedule_delayed_work(&priv->timer_sleep, 1206 msecs_to_jiffies(XC5000_SLEEP_TIME)); 1207 1208 return 0; 1209 } 1210 1211 static int xc5000_init(struct dvb_frontend *fe) 1212 { 1213 struct xc5000_priv *priv = fe->tuner_priv; 1214 dprintk(1, "%s()\n", __func__); 1215 1216 if (xc_load_fw_and_init_tuner(fe, 0) != 0) { 1217 printk(KERN_ERR "xc5000: Unable to initialise tuner\n"); 1218 return -EREMOTEIO; 1219 } 1220 1221 if (debug) 1222 xc_debug_dump(priv); 1223 1224 return 0; 1225 } 1226 1227 static int xc5000_release(struct dvb_frontend *fe) 1228 { 1229 struct xc5000_priv *priv = fe->tuner_priv; 1230 1231 dprintk(1, "%s()\n", __func__); 1232 1233 mutex_lock(&xc5000_list_mutex); 1234 1235 if (priv) { 1236 cancel_delayed_work(&priv->timer_sleep); 1237 hybrid_tuner_release_state(priv); 1238 } 1239 1240 mutex_unlock(&xc5000_list_mutex); 1241 1242 fe->tuner_priv = NULL; 1243 1244 return 0; 1245 } 1246 1247 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg) 1248 { 1249 struct xc5000_priv *priv = fe->tuner_priv; 1250 struct xc5000_config *p = priv_cfg; 1251 1252 dprintk(1, "%s()\n", __func__); 1253 1254 if (p->if_khz) 1255 priv->if_khz = p->if_khz; 1256 1257 if (p->radio_input) 1258 priv->radio_input = p->radio_input; 1259 1260 return 0; 1261 } 1262 1263 1264 static const struct dvb_tuner_ops xc5000_tuner_ops = { 1265 .info = { 1266 .name = "Xceive XC5000", 1267 .frequency_min = 1000000, 1268 .frequency_max = 1023000000, 1269 .frequency_step = 50000, 1270 }, 1271 1272 .release = xc5000_release, 1273 .init = xc5000_init, 1274 .sleep = xc5000_sleep, 1275 1276 .set_config = xc5000_set_config, 1277 .set_params = xc5000_set_params, 1278 .set_analog_params = xc5000_set_analog_params, 1279 .get_frequency = xc5000_get_frequency, 1280 .get_if_frequency = xc5000_get_if_frequency, 1281 .get_bandwidth = xc5000_get_bandwidth, 1282 .get_status = xc5000_get_status 1283 }; 1284 1285 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe, 1286 struct i2c_adapter *i2c, 1287 const struct xc5000_config *cfg) 1288 { 1289 struct xc5000_priv *priv = NULL; 1290 int instance; 1291 u16 id = 0; 1292 1293 dprintk(1, "%s(%d-%04x)\n", __func__, 1294 i2c ? i2c_adapter_id(i2c) : -1, 1295 cfg ? cfg->i2c_address : -1); 1296 1297 mutex_lock(&xc5000_list_mutex); 1298 1299 instance = hybrid_tuner_request_state(struct xc5000_priv, priv, 1300 hybrid_tuner_instance_list, 1301 i2c, cfg->i2c_address, "xc5000"); 1302 switch (instance) { 1303 case 0: 1304 goto fail; 1305 break; 1306 case 1: 1307 /* new tuner instance */ 1308 priv->bandwidth = 6000000; 1309 fe->tuner_priv = priv; 1310 priv->fe = fe; 1311 INIT_DELAYED_WORK(&priv->timer_sleep, xc5000_do_timer_sleep); 1312 break; 1313 default: 1314 /* existing tuner instance */ 1315 fe->tuner_priv = priv; 1316 break; 1317 } 1318 1319 if (priv->if_khz == 0) { 1320 /* If the IF hasn't been set yet, use the value provided by 1321 the caller (occurs in hybrid devices where the analog 1322 call to xc5000_attach occurs before the digital side) */ 1323 priv->if_khz = cfg->if_khz; 1324 } 1325 1326 if (priv->xtal_khz == 0) 1327 priv->xtal_khz = cfg->xtal_khz; 1328 1329 if (priv->radio_input == 0) 1330 priv->radio_input = cfg->radio_input; 1331 1332 /* don't override chip id if it's already been set 1333 unless explicitly specified */ 1334 if ((priv->chip_id == 0) || (cfg->chip_id)) 1335 /* use default chip id if none specified, set to 0 so 1336 it can be overridden if this is a hybrid driver */ 1337 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0; 1338 1339 /* Check if firmware has been loaded. It is possible that another 1340 instance of the driver has loaded the firmware. 1341 */ 1342 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0) 1343 goto fail; 1344 1345 switch (id) { 1346 case XC_PRODUCT_ID_FW_LOADED: 1347 printk(KERN_INFO 1348 "xc5000: Successfully identified at address 0x%02x\n", 1349 cfg->i2c_address); 1350 printk(KERN_INFO 1351 "xc5000: Firmware has been loaded previously\n"); 1352 break; 1353 case XC_PRODUCT_ID_FW_NOT_LOADED: 1354 printk(KERN_INFO 1355 "xc5000: Successfully identified at address 0x%02x\n", 1356 cfg->i2c_address); 1357 printk(KERN_INFO 1358 "xc5000: Firmware has not been loaded previously\n"); 1359 break; 1360 default: 1361 printk(KERN_ERR 1362 "xc5000: Device not found at addr 0x%02x (0x%x)\n", 1363 cfg->i2c_address, id); 1364 goto fail; 1365 } 1366 1367 mutex_unlock(&xc5000_list_mutex); 1368 1369 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops, 1370 sizeof(struct dvb_tuner_ops)); 1371 1372 return fe; 1373 fail: 1374 mutex_unlock(&xc5000_list_mutex); 1375 1376 xc5000_release(fe); 1377 return NULL; 1378 } 1379 EXPORT_SYMBOL(xc5000_attach); 1380 1381 MODULE_AUTHOR("Steven Toth"); 1382 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver"); 1383 MODULE_LICENSE("GPL"); 1384 MODULE_FIRMWARE(XC5000A_FIRMWARE); 1385 MODULE_FIRMWARE(XC5000C_FIRMWARE); 1386