[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>

diff --git a/drivers/media/common/tuners/xc4000.c b/drivers/media/common/tuners/xc4000.c
index 160ca26286cc4b843a3ba2c205d1bbe785ef9c68..ebc84269b5e6bdcd178a4f5981f19775f9597dfa 100644 (file)
--- 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 a5212a5c2b485f7ae7c7b6a29498e0a65c1fffce..d546270d3f5df115877e79939a872e2542b82694 100644 (file)
--- 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 */