1 /* 2 * BSS client mode implementation 3 * Copyright 2003-2008, Jouni Malinen <j@w1.fi> 4 * Copyright 2004, Instant802 Networks, Inc. 5 * Copyright 2005, Devicescape Software, Inc. 6 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 7 * Copyright 2007, Michael Wu <flamingice@sourmilk.net> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 14 #include <linux/delay.h> 15 #include <linux/if_ether.h> 16 #include <linux/skbuff.h> 17 #include <linux/if_arp.h> 18 #include <linux/etherdevice.h> 19 #include <linux/rtnetlink.h> 20 #include <linux/pm_qos_params.h> 21 #include <linux/crc32.h> 22 #include <linux/slab.h> 23 #include <net/mac80211.h> 24 #include <asm/unaligned.h> 25 26 #include "ieee80211_i.h" 27 #include "driver-ops.h" 28 #include "rate.h" 29 #include "led.h" 30 31 #define IEEE80211_MAX_PROBE_TRIES 5 32 33 /* 34 * beacon loss detection timeout 35 * XXX: should depend on beacon interval 36 */ 37 #define IEEE80211_BEACON_LOSS_TIME (2 * HZ) 38 /* 39 * Time the connection can be idle before we probe 40 * it to see if we can still talk to the AP. 41 */ 42 #define IEEE80211_CONNECTION_IDLE_TIME (30 * HZ) 43 /* 44 * Time we wait for a probe response after sending 45 * a probe request because of beacon loss or for 46 * checking the connection still works. 47 */ 48 #define IEEE80211_PROBE_WAIT (HZ / 2) 49 50 /* 51 * Weight given to the latest Beacon frame when calculating average signal 52 * strength for Beacon frames received in the current BSS. This must be 53 * between 1 and 15. 54 */ 55 #define IEEE80211_SIGNAL_AVE_WEIGHT 3 56 57 #define TMR_RUNNING_TIMER 0 58 #define TMR_RUNNING_CHANSW 1 59 60 /* 61 * All cfg80211 functions have to be called outside a locked 62 * section so that they can acquire a lock themselves... This 63 * is much simpler than queuing up things in cfg80211, but we 64 * do need some indirection for that here. 65 */ 66 enum rx_mgmt_action { 67 /* no action required */ 68 RX_MGMT_NONE, 69 70 /* caller must call cfg80211_send_rx_auth() */ 71 RX_MGMT_CFG80211_AUTH, 72 73 /* caller must call cfg80211_send_rx_assoc() */ 74 RX_MGMT_CFG80211_ASSOC, 75 76 /* caller must call cfg80211_send_deauth() */ 77 RX_MGMT_CFG80211_DEAUTH, 78 79 /* caller must call cfg80211_send_disassoc() */ 80 RX_MGMT_CFG80211_DISASSOC, 81 82 /* caller must tell cfg80211 about internal error */ 83 RX_MGMT_CFG80211_ASSOC_ERROR, 84 }; 85 86 /* utils */ 87 static inline void ASSERT_MGD_MTX(struct ieee80211_if_managed *ifmgd) 88 { 89 WARN_ON(!mutex_is_locked(&ifmgd->mtx)); 90 } 91 92 /* 93 * We can have multiple work items (and connection probing) 94 * scheduling this timer, but we need to take care to only 95 * reschedule it when it should fire _earlier_ than it was 96 * asked for before, or if it's not pending right now. This 97 * function ensures that. Note that it then is required to 98 * run this function for all timeouts after the first one 99 * has happened -- the work that runs from this timer will 100 * do that. 101 */ 102 static void run_again(struct ieee80211_if_managed *ifmgd, 103 unsigned long timeout) 104 { 105 ASSERT_MGD_MTX(ifmgd); 106 107 if (!timer_pending(&ifmgd->timer) || 108 time_before(timeout, ifmgd->timer.expires)) 109 mod_timer(&ifmgd->timer, timeout); 110 } 111 112 static void mod_beacon_timer(struct ieee80211_sub_if_data *sdata) 113 { 114 if (sdata->local->hw.flags & IEEE80211_HW_BEACON_FILTER) 115 return; 116 117 mod_timer(&sdata->u.mgd.bcn_mon_timer, 118 round_jiffies_up(jiffies + IEEE80211_BEACON_LOSS_TIME)); 119 } 120 121 static int ecw2cw(int ecw) 122 { 123 return (1 << ecw) - 1; 124 } 125 126 /* 127 * ieee80211_enable_ht should be called only after the operating band 128 * has been determined as ht configuration depends on the hw's 129 * HT abilities for a specific band. 130 */ 131 static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata, 132 struct ieee80211_ht_info *hti, 133 const u8 *bssid, u16 ap_ht_cap_flags) 134 { 135 struct ieee80211_local *local = sdata->local; 136 struct ieee80211_supported_band *sband; 137 struct sta_info *sta; 138 u32 changed = 0; 139 u16 ht_opmode; 140 bool enable_ht = true; 141 enum nl80211_channel_type prev_chantype; 142 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT; 143 144 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 145 146 prev_chantype = sdata->vif.bss_conf.channel_type; 147 148 /* HT is not supported */ 149 if (!sband->ht_cap.ht_supported) 150 enable_ht = false; 151 152 /* check that channel matches the right operating channel */ 153 if (local->hw.conf.channel->center_freq != 154 ieee80211_channel_to_frequency(hti->control_chan)) 155 enable_ht = false; 156 157 if (enable_ht) { 158 channel_type = NL80211_CHAN_HT20; 159 160 if (!(ap_ht_cap_flags & IEEE80211_HT_CAP_40MHZ_INTOLERANT) && 161 (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) && 162 (hti->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) { 163 switch(hti->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) { 164 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: 165 if (!(local->hw.conf.channel->flags & 166 IEEE80211_CHAN_NO_HT40PLUS)) 167 channel_type = NL80211_CHAN_HT40PLUS; 168 break; 169 case IEEE80211_HT_PARAM_CHA_SEC_BELOW: 170 if (!(local->hw.conf.channel->flags & 171 IEEE80211_CHAN_NO_HT40MINUS)) 172 channel_type = NL80211_CHAN_HT40MINUS; 173 break; 174 } 175 } 176 } 177 178 if (local->tmp_channel) 179 local->tmp_channel_type = channel_type; 180 181 if (!ieee80211_set_channel_type(local, sdata, channel_type)) { 182 /* can only fail due to HT40+/- mismatch */ 183 channel_type = NL80211_CHAN_HT20; 184 WARN_ON(!ieee80211_set_channel_type(local, sdata, channel_type)); 185 } 186 187 /* channel_type change automatically detected */ 188 ieee80211_hw_config(local, 0); 189 190 if (prev_chantype != channel_type) { 191 rcu_read_lock(); 192 sta = sta_info_get(sdata, bssid); 193 if (sta) 194 rate_control_rate_update(local, sband, sta, 195 IEEE80211_RC_HT_CHANGED, 196 channel_type); 197 rcu_read_unlock(); 198 } 199 200 ht_opmode = le16_to_cpu(hti->operation_mode); 201 202 /* if bss configuration changed store the new one */ 203 if (sdata->ht_opmode_valid != enable_ht || 204 sdata->vif.bss_conf.ht_operation_mode != ht_opmode || 205 prev_chantype != channel_type) { 206 changed |= BSS_CHANGED_HT; 207 sdata->vif.bss_conf.ht_operation_mode = ht_opmode; 208 sdata->ht_opmode_valid = enable_ht; 209 } 210 211 return changed; 212 } 213 214 /* frame sending functions */ 215 216 static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata, 217 const u8 *bssid, u16 stype, u16 reason, 218 void *cookie, bool send_frame) 219 { 220 struct ieee80211_local *local = sdata->local; 221 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 222 struct sk_buff *skb; 223 struct ieee80211_mgmt *mgmt; 224 225 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt)); 226 if (!skb) { 227 printk(KERN_DEBUG "%s: failed to allocate buffer for " 228 "deauth/disassoc frame\n", sdata->name); 229 return; 230 } 231 skb_reserve(skb, local->hw.extra_tx_headroom); 232 233 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 234 memset(mgmt, 0, 24); 235 memcpy(mgmt->da, bssid, ETH_ALEN); 236 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 237 memcpy(mgmt->bssid, bssid, ETH_ALEN); 238 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype); 239 skb_put(skb, 2); 240 /* u.deauth.reason_code == u.disassoc.reason_code */ 241 mgmt->u.deauth.reason_code = cpu_to_le16(reason); 242 243 if (stype == IEEE80211_STYPE_DEAUTH) 244 if (cookie) 245 __cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len); 246 else 247 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len); 248 else 249 if (cookie) 250 __cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len); 251 else 252 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len); 253 if (!(ifmgd->flags & IEEE80211_STA_MFP_ENABLED)) 254 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 255 256 if (send_frame) 257 ieee80211_tx_skb(sdata, skb); 258 else 259 kfree_skb(skb); 260 } 261 262 void ieee80211_send_pspoll(struct ieee80211_local *local, 263 struct ieee80211_sub_if_data *sdata) 264 { 265 struct ieee80211_pspoll *pspoll; 266 struct sk_buff *skb; 267 268 skb = ieee80211_pspoll_get(&local->hw, &sdata->vif); 269 if (!skb) 270 return; 271 272 pspoll = (struct ieee80211_pspoll *) skb->data; 273 pspoll->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM); 274 275 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 276 ieee80211_tx_skb(sdata, skb); 277 } 278 279 void ieee80211_send_nullfunc(struct ieee80211_local *local, 280 struct ieee80211_sub_if_data *sdata, 281 int powersave) 282 { 283 struct sk_buff *skb; 284 struct ieee80211_hdr_3addr *nullfunc; 285 286 skb = ieee80211_nullfunc_get(&local->hw, &sdata->vif); 287 if (!skb) 288 return; 289 290 nullfunc = (struct ieee80211_hdr_3addr *) skb->data; 291 if (powersave) 292 nullfunc->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM); 293 294 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 295 ieee80211_tx_skb(sdata, skb); 296 } 297 298 static void ieee80211_send_4addr_nullfunc(struct ieee80211_local *local, 299 struct ieee80211_sub_if_data *sdata) 300 { 301 struct sk_buff *skb; 302 struct ieee80211_hdr *nullfunc; 303 __le16 fc; 304 305 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION)) 306 return; 307 308 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 30); 309 if (!skb) { 310 printk(KERN_DEBUG "%s: failed to allocate buffer for 4addr " 311 "nullfunc frame\n", sdata->name); 312 return; 313 } 314 skb_reserve(skb, local->hw.extra_tx_headroom); 315 316 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 30); 317 memset(nullfunc, 0, 30); 318 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC | 319 IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS); 320 nullfunc->frame_control = fc; 321 memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN); 322 memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN); 323 memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN); 324 memcpy(nullfunc->addr4, sdata->vif.addr, ETH_ALEN); 325 326 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 327 ieee80211_tx_skb(sdata, skb); 328 } 329 330 /* spectrum management related things */ 331 static void ieee80211_chswitch_work(struct work_struct *work) 332 { 333 struct ieee80211_sub_if_data *sdata = 334 container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work); 335 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 336 337 if (!ieee80211_sdata_running(sdata)) 338 return; 339 340 mutex_lock(&ifmgd->mtx); 341 if (!ifmgd->associated) 342 goto out; 343 344 sdata->local->oper_channel = sdata->local->csa_channel; 345 if (!sdata->local->ops->channel_switch) { 346 /* call "hw_config" only if doing sw channel switch */ 347 ieee80211_hw_config(sdata->local, 348 IEEE80211_CONF_CHANGE_CHANNEL); 349 } 350 351 /* XXX: shouldn't really modify cfg80211-owned data! */ 352 ifmgd->associated->channel = sdata->local->oper_channel; 353 354 ieee80211_wake_queues_by_reason(&sdata->local->hw, 355 IEEE80211_QUEUE_STOP_REASON_CSA); 356 out: 357 ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED; 358 mutex_unlock(&ifmgd->mtx); 359 } 360 361 void ieee80211_chswitch_done(struct ieee80211_vif *vif, bool success) 362 { 363 struct ieee80211_sub_if_data *sdata; 364 struct ieee80211_if_managed *ifmgd; 365 366 sdata = vif_to_sdata(vif); 367 ifmgd = &sdata->u.mgd; 368 369 trace_api_chswitch_done(sdata, success); 370 if (!success) { 371 /* 372 * If the channel switch was not successful, stay 373 * around on the old channel. We currently lack 374 * good handling of this situation, possibly we 375 * should just drop the association. 376 */ 377 sdata->local->csa_channel = sdata->local->oper_channel; 378 } 379 380 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work); 381 } 382 EXPORT_SYMBOL(ieee80211_chswitch_done); 383 384 static void ieee80211_chswitch_timer(unsigned long data) 385 { 386 struct ieee80211_sub_if_data *sdata = 387 (struct ieee80211_sub_if_data *) data; 388 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 389 390 if (sdata->local->quiescing) { 391 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running); 392 return; 393 } 394 395 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work); 396 } 397 398 void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata, 399 struct ieee80211_channel_sw_ie *sw_elem, 400 struct ieee80211_bss *bss, 401 u64 timestamp) 402 { 403 struct cfg80211_bss *cbss = 404 container_of((void *)bss, struct cfg80211_bss, priv); 405 struct ieee80211_channel *new_ch; 406 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 407 int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num); 408 409 ASSERT_MGD_MTX(ifmgd); 410 411 if (!ifmgd->associated) 412 return; 413 414 if (sdata->local->scanning) 415 return; 416 417 /* Disregard subsequent beacons if we are already running a timer 418 processing a CSA */ 419 420 if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED) 421 return; 422 423 new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq); 424 if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED) 425 return; 426 427 sdata->local->csa_channel = new_ch; 428 429 if (sdata->local->ops->channel_switch) { 430 /* use driver's channel switch callback */ 431 struct ieee80211_channel_switch ch_switch; 432 memset(&ch_switch, 0, sizeof(ch_switch)); 433 ch_switch.timestamp = timestamp; 434 if (sw_elem->mode) { 435 ch_switch.block_tx = true; 436 ieee80211_stop_queues_by_reason(&sdata->local->hw, 437 IEEE80211_QUEUE_STOP_REASON_CSA); 438 } 439 ch_switch.channel = new_ch; 440 ch_switch.count = sw_elem->count; 441 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED; 442 drv_channel_switch(sdata->local, &ch_switch); 443 return; 444 } 445 446 /* channel switch handled in software */ 447 if (sw_elem->count <= 1) { 448 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work); 449 } else { 450 if (sw_elem->mode) 451 ieee80211_stop_queues_by_reason(&sdata->local->hw, 452 IEEE80211_QUEUE_STOP_REASON_CSA); 453 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED; 454 mod_timer(&ifmgd->chswitch_timer, 455 jiffies + 456 msecs_to_jiffies(sw_elem->count * 457 cbss->beacon_interval)); 458 } 459 } 460 461 static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata, 462 u16 capab_info, u8 *pwr_constr_elem, 463 u8 pwr_constr_elem_len) 464 { 465 struct ieee80211_conf *conf = &sdata->local->hw.conf; 466 467 if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT)) 468 return; 469 470 /* Power constraint IE length should be 1 octet */ 471 if (pwr_constr_elem_len != 1) 472 return; 473 474 if ((*pwr_constr_elem <= conf->channel->max_power) && 475 (*pwr_constr_elem != sdata->local->power_constr_level)) { 476 sdata->local->power_constr_level = *pwr_constr_elem; 477 ieee80211_hw_config(sdata->local, 0); 478 } 479 } 480 481 /* powersave */ 482 static void ieee80211_enable_ps(struct ieee80211_local *local, 483 struct ieee80211_sub_if_data *sdata) 484 { 485 struct ieee80211_conf *conf = &local->hw.conf; 486 487 /* 488 * If we are scanning right now then the parameters will 489 * take effect when scan finishes. 490 */ 491 if (local->scanning) 492 return; 493 494 if (conf->dynamic_ps_timeout > 0 && 495 !(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) { 496 mod_timer(&local->dynamic_ps_timer, jiffies + 497 msecs_to_jiffies(conf->dynamic_ps_timeout)); 498 } else { 499 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) 500 ieee80211_send_nullfunc(local, sdata, 1); 501 502 if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) && 503 (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)) 504 return; 505 506 conf->flags |= IEEE80211_CONF_PS; 507 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS); 508 } 509 } 510 511 static void ieee80211_change_ps(struct ieee80211_local *local) 512 { 513 struct ieee80211_conf *conf = &local->hw.conf; 514 515 if (local->ps_sdata) { 516 ieee80211_enable_ps(local, local->ps_sdata); 517 } else if (conf->flags & IEEE80211_CONF_PS) { 518 conf->flags &= ~IEEE80211_CONF_PS; 519 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS); 520 del_timer_sync(&local->dynamic_ps_timer); 521 cancel_work_sync(&local->dynamic_ps_enable_work); 522 } 523 } 524 525 /* need to hold RTNL or interface lock */ 526 void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency) 527 { 528 struct ieee80211_sub_if_data *sdata, *found = NULL; 529 int count = 0; 530 int timeout; 531 532 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) { 533 local->ps_sdata = NULL; 534 return; 535 } 536 537 if (!list_empty(&local->work_list)) { 538 local->ps_sdata = NULL; 539 goto change; 540 } 541 542 list_for_each_entry(sdata, &local->interfaces, list) { 543 if (!ieee80211_sdata_running(sdata)) 544 continue; 545 if (sdata->vif.type != NL80211_IFTYPE_STATION) 546 continue; 547 found = sdata; 548 count++; 549 } 550 551 if (count == 1 && found->u.mgd.powersave && 552 found->u.mgd.associated && 553 found->u.mgd.associated->beacon_ies && 554 !(found->u.mgd.flags & (IEEE80211_STA_BEACON_POLL | 555 IEEE80211_STA_CONNECTION_POLL))) { 556 s32 beaconint_us; 557 558 if (latency < 0) 559 latency = pm_qos_request(PM_QOS_NETWORK_LATENCY); 560 561 beaconint_us = ieee80211_tu_to_usec( 562 found->vif.bss_conf.beacon_int); 563 564 timeout = local->hw.conf.dynamic_ps_forced_timeout; 565 if (timeout < 0) { 566 /* 567 * The 2 second value is there for compatibility until 568 * the PM_QOS_NETWORK_LATENCY is configured with real 569 * values. 570 */ 571 if (latency == 2000000000) 572 timeout = 100; 573 else if (latency <= 50000) 574 timeout = 300; 575 else if (latency <= 100000) 576 timeout = 100; 577 else if (latency <= 500000) 578 timeout = 50; 579 else 580 timeout = 0; 581 } 582 local->hw.conf.dynamic_ps_timeout = timeout; 583 584 if (beaconint_us > latency) { 585 local->ps_sdata = NULL; 586 } else { 587 struct ieee80211_bss *bss; 588 int maxslp = 1; 589 u8 dtimper; 590 591 bss = (void *)found->u.mgd.associated->priv; 592 dtimper = bss->dtim_period; 593 594 /* If the TIM IE is invalid, pretend the value is 1 */ 595 if (!dtimper) 596 dtimper = 1; 597 else if (dtimper > 1) 598 maxslp = min_t(int, dtimper, 599 latency / beaconint_us); 600 601 local->hw.conf.max_sleep_period = maxslp; 602 local->hw.conf.ps_dtim_period = dtimper; 603 local->ps_sdata = found; 604 } 605 } else { 606 local->ps_sdata = NULL; 607 } 608 609 change: 610 ieee80211_change_ps(local); 611 } 612 613 void ieee80211_dynamic_ps_disable_work(struct work_struct *work) 614 { 615 struct ieee80211_local *local = 616 container_of(work, struct ieee80211_local, 617 dynamic_ps_disable_work); 618 619 if (local->hw.conf.flags & IEEE80211_CONF_PS) { 620 local->hw.conf.flags &= ~IEEE80211_CONF_PS; 621 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS); 622 } 623 624 ieee80211_wake_queues_by_reason(&local->hw, 625 IEEE80211_QUEUE_STOP_REASON_PS); 626 } 627 628 void ieee80211_dynamic_ps_enable_work(struct work_struct *work) 629 { 630 struct ieee80211_local *local = 631 container_of(work, struct ieee80211_local, 632 dynamic_ps_enable_work); 633 struct ieee80211_sub_if_data *sdata = local->ps_sdata; 634 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 635 636 /* can only happen when PS was just disabled anyway */ 637 if (!sdata) 638 return; 639 640 if (local->hw.conf.flags & IEEE80211_CONF_PS) 641 return; 642 643 if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) && 644 (!(ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED))) 645 ieee80211_send_nullfunc(local, sdata, 1); 646 647 if (!((local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) && 648 (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)) || 649 (ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) { 650 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED; 651 local->hw.conf.flags |= IEEE80211_CONF_PS; 652 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS); 653 } 654 } 655 656 void ieee80211_dynamic_ps_timer(unsigned long data) 657 { 658 struct ieee80211_local *local = (void *) data; 659 660 if (local->quiescing || local->suspended) 661 return; 662 663 ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work); 664 } 665 666 /* MLME */ 667 static void ieee80211_sta_wmm_params(struct ieee80211_local *local, 668 struct ieee80211_if_managed *ifmgd, 669 u8 *wmm_param, size_t wmm_param_len) 670 { 671 struct ieee80211_tx_queue_params params; 672 size_t left; 673 int count; 674 u8 *pos, uapsd_queues = 0; 675 676 if (!local->ops->conf_tx) 677 return; 678 679 if (local->hw.queues < 4) 680 return; 681 682 if (!wmm_param) 683 return; 684 685 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1) 686 return; 687 688 if (ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED) 689 uapsd_queues = local->uapsd_queues; 690 691 count = wmm_param[6] & 0x0f; 692 if (count == ifmgd->wmm_last_param_set) 693 return; 694 ifmgd->wmm_last_param_set = count; 695 696 pos = wmm_param + 8; 697 left = wmm_param_len - 8; 698 699 memset(¶ms, 0, sizeof(params)); 700 701 local->wmm_acm = 0; 702 for (; left >= 4; left -= 4, pos += 4) { 703 int aci = (pos[0] >> 5) & 0x03; 704 int acm = (pos[0] >> 4) & 0x01; 705 bool uapsd = false; 706 int queue; 707 708 switch (aci) { 709 case 1: /* AC_BK */ 710 queue = 3; 711 if (acm) 712 local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */ 713 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) 714 uapsd = true; 715 break; 716 case 2: /* AC_VI */ 717 queue = 1; 718 if (acm) 719 local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */ 720 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) 721 uapsd = true; 722 break; 723 case 3: /* AC_VO */ 724 queue = 0; 725 if (acm) 726 local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */ 727 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) 728 uapsd = true; 729 break; 730 case 0: /* AC_BE */ 731 default: 732 queue = 2; 733 if (acm) 734 local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */ 735 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) 736 uapsd = true; 737 break; 738 } 739 740 params.aifs = pos[0] & 0x0f; 741 params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4); 742 params.cw_min = ecw2cw(pos[1] & 0x0f); 743 params.txop = get_unaligned_le16(pos + 2); 744 params.uapsd = uapsd; 745 746 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 747 printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d " 748 "cWmin=%d cWmax=%d txop=%d uapsd=%d\n", 749 wiphy_name(local->hw.wiphy), queue, aci, acm, 750 params.aifs, params.cw_min, params.cw_max, params.txop, 751 params.uapsd); 752 #endif 753 if (drv_conf_tx(local, queue, ¶ms)) 754 printk(KERN_DEBUG "%s: failed to set TX queue " 755 "parameters for queue %d\n", 756 wiphy_name(local->hw.wiphy), queue); 757 } 758 759 /* enable WMM or activate new settings */ 760 local->hw.conf.flags |= IEEE80211_CONF_QOS; 761 drv_config(local, IEEE80211_CONF_CHANGE_QOS); 762 } 763 764 static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata, 765 u16 capab, bool erp_valid, u8 erp) 766 { 767 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf; 768 u32 changed = 0; 769 bool use_protection; 770 bool use_short_preamble; 771 bool use_short_slot; 772 773 if (erp_valid) { 774 use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0; 775 use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0; 776 } else { 777 use_protection = false; 778 use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE); 779 } 780 781 use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME); 782 if (sdata->local->hw.conf.channel->band == IEEE80211_BAND_5GHZ) 783 use_short_slot = true; 784 785 if (use_protection != bss_conf->use_cts_prot) { 786 bss_conf->use_cts_prot = use_protection; 787 changed |= BSS_CHANGED_ERP_CTS_PROT; 788 } 789 790 if (use_short_preamble != bss_conf->use_short_preamble) { 791 bss_conf->use_short_preamble = use_short_preamble; 792 changed |= BSS_CHANGED_ERP_PREAMBLE; 793 } 794 795 if (use_short_slot != bss_conf->use_short_slot) { 796 bss_conf->use_short_slot = use_short_slot; 797 changed |= BSS_CHANGED_ERP_SLOT; 798 } 799 800 return changed; 801 } 802 803 static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata, 804 struct cfg80211_bss *cbss, 805 u32 bss_info_changed) 806 { 807 struct ieee80211_bss *bss = (void *)cbss->priv; 808 struct ieee80211_local *local = sdata->local; 809 810 bss_info_changed |= BSS_CHANGED_ASSOC; 811 /* set timing information */ 812 sdata->vif.bss_conf.beacon_int = cbss->beacon_interval; 813 sdata->vif.bss_conf.timestamp = cbss->tsf; 814 815 bss_info_changed |= BSS_CHANGED_BEACON_INT; 816 bss_info_changed |= ieee80211_handle_bss_capability(sdata, 817 cbss->capability, bss->has_erp_value, bss->erp_value); 818 819 sdata->u.mgd.associated = cbss; 820 memcpy(sdata->u.mgd.bssid, cbss->bssid, ETH_ALEN); 821 822 sdata->u.mgd.flags |= IEEE80211_STA_RESET_SIGNAL_AVE; 823 824 /* just to be sure */ 825 sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL | 826 IEEE80211_STA_BEACON_POLL); 827 828 /* 829 * Always handle WMM once after association regardless 830 * of the first value the AP uses. Setting -1 here has 831 * that effect because the AP values is an unsigned 832 * 4-bit value. 833 */ 834 sdata->u.mgd.wmm_last_param_set = -1; 835 836 ieee80211_led_assoc(local, 1); 837 838 sdata->vif.bss_conf.assoc = 1; 839 /* 840 * For now just always ask the driver to update the basic rateset 841 * when we have associated, we aren't checking whether it actually 842 * changed or not. 843 */ 844 bss_info_changed |= BSS_CHANGED_BASIC_RATES; 845 846 /* And the BSSID changed - we're associated now */ 847 bss_info_changed |= BSS_CHANGED_BSSID; 848 849 /* Tell the driver to monitor connection quality (if supported) */ 850 if ((local->hw.flags & IEEE80211_HW_SUPPORTS_CQM_RSSI) && 851 sdata->vif.bss_conf.cqm_rssi_thold) 852 bss_info_changed |= BSS_CHANGED_CQM; 853 854 ieee80211_bss_info_change_notify(sdata, bss_info_changed); 855 856 mutex_lock(&local->iflist_mtx); 857 ieee80211_recalc_ps(local, -1); 858 ieee80211_recalc_smps(local, sdata); 859 mutex_unlock(&local->iflist_mtx); 860 861 netif_tx_start_all_queues(sdata->dev); 862 netif_carrier_on(sdata->dev); 863 } 864 865 static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata, 866 bool remove_sta) 867 { 868 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 869 struct ieee80211_local *local = sdata->local; 870 struct sta_info *sta; 871 u32 changed = 0, config_changed = 0; 872 u8 bssid[ETH_ALEN]; 873 874 ASSERT_MGD_MTX(ifmgd); 875 876 if (WARN_ON(!ifmgd->associated)) 877 return; 878 879 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN); 880 881 ifmgd->associated = NULL; 882 memset(ifmgd->bssid, 0, ETH_ALEN); 883 884 /* 885 * we need to commit the associated = NULL change because the 886 * scan code uses that to determine whether this iface should 887 * go to/wake up from powersave or not -- and could otherwise 888 * wake the queues erroneously. 889 */ 890 smp_mb(); 891 892 /* 893 * Thus, we can only afterwards stop the queues -- to account 894 * for the case where another CPU is finishing a scan at this 895 * time -- we don't want the scan code to enable queues. 896 */ 897 898 netif_tx_stop_all_queues(sdata->dev); 899 netif_carrier_off(sdata->dev); 900 901 rcu_read_lock(); 902 sta = sta_info_get(sdata, bssid); 903 if (sta) { 904 set_sta_flags(sta, WLAN_STA_DISASSOC); 905 ieee80211_sta_tear_down_BA_sessions(sta); 906 } 907 rcu_read_unlock(); 908 909 changed |= ieee80211_reset_erp_info(sdata); 910 911 ieee80211_led_assoc(local, 0); 912 changed |= BSS_CHANGED_ASSOC; 913 sdata->vif.bss_conf.assoc = false; 914 915 ieee80211_set_wmm_default(sdata); 916 917 /* channel(_type) changes are handled by ieee80211_hw_config */ 918 WARN_ON(!ieee80211_set_channel_type(local, sdata, NL80211_CHAN_NO_HT)); 919 920 /* on the next assoc, re-program HT parameters */ 921 sdata->ht_opmode_valid = false; 922 923 local->power_constr_level = 0; 924 925 del_timer_sync(&local->dynamic_ps_timer); 926 cancel_work_sync(&local->dynamic_ps_enable_work); 927 928 if (local->hw.conf.flags & IEEE80211_CONF_PS) { 929 local->hw.conf.flags &= ~IEEE80211_CONF_PS; 930 config_changed |= IEEE80211_CONF_CHANGE_PS; 931 } 932 933 ieee80211_hw_config(local, config_changed); 934 935 /* The BSSID (not really interesting) and HT changed */ 936 changed |= BSS_CHANGED_BSSID | BSS_CHANGED_HT; 937 ieee80211_bss_info_change_notify(sdata, changed); 938 939 if (remove_sta) 940 sta_info_destroy_addr(sdata, bssid); 941 } 942 943 void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata, 944 struct ieee80211_hdr *hdr) 945 { 946 /* 947 * We can postpone the mgd.timer whenever receiving unicast frames 948 * from AP because we know that the connection is working both ways 949 * at that time. But multicast frames (and hence also beacons) must 950 * be ignored here, because we need to trigger the timer during 951 * data idle periods for sending the periodic probe request to the 952 * AP we're connected to. 953 */ 954 if (is_multicast_ether_addr(hdr->addr1)) 955 return; 956 957 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR) 958 return; 959 960 mod_timer(&sdata->u.mgd.conn_mon_timer, 961 round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME)); 962 } 963 964 static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata) 965 { 966 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 967 const u8 *ssid; 968 969 ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID); 970 ieee80211_send_probe_req(sdata, ifmgd->associated->bssid, 971 ssid + 2, ssid[1], NULL, 0); 972 973 ifmgd->probe_send_count++; 974 ifmgd->probe_timeout = jiffies + IEEE80211_PROBE_WAIT; 975 run_again(ifmgd, ifmgd->probe_timeout); 976 } 977 978 static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata, 979 bool beacon) 980 { 981 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 982 bool already = false; 983 984 if (!ieee80211_sdata_running(sdata)) 985 return; 986 987 if (sdata->local->scanning) 988 return; 989 990 if (sdata->local->tmp_channel) 991 return; 992 993 mutex_lock(&ifmgd->mtx); 994 995 if (!ifmgd->associated) 996 goto out; 997 998 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 999 if (beacon && net_ratelimit()) 1000 printk(KERN_DEBUG "%s: detected beacon loss from AP " 1001 "- sending probe request\n", sdata->name); 1002 #endif 1003 1004 /* 1005 * The driver/our work has already reported this event or the 1006 * connection monitoring has kicked in and we have already sent 1007 * a probe request. Or maybe the AP died and the driver keeps 1008 * reporting until we disassociate... 1009 * 1010 * In either case we have to ignore the current call to this 1011 * function (except for setting the correct probe reason bit) 1012 * because otherwise we would reset the timer every time and 1013 * never check whether we received a probe response! 1014 */ 1015 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL | 1016 IEEE80211_STA_CONNECTION_POLL)) 1017 already = true; 1018 1019 if (beacon) 1020 ifmgd->flags |= IEEE80211_STA_BEACON_POLL; 1021 else 1022 ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL; 1023 1024 if (already) 1025 goto out; 1026 1027 mutex_lock(&sdata->local->iflist_mtx); 1028 ieee80211_recalc_ps(sdata->local, -1); 1029 mutex_unlock(&sdata->local->iflist_mtx); 1030 1031 ifmgd->probe_send_count = 0; 1032 ieee80211_mgd_probe_ap_send(sdata); 1033 out: 1034 mutex_unlock(&ifmgd->mtx); 1035 } 1036 1037 static void __ieee80211_connection_loss(struct ieee80211_sub_if_data *sdata) 1038 { 1039 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1040 struct ieee80211_local *local = sdata->local; 1041 u8 bssid[ETH_ALEN]; 1042 1043 mutex_lock(&ifmgd->mtx); 1044 if (!ifmgd->associated) { 1045 mutex_unlock(&ifmgd->mtx); 1046 return; 1047 } 1048 1049 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN); 1050 1051 printk(KERN_DEBUG "Connection to AP %pM lost.\n", bssid); 1052 1053 ieee80211_set_disassoc(sdata, true); 1054 ieee80211_recalc_idle(local); 1055 mutex_unlock(&ifmgd->mtx); 1056 /* 1057 * must be outside lock due to cfg80211, 1058 * but that's not a problem. 1059 */ 1060 ieee80211_send_deauth_disassoc(sdata, bssid, 1061 IEEE80211_STYPE_DEAUTH, 1062 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY, 1063 NULL, true); 1064 } 1065 1066 void ieee80211_beacon_connection_loss_work(struct work_struct *work) 1067 { 1068 struct ieee80211_sub_if_data *sdata = 1069 container_of(work, struct ieee80211_sub_if_data, 1070 u.mgd.beacon_connection_loss_work); 1071 1072 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR) 1073 __ieee80211_connection_loss(sdata); 1074 else 1075 ieee80211_mgd_probe_ap(sdata, true); 1076 } 1077 1078 void ieee80211_beacon_loss(struct ieee80211_vif *vif) 1079 { 1080 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1081 struct ieee80211_hw *hw = &sdata->local->hw; 1082 1083 trace_api_beacon_loss(sdata); 1084 1085 WARN_ON(hw->flags & IEEE80211_HW_CONNECTION_MONITOR); 1086 ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work); 1087 } 1088 EXPORT_SYMBOL(ieee80211_beacon_loss); 1089 1090 void ieee80211_connection_loss(struct ieee80211_vif *vif) 1091 { 1092 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1093 struct ieee80211_hw *hw = &sdata->local->hw; 1094 1095 trace_api_connection_loss(sdata); 1096 1097 WARN_ON(!(hw->flags & IEEE80211_HW_CONNECTION_MONITOR)); 1098 ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work); 1099 } 1100 EXPORT_SYMBOL(ieee80211_connection_loss); 1101 1102 1103 static enum rx_mgmt_action __must_check 1104 ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata, 1105 struct ieee80211_mgmt *mgmt, size_t len) 1106 { 1107 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1108 const u8 *bssid = NULL; 1109 u16 reason_code; 1110 1111 if (len < 24 + 2) 1112 return RX_MGMT_NONE; 1113 1114 ASSERT_MGD_MTX(ifmgd); 1115 1116 bssid = ifmgd->associated->bssid; 1117 1118 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code); 1119 1120 printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n", 1121 sdata->name, bssid, reason_code); 1122 1123 ieee80211_set_disassoc(sdata, true); 1124 ieee80211_recalc_idle(sdata->local); 1125 1126 return RX_MGMT_CFG80211_DEAUTH; 1127 } 1128 1129 1130 static enum rx_mgmt_action __must_check 1131 ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata, 1132 struct ieee80211_mgmt *mgmt, size_t len) 1133 { 1134 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1135 u16 reason_code; 1136 1137 if (len < 24 + 2) 1138 return RX_MGMT_NONE; 1139 1140 ASSERT_MGD_MTX(ifmgd); 1141 1142 if (WARN_ON(!ifmgd->associated)) 1143 return RX_MGMT_NONE; 1144 1145 if (WARN_ON(memcmp(ifmgd->associated->bssid, mgmt->sa, ETH_ALEN))) 1146 return RX_MGMT_NONE; 1147 1148 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code); 1149 1150 printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n", 1151 sdata->name, mgmt->sa, reason_code); 1152 1153 ieee80211_set_disassoc(sdata, true); 1154 ieee80211_recalc_idle(sdata->local); 1155 return RX_MGMT_CFG80211_DISASSOC; 1156 } 1157 1158 1159 static bool ieee80211_assoc_success(struct ieee80211_work *wk, 1160 struct ieee80211_mgmt *mgmt, size_t len) 1161 { 1162 struct ieee80211_sub_if_data *sdata = wk->sdata; 1163 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1164 struct ieee80211_local *local = sdata->local; 1165 struct ieee80211_supported_band *sband; 1166 struct sta_info *sta; 1167 struct cfg80211_bss *cbss = wk->assoc.bss; 1168 u8 *pos; 1169 u32 rates, basic_rates; 1170 u16 capab_info, aid; 1171 struct ieee802_11_elems elems; 1172 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf; 1173 u32 changed = 0; 1174 int i, j, err; 1175 bool have_higher_than_11mbit = false; 1176 u16 ap_ht_cap_flags; 1177 1178 /* AssocResp and ReassocResp have identical structure */ 1179 1180 aid = le16_to_cpu(mgmt->u.assoc_resp.aid); 1181 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info); 1182 1183 if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14))) 1184 printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not " 1185 "set\n", sdata->name, aid); 1186 aid &= ~(BIT(15) | BIT(14)); 1187 1188 pos = mgmt->u.assoc_resp.variable; 1189 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems); 1190 1191 if (!elems.supp_rates) { 1192 printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n", 1193 sdata->name); 1194 return false; 1195 } 1196 1197 ifmgd->aid = aid; 1198 1199 sta = sta_info_alloc(sdata, cbss->bssid, GFP_KERNEL); 1200 if (!sta) { 1201 printk(KERN_DEBUG "%s: failed to alloc STA entry for" 1202 " the AP\n", sdata->name); 1203 return false; 1204 } 1205 1206 set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC | 1207 WLAN_STA_ASSOC_AP); 1208 if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT)) 1209 set_sta_flags(sta, WLAN_STA_AUTHORIZED); 1210 1211 rates = 0; 1212 basic_rates = 0; 1213 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 1214 1215 for (i = 0; i < elems.supp_rates_len; i++) { 1216 int rate = (elems.supp_rates[i] & 0x7f) * 5; 1217 bool is_basic = !!(elems.supp_rates[i] & 0x80); 1218 1219 if (rate > 110) 1220 have_higher_than_11mbit = true; 1221 1222 for (j = 0; j < sband->n_bitrates; j++) { 1223 if (sband->bitrates[j].bitrate == rate) { 1224 rates |= BIT(j); 1225 if (is_basic) 1226 basic_rates |= BIT(j); 1227 break; 1228 } 1229 } 1230 } 1231 1232 for (i = 0; i < elems.ext_supp_rates_len; i++) { 1233 int rate = (elems.ext_supp_rates[i] & 0x7f) * 5; 1234 bool is_basic = !!(elems.ext_supp_rates[i] & 0x80); 1235 1236 if (rate > 110) 1237 have_higher_than_11mbit = true; 1238 1239 for (j = 0; j < sband->n_bitrates; j++) { 1240 if (sband->bitrates[j].bitrate == rate) { 1241 rates |= BIT(j); 1242 if (is_basic) 1243 basic_rates |= BIT(j); 1244 break; 1245 } 1246 } 1247 } 1248 1249 sta->sta.supp_rates[local->hw.conf.channel->band] = rates; 1250 sdata->vif.bss_conf.basic_rates = basic_rates; 1251 1252 /* cf. IEEE 802.11 9.2.12 */ 1253 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ && 1254 have_higher_than_11mbit) 1255 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE; 1256 else 1257 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE; 1258 1259 if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) 1260 ieee80211_ht_cap_ie_to_sta_ht_cap(sband, 1261 elems.ht_cap_elem, &sta->sta.ht_cap); 1262 1263 ap_ht_cap_flags = sta->sta.ht_cap.cap; 1264 1265 rate_control_rate_init(sta); 1266 1267 if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED) 1268 set_sta_flags(sta, WLAN_STA_MFP); 1269 1270 if (elems.wmm_param) 1271 set_sta_flags(sta, WLAN_STA_WME); 1272 1273 err = sta_info_insert(sta); 1274 sta = NULL; 1275 if (err) { 1276 printk(KERN_DEBUG "%s: failed to insert STA entry for" 1277 " the AP (error %d)\n", sdata->name, err); 1278 return false; 1279 } 1280 1281 if (elems.wmm_param) 1282 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param, 1283 elems.wmm_param_len); 1284 else 1285 ieee80211_set_wmm_default(sdata); 1286 1287 local->oper_channel = wk->chan; 1288 1289 if (elems.ht_info_elem && elems.wmm_param && 1290 (sdata->local->hw.queues >= 4) && 1291 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) 1292 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem, 1293 cbss->bssid, ap_ht_cap_flags); 1294 1295 /* set AID and assoc capability, 1296 * ieee80211_set_associated() will tell the driver */ 1297 bss_conf->aid = aid; 1298 bss_conf->assoc_capability = capab_info; 1299 ieee80211_set_associated(sdata, cbss, changed); 1300 1301 /* 1302 * If we're using 4-addr mode, let the AP know that we're 1303 * doing so, so that it can create the STA VLAN on its side 1304 */ 1305 if (ifmgd->use_4addr) 1306 ieee80211_send_4addr_nullfunc(local, sdata); 1307 1308 /* 1309 * Start timer to probe the connection to the AP now. 1310 * Also start the timer that will detect beacon loss. 1311 */ 1312 ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt); 1313 mod_beacon_timer(sdata); 1314 1315 return true; 1316 } 1317 1318 1319 static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata, 1320 struct ieee80211_mgmt *mgmt, 1321 size_t len, 1322 struct ieee80211_rx_status *rx_status, 1323 struct ieee802_11_elems *elems, 1324 bool beacon) 1325 { 1326 struct ieee80211_local *local = sdata->local; 1327 int freq; 1328 struct ieee80211_bss *bss; 1329 struct ieee80211_channel *channel; 1330 bool need_ps = false; 1331 1332 if (sdata->u.mgd.associated) { 1333 bss = (void *)sdata->u.mgd.associated->priv; 1334 /* not previously set so we may need to recalc */ 1335 need_ps = !bss->dtim_period; 1336 } 1337 1338 if (elems->ds_params && elems->ds_params_len == 1) 1339 freq = ieee80211_channel_to_frequency(elems->ds_params[0]); 1340 else 1341 freq = rx_status->freq; 1342 1343 channel = ieee80211_get_channel(local->hw.wiphy, freq); 1344 1345 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) 1346 return; 1347 1348 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems, 1349 channel, beacon); 1350 if (bss) 1351 ieee80211_rx_bss_put(local, bss); 1352 1353 if (!sdata->u.mgd.associated) 1354 return; 1355 1356 if (need_ps) { 1357 mutex_lock(&local->iflist_mtx); 1358 ieee80211_recalc_ps(local, -1); 1359 mutex_unlock(&local->iflist_mtx); 1360 } 1361 1362 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) && 1363 (memcmp(mgmt->bssid, sdata->u.mgd.associated->bssid, 1364 ETH_ALEN) == 0)) { 1365 struct ieee80211_channel_sw_ie *sw_elem = 1366 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem; 1367 ieee80211_sta_process_chanswitch(sdata, sw_elem, 1368 bss, rx_status->mactime); 1369 } 1370 } 1371 1372 1373 static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata, 1374 struct sk_buff *skb) 1375 { 1376 struct ieee80211_mgmt *mgmt = (void *)skb->data; 1377 struct ieee80211_if_managed *ifmgd; 1378 struct ieee80211_rx_status *rx_status = (void *) skb->cb; 1379 size_t baselen, len = skb->len; 1380 struct ieee802_11_elems elems; 1381 1382 ifmgd = &sdata->u.mgd; 1383 1384 ASSERT_MGD_MTX(ifmgd); 1385 1386 if (memcmp(mgmt->da, sdata->vif.addr, ETH_ALEN)) 1387 return; /* ignore ProbeResp to foreign address */ 1388 1389 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt; 1390 if (baselen > len) 1391 return; 1392 1393 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen, 1394 &elems); 1395 1396 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false); 1397 1398 if (ifmgd->associated && 1399 memcmp(mgmt->bssid, ifmgd->associated->bssid, ETH_ALEN) == 0 && 1400 ifmgd->flags & (IEEE80211_STA_BEACON_POLL | 1401 IEEE80211_STA_CONNECTION_POLL)) { 1402 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL | 1403 IEEE80211_STA_BEACON_POLL); 1404 mutex_lock(&sdata->local->iflist_mtx); 1405 ieee80211_recalc_ps(sdata->local, -1); 1406 mutex_unlock(&sdata->local->iflist_mtx); 1407 1408 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR) 1409 return; 1410 1411 /* 1412 * We've received a probe response, but are not sure whether 1413 * we have or will be receiving any beacons or data, so let's 1414 * schedule the timers again, just in case. 1415 */ 1416 mod_beacon_timer(sdata); 1417 1418 mod_timer(&ifmgd->conn_mon_timer, 1419 round_jiffies_up(jiffies + 1420 IEEE80211_CONNECTION_IDLE_TIME)); 1421 } 1422 } 1423 1424 /* 1425 * This is the canonical list of information elements we care about, 1426 * the filter code also gives us all changes to the Microsoft OUI 1427 * (00:50:F2) vendor IE which is used for WMM which we need to track. 1428 * 1429 * We implement beacon filtering in software since that means we can 1430 * avoid processing the frame here and in cfg80211, and userspace 1431 * will not be able to tell whether the hardware supports it or not. 1432 * 1433 * XXX: This list needs to be dynamic -- userspace needs to be able to 1434 * add items it requires. It also needs to be able to tell us to 1435 * look out for other vendor IEs. 1436 */ 1437 static const u64 care_about_ies = 1438 (1ULL << WLAN_EID_COUNTRY) | 1439 (1ULL << WLAN_EID_ERP_INFO) | 1440 (1ULL << WLAN_EID_CHANNEL_SWITCH) | 1441 (1ULL << WLAN_EID_PWR_CONSTRAINT) | 1442 (1ULL << WLAN_EID_HT_CAPABILITY) | 1443 (1ULL << WLAN_EID_HT_INFORMATION); 1444 1445 static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata, 1446 struct ieee80211_mgmt *mgmt, 1447 size_t len, 1448 struct ieee80211_rx_status *rx_status) 1449 { 1450 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1451 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf; 1452 size_t baselen; 1453 struct ieee802_11_elems elems; 1454 struct ieee80211_local *local = sdata->local; 1455 u32 changed = 0; 1456 bool erp_valid, directed_tim = false; 1457 u8 erp_value = 0; 1458 u32 ncrc; 1459 u8 *bssid; 1460 1461 ASSERT_MGD_MTX(ifmgd); 1462 1463 /* Process beacon from the current BSS */ 1464 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt; 1465 if (baselen > len) 1466 return; 1467 1468 if (rx_status->freq != local->hw.conf.channel->center_freq) 1469 return; 1470 1471 /* 1472 * We might have received a number of frames, among them a 1473 * disassoc frame and a beacon... 1474 */ 1475 if (!ifmgd->associated) 1476 return; 1477 1478 bssid = ifmgd->associated->bssid; 1479 1480 /* 1481 * And in theory even frames from a different AP we were just 1482 * associated to a split-second ago! 1483 */ 1484 if (memcmp(bssid, mgmt->bssid, ETH_ALEN) != 0) 1485 return; 1486 1487 /* Track average RSSI from the Beacon frames of the current AP */ 1488 ifmgd->last_beacon_signal = rx_status->signal; 1489 if (ifmgd->flags & IEEE80211_STA_RESET_SIGNAL_AVE) { 1490 ifmgd->flags &= ~IEEE80211_STA_RESET_SIGNAL_AVE; 1491 ifmgd->ave_beacon_signal = rx_status->signal; 1492 ifmgd->last_cqm_event_signal = 0; 1493 } else { 1494 ifmgd->ave_beacon_signal = 1495 (IEEE80211_SIGNAL_AVE_WEIGHT * rx_status->signal * 16 + 1496 (16 - IEEE80211_SIGNAL_AVE_WEIGHT) * 1497 ifmgd->ave_beacon_signal) / 16; 1498 } 1499 if (bss_conf->cqm_rssi_thold && 1500 !(local->hw.flags & IEEE80211_HW_SUPPORTS_CQM_RSSI)) { 1501 int sig = ifmgd->ave_beacon_signal / 16; 1502 int last_event = ifmgd->last_cqm_event_signal; 1503 int thold = bss_conf->cqm_rssi_thold; 1504 int hyst = bss_conf->cqm_rssi_hyst; 1505 if (sig < thold && 1506 (last_event == 0 || sig < last_event - hyst)) { 1507 ifmgd->last_cqm_event_signal = sig; 1508 ieee80211_cqm_rssi_notify( 1509 &sdata->vif, 1510 NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW, 1511 GFP_KERNEL); 1512 } else if (sig > thold && 1513 (last_event == 0 || sig > last_event + hyst)) { 1514 ifmgd->last_cqm_event_signal = sig; 1515 ieee80211_cqm_rssi_notify( 1516 &sdata->vif, 1517 NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH, 1518 GFP_KERNEL); 1519 } 1520 } 1521 1522 if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) { 1523 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 1524 if (net_ratelimit()) { 1525 printk(KERN_DEBUG "%s: cancelling probereq poll due " 1526 "to a received beacon\n", sdata->name); 1527 } 1528 #endif 1529 ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL; 1530 mutex_lock(&local->iflist_mtx); 1531 ieee80211_recalc_ps(local, -1); 1532 mutex_unlock(&local->iflist_mtx); 1533 } 1534 1535 /* 1536 * Push the beacon loss detection into the future since 1537 * we are processing a beacon from the AP just now. 1538 */ 1539 mod_beacon_timer(sdata); 1540 1541 ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4); 1542 ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable, 1543 len - baselen, &elems, 1544 care_about_ies, ncrc); 1545 1546 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) 1547 directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len, 1548 ifmgd->aid); 1549 1550 if (ncrc != ifmgd->beacon_crc) { 1551 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, 1552 true); 1553 1554 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param, 1555 elems.wmm_param_len); 1556 } 1557 1558 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) { 1559 if (directed_tim) { 1560 if (local->hw.conf.dynamic_ps_timeout > 0) { 1561 local->hw.conf.flags &= ~IEEE80211_CONF_PS; 1562 ieee80211_hw_config(local, 1563 IEEE80211_CONF_CHANGE_PS); 1564 ieee80211_send_nullfunc(local, sdata, 0); 1565 } else { 1566 local->pspolling = true; 1567 1568 /* 1569 * Here is assumed that the driver will be 1570 * able to send ps-poll frame and receive a 1571 * response even though power save mode is 1572 * enabled, but some drivers might require 1573 * to disable power save here. This needs 1574 * to be investigated. 1575 */ 1576 ieee80211_send_pspoll(local, sdata); 1577 } 1578 } 1579 } 1580 1581 if (ncrc == ifmgd->beacon_crc) 1582 return; 1583 ifmgd->beacon_crc = ncrc; 1584 1585 if (elems.erp_info && elems.erp_info_len >= 1) { 1586 erp_valid = true; 1587 erp_value = elems.erp_info[0]; 1588 } else { 1589 erp_valid = false; 1590 } 1591 changed |= ieee80211_handle_bss_capability(sdata, 1592 le16_to_cpu(mgmt->u.beacon.capab_info), 1593 erp_valid, erp_value); 1594 1595 1596 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param && 1597 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) { 1598 struct sta_info *sta; 1599 struct ieee80211_supported_band *sband; 1600 u16 ap_ht_cap_flags; 1601 1602 rcu_read_lock(); 1603 1604 sta = sta_info_get(sdata, bssid); 1605 if (WARN_ON(!sta)) { 1606 rcu_read_unlock(); 1607 return; 1608 } 1609 1610 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 1611 1612 ieee80211_ht_cap_ie_to_sta_ht_cap(sband, 1613 elems.ht_cap_elem, &sta->sta.ht_cap); 1614 1615 ap_ht_cap_flags = sta->sta.ht_cap.cap; 1616 1617 rcu_read_unlock(); 1618 1619 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem, 1620 bssid, ap_ht_cap_flags); 1621 } 1622 1623 /* Note: country IE parsing is done for us by cfg80211 */ 1624 if (elems.country_elem) { 1625 /* TODO: IBSS also needs this */ 1626 if (elems.pwr_constr_elem) 1627 ieee80211_handle_pwr_constr(sdata, 1628 le16_to_cpu(mgmt->u.probe_resp.capab_info), 1629 elems.pwr_constr_elem, 1630 elems.pwr_constr_elem_len); 1631 } 1632 1633 ieee80211_bss_info_change_notify(sdata, changed); 1634 } 1635 1636 ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, 1637 struct sk_buff *skb) 1638 { 1639 struct ieee80211_local *local = sdata->local; 1640 struct ieee80211_mgmt *mgmt; 1641 u16 fc; 1642 1643 if (skb->len < 24) 1644 return RX_DROP_MONITOR; 1645 1646 mgmt = (struct ieee80211_mgmt *) skb->data; 1647 fc = le16_to_cpu(mgmt->frame_control); 1648 1649 switch (fc & IEEE80211_FCTL_STYPE) { 1650 case IEEE80211_STYPE_PROBE_RESP: 1651 case IEEE80211_STYPE_BEACON: 1652 case IEEE80211_STYPE_DEAUTH: 1653 case IEEE80211_STYPE_DISASSOC: 1654 case IEEE80211_STYPE_ACTION: 1655 skb_queue_tail(&sdata->u.mgd.skb_queue, skb); 1656 ieee80211_queue_work(&local->hw, &sdata->u.mgd.work); 1657 return RX_QUEUED; 1658 } 1659 1660 return RX_DROP_MONITOR; 1661 } 1662 1663 static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, 1664 struct sk_buff *skb) 1665 { 1666 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1667 struct ieee80211_rx_status *rx_status; 1668 struct ieee80211_mgmt *mgmt; 1669 enum rx_mgmt_action rma = RX_MGMT_NONE; 1670 u16 fc; 1671 1672 rx_status = (struct ieee80211_rx_status *) skb->cb; 1673 mgmt = (struct ieee80211_mgmt *) skb->data; 1674 fc = le16_to_cpu(mgmt->frame_control); 1675 1676 mutex_lock(&ifmgd->mtx); 1677 1678 if (ifmgd->associated && 1679 memcmp(ifmgd->associated->bssid, mgmt->bssid, ETH_ALEN) == 0) { 1680 switch (fc & IEEE80211_FCTL_STYPE) { 1681 case IEEE80211_STYPE_BEACON: 1682 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, 1683 rx_status); 1684 break; 1685 case IEEE80211_STYPE_PROBE_RESP: 1686 ieee80211_rx_mgmt_probe_resp(sdata, skb); 1687 break; 1688 case IEEE80211_STYPE_DEAUTH: 1689 rma = ieee80211_rx_mgmt_deauth(sdata, mgmt, skb->len); 1690 break; 1691 case IEEE80211_STYPE_DISASSOC: 1692 rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len); 1693 break; 1694 case IEEE80211_STYPE_ACTION: 1695 switch (mgmt->u.action.category) { 1696 case WLAN_CATEGORY_BACK: { 1697 struct ieee80211_local *local = sdata->local; 1698 int len = skb->len; 1699 struct sta_info *sta; 1700 1701 rcu_read_lock(); 1702 sta = sta_info_get(sdata, mgmt->sa); 1703 if (!sta) { 1704 rcu_read_unlock(); 1705 break; 1706 } 1707 1708 local_bh_disable(); 1709 1710 switch (mgmt->u.action.u.addba_req.action_code) { 1711 case WLAN_ACTION_ADDBA_REQ: 1712 if (len < (IEEE80211_MIN_ACTION_SIZE + 1713 sizeof(mgmt->u.action.u.addba_req))) 1714 break; 1715 ieee80211_process_addba_request(local, sta, mgmt, len); 1716 break; 1717 case WLAN_ACTION_ADDBA_RESP: 1718 if (len < (IEEE80211_MIN_ACTION_SIZE + 1719 sizeof(mgmt->u.action.u.addba_resp))) 1720 break; 1721 ieee80211_process_addba_resp(local, sta, mgmt, len); 1722 break; 1723 case WLAN_ACTION_DELBA: 1724 if (len < (IEEE80211_MIN_ACTION_SIZE + 1725 sizeof(mgmt->u.action.u.delba))) 1726 break; 1727 ieee80211_process_delba(sdata, sta, mgmt, len); 1728 break; 1729 } 1730 local_bh_enable(); 1731 rcu_read_unlock(); 1732 break; 1733 } 1734 case WLAN_CATEGORY_SPECTRUM_MGMT: 1735 ieee80211_sta_process_chanswitch(sdata, 1736 &mgmt->u.action.u.chan_switch.sw_elem, 1737 (void *)ifmgd->associated->priv, 1738 rx_status->mactime); 1739 break; 1740 } 1741 } 1742 mutex_unlock(&ifmgd->mtx); 1743 1744 switch (rma) { 1745 case RX_MGMT_NONE: 1746 /* no action */ 1747 break; 1748 case RX_MGMT_CFG80211_DEAUTH: 1749 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len); 1750 break; 1751 case RX_MGMT_CFG80211_DISASSOC: 1752 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len); 1753 break; 1754 default: 1755 WARN(1, "unexpected: %d", rma); 1756 } 1757 goto out; 1758 } 1759 1760 mutex_unlock(&ifmgd->mtx); 1761 1762 if (skb->len >= 24 + 2 /* mgmt + deauth reason */ && 1763 (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_DEAUTH) { 1764 struct ieee80211_local *local = sdata->local; 1765 struct ieee80211_work *wk; 1766 1767 mutex_lock(&local->work_mtx); 1768 list_for_each_entry(wk, &local->work_list, list) { 1769 if (wk->sdata != sdata) 1770 continue; 1771 1772 if (wk->type != IEEE80211_WORK_ASSOC) 1773 continue; 1774 1775 if (memcmp(mgmt->bssid, wk->filter_ta, ETH_ALEN)) 1776 continue; 1777 if (memcmp(mgmt->sa, wk->filter_ta, ETH_ALEN)) 1778 continue; 1779 1780 /* 1781 * Printing the message only here means we can't 1782 * spuriously print it, but it also means that it 1783 * won't be printed when the frame comes in before 1784 * we even tried to associate or in similar cases. 1785 * 1786 * Ultimately, I suspect cfg80211 should print the 1787 * messages instead. 1788 */ 1789 printk(KERN_DEBUG 1790 "%s: deauthenticated from %pM (Reason: %u)\n", 1791 sdata->name, mgmt->bssid, 1792 le16_to_cpu(mgmt->u.deauth.reason_code)); 1793 1794 list_del_rcu(&wk->list); 1795 free_work(wk); 1796 break; 1797 } 1798 mutex_unlock(&local->work_mtx); 1799 1800 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len); 1801 } 1802 out: 1803 kfree_skb(skb); 1804 } 1805 1806 static void ieee80211_sta_timer(unsigned long data) 1807 { 1808 struct ieee80211_sub_if_data *sdata = 1809 (struct ieee80211_sub_if_data *) data; 1810 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1811 struct ieee80211_local *local = sdata->local; 1812 1813 if (local->quiescing) { 1814 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running); 1815 return; 1816 } 1817 1818 ieee80211_queue_work(&local->hw, &ifmgd->work); 1819 } 1820 1821 static void ieee80211_sta_work(struct work_struct *work) 1822 { 1823 struct ieee80211_sub_if_data *sdata = 1824 container_of(work, struct ieee80211_sub_if_data, u.mgd.work); 1825 struct ieee80211_local *local = sdata->local; 1826 struct ieee80211_if_managed *ifmgd; 1827 struct sk_buff *skb; 1828 1829 if (!ieee80211_sdata_running(sdata)) 1830 return; 1831 1832 if (local->scanning) 1833 return; 1834 1835 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION)) 1836 return; 1837 1838 /* 1839 * ieee80211_queue_work() should have picked up most cases, 1840 * here we'll pick the the rest. 1841 */ 1842 if (WARN(local->suspended, "STA MLME work scheduled while " 1843 "going to suspend\n")) 1844 return; 1845 1846 ifmgd = &sdata->u.mgd; 1847 1848 /* first process frames to avoid timing out while a frame is pending */ 1849 while ((skb = skb_dequeue(&ifmgd->skb_queue))) 1850 ieee80211_sta_rx_queued_mgmt(sdata, skb); 1851 1852 /* then process the rest of the work */ 1853 mutex_lock(&ifmgd->mtx); 1854 1855 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL | 1856 IEEE80211_STA_CONNECTION_POLL) && 1857 ifmgd->associated) { 1858 u8 bssid[ETH_ALEN]; 1859 1860 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN); 1861 if (time_is_after_jiffies(ifmgd->probe_timeout)) 1862 run_again(ifmgd, ifmgd->probe_timeout); 1863 1864 else if (ifmgd->probe_send_count < IEEE80211_MAX_PROBE_TRIES) { 1865 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 1866 printk(KERN_DEBUG "No probe response from AP %pM" 1867 " after %dms, try %d\n", bssid, 1868 (1000 * IEEE80211_PROBE_WAIT)/HZ, 1869 ifmgd->probe_send_count); 1870 #endif 1871 ieee80211_mgd_probe_ap_send(sdata); 1872 } else { 1873 /* 1874 * We actually lost the connection ... or did we? 1875 * Let's make sure! 1876 */ 1877 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL | 1878 IEEE80211_STA_BEACON_POLL); 1879 printk(KERN_DEBUG "No probe response from AP %pM" 1880 " after %dms, disconnecting.\n", 1881 bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ); 1882 ieee80211_set_disassoc(sdata, true); 1883 ieee80211_recalc_idle(local); 1884 mutex_unlock(&ifmgd->mtx); 1885 /* 1886 * must be outside lock due to cfg80211, 1887 * but that's not a problem. 1888 */ 1889 ieee80211_send_deauth_disassoc(sdata, bssid, 1890 IEEE80211_STYPE_DEAUTH, 1891 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY, 1892 NULL, true); 1893 mutex_lock(&ifmgd->mtx); 1894 } 1895 } 1896 1897 mutex_unlock(&ifmgd->mtx); 1898 } 1899 1900 static void ieee80211_sta_bcn_mon_timer(unsigned long data) 1901 { 1902 struct ieee80211_sub_if_data *sdata = 1903 (struct ieee80211_sub_if_data *) data; 1904 struct ieee80211_local *local = sdata->local; 1905 1906 if (local->quiescing) 1907 return; 1908 1909 ieee80211_queue_work(&sdata->local->hw, 1910 &sdata->u.mgd.beacon_connection_loss_work); 1911 } 1912 1913 static void ieee80211_sta_conn_mon_timer(unsigned long data) 1914 { 1915 struct ieee80211_sub_if_data *sdata = 1916 (struct ieee80211_sub_if_data *) data; 1917 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1918 struct ieee80211_local *local = sdata->local; 1919 1920 if (local->quiescing) 1921 return; 1922 1923 ieee80211_queue_work(&local->hw, &ifmgd->monitor_work); 1924 } 1925 1926 static void ieee80211_sta_monitor_work(struct work_struct *work) 1927 { 1928 struct ieee80211_sub_if_data *sdata = 1929 container_of(work, struct ieee80211_sub_if_data, 1930 u.mgd.monitor_work); 1931 1932 ieee80211_mgd_probe_ap(sdata, false); 1933 } 1934 1935 static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata) 1936 { 1937 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 1938 sdata->u.mgd.flags &= ~(IEEE80211_STA_BEACON_POLL | 1939 IEEE80211_STA_CONNECTION_POLL); 1940 1941 /* let's probe the connection once */ 1942 ieee80211_queue_work(&sdata->local->hw, 1943 &sdata->u.mgd.monitor_work); 1944 /* and do all the other regular work too */ 1945 ieee80211_queue_work(&sdata->local->hw, 1946 &sdata->u.mgd.work); 1947 } 1948 } 1949 1950 #ifdef CONFIG_PM 1951 void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata) 1952 { 1953 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1954 1955 /* 1956 * we need to use atomic bitops for the running bits 1957 * only because both timers might fire at the same 1958 * time -- the code here is properly synchronised. 1959 */ 1960 1961 cancel_work_sync(&ifmgd->work); 1962 cancel_work_sync(&ifmgd->beacon_connection_loss_work); 1963 if (del_timer_sync(&ifmgd->timer)) 1964 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running); 1965 1966 cancel_work_sync(&ifmgd->chswitch_work); 1967 if (del_timer_sync(&ifmgd->chswitch_timer)) 1968 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running); 1969 1970 cancel_work_sync(&ifmgd->monitor_work); 1971 /* these will just be re-established on connection */ 1972 del_timer_sync(&ifmgd->conn_mon_timer); 1973 del_timer_sync(&ifmgd->bcn_mon_timer); 1974 } 1975 1976 void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata) 1977 { 1978 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1979 1980 if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running)) 1981 add_timer(&ifmgd->timer); 1982 if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running)) 1983 add_timer(&ifmgd->chswitch_timer); 1984 } 1985 #endif 1986 1987 /* interface setup */ 1988 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata) 1989 { 1990 struct ieee80211_if_managed *ifmgd; 1991 1992 ifmgd = &sdata->u.mgd; 1993 INIT_WORK(&ifmgd->work, ieee80211_sta_work); 1994 INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work); 1995 INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work); 1996 INIT_WORK(&ifmgd->beacon_connection_loss_work, 1997 ieee80211_beacon_connection_loss_work); 1998 setup_timer(&ifmgd->timer, ieee80211_sta_timer, 1999 (unsigned long) sdata); 2000 setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer, 2001 (unsigned long) sdata); 2002 setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer, 2003 (unsigned long) sdata); 2004 setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer, 2005 (unsigned long) sdata); 2006 skb_queue_head_init(&ifmgd->skb_queue); 2007 2008 ifmgd->flags = 0; 2009 2010 mutex_init(&ifmgd->mtx); 2011 2012 if (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS) 2013 ifmgd->req_smps = IEEE80211_SMPS_AUTOMATIC; 2014 else 2015 ifmgd->req_smps = IEEE80211_SMPS_OFF; 2016 } 2017 2018 /* scan finished notification */ 2019 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local) 2020 { 2021 struct ieee80211_sub_if_data *sdata = local->scan_sdata; 2022 2023 /* Restart STA timers */ 2024 rcu_read_lock(); 2025 list_for_each_entry_rcu(sdata, &local->interfaces, list) 2026 ieee80211_restart_sta_timer(sdata); 2027 rcu_read_unlock(); 2028 } 2029 2030 int ieee80211_max_network_latency(struct notifier_block *nb, 2031 unsigned long data, void *dummy) 2032 { 2033 s32 latency_usec = (s32) data; 2034 struct ieee80211_local *local = 2035 container_of(nb, struct ieee80211_local, 2036 network_latency_notifier); 2037 2038 mutex_lock(&local->iflist_mtx); 2039 ieee80211_recalc_ps(local, latency_usec); 2040 mutex_unlock(&local->iflist_mtx); 2041 2042 return 0; 2043 } 2044 2045 /* config hooks */ 2046 static enum work_done_result 2047 ieee80211_probe_auth_done(struct ieee80211_work *wk, 2048 struct sk_buff *skb) 2049 { 2050 if (!skb) { 2051 cfg80211_send_auth_timeout(wk->sdata->dev, wk->filter_ta); 2052 return WORK_DONE_DESTROY; 2053 } 2054 2055 if (wk->type == IEEE80211_WORK_AUTH) { 2056 cfg80211_send_rx_auth(wk->sdata->dev, skb->data, skb->len); 2057 return WORK_DONE_DESTROY; 2058 } 2059 2060 mutex_lock(&wk->sdata->u.mgd.mtx); 2061 ieee80211_rx_mgmt_probe_resp(wk->sdata, skb); 2062 mutex_unlock(&wk->sdata->u.mgd.mtx); 2063 2064 wk->type = IEEE80211_WORK_AUTH; 2065 wk->probe_auth.tries = 0; 2066 return WORK_DONE_REQUEUE; 2067 } 2068 2069 int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata, 2070 struct cfg80211_auth_request *req) 2071 { 2072 const u8 *ssid; 2073 struct ieee80211_work *wk; 2074 u16 auth_alg; 2075 2076 if (req->local_state_change) 2077 return 0; /* no need to update mac80211 state */ 2078 2079 switch (req->auth_type) { 2080 case NL80211_AUTHTYPE_OPEN_SYSTEM: 2081 auth_alg = WLAN_AUTH_OPEN; 2082 break; 2083 case NL80211_AUTHTYPE_SHARED_KEY: 2084 auth_alg = WLAN_AUTH_SHARED_KEY; 2085 break; 2086 case NL80211_AUTHTYPE_FT: 2087 auth_alg = WLAN_AUTH_FT; 2088 break; 2089 case NL80211_AUTHTYPE_NETWORK_EAP: 2090 auth_alg = WLAN_AUTH_LEAP; 2091 break; 2092 default: 2093 return -EOPNOTSUPP; 2094 } 2095 2096 wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL); 2097 if (!wk) 2098 return -ENOMEM; 2099 2100 memcpy(wk->filter_ta, req->bss->bssid, ETH_ALEN); 2101 2102 if (req->ie && req->ie_len) { 2103 memcpy(wk->ie, req->ie, req->ie_len); 2104 wk->ie_len = req->ie_len; 2105 } 2106 2107 if (req->key && req->key_len) { 2108 wk->probe_auth.key_len = req->key_len; 2109 wk->probe_auth.key_idx = req->key_idx; 2110 memcpy(wk->probe_auth.key, req->key, req->key_len); 2111 } 2112 2113 ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID); 2114 memcpy(wk->probe_auth.ssid, ssid + 2, ssid[1]); 2115 wk->probe_auth.ssid_len = ssid[1]; 2116 2117 wk->probe_auth.algorithm = auth_alg; 2118 wk->probe_auth.privacy = req->bss->capability & WLAN_CAPABILITY_PRIVACY; 2119 2120 /* if we already have a probe, don't probe again */ 2121 if (req->bss->proberesp_ies) 2122 wk->type = IEEE80211_WORK_AUTH; 2123 else 2124 wk->type = IEEE80211_WORK_DIRECT_PROBE; 2125 wk->chan = req->bss->channel; 2126 wk->sdata = sdata; 2127 wk->done = ieee80211_probe_auth_done; 2128 2129 ieee80211_add_work(wk); 2130 return 0; 2131 } 2132 2133 static enum work_done_result ieee80211_assoc_done(struct ieee80211_work *wk, 2134 struct sk_buff *skb) 2135 { 2136 struct ieee80211_mgmt *mgmt; 2137 u16 status; 2138 2139 if (!skb) { 2140 cfg80211_send_assoc_timeout(wk->sdata->dev, wk->filter_ta); 2141 return WORK_DONE_DESTROY; 2142 } 2143 2144 mgmt = (void *)skb->data; 2145 status = le16_to_cpu(mgmt->u.assoc_resp.status_code); 2146 2147 if (status == WLAN_STATUS_SUCCESS) { 2148 mutex_lock(&wk->sdata->u.mgd.mtx); 2149 if (!ieee80211_assoc_success(wk, mgmt, skb->len)) { 2150 mutex_unlock(&wk->sdata->u.mgd.mtx); 2151 /* oops -- internal error -- send timeout for now */ 2152 cfg80211_send_assoc_timeout(wk->sdata->dev, 2153 wk->filter_ta); 2154 return WORK_DONE_DESTROY; 2155 } 2156 mutex_unlock(&wk->sdata->u.mgd.mtx); 2157 } 2158 2159 cfg80211_send_rx_assoc(wk->sdata->dev, skb->data, skb->len); 2160 return WORK_DONE_DESTROY; 2161 } 2162 2163 int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata, 2164 struct cfg80211_assoc_request *req) 2165 { 2166 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2167 struct ieee80211_bss *bss = (void *)req->bss->priv; 2168 struct ieee80211_work *wk; 2169 const u8 *ssid; 2170 int i; 2171 2172 mutex_lock(&ifmgd->mtx); 2173 if (ifmgd->associated) { 2174 if (!req->prev_bssid || 2175 memcmp(req->prev_bssid, ifmgd->associated->bssid, 2176 ETH_ALEN)) { 2177 /* 2178 * We are already associated and the request was not a 2179 * reassociation request from the current BSS, so 2180 * reject it. 2181 */ 2182 mutex_unlock(&ifmgd->mtx); 2183 return -EALREADY; 2184 } 2185 2186 /* Trying to reassociate - clear previous association state */ 2187 ieee80211_set_disassoc(sdata, true); 2188 } 2189 mutex_unlock(&ifmgd->mtx); 2190 2191 wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL); 2192 if (!wk) 2193 return -ENOMEM; 2194 2195 ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N; 2196 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED; 2197 2198 for (i = 0; i < req->crypto.n_ciphers_pairwise; i++) 2199 if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 || 2200 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP || 2201 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104) 2202 ifmgd->flags |= IEEE80211_STA_DISABLE_11N; 2203 2204 2205 if (req->ie && req->ie_len) { 2206 memcpy(wk->ie, req->ie, req->ie_len); 2207 wk->ie_len = req->ie_len; 2208 } else 2209 wk->ie_len = 0; 2210 2211 wk->assoc.bss = req->bss; 2212 2213 memcpy(wk->filter_ta, req->bss->bssid, ETH_ALEN); 2214 2215 /* new association always uses requested smps mode */ 2216 if (ifmgd->req_smps == IEEE80211_SMPS_AUTOMATIC) { 2217 if (ifmgd->powersave) 2218 ifmgd->ap_smps = IEEE80211_SMPS_DYNAMIC; 2219 else 2220 ifmgd->ap_smps = IEEE80211_SMPS_OFF; 2221 } else 2222 ifmgd->ap_smps = ifmgd->req_smps; 2223 2224 wk->assoc.smps = ifmgd->ap_smps; 2225 /* 2226 * IEEE802.11n does not allow TKIP/WEP as pairwise ciphers in HT mode. 2227 * We still associate in non-HT mode (11a/b/g) if any one of these 2228 * ciphers is configured as pairwise. 2229 * We can set this to true for non-11n hardware, that'll be checked 2230 * separately along with the peer capabilities. 2231 */ 2232 wk->assoc.use_11n = !(ifmgd->flags & IEEE80211_STA_DISABLE_11N); 2233 wk->assoc.capability = req->bss->capability; 2234 wk->assoc.wmm_used = bss->wmm_used; 2235 wk->assoc.supp_rates = bss->supp_rates; 2236 wk->assoc.supp_rates_len = bss->supp_rates_len; 2237 wk->assoc.ht_information_ie = 2238 ieee80211_bss_get_ie(req->bss, WLAN_EID_HT_INFORMATION); 2239 2240 if (bss->wmm_used && bss->uapsd_supported && 2241 (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD)) { 2242 wk->assoc.uapsd_used = true; 2243 ifmgd->flags |= IEEE80211_STA_UAPSD_ENABLED; 2244 } else { 2245 wk->assoc.uapsd_used = false; 2246 ifmgd->flags &= ~IEEE80211_STA_UAPSD_ENABLED; 2247 } 2248 2249 ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID); 2250 memcpy(wk->assoc.ssid, ssid + 2, ssid[1]); 2251 wk->assoc.ssid_len = ssid[1]; 2252 2253 if (req->prev_bssid) 2254 memcpy(wk->assoc.prev_bssid, req->prev_bssid, ETH_ALEN); 2255 2256 wk->type = IEEE80211_WORK_ASSOC; 2257 wk->chan = req->bss->channel; 2258 wk->sdata = sdata; 2259 wk->done = ieee80211_assoc_done; 2260 2261 if (req->use_mfp) { 2262 ifmgd->mfp = IEEE80211_MFP_REQUIRED; 2263 ifmgd->flags |= IEEE80211_STA_MFP_ENABLED; 2264 } else { 2265 ifmgd->mfp = IEEE80211_MFP_DISABLED; 2266 ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED; 2267 } 2268 2269 if (req->crypto.control_port) 2270 ifmgd->flags |= IEEE80211_STA_CONTROL_PORT; 2271 else 2272 ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT; 2273 2274 ieee80211_add_work(wk); 2275 return 0; 2276 } 2277 2278 int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata, 2279 struct cfg80211_deauth_request *req, 2280 void *cookie) 2281 { 2282 struct ieee80211_local *local = sdata->local; 2283 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2284 struct ieee80211_work *wk; 2285 const u8 *bssid = req->bss->bssid; 2286 2287 mutex_lock(&ifmgd->mtx); 2288 2289 if (ifmgd->associated == req->bss) { 2290 bssid = req->bss->bssid; 2291 ieee80211_set_disassoc(sdata, true); 2292 mutex_unlock(&ifmgd->mtx); 2293 } else { 2294 bool not_auth_yet = false; 2295 2296 mutex_unlock(&ifmgd->mtx); 2297 2298 mutex_lock(&local->work_mtx); 2299 list_for_each_entry(wk, &local->work_list, list) { 2300 if (wk->sdata != sdata) 2301 continue; 2302 2303 if (wk->type != IEEE80211_WORK_DIRECT_PROBE && 2304 wk->type != IEEE80211_WORK_AUTH && 2305 wk->type != IEEE80211_WORK_ASSOC) 2306 continue; 2307 2308 if (memcmp(req->bss->bssid, wk->filter_ta, ETH_ALEN)) 2309 continue; 2310 2311 not_auth_yet = wk->type == IEEE80211_WORK_DIRECT_PROBE; 2312 list_del_rcu(&wk->list); 2313 free_work(wk); 2314 break; 2315 } 2316 mutex_unlock(&local->work_mtx); 2317 2318 /* 2319 * If somebody requests authentication and we haven't 2320 * sent out an auth frame yet there's no need to send 2321 * out a deauth frame either. If the state was PROBE, 2322 * then this is the case. If it's AUTH we have sent a 2323 * frame, and if it's IDLE we have completed the auth 2324 * process already. 2325 */ 2326 if (not_auth_yet) { 2327 __cfg80211_auth_canceled(sdata->dev, bssid); 2328 return 0; 2329 } 2330 } 2331 2332 printk(KERN_DEBUG "%s: deauthenticating from %pM by local choice (reason=%d)\n", 2333 sdata->name, bssid, req->reason_code); 2334 2335 ieee80211_send_deauth_disassoc(sdata, bssid, IEEE80211_STYPE_DEAUTH, 2336 req->reason_code, cookie, 2337 !req->local_state_change); 2338 2339 ieee80211_recalc_idle(sdata->local); 2340 2341 return 0; 2342 } 2343 2344 int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata, 2345 struct cfg80211_disassoc_request *req, 2346 void *cookie) 2347 { 2348 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2349 u8 bssid[ETH_ALEN]; 2350 2351 mutex_lock(&ifmgd->mtx); 2352 2353 /* 2354 * cfg80211 should catch this ... but it's racy since 2355 * we can receive a disassoc frame, process it, hand it 2356 * to cfg80211 while that's in a locked section already 2357 * trying to tell us that the user wants to disconnect. 2358 */ 2359 if (ifmgd->associated != req->bss) { 2360 mutex_unlock(&ifmgd->mtx); 2361 return -ENOLINK; 2362 } 2363 2364 printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n", 2365 sdata->name, req->bss->bssid, req->reason_code); 2366 2367 memcpy(bssid, req->bss->bssid, ETH_ALEN); 2368 ieee80211_set_disassoc(sdata, false); 2369 2370 mutex_unlock(&ifmgd->mtx); 2371 2372 ieee80211_send_deauth_disassoc(sdata, req->bss->bssid, 2373 IEEE80211_STYPE_DISASSOC, req->reason_code, 2374 cookie, !req->local_state_change); 2375 sta_info_destroy_addr(sdata, bssid); 2376 2377 ieee80211_recalc_idle(sdata->local); 2378 2379 return 0; 2380 } 2381 2382 int ieee80211_mgd_action(struct ieee80211_sub_if_data *sdata, 2383 struct ieee80211_channel *chan, 2384 enum nl80211_channel_type channel_type, 2385 const u8 *buf, size_t len, u64 *cookie) 2386 { 2387 struct ieee80211_local *local = sdata->local; 2388 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2389 struct sk_buff *skb; 2390 2391 /* Check that we are on the requested channel for transmission */ 2392 if ((chan != local->tmp_channel || 2393 channel_type != local->tmp_channel_type) && 2394 (chan != local->oper_channel || 2395 channel_type != local->_oper_channel_type)) 2396 return -EBUSY; 2397 2398 skb = dev_alloc_skb(local->hw.extra_tx_headroom + len); 2399 if (!skb) 2400 return -ENOMEM; 2401 skb_reserve(skb, local->hw.extra_tx_headroom); 2402 2403 memcpy(skb_put(skb, len), buf, len); 2404 2405 if (!(ifmgd->flags & IEEE80211_STA_MFP_ENABLED)) 2406 IEEE80211_SKB_CB(skb)->flags |= 2407 IEEE80211_TX_INTFL_DONT_ENCRYPT; 2408 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_NL80211_FRAME_TX | 2409 IEEE80211_TX_CTL_REQ_TX_STATUS; 2410 skb->dev = sdata->dev; 2411 ieee80211_tx_skb(sdata, skb); 2412 2413 *cookie = (unsigned long) skb; 2414 return 0; 2415 } 2416 2417 void ieee80211_cqm_rssi_notify(struct ieee80211_vif *vif, 2418 enum nl80211_cqm_rssi_threshold_event rssi_event, 2419 gfp_t gfp) 2420 { 2421 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 2422 2423 trace_api_cqm_rssi_notify(sdata, rssi_event); 2424 2425 cfg80211_cqm_rssi_notify(sdata->dev, rssi_event, gfp); 2426 } 2427 EXPORT_SYMBOL(ieee80211_cqm_rssi_notify); 2428