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