1 /* 2 * Copyright 2002-2005, Instant802 Networks, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc. 4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 5 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 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 void *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 BUG_ON(!wiphy); 43 44 local = wiphy_priv(wiphy); 45 return &local->hw; 46 } 47 EXPORT_SYMBOL(wiphy_to_ieee80211_hw); 48 49 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len, 50 enum nl80211_iftype type) 51 { 52 __le16 fc = hdr->frame_control; 53 54 /* drop ACK/CTS frames and incorrect hdr len (ctrl) */ 55 if (len < 16) 56 return NULL; 57 58 if (ieee80211_is_data(fc)) { 59 if (len < 24) /* drop incorrect hdr len (data) */ 60 return NULL; 61 62 if (ieee80211_has_a4(fc)) 63 return NULL; 64 if (ieee80211_has_tods(fc)) 65 return hdr->addr1; 66 if (ieee80211_has_fromds(fc)) 67 return hdr->addr2; 68 69 return hdr->addr3; 70 } 71 72 if (ieee80211_is_mgmt(fc)) { 73 if (len < 24) /* drop incorrect hdr len (mgmt) */ 74 return NULL; 75 return hdr->addr3; 76 } 77 78 if (ieee80211_is_ctl(fc)) { 79 if(ieee80211_is_pspoll(fc)) 80 return hdr->addr1; 81 82 if (ieee80211_is_back_req(fc)) { 83 switch (type) { 84 case NL80211_IFTYPE_STATION: 85 return hdr->addr2; 86 case NL80211_IFTYPE_AP: 87 case NL80211_IFTYPE_AP_VLAN: 88 return hdr->addr1; 89 default: 90 break; /* fall through to the return */ 91 } 92 } 93 } 94 95 return NULL; 96 } 97 98 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx) 99 { 100 struct sk_buff *skb; 101 struct ieee80211_hdr *hdr; 102 103 skb_queue_walk(&tx->skbs, skb) { 104 hdr = (struct ieee80211_hdr *) skb->data; 105 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 106 } 107 } 108 109 int ieee80211_frame_duration(enum ieee80211_band band, size_t len, 110 int rate, int erp, int short_preamble) 111 { 112 int dur; 113 114 /* calculate duration (in microseconds, rounded up to next higher 115 * integer if it includes a fractional microsecond) to send frame of 116 * len bytes (does not include FCS) at the given rate. Duration will 117 * also include SIFS. 118 * 119 * rate is in 100 kbps, so divident is multiplied by 10 in the 120 * DIV_ROUND_UP() operations. 121 */ 122 123 if (band == IEEE80211_BAND_5GHZ || erp) { 124 /* 125 * OFDM: 126 * 127 * N_DBPS = DATARATE x 4 128 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS) 129 * (16 = SIGNAL time, 6 = tail bits) 130 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext 131 * 132 * T_SYM = 4 usec 133 * 802.11a - 17.5.2: aSIFSTime = 16 usec 134 * 802.11g - 19.8.4: aSIFSTime = 10 usec + 135 * signal ext = 6 usec 136 */ 137 dur = 16; /* SIFS + signal ext */ 138 dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */ 139 dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */ 140 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10, 141 4 * rate); /* T_SYM x N_SYM */ 142 } else { 143 /* 144 * 802.11b or 802.11g with 802.11b compatibility: 145 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime + 146 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0. 147 * 148 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4 149 * aSIFSTime = 10 usec 150 * aPreambleLength = 144 usec or 72 usec with short preamble 151 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble 152 */ 153 dur = 10; /* aSIFSTime = 10 usec */ 154 dur += short_preamble ? (72 + 24) : (144 + 48); 155 156 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate); 157 } 158 159 return dur; 160 } 161 162 /* Exported duration function for driver use */ 163 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw, 164 struct ieee80211_vif *vif, 165 enum ieee80211_band band, 166 size_t frame_len, 167 struct ieee80211_rate *rate) 168 { 169 struct ieee80211_sub_if_data *sdata; 170 u16 dur; 171 int erp; 172 bool short_preamble = false; 173 174 erp = 0; 175 if (vif) { 176 sdata = vif_to_sdata(vif); 177 short_preamble = sdata->vif.bss_conf.use_short_preamble; 178 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 179 erp = rate->flags & IEEE80211_RATE_ERP_G; 180 } 181 182 dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp, 183 short_preamble); 184 185 return cpu_to_le16(dur); 186 } 187 EXPORT_SYMBOL(ieee80211_generic_frame_duration); 188 189 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw, 190 struct ieee80211_vif *vif, size_t frame_len, 191 const struct ieee80211_tx_info *frame_txctl) 192 { 193 struct ieee80211_local *local = hw_to_local(hw); 194 struct ieee80211_rate *rate; 195 struct ieee80211_sub_if_data *sdata; 196 bool short_preamble; 197 int erp; 198 u16 dur; 199 struct ieee80211_supported_band *sband; 200 201 sband = local->hw.wiphy->bands[frame_txctl->band]; 202 203 short_preamble = false; 204 205 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx]; 206 207 erp = 0; 208 if (vif) { 209 sdata = vif_to_sdata(vif); 210 short_preamble = sdata->vif.bss_conf.use_short_preamble; 211 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 212 erp = rate->flags & IEEE80211_RATE_ERP_G; 213 } 214 215 /* CTS duration */ 216 dur = ieee80211_frame_duration(sband->band, 10, rate->bitrate, 217 erp, short_preamble); 218 /* Data frame duration */ 219 dur += ieee80211_frame_duration(sband->band, frame_len, rate->bitrate, 220 erp, short_preamble); 221 /* ACK duration */ 222 dur += ieee80211_frame_duration(sband->band, 10, rate->bitrate, 223 erp, short_preamble); 224 225 return cpu_to_le16(dur); 226 } 227 EXPORT_SYMBOL(ieee80211_rts_duration); 228 229 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw, 230 struct ieee80211_vif *vif, 231 size_t frame_len, 232 const struct ieee80211_tx_info *frame_txctl) 233 { 234 struct ieee80211_local *local = hw_to_local(hw); 235 struct ieee80211_rate *rate; 236 struct ieee80211_sub_if_data *sdata; 237 bool short_preamble; 238 int erp; 239 u16 dur; 240 struct ieee80211_supported_band *sband; 241 242 sband = local->hw.wiphy->bands[frame_txctl->band]; 243 244 short_preamble = false; 245 246 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx]; 247 erp = 0; 248 if (vif) { 249 sdata = vif_to_sdata(vif); 250 short_preamble = sdata->vif.bss_conf.use_short_preamble; 251 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 252 erp = rate->flags & IEEE80211_RATE_ERP_G; 253 } 254 255 /* Data frame duration */ 256 dur = ieee80211_frame_duration(sband->band, frame_len, rate->bitrate, 257 erp, short_preamble); 258 if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) { 259 /* ACK duration */ 260 dur += ieee80211_frame_duration(sband->band, 10, rate->bitrate, 261 erp, short_preamble); 262 } 263 264 return cpu_to_le16(dur); 265 } 266 EXPORT_SYMBOL(ieee80211_ctstoself_duration); 267 268 void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue) 269 { 270 struct ieee80211_sub_if_data *sdata; 271 int n_acs = IEEE80211_NUM_ACS; 272 273 if (local->hw.queues < IEEE80211_NUM_ACS) 274 n_acs = 1; 275 276 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 277 int ac; 278 279 if (!sdata->dev) 280 continue; 281 282 if (test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state)) 283 continue; 284 285 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE && 286 local->queue_stop_reasons[sdata->vif.cab_queue] != 0) 287 continue; 288 289 for (ac = 0; ac < n_acs; ac++) { 290 int ac_queue = sdata->vif.hw_queue[ac]; 291 292 if (ac_queue == queue || 293 (sdata->vif.cab_queue == queue && 294 local->queue_stop_reasons[ac_queue] == 0 && 295 skb_queue_empty(&local->pending[ac_queue]))) 296 netif_wake_subqueue(sdata->dev, ac); 297 } 298 } 299 } 300 301 static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue, 302 enum queue_stop_reason reason) 303 { 304 struct ieee80211_local *local = hw_to_local(hw); 305 306 trace_wake_queue(local, queue, reason); 307 308 if (WARN_ON(queue >= hw->queues)) 309 return; 310 311 if (!test_bit(reason, &local->queue_stop_reasons[queue])) 312 return; 313 314 __clear_bit(reason, &local->queue_stop_reasons[queue]); 315 316 if (local->queue_stop_reasons[queue] != 0) 317 /* someone still has this queue stopped */ 318 return; 319 320 if (skb_queue_empty(&local->pending[queue])) { 321 rcu_read_lock(); 322 ieee80211_propagate_queue_wake(local, queue); 323 rcu_read_unlock(); 324 } else 325 tasklet_schedule(&local->tx_pending_tasklet); 326 } 327 328 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue, 329 enum queue_stop_reason reason) 330 { 331 struct ieee80211_local *local = hw_to_local(hw); 332 unsigned long flags; 333 334 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 335 __ieee80211_wake_queue(hw, queue, reason); 336 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 337 } 338 339 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue) 340 { 341 ieee80211_wake_queue_by_reason(hw, queue, 342 IEEE80211_QUEUE_STOP_REASON_DRIVER); 343 } 344 EXPORT_SYMBOL(ieee80211_wake_queue); 345 346 static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue, 347 enum queue_stop_reason reason) 348 { 349 struct ieee80211_local *local = hw_to_local(hw); 350 struct ieee80211_sub_if_data *sdata; 351 int n_acs = IEEE80211_NUM_ACS; 352 353 trace_stop_queue(local, queue, reason); 354 355 if (WARN_ON(queue >= hw->queues)) 356 return; 357 358 if (test_bit(reason, &local->queue_stop_reasons[queue])) 359 return; 360 361 __set_bit(reason, &local->queue_stop_reasons[queue]); 362 363 if (local->hw.queues < IEEE80211_NUM_ACS) 364 n_acs = 1; 365 366 rcu_read_lock(); 367 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 368 int ac; 369 370 if (!sdata->dev) 371 continue; 372 373 for (ac = 0; ac < n_acs; ac++) { 374 if (sdata->vif.hw_queue[ac] == queue || 375 sdata->vif.cab_queue == queue) 376 netif_stop_subqueue(sdata->dev, ac); 377 } 378 } 379 rcu_read_unlock(); 380 } 381 382 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue, 383 enum queue_stop_reason reason) 384 { 385 struct ieee80211_local *local = hw_to_local(hw); 386 unsigned long flags; 387 388 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 389 __ieee80211_stop_queue(hw, queue, reason); 390 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 391 } 392 393 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue) 394 { 395 ieee80211_stop_queue_by_reason(hw, queue, 396 IEEE80211_QUEUE_STOP_REASON_DRIVER); 397 } 398 EXPORT_SYMBOL(ieee80211_stop_queue); 399 400 void ieee80211_add_pending_skb(struct ieee80211_local *local, 401 struct sk_buff *skb) 402 { 403 struct ieee80211_hw *hw = &local->hw; 404 unsigned long flags; 405 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 406 int queue = info->hw_queue; 407 408 if (WARN_ON(!info->control.vif)) { 409 ieee80211_free_txskb(&local->hw, skb); 410 return; 411 } 412 413 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 414 __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 415 __skb_queue_tail(&local->pending[queue], skb); 416 __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 417 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 418 } 419 420 void ieee80211_add_pending_skbs_fn(struct ieee80211_local *local, 421 struct sk_buff_head *skbs, 422 void (*fn)(void *data), void *data) 423 { 424 struct ieee80211_hw *hw = &local->hw; 425 struct sk_buff *skb; 426 unsigned long flags; 427 int queue, i; 428 429 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 430 while ((skb = skb_dequeue(skbs))) { 431 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 432 433 if (WARN_ON(!info->control.vif)) { 434 ieee80211_free_txskb(&local->hw, skb); 435 continue; 436 } 437 438 queue = info->hw_queue; 439 440 __ieee80211_stop_queue(hw, queue, 441 IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 442 443 __skb_queue_tail(&local->pending[queue], skb); 444 } 445 446 if (fn) 447 fn(data); 448 449 for (i = 0; i < hw->queues; i++) 450 __ieee80211_wake_queue(hw, i, 451 IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 452 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 453 } 454 455 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw, 456 enum queue_stop_reason reason) 457 { 458 struct ieee80211_local *local = hw_to_local(hw); 459 unsigned long flags; 460 int i; 461 462 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 463 464 for (i = 0; i < hw->queues; i++) 465 __ieee80211_stop_queue(hw, i, reason); 466 467 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 468 } 469 470 void ieee80211_stop_queues(struct ieee80211_hw *hw) 471 { 472 ieee80211_stop_queues_by_reason(hw, 473 IEEE80211_QUEUE_STOP_REASON_DRIVER); 474 } 475 EXPORT_SYMBOL(ieee80211_stop_queues); 476 477 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue) 478 { 479 struct ieee80211_local *local = hw_to_local(hw); 480 unsigned long flags; 481 int ret; 482 483 if (WARN_ON(queue >= hw->queues)) 484 return true; 485 486 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 487 ret = !!local->queue_stop_reasons[queue]; 488 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 489 return ret; 490 } 491 EXPORT_SYMBOL(ieee80211_queue_stopped); 492 493 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw, 494 enum queue_stop_reason reason) 495 { 496 struct ieee80211_local *local = hw_to_local(hw); 497 unsigned long flags; 498 int i; 499 500 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 501 502 for (i = 0; i < hw->queues; i++) 503 __ieee80211_wake_queue(hw, i, reason); 504 505 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 506 } 507 508 void ieee80211_wake_queues(struct ieee80211_hw *hw) 509 { 510 ieee80211_wake_queues_by_reason(hw, IEEE80211_QUEUE_STOP_REASON_DRIVER); 511 } 512 EXPORT_SYMBOL(ieee80211_wake_queues); 513 514 void ieee80211_iterate_active_interfaces( 515 struct ieee80211_hw *hw, u32 iter_flags, 516 void (*iterator)(void *data, u8 *mac, 517 struct ieee80211_vif *vif), 518 void *data) 519 { 520 struct ieee80211_local *local = hw_to_local(hw); 521 struct ieee80211_sub_if_data *sdata; 522 523 mutex_lock(&local->iflist_mtx); 524 525 list_for_each_entry(sdata, &local->interfaces, list) { 526 switch (sdata->vif.type) { 527 case NL80211_IFTYPE_MONITOR: 528 case NL80211_IFTYPE_AP_VLAN: 529 continue; 530 default: 531 break; 532 } 533 if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) && 534 !(sdata->flags & IEEE80211_SDATA_IN_DRIVER)) 535 continue; 536 if (ieee80211_sdata_running(sdata)) 537 iterator(data, sdata->vif.addr, 538 &sdata->vif); 539 } 540 541 sdata = rcu_dereference_protected(local->monitor_sdata, 542 lockdep_is_held(&local->iflist_mtx)); 543 if (sdata && 544 (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL || 545 sdata->flags & IEEE80211_SDATA_IN_DRIVER)) 546 iterator(data, sdata->vif.addr, &sdata->vif); 547 548 mutex_unlock(&local->iflist_mtx); 549 } 550 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces); 551 552 void ieee80211_iterate_active_interfaces_atomic( 553 struct ieee80211_hw *hw, u32 iter_flags, 554 void (*iterator)(void *data, u8 *mac, 555 struct ieee80211_vif *vif), 556 void *data) 557 { 558 struct ieee80211_local *local = hw_to_local(hw); 559 struct ieee80211_sub_if_data *sdata; 560 561 rcu_read_lock(); 562 563 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 564 switch (sdata->vif.type) { 565 case NL80211_IFTYPE_MONITOR: 566 case NL80211_IFTYPE_AP_VLAN: 567 continue; 568 default: 569 break; 570 } 571 if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) && 572 !(sdata->flags & IEEE80211_SDATA_IN_DRIVER)) 573 continue; 574 if (ieee80211_sdata_running(sdata)) 575 iterator(data, sdata->vif.addr, 576 &sdata->vif); 577 } 578 579 sdata = rcu_dereference(local->monitor_sdata); 580 if (sdata && 581 (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL || 582 sdata->flags & IEEE80211_SDATA_IN_DRIVER)) 583 iterator(data, sdata->vif.addr, &sdata->vif); 584 585 rcu_read_unlock(); 586 } 587 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic); 588 589 /* 590 * Nothing should have been stuffed into the workqueue during 591 * the suspend->resume cycle. If this WARN is seen then there 592 * is a bug with either the driver suspend or something in 593 * mac80211 stuffing into the workqueue which we haven't yet 594 * cleared during mac80211's suspend cycle. 595 */ 596 static bool ieee80211_can_queue_work(struct ieee80211_local *local) 597 { 598 if (WARN(local->suspended && !local->resuming, 599 "queueing ieee80211 work while going to suspend\n")) 600 return false; 601 602 return true; 603 } 604 605 void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work) 606 { 607 struct ieee80211_local *local = hw_to_local(hw); 608 609 if (!ieee80211_can_queue_work(local)) 610 return; 611 612 queue_work(local->workqueue, work); 613 } 614 EXPORT_SYMBOL(ieee80211_queue_work); 615 616 void ieee80211_queue_delayed_work(struct ieee80211_hw *hw, 617 struct delayed_work *dwork, 618 unsigned long delay) 619 { 620 struct ieee80211_local *local = hw_to_local(hw); 621 622 if (!ieee80211_can_queue_work(local)) 623 return; 624 625 queue_delayed_work(local->workqueue, dwork, delay); 626 } 627 EXPORT_SYMBOL(ieee80211_queue_delayed_work); 628 629 u32 ieee802_11_parse_elems_crc(u8 *start, size_t len, 630 struct ieee802_11_elems *elems, 631 u64 filter, u32 crc) 632 { 633 size_t left = len; 634 u8 *pos = start; 635 bool calc_crc = filter != 0; 636 DECLARE_BITMAP(seen_elems, 256); 637 638 bitmap_zero(seen_elems, 256); 639 memset(elems, 0, sizeof(*elems)); 640 elems->ie_start = start; 641 elems->total_len = len; 642 643 while (left >= 2) { 644 u8 id, elen; 645 bool elem_parse_failed; 646 647 id = *pos++; 648 elen = *pos++; 649 left -= 2; 650 651 if (elen > left) { 652 elems->parse_error = true; 653 break; 654 } 655 656 switch (id) { 657 case WLAN_EID_SSID: 658 case WLAN_EID_SUPP_RATES: 659 case WLAN_EID_FH_PARAMS: 660 case WLAN_EID_DS_PARAMS: 661 case WLAN_EID_CF_PARAMS: 662 case WLAN_EID_TIM: 663 case WLAN_EID_IBSS_PARAMS: 664 case WLAN_EID_CHALLENGE: 665 case WLAN_EID_RSN: 666 case WLAN_EID_ERP_INFO: 667 case WLAN_EID_EXT_SUPP_RATES: 668 case WLAN_EID_HT_CAPABILITY: 669 case WLAN_EID_HT_OPERATION: 670 case WLAN_EID_VHT_CAPABILITY: 671 case WLAN_EID_VHT_OPERATION: 672 case WLAN_EID_MESH_ID: 673 case WLAN_EID_MESH_CONFIG: 674 case WLAN_EID_PEER_MGMT: 675 case WLAN_EID_PREQ: 676 case WLAN_EID_PREP: 677 case WLAN_EID_PERR: 678 case WLAN_EID_RANN: 679 case WLAN_EID_CHANNEL_SWITCH: 680 case WLAN_EID_EXT_CHANSWITCH_ANN: 681 case WLAN_EID_COUNTRY: 682 case WLAN_EID_PWR_CONSTRAINT: 683 case WLAN_EID_TIMEOUT_INTERVAL: 684 if (test_bit(id, seen_elems)) { 685 elems->parse_error = true; 686 left -= elen; 687 pos += elen; 688 continue; 689 } 690 break; 691 } 692 693 if (calc_crc && id < 64 && (filter & (1ULL << id))) 694 crc = crc32_be(crc, pos - 2, elen + 2); 695 696 elem_parse_failed = false; 697 698 switch (id) { 699 case WLAN_EID_SSID: 700 elems->ssid = pos; 701 elems->ssid_len = elen; 702 break; 703 case WLAN_EID_SUPP_RATES: 704 elems->supp_rates = pos; 705 elems->supp_rates_len = elen; 706 break; 707 case WLAN_EID_FH_PARAMS: 708 elems->fh_params = pos; 709 elems->fh_params_len = elen; 710 break; 711 case WLAN_EID_DS_PARAMS: 712 elems->ds_params = pos; 713 elems->ds_params_len = elen; 714 break; 715 case WLAN_EID_CF_PARAMS: 716 elems->cf_params = pos; 717 elems->cf_params_len = elen; 718 break; 719 case WLAN_EID_TIM: 720 if (elen >= sizeof(struct ieee80211_tim_ie)) { 721 elems->tim = (void *)pos; 722 elems->tim_len = elen; 723 } else 724 elem_parse_failed = true; 725 break; 726 case WLAN_EID_IBSS_PARAMS: 727 elems->ibss_params = pos; 728 elems->ibss_params_len = elen; 729 break; 730 case WLAN_EID_CHALLENGE: 731 elems->challenge = pos; 732 elems->challenge_len = elen; 733 break; 734 case WLAN_EID_VENDOR_SPECIFIC: 735 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 && 736 pos[2] == 0xf2) { 737 /* Microsoft OUI (00:50:F2) */ 738 739 if (calc_crc) 740 crc = crc32_be(crc, pos - 2, elen + 2); 741 742 if (pos[3] == 1) { 743 /* OUI Type 1 - WPA IE */ 744 elems->wpa = pos; 745 elems->wpa_len = elen; 746 } else if (elen >= 5 && pos[3] == 2) { 747 /* OUI Type 2 - WMM IE */ 748 if (pos[4] == 0) { 749 elems->wmm_info = pos; 750 elems->wmm_info_len = elen; 751 } else if (pos[4] == 1) { 752 elems->wmm_param = pos; 753 elems->wmm_param_len = elen; 754 } 755 } 756 } 757 break; 758 case WLAN_EID_RSN: 759 elems->rsn = pos; 760 elems->rsn_len = elen; 761 break; 762 case WLAN_EID_ERP_INFO: 763 elems->erp_info = pos; 764 elems->erp_info_len = elen; 765 break; 766 case WLAN_EID_EXT_SUPP_RATES: 767 elems->ext_supp_rates = pos; 768 elems->ext_supp_rates_len = elen; 769 break; 770 case WLAN_EID_HT_CAPABILITY: 771 if (elen >= sizeof(struct ieee80211_ht_cap)) 772 elems->ht_cap_elem = (void *)pos; 773 else 774 elem_parse_failed = true; 775 break; 776 case WLAN_EID_HT_OPERATION: 777 if (elen >= sizeof(struct ieee80211_ht_operation)) 778 elems->ht_operation = (void *)pos; 779 else 780 elem_parse_failed = true; 781 break; 782 case WLAN_EID_VHT_CAPABILITY: 783 if (elen >= sizeof(struct ieee80211_vht_cap)) 784 elems->vht_cap_elem = (void *)pos; 785 else 786 elem_parse_failed = true; 787 break; 788 case WLAN_EID_VHT_OPERATION: 789 if (elen >= sizeof(struct ieee80211_vht_operation)) 790 elems->vht_operation = (void *)pos; 791 else 792 elem_parse_failed = true; 793 break; 794 case WLAN_EID_MESH_ID: 795 elems->mesh_id = pos; 796 elems->mesh_id_len = elen; 797 break; 798 case WLAN_EID_MESH_CONFIG: 799 if (elen >= sizeof(struct ieee80211_meshconf_ie)) 800 elems->mesh_config = (void *)pos; 801 else 802 elem_parse_failed = true; 803 break; 804 case WLAN_EID_PEER_MGMT: 805 elems->peering = pos; 806 elems->peering_len = elen; 807 break; 808 case WLAN_EID_PREQ: 809 elems->preq = pos; 810 elems->preq_len = elen; 811 break; 812 case WLAN_EID_PREP: 813 elems->prep = pos; 814 elems->prep_len = elen; 815 break; 816 case WLAN_EID_PERR: 817 elems->perr = pos; 818 elems->perr_len = elen; 819 break; 820 case WLAN_EID_RANN: 821 if (elen >= sizeof(struct ieee80211_rann_ie)) 822 elems->rann = (void *)pos; 823 else 824 elem_parse_failed = true; 825 break; 826 case WLAN_EID_CHANNEL_SWITCH: 827 if (elen != sizeof(struct ieee80211_channel_sw_ie)) { 828 elem_parse_failed = true; 829 break; 830 } 831 elems->ch_switch_ie = (void *)pos; 832 break; 833 case WLAN_EID_QUIET: 834 if (!elems->quiet_elem) { 835 elems->quiet_elem = pos; 836 elems->quiet_elem_len = elen; 837 } 838 elems->num_of_quiet_elem++; 839 break; 840 case WLAN_EID_COUNTRY: 841 elems->country_elem = pos; 842 elems->country_elem_len = elen; 843 break; 844 case WLAN_EID_PWR_CONSTRAINT: 845 if (elen != 1) { 846 elem_parse_failed = true; 847 break; 848 } 849 elems->pwr_constr_elem = pos; 850 break; 851 case WLAN_EID_TIMEOUT_INTERVAL: 852 elems->timeout_int = pos; 853 elems->timeout_int_len = elen; 854 break; 855 default: 856 break; 857 } 858 859 if (elem_parse_failed) 860 elems->parse_error = true; 861 else 862 __set_bit(id, seen_elems); 863 864 left -= elen; 865 pos += elen; 866 } 867 868 if (left != 0) 869 elems->parse_error = true; 870 871 return crc; 872 } 873 874 void ieee802_11_parse_elems(u8 *start, size_t len, 875 struct ieee802_11_elems *elems) 876 { 877 ieee802_11_parse_elems_crc(start, len, elems, 0, 0); 878 } 879 880 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata, 881 bool bss_notify) 882 { 883 struct ieee80211_local *local = sdata->local; 884 struct ieee80211_tx_queue_params qparam; 885 struct ieee80211_chanctx_conf *chanctx_conf; 886 int ac; 887 bool use_11b, enable_qos; 888 int aCWmin, aCWmax; 889 890 if (!local->ops->conf_tx) 891 return; 892 893 if (local->hw.queues < IEEE80211_NUM_ACS) 894 return; 895 896 memset(&qparam, 0, sizeof(qparam)); 897 898 rcu_read_lock(); 899 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 900 use_11b = (chanctx_conf && 901 chanctx_conf->def.chan->band == IEEE80211_BAND_2GHZ) && 902 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE); 903 rcu_read_unlock(); 904 905 /* 906 * By default disable QoS in STA mode for old access points, which do 907 * not support 802.11e. New APs will provide proper queue parameters, 908 * that we will configure later. 909 */ 910 enable_qos = (sdata->vif.type != NL80211_IFTYPE_STATION); 911 912 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 913 /* Set defaults according to 802.11-2007 Table 7-37 */ 914 aCWmax = 1023; 915 if (use_11b) 916 aCWmin = 31; 917 else 918 aCWmin = 15; 919 920 if (enable_qos) { 921 switch (ac) { 922 case IEEE80211_AC_BK: 923 qparam.cw_max = aCWmax; 924 qparam.cw_min = aCWmin; 925 qparam.txop = 0; 926 qparam.aifs = 7; 927 break; 928 /* never happens but let's not leave undefined */ 929 default: 930 case IEEE80211_AC_BE: 931 qparam.cw_max = aCWmax; 932 qparam.cw_min = aCWmin; 933 qparam.txop = 0; 934 qparam.aifs = 3; 935 break; 936 case IEEE80211_AC_VI: 937 qparam.cw_max = aCWmin; 938 qparam.cw_min = (aCWmin + 1) / 2 - 1; 939 if (use_11b) 940 qparam.txop = 6016/32; 941 else 942 qparam.txop = 3008/32; 943 qparam.aifs = 2; 944 break; 945 case IEEE80211_AC_VO: 946 qparam.cw_max = (aCWmin + 1) / 2 - 1; 947 qparam.cw_min = (aCWmin + 1) / 4 - 1; 948 if (use_11b) 949 qparam.txop = 3264/32; 950 else 951 qparam.txop = 1504/32; 952 qparam.aifs = 2; 953 break; 954 } 955 } else { 956 /* Confiure old 802.11b/g medium access rules. */ 957 qparam.cw_max = aCWmax; 958 qparam.cw_min = aCWmin; 959 qparam.txop = 0; 960 qparam.aifs = 2; 961 } 962 963 qparam.uapsd = false; 964 965 sdata->tx_conf[ac] = qparam; 966 drv_conf_tx(local, sdata, ac, &qparam); 967 } 968 969 if (sdata->vif.type != NL80211_IFTYPE_MONITOR && 970 sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) { 971 sdata->vif.bss_conf.qos = enable_qos; 972 if (bss_notify) 973 ieee80211_bss_info_change_notify(sdata, 974 BSS_CHANGED_QOS); 975 } 976 } 977 978 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata, 979 const size_t supp_rates_len, 980 const u8 *supp_rates) 981 { 982 struct ieee80211_chanctx_conf *chanctx_conf; 983 int i, have_higher_than_11mbit = 0; 984 985 /* cf. IEEE 802.11 9.2.12 */ 986 for (i = 0; i < supp_rates_len; i++) 987 if ((supp_rates[i] & 0x7f) * 5 > 110) 988 have_higher_than_11mbit = 1; 989 990 rcu_read_lock(); 991 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 992 993 if (chanctx_conf && 994 chanctx_conf->def.chan->band == IEEE80211_BAND_2GHZ && 995 have_higher_than_11mbit) 996 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE; 997 else 998 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE; 999 rcu_read_unlock(); 1000 1001 ieee80211_set_wmm_default(sdata, true); 1002 } 1003 1004 u32 ieee80211_mandatory_rates(struct ieee80211_local *local, 1005 enum ieee80211_band band) 1006 { 1007 struct ieee80211_supported_band *sband; 1008 struct ieee80211_rate *bitrates; 1009 u32 mandatory_rates; 1010 enum ieee80211_rate_flags mandatory_flag; 1011 int i; 1012 1013 sband = local->hw.wiphy->bands[band]; 1014 if (WARN_ON(!sband)) 1015 return 1; 1016 1017 if (band == IEEE80211_BAND_2GHZ) 1018 mandatory_flag = IEEE80211_RATE_MANDATORY_B; 1019 else 1020 mandatory_flag = IEEE80211_RATE_MANDATORY_A; 1021 1022 bitrates = sband->bitrates; 1023 mandatory_rates = 0; 1024 for (i = 0; i < sband->n_bitrates; i++) 1025 if (bitrates[i].flags & mandatory_flag) 1026 mandatory_rates |= BIT(i); 1027 return mandatory_rates; 1028 } 1029 1030 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata, 1031 u16 transaction, u16 auth_alg, u16 status, 1032 u8 *extra, size_t extra_len, const u8 *da, 1033 const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx) 1034 { 1035 struct ieee80211_local *local = sdata->local; 1036 struct sk_buff *skb; 1037 struct ieee80211_mgmt *mgmt; 1038 int err; 1039 1040 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 1041 sizeof(*mgmt) + 6 + extra_len); 1042 if (!skb) 1043 return; 1044 1045 skb_reserve(skb, local->hw.extra_tx_headroom); 1046 1047 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6); 1048 memset(mgmt, 0, 24 + 6); 1049 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 1050 IEEE80211_STYPE_AUTH); 1051 memcpy(mgmt->da, da, ETH_ALEN); 1052 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 1053 memcpy(mgmt->bssid, bssid, ETH_ALEN); 1054 mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg); 1055 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction); 1056 mgmt->u.auth.status_code = cpu_to_le16(status); 1057 if (extra) 1058 memcpy(skb_put(skb, extra_len), extra, extra_len); 1059 1060 if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) { 1061 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 1062 err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx); 1063 WARN_ON(err); 1064 } 1065 1066 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 1067 ieee80211_tx_skb(sdata, skb); 1068 } 1069 1070 void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata, 1071 const u8 *bssid, u16 stype, u16 reason, 1072 bool send_frame, u8 *frame_buf) 1073 { 1074 struct ieee80211_local *local = sdata->local; 1075 struct sk_buff *skb; 1076 struct ieee80211_mgmt *mgmt = (void *)frame_buf; 1077 1078 /* build frame */ 1079 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype); 1080 mgmt->duration = 0; /* initialize only */ 1081 mgmt->seq_ctrl = 0; /* initialize only */ 1082 memcpy(mgmt->da, bssid, ETH_ALEN); 1083 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 1084 memcpy(mgmt->bssid, bssid, ETH_ALEN); 1085 /* u.deauth.reason_code == u.disassoc.reason_code */ 1086 mgmt->u.deauth.reason_code = cpu_to_le16(reason); 1087 1088 if (send_frame) { 1089 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 1090 IEEE80211_DEAUTH_FRAME_LEN); 1091 if (!skb) 1092 return; 1093 1094 skb_reserve(skb, local->hw.extra_tx_headroom); 1095 1096 /* copy in frame */ 1097 memcpy(skb_put(skb, IEEE80211_DEAUTH_FRAME_LEN), 1098 mgmt, IEEE80211_DEAUTH_FRAME_LEN); 1099 1100 if (sdata->vif.type != NL80211_IFTYPE_STATION || 1101 !(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED)) 1102 IEEE80211_SKB_CB(skb)->flags |= 1103 IEEE80211_TX_INTFL_DONT_ENCRYPT; 1104 1105 ieee80211_tx_skb(sdata, skb); 1106 } 1107 } 1108 1109 int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer, 1110 size_t buffer_len, const u8 *ie, size_t ie_len, 1111 enum ieee80211_band band, u32 rate_mask, 1112 u8 channel) 1113 { 1114 struct ieee80211_supported_band *sband; 1115 u8 *pos = buffer, *end = buffer + buffer_len; 1116 size_t offset = 0, noffset; 1117 int supp_rates_len, i; 1118 u8 rates[32]; 1119 int num_rates; 1120 int ext_rates_len; 1121 1122 sband = local->hw.wiphy->bands[band]; 1123 if (WARN_ON_ONCE(!sband)) 1124 return 0; 1125 1126 num_rates = 0; 1127 for (i = 0; i < sband->n_bitrates; i++) { 1128 if ((BIT(i) & rate_mask) == 0) 1129 continue; /* skip rate */ 1130 rates[num_rates++] = (u8) (sband->bitrates[i].bitrate / 5); 1131 } 1132 1133 supp_rates_len = min_t(int, num_rates, 8); 1134 1135 if (end - pos < 2 + supp_rates_len) 1136 goto out_err; 1137 *pos++ = WLAN_EID_SUPP_RATES; 1138 *pos++ = supp_rates_len; 1139 memcpy(pos, rates, supp_rates_len); 1140 pos += supp_rates_len; 1141 1142 /* insert "request information" if in custom IEs */ 1143 if (ie && ie_len) { 1144 static const u8 before_extrates[] = { 1145 WLAN_EID_SSID, 1146 WLAN_EID_SUPP_RATES, 1147 WLAN_EID_REQUEST, 1148 }; 1149 noffset = ieee80211_ie_split(ie, ie_len, 1150 before_extrates, 1151 ARRAY_SIZE(before_extrates), 1152 offset); 1153 if (end - pos < noffset - offset) 1154 goto out_err; 1155 memcpy(pos, ie + offset, noffset - offset); 1156 pos += noffset - offset; 1157 offset = noffset; 1158 } 1159 1160 ext_rates_len = num_rates - supp_rates_len; 1161 if (ext_rates_len > 0) { 1162 if (end - pos < 2 + ext_rates_len) 1163 goto out_err; 1164 *pos++ = WLAN_EID_EXT_SUPP_RATES; 1165 *pos++ = ext_rates_len; 1166 memcpy(pos, rates + supp_rates_len, ext_rates_len); 1167 pos += ext_rates_len; 1168 } 1169 1170 if (channel && sband->band == IEEE80211_BAND_2GHZ) { 1171 if (end - pos < 3) 1172 goto out_err; 1173 *pos++ = WLAN_EID_DS_PARAMS; 1174 *pos++ = 1; 1175 *pos++ = channel; 1176 } 1177 1178 /* insert custom IEs that go before HT */ 1179 if (ie && ie_len) { 1180 static const u8 before_ht[] = { 1181 WLAN_EID_SSID, 1182 WLAN_EID_SUPP_RATES, 1183 WLAN_EID_REQUEST, 1184 WLAN_EID_EXT_SUPP_RATES, 1185 WLAN_EID_DS_PARAMS, 1186 WLAN_EID_SUPPORTED_REGULATORY_CLASSES, 1187 }; 1188 noffset = ieee80211_ie_split(ie, ie_len, 1189 before_ht, ARRAY_SIZE(before_ht), 1190 offset); 1191 if (end - pos < noffset - offset) 1192 goto out_err; 1193 memcpy(pos, ie + offset, noffset - offset); 1194 pos += noffset - offset; 1195 offset = noffset; 1196 } 1197 1198 if (sband->ht_cap.ht_supported) { 1199 if (end - pos < 2 + sizeof(struct ieee80211_ht_cap)) 1200 goto out_err; 1201 pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap, 1202 sband->ht_cap.cap); 1203 } 1204 1205 /* 1206 * If adding more here, adjust code in main.c 1207 * that calculates local->scan_ies_len. 1208 */ 1209 1210 /* add any remaining custom IEs */ 1211 if (ie && ie_len) { 1212 noffset = ie_len; 1213 if (end - pos < noffset - offset) 1214 goto out_err; 1215 memcpy(pos, ie + offset, noffset - offset); 1216 pos += noffset - offset; 1217 } 1218 1219 if (sband->vht_cap.vht_supported) { 1220 if (end - pos < 2 + sizeof(struct ieee80211_vht_cap)) 1221 goto out_err; 1222 pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap, 1223 sband->vht_cap.cap); 1224 } 1225 1226 return pos - buffer; 1227 out_err: 1228 WARN_ONCE(1, "not enough space for preq IEs\n"); 1229 return pos - buffer; 1230 } 1231 1232 struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata, 1233 u8 *dst, u32 ratemask, 1234 struct ieee80211_channel *chan, 1235 const u8 *ssid, size_t ssid_len, 1236 const u8 *ie, size_t ie_len, 1237 bool directed) 1238 { 1239 struct ieee80211_local *local = sdata->local; 1240 struct sk_buff *skb; 1241 struct ieee80211_mgmt *mgmt; 1242 u8 chan_no; 1243 int ies_len; 1244 1245 /* 1246 * Do not send DS Channel parameter for directed probe requests 1247 * in order to maximize the chance that we get a response. Some 1248 * badly-behaved APs don't respond when this parameter is included. 1249 */ 1250 if (directed) 1251 chan_no = 0; 1252 else 1253 chan_no = ieee80211_frequency_to_channel(chan->center_freq); 1254 1255 skb = ieee80211_probereq_get(&local->hw, &sdata->vif, 1256 ssid, ssid_len, 100 + ie_len); 1257 if (!skb) 1258 return NULL; 1259 1260 ies_len = ieee80211_build_preq_ies(local, skb_tail_pointer(skb), 1261 skb_tailroom(skb), 1262 ie, ie_len, chan->band, 1263 ratemask, chan_no); 1264 skb_put(skb, ies_len); 1265 1266 if (dst) { 1267 mgmt = (struct ieee80211_mgmt *) skb->data; 1268 memcpy(mgmt->da, dst, ETH_ALEN); 1269 memcpy(mgmt->bssid, dst, ETH_ALEN); 1270 } 1271 1272 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 1273 1274 return skb; 1275 } 1276 1277 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst, 1278 const u8 *ssid, size_t ssid_len, 1279 const u8 *ie, size_t ie_len, 1280 u32 ratemask, bool directed, bool no_cck, 1281 struct ieee80211_channel *channel, bool scan) 1282 { 1283 struct sk_buff *skb; 1284 1285 skb = ieee80211_build_probe_req(sdata, dst, ratemask, channel, 1286 ssid, ssid_len, 1287 ie, ie_len, directed); 1288 if (skb) { 1289 if (no_cck) 1290 IEEE80211_SKB_CB(skb)->flags |= 1291 IEEE80211_TX_CTL_NO_CCK_RATE; 1292 if (scan) 1293 ieee80211_tx_skb_tid_band(sdata, skb, 7, channel->band); 1294 else 1295 ieee80211_tx_skb(sdata, skb); 1296 } 1297 } 1298 1299 u32 ieee80211_sta_get_rates(struct ieee80211_local *local, 1300 struct ieee802_11_elems *elems, 1301 enum ieee80211_band band, u32 *basic_rates) 1302 { 1303 struct ieee80211_supported_band *sband; 1304 struct ieee80211_rate *bitrates; 1305 size_t num_rates; 1306 u32 supp_rates; 1307 int i, j; 1308 sband = local->hw.wiphy->bands[band]; 1309 1310 if (WARN_ON(!sband)) 1311 return 1; 1312 1313 bitrates = sband->bitrates; 1314 num_rates = sband->n_bitrates; 1315 supp_rates = 0; 1316 for (i = 0; i < elems->supp_rates_len + 1317 elems->ext_supp_rates_len; i++) { 1318 u8 rate = 0; 1319 int own_rate; 1320 bool is_basic; 1321 if (i < elems->supp_rates_len) 1322 rate = elems->supp_rates[i]; 1323 else if (elems->ext_supp_rates) 1324 rate = elems->ext_supp_rates 1325 [i - elems->supp_rates_len]; 1326 own_rate = 5 * (rate & 0x7f); 1327 is_basic = !!(rate & 0x80); 1328 1329 if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY) 1330 continue; 1331 1332 for (j = 0; j < num_rates; j++) { 1333 if (bitrates[j].bitrate == own_rate) { 1334 supp_rates |= BIT(j); 1335 if (basic_rates && is_basic) 1336 *basic_rates |= BIT(j); 1337 } 1338 } 1339 } 1340 return supp_rates; 1341 } 1342 1343 void ieee80211_stop_device(struct ieee80211_local *local) 1344 { 1345 ieee80211_led_radio(local, false); 1346 ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO); 1347 1348 cancel_work_sync(&local->reconfig_filter); 1349 1350 flush_workqueue(local->workqueue); 1351 drv_stop(local); 1352 } 1353 1354 int ieee80211_reconfig(struct ieee80211_local *local) 1355 { 1356 struct ieee80211_hw *hw = &local->hw; 1357 struct ieee80211_sub_if_data *sdata; 1358 struct ieee80211_chanctx *ctx; 1359 struct sta_info *sta; 1360 int res, i; 1361 1362 #ifdef CONFIG_PM 1363 if (local->suspended) 1364 local->resuming = true; 1365 1366 if (local->wowlan) { 1367 local->wowlan = false; 1368 res = drv_resume(local); 1369 if (res < 0) { 1370 local->resuming = false; 1371 return res; 1372 } 1373 if (res == 0) 1374 goto wake_up; 1375 WARN_ON(res > 1); 1376 /* 1377 * res is 1, which means the driver requested 1378 * to go through a regular reset on wakeup. 1379 */ 1380 } 1381 #endif 1382 /* everything else happens only if HW was up & running */ 1383 if (!local->open_count) 1384 goto wake_up; 1385 1386 /* 1387 * Upon resume hardware can sometimes be goofy due to 1388 * various platform / driver / bus issues, so restarting 1389 * the device may at times not work immediately. Propagate 1390 * the error. 1391 */ 1392 res = drv_start(local); 1393 if (res) { 1394 WARN(local->suspended, "Hardware became unavailable " 1395 "upon resume. This could be a software issue " 1396 "prior to suspend or a hardware issue.\n"); 1397 return res; 1398 } 1399 1400 /* setup fragmentation threshold */ 1401 drv_set_frag_threshold(local, hw->wiphy->frag_threshold); 1402 1403 /* setup RTS threshold */ 1404 drv_set_rts_threshold(local, hw->wiphy->rts_threshold); 1405 1406 /* reset coverage class */ 1407 drv_set_coverage_class(local, hw->wiphy->coverage_class); 1408 1409 ieee80211_led_radio(local, true); 1410 ieee80211_mod_tpt_led_trig(local, 1411 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0); 1412 1413 /* add interfaces */ 1414 sdata = rtnl_dereference(local->monitor_sdata); 1415 if (sdata) { 1416 res = drv_add_interface(local, sdata); 1417 if (WARN_ON(res)) { 1418 rcu_assign_pointer(local->monitor_sdata, NULL); 1419 synchronize_net(); 1420 kfree(sdata); 1421 } 1422 } 1423 1424 list_for_each_entry(sdata, &local->interfaces, list) { 1425 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 1426 sdata->vif.type != NL80211_IFTYPE_MONITOR && 1427 ieee80211_sdata_running(sdata)) 1428 res = drv_add_interface(local, sdata); 1429 } 1430 1431 /* add channel contexts */ 1432 if (local->use_chanctx) { 1433 mutex_lock(&local->chanctx_mtx); 1434 list_for_each_entry(ctx, &local->chanctx_list, list) 1435 WARN_ON(drv_add_chanctx(local, ctx)); 1436 mutex_unlock(&local->chanctx_mtx); 1437 } 1438 1439 list_for_each_entry(sdata, &local->interfaces, list) { 1440 struct ieee80211_chanctx_conf *ctx_conf; 1441 1442 if (!ieee80211_sdata_running(sdata)) 1443 continue; 1444 1445 mutex_lock(&local->chanctx_mtx); 1446 ctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf, 1447 lockdep_is_held(&local->chanctx_mtx)); 1448 if (ctx_conf) { 1449 ctx = container_of(ctx_conf, struct ieee80211_chanctx, 1450 conf); 1451 drv_assign_vif_chanctx(local, sdata, ctx); 1452 } 1453 mutex_unlock(&local->chanctx_mtx); 1454 } 1455 1456 sdata = rtnl_dereference(local->monitor_sdata); 1457 if (sdata && local->use_chanctx && ieee80211_sdata_running(sdata)) { 1458 struct ieee80211_chanctx_conf *ctx_conf; 1459 1460 mutex_lock(&local->chanctx_mtx); 1461 ctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf, 1462 lockdep_is_held(&local->chanctx_mtx)); 1463 if (ctx_conf) { 1464 ctx = container_of(ctx_conf, struct ieee80211_chanctx, 1465 conf); 1466 drv_assign_vif_chanctx(local, sdata, ctx); 1467 } 1468 mutex_unlock(&local->chanctx_mtx); 1469 } 1470 1471 /* add STAs back */ 1472 mutex_lock(&local->sta_mtx); 1473 list_for_each_entry(sta, &local->sta_list, list) { 1474 enum ieee80211_sta_state state; 1475 1476 if (!sta->uploaded) 1477 continue; 1478 1479 /* AP-mode stations will be added later */ 1480 if (sta->sdata->vif.type == NL80211_IFTYPE_AP) 1481 continue; 1482 1483 for (state = IEEE80211_STA_NOTEXIST; 1484 state < sta->sta_state; state++) 1485 WARN_ON(drv_sta_state(local, sta->sdata, sta, state, 1486 state + 1)); 1487 } 1488 mutex_unlock(&local->sta_mtx); 1489 1490 /* reconfigure tx conf */ 1491 if (hw->queues >= IEEE80211_NUM_ACS) { 1492 list_for_each_entry(sdata, &local->interfaces, list) { 1493 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN || 1494 sdata->vif.type == NL80211_IFTYPE_MONITOR || 1495 !ieee80211_sdata_running(sdata)) 1496 continue; 1497 1498 for (i = 0; i < IEEE80211_NUM_ACS; i++) 1499 drv_conf_tx(local, sdata, i, 1500 &sdata->tx_conf[i]); 1501 } 1502 } 1503 1504 /* reconfigure hardware */ 1505 ieee80211_hw_config(local, ~0); 1506 1507 ieee80211_configure_filter(local); 1508 1509 /* Finally also reconfigure all the BSS information */ 1510 list_for_each_entry(sdata, &local->interfaces, list) { 1511 u32 changed; 1512 1513 if (!ieee80211_sdata_running(sdata)) 1514 continue; 1515 1516 /* common change flags for all interface types */ 1517 changed = BSS_CHANGED_ERP_CTS_PROT | 1518 BSS_CHANGED_ERP_PREAMBLE | 1519 BSS_CHANGED_ERP_SLOT | 1520 BSS_CHANGED_HT | 1521 BSS_CHANGED_BASIC_RATES | 1522 BSS_CHANGED_BEACON_INT | 1523 BSS_CHANGED_BSSID | 1524 BSS_CHANGED_CQM | 1525 BSS_CHANGED_QOS | 1526 BSS_CHANGED_IDLE | 1527 BSS_CHANGED_TXPOWER; 1528 1529 switch (sdata->vif.type) { 1530 case NL80211_IFTYPE_STATION: 1531 changed |= BSS_CHANGED_ASSOC | 1532 BSS_CHANGED_ARP_FILTER | 1533 BSS_CHANGED_PS; 1534 mutex_lock(&sdata->u.mgd.mtx); 1535 ieee80211_bss_info_change_notify(sdata, changed); 1536 mutex_unlock(&sdata->u.mgd.mtx); 1537 break; 1538 case NL80211_IFTYPE_ADHOC: 1539 changed |= BSS_CHANGED_IBSS; 1540 /* fall through */ 1541 case NL80211_IFTYPE_AP: 1542 changed |= BSS_CHANGED_SSID | BSS_CHANGED_P2P_PS; 1543 1544 if (sdata->vif.type == NL80211_IFTYPE_AP) { 1545 changed |= BSS_CHANGED_AP_PROBE_RESP; 1546 1547 if (rcu_access_pointer(sdata->u.ap.beacon)) 1548 drv_start_ap(local, sdata); 1549 } 1550 1551 /* fall through */ 1552 case NL80211_IFTYPE_MESH_POINT: 1553 changed |= BSS_CHANGED_BEACON | 1554 BSS_CHANGED_BEACON_ENABLED; 1555 ieee80211_bss_info_change_notify(sdata, changed); 1556 break; 1557 case NL80211_IFTYPE_WDS: 1558 break; 1559 case NL80211_IFTYPE_AP_VLAN: 1560 case NL80211_IFTYPE_MONITOR: 1561 /* ignore virtual */ 1562 break; 1563 case NL80211_IFTYPE_P2P_DEVICE: 1564 changed = BSS_CHANGED_IDLE; 1565 break; 1566 case NL80211_IFTYPE_UNSPECIFIED: 1567 case NUM_NL80211_IFTYPES: 1568 case NL80211_IFTYPE_P2P_CLIENT: 1569 case NL80211_IFTYPE_P2P_GO: 1570 WARN_ON(1); 1571 break; 1572 } 1573 } 1574 1575 ieee80211_recalc_ps(local, -1); 1576 1577 /* 1578 * The sta might be in psm against the ap (e.g. because 1579 * this was the state before a hw restart), so we 1580 * explicitly send a null packet in order to make sure 1581 * it'll sync against the ap (and get out of psm). 1582 */ 1583 if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) { 1584 list_for_each_entry(sdata, &local->interfaces, list) { 1585 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1586 continue; 1587 if (!sdata->u.mgd.associated) 1588 continue; 1589 1590 ieee80211_send_nullfunc(local, sdata, 0); 1591 } 1592 } 1593 1594 /* APs are now beaconing, add back stations */ 1595 mutex_lock(&local->sta_mtx); 1596 list_for_each_entry(sta, &local->sta_list, list) { 1597 enum ieee80211_sta_state state; 1598 1599 if (!sta->uploaded) 1600 continue; 1601 1602 if (sta->sdata->vif.type != NL80211_IFTYPE_AP) 1603 continue; 1604 1605 for (state = IEEE80211_STA_NOTEXIST; 1606 state < sta->sta_state; state++) 1607 WARN_ON(drv_sta_state(local, sta->sdata, sta, state, 1608 state + 1)); 1609 } 1610 mutex_unlock(&local->sta_mtx); 1611 1612 /* add back keys */ 1613 list_for_each_entry(sdata, &local->interfaces, list) 1614 if (ieee80211_sdata_running(sdata)) 1615 ieee80211_enable_keys(sdata); 1616 1617 wake_up: 1618 local->in_reconfig = false; 1619 barrier(); 1620 1621 /* 1622 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation 1623 * sessions can be established after a resume. 1624 * 1625 * Also tear down aggregation sessions since reconfiguring 1626 * them in a hardware restart scenario is not easily done 1627 * right now, and the hardware will have lost information 1628 * about the sessions, but we and the AP still think they 1629 * are active. This is really a workaround though. 1630 */ 1631 if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) { 1632 mutex_lock(&local->sta_mtx); 1633 1634 list_for_each_entry(sta, &local->sta_list, list) { 1635 ieee80211_sta_tear_down_BA_sessions(sta, true); 1636 clear_sta_flag(sta, WLAN_STA_BLOCK_BA); 1637 } 1638 1639 mutex_unlock(&local->sta_mtx); 1640 } 1641 1642 ieee80211_wake_queues_by_reason(hw, 1643 IEEE80211_QUEUE_STOP_REASON_SUSPEND); 1644 1645 /* 1646 * If this is for hw restart things are still running. 1647 * We may want to change that later, however. 1648 */ 1649 if (!local->suspended) { 1650 drv_restart_complete(local); 1651 return 0; 1652 } 1653 1654 #ifdef CONFIG_PM 1655 /* first set suspended false, then resuming */ 1656 local->suspended = false; 1657 mb(); 1658 local->resuming = false; 1659 1660 list_for_each_entry(sdata, &local->interfaces, list) { 1661 switch(sdata->vif.type) { 1662 case NL80211_IFTYPE_STATION: 1663 ieee80211_sta_restart(sdata); 1664 break; 1665 case NL80211_IFTYPE_ADHOC: 1666 ieee80211_ibss_restart(sdata); 1667 break; 1668 case NL80211_IFTYPE_MESH_POINT: 1669 ieee80211_mesh_restart(sdata); 1670 break; 1671 default: 1672 break; 1673 } 1674 } 1675 1676 mod_timer(&local->sta_cleanup, jiffies + 1); 1677 1678 mutex_lock(&local->sta_mtx); 1679 list_for_each_entry(sta, &local->sta_list, list) 1680 mesh_plink_restart(sta); 1681 mutex_unlock(&local->sta_mtx); 1682 #else 1683 WARN_ON(1); 1684 #endif 1685 return 0; 1686 } 1687 1688 void ieee80211_resume_disconnect(struct ieee80211_vif *vif) 1689 { 1690 struct ieee80211_sub_if_data *sdata; 1691 struct ieee80211_local *local; 1692 struct ieee80211_key *key; 1693 1694 if (WARN_ON(!vif)) 1695 return; 1696 1697 sdata = vif_to_sdata(vif); 1698 local = sdata->local; 1699 1700 if (WARN_ON(!local->resuming)) 1701 return; 1702 1703 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION)) 1704 return; 1705 1706 sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME; 1707 1708 mutex_lock(&local->key_mtx); 1709 list_for_each_entry(key, &sdata->key_list, list) 1710 key->flags |= KEY_FLAG_TAINTED; 1711 mutex_unlock(&local->key_mtx); 1712 } 1713 EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect); 1714 1715 void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata) 1716 { 1717 struct ieee80211_local *local = sdata->local; 1718 struct ieee80211_chanctx_conf *chanctx_conf; 1719 struct ieee80211_chanctx *chanctx; 1720 1721 mutex_lock(&local->chanctx_mtx); 1722 1723 chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf, 1724 lockdep_is_held(&local->chanctx_mtx)); 1725 1726 if (WARN_ON_ONCE(!chanctx_conf)) 1727 goto unlock; 1728 1729 chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf); 1730 ieee80211_recalc_smps_chanctx(local, chanctx); 1731 unlock: 1732 mutex_unlock(&local->chanctx_mtx); 1733 } 1734 1735 static bool ieee80211_id_in_list(const u8 *ids, int n_ids, u8 id) 1736 { 1737 int i; 1738 1739 for (i = 0; i < n_ids; i++) 1740 if (ids[i] == id) 1741 return true; 1742 return false; 1743 } 1744 1745 /** 1746 * ieee80211_ie_split - split an IE buffer according to ordering 1747 * 1748 * @ies: the IE buffer 1749 * @ielen: the length of the IE buffer 1750 * @ids: an array with element IDs that are allowed before 1751 * the split 1752 * @n_ids: the size of the element ID array 1753 * @offset: offset where to start splitting in the buffer 1754 * 1755 * This function splits an IE buffer by updating the @offset 1756 * variable to point to the location where the buffer should be 1757 * split. 1758 * 1759 * It assumes that the given IE buffer is well-formed, this 1760 * has to be guaranteed by the caller! 1761 * 1762 * It also assumes that the IEs in the buffer are ordered 1763 * correctly, if not the result of using this function will not 1764 * be ordered correctly either, i.e. it does no reordering. 1765 * 1766 * The function returns the offset where the next part of the 1767 * buffer starts, which may be @ielen if the entire (remainder) 1768 * of the buffer should be used. 1769 */ 1770 size_t ieee80211_ie_split(const u8 *ies, size_t ielen, 1771 const u8 *ids, int n_ids, size_t offset) 1772 { 1773 size_t pos = offset; 1774 1775 while (pos < ielen && ieee80211_id_in_list(ids, n_ids, ies[pos])) 1776 pos += 2 + ies[pos + 1]; 1777 1778 return pos; 1779 } 1780 1781 size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset) 1782 { 1783 size_t pos = offset; 1784 1785 while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC) 1786 pos += 2 + ies[pos + 1]; 1787 1788 return pos; 1789 } 1790 1791 static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata, 1792 int rssi_min_thold, 1793 int rssi_max_thold) 1794 { 1795 trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold); 1796 1797 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION)) 1798 return; 1799 1800 /* 1801 * Scale up threshold values before storing it, as the RSSI averaging 1802 * algorithm uses a scaled up value as well. Change this scaling 1803 * factor if the RSSI averaging algorithm changes. 1804 */ 1805 sdata->u.mgd.rssi_min_thold = rssi_min_thold*16; 1806 sdata->u.mgd.rssi_max_thold = rssi_max_thold*16; 1807 } 1808 1809 void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif, 1810 int rssi_min_thold, 1811 int rssi_max_thold) 1812 { 1813 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1814 1815 WARN_ON(rssi_min_thold == rssi_max_thold || 1816 rssi_min_thold > rssi_max_thold); 1817 1818 _ieee80211_enable_rssi_reports(sdata, rssi_min_thold, 1819 rssi_max_thold); 1820 } 1821 EXPORT_SYMBOL(ieee80211_enable_rssi_reports); 1822 1823 void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif) 1824 { 1825 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1826 1827 _ieee80211_enable_rssi_reports(sdata, 0, 0); 1828 } 1829 EXPORT_SYMBOL(ieee80211_disable_rssi_reports); 1830 1831 u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap, 1832 u16 cap) 1833 { 1834 __le16 tmp; 1835 1836 *pos++ = WLAN_EID_HT_CAPABILITY; 1837 *pos++ = sizeof(struct ieee80211_ht_cap); 1838 memset(pos, 0, sizeof(struct ieee80211_ht_cap)); 1839 1840 /* capability flags */ 1841 tmp = cpu_to_le16(cap); 1842 memcpy(pos, &tmp, sizeof(u16)); 1843 pos += sizeof(u16); 1844 1845 /* AMPDU parameters */ 1846 *pos++ = ht_cap->ampdu_factor | 1847 (ht_cap->ampdu_density << 1848 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT); 1849 1850 /* MCS set */ 1851 memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs)); 1852 pos += sizeof(ht_cap->mcs); 1853 1854 /* extended capabilities */ 1855 pos += sizeof(__le16); 1856 1857 /* BF capabilities */ 1858 pos += sizeof(__le32); 1859 1860 /* antenna selection */ 1861 pos += sizeof(u8); 1862 1863 return pos; 1864 } 1865 1866 u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap, 1867 u32 cap) 1868 { 1869 __le32 tmp; 1870 1871 *pos++ = WLAN_EID_VHT_CAPABILITY; 1872 *pos++ = sizeof(struct ieee80211_vht_cap); 1873 memset(pos, 0, sizeof(struct ieee80211_vht_cap)); 1874 1875 /* capability flags */ 1876 tmp = cpu_to_le32(cap); 1877 memcpy(pos, &tmp, sizeof(u32)); 1878 pos += sizeof(u32); 1879 1880 /* VHT MCS set */ 1881 memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs)); 1882 pos += sizeof(vht_cap->vht_mcs); 1883 1884 return pos; 1885 } 1886 1887 u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap, 1888 const struct cfg80211_chan_def *chandef, 1889 u16 prot_mode) 1890 { 1891 struct ieee80211_ht_operation *ht_oper; 1892 /* Build HT Information */ 1893 *pos++ = WLAN_EID_HT_OPERATION; 1894 *pos++ = sizeof(struct ieee80211_ht_operation); 1895 ht_oper = (struct ieee80211_ht_operation *)pos; 1896 ht_oper->primary_chan = ieee80211_frequency_to_channel( 1897 chandef->chan->center_freq); 1898 switch (chandef->width) { 1899 case NL80211_CHAN_WIDTH_160: 1900 case NL80211_CHAN_WIDTH_80P80: 1901 case NL80211_CHAN_WIDTH_80: 1902 case NL80211_CHAN_WIDTH_40: 1903 if (chandef->center_freq1 > chandef->chan->center_freq) 1904 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 1905 else 1906 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW; 1907 break; 1908 default: 1909 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE; 1910 break; 1911 } 1912 if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 && 1913 chandef->width != NL80211_CHAN_WIDTH_20_NOHT && 1914 chandef->width != NL80211_CHAN_WIDTH_20) 1915 ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY; 1916 1917 ht_oper->operation_mode = cpu_to_le16(prot_mode); 1918 ht_oper->stbc_param = 0x0000; 1919 1920 /* It seems that Basic MCS set and Supported MCS set 1921 are identical for the first 10 bytes */ 1922 memset(&ht_oper->basic_set, 0, 16); 1923 memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10); 1924 1925 return pos + sizeof(struct ieee80211_ht_operation); 1926 } 1927 1928 void ieee80211_ht_oper_to_chandef(struct ieee80211_channel *control_chan, 1929 struct ieee80211_ht_operation *ht_oper, 1930 struct cfg80211_chan_def *chandef) 1931 { 1932 enum nl80211_channel_type channel_type; 1933 1934 if (!ht_oper) { 1935 cfg80211_chandef_create(chandef, control_chan, 1936 NL80211_CHAN_NO_HT); 1937 return; 1938 } 1939 1940 switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) { 1941 case IEEE80211_HT_PARAM_CHA_SEC_NONE: 1942 channel_type = NL80211_CHAN_HT20; 1943 break; 1944 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: 1945 channel_type = NL80211_CHAN_HT40PLUS; 1946 break; 1947 case IEEE80211_HT_PARAM_CHA_SEC_BELOW: 1948 channel_type = NL80211_CHAN_HT40MINUS; 1949 break; 1950 default: 1951 channel_type = NL80211_CHAN_NO_HT; 1952 } 1953 1954 cfg80211_chandef_create(chandef, control_chan, channel_type); 1955 } 1956 1957 int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata, 1958 struct sk_buff *skb, bool need_basic, 1959 enum ieee80211_band band) 1960 { 1961 struct ieee80211_local *local = sdata->local; 1962 struct ieee80211_supported_band *sband; 1963 int rate; 1964 u8 i, rates, *pos; 1965 u32 basic_rates = sdata->vif.bss_conf.basic_rates; 1966 1967 sband = local->hw.wiphy->bands[band]; 1968 rates = sband->n_bitrates; 1969 if (rates > 8) 1970 rates = 8; 1971 1972 if (skb_tailroom(skb) < rates + 2) 1973 return -ENOMEM; 1974 1975 pos = skb_put(skb, rates + 2); 1976 *pos++ = WLAN_EID_SUPP_RATES; 1977 *pos++ = rates; 1978 for (i = 0; i < rates; i++) { 1979 u8 basic = 0; 1980 if (need_basic && basic_rates & BIT(i)) 1981 basic = 0x80; 1982 rate = sband->bitrates[i].bitrate; 1983 *pos++ = basic | (u8) (rate / 5); 1984 } 1985 1986 return 0; 1987 } 1988 1989 int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata, 1990 struct sk_buff *skb, bool need_basic, 1991 enum ieee80211_band band) 1992 { 1993 struct ieee80211_local *local = sdata->local; 1994 struct ieee80211_supported_band *sband; 1995 int rate; 1996 u8 i, exrates, *pos; 1997 u32 basic_rates = sdata->vif.bss_conf.basic_rates; 1998 1999 sband = local->hw.wiphy->bands[band]; 2000 exrates = sband->n_bitrates; 2001 if (exrates > 8) 2002 exrates -= 8; 2003 else 2004 exrates = 0; 2005 2006 if (skb_tailroom(skb) < exrates + 2) 2007 return -ENOMEM; 2008 2009 if (exrates) { 2010 pos = skb_put(skb, exrates + 2); 2011 *pos++ = WLAN_EID_EXT_SUPP_RATES; 2012 *pos++ = exrates; 2013 for (i = 8; i < sband->n_bitrates; i++) { 2014 u8 basic = 0; 2015 if (need_basic && basic_rates & BIT(i)) 2016 basic = 0x80; 2017 rate = sband->bitrates[i].bitrate; 2018 *pos++ = basic | (u8) (rate / 5); 2019 } 2020 } 2021 return 0; 2022 } 2023 2024 int ieee80211_ave_rssi(struct ieee80211_vif *vif) 2025 { 2026 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 2027 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2028 2029 if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) { 2030 /* non-managed type inferfaces */ 2031 return 0; 2032 } 2033 return ifmgd->ave_beacon_signal; 2034 } 2035 EXPORT_SYMBOL_GPL(ieee80211_ave_rssi); 2036 2037 u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs) 2038 { 2039 if (!mcs) 2040 return 1; 2041 2042 /* TODO: consider rx_highest */ 2043 2044 if (mcs->rx_mask[3]) 2045 return 4; 2046 if (mcs->rx_mask[2]) 2047 return 3; 2048 if (mcs->rx_mask[1]) 2049 return 2; 2050 return 1; 2051 } 2052 2053 /** 2054 * ieee80211_calculate_rx_timestamp - calculate timestamp in frame 2055 * @local: mac80211 hw info struct 2056 * @status: RX status 2057 * @mpdu_len: total MPDU length (including FCS) 2058 * @mpdu_offset: offset into MPDU to calculate timestamp at 2059 * 2060 * This function calculates the RX timestamp at the given MPDU offset, taking 2061 * into account what the RX timestamp was. An offset of 0 will just normalize 2062 * the timestamp to TSF at beginning of MPDU reception. 2063 */ 2064 u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local, 2065 struct ieee80211_rx_status *status, 2066 unsigned int mpdu_len, 2067 unsigned int mpdu_offset) 2068 { 2069 u64 ts = status->mactime; 2070 struct rate_info ri; 2071 u16 rate; 2072 2073 if (WARN_ON(!ieee80211_have_rx_timestamp(status))) 2074 return 0; 2075 2076 memset(&ri, 0, sizeof(ri)); 2077 2078 /* Fill cfg80211 rate info */ 2079 if (status->flag & RX_FLAG_HT) { 2080 ri.mcs = status->rate_idx; 2081 ri.flags |= RATE_INFO_FLAGS_MCS; 2082 if (status->flag & RX_FLAG_40MHZ) 2083 ri.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH; 2084 if (status->flag & RX_FLAG_SHORT_GI) 2085 ri.flags |= RATE_INFO_FLAGS_SHORT_GI; 2086 } else if (status->flag & RX_FLAG_VHT) { 2087 ri.flags |= RATE_INFO_FLAGS_VHT_MCS; 2088 ri.mcs = status->rate_idx; 2089 ri.nss = status->vht_nss; 2090 if (status->flag & RX_FLAG_40MHZ) 2091 ri.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH; 2092 if (status->flag & RX_FLAG_80MHZ) 2093 ri.flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH; 2094 if (status->flag & RX_FLAG_80P80MHZ) 2095 ri.flags |= RATE_INFO_FLAGS_80P80_MHZ_WIDTH; 2096 if (status->flag & RX_FLAG_160MHZ) 2097 ri.flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH; 2098 if (status->flag & RX_FLAG_SHORT_GI) 2099 ri.flags |= RATE_INFO_FLAGS_SHORT_GI; 2100 } else { 2101 struct ieee80211_supported_band *sband; 2102 2103 sband = local->hw.wiphy->bands[status->band]; 2104 ri.legacy = sband->bitrates[status->rate_idx].bitrate; 2105 } 2106 2107 rate = cfg80211_calculate_bitrate(&ri); 2108 2109 /* rewind from end of MPDU */ 2110 if (status->flag & RX_FLAG_MACTIME_END) 2111 ts -= mpdu_len * 8 * 10 / rate; 2112 2113 ts += mpdu_offset * 8 * 10 / rate; 2114 2115 return ts; 2116 } 2117