[media] xc4000: code cleanup

Various coding style changes:
  - removed unused / commented out code
  - changed C++ style comments to C format
  - renamed functions and variables that included upper case letters in the name
  - removed tabs from module parameter descriptions
  - replaced the use of XC_RESULT_* with standard error codes

Signed-off-by: Istvan Varga <istvan_v@mailbox.hu>
Cc: Patrick Boettcher <pboettcher@kernellabs.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

2 files changed, 126 insertions, 161 deletions

diff --git a/drivers/media/common/tuners/xc4000.c b/drivers/media/common/tuners/xc4000.c
index 160ca26286cc..ebc84269b5e6 100644
--- a/drivers/media/common/tuners/xc4000.c
+++ b/drivers/media/common/tuners/xc4000.c
@@ -5,6 +5,7 @@
  *  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
@@ -14,7 +15,6 @@
  *  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
@@ -39,44 +39,29 @@
 
 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);
@@ -115,13 +100,21 @@ struct xc4000_priv {
         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
@@ -131,13 +124,6 @@ struct xc4000_priv {
 #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
@@ -202,8 +188,8 @@ struct xc4000_priv {
 
 struct XC_TV_STANDARD {
         const char  *Name;
-        u16         AudioMode;
-        u16         VideoMode;
+        u16         audio_mode;
+        u16         video_mode;
         u16         int_freq;
 };
 
@@ -233,7 +219,7 @@ struct XC_TV_STANDARD {
 #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},
@@ -261,7 +247,7 @@ static struct XC_TV_STANDARD XC4000_Standard[MAX_TV_STANDARD] = {
 };
 
 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)
@@ -276,18 +262,13 @@ 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;
@@ -302,13 +283,14 @@ static int xc4000_TunerReset(struct dvb_frontend *fe)
                                            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)
@@ -339,15 +321,12 @@ static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
                 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
@@ -370,7 +349,7 @@ static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
                                 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;
@@ -378,31 +357,31 @@ static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
                         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");
@@ -418,25 +397,26 @@ static int xc_SetSignalSource(struct xc4000_priv *priv, u16 rf_mode)
 
 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);
 }
@@ -448,7 +428,7 @@ static int xc_get_frequency_error(struct xc4000_priv *priv, u32 *freq_error_hz)
         u32 tmp;
 
         result = xc4000_readreg(priv, XREG_FREQ_ERROR, &regData);
-        if (result != XC_RESULT_SUCCESS)
+        if (result != 0)
                 return result;
 
         tmp = (u32)regData & 0xFFFFU;
@@ -470,7 +450,7 @@ static int xc_get_version(struct xc4000_priv *priv,
         int result;
 
         result = xc4000_readreg(priv, XREG_VERSION, &data);
-        if (result != XC_RESULT_SUCCESS)
+        if (result != 0)
                 return result;
 
         (*hw_majorversion) = (data >> 12) & 0x0F;
@@ -487,7 +467,7 @@ static int xc_get_hsync_freq(struct xc4000_priv *priv, u32 *hsync_freq_hz)
         int result;
 
         result = xc4000_readreg(priv, XREG_HSYNC_FREQ, &regData);
-        if (result != XC_RESULT_SUCCESS)
+        if (result != 0)
                 return result;
 
         (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
@@ -504,19 +484,19 @@ static int xc_get_quality(struct xc4000_priv *priv, u16 *quality)
         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)
@@ -528,15 +508,15 @@ 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;
         }
 
@@ -544,7 +524,7 @@ static int xc_tune_channel(struct xc4000_priv *priv, u32 freq_hz)
          * 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);
@@ -569,7 +549,7 @@ static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val)
         }
 
         *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)
@@ -647,7 +627,7 @@ static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
         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;
         }
 
@@ -685,8 +665,8 @@ static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
 
         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;
         }
 
@@ -695,8 +675,8 @@ found:
 
 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);
         }
@@ -745,11 +725,10 @@ static int xc4000_fwupload(struct dvb_frontend *fe)
         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;
         }
@@ -757,13 +736,12 @@ static int xc4000_fwupload(struct dvb_frontend *fe)
         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);
@@ -920,7 +898,7 @@ static int load_scode(struct dvb_frontend *fe, unsigned int type,
         }
 
         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);
@@ -953,16 +931,11 @@ static int check_firmware(struct dvb_frontend *fe, unsigned int type,
                         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;
 
@@ -971,15 +944,11 @@ retry:
                 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 */
@@ -992,7 +961,7 @@ retry:
         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;
 
@@ -1046,14 +1015,14 @@ skip_std_specific:
         /* 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;
         }
@@ -1121,7 +1090,7 @@ static void xc_debug_dump(struct xc4000_priv *priv)
         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);
@@ -1235,24 +1204,23 @@ static int xc4000_set_params(struct dvb_frontend *fe,
                 __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; */
                 }
@@ -1423,27 +1391,25 @@ static int xc4000_set_analog_params(struct dvb_frontend *fe,
         }
 
 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 &&
@@ -1452,9 +1418,9 @@ tune_channel:
                         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;
                 }
         }
@@ -1542,7 +1508,7 @@ static int xc4000_get_status(struct dvb_frontend *fe, u32 *status)
 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__);
 
@@ -1556,14 +1522,13 @@ static int xc4000_sleep(struct dvb_frontend *fe)
                 /* 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);
@@ -1672,8 +1637,7 @@ struct dvb_frontend *xc4000_attach(struct dvb_frontend *fe,
          */
 
         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 ?
@@ -1713,7 +1677,7 @@ struct dvb_frontend *xc4000_attach(struct dvb_frontend *fe,
                 mutex_lock(&priv->lock);
                 ret = xc4000_fwupload(fe);
                 mutex_unlock(&priv->lock);
-                if (ret != XC_RESULT_SUCCESS)
+                if (ret != 0)
                         goto fail2;
         }
 
diff --git a/drivers/media/dvb/dvb-usb/dib0700_devices.c b/drivers/media/dvb/dvb-usb/dib0700_devices.c
index a5212a5c2b48..d546270d3f5d 100644
--- a/drivers/media/dvb/dvb-usb/dib0700_devices.c
+++ b/drivers/media/dvb/dvb-usb/dib0700_devices.c
@@ -2706,13 +2706,14 @@ static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
 };
 
 static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
-        60000, 30000, // internal, sampling
-        1, 8, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
-        0, 0, 1, 1, 0, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
-        (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
-        39370534, // ifreq
-        20452225, // timf
-        30000000, // xtal
+        60000, 30000,   /* internal, sampling */
+        1, 8, 3, 1, 0,  /* pll_cfg: prediv, ratio, range, reset, bypass */
+        0, 0, 1, 1, 0,  /* misc: refdiv, bypclk_div, IO_CLK_en_core, */
+                        /* ADClkSrc, modulo */
+        (3 << 14) | (1 << 12) | 524,    /* sad_cfg: refsel, sel, freq_15k */
+        39370534,       /* ifreq */
+        20452225,       /* timf */
+        30000000        /* xtal */
 };
 
 /* FIXME: none of these inputs are validated yet */