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 20 #include <linux/module.h> 21 #include <linux/moduleparam.h> 22 #include <linux/videodev2.h> 23 #include <linux/delay.h> 24 #include <linux/workqueue.h> 25 #include <linux/dvb/frontend.h> 26 #include <linux/i2c.h> 27 28 #include "dvb_frontend.h" 29 30 #include "xc5000.h" 31 #include "tuner-i2c.h" 32 33 static int debug; 34 module_param(debug, int, 0644); 35 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); 36 37 static int no_poweroff; 38 module_param(no_poweroff, int, 0644); 39 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n" 40 "\t\t1 keep device energized and with tuner ready all the times.\n" 41 "\t\tFaster, but consumes more power and keeps the device hotter"); 42 43 static DEFINE_MUTEX(xc5000_list_mutex); 44 static LIST_HEAD(hybrid_tuner_instance_list); 45 46 #define dprintk(level, fmt, arg...) if (debug >= level) \ 47 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg) 48 49 struct xc5000_priv { 50 struct tuner_i2c_props i2c_props; 51 struct list_head hybrid_tuner_instance_list; 52 53 u32 if_khz; 54 u16 xtal_khz; 55 u32 freq_hz, freq_offset; 56 u32 bandwidth; 57 u8 video_standard; 58 unsigned int mode; 59 u8 rf_mode; 60 u8 radio_input; 61 u16 output_amp; 62 63 int chip_id; 64 u16 pll_register_no; 65 u8 init_status_supported; 66 u8 fw_checksum_supported; 67 68 struct dvb_frontend *fe; 69 struct delayed_work timer_sleep; 70 71 const struct firmware *firmware; 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 const struct xc5000_fw_cfg *desired_fw, 630 const struct firmware *fw) 631 { 632 struct xc5000_priv *priv = fe->tuner_priv; 633 int ret; 634 635 /* request the firmware, this will block and timeout */ 636 dprintk(1, "waiting for firmware upload (%s)...\n", 637 desired_fw->name); 638 639 priv->pll_register_no = desired_fw->pll_reg; 640 priv->init_status_supported = desired_fw->init_status_supported; 641 priv->fw_checksum_supported = desired_fw->fw_checksum_supported; 642 643 644 dprintk(1, "firmware uploading...\n"); 645 ret = xc_load_i2c_sequence(fe, fw->data); 646 if (!ret) { 647 ret = xc_set_xtal(fe); 648 dprintk(1, "Firmware upload complete...\n"); 649 } else 650 printk(KERN_ERR "xc5000: firmware upload failed...\n"); 651 652 return ret; 653 } 654 655 static void xc_debug_dump(struct xc5000_priv *priv) 656 { 657 u16 adc_envelope; 658 u32 freq_error_hz = 0; 659 u16 lock_status; 660 u32 hsync_freq_hz = 0; 661 u16 frame_lines; 662 u16 quality; 663 u16 snr; 664 u16 totalgain; 665 u8 hw_majorversion = 0, hw_minorversion = 0; 666 u8 fw_majorversion = 0, fw_minorversion = 0; 667 u16 fw_buildversion = 0; 668 u16 regval; 669 670 /* Wait for stats to stabilize. 671 * Frame Lines needs two frame times after initial lock 672 * before it is valid. 673 */ 674 msleep(100); 675 676 xc_get_adc_envelope(priv, &adc_envelope); 677 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope); 678 679 xc_get_frequency_error(priv, &freq_error_hz); 680 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz); 681 682 xc_get_lock_status(priv, &lock_status); 683 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n", 684 lock_status); 685 686 xc_get_version(priv, &hw_majorversion, &hw_minorversion, 687 &fw_majorversion, &fw_minorversion); 688 xc_get_buildversion(priv, &fw_buildversion); 689 dprintk(1, "*** HW: V%d.%d, FW: V %d.%d.%d\n", 690 hw_majorversion, hw_minorversion, 691 fw_majorversion, fw_minorversion, fw_buildversion); 692 693 xc_get_hsync_freq(priv, &hsync_freq_hz); 694 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz); 695 696 xc_get_frame_lines(priv, &frame_lines); 697 dprintk(1, "*** Frame lines = %d\n", frame_lines); 698 699 xc_get_quality(priv, &quality); 700 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality & 0x07); 701 702 xc_get_analogsnr(priv, &snr); 703 dprintk(1, "*** Unweighted analog SNR = %d dB\n", snr & 0x3f); 704 705 xc_get_totalgain(priv, &totalgain); 706 dprintk(1, "*** Total gain = %d.%d dB\n", totalgain / 256, 707 (totalgain % 256) * 100 / 256); 708 709 if (priv->pll_register_no) { 710 xc5000_readreg(priv, priv->pll_register_no, ®val); 711 dprintk(1, "*** PLL lock status = 0x%04x\n", regval); 712 } 713 } 714 715 static int xc5000_tune_digital(struct dvb_frontend *fe) 716 { 717 struct xc5000_priv *priv = fe->tuner_priv; 718 int ret; 719 u32 bw = fe->dtv_property_cache.bandwidth_hz; 720 721 ret = xc_set_signal_source(priv, priv->rf_mode); 722 if (ret != 0) { 723 printk(KERN_ERR 724 "xc5000: xc_set_signal_source(%d) failed\n", 725 priv->rf_mode); 726 return -EREMOTEIO; 727 } 728 729 ret = xc_set_tv_standard(priv, 730 xc5000_standard[priv->video_standard].video_mode, 731 xc5000_standard[priv->video_standard].audio_mode, 0); 732 if (ret != 0) { 733 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n"); 734 return -EREMOTEIO; 735 } 736 737 ret = xc_set_IF_frequency(priv, priv->if_khz); 738 if (ret != 0) { 739 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n", 740 priv->if_khz); 741 return -EIO; 742 } 743 744 dprintk(1, "%s() setting OUTPUT_AMP to 0x%x\n", 745 __func__, priv->output_amp); 746 xc_write_reg(priv, XREG_OUTPUT_AMP, priv->output_amp); 747 748 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL); 749 750 if (debug) 751 xc_debug_dump(priv); 752 753 priv->bandwidth = bw; 754 755 return 0; 756 } 757 758 static int xc5000_set_digital_params(struct dvb_frontend *fe) 759 { 760 int b; 761 struct xc5000_priv *priv = fe->tuner_priv; 762 u32 bw = fe->dtv_property_cache.bandwidth_hz; 763 u32 freq = fe->dtv_property_cache.frequency; 764 u32 delsys = fe->dtv_property_cache.delivery_system; 765 766 if (xc_load_fw_and_init_tuner(fe, 0) != 0) { 767 dprintk(1, "Unable to load firmware and init tuner\n"); 768 return -EINVAL; 769 } 770 771 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq); 772 773 switch (delsys) { 774 case SYS_ATSC: 775 dprintk(1, "%s() VSB modulation\n", __func__); 776 priv->rf_mode = XC_RF_MODE_AIR; 777 priv->freq_offset = 1750000; 778 priv->video_standard = DTV6; 779 break; 780 case SYS_DVBC_ANNEX_B: 781 dprintk(1, "%s() QAM modulation\n", __func__); 782 priv->rf_mode = XC_RF_MODE_CABLE; 783 priv->freq_offset = 1750000; 784 priv->video_standard = DTV6; 785 break; 786 case SYS_ISDBT: 787 /* All ISDB-T are currently for 6 MHz bw */ 788 if (!bw) 789 bw = 6000000; 790 /* fall to OFDM handling */ 791 case SYS_DMBTH: 792 case SYS_DVBT: 793 case SYS_DVBT2: 794 dprintk(1, "%s() OFDM\n", __func__); 795 switch (bw) { 796 case 6000000: 797 priv->video_standard = DTV6; 798 priv->freq_offset = 1750000; 799 break; 800 case 7000000: 801 priv->video_standard = DTV7; 802 priv->freq_offset = 2250000; 803 break; 804 case 8000000: 805 priv->video_standard = DTV8; 806 priv->freq_offset = 2750000; 807 break; 808 default: 809 printk(KERN_ERR "xc5000 bandwidth not set!\n"); 810 return -EINVAL; 811 } 812 priv->rf_mode = XC_RF_MODE_AIR; 813 break; 814 case SYS_DVBC_ANNEX_A: 815 case SYS_DVBC_ANNEX_C: 816 dprintk(1, "%s() QAM modulation\n", __func__); 817 priv->rf_mode = XC_RF_MODE_CABLE; 818 if (bw <= 6000000) { 819 priv->video_standard = DTV6; 820 priv->freq_offset = 1750000; 821 b = 6; 822 } else if (bw <= 7000000) { 823 priv->video_standard = DTV7; 824 priv->freq_offset = 2250000; 825 b = 7; 826 } else { 827 priv->video_standard = DTV7_8; 828 priv->freq_offset = 2750000; 829 b = 8; 830 } 831 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__, 832 b, bw); 833 break; 834 default: 835 printk(KERN_ERR "xc5000: delivery system is not supported!\n"); 836 return -EINVAL; 837 } 838 839 priv->freq_hz = freq - priv->freq_offset; 840 priv->mode = V4L2_TUNER_DIGITAL_TV; 841 842 dprintk(1, "%s() frequency=%d (compensated to %d)\n", 843 __func__, freq, priv->freq_hz); 844 845 return xc5000_tune_digital(fe); 846 } 847 848 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe) 849 { 850 struct xc5000_priv *priv = fe->tuner_priv; 851 int ret; 852 u16 id; 853 854 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id); 855 if (ret == 0) { 856 if (id == XC_PRODUCT_ID_FW_NOT_LOADED) 857 ret = -ENOENT; 858 else 859 ret = 0; 860 } 861 862 dprintk(1, "%s() returns %s id = 0x%x\n", __func__, 863 ret == 0 ? "True" : "False", id); 864 return ret; 865 } 866 867 static void xc5000_config_tv(struct dvb_frontend *fe, 868 struct analog_parameters *params) 869 { 870 struct xc5000_priv *priv = fe->tuner_priv; 871 872 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n", 873 __func__, params->frequency); 874 875 /* Fix me: it could be air. */ 876 priv->rf_mode = params->mode; 877 if (params->mode > XC_RF_MODE_CABLE) 878 priv->rf_mode = XC_RF_MODE_CABLE; 879 880 /* params->frequency is in units of 62.5khz */ 881 priv->freq_hz = params->frequency * 62500; 882 883 /* FIX ME: Some video standards may have several possible audio 884 standards. We simply default to one of them here. 885 */ 886 if (params->std & V4L2_STD_MN) { 887 /* default to BTSC audio standard */ 888 priv->video_standard = MN_NTSC_PAL_BTSC; 889 return; 890 } 891 892 if (params->std & V4L2_STD_PAL_BG) { 893 /* default to NICAM audio standard */ 894 priv->video_standard = BG_PAL_NICAM; 895 return; 896 } 897 898 if (params->std & V4L2_STD_PAL_I) { 899 /* default to NICAM audio standard */ 900 priv->video_standard = I_PAL_NICAM; 901 return; 902 } 903 904 if (params->std & V4L2_STD_PAL_DK) { 905 /* default to NICAM audio standard */ 906 priv->video_standard = DK_PAL_NICAM; 907 return; 908 } 909 910 if (params->std & V4L2_STD_SECAM_DK) { 911 /* default to A2 DK1 audio standard */ 912 priv->video_standard = DK_SECAM_A2DK1; 913 return; 914 } 915 916 if (params->std & V4L2_STD_SECAM_L) { 917 priv->video_standard = L_SECAM_NICAM; 918 return; 919 } 920 921 if (params->std & V4L2_STD_SECAM_LC) { 922 priv->video_standard = LC_SECAM_NICAM; 923 return; 924 } 925 } 926 927 static int xc5000_set_tv_freq(struct dvb_frontend *fe) 928 { 929 struct xc5000_priv *priv = fe->tuner_priv; 930 u16 pll_lock_status; 931 int ret; 932 933 tune_channel: 934 ret = xc_set_signal_source(priv, priv->rf_mode); 935 if (ret != 0) { 936 printk(KERN_ERR 937 "xc5000: xc_set_signal_source(%d) failed\n", 938 priv->rf_mode); 939 return -EREMOTEIO; 940 } 941 942 ret = xc_set_tv_standard(priv, 943 xc5000_standard[priv->video_standard].video_mode, 944 xc5000_standard[priv->video_standard].audio_mode, 0); 945 if (ret != 0) { 946 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n"); 947 return -EREMOTEIO; 948 } 949 950 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09); 951 952 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG); 953 954 if (debug) 955 xc_debug_dump(priv); 956 957 if (priv->pll_register_no != 0) { 958 msleep(20); 959 xc5000_readreg(priv, priv->pll_register_no, &pll_lock_status); 960 if (pll_lock_status > 63) { 961 /* PLL is unlocked, force reload of the firmware */ 962 dprintk(1, "xc5000: PLL not locked (0x%x). Reloading...\n", 963 pll_lock_status); 964 if (xc_load_fw_and_init_tuner(fe, 1) != 0) { 965 printk(KERN_ERR "xc5000: Unable to reload fw\n"); 966 return -EREMOTEIO; 967 } 968 goto tune_channel; 969 } 970 } 971 972 return 0; 973 } 974 975 static int xc5000_config_radio(struct dvb_frontend *fe, 976 struct analog_parameters *params) 977 978 { 979 struct xc5000_priv *priv = fe->tuner_priv; 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 priv->freq_hz = params->frequency * 125 / 2; 990 priv->rf_mode = XC_RF_MODE_AIR; 991 992 return 0; 993 } 994 995 static int xc5000_set_radio_freq(struct dvb_frontend *fe) 996 { 997 struct xc5000_priv *priv = fe->tuner_priv; 998 int ret; 999 u8 radio_input; 1000 1001 if (priv->radio_input == XC5000_RADIO_FM1) 1002 radio_input = FM_RADIO_INPUT1; 1003 else if (priv->radio_input == XC5000_RADIO_FM2) 1004 radio_input = FM_RADIO_INPUT2; 1005 else if (priv->radio_input == XC5000_RADIO_FM1_MONO) 1006 radio_input = FM_RADIO_INPUT1_MONO; 1007 else { 1008 dprintk(1, "%s() unknown radio input %d\n", __func__, 1009 priv->radio_input); 1010 return -EINVAL; 1011 } 1012 1013 ret = xc_set_tv_standard(priv, xc5000_standard[radio_input].video_mode, 1014 xc5000_standard[radio_input].audio_mode, radio_input); 1015 1016 if (ret != 0) { 1017 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n"); 1018 return -EREMOTEIO; 1019 } 1020 1021 ret = xc_set_signal_source(priv, priv->rf_mode); 1022 if (ret != 0) { 1023 printk(KERN_ERR 1024 "xc5000: xc_set_signal_source(%d) failed\n", 1025 priv->rf_mode); 1026 return -EREMOTEIO; 1027 } 1028 1029 if ((priv->radio_input == XC5000_RADIO_FM1) || 1030 (priv->radio_input == XC5000_RADIO_FM2)) 1031 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09); 1032 else if (priv->radio_input == XC5000_RADIO_FM1_MONO) 1033 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06); 1034 1035 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG); 1036 1037 return 0; 1038 } 1039 1040 static int xc5000_set_params(struct dvb_frontend *fe) 1041 { 1042 struct xc5000_priv *priv = fe->tuner_priv; 1043 1044 if (xc_load_fw_and_init_tuner(fe, 0) != 0) { 1045 dprintk(1, "Unable to load firmware and init tuner\n"); 1046 return -EINVAL; 1047 } 1048 1049 switch (priv->mode) { 1050 case V4L2_TUNER_RADIO: 1051 return xc5000_set_radio_freq(fe); 1052 case V4L2_TUNER_ANALOG_TV: 1053 return xc5000_set_tv_freq(fe); 1054 case V4L2_TUNER_DIGITAL_TV: 1055 return xc5000_tune_digital(fe); 1056 } 1057 1058 return 0; 1059 } 1060 1061 static int xc5000_set_analog_params(struct dvb_frontend *fe, 1062 struct analog_parameters *params) 1063 { 1064 struct xc5000_priv *priv = fe->tuner_priv; 1065 int ret; 1066 1067 if (priv->i2c_props.adap == NULL) 1068 return -EINVAL; 1069 1070 switch (params->mode) { 1071 case V4L2_TUNER_RADIO: 1072 ret = xc5000_config_radio(fe, params); 1073 if (ret) 1074 return ret; 1075 break; 1076 case V4L2_TUNER_ANALOG_TV: 1077 xc5000_config_tv(fe, params); 1078 break; 1079 default: 1080 break; 1081 } 1082 priv->mode = params->mode; 1083 1084 return xc5000_set_params(fe); 1085 } 1086 1087 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq) 1088 { 1089 struct xc5000_priv *priv = fe->tuner_priv; 1090 dprintk(1, "%s()\n", __func__); 1091 *freq = priv->freq_hz + priv->freq_offset; 1092 return 0; 1093 } 1094 1095 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq) 1096 { 1097 struct xc5000_priv *priv = fe->tuner_priv; 1098 dprintk(1, "%s()\n", __func__); 1099 *freq = priv->if_khz * 1000; 1100 return 0; 1101 } 1102 1103 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw) 1104 { 1105 struct xc5000_priv *priv = fe->tuner_priv; 1106 dprintk(1, "%s()\n", __func__); 1107 1108 *bw = priv->bandwidth; 1109 return 0; 1110 } 1111 1112 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status) 1113 { 1114 struct xc5000_priv *priv = fe->tuner_priv; 1115 u16 lock_status = 0; 1116 1117 xc_get_lock_status(priv, &lock_status); 1118 1119 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status); 1120 1121 *status = lock_status; 1122 1123 return 0; 1124 } 1125 1126 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force) 1127 { 1128 struct xc5000_priv *priv = fe->tuner_priv; 1129 const struct xc5000_fw_cfg *desired_fw = xc5000_assign_firmware(priv->chip_id); 1130 const struct firmware *fw; 1131 int ret, i; 1132 u16 pll_lock_status; 1133 u16 fw_ck; 1134 1135 cancel_delayed_work(&priv->timer_sleep); 1136 1137 if (!force && xc5000_is_firmware_loaded(fe) == 0) 1138 return 0; 1139 1140 if (!priv->firmware) { 1141 ret = request_firmware(&fw, desired_fw->name, 1142 priv->i2c_props.adap->dev.parent); 1143 if (ret) { 1144 pr_err("xc5000: Upload failed. rc %d\n", ret); 1145 return ret; 1146 } 1147 dprintk(1, "firmware read %zu bytes.\n", fw->size); 1148 1149 if (fw->size != desired_fw->size) { 1150 pr_err("xc5000: Firmware file with incorrect size\n"); 1151 release_firmware(fw); 1152 return -EINVAL; 1153 } 1154 priv->firmware = fw; 1155 } else 1156 fw = priv->firmware; 1157 1158 /* Try up to 5 times to load firmware */ 1159 for (i = 0; i < 5; i++) { 1160 if (i) 1161 printk(KERN_CONT " - retrying to upload firmware.\n"); 1162 1163 ret = xc5000_fwupload(fe, desired_fw, fw); 1164 if (ret != 0) 1165 goto err; 1166 1167 msleep(20); 1168 1169 if (priv->fw_checksum_supported) { 1170 if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck)) { 1171 printk(KERN_ERR 1172 "xc5000: FW checksum reading failed."); 1173 continue; 1174 } 1175 1176 if (!fw_ck) { 1177 printk(KERN_ERR 1178 "xc5000: FW checksum failed = 0x%04x.", 1179 fw_ck); 1180 continue; 1181 } 1182 } 1183 1184 /* Start the tuner self-calibration process */ 1185 ret = xc_initialize(priv); 1186 if (ret) { 1187 printk(KERN_ERR 1188 "xc5000: Can't request Self-callibration."); 1189 continue; 1190 } 1191 1192 /* Wait for calibration to complete. 1193 * We could continue but XC5000 will clock stretch subsequent 1194 * I2C transactions until calibration is complete. This way we 1195 * don't have to rely on clock stretching working. 1196 */ 1197 msleep(100); 1198 1199 if (priv->init_status_supported) { 1200 if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck)) { 1201 printk(KERN_ERR 1202 "xc5000: FW failed reading init status."); 1203 continue; 1204 } 1205 1206 if (!fw_ck) { 1207 printk(KERN_ERR 1208 "xc5000: FW init status failed = 0x%04x.", 1209 fw_ck); 1210 continue; 1211 } 1212 } 1213 1214 if (priv->pll_register_no) { 1215 xc5000_readreg(priv, priv->pll_register_no, 1216 &pll_lock_status); 1217 if (pll_lock_status > 63) { 1218 /* PLL is unlocked, force reload of the firmware */ 1219 printk(KERN_ERR 1220 "xc5000: PLL not running after fwload."); 1221 continue; 1222 } 1223 } 1224 1225 /* Default to "CABLE" mode */ 1226 ret = xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE); 1227 if (!ret) 1228 break; 1229 printk(KERN_ERR "xc5000: can't set to cable mode."); 1230 } 1231 1232 err: 1233 if (!ret) 1234 printk(KERN_INFO "xc5000: Firmware %s loaded and running.\n", 1235 desired_fw->name); 1236 else 1237 printk(KERN_CONT " - too many retries. Giving up\n"); 1238 1239 return ret; 1240 } 1241 1242 static void xc5000_do_timer_sleep(struct work_struct *timer_sleep) 1243 { 1244 struct xc5000_priv *priv =container_of(timer_sleep, struct xc5000_priv, 1245 timer_sleep.work); 1246 struct dvb_frontend *fe = priv->fe; 1247 int ret; 1248 1249 dprintk(1, "%s()\n", __func__); 1250 1251 /* According to Xceive technical support, the "powerdown" register 1252 was removed in newer versions of the firmware. The "supported" 1253 way to sleep the tuner is to pull the reset pin low for 10ms */ 1254 ret = xc5000_tuner_reset(fe); 1255 if (ret != 0) 1256 printk(KERN_ERR 1257 "xc5000: %s() unable to shutdown tuner\n", 1258 __func__); 1259 } 1260 1261 static int xc5000_sleep(struct dvb_frontend *fe) 1262 { 1263 struct xc5000_priv *priv = fe->tuner_priv; 1264 1265 dprintk(1, "%s()\n", __func__); 1266 1267 /* Avoid firmware reload on slow devices */ 1268 if (no_poweroff) 1269 return 0; 1270 1271 schedule_delayed_work(&priv->timer_sleep, 1272 msecs_to_jiffies(XC5000_SLEEP_TIME)); 1273 1274 return 0; 1275 } 1276 1277 static int xc5000_suspend(struct dvb_frontend *fe) 1278 { 1279 struct xc5000_priv *priv = fe->tuner_priv; 1280 int ret; 1281 1282 dprintk(1, "%s()\n", __func__); 1283 1284 cancel_delayed_work(&priv->timer_sleep); 1285 1286 ret = xc5000_tuner_reset(fe); 1287 if (ret != 0) 1288 printk(KERN_ERR 1289 "xc5000: %s() unable to shutdown tuner\n", 1290 __func__); 1291 1292 return 0; 1293 } 1294 1295 static int xc5000_resume(struct dvb_frontend *fe) 1296 { 1297 struct xc5000_priv *priv = fe->tuner_priv; 1298 1299 dprintk(1, "%s()\n", __func__); 1300 1301 /* suspended before firmware is loaded. 1302 Avoid firmware load in resume path. */ 1303 if (!priv->firmware) 1304 return 0; 1305 1306 return xc5000_set_params(fe); 1307 } 1308 1309 static int xc5000_init(struct dvb_frontend *fe) 1310 { 1311 struct xc5000_priv *priv = fe->tuner_priv; 1312 dprintk(1, "%s()\n", __func__); 1313 1314 if (xc_load_fw_and_init_tuner(fe, 0) != 0) { 1315 printk(KERN_ERR "xc5000: Unable to initialise tuner\n"); 1316 return -EREMOTEIO; 1317 } 1318 1319 if (debug) 1320 xc_debug_dump(priv); 1321 1322 return 0; 1323 } 1324 1325 static void xc5000_release(struct dvb_frontend *fe) 1326 { 1327 struct xc5000_priv *priv = fe->tuner_priv; 1328 1329 dprintk(1, "%s()\n", __func__); 1330 1331 mutex_lock(&xc5000_list_mutex); 1332 1333 if (priv) { 1334 cancel_delayed_work(&priv->timer_sleep); 1335 if (priv->firmware) { 1336 release_firmware(priv->firmware); 1337 priv->firmware = NULL; 1338 } 1339 hybrid_tuner_release_state(priv); 1340 } 1341 1342 mutex_unlock(&xc5000_list_mutex); 1343 1344 fe->tuner_priv = NULL; 1345 } 1346 1347 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg) 1348 { 1349 struct xc5000_priv *priv = fe->tuner_priv; 1350 struct xc5000_config *p = priv_cfg; 1351 1352 dprintk(1, "%s()\n", __func__); 1353 1354 if (p->if_khz) 1355 priv->if_khz = p->if_khz; 1356 1357 if (p->radio_input) 1358 priv->radio_input = p->radio_input; 1359 1360 if (p->output_amp) 1361 priv->output_amp = p->output_amp; 1362 1363 return 0; 1364 } 1365 1366 1367 static const struct dvb_tuner_ops xc5000_tuner_ops = { 1368 .info = { 1369 .name = "Xceive XC5000", 1370 .frequency_min = 1000000, 1371 .frequency_max = 1023000000, 1372 .frequency_step = 50000, 1373 }, 1374 1375 .release = xc5000_release, 1376 .init = xc5000_init, 1377 .sleep = xc5000_sleep, 1378 .suspend = xc5000_suspend, 1379 .resume = xc5000_resume, 1380 1381 .set_config = xc5000_set_config, 1382 .set_params = xc5000_set_digital_params, 1383 .set_analog_params = xc5000_set_analog_params, 1384 .get_frequency = xc5000_get_frequency, 1385 .get_if_frequency = xc5000_get_if_frequency, 1386 .get_bandwidth = xc5000_get_bandwidth, 1387 .get_status = xc5000_get_status 1388 }; 1389 1390 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe, 1391 struct i2c_adapter *i2c, 1392 const struct xc5000_config *cfg) 1393 { 1394 struct xc5000_priv *priv = NULL; 1395 int instance; 1396 u16 id = 0; 1397 1398 dprintk(1, "%s(%d-%04x)\n", __func__, 1399 i2c ? i2c_adapter_id(i2c) : -1, 1400 cfg ? cfg->i2c_address : -1); 1401 1402 mutex_lock(&xc5000_list_mutex); 1403 1404 instance = hybrid_tuner_request_state(struct xc5000_priv, priv, 1405 hybrid_tuner_instance_list, 1406 i2c, cfg->i2c_address, "xc5000"); 1407 switch (instance) { 1408 case 0: 1409 goto fail; 1410 case 1: 1411 /* new tuner instance */ 1412 priv->bandwidth = 6000000; 1413 fe->tuner_priv = priv; 1414 priv->fe = fe; 1415 INIT_DELAYED_WORK(&priv->timer_sleep, xc5000_do_timer_sleep); 1416 break; 1417 default: 1418 /* existing tuner instance */ 1419 fe->tuner_priv = priv; 1420 break; 1421 } 1422 1423 if (priv->if_khz == 0) { 1424 /* If the IF hasn't been set yet, use the value provided by 1425 the caller (occurs in hybrid devices where the analog 1426 call to xc5000_attach occurs before the digital side) */ 1427 priv->if_khz = cfg->if_khz; 1428 } 1429 1430 if (priv->xtal_khz == 0) 1431 priv->xtal_khz = cfg->xtal_khz; 1432 1433 if (priv->radio_input == 0) 1434 priv->radio_input = cfg->radio_input; 1435 1436 /* don't override chip id if it's already been set 1437 unless explicitly specified */ 1438 if ((priv->chip_id == 0) || (cfg->chip_id)) 1439 /* use default chip id if none specified, set to 0 so 1440 it can be overridden if this is a hybrid driver */ 1441 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0; 1442 1443 /* don't override output_amp if it's already been set 1444 unless explicitly specified */ 1445 if ((priv->output_amp == 0) || (cfg->output_amp)) 1446 /* use default output_amp value if none specified */ 1447 priv->output_amp = (cfg->output_amp) ? cfg->output_amp : 0x8a; 1448 1449 /* Check if firmware has been loaded. It is possible that another 1450 instance of the driver has loaded the firmware. 1451 */ 1452 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0) 1453 goto fail; 1454 1455 switch (id) { 1456 case XC_PRODUCT_ID_FW_LOADED: 1457 printk(KERN_INFO 1458 "xc5000: Successfully identified at address 0x%02x\n", 1459 cfg->i2c_address); 1460 printk(KERN_INFO 1461 "xc5000: Firmware has been loaded previously\n"); 1462 break; 1463 case XC_PRODUCT_ID_FW_NOT_LOADED: 1464 printk(KERN_INFO 1465 "xc5000: Successfully identified at address 0x%02x\n", 1466 cfg->i2c_address); 1467 printk(KERN_INFO 1468 "xc5000: Firmware has not been loaded previously\n"); 1469 break; 1470 default: 1471 printk(KERN_ERR 1472 "xc5000: Device not found at addr 0x%02x (0x%x)\n", 1473 cfg->i2c_address, id); 1474 goto fail; 1475 } 1476 1477 mutex_unlock(&xc5000_list_mutex); 1478 1479 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops, 1480 sizeof(struct dvb_tuner_ops)); 1481 1482 return fe; 1483 fail: 1484 mutex_unlock(&xc5000_list_mutex); 1485 1486 xc5000_release(fe); 1487 return NULL; 1488 } 1489 EXPORT_SYMBOL(xc5000_attach); 1490 1491 MODULE_AUTHOR("Steven Toth"); 1492 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver"); 1493 MODULE_LICENSE("GPL"); 1494 MODULE_FIRMWARE(XC5000A_FIRMWARE); 1495 MODULE_FIRMWARE(XC5000C_FIRMWARE); 1496