1 /* 2 * HT handling 3 * 4 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi> 5 * Copyright 2002-2005, Instant802 Networks, Inc. 6 * Copyright 2005-2006, Devicescape Software, Inc. 7 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 8 * Copyright 2007, Michael Wu <flamingice@sourmilk.net> 9 * Copyright 2007-2010, Intel Corporation 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License version 2 as 13 * published by the Free Software Foundation. 14 */ 15 16 #include <linux/ieee80211.h> 17 #include <linux/export.h> 18 #include <net/mac80211.h> 19 #include "ieee80211_i.h" 20 #include "rate.h" 21 22 static void __check_htcap_disable(struct ieee80211_ht_cap *ht_capa, 23 struct ieee80211_ht_cap *ht_capa_mask, 24 struct ieee80211_sta_ht_cap *ht_cap, 25 u16 flag) 26 { 27 __le16 le_flag = cpu_to_le16(flag); 28 if (ht_capa_mask->cap_info & le_flag) { 29 if (!(ht_capa->cap_info & le_flag)) 30 ht_cap->cap &= ~flag; 31 } 32 } 33 34 void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data *sdata, 35 struct ieee80211_sta_ht_cap *ht_cap) 36 { 37 struct ieee80211_ht_cap *ht_capa, *ht_capa_mask; 38 u8 *scaps, *smask; 39 int i; 40 41 if (!ht_cap->ht_supported) 42 return; 43 44 switch (sdata->vif.type) { 45 case NL80211_IFTYPE_STATION: 46 ht_capa = &sdata->u.mgd.ht_capa; 47 ht_capa_mask = &sdata->u.mgd.ht_capa_mask; 48 break; 49 case NL80211_IFTYPE_ADHOC: 50 ht_capa = &sdata->u.ibss.ht_capa; 51 ht_capa_mask = &sdata->u.ibss.ht_capa_mask; 52 break; 53 default: 54 WARN_ON_ONCE(1); 55 return; 56 } 57 58 scaps = (u8 *)(&ht_capa->mcs.rx_mask); 59 smask = (u8 *)(&ht_capa_mask->mcs.rx_mask); 60 61 /* NOTE: If you add more over-rides here, update register_hw 62 * ht_capa_mod_msk logic in main.c as well. 63 * And, if this method can ever change ht_cap.ht_supported, fix 64 * the check in ieee80211_add_ht_ie. 65 */ 66 67 /* check for HT over-rides, MCS rates first. */ 68 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) { 69 u8 m = smask[i]; 70 ht_cap->mcs.rx_mask[i] &= ~m; /* turn off all masked bits */ 71 /* Add back rates that are supported */ 72 ht_cap->mcs.rx_mask[i] |= (m & scaps[i]); 73 } 74 75 /* Force removal of HT-40 capabilities? */ 76 __check_htcap_disable(ht_capa, ht_capa_mask, ht_cap, 77 IEEE80211_HT_CAP_SUP_WIDTH_20_40); 78 __check_htcap_disable(ht_capa, ht_capa_mask, ht_cap, 79 IEEE80211_HT_CAP_SGI_40); 80 81 /* Allow user to disable SGI-20 (SGI-40 is handled above) */ 82 __check_htcap_disable(ht_capa, ht_capa_mask, ht_cap, 83 IEEE80211_HT_CAP_SGI_20); 84 85 /* Allow user to disable the max-AMSDU bit. */ 86 __check_htcap_disable(ht_capa, ht_capa_mask, ht_cap, 87 IEEE80211_HT_CAP_MAX_AMSDU); 88 89 /* Allow user to decrease AMPDU factor */ 90 if (ht_capa_mask->ampdu_params_info & 91 IEEE80211_HT_AMPDU_PARM_FACTOR) { 92 u8 n = ht_capa->ampdu_params_info & 93 IEEE80211_HT_AMPDU_PARM_FACTOR; 94 if (n < ht_cap->ampdu_factor) 95 ht_cap->ampdu_factor = n; 96 } 97 98 /* Allow the user to increase AMPDU density. */ 99 if (ht_capa_mask->ampdu_params_info & 100 IEEE80211_HT_AMPDU_PARM_DENSITY) { 101 u8 n = (ht_capa->ampdu_params_info & 102 IEEE80211_HT_AMPDU_PARM_DENSITY) 103 >> IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT; 104 if (n > ht_cap->ampdu_density) 105 ht_cap->ampdu_density = n; 106 } 107 } 108 109 110 bool ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_sub_if_data *sdata, 111 struct ieee80211_supported_band *sband, 112 const struct ieee80211_ht_cap *ht_cap_ie, 113 struct sta_info *sta) 114 { 115 struct ieee80211_sta_ht_cap ht_cap, own_cap; 116 u8 ampdu_info, tx_mcs_set_cap; 117 int i, max_tx_streams; 118 bool changed; 119 enum ieee80211_sta_rx_bandwidth bw; 120 enum ieee80211_smps_mode smps_mode; 121 122 memset(&ht_cap, 0, sizeof(ht_cap)); 123 124 if (!ht_cap_ie || !sband->ht_cap.ht_supported) 125 goto apply; 126 127 ht_cap.ht_supported = true; 128 129 own_cap = sband->ht_cap; 130 131 /* 132 * If user has specified capability over-rides, take care 133 * of that if the station we're setting up is the AP that 134 * we advertised a restricted capability set to. Override 135 * our own capabilities and then use those below. 136 */ 137 if ((sdata->vif.type == NL80211_IFTYPE_STATION || 138 sdata->vif.type == NL80211_IFTYPE_ADHOC) && 139 !test_sta_flag(sta, WLAN_STA_TDLS_PEER)) 140 ieee80211_apply_htcap_overrides(sdata, &own_cap); 141 142 /* 143 * The bits listed in this expression should be 144 * the same for the peer and us, if the station 145 * advertises more then we can't use those thus 146 * we mask them out. 147 */ 148 ht_cap.cap = le16_to_cpu(ht_cap_ie->cap_info) & 149 (own_cap.cap | ~(IEEE80211_HT_CAP_LDPC_CODING | 150 IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 151 IEEE80211_HT_CAP_GRN_FLD | 152 IEEE80211_HT_CAP_SGI_20 | 153 IEEE80211_HT_CAP_SGI_40 | 154 IEEE80211_HT_CAP_DSSSCCK40)); 155 156 /* 157 * The STBC bits are asymmetric -- if we don't have 158 * TX then mask out the peer's RX and vice versa. 159 */ 160 if (!(own_cap.cap & IEEE80211_HT_CAP_TX_STBC)) 161 ht_cap.cap &= ~IEEE80211_HT_CAP_RX_STBC; 162 if (!(own_cap.cap & IEEE80211_HT_CAP_RX_STBC)) 163 ht_cap.cap &= ~IEEE80211_HT_CAP_TX_STBC; 164 165 ampdu_info = ht_cap_ie->ampdu_params_info; 166 ht_cap.ampdu_factor = 167 ampdu_info & IEEE80211_HT_AMPDU_PARM_FACTOR; 168 ht_cap.ampdu_density = 169 (ampdu_info & IEEE80211_HT_AMPDU_PARM_DENSITY) >> 2; 170 171 /* own MCS TX capabilities */ 172 tx_mcs_set_cap = own_cap.mcs.tx_params; 173 174 /* Copy peer MCS TX capabilities, the driver might need them. */ 175 ht_cap.mcs.tx_params = ht_cap_ie->mcs.tx_params; 176 177 /* can we TX with MCS rates? */ 178 if (!(tx_mcs_set_cap & IEEE80211_HT_MCS_TX_DEFINED)) 179 goto apply; 180 181 /* Counting from 0, therefore +1 */ 182 if (tx_mcs_set_cap & IEEE80211_HT_MCS_TX_RX_DIFF) 183 max_tx_streams = 184 ((tx_mcs_set_cap & IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK) 185 >> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT) + 1; 186 else 187 max_tx_streams = IEEE80211_HT_MCS_TX_MAX_STREAMS; 188 189 /* 190 * 802.11n-2009 20.3.5 / 20.6 says: 191 * - indices 0 to 7 and 32 are single spatial stream 192 * - 8 to 31 are multiple spatial streams using equal modulation 193 * [8..15 for two streams, 16..23 for three and 24..31 for four] 194 * - remainder are multiple spatial streams using unequal modulation 195 */ 196 for (i = 0; i < max_tx_streams; i++) 197 ht_cap.mcs.rx_mask[i] = 198 own_cap.mcs.rx_mask[i] & ht_cap_ie->mcs.rx_mask[i]; 199 200 if (tx_mcs_set_cap & IEEE80211_HT_MCS_TX_UNEQUAL_MODULATION) 201 for (i = IEEE80211_HT_MCS_UNEQUAL_MODULATION_START_BYTE; 202 i < IEEE80211_HT_MCS_MASK_LEN; i++) 203 ht_cap.mcs.rx_mask[i] = 204 own_cap.mcs.rx_mask[i] & 205 ht_cap_ie->mcs.rx_mask[i]; 206 207 /* handle MCS rate 32 too */ 208 if (own_cap.mcs.rx_mask[32/8] & ht_cap_ie->mcs.rx_mask[32/8] & 1) 209 ht_cap.mcs.rx_mask[32/8] |= 1; 210 211 apply: 212 changed = memcmp(&sta->sta.ht_cap, &ht_cap, sizeof(ht_cap)); 213 214 memcpy(&sta->sta.ht_cap, &ht_cap, sizeof(ht_cap)); 215 216 switch (sdata->vif.bss_conf.chandef.width) { 217 default: 218 WARN_ON_ONCE(1); 219 /* fall through */ 220 case NL80211_CHAN_WIDTH_20_NOHT: 221 case NL80211_CHAN_WIDTH_20: 222 bw = IEEE80211_STA_RX_BW_20; 223 break; 224 case NL80211_CHAN_WIDTH_40: 225 case NL80211_CHAN_WIDTH_80: 226 case NL80211_CHAN_WIDTH_80P80: 227 case NL80211_CHAN_WIDTH_160: 228 bw = ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ? 229 IEEE80211_STA_RX_BW_40 : IEEE80211_STA_RX_BW_20; 230 break; 231 } 232 233 if (bw != sta->sta.bandwidth) 234 changed = true; 235 sta->sta.bandwidth = bw; 236 237 sta->cur_max_bandwidth = 238 ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ? 239 IEEE80211_STA_RX_BW_40 : IEEE80211_STA_RX_BW_20; 240 241 switch ((ht_cap.cap & IEEE80211_HT_CAP_SM_PS) 242 >> IEEE80211_HT_CAP_SM_PS_SHIFT) { 243 case WLAN_HT_CAP_SM_PS_INVALID: 244 case WLAN_HT_CAP_SM_PS_STATIC: 245 smps_mode = IEEE80211_SMPS_STATIC; 246 break; 247 case WLAN_HT_CAP_SM_PS_DYNAMIC: 248 smps_mode = IEEE80211_SMPS_DYNAMIC; 249 break; 250 case WLAN_HT_CAP_SM_PS_DISABLED: 251 smps_mode = IEEE80211_SMPS_OFF; 252 break; 253 } 254 255 if (smps_mode != sta->sta.smps_mode) 256 changed = true; 257 sta->sta.smps_mode = smps_mode; 258 259 return changed; 260 } 261 262 void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta, 263 enum ieee80211_agg_stop_reason reason) 264 { 265 int i; 266 267 cancel_work_sync(&sta->ampdu_mlme.work); 268 269 for (i = 0; i < IEEE80211_NUM_TIDS; i++) { 270 __ieee80211_stop_tx_ba_session(sta, i, reason); 271 __ieee80211_stop_rx_ba_session(sta, i, WLAN_BACK_RECIPIENT, 272 WLAN_REASON_QSTA_LEAVE_QBSS, 273 reason != AGG_STOP_DESTROY_STA && 274 reason != AGG_STOP_PEER_REQUEST); 275 } 276 } 277 278 void ieee80211_ba_session_work(struct work_struct *work) 279 { 280 struct sta_info *sta = 281 container_of(work, struct sta_info, ampdu_mlme.work); 282 struct tid_ampdu_tx *tid_tx; 283 int tid; 284 285 /* 286 * When this flag is set, new sessions should be 287 * blocked, and existing sessions will be torn 288 * down by the code that set the flag, so this 289 * need not run. 290 */ 291 if (test_sta_flag(sta, WLAN_STA_BLOCK_BA)) 292 return; 293 294 mutex_lock(&sta->ampdu_mlme.mtx); 295 for (tid = 0; tid < IEEE80211_NUM_TIDS; tid++) { 296 if (test_and_clear_bit(tid, sta->ampdu_mlme.tid_rx_timer_expired)) 297 ___ieee80211_stop_rx_ba_session( 298 sta, tid, WLAN_BACK_RECIPIENT, 299 WLAN_REASON_QSTA_TIMEOUT, true); 300 301 if (test_and_clear_bit(tid, 302 sta->ampdu_mlme.tid_rx_stop_requested)) 303 ___ieee80211_stop_rx_ba_session( 304 sta, tid, WLAN_BACK_RECIPIENT, 305 WLAN_REASON_UNSPECIFIED, true); 306 307 spin_lock_bh(&sta->lock); 308 309 tid_tx = sta->ampdu_mlme.tid_start_tx[tid]; 310 if (tid_tx) { 311 /* 312 * Assign it over to the normal tid_tx array 313 * where it "goes live". 314 */ 315 316 sta->ampdu_mlme.tid_start_tx[tid] = NULL; 317 /* could there be a race? */ 318 if (sta->ampdu_mlme.tid_tx[tid]) 319 kfree(tid_tx); 320 else 321 ieee80211_assign_tid_tx(sta, tid, tid_tx); 322 spin_unlock_bh(&sta->lock); 323 324 ieee80211_tx_ba_session_handle_start(sta, tid); 325 continue; 326 } 327 spin_unlock_bh(&sta->lock); 328 329 tid_tx = rcu_dereference_protected_tid_tx(sta, tid); 330 if (tid_tx && test_and_clear_bit(HT_AGG_STATE_WANT_STOP, 331 &tid_tx->state)) 332 ___ieee80211_stop_tx_ba_session(sta, tid, 333 AGG_STOP_LOCAL_REQUEST); 334 } 335 mutex_unlock(&sta->ampdu_mlme.mtx); 336 } 337 338 void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata, 339 const u8 *da, u16 tid, 340 u16 initiator, u16 reason_code) 341 { 342 struct ieee80211_local *local = sdata->local; 343 struct sk_buff *skb; 344 struct ieee80211_mgmt *mgmt; 345 u16 params; 346 347 skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom); 348 if (!skb) 349 return; 350 351 skb_reserve(skb, local->hw.extra_tx_headroom); 352 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 353 memset(mgmt, 0, 24); 354 memcpy(mgmt->da, da, ETH_ALEN); 355 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 356 if (sdata->vif.type == NL80211_IFTYPE_AP || 357 sdata->vif.type == NL80211_IFTYPE_AP_VLAN || 358 sdata->vif.type == NL80211_IFTYPE_MESH_POINT) 359 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN); 360 else if (sdata->vif.type == NL80211_IFTYPE_STATION) 361 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN); 362 else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) 363 memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN); 364 365 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 366 IEEE80211_STYPE_ACTION); 367 368 skb_put(skb, 1 + sizeof(mgmt->u.action.u.delba)); 369 370 mgmt->u.action.category = WLAN_CATEGORY_BACK; 371 mgmt->u.action.u.delba.action_code = WLAN_ACTION_DELBA; 372 params = (u16)(initiator << 11); /* bit 11 initiator */ 373 params |= (u16)(tid << 12); /* bit 15:12 TID number */ 374 375 mgmt->u.action.u.delba.params = cpu_to_le16(params); 376 mgmt->u.action.u.delba.reason_code = cpu_to_le16(reason_code); 377 378 ieee80211_tx_skb_tid(sdata, skb, tid); 379 } 380 381 void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata, 382 struct sta_info *sta, 383 struct ieee80211_mgmt *mgmt, size_t len) 384 { 385 u16 tid, params; 386 u16 initiator; 387 388 params = le16_to_cpu(mgmt->u.action.u.delba.params); 389 tid = (params & IEEE80211_DELBA_PARAM_TID_MASK) >> 12; 390 initiator = (params & IEEE80211_DELBA_PARAM_INITIATOR_MASK) >> 11; 391 392 ht_dbg_ratelimited(sdata, "delba from %pM (%s) tid %d reason code %d\n", 393 mgmt->sa, initiator ? "initiator" : "recipient", 394 tid, 395 le16_to_cpu(mgmt->u.action.u.delba.reason_code)); 396 397 if (initiator == WLAN_BACK_INITIATOR) 398 __ieee80211_stop_rx_ba_session(sta, tid, WLAN_BACK_INITIATOR, 0, 399 true); 400 else 401 __ieee80211_stop_tx_ba_session(sta, tid, AGG_STOP_PEER_REQUEST); 402 } 403 404 int ieee80211_send_smps_action(struct ieee80211_sub_if_data *sdata, 405 enum ieee80211_smps_mode smps, const u8 *da, 406 const u8 *bssid) 407 { 408 struct ieee80211_local *local = sdata->local; 409 struct sk_buff *skb; 410 struct ieee80211_mgmt *action_frame; 411 412 /* 27 = header + category + action + smps mode */ 413 skb = dev_alloc_skb(27 + local->hw.extra_tx_headroom); 414 if (!skb) 415 return -ENOMEM; 416 417 skb_reserve(skb, local->hw.extra_tx_headroom); 418 action_frame = (void *)skb_put(skb, 27); 419 memcpy(action_frame->da, da, ETH_ALEN); 420 memcpy(action_frame->sa, sdata->dev->dev_addr, ETH_ALEN); 421 memcpy(action_frame->bssid, bssid, ETH_ALEN); 422 action_frame->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 423 IEEE80211_STYPE_ACTION); 424 action_frame->u.action.category = WLAN_CATEGORY_HT; 425 action_frame->u.action.u.ht_smps.action = WLAN_HT_ACTION_SMPS; 426 switch (smps) { 427 case IEEE80211_SMPS_AUTOMATIC: 428 case IEEE80211_SMPS_NUM_MODES: 429 WARN_ON(1); 430 case IEEE80211_SMPS_OFF: 431 action_frame->u.action.u.ht_smps.smps_control = 432 WLAN_HT_SMPS_CONTROL_DISABLED; 433 break; 434 case IEEE80211_SMPS_STATIC: 435 action_frame->u.action.u.ht_smps.smps_control = 436 WLAN_HT_SMPS_CONTROL_STATIC; 437 break; 438 case IEEE80211_SMPS_DYNAMIC: 439 action_frame->u.action.u.ht_smps.smps_control = 440 WLAN_HT_SMPS_CONTROL_DYNAMIC; 441 break; 442 } 443 444 /* we'll do more on status of this frame */ 445 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS; 446 ieee80211_tx_skb(sdata, skb); 447 448 return 0; 449 } 450 451 void ieee80211_request_smps_mgd_work(struct work_struct *work) 452 { 453 struct ieee80211_sub_if_data *sdata = 454 container_of(work, struct ieee80211_sub_if_data, 455 u.mgd.request_smps_work); 456 457 sdata_lock(sdata); 458 __ieee80211_request_smps_mgd(sdata, sdata->u.mgd.driver_smps_mode); 459 sdata_unlock(sdata); 460 } 461 462 void ieee80211_request_smps_ap_work(struct work_struct *work) 463 { 464 struct ieee80211_sub_if_data *sdata = 465 container_of(work, struct ieee80211_sub_if_data, 466 u.ap.request_smps_work); 467 468 sdata_lock(sdata); 469 __ieee80211_request_smps_ap(sdata, sdata->u.ap.driver_smps_mode); 470 sdata_unlock(sdata); 471 } 472 473 void ieee80211_request_smps(struct ieee80211_vif *vif, 474 enum ieee80211_smps_mode smps_mode) 475 { 476 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 477 478 if (WARN_ON_ONCE(vif->type != NL80211_IFTYPE_STATION && 479 vif->type != NL80211_IFTYPE_AP)) 480 return; 481 482 if (WARN_ON(smps_mode == IEEE80211_SMPS_OFF)) 483 smps_mode = IEEE80211_SMPS_AUTOMATIC; 484 485 if (vif->type == NL80211_IFTYPE_STATION) { 486 if (sdata->u.mgd.driver_smps_mode == smps_mode) 487 return; 488 sdata->u.mgd.driver_smps_mode = smps_mode; 489 ieee80211_queue_work(&sdata->local->hw, 490 &sdata->u.mgd.request_smps_work); 491 } else { 492 /* AUTOMATIC is meaningless in AP mode */ 493 if (WARN_ON_ONCE(smps_mode == IEEE80211_SMPS_AUTOMATIC)) 494 return; 495 if (sdata->u.ap.driver_smps_mode == smps_mode) 496 return; 497 sdata->u.ap.driver_smps_mode = smps_mode; 498 ieee80211_queue_work(&sdata->local->hw, 499 &sdata->u.ap.request_smps_work); 500 } 501 } 502 /* this might change ... don't want non-open drivers using it */ 503 EXPORT_SYMBOL_GPL(ieee80211_request_smps); 504