case 6000000:
                mt2266_writeregs(priv, mt2266_init_6mhz,
                                 sizeof(mt2266_init_6mhz));
-               priv->bandwidth = BANDWIDTH_6_MHZ;
                break;
        case 8000000:
                mt2266_writeregs(priv, mt2266_init_8mhz,
                                 sizeof(mt2266_init_8mhz));
-               priv->bandwidth = BANDWIDTH_8_MHZ;
                break;
        case 7000000:
        default:
                mt2266_writeregs(priv, mt2266_init_7mhz,
                                 sizeof(mt2266_init_7mhz));
-               priv->bandwidth = BANDWIDTH_7_MHZ;
                break;
        }
+       priv->bandwidth = c->bandwidth_hz;
 
        if (band == MT2266_VHF && priv->band == MT2266_UHF) {
                dprintk("Switch from UHF to VHF");
 
        enum mxl5007t_mode mode;
        int ret;
        u32 freq = c->frequency;
-       u32 band = BANDWIDTH_6_MHZ;
 
        switch (delsys) {
        case SYS_ATSC:
                        break;
                case 7000000:
                        bw = MxL_BW_7MHz;
-                       band = BANDWIDTH_7_MHZ;
                case 8000000:
                        bw = MxL_BW_8MHz;
-                       band = BANDWIDTH_8_MHZ;
                default:
                        return -EINVAL;
                }
                goto fail;
 
        state->frequency = freq;
-       state->bandwidth = band;
+       state->bandwidth = c->bandwidth_hz;
 fail:
        mutex_unlock(&state->lock);
 
 
        u32 delsys = c->delivery_system;
        u32 bw = c->bandwidth_hz;
        u32 freq = c->frequency;
-       u32 band = BANDWIDTH_6_MHZ;
        struct tda18271_priv *priv = fe->tuner_priv;
        struct tda18271_std_map *std_map = &priv->std;
        struct tda18271_std_map_item *map;
                        map = &std_map->dvbt_6;
                } else if (bw <= 7000000) {
                        map = &std_map->dvbt_7;
-                       band = BANDWIDTH_7_MHZ;
                } else {
                        map = &std_map->dvbt_8;
-                       band = BANDWIDTH_8_MHZ;
                }
                break;
        case SYS_DVBC_ANNEX_B:
                        map = &std_map->qam_6;
                } else if (bw <= 7000000) {
                        map = &std_map->qam_7;
-                       band = BANDWIDTH_7_MHZ;
                } else {
                        map = &std_map->qam_8;
-                       band = BANDWIDTH_8_MHZ;
                }
                break;
        default:
 
        priv->if_freq   = map->if_freq;
        priv->frequency = freq;
-       priv->bandwidth = band;
+       priv->bandwidth = bw;
 fail:
        return ret;
 }
 
        struct tda827x_priv *priv = fe->tuner_priv;
        u8 buf[14];
        int rc;
-       u32 band;
 
        struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
                               .buf = buf, .len = sizeof(buf) };
        dprintk("%s:\n", __func__);
        if (c->bandwidth_hz == 0) {
                if_freq = 5000000;
-               band = BANDWIDTH_8_MHZ;
        } else if (c->bandwidth_hz <= 6000000) {
                if_freq = 4000000;
-               band = BANDWIDTH_6_MHZ;
        } else if (c->bandwidth_hz <= 7000000) {
                if_freq = 4500000;
-               band = BANDWIDTH_7_MHZ;
        } else {        /* 8 MHz */
                if_freq = 5000000;
-               band = BANDWIDTH_8_MHZ;
        }
        tuner_freq = c->frequency;
 
                goto err;
 
        priv->frequency = c->frequency;
-       priv->bandwidth = band;
+       priv->bandwidth = c->bandwidth_hz;
 
        return 0;
 
        struct tda827x_priv *priv = fe->tuner_priv;
        struct tda827xa_data *frequency_map = tda827xa_dvbt;
        u8 buf[11];
-       u32 band;
 
        struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
                               .buf = buf, .len = sizeof(buf) };
 
        if (c->bandwidth_hz == 0) {
                if_freq = 5000000;
-               band = BANDWIDTH_8_MHZ;
        } else if (c->bandwidth_hz <= 6000000) {
                if_freq = 4000000;
-               band = BANDWIDTH_6_MHZ;
        } else if (c->bandwidth_hz <= 7000000) {
                if_freq = 4500000;
-               band = BANDWIDTH_7_MHZ;
        } else {        /* 8 MHz */
                if_freq = 5000000;
-               band = BANDWIDTH_8_MHZ;
        }
        tuner_freq = c->frequency;
 
                goto err;
 
        priv->frequency = c->frequency;
-       priv->bandwidth = band;
+       priv->bandwidth = c->bandwidth_hz;
 
        return 0;
 
 
 static int simple_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
 {
        struct tuner_simple_priv *priv = fe->tuner_priv;
-       switch (priv->bandwidth) {
-       case 6000000:
-               *bandwidth = BANDWIDTH_6_MHZ;
-               break;
-       case 7000000:
-               *bandwidth = BANDWIDTH_7_MHZ;
-               break;
-       case 8000000:
-               *bandwidth = BANDWIDTH_8_MHZ;
-               break;
-       }
+       *bandwidth = priv->bandwidth;
        return 0;
 }
 
 
                dprintk(1, "%s() VSB modulation\n", __func__);
                priv->rf_mode = XC_RF_MODE_AIR;
                priv->freq_hz = c->frequency - 1750000;
-               priv->bandwidth = BANDWIDTH_6_MHZ;
                priv->video_standard = XC4000_DTV6;
                type = DTV6;
                break;
                dprintk(1, "%s() QAM modulation\n", __func__);
                priv->rf_mode = XC_RF_MODE_CABLE;
                priv->freq_hz = c->frequency - 1750000;
-               priv->bandwidth = BANDWIDTH_6_MHZ;
                priv->video_standard = XC4000_DTV6;
                type = DTV6;
                break;
                dprintk(1, "%s() OFDM\n", __func__);
                if (bw == 0) {
                        if (c->frequency < 400000000) {
-                               priv->bandwidth = BANDWIDTH_7_MHZ;
                                priv->freq_hz = c->frequency - 2250000;
                        } else {
-                               priv->bandwidth = BANDWIDTH_8_MHZ;
                                priv->freq_hz = c->frequency - 2750000;
                        }
                        priv->video_standard = XC4000_DTV7_8;
                        type = DTV78;
                } else if (bw <= 6000000) {
-                       priv->bandwidth = BANDWIDTH_6_MHZ;
                        priv->video_standard = XC4000_DTV6;
                        priv->freq_hz = c->frequency - 1750000;
                        type = DTV6;
                } else if (bw <= 7000000) {
-                       priv->bandwidth = BANDWIDTH_7_MHZ;
                        priv->video_standard = XC4000_DTV7;
                        priv->freq_hz = c->frequency - 2250000;
                        type = DTV7;
                } else {
-                       priv->bandwidth = BANDWIDTH_8_MHZ;
                        priv->video_standard = XC4000_DTV8;
                        priv->freq_hz = c->frequency - 2750000;
                        type = DTV8;
        if (check_firmware(fe, type, 0, priv->if_khz) != 0)
                goto fail;
 
+       priv->bandwidth = c->bandwidth_hz;
+
        ret = xc_set_signal_source(priv, priv->rf_mode);
        if (ret != 0) {
                printk(KERN_ERR "xc4000: xc_set_signal_source(%d) failed\n",
                break;
        case 1:
                /* new tuner instance */
-               priv->bandwidth = BANDWIDTH_6_MHZ;
+               priv->bandwidth = 6000000;
                /* set default configuration */
                priv->if_khz = 4560;
                priv->default_pm = 0;
 
                dprintk(1, "%s() VSB modulation\n", __func__);
                priv->rf_mode = XC_RF_MODE_AIR;
                priv->freq_hz = freq - 1750000;
-               priv->bandwidth = BANDWIDTH_6_MHZ;
                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->bandwidth = BANDWIDTH_6_MHZ;
                priv->video_standard = DTV6;
                break;
        case SYS_DVBT:
                dprintk(1, "%s() OFDM\n", __func__);
                switch (bw) {
                case 6000000:
-                       priv->bandwidth = BANDWIDTH_6_MHZ;
                        priv->video_standard = DTV6;
                        priv->freq_hz = freq - 1750000;
                        break;
                case 7000000:
-                       priv->bandwidth = BANDWIDTH_7_MHZ;
                        priv->video_standard = DTV7;
                        priv->freq_hz = freq - 2250000;
                        break;
                case 8000000:
-                       priv->bandwidth = BANDWIDTH_8_MHZ;
                        priv->video_standard = DTV8;
                        priv->freq_hz = freq - 2750000;
                        break;
                dprintk(1, "%s() QAM modulation\n", __func__);
                priv->rf_mode = XC_RF_MODE_CABLE;
                if (bw <= 6000000) {
-                       priv->bandwidth = BANDWIDTH_6_MHZ;
                        priv->video_standard = DTV6;
                        priv->freq_hz = freq - 1750000;
                        b = 6;
                } else if (bw <= 7000000) {
-                       priv->bandwidth = BANDWIDTH_7_MHZ;
                        priv->video_standard = DTV7;
                        priv->freq_hz = freq - 2250000;
                        b = 7;
                } else {
-                       priv->bandwidth = BANDWIDTH_8_MHZ;
                        priv->video_standard = DTV7_8;
                        priv->freq_hz = freq - 2750000;
                        b = 8;
        if (debug)
                xc_debug_dump(priv);
 
+       priv->bandwidth = bw;
+
        return 0;
 }
 
                break;
        case 1:
                /* new tuner instance */
-               priv->bandwidth = BANDWIDTH_6_MHZ;
+               priv->bandwidth = 6000000;
                fe->tuner_priv = priv;
                break;
        default:
 
        struct mxl111sf_tuner_state *state = fe->tuner_priv;
        int ret;
        u8 bw;
-       u32 band = BANDWIDTH_6_MHZ;
 
        mxl_dbg("()");
 
                        break;
                case 7000000:
                        bw = 7;
-                       band = BANDWIDTH_7_MHZ;
                        break;
                case 8000000:
                        bw = 8;
-                       band = BANDWIDTH_8_MHZ;
                        break;
                default:
                        err("%s: bandwidth not set!", __func__);
                goto fail;
 
        state->frequency = c->frequency;
-       state->bandwidth = band;
+       state->bandwidth = c->bandwidth_hz;
 fail:
        return ret;
 }
 
        int timing_offset;
        int timing_offset_comp_done;
 
-       fe_bandwidth_t last_tuned_bw;
+       u32 last_tuned_bw;
        u32 last_tuned_freq;
 };
 
 
        }
 
        priv->frequency = frequency;
-       if (c->bandwidth_hz <= 6000000)
-               priv->bandwidth = BANDWIDTH_6_MHZ;
-       else if (c->bandwidth_hz <= 7000000)
-               priv->bandwidth = BANDWIDTH_7_MHZ;
-       if (c->bandwidth_hz <= 8000000)
-               priv->bandwidth = BANDWIDTH_8_MHZ;
+       priv->bandwidth = c->bandwidth_hz;
 
        return 0;
 }