1 /* 2 * Driver for Xceive XC4000 "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 * Copyright (c) 2009 Davide Ferri <d.ferri@zero11.it> 8 * Copyright (c) 2010 Istvan Varga <istvan_v@mailbox.hu> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 23 */ 24 25 #include <linux/module.h> 26 #include <linux/moduleparam.h> 27 #include <linux/videodev2.h> 28 #include <linux/delay.h> 29 #include <linux/dvb/frontend.h> 30 #include <linux/i2c.h> 31 #include <linux/mutex.h> 32 #include <asm/unaligned.h> 33 34 #include "dvb_frontend.h" 35 36 #include "xc4000.h" 37 #include "tuner-i2c.h" 38 #include "tuner-xc2028-types.h" 39 40 static int debug; 41 module_param(debug, int, 0644); 42 MODULE_PARM_DESC(debug, "Debugging level (0 to 2, default: 0 (off))."); 43 44 static int no_poweroff; 45 module_param(no_poweroff, int, 0644); 46 MODULE_PARM_DESC(no_poweroff, "Power management (1: disabled, 2: enabled, " 47 "0 (default): use device-specific default mode)."); 48 49 static int audio_std; 50 module_param(audio_std, int, 0644); 51 MODULE_PARM_DESC(audio_std, "Audio standard. XC4000 audio decoder explicitly " 52 "needs to know what audio standard is needed for some video standards " 53 "with audio A2 or NICAM. The valid settings are a sum of:\n" 54 " 1: use NICAM/B or A2/B instead of NICAM/A or A2/A\n" 55 " 2: use A2 instead of NICAM or BTSC\n" 56 " 4: use SECAM/K3 instead of K1\n" 57 " 8: use PAL-D/K audio for SECAM-D/K\n" 58 "16: use FM radio input 1 instead of input 2\n" 59 "32: use mono audio (the lower three bits are ignored)"); 60 61 static char firmware_name[30]; 62 module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0); 63 MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the " 64 "default firmware name."); 65 66 static DEFINE_MUTEX(xc4000_list_mutex); 67 static LIST_HEAD(hybrid_tuner_instance_list); 68 69 #define dprintk(level, fmt, arg...) if (debug >= level) \ 70 printk(KERN_INFO "%s: " fmt, "xc4000", ## arg) 71 72 /* struct for storing firmware table */ 73 struct firmware_description { 74 unsigned int type; 75 v4l2_std_id id; 76 __u16 int_freq; 77 unsigned char *ptr; 78 unsigned int size; 79 }; 80 81 struct firmware_properties { 82 unsigned int type; 83 v4l2_std_id id; 84 v4l2_std_id std_req; 85 __u16 int_freq; 86 unsigned int scode_table; 87 int scode_nr; 88 }; 89 90 struct xc4000_priv { 91 struct tuner_i2c_props i2c_props; 92 struct list_head hybrid_tuner_instance_list; 93 struct firmware_description *firm; 94 int firm_size; 95 u32 if_khz; 96 u32 freq_hz; 97 u32 bandwidth; 98 u8 video_standard; 99 u8 rf_mode; 100 u8 default_pm; 101 u8 dvb_amplitude; 102 u8 set_smoothedcvbs; 103 u8 ignore_i2c_write_errors; 104 __u16 firm_version; 105 struct firmware_properties cur_fw; 106 __u16 hwmodel; 107 __u16 hwvers; 108 struct mutex lock; 109 }; 110 111 #define XC4000_AUDIO_STD_B 1 112 #define XC4000_AUDIO_STD_A2 2 113 #define XC4000_AUDIO_STD_K3 4 114 #define XC4000_AUDIO_STD_L 8 115 #define XC4000_AUDIO_STD_INPUT1 16 116 #define XC4000_AUDIO_STD_MONO 32 117 118 #define XC4000_DEFAULT_FIRMWARE "dvb-fe-xc4000-1.4.fw" 119 120 /* Misc Defines */ 121 #define MAX_TV_STANDARD 24 122 #define XC_MAX_I2C_WRITE_LENGTH 64 123 #define XC_POWERED_DOWN 0x80000000U 124 125 /* Signal Types */ 126 #define XC_RF_MODE_AIR 0 127 #define XC_RF_MODE_CABLE 1 128 129 /* Product id */ 130 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000 131 #define XC_PRODUCT_ID_XC4000 0x0FA0 132 #define XC_PRODUCT_ID_XC4100 0x1004 133 134 /* Registers (Write-only) */ 135 #define XREG_INIT 0x00 136 #define XREG_VIDEO_MODE 0x01 137 #define XREG_AUDIO_MODE 0x02 138 #define XREG_RF_FREQ 0x03 139 #define XREG_D_CODE 0x04 140 #define XREG_DIRECTSITTING_MODE 0x05 141 #define XREG_SEEK_MODE 0x06 142 #define XREG_POWER_DOWN 0x08 143 #define XREG_SIGNALSOURCE 0x0A 144 #define XREG_SMOOTHEDCVBS 0x0E 145 #define XREG_AMPLITUDE 0x10 146 147 /* Registers (Read-only) */ 148 #define XREG_ADC_ENV 0x00 149 #define XREG_QUALITY 0x01 150 #define XREG_FRAME_LINES 0x02 151 #define XREG_HSYNC_FREQ 0x03 152 #define XREG_LOCK 0x04 153 #define XREG_FREQ_ERROR 0x05 154 #define XREG_SNR 0x06 155 #define XREG_VERSION 0x07 156 #define XREG_PRODUCT_ID 0x08 157 #define XREG_SIGNAL_LEVEL 0x0A 158 #define XREG_NOISE_LEVEL 0x0B 159 160 /* 161 Basic firmware description. This will remain with 162 the driver for documentation purposes. 163 164 This represents an I2C firmware file encoded as a 165 string of unsigned char. Format is as follows: 166 167 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB 168 char[1 ]=len0_LSB -> length of first write transaction 169 char[2 ]=data0 -> first byte to be sent 170 char[3 ]=data1 171 char[4 ]=data2 172 char[ ]=... 173 char[M ]=dataN -> last byte to be sent 174 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB 175 char[M+2]=len1_LSB -> length of second write transaction 176 char[M+3]=data0 177 char[M+4]=data1 178 ... 179 etc. 180 181 The [len] value should be interpreted as follows: 182 183 len= len_MSB _ len_LSB 184 len=1111_1111_1111_1111 : End of I2C_SEQUENCE 185 len=0000_0000_0000_0000 : Reset command: Do hardware reset 186 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767) 187 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms 188 189 For the RESET and WAIT commands, the two following bytes will contain 190 immediately the length of the following transaction. 191 */ 192 193 struct XC_TV_STANDARD { 194 const char *Name; 195 u16 audio_mode; 196 u16 video_mode; 197 u16 int_freq; 198 }; 199 200 /* Tuner standards */ 201 #define XC4000_MN_NTSC_PAL_BTSC 0 202 #define XC4000_MN_NTSC_PAL_A2 1 203 #define XC4000_MN_NTSC_PAL_EIAJ 2 204 #define XC4000_MN_NTSC_PAL_Mono 3 205 #define XC4000_BG_PAL_A2 4 206 #define XC4000_BG_PAL_NICAM 5 207 #define XC4000_BG_PAL_MONO 6 208 #define XC4000_I_PAL_NICAM 7 209 #define XC4000_I_PAL_NICAM_MONO 8 210 #define XC4000_DK_PAL_A2 9 211 #define XC4000_DK_PAL_NICAM 10 212 #define XC4000_DK_PAL_MONO 11 213 #define XC4000_DK_SECAM_A2DK1 12 214 #define XC4000_DK_SECAM_A2LDK3 13 215 #define XC4000_DK_SECAM_A2MONO 14 216 #define XC4000_DK_SECAM_NICAM 15 217 #define XC4000_L_SECAM_NICAM 16 218 #define XC4000_LC_SECAM_NICAM 17 219 #define XC4000_DTV6 18 220 #define XC4000_DTV8 19 221 #define XC4000_DTV7_8 20 222 #define XC4000_DTV7 21 223 #define XC4000_FM_Radio_INPUT2 22 224 #define XC4000_FM_Radio_INPUT1 23 225 226 static struct XC_TV_STANDARD xc4000_standard[MAX_TV_STANDARD] = { 227 {"M/N-NTSC/PAL-BTSC", 0x0000, 0x80A0, 4500}, 228 {"M/N-NTSC/PAL-A2", 0x0000, 0x80A0, 4600}, 229 {"M/N-NTSC/PAL-EIAJ", 0x0040, 0x80A0, 4500}, 230 {"M/N-NTSC/PAL-Mono", 0x0078, 0x80A0, 4500}, 231 {"B/G-PAL-A2", 0x0000, 0x8159, 5640}, 232 {"B/G-PAL-NICAM", 0x0004, 0x8159, 5740}, 233 {"B/G-PAL-MONO", 0x0078, 0x8159, 5500}, 234 {"I-PAL-NICAM", 0x0080, 0x8049, 6240}, 235 {"I-PAL-NICAM-MONO", 0x0078, 0x8049, 6000}, 236 {"D/K-PAL-A2", 0x0000, 0x8049, 6380}, 237 {"D/K-PAL-NICAM", 0x0080, 0x8049, 6200}, 238 {"D/K-PAL-MONO", 0x0078, 0x8049, 6500}, 239 {"D/K-SECAM-A2 DK1", 0x0000, 0x8049, 6340}, 240 {"D/K-SECAM-A2 L/DK3", 0x0000, 0x8049, 6000}, 241 {"D/K-SECAM-A2 MONO", 0x0078, 0x8049, 6500}, 242 {"D/K-SECAM-NICAM", 0x0080, 0x8049, 6200}, 243 {"L-SECAM-NICAM", 0x8080, 0x0009, 6200}, 244 {"L'-SECAM-NICAM", 0x8080, 0x4009, 6200}, 245 {"DTV6", 0x00C0, 0x8002, 0}, 246 {"DTV8", 0x00C0, 0x800B, 0}, 247 {"DTV7/8", 0x00C0, 0x801B, 0}, 248 {"DTV7", 0x00C0, 0x8007, 0}, 249 {"FM Radio-INPUT2", 0x0008, 0x9800, 10700}, 250 {"FM Radio-INPUT1", 0x0008, 0x9000, 10700} 251 }; 252 253 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val); 254 static int xc4000_tuner_reset(struct dvb_frontend *fe); 255 static void xc_debug_dump(struct xc4000_priv *priv); 256 257 static int xc_send_i2c_data(struct xc4000_priv *priv, u8 *buf, int len) 258 { 259 struct i2c_msg msg = { .addr = priv->i2c_props.addr, 260 .flags = 0, .buf = buf, .len = len }; 261 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) { 262 if (priv->ignore_i2c_write_errors == 0) { 263 printk(KERN_ERR "xc4000: I2C write failed (len=%i)\n", 264 len); 265 if (len == 4) { 266 printk(KERN_ERR "bytes %*ph\n", 4, buf); 267 } 268 return -EREMOTEIO; 269 } 270 } 271 return 0; 272 } 273 274 static int xc4000_tuner_reset(struct dvb_frontend *fe) 275 { 276 struct xc4000_priv *priv = fe->tuner_priv; 277 int ret; 278 279 dprintk(1, "%s()\n", __func__); 280 281 if (fe->callback) { 282 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ? 283 fe->dvb->priv : 284 priv->i2c_props.adap->algo_data, 285 DVB_FRONTEND_COMPONENT_TUNER, 286 XC4000_TUNER_RESET, 0); 287 if (ret) { 288 printk(KERN_ERR "xc4000: reset failed\n"); 289 return -EREMOTEIO; 290 } 291 } else { 292 printk(KERN_ERR "xc4000: no tuner reset callback function, " 293 "fatal\n"); 294 return -EINVAL; 295 } 296 return 0; 297 } 298 299 static int xc_write_reg(struct xc4000_priv *priv, u16 regAddr, u16 i2cData) 300 { 301 u8 buf[4]; 302 int result; 303 304 buf[0] = (regAddr >> 8) & 0xFF; 305 buf[1] = regAddr & 0xFF; 306 buf[2] = (i2cData >> 8) & 0xFF; 307 buf[3] = i2cData & 0xFF; 308 result = xc_send_i2c_data(priv, buf, 4); 309 310 return result; 311 } 312 313 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence) 314 { 315 struct xc4000_priv *priv = fe->tuner_priv; 316 317 int i, nbytes_to_send, result; 318 unsigned int len, pos, index; 319 u8 buf[XC_MAX_I2C_WRITE_LENGTH]; 320 321 index = 0; 322 while ((i2c_sequence[index] != 0xFF) || 323 (i2c_sequence[index + 1] != 0xFF)) { 324 len = i2c_sequence[index] * 256 + i2c_sequence[index+1]; 325 if (len == 0x0000) { 326 /* RESET command */ 327 /* NOTE: this is ignored, as the reset callback was */ 328 /* already called by check_firmware() */ 329 index += 2; 330 } else if (len & 0x8000) { 331 /* WAIT command */ 332 msleep(len & 0x7FFF); 333 index += 2; 334 } else { 335 /* Send i2c data whilst ensuring individual transactions 336 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes. 337 */ 338 index += 2; 339 buf[0] = i2c_sequence[index]; 340 buf[1] = i2c_sequence[index + 1]; 341 pos = 2; 342 while (pos < len) { 343 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2) 344 nbytes_to_send = 345 XC_MAX_I2C_WRITE_LENGTH; 346 else 347 nbytes_to_send = (len - pos + 2); 348 for (i = 2; i < nbytes_to_send; i++) { 349 buf[i] = i2c_sequence[index + pos + 350 i - 2]; 351 } 352 result = xc_send_i2c_data(priv, buf, 353 nbytes_to_send); 354 355 if (result != 0) 356 return result; 357 358 pos += nbytes_to_send - 2; 359 } 360 index += len; 361 } 362 } 363 return 0; 364 } 365 366 static int xc_set_tv_standard(struct xc4000_priv *priv, 367 u16 video_mode, u16 audio_mode) 368 { 369 int ret; 370 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode); 371 dprintk(1, "%s() Standard = %s\n", 372 __func__, 373 xc4000_standard[priv->video_standard].Name); 374 375 /* Don't complain when the request fails because of i2c stretching */ 376 priv->ignore_i2c_write_errors = 1; 377 378 ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode); 379 if (ret == 0) 380 ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode); 381 382 priv->ignore_i2c_write_errors = 0; 383 384 return ret; 385 } 386 387 static int xc_set_signal_source(struct xc4000_priv *priv, u16 rf_mode) 388 { 389 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode, 390 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE"); 391 392 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) { 393 rf_mode = XC_RF_MODE_CABLE; 394 printk(KERN_ERR 395 "%s(), Invalid mode, defaulting to CABLE", 396 __func__); 397 } 398 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode); 399 } 400 401 static const struct dvb_tuner_ops xc4000_tuner_ops; 402 403 static int xc_set_rf_frequency(struct xc4000_priv *priv, u32 freq_hz) 404 { 405 u16 freq_code; 406 407 dprintk(1, "%s(%u)\n", __func__, freq_hz); 408 409 if ((freq_hz > xc4000_tuner_ops.info.frequency_max) || 410 (freq_hz < xc4000_tuner_ops.info.frequency_min)) 411 return -EINVAL; 412 413 freq_code = (u16)(freq_hz / 15625); 414 415 /* WAS: Starting in firmware version 1.1.44, Xceive recommends using the 416 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should 417 only be used for fast scanning for channel lock) */ 418 /* WAS: XREG_FINERFREQ */ 419 return xc_write_reg(priv, XREG_RF_FREQ, freq_code); 420 } 421 422 static int xc_get_adc_envelope(struct xc4000_priv *priv, u16 *adc_envelope) 423 { 424 return xc4000_readreg(priv, XREG_ADC_ENV, adc_envelope); 425 } 426 427 static int xc_get_frequency_error(struct xc4000_priv *priv, u32 *freq_error_hz) 428 { 429 int result; 430 u16 regData; 431 u32 tmp; 432 433 result = xc4000_readreg(priv, XREG_FREQ_ERROR, ®Data); 434 if (result != 0) 435 return result; 436 437 tmp = (u32)regData & 0xFFFFU; 438 tmp = (tmp < 0x8000U ? tmp : 0x10000U - tmp); 439 (*freq_error_hz) = tmp * 15625; 440 return result; 441 } 442 443 static int xc_get_lock_status(struct xc4000_priv *priv, u16 *lock_status) 444 { 445 return xc4000_readreg(priv, XREG_LOCK, lock_status); 446 } 447 448 static int xc_get_version(struct xc4000_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 = xc4000_readreg(priv, XREG_VERSION, &data); 456 if (result != 0) 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 467 static int xc_get_hsync_freq(struct xc4000_priv *priv, u32 *hsync_freq_hz) 468 { 469 u16 regData; 470 int result; 471 472 result = xc4000_readreg(priv, XREG_HSYNC_FREQ, ®Data); 473 if (result != 0) 474 return result; 475 476 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100; 477 return result; 478 } 479 480 static int xc_get_frame_lines(struct xc4000_priv *priv, u16 *frame_lines) 481 { 482 return xc4000_readreg(priv, XREG_FRAME_LINES, frame_lines); 483 } 484 485 static int xc_get_quality(struct xc4000_priv *priv, u16 *quality) 486 { 487 return xc4000_readreg(priv, XREG_QUALITY, quality); 488 } 489 490 static int xc_get_signal_level(struct xc4000_priv *priv, u16 *signal) 491 { 492 return xc4000_readreg(priv, XREG_SIGNAL_LEVEL, signal); 493 } 494 495 static int xc_get_noise_level(struct xc4000_priv *priv, u16 *noise) 496 { 497 return xc4000_readreg(priv, XREG_NOISE_LEVEL, noise); 498 } 499 500 static u16 xc_wait_for_lock(struct xc4000_priv *priv) 501 { 502 u16 lock_state = 0; 503 int watchdog_count = 40; 504 505 while ((lock_state == 0) && (watchdog_count > 0)) { 506 xc_get_lock_status(priv, &lock_state); 507 if (lock_state != 1) { 508 msleep(5); 509 watchdog_count--; 510 } 511 } 512 return lock_state; 513 } 514 515 static int xc_tune_channel(struct xc4000_priv *priv, u32 freq_hz) 516 { 517 int found = 1; 518 int result; 519 520 dprintk(1, "%s(%u)\n", __func__, freq_hz); 521 522 /* Don't complain when the request fails because of i2c stretching */ 523 priv->ignore_i2c_write_errors = 1; 524 result = xc_set_rf_frequency(priv, freq_hz); 525 priv->ignore_i2c_write_errors = 0; 526 527 if (result != 0) 528 return 0; 529 530 /* wait for lock only in analog TV mode */ 531 if ((priv->cur_fw.type & (FM | DTV6 | DTV7 | DTV78 | DTV8)) == 0) { 532 if (xc_wait_for_lock(priv) != 1) 533 found = 0; 534 } 535 536 /* Wait for stats to stabilize. 537 * Frame Lines needs two frame times after initial lock 538 * before it is valid. 539 */ 540 msleep(debug ? 100 : 10); 541 542 if (debug) 543 xc_debug_dump(priv); 544 545 return found; 546 } 547 548 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val) 549 { 550 u8 buf[2] = { reg >> 8, reg & 0xff }; 551 u8 bval[2] = { 0, 0 }; 552 struct i2c_msg msg[2] = { 553 { .addr = priv->i2c_props.addr, 554 .flags = 0, .buf = &buf[0], .len = 2 }, 555 { .addr = priv->i2c_props.addr, 556 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 }, 557 }; 558 559 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) { 560 printk(KERN_ERR "xc4000: I2C read failed\n"); 561 return -EREMOTEIO; 562 } 563 564 *val = (bval[0] << 8) | bval[1]; 565 return 0; 566 } 567 568 #define dump_firm_type(t) dump_firm_type_and_int_freq(t, 0) 569 static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq) 570 { 571 if (type & BASE) 572 printk(KERN_CONT "BASE "); 573 if (type & INIT1) 574 printk(KERN_CONT "INIT1 "); 575 if (type & F8MHZ) 576 printk(KERN_CONT "F8MHZ "); 577 if (type & MTS) 578 printk(KERN_CONT "MTS "); 579 if (type & D2620) 580 printk(KERN_CONT "D2620 "); 581 if (type & D2633) 582 printk(KERN_CONT "D2633 "); 583 if (type & DTV6) 584 printk(KERN_CONT "DTV6 "); 585 if (type & QAM) 586 printk(KERN_CONT "QAM "); 587 if (type & DTV7) 588 printk(KERN_CONT "DTV7 "); 589 if (type & DTV78) 590 printk(KERN_CONT "DTV78 "); 591 if (type & DTV8) 592 printk(KERN_CONT "DTV8 "); 593 if (type & FM) 594 printk(KERN_CONT "FM "); 595 if (type & INPUT1) 596 printk(KERN_CONT "INPUT1 "); 597 if (type & LCD) 598 printk(KERN_CONT "LCD "); 599 if (type & NOGD) 600 printk(KERN_CONT "NOGD "); 601 if (type & MONO) 602 printk(KERN_CONT "MONO "); 603 if (type & ATSC) 604 printk(KERN_CONT "ATSC "); 605 if (type & IF) 606 printk(KERN_CONT "IF "); 607 if (type & LG60) 608 printk(KERN_CONT "LG60 "); 609 if (type & ATI638) 610 printk(KERN_CONT "ATI638 "); 611 if (type & OREN538) 612 printk(KERN_CONT "OREN538 "); 613 if (type & OREN36) 614 printk(KERN_CONT "OREN36 "); 615 if (type & TOYOTA388) 616 printk(KERN_CONT "TOYOTA388 "); 617 if (type & TOYOTA794) 618 printk(KERN_CONT "TOYOTA794 "); 619 if (type & DIBCOM52) 620 printk(KERN_CONT "DIBCOM52 "); 621 if (type & ZARLINK456) 622 printk(KERN_CONT "ZARLINK456 "); 623 if (type & CHINA) 624 printk(KERN_CONT "CHINA "); 625 if (type & F6MHZ) 626 printk(KERN_CONT "F6MHZ "); 627 if (type & INPUT2) 628 printk(KERN_CONT "INPUT2 "); 629 if (type & SCODE) 630 printk(KERN_CONT "SCODE "); 631 if (type & HAS_IF) 632 printk(KERN_CONT "HAS_IF_%d ", int_freq); 633 } 634 635 static int seek_firmware(struct dvb_frontend *fe, unsigned int type, 636 v4l2_std_id *id) 637 { 638 struct xc4000_priv *priv = fe->tuner_priv; 639 int i, best_i = -1; 640 unsigned int best_nr_diffs = 255U; 641 642 if (!priv->firm) { 643 printk(KERN_ERR "Error! firmware not loaded\n"); 644 return -EINVAL; 645 } 646 647 if (((type & ~SCODE) == 0) && (*id == 0)) 648 *id = V4L2_STD_PAL; 649 650 /* Seek for generic video standard match */ 651 for (i = 0; i < priv->firm_size; i++) { 652 v4l2_std_id id_diff_mask = 653 (priv->firm[i].id ^ (*id)) & (*id); 654 unsigned int type_diff_mask = 655 (priv->firm[i].type ^ type) 656 & (BASE_TYPES | DTV_TYPES | LCD | NOGD | MONO | SCODE); 657 unsigned int nr_diffs; 658 659 if (type_diff_mask 660 & (BASE | INIT1 | FM | DTV6 | DTV7 | DTV78 | DTV8 | SCODE)) 661 continue; 662 663 nr_diffs = hweight64(id_diff_mask) + hweight32(type_diff_mask); 664 if (!nr_diffs) /* Supports all the requested standards */ 665 goto found; 666 667 if (nr_diffs < best_nr_diffs) { 668 best_nr_diffs = nr_diffs; 669 best_i = i; 670 } 671 } 672 673 /* FIXME: Would make sense to seek for type "hint" match ? */ 674 if (best_i < 0) { 675 i = -ENOENT; 676 goto ret; 677 } 678 679 if (best_nr_diffs > 0U) { 680 printk(KERN_WARNING 681 "Selecting best matching firmware (%u bits differ) for " 682 "type=(%x), id %016llx:\n", 683 best_nr_diffs, type, (unsigned long long)*id); 684 i = best_i; 685 } 686 687 found: 688 *id = priv->firm[i].id; 689 690 ret: 691 if (debug) { 692 printk(KERN_DEBUG "%s firmware for type=", 693 (i < 0) ? "Can't find" : "Found"); 694 dump_firm_type(type); 695 printk(KERN_DEBUG "(%x), id %016llx.\n", type, (unsigned long long)*id); 696 } 697 return i; 698 } 699 700 static int load_firmware(struct dvb_frontend *fe, unsigned int type, 701 v4l2_std_id *id) 702 { 703 struct xc4000_priv *priv = fe->tuner_priv; 704 int pos, rc; 705 unsigned char *p; 706 707 pos = seek_firmware(fe, type, id); 708 if (pos < 0) 709 return pos; 710 711 p = priv->firm[pos].ptr; 712 713 /* Don't complain when the request fails because of i2c stretching */ 714 priv->ignore_i2c_write_errors = 1; 715 716 rc = xc_load_i2c_sequence(fe, p); 717 718 priv->ignore_i2c_write_errors = 0; 719 720 return rc; 721 } 722 723 static int xc4000_fwupload(struct dvb_frontend *fe) 724 { 725 struct xc4000_priv *priv = fe->tuner_priv; 726 const struct firmware *fw = NULL; 727 const unsigned char *p, *endp; 728 int rc = 0; 729 int n, n_array; 730 char name[33]; 731 const char *fname; 732 733 if (firmware_name[0] != '\0') 734 fname = firmware_name; 735 else 736 fname = XC4000_DEFAULT_FIRMWARE; 737 738 dprintk(1, "Reading firmware %s\n", fname); 739 rc = request_firmware(&fw, fname, priv->i2c_props.adap->dev.parent); 740 if (rc < 0) { 741 if (rc == -ENOENT) 742 printk(KERN_ERR "Error: firmware %s not found.\n", fname); 743 else 744 printk(KERN_ERR "Error %d while requesting firmware %s\n", 745 rc, fname); 746 747 return rc; 748 } 749 p = fw->data; 750 endp = p + fw->size; 751 752 if (fw->size < sizeof(name) - 1 + 2 + 2) { 753 printk(KERN_ERR "Error: firmware file %s has invalid size!\n", 754 fname); 755 goto corrupt; 756 } 757 758 memcpy(name, p, sizeof(name) - 1); 759 name[sizeof(name) - 1] = '\0'; 760 p += sizeof(name) - 1; 761 762 priv->firm_version = get_unaligned_le16(p); 763 p += 2; 764 765 n_array = get_unaligned_le16(p); 766 p += 2; 767 768 dprintk(1, "Loading %d firmware images from %s, type: %s, ver %d.%d\n", 769 n_array, fname, name, 770 priv->firm_version >> 8, priv->firm_version & 0xff); 771 772 priv->firm = kcalloc(n_array, sizeof(*priv->firm), GFP_KERNEL); 773 if (priv->firm == NULL) { 774 printk(KERN_ERR "Not enough memory to load firmware file.\n"); 775 rc = -ENOMEM; 776 goto done; 777 } 778 priv->firm_size = n_array; 779 780 n = -1; 781 while (p < endp) { 782 __u32 type, size; 783 v4l2_std_id id; 784 __u16 int_freq = 0; 785 786 n++; 787 if (n >= n_array) { 788 printk(KERN_ERR "More firmware images in file than " 789 "were expected!\n"); 790 goto corrupt; 791 } 792 793 /* Checks if there's enough bytes to read */ 794 if (endp - p < sizeof(type) + sizeof(id) + sizeof(size)) 795 goto header; 796 797 type = get_unaligned_le32(p); 798 p += sizeof(type); 799 800 id = get_unaligned_le64(p); 801 p += sizeof(id); 802 803 if (type & HAS_IF) { 804 int_freq = get_unaligned_le16(p); 805 p += sizeof(int_freq); 806 if (endp - p < sizeof(size)) 807 goto header; 808 } 809 810 size = get_unaligned_le32(p); 811 p += sizeof(size); 812 813 if (!size || size > endp - p) { 814 printk(KERN_ERR "Firmware type (%x), id %llx is corrupted (size=%d, expected %d)\n", 815 type, (unsigned long long)id, 816 (unsigned)(endp - p), size); 817 goto corrupt; 818 } 819 820 priv->firm[n].ptr = kzalloc(size, GFP_KERNEL); 821 if (priv->firm[n].ptr == NULL) { 822 printk(KERN_ERR "Not enough memory to load firmware file.\n"); 823 rc = -ENOMEM; 824 goto done; 825 } 826 827 if (debug) { 828 printk(KERN_DEBUG "Reading firmware type "); 829 dump_firm_type_and_int_freq(type, int_freq); 830 printk(KERN_DEBUG "(%x), id %llx, size=%d.\n", 831 type, (unsigned long long)id, size); 832 } 833 834 memcpy(priv->firm[n].ptr, p, size); 835 priv->firm[n].type = type; 836 priv->firm[n].id = id; 837 priv->firm[n].size = size; 838 priv->firm[n].int_freq = int_freq; 839 840 p += size; 841 } 842 843 if (n + 1 != priv->firm_size) { 844 printk(KERN_ERR "Firmware file is incomplete!\n"); 845 goto corrupt; 846 } 847 848 goto done; 849 850 header: 851 printk(KERN_ERR "Firmware header is incomplete!\n"); 852 corrupt: 853 rc = -EINVAL; 854 printk(KERN_ERR "Error: firmware file is corrupted!\n"); 855 856 done: 857 release_firmware(fw); 858 if (rc == 0) 859 dprintk(1, "Firmware files loaded.\n"); 860 861 return rc; 862 } 863 864 static int load_scode(struct dvb_frontend *fe, unsigned int type, 865 v4l2_std_id *id, __u16 int_freq, int scode) 866 { 867 struct xc4000_priv *priv = fe->tuner_priv; 868 int pos, rc; 869 unsigned char *p; 870 u8 scode_buf[13]; 871 u8 indirect_mode[5]; 872 873 dprintk(1, "%s called int_freq=%d\n", __func__, int_freq); 874 875 if (!int_freq) { 876 pos = seek_firmware(fe, type, id); 877 if (pos < 0) 878 return pos; 879 } else { 880 for (pos = 0; pos < priv->firm_size; pos++) { 881 if ((priv->firm[pos].int_freq == int_freq) && 882 (priv->firm[pos].type & HAS_IF)) 883 break; 884 } 885 if (pos == priv->firm_size) 886 return -ENOENT; 887 } 888 889 p = priv->firm[pos].ptr; 890 891 if (priv->firm[pos].size != 12 * 16 || scode >= 16) 892 return -EINVAL; 893 p += 12 * scode; 894 895 if (debug) { 896 tuner_info("Loading SCODE for type="); 897 dump_firm_type_and_int_freq(priv->firm[pos].type, 898 priv->firm[pos].int_freq); 899 printk(KERN_CONT "(%x), id %016llx.\n", priv->firm[pos].type, 900 (unsigned long long)*id); 901 } 902 903 scode_buf[0] = 0x00; 904 memcpy(&scode_buf[1], p, 12); 905 906 /* Enter direct-mode */ 907 rc = xc_write_reg(priv, XREG_DIRECTSITTING_MODE, 0); 908 if (rc < 0) { 909 printk(KERN_ERR "failed to put device into direct mode!\n"); 910 return -EIO; 911 } 912 913 rc = xc_send_i2c_data(priv, scode_buf, 13); 914 if (rc != 0) { 915 /* Even if the send failed, make sure we set back to indirect 916 mode */ 917 printk(KERN_ERR "Failed to set scode %d\n", rc); 918 } 919 920 /* Switch back to indirect-mode */ 921 memset(indirect_mode, 0, sizeof(indirect_mode)); 922 indirect_mode[4] = 0x88; 923 xc_send_i2c_data(priv, indirect_mode, sizeof(indirect_mode)); 924 msleep(10); 925 926 return 0; 927 } 928 929 static int check_firmware(struct dvb_frontend *fe, unsigned int type, 930 v4l2_std_id std, __u16 int_freq) 931 { 932 struct xc4000_priv *priv = fe->tuner_priv; 933 struct firmware_properties new_fw; 934 int rc = 0, is_retry = 0; 935 u16 hwmodel; 936 v4l2_std_id std0; 937 u8 hw_major = 0, hw_minor = 0, fw_major = 0, fw_minor = 0; 938 939 dprintk(1, "%s called\n", __func__); 940 941 if (!priv->firm) { 942 rc = xc4000_fwupload(fe); 943 if (rc < 0) 944 return rc; 945 } 946 947 retry: 948 new_fw.type = type; 949 new_fw.id = std; 950 new_fw.std_req = std; 951 new_fw.scode_table = SCODE; 952 new_fw.scode_nr = 0; 953 new_fw.int_freq = int_freq; 954 955 dprintk(1, "checking firmware, user requested type="); 956 if (debug) { 957 dump_firm_type(new_fw.type); 958 printk(KERN_CONT "(%x), id %016llx, ", new_fw.type, 959 (unsigned long long)new_fw.std_req); 960 if (!int_freq) 961 printk(KERN_CONT "scode_tbl "); 962 else 963 printk(KERN_CONT "int_freq %d, ", new_fw.int_freq); 964 printk(KERN_CONT "scode_nr %d\n", new_fw.scode_nr); 965 } 966 967 /* No need to reload base firmware if it matches */ 968 if (priv->cur_fw.type & BASE) { 969 dprintk(1, "BASE firmware not changed.\n"); 970 goto skip_base; 971 } 972 973 /* Updating BASE - forget about all currently loaded firmware */ 974 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw)); 975 976 /* Reset is needed before loading firmware */ 977 rc = xc4000_tuner_reset(fe); 978 if (rc < 0) 979 goto fail; 980 981 /* BASE firmwares are all std0 */ 982 std0 = 0; 983 rc = load_firmware(fe, BASE, &std0); 984 if (rc < 0) { 985 printk(KERN_ERR "Error %d while loading base firmware\n", rc); 986 goto fail; 987 } 988 989 /* Load INIT1, if needed */ 990 dprintk(1, "Load init1 firmware, if exists\n"); 991 992 rc = load_firmware(fe, BASE | INIT1, &std0); 993 if (rc == -ENOENT) 994 rc = load_firmware(fe, BASE | INIT1, &std0); 995 if (rc < 0 && rc != -ENOENT) { 996 tuner_err("Error %d while loading init1 firmware\n", 997 rc); 998 goto fail; 999 } 1000 1001 skip_base: 1002 /* 1003 * No need to reload standard specific firmware if base firmware 1004 * was not reloaded and requested video standards have not changed. 1005 */ 1006 if (priv->cur_fw.type == (BASE | new_fw.type) && 1007 priv->cur_fw.std_req == std) { 1008 dprintk(1, "Std-specific firmware already loaded.\n"); 1009 goto skip_std_specific; 1010 } 1011 1012 /* Reloading std-specific firmware forces a SCODE update */ 1013 priv->cur_fw.scode_table = 0; 1014 1015 /* Load the standard firmware */ 1016 rc = load_firmware(fe, new_fw.type, &new_fw.id); 1017 1018 if (rc < 0) 1019 goto fail; 1020 1021 skip_std_specific: 1022 if (priv->cur_fw.scode_table == new_fw.scode_table && 1023 priv->cur_fw.scode_nr == new_fw.scode_nr) { 1024 dprintk(1, "SCODE firmware already loaded.\n"); 1025 goto check_device; 1026 } 1027 1028 /* Load SCODE firmware, if exists */ 1029 rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id, 1030 new_fw.int_freq, new_fw.scode_nr); 1031 if (rc != 0) 1032 dprintk(1, "load scode failed %d\n", rc); 1033 1034 check_device: 1035 rc = xc4000_readreg(priv, XREG_PRODUCT_ID, &hwmodel); 1036 1037 if (xc_get_version(priv, &hw_major, &hw_minor, &fw_major, 1038 &fw_minor) != 0) { 1039 printk(KERN_ERR "Unable to read tuner registers.\n"); 1040 goto fail; 1041 } 1042 1043 dprintk(1, "Device is Xceive %d version %d.%d, " 1044 "firmware version %d.%d\n", 1045 hwmodel, hw_major, hw_minor, fw_major, fw_minor); 1046 1047 /* Check firmware version against what we downloaded. */ 1048 if (priv->firm_version != ((fw_major << 8) | fw_minor)) { 1049 printk(KERN_WARNING 1050 "Incorrect readback of firmware version %d.%d.\n", 1051 fw_major, fw_minor); 1052 goto fail; 1053 } 1054 1055 /* Check that the tuner hardware model remains consistent over time. */ 1056 if (priv->hwmodel == 0 && 1057 (hwmodel == XC_PRODUCT_ID_XC4000 || 1058 hwmodel == XC_PRODUCT_ID_XC4100)) { 1059 priv->hwmodel = hwmodel; 1060 priv->hwvers = (hw_major << 8) | hw_minor; 1061 } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel || 1062 priv->hwvers != ((hw_major << 8) | hw_minor)) { 1063 printk(KERN_WARNING 1064 "Read invalid device hardware information - tuner " 1065 "hung?\n"); 1066 goto fail; 1067 } 1068 1069 memcpy(&priv->cur_fw, &new_fw, sizeof(priv->cur_fw)); 1070 1071 /* 1072 * By setting BASE in cur_fw.type only after successfully loading all 1073 * firmwares, we can: 1074 * 1. Identify that BASE firmware with type=0 has been loaded; 1075 * 2. Tell whether BASE firmware was just changed the next time through. 1076 */ 1077 priv->cur_fw.type |= BASE; 1078 1079 return 0; 1080 1081 fail: 1082 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw)); 1083 if (!is_retry) { 1084 msleep(50); 1085 is_retry = 1; 1086 dprintk(1, "Retrying firmware load\n"); 1087 goto retry; 1088 } 1089 1090 if (rc == -ENOENT) 1091 rc = -EINVAL; 1092 return rc; 1093 } 1094 1095 static void xc_debug_dump(struct xc4000_priv *priv) 1096 { 1097 u16 adc_envelope; 1098 u32 freq_error_hz = 0; 1099 u16 lock_status; 1100 u32 hsync_freq_hz = 0; 1101 u16 frame_lines; 1102 u16 quality; 1103 u16 signal = 0; 1104 u16 noise = 0; 1105 u8 hw_majorversion = 0, hw_minorversion = 0; 1106 u8 fw_majorversion = 0, fw_minorversion = 0; 1107 1108 xc_get_adc_envelope(priv, &adc_envelope); 1109 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope); 1110 1111 xc_get_frequency_error(priv, &freq_error_hz); 1112 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz); 1113 1114 xc_get_lock_status(priv, &lock_status); 1115 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n", 1116 lock_status); 1117 1118 xc_get_version(priv, &hw_majorversion, &hw_minorversion, 1119 &fw_majorversion, &fw_minorversion); 1120 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n", 1121 hw_majorversion, hw_minorversion, 1122 fw_majorversion, fw_minorversion); 1123 1124 if (priv->video_standard < XC4000_DTV6) { 1125 xc_get_hsync_freq(priv, &hsync_freq_hz); 1126 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", 1127 hsync_freq_hz); 1128 1129 xc_get_frame_lines(priv, &frame_lines); 1130 dprintk(1, "*** Frame lines = %d\n", frame_lines); 1131 } 1132 1133 xc_get_quality(priv, &quality); 1134 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality); 1135 1136 xc_get_signal_level(priv, &signal); 1137 dprintk(1, "*** Signal level = -%ddB (%d)\n", signal >> 8, signal); 1138 1139 xc_get_noise_level(priv, &noise); 1140 dprintk(1, "*** Noise level = %ddB (%d)\n", noise >> 8, noise); 1141 } 1142 1143 static int xc4000_set_params(struct dvb_frontend *fe) 1144 { 1145 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1146 u32 delsys = c->delivery_system; 1147 u32 bw = c->bandwidth_hz; 1148 struct xc4000_priv *priv = fe->tuner_priv; 1149 unsigned int type; 1150 int ret = -EREMOTEIO; 1151 1152 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, c->frequency); 1153 1154 mutex_lock(&priv->lock); 1155 1156 switch (delsys) { 1157 case SYS_ATSC: 1158 dprintk(1, "%s() VSB modulation\n", __func__); 1159 priv->rf_mode = XC_RF_MODE_AIR; 1160 priv->freq_hz = c->frequency - 1750000; 1161 priv->video_standard = XC4000_DTV6; 1162 type = DTV6; 1163 break; 1164 case SYS_DVBC_ANNEX_B: 1165 dprintk(1, "%s() QAM modulation\n", __func__); 1166 priv->rf_mode = XC_RF_MODE_CABLE; 1167 priv->freq_hz = c->frequency - 1750000; 1168 priv->video_standard = XC4000_DTV6; 1169 type = DTV6; 1170 break; 1171 case SYS_DVBT: 1172 case SYS_DVBT2: 1173 dprintk(1, "%s() OFDM\n", __func__); 1174 if (bw == 0) { 1175 if (c->frequency < 400000000) { 1176 priv->freq_hz = c->frequency - 2250000; 1177 } else { 1178 priv->freq_hz = c->frequency - 2750000; 1179 } 1180 priv->video_standard = XC4000_DTV7_8; 1181 type = DTV78; 1182 } else if (bw <= 6000000) { 1183 priv->video_standard = XC4000_DTV6; 1184 priv->freq_hz = c->frequency - 1750000; 1185 type = DTV6; 1186 } else if (bw <= 7000000) { 1187 priv->video_standard = XC4000_DTV7; 1188 priv->freq_hz = c->frequency - 2250000; 1189 type = DTV7; 1190 } else { 1191 priv->video_standard = XC4000_DTV8; 1192 priv->freq_hz = c->frequency - 2750000; 1193 type = DTV8; 1194 } 1195 priv->rf_mode = XC_RF_MODE_AIR; 1196 break; 1197 default: 1198 printk(KERN_ERR "xc4000 delivery system not supported!\n"); 1199 ret = -EINVAL; 1200 goto fail; 1201 } 1202 1203 dprintk(1, "%s() frequency=%d (compensated)\n", 1204 __func__, priv->freq_hz); 1205 1206 /* Make sure the correct firmware type is loaded */ 1207 if (check_firmware(fe, type, 0, priv->if_khz) != 0) 1208 goto fail; 1209 1210 priv->bandwidth = c->bandwidth_hz; 1211 1212 ret = xc_set_signal_source(priv, priv->rf_mode); 1213 if (ret != 0) { 1214 printk(KERN_ERR "xc4000: xc_set_signal_source(%d) failed\n", 1215 priv->rf_mode); 1216 goto fail; 1217 } else { 1218 u16 video_mode, audio_mode; 1219 video_mode = xc4000_standard[priv->video_standard].video_mode; 1220 audio_mode = xc4000_standard[priv->video_standard].audio_mode; 1221 if (type == DTV6 && priv->firm_version != 0x0102) 1222 video_mode |= 0x0001; 1223 ret = xc_set_tv_standard(priv, video_mode, audio_mode); 1224 if (ret != 0) { 1225 printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n"); 1226 /* DJH - do not return when it fails... */ 1227 /* goto fail; */ 1228 } 1229 } 1230 1231 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0) 1232 ret = 0; 1233 if (priv->dvb_amplitude != 0) { 1234 if (xc_write_reg(priv, XREG_AMPLITUDE, 1235 (priv->firm_version != 0x0102 || 1236 priv->dvb_amplitude != 134 ? 1237 priv->dvb_amplitude : 132)) != 0) 1238 ret = -EREMOTEIO; 1239 } 1240 if (priv->set_smoothedcvbs != 0) { 1241 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0) 1242 ret = -EREMOTEIO; 1243 } 1244 if (ret != 0) { 1245 printk(KERN_ERR "xc4000: setting registers failed\n"); 1246 /* goto fail; */ 1247 } 1248 1249 xc_tune_channel(priv, priv->freq_hz); 1250 1251 ret = 0; 1252 1253 fail: 1254 mutex_unlock(&priv->lock); 1255 1256 return ret; 1257 } 1258 1259 static int xc4000_set_analog_params(struct dvb_frontend *fe, 1260 struct analog_parameters *params) 1261 { 1262 struct xc4000_priv *priv = fe->tuner_priv; 1263 unsigned int type = 0; 1264 int ret = -EREMOTEIO; 1265 1266 if (params->mode == V4L2_TUNER_RADIO) { 1267 dprintk(1, "%s() frequency=%d (in units of 62.5Hz)\n", 1268 __func__, params->frequency); 1269 1270 mutex_lock(&priv->lock); 1271 1272 params->std = 0; 1273 priv->freq_hz = params->frequency * 125L / 2; 1274 1275 if (audio_std & XC4000_AUDIO_STD_INPUT1) { 1276 priv->video_standard = XC4000_FM_Radio_INPUT1; 1277 type = FM | INPUT1; 1278 } else { 1279 priv->video_standard = XC4000_FM_Radio_INPUT2; 1280 type = FM | INPUT2; 1281 } 1282 1283 goto tune_channel; 1284 } 1285 1286 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n", 1287 __func__, params->frequency); 1288 1289 mutex_lock(&priv->lock); 1290 1291 /* params->frequency is in units of 62.5khz */ 1292 priv->freq_hz = params->frequency * 62500; 1293 1294 params->std &= V4L2_STD_ALL; 1295 /* if std is not defined, choose one */ 1296 if (!params->std) 1297 params->std = V4L2_STD_PAL_BG; 1298 1299 if (audio_std & XC4000_AUDIO_STD_MONO) 1300 type = MONO; 1301 1302 if (params->std & V4L2_STD_MN) { 1303 params->std = V4L2_STD_MN; 1304 if (audio_std & XC4000_AUDIO_STD_MONO) { 1305 priv->video_standard = XC4000_MN_NTSC_PAL_Mono; 1306 } else if (audio_std & XC4000_AUDIO_STD_A2) { 1307 params->std |= V4L2_STD_A2; 1308 priv->video_standard = XC4000_MN_NTSC_PAL_A2; 1309 } else { 1310 params->std |= V4L2_STD_BTSC; 1311 priv->video_standard = XC4000_MN_NTSC_PAL_BTSC; 1312 } 1313 goto tune_channel; 1314 } 1315 1316 if (params->std & V4L2_STD_PAL_BG) { 1317 params->std = V4L2_STD_PAL_BG; 1318 if (audio_std & XC4000_AUDIO_STD_MONO) { 1319 priv->video_standard = XC4000_BG_PAL_MONO; 1320 } else if (!(audio_std & XC4000_AUDIO_STD_A2)) { 1321 if (!(audio_std & XC4000_AUDIO_STD_B)) { 1322 params->std |= V4L2_STD_NICAM_A; 1323 priv->video_standard = XC4000_BG_PAL_NICAM; 1324 } else { 1325 params->std |= V4L2_STD_NICAM_B; 1326 priv->video_standard = XC4000_BG_PAL_NICAM; 1327 } 1328 } else { 1329 if (!(audio_std & XC4000_AUDIO_STD_B)) { 1330 params->std |= V4L2_STD_A2_A; 1331 priv->video_standard = XC4000_BG_PAL_A2; 1332 } else { 1333 params->std |= V4L2_STD_A2_B; 1334 priv->video_standard = XC4000_BG_PAL_A2; 1335 } 1336 } 1337 goto tune_channel; 1338 } 1339 1340 if (params->std & V4L2_STD_PAL_I) { 1341 /* default to NICAM audio standard */ 1342 params->std = V4L2_STD_PAL_I | V4L2_STD_NICAM; 1343 if (audio_std & XC4000_AUDIO_STD_MONO) 1344 priv->video_standard = XC4000_I_PAL_NICAM_MONO; 1345 else 1346 priv->video_standard = XC4000_I_PAL_NICAM; 1347 goto tune_channel; 1348 } 1349 1350 if (params->std & V4L2_STD_PAL_DK) { 1351 params->std = V4L2_STD_PAL_DK; 1352 if (audio_std & XC4000_AUDIO_STD_MONO) { 1353 priv->video_standard = XC4000_DK_PAL_MONO; 1354 } else if (audio_std & XC4000_AUDIO_STD_A2) { 1355 params->std |= V4L2_STD_A2; 1356 priv->video_standard = XC4000_DK_PAL_A2; 1357 } else { 1358 params->std |= V4L2_STD_NICAM; 1359 priv->video_standard = XC4000_DK_PAL_NICAM; 1360 } 1361 goto tune_channel; 1362 } 1363 1364 if (params->std & V4L2_STD_SECAM_DK) { 1365 /* default to A2 audio standard */ 1366 params->std = V4L2_STD_SECAM_DK | V4L2_STD_A2; 1367 if (audio_std & XC4000_AUDIO_STD_L) { 1368 type = 0; 1369 priv->video_standard = XC4000_DK_SECAM_NICAM; 1370 } else if (audio_std & XC4000_AUDIO_STD_MONO) { 1371 priv->video_standard = XC4000_DK_SECAM_A2MONO; 1372 } else if (audio_std & XC4000_AUDIO_STD_K3) { 1373 params->std |= V4L2_STD_SECAM_K3; 1374 priv->video_standard = XC4000_DK_SECAM_A2LDK3; 1375 } else { 1376 priv->video_standard = XC4000_DK_SECAM_A2DK1; 1377 } 1378 goto tune_channel; 1379 } 1380 1381 if (params->std & V4L2_STD_SECAM_L) { 1382 /* default to NICAM audio standard */ 1383 type = 0; 1384 params->std = V4L2_STD_SECAM_L | V4L2_STD_NICAM; 1385 priv->video_standard = XC4000_L_SECAM_NICAM; 1386 goto tune_channel; 1387 } 1388 1389 if (params->std & V4L2_STD_SECAM_LC) { 1390 /* default to NICAM audio standard */ 1391 type = 0; 1392 params->std = V4L2_STD_SECAM_LC | V4L2_STD_NICAM; 1393 priv->video_standard = XC4000_LC_SECAM_NICAM; 1394 goto tune_channel; 1395 } 1396 1397 tune_channel: 1398 /* FIXME: it could be air. */ 1399 priv->rf_mode = XC_RF_MODE_CABLE; 1400 1401 if (check_firmware(fe, type, params->std, 1402 xc4000_standard[priv->video_standard].int_freq) != 0) 1403 goto fail; 1404 1405 ret = xc_set_signal_source(priv, priv->rf_mode); 1406 if (ret != 0) { 1407 printk(KERN_ERR 1408 "xc4000: xc_set_signal_source(%d) failed\n", 1409 priv->rf_mode); 1410 goto fail; 1411 } else { 1412 u16 video_mode, audio_mode; 1413 video_mode = xc4000_standard[priv->video_standard].video_mode; 1414 audio_mode = xc4000_standard[priv->video_standard].audio_mode; 1415 if (priv->video_standard < XC4000_BG_PAL_A2) { 1416 if (type & NOGD) 1417 video_mode &= 0xFF7F; 1418 } else if (priv->video_standard < XC4000_I_PAL_NICAM) { 1419 if (priv->firm_version == 0x0102) 1420 video_mode &= 0xFEFF; 1421 if (audio_std & XC4000_AUDIO_STD_B) 1422 video_mode |= 0x0080; 1423 } 1424 ret = xc_set_tv_standard(priv, video_mode, audio_mode); 1425 if (ret != 0) { 1426 printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n"); 1427 goto fail; 1428 } 1429 } 1430 1431 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0) 1432 ret = 0; 1433 if (xc_write_reg(priv, XREG_AMPLITUDE, 1) != 0) 1434 ret = -EREMOTEIO; 1435 if (priv->set_smoothedcvbs != 0) { 1436 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0) 1437 ret = -EREMOTEIO; 1438 } 1439 if (ret != 0) { 1440 printk(KERN_ERR "xc4000: setting registers failed\n"); 1441 goto fail; 1442 } 1443 1444 xc_tune_channel(priv, priv->freq_hz); 1445 1446 ret = 0; 1447 1448 fail: 1449 mutex_unlock(&priv->lock); 1450 1451 return ret; 1452 } 1453 1454 static int xc4000_get_signal(struct dvb_frontend *fe, u16 *strength) 1455 { 1456 struct xc4000_priv *priv = fe->tuner_priv; 1457 u16 value = 0; 1458 int rc; 1459 1460 mutex_lock(&priv->lock); 1461 rc = xc4000_readreg(priv, XREG_SIGNAL_LEVEL, &value); 1462 mutex_unlock(&priv->lock); 1463 1464 if (rc < 0) 1465 goto ret; 1466 1467 /* Informations from real testing of DVB-T and radio part, 1468 coeficient for one dB is 0xff. 1469 */ 1470 tuner_dbg("Signal strength: -%ddB (%05d)\n", value >> 8, value); 1471 1472 /* all known digital modes */ 1473 if ((priv->video_standard == XC4000_DTV6) || 1474 (priv->video_standard == XC4000_DTV7) || 1475 (priv->video_standard == XC4000_DTV7_8) || 1476 (priv->video_standard == XC4000_DTV8)) 1477 goto digital; 1478 1479 /* Analog mode has NOISE LEVEL important, signal 1480 depends only on gain of antenna and amplifiers, 1481 but it doesn't tell anything about real quality 1482 of reception. 1483 */ 1484 mutex_lock(&priv->lock); 1485 rc = xc4000_readreg(priv, XREG_NOISE_LEVEL, &value); 1486 mutex_unlock(&priv->lock); 1487 1488 tuner_dbg("Noise level: %ddB (%05d)\n", value >> 8, value); 1489 1490 /* highest noise level: 32dB */ 1491 if (value >= 0x2000) { 1492 value = 0; 1493 } else { 1494 value = ~value << 3; 1495 } 1496 1497 goto ret; 1498 1499 /* Digital mode has SIGNAL LEVEL important and real 1500 noise level is stored in demodulator registers. 1501 */ 1502 digital: 1503 /* best signal: -50dB */ 1504 if (value <= 0x3200) { 1505 value = 0xffff; 1506 /* minimum: -114dB - should be 0x7200 but real zero is 0x713A */ 1507 } else if (value >= 0x713A) { 1508 value = 0; 1509 } else { 1510 value = ~(value - 0x3200) << 2; 1511 } 1512 1513 ret: 1514 *strength = value; 1515 1516 return rc; 1517 } 1518 1519 static int xc4000_get_frequency(struct dvb_frontend *fe, u32 *freq) 1520 { 1521 struct xc4000_priv *priv = fe->tuner_priv; 1522 1523 *freq = priv->freq_hz; 1524 1525 if (debug) { 1526 mutex_lock(&priv->lock); 1527 if ((priv->cur_fw.type 1528 & (BASE | FM | DTV6 | DTV7 | DTV78 | DTV8)) == BASE) { 1529 u16 snr = 0; 1530 if (xc4000_readreg(priv, XREG_SNR, &snr) == 0) { 1531 mutex_unlock(&priv->lock); 1532 dprintk(1, "%s() freq = %u, SNR = %d\n", 1533 __func__, *freq, snr); 1534 return 0; 1535 } 1536 } 1537 mutex_unlock(&priv->lock); 1538 } 1539 1540 dprintk(1, "%s()\n", __func__); 1541 1542 return 0; 1543 } 1544 1545 static int xc4000_get_bandwidth(struct dvb_frontend *fe, u32 *bw) 1546 { 1547 struct xc4000_priv *priv = fe->tuner_priv; 1548 dprintk(1, "%s()\n", __func__); 1549 1550 *bw = priv->bandwidth; 1551 return 0; 1552 } 1553 1554 static int xc4000_get_status(struct dvb_frontend *fe, u32 *status) 1555 { 1556 struct xc4000_priv *priv = fe->tuner_priv; 1557 u16 lock_status = 0; 1558 1559 mutex_lock(&priv->lock); 1560 1561 if (priv->cur_fw.type & BASE) 1562 xc_get_lock_status(priv, &lock_status); 1563 1564 *status = (lock_status == 1 ? 1565 TUNER_STATUS_LOCKED | TUNER_STATUS_STEREO : 0); 1566 if (priv->cur_fw.type & (DTV6 | DTV7 | DTV78 | DTV8)) 1567 *status &= (~TUNER_STATUS_STEREO); 1568 1569 mutex_unlock(&priv->lock); 1570 1571 dprintk(2, "%s() lock_status = %d\n", __func__, lock_status); 1572 1573 return 0; 1574 } 1575 1576 static int xc4000_sleep(struct dvb_frontend *fe) 1577 { 1578 struct xc4000_priv *priv = fe->tuner_priv; 1579 int ret = 0; 1580 1581 dprintk(1, "%s()\n", __func__); 1582 1583 mutex_lock(&priv->lock); 1584 1585 /* Avoid firmware reload on slow devices */ 1586 if ((no_poweroff == 2 || 1587 (no_poweroff == 0 && priv->default_pm != 0)) && 1588 (priv->cur_fw.type & BASE) != 0) { 1589 /* force reset and firmware reload */ 1590 priv->cur_fw.type = XC_POWERED_DOWN; 1591 1592 if (xc_write_reg(priv, XREG_POWER_DOWN, 0) != 0) { 1593 printk(KERN_ERR 1594 "xc4000: %s() unable to shutdown tuner\n", 1595 __func__); 1596 ret = -EREMOTEIO; 1597 } 1598 msleep(20); 1599 } 1600 1601 mutex_unlock(&priv->lock); 1602 1603 return ret; 1604 } 1605 1606 static int xc4000_init(struct dvb_frontend *fe) 1607 { 1608 dprintk(1, "%s()\n", __func__); 1609 1610 return 0; 1611 } 1612 1613 static int xc4000_release(struct dvb_frontend *fe) 1614 { 1615 struct xc4000_priv *priv = fe->tuner_priv; 1616 1617 dprintk(1, "%s()\n", __func__); 1618 1619 mutex_lock(&xc4000_list_mutex); 1620 1621 if (priv) 1622 hybrid_tuner_release_state(priv); 1623 1624 mutex_unlock(&xc4000_list_mutex); 1625 1626 fe->tuner_priv = NULL; 1627 1628 return 0; 1629 } 1630 1631 static const struct dvb_tuner_ops xc4000_tuner_ops = { 1632 .info = { 1633 .name = "Xceive XC4000", 1634 .frequency_min = 1000000, 1635 .frequency_max = 1023000000, 1636 .frequency_step = 50000, 1637 }, 1638 1639 .release = xc4000_release, 1640 .init = xc4000_init, 1641 .sleep = xc4000_sleep, 1642 1643 .set_params = xc4000_set_params, 1644 .set_analog_params = xc4000_set_analog_params, 1645 .get_frequency = xc4000_get_frequency, 1646 .get_rf_strength = xc4000_get_signal, 1647 .get_bandwidth = xc4000_get_bandwidth, 1648 .get_status = xc4000_get_status 1649 }; 1650 1651 struct dvb_frontend *xc4000_attach(struct dvb_frontend *fe, 1652 struct i2c_adapter *i2c, 1653 struct xc4000_config *cfg) 1654 { 1655 struct xc4000_priv *priv = NULL; 1656 int instance; 1657 u16 id = 0; 1658 1659 dprintk(1, "%s(%d-%04x)\n", __func__, 1660 i2c ? i2c_adapter_id(i2c) : -1, 1661 cfg ? cfg->i2c_address : -1); 1662 1663 mutex_lock(&xc4000_list_mutex); 1664 1665 instance = hybrid_tuner_request_state(struct xc4000_priv, priv, 1666 hybrid_tuner_instance_list, 1667 i2c, cfg->i2c_address, "xc4000"); 1668 switch (instance) { 1669 case 0: 1670 goto fail; 1671 break; 1672 case 1: 1673 /* new tuner instance */ 1674 priv->bandwidth = 6000000; 1675 /* set default configuration */ 1676 priv->if_khz = 4560; 1677 priv->default_pm = 0; 1678 priv->dvb_amplitude = 134; 1679 priv->set_smoothedcvbs = 1; 1680 mutex_init(&priv->lock); 1681 fe->tuner_priv = priv; 1682 break; 1683 default: 1684 /* existing tuner instance */ 1685 fe->tuner_priv = priv; 1686 break; 1687 } 1688 1689 if (cfg->if_khz != 0) { 1690 /* copy configuration if provided by the caller */ 1691 priv->if_khz = cfg->if_khz; 1692 priv->default_pm = cfg->default_pm; 1693 priv->dvb_amplitude = cfg->dvb_amplitude; 1694 priv->set_smoothedcvbs = cfg->set_smoothedcvbs; 1695 } 1696 1697 /* Check if firmware has been loaded. It is possible that another 1698 instance of the driver has loaded the firmware. 1699 */ 1700 1701 if (instance == 1) { 1702 if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id) != 0) 1703 goto fail; 1704 } else { 1705 id = ((priv->cur_fw.type & BASE) != 0 ? 1706 priv->hwmodel : XC_PRODUCT_ID_FW_NOT_LOADED); 1707 } 1708 1709 switch (id) { 1710 case XC_PRODUCT_ID_XC4000: 1711 case XC_PRODUCT_ID_XC4100: 1712 printk(KERN_INFO 1713 "xc4000: Successfully identified at address 0x%02x\n", 1714 cfg->i2c_address); 1715 printk(KERN_INFO 1716 "xc4000: Firmware has been loaded previously\n"); 1717 break; 1718 case XC_PRODUCT_ID_FW_NOT_LOADED: 1719 printk(KERN_INFO 1720 "xc4000: Successfully identified at address 0x%02x\n", 1721 cfg->i2c_address); 1722 printk(KERN_INFO 1723 "xc4000: Firmware has not been loaded previously\n"); 1724 break; 1725 default: 1726 printk(KERN_ERR 1727 "xc4000: Device not found at addr 0x%02x (0x%x)\n", 1728 cfg->i2c_address, id); 1729 goto fail; 1730 } 1731 1732 mutex_unlock(&xc4000_list_mutex); 1733 1734 memcpy(&fe->ops.tuner_ops, &xc4000_tuner_ops, 1735 sizeof(struct dvb_tuner_ops)); 1736 1737 if (instance == 1) { 1738 int ret; 1739 mutex_lock(&priv->lock); 1740 ret = xc4000_fwupload(fe); 1741 mutex_unlock(&priv->lock); 1742 if (ret != 0) 1743 goto fail2; 1744 } 1745 1746 return fe; 1747 fail: 1748 mutex_unlock(&xc4000_list_mutex); 1749 fail2: 1750 xc4000_release(fe); 1751 return NULL; 1752 } 1753 EXPORT_SYMBOL(xc4000_attach); 1754 1755 MODULE_AUTHOR("Steven Toth, Davide Ferri"); 1756 MODULE_DESCRIPTION("Xceive xc4000 silicon tuner driver"); 1757 MODULE_LICENSE("GPL"); 1758