1 files changed, 66 insertions, 81 deletions

diff --git a/drivers/media/common/tuners/xc5000.c b/drivers/media/common/tuners/xc5000.c
index aa1b2e844d32..296df05b8cda 100644
--- a/drivers/media/common/tuners/xc5000.c
+++ b/drivers/media/common/tuners/xc5000.c
@@ -628,20 +628,13 @@ static void xc_debug_dump(struct xc5000_priv *priv)
         dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
 }
 
-/*
- * As defined on EN 300 429, the DVB-C roll-off factor is 0.15.
- * So, the amount of the needed bandwith is given by:
- *      Bw = Symbol_rate * (1 + 0.15)
- * As such, the maximum symbol rate supported by 6 MHz is given by:
- *      max_symbol_rate = 6 MHz / 1.15 = 5217391 Bauds
- */
-#define MAX_SYMBOL_RATE_6MHz    5217391
-
-static int xc5000_set_params(struct dvb_frontend *fe,
-        struct dvb_frontend_parameters *params)
+static int xc5000_set_params(struct dvb_frontend *fe)
 {
+        int ret, b;
         struct xc5000_priv *priv = fe->tuner_priv;
-        int ret;
+        u32 bw = fe->dtv_property_cache.bandwidth_hz;
+        u32 freq = fe->dtv_property_cache.frequency;
+        u32 delsys  = fe->dtv_property_cache.delivery_system;
 
         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
                 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
@@ -650,88 +643,69 @@ static int xc5000_set_params(struct dvb_frontend *fe,
                 }
         }
 
-        dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
-
-        if (fe->ops.info.type == FE_ATSC) {
-                dprintk(1, "%s() ATSC\n", __func__);
-                switch (params->u.vsb.modulation) {
-                case VSB_8:
-                case VSB_16:
-                        dprintk(1, "%s() VSB modulation\n", __func__);
-                        priv->rf_mode = XC_RF_MODE_AIR;
-                        priv->freq_hz = params->frequency - 1750000;
-                        priv->bandwidth = BANDWIDTH_6_MHZ;
-                        priv->video_standard = DTV6;
-                        break;
-                case QAM_64:
-                case QAM_256:
-                case QAM_AUTO:
-                        dprintk(1, "%s() QAM modulation\n", __func__);
-                        priv->rf_mode = XC_RF_MODE_CABLE;
-                        priv->freq_hz = params->frequency - 1750000;
-                        priv->bandwidth = BANDWIDTH_6_MHZ;
-                        priv->video_standard = DTV6;
-                        break;
-                default:
-                        return -EINVAL;
-                }
-        } else if (fe->ops.info.type == FE_OFDM) {
+        dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
+
+        switch (delsys) {
+        case SYS_ATSC:
+                dprintk(1, "%s() VSB modulation\n", __func__);
+                priv->rf_mode = XC_RF_MODE_AIR;
+                priv->freq_hz = freq - 1750000;
+                priv->video_standard = DTV6;
+                break;
+        case SYS_DVBC_ANNEX_B:
+                dprintk(1, "%s() QAM modulation\n", __func__);
+                priv->rf_mode = XC_RF_MODE_CABLE;
+                priv->freq_hz = freq - 1750000;
+                priv->video_standard = DTV6;
+                break;
+        case SYS_DVBT:
+        case SYS_DVBT2:
                 dprintk(1, "%s() OFDM\n", __func__);
-                switch (params->u.ofdm.bandwidth) {
-                case BANDWIDTH_6_MHZ:
-                        priv->bandwidth = BANDWIDTH_6_MHZ;
+                switch (bw) {
+                case 6000000:
                         priv->video_standard = DTV6;
-                        priv->freq_hz = params->frequency - 1750000;
+                        priv->freq_hz = freq - 1750000;
                         break;
-                case BANDWIDTH_7_MHZ:
-                        printk(KERN_ERR "xc5000 bandwidth 7MHz not supported\n");
-                        return -EINVAL;
-                case BANDWIDTH_8_MHZ:
-                        priv->bandwidth = BANDWIDTH_8_MHZ;
+                case 7000000:
+                        priv->video_standard = DTV7;
+                        priv->freq_hz = freq - 2250000;
+                        break;
+                case 8000000:
                         priv->video_standard = DTV8;
-                        priv->freq_hz = params->frequency - 2750000;
+                        priv->freq_hz = freq - 2750000;
                         break;
                 default:
                         printk(KERN_ERR "xc5000 bandwidth not set!\n");
                         return -EINVAL;
                 }
                 priv->rf_mode = XC_RF_MODE_AIR;
-        } else if (fe->ops.info.type == FE_QAM) {
-                switch (params->u.qam.modulation) {
-                case QAM_256:
-                case QAM_AUTO:
-                case QAM_16:
-                case QAM_32:
-                case QAM_64:
-                case QAM_128:
-                        dprintk(1, "%s() QAM modulation\n", __func__);
-                        priv->rf_mode = XC_RF_MODE_CABLE;
-                        /*
-                         * Using a 8MHz bandwidth sometimes fail
-                         * with 6MHz-spaced channels, due to inter-carrier
-                         * interference. So, use DTV6 firmware
-                         */
-                        if (params->u.qam.symbol_rate <= MAX_SYMBOL_RATE_6MHz) {
-                                priv->bandwidth = BANDWIDTH_6_MHZ;
-                                priv->video_standard = DTV6;
-                                priv->freq_hz = params->frequency - 1750000;
-                        } else {
-                                priv->bandwidth = BANDWIDTH_8_MHZ;
-                                priv->video_standard = DTV7_8;
-                                priv->freq_hz = params->frequency - 2750000;
-                        }
-                        break;
-                default:
-                        dprintk(1, "%s() Unsupported QAM type\n", __func__);
-                        return -EINVAL;
+        case SYS_DVBC_ANNEX_A:
+        case SYS_DVBC_ANNEX_C:
+                dprintk(1, "%s() QAM modulation\n", __func__);
+                priv->rf_mode = XC_RF_MODE_CABLE;
+                if (bw <= 6000000) {
+                        priv->video_standard = DTV6;
+                        priv->freq_hz = freq - 1750000;
+                        b = 6;
+                } else if (bw <= 7000000) {
+                        priv->video_standard = DTV7;
+                        priv->freq_hz = freq - 2250000;
+                        b = 7;
+                } else {
+                        priv->video_standard = DTV7_8;
+                        priv->freq_hz = freq - 2750000;
+                        b = 8;
                 }
-        } else {
-                printk(KERN_ERR "xc5000 modulation type not supported!\n");
+                dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
+                        b, bw);
+                break;
+        default:
+                printk(KERN_ERR "xc5000: delivery system is not supported!\n");
                 return -EINVAL;
         }
 
-        dprintk(1, "%s() frequency=%d (compensated)\n",
-                __func__, priv->freq_hz);
+        dprintk(1, "%s() frequency=%d (compensated to %d)\n",
+                __func__, freq, priv->freq_hz);
 
         ret = xc_SetSignalSource(priv, priv->rf_mode);
         if (ret != XC_RESULT_SUCCESS) {
@@ -763,6 +737,8 @@ static int xc5000_set_params(struct dvb_frontend *fe,
         if (debug)
                 xc_debug_dump(priv);
 
+        priv->bandwidth = bw;
+
         return 0;
 }
 
@@ -968,6 +944,14 @@ static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
         return 0;
 }
 
+static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
+{
+        struct xc5000_priv *priv = fe->tuner_priv;
+        dprintk(1, "%s()\n", __func__);
+        *freq = priv->if_khz * 1000;
+        return 0;
+}
+
 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
 {
         struct xc5000_priv *priv = fe->tuner_priv;
@@ -1108,6 +1092,7 @@ static const struct dvb_tuner_ops xc5000_tuner_ops = {
         .set_params        = xc5000_set_params,
         .set_analog_params = xc5000_set_analog_params,
         .get_frequency     = xc5000_get_frequency,
+        .get_if_frequency  = xc5000_get_if_frequency,
         .get_bandwidth     = xc5000_get_bandwidth,
         .get_status        = xc5000_get_status
 };
@@ -1135,7 +1120,7 @@ struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
                 break;
         case 1:
                 /* new tuner instance */
-                priv->bandwidth = BANDWIDTH_6_MHZ;
+                priv->bandwidth = 6000000;
                 fe->tuner_priv = priv;
                 break;
         default: