Lines Matching refs:priv
237 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val);
239 static void xc_debug_dump(struct xc4000_priv *priv);
241 static int xc_send_i2c_data(struct xc4000_priv *priv, u8 *buf, int len)
243 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
245 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
246 if (priv->ignore_i2c_write_errors == 0) {
260 struct xc4000_priv *priv = fe->tuner_priv;
266 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
267 fe->dvb->priv :
268 priv->i2c_props.adap->algo_data,
282 static int xc_write_reg(struct xc4000_priv *priv, u16 regAddr, u16 i2cData)
291 return xc_send_i2c_data(priv, buf, 4);
296 struct xc4000_priv *priv = fe->tuner_priv;
333 result = xc_send_i2c_data(priv, buf,
347 static int xc_set_tv_standard(struct xc4000_priv *priv,
354 xc4000_standard[priv->video_standard].Name);
357 priv->ignore_i2c_write_errors = 1;
359 ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode);
361 ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode);
363 priv->ignore_i2c_write_errors = 0;
368 static int xc_set_signal_source(struct xc4000_priv *priv, u16 rf_mode)
379 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
384 static int xc_set_rf_frequency(struct xc4000_priv *priv, u32 freq_hz)
400 return xc_write_reg(priv, XREG_RF_FREQ, freq_code);
403 static int xc_get_adc_envelope(struct xc4000_priv *priv, u16 *adc_envelope)
405 return xc4000_readreg(priv, XREG_ADC_ENV, adc_envelope);
408 static int xc_get_frequency_error(struct xc4000_priv *priv, u32 *freq_error_hz)
414 result = xc4000_readreg(priv, XREG_FREQ_ERROR, ®Data);
424 static int xc_get_lock_status(struct xc4000_priv *priv, u16 *lock_status)
426 return xc4000_readreg(priv, XREG_LOCK, lock_status);
429 static int xc_get_version(struct xc4000_priv *priv,
436 result = xc4000_readreg(priv, XREG_VERSION, &data);
448 static int xc_get_hsync_freq(struct xc4000_priv *priv, u32 *hsync_freq_hz)
453 result = xc4000_readreg(priv, XREG_HSYNC_FREQ, ®Data);
461 static int xc_get_frame_lines(struct xc4000_priv *priv, u16 *frame_lines)
463 return xc4000_readreg(priv, XREG_FRAME_LINES, frame_lines);
466 static int xc_get_quality(struct xc4000_priv *priv, u16 *quality)
468 return xc4000_readreg(priv, XREG_QUALITY, quality);
471 static int xc_get_signal_level(struct xc4000_priv *priv, u16 *signal)
473 return xc4000_readreg(priv, XREG_SIGNAL_LEVEL, signal);
476 static int xc_get_noise_level(struct xc4000_priv *priv, u16 *noise)
478 return xc4000_readreg(priv, XREG_NOISE_LEVEL, noise);
481 static u16 xc_wait_for_lock(struct xc4000_priv *priv)
487 xc_get_lock_status(priv, &lock_state);
496 static int xc_tune_channel(struct xc4000_priv *priv, u32 freq_hz)
504 priv->ignore_i2c_write_errors = 1;
505 result = xc_set_rf_frequency(priv, freq_hz);
506 priv->ignore_i2c_write_errors = 0;
512 if ((priv->cur_fw.type & (FM | DTV6 | DTV7 | DTV78 | DTV8)) == 0) {
513 if (xc_wait_for_lock(priv) != 1)
524 xc_debug_dump(priv);
529 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val)
534 { .addr = priv->i2c_props.addr,
536 { .addr = priv->i2c_props.addr,
540 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
619 struct xc4000_priv *priv = fe->tuner_priv;
623 if (!priv->firm) {
632 for (i = 0; i < priv->firm_size; i++) {
634 (priv->firm[i].id ^ (*id)) & (*id);
636 (priv->firm[i].type ^ type)
668 *id = priv->firm[i].id;
683 struct xc4000_priv *priv = fe->tuner_priv;
691 p = priv->firm[pos].ptr;
694 priv->ignore_i2c_write_errors = 1;
698 priv->ignore_i2c_write_errors = 0;
705 struct xc4000_priv *priv = fe->tuner_priv;
718 priv->i2c_props.adap->dev.parent);
723 priv->i2c_props.adap->dev.parent);
728 priv->i2c_props.adap->dev.parent);
756 priv->firm_version = get_unaligned_le16(p);
764 priv->firm_version >> 8, priv->firm_version & 0xff);
766 priv->firm = kcalloc(n_array, sizeof(*priv->firm), GFP_KERNEL);
767 if (priv->firm == NULL) {
772 priv->firm_size = n_array;
813 priv->firm[n].ptr = kmemdup(p, size, GFP_KERNEL);
814 if (priv->firm[n].ptr == NULL) {
827 priv->firm[n].type = type;
828 priv->firm[n].id = id;
829 priv->firm[n].size = size;
830 priv->firm[n].int_freq = int_freq;
835 if (n + 1 != priv->firm_size) {
859 struct xc4000_priv *priv = fe->tuner_priv;
872 for (pos = 0; pos < priv->firm_size; pos++) {
873 if ((priv->firm[pos].int_freq == int_freq) &&
874 (priv->firm[pos].type & HAS_IF))
877 if (pos == priv->firm_size)
881 p = priv->firm[pos].ptr;
883 if (priv->firm[pos].size != 12 * 16 || scode >= 16)
889 dump_firm_type_and_int_freq(priv->firm[pos].type,
890 priv->firm[pos].int_freq);
891 printk(KERN_CONT "(%x), id %016llx.\n", priv->firm[pos].type,
899 rc = xc_write_reg(priv, XREG_DIRECTSITTING_MODE, 0);
905 rc = xc_send_i2c_data(priv, scode_buf, 13);
915 xc_send_i2c_data(priv, indirect_mode, sizeof(indirect_mode));
924 struct xc4000_priv *priv = fe->tuner_priv;
933 if (!priv->firm) {
960 if (priv->cur_fw.type & BASE) {
966 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
998 if (priv->cur_fw.type == (BASE | new_fw.type) &&
999 priv->cur_fw.std_req == std) {
1005 priv->cur_fw.scode_table = 0;
1014 if (priv->cur_fw.scode_table == new_fw.scode_table &&
1015 priv->cur_fw.scode_nr == new_fw.scode_nr) {
1027 if (xc4000_readreg(priv, XREG_PRODUCT_ID, &hwmodel) < 0) {
1032 if (xc_get_version(priv, &hw_major, &hw_minor, &fw_major,
1042 if (priv->firm_version != ((fw_major << 8) | fw_minor)) {
1050 if (priv->hwmodel == 0 &&
1053 priv->hwmodel = hwmodel;
1054 priv->hwvers = (hw_major << 8) | hw_minor;
1055 } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
1056 priv->hwvers != ((hw_major << 8) | hw_minor)) {
1062 priv->cur_fw = new_fw;
1070 priv->cur_fw.type |= BASE;
1075 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
1088 static void xc_debug_dump(struct xc4000_priv *priv)
1101 xc_get_adc_envelope(priv, &adc_envelope);
1104 xc_get_frequency_error(priv, &freq_error_hz);
1107 xc_get_lock_status(priv, &lock_status);
1111 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
1117 if (priv->video_standard < XC4000_DTV6) {
1118 xc_get_hsync_freq(priv, &hsync_freq_hz);
1122 xc_get_frame_lines(priv, &frame_lines);
1126 xc_get_quality(priv, &quality);
1129 xc_get_signal_level(priv, &signal);
1132 xc_get_noise_level(priv, &noise);
1141 struct xc4000_priv *priv = fe->tuner_priv;
1147 mutex_lock(&priv->lock);
1152 priv->rf_mode = XC_RF_MODE_AIR;
1153 priv->freq_offset = 1750000;
1154 priv->video_standard = XC4000_DTV6;
1159 priv->rf_mode = XC_RF_MODE_CABLE;
1160 priv->freq_offset = 1750000;
1161 priv->video_standard = XC4000_DTV6;
1169 priv->freq_offset = 2250000;
1171 priv->freq_offset = 2750000;
1173 priv->video_standard = XC4000_DTV7_8;
1176 priv->video_standard = XC4000_DTV6;
1177 priv->freq_offset = 1750000;
1180 priv->video_standard = XC4000_DTV7;
1181 priv->freq_offset = 2250000;
1184 priv->video_standard = XC4000_DTV8;
1185 priv->freq_offset = 2750000;
1188 priv->rf_mode = XC_RF_MODE_AIR;
1196 priv->freq_hz = c->frequency - priv->freq_offset;
1199 __func__, priv->freq_hz);
1202 if (check_firmware(fe, type, 0, priv->if_khz) != 0)
1205 priv->bandwidth = c->bandwidth_hz;
1207 ret = xc_set_signal_source(priv, priv->rf_mode);
1210 priv->rf_mode);
1214 video_mode = xc4000_standard[priv->video_standard].video_mode;
1215 audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1216 if (type == DTV6 && priv->firm_version != 0x0102)
1218 ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1226 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1228 if (priv->dvb_amplitude != 0) {
1229 if (xc_write_reg(priv, XREG_AMPLITUDE,
1230 (priv->firm_version != 0x0102 ||
1231 priv->dvb_amplitude != 134 ?
1232 priv->dvb_amplitude : 132)) != 0)
1235 if (priv->set_smoothedcvbs != 0) {
1236 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1244 xc_tune_channel(priv, priv->freq_hz);
1249 mutex_unlock(&priv->lock);
1257 struct xc4000_priv *priv = fe->tuner_priv;
1265 mutex_lock(&priv->lock);
1268 priv->freq_hz = params->frequency * 125L / 2;
1271 priv->video_standard = XC4000_FM_Radio_INPUT1;
1274 priv->video_standard = XC4000_FM_Radio_INPUT2;
1284 mutex_lock(&priv->lock);
1287 priv->freq_hz = params->frequency * 62500;
1300 priv->video_standard = XC4000_MN_NTSC_PAL_Mono;
1303 priv->video_standard = XC4000_MN_NTSC_PAL_A2;
1306 priv->video_standard = XC4000_MN_NTSC_PAL_BTSC;
1314 priv->video_standard = XC4000_BG_PAL_MONO;
1318 priv->video_standard = XC4000_BG_PAL_NICAM;
1321 priv->video_standard = XC4000_BG_PAL_NICAM;
1326 priv->video_standard = XC4000_BG_PAL_A2;
1329 priv->video_standard = XC4000_BG_PAL_A2;
1339 priv->video_standard = XC4000_I_PAL_NICAM_MONO;
1341 priv->video_standard = XC4000_I_PAL_NICAM;
1348 priv->video_standard = XC4000_DK_PAL_MONO;
1351 priv->video_standard = XC4000_DK_PAL_A2;
1354 priv->video_standard = XC4000_DK_PAL_NICAM;
1364 priv->video_standard = XC4000_DK_SECAM_NICAM;
1366 priv->video_standard = XC4000_DK_SECAM_A2MONO;
1369 priv->video_standard = XC4000_DK_SECAM_A2LDK3;
1371 priv->video_standard = XC4000_DK_SECAM_A2DK1;
1380 priv->video_standard = XC4000_L_SECAM_NICAM;
1388 priv->video_standard = XC4000_LC_SECAM_NICAM;
1394 priv->rf_mode = XC_RF_MODE_CABLE;
1397 xc4000_standard[priv->video_standard].int_freq) != 0)
1400 ret = xc_set_signal_source(priv, priv->rf_mode);
1404 priv->rf_mode);
1408 video_mode = xc4000_standard[priv->video_standard].video_mode;
1409 audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1410 if (priv->video_standard < XC4000_BG_PAL_A2) {
1413 } else if (priv->video_standard < XC4000_I_PAL_NICAM) {
1414 if (priv->firm_version == 0x0102)
1419 ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1426 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1428 if (xc_write_reg(priv, XREG_AMPLITUDE, 1) != 0)
1430 if (priv->set_smoothedcvbs != 0) {
1431 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1439 xc_tune_channel(priv, priv->freq_hz);
1444 mutex_unlock(&priv->lock);
1451 struct xc4000_priv *priv = fe->tuner_priv;
1455 mutex_lock(&priv->lock);
1456 rc = xc4000_readreg(priv, XREG_SIGNAL_LEVEL, &value);
1457 mutex_unlock(&priv->lock);
1468 if ((priv->video_standard == XC4000_DTV6) ||
1469 (priv->video_standard == XC4000_DTV7) ||
1470 (priv->video_standard == XC4000_DTV7_8) ||
1471 (priv->video_standard == XC4000_DTV8))
1479 mutex_lock(&priv->lock);
1480 rc = xc4000_readreg(priv, XREG_NOISE_LEVEL, &value);
1481 mutex_unlock(&priv->lock);
1516 struct xc4000_priv *priv = fe->tuner_priv;
1518 mutex_lock(&priv->lock);
1519 *freq = priv->freq_hz + priv->freq_offset;
1522 if ((priv->cur_fw.type
1525 if (xc4000_readreg(priv, XREG_SNR, &snr) == 0) {
1526 mutex_unlock(&priv->lock);
1533 mutex_unlock(&priv->lock);
1542 struct xc4000_priv *priv = fe->tuner_priv;
1545 *bw = priv->bandwidth;
1551 struct xc4000_priv *priv = fe->tuner_priv;
1554 mutex_lock(&priv->lock);
1556 if (priv->cur_fw.type & BASE)
1557 xc_get_lock_status(priv, &lock_status);
1561 if (priv->cur_fw.type & (DTV6 | DTV7 | DTV78 | DTV8))
1564 mutex_unlock(&priv->lock);
1573 struct xc4000_priv *priv = fe->tuner_priv;
1578 mutex_lock(&priv->lock);
1582 (no_poweroff == 0 && priv->default_pm != 0)) &&
1583 (priv->cur_fw.type & BASE) != 0) {
1585 priv->cur_fw.type = XC_POWERED_DOWN;
1587 if (xc_write_reg(priv, XREG_POWER_DOWN, 0) != 0) {
1596 mutex_unlock(&priv->lock);
1610 struct xc4000_priv *priv = fe->tuner_priv;
1616 if (priv)
1617 hybrid_tuner_release_state(priv);
1648 struct xc4000_priv *priv = NULL;
1658 instance = hybrid_tuner_request_state(struct xc4000_priv, priv,
1666 priv->bandwidth = 6000000;
1668 priv->if_khz = 4560;
1669 priv->default_pm = 0;
1670 priv->dvb_amplitude = 134;
1671 priv->set_smoothedcvbs = 1;
1672 mutex_init(&priv->lock);
1673 fe->tuner_priv = priv;
1677 fe->tuner_priv = priv;
1683 priv->if_khz = cfg->if_khz;
1684 priv->default_pm = cfg->default_pm;
1685 priv->dvb_amplitude = cfg->dvb_amplitude;
1686 priv->set_smoothedcvbs = cfg->set_smoothedcvbs;
1694 if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1697 id = ((priv->cur_fw.type & BASE) != 0 ?
1698 priv->hwmodel : XC_PRODUCT_ID_FW_NOT_LOADED);
1731 mutex_lock(&priv->lock);
1733 mutex_unlock(&priv->lock);