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