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