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