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