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 (test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state)) 280 continue; 281 282 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE && 283 local->queue_stop_reasons[sdata->vif.cab_queue] != 0) 284 continue; 285 286 for (ac = 0; ac < n_acs; ac++) { 287 int ac_queue = sdata->vif.hw_queue[ac]; 288 289 if (ac_queue == queue || 290 (sdata->vif.cab_queue == queue && 291 local->queue_stop_reasons[ac_queue] == 0 && 292 skb_queue_empty(&local->pending[ac_queue]))) 293 netif_wake_subqueue(sdata->dev, ac); 294 } 295 } 296 } 297 298 static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue, 299 enum queue_stop_reason reason) 300 { 301 struct ieee80211_local *local = hw_to_local(hw); 302 303 trace_wake_queue(local, queue, reason); 304 305 if (WARN_ON(queue >= hw->queues)) 306 return; 307 308 if (!test_bit(reason, &local->queue_stop_reasons[queue])) 309 return; 310 311 __clear_bit(reason, &local->queue_stop_reasons[queue]); 312 313 if (local->queue_stop_reasons[queue] != 0) 314 /* someone still has this queue stopped */ 315 return; 316 317 if (skb_queue_empty(&local->pending[queue])) { 318 rcu_read_lock(); 319 ieee80211_propagate_queue_wake(local, queue); 320 rcu_read_unlock(); 321 } else 322 tasklet_schedule(&local->tx_pending_tasklet); 323 } 324 325 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue, 326 enum queue_stop_reason reason) 327 { 328 struct ieee80211_local *local = hw_to_local(hw); 329 unsigned long flags; 330 331 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 332 __ieee80211_wake_queue(hw, queue, reason); 333 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 334 } 335 336 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue) 337 { 338 ieee80211_wake_queue_by_reason(hw, queue, 339 IEEE80211_QUEUE_STOP_REASON_DRIVER); 340 } 341 EXPORT_SYMBOL(ieee80211_wake_queue); 342 343 static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue, 344 enum queue_stop_reason reason) 345 { 346 struct ieee80211_local *local = hw_to_local(hw); 347 struct ieee80211_sub_if_data *sdata; 348 int n_acs = IEEE80211_NUM_ACS; 349 350 trace_stop_queue(local, queue, reason); 351 352 if (WARN_ON(queue >= hw->queues)) 353 return; 354 355 if (test_bit(reason, &local->queue_stop_reasons[queue])) 356 return; 357 358 __set_bit(reason, &local->queue_stop_reasons[queue]); 359 360 if (local->hw.queues < IEEE80211_NUM_ACS) 361 n_acs = 1; 362 363 rcu_read_lock(); 364 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 365 int ac; 366 367 for (ac = 0; ac < n_acs; ac++) { 368 if (sdata->vif.hw_queue[ac] == queue || 369 sdata->vif.cab_queue == queue) 370 netif_stop_subqueue(sdata->dev, ac); 371 } 372 } 373 rcu_read_unlock(); 374 } 375 376 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue, 377 enum queue_stop_reason reason) 378 { 379 struct ieee80211_local *local = hw_to_local(hw); 380 unsigned long flags; 381 382 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 383 __ieee80211_stop_queue(hw, queue, reason); 384 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 385 } 386 387 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue) 388 { 389 ieee80211_stop_queue_by_reason(hw, queue, 390 IEEE80211_QUEUE_STOP_REASON_DRIVER); 391 } 392 EXPORT_SYMBOL(ieee80211_stop_queue); 393 394 void ieee80211_add_pending_skb(struct ieee80211_local *local, 395 struct sk_buff *skb) 396 { 397 struct ieee80211_hw *hw = &local->hw; 398 unsigned long flags; 399 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 400 int queue = info->hw_queue; 401 402 if (WARN_ON(!info->control.vif)) { 403 kfree_skb(skb); 404 return; 405 } 406 407 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 408 __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 409 __skb_queue_tail(&local->pending[queue], skb); 410 __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 411 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 412 } 413 414 void ieee80211_add_pending_skbs_fn(struct ieee80211_local *local, 415 struct sk_buff_head *skbs, 416 void (*fn)(void *data), void *data) 417 { 418 struct ieee80211_hw *hw = &local->hw; 419 struct sk_buff *skb; 420 unsigned long flags; 421 int queue, i; 422 423 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 424 while ((skb = skb_dequeue(skbs))) { 425 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 426 427 if (WARN_ON(!info->control.vif)) { 428 kfree_skb(skb); 429 continue; 430 } 431 432 queue = info->hw_queue; 433 434 __ieee80211_stop_queue(hw, queue, 435 IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 436 437 __skb_queue_tail(&local->pending[queue], skb); 438 } 439 440 if (fn) 441 fn(data); 442 443 for (i = 0; i < hw->queues; i++) 444 __ieee80211_wake_queue(hw, i, 445 IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 446 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 447 } 448 449 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw, 450 enum queue_stop_reason reason) 451 { 452 struct ieee80211_local *local = hw_to_local(hw); 453 unsigned long flags; 454 int i; 455 456 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 457 458 for (i = 0; i < hw->queues; i++) 459 __ieee80211_stop_queue(hw, i, reason); 460 461 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 462 } 463 464 void ieee80211_stop_queues(struct ieee80211_hw *hw) 465 { 466 ieee80211_stop_queues_by_reason(hw, 467 IEEE80211_QUEUE_STOP_REASON_DRIVER); 468 } 469 EXPORT_SYMBOL(ieee80211_stop_queues); 470 471 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue) 472 { 473 struct ieee80211_local *local = hw_to_local(hw); 474 unsigned long flags; 475 int ret; 476 477 if (WARN_ON(queue >= hw->queues)) 478 return true; 479 480 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 481 ret = !!local->queue_stop_reasons[queue]; 482 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 483 return ret; 484 } 485 EXPORT_SYMBOL(ieee80211_queue_stopped); 486 487 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw, 488 enum queue_stop_reason reason) 489 { 490 struct ieee80211_local *local = hw_to_local(hw); 491 unsigned long flags; 492 int i; 493 494 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 495 496 for (i = 0; i < hw->queues; i++) 497 __ieee80211_wake_queue(hw, i, reason); 498 499 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 500 } 501 502 void ieee80211_wake_queues(struct ieee80211_hw *hw) 503 { 504 ieee80211_wake_queues_by_reason(hw, IEEE80211_QUEUE_STOP_REASON_DRIVER); 505 } 506 EXPORT_SYMBOL(ieee80211_wake_queues); 507 508 void ieee80211_iterate_active_interfaces( 509 struct ieee80211_hw *hw, 510 void (*iterator)(void *data, u8 *mac, 511 struct ieee80211_vif *vif), 512 void *data) 513 { 514 struct ieee80211_local *local = hw_to_local(hw); 515 struct ieee80211_sub_if_data *sdata; 516 517 mutex_lock(&local->iflist_mtx); 518 519 list_for_each_entry(sdata, &local->interfaces, list) { 520 switch (sdata->vif.type) { 521 case NL80211_IFTYPE_MONITOR: 522 case NL80211_IFTYPE_AP_VLAN: 523 continue; 524 default: 525 break; 526 } 527 if (ieee80211_sdata_running(sdata)) 528 iterator(data, sdata->vif.addr, 529 &sdata->vif); 530 } 531 532 sdata = rcu_dereference_protected(local->monitor_sdata, 533 lockdep_is_held(&local->iflist_mtx)); 534 if (sdata) 535 iterator(data, sdata->vif.addr, &sdata->vif); 536 537 mutex_unlock(&local->iflist_mtx); 538 } 539 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces); 540 541 void ieee80211_iterate_active_interfaces_atomic( 542 struct ieee80211_hw *hw, 543 void (*iterator)(void *data, u8 *mac, 544 struct ieee80211_vif *vif), 545 void *data) 546 { 547 struct ieee80211_local *local = hw_to_local(hw); 548 struct ieee80211_sub_if_data *sdata; 549 550 rcu_read_lock(); 551 552 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 553 switch (sdata->vif.type) { 554 case NL80211_IFTYPE_MONITOR: 555 case NL80211_IFTYPE_AP_VLAN: 556 continue; 557 default: 558 break; 559 } 560 if (ieee80211_sdata_running(sdata)) 561 iterator(data, sdata->vif.addr, 562 &sdata->vif); 563 } 564 565 sdata = rcu_dereference(local->monitor_sdata); 566 if (sdata) 567 iterator(data, sdata->vif.addr, &sdata->vif); 568 569 rcu_read_unlock(); 570 } 571 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic); 572 573 /* 574 * Nothing should have been stuffed into the workqueue during 575 * the suspend->resume cycle. If this WARN is seen then there 576 * is a bug with either the driver suspend or something in 577 * mac80211 stuffing into the workqueue which we haven't yet 578 * cleared during mac80211's suspend cycle. 579 */ 580 static bool ieee80211_can_queue_work(struct ieee80211_local *local) 581 { 582 if (WARN(local->suspended && !local->resuming, 583 "queueing ieee80211 work while going to suspend\n")) 584 return false; 585 586 return true; 587 } 588 589 void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work) 590 { 591 struct ieee80211_local *local = hw_to_local(hw); 592 593 if (!ieee80211_can_queue_work(local)) 594 return; 595 596 queue_work(local->workqueue, work); 597 } 598 EXPORT_SYMBOL(ieee80211_queue_work); 599 600 void ieee80211_queue_delayed_work(struct ieee80211_hw *hw, 601 struct delayed_work *dwork, 602 unsigned long delay) 603 { 604 struct ieee80211_local *local = hw_to_local(hw); 605 606 if (!ieee80211_can_queue_work(local)) 607 return; 608 609 queue_delayed_work(local->workqueue, dwork, delay); 610 } 611 EXPORT_SYMBOL(ieee80211_queue_delayed_work); 612 613 u32 ieee802_11_parse_elems_crc(u8 *start, size_t len, 614 struct ieee802_11_elems *elems, 615 u64 filter, u32 crc) 616 { 617 size_t left = len; 618 u8 *pos = start; 619 bool calc_crc = filter != 0; 620 DECLARE_BITMAP(seen_elems, 256); 621 622 bitmap_zero(seen_elems, 256); 623 memset(elems, 0, sizeof(*elems)); 624 elems->ie_start = start; 625 elems->total_len = len; 626 627 while (left >= 2) { 628 u8 id, elen; 629 bool elem_parse_failed; 630 631 id = *pos++; 632 elen = *pos++; 633 left -= 2; 634 635 if (elen > left) { 636 elems->parse_error = true; 637 break; 638 } 639 640 if (id != WLAN_EID_VENDOR_SPECIFIC && 641 id != WLAN_EID_QUIET && 642 test_bit(id, seen_elems)) { 643 elems->parse_error = true; 644 left -= elen; 645 pos += elen; 646 continue; 647 } 648 649 if (calc_crc && id < 64 && (filter & (1ULL << id))) 650 crc = crc32_be(crc, pos - 2, elen + 2); 651 652 elem_parse_failed = false; 653 654 switch (id) { 655 case WLAN_EID_SSID: 656 elems->ssid = pos; 657 elems->ssid_len = elen; 658 break; 659 case WLAN_EID_SUPP_RATES: 660 elems->supp_rates = pos; 661 elems->supp_rates_len = elen; 662 break; 663 case WLAN_EID_FH_PARAMS: 664 elems->fh_params = pos; 665 elems->fh_params_len = elen; 666 break; 667 case WLAN_EID_DS_PARAMS: 668 elems->ds_params = pos; 669 elems->ds_params_len = elen; 670 break; 671 case WLAN_EID_CF_PARAMS: 672 elems->cf_params = pos; 673 elems->cf_params_len = elen; 674 break; 675 case WLAN_EID_TIM: 676 if (elen >= sizeof(struct ieee80211_tim_ie)) { 677 elems->tim = (void *)pos; 678 elems->tim_len = elen; 679 } else 680 elem_parse_failed = true; 681 break; 682 case WLAN_EID_IBSS_PARAMS: 683 elems->ibss_params = pos; 684 elems->ibss_params_len = elen; 685 break; 686 case WLAN_EID_CHALLENGE: 687 elems->challenge = pos; 688 elems->challenge_len = elen; 689 break; 690 case WLAN_EID_VENDOR_SPECIFIC: 691 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 && 692 pos[2] == 0xf2) { 693 /* Microsoft OUI (00:50:F2) */ 694 695 if (calc_crc) 696 crc = crc32_be(crc, pos - 2, elen + 2); 697 698 if (pos[3] == 1) { 699 /* OUI Type 1 - WPA IE */ 700 elems->wpa = pos; 701 elems->wpa_len = elen; 702 } else if (elen >= 5 && pos[3] == 2) { 703 /* OUI Type 2 - WMM IE */ 704 if (pos[4] == 0) { 705 elems->wmm_info = pos; 706 elems->wmm_info_len = elen; 707 } else if (pos[4] == 1) { 708 elems->wmm_param = pos; 709 elems->wmm_param_len = elen; 710 } 711 } 712 } 713 break; 714 case WLAN_EID_RSN: 715 elems->rsn = pos; 716 elems->rsn_len = elen; 717 break; 718 case WLAN_EID_ERP_INFO: 719 elems->erp_info = pos; 720 elems->erp_info_len = elen; 721 break; 722 case WLAN_EID_EXT_SUPP_RATES: 723 elems->ext_supp_rates = pos; 724 elems->ext_supp_rates_len = elen; 725 break; 726 case WLAN_EID_HT_CAPABILITY: 727 if (elen >= sizeof(struct ieee80211_ht_cap)) 728 elems->ht_cap_elem = (void *)pos; 729 else 730 elem_parse_failed = true; 731 break; 732 case WLAN_EID_HT_OPERATION: 733 if (elen >= sizeof(struct ieee80211_ht_operation)) 734 elems->ht_operation = (void *)pos; 735 else 736 elem_parse_failed = true; 737 break; 738 case WLAN_EID_MESH_ID: 739 elems->mesh_id = pos; 740 elems->mesh_id_len = elen; 741 break; 742 case WLAN_EID_MESH_CONFIG: 743 if (elen >= sizeof(struct ieee80211_meshconf_ie)) 744 elems->mesh_config = (void *)pos; 745 else 746 elem_parse_failed = true; 747 break; 748 case WLAN_EID_PEER_MGMT: 749 elems->peering = pos; 750 elems->peering_len = elen; 751 break; 752 case WLAN_EID_PREQ: 753 elems->preq = pos; 754 elems->preq_len = elen; 755 break; 756 case WLAN_EID_PREP: 757 elems->prep = pos; 758 elems->prep_len = elen; 759 break; 760 case WLAN_EID_PERR: 761 elems->perr = pos; 762 elems->perr_len = elen; 763 break; 764 case WLAN_EID_RANN: 765 if (elen >= sizeof(struct ieee80211_rann_ie)) 766 elems->rann = (void *)pos; 767 else 768 elem_parse_failed = true; 769 break; 770 case WLAN_EID_CHANNEL_SWITCH: 771 elems->ch_switch_elem = pos; 772 elems->ch_switch_elem_len = elen; 773 break; 774 case WLAN_EID_QUIET: 775 if (!elems->quiet_elem) { 776 elems->quiet_elem = pos; 777 elems->quiet_elem_len = elen; 778 } 779 elems->num_of_quiet_elem++; 780 break; 781 case WLAN_EID_COUNTRY: 782 elems->country_elem = pos; 783 elems->country_elem_len = elen; 784 break; 785 case WLAN_EID_PWR_CONSTRAINT: 786 elems->pwr_constr_elem = pos; 787 elems->pwr_constr_elem_len = elen; 788 break; 789 case WLAN_EID_TIMEOUT_INTERVAL: 790 elems->timeout_int = pos; 791 elems->timeout_int_len = elen; 792 break; 793 default: 794 break; 795 } 796 797 if (elem_parse_failed) 798 elems->parse_error = true; 799 else 800 set_bit(id, seen_elems); 801 802 left -= elen; 803 pos += elen; 804 } 805 806 if (left != 0) 807 elems->parse_error = true; 808 809 return crc; 810 } 811 812 void ieee802_11_parse_elems(u8 *start, size_t len, 813 struct ieee802_11_elems *elems) 814 { 815 ieee802_11_parse_elems_crc(start, len, elems, 0, 0); 816 } 817 818 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata, 819 bool bss_notify) 820 { 821 struct ieee80211_local *local = sdata->local; 822 struct ieee80211_tx_queue_params qparam; 823 int ac; 824 bool use_11b, enable_qos; 825 int aCWmin, aCWmax; 826 827 if (!local->ops->conf_tx) 828 return; 829 830 if (local->hw.queues < IEEE80211_NUM_ACS) 831 return; 832 833 memset(&qparam, 0, sizeof(qparam)); 834 835 use_11b = (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) && 836 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE); 837 838 /* 839 * By default disable QoS in STA mode for old access points, which do 840 * not support 802.11e. New APs will provide proper queue parameters, 841 * that we will configure later. 842 */ 843 enable_qos = (sdata->vif.type != NL80211_IFTYPE_STATION); 844 845 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 846 /* Set defaults according to 802.11-2007 Table 7-37 */ 847 aCWmax = 1023; 848 if (use_11b) 849 aCWmin = 31; 850 else 851 aCWmin = 15; 852 853 if (enable_qos) { 854 switch (ac) { 855 case IEEE80211_AC_BK: 856 qparam.cw_max = aCWmax; 857 qparam.cw_min = aCWmin; 858 qparam.txop = 0; 859 qparam.aifs = 7; 860 break; 861 /* never happens but let's not leave undefined */ 862 default: 863 case IEEE80211_AC_BE: 864 qparam.cw_max = aCWmax; 865 qparam.cw_min = aCWmin; 866 qparam.txop = 0; 867 qparam.aifs = 3; 868 break; 869 case IEEE80211_AC_VI: 870 qparam.cw_max = aCWmin; 871 qparam.cw_min = (aCWmin + 1) / 2 - 1; 872 if (use_11b) 873 qparam.txop = 6016/32; 874 else 875 qparam.txop = 3008/32; 876 qparam.aifs = 2; 877 break; 878 case IEEE80211_AC_VO: 879 qparam.cw_max = (aCWmin + 1) / 2 - 1; 880 qparam.cw_min = (aCWmin + 1) / 4 - 1; 881 if (use_11b) 882 qparam.txop = 3264/32; 883 else 884 qparam.txop = 1504/32; 885 qparam.aifs = 2; 886 break; 887 } 888 } else { 889 /* Confiure old 802.11b/g medium access rules. */ 890 qparam.cw_max = aCWmax; 891 qparam.cw_min = aCWmin; 892 qparam.txop = 0; 893 qparam.aifs = 2; 894 } 895 896 qparam.uapsd = false; 897 898 sdata->tx_conf[ac] = qparam; 899 drv_conf_tx(local, sdata, ac, &qparam); 900 } 901 902 if (sdata->vif.type != NL80211_IFTYPE_MONITOR) { 903 sdata->vif.bss_conf.qos = enable_qos; 904 if (bss_notify) 905 ieee80211_bss_info_change_notify(sdata, 906 BSS_CHANGED_QOS); 907 } 908 } 909 910 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata, 911 const size_t supp_rates_len, 912 const u8 *supp_rates) 913 { 914 struct ieee80211_local *local = sdata->local; 915 int i, have_higher_than_11mbit = 0; 916 917 /* cf. IEEE 802.11 9.2.12 */ 918 for (i = 0; i < supp_rates_len; i++) 919 if ((supp_rates[i] & 0x7f) * 5 > 110) 920 have_higher_than_11mbit = 1; 921 922 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ && 923 have_higher_than_11mbit) 924 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE; 925 else 926 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE; 927 928 ieee80211_set_wmm_default(sdata, true); 929 } 930 931 u32 ieee80211_mandatory_rates(struct ieee80211_local *local, 932 enum ieee80211_band band) 933 { 934 struct ieee80211_supported_band *sband; 935 struct ieee80211_rate *bitrates; 936 u32 mandatory_rates; 937 enum ieee80211_rate_flags mandatory_flag; 938 int i; 939 940 sband = local->hw.wiphy->bands[band]; 941 if (WARN_ON(!sband)) 942 return 1; 943 944 if (band == IEEE80211_BAND_2GHZ) 945 mandatory_flag = IEEE80211_RATE_MANDATORY_B; 946 else 947 mandatory_flag = IEEE80211_RATE_MANDATORY_A; 948 949 bitrates = sband->bitrates; 950 mandatory_rates = 0; 951 for (i = 0; i < sband->n_bitrates; i++) 952 if (bitrates[i].flags & mandatory_flag) 953 mandatory_rates |= BIT(i); 954 return mandatory_rates; 955 } 956 957 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata, 958 u16 transaction, u16 auth_alg, 959 u8 *extra, size_t extra_len, const u8 *da, 960 const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx) 961 { 962 struct ieee80211_local *local = sdata->local; 963 struct sk_buff *skb; 964 struct ieee80211_mgmt *mgmt; 965 int err; 966 967 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 968 sizeof(*mgmt) + 6 + extra_len); 969 if (!skb) 970 return; 971 972 skb_reserve(skb, local->hw.extra_tx_headroom); 973 974 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6); 975 memset(mgmt, 0, 24 + 6); 976 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 977 IEEE80211_STYPE_AUTH); 978 memcpy(mgmt->da, da, ETH_ALEN); 979 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 980 memcpy(mgmt->bssid, bssid, ETH_ALEN); 981 mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg); 982 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction); 983 mgmt->u.auth.status_code = cpu_to_le16(0); 984 if (extra) 985 memcpy(skb_put(skb, extra_len), extra, extra_len); 986 987 if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) { 988 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 989 err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx); 990 WARN_ON(err); 991 } 992 993 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 994 ieee80211_tx_skb(sdata, skb); 995 } 996 997 int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer, 998 const u8 *ie, size_t ie_len, 999 enum ieee80211_band band, u32 rate_mask, 1000 u8 channel) 1001 { 1002 struct ieee80211_supported_band *sband; 1003 u8 *pos; 1004 size_t offset = 0, noffset; 1005 int supp_rates_len, i; 1006 u8 rates[32]; 1007 int num_rates; 1008 int ext_rates_len; 1009 1010 sband = local->hw.wiphy->bands[band]; 1011 if (WARN_ON_ONCE(!sband)) 1012 return 0; 1013 1014 pos = buffer; 1015 1016 num_rates = 0; 1017 for (i = 0; i < sband->n_bitrates; i++) { 1018 if ((BIT(i) & rate_mask) == 0) 1019 continue; /* skip rate */ 1020 rates[num_rates++] = (u8) (sband->bitrates[i].bitrate / 5); 1021 } 1022 1023 supp_rates_len = min_t(int, num_rates, 8); 1024 1025 *pos++ = WLAN_EID_SUPP_RATES; 1026 *pos++ = supp_rates_len; 1027 memcpy(pos, rates, supp_rates_len); 1028 pos += supp_rates_len; 1029 1030 /* insert "request information" if in custom IEs */ 1031 if (ie && ie_len) { 1032 static const u8 before_extrates[] = { 1033 WLAN_EID_SSID, 1034 WLAN_EID_SUPP_RATES, 1035 WLAN_EID_REQUEST, 1036 }; 1037 noffset = ieee80211_ie_split(ie, ie_len, 1038 before_extrates, 1039 ARRAY_SIZE(before_extrates), 1040 offset); 1041 memcpy(pos, ie + offset, noffset - offset); 1042 pos += noffset - offset; 1043 offset = noffset; 1044 } 1045 1046 ext_rates_len = num_rates - supp_rates_len; 1047 if (ext_rates_len > 0) { 1048 *pos++ = WLAN_EID_EXT_SUPP_RATES; 1049 *pos++ = ext_rates_len; 1050 memcpy(pos, rates + supp_rates_len, ext_rates_len); 1051 pos += ext_rates_len; 1052 } 1053 1054 if (channel && sband->band == IEEE80211_BAND_2GHZ) { 1055 *pos++ = WLAN_EID_DS_PARAMS; 1056 *pos++ = 1; 1057 *pos++ = channel; 1058 } 1059 1060 /* insert custom IEs that go before HT */ 1061 if (ie && ie_len) { 1062 static const u8 before_ht[] = { 1063 WLAN_EID_SSID, 1064 WLAN_EID_SUPP_RATES, 1065 WLAN_EID_REQUEST, 1066 WLAN_EID_EXT_SUPP_RATES, 1067 WLAN_EID_DS_PARAMS, 1068 WLAN_EID_SUPPORTED_REGULATORY_CLASSES, 1069 }; 1070 noffset = ieee80211_ie_split(ie, ie_len, 1071 before_ht, ARRAY_SIZE(before_ht), 1072 offset); 1073 memcpy(pos, ie + offset, noffset - offset); 1074 pos += noffset - offset; 1075 offset = noffset; 1076 } 1077 1078 if (sband->ht_cap.ht_supported) 1079 pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap, 1080 sband->ht_cap.cap); 1081 1082 /* 1083 * If adding more here, adjust code in main.c 1084 * that calculates local->scan_ies_len. 1085 */ 1086 1087 /* add any remaining custom IEs */ 1088 if (ie && ie_len) { 1089 noffset = ie_len; 1090 memcpy(pos, ie + offset, noffset - offset); 1091 pos += noffset - offset; 1092 } 1093 1094 if (sband->vht_cap.vht_supported) 1095 pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap, 1096 sband->vht_cap.cap); 1097 1098 return pos - buffer; 1099 } 1100 1101 struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata, 1102 u8 *dst, u32 ratemask, 1103 const u8 *ssid, size_t ssid_len, 1104 const u8 *ie, size_t ie_len, 1105 bool directed) 1106 { 1107 struct ieee80211_local *local = sdata->local; 1108 struct sk_buff *skb; 1109 struct ieee80211_mgmt *mgmt; 1110 size_t buf_len; 1111 u8 *buf; 1112 u8 chan; 1113 1114 /* FIXME: come up with a proper value */ 1115 buf = kmalloc(200 + ie_len, GFP_KERNEL); 1116 if (!buf) 1117 return NULL; 1118 1119 /* 1120 * Do not send DS Channel parameter for directed probe requests 1121 * in order to maximize the chance that we get a response. Some 1122 * badly-behaved APs don't respond when this parameter is included. 1123 */ 1124 if (directed) 1125 chan = 0; 1126 else 1127 chan = ieee80211_frequency_to_channel( 1128 local->hw.conf.channel->center_freq); 1129 1130 buf_len = ieee80211_build_preq_ies(local, buf, ie, ie_len, 1131 local->hw.conf.channel->band, 1132 ratemask, chan); 1133 1134 skb = ieee80211_probereq_get(&local->hw, &sdata->vif, 1135 ssid, ssid_len, 1136 buf, buf_len); 1137 if (!skb) 1138 goto out; 1139 1140 if (dst) { 1141 mgmt = (struct ieee80211_mgmt *) skb->data; 1142 memcpy(mgmt->da, dst, ETH_ALEN); 1143 memcpy(mgmt->bssid, dst, ETH_ALEN); 1144 } 1145 1146 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 1147 1148 out: 1149 kfree(buf); 1150 1151 return skb; 1152 } 1153 1154 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst, 1155 const u8 *ssid, size_t ssid_len, 1156 const u8 *ie, size_t ie_len, 1157 u32 ratemask, bool directed, bool no_cck) 1158 { 1159 struct sk_buff *skb; 1160 1161 skb = ieee80211_build_probe_req(sdata, dst, ratemask, ssid, ssid_len, 1162 ie, ie_len, directed); 1163 if (skb) { 1164 if (no_cck) 1165 IEEE80211_SKB_CB(skb)->flags |= 1166 IEEE80211_TX_CTL_NO_CCK_RATE; 1167 ieee80211_tx_skb(sdata, skb); 1168 } 1169 } 1170 1171 u32 ieee80211_sta_get_rates(struct ieee80211_local *local, 1172 struct ieee802_11_elems *elems, 1173 enum ieee80211_band band, u32 *basic_rates) 1174 { 1175 struct ieee80211_supported_band *sband; 1176 struct ieee80211_rate *bitrates; 1177 size_t num_rates; 1178 u32 supp_rates; 1179 int i, j; 1180 sband = local->hw.wiphy->bands[band]; 1181 1182 if (WARN_ON(!sband)) 1183 return 1; 1184 1185 bitrates = sband->bitrates; 1186 num_rates = sband->n_bitrates; 1187 supp_rates = 0; 1188 for (i = 0; i < elems->supp_rates_len + 1189 elems->ext_supp_rates_len; i++) { 1190 u8 rate = 0; 1191 int own_rate; 1192 bool is_basic; 1193 if (i < elems->supp_rates_len) 1194 rate = elems->supp_rates[i]; 1195 else if (elems->ext_supp_rates) 1196 rate = elems->ext_supp_rates 1197 [i - elems->supp_rates_len]; 1198 own_rate = 5 * (rate & 0x7f); 1199 is_basic = !!(rate & 0x80); 1200 1201 if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY) 1202 continue; 1203 1204 for (j = 0; j < num_rates; j++) { 1205 if (bitrates[j].bitrate == own_rate) { 1206 supp_rates |= BIT(j); 1207 if (basic_rates && is_basic) 1208 *basic_rates |= BIT(j); 1209 } 1210 } 1211 } 1212 return supp_rates; 1213 } 1214 1215 void ieee80211_stop_device(struct ieee80211_local *local) 1216 { 1217 ieee80211_led_radio(local, false); 1218 ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO); 1219 1220 cancel_work_sync(&local->reconfig_filter); 1221 1222 flush_workqueue(local->workqueue); 1223 drv_stop(local); 1224 } 1225 1226 int ieee80211_reconfig(struct ieee80211_local *local) 1227 { 1228 struct ieee80211_hw *hw = &local->hw; 1229 struct ieee80211_sub_if_data *sdata; 1230 struct sta_info *sta; 1231 int res, i; 1232 1233 #ifdef CONFIG_PM 1234 if (local->suspended) 1235 local->resuming = true; 1236 1237 if (local->wowlan) { 1238 local->wowlan = false; 1239 res = drv_resume(local); 1240 if (res < 0) { 1241 local->resuming = false; 1242 return res; 1243 } 1244 if (res == 0) 1245 goto wake_up; 1246 WARN_ON(res > 1); 1247 /* 1248 * res is 1, which means the driver requested 1249 * to go through a regular reset on wakeup. 1250 */ 1251 } 1252 #endif 1253 /* everything else happens only if HW was up & running */ 1254 if (!local->open_count) 1255 goto wake_up; 1256 1257 /* 1258 * Upon resume hardware can sometimes be goofy due to 1259 * various platform / driver / bus issues, so restarting 1260 * the device may at times not work immediately. Propagate 1261 * the error. 1262 */ 1263 res = drv_start(local); 1264 if (res) { 1265 WARN(local->suspended, "Hardware became unavailable " 1266 "upon resume. This could be a software issue " 1267 "prior to suspend or a hardware issue.\n"); 1268 return res; 1269 } 1270 1271 /* setup fragmentation threshold */ 1272 drv_set_frag_threshold(local, hw->wiphy->frag_threshold); 1273 1274 /* setup RTS threshold */ 1275 drv_set_rts_threshold(local, hw->wiphy->rts_threshold); 1276 1277 /* reset coverage class */ 1278 drv_set_coverage_class(local, hw->wiphy->coverage_class); 1279 1280 ieee80211_led_radio(local, true); 1281 ieee80211_mod_tpt_led_trig(local, 1282 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0); 1283 1284 /* add interfaces */ 1285 sdata = rtnl_dereference(local->monitor_sdata); 1286 if (sdata) { 1287 res = drv_add_interface(local, sdata); 1288 if (WARN_ON(res)) { 1289 rcu_assign_pointer(local->monitor_sdata, NULL); 1290 synchronize_net(); 1291 kfree(sdata); 1292 } 1293 } 1294 1295 list_for_each_entry(sdata, &local->interfaces, list) { 1296 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 1297 sdata->vif.type != NL80211_IFTYPE_MONITOR && 1298 ieee80211_sdata_running(sdata)) 1299 res = drv_add_interface(local, sdata); 1300 } 1301 1302 /* add STAs back */ 1303 mutex_lock(&local->sta_mtx); 1304 list_for_each_entry(sta, &local->sta_list, list) { 1305 enum ieee80211_sta_state state; 1306 1307 if (!sta->uploaded) 1308 continue; 1309 1310 /* AP-mode stations will be added later */ 1311 if (sta->sdata->vif.type == NL80211_IFTYPE_AP) 1312 continue; 1313 1314 for (state = IEEE80211_STA_NOTEXIST; 1315 state < sta->sta_state; state++) 1316 WARN_ON(drv_sta_state(local, sta->sdata, sta, state, 1317 state + 1)); 1318 } 1319 mutex_unlock(&local->sta_mtx); 1320 1321 /* reconfigure tx conf */ 1322 if (hw->queues >= IEEE80211_NUM_ACS) { 1323 list_for_each_entry(sdata, &local->interfaces, list) { 1324 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN || 1325 sdata->vif.type == NL80211_IFTYPE_MONITOR || 1326 !ieee80211_sdata_running(sdata)) 1327 continue; 1328 1329 for (i = 0; i < IEEE80211_NUM_ACS; i++) 1330 drv_conf_tx(local, sdata, i, 1331 &sdata->tx_conf[i]); 1332 } 1333 } 1334 1335 /* reconfigure hardware */ 1336 ieee80211_hw_config(local, ~0); 1337 1338 ieee80211_configure_filter(local); 1339 1340 /* Finally also reconfigure all the BSS information */ 1341 list_for_each_entry(sdata, &local->interfaces, list) { 1342 u32 changed; 1343 1344 if (!ieee80211_sdata_running(sdata)) 1345 continue; 1346 1347 /* common change flags for all interface types */ 1348 changed = BSS_CHANGED_ERP_CTS_PROT | 1349 BSS_CHANGED_ERP_PREAMBLE | 1350 BSS_CHANGED_ERP_SLOT | 1351 BSS_CHANGED_HT | 1352 BSS_CHANGED_BASIC_RATES | 1353 BSS_CHANGED_BEACON_INT | 1354 BSS_CHANGED_BSSID | 1355 BSS_CHANGED_CQM | 1356 BSS_CHANGED_QOS | 1357 BSS_CHANGED_IDLE; 1358 1359 switch (sdata->vif.type) { 1360 case NL80211_IFTYPE_STATION: 1361 changed |= BSS_CHANGED_ASSOC | 1362 BSS_CHANGED_ARP_FILTER; 1363 mutex_lock(&sdata->u.mgd.mtx); 1364 ieee80211_bss_info_change_notify(sdata, changed); 1365 mutex_unlock(&sdata->u.mgd.mtx); 1366 break; 1367 case NL80211_IFTYPE_ADHOC: 1368 changed |= BSS_CHANGED_IBSS; 1369 /* fall through */ 1370 case NL80211_IFTYPE_AP: 1371 changed |= BSS_CHANGED_SSID; 1372 1373 if (sdata->vif.type == NL80211_IFTYPE_AP) 1374 changed |= BSS_CHANGED_AP_PROBE_RESP; 1375 1376 /* fall through */ 1377 case NL80211_IFTYPE_MESH_POINT: 1378 changed |= BSS_CHANGED_BEACON | 1379 BSS_CHANGED_BEACON_ENABLED; 1380 ieee80211_bss_info_change_notify(sdata, changed); 1381 break; 1382 case NL80211_IFTYPE_WDS: 1383 break; 1384 case NL80211_IFTYPE_AP_VLAN: 1385 case NL80211_IFTYPE_MONITOR: 1386 /* ignore virtual */ 1387 break; 1388 case NL80211_IFTYPE_UNSPECIFIED: 1389 case NUM_NL80211_IFTYPES: 1390 case NL80211_IFTYPE_P2P_CLIENT: 1391 case NL80211_IFTYPE_P2P_GO: 1392 WARN_ON(1); 1393 break; 1394 } 1395 } 1396 1397 ieee80211_recalc_ps(local, -1); 1398 1399 /* 1400 * The sta might be in psm against the ap (e.g. because 1401 * this was the state before a hw restart), so we 1402 * explicitly send a null packet in order to make sure 1403 * it'll sync against the ap (and get out of psm). 1404 */ 1405 if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) { 1406 list_for_each_entry(sdata, &local->interfaces, list) { 1407 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1408 continue; 1409 1410 ieee80211_send_nullfunc(local, sdata, 0); 1411 } 1412 } 1413 1414 /* APs are now beaconing, add back stations */ 1415 mutex_lock(&local->sta_mtx); 1416 list_for_each_entry(sta, &local->sta_list, list) { 1417 enum ieee80211_sta_state state; 1418 1419 if (!sta->uploaded) 1420 continue; 1421 1422 if (sta->sdata->vif.type != NL80211_IFTYPE_AP) 1423 continue; 1424 1425 for (state = IEEE80211_STA_NOTEXIST; 1426 state < sta->sta_state; state++) 1427 WARN_ON(drv_sta_state(local, sta->sdata, sta, state, 1428 state + 1)); 1429 } 1430 mutex_unlock(&local->sta_mtx); 1431 1432 /* add back keys */ 1433 list_for_each_entry(sdata, &local->interfaces, list) 1434 if (ieee80211_sdata_running(sdata)) 1435 ieee80211_enable_keys(sdata); 1436 1437 wake_up: 1438 local->in_reconfig = false; 1439 barrier(); 1440 1441 /* 1442 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation 1443 * sessions can be established after a resume. 1444 * 1445 * Also tear down aggregation sessions since reconfiguring 1446 * them in a hardware restart scenario is not easily done 1447 * right now, and the hardware will have lost information 1448 * about the sessions, but we and the AP still think they 1449 * are active. This is really a workaround though. 1450 */ 1451 if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) { 1452 mutex_lock(&local->sta_mtx); 1453 1454 list_for_each_entry(sta, &local->sta_list, list) { 1455 ieee80211_sta_tear_down_BA_sessions(sta, true); 1456 clear_sta_flag(sta, WLAN_STA_BLOCK_BA); 1457 } 1458 1459 mutex_unlock(&local->sta_mtx); 1460 } 1461 1462 ieee80211_wake_queues_by_reason(hw, 1463 IEEE80211_QUEUE_STOP_REASON_SUSPEND); 1464 1465 /* 1466 * If this is for hw restart things are still running. 1467 * We may want to change that later, however. 1468 */ 1469 if (!local->suspended) 1470 return 0; 1471 1472 #ifdef CONFIG_PM 1473 /* first set suspended false, then resuming */ 1474 local->suspended = false; 1475 mb(); 1476 local->resuming = false; 1477 1478 list_for_each_entry(sdata, &local->interfaces, list) { 1479 switch(sdata->vif.type) { 1480 case NL80211_IFTYPE_STATION: 1481 ieee80211_sta_restart(sdata); 1482 break; 1483 case NL80211_IFTYPE_ADHOC: 1484 ieee80211_ibss_restart(sdata); 1485 break; 1486 case NL80211_IFTYPE_MESH_POINT: 1487 ieee80211_mesh_restart(sdata); 1488 break; 1489 default: 1490 break; 1491 } 1492 } 1493 1494 mod_timer(&local->sta_cleanup, jiffies + 1); 1495 1496 mutex_lock(&local->sta_mtx); 1497 list_for_each_entry(sta, &local->sta_list, list) 1498 mesh_plink_restart(sta); 1499 mutex_unlock(&local->sta_mtx); 1500 #else 1501 WARN_ON(1); 1502 #endif 1503 return 0; 1504 } 1505 1506 void ieee80211_resume_disconnect(struct ieee80211_vif *vif) 1507 { 1508 struct ieee80211_sub_if_data *sdata; 1509 struct ieee80211_local *local; 1510 struct ieee80211_key *key; 1511 1512 if (WARN_ON(!vif)) 1513 return; 1514 1515 sdata = vif_to_sdata(vif); 1516 local = sdata->local; 1517 1518 if (WARN_ON(!local->resuming)) 1519 return; 1520 1521 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION)) 1522 return; 1523 1524 sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME; 1525 1526 mutex_lock(&local->key_mtx); 1527 list_for_each_entry(key, &sdata->key_list, list) 1528 key->flags |= KEY_FLAG_TAINTED; 1529 mutex_unlock(&local->key_mtx); 1530 } 1531 EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect); 1532 1533 static int check_mgd_smps(struct ieee80211_if_managed *ifmgd, 1534 enum ieee80211_smps_mode *smps_mode) 1535 { 1536 if (ifmgd->associated) { 1537 *smps_mode = ifmgd->ap_smps; 1538 1539 if (*smps_mode == IEEE80211_SMPS_AUTOMATIC) { 1540 if (ifmgd->powersave) 1541 *smps_mode = IEEE80211_SMPS_DYNAMIC; 1542 else 1543 *smps_mode = IEEE80211_SMPS_OFF; 1544 } 1545 1546 return 1; 1547 } 1548 1549 return 0; 1550 } 1551 1552 /* must hold iflist_mtx */ 1553 void ieee80211_recalc_smps(struct ieee80211_local *local) 1554 { 1555 struct ieee80211_sub_if_data *sdata; 1556 enum ieee80211_smps_mode smps_mode = IEEE80211_SMPS_OFF; 1557 int count = 0; 1558 1559 lockdep_assert_held(&local->iflist_mtx); 1560 1561 /* 1562 * This function could be improved to handle multiple 1563 * interfaces better, but right now it makes any 1564 * non-station interfaces force SM PS to be turned 1565 * off. If there are multiple station interfaces it 1566 * could also use the best possible mode, e.g. if 1567 * one is in static and the other in dynamic then 1568 * dynamic is ok. 1569 */ 1570 1571 list_for_each_entry(sdata, &local->interfaces, list) { 1572 if (!ieee80211_sdata_running(sdata)) 1573 continue; 1574 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1575 goto set; 1576 1577 count += check_mgd_smps(&sdata->u.mgd, &smps_mode); 1578 1579 if (count > 1) { 1580 smps_mode = IEEE80211_SMPS_OFF; 1581 break; 1582 } 1583 } 1584 1585 if (smps_mode == local->smps_mode) 1586 return; 1587 1588 set: 1589 local->smps_mode = smps_mode; 1590 /* changed flag is auto-detected for this */ 1591 ieee80211_hw_config(local, 0); 1592 } 1593 1594 static bool ieee80211_id_in_list(const u8 *ids, int n_ids, u8 id) 1595 { 1596 int i; 1597 1598 for (i = 0; i < n_ids; i++) 1599 if (ids[i] == id) 1600 return true; 1601 return false; 1602 } 1603 1604 /** 1605 * ieee80211_ie_split - split an IE buffer according to ordering 1606 * 1607 * @ies: the IE buffer 1608 * @ielen: the length of the IE buffer 1609 * @ids: an array with element IDs that are allowed before 1610 * the split 1611 * @n_ids: the size of the element ID array 1612 * @offset: offset where to start splitting in the buffer 1613 * 1614 * This function splits an IE buffer by updating the @offset 1615 * variable to point to the location where the buffer should be 1616 * split. 1617 * 1618 * It assumes that the given IE buffer is well-formed, this 1619 * has to be guaranteed by the caller! 1620 * 1621 * It also assumes that the IEs in the buffer are ordered 1622 * correctly, if not the result of using this function will not 1623 * be ordered correctly either, i.e. it does no reordering. 1624 * 1625 * The function returns the offset where the next part of the 1626 * buffer starts, which may be @ielen if the entire (remainder) 1627 * of the buffer should be used. 1628 */ 1629 size_t ieee80211_ie_split(const u8 *ies, size_t ielen, 1630 const u8 *ids, int n_ids, size_t offset) 1631 { 1632 size_t pos = offset; 1633 1634 while (pos < ielen && ieee80211_id_in_list(ids, n_ids, ies[pos])) 1635 pos += 2 + ies[pos + 1]; 1636 1637 return pos; 1638 } 1639 1640 size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset) 1641 { 1642 size_t pos = offset; 1643 1644 while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC) 1645 pos += 2 + ies[pos + 1]; 1646 1647 return pos; 1648 } 1649 1650 static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata, 1651 int rssi_min_thold, 1652 int rssi_max_thold) 1653 { 1654 trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold); 1655 1656 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION)) 1657 return; 1658 1659 /* 1660 * Scale up threshold values before storing it, as the RSSI averaging 1661 * algorithm uses a scaled up value as well. Change this scaling 1662 * factor if the RSSI averaging algorithm changes. 1663 */ 1664 sdata->u.mgd.rssi_min_thold = rssi_min_thold*16; 1665 sdata->u.mgd.rssi_max_thold = rssi_max_thold*16; 1666 } 1667 1668 void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif, 1669 int rssi_min_thold, 1670 int rssi_max_thold) 1671 { 1672 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1673 1674 WARN_ON(rssi_min_thold == rssi_max_thold || 1675 rssi_min_thold > rssi_max_thold); 1676 1677 _ieee80211_enable_rssi_reports(sdata, rssi_min_thold, 1678 rssi_max_thold); 1679 } 1680 EXPORT_SYMBOL(ieee80211_enable_rssi_reports); 1681 1682 void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif) 1683 { 1684 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1685 1686 _ieee80211_enable_rssi_reports(sdata, 0, 0); 1687 } 1688 EXPORT_SYMBOL(ieee80211_disable_rssi_reports); 1689 1690 u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap, 1691 u16 cap) 1692 { 1693 __le16 tmp; 1694 1695 *pos++ = WLAN_EID_HT_CAPABILITY; 1696 *pos++ = sizeof(struct ieee80211_ht_cap); 1697 memset(pos, 0, sizeof(struct ieee80211_ht_cap)); 1698 1699 /* capability flags */ 1700 tmp = cpu_to_le16(cap); 1701 memcpy(pos, &tmp, sizeof(u16)); 1702 pos += sizeof(u16); 1703 1704 /* AMPDU parameters */ 1705 *pos++ = ht_cap->ampdu_factor | 1706 (ht_cap->ampdu_density << 1707 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT); 1708 1709 /* MCS set */ 1710 memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs)); 1711 pos += sizeof(ht_cap->mcs); 1712 1713 /* extended capabilities */ 1714 pos += sizeof(__le16); 1715 1716 /* BF capabilities */ 1717 pos += sizeof(__le32); 1718 1719 /* antenna selection */ 1720 pos += sizeof(u8); 1721 1722 return pos; 1723 } 1724 1725 u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap, 1726 u32 cap) 1727 { 1728 __le32 tmp; 1729 1730 *pos++ = WLAN_EID_VHT_CAPABILITY; 1731 *pos++ = sizeof(struct ieee80211_vht_capabilities); 1732 memset(pos, 0, sizeof(struct ieee80211_vht_capabilities)); 1733 1734 /* capability flags */ 1735 tmp = cpu_to_le32(cap); 1736 memcpy(pos, &tmp, sizeof(u32)); 1737 pos += sizeof(u32); 1738 1739 /* VHT MCS set */ 1740 memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs)); 1741 pos += sizeof(vht_cap->vht_mcs); 1742 1743 return pos; 1744 } 1745 1746 u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap, 1747 struct ieee80211_channel *channel, 1748 enum nl80211_channel_type channel_type, 1749 u16 prot_mode) 1750 { 1751 struct ieee80211_ht_operation *ht_oper; 1752 /* Build HT Information */ 1753 *pos++ = WLAN_EID_HT_OPERATION; 1754 *pos++ = sizeof(struct ieee80211_ht_operation); 1755 ht_oper = (struct ieee80211_ht_operation *)pos; 1756 ht_oper->primary_chan = 1757 ieee80211_frequency_to_channel(channel->center_freq); 1758 switch (channel_type) { 1759 case NL80211_CHAN_HT40MINUS: 1760 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW; 1761 break; 1762 case NL80211_CHAN_HT40PLUS: 1763 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 1764 break; 1765 case NL80211_CHAN_HT20: 1766 default: 1767 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE; 1768 break; 1769 } 1770 if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 && 1771 channel_type != NL80211_CHAN_NO_HT && 1772 channel_type != NL80211_CHAN_HT20) 1773 ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY; 1774 1775 ht_oper->operation_mode = cpu_to_le16(prot_mode); 1776 ht_oper->stbc_param = 0x0000; 1777 1778 /* It seems that Basic MCS set and Supported MCS set 1779 are identical for the first 10 bytes */ 1780 memset(&ht_oper->basic_set, 0, 16); 1781 memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10); 1782 1783 return pos + sizeof(struct ieee80211_ht_operation); 1784 } 1785 1786 enum nl80211_channel_type 1787 ieee80211_ht_oper_to_channel_type(struct ieee80211_ht_operation *ht_oper) 1788 { 1789 enum nl80211_channel_type channel_type; 1790 1791 if (!ht_oper) 1792 return NL80211_CHAN_NO_HT; 1793 1794 switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) { 1795 case IEEE80211_HT_PARAM_CHA_SEC_NONE: 1796 channel_type = NL80211_CHAN_HT20; 1797 break; 1798 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: 1799 channel_type = NL80211_CHAN_HT40PLUS; 1800 break; 1801 case IEEE80211_HT_PARAM_CHA_SEC_BELOW: 1802 channel_type = NL80211_CHAN_HT40MINUS; 1803 break; 1804 default: 1805 channel_type = NL80211_CHAN_NO_HT; 1806 } 1807 1808 return channel_type; 1809 } 1810 1811 int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata, 1812 struct sk_buff *skb, bool need_basic) 1813 { 1814 struct ieee80211_local *local = sdata->local; 1815 struct ieee80211_supported_band *sband; 1816 int rate; 1817 u8 i, rates, *pos; 1818 u32 basic_rates = sdata->vif.bss_conf.basic_rates; 1819 1820 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 1821 rates = sband->n_bitrates; 1822 if (rates > 8) 1823 rates = 8; 1824 1825 if (skb_tailroom(skb) < rates + 2) 1826 return -ENOMEM; 1827 1828 pos = skb_put(skb, rates + 2); 1829 *pos++ = WLAN_EID_SUPP_RATES; 1830 *pos++ = rates; 1831 for (i = 0; i < rates; i++) { 1832 u8 basic = 0; 1833 if (need_basic && basic_rates & BIT(i)) 1834 basic = 0x80; 1835 rate = sband->bitrates[i].bitrate; 1836 *pos++ = basic | (u8) (rate / 5); 1837 } 1838 1839 return 0; 1840 } 1841 1842 int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata, 1843 struct sk_buff *skb, bool need_basic) 1844 { 1845 struct ieee80211_local *local = sdata->local; 1846 struct ieee80211_supported_band *sband; 1847 int rate; 1848 u8 i, exrates, *pos; 1849 u32 basic_rates = sdata->vif.bss_conf.basic_rates; 1850 1851 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 1852 exrates = sband->n_bitrates; 1853 if (exrates > 8) 1854 exrates -= 8; 1855 else 1856 exrates = 0; 1857 1858 if (skb_tailroom(skb) < exrates + 2) 1859 return -ENOMEM; 1860 1861 if (exrates) { 1862 pos = skb_put(skb, exrates + 2); 1863 *pos++ = WLAN_EID_EXT_SUPP_RATES; 1864 *pos++ = exrates; 1865 for (i = 8; i < sband->n_bitrates; i++) { 1866 u8 basic = 0; 1867 if (need_basic && basic_rates & BIT(i)) 1868 basic = 0x80; 1869 rate = sband->bitrates[i].bitrate; 1870 *pos++ = basic | (u8) (rate / 5); 1871 } 1872 } 1873 return 0; 1874 } 1875 1876 int ieee80211_ave_rssi(struct ieee80211_vif *vif) 1877 { 1878 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1879 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1880 1881 if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) { 1882 /* non-managed type inferfaces */ 1883 return 0; 1884 } 1885 return ifmgd->ave_beacon_signal; 1886 } 1887 EXPORT_SYMBOL_GPL(ieee80211_ave_rssi); 1888