+- mutex_unlock(&intf->beacon_skb_mutex);
+-
+ return 0;
+ }
+
+-int rt2x00queue_update_beacon_locked(struct rt2x00_dev *rt2x00dev,
+- struct ieee80211_vif *vif)
++int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev,
++ struct ieee80211_vif *vif)
+ {
+ struct rt2x00_intf *intf = vif_to_intf(vif);
+ struct skb_frame_desc *skbdesc;
+@@ -815,19 +811,6 @@ int rt2x00queue_update_beacon_locked(str
+
+ }
+
+-int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev,
+- struct ieee80211_vif *vif)
+-{
+- struct rt2x00_intf *intf = vif_to_intf(vif);
+- int ret;
+-
+- mutex_lock(&intf->beacon_skb_mutex);
+- ret = rt2x00queue_update_beacon_locked(rt2x00dev, vif);
+- mutex_unlock(&intf->beacon_skb_mutex);
+-
+- return ret;
+-}
+-
+ bool rt2x00queue_for_each_entry(struct data_queue *queue,
+ enum queue_index start,
+ enum queue_index end,
+--- a/drivers/net/wireless/rt2x00/rt2x00queue.h
++++ b/drivers/net/wireless/rt2x00/rt2x00queue.h
+@@ -353,6 +353,7 @@ struct txentry_desc {
+ */
+ enum queue_entry_flags {
+ ENTRY_BCN_ASSIGNED,
++ ENTRY_BCN_ENABLED,
+ ENTRY_OWNER_DEVICE_DATA,
+ ENTRY_DATA_PENDING,
+ ENTRY_DATA_IO_FAILED,
+--- a/drivers/net/wireless/ath/ath9k/main.c
++++ b/drivers/net/wireless/ath/ath9k/main.c
+@@ -1757,7 +1757,6 @@ out:
+ void ath9k_update_p2p_ps(struct ath_softc *sc, struct ieee80211_vif *vif)
+ {
+ struct ath_vif *avp = (void *)vif->drv_priv;
+- unsigned long flags;
+ u32 tsf;
+
+ if (!sc->p2p_ps_timer)
+@@ -1767,14 +1766,9 @@ void ath9k_update_p2p_ps(struct ath_soft
+ return;
+
+ sc->p2p_ps_vif = avp;
+-
+- spin_lock_irqsave(&sc->sc_pm_lock, flags);
+- if (!(sc->ps_flags & PS_BEACON_SYNC)) {
+- tsf = ath9k_hw_gettsf32(sc->sc_ah);
+- ieee80211_parse_p2p_noa(&vif->bss_conf.p2p_noa_attr, &avp->noa, tsf);
+- ath9k_update_p2p_ps_timer(sc, avp);
+- }
+- spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
++ tsf = ath9k_hw_gettsf32(sc->sc_ah);
++ ieee80211_parse_p2p_noa(&vif->bss_conf.p2p_noa_attr, &avp->noa, tsf);
++ ath9k_update_p2p_ps_timer(sc, avp);
+ }
+
+ static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
+@@ -1791,6 +1785,7 @@ static void ath9k_bss_info_changed(struc
+ struct ath_hw *ah = sc->sc_ah;
+ struct ath_common *common = ath9k_hw_common(ah);
+ struct ath_vif *avp = (void *)vif->drv_priv;
++ unsigned long flags;
+ int slottime;
+
+ ath9k_ps_wakeup(sc);
+@@ -1853,7 +1848,10 @@ static void ath9k_bss_info_changed(struc
+
+ if (changed & BSS_CHANGED_P2P_PS) {
+ spin_lock_bh(&sc->sc_pcu_lock);
+- ath9k_update_p2p_ps(sc, vif);
++ spin_lock_irqsave(&sc->sc_pm_lock, flags);
++ if (!(sc->ps_flags & PS_BEACON_SYNC))
++ ath9k_update_p2p_ps(sc, vif);
++ spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
+ spin_unlock_bh(&sc->sc_pcu_lock);
+ }
+
+@@ -2232,14 +2230,6 @@ static void ath9k_sw_scan_complete(struc
+ clear_bit(ATH_OP_SCANNING, &common->op_flags);
+ }
+
+-static void ath9k_channel_switch_beacon(struct ieee80211_hw *hw,
+- struct ieee80211_vif *vif,
+- struct cfg80211_chan_def *chandef)
+-{
+- /* depend on vif->csa_active only */
+- return;
+-}
+-
+ struct ieee80211_ops ath9k_ops = {
+ .tx = ath9k_tx,
+ .start = ath9k_start,
+@@ -2287,5 +2277,4 @@ struct ieee80211_ops ath9k_ops = {
+ #endif
+ .sw_scan_start = ath9k_sw_scan_start,
+ .sw_scan_complete = ath9k_sw_scan_complete,
+- .channel_switch_beacon = ath9k_channel_switch_beacon,
+ };
+--- a/drivers/net/wireless/ath/ath10k/mac.c
++++ b/drivers/net/wireless/ath/ath10k/mac.c
+@@ -4142,14 +4142,6 @@ static int ath10k_set_bitrate_mask(struc
+ fixed_nss, force_sgi);
+ }
+
+-static void ath10k_channel_switch_beacon(struct ieee80211_hw *hw,
+- struct ieee80211_vif *vif,
+- struct cfg80211_chan_def *chandef)
+-{
+- /* there's no need to do anything here. vif->csa_active is enough */
+- return;
+-}
+-
+ static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
+ struct ieee80211_vif *vif,
+ struct ieee80211_sta *sta,
+@@ -4256,7 +4248,6 @@ static const struct ieee80211_ops ath10k
+ .restart_complete = ath10k_restart_complete,
+ .get_survey = ath10k_get_survey,
+ .set_bitrate_mask = ath10k_set_bitrate_mask,
+- .channel_switch_beacon = ath10k_channel_switch_beacon,
+ .sta_rc_update = ath10k_sta_rc_update,
+ .get_tsf = ath10k_get_tsf,
+ #ifdef CONFIG_PM
+--- a/net/mac80211/cfg.c
++++ b/net/mac80211/cfg.c
+@@ -468,327 +468,6 @@ void sta_set_rate_info_rx(struct sta_inf
+ rinfo->flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
+ }
+
+-static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
+-{
+- struct ieee80211_sub_if_data *sdata = sta->sdata;
+- struct ieee80211_local *local = sdata->local;
+- struct rate_control_ref *ref = local->rate_ctrl;
+- struct timespec uptime;
+- u64 packets = 0;
+- u32 thr = 0;
+- int i, ac;
+-
+- sinfo->generation = sdata->local->sta_generation;
+-
+- sinfo->filled = STATION_INFO_INACTIVE_TIME |
+- STATION_INFO_RX_BYTES64 |
+- STATION_INFO_TX_BYTES64 |
+- STATION_INFO_RX_PACKETS |
+- STATION_INFO_TX_PACKETS |
+- STATION_INFO_TX_RETRIES |
+- STATION_INFO_TX_FAILED |
+- STATION_INFO_TX_BITRATE |
+- STATION_INFO_RX_BITRATE |
+- STATION_INFO_RX_DROP_MISC |
+- STATION_INFO_BSS_PARAM |
+- STATION_INFO_CONNECTED_TIME |
+- STATION_INFO_STA_FLAGS |
+- STATION_INFO_BEACON_LOSS_COUNT;
+-
+- do_posix_clock_monotonic_gettime(&uptime);
+- sinfo->connected_time = uptime.tv_sec - sta->last_connected;
+-
+- sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
+- sinfo->tx_bytes = 0;
+- for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
+- sinfo->tx_bytes += sta->tx_bytes[ac];
+- packets += sta->tx_packets[ac];
+- }
+- sinfo->tx_packets = packets;
+- sinfo->rx_bytes = sta->rx_bytes;
+- sinfo->rx_packets = sta->rx_packets;
+- sinfo->tx_retries = sta->tx_retry_count;
+- sinfo->tx_failed = sta->tx_retry_failed;
+- sinfo->rx_dropped_misc = sta->rx_dropped;
+- sinfo->beacon_loss_count = sta->beacon_loss_count;
+-
+- if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) ||
+- (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) {
+- sinfo->filled |= STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
+- if (!local->ops->get_rssi ||
+- drv_get_rssi(local, sdata, &sta->sta, &sinfo->signal))
+- sinfo->signal = (s8)sta->last_signal;
+- sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal);
+- }
+- if (sta->chains) {
+- sinfo->filled |= STATION_INFO_CHAIN_SIGNAL |
+- STATION_INFO_CHAIN_SIGNAL_AVG;
+-
+- sinfo->chains = sta->chains;
+- for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
+- sinfo->chain_signal[i] = sta->chain_signal_last[i];
+- sinfo->chain_signal_avg[i] =
+- (s8) -ewma_read(&sta->chain_signal_avg[i]);
+- }
+- }
+-
+- sta_set_rate_info_tx(sta, &sta->last_tx_rate, &sinfo->txrate);
+- sta_set_rate_info_rx(sta, &sinfo->rxrate);
+-
+- if (ieee80211_vif_is_mesh(&sdata->vif)) {
+-#ifdef CPTCFG_MAC80211_MESH
+- sinfo->filled |= STATION_INFO_LLID |
+- STATION_INFO_PLID |
+- STATION_INFO_PLINK_STATE |
+- STATION_INFO_LOCAL_PM |
+- STATION_INFO_PEER_PM |
+- STATION_INFO_NONPEER_PM;
+-
+- sinfo->llid = sta->llid;
+- sinfo->plid = sta->plid;
+- sinfo->plink_state = sta->plink_state;
+- if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) {
+- sinfo->filled |= STATION_INFO_T_OFFSET;
+- sinfo->t_offset = sta->t_offset;
+- }
+- sinfo->local_pm = sta->local_pm;
+- sinfo->peer_pm = sta->peer_pm;
+- sinfo->nonpeer_pm = sta->nonpeer_pm;
+-#endif
+- }
+-
+- sinfo->bss_param.flags = 0;
+- if (sdata->vif.bss_conf.use_cts_prot)
+- sinfo->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
+- if (sdata->vif.bss_conf.use_short_preamble)
+- sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
+- if (sdata->vif.bss_conf.use_short_slot)
+- sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
+- sinfo->bss_param.dtim_period = sdata->local->hw.conf.ps_dtim_period;
+- sinfo->bss_param.beacon_interval = sdata->vif.bss_conf.beacon_int;
+-
+- sinfo->sta_flags.set = 0;
+- sinfo->sta_flags.mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
+- BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
+- BIT(NL80211_STA_FLAG_WME) |
+- BIT(NL80211_STA_FLAG_MFP) |
+- BIT(NL80211_STA_FLAG_AUTHENTICATED) |
+- BIT(NL80211_STA_FLAG_ASSOCIATED) |
+- BIT(NL80211_STA_FLAG_TDLS_PEER);
+- if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
+- sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
+- if (test_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE))
+- sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);
+- if (test_sta_flag(sta, WLAN_STA_WME))
+- sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_WME);
+- if (test_sta_flag(sta, WLAN_STA_MFP))
+- sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_MFP);
+- if (test_sta_flag(sta, WLAN_STA_AUTH))
+- sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
+- if (test_sta_flag(sta, WLAN_STA_ASSOC))
+- sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
+- if (test_sta_flag(sta, WLAN_STA_TDLS_PEER))
+- sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
+-
+- /* check if the driver has a SW RC implementation */
+- if (ref && ref->ops->get_expected_throughput)
+- thr = ref->ops->get_expected_throughput(sta->rate_ctrl_priv);
+- else
+- thr = drv_get_expected_throughput(local, &sta->sta);
+-
+- if (thr != 0) {
+- sinfo->filled |= STATION_INFO_EXPECTED_THROUGHPUT;
+- sinfo->expected_throughput = thr;
+- }
+-}
+-
+-static const char ieee80211_gstrings_sta_stats[][ETH_GSTRING_LEN] = {
+- "rx_packets", "rx_bytes", "wep_weak_iv_count",
+- "rx_duplicates", "rx_fragments", "rx_dropped",
+- "tx_packets", "tx_bytes", "tx_fragments",
+- "tx_filtered", "tx_retry_failed", "tx_retries",
+- "beacon_loss", "sta_state", "txrate", "rxrate", "signal",
+- "channel", "noise", "ch_time", "ch_time_busy",
+- "ch_time_ext_busy", "ch_time_rx", "ch_time_tx"
+-};
+-#define STA_STATS_LEN ARRAY_SIZE(ieee80211_gstrings_sta_stats)
+-
+-static int ieee80211_get_et_sset_count(struct wiphy *wiphy,
+- struct net_device *dev,
+- int sset)
+-{
+- struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+- int rv = 0;
+-
+- if (sset == ETH_SS_STATS)
+- rv += STA_STATS_LEN;
+-
+- rv += drv_get_et_sset_count(sdata, sset);
+-
+- if (rv == 0)
+- return -EOPNOTSUPP;
+- return rv;
+-}
+-
+-static void ieee80211_get_et_stats(struct wiphy *wiphy,
+- struct net_device *dev,
+- struct ethtool_stats *stats,
+- u64 *data)
+-{
+- struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+- struct ieee80211_chanctx_conf *chanctx_conf;
+- struct ieee80211_channel *channel;
+- struct sta_info *sta;
+- struct ieee80211_local *local = sdata->local;
+- struct station_info sinfo;
+- struct survey_info survey;
+- int i, q;
+-#define STA_STATS_SURVEY_LEN 7
+-
+- memset(data, 0, sizeof(u64) * STA_STATS_LEN);
+-
+-#define ADD_STA_STATS(sta) \
+- do { \
+- data[i++] += sta->rx_packets; \
+- data[i++] += sta->rx_bytes; \
+- data[i++] += sta->wep_weak_iv_count; \
+- data[i++] += sta->num_duplicates; \
+- data[i++] += sta->rx_fragments; \
+- data[i++] += sta->rx_dropped; \
+- \
+- data[i++] += sinfo.tx_packets; \
+- data[i++] += sinfo.tx_bytes; \
+- data[i++] += sta->tx_fragments; \
+- data[i++] += sta->tx_filtered_count; \
+- data[i++] += sta->tx_retry_failed; \
+- data[i++] += sta->tx_retry_count; \
+- data[i++] += sta->beacon_loss_count; \
+- } while (0)
+-
+- /* For Managed stations, find the single station based on BSSID
+- * and use that. For interface types, iterate through all available
+- * stations and add stats for any station that is assigned to this
+- * network device.
+- */
+-
+- mutex_lock(&local->sta_mtx);
+-
+- if (sdata->vif.type == NL80211_IFTYPE_STATION) {
+- sta = sta_info_get_bss(sdata, sdata->u.mgd.bssid);
+-
+- if (!(sta && !WARN_ON(sta->sdata->dev != dev)))
+- goto do_survey;
+-
+- sinfo.filled = 0;
+- sta_set_sinfo(sta, &sinfo);
+-
+- i = 0;
+- ADD_STA_STATS(sta);
+-
+- data[i++] = sta->sta_state;
+-
+-
+- if (sinfo.filled & STATION_INFO_TX_BITRATE)
+- data[i] = 100000 *
+- cfg80211_calculate_bitrate(&sinfo.txrate);
+- i++;
+- if (sinfo.filled & STATION_INFO_RX_BITRATE)
+- data[i] = 100000 *
+- cfg80211_calculate_bitrate(&sinfo.rxrate);
+- i++;
+-
+- if (sinfo.filled & STATION_INFO_SIGNAL_AVG)
+- data[i] = (u8)sinfo.signal_avg;
+- i++;
+- } else {
+- list_for_each_entry(sta, &local->sta_list, list) {
+- /* Make sure this station belongs to the proper dev */
+- if (sta->sdata->dev != dev)
+- continue;
+-
+- sinfo.filled = 0;
+- sta_set_sinfo(sta, &sinfo);
+- i = 0;
+- ADD_STA_STATS(sta);
+- }
+- }
+-
+-do_survey:
+- i = STA_STATS_LEN - STA_STATS_SURVEY_LEN;
+- /* Get survey stats for current channel */
+- survey.filled = 0;
+-
+- rcu_read_lock();
+- chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
+- if (chanctx_conf)
+- channel = chanctx_conf->def.chan;
+- else
+- channel = NULL;
+- rcu_read_unlock();
+-
+- if (channel) {
+- q = 0;
+- do {
+- survey.filled = 0;
+- if (drv_get_survey(local, q, &survey) != 0) {
+- survey.filled = 0;
+- break;
+- }
+- q++;
+- } while (channel != survey.channel);
+- }
+-
+- if (survey.filled)
+- data[i++] = survey.channel->center_freq;
+- else
+- data[i++] = 0;
+- if (survey.filled & SURVEY_INFO_NOISE_DBM)
+- data[i++] = (u8)survey.noise;
+- else
+- data[i++] = -1LL;
+- if (survey.filled & SURVEY_INFO_CHANNEL_TIME)
+- data[i++] = survey.channel_time;
+- else
+- data[i++] = -1LL;
+- if (survey.filled & SURVEY_INFO_CHANNEL_TIME_BUSY)
+- data[i++] = survey.channel_time_busy;
+- else
+- data[i++] = -1LL;
+- if (survey.filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY)
+- data[i++] = survey.channel_time_ext_busy;
+- else
+- data[i++] = -1LL;
+- if (survey.filled & SURVEY_INFO_CHANNEL_TIME_RX)
+- data[i++] = survey.channel_time_rx;
+- else
+- data[i++] = -1LL;
+- if (survey.filled & SURVEY_INFO_CHANNEL_TIME_TX)
+- data[i++] = survey.channel_time_tx;
+- else
+- data[i++] = -1LL;
+-
+- mutex_unlock(&local->sta_mtx);
+-
+- if (WARN_ON(i != STA_STATS_LEN))
+- return;
+-
+- drv_get_et_stats(sdata, stats, &(data[STA_STATS_LEN]));
+-}
+-
+-static void ieee80211_get_et_strings(struct wiphy *wiphy,
+- struct net_device *dev,
+- u32 sset, u8 *data)
+-{
+- struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+- int sz_sta_stats = 0;
+-
+- if (sset == ETH_SS_STATS) {
+- sz_sta_stats = sizeof(ieee80211_gstrings_sta_stats);
+- memcpy(data, ieee80211_gstrings_sta_stats, sz_sta_stats);
+- }
+- drv_get_et_strings(sdata, sset, &(data[sz_sta_stats]));
+-}
+-
+ static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
+ int idx, u8 *mac, struct station_info *sinfo)
+ {
+@@ -875,7 +554,8 @@ static int ieee80211_set_monitor_channel
+ }
+
+ static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata,
+- const u8 *resp, size_t resp_len)
++ const u8 *resp, size_t resp_len,
++ const struct ieee80211_csa_settings *csa)
+ {
+ struct probe_resp *new, *old;
+
+@@ -891,6 +571,11 @@ static int ieee80211_set_probe_resp(stru
+ new->len = resp_len;
+ memcpy(new->data, resp, resp_len);
+
++ if (csa)
++ memcpy(new->csa_counter_offsets, csa->counter_offsets_presp,
++ csa->n_counter_offsets_presp *
++ sizeof(new->csa_counter_offsets[0]));
++
+ rcu_assign_pointer(sdata->u.ap.probe_resp, new);
+ if (old)
+ kfree_rcu(old, rcu_head);
+@@ -899,7 +584,8 @@ static int ieee80211_set_probe_resp(stru
+ }
+
+ static int ieee80211_assign_beacon(struct ieee80211_sub_if_data *sdata,
+- struct cfg80211_beacon_data *params)
++ struct cfg80211_beacon_data *params,
++ const struct ieee80211_csa_settings *csa)
+ {
+ struct beacon_data *new, *old;
+ int new_head_len, new_tail_len;
+@@ -943,6 +629,13 @@ static int ieee80211_assign_beacon(struc
+ new->head_len = new_head_len;
+ new->tail_len = new_tail_len;
+
++ if (csa) {
++ new->csa_current_counter = csa->count;
++ memcpy(new->csa_counter_offsets, csa->counter_offsets_beacon,
++ csa->n_counter_offsets_beacon *
++ sizeof(new->csa_counter_offsets[0]));
++ }
++
+ /* copy in head */
+ if (params->head)
+ memcpy(new->head, params->head, new_head_len);
+@@ -957,7 +650,7 @@ static int ieee80211_assign_beacon(struc
+ memcpy(new->tail, old->tail, new_tail_len);
+
+ err = ieee80211_set_probe_resp(sdata, params->probe_resp,
+- params->probe_resp_len);
++ params->probe_resp_len, csa);
+ if (err < 0)
+ return err;
+ if (err == 0)
+@@ -1042,7 +735,7 @@ static int ieee80211_start_ap(struct wip
+ sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow |=
+ IEEE80211_P2P_OPPPS_ENABLE_BIT;
+
+- err = ieee80211_assign_beacon(sdata, ¶ms->beacon);
++ err = ieee80211_assign_beacon(sdata, ¶ms->beacon, NULL);
+ if (err < 0) {
+ ieee80211_vif_release_channel(sdata);
+ return err;
+@@ -1090,7 +783,7 @@ static int ieee80211_change_beacon(struc
+ if (!old)
+ return -ENOENT;
+
+- err = ieee80211_assign_beacon(sdata, params);
++ err = ieee80211_assign_beacon(sdata, params, NULL);
+ if (err < 0)
+ return err;
+ ieee80211_bss_info_change_notify(sdata, err);
+@@ -3073,7 +2766,8 @@ static int ieee80211_set_after_csa_beaco
+
+ switch (sdata->vif.type) {
+ case NL80211_IFTYPE_AP:
+- err = ieee80211_assign_beacon(sdata, sdata->u.ap.next_beacon);
++ err = ieee80211_assign_beacon(sdata, sdata->u.ap.next_beacon,
++ NULL);
+ kfree(sdata->u.ap.next_beacon);
+ sdata->u.ap.next_beacon = NULL;
+
+@@ -3176,6 +2870,7 @@ static int ieee80211_set_csa_beacon(stru
+ struct cfg80211_csa_settings *params,
+ u32 *changed)
+ {
++ struct ieee80211_csa_settings csa = {};
+ int err;
+
+ switch (sdata->vif.type) {
+@@ -3210,20 +2905,13 @@ static int ieee80211_set_csa_beacon(stru
+ IEEE80211_MAX_CSA_COUNTERS_NUM))
+ return -EINVAL;
+
+- /* make sure we don't have garbage in other counters */
+- memset(sdata->csa_counter_offset_beacon, 0,
+- sizeof(sdata->csa_counter_offset_beacon));
+- memset(sdata->csa_counter_offset_presp, 0,
+- sizeof(sdata->csa_counter_offset_presp));
+-
+- memcpy(sdata->csa_counter_offset_beacon,
+- params->counter_offsets_beacon,
+- params->n_counter_offsets_beacon * sizeof(u16));
+- memcpy(sdata->csa_counter_offset_presp,
+- params->counter_offsets_presp,
+- params->n_counter_offsets_presp * sizeof(u16));
++ csa.counter_offsets_beacon = params->counter_offsets_beacon;
++ csa.counter_offsets_presp = params->counter_offsets_presp;
++ csa.n_counter_offsets_beacon = params->n_counter_offsets_beacon;
++ csa.n_counter_offsets_presp = params->n_counter_offsets_presp;
++ csa.count = params->count;
+
+- err = ieee80211_assign_beacon(sdata, ¶ms->beacon_csa);
++ err = ieee80211_assign_beacon(sdata, ¶ms->beacon_csa, &csa);
+ if (err < 0) {
+ kfree(sdata->u.ap.next_beacon);
+ return err;
+@@ -3367,7 +3055,6 @@ __ieee80211_channel_switch(struct wiphy
+ sdata->csa_radar_required = params->radar_required;
+ sdata->csa_chandef = params->chandef;
+ sdata->csa_block_tx = params->block_tx;
+- sdata->csa_current_counter = params->count;
+ sdata->vif.csa_active = true;
+
+ if (sdata->csa_block_tx)
+@@ -3515,10 +3202,23 @@ static int ieee80211_mgmt_tx(struct wiph
+ sdata->vif.type == NL80211_IFTYPE_ADHOC) &&
+ params->n_csa_offsets) {
+ int i;
+- u8 c = sdata->csa_current_counter;
++ struct beacon_data *beacon = NULL;
++
++ rcu_read_lock();
+
+- for (i = 0; i < params->n_csa_offsets; i++)
+- data[params->csa_offsets[i]] = c;
++ if (sdata->vif.type == NL80211_IFTYPE_AP)
++ beacon = rcu_dereference(sdata->u.ap.beacon);
++ else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
++ beacon = rcu_dereference(sdata->u.ibss.presp);
++ else if (ieee80211_vif_is_mesh(&sdata->vif))
++ beacon = rcu_dereference(sdata->u.mesh.beacon);
++
++ if (beacon)
++ for (i = 0; i < params->n_csa_offsets; i++)
++ data[params->csa_offsets[i]] =
++ beacon->csa_current_counter;
++
++ rcu_read_unlock();
+ }
+
+ IEEE80211_SKB_CB(skb)->flags = flags;
+@@ -3598,21 +3298,6 @@ static int ieee80211_get_antenna(struct
+ return drv_get_antenna(local, tx_ant, rx_ant);
+ }
+
+-static int ieee80211_set_ringparam(struct wiphy *wiphy, u32 tx, u32 rx)
+-{
+- struct ieee80211_local *local = wiphy_priv(wiphy);
+-
+- return drv_set_ringparam(local, tx, rx);
+-}
+-
+-static void ieee80211_get_ringparam(struct wiphy *wiphy,
+- u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
+-{
+- struct ieee80211_local *local = wiphy_priv(wiphy);
+-
+- drv_get_ringparam(local, tx, tx_max, rx, rx_max);
+-}
+-
+ static int ieee80211_set_rekey_data(struct wiphy *wiphy,
+ struct net_device *dev,
+ struct cfg80211_gtk_rekey_data *data)
+@@ -3844,8 +3529,6 @@ const struct cfg80211_ops mac80211_confi
+ .mgmt_frame_register = ieee80211_mgmt_frame_register,
+ .set_antenna = ieee80211_set_antenna,
+ .get_antenna = ieee80211_get_antenna,
+- .set_ringparam = ieee80211_set_ringparam,
+- .get_ringparam = ieee80211_get_ringparam,
+ .set_rekey_data = ieee80211_set_rekey_data,
+ .tdls_oper = ieee80211_tdls_oper,
+ .tdls_mgmt = ieee80211_tdls_mgmt,
+@@ -3854,9 +3537,6 @@ const struct cfg80211_ops mac80211_confi
+ #ifdef CONFIG_PM
+ .set_wakeup = ieee80211_set_wakeup,
+ #endif
+- .get_et_sset_count = ieee80211_get_et_sset_count,
+- .get_et_stats = ieee80211_get_et_stats,
+- .get_et_strings = ieee80211_get_et_strings,
+ .get_channel = ieee80211_cfg_get_channel,
+ .start_radar_detection = ieee80211_start_radar_detection,
+ .channel_switch = ieee80211_channel_switch,
+--- a/net/mac80211/debugfs_sta.c
++++ b/net/mac80211/debugfs_sta.c
+@@ -587,7 +587,6 @@ void ieee80211_sta_debugfs_add(struct st
+ DEBUGFS_ADD_COUNTER(tx_filtered, tx_filtered_count);
+ DEBUGFS_ADD_COUNTER(tx_retry_failed, tx_retry_failed);
+ DEBUGFS_ADD_COUNTER(tx_retry_count, tx_retry_count);
+- DEBUGFS_ADD_COUNTER(wep_weak_iv_count, wep_weak_iv_count);
+
+ if (sizeof(sta->driver_buffered_tids) == sizeof(u32))
+ debugfs_create_x32("driver_buffered_tids", 0400,
+--- a/net/mac80211/wep.c
++++ b/net/mac80211/wep.c
+@@ -271,22 +271,6 @@ static int ieee80211_wep_decrypt(struct
+ return ret;
+ }
+
+-
+-static bool ieee80211_wep_is_weak_iv(struct sk_buff *skb,
+- struct ieee80211_key *key)
+-{
+- struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+- unsigned int hdrlen;
+- u8 *ivpos;
+- u32 iv;
+-
+- hdrlen = ieee80211_hdrlen(hdr->frame_control);
+- ivpos = skb->data + hdrlen;
+- iv = (ivpos[0] << 16) | (ivpos[1] << 8) | ivpos[2];
+-
+- return ieee80211_wep_weak_iv(iv, key->conf.keylen);
+-}
+-
+ ieee80211_rx_result
+ ieee80211_crypto_wep_decrypt(struct ieee80211_rx_data *rx)
+ {
+@@ -301,16 +285,12 @@ ieee80211_crypto_wep_decrypt(struct ieee
+ if (!(status->flag & RX_FLAG_DECRYPTED)) {
+ if (skb_linearize(rx->skb))
+ return RX_DROP_UNUSABLE;
+- if (rx->sta && ieee80211_wep_is_weak_iv(rx->skb, rx->key))
+- rx->sta->wep_weak_iv_count++;
+ if (ieee80211_wep_decrypt(rx->local, rx->skb, rx->key))
+ return RX_DROP_UNUSABLE;
+ } else if (!(status->flag & RX_FLAG_IV_STRIPPED)) {
+ if (!pskb_may_pull(rx->skb, ieee80211_hdrlen(fc) +
+ IEEE80211_WEP_IV_LEN))
+ return RX_DROP_UNUSABLE;
+- if (rx->sta && ieee80211_wep_is_weak_iv(rx->skb, rx->key))
+- rx->sta->wep_weak_iv_count++;
+ ieee80211_wep_remove_iv(rx->local, rx->skb, rx->key);
+ /* remove ICV */
+ if (pskb_trim(rx->skb, rx->skb->len - IEEE80211_WEP_ICV_LEN))
+--- a/include/net/cfg80211.h
++++ b/include/net/cfg80211.h
+@@ -2278,16 +2278,6 @@ struct cfg80211_qos_map {
+ *
+ * @set_noack_map: Set the NoAck Map for the TIDs.
+ *
+- * @get_et_sset_count: Ethtool API to get string-set count.
+- * See @ethtool_ops.get_sset_count
+- *
+- * @get_et_stats: Ethtool API to get a set of u64 stats.
+- * See @ethtool_ops.get_ethtool_stats
+- *
+- * @get_et_strings: Ethtool API to get a set of strings to describe stats
+- * and perhaps other supported types of ethtool data-sets.
+- * See @ethtool_ops.get_strings
+- *
+ * @get_channel: Get the current operating channel for the virtual interface.
+ * For monitor interfaces, it should return %NULL unless there's a single
+ * current monitoring channel.
+@@ -2529,13 +2519,6 @@ struct cfg80211_ops {
+ struct net_device *dev,
+ u16 noack_map);
+
+- int (*get_et_sset_count)(struct wiphy *wiphy,
+- struct net_device *dev, int sset);
+- void (*get_et_stats)(struct wiphy *wiphy, struct net_device *dev,
+- struct ethtool_stats *stats, u64 *data);
+- void (*get_et_strings)(struct wiphy *wiphy, struct net_device *dev,
+- u32 sset, u8 *data);
+-
+ int (*get_channel)(struct wiphy *wiphy,
+ struct wireless_dev *wdev,
+ struct cfg80211_chan_def *chandef);
+@@ -4846,6 +4829,10 @@ void cfg80211_stop_iface(struct wiphy *w
+ */
+ void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy);
+
++
++/* ethtool helper */
++void cfg80211_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info);
++
+ /* Logging, debugging and troubleshooting/diagnostic helpers. */
+
+ /* wiphy_printk helpers, similar to dev_printk */
+--- a/net/mac80211/Makefile
++++ b/net/mac80211/Makefile
+@@ -17,6 +17,7 @@ mac80211-y := \
+ aes_ccm.o \
+ aes_cmac.o \
+ cfg.o \
++ ethtool.o \
+ rx.o \
+ spectmgmt.o \
+ tx.o \
+--- a/net/mac80211/ieee80211_i.h
++++ b/net/mac80211/ieee80211_i.h
+@@ -229,16 +229,29 @@ struct ieee80211_rx_data {
+ u16 tkip_iv16;
+ };
+
++struct ieee80211_csa_settings {
++ const u16 *counter_offsets_beacon;
++ const u16 *counter_offsets_presp;
++
++ int n_counter_offsets_beacon;
++ int n_counter_offsets_presp;
++
++ u8 count;
++};
++
+ struct beacon_data {
+ u8 *head, *tail;
+ int head_len, tail_len;
+ struct ieee80211_meshconf_ie *meshconf;
++ u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
++ u8 csa_current_counter;
+ struct rcu_head rcu_head;
+ };
+
+ struct probe_resp {
+ struct rcu_head rcu_head;
+ int len;
++ u16 csa_counter_offsets[IEEE80211_MAX_CSA_COUNTERS_NUM];
+ u8 data[0];
+ };
+
+@@ -754,8 +767,6 @@ struct ieee80211_sub_if_data {
+ struct mac80211_qos_map __rcu *qos_map;
+
+ struct work_struct csa_finalize_work;
+- u16 csa_counter_offset_beacon[IEEE80211_MAX_CSA_COUNTERS_NUM];
+- u16 csa_counter_offset_presp[IEEE80211_MAX_CSA_COUNTERS_NUM];
+ bool csa_radar_required;
+ bool csa_block_tx; /* write-protected by sdata_lock and local->mtx */
+ struct cfg80211_chan_def csa_chandef;
+@@ -767,7 +778,6 @@ struct ieee80211_sub_if_data {
+ struct ieee80211_chanctx *reserved_chanctx;
+ struct cfg80211_chan_def reserved_chandef;
+ bool reserved_radar_required;
+- u8 csa_current_counter;
+
+ /* used to reconfigure hardware SM PS */
+ struct work_struct recalc_smps;
+@@ -1850,6 +1860,8 @@ int ieee80211_tdls_oper(struct wiphy *wi
+ const u8 *peer, enum nl80211_tdls_operation oper);
+
+
++extern const struct ethtool_ops ieee80211_ethtool_ops;
++
+ #ifdef CPTCFG_MAC80211_NOINLINE
+ #define debug_noinline noinline
+ #else
+--- a/net/mac80211/iface.c
++++ b/net/mac80211/iface.c
+@@ -399,6 +399,7 @@ int ieee80211_add_virtual_monitor(struct
+ sdata->vif.type = NL80211_IFTYPE_MONITOR;
+ snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
+ wiphy_name(local->hw.wiphy));
++ sdata->wdev.iftype = NL80211_IFTYPE_MONITOR;
+
+ sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
+
+@@ -1303,6 +1304,7 @@ static void ieee80211_setup_sdata(struct
+ sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
+ sdata->control_port_no_encrypt = false;
+ sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
++ sdata->vif.bss_conf.idle = true;
+
+ sdata->noack_map = 0;
+
+@@ -1721,6 +1723,8 @@ int ieee80211_if_add(struct ieee80211_lo
+
+ ndev->features |= local->hw.netdev_features;
+
++ netdev_set_default_ethtool_ops(ndev, &ieee80211_ethtool_ops);
++
+ ret = register_netdevice(ndev);
+ if (ret) {
+ free_netdev(ndev);
+--- a/net/wireless/core.c
++++ b/net/wireless/core.c
+@@ -25,7 +25,6 @@
+ #include "sysfs.h"
+ #include "debugfs.h"
+ #include "wext-compat.h"
+-#include "ethtool.h"
+ #include "rdev-ops.h"
+
+ /* name for sysfs, %d is appended */
+@@ -940,8 +939,6 @@ static int cfg80211_netdev_notifier_call
+ /* allow mac80211 to determine the timeout */
+ wdev->ps_timeout = -1;
+
+- netdev_set_default_ethtool_ops(dev, &cfg80211_ethtool_ops);
+-
+ if ((wdev->iftype == NL80211_IFTYPE_STATION ||
+ wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
+ wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
+--- a/net/wireless/ethtool.c
++++ b/net/wireless/ethtool.c
+@@ -1,11 +1,9 @@
+ #include <linux/utsname.h>
+ #include <net/cfg80211.h>
+ #include "core.h"
+-#include "ethtool.h"
+ #include "rdev-ops.h"
+
+-static void cfg80211_get_drvinfo(struct net_device *dev,
+- struct ethtool_drvinfo *info)
++void cfg80211_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
+ {
+ struct wireless_dev *wdev = dev->ieee80211_ptr;
+
+@@ -23,84 +21,4 @@ static void cfg80211_get_drvinfo(struct
+ strlcpy(info->bus_info, dev_name(wiphy_dev(wdev->wiphy)),
+ sizeof(info->bus_info));
+ }
+-
+-static int cfg80211_get_regs_len(struct net_device *dev)
+-{
+- /* For now, return 0... */
+- return 0;
+-}
+-
+-static void cfg80211_get_regs(struct net_device *dev, struct ethtool_regs *regs,
+- void *data)
+-{
+- struct wireless_dev *wdev = dev->ieee80211_ptr;
+-
+- regs->version = wdev->wiphy->hw_version;
+- regs->len = 0;
+-}
+-
+-static void cfg80211_get_ringparam(struct net_device *dev,
+- struct ethtool_ringparam *rp)
+-{
+- struct wireless_dev *wdev = dev->ieee80211_ptr;
+- struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
+-
+- memset(rp, 0, sizeof(*rp));
+-
+- if (rdev->ops->get_ringparam)
+- rdev_get_ringparam(rdev, &rp->tx_pending, &rp->tx_max_pending,
+- &rp->rx_pending, &rp->rx_max_pending);
+-}
+-
+-static int cfg80211_set_ringparam(struct net_device *dev,
+- struct ethtool_ringparam *rp)
+-{
+- struct wireless_dev *wdev = dev->ieee80211_ptr;
+- struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
+-
+- if (rp->rx_mini_pending != 0 || rp->rx_jumbo_pending != 0)
+- return -EINVAL;
+-
+- if (rdev->ops->set_ringparam)
+- return rdev_set_ringparam(rdev, rp->tx_pending, rp->rx_pending);
+-
+- return -ENOTSUPP;
+-}
+-
+-static int cfg80211_get_sset_count(struct net_device *dev, int sset)
+-{
+- struct wireless_dev *wdev = dev->ieee80211_ptr;
+- struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
+- if (rdev->ops->get_et_sset_count)
+- return rdev_get_et_sset_count(rdev, dev, sset);
+- return -EOPNOTSUPP;
+-}
+-
+-static void cfg80211_get_stats(struct net_device *dev,
+- struct ethtool_stats *stats, u64 *data)
+-{
+- struct wireless_dev *wdev = dev->ieee80211_ptr;
+- struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
+- if (rdev->ops->get_et_stats)
+- rdev_get_et_stats(rdev, dev, stats, data);
+-}
+-
+-static void cfg80211_get_strings(struct net_device *dev, u32 sset, u8 *data)
+-{
+- struct wireless_dev *wdev = dev->ieee80211_ptr;
+- struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
+- if (rdev->ops->get_et_strings)
+- rdev_get_et_strings(rdev, dev, sset, data);
+-}
+-
+-const struct ethtool_ops cfg80211_ethtool_ops = {
+- .get_drvinfo = cfg80211_get_drvinfo,
+- .get_regs_len = cfg80211_get_regs_len,
+- .get_regs = cfg80211_get_regs,
+- .get_link = ethtool_op_get_link,
+- .get_ringparam = cfg80211_get_ringparam,
+- .set_ringparam = cfg80211_set_ringparam,
+- .get_strings = cfg80211_get_strings,
+- .get_ethtool_stats = cfg80211_get_stats,
+- .get_sset_count = cfg80211_get_sset_count,
+-};
++EXPORT_SYMBOL(cfg80211_get_drvinfo);
+--- a/net/wireless/ethtool.h
++++ /dev/null
+@@ -1,6 +0,0 @@
+-#ifndef __CFG80211_ETHTOOL__
+-#define __CFG80211_ETHTOOL__
+-
+-extern const struct ethtool_ops cfg80211_ethtool_ops;
+-
+-#endif /* __CFG80211_ETHTOOL__ */
+--- a/net/wireless/rdev-ops.h
++++ b/net/wireless/rdev-ops.h
+@@ -714,25 +714,6 @@ static inline int rdev_get_antenna(struc
+ return ret;
+ }
+
+-static inline int rdev_set_ringparam(struct cfg80211_registered_device *rdev,
+- u32 tx, u32 rx)
+-{
+- int ret;
+- trace_rdev_set_ringparam(&rdev->wiphy, tx, rx);
+- ret = rdev->ops->set_ringparam(&rdev->wiphy, tx, rx);
+- trace_rdev_return_int(&rdev->wiphy, ret);
+- return ret;
+-}
+-
+-static inline void rdev_get_ringparam(struct cfg80211_registered_device *rdev,
+- u32 *tx, u32 *tx_max, u32 *rx,
+- u32 *rx_max)
+-{
+- trace_rdev_get_ringparam(&rdev->wiphy);
+- rdev->ops->get_ringparam(&rdev->wiphy, tx, tx_max, rx, rx_max);
+- trace_rdev_return_void_tx_rx(&rdev->wiphy, *tx, *tx_max, *rx, *rx_max);
+-}
+-
+ static inline int
+ rdev_sched_scan_start(struct cfg80211_registered_device *rdev,
+ struct net_device *dev,
+@@ -816,35 +797,6 @@ static inline int rdev_set_noack_map(str
+ }
+
+ static inline int
+-rdev_get_et_sset_count(struct cfg80211_registered_device *rdev,
+- struct net_device *dev, int sset)
+-{
+- int ret;
+- trace_rdev_get_et_sset_count(&rdev->wiphy, dev, sset);
+- ret = rdev->ops->get_et_sset_count(&rdev->wiphy, dev, sset);
+- trace_rdev_return_int(&rdev->wiphy, ret);
+- return ret;
+-}
+-
+-static inline void rdev_get_et_stats(struct cfg80211_registered_device *rdev,
+- struct net_device *dev,
+- struct ethtool_stats *stats, u64 *data)
+-{
+- trace_rdev_get_et_stats(&rdev->wiphy, dev);
+- rdev->ops->get_et_stats(&rdev->wiphy, dev, stats, data);
+- trace_rdev_return_void(&rdev->wiphy);
+-}
+-
+-static inline void rdev_get_et_strings(struct cfg80211_registered_device *rdev,
+- struct net_device *dev, u32 sset,
+- u8 *data)
+-{
+- trace_rdev_get_et_strings(&rdev->wiphy, dev, sset);
+- rdev->ops->get_et_strings(&rdev->wiphy, dev, sset, data);
+- trace_rdev_return_void(&rdev->wiphy);
+-}
+-
+-static inline int
+ rdev_get_channel(struct cfg80211_registered_device *rdev,
+ struct wireless_dev *wdev,
+ struct cfg80211_chan_def *chandef)
+--- a/net/wireless/trace.h
++++ b/net/wireless/trace.h
+@@ -298,11 +298,6 @@ DEFINE_EVENT(wiphy_only_evt, rdev_return
+ TP_ARGS(wiphy)
+ );
+
+-DEFINE_EVENT(wiphy_only_evt, rdev_get_ringparam,
+- TP_PROTO(struct wiphy *wiphy),
+- TP_ARGS(wiphy)
+-);
+-
+ DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna,
+ TP_PROTO(struct wiphy *wiphy),
+ TP_ARGS(wiphy)
+@@ -580,11 +575,6 @@ DEFINE_EVENT(wiphy_netdev_evt, rdev_stop
+ TP_ARGS(wiphy, netdev)
+ );
+
+-DEFINE_EVENT(wiphy_netdev_evt, rdev_get_et_stats,
+- TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
+- TP_ARGS(wiphy, netdev)
+-);
+-
+ DEFINE_EVENT(wiphy_netdev_evt, rdev_sched_scan_stop,
+ TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
+ TP_ARGS(wiphy, netdev)
+@@ -1439,11 +1429,6 @@ DECLARE_EVENT_CLASS(tx_rx_evt,
+ WIPHY_PR_ARG, __entry->tx, __entry->rx)
+ );
+
+-DEFINE_EVENT(tx_rx_evt, rdev_set_ringparam,
+- TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
+- TP_ARGS(wiphy, rx, tx)
+-);
+-
+ DEFINE_EVENT(tx_rx_evt, rdev_set_antenna,
+ TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
+ TP_ARGS(wiphy, rx, tx)
+@@ -1725,40 +1710,6 @@ TRACE_EVENT(rdev_set_noack_map,
+ WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map)
+ );
+
+-TRACE_EVENT(rdev_get_et_sset_count,
+- TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int sset),
+- TP_ARGS(wiphy, netdev, sset),
+- TP_STRUCT__entry(
+- WIPHY_ENTRY
+- NETDEV_ENTRY
+- __field(int, sset)
+- ),
+- TP_fast_assign(
+- WIPHY_ASSIGN;
+- NETDEV_ASSIGN;
+- __entry->sset = sset;
+- ),
+- TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", sset: %d",
+- WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sset)
+-);
+-
+-TRACE_EVENT(rdev_get_et_strings,
+- TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 sset),
+- TP_ARGS(wiphy, netdev, sset),
+- TP_STRUCT__entry(
+- WIPHY_ENTRY
+- NETDEV_ENTRY
+- __field(u32, sset)
+- ),
+- TP_fast_assign(
+- WIPHY_ASSIGN;
+- NETDEV_ASSIGN;
+- __entry->sset = sset;
+- ),
+- TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", sset: %u",
+- WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sset)
+-);
+-
+ DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel,
+ TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
+ TP_ARGS(wiphy, wdev)
+--- /dev/null
++++ b/net/mac80211/ethtool.c
+@@ -0,0 +1,244 @@
++/*
++ * mac80211 ethtool hooks for cfg80211
++ *
++ * Copied from cfg.c - originally
++ * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
++ * Copyright 2014 Intel Corporation (Author: Johannes Berg)
++ *
++ * This file is GPLv2 as found in COPYING.
++ */
++#include <linux/types.h>
++#include <net/cfg80211.h>
++#include "ieee80211_i.h"
++#include "sta_info.h"
++#include "driver-ops.h"
++
++static int ieee80211_set_ringparam(struct net_device *dev,
++ struct ethtool_ringparam *rp)
++{
++ struct ieee80211_local *local = wiphy_priv(dev->ieee80211_ptr->wiphy);
++
++ if (rp->rx_mini_pending != 0 || rp->rx_jumbo_pending != 0)
++ return -EINVAL;
++
++ return drv_set_ringparam(local, rp->tx_pending, rp->rx_pending);
++}
++
++static void ieee80211_get_ringparam(struct net_device *dev,
++ struct ethtool_ringparam *rp)
++{
++ struct ieee80211_local *local = wiphy_priv(dev->ieee80211_ptr->wiphy);
++
++ memset(rp, 0, sizeof(*rp));
++
++ drv_get_ringparam(local, &rp->tx_pending, &rp->tx_max_pending,
++ &rp->rx_pending, &rp->rx_max_pending);
++}
++
++static const char ieee80211_gstrings_sta_stats[][ETH_GSTRING_LEN] = {
++ "rx_packets", "rx_bytes",
++ "rx_duplicates", "rx_fragments", "rx_dropped",
++ "tx_packets", "tx_bytes", "tx_fragments",
++ "tx_filtered", "tx_retry_failed", "tx_retries",
++ "beacon_loss", "sta_state", "txrate", "rxrate", "signal",
++ "channel", "noise", "ch_time", "ch_time_busy",
++ "ch_time_ext_busy", "ch_time_rx", "ch_time_tx"
++};
++#define STA_STATS_LEN ARRAY_SIZE(ieee80211_gstrings_sta_stats)
++
++static int ieee80211_get_sset_count(struct net_device *dev, int sset)
++{
++ struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
++ int rv = 0;
++
++ if (sset == ETH_SS_STATS)
++ rv += STA_STATS_LEN;
++
++ rv += drv_get_et_sset_count(sdata, sset);
++
++ if (rv == 0)
++ return -EOPNOTSUPP;
++ return rv;
++}
++
++static void ieee80211_get_stats(struct net_device *dev,
++ struct ethtool_stats *stats,
++ u64 *data)
++{
++ struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
++ struct ieee80211_chanctx_conf *chanctx_conf;
++ struct ieee80211_channel *channel;
++ struct sta_info *sta;
++ struct ieee80211_local *local = sdata->local;
++ struct station_info sinfo;
++ struct survey_info survey;
++ int i, q;
++#define STA_STATS_SURVEY_LEN 7
++
++ memset(data, 0, sizeof(u64) * STA_STATS_LEN);
++
++#define ADD_STA_STATS(sta) \
++ do { \
++ data[i++] += sta->rx_packets; \
++ data[i++] += sta->rx_bytes; \
++ data[i++] += sta->num_duplicates; \
++ data[i++] += sta->rx_fragments; \
++ data[i++] += sta->rx_dropped; \
++ \
++ data[i++] += sinfo.tx_packets; \
++ data[i++] += sinfo.tx_bytes; \
++ data[i++] += sta->tx_fragments; \
++ data[i++] += sta->tx_filtered_count; \
++ data[i++] += sta->tx_retry_failed; \
++ data[i++] += sta->tx_retry_count; \
++ data[i++] += sta->beacon_loss_count; \
++ } while (0)
++
++ /* For Managed stations, find the single station based on BSSID
++ * and use that. For interface types, iterate through all available
++ * stations and add stats for any station that is assigned to this
++ * network device.
++ */
++
++ mutex_lock(&local->sta_mtx);
++
++ if (sdata->vif.type == NL80211_IFTYPE_STATION) {
++ sta = sta_info_get_bss(sdata, sdata->u.mgd.bssid);
++
++ if (!(sta && !WARN_ON(sta->sdata->dev != dev)))
++ goto do_survey;
++
++ sinfo.filled = 0;
++ sta_set_sinfo(sta, &sinfo);
++
++ i = 0;
++ ADD_STA_STATS(sta);
++
++ data[i++] = sta->sta_state;
++
++
++ if (sinfo.filled & STATION_INFO_TX_BITRATE)
++ data[i] = 100000 *
++ cfg80211_calculate_bitrate(&sinfo.txrate);
++ i++;
++ if (sinfo.filled & STATION_INFO_RX_BITRATE)
++ data[i] = 100000 *
++ cfg80211_calculate_bitrate(&sinfo.rxrate);
++ i++;
++
++ if (sinfo.filled & STATION_INFO_SIGNAL_AVG)
++ data[i] = (u8)sinfo.signal_avg;
++ i++;
++ } else {
++ list_for_each_entry(sta, &local->sta_list, list) {
++ /* Make sure this station belongs to the proper dev */
++ if (sta->sdata->dev != dev)
++ continue;
++
++ sinfo.filled = 0;
++ sta_set_sinfo(sta, &sinfo);
++ i = 0;
++ ADD_STA_STATS(sta);
++ }
++ }
++
++do_survey:
++ i = STA_STATS_LEN - STA_STATS_SURVEY_LEN;
++ /* Get survey stats for current channel */
++ survey.filled = 0;
++
++ rcu_read_lock();
++ chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
++ if (chanctx_conf)
++ channel = chanctx_conf->def.chan;
++ else
++ channel = NULL;
++ rcu_read_unlock();
++
++ if (channel) {
++ q = 0;
++ do {
++ survey.filled = 0;
++ if (drv_get_survey(local, q, &survey) != 0) {
++ survey.filled = 0;
++ break;
++ }
++ q++;
++ } while (channel != survey.channel);
++ }
++
++ if (survey.filled)
++ data[i++] = survey.channel->center_freq;
++ else
++ data[i++] = 0;
++ if (survey.filled & SURVEY_INFO_NOISE_DBM)
++ data[i++] = (u8)survey.noise;
++ else
++ data[i++] = -1LL;
++ if (survey.filled & SURVEY_INFO_CHANNEL_TIME)
++ data[i++] = survey.channel_time;
++ else
++ data[i++] = -1LL;
++ if (survey.filled & SURVEY_INFO_CHANNEL_TIME_BUSY)
++ data[i++] = survey.channel_time_busy;
++ else
++ data[i++] = -1LL;
++ if (survey.filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY)
++ data[i++] = survey.channel_time_ext_busy;
++ else
++ data[i++] = -1LL;
++ if (survey.filled & SURVEY_INFO_CHANNEL_TIME_RX)
++ data[i++] = survey.channel_time_rx;
++ else
++ data[i++] = -1LL;
++ if (survey.filled & SURVEY_INFO_CHANNEL_TIME_TX)
++ data[i++] = survey.channel_time_tx;
++ else
++ data[i++] = -1LL;
++
++ mutex_unlock(&local->sta_mtx);
++
++ if (WARN_ON(i != STA_STATS_LEN))
++ return;
++
++ drv_get_et_stats(sdata, stats, &(data[STA_STATS_LEN]));
++}
++
++static void ieee80211_get_strings(struct net_device *dev, u32 sset, u8 *data)
++{
++ struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
++ int sz_sta_stats = 0;
++
++ if (sset == ETH_SS_STATS) {
++ sz_sta_stats = sizeof(ieee80211_gstrings_sta_stats);
++ memcpy(data, ieee80211_gstrings_sta_stats, sz_sta_stats);
++ }
++ drv_get_et_strings(sdata, sset, &(data[sz_sta_stats]));
++}
++
++static int ieee80211_get_regs_len(struct net_device *dev)
++{
++ return 0;
++}
++
++static void ieee80211_get_regs(struct net_device *dev,
++ struct ethtool_regs *regs,
++ void *data)
++{
++ struct wireless_dev *wdev = dev->ieee80211_ptr;
++
++ regs->version = wdev->wiphy->hw_version;
++ regs->len = 0;
++}
++
++const struct ethtool_ops ieee80211_ethtool_ops = {
++ .get_drvinfo = cfg80211_get_drvinfo,
++ .get_regs_len = ieee80211_get_regs_len,
++ .get_regs = ieee80211_get_regs,
++ .get_link = ethtool_op_get_link,
++ .get_ringparam = ieee80211_get_ringparam,
++ .set_ringparam = ieee80211_set_ringparam,
++ .get_strings = ieee80211_get_strings,
++ .get_ethtool_stats = ieee80211_get_stats,
++ .get_sset_count = ieee80211_get_sset_count,
++};
+--- a/net/mac80211/ibss.c
++++ b/net/mac80211/ibss.c
+@@ -143,7 +143,7 @@ ieee80211_ibss_build_presp(struct ieee80
+ *pos++ = csa_settings->block_tx ? 1 : 0;
+ *pos++ = ieee80211_frequency_to_channel(
+ csa_settings->chandef.chan->center_freq);
+- sdata->csa_counter_offset_beacon[0] = (pos - presp->head);
++ presp->csa_counter_offsets[0] = (pos - presp->head);
+ *pos++ = csa_settings->count;
+ }
+
+@@ -1677,6 +1677,7 @@ int ieee80211_ibss_join(struct ieee80211
+ sdata->u.ibss.control_port = params->control_port;
+ sdata->u.ibss.userspace_handles_dfs = params->userspace_handles_dfs;
+ sdata->u.ibss.basic_rates = params->basic_rates;
++ sdata->u.ibss.last_scan_completed = jiffies;
+
+ /* fix basic_rates if channel does not support these rates */
+ rate_flags = ieee80211_chandef_rate_flags(¶ms->chandef);
+--- a/net/mac80211/mesh.c
++++ b/net/mac80211/mesh.c
+@@ -679,7 +679,7 @@ ieee80211_mesh_build_beacon(struct ieee8
+ *pos++ = 0x0;
+ *pos++ = ieee80211_frequency_to_channel(
+ csa->settings.chandef.chan->center_freq);
+- sdata->csa_counter_offset_beacon[0] = hdr_len + 6;
++ bcn->csa_counter_offsets[0] = hdr_len + 6;
+ *pos++ = csa->settings.count;
+ *pos++ = WLAN_EID_CHAN_SWITCH_PARAM;
+ *pos++ = 6;
+--- a/net/wireless/genregdb.awk
++++ b/net/wireless/genregdb.awk
+@@ -65,17 +65,7 @@ function parse_reg_rule()
+ sub(/,/, "", units)
+ dfs_cac = $9
+ if (units == "mW") {
+- if (power == 100) {
+- power = 20
+- } else if (power == 200) {
+- power = 23
+- } else if (power == 500) {
+- power = 27
+- } else if (power == 1000) {
+- power = 30
+- } else {
+- print "Unknown power value in database!"
+- }
++ power = 10 * log(power)/log(10)
+ } else {
+ dfs_cac = $8
+ }
+@@ -114,7 +104,7 @@ function parse_reg_rule()
+
+ }
+ flags = flags "0"
+- printf "\t\tREG_RULE_EXT(%d, %d, %d, %d, %d, %d, %s),\n", start, end, bw, gain, power, dfs_cac, flags
++ printf "\t\tREG_RULE_EXT(%d, %d, %d, %d, %.0f, %d, %s),\n", start, end, bw, gain, power, dfs_cac, flags
+ rules++
+ }
+
+--- a/net/mac80211/debugfs_netdev.c
++++ b/net/mac80211/debugfs_netdev.c
+@@ -34,8 +34,7 @@ static ssize_t ieee80211_if_read(
+ ssize_t ret = -EINVAL;
+
+ read_lock(&dev_base_lock);
+- if (sdata->dev->reg_state == NETREG_REGISTERED)
+- ret = (*format)(sdata, buf, sizeof(buf));
++ ret = (*format)(sdata, buf, sizeof(buf));
+ read_unlock(&dev_base_lock);
+
+ if (ret >= 0)
+@@ -62,8 +61,7 @@ static ssize_t ieee80211_if_write(
+
+ ret = -ENODEV;
+ rtnl_lock();
+- if (sdata->dev->reg_state == NETREG_REGISTERED)
+- ret = (*write)(sdata, buf, count);
++ ret = (*write)(sdata, buf, count);
+ rtnl_unlock();
+
+ return ret;
+--- a/drivers/net/wireless/b43/xmit.c
++++ b/drivers/net/wireless/b43/xmit.c
+@@ -811,9 +811,13 @@ void b43_rx(struct b43_wldev *dev, struc
+ break;
+ case B43_PHYTYPE_G:
+ status.band = IEEE80211_BAND_2GHZ;
+- /* chanid is the radio channel cookie value as used
+- * to tune the radio. */
+- status.freq = chanid + 2400;
++ /* Somewhere between 478.104 and 508.1084 firmware for G-PHY
++ * has been modified to be compatible with N-PHY and others.
++ */
++ if (dev->fw.rev >= 508)
++ status.freq = ieee80211_channel_to_frequency(chanid, status.band);
++ else
++ status.freq = chanid + 2400;
+ break;
+ case B43_PHYTYPE_N:
+ case B43_PHYTYPE_LP:
+--- a/drivers/net/wireless/b43/main.c
++++ b/drivers/net/wireless/b43/main.c
+@@ -5216,6 +5216,7 @@ static int b43_wireless_core_attach(stru
+ /* We don't support 5 GHz on some PHYs yet */
+ switch (dev->phy.type) {
+ case B43_PHYTYPE_A:
++ case B43_PHYTYPE_G:
+ case B43_PHYTYPE_N:
+ case B43_PHYTYPE_LP:
+ case B43_PHYTYPE_HT:
+--- a/net/wireless/reg.c
++++ b/net/wireless/reg.c
+@@ -935,7 +935,7 @@ freq_reg_info_regd(struct wiphy *wiphy,
+ if (!band_rule_found)
+ band_rule_found = freq_in_rule_band(fr, center_freq);
+
+- bw_fits = reg_does_bw_fit(fr, center_freq, MHZ_TO_KHZ(5));
++ bw_fits = reg_does_bw_fit(fr, center_freq, MHZ_TO_KHZ(20));
+
+ if (band_rule_found && bw_fits)
+ return rr;
+@@ -1019,10 +1019,10 @@ static void chan_reg_rule_print_dbg(cons
+ }
+ #endif
+
+-/* Find an ieee80211_reg_rule such that a 5MHz channel with frequency
+- * chan->center_freq fits there.
+- * If there is no such reg_rule, disable the channel, otherwise set the
+- * flags corresponding to the bandwidths allowed in the particular reg_rule
++/*
++ * Note that right now we assume the desired channel bandwidth
++ * is always 20 MHz for each individual channel (HT40 uses 20 MHz
++ * per channel, the primary and the extension channel).
+ */
+ static void handle_channel(struct wiphy *wiphy,
+ enum nl80211_reg_initiator initiator,
+@@ -1083,12 +1083,8 @@ static void handle_channel(struct wiphy
+ if (reg_rule->flags & NL80211_RRF_AUTO_BW)
+ max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule);
+
+- if (max_bandwidth_khz < MHZ_TO_KHZ(10))
+- bw_flags = IEEE80211_CHAN_NO_10MHZ;
+- if (max_bandwidth_khz < MHZ_TO_KHZ(20))
+- bw_flags |= IEEE80211_CHAN_NO_20MHZ;
+ if (max_bandwidth_khz < MHZ_TO_KHZ(40))
+- bw_flags |= IEEE80211_CHAN_NO_HT40;
++ bw_flags = IEEE80211_CHAN_NO_HT40;
+ if (max_bandwidth_khz < MHZ_TO_KHZ(80))
+ bw_flags |= IEEE80211_CHAN_NO_80MHZ;
+ if (max_bandwidth_khz < MHZ_TO_KHZ(160))
+@@ -1522,12 +1518,8 @@ static void handle_channel_custom(struct
+ if (reg_rule->flags & NL80211_RRF_AUTO_BW)
+ max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule);
+
+- if (max_bandwidth_khz < MHZ_TO_KHZ(10))
+- bw_flags = IEEE80211_CHAN_NO_10MHZ;
+- if (max_bandwidth_khz < MHZ_TO_KHZ(20))
+- bw_flags |= IEEE80211_CHAN_NO_20MHZ;
+ if (max_bandwidth_khz < MHZ_TO_KHZ(40))
+- bw_flags |= IEEE80211_CHAN_NO_HT40;
++ bw_flags = IEEE80211_CHAN_NO_HT40;
+ if (max_bandwidth_khz < MHZ_TO_KHZ(80))
+ bw_flags |= IEEE80211_CHAN_NO_80MHZ;
+ if (max_bandwidth_khz < MHZ_TO_KHZ(160))
+--- a/drivers/net/wireless/ath/ath9k/ath9k.h
++++ b/drivers/net/wireless/ath/ath9k/ath9k.h
+@@ -185,7 +185,8 @@ struct ath_atx_ac {
+
+ struct ath_frame_info {
+ struct ath_buf *bf;
+- int framelen;
++ u16 framelen;
++ s8 txq;
+ enum ath9k_key_type keytype;
+ u8 keyix;
+ u8 rtscts_rate;
+--- a/drivers/net/wireless/ath/ath9k/xmit.c
++++ b/drivers/net/wireless/ath/ath9k/xmit.c
+@@ -147,15 +147,13 @@ static void ath_set_rates(struct ieee802
+ static void ath_txq_skb_done(struct ath_softc *sc, struct ath_txq *txq,
+ struct sk_buff *skb)
+ {
+- int q;
+-
+- q = skb_get_queue_mapping(skb);
+- if (txq == sc->tx.uapsdq)
+- txq = sc->tx.txq_map[q];
++ struct ath_frame_info *fi = get_frame_info(skb);
++ int q = fi->txq;
+
+- if (txq != sc->tx.txq_map[q])
++ if (q < 0)
+ return;
+
++ txq = sc->tx.txq_map[q];
+ if (WARN_ON(--txq->pending_frames < 0))
+ txq->pending_frames = 0;
+
+@@ -887,6 +885,15 @@ ath_tx_get_tid_subframe(struct ath_softc
+
+ tx_info = IEEE80211_SKB_CB(skb);
+ tx_info->flags &= ~IEEE80211_TX_CTL_CLEAR_PS_FILT;
++
++ /*
++ * No aggregation session is running, but there may be frames
++ * from a previous session or a failed attempt in the queue.
++ * Send them out as normal data frames
++ */
++ if (!tid->active)
++ tx_info->flags &= ~IEEE80211_TX_CTL_AMPDU;
++
+ if (!(tx_info->flags & IEEE80211_TX_CTL_AMPDU)) {
+ bf->bf_state.bf_type = 0;
+ return bf;
+@@ -1999,6 +2006,7 @@ static void setup_frame_info(struct ieee
+ an = (struct ath_node *) sta->drv_priv;
+
+ memset(fi, 0, sizeof(*fi));
++ fi->txq = -1;
+ if (hw_key)
+ fi->keyix = hw_key->hw_key_idx;
+ else if (an && ieee80211_is_data(hdr->frame_control) && an->ps_key > 0)
+@@ -2150,6 +2158,7 @@ int ath_tx_start(struct ieee80211_hw *hw
+ struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ struct ieee80211_sta *sta = txctl->sta;
+ struct ieee80211_vif *vif = info->control.vif;
++ struct ath_frame_info *fi = get_frame_info(skb);
+ struct ath_softc *sc = hw->priv;
+ struct ath_txq *txq = txctl->txq;
+ struct ath_atx_tid *tid = NULL;
+@@ -2170,11 +2179,13 @@ int ath_tx_start(struct ieee80211_hw *hw
+ q = skb_get_queue_mapping(skb);
+
+ ath_txq_lock(sc, txq);
+- if (txq == sc->tx.txq_map[q] &&
+- ++txq->pending_frames > sc->tx.txq_max_pending[q] &&
+- !txq->stopped) {
+- ieee80211_stop_queue(sc->hw, q);
+- txq->stopped = true;
++ if (txq == sc->tx.txq_map[q]) {
++ fi->txq = q;
++ if (++txq->pending_frames > sc->tx.txq_max_pending[q] &&
++ !txq->stopped) {
++ ieee80211_stop_queue(sc->hw, q);
++ txq->stopped = true;
++ }
+ }
+
+ if (txctl->an && ieee80211_is_data_present(hdr->frame_control))
+--- a/net/mac80211/chan.c
++++ b/net/mac80211/chan.c
+@@ -521,6 +521,8 @@ static void ieee80211_recalc_chanctx_cha
+ continue;
+ if (rcu_access_pointer(sdata->vif.chanctx_conf) != conf)
+ continue;
++ if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
++ continue;
+
+ if (!compat)
+ compat = &sdata->vif.bss_conf.chandef;
+--- a/drivers/net/wireless/ath/ath9k/ar5008_phy.c
++++ b/drivers/net/wireless/ath/ath9k/ar5008_phy.c
+@@ -1004,9 +1004,11 @@ static bool ar5008_hw_ani_control_new(st
+ case ATH9K_ANI_FIRSTEP_LEVEL:{
+ u32 level = param;
+
+- value = level;
++ value = level * 2;
+ REG_RMW_FIELD(ah, AR_PHY_FIND_SIG,
+ AR_PHY_FIND_SIG_FIRSTEP, value);
++ REG_RMW_FIELD(ah, AR_PHY_FIND_SIG_LOW,
++ AR_PHY_FIND_SIG_FIRSTEP_LOW, value);
+
+ if (level != aniState->firstepLevel) {
+ ath_dbg(common, ANI,
+@@ -1040,9 +1042,8 @@ static bool ar5008_hw_ani_control_new(st
+ REG_RMW_FIELD(ah, AR_PHY_TIMING5,
+ AR_PHY_TIMING5_CYCPWR_THR1, value);
+
+- if (IS_CHAN_HT40(ah->curchan))
+- REG_RMW_FIELD(ah, AR_PHY_EXT_CCA,
+- AR_PHY_EXT_TIMING5_CYCPWR_THR1, value);
++ REG_RMW_FIELD(ah, AR_PHY_EXT_CCA,
++ AR_PHY_EXT_TIMING5_CYCPWR_THR1, value - 1);
+
+ if (level != aniState->spurImmunityLevel) {
+ ath_dbg(common, ANI,
+--- a/drivers/net/wireless/ath/ath9k/ar9003_phy.c
++++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.c
+@@ -517,6 +517,23 @@ static void ar9003_hw_spur_mitigate(stru
+ ar9003_hw_spur_mitigate_ofdm(ah, chan);
+ }
+
++static u32 ar9003_hw_compute_pll_control_soc(struct ath_hw *ah,
++ struct ath9k_channel *chan)
++{
++ u32 pll;
++
++ pll = SM(0x5, AR_RTC_9300_SOC_PLL_REFDIV);
++
++ if (chan && IS_CHAN_HALF_RATE(chan))
++ pll |= SM(0x1, AR_RTC_9300_SOC_PLL_CLKSEL);
++ else if (chan && IS_CHAN_QUARTER_RATE(chan))
++ pll |= SM(0x2, AR_RTC_9300_SOC_PLL_CLKSEL);
++
++ pll |= SM(0x2c, AR_RTC_9300_SOC_PLL_DIV_INT);
++
++ return pll;
++}
++
+ static u32 ar9003_hw_compute_pll_control(struct ath_hw *ah,
+ struct ath9k_channel *chan)
+ {
+@@ -1779,7 +1796,12 @@ void ar9003_hw_attach_phy_ops(struct ath
+
+ priv_ops->rf_set_freq = ar9003_hw_set_channel;
+ priv_ops->spur_mitigate_freq = ar9003_hw_spur_mitigate;
+- priv_ops->compute_pll_control = ar9003_hw_compute_pll_control;
++
++ if (AR_SREV_9340(ah) || AR_SREV_9550(ah) || AR_SREV_9531(ah))
++ priv_ops->compute_pll_control = ar9003_hw_compute_pll_control_soc;
++ else
++ priv_ops->compute_pll_control = ar9003_hw_compute_pll_control;
++
+ priv_ops->set_channel_regs = ar9003_hw_set_channel_regs;
+ priv_ops->init_bb = ar9003_hw_init_bb;
+ priv_ops->process_ini = ar9003_hw_process_ini;
+--- a/drivers/net/wireless/ath/ath9k/hw.c
++++ b/drivers/net/wireless/ath/ath9k/hw.c
+@@ -702,6 +702,8 @@ static void ath9k_hw_init_pll(struct ath
+ {
+ u32 pll;
+
++ pll = ath9k_hw_compute_pll_control(ah, chan);
++
+ if (AR_SREV_9485(ah) || AR_SREV_9565(ah)) {
+ /* program BB PLL ki and kd value, ki=0x4, kd=0x40 */
+ REG_RMW_FIELD(ah, AR_CH0_BB_DPLL2,
+@@ -752,7 +754,8 @@ static void ath9k_hw_init_pll(struct ath
+ REG_RMW_FIELD(ah, AR_CH0_DDR_DPLL3,
+ AR_CH0_DPLL3_PHASE_SHIFT, 0x1);
+
+- REG_WRITE(ah, AR_RTC_PLL_CONTROL, 0x1142c);
++ REG_WRITE(ah, AR_RTC_PLL_CONTROL,
++ pll | AR_RTC_9300_PLL_BYPASS);
+ udelay(1000);
+
+ /* program refdiv, nint, frac to RTC register */
+@@ -768,7 +771,8 @@ static void ath9k_hw_init_pll(struct ath
+ } else if (AR_SREV_9340(ah) || AR_SREV_9550(ah) || AR_SREV_9531(ah)) {
+ u32 regval, pll2_divint, pll2_divfrac, refdiv;
+
+- REG_WRITE(ah, AR_RTC_PLL_CONTROL, 0x1142c);
++ REG_WRITE(ah, AR_RTC_PLL_CONTROL,
++ pll | AR_RTC_9300_SOC_PLL_BYPASS);
+ udelay(1000);
+
+ REG_SET_BIT(ah, AR_PHY_PLL_MODE, 0x1 << 16);
+@@ -840,7 +844,6 @@ static void ath9k_hw_init_pll(struct ath
+ udelay(1000);
+ }
+
+- pll = ath9k_hw_compute_pll_control(ah, chan);
+ if (AR_SREV_9565(ah))
+ pll |= 0x40000;
+ REG_WRITE(ah, AR_RTC_PLL_CONTROL, pll);
+--- a/drivers/net/wireless/ath/ath9k/reg.h
++++ b/drivers/net/wireless/ath/ath9k/reg.h
+@@ -1236,12 +1236,23 @@ enum {
+ #define AR_CH0_DPLL3_PHASE_SHIFT_S 23
+ #define AR_PHY_CCA_NOM_VAL_2GHZ -118
+
++#define AR_RTC_9300_SOC_PLL_DIV_INT 0x0000003f
++#define AR_RTC_9300_SOC_PLL_DIV_INT_S 0
++#define AR_RTC_9300_SOC_PLL_DIV_FRAC 0x000fffc0
++#define AR_RTC_9300_SOC_PLL_DIV_FRAC_S 6
++#define AR_RTC_9300_SOC_PLL_REFDIV 0x01f00000
++#define AR_RTC_9300_SOC_PLL_REFDIV_S 20
++#define AR_RTC_9300_SOC_PLL_CLKSEL 0x06000000
++#define AR_RTC_9300_SOC_PLL_CLKSEL_S 25
++#define AR_RTC_9300_SOC_PLL_BYPASS 0x08000000
++
+ #define AR_RTC_9300_PLL_DIV 0x000003ff
+ #define AR_RTC_9300_PLL_DIV_S 0
+ #define AR_RTC_9300_PLL_REFDIV 0x00003C00
+ #define AR_RTC_9300_PLL_REFDIV_S 10
+ #define AR_RTC_9300_PLL_CLKSEL 0x0000C000
+ #define AR_RTC_9300_PLL_CLKSEL_S 14
++#define AR_RTC_9300_PLL_BYPASS 0x00010000
+
+ #define AR_RTC_9160_PLL_DIV 0x000003ff
+ #define AR_RTC_9160_PLL_DIV_S 0