1/* 2 * Driver for Xceive XC5000 "QAM/8VSB single chip tuner" 3 * 4 * Copyright (c) 2007 Xceive Corporation 5 * Copyright (c) 2007 Steven Toth <stoth@linuxtv.org> 6 * Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 */ 23 24#include <linux/module.h> 25#include <linux/moduleparam.h> 26#include <linux/videodev2.h> 27#include <linux/delay.h> 28#include <linux/dvb/frontend.h> 29#include <linux/i2c.h> 30 31#include "dvb_frontend.h" 32 33#include "xc5000.h" 34#include "tuner-i2c.h" 35 36static int debug; 37module_param(debug, int, 0644); 38MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); 39 40static int no_poweroff; 41module_param(no_poweroff, int, 0644); 42MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n" 43 "\t\t1 keep device energized and with tuner ready all the times.\n" 44 "\t\tFaster, but consumes more power and keeps the device hotter"); 45 46static DEFINE_MUTEX(xc5000_list_mutex); 47static LIST_HEAD(hybrid_tuner_instance_list); 48 49#define dprintk(level, fmt, arg...) if (debug >= level) \ 50 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg) 51 52#define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.6.114.fw" 53#define XC5000_DEFAULT_FIRMWARE_SIZE 12401 54 55struct xc5000_priv { 56 struct tuner_i2c_props i2c_props; 57 struct list_head hybrid_tuner_instance_list; 58 59 u32 if_khz; 60 u32 freq_hz; 61 u32 bandwidth; 62 u8 video_standard; 63 u8 rf_mode; 64 u8 radio_input; 65}; 66 67/* Misc Defines */ 68#define MAX_TV_STANDARD 23 69#define XC_MAX_I2C_WRITE_LENGTH 64 70 71/* Signal Types */ 72#define XC_RF_MODE_AIR 0 73#define XC_RF_MODE_CABLE 1 74 75/* Result codes */ 76#define XC_RESULT_SUCCESS 0 77#define XC_RESULT_RESET_FAILURE 1 78#define XC_RESULT_I2C_WRITE_FAILURE 2 79#define XC_RESULT_I2C_READ_FAILURE 3 80#define XC_RESULT_OUT_OF_RANGE 5 81 82/* Product id */ 83#define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000 84#define XC_PRODUCT_ID_FW_LOADED 0x1388 85 86/* Registers */ 87#define XREG_INIT 0x00 88#define XREG_VIDEO_MODE 0x01 89#define XREG_AUDIO_MODE 0x02 90#define XREG_RF_FREQ 0x03 91#define XREG_D_CODE 0x04 92#define XREG_IF_OUT 0x05 93#define XREG_SEEK_MODE 0x07 94#define XREG_POWER_DOWN 0x0A /* Obsolete */ 95#define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */ 96#define XREG_SMOOTHEDCVBS 0x0E 97#define XREG_XTALFREQ 0x0F 98#define XREG_FINERFREQ 0x10 99#define XREG_DDIMODE 0x11 100 101#define XREG_ADC_ENV 0x00 102#define XREG_QUALITY 0x01 103#define XREG_FRAME_LINES 0x02 104#define XREG_HSYNC_FREQ 0x03 105#define XREG_LOCK 0x04 106#define XREG_FREQ_ERROR 0x05 107#define XREG_SNR 0x06 108#define XREG_VERSION 0x07 109#define XREG_PRODUCT_ID 0x08 110#define XREG_BUSY 0x09 111#define XREG_BUILD 0x0D 112 113/* 114 Basic firmware description. This will remain with 115 the driver for documentation purposes. 116 117 This represents an I2C firmware file encoded as a 118 string of unsigned char. Format is as follows: 119 120 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB 121 char[1 ]=len0_LSB -> length of first write transaction 122 char[2 ]=data0 -> first byte to be sent 123 char[3 ]=data1 124 char[4 ]=data2 125 char[ ]=... 126 char[M ]=dataN -> last byte to be sent 127 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB 128 char[M+2]=len1_LSB -> length of second write transaction 129 char[M+3]=data0 130 char[M+4]=data1 131 ... 132 etc. 133 134 The [len] value should be interpreted as follows: 135 136 len= len_MSB _ len_LSB 137 len=1111_1111_1111_1111 : End of I2C_SEQUENCE 138 len=0000_0000_0000_0000 : Reset command: Do hardware reset 139 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767) 140 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms 141 142 For the RESET and WAIT commands, the two following bytes will contain 143 immediately the length of the following transaction. 144 145*/ 146struct XC_TV_STANDARD { 147 char *Name; 148 u16 AudioMode; 149 u16 VideoMode; 150}; 151 152/* Tuner standards */ 153#define MN_NTSC_PAL_BTSC 0 154#define MN_NTSC_PAL_A2 1 155#define MN_NTSC_PAL_EIAJ 2 156#define MN_NTSC_PAL_Mono 3 157#define BG_PAL_A2 4 158#define BG_PAL_NICAM 5 159#define BG_PAL_MONO 6 160#define I_PAL_NICAM 7 161#define I_PAL_NICAM_MONO 8 162#define DK_PAL_A2 9 163#define DK_PAL_NICAM 10 164#define DK_PAL_MONO 11 165#define DK_SECAM_A2DK1 12 166#define DK_SECAM_A2LDK3 13 167#define DK_SECAM_A2MONO 14 168#define L_SECAM_NICAM 15 169#define LC_SECAM_NICAM 16 170#define DTV6 17 171#define DTV8 18 172#define DTV7_8 19 173#define DTV7 20 174#define FM_Radio_INPUT2 21 175#define FM_Radio_INPUT1 22 176 177static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = { 178 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020}, 179 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020}, 180 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020}, 181 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020}, 182 {"B/G-PAL-A2", 0x0A00, 0x8049}, 183 {"B/G-PAL-NICAM", 0x0C04, 0x8049}, 184 {"B/G-PAL-MONO", 0x0878, 0x8059}, 185 {"I-PAL-NICAM", 0x1080, 0x8009}, 186 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009}, 187 {"D/K-PAL-A2", 0x1600, 0x8009}, 188 {"D/K-PAL-NICAM", 0x0E80, 0x8009}, 189 {"D/K-PAL-MONO", 0x1478, 0x8009}, 190 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009}, 191 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009}, 192 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009}, 193 {"L-SECAM-NICAM", 0x8E82, 0x0009}, 194 {"L'-SECAM-NICAM", 0x8E82, 0x4009}, 195 {"DTV6", 0x00C0, 0x8002}, 196 {"DTV8", 0x00C0, 0x800B}, 197 {"DTV7/8", 0x00C0, 0x801B}, 198 {"DTV7", 0x00C0, 0x8007}, 199 {"FM Radio-INPUT2", 0x9802, 0x9002}, 200 {"FM Radio-INPUT1", 0x0208, 0x9002} 201}; 202 203static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe); 204static int xc5000_is_firmware_loaded(struct dvb_frontend *fe); 205static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val); 206static int xc5000_TunerReset(struct dvb_frontend *fe); 207 208static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len) 209{ 210 struct i2c_msg msg = { .addr = priv->i2c_props.addr, 211 .flags = 0, .buf = buf, .len = len }; 212 213 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) { 214 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len); 215 return XC_RESULT_I2C_WRITE_FAILURE; 216 } 217 return XC_RESULT_SUCCESS; 218} 219 220 221static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val) 222{ 223 u8 buf[2] = { reg >> 8, reg & 0xff }; 224 u8 bval[2] = { 0, 0 }; 225 struct i2c_msg msg[2] = { 226 { .addr = priv->i2c_props.addr, 227 .flags = 0, .buf = &buf[0], .len = 2 }, 228 { .addr = priv->i2c_props.addr, 229 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 }, 230 }; 231 232 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) { 233 printk(KERN_WARNING "xc5000: I2C read failed\n"); 234 return -EREMOTEIO; 235 } 236 237 *val = (bval[0] << 8) | bval[1]; 238 return XC_RESULT_SUCCESS; 239} 240 241static void xc_wait(int wait_ms) 242{ 243 msleep(wait_ms); 244} 245 246static int xc5000_TunerReset(struct dvb_frontend *fe) 247{ 248 struct xc5000_priv *priv = fe->tuner_priv; 249 int ret; 250 251 dprintk(1, "%s()\n", __func__); 252 253 if (fe->callback) { 254 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ? 255 fe->dvb->priv : 256 priv->i2c_props.adap->algo_data, 257 DVB_FRONTEND_COMPONENT_TUNER, 258 XC5000_TUNER_RESET, 0); 259 if (ret) { 260 printk(KERN_ERR "xc5000: reset failed\n"); 261 return XC_RESULT_RESET_FAILURE; 262 } 263 } else { 264 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n"); 265 return XC_RESULT_RESET_FAILURE; 266 } 267 return XC_RESULT_SUCCESS; 268} 269 270static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData) 271{ 272 u8 buf[4]; 273 int WatchDogTimer = 100; 274 int result; 275 276 buf[0] = (regAddr >> 8) & 0xFF; 277 buf[1] = regAddr & 0xFF; 278 buf[2] = (i2cData >> 8) & 0xFF; 279 buf[3] = i2cData & 0xFF; 280 result = xc_send_i2c_data(priv, buf, 4); 281 if (result == XC_RESULT_SUCCESS) { 282 /* wait for busy flag to clear */ 283 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) { 284 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf); 285 if (result == XC_RESULT_SUCCESS) { 286 if ((buf[0] == 0) && (buf[1] == 0)) { 287 /* busy flag cleared */ 288 break; 289 } else { 290 xc_wait(5); /* wait 5 ms */ 291 WatchDogTimer--; 292 } 293 } 294 } 295 } 296 if (WatchDogTimer < 0) 297 result = XC_RESULT_I2C_WRITE_FAILURE; 298 299 return result; 300} 301 302static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence) 303{ 304 struct xc5000_priv *priv = fe->tuner_priv; 305 306 int i, nbytes_to_send, result; 307 unsigned int len, pos, index; 308 u8 buf[XC_MAX_I2C_WRITE_LENGTH]; 309 310 index = 0; 311 while ((i2c_sequence[index] != 0xFF) || 312 (i2c_sequence[index + 1] != 0xFF)) { 313 len = i2c_sequence[index] * 256 + i2c_sequence[index+1]; 314 if (len == 0x0000) { 315 /* RESET command */ 316 result = xc5000_TunerReset(fe); 317 index += 2; 318 if (result != XC_RESULT_SUCCESS) 319 return result; 320 } else if (len & 0x8000) { 321 /* WAIT command */ 322 xc_wait(len & 0x7FFF); 323 index += 2; 324 } else { 325 /* Send i2c data whilst ensuring individual transactions 326 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes. 327 */ 328 index += 2; 329 buf[0] = i2c_sequence[index]; 330 buf[1] = i2c_sequence[index + 1]; 331 pos = 2; 332 while (pos < len) { 333 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2) 334 nbytes_to_send = 335 XC_MAX_I2C_WRITE_LENGTH; 336 else 337 nbytes_to_send = (len - pos + 2); 338 for (i = 2; i < nbytes_to_send; i++) { 339 buf[i] = i2c_sequence[index + pos + 340 i - 2]; 341 } 342 result = xc_send_i2c_data(priv, buf, 343 nbytes_to_send); 344 345 if (result != XC_RESULT_SUCCESS) 346 return result; 347 348 pos += nbytes_to_send - 2; 349 } 350 index += len; 351 } 352 } 353 return XC_RESULT_SUCCESS; 354} 355 356static int xc_initialize(struct xc5000_priv *priv) 357{ 358 dprintk(1, "%s()\n", __func__); 359 return xc_write_reg(priv, XREG_INIT, 0); 360} 361 362static int xc_SetTVStandard(struct xc5000_priv *priv, 363 u16 VideoMode, u16 AudioMode) 364{ 365 int ret; 366 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode); 367 dprintk(1, "%s() Standard = %s\n", 368 __func__, 369 XC5000_Standard[priv->video_standard].Name); 370 371 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode); 372 if (ret == XC_RESULT_SUCCESS) 373 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode); 374 375 return ret; 376} 377 378static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode) 379{ 380 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode, 381 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE"); 382 383 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) { 384 rf_mode = XC_RF_MODE_CABLE; 385 printk(KERN_ERR 386 "%s(), Invalid mode, defaulting to CABLE", 387 __func__); 388 } 389 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode); 390} 391 392static const struct dvb_tuner_ops xc5000_tuner_ops; 393 394static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz) 395{ 396 u16 freq_code; 397 398 dprintk(1, "%s(%u)\n", __func__, freq_hz); 399 400 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) || 401 (freq_hz < xc5000_tuner_ops.info.frequency_min)) 402 return XC_RESULT_OUT_OF_RANGE; 403 404 freq_code = (u16)(freq_hz / 15625); 405 406 /* Starting in firmware version 1.1.44, Xceive recommends using the 407 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should 408 only be used for fast scanning for channel lock) */ 409 return xc_write_reg(priv, XREG_FINERFREQ, freq_code); 410} 411 412 413static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz) 414{ 415 u32 freq_code = (freq_khz * 1024)/1000; 416 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n", 417 __func__, freq_khz, freq_code); 418 419 return xc_write_reg(priv, XREG_IF_OUT, freq_code); 420} 421 422 423static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope) 424{ 425 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope); 426} 427 428static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz) 429{ 430 int result; 431 u16 regData; 432 u32 tmp; 433 434 result = xc5000_readreg(priv, XREG_FREQ_ERROR, ®Data); 435 if (result != XC_RESULT_SUCCESS) 436 return result; 437 438 tmp = (u32)regData; 439 (*freq_error_hz) = (tmp * 15625) / 1000; 440 return result; 441} 442 443static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status) 444{ 445 return xc5000_readreg(priv, XREG_LOCK, lock_status); 446} 447 448static int xc_get_version(struct xc5000_priv *priv, 449 u8 *hw_majorversion, u8 *hw_minorversion, 450 u8 *fw_majorversion, u8 *fw_minorversion) 451{ 452 u16 data; 453 int result; 454 455 result = xc5000_readreg(priv, XREG_VERSION, &data); 456 if (result != XC_RESULT_SUCCESS) 457 return result; 458 459 (*hw_majorversion) = (data >> 12) & 0x0F; 460 (*hw_minorversion) = (data >> 8) & 0x0F; 461 (*fw_majorversion) = (data >> 4) & 0x0F; 462 (*fw_minorversion) = data & 0x0F; 463 464 return 0; 465} 466 467static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev) 468{ 469 return xc5000_readreg(priv, XREG_BUILD, buildrev); 470} 471 472static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz) 473{ 474 u16 regData; 475 int result; 476 477 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, ®Data); 478 if (result != XC_RESULT_SUCCESS) 479 return result; 480 481 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100; 482 return result; 483} 484 485static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines) 486{ 487 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines); 488} 489 490static int xc_get_quality(struct xc5000_priv *priv, u16 *quality) 491{ 492 return xc5000_readreg(priv, XREG_QUALITY, quality); 493} 494 495static u16 WaitForLock(struct xc5000_priv *priv) 496{ 497 u16 lockState = 0; 498 int watchDogCount = 40; 499 500 while ((lockState == 0) && (watchDogCount > 0)) { 501 xc_get_lock_status(priv, &lockState); 502 if (lockState != 1) { 503 xc_wait(5); 504 watchDogCount--; 505 } 506 } 507 return lockState; 508} 509 510#define XC_TUNE_ANALOG 0 511#define XC_TUNE_DIGITAL 1 512static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode) 513{ 514 int found = 0; 515 516 dprintk(1, "%s(%u)\n", __func__, freq_hz); 517 518 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS) 519 return 0; 520 521 if (mode == XC_TUNE_ANALOG) { 522 if (WaitForLock(priv) == 1) 523 found = 1; 524 } 525 526 return found; 527} 528 529 530static int xc5000_fwupload(struct dvb_frontend *fe) 531{ 532 struct xc5000_priv *priv = fe->tuner_priv; 533 const struct firmware *fw; 534 int ret; 535 536 /* request the firmware, this will block and timeout */ 537 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n", 538 XC5000_DEFAULT_FIRMWARE); 539 540 ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE, 541 priv->i2c_props.adap->dev.parent); 542 if (ret) { 543 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n"); 544 ret = XC_RESULT_RESET_FAILURE; 545 goto out; 546 } else { 547 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n", 548 fw->size); 549 ret = XC_RESULT_SUCCESS; 550 } 551 552 if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) { 553 printk(KERN_ERR "xc5000: firmware incorrect size\n"); 554 ret = XC_RESULT_RESET_FAILURE; 555 } else { 556 printk(KERN_INFO "xc5000: firmware uploading...\n"); 557 ret = xc_load_i2c_sequence(fe, fw->data); 558 printk(KERN_INFO "xc5000: firmware upload complete...\n"); 559 } 560 561out: 562 release_firmware(fw); 563 return ret; 564} 565 566static void xc_debug_dump(struct xc5000_priv *priv) 567{ 568 u16 adc_envelope; 569 u32 freq_error_hz = 0; 570 u16 lock_status; 571 u32 hsync_freq_hz = 0; 572 u16 frame_lines; 573 u16 quality; 574 u8 hw_majorversion = 0, hw_minorversion = 0; 575 u8 fw_majorversion = 0, fw_minorversion = 0; 576 u16 fw_buildversion = 0; 577 578 /* Wait for stats to stabilize. 579 * Frame Lines needs two frame times after initial lock 580 * before it is valid. 581 */ 582 xc_wait(100); 583 584 xc_get_ADC_Envelope(priv, &adc_envelope); 585 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope); 586 587 xc_get_frequency_error(priv, &freq_error_hz); 588 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz); 589 590 xc_get_lock_status(priv, &lock_status); 591 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n", 592 lock_status); 593 594 xc_get_version(priv, &hw_majorversion, &hw_minorversion, 595 &fw_majorversion, &fw_minorversion); 596 xc_get_buildversion(priv, &fw_buildversion); 597 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n", 598 hw_majorversion, hw_minorversion, 599 fw_majorversion, fw_minorversion, fw_buildversion); 600 601 xc_get_hsync_freq(priv, &hsync_freq_hz); 602 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz); 603 604 xc_get_frame_lines(priv, &frame_lines); 605 dprintk(1, "*** Frame lines = %d\n", frame_lines); 606 607 xc_get_quality(priv, &quality); 608 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality); 609} 610 611static int xc5000_set_params(struct dvb_frontend *fe, 612 struct dvb_frontend_parameters *params) 613{ 614 struct xc5000_priv *priv = fe->tuner_priv; 615 int ret; 616 617 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) { 618 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) { 619 dprintk(1, "Unable to load firmware and init tuner\n"); 620 return -EINVAL; 621 } 622 } 623 624 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency); 625 626 if (fe->ops.info.type == FE_ATSC) { 627 dprintk(1, "%s() ATSC\n", __func__); 628 switch (params->u.vsb.modulation) { 629 case VSB_8: 630 case VSB_16: 631 dprintk(1, "%s() VSB modulation\n", __func__); 632 priv->rf_mode = XC_RF_MODE_AIR; 633 priv->freq_hz = params->frequency - 1750000; 634 priv->bandwidth = BANDWIDTH_6_MHZ; 635 priv->video_standard = DTV6; 636 break; 637 case QAM_64: 638 case QAM_256: 639 case QAM_AUTO: 640 dprintk(1, "%s() QAM modulation\n", __func__); 641 priv->rf_mode = XC_RF_MODE_CABLE; 642 priv->freq_hz = params->frequency - 1750000; 643 priv->bandwidth = BANDWIDTH_6_MHZ; 644 priv->video_standard = DTV6; 645 break; 646 default: 647 return -EINVAL; 648 } 649 } else if (fe->ops.info.type == FE_OFDM) { 650 dprintk(1, "%s() OFDM\n", __func__); 651 switch (params->u.ofdm.bandwidth) { 652 case BANDWIDTH_6_MHZ: 653 priv->bandwidth = BANDWIDTH_6_MHZ; 654 priv->video_standard = DTV6; 655 priv->freq_hz = params->frequency - 1750000; 656 break; 657 case BANDWIDTH_7_MHZ: 658 printk(KERN_ERR "xc5000 bandwidth 7MHz not supported\n"); 659 return -EINVAL; 660 case BANDWIDTH_8_MHZ: 661 priv->bandwidth = BANDWIDTH_8_MHZ; 662 priv->video_standard = DTV8; 663 priv->freq_hz = params->frequency - 2750000; 664 break; 665 default: 666 printk(KERN_ERR "xc5000 bandwidth not set!\n"); 667 return -EINVAL; 668 } 669 priv->rf_mode = XC_RF_MODE_AIR; 670 } else { 671 printk(KERN_ERR "xc5000 modulation type not supported!\n"); 672 return -EINVAL; 673 } 674 675 dprintk(1, "%s() frequency=%d (compensated)\n", 676 __func__, priv->freq_hz); 677 678 ret = xc_SetSignalSource(priv, priv->rf_mode); 679 if (ret != XC_RESULT_SUCCESS) { 680 printk(KERN_ERR 681 "xc5000: xc_SetSignalSource(%d) failed\n", 682 priv->rf_mode); 683 return -EREMOTEIO; 684 } 685 686 ret = xc_SetTVStandard(priv, 687 XC5000_Standard[priv->video_standard].VideoMode, 688 XC5000_Standard[priv->video_standard].AudioMode); 689 if (ret != XC_RESULT_SUCCESS) { 690 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n"); 691 return -EREMOTEIO; 692 } 693 694 ret = xc_set_IF_frequency(priv, priv->if_khz); 695 if (ret != XC_RESULT_SUCCESS) { 696 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n", 697 priv->if_khz); 698 return -EIO; 699 } 700 701 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL); 702 703 if (debug) 704 xc_debug_dump(priv); 705 706 return 0; 707} 708 709static int xc5000_is_firmware_loaded(struct dvb_frontend *fe) 710{ 711 struct xc5000_priv *priv = fe->tuner_priv; 712 int ret; 713 u16 id; 714 715 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id); 716 if (ret == XC_RESULT_SUCCESS) { 717 if (id == XC_PRODUCT_ID_FW_NOT_LOADED) 718 ret = XC_RESULT_RESET_FAILURE; 719 else 720 ret = XC_RESULT_SUCCESS; 721 } 722 723 dprintk(1, "%s() returns %s id = 0x%x\n", __func__, 724 ret == XC_RESULT_SUCCESS ? "True" : "False", id); 725 return ret; 726} 727 728static int xc5000_set_tv_freq(struct dvb_frontend *fe, 729 struct analog_parameters *params) 730{ 731 struct xc5000_priv *priv = fe->tuner_priv; 732 int ret; 733 734 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n", 735 __func__, params->frequency); 736 737 /* Fix me: it could be air. */ 738 priv->rf_mode = params->mode; 739 if (params->mode > XC_RF_MODE_CABLE) 740 priv->rf_mode = XC_RF_MODE_CABLE; 741 742 /* params->frequency is in units of 62.5khz */ 743 priv->freq_hz = params->frequency * 62500; 744 745 /* FIX ME: Some video standards may have several possible audio 746 standards. We simply default to one of them here. 747 */ 748 if (params->std & V4L2_STD_MN) { 749 /* default to BTSC audio standard */ 750 priv->video_standard = MN_NTSC_PAL_BTSC; 751 goto tune_channel; 752 } 753 754 if (params->std & V4L2_STD_PAL_BG) { 755 /* default to NICAM audio standard */ 756 priv->video_standard = BG_PAL_NICAM; 757 goto tune_channel; 758 } 759 760 if (params->std & V4L2_STD_PAL_I) { 761 /* default to NICAM audio standard */ 762 priv->video_standard = I_PAL_NICAM; 763 goto tune_channel; 764 } 765 766 if (params->std & V4L2_STD_PAL_DK) { 767 /* default to NICAM audio standard */ 768 priv->video_standard = DK_PAL_NICAM; 769 goto tune_channel; 770 } 771 772 if (params->std & V4L2_STD_SECAM_DK) { 773 /* default to A2 DK1 audio standard */ 774 priv->video_standard = DK_SECAM_A2DK1; 775 goto tune_channel; 776 } 777 778 if (params->std & V4L2_STD_SECAM_L) { 779 priv->video_standard = L_SECAM_NICAM; 780 goto tune_channel; 781 } 782 783 if (params->std & V4L2_STD_SECAM_LC) { 784 priv->video_standard = LC_SECAM_NICAM; 785 goto tune_channel; 786 } 787 788tune_channel: 789 ret = xc_SetSignalSource(priv, priv->rf_mode); 790 if (ret != XC_RESULT_SUCCESS) { 791 printk(KERN_ERR 792 "xc5000: xc_SetSignalSource(%d) failed\n", 793 priv->rf_mode); 794 return -EREMOTEIO; 795 } 796 797 ret = xc_SetTVStandard(priv, 798 XC5000_Standard[priv->video_standard].VideoMode, 799 XC5000_Standard[priv->video_standard].AudioMode); 800 if (ret != XC_RESULT_SUCCESS) { 801 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n"); 802 return -EREMOTEIO; 803 } 804 805 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG); 806 807 if (debug) 808 xc_debug_dump(priv); 809 810 return 0; 811} 812 813static int xc5000_set_radio_freq(struct dvb_frontend *fe, 814 struct analog_parameters *params) 815{ 816 struct xc5000_priv *priv = fe->tuner_priv; 817 int ret = -EINVAL; 818 u8 radio_input; 819 820 dprintk(1, "%s() frequency=%d (in units of khz)\n", 821 __func__, params->frequency); 822 823 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) { 824 dprintk(1, "%s() radio input not configured\n", __func__); 825 return -EINVAL; 826 } 827 828 if (priv->radio_input == XC5000_RADIO_FM1) 829 radio_input = FM_Radio_INPUT1; 830 else if (priv->radio_input == XC5000_RADIO_FM2) 831 radio_input = FM_Radio_INPUT2; 832 else { 833 dprintk(1, "%s() unknown radio input %d\n", __func__, 834 priv->radio_input); 835 return -EINVAL; 836 } 837 838 priv->freq_hz = params->frequency * 125 / 2; 839 840 priv->rf_mode = XC_RF_MODE_AIR; 841 842 ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode, 843 XC5000_Standard[radio_input].AudioMode); 844 845 if (ret != XC_RESULT_SUCCESS) { 846 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n"); 847 return -EREMOTEIO; 848 } 849 850 ret = xc_SetSignalSource(priv, priv->rf_mode); 851 if (ret != XC_RESULT_SUCCESS) { 852 printk(KERN_ERR 853 "xc5000: xc_SetSignalSource(%d) failed\n", 854 priv->rf_mode); 855 return -EREMOTEIO; 856 } 857 858 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG); 859 860 return 0; 861} 862 863static int xc5000_set_analog_params(struct dvb_frontend *fe, 864 struct analog_parameters *params) 865{ 866 struct xc5000_priv *priv = fe->tuner_priv; 867 int ret = -EINVAL; 868 869 if (priv->i2c_props.adap == NULL) 870 return -EINVAL; 871 872 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) { 873 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) { 874 dprintk(1, "Unable to load firmware and init tuner\n"); 875 return -EINVAL; 876 } 877 } 878 879 switch (params->mode) { 880 case V4L2_TUNER_RADIO: 881 ret = xc5000_set_radio_freq(fe, params); 882 break; 883 case V4L2_TUNER_ANALOG_TV: 884 case V4L2_TUNER_DIGITAL_TV: 885 ret = xc5000_set_tv_freq(fe, params); 886 break; 887 } 888 889 return ret; 890} 891 892 893static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq) 894{ 895 struct xc5000_priv *priv = fe->tuner_priv; 896 dprintk(1, "%s()\n", __func__); 897 *freq = priv->freq_hz; 898 return 0; 899} 900 901static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw) 902{ 903 struct xc5000_priv *priv = fe->tuner_priv; 904 dprintk(1, "%s()\n", __func__); 905 906 *bw = priv->bandwidth; 907 return 0; 908} 909 910static int xc5000_get_status(struct dvb_frontend *fe, u32 *status) 911{ 912 struct xc5000_priv *priv = fe->tuner_priv; 913 u16 lock_status = 0; 914 915 xc_get_lock_status(priv, &lock_status); 916 917 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status); 918 919 *status = lock_status; 920 921 return 0; 922} 923 924static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe) 925{ 926 struct xc5000_priv *priv = fe->tuner_priv; 927 int ret = 0; 928 929 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) { 930 ret = xc5000_fwupload(fe); 931 if (ret != XC_RESULT_SUCCESS) 932 return ret; 933 } 934 935 /* Start the tuner self-calibration process */ 936 ret |= xc_initialize(priv); 937 938 /* Wait for calibration to complete. 939 * We could continue but XC5000 will clock stretch subsequent 940 * I2C transactions until calibration is complete. This way we 941 * don't have to rely on clock stretching working. 942 */ 943 xc_wait(100); 944 945 /* Default to "CABLE" mode */ 946 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE); 947 948 return ret; 949} 950 951static int xc5000_sleep(struct dvb_frontend *fe) 952{ 953 int ret; 954 955 dprintk(1, "%s()\n", __func__); 956 957 /* Avoid firmware reload on slow devices */ 958 if (no_poweroff) 959 return 0; 960 961 /* According to Xceive technical support, the "powerdown" register 962 was removed in newer versions of the firmware. The "supported" 963 way to sleep the tuner is to pull the reset pin low for 10ms */ 964 ret = xc5000_TunerReset(fe); 965 if (ret != XC_RESULT_SUCCESS) { 966 printk(KERN_ERR 967 "xc5000: %s() unable to shutdown tuner\n", 968 __func__); 969 return -EREMOTEIO; 970 } else 971 return XC_RESULT_SUCCESS; 972} 973 974static int xc5000_init(struct dvb_frontend *fe) 975{ 976 struct xc5000_priv *priv = fe->tuner_priv; 977 dprintk(1, "%s()\n", __func__); 978 979 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) { 980 printk(KERN_ERR "xc5000: Unable to initialise tuner\n"); 981 return -EREMOTEIO; 982 } 983 984 if (debug) 985 xc_debug_dump(priv); 986 987 return 0; 988} 989 990static int xc5000_release(struct dvb_frontend *fe) 991{ 992 struct xc5000_priv *priv = fe->tuner_priv; 993 994 dprintk(1, "%s()\n", __func__); 995 996 mutex_lock(&xc5000_list_mutex); 997 998 if (priv) 999 hybrid_tuner_release_state(priv); 1000 1001 mutex_unlock(&xc5000_list_mutex); 1002 1003 fe->tuner_priv = NULL; 1004 1005 return 0; 1006} 1007 1008static const struct dvb_tuner_ops xc5000_tuner_ops = { 1009 .info = { 1010 .name = "Xceive XC5000", 1011 .frequency_min = 1000000, 1012 .frequency_max = 1023000000, 1013 .frequency_step = 50000, 1014 }, 1015 1016 .release = xc5000_release, 1017 .init = xc5000_init, 1018 .sleep = xc5000_sleep, 1019 1020 .set_params = xc5000_set_params, 1021 .set_analog_params = xc5000_set_analog_params, 1022 .get_frequency = xc5000_get_frequency, 1023 .get_bandwidth = xc5000_get_bandwidth, 1024 .get_status = xc5000_get_status 1025}; 1026 1027struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe, 1028 struct i2c_adapter *i2c, 1029 struct xc5000_config *cfg) 1030{ 1031 struct xc5000_priv *priv = NULL; 1032 int instance; 1033 u16 id = 0; 1034 1035 dprintk(1, "%s(%d-%04x)\n", __func__, 1036 i2c ? i2c_adapter_id(i2c) : -1, 1037 cfg ? cfg->i2c_address : -1); 1038 1039 mutex_lock(&xc5000_list_mutex); 1040 1041 instance = hybrid_tuner_request_state(struct xc5000_priv, priv, 1042 hybrid_tuner_instance_list, 1043 i2c, cfg->i2c_address, "xc5000"); 1044 switch (instance) { 1045 case 0: 1046 goto fail; 1047 break; 1048 case 1: 1049 /* new tuner instance */ 1050 priv->bandwidth = BANDWIDTH_6_MHZ; 1051 fe->tuner_priv = priv; 1052 break; 1053 default: 1054 /* existing tuner instance */ 1055 fe->tuner_priv = priv; 1056 break; 1057 } 1058 1059 if (priv->if_khz == 0) { 1060 /* If the IF hasn't been set yet, use the value provided by 1061 the caller (occurs in hybrid devices where the analog 1062 call to xc5000_attach occurs before the digital side) */ 1063 priv->if_khz = cfg->if_khz; 1064 } 1065 1066 if (priv->radio_input == 0) 1067 priv->radio_input = cfg->radio_input; 1068 1069 /* Check if firmware has been loaded. It is possible that another 1070 instance of the driver has loaded the firmware. 1071 */ 1072 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS) 1073 goto fail; 1074 1075 switch (id) { 1076 case XC_PRODUCT_ID_FW_LOADED: 1077 printk(KERN_INFO 1078 "xc5000: Successfully identified at address 0x%02x\n", 1079 cfg->i2c_address); 1080 printk(KERN_INFO 1081 "xc5000: Firmware has been loaded previously\n"); 1082 break; 1083 case XC_PRODUCT_ID_FW_NOT_LOADED: 1084 printk(KERN_INFO 1085 "xc5000: Successfully identified at address 0x%02x\n", 1086 cfg->i2c_address); 1087 printk(KERN_INFO 1088 "xc5000: Firmware has not been loaded previously\n"); 1089 break; 1090 default: 1091 printk(KERN_ERR 1092 "xc5000: Device not found at addr 0x%02x (0x%x)\n", 1093 cfg->i2c_address, id); 1094 goto fail; 1095 } 1096 1097 mutex_unlock(&xc5000_list_mutex); 1098 1099 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops, 1100 sizeof(struct dvb_tuner_ops)); 1101 1102 return fe; 1103fail: 1104 mutex_unlock(&xc5000_list_mutex); 1105 1106 xc5000_release(fe); 1107 return NULL; 1108} 1109EXPORT_SYMBOL(xc5000_attach); 1110 1111MODULE_AUTHOR("Steven Toth"); 1112MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver"); 1113MODULE_LICENSE("GPL"); 1114