projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mac80211: allow passing transmitter station on RX
[linux-2.6-block.git] / drivers / net / wireless / intel / iwlwifi / mvm / mac-ctxt.c
CommitLineData
8ca151b5
JB		 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 *
51368bf7 8 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
8b4139dc 9 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
0db056d3 10 * Copyright(c) 2015 - 2016 Intel Deutschland GmbH
8ca151b5
JB		 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
410dc5aa 27 * in the file called COPYING.
8ca151b5
JB		 28 *
29 * Contact Information:
cb2f8277 30 * Intel Linux Wireless <linuxwifi@intel.com>
8ca151b5
JB		 31 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
32 *
33 * BSD LICENSE
34 *
51368bf7 35 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
8b4139dc 36 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
0db056d3 37 * Copyright(c) 2015 - 2016 Intel Deutschland GmbH
8ca151b5
JB		 38 * All rights reserved.
39 *
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
42 * are met:
43 *
44 * * Redistributions of source code must retain the above copyright
45 * notice, this list of conditions and the following disclaimer.
46 * * Redistributions in binary form must reproduce the above copyright
47 * notice, this list of conditions and the following disclaimer in
48 * the documentation and/or other materials provided with the
49 * distribution.
50 * * Neither the name Intel Corporation nor the names of its
51 * contributors may be used to endorse or promote products derived
52 * from this software without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
55 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
56 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
57 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
58 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
59 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
60 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
61 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
62 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
63 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
64 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
65 *
66 *****************************************************************************/
67
68#include <linux/etherdevice.h>
69#include <net/mac80211.h>
70#include "iwl-io.h"
71#include "iwl-prph.h"
72#include "fw-api.h"
73#include "mvm.h"
7f0a7c67 74#include "time-event.h"
2f89a5d7 75#include "fw-dbg.h"
8ca151b5
JB		 76
77const u8 iwl_mvm_ac_to_tx_fifo[] = {
8ca151b5 78 IWL_MVM_TX_FIFO_VO,
3dd94794
EG		 79 IWL_MVM_TX_FIFO_VI,
80 IWL_MVM_TX_FIFO_BE,
81 IWL_MVM_TX_FIFO_BK,
8ca151b5
JB		 82};
83
84struct iwl_mvm_mac_iface_iterator_data {
85 struct iwl_mvm *mvm;
86 struct ieee80211_vif *vif;
87 unsigned long available_mac_ids[BITS_TO_LONGS(NUM_MAC_INDEX_DRIVER)];
88 unsigned long available_tsf_ids[BITS_TO_LONGS(NUM_TSF_IDS)];
8ca151b5
JB		 89 enum iwl_tsf_id preferred_tsf;
90 bool found_vif;
91};
92
a74346d7
AN		 93struct iwl_mvm_hw_queues_iface_iterator_data {
94 struct ieee80211_vif *exclude_vif;
95 unsigned long used_hw_queues;
96};
97
6e97b0d2
IP		 98static void iwl_mvm_mac_tsf_id_iter(void *_data, u8 *mac,
99 struct ieee80211_vif *vif)
8ca151b5
JB		 100{
101 struct iwl_mvm_mac_iface_iterator_data *data = _data;
102 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2c3e62a1 103 u16 min_bi;
8ca151b5 104
6e97b0d2
IP		 105 /* Skip the interface for which we are trying to assign a tsf_id */
106 if (vif == data->vif)
8ca151b5 107 return;
8ca151b5
JB		 108
109 /*
110 * The TSF is a hardware/firmware resource, there are 4 and
111 * the driver should assign and free them as needed. However,
112 * there are cases where 2 MACs should share the same TSF ID
113 * for the purpose of clock sync, an optimization to avoid
114 * clock drift causing overlapping TBTTs/DTIMs for a GO and
115 * client in the system.
116 *
117 * The firmware will decide according to the MAC type which
118 * will be the master and slave. Clients that need to sync
119 * with a remote station will be the master, and an AP or GO
120 * will be the slave.
121 *
122 * Depending on the new interface type it can be slaved to
123 * or become the master of an existing interface.
124 */
125 switch (data->vif->type) {
126 case NL80211_IFTYPE_STATION:
127 /*
2c3e62a1
IP		 128 * The new interface is a client, so if the one we're iterating
129 * is an AP, and the beacon interval of the AP is a multiple or
130 * divisor of the beacon interval of the client, the same TSF
131 * should be used to avoid drift between the new client and
132 * existing AP. The existing AP will get drift updates from the
133 * new client context in this case.
8ca151b5 134 */
2c3e62a1
IP		 135 if (vif->type != NL80211_IFTYPE_AP ||
136 data->preferred_tsf != NUM_TSF_IDS ||
137 !test_bit(mvmvif->tsf_id, data->available_tsf_ids))
138 break;
139
140 min_bi = min(data->vif->bss_conf.beacon_int,
141 vif->bss_conf.beacon_int);
142
143 if (!min_bi)
144 break;
145
146 if ((data->vif->bss_conf.beacon_int -
147 vif->bss_conf.beacon_int) % min_bi == 0) {
148 data->preferred_tsf = mvmvif->tsf_id;
149 return;
8ca151b5
JB		 150 }
151 break;
2c3e62a1 152
8ca151b5
JB		 153 case NL80211_IFTYPE_AP:
154 /*
2c3e62a1
IP		 155 * The new interface is AP/GO, so if its beacon interval is a
156 * multiple or a divisor of the beacon interval of an existing
157 * interface, it should get drift updates from an existing
158 * client or use the same TSF as an existing GO. There's no
159 * drift between TSFs internally but if they used different
160 * TSFs then a new client MAC could update one of them and
161 * cause drift that way.
8ca151b5 162 */
2c3e62a1
IP		 163 if ((vif->type != NL80211_IFTYPE_AP &&
164 vif->type != NL80211_IFTYPE_STATION) ||
165 data->preferred_tsf != NUM_TSF_IDS ||
166 !test_bit(mvmvif->tsf_id, data->available_tsf_ids))
167 break;
168
169 min_bi = min(data->vif->bss_conf.beacon_int,
170 vif->bss_conf.beacon_int);
171
172 if (!min_bi)
173 break;
174
175 if ((data->vif->bss_conf.beacon_int -
176 vif->bss_conf.beacon_int) % min_bi == 0) {
177 data->preferred_tsf = mvmvif->tsf_id;
178 return;
8ca151b5
JB		 179 }
180 break;
181 default:
182 /*
183 * For all other interface types there's no need to
184 * take drift into account. Either they're exclusive
185 * like IBSS and monitor, or we don't care much about
186 * their TSF (like P2P Device), but we won't be able
187 * to share the TSF resource.
188 */
189 break;
190 }
191
192 /*
193 * Unless we exited above, we can't share the TSF resource
194 * that the virtual interface we're iterating over is using
195 * with the new one, so clear the available bit and if this
196 * was the preferred one, reset that as well.
197 */
198 __clear_bit(mvmvif->tsf_id, data->available_tsf_ids);
199
200 if (data->preferred_tsf == mvmvif->tsf_id)
201 data->preferred_tsf = NUM_TSF_IDS;
202}
203
110cf810
JB		 204/*
205 * Get the mask of the queues used by the vif
206 */
d92b732e 207u32 iwl_mvm_mac_get_queues_mask(struct ieee80211_vif *vif)
110cf810
JB		 208{
209 u32 qmask = 0, ac;
210
211 if (vif->type == NL80211_IFTYPE_P2P_DEVICE)
212 return BIT(IWL_MVM_OFFCHANNEL_QUEUE);
213
1008e442
IP		 214 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
215 if (vif->hw_queue[ac] != IEEE80211_INVAL_HW_QUEUE)
216 qmask |= BIT(vif->hw_queue[ac]);
217 }
110cf810
JB		 218
219 if (vif->type == NL80211_IFTYPE_AP)
220 qmask |= BIT(vif->cab_queue);
221
222 return qmask;
223}
224
a74346d7
AN		 225static void iwl_mvm_iface_hw_queues_iter(void *_data, u8 *mac,
226 struct ieee80211_vif *vif)
227{
228 struct iwl_mvm_hw_queues_iface_iterator_data *data = _data;
229
230 /* exclude the given vif */
231 if (vif == data->exclude_vif)
232 return;
233
234 data->used_hw_queues |= iwl_mvm_mac_get_queues_mask(vif);
235}
236
237static void iwl_mvm_mac_sta_hw_queues_iter(void *_data,
238 struct ieee80211_sta *sta)
239{
240 struct iwl_mvm_hw_queues_iface_iterator_data *data = _data;
241 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
242
243 /* Mark the queues used by the sta */
244 data->used_hw_queues |= mvmsta->tfd_queue_msk;
245}
246
247unsigned long iwl_mvm_get_used_hw_queues(struct iwl_mvm *mvm,
248 struct ieee80211_vif *exclude_vif)
249{
51ec09af 250 u8 sta_id;
a74346d7
AN		 251 struct iwl_mvm_hw_queues_iface_iterator_data data = {
252 .exclude_vif = exclude_vif,
253 .used_hw_queues =
254 BIT(IWL_MVM_OFFCHANNEL_QUEUE) |
255 BIT(mvm->aux_queue) |
256 BIT(IWL_MVM_CMD_QUEUE),
257 };
258
259 lockdep_assert_held(&mvm->mutex);
260
261 /* mark all VIF used hw queues */
262 ieee80211_iterate_active_interfaces_atomic(
263 mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
264 iwl_mvm_iface_hw_queues_iter, &data);
265
266 /* don't assign the same hw queues as TDLS stations */
267 ieee80211_iterate_stations_atomic(mvm->hw,
268 iwl_mvm_mac_sta_hw_queues_iter,
269 &data);
270
51ec09af
AN		 271 /*
272 * Some TDLS stations may be removed but are in the process of being
273 * drained. Don't touch their queues.
274 */
275 for_each_set_bit(sta_id, mvm->sta_drained, IWL_MVM_STATION_COUNT)
276 data.used_hw_queues |= mvm->tfd_drained[sta_id];
277
a74346d7
AN		 278 return data.used_hw_queues;
279}
280
6e97b0d2
IP		 281static void iwl_mvm_mac_iface_iterator(void *_data, u8 *mac,
282 struct ieee80211_vif *vif)
283{
284 struct iwl_mvm_mac_iface_iterator_data *data = _data;
285 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
6e97b0d2
IP		 286
287 /* Iterator may already find the interface being added -- skip it */
288 if (vif == data->vif) {
289 data->found_vif = true;
290 return;
291 }
292
6e97b0d2
IP		 293 /* Mark MAC IDs as used by clearing the available bit, and
294 * (below) mark TSFs as used if their existing use is not
295 * compatible with the new interface type.
296 * No locking or atomic bit operations are needed since the
297 * data is on the stack of the caller function.
298 */
299 __clear_bit(mvmvif->id, data->available_mac_ids);
300
301 /* find a suitable tsf_id */
302 iwl_mvm_mac_tsf_id_iter(_data, mac, vif);
303}
304
6e97b0d2
IP		 305void iwl_mvm_mac_ctxt_recalc_tsf_id(struct iwl_mvm *mvm,
306 struct ieee80211_vif *vif)
307{
308 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
309 struct iwl_mvm_mac_iface_iterator_data data = {
310 .mvm = mvm,
311 .vif = vif,
312 .available_tsf_ids = { (1 << NUM_TSF_IDS) - 1 },
313 /* no preference yet */
314 .preferred_tsf = NUM_TSF_IDS,
315 };
316
317 ieee80211_iterate_active_interfaces_atomic(
318 mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
319 iwl_mvm_mac_tsf_id_iter, &data);
320
321 if (data.preferred_tsf != NUM_TSF_IDS)
322 mvmvif->tsf_id = data.preferred_tsf;
323 else if (!test_bit(mvmvif->tsf_id, data.available_tsf_ids))
324 mvmvif->tsf_id = find_first_bit(data.available_tsf_ids,
325 NUM_TSF_IDS);
326}
327
8ca151b5
JB		 328static int iwl_mvm_mac_ctxt_allocate_resources(struct iwl_mvm *mvm,
329 struct ieee80211_vif *vif)
330{
331 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
332 struct iwl_mvm_mac_iface_iterator_data data = {
333 .mvm = mvm,
334 .vif = vif,
335 .available_mac_ids = { (1 << NUM_MAC_INDEX_DRIVER) - 1 },
336 .available_tsf_ids = { (1 << NUM_TSF_IDS) - 1 },
337 /* no preference yet */
338 .preferred_tsf = NUM_TSF_IDS,
8ca151b5
JB		 339 .found_vif = false,
340 };
341 u32 ac;
9ee718aa 342 int ret, i;
110cf810 343 unsigned long used_hw_queues;
8ca151b5
JB		 344
345 /*
346 * Allocate a MAC ID and a TSF for this MAC, along with the queues
347 * and other resources.
348 */
349
350 /*
351 * Before the iterator, we start with all MAC IDs and TSFs available.
352 *
353 * During iteration, all MAC IDs are cleared that are in use by other
354 * virtual interfaces, and all TSF IDs are cleared that can't be used
355 * by this new virtual interface because they're used by an interface
356 * that can't share it with the new one.
357 * At the same time, we check if there's a preferred TSF in the case
358 * that we should share it with another interface.
359 */
360
5023d966
JB		 361 /* Currently, MAC ID 0 should be used only for the managed/IBSS vif */
362 switch (vif->type) {
363 case NL80211_IFTYPE_ADHOC:
364 break;
365 case NL80211_IFTYPE_STATION:
366 if (!vif->p2p)
367 break;
368 /* fall through */
369 default:
ec8b6885 370 __clear_bit(0, data.available_mac_ids);
5023d966 371 }
ec8b6885 372
8ca151b5
JB		 373 ieee80211_iterate_active_interfaces_atomic(
374 mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
375 iwl_mvm_mac_iface_iterator, &data);
376
a74346d7
AN		 377 used_hw_queues = iwl_mvm_get_used_hw_queues(mvm, vif);
378
8ca151b5
JB		 379 /*
380 * In the case we're getting here during resume, it's similar to
381 * firmware restart, and with RESUME_ALL the iterator will find
382 * the vif being added already.
383 * We don't want to reassign any IDs in either case since doing
384 * so would probably assign different IDs (as interfaces aren't
385 * necessarily added in the same order), but the old IDs were
386 * preserved anyway, so skip ID assignment for both resume and
387 * recovery.
388 */
389 if (data.found_vif)
390 return 0;
391
392 /* Therefore, in recovery, we can't get here */
fd11bd05
IP		 393 if (WARN_ON_ONCE(test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)))
394 return -EBUSY;
8ca151b5
JB		 395
396 mvmvif->id = find_first_bit(data.available_mac_ids,
397 NUM_MAC_INDEX_DRIVER);
398 if (mvmvif->id == NUM_MAC_INDEX_DRIVER) {
399 IWL_ERR(mvm, "Failed to init MAC context - no free ID!\n");
400 ret = -EIO;
401 goto exit_fail;
402 }
403
404 if (data.preferred_tsf != NUM_TSF_IDS)
405 mvmvif->tsf_id = data.preferred_tsf;
406 else
407 mvmvif->tsf_id = find_first_bit(data.available_tsf_ids,
408 NUM_TSF_IDS);
409 if (mvmvif->tsf_id == NUM_TSF_IDS) {
410 IWL_ERR(mvm, "Failed to init MAC context - no free TSF!\n");
411 ret = -EIO;
412 goto exit_fail;
413 }
414
415 mvmvif->color = 0;
416
1e849c93
IP		 417 INIT_LIST_HEAD(&mvmvif->time_event_data.list);
418 mvmvif->time_event_data.id = TE_MAX;
419
8ca151b5
JB		 420 /* No need to allocate data queues to P2P Device MAC.*/
421 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
422 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
423 vif->hw_queue[ac] = IEEE80211_INVAL_HW_QUEUE;
424
425 return 0;
426 }
427
428 /* Find available queues, and allocate them to the ACs */
429 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
110cf810 430 u8 queue = find_first_zero_bit(&used_hw_queues,
19e737c9 431 mvm->first_agg_queue);
8ca151b5 432
19e737c9 433 if (queue >= mvm->first_agg_queue) {
8ca151b5
JB		 434 IWL_ERR(mvm, "Failed to allocate queue\n");
435 ret = -EIO;
436 goto exit_fail;
437 }
438
110cf810 439 __set_bit(queue, &used_hw_queues);
8ca151b5
JB		 440 vif->hw_queue[ac] = queue;
441 }
442
443 /* Allocate the CAB queue for softAP and GO interfaces */
444 if (vif->type == NL80211_IFTYPE_AP) {
110cf810 445 u8 queue = find_first_zero_bit(&used_hw_queues,
19e737c9 446 mvm->first_agg_queue);
8ca151b5 447
19e737c9 448 if (queue >= mvm->first_agg_queue) {
8ca151b5
JB		 449 IWL_ERR(mvm, "Failed to allocate cab queue\n");
450 ret = -EIO;
451 goto exit_fail;
452 }
453
454 vif->cab_queue = queue;
455 } else {
456 vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
457 }
458
459 mvmvif->bcast_sta.sta_id = IWL_MVM_STATION_COUNT;
460 mvmvif->ap_sta_id = IWL_MVM_STATION_COUNT;
461
9ee718aa
EL		 462 for (i = 0; i < NUM_IWL_MVM_SMPS_REQ; i++)
463 mvmvif->smps_requests[i] = IEEE80211_SMPS_AUTOMATIC;
464
8ca151b5
JB		 465 return 0;
466
467exit_fail:
468 memset(mvmvif, 0, sizeof(struct iwl_mvm_vif));
469 memset(vif->hw_queue, IEEE80211_INVAL_HW_QUEUE, sizeof(vif->hw_queue));
470 vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
471 return ret;
472}
473
474int iwl_mvm_mac_ctxt_init(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
475{
5d42e7b2
EG		 476 unsigned int wdg_timeout =
477 iwl_mvm_get_wd_timeout(mvm, vif, false, false);
8ca151b5
JB		 478 u32 ac;
479 int ret;
480
481 lockdep_assert_held(&mvm->mutex);
482
483 ret = iwl_mvm_mac_ctxt_allocate_resources(mvm, vif);
484 if (ret)
485 return ret;
486
487 switch (vif->type) {
488 case NL80211_IFTYPE_P2P_DEVICE:
3edf8ff6 489 iwl_mvm_enable_ac_txq(mvm, IWL_MVM_OFFCHANNEL_QUEUE,
4ecafae9 490 IWL_MVM_OFFCHANNEL_QUEUE,
5c1156ef 491 IWL_MVM_TX_FIFO_VO, 0, wdg_timeout);
8ca151b5
JB		 492 break;
493 case NL80211_IFTYPE_AP:
4ecafae9 494 iwl_mvm_enable_ac_txq(mvm, vif->cab_queue, vif->cab_queue,
5c1156ef 495 IWL_MVM_TX_FIFO_MCAST, 0, wdg_timeout);
8ca151b5
JB		 496 /* fall through */
497 default:
498 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
3edf8ff6 499 iwl_mvm_enable_ac_txq(mvm, vif->hw_queue[ac],
4ecafae9 500 vif->hw_queue[ac],
5c1156ef 501 iwl_mvm_ac_to_tx_fifo[ac], 0,
4cf677fd 502 wdg_timeout);
8ca151b5
JB		 503 break;
504 }
505
506 return 0;
507}
508
509void iwl_mvm_mac_ctxt_release(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
510{
511 int ac;
512
513 lockdep_assert_held(&mvm->mutex);
514
515 switch (vif->type) {
516 case NL80211_IFTYPE_P2P_DEVICE:
4ecafae9
LK		 517 iwl_mvm_disable_txq(mvm, IWL_MVM_OFFCHANNEL_QUEUE,
518 IWL_MVM_OFFCHANNEL_QUEUE, IWL_MAX_TID_COUNT,
519 0);
8ca151b5
JB		 520 break;
521 case NL80211_IFTYPE_AP:
4ecafae9
LK		 522 iwl_mvm_disable_txq(mvm, vif->cab_queue, vif->cab_queue,
523 IWL_MAX_TID_COUNT, 0);
8ca151b5
JB		 524 /* fall through */
525 default:
526 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
4ecafae9
LK		 527 iwl_mvm_disable_txq(mvm, vif->hw_queue[ac],
528 vif->hw_queue[ac],
529 IWL_MAX_TID_COUNT, 0);
8ca151b5
JB		 530 }
531}
532
533static void iwl_mvm_ack_rates(struct iwl_mvm *mvm,
534 struct ieee80211_vif *vif,
535 enum ieee80211_band band,
536 u8 *cck_rates, u8 *ofdm_rates)
537{
538 struct ieee80211_supported_band *sband;
539 unsigned long basic = vif->bss_conf.basic_rates;
540 int lowest_present_ofdm = 100;
541 int lowest_present_cck = 100;
542 u8 cck = 0;
543 u8 ofdm = 0;
544 int i;
545
546 sband = mvm->hw->wiphy->bands[band];
547
548 for_each_set_bit(i, &basic, BITS_PER_LONG) {
549 int hw = sband->bitrates[i].hw_value;
550 if (hw >= IWL_FIRST_OFDM_RATE) {
551 ofdm |= BIT(hw - IWL_FIRST_OFDM_RATE);
552 if (lowest_present_ofdm > hw)
553 lowest_present_ofdm = hw;
554 } else {
555 BUILD_BUG_ON(IWL_FIRST_CCK_RATE != 0);
556
557 cck |= BIT(hw);
558 if (lowest_present_cck > hw)
559 lowest_present_cck = hw;
560 }
561 }
562
563 /*
564 * Now we've got the basic rates as bitmaps in the ofdm and cck
565 * variables. This isn't sufficient though, as there might not
566 * be all the right rates in the bitmap. E.g. if the only basic
567 * rates are 5.5 Mbps and 11 Mbps, we still need to add 1 Mbps
568 * and 6 Mbps because the 802.11-2007 standard says in 9.6:
569 *
570 * [...] a STA responding to a received frame shall transmit
571 * its Control Response frame [...] at the highest rate in the
572 * BSSBasicRateSet parameter that is less than or equal to the
573 * rate of the immediately previous frame in the frame exchange
574 * sequence ([...]) and that is of the same modulation class
575 * ([...]) as the received frame. If no rate contained in the
576 * BSSBasicRateSet parameter meets these conditions, then the
577 * control frame sent in response to a received frame shall be
578 * transmitted at the highest mandatory rate of the PHY that is
579 * less than or equal to the rate of the received frame, and
580 * that is of the same modulation class as the received frame.
581 *
582 * As a consequence, we need to add all mandatory rates that are
583 * lower than all of the basic rates to these bitmaps.
584 */
585
586 if (IWL_RATE_24M_INDEX < lowest_present_ofdm)
587 ofdm |= IWL_RATE_BIT_MSK(24) >> IWL_FIRST_OFDM_RATE;
588 if (IWL_RATE_12M_INDEX < lowest_present_ofdm)
589 ofdm |= IWL_RATE_BIT_MSK(12) >> IWL_FIRST_OFDM_RATE;
590 /* 6M already there or needed so always add */
591 ofdm |= IWL_RATE_BIT_MSK(6) >> IWL_FIRST_OFDM_RATE;
592
593 /*
594 * CCK is a bit more complex with DSSS vs. HR/DSSS vs. ERP.
595 * Note, however:
596 * - if no CCK rates are basic, it must be ERP since there must
597 * be some basic rates at all, so they're OFDM => ERP PHY
598 * (or we're in 5 GHz, and the cck bitmap will never be used)
599 * - if 11M is a basic rate, it must be ERP as well, so add 5.5M
600 * - if 5.5M is basic, 1M and 2M are mandatory
601 * - if 2M is basic, 1M is mandatory
602 * - if 1M is basic, that's the only valid ACK rate.
603 * As a consequence, it's not as complicated as it sounds, just add
604 * any lower rates to the ACK rate bitmap.
605 */
606 if (IWL_RATE_11M_INDEX < lowest_present_cck)
607 cck |= IWL_RATE_BIT_MSK(11) >> IWL_FIRST_CCK_RATE;
608 if (IWL_RATE_5M_INDEX < lowest_present_cck)
609 cck |= IWL_RATE_BIT_MSK(5) >> IWL_FIRST_CCK_RATE;
610 if (IWL_RATE_2M_INDEX < lowest_present_cck)
611 cck |= IWL_RATE_BIT_MSK(2) >> IWL_FIRST_CCK_RATE;
612 /* 1M already there or needed so always add */
613 cck |= IWL_RATE_BIT_MSK(1) >> IWL_FIRST_CCK_RATE;
614
615 *cck_rates = cck;
616 *ofdm_rates = ofdm;
617}
618
8a5e3660
AA		 619static void iwl_mvm_mac_ctxt_set_ht_flags(struct iwl_mvm *mvm,
620 struct ieee80211_vif *vif,
621 struct iwl_mac_ctx_cmd *cmd)
622{
623 /* for both sta and ap, ht_operation_mode hold the protection_mode */
624 u8 protection_mode = vif->bss_conf.ht_operation_mode &
625 IEEE80211_HT_OP_MODE_PROTECTION;
626 /* The fw does not distinguish between ht and fat */
627 u32 ht_flag = MAC_PROT_FLG_HT_PROT | MAC_PROT_FLG_FAT_PROT;
628
629 IWL_DEBUG_RATE(mvm, "protection mode set to %d\n", protection_mode);
630 /*
631 * See section 9.23.3.1 of IEEE 80211-2012.
632 * Nongreenfield HT STAs Present is not supported.
633 */
634 switch (protection_mode) {
635 case IEEE80211_HT_OP_MODE_PROTECTION_NONE:
636 break;
637 case IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER:
638 case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED:
639 cmd->protection_flags |= cpu_to_le32(ht_flag);
640 break;
641 case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ:
642 /* Protect when channel wider than 20MHz */
643 if (vif->bss_conf.chandef.width > NL80211_CHAN_WIDTH_20)
644 cmd->protection_flags |= cpu_to_le32(ht_flag);
645 break;
646 default:
647 IWL_ERR(mvm, "Illegal protection mode %d\n",
648 protection_mode);
649 break;
650 }
651}
652
8ca151b5
JB		 653static void iwl_mvm_mac_ctxt_cmd_common(struct iwl_mvm *mvm,
654 struct ieee80211_vif *vif,
655 struct iwl_mac_ctx_cmd *cmd,
3dfd3a97 656 const u8 *bssid_override,
8ca151b5
JB		 657 u32 action)
658{
659 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
660 struct ieee80211_chanctx_conf *chanctx;
8a5e3660
AA		 661 bool ht_enabled = !!(vif->bss_conf.ht_operation_mode &
662 IEEE80211_HT_OP_MODE_PROTECTION);
8ca151b5 663 u8 cck_ack_rates, ofdm_ack_rates;
3dfd3a97 664 const u8 *bssid = bssid_override ?: vif->bss_conf.bssid;
8ca151b5
JB		 665 int i;
666
667 cmd->id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
668 mvmvif->color));
669 cmd->action = cpu_to_le32(action);
670
671 switch (vif->type) {
672 case NL80211_IFTYPE_STATION:
673 if (vif->p2p)
674 cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_P2P_STA);
675 else
676 cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_BSS_STA);
677 break;
678 case NL80211_IFTYPE_AP:
679 cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_GO);
680 break;
681 case NL80211_IFTYPE_MONITOR:
682 cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_LISTENER);
683 break;
684 case NL80211_IFTYPE_P2P_DEVICE:
685 cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_P2P_DEVICE);
686 break;
687 case NL80211_IFTYPE_ADHOC:
688 cmd->mac_type = cpu_to_le32(FW_MAC_TYPE_IBSS);
689 break;
690 default:
691 WARN_ON_ONCE(1);
692 }
693
694 cmd->tsf_id = cpu_to_le32(mvmvif->tsf_id);
695
696 memcpy(cmd->node_addr, vif->addr, ETH_ALEN);
3dfd3a97
JB		 697
698 if (bssid)
699 memcpy(cmd->bssid_addr, bssid, ETH_ALEN);
8ca151b5
JB		 700 else
701 eth_broadcast_addr(cmd->bssid_addr);
702
703 rcu_read_lock();
704 chanctx = rcu_dereference(vif->chanctx_conf);
705 iwl_mvm_ack_rates(mvm, vif, chanctx ? chanctx->def.chan->band
706 : IEEE80211_BAND_2GHZ,
707 &cck_ack_rates, &ofdm_ack_rates);
708 rcu_read_unlock();
709
710 cmd->cck_rates = cpu_to_le32((u32)cck_ack_rates);
711 cmd->ofdm_rates = cpu_to_le32((u32)ofdm_ack_rates);
712
713 cmd->cck_short_preamble =
714 cpu_to_le32(vif->bss_conf.use_short_preamble ?
715 MAC_FLG_SHORT_PREAMBLE : 0);
716 cmd->short_slot =
717 cpu_to_le32(vif->bss_conf.use_short_slot ?
718 MAC_FLG_SHORT_SLOT : 0);
719
bd6f5bd7
AB		 720 cmd->filter_flags = cpu_to_le32(MAC_FILTER_ACCEPT_GRP);
721
3dd94794
EG		 722 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
723 u8 txf = iwl_mvm_ac_to_tx_fifo[i];
724
725 cmd->ac[txf].cw_min =
726 cpu_to_le16(mvmvif->queue_params[i].cw_min);
727 cmd->ac[txf].cw_max =
728 cpu_to_le16(mvmvif->queue_params[i].cw_max);
729 cmd->ac[txf].edca_txop =
8ca151b5 730 cpu_to_le16(mvmvif->queue_params[i].txop * 32);
3dd94794
EG		 731 cmd->ac[txf].aifsn = mvmvif->queue_params[i].aifs;
732 cmd->ac[txf].fifos_mask = BIT(txf);
8ca151b5
JB		 733 }
734
bd6f5bd7
AB		 735 if (vif->type == NL80211_IFTYPE_AP) {
736 /* in AP mode, the MCAST FIFO takes the EDCA params from VO */
3dd94794
EG		 737 cmd->ac[IWL_MVM_TX_FIFO_VO].fifos_mask |=
738 BIT(IWL_MVM_TX_FIFO_MCAST);
86a91ec7 739
bd6f5bd7
AB		 740 /*
741 * in AP mode, pass probe requests and beacons from other APs
742 * (needed for ht protection); when there're no any associated
743 * station don't ask FW to pass beacons to prevent unnecessary
744 * wake-ups.
745 */
746 cmd->filter_flags |= cpu_to_le32(MAC_FILTER_IN_PROBE_REQUEST);
c89e333d 747 if (mvmvif->ap_assoc_sta_count || !mvm->drop_bcn_ap_mode) {
bd6f5bd7
AB		 748 cmd->filter_flags |= cpu_to_le32(MAC_FILTER_IN_BEACON);
749 IWL_DEBUG_HC(mvm, "Asking FW to pass beacons\n");
750 } else {
751 IWL_DEBUG_HC(mvm, "No need to receive beacons\n");
752 }
753 }
754
8ca151b5
JB		 755 if (vif->bss_conf.qos)
756 cmd->qos_flags |= cpu_to_le32(MAC_QOS_FLG_UPDATE_EDCA);
757
dc271ee0 758 if (vif->bss_conf.use_cts_prot)
cc7ee2ba 759 cmd->protection_flags |= cpu_to_le32(MAC_PROT_FLG_TGG_PROTECT);
dc271ee0 760
8a5e3660
AA		 761 IWL_DEBUG_RATE(mvm, "use_cts_prot %d, ht_operation_mode %d\n",
762 vif->bss_conf.use_cts_prot,
763 vif->bss_conf.ht_operation_mode);
764 if (vif->bss_conf.chandef.width != NL80211_CHAN_WIDTH_20_NOHT)
8ca151b5 765 cmd->qos_flags |= cpu_to_le32(MAC_QOS_FLG_TGN);
8a5e3660
AA		 766 if (ht_enabled)
767 iwl_mvm_mac_ctxt_set_ht_flags(mvm, vif, cmd);
8ca151b5
JB		 768}
769
770static int iwl_mvm_mac_ctxt_send_cmd(struct iwl_mvm *mvm,
771 struct iwl_mac_ctx_cmd *cmd)
772{
a1022927 773 int ret = iwl_mvm_send_cmd_pdu(mvm, MAC_CONTEXT_CMD, 0,
8ca151b5
JB		 774 sizeof(*cmd), cmd);
775 if (ret)
776 IWL_ERR(mvm, "Failed to send MAC context (action:%d): %d\n",
777 le32_to_cpu(cmd->action), ret);
778 return ret;
779}
780
cf52023c
LC		 781static int iwl_mvm_mac_ctxt_cmd_sta(struct iwl_mvm *mvm,
782 struct ieee80211_vif *vif,
3dfd3a97
JB		 783 u32 action, bool force_assoc_off,
784 const u8 *bssid_override)
8ca151b5 785{
cf52023c
LC		 786 struct iwl_mac_ctx_cmd cmd = {};
787 struct iwl_mac_data_sta *ctxt_sta;
788
789 WARN_ON(vif->type != NL80211_IFTYPE_STATION);
790
791 /* Fill the common data for all mac context types */
3dfd3a97 792 iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, bssid_override, action);
cf52023c
LC		 793
794 if (vif->p2p) {
795 struct ieee80211_p2p_noa_attr *noa =
796 &vif->bss_conf.p2p_noa_attr;
797
798 cmd.p2p_sta.ctwin = cpu_to_le32(noa->oppps_ctwindow &
799 IEEE80211_P2P_OPPPS_CTWINDOW_MASK);
800 ctxt_sta = &cmd.p2p_sta.sta;
801 } else {
cf52023c
LC		 802 ctxt_sta = &cmd.sta;
803 }
804
210a544e 805 /* We need the dtim_period to set the MAC as associated */
ba283927
AB		 806 if (vif->bss_conf.assoc && vif->bss_conf.dtim_period &&
807 !force_assoc_off) {
d2931bbd
JB		 808 u32 dtim_offs;
809
810 /*
811 * The DTIM count counts down, so when it is N that means N
812 * more beacon intervals happen until the DTIM TBTT. Therefore
813 * add this to the current time. If that ends up being in the
814 * future, the firmware will handle it.
815 *
816 * Also note that the system_timestamp (which we get here as
817 * "sync_device_ts") and TSF timestamp aren't at exactly the
818 * same offset in the frame -- the TSF is at the first symbol
819 * of the TSF, the system timestamp is at signal acquisition
820 * time. This means there's an offset between them of at most
821 * a few hundred microseconds (24 * 8 bits + PLCP time gives
822 * 384us in the longest case), this is currently not relevant
823 * as the firmware wakes up around 2ms before the TBTT.
824 */
825 dtim_offs = vif->bss_conf.sync_dtim_count *
826 vif->bss_conf.beacon_int;
827 /* convert TU to usecs */
828 dtim_offs *= 1024;
829
830 ctxt_sta->dtim_tsf =
831 cpu_to_le64(vif->bss_conf.sync_tsf + dtim_offs);
832 ctxt_sta->dtim_time =
833 cpu_to_le32(vif->bss_conf.sync_device_ts + dtim_offs);
834
835 IWL_DEBUG_INFO(mvm, "DTIM TBTT is 0x%llx/0x%x, offset %d\n",
836 le64_to_cpu(ctxt_sta->dtim_tsf),
837 le32_to_cpu(ctxt_sta->dtim_time),
838 dtim_offs);
839
210a544e 840 ctxt_sta->is_assoc = cpu_to_le32(1);
d2931bbd 841 } else {
210a544e 842 ctxt_sta->is_assoc = cpu_to_le32(0);
7c8b3bc6
LC		 843
844 /* Allow beacons to pass through as long as we are not
845 * associated, or we do not have dtim period information.
846 */
847 cmd.filter_flags |= cpu_to_le32(MAC_FILTER_IN_BEACON);
d2931bbd 848 }
8ca151b5
JB		 849
850 ctxt_sta->bi = cpu_to_le32(vif->bss_conf.beacon_int);
851 ctxt_sta->bi_reciprocal =
852 cpu_to_le32(iwl_mvm_reciprocal(vif->bss_conf.beacon_int));
853 ctxt_sta->dtim_interval = cpu_to_le32(vif->bss_conf.beacon_int *
854 vif->bss_conf.dtim_period);
855 ctxt_sta->dtim_reciprocal =
856 cpu_to_le32(iwl_mvm_reciprocal(vif->bss_conf.beacon_int *
857 vif->bss_conf.dtim_period));
858
859 ctxt_sta->listen_interval = cpu_to_le32(mvm->hw->conf.listen_interval);
860 ctxt_sta->assoc_id = cpu_to_le32(vif->bss_conf.aid);
8ca151b5 861
effd1929
AO		 862 if (vif->probe_req_reg && vif->bss_conf.assoc && vif->p2p)
863 cmd.filter_flags |= cpu_to_le32(MAC_FILTER_IN_PROBE_REQUEST);
864
8ca151b5
JB		 865 return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
866}
867
868static int iwl_mvm_mac_ctxt_cmd_listener(struct iwl_mvm *mvm,
869 struct ieee80211_vif *vif,
870 u32 action)
871{
872 struct iwl_mac_ctx_cmd cmd = {};
0e39eb03
CRI		 873 u32 tfd_queue_msk = 0;
874 int ret, i;
8ca151b5
JB		 875
876 WARN_ON(vif->type != NL80211_IFTYPE_MONITOR);
877
3dfd3a97 878 iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, NULL, action);
53585495 879
0e39eb03
CRI		 880 for (i = 0; i < IEEE80211_NUM_ACS; i++)
881 if (vif->hw_queue[i] != IEEE80211_INVAL_HW_QUEUE)
882 tfd_queue_msk |= BIT(vif->hw_queue[i]);
883
53585495
JB		 884 cmd.filter_flags = cpu_to_le32(MAC_FILTER_IN_PROMISC |
885 MAC_FILTER_IN_CONTROL_AND_MGMT |
886 MAC_FILTER_IN_BEACON |
fb8b8ee1
JB		 887 MAC_FILTER_IN_PROBE_REQUEST |
888 MAC_FILTER_IN_CRC32);
30686bf7 889 ieee80211_hw_set(mvm->hw, RX_INCLUDES_FCS);
53585495 890
0e39eb03
CRI		 891 /* Allocate sniffer station */
892 ret = iwl_mvm_allocate_int_sta(mvm, &mvm->snif_sta, tfd_queue_msk,
893 vif->type);
894 if (ret)
895 return ret;
896
8ca151b5
JB		 897 return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
898}
899
5023d966
JB		 900static int iwl_mvm_mac_ctxt_cmd_ibss(struct iwl_mvm *mvm,
901 struct ieee80211_vif *vif,
902 u32 action)
903{
904 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
905 struct iwl_mac_ctx_cmd cmd = {};
906
907 WARN_ON(vif->type != NL80211_IFTYPE_ADHOC);
908
3dfd3a97 909 iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, NULL, action);
5023d966
JB		 910
911 cmd.filter_flags = cpu_to_le32(MAC_FILTER_IN_BEACON |
912 MAC_FILTER_IN_PROBE_REQUEST);
913
914 /* cmd.ibss.beacon_time/cmd.ibss.beacon_tsf are curently ignored */
915 cmd.ibss.bi = cpu_to_le32(vif->bss_conf.beacon_int);
916 cmd.ibss.bi_reciprocal =
917 cpu_to_le32(iwl_mvm_reciprocal(vif->bss_conf.beacon_int));
918
919 /* TODO: Assumes that the beacon id == mac context id */
920 cmd.ibss.beacon_template = cpu_to_le32(mvmvif->id);
921
922 return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
923}
924
8ca151b5
JB		 925struct iwl_mvm_go_iterator_data {
926 bool go_active;
927};
928
929static void iwl_mvm_go_iterator(void *_data, u8 *mac, struct ieee80211_vif *vif)
930{
931 struct iwl_mvm_go_iterator_data *data = _data;
932 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
933
5023d966
JB		 934 if (vif->type == NL80211_IFTYPE_AP && vif->p2p &&
935 mvmvif->ap_ibss_active)
8ca151b5
JB		 936 data->go_active = true;
937}
938
939static int iwl_mvm_mac_ctxt_cmd_p2p_device(struct iwl_mvm *mvm,
940 struct ieee80211_vif *vif,
941 u32 action)
942{
943 struct iwl_mac_ctx_cmd cmd = {};
944 struct iwl_mvm_go_iterator_data data = {};
945
946 WARN_ON(vif->type != NL80211_IFTYPE_P2P_DEVICE);
947
3dfd3a97 948 iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, NULL, action);
8ca151b5
JB		 949
950 cmd.protection_flags |= cpu_to_le32(MAC_PROT_FLG_TGG_PROTECT);
1dcd15ee
IP		 951
952 /* Override the filter flags to accept only probe requests */
953 cmd.filter_flags = cpu_to_le32(MAC_FILTER_IN_PROBE_REQUEST);
8ca151b5
JB		 954
955 /*
956 * This flag should be set to true when the P2P Device is
957 * discoverable and there is at least another active P2P GO. Settings
958 * this flag will allow the P2P Device to be discoverable on other
959 * channels in addition to its listen channel.
960 * Note that this flag should not be set in other cases as it opens the
961 * Rx filters on all MAC and increases the number of interrupts.
962 */
963 ieee80211_iterate_active_interfaces_atomic(
964 mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
965 iwl_mvm_go_iterator, &data);
966
967 cmd.p2p_dev.is_disc_extended = cpu_to_le32(data.go_active ? 1 : 0);
968 return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
969}
970
971static void iwl_mvm_mac_ctxt_set_tim(struct iwl_mvm *mvm,
972 struct iwl_mac_beacon_cmd *beacon_cmd,
973 u8 *beacon, u32 frame_size)
974{
975 u32 tim_idx;
976 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;
977
978 /* The index is relative to frame start but we start looking at the
979 * variable-length part of the beacon. */
980 tim_idx = mgmt->u.beacon.variable - beacon;
981
982 /* Parse variable-length elements of beacon to find WLAN_EID_TIM */
983 while ((tim_idx < (frame_size - 2)) &&
984 (beacon[tim_idx] != WLAN_EID_TIM))
985 tim_idx += beacon[tim_idx+1] + 2;
986
987 /* If TIM field was found, set variables */
988 if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
989 beacon_cmd->tim_idx = cpu_to_le32(tim_idx);
990 beacon_cmd->tim_size = cpu_to_le32((u32)beacon[tim_idx+1]);
991 } else {
992 IWL_WARN(mvm, "Unable to find TIM Element in beacon\n");
993 }
994}
995
996static int iwl_mvm_mac_ctxt_send_beacon(struct iwl_mvm *mvm,
997 struct ieee80211_vif *vif,
998 struct sk_buff *beacon)
999{
1000 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1001 struct iwl_host_cmd cmd = {
1002 .id = BEACON_TEMPLATE_CMD,
1003 .flags = CMD_ASYNC,
1004 };
1005 struct iwl_mac_beacon_cmd beacon_cmd = {};
1006 struct ieee80211_tx_info *info;
1007 u32 beacon_skb_len;
75f6b9b6 1008 u32 rate, tx_flags;
8ca151b5
JB		 1009
1010 if (WARN_ON(!beacon))
1011 return -EINVAL;
1012
1013 beacon_skb_len = beacon->len;
1014
1015 /* TODO: for now the beacon template id is set to be the mac context id.
1016 * Might be better to handle it as another resource ... */
1017 beacon_cmd.template_id = cpu_to_le32((u32)mvmvif->id);
75f6b9b6 1018 info = IEEE80211_SKB_CB(beacon);
8ca151b5
JB		 1019
1020 /* Set up TX command fields */
1021 beacon_cmd.tx.len = cpu_to_le16((u16)beacon_skb_len);
1022 beacon_cmd.tx.sta_id = mvmvif->bcast_sta.sta_id;
1023 beacon_cmd.tx.life_time = cpu_to_le32(TX_CMD_LIFE_TIME_INFINITE);
75f6b9b6
EG		 1024 tx_flags = TX_CMD_FLG_SEQ_CTL | TX_CMD_FLG_TSF;
1025 tx_flags |=
1026 iwl_mvm_bt_coex_tx_prio(mvm, (void *)beacon->data, info, 0) <<
1027 TX_CMD_FLG_BT_PRIO_POS;
1028 beacon_cmd.tx.tx_flags = cpu_to_le32(tx_flags);
8ca151b5 1029
1e3c3c35
EG		 1030 if (!fw_has_capa(&mvm->fw->ucode_capa,
1031 IWL_UCODE_TLV_CAPA_BEACON_ANT_SELECTION)) {
1032 mvm->mgmt_last_antenna_idx =
1033 iwl_mvm_next_antenna(mvm, iwl_mvm_get_valid_tx_ant(mvm),
1034 mvm->mgmt_last_antenna_idx);
1035 }
8ca151b5
JB		 1036
1037 beacon_cmd.tx.rate_n_flags =
1038 cpu_to_le32(BIT(mvm->mgmt_last_antenna_idx) <<
1039 RATE_MCS_ANT_POS);
1040
8ca151b5
JB		 1041 if (info->band == IEEE80211_BAND_5GHZ || vif->p2p) {
1042 rate = IWL_FIRST_OFDM_RATE;
1043 } else {
1044 rate = IWL_FIRST_CCK_RATE;
1045 beacon_cmd.tx.rate_n_flags |= cpu_to_le32(RATE_MCS_CCK_MSK);
1046 }
1047 beacon_cmd.tx.rate_n_flags |=
1048 cpu_to_le32(iwl_mvm_mac80211_idx_to_hwrate(rate));
1049
1050 /* Set up TX beacon command fields */
5023d966
JB		 1051 if (vif->type == NL80211_IFTYPE_AP)
1052 iwl_mvm_mac_ctxt_set_tim(mvm, &beacon_cmd,
1053 beacon->data,
1054 beacon_skb_len);
8ca151b5
JB		 1055
1056 /* Submit command */
1057 cmd.len[0] = sizeof(beacon_cmd);
1058 cmd.data[0] = &beacon_cmd;
1059 cmd.dataflags[0] = 0;
1060 cmd.len[1] = beacon_skb_len;
1061 cmd.data[1] = beacon->data;
1062 cmd.dataflags[1] = IWL_HCMD_DFL_DUP;
1063
1064 return iwl_mvm_send_cmd(mvm, &cmd);
1065}
1066
5023d966 1067/* The beacon template for the AP/GO/IBSS has changed and needs update */
8ca151b5
JB		 1068int iwl_mvm_mac_ctxt_beacon_changed(struct iwl_mvm *mvm,
1069 struct ieee80211_vif *vif)
1070{
1071 struct sk_buff *beacon;
1072 int ret;
1073
5023d966
JB		 1074 WARN_ON(vif->type != NL80211_IFTYPE_AP &&
1075 vif->type != NL80211_IFTYPE_ADHOC);
8ca151b5 1076
fe887665 1077 beacon = ieee80211_beacon_get_template(mvm->hw, vif, NULL);
8ca151b5
JB		 1078 if (!beacon)
1079 return -ENOMEM;
1080
1081 ret = iwl_mvm_mac_ctxt_send_beacon(mvm, vif, beacon);
1082 dev_kfree_skb(beacon);
1083 return ret;
1084}
1085
3a3cb92e
IP		 1086struct iwl_mvm_mac_ap_iterator_data {
1087 struct iwl_mvm *mvm;
1088 struct ieee80211_vif *vif;
1089 u32 beacon_device_ts;
1090 u16 beacon_int;
1091};
1092
1093/* Find the beacon_device_ts and beacon_int for a managed interface */
1094static void iwl_mvm_mac_ap_iterator(void *_data, u8 *mac,
1095 struct ieee80211_vif *vif)
1096{
1097 struct iwl_mvm_mac_ap_iterator_data *data = _data;
1098
1099 if (vif->type != NL80211_IFTYPE_STATION || !vif->bss_conf.assoc)
1100 return;
1101
1102 /* Station client has higher priority over P2P client*/
1103 if (vif->p2p && data->beacon_device_ts)
1104 return;
1105
1106 data->beacon_device_ts = vif->bss_conf.sync_device_ts;
1107 data->beacon_int = vif->bss_conf.beacon_int;
1108}
1109
8ca151b5
JB		 1110/*
1111 * Fill the specific data for mac context of type AP of P2P GO
1112 */
1113static void iwl_mvm_mac_ctxt_cmd_fill_ap(struct iwl_mvm *mvm,
1114 struct ieee80211_vif *vif,
506a81e6
JB		 1115 struct iwl_mac_data_ap *ctxt_ap,
1116 bool add)
8ca151b5
JB		 1117{
1118 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3a3cb92e
IP		 1119 struct iwl_mvm_mac_ap_iterator_data data = {
1120 .mvm = mvm,
1121 .vif = vif,
1122 .beacon_device_ts = 0
1123 };
8ca151b5
JB		 1124
1125 ctxt_ap->bi = cpu_to_le32(vif->bss_conf.beacon_int);
1126 ctxt_ap->bi_reciprocal =
1127 cpu_to_le32(iwl_mvm_reciprocal(vif->bss_conf.beacon_int));
1128 ctxt_ap->dtim_interval = cpu_to_le32(vif->bss_conf.beacon_int *
1129 vif->bss_conf.dtim_period);
1130 ctxt_ap->dtim_reciprocal =
1131 cpu_to_le32(iwl_mvm_reciprocal(vif->bss_conf.beacon_int *
1132 vif->bss_conf.dtim_period));
1133
1134 ctxt_ap->mcast_qid = cpu_to_le32(vif->cab_queue);
8ca151b5 1135
506a81e6 1136 /*
3a3cb92e 1137 * Only set the beacon time when the MAC is being added, when we
506a81e6
JB		 1138 * just modify the MAC then we should keep the time -- the firmware
1139 * can otherwise have a "jumping" TBTT.
1140 */
3a3cb92e
IP		 1141 if (add) {
1142 /*
1143 * If there is a station/P2P client interface which is
1144 * associated, set the AP's TBTT far enough from the station's
1145 * TBTT. Otherwise, set it to the current system time
1146 */
1147 ieee80211_iterate_active_interfaces_atomic(
1148 mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
1149 iwl_mvm_mac_ap_iterator, &data);
1150
1151 if (data.beacon_device_ts) {
9f8f8ca5 1152 u32 rand = (prandom_u32() % (64 - 36)) + 36;
3a3cb92e
IP		 1153 mvmvif->ap_beacon_time = data.beacon_device_ts +
1154 ieee80211_tu_to_usec(data.beacon_int * rand /
1155 100);
1156 } else {
1157 mvmvif->ap_beacon_time =
1158 iwl_read_prph(mvm->trans,
1159 DEVICE_SYSTEM_TIME_REG);
1160 }
1161 }
506a81e6
JB		 1162
1163 ctxt_ap->beacon_time = cpu_to_le32(mvmvif->ap_beacon_time);
506a81e6 1164 ctxt_ap->beacon_tsf = 0; /* unused */
8ca151b5
JB		 1165
1166 /* TODO: Assume that the beacon id == mac context id */
1167 ctxt_ap->beacon_template = cpu_to_le32(mvmvif->id);
1168}
1169
f82c8339
IP		 1170static int iwl_mvm_mac_ctxt_cmd_ap(struct iwl_mvm *mvm,
1171 struct ieee80211_vif *vif,
1172 u32 action)
8ca151b5
JB		 1173{
1174 struct iwl_mac_ctx_cmd cmd = {};
1175
1176 WARN_ON(vif->type != NL80211_IFTYPE_AP || vif->p2p);
1177
1178 /* Fill the common data for all mac context types */
3dfd3a97 1179 iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, NULL, action);
8ca151b5
JB		 1180
1181 /* Fill the data specific for ap mode */
506a81e6
JB		 1182 iwl_mvm_mac_ctxt_cmd_fill_ap(mvm, vif, &cmd.ap,
1183 action == FW_CTXT_ACTION_ADD);
8ca151b5
JB		 1184
1185 return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
1186}
1187
1188static int iwl_mvm_mac_ctxt_cmd_go(struct iwl_mvm *mvm,
1189 struct ieee80211_vif *vif,
1190 u32 action)
1191{
1192 struct iwl_mac_ctx_cmd cmd = {};
67baf663 1193 struct ieee80211_p2p_noa_attr *noa = &vif->bss_conf.p2p_noa_attr;
8ca151b5
JB		 1194
1195 WARN_ON(vif->type != NL80211_IFTYPE_AP || !vif->p2p);
1196
1197 /* Fill the common data for all mac context types */
3dfd3a97 1198 iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, NULL, action);
8ca151b5
JB		 1199
1200 /* Fill the data specific for GO mode */
506a81e6
JB		 1201 iwl_mvm_mac_ctxt_cmd_fill_ap(mvm, vif, &cmd.go.ap,
1202 action == FW_CTXT_ACTION_ADD);
8ca151b5 1203
67baf663
JD		 1204 cmd.go.ctwin = cpu_to_le32(noa->oppps_ctwindow &
1205 IEEE80211_P2P_OPPPS_CTWINDOW_MASK);
1206 cmd.go.opp_ps_enabled =
1207 cpu_to_le32(!!(noa->oppps_ctwindow &
1208 IEEE80211_P2P_OPPPS_ENABLE_BIT));
8ca151b5
JB		 1209
1210 return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd);
1211}
1212
1213static int iwl_mvm_mac_ctx_send(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
3dfd3a97
JB		 1214 u32 action, bool force_assoc_off,
1215 const u8 *bssid_override)
8ca151b5
JB		 1216{
1217 switch (vif->type) {
1218 case NL80211_IFTYPE_STATION:
cf52023c 1219 return iwl_mvm_mac_ctxt_cmd_sta(mvm, vif, action,
3dfd3a97
JB		 1220 force_assoc_off,
1221 bssid_override);
8ca151b5
JB		 1222 break;
1223 case NL80211_IFTYPE_AP:
1224 if (!vif->p2p)
1225 return iwl_mvm_mac_ctxt_cmd_ap(mvm, vif, action);
1226 else
1227 return iwl_mvm_mac_ctxt_cmd_go(mvm, vif, action);
1228 break;
1229 case NL80211_IFTYPE_MONITOR:
1230 return iwl_mvm_mac_ctxt_cmd_listener(mvm, vif, action);
1231 case NL80211_IFTYPE_P2P_DEVICE:
1232 return iwl_mvm_mac_ctxt_cmd_p2p_device(mvm, vif, action);
5023d966
JB		 1233 case NL80211_IFTYPE_ADHOC:
1234 return iwl_mvm_mac_ctxt_cmd_ibss(mvm, vif, action);
8ca151b5
JB		 1235 default:
1236 break;
1237 }
1238
1239 return -EOPNOTSUPP;
1240}
1241
1242int iwl_mvm_mac_ctxt_add(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1243{
1244 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1245 int ret;
1246
1247 if (WARN_ONCE(mvmvif->uploaded, "Adding active MAC %pM/%d\n",
1248 vif->addr, ieee80211_vif_type_p2p(vif)))
1249 return -EIO;
1250
bca49d9a 1251 ret = iwl_mvm_mac_ctx_send(mvm, vif, FW_CTXT_ACTION_ADD,
3dfd3a97 1252 true, NULL);
8ca151b5
JB		 1253 if (ret)
1254 return ret;
1255
6d9d32b8
JB		 1256 /* will only do anything at resume from D3 time */
1257 iwl_mvm_set_last_nonqos_seq(mvm, vif);
1258
8ca151b5
JB		 1259 mvmvif->uploaded = true;
1260 return 0;
1261}
1262
bca49d9a 1263int iwl_mvm_mac_ctxt_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
3dfd3a97 1264 bool force_assoc_off, const u8 *bssid_override)
8ca151b5
JB		 1265{
1266 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1267
1268 if (WARN_ONCE(!mvmvif->uploaded, "Changing inactive MAC %pM/%d\n",
1269 vif->addr, ieee80211_vif_type_p2p(vif)))
1270 return -EIO;
1271
bca49d9a 1272 return iwl_mvm_mac_ctx_send(mvm, vif, FW_CTXT_ACTION_MODIFY,
3dfd3a97 1273 force_assoc_off, bssid_override);
8ca151b5
JB		 1274}
1275
1276int iwl_mvm_mac_ctxt_remove(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1277{
1278 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1279 struct iwl_mac_ctx_cmd cmd;
1280 int ret;
1281
1282 if (WARN_ONCE(!mvmvif->uploaded, "Removing inactive MAC %pM/%d\n",
1283 vif->addr, ieee80211_vif_type_p2p(vif)))
1284 return -EIO;
1285
1286 memset(&cmd, 0, sizeof(cmd));
1287
1288 cmd.id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
1289 mvmvif->color));
1290 cmd.action = cpu_to_le32(FW_CTXT_ACTION_REMOVE);
1291
a1022927 1292 ret = iwl_mvm_send_cmd_pdu(mvm, MAC_CONTEXT_CMD, 0,
8ca151b5
JB		 1293 sizeof(cmd), &cmd);
1294 if (ret) {
1295 IWL_ERR(mvm, "Failed to remove MAC context: %d\n", ret);
1296 return ret;
1297 }
1298
1299 mvmvif->uploaded = false;
fb8b8ee1 1300
0e39eb03 1301 if (vif->type == NL80211_IFTYPE_MONITOR) {
30686bf7 1302 __clear_bit(IEEE80211_HW_RX_INCLUDES_FCS, mvm->hw->flags);
0e39eb03
CRI		 1303 iwl_mvm_dealloc_snif_sta(mvm);
1304 }
fb8b8ee1 1305
8ca151b5
JB		 1306 return 0;
1307}
571765c8 1308
7f0a7c67 1309static void iwl_mvm_csa_count_down(struct iwl_mvm *mvm,
7ef0aab6
AO		 1310 struct ieee80211_vif *csa_vif, u32 gp2,
1311 bool tx_success)
7f0a7c67
AO		 1312{
1313 struct iwl_mvm_vif *mvmvif =
1314 iwl_mvm_vif_from_mac80211(csa_vif);
1315
7ef0aab6
AO		 1316 /* Don't start to countdown from a failed beacon */
1317 if (!tx_success && !mvmvif->csa_countdown)
1318 return;
1319
1320 mvmvif->csa_countdown = true;
1321
7f0a7c67
AO		 1322 if (!ieee80211_csa_is_complete(csa_vif)) {
1323 int c = ieee80211_csa_update_counter(csa_vif);
1324
1325 iwl_mvm_mac_ctxt_beacon_changed(mvm, csa_vif);
1326 if (csa_vif->p2p &&
7ef0aab6
AO		 1327 !iwl_mvm_te_scheduled(&mvmvif->time_event_data) && gp2 &&
1328 tx_success) {
7f0a7c67
AO		 1329 u32 rel_time = (c + 1) *
1330 csa_vif->bss_conf.beacon_int -
f991e17b 1331 IWL_MVM_CHANNEL_SWITCH_TIME_GO;
7f0a7c67
AO		 1332 u32 apply_time = gp2 + rel_time * 1024;
1333
f991e17b
LC		 1334 iwl_mvm_schedule_csa_period(mvm, csa_vif,
1335 IWL_MVM_CHANNEL_SWITCH_TIME_GO -
1336 IWL_MVM_CHANNEL_SWITCH_MARGIN,
1337 apply_time);
7f0a7c67
AO		 1338 }
1339 } else if (!iwl_mvm_te_scheduled(&mvmvif->time_event_data)) {
1340 /* we don't have CSA NoA scheduled yet, switch now */
1341 ieee80211_csa_finish(csa_vif);
1342 RCU_INIT_POINTER(mvm->csa_vif, NULL);
1343 }
1344}
1345
0416841d
JB		 1346void iwl_mvm_rx_beacon_notif(struct iwl_mvm *mvm,
1347 struct iwl_rx_cmd_buffer *rxb)
571765c8
IP		 1348{
1349 struct iwl_rx_packet *pkt = rxb_addr(rxb);
2d2c0e9c 1350 struct iwl_extended_beacon_notif *beacon = (void *)pkt->data;
1c87bbad 1351 struct iwl_mvm_tx_resp *beacon_notify_hdr;
664322fa 1352 struct ieee80211_vif *csa_vif;
003e5236 1353 struct ieee80211_vif *tx_blocked_vif;
7ef0aab6 1354 u16 status;
571765c8 1355
bd3398e2
AO		 1356 lockdep_assert_held(&mvm->mutex);
1357
2d2c0e9c
EG		 1358 beacon_notify_hdr = &beacon->beacon_notify_hdr;
1359 mvm->ap_last_beacon_gp2 = le32_to_cpu(beacon->gp2);
1c87bbad 1360
7ef0aab6 1361 status = le16_to_cpu(beacon_notify_hdr->status.status) & TX_STATUS_MSK;
1c87bbad
DS		 1362 IWL_DEBUG_RX(mvm,
1363 "beacon status %#x retries:%d tsf:0x%16llX gp2:0x%X rate:%d\n",
2d2c0e9c
EG		 1364 status, beacon_notify_hdr->failure_frame,
1365 le64_to_cpu(beacon->tsf),
1c87bbad
DS		 1366 mvm->ap_last_beacon_gp2,
1367 le32_to_cpu(beacon_notify_hdr->initial_rate));
bd3398e2 1368
664322fa
AO		 1369 csa_vif = rcu_dereference_protected(mvm->csa_vif,
1370 lockdep_is_held(&mvm->mutex));
7f0a7c67 1371 if (unlikely(csa_vif && csa_vif->csa_active))
7ef0aab6
AO		 1372 iwl_mvm_csa_count_down(mvm, csa_vif, mvm->ap_last_beacon_gp2,
1373 (status == TX_STATUS_SUCCESS));
bd3398e2 1374
003e5236
AO		 1375 tx_blocked_vif = rcu_dereference_protected(mvm->csa_tx_blocked_vif,
1376 lockdep_is_held(&mvm->mutex));
1377 if (unlikely(tx_blocked_vif)) {
1378 struct iwl_mvm_vif *mvmvif =
1379 iwl_mvm_vif_from_mac80211(tx_blocked_vif);
1380
1381 /*
1382 * The channel switch is started and we have blocked the
1383 * stations. If this is the first beacon (the timeout wasn't
1384 * set), set the unblock timeout, otherwise countdown
1385 */
1386 if (!mvm->csa_tx_block_bcn_timeout)
1387 mvm->csa_tx_block_bcn_timeout =
1388 IWL_MVM_CS_UNBLOCK_TX_TIMEOUT;
1389 else
1390 mvm->csa_tx_block_bcn_timeout--;
1391
1392 /* Check if the timeout is expired, and unblock tx */
1393 if (mvm->csa_tx_block_bcn_timeout == 0) {
1394 iwl_mvm_modify_all_sta_disable_tx(mvm, mvmvif, false);
1395 RCU_INIT_POINTER(mvm->csa_tx_blocked_vif, NULL);
1396 }
1397 }
571765c8 1398}
d64048ed
HG		 1399
1400static void iwl_mvm_beacon_loss_iterator(void *_data, u8 *mac,
1401 struct ieee80211_vif *vif)
1402{
12d423e8 1403 struct iwl_missed_beacons_notif *missed_beacons = _data;
d64048ed 1404 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
9d761fd8
EG		 1405 struct iwl_mvm *mvm = mvmvif->mvm;
1406 struct iwl_fw_dbg_trigger_missed_bcon *bcon_trig;
1407 struct iwl_fw_dbg_trigger_tlv *trigger;
1408 u32 stop_trig_missed_bcon, stop_trig_missed_bcon_since_rx;
1409 u32 rx_missed_bcon, rx_missed_bcon_since_rx;
d64048ed 1410
12d423e8
IP		 1411 if (mvmvif->id != (u16)le32_to_cpu(missed_beacons->mac_id))
1412 return;
1413
9d761fd8
EG		 1414 rx_missed_bcon = le32_to_cpu(missed_beacons->consec_missed_beacons);
1415 rx_missed_bcon_since_rx =
1416 le32_to_cpu(missed_beacons->consec_missed_beacons_since_last_rx);
12d423e8
IP		 1417 /*
1418 * TODO: the threshold should be adjusted based on latency conditions,
1419 * and/or in case of a CS flow on one of the other AP vifs.
1420 */
1421 if (le32_to_cpu(missed_beacons->consec_missed_beacons_since_last_rx) >
1422 IWL_MVM_MISSED_BEACONS_THRESHOLD)
d64048ed 1423 ieee80211_beacon_loss(vif);
9d761fd8
EG		 1424
1425 if (!iwl_fw_dbg_trigger_enabled(mvm->fw,
1426 FW_DBG_TRIGGER_MISSED_BEACONS))
1427 return;
1428
1429 trigger = iwl_fw_dbg_get_trigger(mvm->fw,
1430 FW_DBG_TRIGGER_MISSED_BEACONS);
1431 bcon_trig = (void *)trigger->data;
1432 stop_trig_missed_bcon = le32_to_cpu(bcon_trig->stop_consec_missed_bcon);
1433 stop_trig_missed_bcon_since_rx =
1434 le32_to_cpu(bcon_trig->stop_consec_missed_bcon_since_rx);
1435
1436 /* TODO: implement start trigger */
1437
1438 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trigger))
1439 return;
1440
1441 if (rx_missed_bcon_since_rx >= stop_trig_missed_bcon_since_rx ||
1442 rx_missed_bcon >= stop_trig_missed_bcon)
5d4f929e 1443 iwl_mvm_fw_dbg_collect_trig(mvm, trigger, NULL);
d64048ed
HG		 1444}
1445
0416841d
JB		 1446void iwl_mvm_rx_missed_beacons_notif(struct iwl_mvm *mvm,
1447 struct iwl_rx_cmd_buffer *rxb)
d64048ed
HG		 1448{
1449 struct iwl_rx_packet *pkt = rxb_addr(rxb);
12d423e8
IP		 1450 struct iwl_missed_beacons_notif *mb = (void *)pkt->data;
1451
1452 IWL_DEBUG_INFO(mvm,
1453 "missed bcn mac_id=%u, consecutive=%u (%u, %u, %u)\n",
1454 le32_to_cpu(mb->mac_id),
1455 le32_to_cpu(mb->consec_missed_beacons),
1456 le32_to_cpu(mb->consec_missed_beacons_since_last_rx),
1457 le32_to_cpu(mb->num_recvd_beacons),
1458 le32_to_cpu(mb->num_expected_beacons));
d64048ed
HG		 1459
1460 ieee80211_iterate_active_interfaces_atomic(mvm->hw,
1461 IEEE80211_IFACE_ITER_NORMAL,
1462 iwl_mvm_beacon_loss_iterator,
12d423e8 1463 mb);
d64048ed 1464}
0db056d3
SS		 1465
1466void iwl_mvm_rx_stored_beacon_notif(struct iwl_mvm *mvm,
1467 struct iwl_rx_cmd_buffer *rxb)
1468{
1469 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1470 struct iwl_stored_beacon_notif *sb = (void *)pkt->data;
1471 struct ieee80211_rx_status rx_status;
1472 struct sk_buff *skb;
1473 u32 size = le32_to_cpu(sb->byte_count);
1474
1475 if (size == 0)
1476 return;
1477
1478 skb = alloc_skb(size, GFP_ATOMIC);
1479 if (!skb) {
1480 IWL_ERR(mvm, "alloc_skb failed\n");
1481 return;
1482 }
1483
1484 /* update rx_status according to the notification's metadata */
1485 memset(&rx_status, 0, sizeof(rx_status));
1486 rx_status.mactime = le64_to_cpu(sb->tsf);
77fe7395
SS		 1487 /* TSF as indicated by the firmware is at INA time */
1488 rx_status.flag |= RX_FLAG_MACTIME_PLCP_START;
0db056d3
SS		 1489 rx_status.device_timestamp = le32_to_cpu(sb->system_time);
1490 rx_status.band =
1491 (sb->phy_flags & cpu_to_le16(RX_RES_PHY_FLAGS_BAND_24)) ?
1492 IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
1493 rx_status.freq =
1494 ieee80211_channel_to_frequency(le16_to_cpu(sb->channel),
1495 rx_status.band);
1496
1497 /* copy the data */
1498 memcpy(skb_put(skb, size), sb->data, size);
1499 memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
1500
1501 /* pass it as regular rx to mac80211 */
d63b548f 1502 ieee80211_rx_napi(mvm->hw, NULL, skb, NULL);
0db056d3 1503}
Linux 6.x block layer and io_uring tree(s)