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 35 /* privid for wiphys to determine whether they belong to us or not */ 36 void *mac80211_wiphy_privid = &mac80211_wiphy_privid; 37 38 struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy) 39 { 40 struct ieee80211_local *local; 41 BUG_ON(!wiphy); 42 43 local = wiphy_priv(wiphy); 44 return &local->hw; 45 } 46 EXPORT_SYMBOL(wiphy_to_ieee80211_hw); 47 48 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len, 49 enum nl80211_iftype type) 50 { 51 __le16 fc = hdr->frame_control; 52 53 /* drop ACK/CTS frames and incorrect hdr len (ctrl) */ 54 if (len < 16) 55 return NULL; 56 57 if (ieee80211_is_data(fc)) { 58 if (len < 24) /* drop incorrect hdr len (data) */ 59 return NULL; 60 61 if (ieee80211_has_a4(fc)) 62 return NULL; 63 if (ieee80211_has_tods(fc)) 64 return hdr->addr1; 65 if (ieee80211_has_fromds(fc)) 66 return hdr->addr2; 67 68 return hdr->addr3; 69 } 70 71 if (ieee80211_is_mgmt(fc)) { 72 if (len < 24) /* drop incorrect hdr len (mgmt) */ 73 return NULL; 74 return hdr->addr3; 75 } 76 77 if (ieee80211_is_ctl(fc)) { 78 if(ieee80211_is_pspoll(fc)) 79 return hdr->addr1; 80 81 if (ieee80211_is_back_req(fc)) { 82 switch (type) { 83 case NL80211_IFTYPE_STATION: 84 return hdr->addr2; 85 case NL80211_IFTYPE_AP: 86 case NL80211_IFTYPE_AP_VLAN: 87 return hdr->addr1; 88 default: 89 break; /* fall through to the return */ 90 } 91 } 92 } 93 94 return NULL; 95 } 96 97 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx) 98 { 99 struct sk_buff *skb = tx->skb; 100 struct ieee80211_hdr *hdr; 101 102 do { 103 hdr = (struct ieee80211_hdr *) skb->data; 104 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 105 } while ((skb = skb->next)); 106 } 107 108 int ieee80211_frame_duration(struct ieee80211_local *local, size_t len, 109 int rate, int erp, int short_preamble) 110 { 111 int dur; 112 113 /* calculate duration (in microseconds, rounded up to next higher 114 * integer if it includes a fractional microsecond) to send frame of 115 * len bytes (does not include FCS) at the given rate. Duration will 116 * also include SIFS. 117 * 118 * rate is in 100 kbps, so divident is multiplied by 10 in the 119 * DIV_ROUND_UP() operations. 120 */ 121 122 if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ || erp) { 123 /* 124 * OFDM: 125 * 126 * N_DBPS = DATARATE x 4 127 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS) 128 * (16 = SIGNAL time, 6 = tail bits) 129 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext 130 * 131 * T_SYM = 4 usec 132 * 802.11a - 17.5.2: aSIFSTime = 16 usec 133 * 802.11g - 19.8.4: aSIFSTime = 10 usec + 134 * signal ext = 6 usec 135 */ 136 dur = 16; /* SIFS + signal ext */ 137 dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */ 138 dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */ 139 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10, 140 4 * rate); /* T_SYM x N_SYM */ 141 } else { 142 /* 143 * 802.11b or 802.11g with 802.11b compatibility: 144 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime + 145 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0. 146 * 147 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4 148 * aSIFSTime = 10 usec 149 * aPreambleLength = 144 usec or 72 usec with short preamble 150 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble 151 */ 152 dur = 10; /* aSIFSTime = 10 usec */ 153 dur += short_preamble ? (72 + 24) : (144 + 48); 154 155 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate); 156 } 157 158 return dur; 159 } 160 161 /* Exported duration function for driver use */ 162 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw, 163 struct ieee80211_vif *vif, 164 size_t frame_len, 165 struct ieee80211_rate *rate) 166 { 167 struct ieee80211_local *local = hw_to_local(hw); 168 struct ieee80211_sub_if_data *sdata; 169 u16 dur; 170 int erp; 171 bool short_preamble = false; 172 173 erp = 0; 174 if (vif) { 175 sdata = vif_to_sdata(vif); 176 short_preamble = sdata->vif.bss_conf.use_short_preamble; 177 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 178 erp = rate->flags & IEEE80211_RATE_ERP_G; 179 } 180 181 dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, erp, 182 short_preamble); 183 184 return cpu_to_le16(dur); 185 } 186 EXPORT_SYMBOL(ieee80211_generic_frame_duration); 187 188 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw, 189 struct ieee80211_vif *vif, size_t frame_len, 190 const struct ieee80211_tx_info *frame_txctl) 191 { 192 struct ieee80211_local *local = hw_to_local(hw); 193 struct ieee80211_rate *rate; 194 struct ieee80211_sub_if_data *sdata; 195 bool short_preamble; 196 int erp; 197 u16 dur; 198 struct ieee80211_supported_band *sband; 199 200 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 201 202 short_preamble = false; 203 204 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx]; 205 206 erp = 0; 207 if (vif) { 208 sdata = vif_to_sdata(vif); 209 short_preamble = sdata->vif.bss_conf.use_short_preamble; 210 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 211 erp = rate->flags & IEEE80211_RATE_ERP_G; 212 } 213 214 /* CTS duration */ 215 dur = ieee80211_frame_duration(local, 10, rate->bitrate, 216 erp, short_preamble); 217 /* Data frame duration */ 218 dur += ieee80211_frame_duration(local, frame_len, rate->bitrate, 219 erp, short_preamble); 220 /* ACK duration */ 221 dur += ieee80211_frame_duration(local, 10, rate->bitrate, 222 erp, short_preamble); 223 224 return cpu_to_le16(dur); 225 } 226 EXPORT_SYMBOL(ieee80211_rts_duration); 227 228 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw, 229 struct ieee80211_vif *vif, 230 size_t frame_len, 231 const struct ieee80211_tx_info *frame_txctl) 232 { 233 struct ieee80211_local *local = hw_to_local(hw); 234 struct ieee80211_rate *rate; 235 struct ieee80211_sub_if_data *sdata; 236 bool short_preamble; 237 int erp; 238 u16 dur; 239 struct ieee80211_supported_band *sband; 240 241 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 242 243 short_preamble = false; 244 245 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx]; 246 erp = 0; 247 if (vif) { 248 sdata = vif_to_sdata(vif); 249 short_preamble = sdata->vif.bss_conf.use_short_preamble; 250 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 251 erp = rate->flags & IEEE80211_RATE_ERP_G; 252 } 253 254 /* Data frame duration */ 255 dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, 256 erp, short_preamble); 257 if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) { 258 /* ACK duration */ 259 dur += ieee80211_frame_duration(local, 10, rate->bitrate, 260 erp, short_preamble); 261 } 262 263 return cpu_to_le16(dur); 264 } 265 EXPORT_SYMBOL(ieee80211_ctstoself_duration); 266 267 static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue, 268 enum queue_stop_reason reason) 269 { 270 struct ieee80211_local *local = hw_to_local(hw); 271 272 if (WARN_ON(queue >= hw->queues)) 273 return; 274 275 __clear_bit(reason, &local->queue_stop_reasons[queue]); 276 277 if (!skb_queue_empty(&local->pending[queue]) && 278 local->queue_stop_reasons[queue] == 279 BIT(IEEE80211_QUEUE_STOP_REASON_PENDING)) 280 tasklet_schedule(&local->tx_pending_tasklet); 281 282 if (local->queue_stop_reasons[queue] != 0) 283 /* someone still has this queue stopped */ 284 return; 285 286 netif_wake_subqueue(local->mdev, queue); 287 } 288 289 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue, 290 enum queue_stop_reason reason) 291 { 292 struct ieee80211_local *local = hw_to_local(hw); 293 unsigned long flags; 294 295 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 296 __ieee80211_wake_queue(hw, queue, reason); 297 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 298 } 299 300 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue) 301 { 302 ieee80211_wake_queue_by_reason(hw, queue, 303 IEEE80211_QUEUE_STOP_REASON_DRIVER); 304 } 305 EXPORT_SYMBOL(ieee80211_wake_queue); 306 307 static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue, 308 enum queue_stop_reason reason) 309 { 310 struct ieee80211_local *local = hw_to_local(hw); 311 312 if (WARN_ON(queue >= hw->queues)) 313 return; 314 315 /* 316 * Only stop if it was previously running, this is necessary 317 * for correct pending packets handling because there we may 318 * start (but not wake) the queue and rely on that. 319 */ 320 if (!local->queue_stop_reasons[queue]) 321 netif_stop_subqueue(local->mdev, queue); 322 323 __set_bit(reason, &local->queue_stop_reasons[queue]); 324 } 325 326 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue, 327 enum queue_stop_reason reason) 328 { 329 struct ieee80211_local *local = hw_to_local(hw); 330 unsigned long flags; 331 332 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 333 __ieee80211_stop_queue(hw, queue, reason); 334 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 335 } 336 337 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue) 338 { 339 ieee80211_stop_queue_by_reason(hw, queue, 340 IEEE80211_QUEUE_STOP_REASON_DRIVER); 341 } 342 EXPORT_SYMBOL(ieee80211_stop_queue); 343 344 void ieee80211_add_pending_skb(struct ieee80211_local *local, 345 struct sk_buff *skb) 346 { 347 struct ieee80211_hw *hw = &local->hw; 348 unsigned long flags; 349 int queue = skb_get_queue_mapping(skb); 350 351 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 352 __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 353 __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_PENDING); 354 skb_queue_tail(&local->pending[queue], skb); 355 __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 356 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 357 } 358 359 int ieee80211_add_pending_skbs(struct ieee80211_local *local, 360 struct sk_buff_head *skbs) 361 { 362 struct ieee80211_hw *hw = &local->hw; 363 struct sk_buff *skb; 364 unsigned long flags; 365 int queue, ret = 0, i; 366 367 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 368 for (i = 0; i < hw->queues; i++) 369 __ieee80211_stop_queue(hw, i, 370 IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 371 372 while ((skb = skb_dequeue(skbs))) { 373 ret++; 374 queue = skb_get_queue_mapping(skb); 375 skb_queue_tail(&local->pending[queue], skb); 376 } 377 378 for (i = 0; i < hw->queues; i++) { 379 if (ret) 380 __ieee80211_stop_queue(hw, i, 381 IEEE80211_QUEUE_STOP_REASON_PENDING); 382 __ieee80211_wake_queue(hw, i, 383 IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 384 } 385 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 386 387 return ret; 388 } 389 390 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw, 391 enum queue_stop_reason reason) 392 { 393 struct ieee80211_local *local = hw_to_local(hw); 394 unsigned long flags; 395 int i; 396 397 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 398 399 for (i = 0; i < hw->queues; i++) 400 __ieee80211_stop_queue(hw, i, reason); 401 402 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 403 } 404 405 void ieee80211_stop_queues(struct ieee80211_hw *hw) 406 { 407 ieee80211_stop_queues_by_reason(hw, 408 IEEE80211_QUEUE_STOP_REASON_DRIVER); 409 } 410 EXPORT_SYMBOL(ieee80211_stop_queues); 411 412 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue) 413 { 414 struct ieee80211_local *local = hw_to_local(hw); 415 416 if (WARN_ON(queue >= hw->queues)) 417 return true; 418 419 return __netif_subqueue_stopped(local->mdev, queue); 420 } 421 EXPORT_SYMBOL(ieee80211_queue_stopped); 422 423 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw, 424 enum queue_stop_reason reason) 425 { 426 struct ieee80211_local *local = hw_to_local(hw); 427 unsigned long flags; 428 int i; 429 430 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 431 432 for (i = 0; i < hw->queues; i++) 433 __ieee80211_wake_queue(hw, i, reason); 434 435 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 436 } 437 438 void ieee80211_wake_queues(struct ieee80211_hw *hw) 439 { 440 ieee80211_wake_queues_by_reason(hw, IEEE80211_QUEUE_STOP_REASON_DRIVER); 441 } 442 EXPORT_SYMBOL(ieee80211_wake_queues); 443 444 void ieee80211_iterate_active_interfaces( 445 struct ieee80211_hw *hw, 446 void (*iterator)(void *data, u8 *mac, 447 struct ieee80211_vif *vif), 448 void *data) 449 { 450 struct ieee80211_local *local = hw_to_local(hw); 451 struct ieee80211_sub_if_data *sdata; 452 453 mutex_lock(&local->iflist_mtx); 454 455 list_for_each_entry(sdata, &local->interfaces, list) { 456 switch (sdata->vif.type) { 457 case __NL80211_IFTYPE_AFTER_LAST: 458 case NL80211_IFTYPE_UNSPECIFIED: 459 case NL80211_IFTYPE_MONITOR: 460 case NL80211_IFTYPE_AP_VLAN: 461 continue; 462 case NL80211_IFTYPE_AP: 463 case NL80211_IFTYPE_STATION: 464 case NL80211_IFTYPE_ADHOC: 465 case NL80211_IFTYPE_WDS: 466 case NL80211_IFTYPE_MESH_POINT: 467 break; 468 } 469 if (netif_running(sdata->dev)) 470 iterator(data, sdata->dev->dev_addr, 471 &sdata->vif); 472 } 473 474 mutex_unlock(&local->iflist_mtx); 475 } 476 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces); 477 478 void ieee80211_iterate_active_interfaces_atomic( 479 struct ieee80211_hw *hw, 480 void (*iterator)(void *data, u8 *mac, 481 struct ieee80211_vif *vif), 482 void *data) 483 { 484 struct ieee80211_local *local = hw_to_local(hw); 485 struct ieee80211_sub_if_data *sdata; 486 487 rcu_read_lock(); 488 489 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 490 switch (sdata->vif.type) { 491 case __NL80211_IFTYPE_AFTER_LAST: 492 case NL80211_IFTYPE_UNSPECIFIED: 493 case NL80211_IFTYPE_MONITOR: 494 case NL80211_IFTYPE_AP_VLAN: 495 continue; 496 case NL80211_IFTYPE_AP: 497 case NL80211_IFTYPE_STATION: 498 case NL80211_IFTYPE_ADHOC: 499 case NL80211_IFTYPE_WDS: 500 case NL80211_IFTYPE_MESH_POINT: 501 break; 502 } 503 if (netif_running(sdata->dev)) 504 iterator(data, sdata->dev->dev_addr, 505 &sdata->vif); 506 } 507 508 rcu_read_unlock(); 509 } 510 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic); 511 512 void ieee802_11_parse_elems(u8 *start, size_t len, 513 struct ieee802_11_elems *elems) 514 { 515 ieee802_11_parse_elems_crc(start, len, elems, 0, 0); 516 } 517 518 u32 ieee802_11_parse_elems_crc(u8 *start, size_t len, 519 struct ieee802_11_elems *elems, 520 u64 filter, u32 crc) 521 { 522 size_t left = len; 523 u8 *pos = start; 524 bool calc_crc = filter != 0; 525 526 memset(elems, 0, sizeof(*elems)); 527 elems->ie_start = start; 528 elems->total_len = len; 529 530 while (left >= 2) { 531 u8 id, elen; 532 533 id = *pos++; 534 elen = *pos++; 535 left -= 2; 536 537 if (elen > left) 538 break; 539 540 if (calc_crc && id < 64 && (filter & BIT(id))) 541 crc = crc32_be(crc, pos - 2, elen + 2); 542 543 switch (id) { 544 case WLAN_EID_SSID: 545 elems->ssid = pos; 546 elems->ssid_len = elen; 547 break; 548 case WLAN_EID_SUPP_RATES: 549 elems->supp_rates = pos; 550 elems->supp_rates_len = elen; 551 break; 552 case WLAN_EID_FH_PARAMS: 553 elems->fh_params = pos; 554 elems->fh_params_len = elen; 555 break; 556 case WLAN_EID_DS_PARAMS: 557 elems->ds_params = pos; 558 elems->ds_params_len = elen; 559 break; 560 case WLAN_EID_CF_PARAMS: 561 elems->cf_params = pos; 562 elems->cf_params_len = elen; 563 break; 564 case WLAN_EID_TIM: 565 if (elen >= sizeof(struct ieee80211_tim_ie)) { 566 elems->tim = (void *)pos; 567 elems->tim_len = elen; 568 } 569 break; 570 case WLAN_EID_IBSS_PARAMS: 571 elems->ibss_params = pos; 572 elems->ibss_params_len = elen; 573 break; 574 case WLAN_EID_CHALLENGE: 575 elems->challenge = pos; 576 elems->challenge_len = elen; 577 break; 578 case WLAN_EID_VENDOR_SPECIFIC: 579 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 && 580 pos[2] == 0xf2) { 581 /* Microsoft OUI (00:50:F2) */ 582 583 if (calc_crc) 584 crc = crc32_be(crc, pos - 2, elen + 2); 585 586 if (pos[3] == 1) { 587 /* OUI Type 1 - WPA IE */ 588 elems->wpa = pos; 589 elems->wpa_len = elen; 590 } else if (elen >= 5 && pos[3] == 2) { 591 /* OUI Type 2 - WMM IE */ 592 if (pos[4] == 0) { 593 elems->wmm_info = pos; 594 elems->wmm_info_len = elen; 595 } else if (pos[4] == 1) { 596 elems->wmm_param = pos; 597 elems->wmm_param_len = elen; 598 } 599 } 600 } 601 break; 602 case WLAN_EID_RSN: 603 elems->rsn = pos; 604 elems->rsn_len = elen; 605 break; 606 case WLAN_EID_ERP_INFO: 607 elems->erp_info = pos; 608 elems->erp_info_len = elen; 609 break; 610 case WLAN_EID_EXT_SUPP_RATES: 611 elems->ext_supp_rates = pos; 612 elems->ext_supp_rates_len = elen; 613 break; 614 case WLAN_EID_HT_CAPABILITY: 615 if (elen >= sizeof(struct ieee80211_ht_cap)) 616 elems->ht_cap_elem = (void *)pos; 617 break; 618 case WLAN_EID_HT_INFORMATION: 619 if (elen >= sizeof(struct ieee80211_ht_info)) 620 elems->ht_info_elem = (void *)pos; 621 break; 622 case WLAN_EID_MESH_ID: 623 elems->mesh_id = pos; 624 elems->mesh_id_len = elen; 625 break; 626 case WLAN_EID_MESH_CONFIG: 627 elems->mesh_config = pos; 628 elems->mesh_config_len = elen; 629 break; 630 case WLAN_EID_PEER_LINK: 631 elems->peer_link = pos; 632 elems->peer_link_len = elen; 633 break; 634 case WLAN_EID_PREQ: 635 elems->preq = pos; 636 elems->preq_len = elen; 637 break; 638 case WLAN_EID_PREP: 639 elems->prep = pos; 640 elems->prep_len = elen; 641 break; 642 case WLAN_EID_PERR: 643 elems->perr = pos; 644 elems->perr_len = elen; 645 break; 646 case WLAN_EID_CHANNEL_SWITCH: 647 elems->ch_switch_elem = pos; 648 elems->ch_switch_elem_len = elen; 649 break; 650 case WLAN_EID_QUIET: 651 if (!elems->quiet_elem) { 652 elems->quiet_elem = pos; 653 elems->quiet_elem_len = elen; 654 } 655 elems->num_of_quiet_elem++; 656 break; 657 case WLAN_EID_COUNTRY: 658 elems->country_elem = pos; 659 elems->country_elem_len = elen; 660 break; 661 case WLAN_EID_PWR_CONSTRAINT: 662 elems->pwr_constr_elem = pos; 663 elems->pwr_constr_elem_len = elen; 664 break; 665 case WLAN_EID_TIMEOUT_INTERVAL: 666 elems->timeout_int = pos; 667 elems->timeout_int_len = elen; 668 break; 669 default: 670 break; 671 } 672 673 left -= elen; 674 pos += elen; 675 } 676 677 return crc; 678 } 679 680 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata) 681 { 682 struct ieee80211_local *local = sdata->local; 683 struct ieee80211_tx_queue_params qparam; 684 int queue; 685 bool use_11b; 686 int aCWmin, aCWmax; 687 688 if (!local->ops->conf_tx) 689 return; 690 691 memset(&qparam, 0, sizeof(qparam)); 692 693 use_11b = (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) && 694 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE); 695 696 for (queue = 0; queue < local_to_hw(local)->queues; queue++) { 697 /* Set defaults according to 802.11-2007 Table 7-37 */ 698 aCWmax = 1023; 699 if (use_11b) 700 aCWmin = 31; 701 else 702 aCWmin = 15; 703 704 switch (queue) { 705 case 3: /* AC_BK */ 706 qparam.cw_max = aCWmax; 707 qparam.cw_min = aCWmin; 708 qparam.txop = 0; 709 qparam.aifs = 7; 710 break; 711 default: /* never happens but let's not leave undefined */ 712 case 2: /* AC_BE */ 713 qparam.cw_max = aCWmax; 714 qparam.cw_min = aCWmin; 715 qparam.txop = 0; 716 qparam.aifs = 3; 717 break; 718 case 1: /* AC_VI */ 719 qparam.cw_max = aCWmin; 720 qparam.cw_min = (aCWmin + 1) / 2 - 1; 721 if (use_11b) 722 qparam.txop = 6016/32; 723 else 724 qparam.txop = 3008/32; 725 qparam.aifs = 2; 726 break; 727 case 0: /* AC_VO */ 728 qparam.cw_max = (aCWmin + 1) / 2 - 1; 729 qparam.cw_min = (aCWmin + 1) / 4 - 1; 730 if (use_11b) 731 qparam.txop = 3264/32; 732 else 733 qparam.txop = 1504/32; 734 qparam.aifs = 2; 735 break; 736 } 737 738 drv_conf_tx(local, queue, &qparam); 739 } 740 } 741 742 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata, 743 const size_t supp_rates_len, 744 const u8 *supp_rates) 745 { 746 struct ieee80211_local *local = sdata->local; 747 int i, have_higher_than_11mbit = 0; 748 749 /* cf. IEEE 802.11 9.2.12 */ 750 for (i = 0; i < supp_rates_len; i++) 751 if ((supp_rates[i] & 0x7f) * 5 > 110) 752 have_higher_than_11mbit = 1; 753 754 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ && 755 have_higher_than_11mbit) 756 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE; 757 else 758 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE; 759 760 ieee80211_set_wmm_default(sdata); 761 } 762 763 void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb, 764 int encrypt) 765 { 766 skb->dev = sdata->local->mdev; 767 skb_set_mac_header(skb, 0); 768 skb_set_network_header(skb, 0); 769 skb_set_transport_header(skb, 0); 770 771 skb->iif = sdata->dev->ifindex; 772 skb->do_not_encrypt = !encrypt; 773 774 dev_queue_xmit(skb); 775 } 776 777 u32 ieee80211_mandatory_rates(struct ieee80211_local *local, 778 enum ieee80211_band band) 779 { 780 struct ieee80211_supported_band *sband; 781 struct ieee80211_rate *bitrates; 782 u32 mandatory_rates; 783 enum ieee80211_rate_flags mandatory_flag; 784 int i; 785 786 sband = local->hw.wiphy->bands[band]; 787 if (!sband) { 788 WARN_ON(1); 789 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 790 } 791 792 if (band == IEEE80211_BAND_2GHZ) 793 mandatory_flag = IEEE80211_RATE_MANDATORY_B; 794 else 795 mandatory_flag = IEEE80211_RATE_MANDATORY_A; 796 797 bitrates = sband->bitrates; 798 mandatory_rates = 0; 799 for (i = 0; i < sband->n_bitrates; i++) 800 if (bitrates[i].flags & mandatory_flag) 801 mandatory_rates |= BIT(i); 802 return mandatory_rates; 803 } 804 805 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata, 806 u16 transaction, u16 auth_alg, 807 u8 *extra, size_t extra_len, 808 const u8 *bssid, int encrypt) 809 { 810 struct ieee80211_local *local = sdata->local; 811 struct sk_buff *skb; 812 struct ieee80211_mgmt *mgmt; 813 814 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 815 sizeof(*mgmt) + 6 + extra_len); 816 if (!skb) { 817 printk(KERN_DEBUG "%s: failed to allocate buffer for auth " 818 "frame\n", sdata->dev->name); 819 return; 820 } 821 skb_reserve(skb, local->hw.extra_tx_headroom); 822 823 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6); 824 memset(mgmt, 0, 24 + 6); 825 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 826 IEEE80211_STYPE_AUTH); 827 if (encrypt) 828 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 829 memcpy(mgmt->da, bssid, ETH_ALEN); 830 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); 831 memcpy(mgmt->bssid, bssid, ETH_ALEN); 832 mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg); 833 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction); 834 mgmt->u.auth.status_code = cpu_to_le16(0); 835 if (extra) 836 memcpy(skb_put(skb, extra_len), extra, extra_len); 837 838 ieee80211_tx_skb(sdata, skb, encrypt); 839 } 840 841 int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer, 842 const u8 *ie, size_t ie_len) 843 { 844 struct ieee80211_supported_band *sband; 845 u8 *pos, *supp_rates_len, *esupp_rates_len = NULL; 846 int i; 847 848 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 849 850 pos = buffer; 851 852 *pos++ = WLAN_EID_SUPP_RATES; 853 supp_rates_len = pos; 854 *pos++ = 0; 855 856 for (i = 0; i < sband->n_bitrates; i++) { 857 struct ieee80211_rate *rate = &sband->bitrates[i]; 858 859 if (esupp_rates_len) { 860 *esupp_rates_len += 1; 861 } else if (*supp_rates_len == 8) { 862 *pos++ = WLAN_EID_EXT_SUPP_RATES; 863 esupp_rates_len = pos; 864 *pos++ = 1; 865 } else 866 *supp_rates_len += 1; 867 868 *pos++ = rate->bitrate / 5; 869 } 870 871 if (sband->ht_cap.ht_supported) { 872 __le16 tmp = cpu_to_le16(sband->ht_cap.cap); 873 874 *pos++ = WLAN_EID_HT_CAPABILITY; 875 *pos++ = sizeof(struct ieee80211_ht_cap); 876 memset(pos, 0, sizeof(struct ieee80211_ht_cap)); 877 memcpy(pos, &tmp, sizeof(u16)); 878 pos += sizeof(u16); 879 /* TODO: needs a define here for << 2 */ 880 *pos++ = sband->ht_cap.ampdu_factor | 881 (sband->ht_cap.ampdu_density << 2); 882 memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs)); 883 pos += sizeof(sband->ht_cap.mcs); 884 pos += 2 + 4 + 1; /* ext info, BF cap, antsel */ 885 } 886 887 /* 888 * If adding more here, adjust code in main.c 889 * that calculates local->scan_ies_len. 890 */ 891 892 if (ie) { 893 memcpy(pos, ie, ie_len); 894 pos += ie_len; 895 } 896 897 return pos - buffer; 898 } 899 900 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst, 901 const u8 *ssid, size_t ssid_len, 902 const u8 *ie, size_t ie_len) 903 { 904 struct ieee80211_local *local = sdata->local; 905 struct sk_buff *skb; 906 struct ieee80211_mgmt *mgmt; 907 u8 *pos; 908 909 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 200 + 910 ie_len); 911 if (!skb) { 912 printk(KERN_DEBUG "%s: failed to allocate buffer for probe " 913 "request\n", sdata->dev->name); 914 return; 915 } 916 skb_reserve(skb, local->hw.extra_tx_headroom); 917 918 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 919 memset(mgmt, 0, 24); 920 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 921 IEEE80211_STYPE_PROBE_REQ); 922 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); 923 if (dst) { 924 memcpy(mgmt->da, dst, ETH_ALEN); 925 memcpy(mgmt->bssid, dst, ETH_ALEN); 926 } else { 927 memset(mgmt->da, 0xff, ETH_ALEN); 928 memset(mgmt->bssid, 0xff, ETH_ALEN); 929 } 930 pos = skb_put(skb, 2 + ssid_len); 931 *pos++ = WLAN_EID_SSID; 932 *pos++ = ssid_len; 933 memcpy(pos, ssid, ssid_len); 934 pos += ssid_len; 935 936 skb_put(skb, ieee80211_build_preq_ies(local, pos, ie, ie_len)); 937 938 ieee80211_tx_skb(sdata, skb, 0); 939 } 940 941 u32 ieee80211_sta_get_rates(struct ieee80211_local *local, 942 struct ieee802_11_elems *elems, 943 enum ieee80211_band band) 944 { 945 struct ieee80211_supported_band *sband; 946 struct ieee80211_rate *bitrates; 947 size_t num_rates; 948 u32 supp_rates; 949 int i, j; 950 sband = local->hw.wiphy->bands[band]; 951 952 if (!sband) { 953 WARN_ON(1); 954 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 955 } 956 957 bitrates = sband->bitrates; 958 num_rates = sband->n_bitrates; 959 supp_rates = 0; 960 for (i = 0; i < elems->supp_rates_len + 961 elems->ext_supp_rates_len; i++) { 962 u8 rate = 0; 963 int own_rate; 964 if (i < elems->supp_rates_len) 965 rate = elems->supp_rates[i]; 966 else if (elems->ext_supp_rates) 967 rate = elems->ext_supp_rates 968 [i - elems->supp_rates_len]; 969 own_rate = 5 * (rate & 0x7f); 970 for (j = 0; j < num_rates; j++) 971 if (bitrates[j].bitrate == own_rate) 972 supp_rates |= BIT(j); 973 } 974 return supp_rates; 975 } 976 977 int ieee80211_reconfig(struct ieee80211_local *local) 978 { 979 struct ieee80211_hw *hw = &local->hw; 980 struct ieee80211_sub_if_data *sdata; 981 struct ieee80211_if_init_conf conf; 982 struct sta_info *sta; 983 unsigned long flags; 984 int res; 985 bool from_suspend = local->suspended; 986 987 /* 988 * We're going to start the hardware, at that point 989 * we are no longer suspended and can RX frames. 990 */ 991 local->suspended = false; 992 993 /* restart hardware */ 994 if (local->open_count) { 995 res = drv_start(local); 996 997 ieee80211_led_radio(local, true); 998 } 999 1000 /* add interfaces */ 1001 list_for_each_entry(sdata, &local->interfaces, list) { 1002 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 1003 sdata->vif.type != NL80211_IFTYPE_MONITOR && 1004 netif_running(sdata->dev)) { 1005 conf.vif = &sdata->vif; 1006 conf.type = sdata->vif.type; 1007 conf.mac_addr = sdata->dev->dev_addr; 1008 res = drv_add_interface(local, &conf); 1009 } 1010 } 1011 1012 /* add STAs back */ 1013 if (local->ops->sta_notify) { 1014 spin_lock_irqsave(&local->sta_lock, flags); 1015 list_for_each_entry(sta, &local->sta_list, list) { 1016 sdata = sta->sdata; 1017 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 1018 sdata = container_of(sdata->bss, 1019 struct ieee80211_sub_if_data, 1020 u.ap); 1021 1022 drv_sta_notify(local, &sdata->vif, STA_NOTIFY_ADD, 1023 &sta->sta); 1024 } 1025 spin_unlock_irqrestore(&local->sta_lock, flags); 1026 } 1027 1028 /* Clear Suspend state so that ADDBA requests can be processed */ 1029 1030 rcu_read_lock(); 1031 1032 if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) { 1033 list_for_each_entry_rcu(sta, &local->sta_list, list) { 1034 clear_sta_flags(sta, WLAN_STA_SUSPEND); 1035 } 1036 } 1037 1038 rcu_read_unlock(); 1039 1040 /* setup RTS threshold */ 1041 drv_set_rts_threshold(local, hw->wiphy->rts_threshold); 1042 1043 /* reconfigure hardware */ 1044 ieee80211_hw_config(local, ~0); 1045 1046 netif_addr_lock_bh(local->mdev); 1047 ieee80211_configure_filter(local); 1048 netif_addr_unlock_bh(local->mdev); 1049 1050 /* Finally also reconfigure all the BSS information */ 1051 list_for_each_entry(sdata, &local->interfaces, list) { 1052 u32 changed = ~0; 1053 if (!netif_running(sdata->dev)) 1054 continue; 1055 switch (sdata->vif.type) { 1056 case NL80211_IFTYPE_STATION: 1057 /* disable beacon change bits */ 1058 changed &= ~(BSS_CHANGED_BEACON | 1059 BSS_CHANGED_BEACON_ENABLED); 1060 /* fall through */ 1061 case NL80211_IFTYPE_ADHOC: 1062 case NL80211_IFTYPE_AP: 1063 case NL80211_IFTYPE_MESH_POINT: 1064 ieee80211_bss_info_change_notify(sdata, changed); 1065 break; 1066 case NL80211_IFTYPE_WDS: 1067 break; 1068 case NL80211_IFTYPE_AP_VLAN: 1069 case NL80211_IFTYPE_MONITOR: 1070 /* ignore virtual */ 1071 break; 1072 case NL80211_IFTYPE_UNSPECIFIED: 1073 case __NL80211_IFTYPE_AFTER_LAST: 1074 WARN_ON(1); 1075 break; 1076 } 1077 } 1078 1079 /* add back keys */ 1080 list_for_each_entry(sdata, &local->interfaces, list) 1081 if (netif_running(sdata->dev)) 1082 ieee80211_enable_keys(sdata); 1083 1084 ieee80211_wake_queues_by_reason(hw, 1085 IEEE80211_QUEUE_STOP_REASON_SUSPEND); 1086 1087 /* 1088 * If this is for hw restart things are still running. 1089 * We may want to change that later, however. 1090 */ 1091 if (!from_suspend) 1092 return 0; 1093 1094 #ifdef CONFIG_PM 1095 local->suspended = false; 1096 1097 list_for_each_entry(sdata, &local->interfaces, list) { 1098 switch(sdata->vif.type) { 1099 case NL80211_IFTYPE_STATION: 1100 ieee80211_sta_restart(sdata); 1101 break; 1102 case NL80211_IFTYPE_ADHOC: 1103 ieee80211_ibss_restart(sdata); 1104 break; 1105 case NL80211_IFTYPE_MESH_POINT: 1106 ieee80211_mesh_restart(sdata); 1107 break; 1108 default: 1109 break; 1110 } 1111 } 1112 1113 add_timer(&local->sta_cleanup); 1114 1115 spin_lock_irqsave(&local->sta_lock, flags); 1116 list_for_each_entry(sta, &local->sta_list, list) 1117 mesh_plink_restart(sta); 1118 spin_unlock_irqrestore(&local->sta_lock, flags); 1119 #else 1120 WARN_ON(1); 1121 #endif 1122 return 0; 1123 } 1124