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