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