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.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
24 * The full GNU General Public License is included in this distribution
25 * in the file called COPYING.
27 * Contact Information:
28 * Intel Linux Wireless <ilw@linux.intel.com>
29 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
33 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
34 * All rights reserved.
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
40 * * Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * * Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the
46 * * Neither the name Intel Corporation nor the names of its
47 * contributors may be used to endorse or promote products derived
48 * from this software without specific prior written permission.
50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61 *****************************************************************************/
62 #include "iwl-trans.h"
68 * iwl_mvm_rx_rx_phy_cmd - REPLY_RX_PHY_CMD handler
70 * Copies the phy information in mvm->last_phy_info, it will be used when the
71 * actual data will come from the fw in the next packet.
73 int iwl_mvm_rx_rx_phy_cmd(struct iwl_mvm
*mvm
, struct iwl_rx_cmd_buffer
*rxb
,
74 struct iwl_device_cmd
*cmd
)
76 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
78 memcpy(&mvm
->last_phy_info
, pkt
->data
, sizeof(mvm
->last_phy_info
));
81 #ifdef CONFIG_IWLWIFI_DEBUGFS
82 if (mvm
->last_phy_info
.phy_flags
& cpu_to_le16(RX_RES_PHY_FLAGS_AGG
)) {
83 spin_lock(&mvm
->drv_stats_lock
);
84 mvm
->drv_rx_stats
.ampdu_count
++;
85 spin_unlock(&mvm
->drv_stats_lock
);
93 * iwl_mvm_pass_packet_to_mac80211 - builds the packet for mac80211
95 * Adds the rxb to a new skb and give it to mac80211
97 static void iwl_mvm_pass_packet_to_mac80211(struct iwl_mvm
*mvm
,
98 struct ieee80211_hdr
*hdr
, u16 len
,
100 struct iwl_rx_cmd_buffer
*rxb
,
101 struct ieee80211_rx_status
*stats
)
104 unsigned int hdrlen
, fraglen
;
106 /* Dont use dev_alloc_skb(), we'll have enough headroom once
107 * ieee80211_hdr pulled.
109 skb
= alloc_skb(128, GFP_ATOMIC
);
111 IWL_ERR(mvm
, "alloc_skb failed\n");
114 /* If frame is small enough to fit in skb->head, pull it completely.
115 * If not, only pull ieee80211_hdr so that splice() or TCP coalesce
116 * are more efficient.
118 hdrlen
= (len
<= skb_tailroom(skb
)) ? len
: sizeof(*hdr
);
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 memcpy(IEEE80211_SKB_RXCB(skb
), stats
, sizeof(*stats
));
133 ieee80211_rx_ni(mvm
->hw
, skb
);
136 static void iwl_mvm_calc_rssi(struct iwl_mvm
*mvm
,
137 struct iwl_rx_phy_info
*phy_info
,
138 struct ieee80211_rx_status
*rx_status
)
140 int rssi_a
, rssi_b
, rssi_a_dbm
, rssi_b_dbm
, max_rssi_dbm
;
144 val
= le32_to_cpu(phy_info
->non_cfg_phy
[IWL_RX_INFO_AGC_IDX
]);
145 agc_a
= (val
& IWL_OFDM_AGC_A_MSK
) >> IWL_OFDM_AGC_A_POS
;
146 agc_b
= (val
& IWL_OFDM_AGC_B_MSK
) >> IWL_OFDM_AGC_B_POS
;
148 val
= le32_to_cpu(phy_info
->non_cfg_phy
[IWL_RX_INFO_RSSI_AB_IDX
]);
149 rssi_a
= (val
& IWL_OFDM_RSSI_INBAND_A_MSK
) >> IWL_OFDM_RSSI_A_POS
;
150 rssi_b
= (val
& IWL_OFDM_RSSI_INBAND_B_MSK
) >> IWL_OFDM_RSSI_B_POS
;
153 * dBm = rssi dB - agc dB - constant.
154 * Higher AGC (higher radio gain) means lower signal.
156 rssi_a_dbm
= rssi_a
- IWL_RSSI_OFFSET
- agc_a
;
157 rssi_b_dbm
= rssi_b
- IWL_RSSI_OFFSET
- agc_b
;
158 max_rssi_dbm
= max_t(int, rssi_a_dbm
, rssi_b_dbm
);
160 IWL_DEBUG_STATS(mvm
, "Rssi In A %d B %d Max %d AGCA %d AGCB %d\n",
161 rssi_a_dbm
, rssi_b_dbm
, max_rssi_dbm
, agc_a
, agc_b
);
163 rx_status
->signal
= max_rssi_dbm
;
164 rx_status
->chains
= (le16_to_cpu(phy_info
->phy_flags
) &
165 RX_RES_PHY_FLAGS_ANTENNA
)
166 >> RX_RES_PHY_FLAGS_ANTENNA_POS
;
167 rx_status
->chain_signal
[0] = rssi_a_dbm
;
168 rx_status
->chain_signal
[1] = rssi_b_dbm
;
172 * iwl_mvm_get_signal_strength - use new rx PHY INFO API
173 * values are reported by the fw as positive values - need to negate
174 * to obtain their dBM. Account for missing antennas by replacing 0
175 * values by -256dBm: practically 0 power and a non-feasible 8 bit value.
177 static void iwl_mvm_get_signal_strength(struct iwl_mvm
*mvm
,
178 struct iwl_rx_phy_info
*phy_info
,
179 struct ieee80211_rx_status
*rx_status
)
181 int energy_a
, energy_b
, energy_c
, max_energy
;
185 le32_to_cpu(phy_info
->non_cfg_phy
[IWL_RX_INFO_ENERGY_ANT_ABC_IDX
]);
186 energy_a
= (val
& IWL_RX_INFO_ENERGY_ANT_A_MSK
) >>
187 IWL_RX_INFO_ENERGY_ANT_A_POS
;
188 energy_a
= energy_a
? -energy_a
: -256;
189 energy_b
= (val
& IWL_RX_INFO_ENERGY_ANT_B_MSK
) >>
190 IWL_RX_INFO_ENERGY_ANT_B_POS
;
191 energy_b
= energy_b
? -energy_b
: -256;
192 energy_c
= (val
& IWL_RX_INFO_ENERGY_ANT_C_MSK
) >>
193 IWL_RX_INFO_ENERGY_ANT_C_POS
;
194 energy_c
= energy_c
? -energy_c
: -256;
195 max_energy
= max(energy_a
, energy_b
);
196 max_energy
= max(max_energy
, energy_c
);
198 IWL_DEBUG_STATS(mvm
, "energy In A %d B %d C %d , and max %d\n",
199 energy_a
, energy_b
, energy_c
, max_energy
);
201 rx_status
->signal
= max_energy
;
202 rx_status
->chains
= (le16_to_cpu(phy_info
->phy_flags
) &
203 RX_RES_PHY_FLAGS_ANTENNA
)
204 >> RX_RES_PHY_FLAGS_ANTENNA_POS
;
205 rx_status
->chain_signal
[0] = energy_a
;
206 rx_status
->chain_signal
[1] = energy_b
;
207 rx_status
->chain_signal
[2] = energy_c
;
211 * iwl_mvm_set_mac80211_rx_flag - translate fw status to mac80211 format
212 * @mvm: the mvm object
214 * @stats: status in mac80211's format
215 * @rx_pkt_status: status coming from fw
217 * returns non 0 value if the packet should be dropped
219 static u32
iwl_mvm_set_mac80211_rx_flag(struct iwl_mvm
*mvm
,
220 struct ieee80211_hdr
*hdr
,
221 struct ieee80211_rx_status
*stats
,
224 if (!ieee80211_has_protected(hdr
->frame_control
) ||
225 (rx_pkt_status
& RX_MPDU_RES_STATUS_SEC_ENC_MSK
) ==
226 RX_MPDU_RES_STATUS_SEC_NO_ENC
)
229 /* packet was encrypted with unknown alg */
230 if ((rx_pkt_status
& RX_MPDU_RES_STATUS_SEC_ENC_MSK
) ==
231 RX_MPDU_RES_STATUS_SEC_ENC_ERR
)
234 switch (rx_pkt_status
& RX_MPDU_RES_STATUS_SEC_ENC_MSK
) {
235 case RX_MPDU_RES_STATUS_SEC_CCM_ENC
:
236 /* alg is CCM: check MIC only */
237 if (!(rx_pkt_status
& RX_MPDU_RES_STATUS_MIC_OK
))
240 stats
->flag
|= RX_FLAG_DECRYPTED
;
241 IWL_DEBUG_WEP(mvm
, "hw decrypted CCMP successfully\n");
244 case RX_MPDU_RES_STATUS_SEC_TKIP_ENC
:
245 /* Don't drop the frame and decrypt it in SW */
246 if (!(rx_pkt_status
& RX_MPDU_RES_STATUS_TTAK_OK
))
248 /* fall through if TTAK OK */
250 case RX_MPDU_RES_STATUS_SEC_WEP_ENC
:
251 if (!(rx_pkt_status
& RX_MPDU_RES_STATUS_ICV_OK
))
254 stats
->flag
|= RX_FLAG_DECRYPTED
;
257 case RX_MPDU_RES_STATUS_SEC_EXT_ENC
:
258 if (!(rx_pkt_status
& RX_MPDU_RES_STATUS_MIC_OK
))
260 stats
->flag
|= RX_FLAG_DECRYPTED
;
264 IWL_ERR(mvm
, "Unhandled alg: 0x%x\n", rx_pkt_status
);
271 * iwl_mvm_rx_rx_mpdu - REPLY_RX_MPDU_CMD handler
273 * Handles the actual data of the Rx packet from the fw
275 int iwl_mvm_rx_rx_mpdu(struct iwl_mvm
*mvm
, struct iwl_rx_cmd_buffer
*rxb
,
276 struct iwl_device_cmd
*cmd
)
278 struct ieee80211_hdr
*hdr
;
279 struct ieee80211_rx_status rx_status
= {};
280 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
281 struct iwl_rx_phy_info
*phy_info
;
282 struct iwl_rx_mpdu_res_start
*rx_res
;
288 phy_info
= &mvm
->last_phy_info
;
289 rx_res
= (struct iwl_rx_mpdu_res_start
*)pkt
->data
;
290 hdr
= (struct ieee80211_hdr
*)(pkt
->data
+ sizeof(*rx_res
));
291 len
= le16_to_cpu(rx_res
->byte_count
);
292 rx_pkt_status
= le32_to_cpup((__le32
*)
293 (pkt
->data
+ sizeof(*rx_res
) + len
));
295 memset(&rx_status
, 0, sizeof(rx_status
));
298 * drop the packet if it has failed being decrypted by HW
300 if (iwl_mvm_set_mac80211_rx_flag(mvm
, hdr
, &rx_status
, rx_pkt_status
)) {
301 IWL_DEBUG_DROP(mvm
, "Bad decryption results 0x%08x\n",
306 if ((unlikely(phy_info
->cfg_phy_cnt
> 20))) {
307 IWL_DEBUG_DROP(mvm
, "dsp size out of range [0,20]: %d\n",
308 phy_info
->cfg_phy_cnt
);
313 * Keep packets with CRC errors (and with overrun) for monitor mode
314 * (otherwise the firmware discards them) but mark them as bad.
316 if (!(rx_pkt_status
& RX_MPDU_RES_STATUS_CRC_OK
) ||
317 !(rx_pkt_status
& RX_MPDU_RES_STATUS_OVERRUN_OK
)) {
318 IWL_DEBUG_RX(mvm
, "Bad CRC or FIFO: 0x%08X.\n", rx_pkt_status
);
319 rx_status
.flag
|= RX_FLAG_FAILED_FCS_CRC
;
322 /* This will be used in several places later */
323 rate_n_flags
= le32_to_cpu(phy_info
->rate_n_flags
);
325 /* rx_status carries information about the packet to mac80211 */
326 rx_status
.mactime
= le64_to_cpu(phy_info
->timestamp
);
327 rx_status
.device_timestamp
= le32_to_cpu(phy_info
->system_timestamp
);
329 (phy_info
->phy_flags
& cpu_to_le16(RX_RES_PHY_FLAGS_BAND_24
)) ?
330 IEEE80211_BAND_2GHZ
: IEEE80211_BAND_5GHZ
;
332 ieee80211_channel_to_frequency(le16_to_cpu(phy_info
->channel
),
335 * TSF as indicated by the fw is at INA time, but mac80211 expects the
336 * TSF at the beginning of the MPDU.
338 /*rx_status.flag |= RX_FLAG_MACTIME_MPDU;*/
340 if (mvm
->fw
->ucode_capa
.flags
& IWL_UCODE_TLV_FLAGS_RX_ENERGY_API
)
341 iwl_mvm_get_signal_strength(mvm
, phy_info
, &rx_status
);
343 iwl_mvm_calc_rssi(mvm
, phy_info
, &rx_status
);
345 IWL_DEBUG_STATS_LIMIT(mvm
, "Rssi %d, TSF %llu\n", rx_status
.signal
,
346 (unsigned long long)rx_status
.mactime
);
348 /* set the preamble flag if appropriate */
349 if (phy_info
->phy_flags
& cpu_to_le16(RX_RES_PHY_FLAGS_SHORT_PREAMBLE
))
350 rx_status
.flag
|= RX_FLAG_SHORTPRE
;
352 if (phy_info
->phy_flags
& cpu_to_le16(RX_RES_PHY_FLAGS_AGG
)) {
354 * We know which subframes of an A-MPDU belong
355 * together since we get a single PHY response
356 * from the firmware for all of them
358 rx_status
.flag
|= RX_FLAG_AMPDU_DETAILS
;
359 rx_status
.ampdu_reference
= mvm
->ampdu_ref
;
362 /* Set up the HT phy flags */
363 switch (rate_n_flags
& RATE_MCS_CHAN_WIDTH_MSK
) {
364 case RATE_MCS_CHAN_WIDTH_20
:
366 case RATE_MCS_CHAN_WIDTH_40
:
367 rx_status
.flag
|= RX_FLAG_40MHZ
;
369 case RATE_MCS_CHAN_WIDTH_80
:
370 rx_status
.vht_flag
|= RX_VHT_FLAG_80MHZ
;
372 case RATE_MCS_CHAN_WIDTH_160
:
373 rx_status
.vht_flag
|= RX_VHT_FLAG_160MHZ
;
376 if (rate_n_flags
& RATE_MCS_SGI_MSK
)
377 rx_status
.flag
|= RX_FLAG_SHORT_GI
;
378 if (rate_n_flags
& RATE_HT_MCS_GF_MSK
)
379 rx_status
.flag
|= RX_FLAG_HT_GF
;
380 if (rate_n_flags
& RATE_MCS_LDPC_MSK
)
381 rx_status
.flag
|= RX_FLAG_LDPC
;
382 if (rate_n_flags
& RATE_MCS_HT_MSK
) {
383 u8 stbc
= (rate_n_flags
& RATE_MCS_HT_STBC_MSK
) >>
385 rx_status
.flag
|= RX_FLAG_HT
;
386 rx_status
.rate_idx
= rate_n_flags
& RATE_HT_MCS_INDEX_MSK
;
387 rx_status
.flag
|= stbc
<< RX_FLAG_STBC_SHIFT
;
388 } else if (rate_n_flags
& RATE_MCS_VHT_MSK
) {
389 u8 stbc
= (rate_n_flags
& RATE_MCS_VHT_STBC_MSK
) >>
392 ((rate_n_flags
& RATE_VHT_MCS_NSS_MSK
) >>
393 RATE_VHT_MCS_NSS_POS
) + 1;
394 rx_status
.rate_idx
= rate_n_flags
& RATE_VHT_MCS_RATE_CODE_MSK
;
395 rx_status
.flag
|= RX_FLAG_VHT
;
396 rx_status
.flag
|= stbc
<< RX_FLAG_STBC_SHIFT
;
399 iwl_mvm_legacy_rate_to_mac80211_idx(rate_n_flags
,
403 #ifdef CONFIG_IWLWIFI_DEBUGFS
404 iwl_mvm_update_frame_stats(mvm
, &mvm
->drv_rx_stats
, rate_n_flags
,
405 rx_status
.flag
& RX_FLAG_AMPDU_DETAILS
);
407 iwl_mvm_pass_packet_to_mac80211(mvm
, hdr
, len
, ampdu_status
,
412 static void iwl_mvm_update_rx_statistics(struct iwl_mvm
*mvm
,
413 struct iwl_notif_statistics
*stats
)
416 * NOTE FW aggregates the statistics - BUT the statistics are cleared
417 * when the driver issues REPLY_STATISTICS_CMD 0x9c with CLEAR_STATS
420 lockdep_assert_held(&mvm
->mutex
);
421 memcpy(&mvm
->rx_stats
, &stats
->rx
, sizeof(struct mvm_statistics_rx
));
424 struct iwl_mvm_stat_data
{
425 struct iwl_notif_statistics
*stats
;
429 static void iwl_mvm_stat_iterator(void *_data
, u8
*mac
,
430 struct ieee80211_vif
*vif
)
432 struct iwl_mvm_stat_data
*data
= _data
;
433 struct iwl_notif_statistics
*stats
= data
->stats
;
434 struct iwl_mvm
*mvm
= data
->mvm
;
435 int sig
= -stats
->general
.beacon_filter_average_energy
;
437 int thold
= vif
->bss_conf
.cqm_rssi_thold
;
438 int hyst
= vif
->bss_conf
.cqm_rssi_hyst
;
439 u16 id
= le32_to_cpu(stats
->rx
.general
.mac_id
);
440 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
442 if (mvmvif
->id
!= id
)
445 if (vif
->type
!= NL80211_IFTYPE_STATION
)
448 mvmvif
->bf_data
.ave_beacon_signal
= sig
;
451 if (mvmvif
->bf_data
.bt_coex_min_thold
!=
452 mvmvif
->bf_data
.bt_coex_max_thold
) {
453 last_event
= mvmvif
->bf_data
.last_bt_coex_event
;
454 if (sig
> mvmvif
->bf_data
.bt_coex_max_thold
&&
455 (last_event
<= mvmvif
->bf_data
.bt_coex_min_thold
||
457 mvmvif
->bf_data
.last_bt_coex_event
= sig
;
458 IWL_DEBUG_RX(mvm
, "cqm_iterator bt coex high %d\n",
460 iwl_mvm_bt_rssi_event(mvm
, vif
, RSSI_EVENT_HIGH
);
461 } else if (sig
< mvmvif
->bf_data
.bt_coex_min_thold
&&
462 (last_event
>= mvmvif
->bf_data
.bt_coex_max_thold
||
464 mvmvif
->bf_data
.last_bt_coex_event
= sig
;
465 IWL_DEBUG_RX(mvm
, "cqm_iterator bt coex low %d\n",
467 iwl_mvm_bt_rssi_event(mvm
, vif
, RSSI_EVENT_LOW
);
471 if (!(vif
->driver_flags
& IEEE80211_VIF_SUPPORTS_CQM_RSSI
))
474 /* CQM Notification */
475 last_event
= mvmvif
->bf_data
.last_cqm_event
;
476 if (thold
&& sig
< thold
&& (last_event
== 0 ||
477 sig
< last_event
- hyst
)) {
478 mvmvif
->bf_data
.last_cqm_event
= sig
;
479 IWL_DEBUG_RX(mvm
, "cqm_iterator cqm low %d\n",
481 ieee80211_cqm_rssi_notify(
483 NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW
,
485 } else if (sig
> thold
&&
486 (last_event
== 0 || sig
> last_event
+ hyst
)) {
487 mvmvif
->bf_data
.last_cqm_event
= sig
;
488 IWL_DEBUG_RX(mvm
, "cqm_iterator cqm high %d\n",
490 ieee80211_cqm_rssi_notify(
492 NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH
,
498 * iwl_mvm_rx_statistics - STATISTICS_NOTIFICATION handler
500 * TODO: This handler is implemented partially.
502 int iwl_mvm_rx_statistics(struct iwl_mvm
*mvm
,
503 struct iwl_rx_cmd_buffer
*rxb
,
504 struct iwl_device_cmd
*cmd
)
506 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
507 struct iwl_notif_statistics
*stats
= (void *)&pkt
->data
;
508 struct mvm_statistics_general_common
*common
= &stats
->general
.common
;
509 struct iwl_mvm_stat_data data
= {
514 if (mvm
->temperature
!= le32_to_cpu(common
->temperature
)) {
515 mvm
->temperature
= le32_to_cpu(common
->temperature
);
516 iwl_mvm_tt_handler(mvm
);
518 iwl_mvm_update_rx_statistics(mvm
, stats
);
520 ieee80211_iterate_active_interfaces(mvm
->hw
,
521 IEEE80211_IFACE_ITER_NORMAL
,
522 iwl_mvm_stat_iterator
,