1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright 2002-2005, Instant802 Networks, Inc. 4 * Copyright 2005-2006, Devicescape Software, Inc. 5 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 6 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> 7 * Copyright 2013-2014 Intel Mobile Communications GmbH 8 * Copyright (C) 2015-2017 Intel Deutschland GmbH 9 * Copyright (C) 2018-2021 Intel Corporation 10 * 11 * utilities for mac80211 12 */ 13 14 #include <net/mac80211.h> 15 #include <linux/netdevice.h> 16 #include <linux/export.h> 17 #include <linux/types.h> 18 #include <linux/slab.h> 19 #include <linux/skbuff.h> 20 #include <linux/etherdevice.h> 21 #include <linux/if_arp.h> 22 #include <linux/bitmap.h> 23 #include <linux/crc32.h> 24 #include <net/net_namespace.h> 25 #include <net/cfg80211.h> 26 #include <net/rtnetlink.h> 27 28 #include "ieee80211_i.h" 29 #include "driver-ops.h" 30 #include "rate.h" 31 #include "mesh.h" 32 #include "wme.h" 33 #include "led.h" 34 #include "wep.h" 35 36 /* privid for wiphys to determine whether they belong to us or not */ 37 const void *const mac80211_wiphy_privid = &mac80211_wiphy_privid; 38 39 struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy) 40 { 41 struct ieee80211_local *local; 42 43 local = wiphy_priv(wiphy); 44 return &local->hw; 45 } 46 EXPORT_SYMBOL(wiphy_to_ieee80211_hw); 47 48 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len, 49 enum nl80211_iftype type) 50 { 51 __le16 fc = hdr->frame_control; 52 53 if (ieee80211_is_data(fc)) { 54 if (len < 24) /* drop incorrect hdr len (data) */ 55 return NULL; 56 57 if (ieee80211_has_a4(fc)) 58 return NULL; 59 if (ieee80211_has_tods(fc)) 60 return hdr->addr1; 61 if (ieee80211_has_fromds(fc)) 62 return hdr->addr2; 63 64 return hdr->addr3; 65 } 66 67 if (ieee80211_is_s1g_beacon(fc)) { 68 struct ieee80211_ext *ext = (void *) hdr; 69 70 return ext->u.s1g_beacon.sa; 71 } 72 73 if (ieee80211_is_mgmt(fc)) { 74 if (len < 24) /* drop incorrect hdr len (mgmt) */ 75 return NULL; 76 return hdr->addr3; 77 } 78 79 if (ieee80211_is_ctl(fc)) { 80 if (ieee80211_is_pspoll(fc)) 81 return hdr->addr1; 82 83 if (ieee80211_is_back_req(fc)) { 84 switch (type) { 85 case NL80211_IFTYPE_STATION: 86 return hdr->addr2; 87 case NL80211_IFTYPE_AP: 88 case NL80211_IFTYPE_AP_VLAN: 89 return hdr->addr1; 90 default: 91 break; /* fall through to the return */ 92 } 93 } 94 } 95 96 return NULL; 97 } 98 EXPORT_SYMBOL(ieee80211_get_bssid); 99 100 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx) 101 { 102 struct sk_buff *skb; 103 struct ieee80211_hdr *hdr; 104 105 skb_queue_walk(&tx->skbs, skb) { 106 hdr = (struct ieee80211_hdr *) skb->data; 107 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 108 } 109 } 110 111 int ieee80211_frame_duration(enum nl80211_band band, size_t len, 112 int rate, int erp, int short_preamble, 113 int shift) 114 { 115 int dur; 116 117 /* calculate duration (in microseconds, rounded up to next higher 118 * integer if it includes a fractional microsecond) to send frame of 119 * len bytes (does not include FCS) at the given rate. Duration will 120 * also include SIFS. 121 * 122 * rate is in 100 kbps, so divident is multiplied by 10 in the 123 * DIV_ROUND_UP() operations. 124 * 125 * shift may be 2 for 5 MHz channels or 1 for 10 MHz channels, and 126 * is assumed to be 0 otherwise. 127 */ 128 129 if (band == NL80211_BAND_5GHZ || erp) { 130 /* 131 * OFDM: 132 * 133 * N_DBPS = DATARATE x 4 134 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS) 135 * (16 = SIGNAL time, 6 = tail bits) 136 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext 137 * 138 * T_SYM = 4 usec 139 * 802.11a - 18.5.2: aSIFSTime = 16 usec 140 * 802.11g - 19.8.4: aSIFSTime = 10 usec + 141 * signal ext = 6 usec 142 */ 143 dur = 16; /* SIFS + signal ext */ 144 dur += 16; /* IEEE 802.11-2012 18.3.2.4: T_PREAMBLE = 16 usec */ 145 dur += 4; /* IEEE 802.11-2012 18.3.2.4: T_SIGNAL = 4 usec */ 146 147 /* IEEE 802.11-2012 18.3.2.4: all values above are: 148 * * times 4 for 5 MHz 149 * * times 2 for 10 MHz 150 */ 151 dur *= 1 << shift; 152 153 /* rates should already consider the channel bandwidth, 154 * don't apply divisor again. 155 */ 156 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10, 157 4 * rate); /* T_SYM x N_SYM */ 158 } else { 159 /* 160 * 802.11b or 802.11g with 802.11b compatibility: 161 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime + 162 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0. 163 * 164 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4 165 * aSIFSTime = 10 usec 166 * aPreambleLength = 144 usec or 72 usec with short preamble 167 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble 168 */ 169 dur = 10; /* aSIFSTime = 10 usec */ 170 dur += short_preamble ? (72 + 24) : (144 + 48); 171 172 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate); 173 } 174 175 return dur; 176 } 177 178 /* Exported duration function for driver use */ 179 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw, 180 struct ieee80211_vif *vif, 181 enum nl80211_band band, 182 size_t frame_len, 183 struct ieee80211_rate *rate) 184 { 185 struct ieee80211_sub_if_data *sdata; 186 u16 dur; 187 int erp, shift = 0; 188 bool short_preamble = false; 189 190 erp = 0; 191 if (vif) { 192 sdata = vif_to_sdata(vif); 193 short_preamble = sdata->vif.bss_conf.use_short_preamble; 194 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 195 erp = rate->flags & IEEE80211_RATE_ERP_G; 196 shift = ieee80211_vif_get_shift(vif); 197 } 198 199 dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp, 200 short_preamble, shift); 201 202 return cpu_to_le16(dur); 203 } 204 EXPORT_SYMBOL(ieee80211_generic_frame_duration); 205 206 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw, 207 struct ieee80211_vif *vif, size_t frame_len, 208 const struct ieee80211_tx_info *frame_txctl) 209 { 210 struct ieee80211_local *local = hw_to_local(hw); 211 struct ieee80211_rate *rate; 212 struct ieee80211_sub_if_data *sdata; 213 bool short_preamble; 214 int erp, shift = 0, bitrate; 215 u16 dur; 216 struct ieee80211_supported_band *sband; 217 218 sband = local->hw.wiphy->bands[frame_txctl->band]; 219 220 short_preamble = false; 221 222 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx]; 223 224 erp = 0; 225 if (vif) { 226 sdata = vif_to_sdata(vif); 227 short_preamble = sdata->vif.bss_conf.use_short_preamble; 228 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 229 erp = rate->flags & IEEE80211_RATE_ERP_G; 230 shift = ieee80211_vif_get_shift(vif); 231 } 232 233 bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift); 234 235 /* CTS duration */ 236 dur = ieee80211_frame_duration(sband->band, 10, bitrate, 237 erp, short_preamble, shift); 238 /* Data frame duration */ 239 dur += ieee80211_frame_duration(sband->band, frame_len, bitrate, 240 erp, short_preamble, shift); 241 /* ACK duration */ 242 dur += ieee80211_frame_duration(sband->band, 10, bitrate, 243 erp, short_preamble, shift); 244 245 return cpu_to_le16(dur); 246 } 247 EXPORT_SYMBOL(ieee80211_rts_duration); 248 249 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw, 250 struct ieee80211_vif *vif, 251 size_t frame_len, 252 const struct ieee80211_tx_info *frame_txctl) 253 { 254 struct ieee80211_local *local = hw_to_local(hw); 255 struct ieee80211_rate *rate; 256 struct ieee80211_sub_if_data *sdata; 257 bool short_preamble; 258 int erp, shift = 0, bitrate; 259 u16 dur; 260 struct ieee80211_supported_band *sband; 261 262 sband = local->hw.wiphy->bands[frame_txctl->band]; 263 264 short_preamble = false; 265 266 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx]; 267 erp = 0; 268 if (vif) { 269 sdata = vif_to_sdata(vif); 270 short_preamble = sdata->vif.bss_conf.use_short_preamble; 271 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 272 erp = rate->flags & IEEE80211_RATE_ERP_G; 273 shift = ieee80211_vif_get_shift(vif); 274 } 275 276 bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift); 277 278 /* Data frame duration */ 279 dur = ieee80211_frame_duration(sband->band, frame_len, bitrate, 280 erp, short_preamble, shift); 281 if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) { 282 /* ACK duration */ 283 dur += ieee80211_frame_duration(sband->band, 10, bitrate, 284 erp, short_preamble, shift); 285 } 286 287 return cpu_to_le16(dur); 288 } 289 EXPORT_SYMBOL(ieee80211_ctstoself_duration); 290 291 static void __ieee80211_wake_txqs(struct ieee80211_sub_if_data *sdata, int ac) 292 { 293 struct ieee80211_local *local = sdata->local; 294 struct ieee80211_vif *vif = &sdata->vif; 295 struct fq *fq = &local->fq; 296 struct ps_data *ps = NULL; 297 struct txq_info *txqi; 298 struct sta_info *sta; 299 int i; 300 301 local_bh_disable(); 302 spin_lock(&fq->lock); 303 304 if (sdata->vif.type == NL80211_IFTYPE_AP) 305 ps = &sdata->bss->ps; 306 307 sdata->vif.txqs_stopped[ac] = false; 308 309 list_for_each_entry_rcu(sta, &local->sta_list, list) { 310 if (sdata != sta->sdata) 311 continue; 312 313 for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) { 314 struct ieee80211_txq *txq = sta->sta.txq[i]; 315 316 if (!txq) 317 continue; 318 319 txqi = to_txq_info(txq); 320 321 if (ac != txq->ac) 322 continue; 323 324 if (!test_and_clear_bit(IEEE80211_TXQ_STOP_NETIF_TX, 325 &txqi->flags)) 326 continue; 327 328 spin_unlock(&fq->lock); 329 drv_wake_tx_queue(local, txqi); 330 spin_lock(&fq->lock); 331 } 332 } 333 334 if (!vif->txq) 335 goto out; 336 337 txqi = to_txq_info(vif->txq); 338 339 if (!test_and_clear_bit(IEEE80211_TXQ_STOP_NETIF_TX, &txqi->flags) || 340 (ps && atomic_read(&ps->num_sta_ps)) || ac != vif->txq->ac) 341 goto out; 342 343 spin_unlock(&fq->lock); 344 345 drv_wake_tx_queue(local, txqi); 346 local_bh_enable(); 347 return; 348 out: 349 spin_unlock(&fq->lock); 350 local_bh_enable(); 351 } 352 353 static void 354 __releases(&local->queue_stop_reason_lock) 355 __acquires(&local->queue_stop_reason_lock) 356 _ieee80211_wake_txqs(struct ieee80211_local *local, unsigned long *flags) 357 { 358 struct ieee80211_sub_if_data *sdata; 359 int n_acs = IEEE80211_NUM_ACS; 360 int i; 361 362 rcu_read_lock(); 363 364 if (local->hw.queues < IEEE80211_NUM_ACS) 365 n_acs = 1; 366 367 for (i = 0; i < local->hw.queues; i++) { 368 if (local->queue_stop_reasons[i]) 369 continue; 370 371 spin_unlock_irqrestore(&local->queue_stop_reason_lock, *flags); 372 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 373 int ac; 374 375 for (ac = 0; ac < n_acs; ac++) { 376 int ac_queue = sdata->vif.hw_queue[ac]; 377 378 if (ac_queue == i || 379 sdata->vif.cab_queue == i) 380 __ieee80211_wake_txqs(sdata, ac); 381 } 382 } 383 spin_lock_irqsave(&local->queue_stop_reason_lock, *flags); 384 } 385 386 rcu_read_unlock(); 387 } 388 389 void ieee80211_wake_txqs(struct tasklet_struct *t) 390 { 391 struct ieee80211_local *local = from_tasklet(local, t, 392 wake_txqs_tasklet); 393 unsigned long flags; 394 395 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 396 _ieee80211_wake_txqs(local, &flags); 397 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 398 } 399 400 void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue) 401 { 402 struct ieee80211_sub_if_data *sdata; 403 int n_acs = IEEE80211_NUM_ACS; 404 405 if (local->ops->wake_tx_queue) 406 return; 407 408 if (local->hw.queues < IEEE80211_NUM_ACS) 409 n_acs = 1; 410 411 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 412 int ac; 413 414 if (!sdata->dev) 415 continue; 416 417 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE && 418 local->queue_stop_reasons[sdata->vif.cab_queue] != 0) 419 continue; 420 421 for (ac = 0; ac < n_acs; ac++) { 422 int ac_queue = sdata->vif.hw_queue[ac]; 423 424 if (ac_queue == queue || 425 (sdata->vif.cab_queue == queue && 426 local->queue_stop_reasons[ac_queue] == 0 && 427 skb_queue_empty(&local->pending[ac_queue]))) 428 netif_wake_subqueue(sdata->dev, ac); 429 } 430 } 431 } 432 433 static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue, 434 enum queue_stop_reason reason, 435 bool refcounted, 436 unsigned long *flags) 437 { 438 struct ieee80211_local *local = hw_to_local(hw); 439 440 trace_wake_queue(local, queue, reason); 441 442 if (WARN_ON(queue >= hw->queues)) 443 return; 444 445 if (!test_bit(reason, &local->queue_stop_reasons[queue])) 446 return; 447 448 if (!refcounted) { 449 local->q_stop_reasons[queue][reason] = 0; 450 } else { 451 local->q_stop_reasons[queue][reason]--; 452 if (WARN_ON(local->q_stop_reasons[queue][reason] < 0)) 453 local->q_stop_reasons[queue][reason] = 0; 454 } 455 456 if (local->q_stop_reasons[queue][reason] == 0) 457 __clear_bit(reason, &local->queue_stop_reasons[queue]); 458 459 if (local->queue_stop_reasons[queue] != 0) 460 /* someone still has this queue stopped */ 461 return; 462 463 if (skb_queue_empty(&local->pending[queue])) { 464 rcu_read_lock(); 465 ieee80211_propagate_queue_wake(local, queue); 466 rcu_read_unlock(); 467 } else 468 tasklet_schedule(&local->tx_pending_tasklet); 469 470 /* 471 * Calling _ieee80211_wake_txqs here can be a problem because it may 472 * release queue_stop_reason_lock which has been taken by 473 * __ieee80211_wake_queue's caller. It is certainly not very nice to 474 * release someone's lock, but it is fine because all the callers of 475 * __ieee80211_wake_queue call it right before releasing the lock. 476 */ 477 if (local->ops->wake_tx_queue) { 478 if (reason == IEEE80211_QUEUE_STOP_REASON_DRIVER) 479 tasklet_schedule(&local->wake_txqs_tasklet); 480 else 481 _ieee80211_wake_txqs(local, flags); 482 } 483 } 484 485 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue, 486 enum queue_stop_reason reason, 487 bool refcounted) 488 { 489 struct ieee80211_local *local = hw_to_local(hw); 490 unsigned long flags; 491 492 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 493 __ieee80211_wake_queue(hw, queue, reason, refcounted, &flags); 494 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 495 } 496 497 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue) 498 { 499 ieee80211_wake_queue_by_reason(hw, queue, 500 IEEE80211_QUEUE_STOP_REASON_DRIVER, 501 false); 502 } 503 EXPORT_SYMBOL(ieee80211_wake_queue); 504 505 static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue, 506 enum queue_stop_reason reason, 507 bool refcounted) 508 { 509 struct ieee80211_local *local = hw_to_local(hw); 510 struct ieee80211_sub_if_data *sdata; 511 int n_acs = IEEE80211_NUM_ACS; 512 513 trace_stop_queue(local, queue, reason); 514 515 if (WARN_ON(queue >= hw->queues)) 516 return; 517 518 if (!refcounted) 519 local->q_stop_reasons[queue][reason] = 1; 520 else 521 local->q_stop_reasons[queue][reason]++; 522 523 if (__test_and_set_bit(reason, &local->queue_stop_reasons[queue])) 524 return; 525 526 if (local->hw.queues < IEEE80211_NUM_ACS) 527 n_acs = 1; 528 529 rcu_read_lock(); 530 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 531 int ac; 532 533 if (!sdata->dev) 534 continue; 535 536 for (ac = 0; ac < n_acs; ac++) { 537 if (sdata->vif.hw_queue[ac] == queue || 538 sdata->vif.cab_queue == queue) { 539 if (!local->ops->wake_tx_queue) { 540 netif_stop_subqueue(sdata->dev, ac); 541 continue; 542 } 543 spin_lock(&local->fq.lock); 544 sdata->vif.txqs_stopped[ac] = true; 545 spin_unlock(&local->fq.lock); 546 } 547 } 548 } 549 rcu_read_unlock(); 550 } 551 552 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue, 553 enum queue_stop_reason reason, 554 bool refcounted) 555 { 556 struct ieee80211_local *local = hw_to_local(hw); 557 unsigned long flags; 558 559 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 560 __ieee80211_stop_queue(hw, queue, reason, refcounted); 561 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 562 } 563 564 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue) 565 { 566 ieee80211_stop_queue_by_reason(hw, queue, 567 IEEE80211_QUEUE_STOP_REASON_DRIVER, 568 false); 569 } 570 EXPORT_SYMBOL(ieee80211_stop_queue); 571 572 void ieee80211_add_pending_skb(struct ieee80211_local *local, 573 struct sk_buff *skb) 574 { 575 struct ieee80211_hw *hw = &local->hw; 576 unsigned long flags; 577 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 578 int queue = info->hw_queue; 579 580 if (WARN_ON(!info->control.vif)) { 581 ieee80211_free_txskb(&local->hw, skb); 582 return; 583 } 584 585 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 586 __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD, 587 false); 588 __skb_queue_tail(&local->pending[queue], skb); 589 __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD, 590 false, &flags); 591 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 592 } 593 594 void ieee80211_add_pending_skbs(struct ieee80211_local *local, 595 struct sk_buff_head *skbs) 596 { 597 struct ieee80211_hw *hw = &local->hw; 598 struct sk_buff *skb; 599 unsigned long flags; 600 int queue, i; 601 602 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 603 while ((skb = skb_dequeue(skbs))) { 604 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 605 606 if (WARN_ON(!info->control.vif)) { 607 ieee80211_free_txskb(&local->hw, skb); 608 continue; 609 } 610 611 queue = info->hw_queue; 612 613 __ieee80211_stop_queue(hw, queue, 614 IEEE80211_QUEUE_STOP_REASON_SKB_ADD, 615 false); 616 617 __skb_queue_tail(&local->pending[queue], skb); 618 } 619 620 for (i = 0; i < hw->queues; i++) 621 __ieee80211_wake_queue(hw, i, 622 IEEE80211_QUEUE_STOP_REASON_SKB_ADD, 623 false, &flags); 624 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 625 } 626 627 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw, 628 unsigned long queues, 629 enum queue_stop_reason reason, 630 bool refcounted) 631 { 632 struct ieee80211_local *local = hw_to_local(hw); 633 unsigned long flags; 634 int i; 635 636 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 637 638 for_each_set_bit(i, &queues, hw->queues) 639 __ieee80211_stop_queue(hw, i, reason, refcounted); 640 641 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 642 } 643 644 void ieee80211_stop_queues(struct ieee80211_hw *hw) 645 { 646 ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP, 647 IEEE80211_QUEUE_STOP_REASON_DRIVER, 648 false); 649 } 650 EXPORT_SYMBOL(ieee80211_stop_queues); 651 652 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue) 653 { 654 struct ieee80211_local *local = hw_to_local(hw); 655 unsigned long flags; 656 int ret; 657 658 if (WARN_ON(queue >= hw->queues)) 659 return true; 660 661 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 662 ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER, 663 &local->queue_stop_reasons[queue]); 664 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 665 return ret; 666 } 667 EXPORT_SYMBOL(ieee80211_queue_stopped); 668 669 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw, 670 unsigned long queues, 671 enum queue_stop_reason reason, 672 bool refcounted) 673 { 674 struct ieee80211_local *local = hw_to_local(hw); 675 unsigned long flags; 676 int i; 677 678 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 679 680 for_each_set_bit(i, &queues, hw->queues) 681 __ieee80211_wake_queue(hw, i, reason, refcounted, &flags); 682 683 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 684 } 685 686 void ieee80211_wake_queues(struct ieee80211_hw *hw) 687 { 688 ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP, 689 IEEE80211_QUEUE_STOP_REASON_DRIVER, 690 false); 691 } 692 EXPORT_SYMBOL(ieee80211_wake_queues); 693 694 static unsigned int 695 ieee80211_get_vif_queues(struct ieee80211_local *local, 696 struct ieee80211_sub_if_data *sdata) 697 { 698 unsigned int queues; 699 700 if (sdata && ieee80211_hw_check(&local->hw, QUEUE_CONTROL)) { 701 int ac; 702 703 queues = 0; 704 705 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) 706 queues |= BIT(sdata->vif.hw_queue[ac]); 707 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE) 708 queues |= BIT(sdata->vif.cab_queue); 709 } else { 710 /* all queues */ 711 queues = BIT(local->hw.queues) - 1; 712 } 713 714 return queues; 715 } 716 717 void __ieee80211_flush_queues(struct ieee80211_local *local, 718 struct ieee80211_sub_if_data *sdata, 719 unsigned int queues, bool drop) 720 { 721 if (!local->ops->flush) 722 return; 723 724 /* 725 * If no queue was set, or if the HW doesn't support 726 * IEEE80211_HW_QUEUE_CONTROL - flush all queues 727 */ 728 if (!queues || !ieee80211_hw_check(&local->hw, QUEUE_CONTROL)) 729 queues = ieee80211_get_vif_queues(local, sdata); 730 731 ieee80211_stop_queues_by_reason(&local->hw, queues, 732 IEEE80211_QUEUE_STOP_REASON_FLUSH, 733 false); 734 735 drv_flush(local, sdata, queues, drop); 736 737 ieee80211_wake_queues_by_reason(&local->hw, queues, 738 IEEE80211_QUEUE_STOP_REASON_FLUSH, 739 false); 740 } 741 742 void ieee80211_flush_queues(struct ieee80211_local *local, 743 struct ieee80211_sub_if_data *sdata, bool drop) 744 { 745 __ieee80211_flush_queues(local, sdata, 0, drop); 746 } 747 748 void ieee80211_stop_vif_queues(struct ieee80211_local *local, 749 struct ieee80211_sub_if_data *sdata, 750 enum queue_stop_reason reason) 751 { 752 ieee80211_stop_queues_by_reason(&local->hw, 753 ieee80211_get_vif_queues(local, sdata), 754 reason, true); 755 } 756 757 void ieee80211_wake_vif_queues(struct ieee80211_local *local, 758 struct ieee80211_sub_if_data *sdata, 759 enum queue_stop_reason reason) 760 { 761 ieee80211_wake_queues_by_reason(&local->hw, 762 ieee80211_get_vif_queues(local, sdata), 763 reason, true); 764 } 765 766 static void __iterate_interfaces(struct ieee80211_local *local, 767 u32 iter_flags, 768 void (*iterator)(void *data, u8 *mac, 769 struct ieee80211_vif *vif), 770 void *data) 771 { 772 struct ieee80211_sub_if_data *sdata; 773 bool active_only = iter_flags & IEEE80211_IFACE_ITER_ACTIVE; 774 775 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 776 switch (sdata->vif.type) { 777 case NL80211_IFTYPE_MONITOR: 778 if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE)) 779 continue; 780 break; 781 case NL80211_IFTYPE_AP_VLAN: 782 continue; 783 default: 784 break; 785 } 786 if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) && 787 active_only && !(sdata->flags & IEEE80211_SDATA_IN_DRIVER)) 788 continue; 789 if ((iter_flags & IEEE80211_IFACE_SKIP_SDATA_NOT_IN_DRIVER) && 790 !(sdata->flags & IEEE80211_SDATA_IN_DRIVER)) 791 continue; 792 if (ieee80211_sdata_running(sdata) || !active_only) 793 iterator(data, sdata->vif.addr, 794 &sdata->vif); 795 } 796 797 sdata = rcu_dereference_check(local->monitor_sdata, 798 lockdep_is_held(&local->iflist_mtx) || 799 lockdep_rtnl_is_held()); 800 if (sdata && 801 (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL || !active_only || 802 sdata->flags & IEEE80211_SDATA_IN_DRIVER)) 803 iterator(data, sdata->vif.addr, &sdata->vif); 804 } 805 806 void ieee80211_iterate_interfaces( 807 struct ieee80211_hw *hw, u32 iter_flags, 808 void (*iterator)(void *data, u8 *mac, 809 struct ieee80211_vif *vif), 810 void *data) 811 { 812 struct ieee80211_local *local = hw_to_local(hw); 813 814 mutex_lock(&local->iflist_mtx); 815 __iterate_interfaces(local, iter_flags, iterator, data); 816 mutex_unlock(&local->iflist_mtx); 817 } 818 EXPORT_SYMBOL_GPL(ieee80211_iterate_interfaces); 819 820 void ieee80211_iterate_active_interfaces_atomic( 821 struct ieee80211_hw *hw, u32 iter_flags, 822 void (*iterator)(void *data, u8 *mac, 823 struct ieee80211_vif *vif), 824 void *data) 825 { 826 struct ieee80211_local *local = hw_to_local(hw); 827 828 rcu_read_lock(); 829 __iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE, 830 iterator, data); 831 rcu_read_unlock(); 832 } 833 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic); 834 835 void ieee80211_iterate_active_interfaces_mtx( 836 struct ieee80211_hw *hw, u32 iter_flags, 837 void (*iterator)(void *data, u8 *mac, 838 struct ieee80211_vif *vif), 839 void *data) 840 { 841 struct ieee80211_local *local = hw_to_local(hw); 842 843 lockdep_assert_wiphy(hw->wiphy); 844 845 __iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE, 846 iterator, data); 847 } 848 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_mtx); 849 850 static void __iterate_stations(struct ieee80211_local *local, 851 void (*iterator)(void *data, 852 struct ieee80211_sta *sta), 853 void *data) 854 { 855 struct sta_info *sta; 856 857 list_for_each_entry_rcu(sta, &local->sta_list, list) { 858 if (!sta->uploaded) 859 continue; 860 861 iterator(data, &sta->sta); 862 } 863 } 864 865 void ieee80211_iterate_stations_atomic(struct ieee80211_hw *hw, 866 void (*iterator)(void *data, 867 struct ieee80211_sta *sta), 868 void *data) 869 { 870 struct ieee80211_local *local = hw_to_local(hw); 871 872 rcu_read_lock(); 873 __iterate_stations(local, iterator, data); 874 rcu_read_unlock(); 875 } 876 EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_atomic); 877 878 struct ieee80211_vif *wdev_to_ieee80211_vif(struct wireless_dev *wdev) 879 { 880 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev); 881 882 if (!ieee80211_sdata_running(sdata) || 883 !(sdata->flags & IEEE80211_SDATA_IN_DRIVER)) 884 return NULL; 885 return &sdata->vif; 886 } 887 EXPORT_SYMBOL_GPL(wdev_to_ieee80211_vif); 888 889 struct wireless_dev *ieee80211_vif_to_wdev(struct ieee80211_vif *vif) 890 { 891 if (!vif) 892 return NULL; 893 894 return &vif_to_sdata(vif)->wdev; 895 } 896 EXPORT_SYMBOL_GPL(ieee80211_vif_to_wdev); 897 898 /* 899 * Nothing should have been stuffed into the workqueue during 900 * the suspend->resume cycle. Since we can't check each caller 901 * of this function if we are already quiescing / suspended, 902 * check here and don't WARN since this can actually happen when 903 * the rx path (for example) is racing against __ieee80211_suspend 904 * and suspending / quiescing was set after the rx path checked 905 * them. 906 */ 907 static bool ieee80211_can_queue_work(struct ieee80211_local *local) 908 { 909 if (local->quiescing || (local->suspended && !local->resuming)) { 910 pr_warn("queueing ieee80211 work while going to suspend\n"); 911 return false; 912 } 913 914 return true; 915 } 916 917 void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work) 918 { 919 struct ieee80211_local *local = hw_to_local(hw); 920 921 if (!ieee80211_can_queue_work(local)) 922 return; 923 924 queue_work(local->workqueue, work); 925 } 926 EXPORT_SYMBOL(ieee80211_queue_work); 927 928 void ieee80211_queue_delayed_work(struct ieee80211_hw *hw, 929 struct delayed_work *dwork, 930 unsigned long delay) 931 { 932 struct ieee80211_local *local = hw_to_local(hw); 933 934 if (!ieee80211_can_queue_work(local)) 935 return; 936 937 queue_delayed_work(local->workqueue, dwork, delay); 938 } 939 EXPORT_SYMBOL(ieee80211_queue_delayed_work); 940 941 static void ieee80211_parse_extension_element(u32 *crc, 942 const struct element *elem, 943 struct ieee802_11_elems *elems) 944 { 945 const void *data = elem->data + 1; 946 u8 len = elem->datalen - 1; 947 948 switch (elem->data[0]) { 949 case WLAN_EID_EXT_HE_MU_EDCA: 950 if (len >= sizeof(*elems->mu_edca_param_set)) { 951 elems->mu_edca_param_set = data; 952 if (crc) 953 *crc = crc32_be(*crc, (void *)elem, 954 elem->datalen + 2); 955 } 956 break; 957 case WLAN_EID_EXT_HE_CAPABILITY: 958 elems->he_cap = data; 959 elems->he_cap_len = len; 960 break; 961 case WLAN_EID_EXT_HE_OPERATION: 962 if (len >= sizeof(*elems->he_operation) && 963 len >= ieee80211_he_oper_size(data) - 1) { 964 if (crc) 965 *crc = crc32_be(*crc, (void *)elem, 966 elem->datalen + 2); 967 elems->he_operation = data; 968 } 969 break; 970 case WLAN_EID_EXT_UORA: 971 if (len >= 1) 972 elems->uora_element = data; 973 break; 974 case WLAN_EID_EXT_MAX_CHANNEL_SWITCH_TIME: 975 if (len == 3) 976 elems->max_channel_switch_time = data; 977 break; 978 case WLAN_EID_EXT_MULTIPLE_BSSID_CONFIGURATION: 979 if (len >= sizeof(*elems->mbssid_config_ie)) 980 elems->mbssid_config_ie = data; 981 break; 982 case WLAN_EID_EXT_HE_SPR: 983 if (len >= sizeof(*elems->he_spr) && 984 len >= ieee80211_he_spr_size(data)) 985 elems->he_spr = data; 986 break; 987 case WLAN_EID_EXT_HE_6GHZ_CAPA: 988 if (len >= sizeof(*elems->he_6ghz_capa)) 989 elems->he_6ghz_capa = data; 990 break; 991 } 992 } 993 994 static u32 995 _ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action, 996 struct ieee802_11_elems *elems, 997 u64 filter, u32 crc, 998 const struct element *check_inherit) 999 { 1000 const struct element *elem; 1001 bool calc_crc = filter != 0; 1002 DECLARE_BITMAP(seen_elems, 256); 1003 const u8 *ie; 1004 1005 bitmap_zero(seen_elems, 256); 1006 1007 for_each_element(elem, start, len) { 1008 bool elem_parse_failed; 1009 u8 id = elem->id; 1010 u8 elen = elem->datalen; 1011 const u8 *pos = elem->data; 1012 1013 if (check_inherit && 1014 !cfg80211_is_element_inherited(elem, 1015 check_inherit)) 1016 continue; 1017 1018 switch (id) { 1019 case WLAN_EID_SSID: 1020 case WLAN_EID_SUPP_RATES: 1021 case WLAN_EID_FH_PARAMS: 1022 case WLAN_EID_DS_PARAMS: 1023 case WLAN_EID_CF_PARAMS: 1024 case WLAN_EID_TIM: 1025 case WLAN_EID_IBSS_PARAMS: 1026 case WLAN_EID_CHALLENGE: 1027 case WLAN_EID_RSN: 1028 case WLAN_EID_ERP_INFO: 1029 case WLAN_EID_EXT_SUPP_RATES: 1030 case WLAN_EID_HT_CAPABILITY: 1031 case WLAN_EID_HT_OPERATION: 1032 case WLAN_EID_VHT_CAPABILITY: 1033 case WLAN_EID_VHT_OPERATION: 1034 case WLAN_EID_MESH_ID: 1035 case WLAN_EID_MESH_CONFIG: 1036 case WLAN_EID_PEER_MGMT: 1037 case WLAN_EID_PREQ: 1038 case WLAN_EID_PREP: 1039 case WLAN_EID_PERR: 1040 case WLAN_EID_RANN: 1041 case WLAN_EID_CHANNEL_SWITCH: 1042 case WLAN_EID_EXT_CHANSWITCH_ANN: 1043 case WLAN_EID_COUNTRY: 1044 case WLAN_EID_PWR_CONSTRAINT: 1045 case WLAN_EID_TIMEOUT_INTERVAL: 1046 case WLAN_EID_SECONDARY_CHANNEL_OFFSET: 1047 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH: 1048 case WLAN_EID_CHAN_SWITCH_PARAM: 1049 case WLAN_EID_EXT_CAPABILITY: 1050 case WLAN_EID_CHAN_SWITCH_TIMING: 1051 case WLAN_EID_LINK_ID: 1052 case WLAN_EID_BSS_MAX_IDLE_PERIOD: 1053 case WLAN_EID_RSNX: 1054 case WLAN_EID_S1G_BCN_COMPAT: 1055 case WLAN_EID_S1G_CAPABILITIES: 1056 case WLAN_EID_S1G_OPERATION: 1057 case WLAN_EID_AID_RESPONSE: 1058 case WLAN_EID_S1G_SHORT_BCN_INTERVAL: 1059 /* 1060 * not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible 1061 * that if the content gets bigger it might be needed more than once 1062 */ 1063 if (test_bit(id, seen_elems)) { 1064 elems->parse_error = true; 1065 continue; 1066 } 1067 break; 1068 } 1069 1070 if (calc_crc && id < 64 && (filter & (1ULL << id))) 1071 crc = crc32_be(crc, pos - 2, elen + 2); 1072 1073 elem_parse_failed = false; 1074 1075 switch (id) { 1076 case WLAN_EID_LINK_ID: 1077 if (elen + 2 < sizeof(struct ieee80211_tdls_lnkie)) { 1078 elem_parse_failed = true; 1079 break; 1080 } 1081 elems->lnk_id = (void *)(pos - 2); 1082 break; 1083 case WLAN_EID_CHAN_SWITCH_TIMING: 1084 if (elen < sizeof(struct ieee80211_ch_switch_timing)) { 1085 elem_parse_failed = true; 1086 break; 1087 } 1088 elems->ch_sw_timing = (void *)pos; 1089 break; 1090 case WLAN_EID_EXT_CAPABILITY: 1091 elems->ext_capab = pos; 1092 elems->ext_capab_len = elen; 1093 break; 1094 case WLAN_EID_SSID: 1095 elems->ssid = pos; 1096 elems->ssid_len = elen; 1097 break; 1098 case WLAN_EID_SUPP_RATES: 1099 elems->supp_rates = pos; 1100 elems->supp_rates_len = elen; 1101 break; 1102 case WLAN_EID_DS_PARAMS: 1103 if (elen >= 1) 1104 elems->ds_params = pos; 1105 else 1106 elem_parse_failed = true; 1107 break; 1108 case WLAN_EID_TIM: 1109 if (elen >= sizeof(struct ieee80211_tim_ie)) { 1110 elems->tim = (void *)pos; 1111 elems->tim_len = elen; 1112 } else 1113 elem_parse_failed = true; 1114 break; 1115 case WLAN_EID_VENDOR_SPECIFIC: 1116 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 && 1117 pos[2] == 0xf2) { 1118 /* Microsoft OUI (00:50:F2) */ 1119 1120 if (calc_crc) 1121 crc = crc32_be(crc, pos - 2, elen + 2); 1122 1123 if (elen >= 5 && pos[3] == 2) { 1124 /* OUI Type 2 - WMM IE */ 1125 if (pos[4] == 0) { 1126 elems->wmm_info = pos; 1127 elems->wmm_info_len = elen; 1128 } else if (pos[4] == 1) { 1129 elems->wmm_param = pos; 1130 elems->wmm_param_len = elen; 1131 } 1132 } 1133 } 1134 break; 1135 case WLAN_EID_RSN: 1136 elems->rsn = pos; 1137 elems->rsn_len = elen; 1138 break; 1139 case WLAN_EID_ERP_INFO: 1140 if (elen >= 1) 1141 elems->erp_info = pos; 1142 else 1143 elem_parse_failed = true; 1144 break; 1145 case WLAN_EID_EXT_SUPP_RATES: 1146 elems->ext_supp_rates = pos; 1147 elems->ext_supp_rates_len = elen; 1148 break; 1149 case WLAN_EID_HT_CAPABILITY: 1150 if (elen >= sizeof(struct ieee80211_ht_cap)) 1151 elems->ht_cap_elem = (void *)pos; 1152 else 1153 elem_parse_failed = true; 1154 break; 1155 case WLAN_EID_HT_OPERATION: 1156 if (elen >= sizeof(struct ieee80211_ht_operation)) 1157 elems->ht_operation = (void *)pos; 1158 else 1159 elem_parse_failed = true; 1160 break; 1161 case WLAN_EID_VHT_CAPABILITY: 1162 if (elen >= sizeof(struct ieee80211_vht_cap)) 1163 elems->vht_cap_elem = (void *)pos; 1164 else 1165 elem_parse_failed = true; 1166 break; 1167 case WLAN_EID_VHT_OPERATION: 1168 if (elen >= sizeof(struct ieee80211_vht_operation)) { 1169 elems->vht_operation = (void *)pos; 1170 if (calc_crc) 1171 crc = crc32_be(crc, pos - 2, elen + 2); 1172 break; 1173 } 1174 elem_parse_failed = true; 1175 break; 1176 case WLAN_EID_OPMODE_NOTIF: 1177 if (elen > 0) { 1178 elems->opmode_notif = pos; 1179 if (calc_crc) 1180 crc = crc32_be(crc, pos - 2, elen + 2); 1181 break; 1182 } 1183 elem_parse_failed = true; 1184 break; 1185 case WLAN_EID_MESH_ID: 1186 elems->mesh_id = pos; 1187 elems->mesh_id_len = elen; 1188 break; 1189 case WLAN_EID_MESH_CONFIG: 1190 if (elen >= sizeof(struct ieee80211_meshconf_ie)) 1191 elems->mesh_config = (void *)pos; 1192 else 1193 elem_parse_failed = true; 1194 break; 1195 case WLAN_EID_PEER_MGMT: 1196 elems->peering = pos; 1197 elems->peering_len = elen; 1198 break; 1199 case WLAN_EID_MESH_AWAKE_WINDOW: 1200 if (elen >= 2) 1201 elems->awake_window = (void *)pos; 1202 break; 1203 case WLAN_EID_PREQ: 1204 elems->preq = pos; 1205 elems->preq_len = elen; 1206 break; 1207 case WLAN_EID_PREP: 1208 elems->prep = pos; 1209 elems->prep_len = elen; 1210 break; 1211 case WLAN_EID_PERR: 1212 elems->perr = pos; 1213 elems->perr_len = elen; 1214 break; 1215 case WLAN_EID_RANN: 1216 if (elen >= sizeof(struct ieee80211_rann_ie)) 1217 elems->rann = (void *)pos; 1218 else 1219 elem_parse_failed = true; 1220 break; 1221 case WLAN_EID_CHANNEL_SWITCH: 1222 if (elen != sizeof(struct ieee80211_channel_sw_ie)) { 1223 elem_parse_failed = true; 1224 break; 1225 } 1226 elems->ch_switch_ie = (void *)pos; 1227 break; 1228 case WLAN_EID_EXT_CHANSWITCH_ANN: 1229 if (elen != sizeof(struct ieee80211_ext_chansw_ie)) { 1230 elem_parse_failed = true; 1231 break; 1232 } 1233 elems->ext_chansw_ie = (void *)pos; 1234 break; 1235 case WLAN_EID_SECONDARY_CHANNEL_OFFSET: 1236 if (elen != sizeof(struct ieee80211_sec_chan_offs_ie)) { 1237 elem_parse_failed = true; 1238 break; 1239 } 1240 elems->sec_chan_offs = (void *)pos; 1241 break; 1242 case WLAN_EID_CHAN_SWITCH_PARAM: 1243 if (elen < 1244 sizeof(*elems->mesh_chansw_params_ie)) { 1245 elem_parse_failed = true; 1246 break; 1247 } 1248 elems->mesh_chansw_params_ie = (void *)pos; 1249 break; 1250 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH: 1251 if (!action || 1252 elen < sizeof(*elems->wide_bw_chansw_ie)) { 1253 elem_parse_failed = true; 1254 break; 1255 } 1256 elems->wide_bw_chansw_ie = (void *)pos; 1257 break; 1258 case WLAN_EID_CHANNEL_SWITCH_WRAPPER: 1259 if (action) { 1260 elem_parse_failed = true; 1261 break; 1262 } 1263 /* 1264 * This is a bit tricky, but as we only care about 1265 * the wide bandwidth channel switch element, so 1266 * just parse it out manually. 1267 */ 1268 ie = cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH, 1269 pos, elen); 1270 if (ie) { 1271 if (ie[1] >= sizeof(*elems->wide_bw_chansw_ie)) 1272 elems->wide_bw_chansw_ie = 1273 (void *)(ie + 2); 1274 else 1275 elem_parse_failed = true; 1276 } 1277 break; 1278 case WLAN_EID_COUNTRY: 1279 elems->country_elem = pos; 1280 elems->country_elem_len = elen; 1281 break; 1282 case WLAN_EID_PWR_CONSTRAINT: 1283 if (elen != 1) { 1284 elem_parse_failed = true; 1285 break; 1286 } 1287 elems->pwr_constr_elem = pos; 1288 break; 1289 case WLAN_EID_CISCO_VENDOR_SPECIFIC: 1290 /* Lots of different options exist, but we only care 1291 * about the Dynamic Transmit Power Control element. 1292 * First check for the Cisco OUI, then for the DTPC 1293 * tag (0x00). 1294 */ 1295 if (elen < 4) { 1296 elem_parse_failed = true; 1297 break; 1298 } 1299 1300 if (pos[0] != 0x00 || pos[1] != 0x40 || 1301 pos[2] != 0x96 || pos[3] != 0x00) 1302 break; 1303 1304 if (elen != 6) { 1305 elem_parse_failed = true; 1306 break; 1307 } 1308 1309 if (calc_crc) 1310 crc = crc32_be(crc, pos - 2, elen + 2); 1311 1312 elems->cisco_dtpc_elem = pos; 1313 break; 1314 case WLAN_EID_ADDBA_EXT: 1315 if (elen < sizeof(struct ieee80211_addba_ext_ie)) { 1316 elem_parse_failed = true; 1317 break; 1318 } 1319 elems->addba_ext_ie = (void *)pos; 1320 break; 1321 case WLAN_EID_TIMEOUT_INTERVAL: 1322 if (elen >= sizeof(struct ieee80211_timeout_interval_ie)) 1323 elems->timeout_int = (void *)pos; 1324 else 1325 elem_parse_failed = true; 1326 break; 1327 case WLAN_EID_BSS_MAX_IDLE_PERIOD: 1328 if (elen >= sizeof(*elems->max_idle_period_ie)) 1329 elems->max_idle_period_ie = (void *)pos; 1330 break; 1331 case WLAN_EID_RSNX: 1332 elems->rsnx = pos; 1333 elems->rsnx_len = elen; 1334 break; 1335 case WLAN_EID_TX_POWER_ENVELOPE: 1336 if (elen < 1 || 1337 elen > sizeof(struct ieee80211_tx_pwr_env)) 1338 break; 1339 1340 if (elems->tx_pwr_env_num >= ARRAY_SIZE(elems->tx_pwr_env)) 1341 break; 1342 1343 elems->tx_pwr_env[elems->tx_pwr_env_num] = (void *)pos; 1344 elems->tx_pwr_env_len[elems->tx_pwr_env_num] = elen; 1345 elems->tx_pwr_env_num++; 1346 break; 1347 case WLAN_EID_EXTENSION: 1348 ieee80211_parse_extension_element(calc_crc ? 1349 &crc : NULL, 1350 elem, elems); 1351 break; 1352 case WLAN_EID_S1G_CAPABILITIES: 1353 if (elen >= sizeof(*elems->s1g_capab)) 1354 elems->s1g_capab = (void *)pos; 1355 else 1356 elem_parse_failed = true; 1357 break; 1358 case WLAN_EID_S1G_OPERATION: 1359 if (elen == sizeof(*elems->s1g_oper)) 1360 elems->s1g_oper = (void *)pos; 1361 else 1362 elem_parse_failed = true; 1363 break; 1364 case WLAN_EID_S1G_BCN_COMPAT: 1365 if (elen == sizeof(*elems->s1g_bcn_compat)) 1366 elems->s1g_bcn_compat = (void *)pos; 1367 else 1368 elem_parse_failed = true; 1369 break; 1370 case WLAN_EID_AID_RESPONSE: 1371 if (elen == sizeof(struct ieee80211_aid_response_ie)) 1372 elems->aid_resp = (void *)pos; 1373 else 1374 elem_parse_failed = true; 1375 break; 1376 default: 1377 break; 1378 } 1379 1380 if (elem_parse_failed) 1381 elems->parse_error = true; 1382 else 1383 __set_bit(id, seen_elems); 1384 } 1385 1386 if (!for_each_element_completed(elem, start, len)) 1387 elems->parse_error = true; 1388 1389 return crc; 1390 } 1391 1392 static size_t ieee802_11_find_bssid_profile(const u8 *start, size_t len, 1393 struct ieee802_11_elems *elems, 1394 const u8 *transmitter_bssid, 1395 const u8 *bss_bssid, 1396 u8 *nontransmitted_profile) 1397 { 1398 const struct element *elem, *sub; 1399 size_t profile_len = 0; 1400 bool found = false; 1401 1402 if (!bss_bssid || !transmitter_bssid) 1403 return profile_len; 1404 1405 for_each_element_id(elem, WLAN_EID_MULTIPLE_BSSID, start, len) { 1406 if (elem->datalen < 2) 1407 continue; 1408 1409 for_each_element(sub, elem->data + 1, elem->datalen - 1) { 1410 u8 new_bssid[ETH_ALEN]; 1411 const u8 *index; 1412 1413 if (sub->id != 0 || sub->datalen < 4) { 1414 /* not a valid BSS profile */ 1415 continue; 1416 } 1417 1418 if (sub->data[0] != WLAN_EID_NON_TX_BSSID_CAP || 1419 sub->data[1] != 2) { 1420 /* The first element of the 1421 * Nontransmitted BSSID Profile is not 1422 * the Nontransmitted BSSID Capability 1423 * element. 1424 */ 1425 continue; 1426 } 1427 1428 memset(nontransmitted_profile, 0, len); 1429 profile_len = cfg80211_merge_profile(start, len, 1430 elem, 1431 sub, 1432 nontransmitted_profile, 1433 len); 1434 1435 /* found a Nontransmitted BSSID Profile */ 1436 index = cfg80211_find_ie(WLAN_EID_MULTI_BSSID_IDX, 1437 nontransmitted_profile, 1438 profile_len); 1439 if (!index || index[1] < 1 || index[2] == 0) { 1440 /* Invalid MBSSID Index element */ 1441 continue; 1442 } 1443 1444 cfg80211_gen_new_bssid(transmitter_bssid, 1445 elem->data[0], 1446 index[2], 1447 new_bssid); 1448 if (ether_addr_equal(new_bssid, bss_bssid)) { 1449 found = true; 1450 elems->bssid_index_len = index[1]; 1451 elems->bssid_index = (void *)&index[2]; 1452 break; 1453 } 1454 } 1455 } 1456 1457 return found ? profile_len : 0; 1458 } 1459 1460 struct ieee802_11_elems *ieee802_11_parse_elems_crc(const u8 *start, size_t len, 1461 bool action, u64 filter, 1462 u32 crc, 1463 const u8 *transmitter_bssid, 1464 const u8 *bss_bssid) 1465 { 1466 struct ieee802_11_elems *elems; 1467 const struct element *non_inherit = NULL; 1468 u8 *nontransmitted_profile; 1469 int nontransmitted_profile_len = 0; 1470 1471 elems = kzalloc(sizeof(*elems), GFP_ATOMIC); 1472 if (!elems) 1473 return NULL; 1474 elems->ie_start = start; 1475 elems->total_len = len; 1476 1477 nontransmitted_profile = kmalloc(len, GFP_ATOMIC); 1478 if (nontransmitted_profile) { 1479 nontransmitted_profile_len = 1480 ieee802_11_find_bssid_profile(start, len, elems, 1481 transmitter_bssid, 1482 bss_bssid, 1483 nontransmitted_profile); 1484 non_inherit = 1485 cfg80211_find_ext_elem(WLAN_EID_EXT_NON_INHERITANCE, 1486 nontransmitted_profile, 1487 nontransmitted_profile_len); 1488 } 1489 1490 crc = _ieee802_11_parse_elems_crc(start, len, action, elems, filter, 1491 crc, non_inherit); 1492 1493 /* Override with nontransmitted profile, if found */ 1494 if (nontransmitted_profile_len) 1495 _ieee802_11_parse_elems_crc(nontransmitted_profile, 1496 nontransmitted_profile_len, 1497 action, elems, 0, 0, NULL); 1498 1499 if (elems->tim && !elems->parse_error) { 1500 const struct ieee80211_tim_ie *tim_ie = elems->tim; 1501 1502 elems->dtim_period = tim_ie->dtim_period; 1503 elems->dtim_count = tim_ie->dtim_count; 1504 } 1505 1506 /* Override DTIM period and count if needed */ 1507 if (elems->bssid_index && 1508 elems->bssid_index_len >= 1509 offsetofend(struct ieee80211_bssid_index, dtim_period)) 1510 elems->dtim_period = elems->bssid_index->dtim_period; 1511 1512 if (elems->bssid_index && 1513 elems->bssid_index_len >= 1514 offsetofend(struct ieee80211_bssid_index, dtim_count)) 1515 elems->dtim_count = elems->bssid_index->dtim_count; 1516 1517 kfree(nontransmitted_profile); 1518 1519 elems->crc = crc; 1520 1521 return elems; 1522 } 1523 1524 void ieee80211_regulatory_limit_wmm_params(struct ieee80211_sub_if_data *sdata, 1525 struct ieee80211_tx_queue_params 1526 *qparam, int ac) 1527 { 1528 struct ieee80211_chanctx_conf *chanctx_conf; 1529 const struct ieee80211_reg_rule *rrule; 1530 const struct ieee80211_wmm_ac *wmm_ac; 1531 u16 center_freq = 0; 1532 1533 if (sdata->vif.type != NL80211_IFTYPE_AP && 1534 sdata->vif.type != NL80211_IFTYPE_STATION) 1535 return; 1536 1537 rcu_read_lock(); 1538 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 1539 if (chanctx_conf) 1540 center_freq = chanctx_conf->def.chan->center_freq; 1541 1542 if (!center_freq) { 1543 rcu_read_unlock(); 1544 return; 1545 } 1546 1547 rrule = freq_reg_info(sdata->wdev.wiphy, MHZ_TO_KHZ(center_freq)); 1548 1549 if (IS_ERR_OR_NULL(rrule) || !rrule->has_wmm) { 1550 rcu_read_unlock(); 1551 return; 1552 } 1553 1554 if (sdata->vif.type == NL80211_IFTYPE_AP) 1555 wmm_ac = &rrule->wmm_rule.ap[ac]; 1556 else 1557 wmm_ac = &rrule->wmm_rule.client[ac]; 1558 qparam->cw_min = max_t(u16, qparam->cw_min, wmm_ac->cw_min); 1559 qparam->cw_max = max_t(u16, qparam->cw_max, wmm_ac->cw_max); 1560 qparam->aifs = max_t(u8, qparam->aifs, wmm_ac->aifsn); 1561 qparam->txop = min_t(u16, qparam->txop, wmm_ac->cot / 32); 1562 rcu_read_unlock(); 1563 } 1564 1565 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata, 1566 bool bss_notify, bool enable_qos) 1567 { 1568 struct ieee80211_local *local = sdata->local; 1569 struct ieee80211_tx_queue_params qparam; 1570 struct ieee80211_chanctx_conf *chanctx_conf; 1571 int ac; 1572 bool use_11b; 1573 bool is_ocb; /* Use another EDCA parameters if dot11OCBActivated=true */ 1574 int aCWmin, aCWmax; 1575 1576 if (!local->ops->conf_tx) 1577 return; 1578 1579 if (local->hw.queues < IEEE80211_NUM_ACS) 1580 return; 1581 1582 memset(&qparam, 0, sizeof(qparam)); 1583 1584 rcu_read_lock(); 1585 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 1586 use_11b = (chanctx_conf && 1587 chanctx_conf->def.chan->band == NL80211_BAND_2GHZ) && 1588 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE); 1589 rcu_read_unlock(); 1590 1591 is_ocb = (sdata->vif.type == NL80211_IFTYPE_OCB); 1592 1593 /* Set defaults according to 802.11-2007 Table 7-37 */ 1594 aCWmax = 1023; 1595 if (use_11b) 1596 aCWmin = 31; 1597 else 1598 aCWmin = 15; 1599 1600 /* Confiure old 802.11b/g medium access rules. */ 1601 qparam.cw_max = aCWmax; 1602 qparam.cw_min = aCWmin; 1603 qparam.txop = 0; 1604 qparam.aifs = 2; 1605 1606 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 1607 /* Update if QoS is enabled. */ 1608 if (enable_qos) { 1609 switch (ac) { 1610 case IEEE80211_AC_BK: 1611 qparam.cw_max = aCWmax; 1612 qparam.cw_min = aCWmin; 1613 qparam.txop = 0; 1614 if (is_ocb) 1615 qparam.aifs = 9; 1616 else 1617 qparam.aifs = 7; 1618 break; 1619 /* never happens but let's not leave undefined */ 1620 default: 1621 case IEEE80211_AC_BE: 1622 qparam.cw_max = aCWmax; 1623 qparam.cw_min = aCWmin; 1624 qparam.txop = 0; 1625 if (is_ocb) 1626 qparam.aifs = 6; 1627 else 1628 qparam.aifs = 3; 1629 break; 1630 case IEEE80211_AC_VI: 1631 qparam.cw_max = aCWmin; 1632 qparam.cw_min = (aCWmin + 1) / 2 - 1; 1633 if (is_ocb) 1634 qparam.txop = 0; 1635 else if (use_11b) 1636 qparam.txop = 6016/32; 1637 else 1638 qparam.txop = 3008/32; 1639 1640 if (is_ocb) 1641 qparam.aifs = 3; 1642 else 1643 qparam.aifs = 2; 1644 break; 1645 case IEEE80211_AC_VO: 1646 qparam.cw_max = (aCWmin + 1) / 2 - 1; 1647 qparam.cw_min = (aCWmin + 1) / 4 - 1; 1648 if (is_ocb) 1649 qparam.txop = 0; 1650 else if (use_11b) 1651 qparam.txop = 3264/32; 1652 else 1653 qparam.txop = 1504/32; 1654 qparam.aifs = 2; 1655 break; 1656 } 1657 } 1658 ieee80211_regulatory_limit_wmm_params(sdata, &qparam, ac); 1659 1660 qparam.uapsd = false; 1661 1662 sdata->tx_conf[ac] = qparam; 1663 drv_conf_tx(local, sdata, ac, &qparam); 1664 } 1665 1666 if (sdata->vif.type != NL80211_IFTYPE_MONITOR && 1667 sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE && 1668 sdata->vif.type != NL80211_IFTYPE_NAN) { 1669 sdata->vif.bss_conf.qos = enable_qos; 1670 if (bss_notify) 1671 ieee80211_bss_info_change_notify(sdata, 1672 BSS_CHANGED_QOS); 1673 } 1674 } 1675 1676 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata, 1677 u16 transaction, u16 auth_alg, u16 status, 1678 const u8 *extra, size_t extra_len, const u8 *da, 1679 const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx, 1680 u32 tx_flags) 1681 { 1682 struct ieee80211_local *local = sdata->local; 1683 struct sk_buff *skb; 1684 struct ieee80211_mgmt *mgmt; 1685 int err; 1686 1687 /* 24 + 6 = header + auth_algo + auth_transaction + status_code */ 1688 skb = dev_alloc_skb(local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN + 1689 24 + 6 + extra_len + IEEE80211_WEP_ICV_LEN); 1690 if (!skb) 1691 return; 1692 1693 skb_reserve(skb, local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN); 1694 1695 mgmt = skb_put_zero(skb, 24 + 6); 1696 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 1697 IEEE80211_STYPE_AUTH); 1698 memcpy(mgmt->da, da, ETH_ALEN); 1699 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 1700 memcpy(mgmt->bssid, bssid, ETH_ALEN); 1701 mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg); 1702 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction); 1703 mgmt->u.auth.status_code = cpu_to_le16(status); 1704 if (extra) 1705 skb_put_data(skb, extra, extra_len); 1706 1707 if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) { 1708 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 1709 err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx); 1710 if (WARN_ON(err)) { 1711 kfree_skb(skb); 1712 return; 1713 } 1714 } 1715 1716 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT | 1717 tx_flags; 1718 ieee80211_tx_skb(sdata, skb); 1719 } 1720 1721 void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata, 1722 const u8 *da, const u8 *bssid, 1723 u16 stype, u16 reason, 1724 bool send_frame, u8 *frame_buf) 1725 { 1726 struct ieee80211_local *local = sdata->local; 1727 struct sk_buff *skb; 1728 struct ieee80211_mgmt *mgmt = (void *)frame_buf; 1729 1730 /* build frame */ 1731 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype); 1732 mgmt->duration = 0; /* initialize only */ 1733 mgmt->seq_ctrl = 0; /* initialize only */ 1734 memcpy(mgmt->da, da, ETH_ALEN); 1735 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 1736 memcpy(mgmt->bssid, bssid, ETH_ALEN); 1737 /* u.deauth.reason_code == u.disassoc.reason_code */ 1738 mgmt->u.deauth.reason_code = cpu_to_le16(reason); 1739 1740 if (send_frame) { 1741 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 1742 IEEE80211_DEAUTH_FRAME_LEN); 1743 if (!skb) 1744 return; 1745 1746 skb_reserve(skb, local->hw.extra_tx_headroom); 1747 1748 /* copy in frame */ 1749 skb_put_data(skb, mgmt, IEEE80211_DEAUTH_FRAME_LEN); 1750 1751 if (sdata->vif.type != NL80211_IFTYPE_STATION || 1752 !(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED)) 1753 IEEE80211_SKB_CB(skb)->flags |= 1754 IEEE80211_TX_INTFL_DONT_ENCRYPT; 1755 1756 ieee80211_tx_skb(sdata, skb); 1757 } 1758 } 1759 1760 static u8 *ieee80211_write_he_6ghz_cap(u8 *pos, __le16 cap, u8 *end) 1761 { 1762 if ((end - pos) < 5) 1763 return pos; 1764 1765 *pos++ = WLAN_EID_EXTENSION; 1766 *pos++ = 1 + sizeof(cap); 1767 *pos++ = WLAN_EID_EXT_HE_6GHZ_CAPA; 1768 memcpy(pos, &cap, sizeof(cap)); 1769 1770 return pos + 2; 1771 } 1772 1773 static int ieee80211_build_preq_ies_band(struct ieee80211_sub_if_data *sdata, 1774 u8 *buffer, size_t buffer_len, 1775 const u8 *ie, size_t ie_len, 1776 enum nl80211_band band, 1777 u32 rate_mask, 1778 struct cfg80211_chan_def *chandef, 1779 size_t *offset, u32 flags) 1780 { 1781 struct ieee80211_local *local = sdata->local; 1782 struct ieee80211_supported_band *sband; 1783 const struct ieee80211_sta_he_cap *he_cap; 1784 u8 *pos = buffer, *end = buffer + buffer_len; 1785 size_t noffset; 1786 int supp_rates_len, i; 1787 u8 rates[32]; 1788 int num_rates; 1789 int ext_rates_len; 1790 int shift; 1791 u32 rate_flags; 1792 bool have_80mhz = false; 1793 1794 *offset = 0; 1795 1796 sband = local->hw.wiphy->bands[band]; 1797 if (WARN_ON_ONCE(!sband)) 1798 return 0; 1799 1800 rate_flags = ieee80211_chandef_rate_flags(chandef); 1801 shift = ieee80211_chandef_get_shift(chandef); 1802 1803 num_rates = 0; 1804 for (i = 0; i < sband->n_bitrates; i++) { 1805 if ((BIT(i) & rate_mask) == 0) 1806 continue; /* skip rate */ 1807 if ((rate_flags & sband->bitrates[i].flags) != rate_flags) 1808 continue; 1809 1810 rates[num_rates++] = 1811 (u8) DIV_ROUND_UP(sband->bitrates[i].bitrate, 1812 (1 << shift) * 5); 1813 } 1814 1815 supp_rates_len = min_t(int, num_rates, 8); 1816 1817 if (end - pos < 2 + supp_rates_len) 1818 goto out_err; 1819 *pos++ = WLAN_EID_SUPP_RATES; 1820 *pos++ = supp_rates_len; 1821 memcpy(pos, rates, supp_rates_len); 1822 pos += supp_rates_len; 1823 1824 /* insert "request information" if in custom IEs */ 1825 if (ie && ie_len) { 1826 static const u8 before_extrates[] = { 1827 WLAN_EID_SSID, 1828 WLAN_EID_SUPP_RATES, 1829 WLAN_EID_REQUEST, 1830 }; 1831 noffset = ieee80211_ie_split(ie, ie_len, 1832 before_extrates, 1833 ARRAY_SIZE(before_extrates), 1834 *offset); 1835 if (end - pos < noffset - *offset) 1836 goto out_err; 1837 memcpy(pos, ie + *offset, noffset - *offset); 1838 pos += noffset - *offset; 1839 *offset = noffset; 1840 } 1841 1842 ext_rates_len = num_rates - supp_rates_len; 1843 if (ext_rates_len > 0) { 1844 if (end - pos < 2 + ext_rates_len) 1845 goto out_err; 1846 *pos++ = WLAN_EID_EXT_SUPP_RATES; 1847 *pos++ = ext_rates_len; 1848 memcpy(pos, rates + supp_rates_len, ext_rates_len); 1849 pos += ext_rates_len; 1850 } 1851 1852 if (chandef->chan && sband->band == NL80211_BAND_2GHZ) { 1853 if (end - pos < 3) 1854 goto out_err; 1855 *pos++ = WLAN_EID_DS_PARAMS; 1856 *pos++ = 1; 1857 *pos++ = ieee80211_frequency_to_channel( 1858 chandef->chan->center_freq); 1859 } 1860 1861 if (flags & IEEE80211_PROBE_FLAG_MIN_CONTENT) 1862 goto done; 1863 1864 /* insert custom IEs that go before HT */ 1865 if (ie && ie_len) { 1866 static const u8 before_ht[] = { 1867 /* 1868 * no need to list the ones split off already 1869 * (or generated here) 1870 */ 1871 WLAN_EID_DS_PARAMS, 1872 WLAN_EID_SUPPORTED_REGULATORY_CLASSES, 1873 }; 1874 noffset = ieee80211_ie_split(ie, ie_len, 1875 before_ht, ARRAY_SIZE(before_ht), 1876 *offset); 1877 if (end - pos < noffset - *offset) 1878 goto out_err; 1879 memcpy(pos, ie + *offset, noffset - *offset); 1880 pos += noffset - *offset; 1881 *offset = noffset; 1882 } 1883 1884 if (sband->ht_cap.ht_supported) { 1885 if (end - pos < 2 + sizeof(struct ieee80211_ht_cap)) 1886 goto out_err; 1887 pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap, 1888 sband->ht_cap.cap); 1889 } 1890 1891 /* insert custom IEs that go before VHT */ 1892 if (ie && ie_len) { 1893 static const u8 before_vht[] = { 1894 /* 1895 * no need to list the ones split off already 1896 * (or generated here) 1897 */ 1898 WLAN_EID_BSS_COEX_2040, 1899 WLAN_EID_EXT_CAPABILITY, 1900 WLAN_EID_SSID_LIST, 1901 WLAN_EID_CHANNEL_USAGE, 1902 WLAN_EID_INTERWORKING, 1903 WLAN_EID_MESH_ID, 1904 /* 60 GHz (Multi-band, DMG, MMS) can't happen */ 1905 }; 1906 noffset = ieee80211_ie_split(ie, ie_len, 1907 before_vht, ARRAY_SIZE(before_vht), 1908 *offset); 1909 if (end - pos < noffset - *offset) 1910 goto out_err; 1911 memcpy(pos, ie + *offset, noffset - *offset); 1912 pos += noffset - *offset; 1913 *offset = noffset; 1914 } 1915 1916 /* Check if any channel in this sband supports at least 80 MHz */ 1917 for (i = 0; i < sband->n_channels; i++) { 1918 if (sband->channels[i].flags & (IEEE80211_CHAN_DISABLED | 1919 IEEE80211_CHAN_NO_80MHZ)) 1920 continue; 1921 1922 have_80mhz = true; 1923 break; 1924 } 1925 1926 if (sband->vht_cap.vht_supported && have_80mhz) { 1927 if (end - pos < 2 + sizeof(struct ieee80211_vht_cap)) 1928 goto out_err; 1929 pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap, 1930 sband->vht_cap.cap); 1931 } 1932 1933 /* insert custom IEs that go before HE */ 1934 if (ie && ie_len) { 1935 static const u8 before_he[] = { 1936 /* 1937 * no need to list the ones split off before VHT 1938 * or generated here 1939 */ 1940 WLAN_EID_EXTENSION, WLAN_EID_EXT_FILS_REQ_PARAMS, 1941 WLAN_EID_AP_CSN, 1942 /* TODO: add 11ah/11aj/11ak elements */ 1943 }; 1944 noffset = ieee80211_ie_split(ie, ie_len, 1945 before_he, ARRAY_SIZE(before_he), 1946 *offset); 1947 if (end - pos < noffset - *offset) 1948 goto out_err; 1949 memcpy(pos, ie + *offset, noffset - *offset); 1950 pos += noffset - *offset; 1951 *offset = noffset; 1952 } 1953 1954 he_cap = ieee80211_get_he_iftype_cap(sband, 1955 ieee80211_vif_type_p2p(&sdata->vif)); 1956 if (he_cap && 1957 cfg80211_any_usable_channels(local->hw.wiphy, BIT(sband->band), 1958 IEEE80211_CHAN_NO_HE)) { 1959 pos = ieee80211_ie_build_he_cap(pos, he_cap, end); 1960 if (!pos) 1961 goto out_err; 1962 } 1963 1964 if (cfg80211_any_usable_channels(local->hw.wiphy, 1965 BIT(NL80211_BAND_6GHZ), 1966 IEEE80211_CHAN_NO_HE)) { 1967 struct ieee80211_supported_band *sband6; 1968 1969 sband6 = local->hw.wiphy->bands[NL80211_BAND_6GHZ]; 1970 he_cap = ieee80211_get_he_iftype_cap(sband6, 1971 ieee80211_vif_type_p2p(&sdata->vif)); 1972 1973 if (he_cap) { 1974 enum nl80211_iftype iftype = 1975 ieee80211_vif_type_p2p(&sdata->vif); 1976 __le16 cap = ieee80211_get_he_6ghz_capa(sband, iftype); 1977 1978 pos = ieee80211_write_he_6ghz_cap(pos, cap, end); 1979 } 1980 } 1981 1982 /* 1983 * If adding more here, adjust code in main.c 1984 * that calculates local->scan_ies_len. 1985 */ 1986 1987 return pos - buffer; 1988 out_err: 1989 WARN_ONCE(1, "not enough space for preq IEs\n"); 1990 done: 1991 return pos - buffer; 1992 } 1993 1994 int ieee80211_build_preq_ies(struct ieee80211_sub_if_data *sdata, u8 *buffer, 1995 size_t buffer_len, 1996 struct ieee80211_scan_ies *ie_desc, 1997 const u8 *ie, size_t ie_len, 1998 u8 bands_used, u32 *rate_masks, 1999 struct cfg80211_chan_def *chandef, 2000 u32 flags) 2001 { 2002 size_t pos = 0, old_pos = 0, custom_ie_offset = 0; 2003 int i; 2004 2005 memset(ie_desc, 0, sizeof(*ie_desc)); 2006 2007 for (i = 0; i < NUM_NL80211_BANDS; i++) { 2008 if (bands_used & BIT(i)) { 2009 pos += ieee80211_build_preq_ies_band(sdata, 2010 buffer + pos, 2011 buffer_len - pos, 2012 ie, ie_len, i, 2013 rate_masks[i], 2014 chandef, 2015 &custom_ie_offset, 2016 flags); 2017 ie_desc->ies[i] = buffer + old_pos; 2018 ie_desc->len[i] = pos - old_pos; 2019 old_pos = pos; 2020 } 2021 } 2022 2023 /* add any remaining custom IEs */ 2024 if (ie && ie_len) { 2025 if (WARN_ONCE(buffer_len - pos < ie_len - custom_ie_offset, 2026 "not enough space for preq custom IEs\n")) 2027 return pos; 2028 memcpy(buffer + pos, ie + custom_ie_offset, 2029 ie_len - custom_ie_offset); 2030 ie_desc->common_ies = buffer + pos; 2031 ie_desc->common_ie_len = ie_len - custom_ie_offset; 2032 pos += ie_len - custom_ie_offset; 2033 } 2034 2035 return pos; 2036 }; 2037 2038 struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata, 2039 const u8 *src, const u8 *dst, 2040 u32 ratemask, 2041 struct ieee80211_channel *chan, 2042 const u8 *ssid, size_t ssid_len, 2043 const u8 *ie, size_t ie_len, 2044 u32 flags) 2045 { 2046 struct ieee80211_local *local = sdata->local; 2047 struct cfg80211_chan_def chandef; 2048 struct sk_buff *skb; 2049 struct ieee80211_mgmt *mgmt; 2050 int ies_len; 2051 u32 rate_masks[NUM_NL80211_BANDS] = {}; 2052 struct ieee80211_scan_ies dummy_ie_desc; 2053 2054 /* 2055 * Do not send DS Channel parameter for directed probe requests 2056 * in order to maximize the chance that we get a response. Some 2057 * badly-behaved APs don't respond when this parameter is included. 2058 */ 2059 chandef.width = sdata->vif.bss_conf.chandef.width; 2060 if (flags & IEEE80211_PROBE_FLAG_DIRECTED) 2061 chandef.chan = NULL; 2062 else 2063 chandef.chan = chan; 2064 2065 skb = ieee80211_probereq_get(&local->hw, src, ssid, ssid_len, 2066 100 + ie_len); 2067 if (!skb) 2068 return NULL; 2069 2070 rate_masks[chan->band] = ratemask; 2071 ies_len = ieee80211_build_preq_ies(sdata, skb_tail_pointer(skb), 2072 skb_tailroom(skb), &dummy_ie_desc, 2073 ie, ie_len, BIT(chan->band), 2074 rate_masks, &chandef, flags); 2075 skb_put(skb, ies_len); 2076 2077 if (dst) { 2078 mgmt = (struct ieee80211_mgmt *) skb->data; 2079 memcpy(mgmt->da, dst, ETH_ALEN); 2080 memcpy(mgmt->bssid, dst, ETH_ALEN); 2081 } 2082 2083 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 2084 2085 return skb; 2086 } 2087 2088 u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata, 2089 struct ieee802_11_elems *elems, 2090 enum nl80211_band band, u32 *basic_rates) 2091 { 2092 struct ieee80211_supported_band *sband; 2093 size_t num_rates; 2094 u32 supp_rates, rate_flags; 2095 int i, j, shift; 2096 2097 sband = sdata->local->hw.wiphy->bands[band]; 2098 if (WARN_ON(!sband)) 2099 return 1; 2100 2101 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef); 2102 shift = ieee80211_vif_get_shift(&sdata->vif); 2103 2104 num_rates = sband->n_bitrates; 2105 supp_rates = 0; 2106 for (i = 0; i < elems->supp_rates_len + 2107 elems->ext_supp_rates_len; i++) { 2108 u8 rate = 0; 2109 int own_rate; 2110 bool is_basic; 2111 if (i < elems->supp_rates_len) 2112 rate = elems->supp_rates[i]; 2113 else if (elems->ext_supp_rates) 2114 rate = elems->ext_supp_rates 2115 [i - elems->supp_rates_len]; 2116 own_rate = 5 * (rate & 0x7f); 2117 is_basic = !!(rate & 0x80); 2118 2119 if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY) 2120 continue; 2121 2122 for (j = 0; j < num_rates; j++) { 2123 int brate; 2124 if ((rate_flags & sband->bitrates[j].flags) 2125 != rate_flags) 2126 continue; 2127 2128 brate = DIV_ROUND_UP(sband->bitrates[j].bitrate, 2129 1 << shift); 2130 2131 if (brate == own_rate) { 2132 supp_rates |= BIT(j); 2133 if (basic_rates && is_basic) 2134 *basic_rates |= BIT(j); 2135 } 2136 } 2137 } 2138 return supp_rates; 2139 } 2140 2141 void ieee80211_stop_device(struct ieee80211_local *local) 2142 { 2143 ieee80211_led_radio(local, false); 2144 ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO); 2145 2146 cancel_work_sync(&local->reconfig_filter); 2147 2148 flush_workqueue(local->workqueue); 2149 drv_stop(local); 2150 } 2151 2152 static void ieee80211_flush_completed_scan(struct ieee80211_local *local, 2153 bool aborted) 2154 { 2155 /* It's possible that we don't handle the scan completion in 2156 * time during suspend, so if it's still marked as completed 2157 * here, queue the work and flush it to clean things up. 2158 * Instead of calling the worker function directly here, we 2159 * really queue it to avoid potential races with other flows 2160 * scheduling the same work. 2161 */ 2162 if (test_bit(SCAN_COMPLETED, &local->scanning)) { 2163 /* If coming from reconfiguration failure, abort the scan so 2164 * we don't attempt to continue a partial HW scan - which is 2165 * possible otherwise if (e.g.) the 2.4 GHz portion was the 2166 * completed scan, and a 5 GHz portion is still pending. 2167 */ 2168 if (aborted) 2169 set_bit(SCAN_ABORTED, &local->scanning); 2170 ieee80211_queue_delayed_work(&local->hw, &local->scan_work, 0); 2171 flush_delayed_work(&local->scan_work); 2172 } 2173 } 2174 2175 static void ieee80211_handle_reconfig_failure(struct ieee80211_local *local) 2176 { 2177 struct ieee80211_sub_if_data *sdata; 2178 struct ieee80211_chanctx *ctx; 2179 2180 /* 2181 * We get here if during resume the device can't be restarted properly. 2182 * We might also get here if this happens during HW reset, which is a 2183 * slightly different situation and we need to drop all connections in 2184 * the latter case. 2185 * 2186 * Ask cfg80211 to turn off all interfaces, this will result in more 2187 * warnings but at least we'll then get into a clean stopped state. 2188 */ 2189 2190 local->resuming = false; 2191 local->suspended = false; 2192 local->in_reconfig = false; 2193 2194 ieee80211_flush_completed_scan(local, true); 2195 2196 /* scheduled scan clearly can't be running any more, but tell 2197 * cfg80211 and clear local state 2198 */ 2199 ieee80211_sched_scan_end(local); 2200 2201 list_for_each_entry(sdata, &local->interfaces, list) 2202 sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER; 2203 2204 /* Mark channel contexts as not being in the driver any more to avoid 2205 * removing them from the driver during the shutdown process... 2206 */ 2207 mutex_lock(&local->chanctx_mtx); 2208 list_for_each_entry(ctx, &local->chanctx_list, list) 2209 ctx->driver_present = false; 2210 mutex_unlock(&local->chanctx_mtx); 2211 } 2212 2213 static void ieee80211_assign_chanctx(struct ieee80211_local *local, 2214 struct ieee80211_sub_if_data *sdata) 2215 { 2216 struct ieee80211_chanctx_conf *conf; 2217 struct ieee80211_chanctx *ctx; 2218 2219 if (!local->use_chanctx) 2220 return; 2221 2222 mutex_lock(&local->chanctx_mtx); 2223 conf = rcu_dereference_protected(sdata->vif.chanctx_conf, 2224 lockdep_is_held(&local->chanctx_mtx)); 2225 if (conf) { 2226 ctx = container_of(conf, struct ieee80211_chanctx, conf); 2227 drv_assign_vif_chanctx(local, sdata, ctx); 2228 } 2229 mutex_unlock(&local->chanctx_mtx); 2230 } 2231 2232 static void ieee80211_reconfig_stations(struct ieee80211_sub_if_data *sdata) 2233 { 2234 struct ieee80211_local *local = sdata->local; 2235 struct sta_info *sta; 2236 2237 /* add STAs back */ 2238 mutex_lock(&local->sta_mtx); 2239 list_for_each_entry(sta, &local->sta_list, list) { 2240 enum ieee80211_sta_state state; 2241 2242 if (!sta->uploaded || sta->sdata != sdata) 2243 continue; 2244 2245 for (state = IEEE80211_STA_NOTEXIST; 2246 state < sta->sta_state; state++) 2247 WARN_ON(drv_sta_state(local, sta->sdata, sta, state, 2248 state + 1)); 2249 } 2250 mutex_unlock(&local->sta_mtx); 2251 } 2252 2253 static int ieee80211_reconfig_nan(struct ieee80211_sub_if_data *sdata) 2254 { 2255 struct cfg80211_nan_func *func, **funcs; 2256 int res, id, i = 0; 2257 2258 res = drv_start_nan(sdata->local, sdata, 2259 &sdata->u.nan.conf); 2260 if (WARN_ON(res)) 2261 return res; 2262 2263 funcs = kcalloc(sdata->local->hw.max_nan_de_entries + 1, 2264 sizeof(*funcs), 2265 GFP_KERNEL); 2266 if (!funcs) 2267 return -ENOMEM; 2268 2269 /* Add all the functions: 2270 * This is a little bit ugly. We need to call a potentially sleeping 2271 * callback for each NAN function, so we can't hold the spinlock. 2272 */ 2273 spin_lock_bh(&sdata->u.nan.func_lock); 2274 2275 idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, id) 2276 funcs[i++] = func; 2277 2278 spin_unlock_bh(&sdata->u.nan.func_lock); 2279 2280 for (i = 0; funcs[i]; i++) { 2281 res = drv_add_nan_func(sdata->local, sdata, funcs[i]); 2282 if (WARN_ON(res)) 2283 ieee80211_nan_func_terminated(&sdata->vif, 2284 funcs[i]->instance_id, 2285 NL80211_NAN_FUNC_TERM_REASON_ERROR, 2286 GFP_KERNEL); 2287 } 2288 2289 kfree(funcs); 2290 2291 return 0; 2292 } 2293 2294 int ieee80211_reconfig(struct ieee80211_local *local) 2295 { 2296 struct ieee80211_hw *hw = &local->hw; 2297 struct ieee80211_sub_if_data *sdata; 2298 struct ieee80211_chanctx *ctx; 2299 struct sta_info *sta; 2300 int res, i; 2301 bool reconfig_due_to_wowlan = false; 2302 struct ieee80211_sub_if_data *sched_scan_sdata; 2303 struct cfg80211_sched_scan_request *sched_scan_req; 2304 bool sched_scan_stopped = false; 2305 bool suspended = local->suspended; 2306 2307 /* nothing to do if HW shouldn't run */ 2308 if (!local->open_count) 2309 goto wake_up; 2310 2311 #ifdef CONFIG_PM 2312 if (suspended) 2313 local->resuming = true; 2314 2315 if (local->wowlan) { 2316 /* 2317 * In the wowlan case, both mac80211 and the device 2318 * are functional when the resume op is called, so 2319 * clear local->suspended so the device could operate 2320 * normally (e.g. pass rx frames). 2321 */ 2322 local->suspended = false; 2323 res = drv_resume(local); 2324 local->wowlan = false; 2325 if (res < 0) { 2326 local->resuming = false; 2327 return res; 2328 } 2329 if (res == 0) 2330 goto wake_up; 2331 WARN_ON(res > 1); 2332 /* 2333 * res is 1, which means the driver requested 2334 * to go through a regular reset on wakeup. 2335 * restore local->suspended in this case. 2336 */ 2337 reconfig_due_to_wowlan = true; 2338 local->suspended = true; 2339 } 2340 #endif 2341 2342 /* 2343 * In case of hw_restart during suspend (without wowlan), 2344 * cancel restart work, as we are reconfiguring the device 2345 * anyway. 2346 * Note that restart_work is scheduled on a frozen workqueue, 2347 * so we can't deadlock in this case. 2348 */ 2349 if (suspended && local->in_reconfig && !reconfig_due_to_wowlan) 2350 cancel_work_sync(&local->restart_work); 2351 2352 local->started = false; 2353 2354 /* 2355 * Upon resume hardware can sometimes be goofy due to 2356 * various platform / driver / bus issues, so restarting 2357 * the device may at times not work immediately. Propagate 2358 * the error. 2359 */ 2360 res = drv_start(local); 2361 if (res) { 2362 if (suspended) 2363 WARN(1, "Hardware became unavailable upon resume. This could be a software issue prior to suspend or a hardware issue.\n"); 2364 else 2365 WARN(1, "Hardware became unavailable during restart.\n"); 2366 ieee80211_handle_reconfig_failure(local); 2367 return res; 2368 } 2369 2370 /* setup fragmentation threshold */ 2371 drv_set_frag_threshold(local, hw->wiphy->frag_threshold); 2372 2373 /* setup RTS threshold */ 2374 drv_set_rts_threshold(local, hw->wiphy->rts_threshold); 2375 2376 /* reset coverage class */ 2377 drv_set_coverage_class(local, hw->wiphy->coverage_class); 2378 2379 ieee80211_led_radio(local, true); 2380 ieee80211_mod_tpt_led_trig(local, 2381 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0); 2382 2383 /* add interfaces */ 2384 sdata = rtnl_dereference(local->monitor_sdata); 2385 if (sdata) { 2386 /* in HW restart it exists already */ 2387 WARN_ON(local->resuming); 2388 res = drv_add_interface(local, sdata); 2389 if (WARN_ON(res)) { 2390 RCU_INIT_POINTER(local->monitor_sdata, NULL); 2391 synchronize_net(); 2392 kfree(sdata); 2393 } 2394 } 2395 2396 list_for_each_entry(sdata, &local->interfaces, list) { 2397 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 2398 sdata->vif.type != NL80211_IFTYPE_MONITOR && 2399 ieee80211_sdata_running(sdata)) { 2400 res = drv_add_interface(local, sdata); 2401 if (WARN_ON(res)) 2402 break; 2403 } 2404 } 2405 2406 /* If adding any of the interfaces failed above, roll back and 2407 * report failure. 2408 */ 2409 if (res) { 2410 list_for_each_entry_continue_reverse(sdata, &local->interfaces, 2411 list) 2412 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 2413 sdata->vif.type != NL80211_IFTYPE_MONITOR && 2414 ieee80211_sdata_running(sdata)) 2415 drv_remove_interface(local, sdata); 2416 ieee80211_handle_reconfig_failure(local); 2417 return res; 2418 } 2419 2420 /* add channel contexts */ 2421 if (local->use_chanctx) { 2422 mutex_lock(&local->chanctx_mtx); 2423 list_for_each_entry(ctx, &local->chanctx_list, list) 2424 if (ctx->replace_state != 2425 IEEE80211_CHANCTX_REPLACES_OTHER) 2426 WARN_ON(drv_add_chanctx(local, ctx)); 2427 mutex_unlock(&local->chanctx_mtx); 2428 2429 sdata = rtnl_dereference(local->monitor_sdata); 2430 if (sdata && ieee80211_sdata_running(sdata)) 2431 ieee80211_assign_chanctx(local, sdata); 2432 } 2433 2434 /* reconfigure hardware */ 2435 ieee80211_hw_config(local, ~0); 2436 2437 ieee80211_configure_filter(local); 2438 2439 /* Finally also reconfigure all the BSS information */ 2440 list_for_each_entry(sdata, &local->interfaces, list) { 2441 u32 changed; 2442 2443 if (!ieee80211_sdata_running(sdata)) 2444 continue; 2445 2446 ieee80211_assign_chanctx(local, sdata); 2447 2448 switch (sdata->vif.type) { 2449 case NL80211_IFTYPE_AP_VLAN: 2450 case NL80211_IFTYPE_MONITOR: 2451 break; 2452 case NL80211_IFTYPE_ADHOC: 2453 if (sdata->vif.bss_conf.ibss_joined) 2454 WARN_ON(drv_join_ibss(local, sdata)); 2455 fallthrough; 2456 default: 2457 ieee80211_reconfig_stations(sdata); 2458 fallthrough; 2459 case NL80211_IFTYPE_AP: /* AP stations are handled later */ 2460 for (i = 0; i < IEEE80211_NUM_ACS; i++) 2461 drv_conf_tx(local, sdata, i, 2462 &sdata->tx_conf[i]); 2463 break; 2464 } 2465 2466 /* common change flags for all interface types */ 2467 changed = BSS_CHANGED_ERP_CTS_PROT | 2468 BSS_CHANGED_ERP_PREAMBLE | 2469 BSS_CHANGED_ERP_SLOT | 2470 BSS_CHANGED_HT | 2471 BSS_CHANGED_BASIC_RATES | 2472 BSS_CHANGED_BEACON_INT | 2473 BSS_CHANGED_BSSID | 2474 BSS_CHANGED_CQM | 2475 BSS_CHANGED_QOS | 2476 BSS_CHANGED_IDLE | 2477 BSS_CHANGED_TXPOWER | 2478 BSS_CHANGED_MCAST_RATE; 2479 2480 if (sdata->vif.mu_mimo_owner) 2481 changed |= BSS_CHANGED_MU_GROUPS; 2482 2483 switch (sdata->vif.type) { 2484 case NL80211_IFTYPE_STATION: 2485 changed |= BSS_CHANGED_ASSOC | 2486 BSS_CHANGED_ARP_FILTER | 2487 BSS_CHANGED_PS; 2488 2489 /* Re-send beacon info report to the driver */ 2490 if (sdata->u.mgd.have_beacon) 2491 changed |= BSS_CHANGED_BEACON_INFO; 2492 2493 if (sdata->vif.bss_conf.max_idle_period || 2494 sdata->vif.bss_conf.protected_keep_alive) 2495 changed |= BSS_CHANGED_KEEP_ALIVE; 2496 2497 sdata_lock(sdata); 2498 ieee80211_bss_info_change_notify(sdata, changed); 2499 sdata_unlock(sdata); 2500 break; 2501 case NL80211_IFTYPE_OCB: 2502 changed |= BSS_CHANGED_OCB; 2503 ieee80211_bss_info_change_notify(sdata, changed); 2504 break; 2505 case NL80211_IFTYPE_ADHOC: 2506 changed |= BSS_CHANGED_IBSS; 2507 fallthrough; 2508 case NL80211_IFTYPE_AP: 2509 changed |= BSS_CHANGED_SSID | BSS_CHANGED_P2P_PS; 2510 2511 if (sdata->vif.bss_conf.ftm_responder == 1 && 2512 wiphy_ext_feature_isset(sdata->local->hw.wiphy, 2513 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER)) 2514 changed |= BSS_CHANGED_FTM_RESPONDER; 2515 2516 if (sdata->vif.type == NL80211_IFTYPE_AP) { 2517 changed |= BSS_CHANGED_AP_PROBE_RESP; 2518 2519 if (rcu_access_pointer(sdata->u.ap.beacon)) 2520 drv_start_ap(local, sdata); 2521 } 2522 fallthrough; 2523 case NL80211_IFTYPE_MESH_POINT: 2524 if (sdata->vif.bss_conf.enable_beacon) { 2525 changed |= BSS_CHANGED_BEACON | 2526 BSS_CHANGED_BEACON_ENABLED; 2527 ieee80211_bss_info_change_notify(sdata, changed); 2528 } 2529 break; 2530 case NL80211_IFTYPE_NAN: 2531 res = ieee80211_reconfig_nan(sdata); 2532 if (res < 0) { 2533 ieee80211_handle_reconfig_failure(local); 2534 return res; 2535 } 2536 break; 2537 case NL80211_IFTYPE_AP_VLAN: 2538 case NL80211_IFTYPE_MONITOR: 2539 case NL80211_IFTYPE_P2P_DEVICE: 2540 /* nothing to do */ 2541 break; 2542 case NL80211_IFTYPE_UNSPECIFIED: 2543 case NUM_NL80211_IFTYPES: 2544 case NL80211_IFTYPE_P2P_CLIENT: 2545 case NL80211_IFTYPE_P2P_GO: 2546 case NL80211_IFTYPE_WDS: 2547 WARN_ON(1); 2548 break; 2549 } 2550 } 2551 2552 ieee80211_recalc_ps(local); 2553 2554 /* 2555 * The sta might be in psm against the ap (e.g. because 2556 * this was the state before a hw restart), so we 2557 * explicitly send a null packet in order to make sure 2558 * it'll sync against the ap (and get out of psm). 2559 */ 2560 if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) { 2561 list_for_each_entry(sdata, &local->interfaces, list) { 2562 if (sdata->vif.type != NL80211_IFTYPE_STATION) 2563 continue; 2564 if (!sdata->u.mgd.associated) 2565 continue; 2566 2567 ieee80211_send_nullfunc(local, sdata, false); 2568 } 2569 } 2570 2571 /* APs are now beaconing, add back stations */ 2572 mutex_lock(&local->sta_mtx); 2573 list_for_each_entry(sta, &local->sta_list, list) { 2574 enum ieee80211_sta_state state; 2575 2576 if (!sta->uploaded) 2577 continue; 2578 2579 if (sta->sdata->vif.type != NL80211_IFTYPE_AP && 2580 sta->sdata->vif.type != NL80211_IFTYPE_AP_VLAN) 2581 continue; 2582 2583 for (state = IEEE80211_STA_NOTEXIST; 2584 state < sta->sta_state; state++) 2585 WARN_ON(drv_sta_state(local, sta->sdata, sta, state, 2586 state + 1)); 2587 } 2588 mutex_unlock(&local->sta_mtx); 2589 2590 /* add back keys */ 2591 list_for_each_entry(sdata, &local->interfaces, list) 2592 ieee80211_reenable_keys(sdata); 2593 2594 /* Reconfigure sched scan if it was interrupted by FW restart */ 2595 mutex_lock(&local->mtx); 2596 sched_scan_sdata = rcu_dereference_protected(local->sched_scan_sdata, 2597 lockdep_is_held(&local->mtx)); 2598 sched_scan_req = rcu_dereference_protected(local->sched_scan_req, 2599 lockdep_is_held(&local->mtx)); 2600 if (sched_scan_sdata && sched_scan_req) 2601 /* 2602 * Sched scan stopped, but we don't want to report it. Instead, 2603 * we're trying to reschedule. However, if more than one scan 2604 * plan was set, we cannot reschedule since we don't know which 2605 * scan plan was currently running (and some scan plans may have 2606 * already finished). 2607 */ 2608 if (sched_scan_req->n_scan_plans > 1 || 2609 __ieee80211_request_sched_scan_start(sched_scan_sdata, 2610 sched_scan_req)) { 2611 RCU_INIT_POINTER(local->sched_scan_sdata, NULL); 2612 RCU_INIT_POINTER(local->sched_scan_req, NULL); 2613 sched_scan_stopped = true; 2614 } 2615 mutex_unlock(&local->mtx); 2616 2617 if (sched_scan_stopped) 2618 cfg80211_sched_scan_stopped_locked(local->hw.wiphy, 0); 2619 2620 wake_up: 2621 2622 if (local->monitors == local->open_count && local->monitors > 0) 2623 ieee80211_add_virtual_monitor(local); 2624 2625 /* 2626 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation 2627 * sessions can be established after a resume. 2628 * 2629 * Also tear down aggregation sessions since reconfiguring 2630 * them in a hardware restart scenario is not easily done 2631 * right now, and the hardware will have lost information 2632 * about the sessions, but we and the AP still think they 2633 * are active. This is really a workaround though. 2634 */ 2635 if (ieee80211_hw_check(hw, AMPDU_AGGREGATION)) { 2636 mutex_lock(&local->sta_mtx); 2637 2638 list_for_each_entry(sta, &local->sta_list, list) { 2639 if (!local->resuming) 2640 ieee80211_sta_tear_down_BA_sessions( 2641 sta, AGG_STOP_LOCAL_REQUEST); 2642 clear_sta_flag(sta, WLAN_STA_BLOCK_BA); 2643 } 2644 2645 mutex_unlock(&local->sta_mtx); 2646 } 2647 2648 if (local->in_reconfig) { 2649 local->in_reconfig = false; 2650 barrier(); 2651 2652 /* Restart deferred ROCs */ 2653 mutex_lock(&local->mtx); 2654 ieee80211_start_next_roc(local); 2655 mutex_unlock(&local->mtx); 2656 2657 /* Requeue all works */ 2658 list_for_each_entry(sdata, &local->interfaces, list) 2659 ieee80211_queue_work(&local->hw, &sdata->work); 2660 } 2661 2662 ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP, 2663 IEEE80211_QUEUE_STOP_REASON_SUSPEND, 2664 false); 2665 2666 /* 2667 * If this is for hw restart things are still running. 2668 * We may want to change that later, however. 2669 */ 2670 if (local->open_count && (!suspended || reconfig_due_to_wowlan)) 2671 drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_RESTART); 2672 2673 if (!suspended) 2674 return 0; 2675 2676 #ifdef CONFIG_PM 2677 /* first set suspended false, then resuming */ 2678 local->suspended = false; 2679 mb(); 2680 local->resuming = false; 2681 2682 ieee80211_flush_completed_scan(local, false); 2683 2684 if (local->open_count && !reconfig_due_to_wowlan) 2685 drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_SUSPEND); 2686 2687 list_for_each_entry(sdata, &local->interfaces, list) { 2688 if (!ieee80211_sdata_running(sdata)) 2689 continue; 2690 if (sdata->vif.type == NL80211_IFTYPE_STATION) 2691 ieee80211_sta_restart(sdata); 2692 } 2693 2694 mod_timer(&local->sta_cleanup, jiffies + 1); 2695 #else 2696 WARN_ON(1); 2697 #endif 2698 2699 return 0; 2700 } 2701 2702 void ieee80211_resume_disconnect(struct ieee80211_vif *vif) 2703 { 2704 struct ieee80211_sub_if_data *sdata; 2705 struct ieee80211_local *local; 2706 struct ieee80211_key *key; 2707 2708 if (WARN_ON(!vif)) 2709 return; 2710 2711 sdata = vif_to_sdata(vif); 2712 local = sdata->local; 2713 2714 if (WARN_ON(!local->resuming)) 2715 return; 2716 2717 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION)) 2718 return; 2719 2720 sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME; 2721 2722 mutex_lock(&local->key_mtx); 2723 list_for_each_entry(key, &sdata->key_list, list) 2724 key->flags |= KEY_FLAG_TAINTED; 2725 mutex_unlock(&local->key_mtx); 2726 } 2727 EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect); 2728 2729 void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata) 2730 { 2731 struct ieee80211_local *local = sdata->local; 2732 struct ieee80211_chanctx_conf *chanctx_conf; 2733 struct ieee80211_chanctx *chanctx; 2734 2735 mutex_lock(&local->chanctx_mtx); 2736 2737 chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf, 2738 lockdep_is_held(&local->chanctx_mtx)); 2739 2740 /* 2741 * This function can be called from a work, thus it may be possible 2742 * that the chanctx_conf is removed (due to a disconnection, for 2743 * example). 2744 * So nothing should be done in such case. 2745 */ 2746 if (!chanctx_conf) 2747 goto unlock; 2748 2749 chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf); 2750 ieee80211_recalc_smps_chanctx(local, chanctx); 2751 unlock: 2752 mutex_unlock(&local->chanctx_mtx); 2753 } 2754 2755 void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata) 2756 { 2757 struct ieee80211_local *local = sdata->local; 2758 struct ieee80211_chanctx_conf *chanctx_conf; 2759 struct ieee80211_chanctx *chanctx; 2760 2761 mutex_lock(&local->chanctx_mtx); 2762 2763 chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf, 2764 lockdep_is_held(&local->chanctx_mtx)); 2765 2766 if (WARN_ON_ONCE(!chanctx_conf)) 2767 goto unlock; 2768 2769 chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf); 2770 ieee80211_recalc_chanctx_min_def(local, chanctx); 2771 unlock: 2772 mutex_unlock(&local->chanctx_mtx); 2773 } 2774 2775 size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset) 2776 { 2777 size_t pos = offset; 2778 2779 while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC) 2780 pos += 2 + ies[pos + 1]; 2781 2782 return pos; 2783 } 2784 2785 static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata, 2786 int rssi_min_thold, 2787 int rssi_max_thold) 2788 { 2789 trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold); 2790 2791 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION)) 2792 return; 2793 2794 /* 2795 * Scale up threshold values before storing it, as the RSSI averaging 2796 * algorithm uses a scaled up value as well. Change this scaling 2797 * factor if the RSSI averaging algorithm changes. 2798 */ 2799 sdata->u.mgd.rssi_min_thold = rssi_min_thold*16; 2800 sdata->u.mgd.rssi_max_thold = rssi_max_thold*16; 2801 } 2802 2803 void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif, 2804 int rssi_min_thold, 2805 int rssi_max_thold) 2806 { 2807 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 2808 2809 WARN_ON(rssi_min_thold == rssi_max_thold || 2810 rssi_min_thold > rssi_max_thold); 2811 2812 _ieee80211_enable_rssi_reports(sdata, rssi_min_thold, 2813 rssi_max_thold); 2814 } 2815 EXPORT_SYMBOL(ieee80211_enable_rssi_reports); 2816 2817 void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif) 2818 { 2819 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 2820 2821 _ieee80211_enable_rssi_reports(sdata, 0, 0); 2822 } 2823 EXPORT_SYMBOL(ieee80211_disable_rssi_reports); 2824 2825 u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap, 2826 u16 cap) 2827 { 2828 __le16 tmp; 2829 2830 *pos++ = WLAN_EID_HT_CAPABILITY; 2831 *pos++ = sizeof(struct ieee80211_ht_cap); 2832 memset(pos, 0, sizeof(struct ieee80211_ht_cap)); 2833 2834 /* capability flags */ 2835 tmp = cpu_to_le16(cap); 2836 memcpy(pos, &tmp, sizeof(u16)); 2837 pos += sizeof(u16); 2838 2839 /* AMPDU parameters */ 2840 *pos++ = ht_cap->ampdu_factor | 2841 (ht_cap->ampdu_density << 2842 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT); 2843 2844 /* MCS set */ 2845 memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs)); 2846 pos += sizeof(ht_cap->mcs); 2847 2848 /* extended capabilities */ 2849 pos += sizeof(__le16); 2850 2851 /* BF capabilities */ 2852 pos += sizeof(__le32); 2853 2854 /* antenna selection */ 2855 pos += sizeof(u8); 2856 2857 return pos; 2858 } 2859 2860 u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap, 2861 u32 cap) 2862 { 2863 __le32 tmp; 2864 2865 *pos++ = WLAN_EID_VHT_CAPABILITY; 2866 *pos++ = sizeof(struct ieee80211_vht_cap); 2867 memset(pos, 0, sizeof(struct ieee80211_vht_cap)); 2868 2869 /* capability flags */ 2870 tmp = cpu_to_le32(cap); 2871 memcpy(pos, &tmp, sizeof(u32)); 2872 pos += sizeof(u32); 2873 2874 /* VHT MCS set */ 2875 memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs)); 2876 pos += sizeof(vht_cap->vht_mcs); 2877 2878 return pos; 2879 } 2880 2881 u8 ieee80211_ie_len_he_cap(struct ieee80211_sub_if_data *sdata, u8 iftype) 2882 { 2883 const struct ieee80211_sta_he_cap *he_cap; 2884 struct ieee80211_supported_band *sband; 2885 u8 n; 2886 2887 sband = ieee80211_get_sband(sdata); 2888 if (!sband) 2889 return 0; 2890 2891 he_cap = ieee80211_get_he_iftype_cap(sband, iftype); 2892 if (!he_cap) 2893 return 0; 2894 2895 n = ieee80211_he_mcs_nss_size(&he_cap->he_cap_elem); 2896 return 2 + 1 + 2897 sizeof(he_cap->he_cap_elem) + n + 2898 ieee80211_he_ppe_size(he_cap->ppe_thres[0], 2899 he_cap->he_cap_elem.phy_cap_info); 2900 } 2901 2902 u8 *ieee80211_ie_build_he_cap(u8 *pos, 2903 const struct ieee80211_sta_he_cap *he_cap, 2904 u8 *end) 2905 { 2906 u8 n; 2907 u8 ie_len; 2908 u8 *orig_pos = pos; 2909 2910 /* Make sure we have place for the IE */ 2911 /* 2912 * TODO: the 1 added is because this temporarily is under the EXTENSION 2913 * IE. Get rid of it when it moves. 2914 */ 2915 if (!he_cap) 2916 return orig_pos; 2917 2918 n = ieee80211_he_mcs_nss_size(&he_cap->he_cap_elem); 2919 ie_len = 2 + 1 + 2920 sizeof(he_cap->he_cap_elem) + n + 2921 ieee80211_he_ppe_size(he_cap->ppe_thres[0], 2922 he_cap->he_cap_elem.phy_cap_info); 2923 2924 if ((end - pos) < ie_len) 2925 return orig_pos; 2926 2927 *pos++ = WLAN_EID_EXTENSION; 2928 pos++; /* We'll set the size later below */ 2929 *pos++ = WLAN_EID_EXT_HE_CAPABILITY; 2930 2931 /* Fixed data */ 2932 memcpy(pos, &he_cap->he_cap_elem, sizeof(he_cap->he_cap_elem)); 2933 pos += sizeof(he_cap->he_cap_elem); 2934 2935 memcpy(pos, &he_cap->he_mcs_nss_supp, n); 2936 pos += n; 2937 2938 /* Check if PPE Threshold should be present */ 2939 if ((he_cap->he_cap_elem.phy_cap_info[6] & 2940 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) == 0) 2941 goto end; 2942 2943 /* 2944 * Calculate how many PPET16/PPET8 pairs are to come. Algorithm: 2945 * (NSS_M1 + 1) x (num of 1 bits in RU_INDEX_BITMASK) 2946 */ 2947 n = hweight8(he_cap->ppe_thres[0] & 2948 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK); 2949 n *= (1 + ((he_cap->ppe_thres[0] & IEEE80211_PPE_THRES_NSS_MASK) >> 2950 IEEE80211_PPE_THRES_NSS_POS)); 2951 2952 /* 2953 * Each pair is 6 bits, and we need to add the 7 "header" bits to the 2954 * total size. 2955 */ 2956 n = (n * IEEE80211_PPE_THRES_INFO_PPET_SIZE * 2) + 7; 2957 n = DIV_ROUND_UP(n, 8); 2958 2959 /* Copy PPE Thresholds */ 2960 memcpy(pos, &he_cap->ppe_thres, n); 2961 pos += n; 2962 2963 end: 2964 orig_pos[1] = (pos - orig_pos) - 2; 2965 return pos; 2966 } 2967 2968 void ieee80211_ie_build_he_6ghz_cap(struct ieee80211_sub_if_data *sdata, 2969 struct sk_buff *skb) 2970 { 2971 struct ieee80211_supported_band *sband; 2972 const struct ieee80211_sband_iftype_data *iftd; 2973 enum nl80211_iftype iftype = ieee80211_vif_type_p2p(&sdata->vif); 2974 u8 *pos; 2975 u16 cap; 2976 2977 if (!cfg80211_any_usable_channels(sdata->local->hw.wiphy, 2978 BIT(NL80211_BAND_6GHZ), 2979 IEEE80211_CHAN_NO_HE)) 2980 return; 2981 2982 sband = sdata->local->hw.wiphy->bands[NL80211_BAND_6GHZ]; 2983 2984 iftd = ieee80211_get_sband_iftype_data(sband, iftype); 2985 if (!iftd) 2986 return; 2987 2988 /* Check for device HE 6 GHz capability before adding element */ 2989 if (!iftd->he_6ghz_capa.capa) 2990 return; 2991 2992 cap = le16_to_cpu(iftd->he_6ghz_capa.capa); 2993 cap &= ~IEEE80211_HE_6GHZ_CAP_SM_PS; 2994 2995 switch (sdata->smps_mode) { 2996 case IEEE80211_SMPS_AUTOMATIC: 2997 case IEEE80211_SMPS_NUM_MODES: 2998 WARN_ON(1); 2999 fallthrough; 3000 case IEEE80211_SMPS_OFF: 3001 cap |= u16_encode_bits(WLAN_HT_CAP_SM_PS_DISABLED, 3002 IEEE80211_HE_6GHZ_CAP_SM_PS); 3003 break; 3004 case IEEE80211_SMPS_STATIC: 3005 cap |= u16_encode_bits(WLAN_HT_CAP_SM_PS_STATIC, 3006 IEEE80211_HE_6GHZ_CAP_SM_PS); 3007 break; 3008 case IEEE80211_SMPS_DYNAMIC: 3009 cap |= u16_encode_bits(WLAN_HT_CAP_SM_PS_DYNAMIC, 3010 IEEE80211_HE_6GHZ_CAP_SM_PS); 3011 break; 3012 } 3013 3014 pos = skb_put(skb, 2 + 1 + sizeof(cap)); 3015 ieee80211_write_he_6ghz_cap(pos, cpu_to_le16(cap), 3016 pos + 2 + 1 + sizeof(cap)); 3017 } 3018 3019 u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap, 3020 const struct cfg80211_chan_def *chandef, 3021 u16 prot_mode, bool rifs_mode) 3022 { 3023 struct ieee80211_ht_operation *ht_oper; 3024 /* Build HT Information */ 3025 *pos++ = WLAN_EID_HT_OPERATION; 3026 *pos++ = sizeof(struct ieee80211_ht_operation); 3027 ht_oper = (struct ieee80211_ht_operation *)pos; 3028 ht_oper->primary_chan = ieee80211_frequency_to_channel( 3029 chandef->chan->center_freq); 3030 switch (chandef->width) { 3031 case NL80211_CHAN_WIDTH_160: 3032 case NL80211_CHAN_WIDTH_80P80: 3033 case NL80211_CHAN_WIDTH_80: 3034 case NL80211_CHAN_WIDTH_40: 3035 if (chandef->center_freq1 > chandef->chan->center_freq) 3036 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 3037 else 3038 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW; 3039 break; 3040 default: 3041 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE; 3042 break; 3043 } 3044 if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 && 3045 chandef->width != NL80211_CHAN_WIDTH_20_NOHT && 3046 chandef->width != NL80211_CHAN_WIDTH_20) 3047 ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY; 3048 3049 if (rifs_mode) 3050 ht_oper->ht_param |= IEEE80211_HT_PARAM_RIFS_MODE; 3051 3052 ht_oper->operation_mode = cpu_to_le16(prot_mode); 3053 ht_oper->stbc_param = 0x0000; 3054 3055 /* It seems that Basic MCS set and Supported MCS set 3056 are identical for the first 10 bytes */ 3057 memset(&ht_oper->basic_set, 0, 16); 3058 memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10); 3059 3060 return pos + sizeof(struct ieee80211_ht_operation); 3061 } 3062 3063 void ieee80211_ie_build_wide_bw_cs(u8 *pos, 3064 const struct cfg80211_chan_def *chandef) 3065 { 3066 *pos++ = WLAN_EID_WIDE_BW_CHANNEL_SWITCH; /* EID */ 3067 *pos++ = 3; /* IE length */ 3068 /* New channel width */ 3069 switch (chandef->width) { 3070 case NL80211_CHAN_WIDTH_80: 3071 *pos++ = IEEE80211_VHT_CHANWIDTH_80MHZ; 3072 break; 3073 case NL80211_CHAN_WIDTH_160: 3074 *pos++ = IEEE80211_VHT_CHANWIDTH_160MHZ; 3075 break; 3076 case NL80211_CHAN_WIDTH_80P80: 3077 *pos++ = IEEE80211_VHT_CHANWIDTH_80P80MHZ; 3078 break; 3079 default: 3080 *pos++ = IEEE80211_VHT_CHANWIDTH_USE_HT; 3081 } 3082 3083 /* new center frequency segment 0 */ 3084 *pos++ = ieee80211_frequency_to_channel(chandef->center_freq1); 3085 /* new center frequency segment 1 */ 3086 if (chandef->center_freq2) 3087 *pos++ = ieee80211_frequency_to_channel(chandef->center_freq2); 3088 else 3089 *pos++ = 0; 3090 } 3091 3092 u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap, 3093 const struct cfg80211_chan_def *chandef) 3094 { 3095 struct ieee80211_vht_operation *vht_oper; 3096 3097 *pos++ = WLAN_EID_VHT_OPERATION; 3098 *pos++ = sizeof(struct ieee80211_vht_operation); 3099 vht_oper = (struct ieee80211_vht_operation *)pos; 3100 vht_oper->center_freq_seg0_idx = ieee80211_frequency_to_channel( 3101 chandef->center_freq1); 3102 if (chandef->center_freq2) 3103 vht_oper->center_freq_seg1_idx = 3104 ieee80211_frequency_to_channel(chandef->center_freq2); 3105 else 3106 vht_oper->center_freq_seg1_idx = 0x00; 3107 3108 switch (chandef->width) { 3109 case NL80211_CHAN_WIDTH_160: 3110 /* 3111 * Convert 160 MHz channel width to new style as interop 3112 * workaround. 3113 */ 3114 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ; 3115 vht_oper->center_freq_seg1_idx = vht_oper->center_freq_seg0_idx; 3116 if (chandef->chan->center_freq < chandef->center_freq1) 3117 vht_oper->center_freq_seg0_idx -= 8; 3118 else 3119 vht_oper->center_freq_seg0_idx += 8; 3120 break; 3121 case NL80211_CHAN_WIDTH_80P80: 3122 /* 3123 * Convert 80+80 MHz channel width to new style as interop 3124 * workaround. 3125 */ 3126 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ; 3127 break; 3128 case NL80211_CHAN_WIDTH_80: 3129 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ; 3130 break; 3131 default: 3132 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_USE_HT; 3133 break; 3134 } 3135 3136 /* don't require special VHT peer rates */ 3137 vht_oper->basic_mcs_set = cpu_to_le16(0xffff); 3138 3139 return pos + sizeof(struct ieee80211_vht_operation); 3140 } 3141 3142 u8 *ieee80211_ie_build_he_oper(u8 *pos, struct cfg80211_chan_def *chandef) 3143 { 3144 struct ieee80211_he_operation *he_oper; 3145 struct ieee80211_he_6ghz_oper *he_6ghz_op; 3146 u32 he_oper_params; 3147 u8 ie_len = 1 + sizeof(struct ieee80211_he_operation); 3148 3149 if (chandef->chan->band == NL80211_BAND_6GHZ) 3150 ie_len += sizeof(struct ieee80211_he_6ghz_oper); 3151 3152 *pos++ = WLAN_EID_EXTENSION; 3153 *pos++ = ie_len; 3154 *pos++ = WLAN_EID_EXT_HE_OPERATION; 3155 3156 he_oper_params = 0; 3157 he_oper_params |= u32_encode_bits(1023, /* disabled */ 3158 IEEE80211_HE_OPERATION_RTS_THRESHOLD_MASK); 3159 he_oper_params |= u32_encode_bits(1, 3160 IEEE80211_HE_OPERATION_ER_SU_DISABLE); 3161 he_oper_params |= u32_encode_bits(1, 3162 IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED); 3163 if (chandef->chan->band == NL80211_BAND_6GHZ) 3164 he_oper_params |= u32_encode_bits(1, 3165 IEEE80211_HE_OPERATION_6GHZ_OP_INFO); 3166 3167 he_oper = (struct ieee80211_he_operation *)pos; 3168 he_oper->he_oper_params = cpu_to_le32(he_oper_params); 3169 3170 /* don't require special HE peer rates */ 3171 he_oper->he_mcs_nss_set = cpu_to_le16(0xffff); 3172 pos += sizeof(struct ieee80211_he_operation); 3173 3174 if (chandef->chan->band != NL80211_BAND_6GHZ) 3175 goto out; 3176 3177 /* TODO add VHT operational */ 3178 he_6ghz_op = (struct ieee80211_he_6ghz_oper *)pos; 3179 he_6ghz_op->minrate = 6; /* 6 Mbps */ 3180 he_6ghz_op->primary = 3181 ieee80211_frequency_to_channel(chandef->chan->center_freq); 3182 he_6ghz_op->ccfs0 = 3183 ieee80211_frequency_to_channel(chandef->center_freq1); 3184 if (chandef->center_freq2) 3185 he_6ghz_op->ccfs1 = 3186 ieee80211_frequency_to_channel(chandef->center_freq2); 3187 else 3188 he_6ghz_op->ccfs1 = 0; 3189 3190 switch (chandef->width) { 3191 case NL80211_CHAN_WIDTH_160: 3192 /* Convert 160 MHz channel width to new style as interop 3193 * workaround. 3194 */ 3195 he_6ghz_op->control = 3196 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ; 3197 he_6ghz_op->ccfs1 = he_6ghz_op->ccfs0; 3198 if (chandef->chan->center_freq < chandef->center_freq1) 3199 he_6ghz_op->ccfs0 -= 8; 3200 else 3201 he_6ghz_op->ccfs0 += 8; 3202 fallthrough; 3203 case NL80211_CHAN_WIDTH_80P80: 3204 he_6ghz_op->control = 3205 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ; 3206 break; 3207 case NL80211_CHAN_WIDTH_80: 3208 he_6ghz_op->control = 3209 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ; 3210 break; 3211 case NL80211_CHAN_WIDTH_40: 3212 he_6ghz_op->control = 3213 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ; 3214 break; 3215 default: 3216 he_6ghz_op->control = 3217 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ; 3218 break; 3219 } 3220 3221 pos += sizeof(struct ieee80211_he_6ghz_oper); 3222 3223 out: 3224 return pos; 3225 } 3226 3227 bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation *ht_oper, 3228 struct cfg80211_chan_def *chandef) 3229 { 3230 enum nl80211_channel_type channel_type; 3231 3232 if (!ht_oper) 3233 return false; 3234 3235 switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) { 3236 case IEEE80211_HT_PARAM_CHA_SEC_NONE: 3237 channel_type = NL80211_CHAN_HT20; 3238 break; 3239 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: 3240 channel_type = NL80211_CHAN_HT40PLUS; 3241 break; 3242 case IEEE80211_HT_PARAM_CHA_SEC_BELOW: 3243 channel_type = NL80211_CHAN_HT40MINUS; 3244 break; 3245 default: 3246 channel_type = NL80211_CHAN_NO_HT; 3247 return false; 3248 } 3249 3250 cfg80211_chandef_create(chandef, chandef->chan, channel_type); 3251 return true; 3252 } 3253 3254 bool ieee80211_chandef_vht_oper(struct ieee80211_hw *hw, u32 vht_cap_info, 3255 const struct ieee80211_vht_operation *oper, 3256 const struct ieee80211_ht_operation *htop, 3257 struct cfg80211_chan_def *chandef) 3258 { 3259 struct cfg80211_chan_def new = *chandef; 3260 int cf0, cf1; 3261 int ccfs0, ccfs1, ccfs2; 3262 int ccf0, ccf1; 3263 u32 vht_cap; 3264 bool support_80_80 = false; 3265 bool support_160 = false; 3266 u8 ext_nss_bw_supp = u32_get_bits(vht_cap_info, 3267 IEEE80211_VHT_CAP_EXT_NSS_BW_MASK); 3268 u8 supp_chwidth = u32_get_bits(vht_cap_info, 3269 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK); 3270 3271 if (!oper || !htop) 3272 return false; 3273 3274 vht_cap = hw->wiphy->bands[chandef->chan->band]->vht_cap.cap; 3275 support_160 = (vht_cap & (IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK | 3276 IEEE80211_VHT_CAP_EXT_NSS_BW_MASK)); 3277 support_80_80 = ((vht_cap & 3278 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) || 3279 (vht_cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ && 3280 vht_cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) || 3281 ((vht_cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) >> 3282 IEEE80211_VHT_CAP_EXT_NSS_BW_SHIFT > 1)); 3283 ccfs0 = oper->center_freq_seg0_idx; 3284 ccfs1 = oper->center_freq_seg1_idx; 3285 ccfs2 = (le16_to_cpu(htop->operation_mode) & 3286 IEEE80211_HT_OP_MODE_CCFS2_MASK) 3287 >> IEEE80211_HT_OP_MODE_CCFS2_SHIFT; 3288 3289 ccf0 = ccfs0; 3290 3291 /* if not supported, parse as though we didn't understand it */ 3292 if (!ieee80211_hw_check(hw, SUPPORTS_VHT_EXT_NSS_BW)) 3293 ext_nss_bw_supp = 0; 3294 3295 /* 3296 * Cf. IEEE 802.11 Table 9-250 3297 * 3298 * We really just consider that because it's inefficient to connect 3299 * at a higher bandwidth than we'll actually be able to use. 3300 */ 3301 switch ((supp_chwidth << 4) | ext_nss_bw_supp) { 3302 default: 3303 case 0x00: 3304 ccf1 = 0; 3305 support_160 = false; 3306 support_80_80 = false; 3307 break; 3308 case 0x01: 3309 support_80_80 = false; 3310 fallthrough; 3311 case 0x02: 3312 case 0x03: 3313 ccf1 = ccfs2; 3314 break; 3315 case 0x10: 3316 ccf1 = ccfs1; 3317 break; 3318 case 0x11: 3319 case 0x12: 3320 if (!ccfs1) 3321 ccf1 = ccfs2; 3322 else 3323 ccf1 = ccfs1; 3324 break; 3325 case 0x13: 3326 case 0x20: 3327 case 0x23: 3328 ccf1 = ccfs1; 3329 break; 3330 } 3331 3332 cf0 = ieee80211_channel_to_frequency(ccf0, chandef->chan->band); 3333 cf1 = ieee80211_channel_to_frequency(ccf1, chandef->chan->band); 3334 3335 switch (oper->chan_width) { 3336 case IEEE80211_VHT_CHANWIDTH_USE_HT: 3337 /* just use HT information directly */ 3338 break; 3339 case IEEE80211_VHT_CHANWIDTH_80MHZ: 3340 new.width = NL80211_CHAN_WIDTH_80; 3341 new.center_freq1 = cf0; 3342 /* If needed, adjust based on the newer interop workaround. */ 3343 if (ccf1) { 3344 unsigned int diff; 3345 3346 diff = abs(ccf1 - ccf0); 3347 if ((diff == 8) && support_160) { 3348 new.width = NL80211_CHAN_WIDTH_160; 3349 new.center_freq1 = cf1; 3350 } else if ((diff > 8) && support_80_80) { 3351 new.width = NL80211_CHAN_WIDTH_80P80; 3352 new.center_freq2 = cf1; 3353 } 3354 } 3355 break; 3356 case IEEE80211_VHT_CHANWIDTH_160MHZ: 3357 /* deprecated encoding */ 3358 new.width = NL80211_CHAN_WIDTH_160; 3359 new.center_freq1 = cf0; 3360 break; 3361 case IEEE80211_VHT_CHANWIDTH_80P80MHZ: 3362 /* deprecated encoding */ 3363 new.width = NL80211_CHAN_WIDTH_80P80; 3364 new.center_freq1 = cf0; 3365 new.center_freq2 = cf1; 3366 break; 3367 default: 3368 return false; 3369 } 3370 3371 if (!cfg80211_chandef_valid(&new)) 3372 return false; 3373 3374 *chandef = new; 3375 return true; 3376 } 3377 3378 bool ieee80211_chandef_he_6ghz_oper(struct ieee80211_sub_if_data *sdata, 3379 const struct ieee80211_he_operation *he_oper, 3380 struct cfg80211_chan_def *chandef) 3381 { 3382 struct ieee80211_local *local = sdata->local; 3383 struct ieee80211_supported_band *sband; 3384 enum nl80211_iftype iftype = ieee80211_vif_type_p2p(&sdata->vif); 3385 const struct ieee80211_sta_he_cap *he_cap; 3386 struct cfg80211_chan_def he_chandef = *chandef; 3387 const struct ieee80211_he_6ghz_oper *he_6ghz_oper; 3388 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf; 3389 bool support_80_80, support_160; 3390 u8 he_phy_cap; 3391 u32 freq; 3392 3393 if (chandef->chan->band != NL80211_BAND_6GHZ) 3394 return true; 3395 3396 sband = local->hw.wiphy->bands[NL80211_BAND_6GHZ]; 3397 3398 he_cap = ieee80211_get_he_iftype_cap(sband, iftype); 3399 if (!he_cap) { 3400 sdata_info(sdata, "Missing iftype sband data/HE cap"); 3401 return false; 3402 } 3403 3404 he_phy_cap = he_cap->he_cap_elem.phy_cap_info[0]; 3405 support_160 = 3406 he_phy_cap & 3407 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G; 3408 support_80_80 = 3409 he_phy_cap & 3410 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G; 3411 3412 if (!he_oper) { 3413 sdata_info(sdata, 3414 "HE is not advertised on (on %d MHz), expect issues\n", 3415 chandef->chan->center_freq); 3416 return false; 3417 } 3418 3419 he_6ghz_oper = ieee80211_he_6ghz_oper(he_oper); 3420 3421 if (!he_6ghz_oper) { 3422 sdata_info(sdata, 3423 "HE 6GHz operation missing (on %d MHz), expect issues\n", 3424 chandef->chan->center_freq); 3425 return false; 3426 } 3427 3428 freq = ieee80211_channel_to_frequency(he_6ghz_oper->primary, 3429 NL80211_BAND_6GHZ); 3430 he_chandef.chan = ieee80211_get_channel(sdata->local->hw.wiphy, freq); 3431 3432 switch (u8_get_bits(he_6ghz_oper->control, 3433 IEEE80211_HE_6GHZ_OPER_CTRL_REG_INFO)) { 3434 case IEEE80211_6GHZ_CTRL_REG_LPI_AP: 3435 bss_conf->power_type = IEEE80211_REG_LPI_AP; 3436 break; 3437 case IEEE80211_6GHZ_CTRL_REG_SP_AP: 3438 bss_conf->power_type = IEEE80211_REG_SP_AP; 3439 break; 3440 default: 3441 bss_conf->power_type = IEEE80211_REG_UNSET_AP; 3442 break; 3443 } 3444 3445 switch (u8_get_bits(he_6ghz_oper->control, 3446 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH)) { 3447 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ: 3448 he_chandef.width = NL80211_CHAN_WIDTH_20; 3449 break; 3450 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ: 3451 he_chandef.width = NL80211_CHAN_WIDTH_40; 3452 break; 3453 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ: 3454 he_chandef.width = NL80211_CHAN_WIDTH_80; 3455 break; 3456 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ: 3457 he_chandef.width = NL80211_CHAN_WIDTH_80; 3458 if (!he_6ghz_oper->ccfs1) 3459 break; 3460 if (abs(he_6ghz_oper->ccfs1 - he_6ghz_oper->ccfs0) == 8) { 3461 if (support_160) 3462 he_chandef.width = NL80211_CHAN_WIDTH_160; 3463 } else { 3464 if (support_80_80) 3465 he_chandef.width = NL80211_CHAN_WIDTH_80P80; 3466 } 3467 break; 3468 } 3469 3470 if (he_chandef.width == NL80211_CHAN_WIDTH_160) { 3471 he_chandef.center_freq1 = 3472 ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1, 3473 NL80211_BAND_6GHZ); 3474 } else { 3475 he_chandef.center_freq1 = 3476 ieee80211_channel_to_frequency(he_6ghz_oper->ccfs0, 3477 NL80211_BAND_6GHZ); 3478 if (support_80_80 || support_160) 3479 he_chandef.center_freq2 = 3480 ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1, 3481 NL80211_BAND_6GHZ); 3482 } 3483 3484 if (!cfg80211_chandef_valid(&he_chandef)) { 3485 sdata_info(sdata, 3486 "HE 6GHz operation resulted in invalid chandef: %d MHz/%d/%d MHz/%d MHz\n", 3487 he_chandef.chan ? he_chandef.chan->center_freq : 0, 3488 he_chandef.width, 3489 he_chandef.center_freq1, 3490 he_chandef.center_freq2); 3491 return false; 3492 } 3493 3494 *chandef = he_chandef; 3495 3496 return true; 3497 } 3498 3499 bool ieee80211_chandef_s1g_oper(const struct ieee80211_s1g_oper_ie *oper, 3500 struct cfg80211_chan_def *chandef) 3501 { 3502 u32 oper_freq; 3503 3504 if (!oper) 3505 return false; 3506 3507 switch (FIELD_GET(S1G_OPER_CH_WIDTH_OPER, oper->ch_width)) { 3508 case IEEE80211_S1G_CHANWIDTH_1MHZ: 3509 chandef->width = NL80211_CHAN_WIDTH_1; 3510 break; 3511 case IEEE80211_S1G_CHANWIDTH_2MHZ: 3512 chandef->width = NL80211_CHAN_WIDTH_2; 3513 break; 3514 case IEEE80211_S1G_CHANWIDTH_4MHZ: 3515 chandef->width = NL80211_CHAN_WIDTH_4; 3516 break; 3517 case IEEE80211_S1G_CHANWIDTH_8MHZ: 3518 chandef->width = NL80211_CHAN_WIDTH_8; 3519 break; 3520 case IEEE80211_S1G_CHANWIDTH_16MHZ: 3521 chandef->width = NL80211_CHAN_WIDTH_16; 3522 break; 3523 default: 3524 return false; 3525 } 3526 3527 oper_freq = ieee80211_channel_to_freq_khz(oper->oper_ch, 3528 NL80211_BAND_S1GHZ); 3529 chandef->center_freq1 = KHZ_TO_MHZ(oper_freq); 3530 chandef->freq1_offset = oper_freq % 1000; 3531 3532 return true; 3533 } 3534 3535 int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef, 3536 const struct ieee80211_supported_band *sband, 3537 const u8 *srates, int srates_len, u32 *rates) 3538 { 3539 u32 rate_flags = ieee80211_chandef_rate_flags(chandef); 3540 int shift = ieee80211_chandef_get_shift(chandef); 3541 struct ieee80211_rate *br; 3542 int brate, rate, i, j, count = 0; 3543 3544 *rates = 0; 3545 3546 for (i = 0; i < srates_len; i++) { 3547 rate = srates[i] & 0x7f; 3548 3549 for (j = 0; j < sband->n_bitrates; j++) { 3550 br = &sband->bitrates[j]; 3551 if ((rate_flags & br->flags) != rate_flags) 3552 continue; 3553 3554 brate = DIV_ROUND_UP(br->bitrate, (1 << shift) * 5); 3555 if (brate == rate) { 3556 *rates |= BIT(j); 3557 count++; 3558 break; 3559 } 3560 } 3561 } 3562 return count; 3563 } 3564 3565 int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata, 3566 struct sk_buff *skb, bool need_basic, 3567 enum nl80211_band band) 3568 { 3569 struct ieee80211_local *local = sdata->local; 3570 struct ieee80211_supported_band *sband; 3571 int rate, shift; 3572 u8 i, rates, *pos; 3573 u32 basic_rates = sdata->vif.bss_conf.basic_rates; 3574 u32 rate_flags; 3575 3576 shift = ieee80211_vif_get_shift(&sdata->vif); 3577 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef); 3578 sband = local->hw.wiphy->bands[band]; 3579 rates = 0; 3580 for (i = 0; i < sband->n_bitrates; i++) { 3581 if ((rate_flags & sband->bitrates[i].flags) != rate_flags) 3582 continue; 3583 rates++; 3584 } 3585 if (rates > 8) 3586 rates = 8; 3587 3588 if (skb_tailroom(skb) < rates + 2) 3589 return -ENOMEM; 3590 3591 pos = skb_put(skb, rates + 2); 3592 *pos++ = WLAN_EID_SUPP_RATES; 3593 *pos++ = rates; 3594 for (i = 0; i < rates; i++) { 3595 u8 basic = 0; 3596 if ((rate_flags & sband->bitrates[i].flags) != rate_flags) 3597 continue; 3598 3599 if (need_basic && basic_rates & BIT(i)) 3600 basic = 0x80; 3601 rate = DIV_ROUND_UP(sband->bitrates[i].bitrate, 3602 5 * (1 << shift)); 3603 *pos++ = basic | (u8) rate; 3604 } 3605 3606 return 0; 3607 } 3608 3609 int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata, 3610 struct sk_buff *skb, bool need_basic, 3611 enum nl80211_band band) 3612 { 3613 struct ieee80211_local *local = sdata->local; 3614 struct ieee80211_supported_band *sband; 3615 int rate, shift; 3616 u8 i, exrates, *pos; 3617 u32 basic_rates = sdata->vif.bss_conf.basic_rates; 3618 u32 rate_flags; 3619 3620 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef); 3621 shift = ieee80211_vif_get_shift(&sdata->vif); 3622 3623 sband = local->hw.wiphy->bands[band]; 3624 exrates = 0; 3625 for (i = 0; i < sband->n_bitrates; i++) { 3626 if ((rate_flags & sband->bitrates[i].flags) != rate_flags) 3627 continue; 3628 exrates++; 3629 } 3630 3631 if (exrates > 8) 3632 exrates -= 8; 3633 else 3634 exrates = 0; 3635 3636 if (skb_tailroom(skb) < exrates + 2) 3637 return -ENOMEM; 3638 3639 if (exrates) { 3640 pos = skb_put(skb, exrates + 2); 3641 *pos++ = WLAN_EID_EXT_SUPP_RATES; 3642 *pos++ = exrates; 3643 for (i = 8; i < sband->n_bitrates; i++) { 3644 u8 basic = 0; 3645 if ((rate_flags & sband->bitrates[i].flags) 3646 != rate_flags) 3647 continue; 3648 if (need_basic && basic_rates & BIT(i)) 3649 basic = 0x80; 3650 rate = DIV_ROUND_UP(sband->bitrates[i].bitrate, 3651 5 * (1 << shift)); 3652 *pos++ = basic | (u8) rate; 3653 } 3654 } 3655 return 0; 3656 } 3657 3658 int ieee80211_ave_rssi(struct ieee80211_vif *vif) 3659 { 3660 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 3661 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 3662 3663 if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) { 3664 /* non-managed type inferfaces */ 3665 return 0; 3666 } 3667 return -ewma_beacon_signal_read(&ifmgd->ave_beacon_signal); 3668 } 3669 EXPORT_SYMBOL_GPL(ieee80211_ave_rssi); 3670 3671 u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs) 3672 { 3673 if (!mcs) 3674 return 1; 3675 3676 /* TODO: consider rx_highest */ 3677 3678 if (mcs->rx_mask[3]) 3679 return 4; 3680 if (mcs->rx_mask[2]) 3681 return 3; 3682 if (mcs->rx_mask[1]) 3683 return 2; 3684 return 1; 3685 } 3686 3687 /** 3688 * ieee80211_calculate_rx_timestamp - calculate timestamp in frame 3689 * @local: mac80211 hw info struct 3690 * @status: RX status 3691 * @mpdu_len: total MPDU length (including FCS) 3692 * @mpdu_offset: offset into MPDU to calculate timestamp at 3693 * 3694 * This function calculates the RX timestamp at the given MPDU offset, taking 3695 * into account what the RX timestamp was. An offset of 0 will just normalize 3696 * the timestamp to TSF at beginning of MPDU reception. 3697 */ 3698 u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local, 3699 struct ieee80211_rx_status *status, 3700 unsigned int mpdu_len, 3701 unsigned int mpdu_offset) 3702 { 3703 u64 ts = status->mactime; 3704 struct rate_info ri; 3705 u16 rate; 3706 u8 n_ltf; 3707 3708 if (WARN_ON(!ieee80211_have_rx_timestamp(status))) 3709 return 0; 3710 3711 memset(&ri, 0, sizeof(ri)); 3712 3713 ri.bw = status->bw; 3714 3715 /* Fill cfg80211 rate info */ 3716 switch (status->encoding) { 3717 case RX_ENC_HE: 3718 ri.flags |= RATE_INFO_FLAGS_HE_MCS; 3719 ri.mcs = status->rate_idx; 3720 ri.nss = status->nss; 3721 ri.he_ru_alloc = status->he_ru; 3722 if (status->enc_flags & RX_ENC_FLAG_SHORT_GI) 3723 ri.flags |= RATE_INFO_FLAGS_SHORT_GI; 3724 3725 /* 3726 * See P802.11ax_D6.0, section 27.3.4 for 3727 * VHT PPDU format. 3728 */ 3729 if (status->flag & RX_FLAG_MACTIME_PLCP_START) { 3730 mpdu_offset += 2; 3731 ts += 36; 3732 3733 /* 3734 * TODO: 3735 * For HE MU PPDU, add the HE-SIG-B. 3736 * For HE ER PPDU, add 8us for the HE-SIG-A. 3737 * For HE TB PPDU, add 4us for the HE-STF. 3738 * Add the HE-LTF durations - variable. 3739 */ 3740 } 3741 3742 break; 3743 case RX_ENC_HT: 3744 ri.mcs = status->rate_idx; 3745 ri.flags |= RATE_INFO_FLAGS_MCS; 3746 if (status->enc_flags & RX_ENC_FLAG_SHORT_GI) 3747 ri.flags |= RATE_INFO_FLAGS_SHORT_GI; 3748 3749 /* 3750 * See P802.11REVmd_D3.0, section 19.3.2 for 3751 * HT PPDU format. 3752 */ 3753 if (status->flag & RX_FLAG_MACTIME_PLCP_START) { 3754 mpdu_offset += 2; 3755 if (status->enc_flags & RX_ENC_FLAG_HT_GF) 3756 ts += 24; 3757 else 3758 ts += 32; 3759 3760 /* 3761 * Add Data HT-LTFs per streams 3762 * TODO: add Extension HT-LTFs, 4us per LTF 3763 */ 3764 n_ltf = ((ri.mcs >> 3) & 3) + 1; 3765 n_ltf = n_ltf == 3 ? 4 : n_ltf; 3766 ts += n_ltf * 4; 3767 } 3768 3769 break; 3770 case RX_ENC_VHT: 3771 ri.flags |= RATE_INFO_FLAGS_VHT_MCS; 3772 ri.mcs = status->rate_idx; 3773 ri.nss = status->nss; 3774 if (status->enc_flags & RX_ENC_FLAG_SHORT_GI) 3775 ri.flags |= RATE_INFO_FLAGS_SHORT_GI; 3776 3777 /* 3778 * See P802.11REVmd_D3.0, section 21.3.2 for 3779 * VHT PPDU format. 3780 */ 3781 if (status->flag & RX_FLAG_MACTIME_PLCP_START) { 3782 mpdu_offset += 2; 3783 ts += 36; 3784 3785 /* 3786 * Add VHT-LTFs per streams 3787 */ 3788 n_ltf = (ri.nss != 1) && (ri.nss % 2) ? 3789 ri.nss + 1 : ri.nss; 3790 ts += 4 * n_ltf; 3791 } 3792 3793 break; 3794 default: 3795 WARN_ON(1); 3796 fallthrough; 3797 case RX_ENC_LEGACY: { 3798 struct ieee80211_supported_band *sband; 3799 int shift = 0; 3800 int bitrate; 3801 3802 switch (status->bw) { 3803 case RATE_INFO_BW_10: 3804 shift = 1; 3805 break; 3806 case RATE_INFO_BW_5: 3807 shift = 2; 3808 break; 3809 } 3810 3811 sband = local->hw.wiphy->bands[status->band]; 3812 bitrate = sband->bitrates[status->rate_idx].bitrate; 3813 ri.legacy = DIV_ROUND_UP(bitrate, (1 << shift)); 3814 3815 if (status->flag & RX_FLAG_MACTIME_PLCP_START) { 3816 if (status->band == NL80211_BAND_5GHZ) { 3817 ts += 20 << shift; 3818 mpdu_offset += 2; 3819 } else if (status->enc_flags & RX_ENC_FLAG_SHORTPRE) { 3820 ts += 96; 3821 } else { 3822 ts += 192; 3823 } 3824 } 3825 break; 3826 } 3827 } 3828 3829 rate = cfg80211_calculate_bitrate(&ri); 3830 if (WARN_ONCE(!rate, 3831 "Invalid bitrate: flags=0x%llx, idx=%d, vht_nss=%d\n", 3832 (unsigned long long)status->flag, status->rate_idx, 3833 status->nss)) 3834 return 0; 3835 3836 /* rewind from end of MPDU */ 3837 if (status->flag & RX_FLAG_MACTIME_END) 3838 ts -= mpdu_len * 8 * 10 / rate; 3839 3840 ts += mpdu_offset * 8 * 10 / rate; 3841 3842 return ts; 3843 } 3844 3845 void ieee80211_dfs_cac_cancel(struct ieee80211_local *local) 3846 { 3847 struct ieee80211_sub_if_data *sdata; 3848 struct cfg80211_chan_def chandef; 3849 3850 /* for interface list, to avoid linking iflist_mtx and chanctx_mtx */ 3851 lockdep_assert_wiphy(local->hw.wiphy); 3852 3853 mutex_lock(&local->mtx); 3854 list_for_each_entry(sdata, &local->interfaces, list) { 3855 /* it might be waiting for the local->mtx, but then 3856 * by the time it gets it, sdata->wdev.cac_started 3857 * will no longer be true 3858 */ 3859 cancel_delayed_work(&sdata->dfs_cac_timer_work); 3860 3861 if (sdata->wdev.cac_started) { 3862 chandef = sdata->vif.bss_conf.chandef; 3863 ieee80211_vif_release_channel(sdata); 3864 cfg80211_cac_event(sdata->dev, 3865 &chandef, 3866 NL80211_RADAR_CAC_ABORTED, 3867 GFP_KERNEL); 3868 } 3869 } 3870 mutex_unlock(&local->mtx); 3871 } 3872 3873 void ieee80211_dfs_radar_detected_work(struct work_struct *work) 3874 { 3875 struct ieee80211_local *local = 3876 container_of(work, struct ieee80211_local, radar_detected_work); 3877 struct cfg80211_chan_def chandef = local->hw.conf.chandef; 3878 struct ieee80211_chanctx *ctx; 3879 int num_chanctx = 0; 3880 3881 mutex_lock(&local->chanctx_mtx); 3882 list_for_each_entry(ctx, &local->chanctx_list, list) { 3883 if (ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER) 3884 continue; 3885 3886 num_chanctx++; 3887 chandef = ctx->conf.def; 3888 } 3889 mutex_unlock(&local->chanctx_mtx); 3890 3891 wiphy_lock(local->hw.wiphy); 3892 ieee80211_dfs_cac_cancel(local); 3893 wiphy_unlock(local->hw.wiphy); 3894 3895 if (num_chanctx > 1) 3896 /* XXX: multi-channel is not supported yet */ 3897 WARN_ON(1); 3898 else 3899 cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL); 3900 } 3901 3902 void ieee80211_radar_detected(struct ieee80211_hw *hw) 3903 { 3904 struct ieee80211_local *local = hw_to_local(hw); 3905 3906 trace_api_radar_detected(local); 3907 3908 schedule_work(&local->radar_detected_work); 3909 } 3910 EXPORT_SYMBOL(ieee80211_radar_detected); 3911 3912 u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c) 3913 { 3914 u32 ret; 3915 int tmp; 3916 3917 switch (c->width) { 3918 case NL80211_CHAN_WIDTH_20: 3919 c->width = NL80211_CHAN_WIDTH_20_NOHT; 3920 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT; 3921 break; 3922 case NL80211_CHAN_WIDTH_40: 3923 c->width = NL80211_CHAN_WIDTH_20; 3924 c->center_freq1 = c->chan->center_freq; 3925 ret = IEEE80211_STA_DISABLE_40MHZ | 3926 IEEE80211_STA_DISABLE_VHT; 3927 break; 3928 case NL80211_CHAN_WIDTH_80: 3929 tmp = (30 + c->chan->center_freq - c->center_freq1)/20; 3930 /* n_P40 */ 3931 tmp /= 2; 3932 /* freq_P40 */ 3933 c->center_freq1 = c->center_freq1 - 20 + 40 * tmp; 3934 c->width = NL80211_CHAN_WIDTH_40; 3935 ret = IEEE80211_STA_DISABLE_VHT; 3936 break; 3937 case NL80211_CHAN_WIDTH_80P80: 3938 c->center_freq2 = 0; 3939 c->width = NL80211_CHAN_WIDTH_80; 3940 ret = IEEE80211_STA_DISABLE_80P80MHZ | 3941 IEEE80211_STA_DISABLE_160MHZ; 3942 break; 3943 case NL80211_CHAN_WIDTH_160: 3944 /* n_P20 */ 3945 tmp = (70 + c->chan->center_freq - c->center_freq1)/20; 3946 /* n_P80 */ 3947 tmp /= 4; 3948 c->center_freq1 = c->center_freq1 - 40 + 80 * tmp; 3949 c->width = NL80211_CHAN_WIDTH_80; 3950 ret = IEEE80211_STA_DISABLE_80P80MHZ | 3951 IEEE80211_STA_DISABLE_160MHZ; 3952 break; 3953 default: 3954 case NL80211_CHAN_WIDTH_20_NOHT: 3955 WARN_ON_ONCE(1); 3956 c->width = NL80211_CHAN_WIDTH_20_NOHT; 3957 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT; 3958 break; 3959 case NL80211_CHAN_WIDTH_1: 3960 case NL80211_CHAN_WIDTH_2: 3961 case NL80211_CHAN_WIDTH_4: 3962 case NL80211_CHAN_WIDTH_8: 3963 case NL80211_CHAN_WIDTH_16: 3964 case NL80211_CHAN_WIDTH_5: 3965 case NL80211_CHAN_WIDTH_10: 3966 WARN_ON_ONCE(1); 3967 /* keep c->width */ 3968 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT; 3969 break; 3970 } 3971 3972 WARN_ON_ONCE(!cfg80211_chandef_valid(c)); 3973 3974 return ret; 3975 } 3976 3977 /* 3978 * Returns true if smps_mode_new is strictly more restrictive than 3979 * smps_mode_old. 3980 */ 3981 bool ieee80211_smps_is_restrictive(enum ieee80211_smps_mode smps_mode_old, 3982 enum ieee80211_smps_mode smps_mode_new) 3983 { 3984 if (WARN_ON_ONCE(smps_mode_old == IEEE80211_SMPS_AUTOMATIC || 3985 smps_mode_new == IEEE80211_SMPS_AUTOMATIC)) 3986 return false; 3987 3988 switch (smps_mode_old) { 3989 case IEEE80211_SMPS_STATIC: 3990 return false; 3991 case IEEE80211_SMPS_DYNAMIC: 3992 return smps_mode_new == IEEE80211_SMPS_STATIC; 3993 case IEEE80211_SMPS_OFF: 3994 return smps_mode_new != IEEE80211_SMPS_OFF; 3995 default: 3996 WARN_ON(1); 3997 } 3998 3999 return false; 4000 } 4001 4002 int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata, 4003 struct cfg80211_csa_settings *csa_settings) 4004 { 4005 struct sk_buff *skb; 4006 struct ieee80211_mgmt *mgmt; 4007 struct ieee80211_local *local = sdata->local; 4008 int freq; 4009 int hdr_len = offsetofend(struct ieee80211_mgmt, 4010 u.action.u.chan_switch); 4011 u8 *pos; 4012 4013 if (sdata->vif.type != NL80211_IFTYPE_ADHOC && 4014 sdata->vif.type != NL80211_IFTYPE_MESH_POINT) 4015 return -EOPNOTSUPP; 4016 4017 skb = dev_alloc_skb(local->tx_headroom + hdr_len + 4018 5 + /* channel switch announcement element */ 4019 3 + /* secondary channel offset element */ 4020 5 + /* wide bandwidth channel switch announcement */ 4021 8); /* mesh channel switch parameters element */ 4022 if (!skb) 4023 return -ENOMEM; 4024 4025 skb_reserve(skb, local->tx_headroom); 4026 mgmt = skb_put_zero(skb, hdr_len); 4027 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 4028 IEEE80211_STYPE_ACTION); 4029 4030 eth_broadcast_addr(mgmt->da); 4031 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 4032 if (ieee80211_vif_is_mesh(&sdata->vif)) { 4033 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN); 4034 } else { 4035 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 4036 memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN); 4037 } 4038 mgmt->u.action.category = WLAN_CATEGORY_SPECTRUM_MGMT; 4039 mgmt->u.action.u.chan_switch.action_code = WLAN_ACTION_SPCT_CHL_SWITCH; 4040 pos = skb_put(skb, 5); 4041 *pos++ = WLAN_EID_CHANNEL_SWITCH; /* EID */ 4042 *pos++ = 3; /* IE length */ 4043 *pos++ = csa_settings->block_tx ? 1 : 0; /* CSA mode */ 4044 freq = csa_settings->chandef.chan->center_freq; 4045 *pos++ = ieee80211_frequency_to_channel(freq); /* channel */ 4046 *pos++ = csa_settings->count; /* count */ 4047 4048 if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_40) { 4049 enum nl80211_channel_type ch_type; 4050 4051 skb_put(skb, 3); 4052 *pos++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET; /* EID */ 4053 *pos++ = 1; /* IE length */ 4054 ch_type = cfg80211_get_chandef_type(&csa_settings->chandef); 4055 if (ch_type == NL80211_CHAN_HT40PLUS) 4056 *pos++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 4057 else 4058 *pos++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW; 4059 } 4060 4061 if (ieee80211_vif_is_mesh(&sdata->vif)) { 4062 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 4063 4064 skb_put(skb, 8); 4065 *pos++ = WLAN_EID_CHAN_SWITCH_PARAM; /* EID */ 4066 *pos++ = 6; /* IE length */ 4067 *pos++ = sdata->u.mesh.mshcfg.dot11MeshTTL; /* Mesh TTL */ 4068 *pos = 0x00; /* Mesh Flag: Tx Restrict, Initiator, Reason */ 4069 *pos |= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR; 4070 *pos++ |= csa_settings->block_tx ? 4071 WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00; 4072 put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos); /* Reason Cd */ 4073 pos += 2; 4074 put_unaligned_le16(ifmsh->pre_value, pos);/* Precedence Value */ 4075 pos += 2; 4076 } 4077 4078 if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_80 || 4079 csa_settings->chandef.width == NL80211_CHAN_WIDTH_80P80 || 4080 csa_settings->chandef.width == NL80211_CHAN_WIDTH_160) { 4081 skb_put(skb, 5); 4082 ieee80211_ie_build_wide_bw_cs(pos, &csa_settings->chandef); 4083 } 4084 4085 ieee80211_tx_skb(sdata, skb); 4086 return 0; 4087 } 4088 4089 bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs) 4090 { 4091 return !(cs == NULL || cs->cipher == 0 || 4092 cs->hdr_len < cs->pn_len + cs->pn_off || 4093 cs->hdr_len <= cs->key_idx_off || 4094 cs->key_idx_shift > 7 || 4095 cs->key_idx_mask == 0); 4096 } 4097 4098 bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n) 4099 { 4100 int i; 4101 4102 /* Ensure we have enough iftype bitmap space for all iftype values */ 4103 WARN_ON((NUM_NL80211_IFTYPES / 8 + 1) > sizeof(cs[0].iftype)); 4104 4105 for (i = 0; i < n; i++) 4106 if (!ieee80211_cs_valid(&cs[i])) 4107 return false; 4108 4109 return true; 4110 } 4111 4112 const struct ieee80211_cipher_scheme * 4113 ieee80211_cs_get(struct ieee80211_local *local, u32 cipher, 4114 enum nl80211_iftype iftype) 4115 { 4116 const struct ieee80211_cipher_scheme *l = local->hw.cipher_schemes; 4117 int n = local->hw.n_cipher_schemes; 4118 int i; 4119 const struct ieee80211_cipher_scheme *cs = NULL; 4120 4121 for (i = 0; i < n; i++) { 4122 if (l[i].cipher == cipher) { 4123 cs = &l[i]; 4124 break; 4125 } 4126 } 4127 4128 if (!cs || !(cs->iftype & BIT(iftype))) 4129 return NULL; 4130 4131 return cs; 4132 } 4133 4134 int ieee80211_cs_headroom(struct ieee80211_local *local, 4135 struct cfg80211_crypto_settings *crypto, 4136 enum nl80211_iftype iftype) 4137 { 4138 const struct ieee80211_cipher_scheme *cs; 4139 int headroom = IEEE80211_ENCRYPT_HEADROOM; 4140 int i; 4141 4142 for (i = 0; i < crypto->n_ciphers_pairwise; i++) { 4143 cs = ieee80211_cs_get(local, crypto->ciphers_pairwise[i], 4144 iftype); 4145 4146 if (cs && headroom < cs->hdr_len) 4147 headroom = cs->hdr_len; 4148 } 4149 4150 cs = ieee80211_cs_get(local, crypto->cipher_group, iftype); 4151 if (cs && headroom < cs->hdr_len) 4152 headroom = cs->hdr_len; 4153 4154 return headroom; 4155 } 4156 4157 static bool 4158 ieee80211_extend_noa_desc(struct ieee80211_noa_data *data, u32 tsf, int i) 4159 { 4160 s32 end = data->desc[i].start + data->desc[i].duration - (tsf + 1); 4161 int skip; 4162 4163 if (end > 0) 4164 return false; 4165 4166 /* One shot NOA */ 4167 if (data->count[i] == 1) 4168 return false; 4169 4170 if (data->desc[i].interval == 0) 4171 return false; 4172 4173 /* End time is in the past, check for repetitions */ 4174 skip = DIV_ROUND_UP(-end, data->desc[i].interval); 4175 if (data->count[i] < 255) { 4176 if (data->count[i] <= skip) { 4177 data->count[i] = 0; 4178 return false; 4179 } 4180 4181 data->count[i] -= skip; 4182 } 4183 4184 data->desc[i].start += skip * data->desc[i].interval; 4185 4186 return true; 4187 } 4188 4189 static bool 4190 ieee80211_extend_absent_time(struct ieee80211_noa_data *data, u32 tsf, 4191 s32 *offset) 4192 { 4193 bool ret = false; 4194 int i; 4195 4196 for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) { 4197 s32 cur; 4198 4199 if (!data->count[i]) 4200 continue; 4201 4202 if (ieee80211_extend_noa_desc(data, tsf + *offset, i)) 4203 ret = true; 4204 4205 cur = data->desc[i].start - tsf; 4206 if (cur > *offset) 4207 continue; 4208 4209 cur = data->desc[i].start + data->desc[i].duration - tsf; 4210 if (cur > *offset) 4211 *offset = cur; 4212 } 4213 4214 return ret; 4215 } 4216 4217 static u32 4218 ieee80211_get_noa_absent_time(struct ieee80211_noa_data *data, u32 tsf) 4219 { 4220 s32 offset = 0; 4221 int tries = 0; 4222 /* 4223 * arbitrary limit, used to avoid infinite loops when combined NoA 4224 * descriptors cover the full time period. 4225 */ 4226 int max_tries = 5; 4227 4228 ieee80211_extend_absent_time(data, tsf, &offset); 4229 do { 4230 if (!ieee80211_extend_absent_time(data, tsf, &offset)) 4231 break; 4232 4233 tries++; 4234 } while (tries < max_tries); 4235 4236 return offset; 4237 } 4238 4239 void ieee80211_update_p2p_noa(struct ieee80211_noa_data *data, u32 tsf) 4240 { 4241 u32 next_offset = BIT(31) - 1; 4242 int i; 4243 4244 data->absent = 0; 4245 data->has_next_tsf = false; 4246 for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) { 4247 s32 start; 4248 4249 if (!data->count[i]) 4250 continue; 4251 4252 ieee80211_extend_noa_desc(data, tsf, i); 4253 start = data->desc[i].start - tsf; 4254 if (start <= 0) 4255 data->absent |= BIT(i); 4256 4257 if (next_offset > start) 4258 next_offset = start; 4259 4260 data->has_next_tsf = true; 4261 } 4262 4263 if (data->absent) 4264 next_offset = ieee80211_get_noa_absent_time(data, tsf); 4265 4266 data->next_tsf = tsf + next_offset; 4267 } 4268 EXPORT_SYMBOL(ieee80211_update_p2p_noa); 4269 4270 int ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr *attr, 4271 struct ieee80211_noa_data *data, u32 tsf) 4272 { 4273 int ret = 0; 4274 int i; 4275 4276 memset(data, 0, sizeof(*data)); 4277 4278 for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) { 4279 const struct ieee80211_p2p_noa_desc *desc = &attr->desc[i]; 4280 4281 if (!desc->count || !desc->duration) 4282 continue; 4283 4284 data->count[i] = desc->count; 4285 data->desc[i].start = le32_to_cpu(desc->start_time); 4286 data->desc[i].duration = le32_to_cpu(desc->duration); 4287 data->desc[i].interval = le32_to_cpu(desc->interval); 4288 4289 if (data->count[i] > 1 && 4290 data->desc[i].interval < data->desc[i].duration) 4291 continue; 4292 4293 ieee80211_extend_noa_desc(data, tsf, i); 4294 ret++; 4295 } 4296 4297 if (ret) 4298 ieee80211_update_p2p_noa(data, tsf); 4299 4300 return ret; 4301 } 4302 EXPORT_SYMBOL(ieee80211_parse_p2p_noa); 4303 4304 void ieee80211_recalc_dtim(struct ieee80211_local *local, 4305 struct ieee80211_sub_if_data *sdata) 4306 { 4307 u64 tsf = drv_get_tsf(local, sdata); 4308 u64 dtim_count = 0; 4309 u16 beacon_int = sdata->vif.bss_conf.beacon_int * 1024; 4310 u8 dtim_period = sdata->vif.bss_conf.dtim_period; 4311 struct ps_data *ps; 4312 u8 bcns_from_dtim; 4313 4314 if (tsf == -1ULL || !beacon_int || !dtim_period) 4315 return; 4316 4317 if (sdata->vif.type == NL80211_IFTYPE_AP || 4318 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) { 4319 if (!sdata->bss) 4320 return; 4321 4322 ps = &sdata->bss->ps; 4323 } else if (ieee80211_vif_is_mesh(&sdata->vif)) { 4324 ps = &sdata->u.mesh.ps; 4325 } else { 4326 return; 4327 } 4328 4329 /* 4330 * actually finds last dtim_count, mac80211 will update in 4331 * __beacon_add_tim(). 4332 * dtim_count = dtim_period - (tsf / bcn_int) % dtim_period 4333 */ 4334 do_div(tsf, beacon_int); 4335 bcns_from_dtim = do_div(tsf, dtim_period); 4336 /* just had a DTIM */ 4337 if (!bcns_from_dtim) 4338 dtim_count = 0; 4339 else 4340 dtim_count = dtim_period - bcns_from_dtim; 4341 4342 ps->dtim_count = dtim_count; 4343 } 4344 4345 static u8 ieee80211_chanctx_radar_detect(struct ieee80211_local *local, 4346 struct ieee80211_chanctx *ctx) 4347 { 4348 struct ieee80211_sub_if_data *sdata; 4349 u8 radar_detect = 0; 4350 4351 lockdep_assert_held(&local->chanctx_mtx); 4352 4353 if (WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)) 4354 return 0; 4355 4356 list_for_each_entry(sdata, &ctx->reserved_vifs, reserved_chanctx_list) 4357 if (sdata->reserved_radar_required) 4358 radar_detect |= BIT(sdata->reserved_chandef.width); 4359 4360 /* 4361 * An in-place reservation context should not have any assigned vifs 4362 * until it replaces the other context. 4363 */ 4364 WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER && 4365 !list_empty(&ctx->assigned_vifs)); 4366 4367 list_for_each_entry(sdata, &ctx->assigned_vifs, assigned_chanctx_list) 4368 if (sdata->radar_required) 4369 radar_detect |= BIT(sdata->vif.bss_conf.chandef.width); 4370 4371 return radar_detect; 4372 } 4373 4374 int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata, 4375 const struct cfg80211_chan_def *chandef, 4376 enum ieee80211_chanctx_mode chanmode, 4377 u8 radar_detect) 4378 { 4379 struct ieee80211_local *local = sdata->local; 4380 struct ieee80211_sub_if_data *sdata_iter; 4381 enum nl80211_iftype iftype = sdata->wdev.iftype; 4382 struct ieee80211_chanctx *ctx; 4383 int total = 1; 4384 struct iface_combination_params params = { 4385 .radar_detect = radar_detect, 4386 }; 4387 4388 lockdep_assert_held(&local->chanctx_mtx); 4389 4390 if (WARN_ON(hweight32(radar_detect) > 1)) 4391 return -EINVAL; 4392 4393 if (WARN_ON(chandef && chanmode == IEEE80211_CHANCTX_SHARED && 4394 !chandef->chan)) 4395 return -EINVAL; 4396 4397 if (WARN_ON(iftype >= NUM_NL80211_IFTYPES)) 4398 return -EINVAL; 4399 4400 if (sdata->vif.type == NL80211_IFTYPE_AP || 4401 sdata->vif.type == NL80211_IFTYPE_MESH_POINT) { 4402 /* 4403 * always passing this is harmless, since it'll be the 4404 * same value that cfg80211 finds if it finds the same 4405 * interface ... and that's always allowed 4406 */ 4407 params.new_beacon_int = sdata->vif.bss_conf.beacon_int; 4408 } 4409 4410 /* Always allow software iftypes */ 4411 if (cfg80211_iftype_allowed(local->hw.wiphy, iftype, 0, 1)) { 4412 if (radar_detect) 4413 return -EINVAL; 4414 return 0; 4415 } 4416 4417 if (chandef) 4418 params.num_different_channels = 1; 4419 4420 if (iftype != NL80211_IFTYPE_UNSPECIFIED) 4421 params.iftype_num[iftype] = 1; 4422 4423 list_for_each_entry(ctx, &local->chanctx_list, list) { 4424 if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED) 4425 continue; 4426 params.radar_detect |= 4427 ieee80211_chanctx_radar_detect(local, ctx); 4428 if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE) { 4429 params.num_different_channels++; 4430 continue; 4431 } 4432 if (chandef && chanmode == IEEE80211_CHANCTX_SHARED && 4433 cfg80211_chandef_compatible(chandef, 4434 &ctx->conf.def)) 4435 continue; 4436 params.num_different_channels++; 4437 } 4438 4439 list_for_each_entry_rcu(sdata_iter, &local->interfaces, list) { 4440 struct wireless_dev *wdev_iter; 4441 4442 wdev_iter = &sdata_iter->wdev; 4443 4444 if (sdata_iter == sdata || 4445 !ieee80211_sdata_running(sdata_iter) || 4446 cfg80211_iftype_allowed(local->hw.wiphy, 4447 wdev_iter->iftype, 0, 1)) 4448 continue; 4449 4450 params.iftype_num[wdev_iter->iftype]++; 4451 total++; 4452 } 4453 4454 if (total == 1 && !params.radar_detect) 4455 return 0; 4456 4457 return cfg80211_check_combinations(local->hw.wiphy, ¶ms); 4458 } 4459 4460 static void 4461 ieee80211_iter_max_chans(const struct ieee80211_iface_combination *c, 4462 void *data) 4463 { 4464 u32 *max_num_different_channels = data; 4465 4466 *max_num_different_channels = max(*max_num_different_channels, 4467 c->num_different_channels); 4468 } 4469 4470 int ieee80211_max_num_channels(struct ieee80211_local *local) 4471 { 4472 struct ieee80211_sub_if_data *sdata; 4473 struct ieee80211_chanctx *ctx; 4474 u32 max_num_different_channels = 1; 4475 int err; 4476 struct iface_combination_params params = {0}; 4477 4478 lockdep_assert_held(&local->chanctx_mtx); 4479 4480 list_for_each_entry(ctx, &local->chanctx_list, list) { 4481 if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED) 4482 continue; 4483 4484 params.num_different_channels++; 4485 4486 params.radar_detect |= 4487 ieee80211_chanctx_radar_detect(local, ctx); 4488 } 4489 4490 list_for_each_entry_rcu(sdata, &local->interfaces, list) 4491 params.iftype_num[sdata->wdev.iftype]++; 4492 4493 err = cfg80211_iter_combinations(local->hw.wiphy, ¶ms, 4494 ieee80211_iter_max_chans, 4495 &max_num_different_channels); 4496 if (err < 0) 4497 return err; 4498 4499 return max_num_different_channels; 4500 } 4501 4502 void ieee80211_add_s1g_capab_ie(struct ieee80211_sub_if_data *sdata, 4503 struct ieee80211_sta_s1g_cap *caps, 4504 struct sk_buff *skb) 4505 { 4506 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 4507 struct ieee80211_s1g_cap s1g_capab; 4508 u8 *pos; 4509 int i; 4510 4511 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION)) 4512 return; 4513 4514 if (!caps->s1g) 4515 return; 4516 4517 memcpy(s1g_capab.capab_info, caps->cap, sizeof(caps->cap)); 4518 memcpy(s1g_capab.supp_mcs_nss, caps->nss_mcs, sizeof(caps->nss_mcs)); 4519 4520 /* override the capability info */ 4521 for (i = 0; i < sizeof(ifmgd->s1g_capa.capab_info); i++) { 4522 u8 mask = ifmgd->s1g_capa_mask.capab_info[i]; 4523 4524 s1g_capab.capab_info[i] &= ~mask; 4525 s1g_capab.capab_info[i] |= ifmgd->s1g_capa.capab_info[i] & mask; 4526 } 4527 4528 /* then MCS and NSS set */ 4529 for (i = 0; i < sizeof(ifmgd->s1g_capa.supp_mcs_nss); i++) { 4530 u8 mask = ifmgd->s1g_capa_mask.supp_mcs_nss[i]; 4531 4532 s1g_capab.supp_mcs_nss[i] &= ~mask; 4533 s1g_capab.supp_mcs_nss[i] |= 4534 ifmgd->s1g_capa.supp_mcs_nss[i] & mask; 4535 } 4536 4537 pos = skb_put(skb, 2 + sizeof(s1g_capab)); 4538 *pos++ = WLAN_EID_S1G_CAPABILITIES; 4539 *pos++ = sizeof(s1g_capab); 4540 4541 memcpy(pos, &s1g_capab, sizeof(s1g_capab)); 4542 } 4543 4544 void ieee80211_add_aid_request_ie(struct ieee80211_sub_if_data *sdata, 4545 struct sk_buff *skb) 4546 { 4547 u8 *pos = skb_put(skb, 3); 4548 4549 *pos++ = WLAN_EID_AID_REQUEST; 4550 *pos++ = 1; 4551 *pos++ = 0; 4552 } 4553 4554 u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo) 4555 { 4556 *buf++ = WLAN_EID_VENDOR_SPECIFIC; 4557 *buf++ = 7; /* len */ 4558 *buf++ = 0x00; /* Microsoft OUI 00:50:F2 */ 4559 *buf++ = 0x50; 4560 *buf++ = 0xf2; 4561 *buf++ = 2; /* WME */ 4562 *buf++ = 0; /* WME info */ 4563 *buf++ = 1; /* WME ver */ 4564 *buf++ = qosinfo; /* U-APSD no in use */ 4565 4566 return buf; 4567 } 4568 4569 void ieee80211_txq_get_depth(struct ieee80211_txq *txq, 4570 unsigned long *frame_cnt, 4571 unsigned long *byte_cnt) 4572 { 4573 struct txq_info *txqi = to_txq_info(txq); 4574 u32 frag_cnt = 0, frag_bytes = 0; 4575 struct sk_buff *skb; 4576 4577 skb_queue_walk(&txqi->frags, skb) { 4578 frag_cnt++; 4579 frag_bytes += skb->len; 4580 } 4581 4582 if (frame_cnt) 4583 *frame_cnt = txqi->tin.backlog_packets + frag_cnt; 4584 4585 if (byte_cnt) 4586 *byte_cnt = txqi->tin.backlog_bytes + frag_bytes; 4587 } 4588 EXPORT_SYMBOL(ieee80211_txq_get_depth); 4589 4590 const u8 ieee80211_ac_to_qos_mask[IEEE80211_NUM_ACS] = { 4591 IEEE80211_WMM_IE_STA_QOSINFO_AC_VO, 4592 IEEE80211_WMM_IE_STA_QOSINFO_AC_VI, 4593 IEEE80211_WMM_IE_STA_QOSINFO_AC_BE, 4594 IEEE80211_WMM_IE_STA_QOSINFO_AC_BK 4595 }; 4596 4597 u16 ieee80211_encode_usf(int listen_interval) 4598 { 4599 static const int listen_int_usf[] = { 1, 10, 1000, 10000 }; 4600 u16 ui, usf = 0; 4601 4602 /* find greatest USF */ 4603 while (usf < IEEE80211_MAX_USF) { 4604 if (listen_interval % listen_int_usf[usf + 1]) 4605 break; 4606 usf += 1; 4607 } 4608 ui = listen_interval / listen_int_usf[usf]; 4609 4610 /* error if there is a remainder. Should've been checked by user */ 4611 WARN_ON_ONCE(ui > IEEE80211_MAX_UI); 4612 listen_interval = FIELD_PREP(LISTEN_INT_USF, usf) | 4613 FIELD_PREP(LISTEN_INT_UI, ui); 4614 4615 return (u16) listen_interval; 4616 } 4617