* Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
* Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
* Copyright (c) 2009 Davide Ferri <d.ferri@zero11.it>
+ * Copyright (c) 2010 Istvan Varga <istvan_v@mailbox.hu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
static int debug;
module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "\n\t\tDebugging level (0 to 2, default: 0 (off)).");
+MODULE_PARM_DESC(debug, "Debugging level (0 to 2, default: 0 (off)).");
static int no_poweroff;
module_param(no_poweroff, int, 0644);
-MODULE_PARM_DESC(no_poweroff, "\n\t\t1: keep device energized and with tuner "
- "ready all the times.\n"
- "\t\tFaster, but consumes more power and keeps the device hotter.\n"
- "\t\t2: powers device off when not used.\n"
- "\t\t0 (default): use device-specific default mode.");
-
-#define XC4000_AUDIO_STD_B 1
-#define XC4000_AUDIO_STD_A2 2
-#define XC4000_AUDIO_STD_K3 4
-#define XC4000_AUDIO_STD_L 8
-#define XC4000_AUDIO_STD_INPUT1 16
-#define XC4000_AUDIO_STD_MONO 32
+MODULE_PARM_DESC(no_poweroff, "Power management (1: disabled, 2: enabled, "
+ "0 (default): use device-specific default mode).");
static int audio_std;
module_param(audio_std, int, 0644);
-MODULE_PARM_DESC(audio_std, "\n\t\tAudio standard. XC4000 audio decoder "
- "explicitly needs to know\n"
- "\t\twhat audio standard is needed for some video standards with\n"
- "\t\taudio A2 or NICAM.\n"
- "\t\tThe valid settings are a sum of:\n"
- "\t\t 1: use NICAM/B or A2/B instead of NICAM/A or A2/A\n"
- "\t\t 2: use A2 instead of NICAM or BTSC\n"
- "\t\t 4: use SECAM/K3 instead of K1\n"
- "\t\t 8: use PAL-D/K audio for SECAM-D/K\n"
- "\t\t16: use FM radio input 1 instead of input 2\n"
- "\t\t32: use mono audio (the lower three bits are ignored)");
-
-#define XC4000_DEFAULT_FIRMWARE "xc4000.fw"
+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"
+ " 1: use NICAM/B or A2/B instead of NICAM/A or A2/A\n"
+ " 2: use A2 instead of NICAM or BTSC\n"
+ " 4: use SECAM/K3 instead of K1\n"
+ " 8: use PAL-D/K audio for SECAM-D/K\n"
+ "16: use FM radio input 1 instead of input 2\n"
+ "32: use mono audio (the lower three bits are ignored)");
static char firmware_name[30];
module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
-MODULE_PARM_DESC(firmware_name, "\n\t\tFirmware file name. Allows overriding "
- "the default firmware\n"
- "\t\tname.");
+MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the "
+ "default firmware name.");
static DEFINE_MUTEX(xc4000_list_mutex);
static LIST_HEAD(hybrid_tuner_instance_list);
u8 rf_mode;
u8 card_type;
u8 ignore_i2c_write_errors;
- /* struct xc2028_ctrl ctrl; */
struct firmware_properties cur_fw;
__u16 hwmodel;
__u16 hwvers;
struct mutex lock;
};
+#define XC4000_AUDIO_STD_B 1
+#define XC4000_AUDIO_STD_A2 2
+#define XC4000_AUDIO_STD_K3 4
+#define XC4000_AUDIO_STD_L 8
+#define XC4000_AUDIO_STD_INPUT1 16
+#define XC4000_AUDIO_STD_MONO 32
+
+#define XC4000_DEFAULT_FIRMWARE "dvb-fe-xc4000-1.4.fw"
+
/* Misc Defines */
#define MAX_TV_STANDARD 24
#define XC_MAX_I2C_WRITE_LENGTH 64
#define XC_RF_MODE_AIR 0
#define XC_RF_MODE_CABLE 1
-/* Result codes */
-#define XC_RESULT_SUCCESS 0
-#define XC_RESULT_RESET_FAILURE 1
-#define XC_RESULT_I2C_WRITE_FAILURE 2
-#define XC_RESULT_I2C_READ_FAILURE 3
-#define XC_RESULT_OUT_OF_RANGE 5
-
/* Product id */
#define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
#define XC_PRODUCT_ID_XC4000 0x0FA0
struct XC_TV_STANDARD {
const char *Name;
- u16 AudioMode;
- u16 VideoMode;
+ u16 audio_mode;
+ u16 video_mode;
u16 int_freq;
};
#define XC4000_FM_Radio_INPUT2 22
#define XC4000_FM_Radio_INPUT1 23
-static struct XC_TV_STANDARD XC4000_Standard[MAX_TV_STANDARD] = {
+static struct XC_TV_STANDARD xc4000_standard[MAX_TV_STANDARD] = {
{"M/N-NTSC/PAL-BTSC", 0x0000, 0x80A0, 4500},
{"M/N-NTSC/PAL-A2", 0x0000, 0x80A0, 4600},
{"M/N-NTSC/PAL-EIAJ", 0x0040, 0x80A0, 4500},
};
static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val);
-static int xc4000_TunerReset(struct dvb_frontend *fe);
+static int xc4000_tuner_reset(struct dvb_frontend *fe);
static void xc_debug_dump(struct xc4000_priv *priv);
static int xc_send_i2c_data(struct xc4000_priv *priv, u8 *buf, int len)
printk("bytes %02x %02x %02x %02x\n", buf[0],
buf[1], buf[2], buf[3]);
}
- return XC_RESULT_I2C_WRITE_FAILURE;
+ return -EREMOTEIO;
}
}
- return XC_RESULT_SUCCESS;
-}
-
-static void xc_wait(int wait_ms)
-{
- msleep(wait_ms);
+ return 0;
}
-static int xc4000_TunerReset(struct dvb_frontend *fe)
+static int xc4000_tuner_reset(struct dvb_frontend *fe)
{
struct xc4000_priv *priv = fe->tuner_priv;
int ret;
XC4000_TUNER_RESET, 0);
if (ret) {
printk(KERN_ERR "xc4000: reset failed\n");
- return XC_RESULT_RESET_FAILURE;
+ return -EREMOTEIO;
}
} else {
- printk(KERN_ERR "xc4000: no tuner reset callback function, fatal\n");
- return XC_RESULT_RESET_FAILURE;
+ printk(KERN_ERR "xc4000: no tuner reset callback function, "
+ "fatal\n");
+ return -EINVAL;
}
- return XC_RESULT_SUCCESS;
+ return 0;
}
static int xc_write_reg(struct xc4000_priv *priv, u16 regAddr, u16 i2cData)
len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
if (len == 0x0000) {
/* RESET command */
+ /* NOTE: this is ignored, as the reset callback was */
+ /* already called by check_firmware() */
index += 2;
-#if 0 /* not needed, as already called by check_firmware() */
- result = xc4000_TunerReset(fe);
- if (result != XC_RESULT_SUCCESS)
- return result;
-#endif
} else if (len & 0x8000) {
/* WAIT command */
- xc_wait(len & 0x7FFF);
+ msleep(len & 0x7FFF);
index += 2;
} else {
/* Send i2c data whilst ensuring individual transactions
result = xc_send_i2c_data(priv, buf,
nbytes_to_send);
- if (result != XC_RESULT_SUCCESS)
+ if (result != 0)
return result;
pos += nbytes_to_send - 2;
index += len;
}
}
- return XC_RESULT_SUCCESS;
+ return 0;
}
-static int xc_SetTVStandard(struct xc4000_priv *priv,
- u16 VideoMode, u16 AudioMode)
+static int xc_set_tv_standard(struct xc4000_priv *priv,
+ u16 video_mode, u16 audio_mode)
{
int ret;
- dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
+ dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode);
dprintk(1, "%s() Standard = %s\n",
__func__,
- XC4000_Standard[priv->video_standard].Name);
+ xc4000_standard[priv->video_standard].Name);
/* Don't complain when the request fails because of i2c stretching */
priv->ignore_i2c_write_errors = 1;
- ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
- if (ret == XC_RESULT_SUCCESS)
- ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
+ ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode);
+ if (ret == 0)
+ ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode);
priv->ignore_i2c_write_errors = 0;
return ret;
}
-static int xc_SetSignalSource(struct xc4000_priv *priv, u16 rf_mode)
+static int xc_set_signal_source(struct xc4000_priv *priv, u16 rf_mode)
{
dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
static const struct dvb_tuner_ops xc4000_tuner_ops;
-static int xc_set_RF_frequency(struct xc4000_priv *priv, u32 freq_hz)
+static int xc_set_rf_frequency(struct xc4000_priv *priv, u32 freq_hz)
{
u16 freq_code;
dprintk(1, "%s(%u)\n", __func__, freq_hz);
if ((freq_hz > xc4000_tuner_ops.info.frequency_max) ||
- (freq_hz < xc4000_tuner_ops.info.frequency_min))
- return XC_RESULT_OUT_OF_RANGE;
+ (freq_hz < xc4000_tuner_ops.info.frequency_min))
+ return -EINVAL;
freq_code = (u16)(freq_hz / 15625);
/* WAS: Starting in firmware version 1.1.44, Xceive recommends using the
FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
only be used for fast scanning for channel lock) */
- return xc_write_reg(priv, XREG_RF_FREQ, freq_code); /* WAS: XREG_FINERFREQ */
+ /* WAS: XREG_FINERFREQ */
+ return xc_write_reg(priv, XREG_RF_FREQ, freq_code);
}
-static int xc_get_ADC_Envelope(struct xc4000_priv *priv, u16 *adc_envelope)
+static int xc_get_adc_envelope(struct xc4000_priv *priv, u16 *adc_envelope)
{
return xc4000_readreg(priv, XREG_ADC_ENV, adc_envelope);
}
u32 tmp;
result = xc4000_readreg(priv, XREG_FREQ_ERROR, ®Data);
- if (result != XC_RESULT_SUCCESS)
+ if (result != 0)
return result;
tmp = (u32)regData & 0xFFFFU;
int result;
result = xc4000_readreg(priv, XREG_VERSION, &data);
- if (result != XC_RESULT_SUCCESS)
+ if (result != 0)
return result;
(*hw_majorversion) = (data >> 12) & 0x0F;
int result;
result = xc4000_readreg(priv, XREG_HSYNC_FREQ, ®Data);
- if (result != XC_RESULT_SUCCESS)
+ if (result != 0)
return result;
(*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
return xc4000_readreg(priv, XREG_QUALITY, quality);
}
-static u16 WaitForLock(struct xc4000_priv *priv)
+static u16 xc_wait_for_lock(struct xc4000_priv *priv)
{
- u16 lockState = 0;
- int watchDogCount = 40;
-
- while ((lockState == 0) && (watchDogCount > 0)) {
- xc_get_lock_status(priv, &lockState);
- if (lockState != 1) {
- xc_wait(5);
- watchDogCount--;
+ u16 lock_state = 0;
+ int watchdog_count = 40;
+
+ while ((lock_state == 0) && (watchdog_count > 0)) {
+ xc_get_lock_status(priv, &lock_state);
+ if (lock_state != 1) {
+ msleep(5);
+ watchdog_count--;
}
}
- return lockState;
+ return lock_state;
}
static int xc_tune_channel(struct xc4000_priv *priv, u32 freq_hz)
/* Don't complain when the request fails because of i2c stretching */
priv->ignore_i2c_write_errors = 1;
- result = xc_set_RF_frequency(priv, freq_hz);
+ result = xc_set_rf_frequency(priv, freq_hz);
priv->ignore_i2c_write_errors = 0;
- if (result != XC_RESULT_SUCCESS)
+ if (result != 0)
return 0;
/* wait for lock only in analog TV mode */
if ((priv->cur_fw.type & (FM | DTV6 | DTV7 | DTV78 | DTV8)) == 0) {
- if (WaitForLock(priv) != 1)
+ if (xc_wait_for_lock(priv) != 1)
found = 0;
}
* Frame Lines needs two frame times after initial lock
* before it is valid.
*/
- xc_wait(debug ? 100 : 10);
+ msleep(debug ? 100 : 10);
if (debug)
xc_debug_dump(priv);
}
*val = (bval[0] << 8) | bval[1];
- return XC_RESULT_SUCCESS;
+ return 0;
}
#define dump_firm_type(t) dump_firm_type_and_int_freq(t, 0)
unsigned int best_nr_diffs = 255U;
if (!priv->firm) {
- printk("Error! firmware not loaded\n");
+ printk(KERN_ERR "Error! firmware not loaded\n");
return -EINVAL;
}
if (best_nr_diffs > 0U) {
printk("Selecting best matching firmware (%u bits differ) for "
- "type=", best_nr_diffs);
- printk("(%x), id %016llx:\n", type, (unsigned long long)*id);
+ "type=(%x), id %016llx:\n",
+ best_nr_diffs, type, (unsigned long long)*id);
i = best_i;
}
ret:
if (debug) {
- printk("%s firmware for type=", (i < 0) ? "Can't find" :
- "Found");
+ printk("%s firmware for type=",
+ (i < 0) ? "Can't find" : "Found");
dump_firm_type(type);
printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
}
rc = request_firmware(&fw, fname, priv->i2c_props.adap->dev.parent);
if (rc < 0) {
if (rc == -ENOENT)
- printk("Error: firmware %s not found.\n",
- fname);
+ printk("Error: firmware %s not found.\n", fname);
else
printk("Error %d while requesting firmware %s \n",
- rc, fname);
+ rc, fname);
return rc;
}
endp = p + fw->size;
if (fw->size < sizeof(name) - 1 + 2 + 2) {
- printk("Error: firmware file %s has invalid size!\n",
- fname);
+ printk("Error: firmware file %s has invalid size!\n", fname);
goto corrupt;
}
memcpy(name, p, sizeof(name) - 1);
- name[sizeof(name) - 1] = 0;
+ name[sizeof(name) - 1] = '\0';
p += sizeof(name) - 1;
priv->firm_version = get_unaligned_le16(p);
}
rc = xc_send_i2c_data(priv, scode_buf, 13);
- if (rc != XC_RESULT_SUCCESS) {
+ if (rc != 0) {
/* Even if the send failed, make sure we set back to indirect
mode */
printk("Failed to set scode %d\n", rc);
return rc;
}
-#ifdef DJH_DEBUG
- if (priv->ctrl.mts && !(type & FM))
- type |= MTS;
-#endif
-
retry:
new_fw.type = type;
new_fw.id = std;
new_fw.std_req = std;
- new_fw.scode_table = SCODE /* | priv->ctrl.scode_table */;
+ new_fw.scode_table = SCODE;
new_fw.scode_nr = 0;
new_fw.int_freq = int_freq;
dump_firm_type(new_fw.type);
printk("(%x), id %016llx, ", new_fw.type,
(unsigned long long)new_fw.std_req);
- if (!int_freq) {
- printk("scode_tbl ");
-#ifdef DJH_DEBUG
- dump_firm_type(priv->ctrl.scode_table);
- printk("(%x), ", priv->ctrl.scode_table);
-#endif
- } else
- printk("int_freq %d, ", new_fw.int_freq);
- printk("scode_nr %d\n", new_fw.scode_nr);
+ if (!int_freq)
+ printk(KERN_CONT "scode_tbl ");
+ else
+ printk(KERN_CONT "int_freq %d, ", new_fw.int_freq);
+ printk(KERN_CONT "scode_nr %d\n", new_fw.scode_nr);
}
/* No need to reload base firmware if it matches */
memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
/* Reset is needed before loading firmware */
- rc = xc4000_TunerReset(fe);
+ rc = xc4000_tuner_reset(fe);
if (rc < 0)
goto fail;
/* Load SCODE firmware, if exists */
rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
new_fw.int_freq, new_fw.scode_nr);
- if (rc != XC_RESULT_SUCCESS)
+ if (rc != 0)
dprintk(1, "load scode failed %d\n", rc);
check_device:
rc = xc4000_readreg(priv, XREG_PRODUCT_ID, &hwmodel);
if (xc_get_version(priv, &hw_major, &hw_minor, &fw_major,
- &fw_minor) != XC_RESULT_SUCCESS) {
+ &fw_minor) != 0) {
printk("Unable to read tuner registers.\n");
goto fail;
}
u8 hw_majorversion = 0, hw_minorversion = 0;
u8 fw_majorversion = 0, fw_minorversion = 0;
- xc_get_ADC_Envelope(priv, &adc_envelope);
+ xc_get_adc_envelope(priv, &adc_envelope);
dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
xc_get_frequency_error(priv, &freq_error_hz);
__func__, priv->freq_hz);
/* Make sure the correct firmware type is loaded */
- if (check_firmware(fe, type, 0, priv->if_khz) != XC_RESULT_SUCCESS)
+ if (check_firmware(fe, type, 0, priv->if_khz) != 0)
goto fail;
- ret = xc_SetSignalSource(priv, priv->rf_mode);
- if (ret != XC_RESULT_SUCCESS) {
- printk(KERN_ERR
- "xc4000: xc_SetSignalSource(%d) failed\n",
+ ret = xc_set_signal_source(priv, priv->rf_mode);
+ if (ret != 0) {
+ printk(KERN_ERR "xc4000: xc_set_signal_source(%d) failed\n",
priv->rf_mode);
goto fail;
} else {
u16 video_mode, audio_mode;
- video_mode = XC4000_Standard[priv->video_standard].VideoMode;
- audio_mode = XC4000_Standard[priv->video_standard].AudioMode;
+ video_mode = xc4000_standard[priv->video_standard].video_mode;
+ audio_mode = xc4000_standard[priv->video_standard].audio_mode;
if (type == DTV6 && priv->firm_version != 0x0102)
video_mode |= 0x0001;
- ret = xc_SetTVStandard(priv, video_mode, audio_mode);
- if (ret != XC_RESULT_SUCCESS) {
- printk(KERN_ERR "xc4000: xc_SetTVStandard failed\n");
+ ret = xc_set_tv_standard(priv, video_mode, audio_mode);
+ if (ret != 0) {
+ printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
/* DJH - do not return when it fails... */
/* goto fail; */
}
}
tune_channel:
- /* Fix me: it could be air. */
+ /* FIXME: it could be air. */
priv->rf_mode = XC_RF_MODE_CABLE;
if (check_firmware(fe, type, params->std,
- XC4000_Standard[priv->video_standard].int_freq)
- != XC_RESULT_SUCCESS) {
+ xc4000_standard[priv->video_standard].int_freq) != 0)
goto fail;
- }
- ret = xc_SetSignalSource(priv, priv->rf_mode);
- if (ret != XC_RESULT_SUCCESS) {
+ ret = xc_set_signal_source(priv, priv->rf_mode);
+ if (ret != 0) {
printk(KERN_ERR
- "xc4000: xc_SetSignalSource(%d) failed\n",
+ "xc4000: xc_set_signal_source(%d) failed\n",
priv->rf_mode);
goto fail;
} else {
u16 video_mode, audio_mode;
- video_mode = XC4000_Standard[priv->video_standard].VideoMode;
- audio_mode = XC4000_Standard[priv->video_standard].AudioMode;
+ video_mode = xc4000_standard[priv->video_standard].video_mode;
+ audio_mode = xc4000_standard[priv->video_standard].audio_mode;
if (priv->video_standard < XC4000_BG_PAL_A2) {
- if (0 /*type & NOGD*/)
+ if (type & NOGD)
video_mode &= 0xFF7F;
} else if (priv->video_standard < XC4000_I_PAL_NICAM) {
if (priv->card_type == XC4000_CARD_WINFAST_CX88 &&
if (audio_std & XC4000_AUDIO_STD_B)
video_mode |= 0x0080;
}
- ret = xc_SetTVStandard(priv, video_mode, audio_mode);
- if (ret != XC_RESULT_SUCCESS) {
- printk(KERN_ERR "xc4000: xc_SetTVStandard failed\n");
+ ret = xc_set_tv_standard(priv, video_mode, audio_mode);
+ if (ret != 0) {
+ printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
goto fail;
}
}
static int xc4000_sleep(struct dvb_frontend *fe)
{
struct xc4000_priv *priv = fe->tuner_priv;
- int ret = XC_RESULT_SUCCESS;
+ int ret = 0;
dprintk(1, "%s()\n", __func__);
/* force reset and firmware reload */
priv->cur_fw.type = XC_POWERED_DOWN;
- if (xc_write_reg(priv, XREG_POWER_DOWN, 0)
- != XC_RESULT_SUCCESS) {
+ if (xc_write_reg(priv, XREG_POWER_DOWN, 0) != 0) {
printk(KERN_ERR
"xc4000: %s() unable to shutdown tuner\n",
__func__);
ret = -EREMOTEIO;
}
- xc_wait(20);
+ msleep(20);
}
mutex_unlock(&priv->lock);
*/
if (instance == 1) {
- if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id)
- != XC_RESULT_SUCCESS)
+ if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
goto fail;
} else {
id = ((priv->cur_fw.type & BASE) != 0 ?
mutex_lock(&priv->lock);
ret = xc4000_fwupload(fe);
mutex_unlock(&priv->lock);
- if (ret != XC_RESULT_SUCCESS)
+ if (ret != 0)
goto fail2;
}
projects / ~andy / linux / commitdiff