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