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