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