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