1 /******************************************************************************
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.
8 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
9 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of version 2 of the GNU General Public License as
13 * published by the Free Software Foundation.
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
25 * The full GNU General Public License is included in this distribution
26 * in the file called COPYING.
28 * Contact Information:
29 * Intel Linux Wireless <ilw@linux.intel.com>
30 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
34 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
35 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
36 * All rights reserved.
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
42 * * Redistributions of source code must retain the above copyright
43 * notice, this list of conditions and the following disclaimer.
44 * * Redistributions in binary form must reproduce the above copyright
45 * notice, this list of conditions and the following disclaimer in
46 * the documentation and/or other materials provided with the
48 * * Neither the name Intel Corporation nor the names of its
49 * contributors may be used to endorse or promote products derived
50 * from this software without specific prior written permission.
52 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
53 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
54 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
55 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
56 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
57 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
58 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
59 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
60 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
61 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
62 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
63 *****************************************************************************/
64 #include <linux/skbuff.h>
65 #include "iwl-trans.h"
70 * iwl_mvm_rx_rx_phy_cmd - REPLY_RX_PHY_CMD handler
72 * Copies the phy information in mvm->last_phy_info, it will be used when the
73 * actual data will come from the fw in the next packet.
75 void iwl_mvm_rx_rx_phy_cmd(struct iwl_mvm
*mvm
, struct iwl_rx_cmd_buffer
*rxb
)
77 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
79 memcpy(&mvm
->last_phy_info
, pkt
->data
, sizeof(mvm
->last_phy_info
));
82 #ifdef CONFIG_IWLWIFI_DEBUGFS
83 if (mvm
->last_phy_info
.phy_flags
& cpu_to_le16(RX_RES_PHY_FLAGS_AGG
)) {
84 spin_lock(&mvm
->drv_stats_lock
);
85 mvm
->drv_rx_stats
.ampdu_count
++;
86 spin_unlock(&mvm
->drv_stats_lock
);
92 * iwl_mvm_pass_packet_to_mac80211 - builds the packet for mac80211
94 * Adds the rxb to a new skb and give it to mac80211
96 static void iwl_mvm_pass_packet_to_mac80211(struct iwl_mvm
*mvm
,
97 struct napi_struct
*napi
,
99 struct ieee80211_hdr
*hdr
, u16 len
,
100 u32 ampdu_status
, u8 crypt_len
,
101 struct iwl_rx_cmd_buffer
*rxb
)
103 unsigned int hdrlen
, fraglen
;
105 /* If frame is small enough to fit in skb->head, pull it completely.
106 * If not, only pull ieee80211_hdr (including crypto if present, and
107 * an additional 8 bytes for SNAP/ethertype, see below) so that
108 * splice() or TCP coalesce are more efficient.
110 * Since, in addition, ieee80211_data_to_8023() always pull in at
111 * least 8 bytes (possibly more for mesh) we can do the same here
112 * to save the cost of doing it later. That still doesn't pull in
113 * the actual IP header since the typical case has a SNAP header.
114 * If the latter changes (there are efforts in the standards group
115 * to do so) we should revisit this and ieee80211_data_to_8023().
117 hdrlen
= (len
<= skb_tailroom(skb
)) ? len
:
118 sizeof(*hdr
) + crypt_len
+ 8;
120 memcpy(skb_put(skb
, hdrlen
), hdr
, hdrlen
);
121 fraglen
= len
- hdrlen
;
124 int offset
= (void *)hdr
+ hdrlen
-
125 rxb_addr(rxb
) + rxb_offset(rxb
);
127 skb_add_rx_frag(skb
, 0, rxb_steal_page(rxb
), offset
,
128 fraglen
, rxb
->truesize
);
131 ieee80211_rx_napi(mvm
->hw
, skb
, napi
);
135 * iwl_mvm_get_signal_strength - use new rx PHY INFO API
136 * values are reported by the fw as positive values - need to negate
137 * to obtain their dBM. Account for missing antennas by replacing 0
138 * values by -256dBm: practically 0 power and a non-feasible 8 bit value.
140 static void iwl_mvm_get_signal_strength(struct iwl_mvm
*mvm
,
141 struct iwl_rx_phy_info
*phy_info
,
142 struct ieee80211_rx_status
*rx_status
)
144 int energy_a
, energy_b
, energy_c
, max_energy
;
148 le32_to_cpu(phy_info
->non_cfg_phy
[IWL_RX_INFO_ENERGY_ANT_ABC_IDX
]);
149 energy_a
= (val
& IWL_RX_INFO_ENERGY_ANT_A_MSK
) >>
150 IWL_RX_INFO_ENERGY_ANT_A_POS
;
151 energy_a
= energy_a
? -energy_a
: S8_MIN
;
152 energy_b
= (val
& IWL_RX_INFO_ENERGY_ANT_B_MSK
) >>
153 IWL_RX_INFO_ENERGY_ANT_B_POS
;
154 energy_b
= energy_b
? -energy_b
: S8_MIN
;
155 energy_c
= (val
& IWL_RX_INFO_ENERGY_ANT_C_MSK
) >>
156 IWL_RX_INFO_ENERGY_ANT_C_POS
;
157 energy_c
= energy_c
? -energy_c
: S8_MIN
;
158 max_energy
= max(energy_a
, energy_b
);
159 max_energy
= max(max_energy
, energy_c
);
161 IWL_DEBUG_STATS(mvm
, "energy In A %d B %d C %d , and max %d\n",
162 energy_a
, energy_b
, energy_c
, max_energy
);
164 rx_status
->signal
= max_energy
;
165 rx_status
->chains
= (le16_to_cpu(phy_info
->phy_flags
) &
166 RX_RES_PHY_FLAGS_ANTENNA
)
167 >> RX_RES_PHY_FLAGS_ANTENNA_POS
;
168 rx_status
->chain_signal
[0] = energy_a
;
169 rx_status
->chain_signal
[1] = energy_b
;
170 rx_status
->chain_signal
[2] = energy_c
;
174 * iwl_mvm_set_mac80211_rx_flag - translate fw status to mac80211 format
175 * @mvm: the mvm object
177 * @stats: status in mac80211's format
178 * @rx_pkt_status: status coming from fw
180 * returns non 0 value if the packet should be dropped
182 static u32
iwl_mvm_set_mac80211_rx_flag(struct iwl_mvm
*mvm
,
183 struct ieee80211_hdr
*hdr
,
184 struct ieee80211_rx_status
*stats
,
188 if (!ieee80211_has_protected(hdr
->frame_control
) ||
189 (rx_pkt_status
& RX_MPDU_RES_STATUS_SEC_ENC_MSK
) ==
190 RX_MPDU_RES_STATUS_SEC_NO_ENC
)
193 /* packet was encrypted with unknown alg */
194 if ((rx_pkt_status
& RX_MPDU_RES_STATUS_SEC_ENC_MSK
) ==
195 RX_MPDU_RES_STATUS_SEC_ENC_ERR
)
198 switch (rx_pkt_status
& RX_MPDU_RES_STATUS_SEC_ENC_MSK
) {
199 case RX_MPDU_RES_STATUS_SEC_CCM_ENC
:
200 /* alg is CCM: check MIC only */
201 if (!(rx_pkt_status
& RX_MPDU_RES_STATUS_MIC_OK
))
204 stats
->flag
|= RX_FLAG_DECRYPTED
;
205 IWL_DEBUG_WEP(mvm
, "hw decrypted CCMP successfully\n");
206 *crypt_len
= IEEE80211_CCMP_HDR_LEN
;
209 case RX_MPDU_RES_STATUS_SEC_TKIP_ENC
:
210 /* Don't drop the frame and decrypt it in SW */
211 if (!(rx_pkt_status
& RX_MPDU_RES_STATUS_TTAK_OK
))
213 *crypt_len
= IEEE80211_TKIP_IV_LEN
;
214 /* fall through if TTAK OK */
216 case RX_MPDU_RES_STATUS_SEC_WEP_ENC
:
217 if (!(rx_pkt_status
& RX_MPDU_RES_STATUS_ICV_OK
))
220 stats
->flag
|= RX_FLAG_DECRYPTED
;
221 if ((rx_pkt_status
& RX_MPDU_RES_STATUS_SEC_ENC_MSK
) ==
222 RX_MPDU_RES_STATUS_SEC_WEP_ENC
)
223 *crypt_len
= IEEE80211_WEP_IV_LEN
;
226 case RX_MPDU_RES_STATUS_SEC_EXT_ENC
:
227 if (!(rx_pkt_status
& RX_MPDU_RES_STATUS_MIC_OK
))
229 stats
->flag
|= RX_FLAG_DECRYPTED
;
233 IWL_ERR(mvm
, "Unhandled alg: 0x%x\n", rx_pkt_status
);
239 static void iwl_mvm_rx_csum(struct ieee80211_sta
*sta
,
243 struct iwl_mvm_sta
*mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
244 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(mvmsta
->vif
);
246 if (mvmvif
->features
& NETIF_F_RXCSUM
&&
247 status
& RX_MPDU_RES_STATUS_CSUM_DONE
&&
248 status
& RX_MPDU_RES_STATUS_CSUM_OK
)
249 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
253 * iwl_mvm_rx_rx_mpdu - REPLY_RX_MPDU_CMD handler
255 * Handles the actual data of the Rx packet from the fw
257 void iwl_mvm_rx_rx_mpdu(struct iwl_mvm
*mvm
, struct napi_struct
*napi
,
258 struct iwl_rx_cmd_buffer
*rxb
)
260 struct ieee80211_hdr
*hdr
;
261 struct ieee80211_rx_status
*rx_status
;
262 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
263 struct iwl_rx_phy_info
*phy_info
;
264 struct iwl_rx_mpdu_res_start
*rx_res
;
265 struct ieee80211_sta
*sta
;
273 phy_info
= &mvm
->last_phy_info
;
274 rx_res
= (struct iwl_rx_mpdu_res_start
*)pkt
->data
;
275 hdr
= (struct ieee80211_hdr
*)(pkt
->data
+ sizeof(*rx_res
));
276 len
= le16_to_cpu(rx_res
->byte_count
);
277 rx_pkt_status
= le32_to_cpup((__le32
*)
278 (pkt
->data
+ sizeof(*rx_res
) + len
));
280 /* Dont use dev_alloc_skb(), we'll have enough headroom once
281 * ieee80211_hdr pulled.
283 skb
= alloc_skb(128, GFP_ATOMIC
);
285 IWL_ERR(mvm
, "alloc_skb failed\n");
289 rx_status
= IEEE80211_SKB_RXCB(skb
);
292 * drop the packet if it has failed being decrypted by HW
294 if (iwl_mvm_set_mac80211_rx_flag(mvm
, hdr
, rx_status
, rx_pkt_status
,
296 IWL_DEBUG_DROP(mvm
, "Bad decryption results 0x%08x\n",
302 if ((unlikely(phy_info
->cfg_phy_cnt
> 20))) {
303 IWL_DEBUG_DROP(mvm
, "dsp size out of range [0,20]: %d\n",
304 phy_info
->cfg_phy_cnt
);
310 * Keep packets with CRC errors (and with overrun) for monitor mode
311 * (otherwise the firmware discards them) but mark them as bad.
313 if (!(rx_pkt_status
& RX_MPDU_RES_STATUS_CRC_OK
) ||
314 !(rx_pkt_status
& RX_MPDU_RES_STATUS_OVERRUN_OK
)) {
315 IWL_DEBUG_RX(mvm
, "Bad CRC or FIFO: 0x%08X.\n", rx_pkt_status
);
316 rx_status
->flag
|= RX_FLAG_FAILED_FCS_CRC
;
319 /* This will be used in several places later */
320 rate_n_flags
= le32_to_cpu(phy_info
->rate_n_flags
);
322 /* rx_status carries information about the packet to mac80211 */
323 rx_status
->mactime
= le64_to_cpu(phy_info
->timestamp
);
324 rx_status
->device_timestamp
= le32_to_cpu(phy_info
->system_timestamp
);
326 (phy_info
->phy_flags
& cpu_to_le16(RX_RES_PHY_FLAGS_BAND_24
)) ?
327 IEEE80211_BAND_2GHZ
: IEEE80211_BAND_5GHZ
;
329 ieee80211_channel_to_frequency(le16_to_cpu(phy_info
->channel
),
332 * TSF as indicated by the fw is at INA time, but mac80211 expects the
333 * TSF at the beginning of the MPDU.
335 /*rx_status->flag |= RX_FLAG_MACTIME_MPDU;*/
337 iwl_mvm_get_signal_strength(mvm
, phy_info
, rx_status
);
339 IWL_DEBUG_STATS_LIMIT(mvm
, "Rssi %d, TSF %llu\n", rx_status
->signal
,
340 (unsigned long long)rx_status
->mactime
);
344 * We have tx blocked stations (with CS bit). If we heard frames from
345 * a blocked station on a new channel we can TX to it again.
347 if (unlikely(mvm
->csa_tx_block_bcn_timeout
)) {
348 sta
= ieee80211_find_sta(
349 rcu_dereference(mvm
->csa_tx_blocked_vif
), hdr
->addr2
);
351 iwl_mvm_sta_modify_disable_tx_ap(mvm
, sta
, false);
354 /* This is fine since we don't support multiple AP interfaces */
355 sta
= ieee80211_find_sta_by_ifaddr(mvm
->hw
, hdr
->addr2
, NULL
);
357 struct iwl_mvm_sta
*mvmsta
;
358 mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
359 rs_update_last_rssi(mvm
, &mvmsta
->lq_sta
, rx_status
);
361 if (iwl_fw_dbg_trigger_enabled(mvm
->fw
, FW_DBG_TRIGGER_RSSI
) &&
362 ieee80211_is_beacon(hdr
->frame_control
)) {
363 struct iwl_fw_dbg_trigger_tlv
*trig
;
364 struct iwl_fw_dbg_trigger_low_rssi
*rssi_trig
;
368 trig
= iwl_fw_dbg_get_trigger(mvm
->fw
,
369 FW_DBG_TRIGGER_RSSI
);
370 rssi_trig
= (void *)trig
->data
;
371 rssi
= le32_to_cpu(rssi_trig
->rssi
);
374 iwl_fw_dbg_trigger_check_stop(mvm
, mvmsta
->vif
,
376 if (trig_check
&& rx_status
->signal
< rssi
)
377 iwl_mvm_fw_dbg_collect_trig(mvm
, trig
, NULL
);
381 if (sta
&& ieee80211_is_data(hdr
->frame_control
))
382 iwl_mvm_rx_csum(sta
, skb
, rx_pkt_status
);
386 /* set the preamble flag if appropriate */
387 if (phy_info
->phy_flags
& cpu_to_le16(RX_RES_PHY_FLAGS_SHORT_PREAMBLE
))
388 rx_status
->flag
|= RX_FLAG_SHORTPRE
;
390 if (phy_info
->phy_flags
& cpu_to_le16(RX_RES_PHY_FLAGS_AGG
)) {
392 * We know which subframes of an A-MPDU belong
393 * together since we get a single PHY response
394 * from the firmware for all of them
396 rx_status
->flag
|= RX_FLAG_AMPDU_DETAILS
;
397 rx_status
->ampdu_reference
= mvm
->ampdu_ref
;
400 /* Set up the HT phy flags */
401 switch (rate_n_flags
& RATE_MCS_CHAN_WIDTH_MSK
) {
402 case RATE_MCS_CHAN_WIDTH_20
:
404 case RATE_MCS_CHAN_WIDTH_40
:
405 rx_status
->flag
|= RX_FLAG_40MHZ
;
407 case RATE_MCS_CHAN_WIDTH_80
:
408 rx_status
->vht_flag
|= RX_VHT_FLAG_80MHZ
;
410 case RATE_MCS_CHAN_WIDTH_160
:
411 rx_status
->vht_flag
|= RX_VHT_FLAG_160MHZ
;
414 if (rate_n_flags
& RATE_MCS_SGI_MSK
)
415 rx_status
->flag
|= RX_FLAG_SHORT_GI
;
416 if (rate_n_flags
& RATE_HT_MCS_GF_MSK
)
417 rx_status
->flag
|= RX_FLAG_HT_GF
;
418 if (rate_n_flags
& RATE_MCS_LDPC_MSK
)
419 rx_status
->flag
|= RX_FLAG_LDPC
;
420 if (rate_n_flags
& RATE_MCS_HT_MSK
) {
421 u8 stbc
= (rate_n_flags
& RATE_MCS_HT_STBC_MSK
) >>
423 rx_status
->flag
|= RX_FLAG_HT
;
424 rx_status
->rate_idx
= rate_n_flags
& RATE_HT_MCS_INDEX_MSK
;
425 rx_status
->flag
|= stbc
<< RX_FLAG_STBC_SHIFT
;
426 } else if (rate_n_flags
& RATE_MCS_VHT_MSK
) {
427 u8 stbc
= (rate_n_flags
& RATE_MCS_VHT_STBC_MSK
) >>
430 ((rate_n_flags
& RATE_VHT_MCS_NSS_MSK
) >>
431 RATE_VHT_MCS_NSS_POS
) + 1;
432 rx_status
->rate_idx
= rate_n_flags
& RATE_VHT_MCS_RATE_CODE_MSK
;
433 rx_status
->flag
|= RX_FLAG_VHT
;
434 rx_status
->flag
|= stbc
<< RX_FLAG_STBC_SHIFT
;
435 if (rate_n_flags
& RATE_MCS_BF_MSK
)
436 rx_status
->vht_flag
|= RX_VHT_FLAG_BF
;
438 rx_status
->rate_idx
=
439 iwl_mvm_legacy_rate_to_mac80211_idx(rate_n_flags
,
443 #ifdef CONFIG_IWLWIFI_DEBUGFS
444 iwl_mvm_update_frame_stats(mvm
, rate_n_flags
,
445 rx_status
->flag
& RX_FLAG_AMPDU_DETAILS
);
447 iwl_mvm_pass_packet_to_mac80211(mvm
, napi
, skb
, hdr
, len
, ampdu_status
,
451 static void iwl_mvm_update_rx_statistics(struct iwl_mvm
*mvm
,
452 struct mvm_statistics_rx
*rx_stats
)
454 lockdep_assert_held(&mvm
->mutex
);
456 mvm
->rx_stats
= *rx_stats
;
459 struct iwl_mvm_stat_data
{
462 u8 beacon_filter_average_energy
;
463 struct mvm_statistics_general_v8
*general
;
466 static void iwl_mvm_stat_iterator(void *_data
, u8
*mac
,
467 struct ieee80211_vif
*vif
)
469 struct iwl_mvm_stat_data
*data
= _data
;
470 struct iwl_mvm
*mvm
= data
->mvm
;
471 int sig
= -data
->beacon_filter_average_energy
;
473 int thold
= vif
->bss_conf
.cqm_rssi_thold
;
474 int hyst
= vif
->bss_conf
.cqm_rssi_hyst
;
475 u16 id
= le32_to_cpu(data
->mac_id
);
476 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
478 /* This doesn't need the MAC ID check since it's not taking the
479 * data copied into the "data" struct, but rather the data from
480 * the notification directly.
483 mvmvif
->beacon_stats
.num_beacons
=
484 le32_to_cpu(data
->general
->beacon_counter
[mvmvif
->id
]);
485 mvmvif
->beacon_stats
.avg_signal
=
486 -data
->general
->beacon_average_energy
[mvmvif
->id
];
489 if (mvmvif
->id
!= id
)
492 if (vif
->type
!= NL80211_IFTYPE_STATION
)
496 IWL_DEBUG_RX(mvm
, "RSSI is 0 - skip signal based decision\n");
500 mvmvif
->bf_data
.ave_beacon_signal
= sig
;
503 if (mvmvif
->bf_data
.bt_coex_min_thold
!=
504 mvmvif
->bf_data
.bt_coex_max_thold
) {
505 last_event
= mvmvif
->bf_data
.last_bt_coex_event
;
506 if (sig
> mvmvif
->bf_data
.bt_coex_max_thold
&&
507 (last_event
<= mvmvif
->bf_data
.bt_coex_min_thold
||
509 mvmvif
->bf_data
.last_bt_coex_event
= sig
;
510 IWL_DEBUG_RX(mvm
, "cqm_iterator bt coex high %d\n",
512 iwl_mvm_bt_rssi_event(mvm
, vif
, RSSI_EVENT_HIGH
);
513 } else if (sig
< mvmvif
->bf_data
.bt_coex_min_thold
&&
514 (last_event
>= mvmvif
->bf_data
.bt_coex_max_thold
||
516 mvmvif
->bf_data
.last_bt_coex_event
= sig
;
517 IWL_DEBUG_RX(mvm
, "cqm_iterator bt coex low %d\n",
519 iwl_mvm_bt_rssi_event(mvm
, vif
, RSSI_EVENT_LOW
);
523 if (!(vif
->driver_flags
& IEEE80211_VIF_SUPPORTS_CQM_RSSI
))
526 /* CQM Notification */
527 last_event
= mvmvif
->bf_data
.last_cqm_event
;
528 if (thold
&& sig
< thold
&& (last_event
== 0 ||
529 sig
< last_event
- hyst
)) {
530 mvmvif
->bf_data
.last_cqm_event
= sig
;
531 IWL_DEBUG_RX(mvm
, "cqm_iterator cqm low %d\n",
533 ieee80211_cqm_rssi_notify(
535 NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW
,
537 } else if (sig
> thold
&&
538 (last_event
== 0 || sig
> last_event
+ hyst
)) {
539 mvmvif
->bf_data
.last_cqm_event
= sig
;
540 IWL_DEBUG_RX(mvm
, "cqm_iterator cqm high %d\n",
542 ieee80211_cqm_rssi_notify(
544 NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH
,
550 iwl_mvm_rx_stats_check_trigger(struct iwl_mvm
*mvm
, struct iwl_rx_packet
*pkt
)
552 struct iwl_fw_dbg_trigger_tlv
*trig
;
553 struct iwl_fw_dbg_trigger_stats
*trig_stats
;
554 u32 trig_offset
, trig_thold
;
556 if (!iwl_fw_dbg_trigger_enabled(mvm
->fw
, FW_DBG_TRIGGER_STATS
))
559 trig
= iwl_fw_dbg_get_trigger(mvm
->fw
, FW_DBG_TRIGGER_STATS
);
560 trig_stats
= (void *)trig
->data
;
562 if (!iwl_fw_dbg_trigger_check_stop(mvm
, NULL
, trig
))
565 trig_offset
= le32_to_cpu(trig_stats
->stop_offset
);
566 trig_thold
= le32_to_cpu(trig_stats
->stop_threshold
);
568 if (WARN_ON_ONCE(trig_offset
>= iwl_rx_packet_payload_len(pkt
)))
571 if (le32_to_cpup((__le32
*) (pkt
->data
+ trig_offset
)) < trig_thold
)
574 iwl_mvm_fw_dbg_collect_trig(mvm
, trig
, NULL
);
577 void iwl_mvm_handle_rx_statistics(struct iwl_mvm
*mvm
,
578 struct iwl_rx_packet
*pkt
)
580 size_t v8_len
= sizeof(struct iwl_notif_statistics_v8
);
581 size_t v10_len
= sizeof(struct iwl_notif_statistics_v10
);
582 struct iwl_mvm_stat_data data
= {
587 if (fw_has_api(&mvm
->fw
->ucode_capa
, IWL_UCODE_TLV_API_STATS_V10
)) {
588 struct iwl_notif_statistics_v10
*stats
= (void *)&pkt
->data
;
590 if (iwl_rx_packet_payload_len(pkt
) != v10_len
)
593 temperature
= le32_to_cpu(stats
->general
.radio_temperature
);
594 data
.mac_id
= stats
->rx
.general
.mac_id
;
595 data
.beacon_filter_average_energy
=
596 stats
->general
.beacon_filter_average_energy
;
598 iwl_mvm_update_rx_statistics(mvm
, &stats
->rx
);
600 mvm
->radio_stats
.rx_time
= le64_to_cpu(stats
->general
.rx_time
);
601 mvm
->radio_stats
.tx_time
= le64_to_cpu(stats
->general
.tx_time
);
602 mvm
->radio_stats
.on_time_rf
=
603 le64_to_cpu(stats
->general
.on_time_rf
);
604 mvm
->radio_stats
.on_time_scan
=
605 le64_to_cpu(stats
->general
.on_time_scan
);
607 data
.general
= &stats
->general
;
609 struct iwl_notif_statistics_v8
*stats
= (void *)&pkt
->data
;
611 if (iwl_rx_packet_payload_len(pkt
) != v8_len
)
614 temperature
= le32_to_cpu(stats
->general
.radio_temperature
);
615 data
.mac_id
= stats
->rx
.general
.mac_id
;
616 data
.beacon_filter_average_energy
=
617 stats
->general
.beacon_filter_average_energy
;
619 iwl_mvm_update_rx_statistics(mvm
, &stats
->rx
);
622 iwl_mvm_rx_stats_check_trigger(mvm
, pkt
);
624 ieee80211_iterate_active_interfaces(mvm
->hw
,
625 IEEE80211_IFACE_ITER_NORMAL
,
626 iwl_mvm_stat_iterator
,
630 IWL_ERR(mvm
, "received invalid statistics size (%d)!\n",
631 iwl_rx_packet_payload_len(pkt
));
634 void iwl_mvm_rx_statistics(struct iwl_mvm
*mvm
, struct iwl_rx_cmd_buffer
*rxb
)
636 iwl_mvm_handle_rx_statistics(mvm
, rxb_addr(rxb
));