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/types.h> 17 #include <linux/slab.h> 18 #include <linux/skbuff.h> 19 #include <linux/etherdevice.h> 20 #include <linux/if_arp.h> 21 #include <linux/wireless.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 = tx->skb; 101 struct ieee80211_hdr *hdr; 102 103 do { 104 hdr = (struct ieee80211_hdr *) skb->data; 105 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 106 } while ((skb = skb->next)); 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 273 if (WARN_ON(queue >= hw->queues)) 274 return; 275 276 __clear_bit(reason, &local->queue_stop_reasons[queue]); 277 278 if (local->queue_stop_reasons[queue] != 0) 279 /* someone still has this queue stopped */ 280 return; 281 282 if (!skb_queue_empty(&local->pending[queue])) 283 tasklet_schedule(&local->tx_pending_tasklet); 284 } 285 286 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue, 287 enum queue_stop_reason reason) 288 { 289 struct ieee80211_local *local = hw_to_local(hw); 290 unsigned long flags; 291 292 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 293 __ieee80211_wake_queue(hw, queue, reason); 294 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 295 } 296 297 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue) 298 { 299 ieee80211_wake_queue_by_reason(hw, queue, 300 IEEE80211_QUEUE_STOP_REASON_DRIVER); 301 } 302 EXPORT_SYMBOL(ieee80211_wake_queue); 303 304 static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue, 305 enum queue_stop_reason reason) 306 { 307 struct ieee80211_local *local = hw_to_local(hw); 308 309 if (WARN_ON(queue >= hw->queues)) 310 return; 311 312 __set_bit(reason, &local->queue_stop_reasons[queue]); 313 } 314 315 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue, 316 enum queue_stop_reason reason) 317 { 318 struct ieee80211_local *local = hw_to_local(hw); 319 unsigned long flags; 320 321 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 322 __ieee80211_stop_queue(hw, queue, reason); 323 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 324 } 325 326 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue) 327 { 328 ieee80211_stop_queue_by_reason(hw, queue, 329 IEEE80211_QUEUE_STOP_REASON_DRIVER); 330 } 331 EXPORT_SYMBOL(ieee80211_stop_queue); 332 333 void ieee80211_add_pending_skb(struct ieee80211_local *local, 334 struct sk_buff *skb) 335 { 336 struct ieee80211_hw *hw = &local->hw; 337 unsigned long flags; 338 int queue = skb_get_queue_mapping(skb); 339 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 340 341 if (WARN_ON(!info->control.vif)) { 342 kfree_skb(skb); 343 return; 344 } 345 346 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 347 __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 348 __skb_queue_tail(&local->pending[queue], skb); 349 __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 350 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 351 } 352 353 int ieee80211_add_pending_skbs(struct ieee80211_local *local, 354 struct sk_buff_head *skbs) 355 { 356 struct ieee80211_hw *hw = &local->hw; 357 struct sk_buff *skb; 358 unsigned long flags; 359 int queue, ret = 0, i; 360 361 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 362 for (i = 0; i < hw->queues; i++) 363 __ieee80211_stop_queue(hw, i, 364 IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 365 366 while ((skb = skb_dequeue(skbs))) { 367 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 368 369 if (WARN_ON(!info->control.vif)) { 370 kfree_skb(skb); 371 continue; 372 } 373 374 ret++; 375 queue = skb_get_queue_mapping(skb); 376 __skb_queue_tail(&local->pending[queue], skb); 377 } 378 379 for (i = 0; i < hw->queues; i++) 380 __ieee80211_wake_queue(hw, i, 381 IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 382 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 383 384 return ret; 385 } 386 387 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw, 388 enum queue_stop_reason reason) 389 { 390 struct ieee80211_local *local = hw_to_local(hw); 391 unsigned long flags; 392 int i; 393 394 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 395 396 for (i = 0; i < hw->queues; i++) 397 __ieee80211_stop_queue(hw, i, reason); 398 399 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 400 } 401 402 void ieee80211_stop_queues(struct ieee80211_hw *hw) 403 { 404 ieee80211_stop_queues_by_reason(hw, 405 IEEE80211_QUEUE_STOP_REASON_DRIVER); 406 } 407 EXPORT_SYMBOL(ieee80211_stop_queues); 408 409 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue) 410 { 411 struct ieee80211_local *local = hw_to_local(hw); 412 unsigned long flags; 413 int ret; 414 415 if (WARN_ON(queue >= hw->queues)) 416 return true; 417 418 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 419 ret = !!local->queue_stop_reasons[queue]; 420 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 421 return ret; 422 } 423 EXPORT_SYMBOL(ieee80211_queue_stopped); 424 425 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw, 426 enum queue_stop_reason reason) 427 { 428 struct ieee80211_local *local = hw_to_local(hw); 429 unsigned long flags; 430 int i; 431 432 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 433 434 for (i = 0; i < hw->queues; i++) 435 __ieee80211_wake_queue(hw, i, reason); 436 437 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 438 } 439 440 void ieee80211_wake_queues(struct ieee80211_hw *hw) 441 { 442 ieee80211_wake_queues_by_reason(hw, IEEE80211_QUEUE_STOP_REASON_DRIVER); 443 } 444 EXPORT_SYMBOL(ieee80211_wake_queues); 445 446 void ieee80211_iterate_active_interfaces( 447 struct ieee80211_hw *hw, 448 void (*iterator)(void *data, u8 *mac, 449 struct ieee80211_vif *vif), 450 void *data) 451 { 452 struct ieee80211_local *local = hw_to_local(hw); 453 struct ieee80211_sub_if_data *sdata; 454 455 mutex_lock(&local->iflist_mtx); 456 457 list_for_each_entry(sdata, &local->interfaces, list) { 458 switch (sdata->vif.type) { 459 case __NL80211_IFTYPE_AFTER_LAST: 460 case NL80211_IFTYPE_UNSPECIFIED: 461 case NL80211_IFTYPE_MONITOR: 462 case NL80211_IFTYPE_AP_VLAN: 463 continue; 464 case NL80211_IFTYPE_AP: 465 case NL80211_IFTYPE_STATION: 466 case NL80211_IFTYPE_ADHOC: 467 case NL80211_IFTYPE_WDS: 468 case NL80211_IFTYPE_MESH_POINT: 469 break; 470 } 471 if (netif_running(sdata->dev)) 472 iterator(data, sdata->dev->dev_addr, 473 &sdata->vif); 474 } 475 476 mutex_unlock(&local->iflist_mtx); 477 } 478 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces); 479 480 void ieee80211_iterate_active_interfaces_atomic( 481 struct ieee80211_hw *hw, 482 void (*iterator)(void *data, u8 *mac, 483 struct ieee80211_vif *vif), 484 void *data) 485 { 486 struct ieee80211_local *local = hw_to_local(hw); 487 struct ieee80211_sub_if_data *sdata; 488 489 rcu_read_lock(); 490 491 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 492 switch (sdata->vif.type) { 493 case __NL80211_IFTYPE_AFTER_LAST: 494 case NL80211_IFTYPE_UNSPECIFIED: 495 case NL80211_IFTYPE_MONITOR: 496 case NL80211_IFTYPE_AP_VLAN: 497 continue; 498 case NL80211_IFTYPE_AP: 499 case NL80211_IFTYPE_STATION: 500 case NL80211_IFTYPE_ADHOC: 501 case NL80211_IFTYPE_WDS: 502 case NL80211_IFTYPE_MESH_POINT: 503 break; 504 } 505 if (netif_running(sdata->dev)) 506 iterator(data, sdata->dev->dev_addr, 507 &sdata->vif); 508 } 509 510 rcu_read_unlock(); 511 } 512 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic); 513 514 /* 515 * Nothing should have been stuffed into the workqueue during 516 * the suspend->resume cycle. If this WARN is seen then there 517 * is a bug with either the driver suspend or something in 518 * mac80211 stuffing into the workqueue which we haven't yet 519 * cleared during mac80211's suspend cycle. 520 */ 521 static bool ieee80211_can_queue_work(struct ieee80211_local *local) 522 { 523 if (WARN(local->suspended && !local->resuming, 524 "queueing ieee80211 work while going to suspend\n")) 525 return false; 526 527 return true; 528 } 529 530 void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work) 531 { 532 struct ieee80211_local *local = hw_to_local(hw); 533 534 if (!ieee80211_can_queue_work(local)) 535 return; 536 537 queue_work(local->workqueue, work); 538 } 539 EXPORT_SYMBOL(ieee80211_queue_work); 540 541 void ieee80211_queue_delayed_work(struct ieee80211_hw *hw, 542 struct delayed_work *dwork, 543 unsigned long delay) 544 { 545 struct ieee80211_local *local = hw_to_local(hw); 546 547 if (!ieee80211_can_queue_work(local)) 548 return; 549 550 queue_delayed_work(local->workqueue, dwork, delay); 551 } 552 EXPORT_SYMBOL(ieee80211_queue_delayed_work); 553 554 void ieee802_11_parse_elems(u8 *start, size_t len, 555 struct ieee802_11_elems *elems) 556 { 557 ieee802_11_parse_elems_crc(start, len, elems, 0, 0); 558 } 559 560 u32 ieee802_11_parse_elems_crc(u8 *start, size_t len, 561 struct ieee802_11_elems *elems, 562 u64 filter, u32 crc) 563 { 564 size_t left = len; 565 u8 *pos = start; 566 bool calc_crc = filter != 0; 567 568 memset(elems, 0, sizeof(*elems)); 569 elems->ie_start = start; 570 elems->total_len = len; 571 572 while (left >= 2) { 573 u8 id, elen; 574 575 id = *pos++; 576 elen = *pos++; 577 left -= 2; 578 579 if (elen > left) 580 break; 581 582 if (calc_crc && id < 64 && (filter & (1ULL << id))) 583 crc = crc32_be(crc, pos - 2, elen + 2); 584 585 switch (id) { 586 case WLAN_EID_SSID: 587 elems->ssid = pos; 588 elems->ssid_len = elen; 589 break; 590 case WLAN_EID_SUPP_RATES: 591 elems->supp_rates = pos; 592 elems->supp_rates_len = elen; 593 break; 594 case WLAN_EID_FH_PARAMS: 595 elems->fh_params = pos; 596 elems->fh_params_len = elen; 597 break; 598 case WLAN_EID_DS_PARAMS: 599 elems->ds_params = pos; 600 elems->ds_params_len = elen; 601 break; 602 case WLAN_EID_CF_PARAMS: 603 elems->cf_params = pos; 604 elems->cf_params_len = elen; 605 break; 606 case WLAN_EID_TIM: 607 if (elen >= sizeof(struct ieee80211_tim_ie)) { 608 elems->tim = (void *)pos; 609 elems->tim_len = elen; 610 } 611 break; 612 case WLAN_EID_IBSS_PARAMS: 613 elems->ibss_params = pos; 614 elems->ibss_params_len = elen; 615 break; 616 case WLAN_EID_CHALLENGE: 617 elems->challenge = pos; 618 elems->challenge_len = elen; 619 break; 620 case WLAN_EID_VENDOR_SPECIFIC: 621 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 && 622 pos[2] == 0xf2) { 623 /* Microsoft OUI (00:50:F2) */ 624 625 if (calc_crc) 626 crc = crc32_be(crc, pos - 2, elen + 2); 627 628 if (pos[3] == 1) { 629 /* OUI Type 1 - WPA IE */ 630 elems->wpa = pos; 631 elems->wpa_len = elen; 632 } else if (elen >= 5 && pos[3] == 2) { 633 /* OUI Type 2 - WMM IE */ 634 if (pos[4] == 0) { 635 elems->wmm_info = pos; 636 elems->wmm_info_len = elen; 637 } else if (pos[4] == 1) { 638 elems->wmm_param = pos; 639 elems->wmm_param_len = elen; 640 } 641 } 642 } 643 break; 644 case WLAN_EID_RSN: 645 elems->rsn = pos; 646 elems->rsn_len = elen; 647 break; 648 case WLAN_EID_ERP_INFO: 649 elems->erp_info = pos; 650 elems->erp_info_len = elen; 651 break; 652 case WLAN_EID_EXT_SUPP_RATES: 653 elems->ext_supp_rates = pos; 654 elems->ext_supp_rates_len = elen; 655 break; 656 case WLAN_EID_HT_CAPABILITY: 657 if (elen >= sizeof(struct ieee80211_ht_cap)) 658 elems->ht_cap_elem = (void *)pos; 659 break; 660 case WLAN_EID_HT_INFORMATION: 661 if (elen >= sizeof(struct ieee80211_ht_info)) 662 elems->ht_info_elem = (void *)pos; 663 break; 664 case WLAN_EID_MESH_ID: 665 elems->mesh_id = pos; 666 elems->mesh_id_len = elen; 667 break; 668 case WLAN_EID_MESH_CONFIG: 669 if (elen >= sizeof(struct ieee80211_meshconf_ie)) 670 elems->mesh_config = (void *)pos; 671 break; 672 case WLAN_EID_PEER_LINK: 673 elems->peer_link = pos; 674 elems->peer_link_len = elen; 675 break; 676 case WLAN_EID_PREQ: 677 elems->preq = pos; 678 elems->preq_len = elen; 679 break; 680 case WLAN_EID_PREP: 681 elems->prep = pos; 682 elems->prep_len = elen; 683 break; 684 case WLAN_EID_PERR: 685 elems->perr = pos; 686 elems->perr_len = elen; 687 break; 688 case WLAN_EID_RANN: 689 if (elen >= sizeof(struct ieee80211_rann_ie)) 690 elems->rann = (void *)pos; 691 break; 692 case WLAN_EID_CHANNEL_SWITCH: 693 elems->ch_switch_elem = pos; 694 elems->ch_switch_elem_len = elen; 695 break; 696 case WLAN_EID_QUIET: 697 if (!elems->quiet_elem) { 698 elems->quiet_elem = pos; 699 elems->quiet_elem_len = elen; 700 } 701 elems->num_of_quiet_elem++; 702 break; 703 case WLAN_EID_COUNTRY: 704 elems->country_elem = pos; 705 elems->country_elem_len = elen; 706 break; 707 case WLAN_EID_PWR_CONSTRAINT: 708 elems->pwr_constr_elem = pos; 709 elems->pwr_constr_elem_len = elen; 710 break; 711 case WLAN_EID_TIMEOUT_INTERVAL: 712 elems->timeout_int = pos; 713 elems->timeout_int_len = elen; 714 break; 715 default: 716 break; 717 } 718 719 left -= elen; 720 pos += elen; 721 } 722 723 return crc; 724 } 725 726 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata) 727 { 728 struct ieee80211_local *local = sdata->local; 729 struct ieee80211_tx_queue_params qparam; 730 int queue; 731 bool use_11b; 732 int aCWmin, aCWmax; 733 734 if (!local->ops->conf_tx) 735 return; 736 737 memset(&qparam, 0, sizeof(qparam)); 738 739 use_11b = (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) && 740 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE); 741 742 for (queue = 0; queue < local_to_hw(local)->queues; queue++) { 743 /* Set defaults according to 802.11-2007 Table 7-37 */ 744 aCWmax = 1023; 745 if (use_11b) 746 aCWmin = 31; 747 else 748 aCWmin = 15; 749 750 switch (queue) { 751 case 3: /* AC_BK */ 752 qparam.cw_max = aCWmax; 753 qparam.cw_min = aCWmin; 754 qparam.txop = 0; 755 qparam.aifs = 7; 756 break; 757 default: /* never happens but let's not leave undefined */ 758 case 2: /* AC_BE */ 759 qparam.cw_max = aCWmax; 760 qparam.cw_min = aCWmin; 761 qparam.txop = 0; 762 qparam.aifs = 3; 763 break; 764 case 1: /* AC_VI */ 765 qparam.cw_max = aCWmin; 766 qparam.cw_min = (aCWmin + 1) / 2 - 1; 767 if (use_11b) 768 qparam.txop = 6016/32; 769 else 770 qparam.txop = 3008/32; 771 qparam.aifs = 2; 772 break; 773 case 0: /* AC_VO */ 774 qparam.cw_max = (aCWmin + 1) / 2 - 1; 775 qparam.cw_min = (aCWmin + 1) / 4 - 1; 776 if (use_11b) 777 qparam.txop = 3264/32; 778 else 779 qparam.txop = 1504/32; 780 qparam.aifs = 2; 781 break; 782 } 783 784 drv_conf_tx(local, queue, &qparam); 785 } 786 } 787 788 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata, 789 const size_t supp_rates_len, 790 const u8 *supp_rates) 791 { 792 struct ieee80211_local *local = sdata->local; 793 int i, have_higher_than_11mbit = 0; 794 795 /* cf. IEEE 802.11 9.2.12 */ 796 for (i = 0; i < supp_rates_len; i++) 797 if ((supp_rates[i] & 0x7f) * 5 > 110) 798 have_higher_than_11mbit = 1; 799 800 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ && 801 have_higher_than_11mbit) 802 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE; 803 else 804 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE; 805 806 ieee80211_set_wmm_default(sdata); 807 } 808 809 u32 ieee80211_mandatory_rates(struct ieee80211_local *local, 810 enum ieee80211_band band) 811 { 812 struct ieee80211_supported_band *sband; 813 struct ieee80211_rate *bitrates; 814 u32 mandatory_rates; 815 enum ieee80211_rate_flags mandatory_flag; 816 int i; 817 818 sband = local->hw.wiphy->bands[band]; 819 if (!sband) { 820 WARN_ON(1); 821 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 822 } 823 824 if (band == IEEE80211_BAND_2GHZ) 825 mandatory_flag = IEEE80211_RATE_MANDATORY_B; 826 else 827 mandatory_flag = IEEE80211_RATE_MANDATORY_A; 828 829 bitrates = sband->bitrates; 830 mandatory_rates = 0; 831 for (i = 0; i < sband->n_bitrates; i++) 832 if (bitrates[i].flags & mandatory_flag) 833 mandatory_rates |= BIT(i); 834 return mandatory_rates; 835 } 836 837 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata, 838 u16 transaction, u16 auth_alg, 839 u8 *extra, size_t extra_len, const u8 *bssid, 840 const u8 *key, u8 key_len, u8 key_idx) 841 { 842 struct ieee80211_local *local = sdata->local; 843 struct sk_buff *skb; 844 struct ieee80211_mgmt *mgmt; 845 int err; 846 847 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 848 sizeof(*mgmt) + 6 + extra_len); 849 if (!skb) { 850 printk(KERN_DEBUG "%s: failed to allocate buffer for auth " 851 "frame\n", sdata->dev->name); 852 return; 853 } 854 skb_reserve(skb, local->hw.extra_tx_headroom); 855 856 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6); 857 memset(mgmt, 0, 24 + 6); 858 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 859 IEEE80211_STYPE_AUTH); 860 memcpy(mgmt->da, bssid, ETH_ALEN); 861 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); 862 memcpy(mgmt->bssid, bssid, ETH_ALEN); 863 mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg); 864 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction); 865 mgmt->u.auth.status_code = cpu_to_le16(0); 866 if (extra) 867 memcpy(skb_put(skb, extra_len), extra, extra_len); 868 869 if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) { 870 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 871 err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx); 872 WARN_ON(err); 873 } 874 875 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 876 ieee80211_tx_skb(sdata, skb); 877 } 878 879 int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer, 880 const u8 *ie, size_t ie_len, 881 enum ieee80211_band band) 882 { 883 struct ieee80211_supported_band *sband; 884 u8 *pos, *supp_rates_len, *esupp_rates_len = NULL; 885 int i; 886 887 sband = local->hw.wiphy->bands[band]; 888 889 pos = buffer; 890 891 *pos++ = WLAN_EID_SUPP_RATES; 892 supp_rates_len = pos; 893 *pos++ = 0; 894 895 for (i = 0; i < sband->n_bitrates; i++) { 896 struct ieee80211_rate *rate = &sband->bitrates[i]; 897 898 if (esupp_rates_len) { 899 *esupp_rates_len += 1; 900 } else if (*supp_rates_len == 8) { 901 *pos++ = WLAN_EID_EXT_SUPP_RATES; 902 esupp_rates_len = pos; 903 *pos++ = 1; 904 } else 905 *supp_rates_len += 1; 906 907 *pos++ = rate->bitrate / 5; 908 } 909 910 if (sband->ht_cap.ht_supported) { 911 __le16 tmp = cpu_to_le16(sband->ht_cap.cap); 912 913 *pos++ = WLAN_EID_HT_CAPABILITY; 914 *pos++ = sizeof(struct ieee80211_ht_cap); 915 memset(pos, 0, sizeof(struct ieee80211_ht_cap)); 916 memcpy(pos, &tmp, sizeof(u16)); 917 pos += sizeof(u16); 918 /* TODO: needs a define here for << 2 */ 919 *pos++ = sband->ht_cap.ampdu_factor | 920 (sband->ht_cap.ampdu_density << 2); 921 memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs)); 922 pos += sizeof(sband->ht_cap.mcs); 923 pos += 2 + 4 + 1; /* ext info, BF cap, antsel */ 924 } 925 926 /* 927 * If adding more here, adjust code in main.c 928 * that calculates local->scan_ies_len. 929 */ 930 931 if (ie) { 932 memcpy(pos, ie, ie_len); 933 pos += ie_len; 934 } 935 936 return pos - buffer; 937 } 938 939 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst, 940 const u8 *ssid, size_t ssid_len, 941 const u8 *ie, size_t ie_len) 942 { 943 struct ieee80211_local *local = sdata->local; 944 struct sk_buff *skb; 945 struct ieee80211_mgmt *mgmt; 946 u8 *pos; 947 948 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 200 + 949 ie_len); 950 if (!skb) { 951 printk(KERN_DEBUG "%s: failed to allocate buffer for probe " 952 "request\n", sdata->dev->name); 953 return; 954 } 955 skb_reserve(skb, local->hw.extra_tx_headroom); 956 957 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 958 memset(mgmt, 0, 24); 959 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 960 IEEE80211_STYPE_PROBE_REQ); 961 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); 962 if (dst) { 963 memcpy(mgmt->da, dst, ETH_ALEN); 964 memcpy(mgmt->bssid, dst, ETH_ALEN); 965 } else { 966 memset(mgmt->da, 0xff, ETH_ALEN); 967 memset(mgmt->bssid, 0xff, ETH_ALEN); 968 } 969 pos = skb_put(skb, 2 + ssid_len); 970 *pos++ = WLAN_EID_SSID; 971 *pos++ = ssid_len; 972 memcpy(pos, ssid, ssid_len); 973 pos += ssid_len; 974 975 skb_put(skb, ieee80211_build_preq_ies(local, pos, ie, ie_len, 976 local->hw.conf.channel->band)); 977 978 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 979 ieee80211_tx_skb(sdata, skb); 980 } 981 982 u32 ieee80211_sta_get_rates(struct ieee80211_local *local, 983 struct ieee802_11_elems *elems, 984 enum ieee80211_band band) 985 { 986 struct ieee80211_supported_band *sband; 987 struct ieee80211_rate *bitrates; 988 size_t num_rates; 989 u32 supp_rates; 990 int i, j; 991 sband = local->hw.wiphy->bands[band]; 992 993 if (!sband) { 994 WARN_ON(1); 995 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 996 } 997 998 bitrates = sband->bitrates; 999 num_rates = sband->n_bitrates; 1000 supp_rates = 0; 1001 for (i = 0; i < elems->supp_rates_len + 1002 elems->ext_supp_rates_len; i++) { 1003 u8 rate = 0; 1004 int own_rate; 1005 if (i < elems->supp_rates_len) 1006 rate = elems->supp_rates[i]; 1007 else if (elems->ext_supp_rates) 1008 rate = elems->ext_supp_rates 1009 [i - elems->supp_rates_len]; 1010 own_rate = 5 * (rate & 0x7f); 1011 for (j = 0; j < num_rates; j++) 1012 if (bitrates[j].bitrate == own_rate) 1013 supp_rates |= BIT(j); 1014 } 1015 return supp_rates; 1016 } 1017 1018 void ieee80211_stop_device(struct ieee80211_local *local) 1019 { 1020 ieee80211_led_radio(local, false); 1021 1022 cancel_work_sync(&local->reconfig_filter); 1023 drv_stop(local); 1024 1025 flush_workqueue(local->workqueue); 1026 } 1027 1028 int ieee80211_reconfig(struct ieee80211_local *local) 1029 { 1030 struct ieee80211_hw *hw = &local->hw; 1031 struct ieee80211_sub_if_data *sdata; 1032 struct ieee80211_if_init_conf conf; 1033 struct sta_info *sta; 1034 unsigned long flags; 1035 int res; 1036 1037 if (local->suspended) 1038 local->resuming = true; 1039 1040 /* restart hardware */ 1041 if (local->open_count) { 1042 /* 1043 * Upon resume hardware can sometimes be goofy due to 1044 * various platform / driver / bus issues, so restarting 1045 * the device may at times not work immediately. Propagate 1046 * the error. 1047 */ 1048 res = drv_start(local); 1049 if (res) { 1050 WARN(local->suspended, "Harware became unavailable " 1051 "upon resume. This is could be a software issue" 1052 "prior to suspend or a harware issue\n"); 1053 return res; 1054 } 1055 1056 ieee80211_led_radio(local, true); 1057 } 1058 1059 /* add interfaces */ 1060 list_for_each_entry(sdata, &local->interfaces, list) { 1061 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 1062 sdata->vif.type != NL80211_IFTYPE_MONITOR && 1063 netif_running(sdata->dev)) { 1064 conf.vif = &sdata->vif; 1065 conf.type = sdata->vif.type; 1066 conf.mac_addr = sdata->dev->dev_addr; 1067 res = drv_add_interface(local, &conf); 1068 } 1069 } 1070 1071 /* add STAs back */ 1072 if (local->ops->sta_notify) { 1073 spin_lock_irqsave(&local->sta_lock, flags); 1074 list_for_each_entry(sta, &local->sta_list, list) { 1075 sdata = sta->sdata; 1076 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 1077 sdata = container_of(sdata->bss, 1078 struct ieee80211_sub_if_data, 1079 u.ap); 1080 1081 drv_sta_notify(local, &sdata->vif, STA_NOTIFY_ADD, 1082 &sta->sta); 1083 } 1084 spin_unlock_irqrestore(&local->sta_lock, flags); 1085 } 1086 1087 /* Clear Suspend state so that ADDBA requests can be processed */ 1088 1089 rcu_read_lock(); 1090 1091 if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) { 1092 list_for_each_entry_rcu(sta, &local->sta_list, list) { 1093 clear_sta_flags(sta, WLAN_STA_SUSPEND); 1094 } 1095 } 1096 1097 rcu_read_unlock(); 1098 1099 /* setup RTS threshold */ 1100 drv_set_rts_threshold(local, hw->wiphy->rts_threshold); 1101 1102 /* reconfigure hardware */ 1103 ieee80211_hw_config(local, ~0); 1104 1105 ieee80211_configure_filter(local); 1106 1107 /* Finally also reconfigure all the BSS information */ 1108 list_for_each_entry(sdata, &local->interfaces, list) { 1109 u32 changed = ~0; 1110 if (!netif_running(sdata->dev)) 1111 continue; 1112 switch (sdata->vif.type) { 1113 case NL80211_IFTYPE_STATION: 1114 /* disable beacon change bits */ 1115 changed &= ~(BSS_CHANGED_BEACON | 1116 BSS_CHANGED_BEACON_ENABLED); 1117 /* fall through */ 1118 case NL80211_IFTYPE_ADHOC: 1119 case NL80211_IFTYPE_AP: 1120 case NL80211_IFTYPE_MESH_POINT: 1121 ieee80211_bss_info_change_notify(sdata, changed); 1122 break; 1123 case NL80211_IFTYPE_WDS: 1124 break; 1125 case NL80211_IFTYPE_AP_VLAN: 1126 case NL80211_IFTYPE_MONITOR: 1127 /* ignore virtual */ 1128 break; 1129 case NL80211_IFTYPE_UNSPECIFIED: 1130 case __NL80211_IFTYPE_AFTER_LAST: 1131 WARN_ON(1); 1132 break; 1133 } 1134 } 1135 1136 /* add back keys */ 1137 list_for_each_entry(sdata, &local->interfaces, list) 1138 if (netif_running(sdata->dev)) 1139 ieee80211_enable_keys(sdata); 1140 1141 ieee80211_wake_queues_by_reason(hw, 1142 IEEE80211_QUEUE_STOP_REASON_SUSPEND); 1143 1144 /* 1145 * If this is for hw restart things are still running. 1146 * We may want to change that later, however. 1147 */ 1148 if (!local->suspended) 1149 return 0; 1150 1151 #ifdef CONFIG_PM 1152 /* first set suspended false, then resuming */ 1153 local->suspended = false; 1154 mb(); 1155 local->resuming = false; 1156 1157 list_for_each_entry(sdata, &local->interfaces, list) { 1158 switch(sdata->vif.type) { 1159 case NL80211_IFTYPE_STATION: 1160 ieee80211_sta_restart(sdata); 1161 break; 1162 case NL80211_IFTYPE_ADHOC: 1163 ieee80211_ibss_restart(sdata); 1164 break; 1165 case NL80211_IFTYPE_MESH_POINT: 1166 ieee80211_mesh_restart(sdata); 1167 break; 1168 default: 1169 break; 1170 } 1171 } 1172 1173 add_timer(&local->sta_cleanup); 1174 1175 spin_lock_irqsave(&local->sta_lock, flags); 1176 list_for_each_entry(sta, &local->sta_list, list) 1177 mesh_plink_restart(sta); 1178 spin_unlock_irqrestore(&local->sta_lock, flags); 1179 #else 1180 WARN_ON(1); 1181 #endif 1182 return 0; 1183 } 1184 1185