Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * |
| 3 | * This file is provided under a dual BSD/GPLv2 license. When using or |
| 4 | * redistributing this file, you may do so under either license. |
| 5 | * |
| 6 | * GPL LICENSE SUMMARY |
| 7 | * |
Emmanuel Grumbach | 51368bf | 2013-12-30 13:15:54 +0200 | [diff] [blame] | 8 | * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. |
Johannes Berg | 777c9b6 | 2015-01-14 17:58:57 +0100 | [diff] [blame] | 9 | * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH |
Goodstein, Mordechay | cfbeb598 | 2016-11-21 10:26:36 +0200 | [diff] [blame] | 10 | * Copyright(c) 2016 - 2017 Intel Deutschland GmbH |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 11 | * |
| 12 | * This program is free software; you can redistribute it and/or modify |
| 13 | * it under the terms of version 2 of the GNU General Public License as |
| 14 | * published by the Free Software Foundation. |
| 15 | * |
| 16 | * This program is distributed in the hope that it will be useful, but |
| 17 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 19 | * General Public License for more details. |
| 20 | * |
| 21 | * You should have received a copy of the GNU General Public License |
| 22 | * along with this program; if not, write to the Free Software |
| 23 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, |
| 24 | * USA |
| 25 | * |
| 26 | * The full GNU General Public License is included in this distribution |
Emmanuel Grumbach | 410dc5a | 2013-02-18 09:22:28 +0200 | [diff] [blame] | 27 | * in the file called COPYING. |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 28 | * |
| 29 | * Contact Information: |
Emmanuel Grumbach | cb2f827 | 2015-11-17 15:39:56 +0200 | [diff] [blame] | 30 | * Intel Linux Wireless <linuxwifi@intel.com> |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 31 | * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 |
| 32 | * |
| 33 | * BSD LICENSE |
| 34 | * |
Emmanuel Grumbach | 51368bf | 2013-12-30 13:15:54 +0200 | [diff] [blame] | 35 | * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. |
Johannes Berg | 777c9b6 | 2015-01-14 17:58:57 +0100 | [diff] [blame] | 36 | * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 37 | * All rights reserved. |
| 38 | * |
| 39 | * Redistribution and use in source and binary forms, with or without |
| 40 | * modification, are permitted provided that the following conditions |
| 41 | * are met: |
| 42 | * |
| 43 | * * Redistributions of source code must retain the above copyright |
| 44 | * notice, this list of conditions and the following disclaimer. |
| 45 | * * Redistributions in binary form must reproduce the above copyright |
| 46 | * notice, this list of conditions and the following disclaimer in |
| 47 | * the documentation and/or other materials provided with the |
| 48 | * distribution. |
| 49 | * * Neither the name Intel Corporation nor the names of its |
| 50 | * contributors may be used to endorse or promote products derived |
| 51 | * from this software without specific prior written permission. |
| 52 | * |
| 53 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 54 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 55 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 56 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 57 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 58 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 59 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 60 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 61 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 62 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 63 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 64 | *****************************************************************************/ |
Johannes Berg | a399f98 | 2015-09-24 18:29:00 +0200 | [diff] [blame] | 65 | #include <linux/etherdevice.h> |
Avri Altman | 93190fb | 2014-12-27 09:09:47 +0200 | [diff] [blame] | 66 | #include <linux/skbuff.h> |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 67 | #include "iwl-trans.h" |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 68 | #include "mvm.h" |
| 69 | #include "fw-api.h" |
| 70 | |
| 71 | /* |
| 72 | * iwl_mvm_rx_rx_phy_cmd - REPLY_RX_PHY_CMD handler |
| 73 | * |
| 74 | * Copies the phy information in mvm->last_phy_info, it will be used when the |
| 75 | * actual data will come from the fw in the next packet. |
| 76 | */ |
Johannes Berg | 0416841 | 2015-06-23 21:22:09 +0200 | [diff] [blame] | 77 | void iwl_mvm_rx_rx_phy_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 78 | { |
| 79 | struct iwl_rx_packet *pkt = rxb_addr(rxb); |
| 80 | |
| 81 | memcpy(&mvm->last_phy_info, pkt->data, sizeof(mvm->last_phy_info)); |
| 82 | mvm->ampdu_ref++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 83 | |
| 84 | #ifdef CONFIG_IWLWIFI_DEBUGFS |
| 85 | if (mvm->last_phy_info.phy_flags & cpu_to_le16(RX_RES_PHY_FLAGS_AGG)) { |
| 86 | spin_lock(&mvm->drv_stats_lock); |
| 87 | mvm->drv_rx_stats.ampdu_count++; |
| 88 | spin_unlock(&mvm->drv_stats_lock); |
| 89 | } |
| 90 | #endif |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 91 | } |
| 92 | |
| 93 | /* |
| 94 | * iwl_mvm_pass_packet_to_mac80211 - builds the packet for mac80211 |
| 95 | * |
| 96 | * Adds the rxb to a new skb and give it to mac80211 |
| 97 | */ |
| 98 | static void iwl_mvm_pass_packet_to_mac80211(struct iwl_mvm *mvm, |
Johannes Berg | 43ec72b | 2016-03-10 11:55:44 +0100 | [diff] [blame] | 99 | struct ieee80211_sta *sta, |
Johannes Berg | 1be5d8c | 2015-06-11 16:51:24 +0200 | [diff] [blame] | 100 | struct napi_struct *napi, |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 101 | struct sk_buff *skb, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 102 | struct ieee80211_hdr *hdr, u16 len, |
Dan Carpenter | bdbc58a | 2016-05-04 09:19:13 +0300 | [diff] [blame] | 103 | u8 crypt_len, |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 104 | struct iwl_rx_cmd_buffer *rxb) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 105 | { |
Johannes Berg | 5cddd05 | 2016-12-14 13:48:04 +0100 | [diff] [blame] | 106 | unsigned int hdrlen = ieee80211_hdrlen(hdr->frame_control); |
| 107 | unsigned int fraglen; |
| 108 | |
| 109 | /* |
| 110 | * The 'hdrlen' (plus the 8 bytes for the SNAP and the crypt_len, |
| 111 | * but those are all multiples of 4 long) all goes away, but we |
| 112 | * want the *end* of it, which is going to be the start of the IP |
| 113 | * header, to be aligned when it gets pulled in. |
| 114 | * The beginning of the skb->data is aligned on at least a 4-byte |
| 115 | * boundary after allocation. Everything here is aligned at least |
| 116 | * on a 2-byte boundary so we can just take hdrlen & 3 and pad by |
| 117 | * the result. |
| 118 | */ |
| 119 | skb_reserve(skb, hdrlen & 3); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 120 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 121 | /* If frame is small enough to fit in skb->head, pull it completely. |
Johannes Berg | 3771a89 | 2014-11-13 11:06:43 +0100 | [diff] [blame] | 122 | * If not, only pull ieee80211_hdr (including crypto if present, and |
| 123 | * an additional 8 bytes for SNAP/ethertype, see below) so that |
| 124 | * splice() or TCP coalesce are more efficient. |
| 125 | * |
| 126 | * Since, in addition, ieee80211_data_to_8023() always pull in at |
| 127 | * least 8 bytes (possibly more for mesh) we can do the same here |
| 128 | * to save the cost of doing it later. That still doesn't pull in |
| 129 | * the actual IP header since the typical case has a SNAP header. |
| 130 | * If the latter changes (there are efforts in the standards group |
| 131 | * to do so) we should revisit this and ieee80211_data_to_8023(). |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 132 | */ |
Johannes Berg | 5cddd05 | 2016-12-14 13:48:04 +0100 | [diff] [blame] | 133 | hdrlen = (len <= skb_tailroom(skb)) ? len : hdrlen + crypt_len + 8; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 134 | |
Johannes Berg | 59ae1d1 | 2017-06-16 14:29:20 +0200 | [diff] [blame] | 135 | skb_put_data(skb, hdr, hdrlen); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 136 | fraglen = len - hdrlen; |
| 137 | |
| 138 | if (fraglen) { |
| 139 | int offset = (void *)hdr + hdrlen - |
| 140 | rxb_addr(rxb) + rxb_offset(rxb); |
| 141 | |
| 142 | skb_add_rx_frag(skb, 0, rxb_steal_page(rxb), offset, |
| 143 | fraglen, rxb->truesize); |
| 144 | } |
| 145 | |
Johannes Berg | 43ec72b | 2016-03-10 11:55:44 +0100 | [diff] [blame] | 146 | ieee80211_rx_napi(mvm->hw, sta, skb, napi); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 147 | } |
| 148 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 149 | /* |
Avri Altman | a2d7b87 | 2013-07-09 01:42:17 +0300 | [diff] [blame] | 150 | * iwl_mvm_get_signal_strength - use new rx PHY INFO API |
Avri Altman | 17dbe56 | 2013-08-01 07:19:27 +0300 | [diff] [blame] | 151 | * values are reported by the fw as positive values - need to negate |
| 152 | * to obtain their dBM. Account for missing antennas by replacing 0 |
| 153 | * values by -256dBm: practically 0 power and a non-feasible 8 bit value. |
Avri Altman | a2d7b87 | 2013-07-09 01:42:17 +0300 | [diff] [blame] | 154 | */ |
Johannes Berg | 226eb8c | 2013-07-03 11:55:17 +0200 | [diff] [blame] | 155 | static void iwl_mvm_get_signal_strength(struct iwl_mvm *mvm, |
| 156 | struct iwl_rx_phy_info *phy_info, |
| 157 | struct ieee80211_rx_status *rx_status) |
Avri Altman | a2d7b87 | 2013-07-09 01:42:17 +0300 | [diff] [blame] | 158 | { |
| 159 | int energy_a, energy_b, energy_c, max_energy; |
| 160 | u32 val; |
| 161 | |
| 162 | val = |
| 163 | le32_to_cpu(phy_info->non_cfg_phy[IWL_RX_INFO_ENERGY_ANT_ABC_IDX]); |
Avri Altman | 17dbe56 | 2013-08-01 07:19:27 +0300 | [diff] [blame] | 164 | energy_a = (val & IWL_RX_INFO_ENERGY_ANT_A_MSK) >> |
| 165 | IWL_RX_INFO_ENERGY_ANT_A_POS; |
Eyal Shapira | 2cddddc | 2014-08-13 00:26:17 +0300 | [diff] [blame] | 166 | energy_a = energy_a ? -energy_a : S8_MIN; |
Avri Altman | 17dbe56 | 2013-08-01 07:19:27 +0300 | [diff] [blame] | 167 | energy_b = (val & IWL_RX_INFO_ENERGY_ANT_B_MSK) >> |
| 168 | IWL_RX_INFO_ENERGY_ANT_B_POS; |
Eyal Shapira | 2cddddc | 2014-08-13 00:26:17 +0300 | [diff] [blame] | 169 | energy_b = energy_b ? -energy_b : S8_MIN; |
Avri Altman | 17dbe56 | 2013-08-01 07:19:27 +0300 | [diff] [blame] | 170 | energy_c = (val & IWL_RX_INFO_ENERGY_ANT_C_MSK) >> |
| 171 | IWL_RX_INFO_ENERGY_ANT_C_POS; |
Eyal Shapira | 2cddddc | 2014-08-13 00:26:17 +0300 | [diff] [blame] | 172 | energy_c = energy_c ? -energy_c : S8_MIN; |
Avri Altman | a2d7b87 | 2013-07-09 01:42:17 +0300 | [diff] [blame] | 173 | max_energy = max(energy_a, energy_b); |
| 174 | max_energy = max(max_energy, energy_c); |
| 175 | |
| 176 | IWL_DEBUG_STATS(mvm, "energy In A %d B %d C %d , and max %d\n", |
| 177 | energy_a, energy_b, energy_c, max_energy); |
| 178 | |
Johannes Berg | 226eb8c | 2013-07-03 11:55:17 +0200 | [diff] [blame] | 179 | rx_status->signal = max_energy; |
| 180 | rx_status->chains = (le16_to_cpu(phy_info->phy_flags) & |
| 181 | RX_RES_PHY_FLAGS_ANTENNA) |
| 182 | >> RX_RES_PHY_FLAGS_ANTENNA_POS; |
| 183 | rx_status->chain_signal[0] = energy_a; |
| 184 | rx_status->chain_signal[1] = energy_b; |
| 185 | rx_status->chain_signal[2] = energy_c; |
Avri Altman | a2d7b87 | 2013-07-09 01:42:17 +0300 | [diff] [blame] | 186 | } |
| 187 | |
| 188 | /* |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 189 | * iwl_mvm_set_mac80211_rx_flag - translate fw status to mac80211 format |
| 190 | * @mvm: the mvm object |
| 191 | * @hdr: 80211 header |
| 192 | * @stats: status in mac80211's format |
| 193 | * @rx_pkt_status: status coming from fw |
| 194 | * |
| 195 | * returns non 0 value if the packet should be dropped |
| 196 | */ |
| 197 | static u32 iwl_mvm_set_mac80211_rx_flag(struct iwl_mvm *mvm, |
| 198 | struct ieee80211_hdr *hdr, |
| 199 | struct ieee80211_rx_status *stats, |
Johannes Berg | eb96ccb | 2014-11-12 17:12:05 +0100 | [diff] [blame] | 200 | u32 rx_pkt_status, |
| 201 | u8 *crypt_len) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 202 | { |
| 203 | if (!ieee80211_has_protected(hdr->frame_control) || |
| 204 | (rx_pkt_status & RX_MPDU_RES_STATUS_SEC_ENC_MSK) == |
| 205 | RX_MPDU_RES_STATUS_SEC_NO_ENC) |
| 206 | return 0; |
| 207 | |
| 208 | /* packet was encrypted with unknown alg */ |
| 209 | if ((rx_pkt_status & RX_MPDU_RES_STATUS_SEC_ENC_MSK) == |
| 210 | RX_MPDU_RES_STATUS_SEC_ENC_ERR) |
| 211 | return 0; |
| 212 | |
| 213 | switch (rx_pkt_status & RX_MPDU_RES_STATUS_SEC_ENC_MSK) { |
| 214 | case RX_MPDU_RES_STATUS_SEC_CCM_ENC: |
| 215 | /* alg is CCM: check MIC only */ |
| 216 | if (!(rx_pkt_status & RX_MPDU_RES_STATUS_MIC_OK)) |
| 217 | return -1; |
| 218 | |
| 219 | stats->flag |= RX_FLAG_DECRYPTED; |
Johannes Berg | eb96ccb | 2014-11-12 17:12:05 +0100 | [diff] [blame] | 220 | *crypt_len = IEEE80211_CCMP_HDR_LEN; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 221 | return 0; |
| 222 | |
| 223 | case RX_MPDU_RES_STATUS_SEC_TKIP_ENC: |
| 224 | /* Don't drop the frame and decrypt it in SW */ |
Sara Sharon | 57df383 | 2017-12-06 13:57:19 +0200 | [diff] [blame] | 225 | if (!fw_has_api(&mvm->fw->ucode_capa, |
| 226 | IWL_UCODE_TLV_API_DEPRECATE_TTAK) && |
| 227 | !(rx_pkt_status & RX_MPDU_RES_STATUS_TTAK_OK)) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 228 | return 0; |
Johannes Berg | eb96ccb | 2014-11-12 17:12:05 +0100 | [diff] [blame] | 229 | *crypt_len = IEEE80211_TKIP_IV_LEN; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 230 | /* fall through if TTAK OK */ |
| 231 | |
| 232 | case RX_MPDU_RES_STATUS_SEC_WEP_ENC: |
| 233 | if (!(rx_pkt_status & RX_MPDU_RES_STATUS_ICV_OK)) |
| 234 | return -1; |
| 235 | |
| 236 | stats->flag |= RX_FLAG_DECRYPTED; |
Johannes Berg | eb96ccb | 2014-11-12 17:12:05 +0100 | [diff] [blame] | 237 | if ((rx_pkt_status & RX_MPDU_RES_STATUS_SEC_ENC_MSK) == |
| 238 | RX_MPDU_RES_STATUS_SEC_WEP_ENC) |
| 239 | *crypt_len = IEEE80211_WEP_IV_LEN; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 240 | return 0; |
| 241 | |
Max Stepanov | e36e543 | 2013-08-27 19:56:13 +0300 | [diff] [blame] | 242 | case RX_MPDU_RES_STATUS_SEC_EXT_ENC: |
| 243 | if (!(rx_pkt_status & RX_MPDU_RES_STATUS_MIC_OK)) |
| 244 | return -1; |
| 245 | stats->flag |= RX_FLAG_DECRYPTED; |
| 246 | return 0; |
| 247 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 248 | default: |
Shaul Triebitz | baf41bc | 2017-09-13 16:46:14 +0300 | [diff] [blame] | 249 | /* Expected in monitor (not having the keys) */ |
| 250 | if (!mvm->monitor_on) |
| 251 | IWL_ERR(mvm, "Unhandled alg: 0x%x\n", rx_pkt_status); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 252 | } |
| 253 | |
| 254 | return 0; |
| 255 | } |
| 256 | |
Luca Coelho | 7d9d0d5 | 2018-04-12 16:15:07 +0300 | [diff] [blame] | 257 | static void iwl_mvm_rx_handle_tcm(struct iwl_mvm *mvm, |
| 258 | struct ieee80211_sta *sta, |
| 259 | struct ieee80211_hdr *hdr, u32 len, |
| 260 | struct iwl_rx_phy_info *phy_info, |
| 261 | u32 rate_n_flags) |
| 262 | { |
| 263 | struct iwl_mvm_sta *mvmsta; |
| 264 | struct iwl_mvm_tcm_mac *mdata; |
| 265 | int mac; |
| 266 | int ac = IEEE80211_AC_BE; /* treat non-QoS as BE */ |
Johannes Berg | b0ffe45 | 2014-11-11 12:57:03 +0100 | [diff] [blame] | 267 | struct iwl_mvm_vif *mvmvif; |
| 268 | /* expected throughput in 100Kbps, single stream, 20 MHz */ |
| 269 | static const u8 thresh_tpt[] = { |
| 270 | 9, 18, 30, 42, 60, 78, 90, 96, 120, 135, |
| 271 | }; |
| 272 | u16 thr; |
Luca Coelho | 7d9d0d5 | 2018-04-12 16:15:07 +0300 | [diff] [blame] | 273 | |
| 274 | if (ieee80211_is_data_qos(hdr->frame_control)) |
| 275 | ac = tid_to_mac80211_ac[ieee80211_get_tid(hdr)]; |
| 276 | |
| 277 | mvmsta = iwl_mvm_sta_from_mac80211(sta); |
| 278 | mac = mvmsta->mac_id_n_color & FW_CTXT_ID_MSK; |
| 279 | |
| 280 | if (time_after(jiffies, mvm->tcm.ts + MVM_TCM_PERIOD)) |
| 281 | schedule_delayed_work(&mvm->tcm.work, 0); |
| 282 | mdata = &mvm->tcm.data[mac]; |
| 283 | mdata->rx.pkts[ac]++; |
| 284 | |
| 285 | /* count the airtime only once for each ampdu */ |
| 286 | if (mdata->rx.last_ampdu_ref != mvm->ampdu_ref) { |
| 287 | mdata->rx.last_ampdu_ref = mvm->ampdu_ref; |
| 288 | mdata->rx.airtime += le16_to_cpu(phy_info->frame_time); |
| 289 | } |
| 290 | |
| 291 | if (!(rate_n_flags & (RATE_MCS_HT_MSK | RATE_MCS_VHT_MSK))) |
| 292 | return; |
| 293 | |
Johannes Berg | b0ffe45 | 2014-11-11 12:57:03 +0100 | [diff] [blame] | 294 | mvmvif = iwl_mvm_vif_from_mac80211(mvmsta->vif); |
| 295 | |
| 296 | if (mdata->opened_rx_ba_sessions || |
| 297 | mdata->uapsd_nonagg_detect.detected || |
| 298 | (!mvmvif->queue_params[IEEE80211_AC_VO].uapsd && |
| 299 | !mvmvif->queue_params[IEEE80211_AC_VI].uapsd && |
| 300 | !mvmvif->queue_params[IEEE80211_AC_BE].uapsd && |
| 301 | !mvmvif->queue_params[IEEE80211_AC_BK].uapsd) || |
| 302 | mvmsta->sta_id != mvmvif->ap_sta_id) |
| 303 | return; |
| 304 | |
| 305 | if (rate_n_flags & RATE_MCS_HT_MSK) { |
| 306 | thr = thresh_tpt[rate_n_flags & RATE_HT_MCS_RATE_CODE_MSK]; |
| 307 | thr *= 1 + ((rate_n_flags & RATE_HT_MCS_NSS_MSK) >> |
| 308 | RATE_HT_MCS_NSS_POS); |
| 309 | } else { |
| 310 | if (WARN_ON((rate_n_flags & RATE_VHT_MCS_RATE_CODE_MSK) >= |
| 311 | ARRAY_SIZE(thresh_tpt))) |
| 312 | return; |
| 313 | thr = thresh_tpt[rate_n_flags & RATE_VHT_MCS_RATE_CODE_MSK]; |
| 314 | thr *= 1 + ((rate_n_flags & RATE_VHT_MCS_NSS_MSK) >> |
| 315 | RATE_VHT_MCS_NSS_POS); |
| 316 | } |
| 317 | |
| 318 | thr <<= ((rate_n_flags & RATE_MCS_CHAN_WIDTH_MSK) >> |
| 319 | RATE_MCS_CHAN_WIDTH_POS); |
| 320 | |
| 321 | mdata->uapsd_nonagg_detect.rx_bytes += len; |
| 322 | ewma_rate_add(&mdata->uapsd_nonagg_detect.rate, thr); |
Luca Coelho | 7d9d0d5 | 2018-04-12 16:15:07 +0300 | [diff] [blame] | 323 | } |
| 324 | |
Avri Altman | 93190fb | 2014-12-27 09:09:47 +0200 | [diff] [blame] | 325 | static void iwl_mvm_rx_csum(struct ieee80211_sta *sta, |
| 326 | struct sk_buff *skb, |
| 327 | u32 status) |
| 328 | { |
| 329 | struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta); |
| 330 | struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(mvmsta->vif); |
| 331 | |
| 332 | if (mvmvif->features & NETIF_F_RXCSUM && |
| 333 | status & RX_MPDU_RES_STATUS_CSUM_DONE && |
| 334 | status & RX_MPDU_RES_STATUS_CSUM_OK) |
| 335 | skb->ip_summed = CHECKSUM_UNNECESSARY; |
| 336 | } |
| 337 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 338 | /* |
| 339 | * iwl_mvm_rx_rx_mpdu - REPLY_RX_MPDU_CMD handler |
| 340 | * |
| 341 | * Handles the actual data of the Rx packet from the fw |
| 342 | */ |
Johannes Berg | 1be5d8c | 2015-06-11 16:51:24 +0200 | [diff] [blame] | 343 | void iwl_mvm_rx_rx_mpdu(struct iwl_mvm *mvm, struct napi_struct *napi, |
| 344 | struct iwl_rx_cmd_buffer *rxb) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 345 | { |
| 346 | struct ieee80211_hdr *hdr; |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 347 | struct ieee80211_rx_status *rx_status; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 348 | struct iwl_rx_packet *pkt = rxb_addr(rxb); |
| 349 | struct iwl_rx_phy_info *phy_info; |
| 350 | struct iwl_rx_mpdu_res_start *rx_res; |
Johannes Berg | a399f98 | 2015-09-24 18:29:00 +0200 | [diff] [blame] | 351 | struct ieee80211_sta *sta = NULL; |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 352 | struct sk_buff *skb; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 353 | u32 len; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 354 | u32 rate_n_flags; |
| 355 | u32 rx_pkt_status; |
Johannes Berg | eb96ccb | 2014-11-12 17:12:05 +0100 | [diff] [blame] | 356 | u8 crypt_len = 0; |
Luca Coelho | 16e4dd8 | 2016-03-30 15:05:56 +0300 | [diff] [blame] | 357 | bool take_ref; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 358 | |
| 359 | phy_info = &mvm->last_phy_info; |
| 360 | rx_res = (struct iwl_rx_mpdu_res_start *)pkt->data; |
| 361 | hdr = (struct ieee80211_hdr *)(pkt->data + sizeof(*rx_res)); |
| 362 | len = le16_to_cpu(rx_res->byte_count); |
| 363 | rx_pkt_status = le32_to_cpup((__le32 *) |
| 364 | (pkt->data + sizeof(*rx_res) + len)); |
| 365 | |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 366 | /* Dont use dev_alloc_skb(), we'll have enough headroom once |
| 367 | * ieee80211_hdr pulled. |
| 368 | */ |
| 369 | skb = alloc_skb(128, GFP_ATOMIC); |
| 370 | if (!skb) { |
| 371 | IWL_ERR(mvm, "alloc_skb failed\n"); |
Johannes Berg | 0416841 | 2015-06-23 21:22:09 +0200 | [diff] [blame] | 372 | return; |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 373 | } |
| 374 | |
| 375 | rx_status = IEEE80211_SKB_RXCB(skb); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 376 | |
| 377 | /* |
| 378 | * drop the packet if it has failed being decrypted by HW |
| 379 | */ |
Johannes Berg | eb96ccb | 2014-11-12 17:12:05 +0100 | [diff] [blame] | 380 | if (iwl_mvm_set_mac80211_rx_flag(mvm, hdr, rx_status, rx_pkt_status, |
| 381 | &crypt_len)) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 382 | IWL_DEBUG_DROP(mvm, "Bad decryption results 0x%08x\n", |
| 383 | rx_pkt_status); |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 384 | kfree_skb(skb); |
Johannes Berg | 0416841 | 2015-06-23 21:22:09 +0200 | [diff] [blame] | 385 | return; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 386 | } |
| 387 | |
Johannes Berg | fb8b8ee | 2013-10-21 12:37:53 +0200 | [diff] [blame] | 388 | /* |
| 389 | * Keep packets with CRC errors (and with overrun) for monitor mode |
| 390 | * (otherwise the firmware discards them) but mark them as bad. |
| 391 | */ |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 392 | if (!(rx_pkt_status & RX_MPDU_RES_STATUS_CRC_OK) || |
| 393 | !(rx_pkt_status & RX_MPDU_RES_STATUS_OVERRUN_OK)) { |
| 394 | IWL_DEBUG_RX(mvm, "Bad CRC or FIFO: 0x%08X.\n", rx_pkt_status); |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 395 | rx_status->flag |= RX_FLAG_FAILED_FCS_CRC; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 396 | } |
| 397 | |
| 398 | /* This will be used in several places later */ |
| 399 | rate_n_flags = le32_to_cpu(phy_info->rate_n_flags); |
| 400 | |
| 401 | /* rx_status carries information about the packet to mac80211 */ |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 402 | rx_status->mactime = le64_to_cpu(phy_info->timestamp); |
| 403 | rx_status->device_timestamp = le32_to_cpu(phy_info->system_timestamp); |
| 404 | rx_status->band = |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 405 | (phy_info->phy_flags & cpu_to_le16(RX_RES_PHY_FLAGS_BAND_24)) ? |
Johannes Berg | 57fbcce | 2016-04-12 15:56:15 +0200 | [diff] [blame] | 406 | NL80211_BAND_2GHZ : NL80211_BAND_5GHZ; |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 407 | rx_status->freq = |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 408 | ieee80211_channel_to_frequency(le16_to_cpu(phy_info->channel), |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 409 | rx_status->band); |
Sara Sharon | 77fe739 | 2016-01-10 14:23:25 +0200 | [diff] [blame] | 410 | |
| 411 | /* TSF as indicated by the firmware is at INA time */ |
| 412 | rx_status->flag |= RX_FLAG_MACTIME_PLCP_START; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 413 | |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 414 | iwl_mvm_get_signal_strength(mvm, phy_info, rx_status); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 415 | |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 416 | IWL_DEBUG_STATS_LIMIT(mvm, "Rssi %d, TSF %llu\n", rx_status->signal, |
| 417 | (unsigned long long)rx_status->mactime); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 418 | |
Eyal Shapira | 361dbec | 2014-08-13 00:31:13 +0300 | [diff] [blame] | 419 | rcu_read_lock(); |
Johannes Berg | a399f98 | 2015-09-24 18:29:00 +0200 | [diff] [blame] | 420 | if (rx_pkt_status & RX_MPDU_RES_STATUS_SRC_STA_FOUND) { |
| 421 | u32 id = rx_pkt_status & RX_MPDU_RES_STATUS_STA_ID_MSK; |
| 422 | |
| 423 | id >>= RX_MDPU_RES_STATUS_STA_ID_SHIFT; |
| 424 | |
Sara Sharon | 0ae9881 | 2017-01-04 14:53:58 +0200 | [diff] [blame] | 425 | if (!WARN_ON_ONCE(id >= ARRAY_SIZE(mvm->fw_id_to_mac_id))) { |
Johannes Berg | a399f98 | 2015-09-24 18:29:00 +0200 | [diff] [blame] | 426 | sta = rcu_dereference(mvm->fw_id_to_mac_id[id]); |
| 427 | if (IS_ERR(sta)) |
| 428 | sta = NULL; |
| 429 | } |
| 430 | } else if (!is_multicast_ether_addr(hdr->addr2)) { |
| 431 | /* This is fine since we prevent two stations with the same |
| 432 | * address from being added. |
| 433 | */ |
| 434 | sta = ieee80211_find_sta_by_ifaddr(mvm->hw, hdr->addr2, NULL); |
Eyal Shapira | 361dbec | 2014-08-13 00:31:13 +0300 | [diff] [blame] | 435 | } |
| 436 | |
Eyal Shapira | 361dbec | 2014-08-13 00:31:13 +0300 | [diff] [blame] | 437 | if (sta) { |
Johannes Berg | 7c0ebd7 | 2015-09-22 12:28:42 +0200 | [diff] [blame] | 438 | struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta); |
Andrei Otcheretianski | d3a108a | 2016-02-28 17:12:21 +0200 | [diff] [blame] | 439 | struct ieee80211_vif *tx_blocked_vif = |
| 440 | rcu_dereference(mvm->csa_tx_blocked_vif); |
Johannes Berg | 7c0ebd7 | 2015-09-22 12:28:42 +0200 | [diff] [blame] | 441 | |
Johannes Berg | a399f98 | 2015-09-24 18:29:00 +0200 | [diff] [blame] | 442 | /* We have tx blocked stations (with CS bit). If we heard |
| 443 | * frames from a blocked station on a new channel we can |
| 444 | * TX to it again. |
| 445 | */ |
Andrei Otcheretianski | d3a108a | 2016-02-28 17:12:21 +0200 | [diff] [blame] | 446 | if (unlikely(tx_blocked_vif) && |
| 447 | mvmsta->vif == tx_blocked_vif) { |
| 448 | struct iwl_mvm_vif *mvmvif = |
| 449 | iwl_mvm_vif_from_mac80211(tx_blocked_vif); |
| 450 | |
| 451 | if (mvmvif->csa_target_freq == rx_status->freq) |
| 452 | iwl_mvm_sta_modify_disable_tx_ap(mvm, sta, |
| 453 | false); |
| 454 | } |
Johannes Berg | a399f98 | 2015-09-24 18:29:00 +0200 | [diff] [blame] | 455 | |
Gregory Greenman | ecaf71d | 2017-11-01 07:16:29 +0200 | [diff] [blame] | 456 | rs_update_last_rssi(mvm, mvmsta, rx_status); |
Emmanuel Grumbach | 3ec50b5e | 2015-02-03 14:29:36 +0200 | [diff] [blame] | 457 | |
| 458 | if (iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_RSSI) && |
| 459 | ieee80211_is_beacon(hdr->frame_control)) { |
| 460 | struct iwl_fw_dbg_trigger_tlv *trig; |
| 461 | struct iwl_fw_dbg_trigger_low_rssi *rssi_trig; |
| 462 | bool trig_check; |
| 463 | s32 rssi; |
| 464 | |
| 465 | trig = iwl_fw_dbg_get_trigger(mvm->fw, |
| 466 | FW_DBG_TRIGGER_RSSI); |
| 467 | rssi_trig = (void *)trig->data; |
| 468 | rssi = le32_to_cpu(rssi_trig->rssi); |
| 469 | |
| 470 | trig_check = |
Johannes Berg | 7174beb | 2017-06-01 16:03:19 +0200 | [diff] [blame] | 471 | iwl_fw_dbg_trigger_check_stop(&mvm->fwrt, |
| 472 | ieee80211_vif_to_wdev(mvmsta->vif), |
Emmanuel Grumbach | 3ec50b5e | 2015-02-03 14:29:36 +0200 | [diff] [blame] | 473 | trig); |
| 474 | if (trig_check && rx_status->signal < rssi) |
Johannes Berg | 7174beb | 2017-06-01 16:03:19 +0200 | [diff] [blame] | 475 | iwl_fw_dbg_collect_trig(&mvm->fwrt, trig, |
| 476 | NULL); |
Emmanuel Grumbach | 3ec50b5e | 2015-02-03 14:29:36 +0200 | [diff] [blame] | 477 | } |
Johannes Berg | a399f98 | 2015-09-24 18:29:00 +0200 | [diff] [blame] | 478 | |
Luca Coelho | 7d9d0d5 | 2018-04-12 16:15:07 +0300 | [diff] [blame] | 479 | if (!mvm->tcm.paused && len >= sizeof(*hdr) && |
| 480 | !is_multicast_ether_addr(hdr->addr1) && |
| 481 | ieee80211_is_data(hdr->frame_control)) |
| 482 | iwl_mvm_rx_handle_tcm(mvm, sta, hdr, len, phy_info, |
| 483 | rate_n_flags); |
| 484 | |
Johannes Berg | a399f98 | 2015-09-24 18:29:00 +0200 | [diff] [blame] | 485 | if (ieee80211_is_data(hdr->frame_control)) |
| 486 | iwl_mvm_rx_csum(sta, skb, rx_pkt_status); |
Eyal Shapira | 361dbec | 2014-08-13 00:31:13 +0300 | [diff] [blame] | 487 | } |
Eyal Shapira | 361dbec | 2014-08-13 00:31:13 +0300 | [diff] [blame] | 488 | rcu_read_unlock(); |
| 489 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 490 | /* set the preamble flag if appropriate */ |
| 491 | if (phy_info->phy_flags & cpu_to_le16(RX_RES_PHY_FLAGS_SHORT_PREAMBLE)) |
Johannes Berg | 7fdd69c | 2017-04-26 11:13:00 +0200 | [diff] [blame] | 492 | rx_status->enc_flags |= RX_ENC_FLAG_SHORTPRE; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 493 | |
| 494 | if (phy_info->phy_flags & cpu_to_le16(RX_RES_PHY_FLAGS_AGG)) { |
| 495 | /* |
| 496 | * We know which subframes of an A-MPDU belong |
| 497 | * together since we get a single PHY response |
| 498 | * from the firmware for all of them |
| 499 | */ |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 500 | rx_status->flag |= RX_FLAG_AMPDU_DETAILS; |
| 501 | rx_status->ampdu_reference = mvm->ampdu_ref; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 502 | } |
| 503 | |
| 504 | /* Set up the HT phy flags */ |
| 505 | switch (rate_n_flags & RATE_MCS_CHAN_WIDTH_MSK) { |
| 506 | case RATE_MCS_CHAN_WIDTH_20: |
| 507 | break; |
| 508 | case RATE_MCS_CHAN_WIDTH_40: |
Johannes Berg | da6a435 | 2017-04-26 12:14:59 +0200 | [diff] [blame] | 509 | rx_status->bw = RATE_INFO_BW_40; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 510 | break; |
| 511 | case RATE_MCS_CHAN_WIDTH_80: |
Johannes Berg | da6a435 | 2017-04-26 12:14:59 +0200 | [diff] [blame] | 512 | rx_status->bw = RATE_INFO_BW_80; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 513 | break; |
| 514 | case RATE_MCS_CHAN_WIDTH_160: |
Johannes Berg | da6a435 | 2017-04-26 12:14:59 +0200 | [diff] [blame] | 515 | rx_status->bw = RATE_INFO_BW_160; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 516 | break; |
| 517 | } |
Sara Sharon | 4c59ff5 | 2017-10-29 10:46:39 +0200 | [diff] [blame] | 518 | if (!(rate_n_flags & RATE_MCS_CCK_MSK) && |
| 519 | rate_n_flags & RATE_MCS_SGI_MSK) |
Johannes Berg | 7fdd69c | 2017-04-26 11:13:00 +0200 | [diff] [blame] | 520 | rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 521 | if (rate_n_flags & RATE_HT_MCS_GF_MSK) |
Johannes Berg | 7fdd69c | 2017-04-26 11:13:00 +0200 | [diff] [blame] | 522 | rx_status->enc_flags |= RX_ENC_FLAG_HT_GF; |
Emmanuel Grumbach | 7b1dd04 | 2014-02-04 15:32:43 +0200 | [diff] [blame] | 523 | if (rate_n_flags & RATE_MCS_LDPC_MSK) |
Johannes Berg | 7fdd69c | 2017-04-26 11:13:00 +0200 | [diff] [blame] | 524 | rx_status->enc_flags |= RX_ENC_FLAG_LDPC; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 525 | if (rate_n_flags & RATE_MCS_HT_MSK) { |
Sara Sharon | 77e4094 | 2017-01-11 11:58:38 +0200 | [diff] [blame] | 526 | u8 stbc = (rate_n_flags & RATE_MCS_STBC_MSK) >> |
Emmanuel Grumbach | 7b1dd04 | 2014-02-04 15:32:43 +0200 | [diff] [blame] | 527 | RATE_MCS_STBC_POS; |
Johannes Berg | da6a435 | 2017-04-26 12:14:59 +0200 | [diff] [blame] | 528 | rx_status->encoding = RX_ENC_HT; |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 529 | rx_status->rate_idx = rate_n_flags & RATE_HT_MCS_INDEX_MSK; |
Johannes Berg | 7fdd69c | 2017-04-26 11:13:00 +0200 | [diff] [blame] | 530 | rx_status->enc_flags |= stbc << RX_ENC_FLAG_STBC_SHIFT; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 531 | } else if (rate_n_flags & RATE_MCS_VHT_MSK) { |
Sara Sharon | 77e4094 | 2017-01-11 11:58:38 +0200 | [diff] [blame] | 532 | u8 stbc = (rate_n_flags & RATE_MCS_STBC_MSK) >> |
Emmanuel Grumbach | 7b1dd04 | 2014-02-04 15:32:43 +0200 | [diff] [blame] | 533 | RATE_MCS_STBC_POS; |
Johannes Berg | 8613c94 | 2017-04-26 13:51:41 +0200 | [diff] [blame] | 534 | rx_status->nss = |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 535 | ((rate_n_flags & RATE_VHT_MCS_NSS_MSK) >> |
| 536 | RATE_VHT_MCS_NSS_POS) + 1; |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 537 | rx_status->rate_idx = rate_n_flags & RATE_VHT_MCS_RATE_CODE_MSK; |
Johannes Berg | da6a435 | 2017-04-26 12:14:59 +0200 | [diff] [blame] | 538 | rx_status->encoding = RX_ENC_VHT; |
Johannes Berg | 7fdd69c | 2017-04-26 11:13:00 +0200 | [diff] [blame] | 539 | rx_status->enc_flags |= stbc << RX_ENC_FLAG_STBC_SHIFT; |
Emmanuel Grumbach | 95e05ab | 2014-03-04 09:38:43 +0200 | [diff] [blame] | 540 | if (rate_n_flags & RATE_MCS_BF_MSK) |
Johannes Berg | 7fdd69c | 2017-04-26 11:13:00 +0200 | [diff] [blame] | 541 | rx_status->enc_flags |= RX_ENC_FLAG_BF; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 542 | } else { |
Sara Sharon | cb2de6b | 2017-02-13 13:36:31 +0200 | [diff] [blame] | 543 | int rate = iwl_mvm_legacy_rate_to_mac80211_idx(rate_n_flags, |
| 544 | rx_status->band); |
| 545 | |
| 546 | if (WARN(rate < 0 || rate > 0xFF, |
| 547 | "Invalid rate flags 0x%x, band %d,\n", |
| 548 | rate_n_flags, rx_status->band)) { |
| 549 | kfree_skb(skb); |
| 550 | return; |
| 551 | } |
| 552 | rx_status->rate_idx = rate; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 553 | } |
| 554 | |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 555 | #ifdef CONFIG_IWLWIFI_DEBUGFS |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 556 | iwl_mvm_update_frame_stats(mvm, rate_n_flags, |
Johannes Berg | d0963b5 | 2014-11-12 16:45:12 +0100 | [diff] [blame] | 557 | rx_status->flag & RX_FLAG_AMPDU_DETAILS); |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 558 | #endif |
Luca Coelho | a339e91 | 2016-02-02 22:58:46 +0200 | [diff] [blame] | 559 | |
| 560 | if (unlikely((ieee80211_is_beacon(hdr->frame_control) || |
| 561 | ieee80211_is_probe_resp(hdr->frame_control)) && |
| 562 | mvm->sched_scan_pass_all == SCHED_SCAN_PASS_ALL_ENABLED)) |
| 563 | mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_FOUND; |
| 564 | |
Johannes Berg | 43ec72b | 2016-03-10 11:55:44 +0100 | [diff] [blame] | 565 | if (unlikely(ieee80211_is_beacon(hdr->frame_control) || |
| 566 | ieee80211_is_probe_resp(hdr->frame_control))) |
| 567 | rx_status->boottime_ns = ktime_get_boot_ns(); |
| 568 | |
Luca Coelho | 16e4dd8 | 2016-03-30 15:05:56 +0300 | [diff] [blame] | 569 | /* Take a reference briefly to kick off a d0i3 entry delay so |
| 570 | * we can handle bursts of RX packets without toggling the |
| 571 | * state too often. But don't do this for beacons if we are |
| 572 | * going to idle because the beacon filtering changes we make |
| 573 | * cause the firmware to send us collateral beacons. */ |
| 574 | take_ref = !(test_bit(STATUS_TRANS_GOING_IDLE, &mvm->trans->status) && |
| 575 | ieee80211_is_beacon(hdr->frame_control)); |
| 576 | |
| 577 | if (take_ref) |
| 578 | iwl_mvm_ref(mvm, IWL_MVM_REF_RX); |
| 579 | |
Johannes Berg | 43ec72b | 2016-03-10 11:55:44 +0100 | [diff] [blame] | 580 | iwl_mvm_pass_packet_to_mac80211(mvm, sta, napi, skb, hdr, len, |
Dan Carpenter | bdbc58a | 2016-05-04 09:19:13 +0300 | [diff] [blame] | 581 | crypt_len, rxb); |
Luca Coelho | 16e4dd8 | 2016-03-30 15:05:56 +0300 | [diff] [blame] | 582 | |
| 583 | if (take_ref) |
| 584 | iwl_mvm_unref(mvm, IWL_MVM_REF_RX); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 585 | } |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 586 | |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 587 | struct iwl_mvm_stat_data { |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 588 | struct iwl_mvm *mvm; |
Johannes Berg | 777c9b6 | 2015-01-14 17:58:57 +0100 | [diff] [blame] | 589 | __le32 mac_id; |
Sara Sharon | 62e004f | 2015-08-20 14:12:58 +0300 | [diff] [blame] | 590 | u8 beacon_filter_average_energy; |
Sara Sharon | 0e7ac01 | 2016-09-08 17:32:19 +0300 | [diff] [blame] | 591 | void *general; |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 592 | }; |
| 593 | |
| 594 | static void iwl_mvm_stat_iterator(void *_data, u8 *mac, |
| 595 | struct ieee80211_vif *vif) |
| 596 | { |
| 597 | struct iwl_mvm_stat_data *data = _data; |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 598 | struct iwl_mvm *mvm = data->mvm; |
Johannes Berg | 777c9b6 | 2015-01-14 17:58:57 +0100 | [diff] [blame] | 599 | int sig = -data->beacon_filter_average_energy; |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 600 | int last_event; |
| 601 | int thold = vif->bss_conf.cqm_rssi_thold; |
| 602 | int hyst = vif->bss_conf.cqm_rssi_hyst; |
Johannes Berg | 777c9b6 | 2015-01-14 17:58:57 +0100 | [diff] [blame] | 603 | u16 id = le32_to_cpu(data->mac_id); |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 604 | struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 605 | |
Johannes Berg | 33cef92 | 2015-01-21 21:41:29 +0100 | [diff] [blame] | 606 | /* This doesn't need the MAC ID check since it's not taking the |
| 607 | * data copied into the "data" struct, but rather the data from |
| 608 | * the notification directly. |
| 609 | */ |
| 610 | if (data->general) { |
Sara Sharon | 0e7ac01 | 2016-09-08 17:32:19 +0300 | [diff] [blame] | 611 | u16 vif_id = mvmvif->id; |
| 612 | |
| 613 | if (iwl_mvm_is_cdb_supported(mvm)) { |
| 614 | struct mvm_statistics_general_cdb *general = |
| 615 | data->general; |
| 616 | |
| 617 | mvmvif->beacon_stats.num_beacons = |
| 618 | le32_to_cpu(general->beacon_counter[vif_id]); |
| 619 | mvmvif->beacon_stats.avg_signal = |
| 620 | -general->beacon_average_energy[vif_id]; |
| 621 | } else { |
| 622 | struct mvm_statistics_general_v8 *general = |
| 623 | data->general; |
| 624 | |
| 625 | mvmvif->beacon_stats.num_beacons = |
| 626 | le32_to_cpu(general->beacon_counter[vif_id]); |
| 627 | mvmvif->beacon_stats.avg_signal = |
| 628 | -general->beacon_average_energy[vif_id]; |
| 629 | } |
Johannes Berg | 33cef92 | 2015-01-21 21:41:29 +0100 | [diff] [blame] | 630 | } |
| 631 | |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 632 | if (mvmvif->id != id) |
| 633 | return; |
| 634 | |
| 635 | if (vif->type != NL80211_IFTYPE_STATION) |
| 636 | return; |
| 637 | |
Alexander Bondar | 8047cc0 | 2015-03-26 13:15:03 +0200 | [diff] [blame] | 638 | if (sig == 0) { |
| 639 | IWL_DEBUG_RX(mvm, "RSSI is 0 - skip signal based decision\n"); |
| 640 | return; |
| 641 | } |
| 642 | |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 643 | mvmvif->bf_data.ave_beacon_signal = sig; |
| 644 | |
Andrei Otcheretianski | 911222b | 2013-07-21 17:37:19 +0300 | [diff] [blame] | 645 | /* BT Coex */ |
| 646 | if (mvmvif->bf_data.bt_coex_min_thold != |
| 647 | mvmvif->bf_data.bt_coex_max_thold) { |
| 648 | last_event = mvmvif->bf_data.last_bt_coex_event; |
| 649 | if (sig > mvmvif->bf_data.bt_coex_max_thold && |
| 650 | (last_event <= mvmvif->bf_data.bt_coex_min_thold || |
| 651 | last_event == 0)) { |
| 652 | mvmvif->bf_data.last_bt_coex_event = sig; |
| 653 | IWL_DEBUG_RX(mvm, "cqm_iterator bt coex high %d\n", |
| 654 | sig); |
| 655 | iwl_mvm_bt_rssi_event(mvm, vif, RSSI_EVENT_HIGH); |
| 656 | } else if (sig < mvmvif->bf_data.bt_coex_min_thold && |
| 657 | (last_event >= mvmvif->bf_data.bt_coex_max_thold || |
| 658 | last_event == 0)) { |
| 659 | mvmvif->bf_data.last_bt_coex_event = sig; |
| 660 | IWL_DEBUG_RX(mvm, "cqm_iterator bt coex low %d\n", |
| 661 | sig); |
| 662 | iwl_mvm_bt_rssi_event(mvm, vif, RSSI_EVENT_LOW); |
| 663 | } |
| 664 | } |
| 665 | |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 666 | if (!(vif->driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)) |
| 667 | return; |
| 668 | |
| 669 | /* CQM Notification */ |
| 670 | last_event = mvmvif->bf_data.last_cqm_event; |
| 671 | if (thold && sig < thold && (last_event == 0 || |
| 672 | sig < last_event - hyst)) { |
| 673 | mvmvif->bf_data.last_cqm_event = sig; |
| 674 | IWL_DEBUG_RX(mvm, "cqm_iterator cqm low %d\n", |
| 675 | sig); |
| 676 | ieee80211_cqm_rssi_notify( |
| 677 | vif, |
| 678 | NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW, |
Andrzej Zaborowski | 769f07d | 2017-01-25 12:43:40 +0100 | [diff] [blame] | 679 | sig, |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 680 | GFP_KERNEL); |
| 681 | } else if (sig > thold && |
| 682 | (last_event == 0 || sig > last_event + hyst)) { |
| 683 | mvmvif->bf_data.last_cqm_event = sig; |
| 684 | IWL_DEBUG_RX(mvm, "cqm_iterator cqm high %d\n", |
| 685 | sig); |
| 686 | ieee80211_cqm_rssi_notify( |
| 687 | vif, |
| 688 | NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH, |
Andrzej Zaborowski | 769f07d | 2017-01-25 12:43:40 +0100 | [diff] [blame] | 689 | sig, |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 690 | GFP_KERNEL); |
| 691 | } |
| 692 | } |
| 693 | |
Emmanuel Grumbach | 5a756c2 | 2015-02-10 15:26:57 +0200 | [diff] [blame] | 694 | static inline void |
| 695 | iwl_mvm_rx_stats_check_trigger(struct iwl_mvm *mvm, struct iwl_rx_packet *pkt) |
| 696 | { |
| 697 | struct iwl_fw_dbg_trigger_tlv *trig; |
| 698 | struct iwl_fw_dbg_trigger_stats *trig_stats; |
| 699 | u32 trig_offset, trig_thold; |
| 700 | |
| 701 | if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_STATS)) |
| 702 | return; |
| 703 | |
| 704 | trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_STATS); |
| 705 | trig_stats = (void *)trig->data; |
| 706 | |
Johannes Berg | 7174beb | 2017-06-01 16:03:19 +0200 | [diff] [blame] | 707 | if (!iwl_fw_dbg_trigger_check_stop(&mvm->fwrt, NULL, trig)) |
Emmanuel Grumbach | 5a756c2 | 2015-02-10 15:26:57 +0200 | [diff] [blame] | 708 | return; |
| 709 | |
| 710 | trig_offset = le32_to_cpu(trig_stats->stop_offset); |
| 711 | trig_thold = le32_to_cpu(trig_stats->stop_threshold); |
| 712 | |
| 713 | if (WARN_ON_ONCE(trig_offset >= iwl_rx_packet_payload_len(pkt))) |
| 714 | return; |
| 715 | |
| 716 | if (le32_to_cpup((__le32 *) (pkt->data + trig_offset)) < trig_thold) |
| 717 | return; |
| 718 | |
Johannes Berg | 7174beb | 2017-06-01 16:03:19 +0200 | [diff] [blame] | 719 | iwl_fw_dbg_collect_trig(&mvm->fwrt, trig, NULL); |
Emmanuel Grumbach | 5a756c2 | 2015-02-10 15:26:57 +0200 | [diff] [blame] | 720 | } |
| 721 | |
Johannes Berg | 91a8bcd | 2015-01-14 18:12:41 +0100 | [diff] [blame] | 722 | void iwl_mvm_handle_rx_statistics(struct iwl_mvm *mvm, |
| 723 | struct iwl_rx_packet *pkt) |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 724 | { |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 725 | struct iwl_mvm_stat_data data = { |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 726 | .mvm = mvm, |
| 727 | }; |
Sara Sharon | 0e7ac01 | 2016-09-08 17:32:19 +0300 | [diff] [blame] | 728 | int expected_size; |
Goodstein, Mordechay | cfbeb598 | 2016-11-21 10:26:36 +0200 | [diff] [blame] | 729 | int i; |
| 730 | u8 *energy; |
Johannes Berg | b0ffe45 | 2014-11-11 12:57:03 +0100 | [diff] [blame] | 731 | __le32 *bytes; |
Luca Coelho | 7d9d0d5 | 2018-04-12 16:15:07 +0300 | [diff] [blame] | 732 | __le32 *air_time; |
Liad Kaufman | 678d9b6 | 2017-05-18 18:00:49 +0300 | [diff] [blame] | 733 | __le32 flags; |
Sara Sharon | 0e7ac01 | 2016-09-08 17:32:19 +0300 | [diff] [blame] | 734 | |
Liad Kaufman | 678d9b6 | 2017-05-18 18:00:49 +0300 | [diff] [blame] | 735 | if (!iwl_mvm_has_new_rx_stats_api(mvm)) { |
| 736 | if (iwl_mvm_has_new_rx_api(mvm)) |
| 737 | expected_size = sizeof(struct iwl_notif_statistics_v11); |
| 738 | else |
| 739 | expected_size = sizeof(struct iwl_notif_statistics_v10); |
| 740 | } else { |
| 741 | expected_size = sizeof(struct iwl_notif_statistics_cdb); |
| 742 | } |
Johannes Berg | 777c9b6 | 2015-01-14 17:58:57 +0100 | [diff] [blame] | 743 | |
Johannes Berg | 42fa5e0 | 2017-09-26 16:37:12 +0200 | [diff] [blame] | 744 | if (WARN_ONCE(iwl_rx_packet_payload_len(pkt) != expected_size, |
| 745 | "received invalid statistics size (%d)!\n", |
| 746 | iwl_rx_packet_payload_len(pkt))) |
Luca Coelho | 6a90f85 | 2017-01-25 18:57:26 +0200 | [diff] [blame] | 747 | return; |
Johannes Berg | 777c9b6 | 2015-01-14 17:58:57 +0100 | [diff] [blame] | 748 | |
Liad Kaufman | 678d9b6 | 2017-05-18 18:00:49 +0300 | [diff] [blame] | 749 | if (!iwl_mvm_has_new_rx_stats_api(mvm)) { |
| 750 | struct iwl_notif_statistics_v11 *stats = (void *)&pkt->data; |
Johannes Berg | 777c9b6 | 2015-01-14 17:58:57 +0100 | [diff] [blame] | 751 | |
Liad Kaufman | 678d9b6 | 2017-05-18 18:00:49 +0300 | [diff] [blame] | 752 | data.mac_id = stats->rx.general.mac_id; |
| 753 | data.beacon_filter_average_energy = |
| 754 | stats->general.common.beacon_filter_average_energy; |
Johannes Berg | 777c9b6 | 2015-01-14 17:58:57 +0100 | [diff] [blame] | 755 | |
Liad Kaufman | 678d9b6 | 2017-05-18 18:00:49 +0300 | [diff] [blame] | 756 | mvm->rx_stats_v3 = stats->rx; |
Johannes Berg | 91a8bcd | 2015-01-14 18:12:41 +0100 | [diff] [blame] | 757 | |
Liad Kaufman | 678d9b6 | 2017-05-18 18:00:49 +0300 | [diff] [blame] | 758 | mvm->radio_stats.rx_time = |
| 759 | le64_to_cpu(stats->general.common.rx_time); |
| 760 | mvm->radio_stats.tx_time = |
| 761 | le64_to_cpu(stats->general.common.tx_time); |
| 762 | mvm->radio_stats.on_time_rf = |
| 763 | le64_to_cpu(stats->general.common.on_time_rf); |
| 764 | mvm->radio_stats.on_time_scan = |
| 765 | le64_to_cpu(stats->general.common.on_time_scan); |
| 766 | |
| 767 | data.general = &stats->general; |
| 768 | |
| 769 | flags = stats->flag; |
| 770 | } else { |
| 771 | struct iwl_notif_statistics_cdb *stats = (void *)&pkt->data; |
| 772 | |
| 773 | data.mac_id = stats->rx.general.mac_id; |
| 774 | data.beacon_filter_average_energy = |
| 775 | stats->general.common.beacon_filter_average_energy; |
| 776 | |
| 777 | mvm->rx_stats = stats->rx; |
| 778 | |
| 779 | mvm->radio_stats.rx_time = |
| 780 | le64_to_cpu(stats->general.common.rx_time); |
| 781 | mvm->radio_stats.tx_time = |
| 782 | le64_to_cpu(stats->general.common.tx_time); |
| 783 | mvm->radio_stats.on_time_rf = |
| 784 | le64_to_cpu(stats->general.common.on_time_rf); |
| 785 | mvm->radio_stats.on_time_scan = |
| 786 | le64_to_cpu(stats->general.common.on_time_scan); |
| 787 | |
| 788 | data.general = &stats->general; |
| 789 | |
| 790 | flags = stats->flag; |
| 791 | } |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 792 | |
Emmanuel Grumbach | 5a756c2 | 2015-02-10 15:26:57 +0200 | [diff] [blame] | 793 | iwl_mvm_rx_stats_check_trigger(mvm, pkt); |
| 794 | |
Andrei Otcheretianski | a20fd39 | 2013-07-21 17:23:59 +0300 | [diff] [blame] | 795 | ieee80211_iterate_active_interfaces(mvm->hw, |
| 796 | IEEE80211_IFACE_ITER_NORMAL, |
| 797 | iwl_mvm_stat_iterator, |
| 798 | &data); |
Goodstein, Mordechay | cfbeb598 | 2016-11-21 10:26:36 +0200 | [diff] [blame] | 799 | |
| 800 | if (!iwl_mvm_has_new_rx_api(mvm)) |
| 801 | return; |
| 802 | |
Liad Kaufman | 678d9b6 | 2017-05-18 18:00:49 +0300 | [diff] [blame] | 803 | if (!iwl_mvm_has_new_rx_stats_api(mvm)) { |
| 804 | struct iwl_notif_statistics_v11 *v11 = (void *)&pkt->data; |
Goodstein, Mordechay | cfbeb598 | 2016-11-21 10:26:36 +0200 | [diff] [blame] | 805 | |
| 806 | energy = (void *)&v11->load_stats.avg_energy; |
Johannes Berg | b0ffe45 | 2014-11-11 12:57:03 +0100 | [diff] [blame] | 807 | bytes = (void *)&v11->load_stats.byte_count; |
Goodstein, Mordechay | cfbeb598 | 2016-11-21 10:26:36 +0200 | [diff] [blame] | 808 | air_time = (void *)&v11->load_stats.air_time; |
| 809 | } else { |
Liad Kaufman | 678d9b6 | 2017-05-18 18:00:49 +0300 | [diff] [blame] | 810 | struct iwl_notif_statistics_cdb *stats = (void *)&pkt->data; |
| 811 | |
Goodstein, Mordechay | cfbeb598 | 2016-11-21 10:26:36 +0200 | [diff] [blame] | 812 | energy = (void *)&stats->load_stats.avg_energy; |
Johannes Berg | b0ffe45 | 2014-11-11 12:57:03 +0100 | [diff] [blame] | 813 | bytes = (void *)&stats->load_stats.byte_count; |
Goodstein, Mordechay | cfbeb598 | 2016-11-21 10:26:36 +0200 | [diff] [blame] | 814 | air_time = (void *)&stats->load_stats.air_time; |
| 815 | } |
| 816 | |
| 817 | rcu_read_lock(); |
| 818 | for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) { |
| 819 | struct iwl_mvm_sta *sta; |
| 820 | |
| 821 | if (!energy[i]) |
| 822 | continue; |
| 823 | |
| 824 | sta = iwl_mvm_sta_from_staid_rcu(mvm, i); |
| 825 | if (!sta) |
| 826 | continue; |
| 827 | sta->avg_energy = energy[i]; |
| 828 | } |
| 829 | rcu_read_unlock(); |
Luca Coelho | 7d9d0d5 | 2018-04-12 16:15:07 +0300 | [diff] [blame] | 830 | |
| 831 | /* |
| 832 | * Don't update in case the statistics are not cleared, since |
| 833 | * we will end up counting twice the same airtime, once in TCM |
| 834 | * request and once in statistics notification. |
| 835 | */ |
| 836 | if (!(le32_to_cpu(flags) & IWL_STATISTICS_REPLY_FLG_CLEAR)) |
| 837 | return; |
| 838 | |
| 839 | spin_lock(&mvm->tcm.lock); |
| 840 | for (i = 0; i < NUM_MAC_INDEX_DRIVER; i++) { |
| 841 | struct iwl_mvm_tcm_mac *mdata = &mvm->tcm.data[i]; |
| 842 | u32 airtime = le32_to_cpu(air_time[i]); |
Johannes Berg | b0ffe45 | 2014-11-11 12:57:03 +0100 | [diff] [blame] | 843 | u32 rx_bytes = le32_to_cpu(bytes[i]); |
| 844 | |
| 845 | mdata->uapsd_nonagg_detect.rx_bytes += rx_bytes; |
| 846 | if (airtime) { |
| 847 | /* re-init every time to store rate from FW */ |
| 848 | ewma_rate_init(&mdata->uapsd_nonagg_detect.rate); |
| 849 | ewma_rate_add(&mdata->uapsd_nonagg_detect.rate, |
| 850 | rx_bytes * 8 / airtime); |
| 851 | } |
Luca Coelho | 7d9d0d5 | 2018-04-12 16:15:07 +0300 | [diff] [blame] | 852 | |
| 853 | mdata->rx.airtime += airtime; |
| 854 | } |
| 855 | spin_unlock(&mvm->tcm.lock); |
Johannes Berg | 91a8bcd | 2015-01-14 18:12:41 +0100 | [diff] [blame] | 856 | } |
| 857 | |
Johannes Berg | 0416841 | 2015-06-23 21:22:09 +0200 | [diff] [blame] | 858 | void iwl_mvm_rx_statistics(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb) |
Johannes Berg | 91a8bcd | 2015-01-14 18:12:41 +0100 | [diff] [blame] | 859 | { |
| 860 | iwl_mvm_handle_rx_statistics(mvm, rxb_addr(rxb)); |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 861 | } |
Sara Sharon | 3af512d6 | 2015-07-22 11:38:40 +0300 | [diff] [blame] | 862 | |
| 863 | void iwl_mvm_window_status_notif(struct iwl_mvm *mvm, |
| 864 | struct iwl_rx_cmd_buffer *rxb) |
| 865 | { |
| 866 | struct iwl_rx_packet *pkt = rxb_addr(rxb); |
| 867 | struct iwl_ba_window_status_notif *notif = (void *)pkt->data; |
| 868 | int i; |
| 869 | u32 pkt_len = iwl_rx_packet_payload_len(pkt); |
| 870 | |
| 871 | if (WARN_ONCE(pkt_len != sizeof(*notif), |
| 872 | "Received window status notification of wrong size (%u)\n", |
| 873 | pkt_len)) |
| 874 | return; |
| 875 | |
| 876 | rcu_read_lock(); |
| 877 | for (i = 0; i < BA_WINDOW_STREAMS_MAX; i++) { |
| 878 | struct ieee80211_sta *sta; |
| 879 | u8 sta_id, tid; |
| 880 | u64 bitmap; |
| 881 | u32 ssn; |
| 882 | u16 ratid; |
| 883 | u16 received_mpdu; |
| 884 | |
| 885 | ratid = le16_to_cpu(notif->ra_tid[i]); |
| 886 | /* check that this TID is valid */ |
| 887 | if (!(ratid & BA_WINDOW_STATUS_VALID_MSK)) |
| 888 | continue; |
| 889 | |
| 890 | received_mpdu = le16_to_cpu(notif->mpdu_rx_count[i]); |
| 891 | if (received_mpdu == 0) |
| 892 | continue; |
| 893 | |
| 894 | tid = ratid & BA_WINDOW_STATUS_TID_MSK; |
| 895 | /* get the station */ |
| 896 | sta_id = (ratid & BA_WINDOW_STATUS_STA_ID_MSK) |
| 897 | >> BA_WINDOW_STATUS_STA_ID_POS; |
| 898 | sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]); |
| 899 | if (IS_ERR_OR_NULL(sta)) |
| 900 | continue; |
| 901 | bitmap = le64_to_cpu(notif->bitmap[i]); |
| 902 | ssn = le32_to_cpu(notif->start_seq_num[i]); |
| 903 | |
| 904 | /* update mac80211 with the bitmap for the reordering buffer */ |
| 905 | ieee80211_mark_rx_ba_filtered_frames(sta, tid, ssn, bitmap, |
| 906 | received_mpdu); |
| 907 | } |
| 908 | rcu_read_unlock(); |
| 909 | } |