/* Protocol Control Unit Functions */
 /* Helpers */
-int ath5k_hw_get_frame_duration(struct ath5k_hw *ah,
+int ath5k_hw_get_frame_duration(struct ath5k_hw *ah, enum ieee80211_band band,
                int len, struct ieee80211_rate *rate, bool shortpre);
 unsigned int ath5k_hw_get_default_slottime(struct ath5k_hw *ah);
 unsigned int ath5k_hw_get_default_sifs(struct ath5k_hw *ah);
 
  * bwmodes.
  */
 int
-ath5k_hw_get_frame_duration(struct ath5k_hw *ah,
+ath5k_hw_get_frame_duration(struct ath5k_hw *ah, enum ieee80211_band band,
                int len, struct ieee80211_rate *rate, bool shortpre)
 {
        int sifs, preamble, plcp_bits, sym_time;
        /* Fallback */
        if (!ah->ah_bwmode) {
                __le16 raw_dur = ieee80211_generic_frame_duration(ah->hw,
-                                       NULL, len, rate);
+                                       NULL, band, len, rate);
 
                /* subtract difference between long and short preamble */
                dur = le16_to_cpu(raw_dur);
                 * actual rate for this rate. See mac80211 tx.c
                 * ieee80211_duration() for a brief description of
                 * what rate we should choose to TX ACKs. */
-               tx_time = ath5k_hw_get_frame_duration(ah, 10, rate, false);
+               tx_time = ath5k_hw_get_frame_duration(ah, band, 10,
+                                       rate, false);
 
                ath5k_hw_reg_write(ah, tx_time, reg);
 
                if (!(rate->flags & IEEE80211_RATE_SHORT_PREAMBLE))
                        continue;
 
-               tx_time = ath5k_hw_get_frame_duration(ah, 10, rate, true);
+               tx_time = ath5k_hw_get_frame_duration(ah, band, 10, rate, true);
                ath5k_hw_reg_write(ah, tx_time,
                        reg + (AR5K_SET_SHORT_PREAMBLE << 2));
        }
 
 int ath5k_hw_set_ifs_intervals(struct ath5k_hw *ah, unsigned int slot_time)
 {
        struct ieee80211_channel *channel = ah->ah_current_channel;
+       enum ieee80211_band band;
        struct ieee80211_rate *rate;
        u32 ack_tx_time, eifs, eifs_clock, sifs, sifs_clock;
        u32 slot_time_clock = ath5k_hw_htoclock(ah, slot_time);
         * Also we have different lowest rate for 802.11a
         */
        if (channel->band == IEEE80211_BAND_5GHZ)
-               rate = &ah->sbands[IEEE80211_BAND_5GHZ].bitrates[0];
+               band = IEEE80211_BAND_5GHZ;
        else
-               rate = &ah->sbands[IEEE80211_BAND_2GHZ].bitrates[0];
+               band = IEEE80211_BAND_2GHZ;
 
-       ack_tx_time = ath5k_hw_get_frame_duration(ah, 10, rate, false);
+       rate = &ah->sbands[band].bitrates[0];
+       ack_tx_time = ath5k_hw_get_frame_duration(ah, band, 10, rate, false);
 
        /* ack_tx_time includes an SIFS already */
        eifs = ack_tx_time + sifs + 2 * slot_time;
 
                txhdr->dur_fb = wlhdr->duration_id;
        } else {
                txhdr->dur_fb = ieee80211_generic_frame_duration(
-                       dev->wl->hw, info->control.vif, fragment_len, fbrate);
+                       dev->wl->hw, info->control.vif, info->band,
+                       fragment_len, fbrate);
        }
 
        plcp_fragment_len = fragment_len + FCS_LEN;
 
        b43legacy_generate_plcp_hdr(&plcp, size + FCS_LEN, rate->hw_value);
        dur = ieee80211_generic_frame_duration(dev->wl->hw,
                                               dev->wl->vif,
+                                              IEEE80211_BAND_2GHZ,
                                               size,
                                               rate);
        /* Write PLCP in two parts and timing for packet transfer */
                                         IEEE80211_STYPE_PROBE_RESP);
        dur = ieee80211_generic_frame_duration(dev->wl->hw,
                                               dev->wl->vif,
+                                              IEEE80211_BAND_2GHZ,
                                               *dest_size,
                                               rate);
        hdr->duration_id = dur;
 
        } else {
                txhdr->dur_fb = ieee80211_generic_frame_duration(dev->wl->hw,
                                                         info->control.vif,
+                                                        info->band,
                                                         fragment_len,
                                                         rate_fb);
        }
 
                hdr->retry = cpu_to_le32((info->control.rates[0].count - 1) << 8);
                hdr->tx_duration =
                        ieee80211_generic_frame_duration(dev, priv->vif,
+                                                        info->band,
                                                         skb->len, txrate);
                buf = hdr;
 
 
  */
 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
                                        struct ieee80211_vif *vif,
+                                       enum ieee80211_band band,
                                        size_t frame_len,
                                        struct ieee80211_rate *rate);
 
 
 extern void *mac80211_wiphy_privid; /* for wiphy privid */
 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
                        enum nl80211_iftype type);
-int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,
+int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
                             int rate, int erp, int short_preamble);
 void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
                                     struct ieee80211_hdr *hdr, const u8 *tsc,
 
 
 
 static void
-calc_rate_durations(struct ieee80211_local *local, struct minstrel_rate *d,
+calc_rate_durations(enum ieee80211_band band,
+                   struct minstrel_rate *d,
                    struct ieee80211_rate *rate)
 {
        int erp = !!(rate->flags & IEEE80211_RATE_ERP_G);
 
-       d->perfect_tx_time = ieee80211_frame_duration(local, 1200,
+       d->perfect_tx_time = ieee80211_frame_duration(band, 1200,
                        rate->bitrate, erp, 1);
-       d->ack_time = ieee80211_frame_duration(local, 10,
+       d->ack_time = ieee80211_frame_duration(band, 10,
                        rate->bitrate, erp, 1);
 }
 
 {
        struct minstrel_sta_info *mi = priv_sta;
        struct minstrel_priv *mp = priv;
-       struct ieee80211_local *local = hw_to_local(mp->hw);
        struct ieee80211_rate *ctl_rate;
        unsigned int i, n = 0;
        unsigned int t_slot = 9; /* FIXME: get real slot time */
 
        mi->lowest_rix = rate_lowest_index(sband, sta);
        ctl_rate = &sband->bitrates[mi->lowest_rix];
-       mi->sp_ack_dur = ieee80211_frame_duration(local, 10, ctl_rate->bitrate,
+       mi->sp_ack_dur = ieee80211_frame_duration(sband->band, 10,
+                               ctl_rate->bitrate,
                                !!(ctl_rate->flags & IEEE80211_RATE_ERP_G), 1);
 
        for (i = 0; i < sband->n_bitrates; i++) {
 
                mr->rix = i;
                mr->bitrate = sband->bitrates[i].bitrate / 5;
-               calc_rate_durations(local, mr, &sband->bitrates[i]);
+               calc_rate_durations(sband->band, mr, &sband->bitrates[i]);
 
                /* calculate maximum number of retransmissions before
                 * fallback (based on maximum segment size) */
 
        struct minstrel_ht_sta_priv *msp = priv_sta;
        struct minstrel_ht_sta *mi = &msp->ht;
        struct ieee80211_mcs_info *mcs = &sta->ht_cap.mcs;
-       struct ieee80211_local *local = hw_to_local(mp->hw);
        u16 sta_cap = sta->ht_cap.cap;
        int n_supported = 0;
        int ack_dur;
        memset(mi, 0, sizeof(*mi));
        mi->stats_update = jiffies;
 
-       ack_dur = ieee80211_frame_duration(local, 10, 60, 1, 1);
-       mi->overhead = ieee80211_frame_duration(local, 0, 60, 1, 1) + ack_dur;
+       ack_dur = ieee80211_frame_duration(sband->band, 10, 60, 1, 1);
+       mi->overhead = ieee80211_frame_duration(sband->band, 0, 60, 1, 1) + ack_dur;
        mi->overhead_rtscts = mi->overhead + 2 * ack_dur;
 
        mi->avg_ampdu_len = MINSTREL_FRAC(1, 1);
 
                /* Time needed to transmit ACK
                 * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
                 * to closest integer */
-               dur = ieee80211_frame_duration(local, 10, rate, erp,
+               dur = ieee80211_frame_duration(sband->band, 10, rate, erp,
                                tx->sdata->vif.bss_conf.use_short_preamble);
 
        if (next_frag_len) {
                 * transmit next fragment plus ACK and 2 x SIFS. */
                dur *= 2; /* ACK + SIFS */
                /* next fragment */
-               dur += ieee80211_frame_duration(local, next_frag_len,
+               dur += ieee80211_frame_duration(sband->band, next_frag_len,
                                txrate->bitrate, erp,
                                tx->sdata->vif.bss_conf.use_short_preamble);
        }
 
        }
 }
 
-int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,
+int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
                             int rate, int erp, int short_preamble)
 {
        int dur;
         * DIV_ROUND_UP() operations.
         */
 
-       if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ || erp) {
+       if (band == IEEE80211_BAND_5GHZ || erp) {
                /*
                 * OFDM:
                 *
 /* Exported duration function for driver use */
 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
                                        struct ieee80211_vif *vif,
+                                       enum ieee80211_band band,
                                        size_t frame_len,
                                        struct ieee80211_rate *rate)
 {
-       struct ieee80211_local *local = hw_to_local(hw);
        struct ieee80211_sub_if_data *sdata;
        u16 dur;
        int erp;
                        erp = rate->flags & IEEE80211_RATE_ERP_G;
        }
 
-       dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, erp,
+       dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
                                       short_preamble);
 
        return cpu_to_le16(dur);
        u16 dur;
        struct ieee80211_supported_band *sband;
 
-       sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
+       sband = local->hw.wiphy->bands[frame_txctl->band];
 
        short_preamble = false;
 
        }
 
        /* CTS duration */
-       dur = ieee80211_frame_duration(local, 10, rate->bitrate,
+       dur = ieee80211_frame_duration(sband->band, 10, rate->bitrate,
                                       erp, short_preamble);
        /* Data frame duration */
-       dur += ieee80211_frame_duration(local, frame_len, rate->bitrate,
+       dur += ieee80211_frame_duration(sband->band, frame_len, rate->bitrate,
                                        erp, short_preamble);
        /* ACK duration */
-       dur += ieee80211_frame_duration(local, 10, rate->bitrate,
+       dur += ieee80211_frame_duration(sband->band, 10, rate->bitrate,
                                        erp, short_preamble);
 
        return cpu_to_le16(dur);
        u16 dur;
        struct ieee80211_supported_band *sband;
 
-       sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
+       sband = local->hw.wiphy->bands[frame_txctl->band];
 
        short_preamble = false;
 
        }
 
        /* Data frame duration */
-       dur = ieee80211_frame_duration(local, frame_len, rate->bitrate,
+       dur = ieee80211_frame_duration(sband->band, frame_len, rate->bitrate,
                                       erp, short_preamble);
        if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
                /* ACK duration */
-               dur += ieee80211_frame_duration(local, 10, rate->bitrate,
+               dur += ieee80211_frame_duration(sband->band, 10, rate->bitrate,
                                                erp, short_preamble);
        }
 
        int i;
 
        sband = local->hw.wiphy->bands[band];
-       if (!sband) {
-               WARN_ON(1);
-               sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
-       }
+       if (WARN_ON(!sband))
+               return 1;
 
        if (band == IEEE80211_BAND_2GHZ)
                mandatory_flag = IEEE80211_RATE_MANDATORY_B;
        int i, j;
        sband = local->hw.wiphy->bands[band];
 
-       if (!sband) {
-               WARN_ON(1);
-               sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
-       }
+       if (WARN_ON(!sband))
+               return 1;
 
        bitrates = sband->bitrates;
        num_rates = sband->n_bitrates;