1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67#include <net/mac80211.h>
68
69#include "mvm.h"
70#include "sta.h"
71#include "rs.h"
72
73
74
75
76
77
78static inline int iwl_mvm_add_sta_cmd_size(struct iwl_mvm *mvm)
79{
80 if (iwl_mvm_has_new_rx_api(mvm) ||
81 fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE))
82 return sizeof(struct iwl_mvm_add_sta_cmd);
83 else
84 return sizeof(struct iwl_mvm_add_sta_cmd_v7);
85}
86
87static int iwl_mvm_find_free_sta_id(struct iwl_mvm *mvm,
88 enum nl80211_iftype iftype)
89{
90 int sta_id;
91 u32 reserved_ids = 0;
92
93 BUILD_BUG_ON(IWL_MVM_STATION_COUNT > 32);
94 WARN_ON_ONCE(test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status));
95
96 lockdep_assert_held(&mvm->mutex);
97
98
99 if (iftype != NL80211_IFTYPE_STATION)
100 reserved_ids = BIT(0);
101
102
103 for (sta_id = 0; sta_id < ARRAY_SIZE(mvm->fw_id_to_mac_id); sta_id++) {
104 if (BIT(sta_id) & reserved_ids)
105 continue;
106
107 if (!rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
108 lockdep_is_held(&mvm->mutex)))
109 return sta_id;
110 }
111 return IWL_MVM_INVALID_STA;
112}
113
114
115int iwl_mvm_sta_send_to_fw(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
116 bool update, unsigned int flags)
117{
118 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
119 struct iwl_mvm_add_sta_cmd add_sta_cmd = {
120 .sta_id = mvm_sta->sta_id,
121 .mac_id_n_color = cpu_to_le32(mvm_sta->mac_id_n_color),
122 .add_modify = update ? 1 : 0,
123 .station_flags_msk = cpu_to_le32(STA_FLG_FAT_EN_MSK |
124 STA_FLG_MIMO_EN_MSK |
125 STA_FLG_RTS_MIMO_PROT),
126 .tid_disable_tx = cpu_to_le16(mvm_sta->tid_disable_agg),
127 };
128 int ret;
129 u32 status;
130 u32 agg_size = 0, mpdu_dens = 0;
131
132 if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE))
133 add_sta_cmd.station_type = mvm_sta->sta_type;
134
135 if (!update || (flags & STA_MODIFY_QUEUES)) {
136 memcpy(&add_sta_cmd.addr, sta->addr, ETH_ALEN);
137
138 if (!iwl_mvm_has_new_tx_api(mvm)) {
139 add_sta_cmd.tfd_queue_msk =
140 cpu_to_le32(mvm_sta->tfd_queue_msk);
141
142 if (flags & STA_MODIFY_QUEUES)
143 add_sta_cmd.modify_mask |= STA_MODIFY_QUEUES;
144 } else {
145 WARN_ON(flags & STA_MODIFY_QUEUES);
146 }
147 }
148
149 switch (sta->bandwidth) {
150 case IEEE80211_STA_RX_BW_160:
151 add_sta_cmd.station_flags |= cpu_to_le32(STA_FLG_FAT_EN_160MHZ);
152
153 case IEEE80211_STA_RX_BW_80:
154 add_sta_cmd.station_flags |= cpu_to_le32(STA_FLG_FAT_EN_80MHZ);
155
156 case IEEE80211_STA_RX_BW_40:
157 add_sta_cmd.station_flags |= cpu_to_le32(STA_FLG_FAT_EN_40MHZ);
158
159 case IEEE80211_STA_RX_BW_20:
160 if (sta->ht_cap.ht_supported)
161 add_sta_cmd.station_flags |=
162 cpu_to_le32(STA_FLG_FAT_EN_20MHZ);
163 break;
164 }
165
166 switch (sta->rx_nss) {
167 case 1:
168 add_sta_cmd.station_flags |= cpu_to_le32(STA_FLG_MIMO_EN_SISO);
169 break;
170 case 2:
171 add_sta_cmd.station_flags |= cpu_to_le32(STA_FLG_MIMO_EN_MIMO2);
172 break;
173 case 3 ... 8:
174 add_sta_cmd.station_flags |= cpu_to_le32(STA_FLG_MIMO_EN_MIMO3);
175 break;
176 }
177
178 switch (sta->smps_mode) {
179 case IEEE80211_SMPS_AUTOMATIC:
180 case IEEE80211_SMPS_NUM_MODES:
181 WARN_ON(1);
182 break;
183 case IEEE80211_SMPS_STATIC:
184
185 add_sta_cmd.station_flags &= ~cpu_to_le32(STA_FLG_MIMO_EN_MSK);
186 add_sta_cmd.station_flags |= cpu_to_le32(STA_FLG_MIMO_EN_SISO);
187 break;
188 case IEEE80211_SMPS_DYNAMIC:
189 add_sta_cmd.station_flags |= cpu_to_le32(STA_FLG_RTS_MIMO_PROT);
190 break;
191 case IEEE80211_SMPS_OFF:
192
193 break;
194 }
195
196 if (sta->ht_cap.ht_supported) {
197 add_sta_cmd.station_flags_msk |=
198 cpu_to_le32(STA_FLG_MAX_AGG_SIZE_MSK |
199 STA_FLG_AGG_MPDU_DENS_MSK);
200
201 mpdu_dens = sta->ht_cap.ampdu_density;
202 }
203
204 if (sta->vht_cap.vht_supported) {
205 agg_size = sta->vht_cap.cap &
206 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
207 agg_size >>=
208 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
209 } else if (sta->ht_cap.ht_supported) {
210 agg_size = sta->ht_cap.ampdu_factor;
211 }
212
213 add_sta_cmd.station_flags |=
214 cpu_to_le32(agg_size << STA_FLG_MAX_AGG_SIZE_SHIFT);
215 add_sta_cmd.station_flags |=
216 cpu_to_le32(mpdu_dens << STA_FLG_AGG_MPDU_DENS_SHIFT);
217 if (mvm_sta->associated)
218 add_sta_cmd.assoc_id = cpu_to_le16(sta->aid);
219
220 if (sta->wme) {
221 add_sta_cmd.modify_mask |= STA_MODIFY_UAPSD_ACS;
222
223 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
224 add_sta_cmd.uapsd_acs |= BIT(AC_BK);
225 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
226 add_sta_cmd.uapsd_acs |= BIT(AC_BE);
227 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
228 add_sta_cmd.uapsd_acs |= BIT(AC_VI);
229 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
230 add_sta_cmd.uapsd_acs |= BIT(AC_VO);
231 add_sta_cmd.uapsd_acs |= add_sta_cmd.uapsd_acs << 4;
232 add_sta_cmd.sp_length = sta->max_sp ? sta->max_sp * 2 : 128;
233 }
234
235 status = ADD_STA_SUCCESS;
236 ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA,
237 iwl_mvm_add_sta_cmd_size(mvm),
238 &add_sta_cmd, &status);
239 if (ret)
240 return ret;
241
242 switch (status & IWL_ADD_STA_STATUS_MASK) {
243 case ADD_STA_SUCCESS:
244 IWL_DEBUG_ASSOC(mvm, "ADD_STA PASSED\n");
245 break;
246 default:
247 ret = -EIO;
248 IWL_ERR(mvm, "ADD_STA failed\n");
249 break;
250 }
251
252 return ret;
253}
254
255static void iwl_mvm_rx_agg_session_expired(struct timer_list *t)
256{
257 struct iwl_mvm_baid_data *data =
258 from_timer(data, t, session_timer);
259 struct iwl_mvm_baid_data __rcu **rcu_ptr = data->rcu_ptr;
260 struct iwl_mvm_baid_data *ba_data;
261 struct ieee80211_sta *sta;
262 struct iwl_mvm_sta *mvm_sta;
263 unsigned long timeout;
264
265 rcu_read_lock();
266
267 ba_data = rcu_dereference(*rcu_ptr);
268
269 if (WARN_ON(!ba_data))
270 goto unlock;
271
272 if (!ba_data->timeout)
273 goto unlock;
274
275 timeout = ba_data->last_rx + TU_TO_JIFFIES(ba_data->timeout * 2);
276 if (time_is_after_jiffies(timeout)) {
277 mod_timer(&ba_data->session_timer, timeout);
278 goto unlock;
279 }
280
281
282 sta = rcu_dereference(ba_data->mvm->fw_id_to_mac_id[ba_data->sta_id]);
283
284
285
286
287
288
289
290
291
292 if (!sta)
293 goto unlock;
294
295 mvm_sta = iwl_mvm_sta_from_mac80211(sta);
296 ieee80211_rx_ba_timer_expired(mvm_sta->vif,
297 sta->addr, ba_data->tid);
298unlock:
299 rcu_read_unlock();
300}
301
302
303static int iwl_mvm_invalidate_sta_queue(struct iwl_mvm *mvm, int queue,
304 unsigned long disable_agg_tids,
305 bool remove_queue)
306{
307 struct iwl_mvm_add_sta_cmd cmd = {};
308 struct ieee80211_sta *sta;
309 struct iwl_mvm_sta *mvmsta;
310 u32 status;
311 u8 sta_id;
312 int ret;
313
314 if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
315 return -EINVAL;
316
317 spin_lock_bh(&mvm->queue_info_lock);
318 sta_id = mvm->queue_info[queue].ra_sta_id;
319 spin_unlock_bh(&mvm->queue_info_lock);
320
321 rcu_read_lock();
322
323 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
324
325 if (WARN_ON_ONCE(IS_ERR_OR_NULL(sta))) {
326 rcu_read_unlock();
327 return -EINVAL;
328 }
329
330 mvmsta = iwl_mvm_sta_from_mac80211(sta);
331
332 mvmsta->tid_disable_agg |= disable_agg_tids;
333
334 cmd.mac_id_n_color = cpu_to_le32(mvmsta->mac_id_n_color);
335 cmd.sta_id = mvmsta->sta_id;
336 cmd.add_modify = STA_MODE_MODIFY;
337 cmd.modify_mask = STA_MODIFY_QUEUES;
338 if (disable_agg_tids)
339 cmd.modify_mask |= STA_MODIFY_TID_DISABLE_TX;
340 if (remove_queue)
341 cmd.modify_mask |= STA_MODIFY_QUEUE_REMOVAL;
342 cmd.tfd_queue_msk = cpu_to_le32(mvmsta->tfd_queue_msk);
343 cmd.tid_disable_tx = cpu_to_le16(mvmsta->tid_disable_agg);
344
345 rcu_read_unlock();
346
347
348 status = ADD_STA_SUCCESS;
349 ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA,
350 iwl_mvm_add_sta_cmd_size(mvm),
351 &cmd, &status);
352
353 return ret;
354}
355
356static int iwl_mvm_get_queue_agg_tids(struct iwl_mvm *mvm, int queue)
357{
358 struct ieee80211_sta *sta;
359 struct iwl_mvm_sta *mvmsta;
360 unsigned long tid_bitmap;
361 unsigned long agg_tids = 0;
362 u8 sta_id;
363 int tid;
364
365 lockdep_assert_held(&mvm->mutex);
366
367 if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
368 return -EINVAL;
369
370 spin_lock_bh(&mvm->queue_info_lock);
371 sta_id = mvm->queue_info[queue].ra_sta_id;
372 tid_bitmap = mvm->queue_info[queue].tid_bitmap;
373 spin_unlock_bh(&mvm->queue_info_lock);
374
375 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
376 lockdep_is_held(&mvm->mutex));
377
378 if (WARN_ON_ONCE(IS_ERR_OR_NULL(sta)))
379 return -EINVAL;
380
381 mvmsta = iwl_mvm_sta_from_mac80211(sta);
382
383 spin_lock_bh(&mvmsta->lock);
384 for_each_set_bit(tid, &tid_bitmap, IWL_MAX_TID_COUNT + 1) {
385 if (mvmsta->tid_data[tid].state == IWL_AGG_ON)
386 agg_tids |= BIT(tid);
387 }
388 spin_unlock_bh(&mvmsta->lock);
389
390 return agg_tids;
391}
392
393
394
395
396
397
398static int iwl_mvm_remove_sta_queue_marking(struct iwl_mvm *mvm, int queue)
399{
400 struct ieee80211_sta *sta;
401 struct iwl_mvm_sta *mvmsta;
402 unsigned long tid_bitmap;
403 unsigned long disable_agg_tids = 0;
404 u8 sta_id;
405 int tid;
406
407 lockdep_assert_held(&mvm->mutex);
408
409 if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
410 return -EINVAL;
411
412 spin_lock_bh(&mvm->queue_info_lock);
413 sta_id = mvm->queue_info[queue].ra_sta_id;
414 tid_bitmap = mvm->queue_info[queue].tid_bitmap;
415 spin_unlock_bh(&mvm->queue_info_lock);
416
417 rcu_read_lock();
418
419 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
420
421 if (WARN_ON_ONCE(IS_ERR_OR_NULL(sta))) {
422 rcu_read_unlock();
423 return 0;
424 }
425
426 mvmsta = iwl_mvm_sta_from_mac80211(sta);
427
428 spin_lock_bh(&mvmsta->lock);
429
430 for_each_set_bit(tid, &tid_bitmap, IWL_MAX_TID_COUNT + 1) {
431 if (mvmsta->tid_data[tid].state == IWL_AGG_ON)
432 disable_agg_tids |= BIT(tid);
433 mvmsta->tid_data[tid].txq_id = IWL_MVM_INVALID_QUEUE;
434 }
435
436 mvmsta->tfd_queue_msk &= ~BIT(queue);
437 spin_unlock_bh(&mvmsta->lock);
438
439 rcu_read_unlock();
440
441 return disable_agg_tids;
442}
443
444static int iwl_mvm_free_inactive_queue(struct iwl_mvm *mvm, int queue,
445 bool same_sta)
446{
447 struct iwl_mvm_sta *mvmsta;
448 u8 txq_curr_ac, sta_id, tid;
449 unsigned long disable_agg_tids = 0;
450 int ret;
451
452 lockdep_assert_held(&mvm->mutex);
453
454 if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
455 return -EINVAL;
456
457 spin_lock_bh(&mvm->queue_info_lock);
458 txq_curr_ac = mvm->queue_info[queue].mac80211_ac;
459 sta_id = mvm->queue_info[queue].ra_sta_id;
460 tid = mvm->queue_info[queue].txq_tid;
461 spin_unlock_bh(&mvm->queue_info_lock);
462
463 mvmsta = iwl_mvm_sta_from_staid_protected(mvm, sta_id);
464 if (WARN_ON(!mvmsta))
465 return -EINVAL;
466
467 disable_agg_tids = iwl_mvm_remove_sta_queue_marking(mvm, queue);
468
469 if (disable_agg_tids)
470 iwl_mvm_invalidate_sta_queue(mvm, queue,
471 disable_agg_tids, false);
472
473 ret = iwl_mvm_disable_txq(mvm, queue,
474 mvmsta->vif->hw_queue[txq_curr_ac],
475 tid, 0);
476 if (ret) {
477
478 spin_lock_bh(&mvm->queue_info_lock);
479 mvm->queue_info[queue].status = IWL_MVM_QUEUE_INACTIVE;
480 spin_unlock_bh(&mvm->queue_info_lock);
481 IWL_ERR(mvm,
482 "Failed to free inactive queue %d (ret=%d)\n",
483 queue, ret);
484
485 return ret;
486 }
487
488
489 if (!same_sta)
490 iwl_mvm_invalidate_sta_queue(mvm, queue, 0, true);
491
492 return 0;
493}
494
495static int iwl_mvm_get_shared_queue(struct iwl_mvm *mvm,
496 unsigned long tfd_queue_mask, u8 ac)
497{
498 int queue = 0;
499 u8 ac_to_queue[IEEE80211_NUM_ACS];
500 int i;
501
502 lockdep_assert_held(&mvm->queue_info_lock);
503 if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
504 return -EINVAL;
505
506 memset(&ac_to_queue, IEEE80211_INVAL_HW_QUEUE, sizeof(ac_to_queue));
507
508
509 for_each_set_bit(i, &tfd_queue_mask, IWL_MVM_DQA_MAX_DATA_QUEUE) {
510
511 if (i < IWL_MVM_DQA_MIN_DATA_QUEUE &&
512 i != IWL_MVM_DQA_BSS_CLIENT_QUEUE)
513 continue;
514
515
516 if (mvm->queue_info[queue].status ==
517 IWL_MVM_QUEUE_RECONFIGURING)
518 continue;
519
520 ac_to_queue[mvm->queue_info[i].mac80211_ac] = i;
521 }
522
523
524
525
526
527
528
529
530
531
532
533 if (ac_to_queue[IEEE80211_AC_BE] != IEEE80211_INVAL_HW_QUEUE)
534 queue = ac_to_queue[IEEE80211_AC_BE];
535
536 else if (ac_to_queue[ac] != IEEE80211_INVAL_HW_QUEUE)
537 queue = ac_to_queue[ac];
538
539 else if (ac == IEEE80211_AC_VO &&
540 ac_to_queue[IEEE80211_AC_VI] != IEEE80211_INVAL_HW_QUEUE)
541 queue = ac_to_queue[IEEE80211_AC_VI];
542
543 else if (ac_to_queue[IEEE80211_AC_BK] != IEEE80211_INVAL_HW_QUEUE)
544 queue = ac_to_queue[IEEE80211_AC_BK];
545
546 else if (ac_to_queue[IEEE80211_AC_VI] != IEEE80211_INVAL_HW_QUEUE)
547 queue = ac_to_queue[IEEE80211_AC_VI];
548
549 else if (ac_to_queue[IEEE80211_AC_VO] != IEEE80211_INVAL_HW_QUEUE)
550 queue = ac_to_queue[IEEE80211_AC_VO];
551
552
553 if (!iwl_mvm_is_dqa_data_queue(mvm, queue) &&
554 !iwl_mvm_is_dqa_mgmt_queue(mvm, queue) &&
555 (queue != IWL_MVM_DQA_BSS_CLIENT_QUEUE)) {
556 IWL_ERR(mvm, "No DATA queues available to share\n");
557 return -ENOSPC;
558 }
559
560
561 if (mvm->queue_info[queue].status == IWL_MVM_QUEUE_RECONFIGURING) {
562 IWL_ERR(mvm,
563 "TXQ %d is in the middle of re-config - try again\n",
564 queue);
565 return -EBUSY;
566 }
567
568 return queue;
569}
570
571
572
573
574
575
576
577int iwl_mvm_scd_queue_redirect(struct iwl_mvm *mvm, int queue, int tid,
578 int ac, int ssn, unsigned int wdg_timeout,
579 bool force)
580{
581 struct iwl_scd_txq_cfg_cmd cmd = {
582 .scd_queue = queue,
583 .action = SCD_CFG_DISABLE_QUEUE,
584 };
585 bool shared_queue;
586 unsigned long mq;
587 int ret;
588
589 if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
590 return -EINVAL;
591
592
593
594
595
596
597
598
599
600 spin_lock_bh(&mvm->queue_info_lock);
601 if (ac <= mvm->queue_info[queue].mac80211_ac && !force) {
602 spin_unlock_bh(&mvm->queue_info_lock);
603
604 IWL_DEBUG_TX_QUEUES(mvm,
605 "No redirection needed on TXQ #%d\n",
606 queue);
607 return 0;
608 }
609
610 cmd.sta_id = mvm->queue_info[queue].ra_sta_id;
611 cmd.tx_fifo = iwl_mvm_ac_to_tx_fifo[mvm->queue_info[queue].mac80211_ac];
612 cmd.tid = mvm->queue_info[queue].txq_tid;
613 mq = mvm->hw_queue_to_mac80211[queue];
614 shared_queue = (mvm->queue_info[queue].hw_queue_refcount > 1);
615 spin_unlock_bh(&mvm->queue_info_lock);
616
617 IWL_DEBUG_TX_QUEUES(mvm, "Redirecting TXQ #%d to FIFO #%d\n",
618 queue, iwl_mvm_ac_to_tx_fifo[ac]);
619
620
621 iwl_mvm_stop_mac_queues(mvm, mq);
622 ret = iwl_trans_wait_tx_queues_empty(mvm->trans, BIT(queue));
623 if (ret) {
624 IWL_ERR(mvm, "Error draining queue %d before reconfig\n",
625 queue);
626 ret = -EIO;
627 goto out;
628 }
629
630
631 iwl_trans_txq_disable(mvm->trans, queue, false);
632 ret = iwl_mvm_send_cmd_pdu(mvm, SCD_QUEUE_CFG, 0, sizeof(cmd), &cmd);
633 if (ret)
634 IWL_ERR(mvm, "Failed SCD disable TXQ %d (ret=%d)\n", queue,
635 ret);
636
637
638 iwl_trans_txq_enable_cfg(mvm->trans, queue, ssn, NULL, wdg_timeout);
639
640
641 spin_lock_bh(&mvm->queue_info_lock);
642 mvm->queue_info[queue].txq_tid = tid;
643 spin_unlock_bh(&mvm->queue_info_lock);
644
645
646
647
648 iwl_mvm_reconfig_scd(mvm, queue, iwl_mvm_ac_to_tx_fifo[ac],
649 cmd.sta_id, tid, IWL_FRAME_LIMIT, ssn);
650
651
652 spin_lock_bh(&mvm->queue_info_lock);
653 mvm->queue_info[queue].mac80211_ac = ac;
654 spin_unlock_bh(&mvm->queue_info_lock);
655
656
657
658
659
660
661
662 if (shared_queue)
663 iwl_trans_txq_set_shared_mode(mvm->trans, queue, true);
664
665out:
666
667 iwl_mvm_start_mac_queues(mvm, mq);
668
669 return ret;
670}
671
672static int iwl_mvm_sta_alloc_queue_tvqm(struct iwl_mvm *mvm,
673 struct ieee80211_sta *sta, u8 ac,
674 int tid)
675{
676 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
677 unsigned int wdg_timeout =
678 iwl_mvm_get_wd_timeout(mvm, mvmsta->vif, false, false);
679 u8 mac_queue = mvmsta->vif->hw_queue[ac];
680 int queue = -1;
681
682 lockdep_assert_held(&mvm->mutex);
683
684 IWL_DEBUG_TX_QUEUES(mvm,
685 "Allocating queue for sta %d on tid %d\n",
686 mvmsta->sta_id, tid);
687 queue = iwl_mvm_tvqm_enable_txq(mvm, mac_queue, mvmsta->sta_id, tid,
688 wdg_timeout);
689 if (queue < 0)
690 return queue;
691
692 IWL_DEBUG_TX_QUEUES(mvm, "Allocated queue is %d\n", queue);
693
694 spin_lock_bh(&mvmsta->lock);
695 mvmsta->tid_data[tid].txq_id = queue;
696 mvmsta->tid_data[tid].is_tid_active = true;
697 spin_unlock_bh(&mvmsta->lock);
698
699 return 0;
700}
701
702static int iwl_mvm_sta_alloc_queue(struct iwl_mvm *mvm,
703 struct ieee80211_sta *sta, u8 ac, int tid,
704 struct ieee80211_hdr *hdr)
705{
706 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
707 struct iwl_trans_txq_scd_cfg cfg = {
708 .fifo = iwl_mvm_mac_ac_to_tx_fifo(mvm, ac),
709 .sta_id = mvmsta->sta_id,
710 .tid = tid,
711 .frame_limit = IWL_FRAME_LIMIT,
712 };
713 unsigned int wdg_timeout =
714 iwl_mvm_get_wd_timeout(mvm, mvmsta->vif, false, false);
715 u8 mac_queue = mvmsta->vif->hw_queue[ac];
716 int queue = -1;
717 bool using_inactive_queue = false, same_sta = false;
718 unsigned long disable_agg_tids = 0;
719 enum iwl_mvm_agg_state queue_state;
720 bool shared_queue = false, inc_ssn;
721 int ssn;
722 unsigned long tfd_queue_mask;
723 int ret;
724
725 lockdep_assert_held(&mvm->mutex);
726
727 if (iwl_mvm_has_new_tx_api(mvm))
728 return iwl_mvm_sta_alloc_queue_tvqm(mvm, sta, ac, tid);
729
730 spin_lock_bh(&mvmsta->lock);
731 tfd_queue_mask = mvmsta->tfd_queue_msk;
732 spin_unlock_bh(&mvmsta->lock);
733
734 spin_lock_bh(&mvm->queue_info_lock);
735
736
737
738
739
740 if (!ieee80211_is_data_qos(hdr->frame_control) ||
741 ieee80211_is_qos_nullfunc(hdr->frame_control)) {
742 queue = iwl_mvm_find_free_queue(mvm, mvmsta->sta_id,
743 IWL_MVM_DQA_MIN_MGMT_QUEUE,
744 IWL_MVM_DQA_MAX_MGMT_QUEUE);
745 if (queue >= IWL_MVM_DQA_MIN_MGMT_QUEUE)
746 IWL_DEBUG_TX_QUEUES(mvm, "Found free MGMT queue #%d\n",
747 queue);
748
749
750 }
751
752 if ((queue < 0 && mvmsta->reserved_queue != IEEE80211_INVAL_HW_QUEUE) &&
753 (mvm->queue_info[mvmsta->reserved_queue].status ==
754 IWL_MVM_QUEUE_RESERVED ||
755 mvm->queue_info[mvmsta->reserved_queue].status ==
756 IWL_MVM_QUEUE_INACTIVE)) {
757 queue = mvmsta->reserved_queue;
758 mvm->queue_info[queue].reserved = true;
759 IWL_DEBUG_TX_QUEUES(mvm, "Using reserved queue #%d\n", queue);
760 }
761
762 if (queue < 0)
763 queue = iwl_mvm_find_free_queue(mvm, mvmsta->sta_id,
764 IWL_MVM_DQA_MIN_DATA_QUEUE,
765 IWL_MVM_DQA_MAX_DATA_QUEUE);
766
767
768
769
770
771
772
773 if (queue > 0 &&
774 mvm->queue_info[queue].status == IWL_MVM_QUEUE_INACTIVE) {
775 mvm->queue_info[queue].status = IWL_MVM_QUEUE_RESERVED;
776 using_inactive_queue = true;
777 same_sta = mvm->queue_info[queue].ra_sta_id == mvmsta->sta_id;
778 IWL_DEBUG_TX_QUEUES(mvm,
779 "Re-assigning TXQ %d: sta_id=%d, tid=%d\n",
780 queue, mvmsta->sta_id, tid);
781 }
782
783
784 if (queue <= 0) {
785 queue = iwl_mvm_get_shared_queue(mvm, tfd_queue_mask, ac);
786 if (queue > 0) {
787 shared_queue = true;
788 mvm->queue_info[queue].status = IWL_MVM_QUEUE_SHARED;
789 }
790 }
791
792
793
794
795
796
797
798 if ((queue > 0) && !shared_queue)
799 mvm->queue_info[queue].status = IWL_MVM_QUEUE_READY;
800
801 spin_unlock_bh(&mvm->queue_info_lock);
802
803
804 if (WARN_ON(queue <= 0)) {
805 IWL_ERR(mvm, "No available queues for tid %d on sta_id %d\n",
806 tid, cfg.sta_id);
807 return queue;
808 }
809
810
811
812
813
814
815
816 cfg.aggregate = (queue >= IWL_MVM_DQA_MIN_DATA_QUEUE ||
817 queue == IWL_MVM_DQA_BSS_CLIENT_QUEUE);
818
819
820
821
822
823 if (using_inactive_queue) {
824 ret = iwl_mvm_free_inactive_queue(mvm, queue, same_sta);
825 if (ret)
826 return ret;
827 }
828
829 IWL_DEBUG_TX_QUEUES(mvm,
830 "Allocating %squeue #%d to sta %d on tid %d\n",
831 shared_queue ? "shared " : "", queue,
832 mvmsta->sta_id, tid);
833
834 if (shared_queue) {
835
836 disable_agg_tids = iwl_mvm_get_queue_agg_tids(mvm, queue);
837
838 if (disable_agg_tids) {
839 IWL_DEBUG_TX_QUEUES(mvm, "Disabling aggs on queue %d\n",
840 queue);
841 iwl_mvm_invalidate_sta_queue(mvm, queue,
842 disable_agg_tids, false);
843 }
844 }
845
846 ssn = IEEE80211_SEQ_TO_SN(le16_to_cpu(hdr->seq_ctrl));
847 inc_ssn = iwl_mvm_enable_txq(mvm, queue, mac_queue,
848 ssn, &cfg, wdg_timeout);
849 if (inc_ssn) {
850 ssn = (ssn + 1) & IEEE80211_SCTL_SEQ;
851 le16_add_cpu(&hdr->seq_ctrl, 0x10);
852 }
853
854
855
856
857
858
859
860 if (shared_queue)
861 iwl_trans_txq_set_shared_mode(mvm->trans, queue, true);
862
863 spin_lock_bh(&mvmsta->lock);
864
865
866
867
868
869 if (inc_ssn)
870 mvmsta->tid_data[tid].seq_number += 0x10;
871 mvmsta->tid_data[tid].txq_id = queue;
872 mvmsta->tid_data[tid].is_tid_active = true;
873 mvmsta->tfd_queue_msk |= BIT(queue);
874 queue_state = mvmsta->tid_data[tid].state;
875
876 if (mvmsta->reserved_queue == queue)
877 mvmsta->reserved_queue = IEEE80211_INVAL_HW_QUEUE;
878 spin_unlock_bh(&mvmsta->lock);
879
880 if (!shared_queue) {
881 ret = iwl_mvm_sta_send_to_fw(mvm, sta, true, STA_MODIFY_QUEUES);
882 if (ret)
883 goto out_err;
884
885
886 if (queue_state == IWL_AGG_ON) {
887 ret = iwl_mvm_sta_tx_agg(mvm, sta, tid, queue, true);
888 if (ret)
889 goto out_err;
890 }
891 } else {
892
893 ret = iwl_mvm_scd_queue_redirect(mvm, queue, tid, ac, ssn,
894 wdg_timeout, false);
895 if (ret)
896 goto out_err;
897 }
898
899 return 0;
900
901out_err:
902 iwl_mvm_disable_txq(mvm, queue, mac_queue, tid, 0);
903
904 return ret;
905}
906
907static void iwl_mvm_change_queue_owner(struct iwl_mvm *mvm, int queue)
908{
909 struct iwl_scd_txq_cfg_cmd cmd = {
910 .scd_queue = queue,
911 .action = SCD_CFG_UPDATE_QUEUE_TID,
912 };
913 int tid;
914 unsigned long tid_bitmap;
915 int ret;
916
917 lockdep_assert_held(&mvm->mutex);
918
919 if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
920 return;
921
922 spin_lock_bh(&mvm->queue_info_lock);
923 tid_bitmap = mvm->queue_info[queue].tid_bitmap;
924 spin_unlock_bh(&mvm->queue_info_lock);
925
926 if (WARN(!tid_bitmap, "TXQ %d has no tids assigned to it\n", queue))
927 return;
928
929
930 tid = find_first_bit(&tid_bitmap, IWL_MAX_TID_COUNT + 1);
931 cmd.tid = tid;
932 cmd.tx_fifo = iwl_mvm_ac_to_tx_fifo[tid_to_mac80211_ac[tid]];
933
934 ret = iwl_mvm_send_cmd_pdu(mvm, SCD_QUEUE_CFG, 0, sizeof(cmd), &cmd);
935 if (ret) {
936 IWL_ERR(mvm, "Failed to update owner of TXQ %d (ret=%d)\n",
937 queue, ret);
938 return;
939 }
940
941 spin_lock_bh(&mvm->queue_info_lock);
942 mvm->queue_info[queue].txq_tid = tid;
943 spin_unlock_bh(&mvm->queue_info_lock);
944 IWL_DEBUG_TX_QUEUES(mvm, "Changed TXQ %d ownership to tid %d\n",
945 queue, tid);
946}
947
948static void iwl_mvm_unshare_queue(struct iwl_mvm *mvm, int queue)
949{
950 struct ieee80211_sta *sta;
951 struct iwl_mvm_sta *mvmsta;
952 u8 sta_id;
953 int tid = -1;
954 unsigned long tid_bitmap;
955 unsigned int wdg_timeout;
956 int ssn;
957 int ret = true;
958
959
960 if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
961 return;
962
963 lockdep_assert_held(&mvm->mutex);
964
965 spin_lock_bh(&mvm->queue_info_lock);
966 sta_id = mvm->queue_info[queue].ra_sta_id;
967 tid_bitmap = mvm->queue_info[queue].tid_bitmap;
968 spin_unlock_bh(&mvm->queue_info_lock);
969
970
971 tid = find_first_bit(&tid_bitmap, IWL_MAX_TID_COUNT + 1);
972 if (tid_bitmap != BIT(tid)) {
973 IWL_ERR(mvm, "Failed to unshare q %d, active tids=0x%lx\n",
974 queue, tid_bitmap);
975 return;
976 }
977
978 IWL_DEBUG_TX_QUEUES(mvm, "Unsharing TXQ %d, keeping tid %d\n", queue,
979 tid);
980
981 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
982 lockdep_is_held(&mvm->mutex));
983
984 if (WARN_ON_ONCE(IS_ERR_OR_NULL(sta)))
985 return;
986
987 mvmsta = iwl_mvm_sta_from_mac80211(sta);
988 wdg_timeout = iwl_mvm_get_wd_timeout(mvm, mvmsta->vif, false, false);
989
990 ssn = IEEE80211_SEQ_TO_SN(mvmsta->tid_data[tid].seq_number);
991
992 ret = iwl_mvm_scd_queue_redirect(mvm, queue, tid,
993 tid_to_mac80211_ac[tid], ssn,
994 wdg_timeout, true);
995 if (ret) {
996 IWL_ERR(mvm, "Failed to redirect TXQ %d\n", queue);
997 return;
998 }
999
1000
1001 if (mvmsta->tid_data[tid].state == IWL_AGG_ON) {
1002 struct iwl_mvm_add_sta_cmd cmd = {0};
1003
1004 mvmsta->tid_disable_agg &= ~BIT(tid);
1005
1006 cmd.mac_id_n_color = cpu_to_le32(mvmsta->mac_id_n_color);
1007 cmd.sta_id = mvmsta->sta_id;
1008 cmd.add_modify = STA_MODE_MODIFY;
1009 cmd.modify_mask = STA_MODIFY_TID_DISABLE_TX;
1010 cmd.tfd_queue_msk = cpu_to_le32(mvmsta->tfd_queue_msk);
1011 cmd.tid_disable_tx = cpu_to_le16(mvmsta->tid_disable_agg);
1012
1013 ret = iwl_mvm_send_cmd_pdu(mvm, ADD_STA, CMD_ASYNC,
1014 iwl_mvm_add_sta_cmd_size(mvm), &cmd);
1015 if (!ret) {
1016 IWL_DEBUG_TX_QUEUES(mvm,
1017 "TXQ #%d is now aggregated again\n",
1018 queue);
1019
1020
1021 iwl_trans_txq_set_shared_mode(mvm->trans, queue, false);
1022 }
1023 }
1024
1025 spin_lock_bh(&mvm->queue_info_lock);
1026 mvm->queue_info[queue].status = IWL_MVM_QUEUE_READY;
1027 spin_unlock_bh(&mvm->queue_info_lock);
1028}
1029
1030static inline u8 iwl_mvm_tid_to_ac_queue(int tid)
1031{
1032 if (tid == IWL_MAX_TID_COUNT)
1033 return IEEE80211_AC_VO;
1034
1035 return tid_to_mac80211_ac[tid];
1036}
1037
1038static void iwl_mvm_tx_deferred_stream(struct iwl_mvm *mvm,
1039 struct ieee80211_sta *sta, int tid)
1040{
1041 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1042 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
1043 struct sk_buff *skb;
1044 struct ieee80211_hdr *hdr;
1045 struct sk_buff_head deferred_tx;
1046 u8 mac_queue;
1047 bool no_queue = false;
1048 u8 ac;
1049
1050 lockdep_assert_held(&mvm->mutex);
1051
1052 skb = skb_peek(&tid_data->deferred_tx_frames);
1053 if (!skb)
1054 return;
1055 hdr = (void *)skb->data;
1056
1057 ac = iwl_mvm_tid_to_ac_queue(tid);
1058 mac_queue = IEEE80211_SKB_CB(skb)->hw_queue;
1059
1060 if (tid_data->txq_id == IWL_MVM_INVALID_QUEUE &&
1061 iwl_mvm_sta_alloc_queue(mvm, sta, ac, tid, hdr)) {
1062 IWL_ERR(mvm,
1063 "Can't alloc TXQ for sta %d tid %d - dropping frame\n",
1064 mvmsta->sta_id, tid);
1065
1066
1067
1068
1069
1070 no_queue = true;
1071 }
1072
1073 __skb_queue_head_init(&deferred_tx);
1074
1075
1076 local_bh_disable();
1077 spin_lock(&mvmsta->lock);
1078 skb_queue_splice_init(&tid_data->deferred_tx_frames, &deferred_tx);
1079 mvmsta->deferred_traffic_tid_map &= ~BIT(tid);
1080 spin_unlock(&mvmsta->lock);
1081
1082 while ((skb = __skb_dequeue(&deferred_tx)))
1083 if (no_queue || iwl_mvm_tx_skb(mvm, skb, sta))
1084 ieee80211_free_txskb(mvm->hw, skb);
1085 local_bh_enable();
1086
1087
1088 iwl_mvm_start_mac_queues(mvm, BIT(mac_queue));
1089}
1090
1091void iwl_mvm_add_new_dqa_stream_wk(struct work_struct *wk)
1092{
1093 struct iwl_mvm *mvm = container_of(wk, struct iwl_mvm,
1094 add_stream_wk);
1095 struct ieee80211_sta *sta;
1096 struct iwl_mvm_sta *mvmsta;
1097 unsigned long deferred_tid_traffic;
1098 int queue, sta_id, tid;
1099
1100
1101 iwl_mvm_inactivity_check(mvm);
1102
1103 mutex_lock(&mvm->mutex);
1104
1105
1106 if (iwl_mvm_has_new_tx_api(mvm))
1107 goto alloc_queues;
1108
1109
1110 for (queue = 0; queue < ARRAY_SIZE(mvm->queue_info); queue++) {
1111 bool reconfig;
1112 bool change_owner;
1113
1114 spin_lock_bh(&mvm->queue_info_lock);
1115 reconfig = (mvm->queue_info[queue].status ==
1116 IWL_MVM_QUEUE_RECONFIGURING);
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126 change_owner = !(mvm->queue_info[queue].tid_bitmap &
1127 BIT(mvm->queue_info[queue].txq_tid)) &&
1128 (mvm->queue_info[queue].status ==
1129 IWL_MVM_QUEUE_SHARED);
1130 spin_unlock_bh(&mvm->queue_info_lock);
1131
1132 if (reconfig)
1133 iwl_mvm_unshare_queue(mvm, queue);
1134 else if (change_owner)
1135 iwl_mvm_change_queue_owner(mvm, queue);
1136 }
1137
1138alloc_queues:
1139
1140 for_each_set_bit(sta_id, mvm->sta_deferred_frames,
1141 IWL_MVM_STATION_COUNT) {
1142 clear_bit(sta_id, mvm->sta_deferred_frames);
1143 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
1144 lockdep_is_held(&mvm->mutex));
1145 if (IS_ERR_OR_NULL(sta))
1146 continue;
1147
1148 mvmsta = iwl_mvm_sta_from_mac80211(sta);
1149 deferred_tid_traffic = mvmsta->deferred_traffic_tid_map;
1150
1151 for_each_set_bit(tid, &deferred_tid_traffic,
1152 IWL_MAX_TID_COUNT + 1)
1153 iwl_mvm_tx_deferred_stream(mvm, sta, tid);
1154 }
1155
1156 mutex_unlock(&mvm->mutex);
1157}
1158
1159static int iwl_mvm_reserve_sta_stream(struct iwl_mvm *mvm,
1160 struct ieee80211_sta *sta,
1161 enum nl80211_iftype vif_type)
1162{
1163 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1164 int queue;
1165 bool using_inactive_queue = false, same_sta = false;
1166
1167
1168 if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
1169 return 0;
1170
1171
1172
1173
1174
1175 iwl_mvm_inactivity_check(mvm);
1176
1177 spin_lock_bh(&mvm->queue_info_lock);
1178
1179
1180 if (vif_type == NL80211_IFTYPE_STATION && !sta->tdls &&
1181 !mvm->queue_info[IWL_MVM_DQA_BSS_CLIENT_QUEUE].hw_queue_refcount &&
1182 (mvm->queue_info[IWL_MVM_DQA_BSS_CLIENT_QUEUE].status ==
1183 IWL_MVM_QUEUE_FREE))
1184 queue = IWL_MVM_DQA_BSS_CLIENT_QUEUE;
1185 else
1186 queue = iwl_mvm_find_free_queue(mvm, mvmsta->sta_id,
1187 IWL_MVM_DQA_MIN_DATA_QUEUE,
1188 IWL_MVM_DQA_MAX_DATA_QUEUE);
1189 if (queue < 0) {
1190 spin_unlock_bh(&mvm->queue_info_lock);
1191 IWL_ERR(mvm, "No available queues for new station\n");
1192 return -ENOSPC;
1193 } else if (mvm->queue_info[queue].status == IWL_MVM_QUEUE_INACTIVE) {
1194
1195
1196
1197
1198
1199 using_inactive_queue = true;
1200 same_sta = mvm->queue_info[queue].ra_sta_id == mvmsta->sta_id;
1201 }
1202 mvm->queue_info[queue].status = IWL_MVM_QUEUE_RESERVED;
1203
1204 spin_unlock_bh(&mvm->queue_info_lock);
1205
1206 mvmsta->reserved_queue = queue;
1207
1208 if (using_inactive_queue)
1209 iwl_mvm_free_inactive_queue(mvm, queue, same_sta);
1210
1211 IWL_DEBUG_TX_QUEUES(mvm, "Reserving data queue #%d for sta_id %d\n",
1212 queue, mvmsta->sta_id);
1213
1214 return 0;
1215}
1216
1217
1218
1219
1220
1221
1222
1223
1224static void iwl_mvm_realloc_queues_after_restart(struct iwl_mvm *mvm,
1225 struct iwl_mvm_sta *mvm_sta)
1226{
1227 unsigned int wdg_timeout =
1228 iwl_mvm_get_wd_timeout(mvm, mvm_sta->vif, false, false);
1229 int i;
1230 struct iwl_trans_txq_scd_cfg cfg = {
1231 .sta_id = mvm_sta->sta_id,
1232 .frame_limit = IWL_FRAME_LIMIT,
1233 };
1234
1235
1236 if (mvm_sta->reserved_queue != IEEE80211_INVAL_HW_QUEUE)
1237 mvm->queue_info[mvm_sta->reserved_queue].status =
1238 IWL_MVM_QUEUE_RESERVED;
1239
1240 for (i = 0; i <= IWL_MAX_TID_COUNT; i++) {
1241 struct iwl_mvm_tid_data *tid_data = &mvm_sta->tid_data[i];
1242 int txq_id = tid_data->txq_id;
1243 int ac;
1244 u8 mac_queue;
1245
1246 if (txq_id == IWL_MVM_INVALID_QUEUE)
1247 continue;
1248
1249 skb_queue_head_init(&tid_data->deferred_tx_frames);
1250
1251 ac = tid_to_mac80211_ac[i];
1252 mac_queue = mvm_sta->vif->hw_queue[ac];
1253
1254 if (iwl_mvm_has_new_tx_api(mvm)) {
1255 IWL_DEBUG_TX_QUEUES(mvm,
1256 "Re-mapping sta %d tid %d\n",
1257 mvm_sta->sta_id, i);
1258 txq_id = iwl_mvm_tvqm_enable_txq(mvm, mac_queue,
1259 mvm_sta->sta_id,
1260 i, wdg_timeout);
1261 tid_data->txq_id = txq_id;
1262
1263
1264
1265
1266
1267
1268
1269 tid_data->seq_number = 0;
1270 } else {
1271 u16 seq = IEEE80211_SEQ_TO_SN(tid_data->seq_number);
1272
1273 cfg.tid = i;
1274 cfg.fifo = iwl_mvm_mac_ac_to_tx_fifo(mvm, ac);
1275 cfg.aggregate = (txq_id >= IWL_MVM_DQA_MIN_DATA_QUEUE ||
1276 txq_id ==
1277 IWL_MVM_DQA_BSS_CLIENT_QUEUE);
1278
1279 IWL_DEBUG_TX_QUEUES(mvm,
1280 "Re-mapping sta %d tid %d to queue %d\n",
1281 mvm_sta->sta_id, i, txq_id);
1282
1283 iwl_mvm_enable_txq(mvm, txq_id, mac_queue, seq, &cfg,
1284 wdg_timeout);
1285 mvm->queue_info[txq_id].status = IWL_MVM_QUEUE_READY;
1286 }
1287 }
1288}
1289
1290static int iwl_mvm_add_int_sta_common(struct iwl_mvm *mvm,
1291 struct iwl_mvm_int_sta *sta,
1292 const u8 *addr,
1293 u16 mac_id, u16 color)
1294{
1295 struct iwl_mvm_add_sta_cmd cmd;
1296 int ret;
1297 u32 status = ADD_STA_SUCCESS;
1298
1299 lockdep_assert_held(&mvm->mutex);
1300
1301 memset(&cmd, 0, sizeof(cmd));
1302 cmd.sta_id = sta->sta_id;
1303 cmd.mac_id_n_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mac_id,
1304 color));
1305 if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE))
1306 cmd.station_type = sta->type;
1307
1308 if (!iwl_mvm_has_new_tx_api(mvm))
1309 cmd.tfd_queue_msk = cpu_to_le32(sta->tfd_queue_msk);
1310 cmd.tid_disable_tx = cpu_to_le16(0xffff);
1311
1312 if (addr)
1313 memcpy(cmd.addr, addr, ETH_ALEN);
1314
1315 ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA,
1316 iwl_mvm_add_sta_cmd_size(mvm),
1317 &cmd, &status);
1318 if (ret)
1319 return ret;
1320
1321 switch (status & IWL_ADD_STA_STATUS_MASK) {
1322 case ADD_STA_SUCCESS:
1323 IWL_DEBUG_INFO(mvm, "Internal station added.\n");
1324 return 0;
1325 default:
1326 ret = -EIO;
1327 IWL_ERR(mvm, "Add internal station failed, status=0x%x\n",
1328 status);
1329 break;
1330 }
1331 return ret;
1332}
1333
1334int iwl_mvm_add_sta(struct iwl_mvm *mvm,
1335 struct ieee80211_vif *vif,
1336 struct ieee80211_sta *sta)
1337{
1338 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1339 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
1340 struct iwl_mvm_rxq_dup_data *dup_data;
1341 int i, ret, sta_id;
1342 bool sta_update = false;
1343 unsigned int sta_flags = 0;
1344
1345 lockdep_assert_held(&mvm->mutex);
1346
1347 if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1348 sta_id = iwl_mvm_find_free_sta_id(mvm,
1349 ieee80211_vif_type_p2p(vif));
1350 else
1351 sta_id = mvm_sta->sta_id;
1352
1353 if (sta_id == IWL_MVM_INVALID_STA)
1354 return -ENOSPC;
1355
1356 spin_lock_init(&mvm_sta->lock);
1357
1358
1359 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
1360 struct iwl_mvm_int_sta tmp_sta = {
1361 .sta_id = sta_id,
1362 .type = mvm_sta->sta_type,
1363 };
1364
1365
1366
1367
1368
1369 ret = iwl_mvm_add_int_sta_common(mvm, &tmp_sta, sta->addr,
1370 mvmvif->id, mvmvif->color);
1371 if (ret)
1372 goto err;
1373
1374 iwl_mvm_realloc_queues_after_restart(mvm, mvm_sta);
1375 sta_update = true;
1376 sta_flags = iwl_mvm_has_new_tx_api(mvm) ? 0 : STA_MODIFY_QUEUES;
1377 goto update_fw;
1378 }
1379
1380 mvm_sta->sta_id = sta_id;
1381 mvm_sta->mac_id_n_color = FW_CMD_ID_AND_COLOR(mvmvif->id,
1382 mvmvif->color);
1383 mvm_sta->vif = vif;
1384 if (!mvm->trans->cfg->gen2)
1385 mvm_sta->max_agg_bufsize = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
1386 else
1387 mvm_sta->max_agg_bufsize = LINK_QUAL_AGG_FRAME_LIMIT_GEN2_DEF;
1388 mvm_sta->tx_protection = 0;
1389 mvm_sta->tt_tx_protection = false;
1390 mvm_sta->sta_type = sta->tdls ? IWL_STA_TDLS_LINK : IWL_STA_LINK;
1391
1392
1393 mvm_sta->tid_disable_agg = 0xffff;
1394 mvm_sta->tfd_queue_msk = 0;
1395
1396
1397 for (i = 0; i <= IWL_MAX_TID_COUNT; i++) {
1398 u16 seq = mvm_sta->tid_data[i].seq_number;
1399 memset(&mvm_sta->tid_data[i], 0, sizeof(mvm_sta->tid_data[i]));
1400 mvm_sta->tid_data[i].seq_number = seq;
1401
1402
1403
1404
1405
1406 mvm_sta->tid_data[i].txq_id = IWL_MVM_INVALID_QUEUE;
1407 skb_queue_head_init(&mvm_sta->tid_data[i].deferred_tx_frames);
1408 }
1409 mvm_sta->deferred_traffic_tid_map = 0;
1410 mvm_sta->agg_tids = 0;
1411
1412 if (iwl_mvm_has_new_rx_api(mvm) &&
1413 !test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
1414 int q;
1415
1416 dup_data = kcalloc(mvm->trans->num_rx_queues,
1417 sizeof(*dup_data), GFP_KERNEL);
1418 if (!dup_data)
1419 return -ENOMEM;
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429 for (q = 0; q < mvm->trans->num_rx_queues; q++)
1430 memset(dup_data[q].last_seq, 0xff,
1431 sizeof(dup_data[q].last_seq));
1432 mvm_sta->dup_data = dup_data;
1433 }
1434
1435 if (!iwl_mvm_has_new_tx_api(mvm)) {
1436 ret = iwl_mvm_reserve_sta_stream(mvm, sta,
1437 ieee80211_vif_type_p2p(vif));
1438 if (ret)
1439 goto err;
1440 }
1441
1442
1443
1444
1445
1446 if (iwl_mvm_has_tlc_offload(mvm))
1447 iwl_mvm_rs_add_sta(mvm, mvm_sta);
1448
1449update_fw:
1450 ret = iwl_mvm_sta_send_to_fw(mvm, sta, sta_update, sta_flags);
1451 if (ret)
1452 goto err;
1453
1454 if (vif->type == NL80211_IFTYPE_STATION) {
1455 if (!sta->tdls) {
1456 WARN_ON(mvmvif->ap_sta_id != IWL_MVM_INVALID_STA);
1457 mvmvif->ap_sta_id = sta_id;
1458 } else {
1459 WARN_ON(mvmvif->ap_sta_id == IWL_MVM_INVALID_STA);
1460 }
1461 }
1462
1463 rcu_assign_pointer(mvm->fw_id_to_mac_id[sta_id], sta);
1464
1465 return 0;
1466
1467err:
1468 return ret;
1469}
1470
1471int iwl_mvm_drain_sta(struct iwl_mvm *mvm, struct iwl_mvm_sta *mvmsta,
1472 bool drain)
1473{
1474 struct iwl_mvm_add_sta_cmd cmd = {};
1475 int ret;
1476 u32 status;
1477
1478 lockdep_assert_held(&mvm->mutex);
1479
1480 cmd.mac_id_n_color = cpu_to_le32(mvmsta->mac_id_n_color);
1481 cmd.sta_id = mvmsta->sta_id;
1482 cmd.add_modify = STA_MODE_MODIFY;
1483 cmd.station_flags = drain ? cpu_to_le32(STA_FLG_DRAIN_FLOW) : 0;
1484 cmd.station_flags_msk = cpu_to_le32(STA_FLG_DRAIN_FLOW);
1485
1486 status = ADD_STA_SUCCESS;
1487 ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA,
1488 iwl_mvm_add_sta_cmd_size(mvm),
1489 &cmd, &status);
1490 if (ret)
1491 return ret;
1492
1493 switch (status & IWL_ADD_STA_STATUS_MASK) {
1494 case ADD_STA_SUCCESS:
1495 IWL_DEBUG_INFO(mvm, "Frames for staid %d will drained in fw\n",
1496 mvmsta->sta_id);
1497 break;
1498 default:
1499 ret = -EIO;
1500 IWL_ERR(mvm, "Couldn't drain frames for staid %d\n",
1501 mvmsta->sta_id);
1502 break;
1503 }
1504
1505 return ret;
1506}
1507
1508
1509
1510
1511
1512
1513static int iwl_mvm_rm_sta_common(struct iwl_mvm *mvm, u8 sta_id)
1514{
1515 struct ieee80211_sta *sta;
1516 struct iwl_mvm_rm_sta_cmd rm_sta_cmd = {
1517 .sta_id = sta_id,
1518 };
1519 int ret;
1520
1521 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
1522 lockdep_is_held(&mvm->mutex));
1523
1524
1525 if (!sta) {
1526 IWL_ERR(mvm, "Invalid station id\n");
1527 return -EINVAL;
1528 }
1529
1530 ret = iwl_mvm_send_cmd_pdu(mvm, REMOVE_STA, 0,
1531 sizeof(rm_sta_cmd), &rm_sta_cmd);
1532 if (ret) {
1533 IWL_ERR(mvm, "Failed to remove station. Id=%d\n", sta_id);
1534 return ret;
1535 }
1536
1537 return 0;
1538}
1539
1540static void iwl_mvm_disable_sta_queues(struct iwl_mvm *mvm,
1541 struct ieee80211_vif *vif,
1542 struct iwl_mvm_sta *mvm_sta)
1543{
1544 int ac;
1545 int i;
1546
1547 lockdep_assert_held(&mvm->mutex);
1548
1549 for (i = 0; i < ARRAY_SIZE(mvm_sta->tid_data); i++) {
1550 if (mvm_sta->tid_data[i].txq_id == IWL_MVM_INVALID_QUEUE)
1551 continue;
1552
1553 ac = iwl_mvm_tid_to_ac_queue(i);
1554 iwl_mvm_disable_txq(mvm, mvm_sta->tid_data[i].txq_id,
1555 vif->hw_queue[ac], i, 0);
1556 mvm_sta->tid_data[i].txq_id = IWL_MVM_INVALID_QUEUE;
1557 }
1558}
1559
1560int iwl_mvm_wait_sta_queues_empty(struct iwl_mvm *mvm,
1561 struct iwl_mvm_sta *mvm_sta)
1562{
1563 int i;
1564
1565 for (i = 0; i < ARRAY_SIZE(mvm_sta->tid_data); i++) {
1566 u16 txq_id;
1567 int ret;
1568
1569 spin_lock_bh(&mvm_sta->lock);
1570 txq_id = mvm_sta->tid_data[i].txq_id;
1571 spin_unlock_bh(&mvm_sta->lock);
1572
1573 if (txq_id == IWL_MVM_INVALID_QUEUE)
1574 continue;
1575
1576 ret = iwl_trans_wait_txq_empty(mvm->trans, txq_id);
1577 if (ret)
1578 return ret;
1579 }
1580
1581 return 0;
1582}
1583
1584int iwl_mvm_rm_sta(struct iwl_mvm *mvm,
1585 struct ieee80211_vif *vif,
1586 struct ieee80211_sta *sta)
1587{
1588 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1589 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
1590 u8 sta_id = mvm_sta->sta_id;
1591 int ret;
1592
1593 lockdep_assert_held(&mvm->mutex);
1594
1595 if (iwl_mvm_has_new_rx_api(mvm))
1596 kfree(mvm_sta->dup_data);
1597
1598 ret = iwl_mvm_drain_sta(mvm, mvm_sta, true);
1599 if (ret)
1600 return ret;
1601
1602
1603 ret = iwl_mvm_flush_sta(mvm, mvm_sta, false, 0);
1604 if (ret)
1605 return ret;
1606 if (iwl_mvm_has_new_tx_api(mvm)) {
1607 ret = iwl_mvm_wait_sta_queues_empty(mvm, mvm_sta);
1608 } else {
1609 u32 q_mask = mvm_sta->tfd_queue_msk;
1610
1611 ret = iwl_trans_wait_tx_queues_empty(mvm->trans,
1612 q_mask);
1613 }
1614 if (ret)
1615 return ret;
1616
1617 ret = iwl_mvm_drain_sta(mvm, mvm_sta, false);
1618
1619 iwl_mvm_disable_sta_queues(mvm, vif, mvm_sta);
1620
1621
1622 if (mvm_sta->reserved_queue != IEEE80211_INVAL_HW_QUEUE) {
1623 u8 reserved_txq = mvm_sta->reserved_queue;
1624 enum iwl_mvm_queue_status *status;
1625
1626
1627
1628
1629
1630
1631 spin_lock_bh(&mvm->queue_info_lock);
1632 status = &mvm->queue_info[reserved_txq].status;
1633 if (WARN((*status != IWL_MVM_QUEUE_RESERVED) &&
1634 (*status != IWL_MVM_QUEUE_FREE),
1635 "sta_id %d reserved txq %d status %d",
1636 sta_id, reserved_txq, *status)) {
1637 spin_unlock_bh(&mvm->queue_info_lock);
1638 return -EINVAL;
1639 }
1640
1641 *status = IWL_MVM_QUEUE_FREE;
1642 spin_unlock_bh(&mvm->queue_info_lock);
1643 }
1644
1645 if (vif->type == NL80211_IFTYPE_STATION &&
1646 mvmvif->ap_sta_id == sta_id) {
1647
1648 if (vif->bss_conf.assoc)
1649 return ret;
1650
1651
1652 mvmvif->ap_sta_id = IWL_MVM_INVALID_STA;
1653
1654
1655 if (mvm->d0i3_ap_sta_id == sta_id)
1656 mvm->d0i3_ap_sta_id = IWL_MVM_INVALID_STA;
1657 }
1658
1659
1660
1661
1662
1663 if (WARN_ON_ONCE(mvm->tdls_cs.peer.sta_id == sta_id)) {
1664 mvm->tdls_cs.peer.sta_id = IWL_MVM_INVALID_STA;
1665 cancel_delayed_work(&mvm->tdls_cs.dwork);
1666 }
1667
1668
1669
1670
1671
1672 spin_lock_bh(&mvm_sta->lock);
1673 spin_unlock_bh(&mvm_sta->lock);
1674
1675 ret = iwl_mvm_rm_sta_common(mvm, mvm_sta->sta_id);
1676 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[mvm_sta->sta_id], NULL);
1677
1678 return ret;
1679}
1680
1681int iwl_mvm_rm_sta_id(struct iwl_mvm *mvm,
1682 struct ieee80211_vif *vif,
1683 u8 sta_id)
1684{
1685 int ret = iwl_mvm_rm_sta_common(mvm, sta_id);
1686
1687 lockdep_assert_held(&mvm->mutex);
1688
1689 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[sta_id], NULL);
1690 return ret;
1691}
1692
1693int iwl_mvm_allocate_int_sta(struct iwl_mvm *mvm,
1694 struct iwl_mvm_int_sta *sta,
1695 u32 qmask, enum nl80211_iftype iftype,
1696 enum iwl_sta_type type)
1697{
1698 if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) ||
1699 sta->sta_id == IWL_MVM_INVALID_STA) {
1700 sta->sta_id = iwl_mvm_find_free_sta_id(mvm, iftype);
1701 if (WARN_ON_ONCE(sta->sta_id == IWL_MVM_INVALID_STA))
1702 return -ENOSPC;
1703 }
1704
1705 sta->tfd_queue_msk = qmask;
1706 sta->type = type;
1707
1708
1709 rcu_assign_pointer(mvm->fw_id_to_mac_id[sta->sta_id], ERR_PTR(-EINVAL));
1710 return 0;
1711}
1712
1713void iwl_mvm_dealloc_int_sta(struct iwl_mvm *mvm, struct iwl_mvm_int_sta *sta)
1714{
1715 RCU_INIT_POINTER(mvm->fw_id_to_mac_id[sta->sta_id], NULL);
1716 memset(sta, 0, sizeof(struct iwl_mvm_int_sta));
1717 sta->sta_id = IWL_MVM_INVALID_STA;
1718}
1719
1720static void iwl_mvm_enable_aux_snif_queue(struct iwl_mvm *mvm, u16 *queue,
1721 u8 sta_id, u8 fifo)
1722{
1723 unsigned int wdg_timeout = iwlmvm_mod_params.tfd_q_hang_detect ?
1724 mvm->cfg->base_params->wd_timeout :
1725 IWL_WATCHDOG_DISABLED;
1726
1727 if (iwl_mvm_has_new_tx_api(mvm)) {
1728 int tvqm_queue =
1729 iwl_mvm_tvqm_enable_txq(mvm, *queue, sta_id,
1730 IWL_MAX_TID_COUNT,
1731 wdg_timeout);
1732 *queue = tvqm_queue;
1733 } else {
1734 struct iwl_trans_txq_scd_cfg cfg = {
1735 .fifo = fifo,
1736 .sta_id = sta_id,
1737 .tid = IWL_MAX_TID_COUNT,
1738 .aggregate = false,
1739 .frame_limit = IWL_FRAME_LIMIT,
1740 };
1741
1742 iwl_mvm_enable_txq(mvm, *queue, *queue, 0, &cfg, wdg_timeout);
1743 }
1744}
1745
1746int iwl_mvm_add_aux_sta(struct iwl_mvm *mvm)
1747{
1748 int ret;
1749
1750 lockdep_assert_held(&mvm->mutex);
1751
1752
1753 ret = iwl_mvm_allocate_int_sta(mvm, &mvm->aux_sta, BIT(mvm->aux_queue),
1754 NL80211_IFTYPE_UNSPECIFIED,
1755 IWL_STA_AUX_ACTIVITY);
1756 if (ret)
1757 return ret;
1758
1759
1760 if (!iwl_mvm_has_new_tx_api(mvm))
1761 iwl_mvm_enable_aux_snif_queue(mvm, &mvm->aux_queue,
1762 mvm->aux_sta.sta_id,
1763 IWL_MVM_TX_FIFO_MCAST);
1764
1765 ret = iwl_mvm_add_int_sta_common(mvm, &mvm->aux_sta, NULL,
1766 MAC_INDEX_AUX, 0);
1767 if (ret) {
1768 iwl_mvm_dealloc_int_sta(mvm, &mvm->aux_sta);
1769 return ret;
1770 }
1771
1772
1773
1774
1775
1776 if (iwl_mvm_has_new_tx_api(mvm))
1777 iwl_mvm_enable_aux_snif_queue(mvm, &mvm->aux_queue,
1778 mvm->aux_sta.sta_id,
1779 IWL_MVM_TX_FIFO_MCAST);
1780
1781 return 0;
1782}
1783
1784int iwl_mvm_add_snif_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1785{
1786 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1787 int ret;
1788
1789 lockdep_assert_held(&mvm->mutex);
1790
1791
1792 if (!iwl_mvm_has_new_tx_api(mvm))
1793 iwl_mvm_enable_aux_snif_queue(mvm, &mvm->snif_queue,
1794 mvm->snif_sta.sta_id,
1795 IWL_MVM_TX_FIFO_BE);
1796
1797 ret = iwl_mvm_add_int_sta_common(mvm, &mvm->snif_sta, vif->addr,
1798 mvmvif->id, 0);
1799 if (ret)
1800 return ret;
1801
1802
1803
1804
1805
1806 if (iwl_mvm_has_new_tx_api(mvm))
1807 iwl_mvm_enable_aux_snif_queue(mvm, &mvm->snif_queue,
1808 mvm->snif_sta.sta_id,
1809 IWL_MVM_TX_FIFO_BE);
1810
1811 return 0;
1812}
1813
1814int iwl_mvm_rm_snif_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1815{
1816 int ret;
1817
1818 lockdep_assert_held(&mvm->mutex);
1819
1820 iwl_mvm_disable_txq(mvm, mvm->snif_queue, mvm->snif_queue,
1821 IWL_MAX_TID_COUNT, 0);
1822 ret = iwl_mvm_rm_sta_common(mvm, mvm->snif_sta.sta_id);
1823 if (ret)
1824 IWL_WARN(mvm, "Failed sending remove station\n");
1825
1826 return ret;
1827}
1828
1829void iwl_mvm_dealloc_snif_sta(struct iwl_mvm *mvm)
1830{
1831 iwl_mvm_dealloc_int_sta(mvm, &mvm->snif_sta);
1832}
1833
1834void iwl_mvm_del_aux_sta(struct iwl_mvm *mvm)
1835{
1836 lockdep_assert_held(&mvm->mutex);
1837
1838 iwl_mvm_dealloc_int_sta(mvm, &mvm->aux_sta);
1839}
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849int iwl_mvm_send_add_bcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1850{
1851 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1852 struct iwl_mvm_int_sta *bsta = &mvmvif->bcast_sta;
1853 static const u8 _baddr[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
1854 const u8 *baddr = _baddr;
1855 int queue;
1856 int ret;
1857 unsigned int wdg_timeout =
1858 iwl_mvm_get_wd_timeout(mvm, vif, false, false);
1859 struct iwl_trans_txq_scd_cfg cfg = {
1860 .fifo = IWL_MVM_TX_FIFO_VO,
1861 .sta_id = mvmvif->bcast_sta.sta_id,
1862 .tid = IWL_MAX_TID_COUNT,
1863 .aggregate = false,
1864 .frame_limit = IWL_FRAME_LIMIT,
1865 };
1866
1867 lockdep_assert_held(&mvm->mutex);
1868
1869 if (!iwl_mvm_has_new_tx_api(mvm)) {
1870 if (vif->type == NL80211_IFTYPE_AP ||
1871 vif->type == NL80211_IFTYPE_ADHOC)
1872 queue = mvm->probe_queue;
1873 else if (vif->type == NL80211_IFTYPE_P2P_DEVICE)
1874 queue = mvm->p2p_dev_queue;
1875 else if (WARN(1, "Missing required TXQ for adding bcast STA\n"))
1876 return -EINVAL;
1877
1878 bsta->tfd_queue_msk |= BIT(queue);
1879
1880 iwl_mvm_enable_txq(mvm, queue, vif->hw_queue[0], 0,
1881 &cfg, wdg_timeout);
1882 }
1883
1884 if (vif->type == NL80211_IFTYPE_ADHOC)
1885 baddr = vif->bss_conf.bssid;
1886
1887 if (WARN_ON_ONCE(bsta->sta_id == IWL_MVM_INVALID_STA))
1888 return -ENOSPC;
1889
1890 ret = iwl_mvm_add_int_sta_common(mvm, bsta, baddr,
1891 mvmvif->id, mvmvif->color);
1892 if (ret)
1893 return ret;
1894
1895
1896
1897
1898
1899 if (iwl_mvm_has_new_tx_api(mvm)) {
1900 queue = iwl_mvm_tvqm_enable_txq(mvm, vif->hw_queue[0],
1901 bsta->sta_id,
1902 IWL_MAX_TID_COUNT,
1903 wdg_timeout);
1904
1905 if (vif->type == NL80211_IFTYPE_AP ||
1906 vif->type == NL80211_IFTYPE_ADHOC)
1907 mvm->probe_queue = queue;
1908 else if (vif->type == NL80211_IFTYPE_P2P_DEVICE)
1909 mvm->p2p_dev_queue = queue;
1910 }
1911
1912 return 0;
1913}
1914
1915static void iwl_mvm_free_bcast_sta_queues(struct iwl_mvm *mvm,
1916 struct ieee80211_vif *vif)
1917{
1918 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1919 int queue;
1920
1921 lockdep_assert_held(&mvm->mutex);
1922
1923 iwl_mvm_flush_sta(mvm, &mvmvif->bcast_sta, true, 0);
1924
1925 switch (vif->type) {
1926 case NL80211_IFTYPE_AP:
1927 case NL80211_IFTYPE_ADHOC:
1928 queue = mvm->probe_queue;
1929 break;
1930 case NL80211_IFTYPE_P2P_DEVICE:
1931 queue = mvm->p2p_dev_queue;
1932 break;
1933 default:
1934 WARN(1, "Can't free bcast queue on vif type %d\n",
1935 vif->type);
1936 return;
1937 }
1938
1939 iwl_mvm_disable_txq(mvm, queue, vif->hw_queue[0], IWL_MAX_TID_COUNT, 0);
1940 if (iwl_mvm_has_new_tx_api(mvm))
1941 return;
1942
1943 WARN_ON(!(mvmvif->bcast_sta.tfd_queue_msk & BIT(queue)));
1944 mvmvif->bcast_sta.tfd_queue_msk &= ~BIT(queue);
1945}
1946
1947
1948
1949int iwl_mvm_send_rm_bcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1950{
1951 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1952 int ret;
1953
1954 lockdep_assert_held(&mvm->mutex);
1955
1956 iwl_mvm_free_bcast_sta_queues(mvm, vif);
1957
1958 ret = iwl_mvm_rm_sta_common(mvm, mvmvif->bcast_sta.sta_id);
1959 if (ret)
1960 IWL_WARN(mvm, "Failed sending remove station\n");
1961 return ret;
1962}
1963
1964int iwl_mvm_alloc_bcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1965{
1966 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1967
1968 lockdep_assert_held(&mvm->mutex);
1969
1970 return iwl_mvm_allocate_int_sta(mvm, &mvmvif->bcast_sta, 0,
1971 ieee80211_vif_type_p2p(vif),
1972 IWL_STA_GENERAL_PURPOSE);
1973}
1974
1975
1976
1977
1978
1979
1980
1981
1982int iwl_mvm_add_p2p_bcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1983{
1984 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1985 struct iwl_mvm_int_sta *bsta = &mvmvif->bcast_sta;
1986 int ret;
1987
1988 lockdep_assert_held(&mvm->mutex);
1989
1990 ret = iwl_mvm_alloc_bcast_sta(mvm, vif);
1991 if (ret)
1992 return ret;
1993
1994 ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
1995
1996 if (ret)
1997 iwl_mvm_dealloc_int_sta(mvm, bsta);
1998
1999 return ret;
2000}
2001
2002void iwl_mvm_dealloc_bcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
2003{
2004 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2005
2006 iwl_mvm_dealloc_int_sta(mvm, &mvmvif->bcast_sta);
2007}
2008
2009
2010
2011
2012
2013int iwl_mvm_rm_p2p_bcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
2014{
2015 int ret;
2016
2017 lockdep_assert_held(&mvm->mutex);
2018
2019 ret = iwl_mvm_send_rm_bcast_sta(mvm, vif);
2020
2021 iwl_mvm_dealloc_bcast_sta(mvm, vif);
2022
2023 return ret;
2024}
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034int iwl_mvm_add_mcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
2035{
2036 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2037 struct iwl_mvm_int_sta *msta = &mvmvif->mcast_sta;
2038 static const u8 _maddr[] = {0x03, 0x00, 0x00, 0x00, 0x00, 0x00};
2039 const u8 *maddr = _maddr;
2040 struct iwl_trans_txq_scd_cfg cfg = {
2041 .fifo = IWL_MVM_TX_FIFO_MCAST,
2042 .sta_id = msta->sta_id,
2043 .tid = 0,
2044 .aggregate = false,
2045 .frame_limit = IWL_FRAME_LIMIT,
2046 };
2047 unsigned int timeout = iwl_mvm_get_wd_timeout(mvm, vif, false, false);
2048 int ret;
2049
2050 lockdep_assert_held(&mvm->mutex);
2051
2052 if (WARN_ON(vif->type != NL80211_IFTYPE_AP &&
2053 vif->type != NL80211_IFTYPE_ADHOC))
2054 return -ENOTSUPP;
2055
2056
2057
2058
2059
2060
2061
2062 if (vif->type == NL80211_IFTYPE_ADHOC) {
2063 vif->cab_queue = IWL_MVM_DQA_GCAST_QUEUE;
2064 mvmvif->cab_queue = vif->cab_queue;
2065 }
2066
2067
2068
2069
2070
2071 if (!iwl_mvm_has_new_tx_api(mvm) &&
2072 fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE)) {
2073 iwl_mvm_enable_txq(mvm, vif->cab_queue, vif->cab_queue, 0,
2074 &cfg, timeout);
2075 msta->tfd_queue_msk |= BIT(vif->cab_queue);
2076 }
2077 ret = iwl_mvm_add_int_sta_common(mvm, msta, maddr,
2078 mvmvif->id, mvmvif->color);
2079 if (ret) {
2080 iwl_mvm_dealloc_int_sta(mvm, msta);
2081 return ret;
2082 }
2083
2084
2085
2086
2087
2088
2089
2090
2091 if (iwl_mvm_has_new_tx_api(mvm)) {
2092 int queue = iwl_mvm_tvqm_enable_txq(mvm, vif->cab_queue,
2093 msta->sta_id,
2094 0,
2095 timeout);
2096 mvmvif->cab_queue = queue;
2097 } else if (!fw_has_api(&mvm->fw->ucode_capa,
2098 IWL_UCODE_TLV_API_STA_TYPE))
2099 iwl_mvm_enable_txq(mvm, vif->cab_queue, vif->cab_queue, 0,
2100 &cfg, timeout);
2101
2102 return 0;
2103}
2104
2105
2106
2107
2108
2109int iwl_mvm_rm_mcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
2110{
2111 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2112 int ret;
2113
2114 lockdep_assert_held(&mvm->mutex);
2115
2116 iwl_mvm_flush_sta(mvm, &mvmvif->mcast_sta, true, 0);
2117
2118 iwl_mvm_disable_txq(mvm, mvmvif->cab_queue, vif->cab_queue,
2119 0, 0);
2120
2121 ret = iwl_mvm_rm_sta_common(mvm, mvmvif->mcast_sta.sta_id);
2122 if (ret)
2123 IWL_WARN(mvm, "Failed sending remove station\n");
2124
2125 return ret;
2126}
2127
2128#define IWL_MAX_RX_BA_SESSIONS 16
2129
2130static void iwl_mvm_sync_rxq_del_ba(struct iwl_mvm *mvm, u8 baid)
2131{
2132 struct iwl_mvm_delba_notif notif = {
2133 .metadata.type = IWL_MVM_RXQ_NOTIF_DEL_BA,
2134 .metadata.sync = 1,
2135 .delba.baid = baid,
2136 };
2137 iwl_mvm_sync_rx_queues_internal(mvm, (void *)¬if, sizeof(notif));
2138};
2139
2140static void iwl_mvm_free_reorder(struct iwl_mvm *mvm,
2141 struct iwl_mvm_baid_data *data)
2142{
2143 int i;
2144
2145 iwl_mvm_sync_rxq_del_ba(mvm, data->baid);
2146
2147 for (i = 0; i < mvm->trans->num_rx_queues; i++) {
2148 int j;
2149 struct iwl_mvm_reorder_buffer *reorder_buf =
2150 &data->reorder_buf[i];
2151 struct iwl_mvm_reorder_buf_entry *entries =
2152 &data->entries[i * data->entries_per_queue];
2153
2154 spin_lock_bh(&reorder_buf->lock);
2155 if (likely(!reorder_buf->num_stored)) {
2156 spin_unlock_bh(&reorder_buf->lock);
2157 continue;
2158 }
2159
2160
2161
2162
2163
2164
2165 WARN_ON(1);
2166
2167 for (j = 0; j < reorder_buf->buf_size; j++)
2168 __skb_queue_purge(&entries[j].e.frames);
2169
2170
2171
2172
2173
2174
2175
2176
2177 reorder_buf->removed = true;
2178 spin_unlock_bh(&reorder_buf->lock);
2179 del_timer_sync(&reorder_buf->reorder_timer);
2180 }
2181}
2182
2183static void iwl_mvm_init_reorder_buffer(struct iwl_mvm *mvm,
2184 struct iwl_mvm_baid_data *data,
2185 u16 ssn, u8 buf_size)
2186{
2187 int i;
2188
2189 for (i = 0; i < mvm->trans->num_rx_queues; i++) {
2190 struct iwl_mvm_reorder_buffer *reorder_buf =
2191 &data->reorder_buf[i];
2192 struct iwl_mvm_reorder_buf_entry *entries =
2193 &data->entries[i * data->entries_per_queue];
2194 int j;
2195
2196 reorder_buf->num_stored = 0;
2197 reorder_buf->head_sn = ssn;
2198 reorder_buf->buf_size = buf_size;
2199
2200 timer_setup(&reorder_buf->reorder_timer,
2201 iwl_mvm_reorder_timer_expired, 0);
2202 spin_lock_init(&reorder_buf->lock);
2203 reorder_buf->mvm = mvm;
2204 reorder_buf->queue = i;
2205 reorder_buf->valid = false;
2206 for (j = 0; j < reorder_buf->buf_size; j++)
2207 __skb_queue_head_init(&entries[j].e.frames);
2208 }
2209}
2210
2211int iwl_mvm_sta_rx_agg(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
2212 int tid, u16 ssn, bool start, u8 buf_size, u16 timeout)
2213{
2214 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
2215 struct iwl_mvm_add_sta_cmd cmd = {};
2216 struct iwl_mvm_baid_data *baid_data = NULL;
2217 int ret;
2218 u32 status;
2219
2220 lockdep_assert_held(&mvm->mutex);
2221
2222 if (start && mvm->rx_ba_sessions >= IWL_MAX_RX_BA_SESSIONS) {
2223 IWL_WARN(mvm, "Not enough RX BA SESSIONS\n");
2224 return -ENOSPC;
2225 }
2226
2227 if (iwl_mvm_has_new_rx_api(mvm) && start) {
2228 u16 reorder_buf_size = buf_size * sizeof(baid_data->entries[0]);
2229
2230
2231#ifndef __CHECKER__
2232
2233
2234
2235
2236
2237
2238 BUILD_BUG_ON(SMP_CACHE_BYTES % sizeof(baid_data->entries[0]) &&
2239 sizeof(baid_data->entries[0]) % SMP_CACHE_BYTES);
2240#endif
2241
2242
2243
2244
2245
2246
2247 reorder_buf_size = ALIGN(reorder_buf_size, SMP_CACHE_BYTES);
2248
2249
2250
2251
2252
2253 baid_data = kzalloc(sizeof(*baid_data) +
2254 mvm->trans->num_rx_queues *
2255 reorder_buf_size,
2256 GFP_KERNEL);
2257 if (!baid_data)
2258 return -ENOMEM;
2259
2260
2261
2262
2263
2264 baid_data->entries_per_queue =
2265 reorder_buf_size / sizeof(baid_data->entries[0]);
2266 }
2267
2268 cmd.mac_id_n_color = cpu_to_le32(mvm_sta->mac_id_n_color);
2269 cmd.sta_id = mvm_sta->sta_id;
2270 cmd.add_modify = STA_MODE_MODIFY;
2271 if (start) {
2272 cmd.add_immediate_ba_tid = (u8) tid;
2273 cmd.add_immediate_ba_ssn = cpu_to_le16(ssn);
2274 cmd.rx_ba_window = cpu_to_le16((u16)buf_size);
2275 } else {
2276 cmd.remove_immediate_ba_tid = (u8) tid;
2277 }
2278 cmd.modify_mask = start ? STA_MODIFY_ADD_BA_TID :
2279 STA_MODIFY_REMOVE_BA_TID;
2280
2281 status = ADD_STA_SUCCESS;
2282 ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA,
2283 iwl_mvm_add_sta_cmd_size(mvm),
2284 &cmd, &status);
2285 if (ret)
2286 goto out_free;
2287
2288 switch (status & IWL_ADD_STA_STATUS_MASK) {
2289 case ADD_STA_SUCCESS:
2290 IWL_DEBUG_HT(mvm, "RX BA Session %sed in fw\n",
2291 start ? "start" : "stopp");
2292 break;
2293 case ADD_STA_IMMEDIATE_BA_FAILURE:
2294 IWL_WARN(mvm, "RX BA Session refused by fw\n");
2295 ret = -ENOSPC;
2296 break;
2297 default:
2298 ret = -EIO;
2299 IWL_ERR(mvm, "RX BA Session failed %sing, status 0x%x\n",
2300 start ? "start" : "stopp", status);
2301 break;
2302 }
2303
2304 if (ret)
2305 goto out_free;
2306
2307 if (start) {
2308 u8 baid;
2309
2310 mvm->rx_ba_sessions++;
2311
2312 if (!iwl_mvm_has_new_rx_api(mvm))
2313 return 0;
2314
2315 if (WARN_ON(!(status & IWL_ADD_STA_BAID_VALID_MASK))) {
2316 ret = -EINVAL;
2317 goto out_free;
2318 }
2319 baid = (u8)((status & IWL_ADD_STA_BAID_MASK) >>
2320 IWL_ADD_STA_BAID_SHIFT);
2321 baid_data->baid = baid;
2322 baid_data->timeout = timeout;
2323 baid_data->last_rx = jiffies;
2324 baid_data->rcu_ptr = &mvm->baid_map[baid];
2325 timer_setup(&baid_data->session_timer,
2326 iwl_mvm_rx_agg_session_expired, 0);
2327 baid_data->mvm = mvm;
2328 baid_data->tid = tid;
2329 baid_data->sta_id = mvm_sta->sta_id;
2330
2331 mvm_sta->tid_to_baid[tid] = baid;
2332 if (timeout)
2333 mod_timer(&baid_data->session_timer,
2334 TU_TO_EXP_TIME(timeout * 2));
2335
2336 iwl_mvm_init_reorder_buffer(mvm, baid_data, ssn, buf_size);
2337
2338
2339
2340
2341
2342
2343 IWL_DEBUG_HT(mvm, "Sta %d(%d) is assigned to BAID %d\n",
2344 mvm_sta->sta_id, tid, baid);
2345 WARN_ON(rcu_access_pointer(mvm->baid_map[baid]));
2346 rcu_assign_pointer(mvm->baid_map[baid], baid_data);
2347 } else {
2348 u8 baid = mvm_sta->tid_to_baid[tid];
2349
2350 if (mvm->rx_ba_sessions > 0)
2351
2352 mvm->rx_ba_sessions--;
2353 if (!iwl_mvm_has_new_rx_api(mvm))
2354 return 0;
2355
2356 if (WARN_ON(baid == IWL_RX_REORDER_DATA_INVALID_BAID))
2357 return -EINVAL;
2358
2359 baid_data = rcu_access_pointer(mvm->baid_map[baid]);
2360 if (WARN_ON(!baid_data))
2361 return -EINVAL;
2362
2363
2364 iwl_mvm_free_reorder(mvm, baid_data);
2365 del_timer_sync(&baid_data->session_timer);
2366 RCU_INIT_POINTER(mvm->baid_map[baid], NULL);
2367 kfree_rcu(baid_data, rcu_head);
2368 IWL_DEBUG_HT(mvm, "BAID %d is free\n", baid);
2369 }
2370 return 0;
2371
2372out_free:
2373 kfree(baid_data);
2374 return ret;
2375}
2376
2377int iwl_mvm_sta_tx_agg(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
2378 int tid, u8 queue, bool start)
2379{
2380 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
2381 struct iwl_mvm_add_sta_cmd cmd = {};
2382 int ret;
2383 u32 status;
2384
2385 lockdep_assert_held(&mvm->mutex);
2386
2387 if (start) {
2388 mvm_sta->tfd_queue_msk |= BIT(queue);
2389 mvm_sta->tid_disable_agg &= ~BIT(tid);
2390 } else {
2391
2392 mvm_sta->tid_disable_agg |= BIT(tid);
2393 }
2394
2395 cmd.mac_id_n_color = cpu_to_le32(mvm_sta->mac_id_n_color);
2396 cmd.sta_id = mvm_sta->sta_id;
2397 cmd.add_modify = STA_MODE_MODIFY;
2398 if (!iwl_mvm_has_new_tx_api(mvm))
2399 cmd.modify_mask = STA_MODIFY_QUEUES;
2400 cmd.modify_mask |= STA_MODIFY_TID_DISABLE_TX;
2401 cmd.tfd_queue_msk = cpu_to_le32(mvm_sta->tfd_queue_msk);
2402 cmd.tid_disable_tx = cpu_to_le16(mvm_sta->tid_disable_agg);
2403
2404 status = ADD_STA_SUCCESS;
2405 ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA,
2406 iwl_mvm_add_sta_cmd_size(mvm),
2407 &cmd, &status);
2408 if (ret)
2409 return ret;
2410
2411 switch (status & IWL_ADD_STA_STATUS_MASK) {
2412 case ADD_STA_SUCCESS:
2413 break;
2414 default:
2415 ret = -EIO;
2416 IWL_ERR(mvm, "TX BA Session failed %sing, status 0x%x\n",
2417 start ? "start" : "stopp", status);
2418 break;
2419 }
2420
2421 return ret;
2422}
2423
2424const u8 tid_to_mac80211_ac[] = {
2425 IEEE80211_AC_BE,
2426 IEEE80211_AC_BK,
2427 IEEE80211_AC_BK,
2428 IEEE80211_AC_BE,
2429 IEEE80211_AC_VI,
2430 IEEE80211_AC_VI,
2431 IEEE80211_AC_VO,
2432 IEEE80211_AC_VO,
2433 IEEE80211_AC_VO,
2434};
2435
2436static const u8 tid_to_ucode_ac[] = {
2437 AC_BE,
2438 AC_BK,
2439 AC_BK,
2440 AC_BE,
2441 AC_VI,
2442 AC_VI,
2443 AC_VO,
2444 AC_VO,
2445};
2446
2447int iwl_mvm_sta_tx_agg_start(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
2448 struct ieee80211_sta *sta, u16 tid, u16 *ssn)
2449{
2450 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
2451 struct iwl_mvm_tid_data *tid_data;
2452 u16 normalized_ssn;
2453 int txq_id;
2454 int ret;
2455
2456 if (WARN_ON_ONCE(tid >= IWL_MAX_TID_COUNT))
2457 return -EINVAL;
2458
2459 if (mvmsta->tid_data[tid].state != IWL_AGG_QUEUED &&
2460 mvmsta->tid_data[tid].state != IWL_AGG_OFF) {
2461 IWL_ERR(mvm,
2462 "Start AGG when state is not IWL_AGG_QUEUED or IWL_AGG_OFF %d!\n",
2463 mvmsta->tid_data[tid].state);
2464 return -ENXIO;
2465 }
2466
2467 lockdep_assert_held(&mvm->mutex);
2468
2469 spin_lock_bh(&mvmsta->lock);
2470
2471
2472 if (test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status)) {
2473 spin_unlock_bh(&mvmsta->lock);
2474 IWL_ERR(mvm, "Entered D0i3 while starting Tx agg\n");
2475 return -EIO;
2476 }
2477
2478 spin_lock(&mvm->queue_info_lock);
2479
2480
2481
2482
2483
2484
2485
2486 txq_id = mvmsta->tid_data[tid].txq_id;
2487 if (txq_id == IWL_MVM_INVALID_QUEUE) {
2488 txq_id = iwl_mvm_find_free_queue(mvm, mvmsta->sta_id,
2489 IWL_MVM_DQA_MIN_DATA_QUEUE,
2490 IWL_MVM_DQA_MAX_DATA_QUEUE);
2491 if (txq_id < 0) {
2492 ret = txq_id;
2493 IWL_ERR(mvm, "Failed to allocate agg queue\n");
2494 goto release_locks;
2495 }
2496
2497
2498 mvm->queue_info[txq_id].status = IWL_MVM_QUEUE_RESERVED;
2499 } else if (unlikely(mvm->queue_info[txq_id].status ==
2500 IWL_MVM_QUEUE_SHARED)) {
2501 ret = -ENXIO;
2502 IWL_DEBUG_TX_QUEUES(mvm,
2503 "Can't start tid %d agg on shared queue!\n",
2504 tid);
2505 goto release_locks;
2506 }
2507
2508 spin_unlock(&mvm->queue_info_lock);
2509
2510 IWL_DEBUG_TX_QUEUES(mvm,
2511 "AGG for tid %d will be on queue #%d\n",
2512 tid, txq_id);
2513
2514 tid_data = &mvmsta->tid_data[tid];
2515 tid_data->ssn = IEEE80211_SEQ_TO_SN(tid_data->seq_number);
2516 tid_data->txq_id = txq_id;
2517 *ssn = tid_data->ssn;
2518
2519 IWL_DEBUG_TX_QUEUES(mvm,
2520 "Start AGG: sta %d tid %d queue %d - ssn = %d, next_recl = %d\n",
2521 mvmsta->sta_id, tid, txq_id, tid_data->ssn,
2522 tid_data->next_reclaimed);
2523
2524
2525
2526
2527
2528 normalized_ssn = tid_data->ssn;
2529 if (mvm->trans->cfg->gen2)
2530 normalized_ssn &= 0xff;
2531
2532 if (normalized_ssn == tid_data->next_reclaimed) {
2533 tid_data->state = IWL_AGG_STARTING;
2534 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2535 } else {
2536 tid_data->state = IWL_EMPTYING_HW_QUEUE_ADDBA;
2537 }
2538
2539 ret = 0;
2540 goto out;
2541
2542release_locks:
2543 spin_unlock(&mvm->queue_info_lock);
2544out:
2545 spin_unlock_bh(&mvmsta->lock);
2546
2547 return ret;
2548}
2549
2550int iwl_mvm_sta_tx_agg_oper(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
2551 struct ieee80211_sta *sta, u16 tid, u8 buf_size,
2552 bool amsdu)
2553{
2554 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
2555 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
2556 unsigned int wdg_timeout =
2557 iwl_mvm_get_wd_timeout(mvm, vif, sta->tdls, false);
2558 int queue, ret;
2559 bool alloc_queue = true;
2560 enum iwl_mvm_queue_status queue_status;
2561 u16 ssn;
2562
2563 struct iwl_trans_txq_scd_cfg cfg = {
2564 .sta_id = mvmsta->sta_id,
2565 .tid = tid,
2566 .frame_limit = buf_size,
2567 .aggregate = true,
2568 };
2569
2570
2571
2572
2573
2574 if (WARN_ON_ONCE(iwl_mvm_has_tlc_offload(mvm)))
2575 return -EINVAL;
2576
2577 BUILD_BUG_ON((sizeof(mvmsta->agg_tids) * BITS_PER_BYTE)
2578 != IWL_MAX_TID_COUNT);
2579
2580 spin_lock_bh(&mvmsta->lock);
2581 ssn = tid_data->ssn;
2582 queue = tid_data->txq_id;
2583 tid_data->state = IWL_AGG_ON;
2584 mvmsta->agg_tids |= BIT(tid);
2585 tid_data->ssn = 0xffff;
2586 tid_data->amsdu_in_ampdu_allowed = amsdu;
2587 spin_unlock_bh(&mvmsta->lock);
2588
2589 if (iwl_mvm_has_new_tx_api(mvm)) {
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601 if (buf_size < IWL_FRAME_LIMIT)
2602 return -ENOTSUPP;
2603
2604 ret = iwl_mvm_sta_tx_agg(mvm, sta, tid, queue, true);
2605 if (ret)
2606 return -EIO;
2607 goto out;
2608 }
2609
2610 cfg.fifo = iwl_mvm_ac_to_tx_fifo[tid_to_mac80211_ac[tid]];
2611
2612 spin_lock_bh(&mvm->queue_info_lock);
2613 queue_status = mvm->queue_info[queue].status;
2614 spin_unlock_bh(&mvm->queue_info_lock);
2615
2616
2617 if (mvm->queue_info[queue].status == IWL_MVM_QUEUE_READY)
2618 alloc_queue = false;
2619
2620
2621
2622
2623
2624 if (!alloc_queue && buf_size < IWL_FRAME_LIMIT) {
2625
2626
2627
2628
2629 ret = iwl_trans_wait_tx_queues_empty(mvm->trans,
2630 BIT(queue));
2631 if (ret) {
2632 IWL_ERR(mvm,
2633 "Error draining queue before reconfig\n");
2634 return ret;
2635 }
2636
2637 ret = iwl_mvm_reconfig_scd(mvm, queue, cfg.fifo,
2638 mvmsta->sta_id, tid,
2639 buf_size, ssn);
2640 if (ret) {
2641 IWL_ERR(mvm,
2642 "Error reconfiguring TXQ #%d\n", queue);
2643 return ret;
2644 }
2645 }
2646
2647 if (alloc_queue)
2648 iwl_mvm_enable_txq(mvm, queue,
2649 vif->hw_queue[tid_to_mac80211_ac[tid]], ssn,
2650 &cfg, wdg_timeout);
2651
2652
2653 if (queue_status != IWL_MVM_QUEUE_SHARED) {
2654 ret = iwl_mvm_sta_tx_agg(mvm, sta, tid, queue, true);
2655 if (ret)
2656 return -EIO;
2657 }
2658
2659
2660 spin_lock_bh(&mvm->queue_info_lock);
2661 mvm->queue_info[queue].status = IWL_MVM_QUEUE_READY;
2662 spin_unlock_bh(&mvm->queue_info_lock);
2663
2664out:
2665
2666
2667
2668
2669
2670
2671
2672 mvmsta->max_agg_bufsize =
2673 min(mvmsta->max_agg_bufsize, buf_size);
2674 mvmsta->lq_sta.rs_drv.lq.agg_frame_cnt_limit = mvmsta->max_agg_bufsize;
2675
2676 IWL_DEBUG_HT(mvm, "Tx aggregation enabled on ra = %pM tid = %d\n",
2677 sta->addr, tid);
2678
2679 return iwl_mvm_send_lq_cmd(mvm, &mvmsta->lq_sta.rs_drv.lq, false);
2680}
2681
2682static void iwl_mvm_unreserve_agg_queue(struct iwl_mvm *mvm,
2683 struct iwl_mvm_sta *mvmsta,
2684 struct iwl_mvm_tid_data *tid_data)
2685{
2686 u16 txq_id = tid_data->txq_id;
2687
2688 if (iwl_mvm_has_new_tx_api(mvm))
2689 return;
2690
2691 spin_lock_bh(&mvm->queue_info_lock);
2692
2693
2694
2695
2696
2697
2698
2699 if (mvm->queue_info[txq_id].status == IWL_MVM_QUEUE_RESERVED) {
2700 mvm->queue_info[txq_id].status = IWL_MVM_QUEUE_FREE;
2701 tid_data->txq_id = IWL_MVM_INVALID_QUEUE;
2702 }
2703
2704 spin_unlock_bh(&mvm->queue_info_lock);
2705}
2706
2707int iwl_mvm_sta_tx_agg_stop(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
2708 struct ieee80211_sta *sta, u16 tid)
2709{
2710 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
2711 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
2712 u16 txq_id;
2713 int err;
2714
2715
2716
2717
2718
2719 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
2720 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2721 return 0;
2722 }
2723
2724 spin_lock_bh(&mvmsta->lock);
2725
2726 txq_id = tid_data->txq_id;
2727
2728 IWL_DEBUG_TX_QUEUES(mvm, "Stop AGG: sta %d tid %d q %d state %d\n",
2729 mvmsta->sta_id, tid, txq_id, tid_data->state);
2730
2731 mvmsta->agg_tids &= ~BIT(tid);
2732
2733 iwl_mvm_unreserve_agg_queue(mvm, mvmsta, tid_data);
2734
2735 switch (tid_data->state) {
2736 case IWL_AGG_ON:
2737 tid_data->ssn = IEEE80211_SEQ_TO_SN(tid_data->seq_number);
2738
2739 IWL_DEBUG_TX_QUEUES(mvm,
2740 "ssn = %d, next_recl = %d\n",
2741 tid_data->ssn, tid_data->next_reclaimed);
2742
2743 tid_data->ssn = 0xffff;
2744 tid_data->state = IWL_AGG_OFF;
2745 spin_unlock_bh(&mvmsta->lock);
2746
2747 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2748
2749 iwl_mvm_sta_tx_agg(mvm, sta, tid, txq_id, false);
2750 return 0;
2751 case IWL_AGG_STARTING:
2752 case IWL_EMPTYING_HW_QUEUE_ADDBA:
2753
2754
2755
2756
2757
2758
2759 lockdep_assert_held(&mvm->mutex);
2760
2761 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2762 tid_data->state = IWL_AGG_OFF;
2763 err = 0;
2764 break;
2765 default:
2766 IWL_ERR(mvm,
2767 "Stopping AGG while state not ON or starting for %d on %d (%d)\n",
2768 mvmsta->sta_id, tid, tid_data->state);
2769 IWL_ERR(mvm,
2770 "\ttid_data->txq_id = %d\n", tid_data->txq_id);
2771 err = -EINVAL;
2772 }
2773
2774 spin_unlock_bh(&mvmsta->lock);
2775
2776 return err;
2777}
2778
2779int iwl_mvm_sta_tx_agg_flush(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
2780 struct ieee80211_sta *sta, u16 tid)
2781{
2782 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
2783 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
2784 u16 txq_id;
2785 enum iwl_mvm_agg_state old_state;
2786
2787
2788
2789
2790
2791 spin_lock_bh(&mvmsta->lock);
2792 txq_id = tid_data->txq_id;
2793 IWL_DEBUG_TX_QUEUES(mvm, "Flush AGG: sta %d tid %d q %d state %d\n",
2794 mvmsta->sta_id, tid, txq_id, tid_data->state);
2795 old_state = tid_data->state;
2796 tid_data->state = IWL_AGG_OFF;
2797 mvmsta->agg_tids &= ~BIT(tid);
2798 spin_unlock_bh(&mvmsta->lock);
2799
2800 iwl_mvm_unreserve_agg_queue(mvm, mvmsta, tid_data);
2801
2802 if (old_state >= IWL_AGG_ON) {
2803 iwl_mvm_drain_sta(mvm, mvmsta, true);
2804
2805 if (iwl_mvm_has_new_tx_api(mvm)) {
2806 if (iwl_mvm_flush_sta_tids(mvm, mvmsta->sta_id,
2807 BIT(tid), 0))
2808 IWL_ERR(mvm, "Couldn't flush the AGG queue\n");
2809 iwl_trans_wait_txq_empty(mvm->trans, txq_id);
2810 } else {
2811 if (iwl_mvm_flush_tx_path(mvm, BIT(txq_id), 0))
2812 IWL_ERR(mvm, "Couldn't flush the AGG queue\n");
2813 iwl_trans_wait_tx_queues_empty(mvm->trans, BIT(txq_id));
2814 }
2815
2816 iwl_mvm_drain_sta(mvm, mvmsta, false);
2817
2818 iwl_mvm_sta_tx_agg(mvm, sta, tid, txq_id, false);
2819 }
2820
2821 return 0;
2822}
2823
2824static int iwl_mvm_set_fw_key_idx(struct iwl_mvm *mvm)
2825{
2826 int i, max = -1, max_offs = -1;
2827
2828 lockdep_assert_held(&mvm->mutex);
2829
2830
2831
2832
2833
2834
2835
2836 for (i = 0; i < STA_KEY_MAX_NUM; i++) {
2837 if (test_bit(i, mvm->fw_key_table))
2838 continue;
2839 if (mvm->fw_key_deleted[i] > max) {
2840 max = mvm->fw_key_deleted[i];
2841 max_offs = i;
2842 }
2843 }
2844
2845 if (max_offs < 0)
2846 return STA_KEY_IDX_INVALID;
2847
2848 return max_offs;
2849}
2850
2851static struct iwl_mvm_sta *iwl_mvm_get_key_sta(struct iwl_mvm *mvm,
2852 struct ieee80211_vif *vif,
2853 struct ieee80211_sta *sta)
2854{
2855 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2856
2857 if (sta)
2858 return iwl_mvm_sta_from_mac80211(sta);
2859
2860
2861
2862
2863
2864
2865 if (vif->type == NL80211_IFTYPE_STATION &&
2866 mvmvif->ap_sta_id != IWL_MVM_INVALID_STA) {
2867 u8 sta_id = mvmvif->ap_sta_id;
2868
2869 sta = rcu_dereference_check(mvm->fw_id_to_mac_id[sta_id],
2870 lockdep_is_held(&mvm->mutex));
2871
2872
2873
2874
2875
2876
2877 if (IS_ERR_OR_NULL(sta))
2878 return NULL;
2879
2880 return iwl_mvm_sta_from_mac80211(sta);
2881 }
2882
2883 return NULL;
2884}
2885
2886static int iwl_mvm_send_sta_key(struct iwl_mvm *mvm,
2887 u32 sta_id,
2888 struct ieee80211_key_conf *key, bool mcast,
2889 u32 tkip_iv32, u16 *tkip_p1k, u32 cmd_flags,
2890 u8 key_offset)
2891{
2892 union {
2893 struct iwl_mvm_add_sta_key_cmd_v1 cmd_v1;
2894 struct iwl_mvm_add_sta_key_cmd cmd;
2895 } u = {};
2896 __le16 key_flags;
2897 int ret;
2898 u32 status;
2899 u16 keyidx;
2900 u64 pn = 0;
2901 int i, size;
2902 bool new_api = fw_has_api(&mvm->fw->ucode_capa,
2903 IWL_UCODE_TLV_API_TKIP_MIC_KEYS);
2904
2905 if (sta_id == IWL_MVM_INVALID_STA)
2906 return -EINVAL;
2907
2908 keyidx = (key->keyidx << STA_KEY_FLG_KEYID_POS) &
2909 STA_KEY_FLG_KEYID_MSK;
2910 key_flags = cpu_to_le16(keyidx);
2911 key_flags |= cpu_to_le16(STA_KEY_FLG_WEP_KEY_MAP);
2912
2913 switch (key->cipher) {
2914 case WLAN_CIPHER_SUITE_TKIP:
2915 key_flags |= cpu_to_le16(STA_KEY_FLG_TKIP);
2916 if (new_api) {
2917 memcpy((void *)&u.cmd.tx_mic_key,
2918 &key->key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY],
2919 IWL_MIC_KEY_SIZE);
2920
2921 memcpy((void *)&u.cmd.rx_mic_key,
2922 &key->key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY],
2923 IWL_MIC_KEY_SIZE);
2924 pn = atomic64_read(&key->tx_pn);
2925
2926 } else {
2927 u.cmd_v1.tkip_rx_tsc_byte2 = tkip_iv32;
2928 for (i = 0; i < 5; i++)
2929 u.cmd_v1.tkip_rx_ttak[i] =
2930 cpu_to_le16(tkip_p1k[i]);
2931 }
2932 memcpy(u.cmd.common.key, key->key, key->keylen);
2933 break;
2934 case WLAN_CIPHER_SUITE_CCMP:
2935 key_flags |= cpu_to_le16(STA_KEY_FLG_CCM);
2936 memcpy(u.cmd.common.key, key->key, key->keylen);
2937 if (new_api)
2938 pn = atomic64_read(&key->tx_pn);
2939 break;
2940 case WLAN_CIPHER_SUITE_WEP104:
2941 key_flags |= cpu_to_le16(STA_KEY_FLG_WEP_13BYTES);
2942
2943 case WLAN_CIPHER_SUITE_WEP40:
2944 key_flags |= cpu_to_le16(STA_KEY_FLG_WEP);
2945 memcpy(u.cmd.common.key + 3, key->key, key->keylen);
2946 break;
2947 case WLAN_CIPHER_SUITE_GCMP_256:
2948 key_flags |= cpu_to_le16(STA_KEY_FLG_KEY_32BYTES);
2949
2950 case WLAN_CIPHER_SUITE_GCMP:
2951 key_flags |= cpu_to_le16(STA_KEY_FLG_GCMP);
2952 memcpy(u.cmd.common.key, key->key, key->keylen);
2953 if (new_api)
2954 pn = atomic64_read(&key->tx_pn);
2955 break;
2956 default:
2957 key_flags |= cpu_to_le16(STA_KEY_FLG_EXT);
2958 memcpy(u.cmd.common.key, key->key, key->keylen);
2959 }
2960
2961 if (mcast)
2962 key_flags |= cpu_to_le16(STA_KEY_MULTICAST);
2963
2964 u.cmd.common.key_offset = key_offset;
2965 u.cmd.common.key_flags = key_flags;
2966 u.cmd.common.sta_id = sta_id;
2967
2968 if (new_api) {
2969 u.cmd.transmit_seq_cnt = cpu_to_le64(pn);
2970 size = sizeof(u.cmd);
2971 } else {
2972 size = sizeof(u.cmd_v1);
2973 }
2974
2975 status = ADD_STA_SUCCESS;
2976 if (cmd_flags & CMD_ASYNC)
2977 ret = iwl_mvm_send_cmd_pdu(mvm, ADD_STA_KEY, CMD_ASYNC, size,
2978 &u.cmd);
2979 else
2980 ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA_KEY, size,
2981 &u.cmd, &status);
2982
2983 switch (status) {
2984 case ADD_STA_SUCCESS:
2985 IWL_DEBUG_WEP(mvm, "MODIFY_STA: set dynamic key passed\n");
2986 break;
2987 default:
2988 ret = -EIO;
2989 IWL_ERR(mvm, "MODIFY_STA: set dynamic key failed\n");
2990 break;
2991 }
2992
2993 return ret;
2994}
2995
2996static int iwl_mvm_send_sta_igtk(struct iwl_mvm *mvm,
2997 struct ieee80211_key_conf *keyconf,
2998 u8 sta_id, bool remove_key)
2999{
3000 struct iwl_mvm_mgmt_mcast_key_cmd igtk_cmd = {};
3001
3002
3003 if (WARN_ON((keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE) ||
3004 (keyconf->keyidx != 4 && keyconf->keyidx != 5) ||
3005 (keyconf->cipher != WLAN_CIPHER_SUITE_AES_CMAC &&
3006 keyconf->cipher != WLAN_CIPHER_SUITE_BIP_GMAC_128 &&
3007 keyconf->cipher != WLAN_CIPHER_SUITE_BIP_GMAC_256)))
3008 return -EINVAL;
3009
3010 if (WARN_ON(!iwl_mvm_has_new_rx_api(mvm) &&
3011 keyconf->cipher != WLAN_CIPHER_SUITE_AES_CMAC))
3012 return -EINVAL;
3013
3014 igtk_cmd.key_id = cpu_to_le32(keyconf->keyidx);
3015 igtk_cmd.sta_id = cpu_to_le32(sta_id);
3016
3017 if (remove_key) {
3018 igtk_cmd.ctrl_flags |= cpu_to_le32(STA_KEY_NOT_VALID);
3019 } else {
3020 struct ieee80211_key_seq seq;
3021 const u8 *pn;
3022
3023 switch (keyconf->cipher) {
3024 case WLAN_CIPHER_SUITE_AES_CMAC:
3025 igtk_cmd.ctrl_flags |= cpu_to_le32(STA_KEY_FLG_CCM);
3026 break;
3027 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
3028 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
3029 igtk_cmd.ctrl_flags |= cpu_to_le32(STA_KEY_FLG_GCMP);
3030 break;
3031 default:
3032 return -EINVAL;
3033 }
3034
3035 memcpy(igtk_cmd.igtk, keyconf->key, keyconf->keylen);
3036 if (keyconf->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256)
3037 igtk_cmd.ctrl_flags |=
3038 cpu_to_le32(STA_KEY_FLG_KEY_32BYTES);
3039 ieee80211_get_key_rx_seq(keyconf, 0, &seq);
3040 pn = seq.aes_cmac.pn;
3041 igtk_cmd.receive_seq_cnt = cpu_to_le64(((u64) pn[5] << 0) |
3042 ((u64) pn[4] << 8) |
3043 ((u64) pn[3] << 16) |
3044 ((u64) pn[2] << 24) |
3045 ((u64) pn[1] << 32) |
3046 ((u64) pn[0] << 40));
3047 }
3048
3049 IWL_DEBUG_INFO(mvm, "%s igtk for sta %u\n",
3050 remove_key ? "removing" : "installing",
3051 igtk_cmd.sta_id);
3052
3053 if (!iwl_mvm_has_new_rx_api(mvm)) {
3054 struct iwl_mvm_mgmt_mcast_key_cmd_v1 igtk_cmd_v1 = {
3055 .ctrl_flags = igtk_cmd.ctrl_flags,
3056 .key_id = igtk_cmd.key_id,
3057 .sta_id = igtk_cmd.sta_id,
3058 .receive_seq_cnt = igtk_cmd.receive_seq_cnt
3059 };
3060
3061 memcpy(igtk_cmd_v1.igtk, igtk_cmd.igtk,
3062 ARRAY_SIZE(igtk_cmd_v1.igtk));
3063 return iwl_mvm_send_cmd_pdu(mvm, MGMT_MCAST_KEY, 0,
3064 sizeof(igtk_cmd_v1), &igtk_cmd_v1);
3065 }
3066 return iwl_mvm_send_cmd_pdu(mvm, MGMT_MCAST_KEY, 0,
3067 sizeof(igtk_cmd), &igtk_cmd);
3068}
3069
3070
3071static inline u8 *iwl_mvm_get_mac_addr(struct iwl_mvm *mvm,
3072 struct ieee80211_vif *vif,
3073 struct ieee80211_sta *sta)
3074{
3075 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3076
3077 if (sta)
3078 return sta->addr;
3079
3080 if (vif->type == NL80211_IFTYPE_STATION &&
3081 mvmvif->ap_sta_id != IWL_MVM_INVALID_STA) {
3082 u8 sta_id = mvmvif->ap_sta_id;
3083 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
3084 lockdep_is_held(&mvm->mutex));
3085 return sta->addr;
3086 }
3087
3088
3089 return NULL;
3090}
3091
3092static int __iwl_mvm_set_sta_key(struct iwl_mvm *mvm,
3093 struct ieee80211_vif *vif,
3094 struct ieee80211_sta *sta,
3095 struct ieee80211_key_conf *keyconf,
3096 u8 key_offset,
3097 bool mcast)
3098{
3099 int ret;
3100 const u8 *addr;
3101 struct ieee80211_key_seq seq;
3102 u16 p1k[5];
3103 u32 sta_id;
3104
3105 if (sta) {
3106 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
3107
3108 sta_id = mvm_sta->sta_id;
3109 } else if (vif->type == NL80211_IFTYPE_AP &&
3110 !(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
3111 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3112
3113 sta_id = mvmvif->mcast_sta.sta_id;
3114 } else {
3115 IWL_ERR(mvm, "Failed to find station id\n");
3116 return -EINVAL;
3117 }
3118
3119 switch (keyconf->cipher) {
3120 case WLAN_CIPHER_SUITE_TKIP:
3121 if (vif->type == NL80211_IFTYPE_AP) {
3122 ret = -EINVAL;
3123 break;
3124 }
3125 addr = iwl_mvm_get_mac_addr(mvm, vif, sta);
3126
3127 ieee80211_get_key_rx_seq(keyconf, 0, &seq);
3128 ieee80211_get_tkip_rx_p1k(keyconf, addr, seq.tkip.iv32, p1k);
3129 ret = iwl_mvm_send_sta_key(mvm, sta_id, keyconf, mcast,
3130 seq.tkip.iv32, p1k, 0, key_offset);
3131 break;
3132 case WLAN_CIPHER_SUITE_CCMP:
3133 case WLAN_CIPHER_SUITE_WEP40:
3134 case WLAN_CIPHER_SUITE_WEP104:
3135 case WLAN_CIPHER_SUITE_GCMP:
3136 case WLAN_CIPHER_SUITE_GCMP_256:
3137 ret = iwl_mvm_send_sta_key(mvm, sta_id, keyconf, mcast,
3138 0, NULL, 0, key_offset);
3139 break;
3140 default:
3141 ret = iwl_mvm_send_sta_key(mvm, sta_id, keyconf, mcast,
3142 0, NULL, 0, key_offset);
3143 }
3144
3145 return ret;
3146}
3147
3148static int __iwl_mvm_remove_sta_key(struct iwl_mvm *mvm, u8 sta_id,
3149 struct ieee80211_key_conf *keyconf,
3150 bool mcast)
3151{
3152 union {
3153 struct iwl_mvm_add_sta_key_cmd_v1 cmd_v1;
3154 struct iwl_mvm_add_sta_key_cmd cmd;
3155 } u = {};
3156 bool new_api = fw_has_api(&mvm->fw->ucode_capa,
3157 IWL_UCODE_TLV_API_TKIP_MIC_KEYS);
3158 __le16 key_flags;
3159 int ret, size;
3160 u32 status;
3161
3162
3163 if (sta_id == IWL_MVM_INVALID_STA)
3164 return 0;
3165
3166 key_flags = cpu_to_le16((keyconf->keyidx << STA_KEY_FLG_KEYID_POS) &
3167 STA_KEY_FLG_KEYID_MSK);
3168 key_flags |= cpu_to_le16(STA_KEY_FLG_NO_ENC | STA_KEY_FLG_WEP_KEY_MAP);
3169 key_flags |= cpu_to_le16(STA_KEY_NOT_VALID);
3170
3171 if (mcast)
3172 key_flags |= cpu_to_le16(STA_KEY_MULTICAST);
3173
3174
3175
3176
3177
3178 u.cmd.common.key_flags = key_flags;
3179 u.cmd.common.key_offset = keyconf->hw_key_idx;
3180 u.cmd.common.sta_id = sta_id;
3181
3182 size = new_api ? sizeof(u.cmd) : sizeof(u.cmd_v1);
3183
3184 status = ADD_STA_SUCCESS;
3185 ret = iwl_mvm_send_cmd_pdu_status(mvm, ADD_STA_KEY, size, &u.cmd,
3186 &status);
3187
3188 switch (status) {
3189 case ADD_STA_SUCCESS:
3190 IWL_DEBUG_WEP(mvm, "MODIFY_STA: remove sta key passed\n");
3191 break;
3192 default:
3193 ret = -EIO;
3194 IWL_ERR(mvm, "MODIFY_STA: remove sta key failed\n");
3195 break;
3196 }
3197
3198 return ret;
3199}
3200
3201int iwl_mvm_set_sta_key(struct iwl_mvm *mvm,
3202 struct ieee80211_vif *vif,
3203 struct ieee80211_sta *sta,
3204 struct ieee80211_key_conf *keyconf,
3205 u8 key_offset)
3206{
3207 bool mcast = !(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE);
3208 struct iwl_mvm_sta *mvm_sta;
3209 u8 sta_id = IWL_MVM_INVALID_STA;
3210 int ret;
3211 static const u8 __maybe_unused zero_addr[ETH_ALEN] = {0};
3212
3213 lockdep_assert_held(&mvm->mutex);
3214
3215 if (vif->type != NL80211_IFTYPE_AP ||
3216 keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
3217
3218 mvm_sta = iwl_mvm_get_key_sta(mvm, vif, sta);
3219 if (!mvm_sta) {
3220 IWL_ERR(mvm, "Failed to find station\n");
3221 return -EINVAL;
3222 }
3223 sta_id = mvm_sta->sta_id;
3224
3225
3226
3227
3228
3229
3230 if (!sta) {
3231 sta = rcu_dereference_protected(
3232 mvm->fw_id_to_mac_id[sta_id],
3233 lockdep_is_held(&mvm->mutex));
3234 if (IS_ERR_OR_NULL(sta)) {
3235 IWL_ERR(mvm, "Invalid station id\n");
3236 return -EINVAL;
3237 }
3238 }
3239
3240 if (WARN_ON_ONCE(iwl_mvm_sta_from_mac80211(sta)->vif != vif))
3241 return -EINVAL;
3242 } else {
3243 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3244
3245 sta_id = mvmvif->mcast_sta.sta_id;
3246 }
3247
3248 if (keyconf->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
3249 keyconf->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
3250 keyconf->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256) {
3251 ret = iwl_mvm_send_sta_igtk(mvm, keyconf, sta_id, false);
3252 goto end;
3253 }
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266 if (key_offset == STA_KEY_IDX_INVALID) {
3267 key_offset = iwl_mvm_set_fw_key_idx(mvm);
3268 if (key_offset == STA_KEY_IDX_INVALID)
3269 return -ENOSPC;
3270 keyconf->hw_key_idx = key_offset;
3271 }
3272
3273 ret = __iwl_mvm_set_sta_key(mvm, vif, sta, keyconf, key_offset, mcast);
3274 if (ret)
3275 goto end;
3276
3277
3278
3279
3280
3281
3282
3283 if ((keyconf->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3284 keyconf->cipher == WLAN_CIPHER_SUITE_WEP104) &&
3285 sta) {
3286 ret = __iwl_mvm_set_sta_key(mvm, vif, sta, keyconf,
3287 key_offset, !mcast);
3288 if (ret) {
3289 __iwl_mvm_remove_sta_key(mvm, sta_id, keyconf, mcast);
3290 goto end;
3291 }
3292 }
3293
3294 __set_bit(key_offset, mvm->fw_key_table);
3295
3296end:
3297 IWL_DEBUG_WEP(mvm, "key: cipher=%x len=%d idx=%d sta=%pM ret=%d\n",
3298 keyconf->cipher, keyconf->keylen, keyconf->keyidx,
3299 sta ? sta->addr : zero_addr, ret);
3300 return ret;
3301}
3302
3303int iwl_mvm_remove_sta_key(struct iwl_mvm *mvm,
3304 struct ieee80211_vif *vif,
3305 struct ieee80211_sta *sta,
3306 struct ieee80211_key_conf *keyconf)
3307{
3308 bool mcast = !(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE);
3309 struct iwl_mvm_sta *mvm_sta;
3310 u8 sta_id = IWL_MVM_INVALID_STA;
3311 int ret, i;
3312
3313 lockdep_assert_held(&mvm->mutex);
3314
3315
3316 mvm_sta = iwl_mvm_get_key_sta(mvm, vif, sta);
3317 if (mvm_sta)
3318 sta_id = mvm_sta->sta_id;
3319 else if (!sta && vif->type == NL80211_IFTYPE_AP && mcast)
3320 sta_id = iwl_mvm_vif_from_mac80211(vif)->mcast_sta.sta_id;
3321
3322
3323 IWL_DEBUG_WEP(mvm, "mvm remove dynamic key: idx=%d sta=%d\n",
3324 keyconf->keyidx, sta_id);
3325
3326 if (mvm_sta && (keyconf->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
3327 keyconf->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
3328 keyconf->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256))
3329 return iwl_mvm_send_sta_igtk(mvm, keyconf, sta_id, true);
3330
3331 if (!__test_and_clear_bit(keyconf->hw_key_idx, mvm->fw_key_table)) {
3332 IWL_ERR(mvm, "offset %d not used in fw key table.\n",
3333 keyconf->hw_key_idx);
3334 return -ENOENT;
3335 }
3336
3337
3338 for (i = 0; i < STA_KEY_MAX_NUM; i++) {
3339 if (mvm->fw_key_deleted[i] < U8_MAX)
3340 mvm->fw_key_deleted[i]++;
3341 }
3342 mvm->fw_key_deleted[keyconf->hw_key_idx] = 0;
3343
3344 if (sta && !mvm_sta) {
3345 IWL_DEBUG_WEP(mvm, "station non-existent, early return.\n");
3346 return 0;
3347 }
3348
3349 ret = __iwl_mvm_remove_sta_key(mvm, sta_id, keyconf, mcast);
3350 if (ret)
3351 return ret;
3352
3353
3354 if (keyconf->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3355 keyconf->cipher == WLAN_CIPHER_SUITE_WEP104)
3356 ret = __iwl_mvm_remove_sta_key(mvm, sta_id, keyconf, !mcast);
3357
3358 return ret;
3359}
3360
3361void iwl_mvm_update_tkip_key(struct iwl_mvm *mvm,
3362 struct ieee80211_vif *vif,
3363 struct ieee80211_key_conf *keyconf,
3364 struct ieee80211_sta *sta, u32 iv32,
3365 u16 *phase1key)
3366{
3367 struct iwl_mvm_sta *mvm_sta;
3368 bool mcast = !(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE);
3369
3370 rcu_read_lock();
3371
3372 mvm_sta = iwl_mvm_get_key_sta(mvm, vif, sta);
3373 if (WARN_ON_ONCE(!mvm_sta))
3374 goto unlock;
3375 iwl_mvm_send_sta_key(mvm, mvm_sta->sta_id, keyconf, mcast,
3376 iv32, phase1key, CMD_ASYNC, keyconf->hw_key_idx);
3377
3378 unlock:
3379 rcu_read_unlock();
3380}
3381
3382void iwl_mvm_sta_modify_ps_wake(struct iwl_mvm *mvm,
3383 struct ieee80211_sta *sta)
3384{
3385 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
3386 struct iwl_mvm_add_sta_cmd cmd = {
3387 .add_modify = STA_MODE_MODIFY,
3388 .sta_id = mvmsta->sta_id,
3389 .station_flags_msk = cpu_to_le32(STA_FLG_PS),
3390 .mac_id_n_color = cpu_to_le32(mvmsta->mac_id_n_color),
3391 };
3392 int ret;
3393
3394 ret = iwl_mvm_send_cmd_pdu(mvm, ADD_STA, CMD_ASYNC,
3395 iwl_mvm_add_sta_cmd_size(mvm), &cmd);
3396 if (ret)
3397 IWL_ERR(mvm, "Failed to send ADD_STA command (%d)\n", ret);
3398}
3399
3400void iwl_mvm_sta_modify_sleep_tx_count(struct iwl_mvm *mvm,
3401 struct ieee80211_sta *sta,
3402 enum ieee80211_frame_release_type reason,
3403 u16 cnt, u16 tids, bool more_data,
3404 bool single_sta_queue)
3405{
3406 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
3407 struct iwl_mvm_add_sta_cmd cmd = {
3408 .add_modify = STA_MODE_MODIFY,
3409 .sta_id = mvmsta->sta_id,
3410 .modify_mask = STA_MODIFY_SLEEPING_STA_TX_COUNT,
3411 .sleep_tx_count = cpu_to_le16(cnt),
3412 .mac_id_n_color = cpu_to_le32(mvmsta->mac_id_n_color),
3413 };
3414 int tid, ret;
3415 unsigned long _tids = tids;
3416
3417
3418
3419
3420
3421 for_each_set_bit(tid, &_tids, IWL_MAX_TID_COUNT)
3422 cmd.awake_acs |= BIT(tid_to_ucode_ac[tid]);
3423
3424
3425
3426
3427
3428
3429
3430
3431 if (single_sta_queue) {
3432 int remaining = cnt;
3433 int sleep_tx_count;
3434
3435 spin_lock_bh(&mvmsta->lock);
3436 for_each_set_bit(tid, &_tids, IWL_MAX_TID_COUNT) {
3437 struct iwl_mvm_tid_data *tid_data;
3438 u16 n_queued;
3439
3440 tid_data = &mvmsta->tid_data[tid];
3441
3442 n_queued = iwl_mvm_tid_queued(mvm, tid_data);
3443 if (n_queued > remaining) {
3444 more_data = true;
3445 remaining = 0;
3446 break;
3447 }
3448 remaining -= n_queued;
3449 }
3450 sleep_tx_count = cnt - remaining;
3451 if (reason == IEEE80211_FRAME_RELEASE_UAPSD)
3452 mvmsta->sleep_tx_count = sleep_tx_count;
3453 spin_unlock_bh(&mvmsta->lock);
3454
3455 cmd.sleep_tx_count = cpu_to_le16(sleep_tx_count);
3456 if (WARN_ON(cnt - remaining == 0)) {
3457 ieee80211_sta_eosp(sta);
3458 return;
3459 }
3460 }
3461
3462
3463 if (more_data)
3464 cmd.sleep_state_flags |= STA_SLEEP_STATE_MOREDATA;
3465
3466 if (reason == IEEE80211_FRAME_RELEASE_PSPOLL) {
3467 mvmsta->next_status_eosp = true;
3468 cmd.sleep_state_flags |= STA_SLEEP_STATE_PS_POLL;
3469 } else {
3470 cmd.sleep_state_flags |= STA_SLEEP_STATE_UAPSD;
3471 }
3472
3473
3474 iwl_trans_block_txq_ptrs(mvm->trans, true);
3475
3476 ret = iwl_mvm_send_cmd_pdu(mvm, ADD_STA,
3477 CMD_ASYNC | CMD_WANT_ASYNC_CALLBACK,
3478 iwl_mvm_add_sta_cmd_size(mvm), &cmd);
3479 if (ret)
3480 IWL_ERR(mvm, "Failed to send ADD_STA command (%d)\n", ret);
3481}
3482
3483void iwl_mvm_rx_eosp_notif(struct iwl_mvm *mvm,
3484 struct iwl_rx_cmd_buffer *rxb)
3485{
3486 struct iwl_rx_packet *pkt = rxb_addr(rxb);
3487 struct iwl_mvm_eosp_notification *notif = (void *)pkt->data;
3488 struct ieee80211_sta *sta;
3489 u32 sta_id = le32_to_cpu(notif->sta_id);
3490
3491 if (WARN_ON_ONCE(sta_id >= IWL_MVM_STATION_COUNT))
3492 return;
3493
3494 rcu_read_lock();
3495 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
3496 if (!IS_ERR_OR_NULL(sta))
3497 ieee80211_sta_eosp(sta);
3498 rcu_read_unlock();
3499}
3500
3501void iwl_mvm_sta_modify_disable_tx(struct iwl_mvm *mvm,
3502 struct iwl_mvm_sta *mvmsta, bool disable)
3503{
3504 struct iwl_mvm_add_sta_cmd cmd = {
3505 .add_modify = STA_MODE_MODIFY,
3506 .sta_id = mvmsta->sta_id,
3507 .station_flags = disable ? cpu_to_le32(STA_FLG_DISABLE_TX) : 0,
3508 .station_flags_msk = cpu_to_le32(STA_FLG_DISABLE_TX),
3509 .mac_id_n_color = cpu_to_le32(mvmsta->mac_id_n_color),
3510 };
3511 int ret;
3512
3513 ret = iwl_mvm_send_cmd_pdu(mvm, ADD_STA, CMD_ASYNC,
3514 iwl_mvm_add_sta_cmd_size(mvm), &cmd);
3515 if (ret)
3516 IWL_ERR(mvm, "Failed to send ADD_STA command (%d)\n", ret);
3517}
3518
3519void iwl_mvm_sta_modify_disable_tx_ap(struct iwl_mvm *mvm,
3520 struct ieee80211_sta *sta,
3521 bool disable)
3522{
3523 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
3524
3525 spin_lock_bh(&mvm_sta->lock);
3526
3527 if (mvm_sta->disable_tx == disable) {
3528 spin_unlock_bh(&mvm_sta->lock);
3529 return;
3530 }
3531
3532 mvm_sta->disable_tx = disable;
3533
3534
3535 ieee80211_sta_block_awake(mvm->hw, sta, disable);
3536
3537 iwl_mvm_sta_modify_disable_tx(mvm, mvm_sta, disable);
3538
3539 spin_unlock_bh(&mvm_sta->lock);
3540}
3541
3542static void iwl_mvm_int_sta_modify_disable_tx(struct iwl_mvm *mvm,
3543 struct iwl_mvm_vif *mvmvif,
3544 struct iwl_mvm_int_sta *sta,
3545 bool disable)
3546{
3547 u32 id = FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color);
3548 struct iwl_mvm_add_sta_cmd cmd = {
3549 .add_modify = STA_MODE_MODIFY,
3550 .sta_id = sta->sta_id,
3551 .station_flags = disable ? cpu_to_le32(STA_FLG_DISABLE_TX) : 0,
3552 .station_flags_msk = cpu_to_le32(STA_FLG_DISABLE_TX),
3553 .mac_id_n_color = cpu_to_le32(id),
3554 };
3555 int ret;
3556
3557 ret = iwl_mvm_send_cmd_pdu(mvm, ADD_STA, 0,
3558 iwl_mvm_add_sta_cmd_size(mvm), &cmd);
3559 if (ret)
3560 IWL_ERR(mvm, "Failed to send ADD_STA command (%d)\n", ret);
3561}
3562
3563void iwl_mvm_modify_all_sta_disable_tx(struct iwl_mvm *mvm,
3564 struct iwl_mvm_vif *mvmvif,
3565 bool disable)
3566{
3567 struct ieee80211_sta *sta;
3568 struct iwl_mvm_sta *mvm_sta;
3569 int i;
3570
3571 lockdep_assert_held(&mvm->mutex);
3572
3573
3574 for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
3575 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
3576 lockdep_is_held(&mvm->mutex));
3577 if (IS_ERR_OR_NULL(sta))
3578 continue;
3579
3580 mvm_sta = iwl_mvm_sta_from_mac80211(sta);
3581 if (mvm_sta->mac_id_n_color !=
3582 FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color))
3583 continue;
3584
3585 iwl_mvm_sta_modify_disable_tx_ap(mvm, sta, disable);
3586 }
3587
3588 if (!fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE))
3589 return;
3590
3591
3592 if (mvmvif->mcast_sta.sta_id != IWL_MVM_INVALID_STA)
3593 iwl_mvm_int_sta_modify_disable_tx(mvm, mvmvif,
3594 &mvmvif->mcast_sta, disable);
3595
3596
3597
3598
3599
3600 if (!disable && mvmvif->bcast_sta.sta_id != IWL_MVM_INVALID_STA)
3601 iwl_mvm_int_sta_modify_disable_tx(mvm, mvmvif,
3602 &mvmvif->bcast_sta, disable);
3603}
3604
3605void iwl_mvm_csa_client_absent(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
3606{
3607 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3608 struct iwl_mvm_sta *mvmsta;
3609
3610 rcu_read_lock();
3611
3612 mvmsta = iwl_mvm_sta_from_staid_rcu(mvm, mvmvif->ap_sta_id);
3613
3614 if (!WARN_ON(!mvmsta))
3615 iwl_mvm_sta_modify_disable_tx(mvm, mvmsta, true);
3616
3617 rcu_read_unlock();
3618}
3619
3620u16 iwl_mvm_tid_queued(struct iwl_mvm *mvm, struct iwl_mvm_tid_data *tid_data)
3621{
3622 u16 sn = IEEE80211_SEQ_TO_SN(tid_data->seq_number);
3623
3624
3625
3626
3627
3628 if (mvm->trans->cfg->gen2)
3629 sn &= 0xff;
3630
3631 return ieee80211_sn_sub(sn, tid_data->next_reclaimed);
3632}
3633