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