1 /* 2 * Copyright 2002-2005, Instant802 Networks, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc. 4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 5 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * utilities for mac80211 12 */ 13 14 #include <net/mac80211.h> 15 #include <linux/netdevice.h> 16 #include <linux/export.h> 17 #include <linux/types.h> 18 #include <linux/slab.h> 19 #include <linux/skbuff.h> 20 #include <linux/etherdevice.h> 21 #include <linux/if_arp.h> 22 #include <linux/bitmap.h> 23 #include <linux/crc32.h> 24 #include <net/net_namespace.h> 25 #include <net/cfg80211.h> 26 #include <net/rtnetlink.h> 27 28 #include "ieee80211_i.h" 29 #include "driver-ops.h" 30 #include "rate.h" 31 #include "mesh.h" 32 #include "wme.h" 33 #include "led.h" 34 #include "wep.h" 35 36 /* privid for wiphys to determine whether they belong to us or not */ 37 void *mac80211_wiphy_privid = &mac80211_wiphy_privid; 38 39 struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy) 40 { 41 struct ieee80211_local *local; 42 BUG_ON(!wiphy); 43 44 local = wiphy_priv(wiphy); 45 return &local->hw; 46 } 47 EXPORT_SYMBOL(wiphy_to_ieee80211_hw); 48 49 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len, 50 enum nl80211_iftype type) 51 { 52 __le16 fc = hdr->frame_control; 53 54 /* drop ACK/CTS frames and incorrect hdr len (ctrl) */ 55 if (len < 16) 56 return NULL; 57 58 if (ieee80211_is_data(fc)) { 59 if (len < 24) /* drop incorrect hdr len (data) */ 60 return NULL; 61 62 if (ieee80211_has_a4(fc)) 63 return NULL; 64 if (ieee80211_has_tods(fc)) 65 return hdr->addr1; 66 if (ieee80211_has_fromds(fc)) 67 return hdr->addr2; 68 69 return hdr->addr3; 70 } 71 72 if (ieee80211_is_mgmt(fc)) { 73 if (len < 24) /* drop incorrect hdr len (mgmt) */ 74 return NULL; 75 return hdr->addr3; 76 } 77 78 if (ieee80211_is_ctl(fc)) { 79 if(ieee80211_is_pspoll(fc)) 80 return hdr->addr1; 81 82 if (ieee80211_is_back_req(fc)) { 83 switch (type) { 84 case NL80211_IFTYPE_STATION: 85 return hdr->addr2; 86 case NL80211_IFTYPE_AP: 87 case NL80211_IFTYPE_AP_VLAN: 88 return hdr->addr1; 89 default: 90 break; /* fall through to the return */ 91 } 92 } 93 } 94 95 return NULL; 96 } 97 98 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx) 99 { 100 struct sk_buff *skb; 101 struct ieee80211_hdr *hdr; 102 103 skb_queue_walk(&tx->skbs, skb) { 104 hdr = (struct ieee80211_hdr *) skb->data; 105 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 106 } 107 } 108 109 int ieee80211_frame_duration(enum ieee80211_band band, 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 (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 enum ieee80211_band band, 166 size_t frame_len, 167 struct ieee80211_rate *rate) 168 { 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(band, 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[frame_txctl->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(sband->band, 10, rate->bitrate, 217 erp, short_preamble); 218 /* Data frame duration */ 219 dur += ieee80211_frame_duration(sband->band, frame_len, rate->bitrate, 220 erp, short_preamble); 221 /* ACK duration */ 222 dur += ieee80211_frame_duration(sband->band, 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[frame_txctl->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(sband->band, 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(sband->band, 10, rate->bitrate, 261 erp, short_preamble); 262 } 263 264 return cpu_to_le16(dur); 265 } 266 EXPORT_SYMBOL(ieee80211_ctstoself_duration); 267 268 void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue) 269 { 270 struct ieee80211_sub_if_data *sdata; 271 int n_acs = IEEE80211_NUM_ACS; 272 273 if (local->hw.queues < IEEE80211_NUM_ACS) 274 n_acs = 1; 275 276 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 277 int ac; 278 279 if (!sdata->dev) 280 continue; 281 282 if (test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state)) 283 continue; 284 285 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE && 286 local->queue_stop_reasons[sdata->vif.cab_queue] != 0) 287 continue; 288 289 for (ac = 0; ac < n_acs; ac++) { 290 int ac_queue = sdata->vif.hw_queue[ac]; 291 292 if (ac_queue == queue || 293 (sdata->vif.cab_queue == queue && 294 local->queue_stop_reasons[ac_queue] == 0 && 295 skb_queue_empty(&local->pending[ac_queue]))) 296 netif_wake_subqueue(sdata->dev, ac); 297 } 298 } 299 } 300 301 static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue, 302 enum queue_stop_reason reason) 303 { 304 struct ieee80211_local *local = hw_to_local(hw); 305 306 trace_wake_queue(local, queue, reason); 307 308 if (WARN_ON(queue >= hw->queues)) 309 return; 310 311 if (!test_bit(reason, &local->queue_stop_reasons[queue])) 312 return; 313 314 __clear_bit(reason, &local->queue_stop_reasons[queue]); 315 316 if (local->queue_stop_reasons[queue] != 0) 317 /* someone still has this queue stopped */ 318 return; 319 320 if (skb_queue_empty(&local->pending[queue])) { 321 rcu_read_lock(); 322 ieee80211_propagate_queue_wake(local, queue); 323 rcu_read_unlock(); 324 } else 325 tasklet_schedule(&local->tx_pending_tasklet); 326 } 327 328 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue, 329 enum queue_stop_reason reason) 330 { 331 struct ieee80211_local *local = hw_to_local(hw); 332 unsigned long flags; 333 334 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 335 __ieee80211_wake_queue(hw, queue, reason); 336 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 337 } 338 339 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue) 340 { 341 ieee80211_wake_queue_by_reason(hw, queue, 342 IEEE80211_QUEUE_STOP_REASON_DRIVER); 343 } 344 EXPORT_SYMBOL(ieee80211_wake_queue); 345 346 static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue, 347 enum queue_stop_reason reason) 348 { 349 struct ieee80211_local *local = hw_to_local(hw); 350 struct ieee80211_sub_if_data *sdata; 351 int n_acs = IEEE80211_NUM_ACS; 352 353 trace_stop_queue(local, queue, reason); 354 355 if (WARN_ON(queue >= hw->queues)) 356 return; 357 358 if (test_bit(reason, &local->queue_stop_reasons[queue])) 359 return; 360 361 __set_bit(reason, &local->queue_stop_reasons[queue]); 362 363 if (local->hw.queues < IEEE80211_NUM_ACS) 364 n_acs = 1; 365 366 rcu_read_lock(); 367 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 368 int ac; 369 370 if (!sdata->dev) 371 continue; 372 373 for (ac = 0; ac < n_acs; ac++) { 374 if (sdata->vif.hw_queue[ac] == queue || 375 sdata->vif.cab_queue == queue) 376 netif_stop_subqueue(sdata->dev, ac); 377 } 378 } 379 rcu_read_unlock(); 380 } 381 382 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue, 383 enum queue_stop_reason reason) 384 { 385 struct ieee80211_local *local = hw_to_local(hw); 386 unsigned long flags; 387 388 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 389 __ieee80211_stop_queue(hw, queue, reason); 390 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 391 } 392 393 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue) 394 { 395 ieee80211_stop_queue_by_reason(hw, queue, 396 IEEE80211_QUEUE_STOP_REASON_DRIVER); 397 } 398 EXPORT_SYMBOL(ieee80211_stop_queue); 399 400 void ieee80211_add_pending_skb(struct ieee80211_local *local, 401 struct sk_buff *skb) 402 { 403 struct ieee80211_hw *hw = &local->hw; 404 unsigned long flags; 405 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 406 int queue = info->hw_queue; 407 408 if (WARN_ON(!info->control.vif)) { 409 ieee80211_free_txskb(&local->hw, skb); 410 return; 411 } 412 413 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 414 __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 415 __skb_queue_tail(&local->pending[queue], skb); 416 __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 417 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 418 } 419 420 void ieee80211_add_pending_skbs_fn(struct ieee80211_local *local, 421 struct sk_buff_head *skbs, 422 void (*fn)(void *data), void *data) 423 { 424 struct ieee80211_hw *hw = &local->hw; 425 struct sk_buff *skb; 426 unsigned long flags; 427 int queue, i; 428 429 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 430 while ((skb = skb_dequeue(skbs))) { 431 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 432 433 if (WARN_ON(!info->control.vif)) { 434 ieee80211_free_txskb(&local->hw, skb); 435 continue; 436 } 437 438 queue = info->hw_queue; 439 440 __ieee80211_stop_queue(hw, queue, 441 IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 442 443 __skb_queue_tail(&local->pending[queue], skb); 444 } 445 446 if (fn) 447 fn(data); 448 449 for (i = 0; i < hw->queues; i++) 450 __ieee80211_wake_queue(hw, i, 451 IEEE80211_QUEUE_STOP_REASON_SKB_ADD); 452 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 453 } 454 455 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw, 456 enum queue_stop_reason reason) 457 { 458 struct ieee80211_local *local = hw_to_local(hw); 459 unsigned long flags; 460 int i; 461 462 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 463 464 for (i = 0; i < hw->queues; i++) 465 __ieee80211_stop_queue(hw, i, reason); 466 467 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 468 } 469 470 void ieee80211_stop_queues(struct ieee80211_hw *hw) 471 { 472 ieee80211_stop_queues_by_reason(hw, 473 IEEE80211_QUEUE_STOP_REASON_DRIVER); 474 } 475 EXPORT_SYMBOL(ieee80211_stop_queues); 476 477 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue) 478 { 479 struct ieee80211_local *local = hw_to_local(hw); 480 unsigned long flags; 481 int ret; 482 483 if (WARN_ON(queue >= hw->queues)) 484 return true; 485 486 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 487 ret = !!local->queue_stop_reasons[queue]; 488 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 489 return ret; 490 } 491 EXPORT_SYMBOL(ieee80211_queue_stopped); 492 493 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw, 494 enum queue_stop_reason reason) 495 { 496 struct ieee80211_local *local = hw_to_local(hw); 497 unsigned long flags; 498 int i; 499 500 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 501 502 for (i = 0; i < hw->queues; i++) 503 __ieee80211_wake_queue(hw, i, reason); 504 505 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 506 } 507 508 void ieee80211_wake_queues(struct ieee80211_hw *hw) 509 { 510 ieee80211_wake_queues_by_reason(hw, IEEE80211_QUEUE_STOP_REASON_DRIVER); 511 } 512 EXPORT_SYMBOL(ieee80211_wake_queues); 513 514 void ieee80211_iterate_active_interfaces( 515 struct ieee80211_hw *hw, 516 void (*iterator)(void *data, u8 *mac, 517 struct ieee80211_vif *vif), 518 void *data) 519 { 520 struct ieee80211_local *local = hw_to_local(hw); 521 struct ieee80211_sub_if_data *sdata; 522 523 mutex_lock(&local->iflist_mtx); 524 525 list_for_each_entry(sdata, &local->interfaces, list) { 526 switch (sdata->vif.type) { 527 case NL80211_IFTYPE_MONITOR: 528 case NL80211_IFTYPE_AP_VLAN: 529 continue; 530 default: 531 break; 532 } 533 if (ieee80211_sdata_running(sdata)) 534 iterator(data, sdata->vif.addr, 535 &sdata->vif); 536 } 537 538 sdata = rcu_dereference_protected(local->monitor_sdata, 539 lockdep_is_held(&local->iflist_mtx)); 540 if (sdata) 541 iterator(data, sdata->vif.addr, &sdata->vif); 542 543 mutex_unlock(&local->iflist_mtx); 544 } 545 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces); 546 547 void ieee80211_iterate_active_interfaces_atomic( 548 struct ieee80211_hw *hw, 549 void (*iterator)(void *data, u8 *mac, 550 struct ieee80211_vif *vif), 551 void *data) 552 { 553 struct ieee80211_local *local = hw_to_local(hw); 554 struct ieee80211_sub_if_data *sdata; 555 556 rcu_read_lock(); 557 558 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 559 switch (sdata->vif.type) { 560 case NL80211_IFTYPE_MONITOR: 561 case NL80211_IFTYPE_AP_VLAN: 562 continue; 563 default: 564 break; 565 } 566 if (ieee80211_sdata_running(sdata)) 567 iterator(data, sdata->vif.addr, 568 &sdata->vif); 569 } 570 571 sdata = rcu_dereference(local->monitor_sdata); 572 if (sdata) 573 iterator(data, sdata->vif.addr, &sdata->vif); 574 575 rcu_read_unlock(); 576 } 577 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic); 578 579 /* 580 * Nothing should have been stuffed into the workqueue during 581 * the suspend->resume cycle. If this WARN is seen then there 582 * is a bug with either the driver suspend or something in 583 * mac80211 stuffing into the workqueue which we haven't yet 584 * cleared during mac80211's suspend cycle. 585 */ 586 static bool ieee80211_can_queue_work(struct ieee80211_local *local) 587 { 588 if (WARN(local->suspended && !local->resuming, 589 "queueing ieee80211 work while going to suspend\n")) 590 return false; 591 592 return true; 593 } 594 595 void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work) 596 { 597 struct ieee80211_local *local = hw_to_local(hw); 598 599 if (!ieee80211_can_queue_work(local)) 600 return; 601 602 queue_work(local->workqueue, work); 603 } 604 EXPORT_SYMBOL(ieee80211_queue_work); 605 606 void ieee80211_queue_delayed_work(struct ieee80211_hw *hw, 607 struct delayed_work *dwork, 608 unsigned long delay) 609 { 610 struct ieee80211_local *local = hw_to_local(hw); 611 612 if (!ieee80211_can_queue_work(local)) 613 return; 614 615 queue_delayed_work(local->workqueue, dwork, delay); 616 } 617 EXPORT_SYMBOL(ieee80211_queue_delayed_work); 618 619 u32 ieee802_11_parse_elems_crc(u8 *start, size_t len, 620 struct ieee802_11_elems *elems, 621 u64 filter, u32 crc) 622 { 623 size_t left = len; 624 u8 *pos = start; 625 bool calc_crc = filter != 0; 626 DECLARE_BITMAP(seen_elems, 256); 627 628 bitmap_zero(seen_elems, 256); 629 memset(elems, 0, sizeof(*elems)); 630 elems->ie_start = start; 631 elems->total_len = len; 632 633 while (left >= 2) { 634 u8 id, elen; 635 bool elem_parse_failed; 636 637 id = *pos++; 638 elen = *pos++; 639 left -= 2; 640 641 if (elen > left) { 642 elems->parse_error = true; 643 break; 644 } 645 646 switch (id) { 647 case WLAN_EID_SSID: 648 case WLAN_EID_SUPP_RATES: 649 case WLAN_EID_FH_PARAMS: 650 case WLAN_EID_DS_PARAMS: 651 case WLAN_EID_CF_PARAMS: 652 case WLAN_EID_TIM: 653 case WLAN_EID_IBSS_PARAMS: 654 case WLAN_EID_CHALLENGE: 655 case WLAN_EID_RSN: 656 case WLAN_EID_ERP_INFO: 657 case WLAN_EID_EXT_SUPP_RATES: 658 case WLAN_EID_HT_CAPABILITY: 659 case WLAN_EID_HT_OPERATION: 660 case WLAN_EID_VHT_CAPABILITY: 661 case WLAN_EID_VHT_OPERATION: 662 case WLAN_EID_MESH_ID: 663 case WLAN_EID_MESH_CONFIG: 664 case WLAN_EID_PEER_MGMT: 665 case WLAN_EID_PREQ: 666 case WLAN_EID_PREP: 667 case WLAN_EID_PERR: 668 case WLAN_EID_RANN: 669 case WLAN_EID_CHANNEL_SWITCH: 670 case WLAN_EID_EXT_CHANSWITCH_ANN: 671 case WLAN_EID_COUNTRY: 672 case WLAN_EID_PWR_CONSTRAINT: 673 case WLAN_EID_TIMEOUT_INTERVAL: 674 if (test_bit(id, seen_elems)) { 675 elems->parse_error = true; 676 left -= elen; 677 pos += elen; 678 continue; 679 } 680 break; 681 } 682 683 if (calc_crc && id < 64 && (filter & (1ULL << id))) 684 crc = crc32_be(crc, pos - 2, elen + 2); 685 686 elem_parse_failed = false; 687 688 switch (id) { 689 case WLAN_EID_SSID: 690 elems->ssid = pos; 691 elems->ssid_len = elen; 692 break; 693 case WLAN_EID_SUPP_RATES: 694 elems->supp_rates = pos; 695 elems->supp_rates_len = elen; 696 break; 697 case WLAN_EID_FH_PARAMS: 698 elems->fh_params = pos; 699 elems->fh_params_len = elen; 700 break; 701 case WLAN_EID_DS_PARAMS: 702 elems->ds_params = pos; 703 elems->ds_params_len = elen; 704 break; 705 case WLAN_EID_CF_PARAMS: 706 elems->cf_params = pos; 707 elems->cf_params_len = elen; 708 break; 709 case WLAN_EID_TIM: 710 if (elen >= sizeof(struct ieee80211_tim_ie)) { 711 elems->tim = (void *)pos; 712 elems->tim_len = elen; 713 } else 714 elem_parse_failed = true; 715 break; 716 case WLAN_EID_IBSS_PARAMS: 717 elems->ibss_params = pos; 718 elems->ibss_params_len = elen; 719 break; 720 case WLAN_EID_CHALLENGE: 721 elems->challenge = pos; 722 elems->challenge_len = elen; 723 break; 724 case WLAN_EID_VENDOR_SPECIFIC: 725 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 && 726 pos[2] == 0xf2) { 727 /* Microsoft OUI (00:50:F2) */ 728 729 if (calc_crc) 730 crc = crc32_be(crc, pos - 2, elen + 2); 731 732 if (pos[3] == 1) { 733 /* OUI Type 1 - WPA IE */ 734 elems->wpa = pos; 735 elems->wpa_len = elen; 736 } else if (elen >= 5 && pos[3] == 2) { 737 /* OUI Type 2 - WMM IE */ 738 if (pos[4] == 0) { 739 elems->wmm_info = pos; 740 elems->wmm_info_len = elen; 741 } else if (pos[4] == 1) { 742 elems->wmm_param = pos; 743 elems->wmm_param_len = elen; 744 } 745 } 746 } 747 break; 748 case WLAN_EID_RSN: 749 elems->rsn = pos; 750 elems->rsn_len = elen; 751 break; 752 case WLAN_EID_ERP_INFO: 753 elems->erp_info = pos; 754 elems->erp_info_len = elen; 755 break; 756 case WLAN_EID_EXT_SUPP_RATES: 757 elems->ext_supp_rates = pos; 758 elems->ext_supp_rates_len = elen; 759 break; 760 case WLAN_EID_HT_CAPABILITY: 761 if (elen >= sizeof(struct ieee80211_ht_cap)) 762 elems->ht_cap_elem = (void *)pos; 763 else 764 elem_parse_failed = true; 765 break; 766 case WLAN_EID_HT_OPERATION: 767 if (elen >= sizeof(struct ieee80211_ht_operation)) 768 elems->ht_operation = (void *)pos; 769 else 770 elem_parse_failed = true; 771 break; 772 case WLAN_EID_MESH_ID: 773 elems->mesh_id = pos; 774 elems->mesh_id_len = elen; 775 break; 776 case WLAN_EID_MESH_CONFIG: 777 if (elen >= sizeof(struct ieee80211_meshconf_ie)) 778 elems->mesh_config = (void *)pos; 779 else 780 elem_parse_failed = true; 781 break; 782 case WLAN_EID_PEER_MGMT: 783 elems->peering = pos; 784 elems->peering_len = elen; 785 break; 786 case WLAN_EID_PREQ: 787 elems->preq = pos; 788 elems->preq_len = elen; 789 break; 790 case WLAN_EID_PREP: 791 elems->prep = pos; 792 elems->prep_len = elen; 793 break; 794 case WLAN_EID_PERR: 795 elems->perr = pos; 796 elems->perr_len = elen; 797 break; 798 case WLAN_EID_RANN: 799 if (elen >= sizeof(struct ieee80211_rann_ie)) 800 elems->rann = (void *)pos; 801 else 802 elem_parse_failed = true; 803 break; 804 case WLAN_EID_CHANNEL_SWITCH: 805 if (elen != sizeof(struct ieee80211_channel_sw_ie)) { 806 elem_parse_failed = true; 807 break; 808 } 809 elems->ch_switch_ie = (void *)pos; 810 break; 811 case WLAN_EID_QUIET: 812 if (!elems->quiet_elem) { 813 elems->quiet_elem = pos; 814 elems->quiet_elem_len = elen; 815 } 816 elems->num_of_quiet_elem++; 817 break; 818 case WLAN_EID_COUNTRY: 819 elems->country_elem = pos; 820 elems->country_elem_len = elen; 821 break; 822 case WLAN_EID_PWR_CONSTRAINT: 823 if (elen != 1) { 824 elem_parse_failed = true; 825 break; 826 } 827 elems->pwr_constr_elem = pos; 828 break; 829 case WLAN_EID_TIMEOUT_INTERVAL: 830 elems->timeout_int = pos; 831 elems->timeout_int_len = elen; 832 break; 833 default: 834 break; 835 } 836 837 if (elem_parse_failed) 838 elems->parse_error = true; 839 else 840 set_bit(id, seen_elems); 841 842 left -= elen; 843 pos += elen; 844 } 845 846 if (left != 0) 847 elems->parse_error = true; 848 849 return crc; 850 } 851 852 void ieee802_11_parse_elems(u8 *start, size_t len, 853 struct ieee802_11_elems *elems) 854 { 855 ieee802_11_parse_elems_crc(start, len, elems, 0, 0); 856 } 857 858 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata, 859 bool bss_notify) 860 { 861 struct ieee80211_local *local = sdata->local; 862 struct ieee80211_tx_queue_params qparam; 863 int ac; 864 bool use_11b, enable_qos; 865 int aCWmin, aCWmax; 866 867 if (!local->ops->conf_tx) 868 return; 869 870 if (local->hw.queues < IEEE80211_NUM_ACS) 871 return; 872 873 memset(&qparam, 0, sizeof(qparam)); 874 875 use_11b = (local->oper_channel->band == IEEE80211_BAND_2GHZ) && 876 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE); 877 878 /* 879 * By default disable QoS in STA mode for old access points, which do 880 * not support 802.11e. New APs will provide proper queue parameters, 881 * that we will configure later. 882 */ 883 enable_qos = (sdata->vif.type != NL80211_IFTYPE_STATION); 884 885 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 886 /* Set defaults according to 802.11-2007 Table 7-37 */ 887 aCWmax = 1023; 888 if (use_11b) 889 aCWmin = 31; 890 else 891 aCWmin = 15; 892 893 if (enable_qos) { 894 switch (ac) { 895 case IEEE80211_AC_BK: 896 qparam.cw_max = aCWmax; 897 qparam.cw_min = aCWmin; 898 qparam.txop = 0; 899 qparam.aifs = 7; 900 break; 901 /* never happens but let's not leave undefined */ 902 default: 903 case IEEE80211_AC_BE: 904 qparam.cw_max = aCWmax; 905 qparam.cw_min = aCWmin; 906 qparam.txop = 0; 907 qparam.aifs = 3; 908 break; 909 case IEEE80211_AC_VI: 910 qparam.cw_max = aCWmin; 911 qparam.cw_min = (aCWmin + 1) / 2 - 1; 912 if (use_11b) 913 qparam.txop = 6016/32; 914 else 915 qparam.txop = 3008/32; 916 qparam.aifs = 2; 917 break; 918 case IEEE80211_AC_VO: 919 qparam.cw_max = (aCWmin + 1) / 2 - 1; 920 qparam.cw_min = (aCWmin + 1) / 4 - 1; 921 if (use_11b) 922 qparam.txop = 3264/32; 923 else 924 qparam.txop = 1504/32; 925 qparam.aifs = 2; 926 break; 927 } 928 } else { 929 /* Confiure old 802.11b/g medium access rules. */ 930 qparam.cw_max = aCWmax; 931 qparam.cw_min = aCWmin; 932 qparam.txop = 0; 933 qparam.aifs = 2; 934 } 935 936 qparam.uapsd = false; 937 938 sdata->tx_conf[ac] = qparam; 939 drv_conf_tx(local, sdata, ac, &qparam); 940 } 941 942 if (sdata->vif.type != NL80211_IFTYPE_MONITOR && 943 sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) { 944 sdata->vif.bss_conf.qos = enable_qos; 945 if (bss_notify) 946 ieee80211_bss_info_change_notify(sdata, 947 BSS_CHANGED_QOS); 948 } 949 } 950 951 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata, 952 const size_t supp_rates_len, 953 const u8 *supp_rates) 954 { 955 struct ieee80211_local *local = sdata->local; 956 int i, have_higher_than_11mbit = 0; 957 958 /* cf. IEEE 802.11 9.2.12 */ 959 for (i = 0; i < supp_rates_len; i++) 960 if ((supp_rates[i] & 0x7f) * 5 > 110) 961 have_higher_than_11mbit = 1; 962 963 if (local->oper_channel->band == IEEE80211_BAND_2GHZ && 964 have_higher_than_11mbit) 965 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE; 966 else 967 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE; 968 969 ieee80211_set_wmm_default(sdata, true); 970 } 971 972 u32 ieee80211_mandatory_rates(struct ieee80211_local *local, 973 enum ieee80211_band band) 974 { 975 struct ieee80211_supported_band *sband; 976 struct ieee80211_rate *bitrates; 977 u32 mandatory_rates; 978 enum ieee80211_rate_flags mandatory_flag; 979 int i; 980 981 sband = local->hw.wiphy->bands[band]; 982 if (WARN_ON(!sband)) 983 return 1; 984 985 if (band == IEEE80211_BAND_2GHZ) 986 mandatory_flag = IEEE80211_RATE_MANDATORY_B; 987 else 988 mandatory_flag = IEEE80211_RATE_MANDATORY_A; 989 990 bitrates = sband->bitrates; 991 mandatory_rates = 0; 992 for (i = 0; i < sband->n_bitrates; i++) 993 if (bitrates[i].flags & mandatory_flag) 994 mandatory_rates |= BIT(i); 995 return mandatory_rates; 996 } 997 998 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata, 999 u16 transaction, u16 auth_alg, 1000 u8 *extra, size_t extra_len, const u8 *da, 1001 const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx) 1002 { 1003 struct ieee80211_local *local = sdata->local; 1004 struct sk_buff *skb; 1005 struct ieee80211_mgmt *mgmt; 1006 int err; 1007 1008 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 1009 sizeof(*mgmt) + 6 + extra_len); 1010 if (!skb) 1011 return; 1012 1013 skb_reserve(skb, local->hw.extra_tx_headroom); 1014 1015 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6); 1016 memset(mgmt, 0, 24 + 6); 1017 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 1018 IEEE80211_STYPE_AUTH); 1019 memcpy(mgmt->da, da, ETH_ALEN); 1020 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 1021 memcpy(mgmt->bssid, bssid, ETH_ALEN); 1022 mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg); 1023 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction); 1024 mgmt->u.auth.status_code = cpu_to_le16(0); 1025 if (extra) 1026 memcpy(skb_put(skb, extra_len), extra, extra_len); 1027 1028 if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) { 1029 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 1030 err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx); 1031 WARN_ON(err); 1032 } 1033 1034 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 1035 ieee80211_tx_skb(sdata, skb); 1036 } 1037 1038 void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata, 1039 const u8 *bssid, u16 stype, u16 reason, 1040 bool send_frame, u8 *frame_buf) 1041 { 1042 struct ieee80211_local *local = sdata->local; 1043 struct sk_buff *skb; 1044 struct ieee80211_mgmt *mgmt = (void *)frame_buf; 1045 1046 /* build frame */ 1047 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype); 1048 mgmt->duration = 0; /* initialize only */ 1049 mgmt->seq_ctrl = 0; /* initialize only */ 1050 memcpy(mgmt->da, bssid, ETH_ALEN); 1051 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 1052 memcpy(mgmt->bssid, bssid, ETH_ALEN); 1053 /* u.deauth.reason_code == u.disassoc.reason_code */ 1054 mgmt->u.deauth.reason_code = cpu_to_le16(reason); 1055 1056 if (send_frame) { 1057 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 1058 IEEE80211_DEAUTH_FRAME_LEN); 1059 if (!skb) 1060 return; 1061 1062 skb_reserve(skb, local->hw.extra_tx_headroom); 1063 1064 /* copy in frame */ 1065 memcpy(skb_put(skb, IEEE80211_DEAUTH_FRAME_LEN), 1066 mgmt, IEEE80211_DEAUTH_FRAME_LEN); 1067 1068 if (sdata->vif.type != NL80211_IFTYPE_STATION || 1069 !(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED)) 1070 IEEE80211_SKB_CB(skb)->flags |= 1071 IEEE80211_TX_INTFL_DONT_ENCRYPT; 1072 1073 ieee80211_tx_skb(sdata, skb); 1074 } 1075 } 1076 1077 int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer, 1078 const u8 *ie, size_t ie_len, 1079 enum ieee80211_band band, u32 rate_mask, 1080 u8 channel) 1081 { 1082 struct ieee80211_supported_band *sband; 1083 u8 *pos; 1084 size_t offset = 0, noffset; 1085 int supp_rates_len, i; 1086 u8 rates[32]; 1087 int num_rates; 1088 int ext_rates_len; 1089 1090 sband = local->hw.wiphy->bands[band]; 1091 if (WARN_ON_ONCE(!sband)) 1092 return 0; 1093 1094 pos = buffer; 1095 1096 num_rates = 0; 1097 for (i = 0; i < sband->n_bitrates; i++) { 1098 if ((BIT(i) & rate_mask) == 0) 1099 continue; /* skip rate */ 1100 rates[num_rates++] = (u8) (sband->bitrates[i].bitrate / 5); 1101 } 1102 1103 supp_rates_len = min_t(int, num_rates, 8); 1104 1105 *pos++ = WLAN_EID_SUPP_RATES; 1106 *pos++ = supp_rates_len; 1107 memcpy(pos, rates, supp_rates_len); 1108 pos += supp_rates_len; 1109 1110 /* insert "request information" if in custom IEs */ 1111 if (ie && ie_len) { 1112 static const u8 before_extrates[] = { 1113 WLAN_EID_SSID, 1114 WLAN_EID_SUPP_RATES, 1115 WLAN_EID_REQUEST, 1116 }; 1117 noffset = ieee80211_ie_split(ie, ie_len, 1118 before_extrates, 1119 ARRAY_SIZE(before_extrates), 1120 offset); 1121 memcpy(pos, ie + offset, noffset - offset); 1122 pos += noffset - offset; 1123 offset = noffset; 1124 } 1125 1126 ext_rates_len = num_rates - supp_rates_len; 1127 if (ext_rates_len > 0) { 1128 *pos++ = WLAN_EID_EXT_SUPP_RATES; 1129 *pos++ = ext_rates_len; 1130 memcpy(pos, rates + supp_rates_len, ext_rates_len); 1131 pos += ext_rates_len; 1132 } 1133 1134 if (channel && sband->band == IEEE80211_BAND_2GHZ) { 1135 *pos++ = WLAN_EID_DS_PARAMS; 1136 *pos++ = 1; 1137 *pos++ = channel; 1138 } 1139 1140 /* insert custom IEs that go before HT */ 1141 if (ie && ie_len) { 1142 static const u8 before_ht[] = { 1143 WLAN_EID_SSID, 1144 WLAN_EID_SUPP_RATES, 1145 WLAN_EID_REQUEST, 1146 WLAN_EID_EXT_SUPP_RATES, 1147 WLAN_EID_DS_PARAMS, 1148 WLAN_EID_SUPPORTED_REGULATORY_CLASSES, 1149 }; 1150 noffset = ieee80211_ie_split(ie, ie_len, 1151 before_ht, ARRAY_SIZE(before_ht), 1152 offset); 1153 memcpy(pos, ie + offset, noffset - offset); 1154 pos += noffset - offset; 1155 offset = noffset; 1156 } 1157 1158 if (sband->ht_cap.ht_supported) 1159 pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap, 1160 sband->ht_cap.cap); 1161 1162 /* 1163 * If adding more here, adjust code in main.c 1164 * that calculates local->scan_ies_len. 1165 */ 1166 1167 /* add any remaining custom IEs */ 1168 if (ie && ie_len) { 1169 noffset = ie_len; 1170 memcpy(pos, ie + offset, noffset - offset); 1171 pos += noffset - offset; 1172 } 1173 1174 if (sband->vht_cap.vht_supported) 1175 pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap, 1176 sband->vht_cap.cap); 1177 1178 return pos - buffer; 1179 } 1180 1181 struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata, 1182 u8 *dst, u32 ratemask, 1183 struct ieee80211_channel *chan, 1184 const u8 *ssid, size_t ssid_len, 1185 const u8 *ie, size_t ie_len, 1186 bool directed) 1187 { 1188 struct ieee80211_local *local = sdata->local; 1189 struct sk_buff *skb; 1190 struct ieee80211_mgmt *mgmt; 1191 size_t buf_len; 1192 u8 *buf; 1193 u8 chan_no; 1194 1195 /* FIXME: come up with a proper value */ 1196 buf = kmalloc(200 + ie_len, GFP_KERNEL); 1197 if (!buf) 1198 return NULL; 1199 1200 /* 1201 * Do not send DS Channel parameter for directed probe requests 1202 * in order to maximize the chance that we get a response. Some 1203 * badly-behaved APs don't respond when this parameter is included. 1204 */ 1205 if (directed) 1206 chan_no = 0; 1207 else 1208 chan_no = ieee80211_frequency_to_channel(chan->center_freq); 1209 1210 buf_len = ieee80211_build_preq_ies(local, buf, ie, ie_len, chan->band, 1211 ratemask, chan_no); 1212 1213 skb = ieee80211_probereq_get(&local->hw, &sdata->vif, 1214 ssid, ssid_len, 1215 buf, buf_len); 1216 if (!skb) 1217 goto out; 1218 1219 if (dst) { 1220 mgmt = (struct ieee80211_mgmt *) skb->data; 1221 memcpy(mgmt->da, dst, ETH_ALEN); 1222 memcpy(mgmt->bssid, dst, ETH_ALEN); 1223 } 1224 1225 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 1226 1227 out: 1228 kfree(buf); 1229 1230 return skb; 1231 } 1232 1233 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst, 1234 const u8 *ssid, size_t ssid_len, 1235 const u8 *ie, size_t ie_len, 1236 u32 ratemask, bool directed, bool no_cck, 1237 struct ieee80211_channel *channel) 1238 { 1239 struct sk_buff *skb; 1240 1241 skb = ieee80211_build_probe_req(sdata, dst, ratemask, channel, 1242 ssid, ssid_len, 1243 ie, ie_len, directed); 1244 if (skb) { 1245 if (no_cck) 1246 IEEE80211_SKB_CB(skb)->flags |= 1247 IEEE80211_TX_CTL_NO_CCK_RATE; 1248 ieee80211_tx_skb(sdata, skb); 1249 } 1250 } 1251 1252 u32 ieee80211_sta_get_rates(struct ieee80211_local *local, 1253 struct ieee802_11_elems *elems, 1254 enum ieee80211_band band, u32 *basic_rates) 1255 { 1256 struct ieee80211_supported_band *sband; 1257 struct ieee80211_rate *bitrates; 1258 size_t num_rates; 1259 u32 supp_rates; 1260 int i, j; 1261 sband = local->hw.wiphy->bands[band]; 1262 1263 if (WARN_ON(!sband)) 1264 return 1; 1265 1266 bitrates = sband->bitrates; 1267 num_rates = sband->n_bitrates; 1268 supp_rates = 0; 1269 for (i = 0; i < elems->supp_rates_len + 1270 elems->ext_supp_rates_len; i++) { 1271 u8 rate = 0; 1272 int own_rate; 1273 bool is_basic; 1274 if (i < elems->supp_rates_len) 1275 rate = elems->supp_rates[i]; 1276 else if (elems->ext_supp_rates) 1277 rate = elems->ext_supp_rates 1278 [i - elems->supp_rates_len]; 1279 own_rate = 5 * (rate & 0x7f); 1280 is_basic = !!(rate & 0x80); 1281 1282 if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY) 1283 continue; 1284 1285 for (j = 0; j < num_rates; j++) { 1286 if (bitrates[j].bitrate == own_rate) { 1287 supp_rates |= BIT(j); 1288 if (basic_rates && is_basic) 1289 *basic_rates |= BIT(j); 1290 } 1291 } 1292 } 1293 return supp_rates; 1294 } 1295 1296 void ieee80211_stop_device(struct ieee80211_local *local) 1297 { 1298 ieee80211_led_radio(local, false); 1299 ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO); 1300 1301 cancel_work_sync(&local->reconfig_filter); 1302 1303 flush_workqueue(local->workqueue); 1304 drv_stop(local); 1305 } 1306 1307 int ieee80211_reconfig(struct ieee80211_local *local) 1308 { 1309 struct ieee80211_hw *hw = &local->hw; 1310 struct ieee80211_sub_if_data *sdata; 1311 struct sta_info *sta; 1312 int res, i; 1313 1314 #ifdef CONFIG_PM 1315 if (local->suspended) 1316 local->resuming = true; 1317 1318 if (local->wowlan) { 1319 local->wowlan = false; 1320 res = drv_resume(local); 1321 if (res < 0) { 1322 local->resuming = false; 1323 return res; 1324 } 1325 if (res == 0) 1326 goto wake_up; 1327 WARN_ON(res > 1); 1328 /* 1329 * res is 1, which means the driver requested 1330 * to go through a regular reset on wakeup. 1331 */ 1332 } 1333 #endif 1334 /* everything else happens only if HW was up & running */ 1335 if (!local->open_count) 1336 goto wake_up; 1337 1338 /* 1339 * Upon resume hardware can sometimes be goofy due to 1340 * various platform / driver / bus issues, so restarting 1341 * the device may at times not work immediately. Propagate 1342 * the error. 1343 */ 1344 res = drv_start(local); 1345 if (res) { 1346 WARN(local->suspended, "Hardware became unavailable " 1347 "upon resume. This could be a software issue " 1348 "prior to suspend or a hardware issue.\n"); 1349 return res; 1350 } 1351 1352 /* setup fragmentation threshold */ 1353 drv_set_frag_threshold(local, hw->wiphy->frag_threshold); 1354 1355 /* setup RTS threshold */ 1356 drv_set_rts_threshold(local, hw->wiphy->rts_threshold); 1357 1358 /* reset coverage class */ 1359 drv_set_coverage_class(local, hw->wiphy->coverage_class); 1360 1361 ieee80211_led_radio(local, true); 1362 ieee80211_mod_tpt_led_trig(local, 1363 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0); 1364 1365 /* add interfaces */ 1366 sdata = rtnl_dereference(local->monitor_sdata); 1367 if (sdata) { 1368 res = drv_add_interface(local, sdata); 1369 if (WARN_ON(res)) { 1370 rcu_assign_pointer(local->monitor_sdata, NULL); 1371 synchronize_net(); 1372 kfree(sdata); 1373 } 1374 } 1375 1376 list_for_each_entry(sdata, &local->interfaces, list) { 1377 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 1378 sdata->vif.type != NL80211_IFTYPE_MONITOR && 1379 ieee80211_sdata_running(sdata)) 1380 res = drv_add_interface(local, sdata); 1381 } 1382 1383 /* add STAs back */ 1384 mutex_lock(&local->sta_mtx); 1385 list_for_each_entry(sta, &local->sta_list, list) { 1386 enum ieee80211_sta_state state; 1387 1388 if (!sta->uploaded) 1389 continue; 1390 1391 /* AP-mode stations will be added later */ 1392 if (sta->sdata->vif.type == NL80211_IFTYPE_AP) 1393 continue; 1394 1395 for (state = IEEE80211_STA_NOTEXIST; 1396 state < sta->sta_state; state++) 1397 WARN_ON(drv_sta_state(local, sta->sdata, sta, state, 1398 state + 1)); 1399 } 1400 mutex_unlock(&local->sta_mtx); 1401 1402 /* reconfigure tx conf */ 1403 if (hw->queues >= IEEE80211_NUM_ACS) { 1404 list_for_each_entry(sdata, &local->interfaces, list) { 1405 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN || 1406 sdata->vif.type == NL80211_IFTYPE_MONITOR || 1407 !ieee80211_sdata_running(sdata)) 1408 continue; 1409 1410 for (i = 0; i < IEEE80211_NUM_ACS; i++) 1411 drv_conf_tx(local, sdata, i, 1412 &sdata->tx_conf[i]); 1413 } 1414 } 1415 1416 /* reconfigure hardware */ 1417 ieee80211_hw_config(local, ~0); 1418 1419 ieee80211_configure_filter(local); 1420 1421 /* Finally also reconfigure all the BSS information */ 1422 list_for_each_entry(sdata, &local->interfaces, list) { 1423 u32 changed; 1424 1425 if (!ieee80211_sdata_running(sdata)) 1426 continue; 1427 1428 /* common change flags for all interface types */ 1429 changed = BSS_CHANGED_ERP_CTS_PROT | 1430 BSS_CHANGED_ERP_PREAMBLE | 1431 BSS_CHANGED_ERP_SLOT | 1432 BSS_CHANGED_HT | 1433 BSS_CHANGED_BASIC_RATES | 1434 BSS_CHANGED_BEACON_INT | 1435 BSS_CHANGED_BSSID | 1436 BSS_CHANGED_CQM | 1437 BSS_CHANGED_QOS | 1438 BSS_CHANGED_IDLE; 1439 1440 switch (sdata->vif.type) { 1441 case NL80211_IFTYPE_STATION: 1442 changed |= BSS_CHANGED_ASSOC | 1443 BSS_CHANGED_ARP_FILTER | 1444 BSS_CHANGED_PS; 1445 mutex_lock(&sdata->u.mgd.mtx); 1446 ieee80211_bss_info_change_notify(sdata, changed); 1447 mutex_unlock(&sdata->u.mgd.mtx); 1448 break; 1449 case NL80211_IFTYPE_ADHOC: 1450 changed |= BSS_CHANGED_IBSS; 1451 /* fall through */ 1452 case NL80211_IFTYPE_AP: 1453 changed |= BSS_CHANGED_SSID; 1454 1455 if (sdata->vif.type == NL80211_IFTYPE_AP) 1456 changed |= BSS_CHANGED_AP_PROBE_RESP; 1457 1458 /* fall through */ 1459 case NL80211_IFTYPE_MESH_POINT: 1460 changed |= BSS_CHANGED_BEACON | 1461 BSS_CHANGED_BEACON_ENABLED; 1462 ieee80211_bss_info_change_notify(sdata, changed); 1463 break; 1464 case NL80211_IFTYPE_WDS: 1465 break; 1466 case NL80211_IFTYPE_AP_VLAN: 1467 case NL80211_IFTYPE_MONITOR: 1468 /* ignore virtual */ 1469 break; 1470 case NL80211_IFTYPE_P2P_DEVICE: 1471 changed = BSS_CHANGED_IDLE; 1472 break; 1473 case NL80211_IFTYPE_UNSPECIFIED: 1474 case NUM_NL80211_IFTYPES: 1475 case NL80211_IFTYPE_P2P_CLIENT: 1476 case NL80211_IFTYPE_P2P_GO: 1477 WARN_ON(1); 1478 break; 1479 } 1480 } 1481 1482 ieee80211_recalc_ps(local, -1); 1483 1484 /* 1485 * The sta might be in psm against the ap (e.g. because 1486 * this was the state before a hw restart), so we 1487 * explicitly send a null packet in order to make sure 1488 * it'll sync against the ap (and get out of psm). 1489 */ 1490 if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) { 1491 list_for_each_entry(sdata, &local->interfaces, list) { 1492 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1493 continue; 1494 if (!sdata->u.mgd.associated) 1495 continue; 1496 1497 ieee80211_send_nullfunc(local, sdata, 0); 1498 } 1499 } 1500 1501 /* APs are now beaconing, add back stations */ 1502 mutex_lock(&local->sta_mtx); 1503 list_for_each_entry(sta, &local->sta_list, list) { 1504 enum ieee80211_sta_state state; 1505 1506 if (!sta->uploaded) 1507 continue; 1508 1509 if (sta->sdata->vif.type != NL80211_IFTYPE_AP) 1510 continue; 1511 1512 for (state = IEEE80211_STA_NOTEXIST; 1513 state < sta->sta_state; state++) 1514 WARN_ON(drv_sta_state(local, sta->sdata, sta, state, 1515 state + 1)); 1516 } 1517 mutex_unlock(&local->sta_mtx); 1518 1519 /* add back keys */ 1520 list_for_each_entry(sdata, &local->interfaces, list) 1521 if (ieee80211_sdata_running(sdata)) 1522 ieee80211_enable_keys(sdata); 1523 1524 wake_up: 1525 local->in_reconfig = false; 1526 barrier(); 1527 1528 /* 1529 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation 1530 * sessions can be established after a resume. 1531 * 1532 * Also tear down aggregation sessions since reconfiguring 1533 * them in a hardware restart scenario is not easily done 1534 * right now, and the hardware will have lost information 1535 * about the sessions, but we and the AP still think they 1536 * are active. This is really a workaround though. 1537 */ 1538 if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) { 1539 mutex_lock(&local->sta_mtx); 1540 1541 list_for_each_entry(sta, &local->sta_list, list) { 1542 ieee80211_sta_tear_down_BA_sessions(sta, true); 1543 clear_sta_flag(sta, WLAN_STA_BLOCK_BA); 1544 } 1545 1546 mutex_unlock(&local->sta_mtx); 1547 } 1548 1549 ieee80211_wake_queues_by_reason(hw, 1550 IEEE80211_QUEUE_STOP_REASON_SUSPEND); 1551 1552 /* 1553 * If this is for hw restart things are still running. 1554 * We may want to change that later, however. 1555 */ 1556 if (!local->suspended) 1557 return 0; 1558 1559 #ifdef CONFIG_PM 1560 /* first set suspended false, then resuming */ 1561 local->suspended = false; 1562 mb(); 1563 local->resuming = false; 1564 1565 list_for_each_entry(sdata, &local->interfaces, list) { 1566 switch(sdata->vif.type) { 1567 case NL80211_IFTYPE_STATION: 1568 ieee80211_sta_restart(sdata); 1569 break; 1570 case NL80211_IFTYPE_ADHOC: 1571 ieee80211_ibss_restart(sdata); 1572 break; 1573 case NL80211_IFTYPE_MESH_POINT: 1574 ieee80211_mesh_restart(sdata); 1575 break; 1576 default: 1577 break; 1578 } 1579 } 1580 1581 mod_timer(&local->sta_cleanup, jiffies + 1); 1582 1583 mutex_lock(&local->sta_mtx); 1584 list_for_each_entry(sta, &local->sta_list, list) 1585 mesh_plink_restart(sta); 1586 mutex_unlock(&local->sta_mtx); 1587 #else 1588 WARN_ON(1); 1589 #endif 1590 return 0; 1591 } 1592 1593 void ieee80211_resume_disconnect(struct ieee80211_vif *vif) 1594 { 1595 struct ieee80211_sub_if_data *sdata; 1596 struct ieee80211_local *local; 1597 struct ieee80211_key *key; 1598 1599 if (WARN_ON(!vif)) 1600 return; 1601 1602 sdata = vif_to_sdata(vif); 1603 local = sdata->local; 1604 1605 if (WARN_ON(!local->resuming)) 1606 return; 1607 1608 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION)) 1609 return; 1610 1611 sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME; 1612 1613 mutex_lock(&local->key_mtx); 1614 list_for_each_entry(key, &sdata->key_list, list) 1615 key->flags |= KEY_FLAG_TAINTED; 1616 mutex_unlock(&local->key_mtx); 1617 } 1618 EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect); 1619 1620 static int check_mgd_smps(struct ieee80211_if_managed *ifmgd, 1621 enum ieee80211_smps_mode *smps_mode) 1622 { 1623 if (ifmgd->associated) { 1624 *smps_mode = ifmgd->ap_smps; 1625 1626 if (*smps_mode == IEEE80211_SMPS_AUTOMATIC) { 1627 if (ifmgd->powersave) 1628 *smps_mode = IEEE80211_SMPS_DYNAMIC; 1629 else 1630 *smps_mode = IEEE80211_SMPS_OFF; 1631 } 1632 1633 return 1; 1634 } 1635 1636 return 0; 1637 } 1638 1639 void ieee80211_recalc_smps(struct ieee80211_local *local) 1640 { 1641 struct ieee80211_sub_if_data *sdata; 1642 enum ieee80211_smps_mode smps_mode = IEEE80211_SMPS_OFF; 1643 int count = 0; 1644 1645 mutex_lock(&local->iflist_mtx); 1646 1647 /* 1648 * This function could be improved to handle multiple 1649 * interfaces better, but right now it makes any 1650 * non-station interfaces force SM PS to be turned 1651 * off. If there are multiple station interfaces it 1652 * could also use the best possible mode, e.g. if 1653 * one is in static and the other in dynamic then 1654 * dynamic is ok. 1655 */ 1656 1657 list_for_each_entry(sdata, &local->interfaces, list) { 1658 if (!ieee80211_sdata_running(sdata)) 1659 continue; 1660 if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) 1661 continue; 1662 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1663 goto set; 1664 1665 count += check_mgd_smps(&sdata->u.mgd, &smps_mode); 1666 1667 if (count > 1) { 1668 smps_mode = IEEE80211_SMPS_OFF; 1669 break; 1670 } 1671 } 1672 1673 if (smps_mode == local->smps_mode) 1674 goto unlock; 1675 1676 set: 1677 local->smps_mode = smps_mode; 1678 /* changed flag is auto-detected for this */ 1679 ieee80211_hw_config(local, 0); 1680 unlock: 1681 mutex_unlock(&local->iflist_mtx); 1682 } 1683 1684 static bool ieee80211_id_in_list(const u8 *ids, int n_ids, u8 id) 1685 { 1686 int i; 1687 1688 for (i = 0; i < n_ids; i++) 1689 if (ids[i] == id) 1690 return true; 1691 return false; 1692 } 1693 1694 /** 1695 * ieee80211_ie_split - split an IE buffer according to ordering 1696 * 1697 * @ies: the IE buffer 1698 * @ielen: the length of the IE buffer 1699 * @ids: an array with element IDs that are allowed before 1700 * the split 1701 * @n_ids: the size of the element ID array 1702 * @offset: offset where to start splitting in the buffer 1703 * 1704 * This function splits an IE buffer by updating the @offset 1705 * variable to point to the location where the buffer should be 1706 * split. 1707 * 1708 * It assumes that the given IE buffer is well-formed, this 1709 * has to be guaranteed by the caller! 1710 * 1711 * It also assumes that the IEs in the buffer are ordered 1712 * correctly, if not the result of using this function will not 1713 * be ordered correctly either, i.e. it does no reordering. 1714 * 1715 * The function returns the offset where the next part of the 1716 * buffer starts, which may be @ielen if the entire (remainder) 1717 * of the buffer should be used. 1718 */ 1719 size_t ieee80211_ie_split(const u8 *ies, size_t ielen, 1720 const u8 *ids, int n_ids, size_t offset) 1721 { 1722 size_t pos = offset; 1723 1724 while (pos < ielen && ieee80211_id_in_list(ids, n_ids, ies[pos])) 1725 pos += 2 + ies[pos + 1]; 1726 1727 return pos; 1728 } 1729 1730 size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset) 1731 { 1732 size_t pos = offset; 1733 1734 while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC) 1735 pos += 2 + ies[pos + 1]; 1736 1737 return pos; 1738 } 1739 1740 static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata, 1741 int rssi_min_thold, 1742 int rssi_max_thold) 1743 { 1744 trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold); 1745 1746 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION)) 1747 return; 1748 1749 /* 1750 * Scale up threshold values before storing it, as the RSSI averaging 1751 * algorithm uses a scaled up value as well. Change this scaling 1752 * factor if the RSSI averaging algorithm changes. 1753 */ 1754 sdata->u.mgd.rssi_min_thold = rssi_min_thold*16; 1755 sdata->u.mgd.rssi_max_thold = rssi_max_thold*16; 1756 } 1757 1758 void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif, 1759 int rssi_min_thold, 1760 int rssi_max_thold) 1761 { 1762 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1763 1764 WARN_ON(rssi_min_thold == rssi_max_thold || 1765 rssi_min_thold > rssi_max_thold); 1766 1767 _ieee80211_enable_rssi_reports(sdata, rssi_min_thold, 1768 rssi_max_thold); 1769 } 1770 EXPORT_SYMBOL(ieee80211_enable_rssi_reports); 1771 1772 void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif) 1773 { 1774 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1775 1776 _ieee80211_enable_rssi_reports(sdata, 0, 0); 1777 } 1778 EXPORT_SYMBOL(ieee80211_disable_rssi_reports); 1779 1780 u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap, 1781 u16 cap) 1782 { 1783 __le16 tmp; 1784 1785 *pos++ = WLAN_EID_HT_CAPABILITY; 1786 *pos++ = sizeof(struct ieee80211_ht_cap); 1787 memset(pos, 0, sizeof(struct ieee80211_ht_cap)); 1788 1789 /* capability flags */ 1790 tmp = cpu_to_le16(cap); 1791 memcpy(pos, &tmp, sizeof(u16)); 1792 pos += sizeof(u16); 1793 1794 /* AMPDU parameters */ 1795 *pos++ = ht_cap->ampdu_factor | 1796 (ht_cap->ampdu_density << 1797 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT); 1798 1799 /* MCS set */ 1800 memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs)); 1801 pos += sizeof(ht_cap->mcs); 1802 1803 /* extended capabilities */ 1804 pos += sizeof(__le16); 1805 1806 /* BF capabilities */ 1807 pos += sizeof(__le32); 1808 1809 /* antenna selection */ 1810 pos += sizeof(u8); 1811 1812 return pos; 1813 } 1814 1815 u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap, 1816 u32 cap) 1817 { 1818 __le32 tmp; 1819 1820 *pos++ = WLAN_EID_VHT_CAPABILITY; 1821 *pos++ = sizeof(struct ieee80211_vht_capabilities); 1822 memset(pos, 0, sizeof(struct ieee80211_vht_capabilities)); 1823 1824 /* capability flags */ 1825 tmp = cpu_to_le32(cap); 1826 memcpy(pos, &tmp, sizeof(u32)); 1827 pos += sizeof(u32); 1828 1829 /* VHT MCS set */ 1830 memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs)); 1831 pos += sizeof(vht_cap->vht_mcs); 1832 1833 return pos; 1834 } 1835 1836 u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap, 1837 struct ieee80211_channel *channel, 1838 enum nl80211_channel_type channel_type, 1839 u16 prot_mode) 1840 { 1841 struct ieee80211_ht_operation *ht_oper; 1842 /* Build HT Information */ 1843 *pos++ = WLAN_EID_HT_OPERATION; 1844 *pos++ = sizeof(struct ieee80211_ht_operation); 1845 ht_oper = (struct ieee80211_ht_operation *)pos; 1846 ht_oper->primary_chan = 1847 ieee80211_frequency_to_channel(channel->center_freq); 1848 switch (channel_type) { 1849 case NL80211_CHAN_HT40MINUS: 1850 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW; 1851 break; 1852 case NL80211_CHAN_HT40PLUS: 1853 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 1854 break; 1855 case NL80211_CHAN_HT20: 1856 default: 1857 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE; 1858 break; 1859 } 1860 if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 && 1861 channel_type != NL80211_CHAN_NO_HT && 1862 channel_type != NL80211_CHAN_HT20) 1863 ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY; 1864 1865 ht_oper->operation_mode = cpu_to_le16(prot_mode); 1866 ht_oper->stbc_param = 0x0000; 1867 1868 /* It seems that Basic MCS set and Supported MCS set 1869 are identical for the first 10 bytes */ 1870 memset(&ht_oper->basic_set, 0, 16); 1871 memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10); 1872 1873 return pos + sizeof(struct ieee80211_ht_operation); 1874 } 1875 1876 enum nl80211_channel_type 1877 ieee80211_ht_oper_to_channel_type(struct ieee80211_ht_operation *ht_oper) 1878 { 1879 enum nl80211_channel_type channel_type; 1880 1881 if (!ht_oper) 1882 return NL80211_CHAN_NO_HT; 1883 1884 switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) { 1885 case IEEE80211_HT_PARAM_CHA_SEC_NONE: 1886 channel_type = NL80211_CHAN_HT20; 1887 break; 1888 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: 1889 channel_type = NL80211_CHAN_HT40PLUS; 1890 break; 1891 case IEEE80211_HT_PARAM_CHA_SEC_BELOW: 1892 channel_type = NL80211_CHAN_HT40MINUS; 1893 break; 1894 default: 1895 channel_type = NL80211_CHAN_NO_HT; 1896 } 1897 1898 return channel_type; 1899 } 1900 1901 int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata, 1902 struct sk_buff *skb, bool need_basic, 1903 enum ieee80211_band band) 1904 { 1905 struct ieee80211_local *local = sdata->local; 1906 struct ieee80211_supported_band *sband; 1907 int rate; 1908 u8 i, rates, *pos; 1909 u32 basic_rates = sdata->vif.bss_conf.basic_rates; 1910 1911 sband = local->hw.wiphy->bands[band]; 1912 rates = sband->n_bitrates; 1913 if (rates > 8) 1914 rates = 8; 1915 1916 if (skb_tailroom(skb) < rates + 2) 1917 return -ENOMEM; 1918 1919 pos = skb_put(skb, rates + 2); 1920 *pos++ = WLAN_EID_SUPP_RATES; 1921 *pos++ = rates; 1922 for (i = 0; i < rates; i++) { 1923 u8 basic = 0; 1924 if (need_basic && basic_rates & BIT(i)) 1925 basic = 0x80; 1926 rate = sband->bitrates[i].bitrate; 1927 *pos++ = basic | (u8) (rate / 5); 1928 } 1929 1930 return 0; 1931 } 1932 1933 int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata, 1934 struct sk_buff *skb, bool need_basic, 1935 enum ieee80211_band band) 1936 { 1937 struct ieee80211_local *local = sdata->local; 1938 struct ieee80211_supported_band *sband; 1939 int rate; 1940 u8 i, exrates, *pos; 1941 u32 basic_rates = sdata->vif.bss_conf.basic_rates; 1942 1943 sband = local->hw.wiphy->bands[band]; 1944 exrates = sband->n_bitrates; 1945 if (exrates > 8) 1946 exrates -= 8; 1947 else 1948 exrates = 0; 1949 1950 if (skb_tailroom(skb) < exrates + 2) 1951 return -ENOMEM; 1952 1953 if (exrates) { 1954 pos = skb_put(skb, exrates + 2); 1955 *pos++ = WLAN_EID_EXT_SUPP_RATES; 1956 *pos++ = exrates; 1957 for (i = 8; i < sband->n_bitrates; i++) { 1958 u8 basic = 0; 1959 if (need_basic && basic_rates & BIT(i)) 1960 basic = 0x80; 1961 rate = sband->bitrates[i].bitrate; 1962 *pos++ = basic | (u8) (rate / 5); 1963 } 1964 } 1965 return 0; 1966 } 1967 1968 int ieee80211_ave_rssi(struct ieee80211_vif *vif) 1969 { 1970 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1971 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1972 1973 if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) { 1974 /* non-managed type inferfaces */ 1975 return 0; 1976 } 1977 return ifmgd->ave_beacon_signal; 1978 } 1979 EXPORT_SYMBOL_GPL(ieee80211_ave_rssi); 1980