Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 1 | /* |
| 2 | * HT handling |
| 3 | * |
| 4 | * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi> |
Johannes Berg | bacac54 | 2008-09-08 17:44:29 +0200 | [diff] [blame] | 5 | * Copyright 2002-2005, Instant802 Networks, Inc. |
| 6 | * Copyright 2005-2006, Devicescape Software, Inc. |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 7 | * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> |
| 8 | * Copyright 2007, Michael Wu <flamingice@sourmilk.net> |
| 9 | * Copyright 2007-2008, 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> |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 17 | #include <net/mac80211.h> |
| 18 | #include "ieee80211_i.h" |
Sujith | 81cb762 | 2009-02-12 11:38:37 +0530 | [diff] [blame] | 19 | #include "rate.h" |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 20 | |
Johannes Berg | ae5eb02 | 2008-10-14 16:58:37 +0200 | [diff] [blame] | 21 | void ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_supported_band *sband, |
| 22 | struct ieee80211_ht_cap *ht_cap_ie, |
Johannes Berg | d9fe60d | 2008-10-09 12:13:49 +0200 | [diff] [blame] | 23 | struct ieee80211_sta_ht_cap *ht_cap) |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 24 | { |
Johannes Berg | ae5eb02 | 2008-10-14 16:58:37 +0200 | [diff] [blame] | 25 | u8 ampdu_info, tx_mcs_set_cap; |
| 26 | int i, max_tx_streams; |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 27 | |
Johannes Berg | d9fe60d | 2008-10-09 12:13:49 +0200 | [diff] [blame] | 28 | BUG_ON(!ht_cap); |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 29 | |
Johannes Berg | d9fe60d | 2008-10-09 12:13:49 +0200 | [diff] [blame] | 30 | memset(ht_cap, 0, sizeof(*ht_cap)); |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 31 | |
Johannes Berg | ae5eb02 | 2008-10-14 16:58:37 +0200 | [diff] [blame] | 32 | if (!ht_cap_ie) |
| 33 | return; |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 34 | |
Johannes Berg | ae5eb02 | 2008-10-14 16:58:37 +0200 | [diff] [blame] | 35 | ht_cap->ht_supported = true; |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 36 | |
Johannes Berg | 9a418af | 2009-12-17 13:55:48 +0100 | [diff] [blame] | 37 | /* |
| 38 | * The bits listed in this expression should be |
| 39 | * the same for the peer and us, if the station |
| 40 | * advertises more then we can't use those thus |
| 41 | * we mask them out. |
| 42 | */ |
| 43 | ht_cap->cap = le16_to_cpu(ht_cap_ie->cap_info) & |
| 44 | (sband->ht_cap.cap | |
| 45 | ~(IEEE80211_HT_CAP_LDPC_CODING | |
| 46 | IEEE80211_HT_CAP_SUP_WIDTH_20_40 | |
| 47 | IEEE80211_HT_CAP_GRN_FLD | |
| 48 | IEEE80211_HT_CAP_SGI_20 | |
| 49 | IEEE80211_HT_CAP_SGI_40 | |
| 50 | IEEE80211_HT_CAP_DSSSCCK40)); |
| 51 | /* |
| 52 | * The STBC bits are asymmetric -- if we don't have |
| 53 | * TX then mask out the peer's RX and vice versa. |
| 54 | */ |
| 55 | if (!(sband->ht_cap.cap & IEEE80211_HT_CAP_TX_STBC)) |
| 56 | ht_cap->cap &= ~IEEE80211_HT_CAP_RX_STBC; |
| 57 | if (!(sband->ht_cap.cap & IEEE80211_HT_CAP_RX_STBC)) |
| 58 | ht_cap->cap &= ~IEEE80211_HT_CAP_TX_STBC; |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 59 | |
Johannes Berg | ae5eb02 | 2008-10-14 16:58:37 +0200 | [diff] [blame] | 60 | ampdu_info = ht_cap_ie->ampdu_params_info; |
| 61 | ht_cap->ampdu_factor = |
| 62 | ampdu_info & IEEE80211_HT_AMPDU_PARM_FACTOR; |
| 63 | ht_cap->ampdu_density = |
| 64 | (ampdu_info & IEEE80211_HT_AMPDU_PARM_DENSITY) >> 2; |
Johannes Berg | d9fe60d | 2008-10-09 12:13:49 +0200 | [diff] [blame] | 65 | |
| 66 | /* own MCS TX capabilities */ |
| 67 | tx_mcs_set_cap = sband->ht_cap.mcs.tx_params; |
| 68 | |
Johannes Berg | d9fe60d | 2008-10-09 12:13:49 +0200 | [diff] [blame] | 69 | /* can we TX with MCS rates? */ |
| 70 | if (!(tx_mcs_set_cap & IEEE80211_HT_MCS_TX_DEFINED)) |
Johannes Berg | ae5eb02 | 2008-10-14 16:58:37 +0200 | [diff] [blame] | 71 | return; |
Johannes Berg | d9fe60d | 2008-10-09 12:13:49 +0200 | [diff] [blame] | 72 | |
| 73 | /* Counting from 0, therefore +1 */ |
| 74 | if (tx_mcs_set_cap & IEEE80211_HT_MCS_TX_RX_DIFF) |
| 75 | max_tx_streams = |
| 76 | ((tx_mcs_set_cap & IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK) |
| 77 | >> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT) + 1; |
| 78 | else |
| 79 | max_tx_streams = IEEE80211_HT_MCS_TX_MAX_STREAMS; |
| 80 | |
| 81 | /* |
| 82 | * 802.11n D5.0 20.3.5 / 20.6 says: |
| 83 | * - indices 0 to 7 and 32 are single spatial stream |
| 84 | * - 8 to 31 are multiple spatial streams using equal modulation |
| 85 | * [8..15 for two streams, 16..23 for three and 24..31 for four] |
| 86 | * - remainder are multiple spatial streams using unequal modulation |
| 87 | */ |
| 88 | for (i = 0; i < max_tx_streams; i++) |
Johannes Berg | ae5eb02 | 2008-10-14 16:58:37 +0200 | [diff] [blame] | 89 | ht_cap->mcs.rx_mask[i] = |
| 90 | sband->ht_cap.mcs.rx_mask[i] & ht_cap_ie->mcs.rx_mask[i]; |
Johannes Berg | d9fe60d | 2008-10-09 12:13:49 +0200 | [diff] [blame] | 91 | |
| 92 | if (tx_mcs_set_cap & IEEE80211_HT_MCS_TX_UNEQUAL_MODULATION) |
| 93 | for (i = IEEE80211_HT_MCS_UNEQUAL_MODULATION_START_BYTE; |
| 94 | i < IEEE80211_HT_MCS_MASK_LEN; i++) |
Johannes Berg | ae5eb02 | 2008-10-14 16:58:37 +0200 | [diff] [blame] | 95 | ht_cap->mcs.rx_mask[i] = |
Johannes Berg | d9fe60d | 2008-10-09 12:13:49 +0200 | [diff] [blame] | 96 | sband->ht_cap.mcs.rx_mask[i] & |
Johannes Berg | ae5eb02 | 2008-10-14 16:58:37 +0200 | [diff] [blame] | 97 | ht_cap_ie->mcs.rx_mask[i]; |
Johannes Berg | d9fe60d | 2008-10-09 12:13:49 +0200 | [diff] [blame] | 98 | |
| 99 | /* handle MCS rate 32 too */ |
Johannes Berg | ae5eb02 | 2008-10-14 16:58:37 +0200 | [diff] [blame] | 100 | if (sband->ht_cap.mcs.rx_mask[32/8] & ht_cap_ie->mcs.rx_mask[32/8] & 1) |
| 101 | ht_cap->mcs.rx_mask[32/8] |= 1; |
| 102 | } |
Johannes Berg | d9fe60d | 2008-10-09 12:13:49 +0200 | [diff] [blame] | 103 | |
Johannes Berg | 2dace10 | 2009-02-10 21:25:52 +0100 | [diff] [blame] | 104 | void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta) |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 105 | { |
Johannes Berg | b8695a8 | 2009-02-10 21:25:46 +0100 | [diff] [blame] | 106 | int i; |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 107 | |
Johannes Berg | b8695a8 | 2009-02-10 21:25:46 +0100 | [diff] [blame] | 108 | for (i = 0; i < STA_TID_NUM; i++) { |
Johannes Berg | 849b796 | 2009-02-10 21:25:54 +0100 | [diff] [blame] | 109 | __ieee80211_stop_tx_ba_session(sta, i, WLAN_BACK_INITIATOR); |
| 110 | __ieee80211_stop_rx_ba_session(sta, i, WLAN_BACK_RECIPIENT, |
| 111 | WLAN_REASON_QSTA_LEAVE_QBSS); |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 112 | } |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 113 | } |
| 114 | |
Johannes Berg | b8695a8 | 2009-02-10 21:25:46 +0100 | [diff] [blame] | 115 | void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata, |
| 116 | const u8 *da, u16 tid, |
| 117 | u16 initiator, u16 reason_code) |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 118 | { |
| 119 | struct ieee80211_local *local = sdata->local; |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 120 | struct sk_buff *skb; |
| 121 | struct ieee80211_mgmt *mgmt; |
| 122 | u16 params; |
| 123 | |
| 124 | skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom); |
| 125 | |
| 126 | if (!skb) { |
| 127 | printk(KERN_ERR "%s: failed to allocate buffer " |
Johannes Berg | 47846c9 | 2009-11-25 17:46:19 +0100 | [diff] [blame] | 128 | "for delba frame\n", sdata->name); |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 129 | return; |
| 130 | } |
| 131 | |
| 132 | skb_reserve(skb, local->hw.extra_tx_headroom); |
| 133 | mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); |
| 134 | memset(mgmt, 0, 24); |
| 135 | memcpy(mgmt->da, da, ETH_ALEN); |
Johannes Berg | 47846c9 | 2009-11-25 17:46:19 +0100 | [diff] [blame] | 136 | memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); |
Johannes Berg | 8abd3f9 | 2009-02-10 21:25:47 +0100 | [diff] [blame] | 137 | if (sdata->vif.type == NL80211_IFTYPE_AP || |
| 138 | sdata->vif.type == NL80211_IFTYPE_AP_VLAN) |
Johannes Berg | 47846c9 | 2009-11-25 17:46:19 +0100 | [diff] [blame] | 139 | memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN); |
Johannes Berg | 4690029 | 2009-02-15 12:44:28 +0100 | [diff] [blame] | 140 | else if (sdata->vif.type == NL80211_IFTYPE_STATION) |
| 141 | memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN); |
| 142 | |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 143 | mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | |
| 144 | IEEE80211_STYPE_ACTION); |
| 145 | |
| 146 | skb_put(skb, 1 + sizeof(mgmt->u.action.u.delba)); |
| 147 | |
| 148 | mgmt->u.action.category = WLAN_CATEGORY_BACK; |
| 149 | mgmt->u.action.u.delba.action_code = WLAN_ACTION_DELBA; |
| 150 | params = (u16)(initiator << 11); /* bit 11 initiator */ |
| 151 | params |= (u16)(tid << 12); /* bit 15:12 TID number */ |
| 152 | |
| 153 | mgmt->u.action.u.delba.params = cpu_to_le16(params); |
| 154 | mgmt->u.action.u.delba.reason_code = cpu_to_le16(reason_code); |
| 155 | |
Johannes Berg | 62ae67b | 2009-11-18 18:42:05 +0100 | [diff] [blame] | 156 | ieee80211_tx_skb(sdata, skb); |
Johannes Berg | 44d414d | 2008-09-08 17:44:28 +0200 | [diff] [blame] | 157 | } |
| 158 | |
Johannes Berg | de1ede7 | 2008-09-09 14:42:50 +0200 | [diff] [blame] | 159 | void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata, |
| 160 | struct sta_info *sta, |
| 161 | struct ieee80211_mgmt *mgmt, size_t len) |
| 162 | { |
Johannes Berg | de1ede7 | 2008-09-09 14:42:50 +0200 | [diff] [blame] | 163 | u16 tid, params; |
| 164 | u16 initiator; |
Johannes Berg | de1ede7 | 2008-09-09 14:42:50 +0200 | [diff] [blame] | 165 | |
| 166 | params = le16_to_cpu(mgmt->u.action.u.delba.params); |
| 167 | tid = (params & IEEE80211_DELBA_PARAM_TID_MASK) >> 12; |
| 168 | initiator = (params & IEEE80211_DELBA_PARAM_INITIATOR_MASK) >> 11; |
| 169 | |
| 170 | #ifdef CONFIG_MAC80211_HT_DEBUG |
| 171 | if (net_ratelimit()) |
Johannes Berg | 0c68ae26 | 2008-10-27 15:56:10 -0700 | [diff] [blame] | 172 | printk(KERN_DEBUG "delba from %pM (%s) tid %d reason code %d\n", |
| 173 | mgmt->sa, initiator ? "initiator" : "recipient", tid, |
Johannes Berg | 372362a | 2009-10-29 10:09:28 +0100 | [diff] [blame] | 174 | le16_to_cpu(mgmt->u.action.u.delba.reason_code)); |
Johannes Berg | de1ede7 | 2008-09-09 14:42:50 +0200 | [diff] [blame] | 175 | #endif /* CONFIG_MAC80211_HT_DEBUG */ |
| 176 | |
| 177 | if (initiator == WLAN_BACK_INITIATOR) |
Johannes Berg | 17741cd | 2008-09-11 00:02:02 +0200 | [diff] [blame] | 178 | ieee80211_sta_stop_rx_ba_session(sdata, sta->sta.addr, tid, |
Johannes Berg | de1ede7 | 2008-09-09 14:42:50 +0200 | [diff] [blame] | 179 | WLAN_BACK_INITIATOR, 0); |
| 180 | else { /* WLAN_BACK_RECIPIENT */ |
| 181 | spin_lock_bh(&sta->lock); |
Johannes Berg | 827d42c | 2009-11-22 12:28:41 +0100 | [diff] [blame] | 182 | if (sta->ampdu_mlme.tid_state_tx[tid] & HT_ADDBA_REQUESTED_MSK) |
| 183 | ___ieee80211_stop_tx_ba_session(sta, tid, |
| 184 | WLAN_BACK_RECIPIENT); |
Johannes Berg | de1ede7 | 2008-09-09 14:42:50 +0200 | [diff] [blame] | 185 | spin_unlock_bh(&sta->lock); |
Johannes Berg | de1ede7 | 2008-09-09 14:42:50 +0200 | [diff] [blame] | 186 | } |
| 187 | } |
Johannes Berg | 0f78231 | 2009-12-01 13:37:02 +0100 | [diff] [blame] | 188 | |
| 189 | int ieee80211_send_smps_action(struct ieee80211_sub_if_data *sdata, |
| 190 | enum ieee80211_smps_mode smps, const u8 *da, |
| 191 | const u8 *bssid) |
| 192 | { |
| 193 | struct ieee80211_local *local = sdata->local; |
| 194 | struct sk_buff *skb; |
| 195 | struct ieee80211_mgmt *action_frame; |
| 196 | |
| 197 | /* 27 = header + category + action + smps mode */ |
| 198 | skb = dev_alloc_skb(27 + local->hw.extra_tx_headroom); |
| 199 | if (!skb) |
| 200 | return -ENOMEM; |
| 201 | |
| 202 | skb_reserve(skb, local->hw.extra_tx_headroom); |
| 203 | action_frame = (void *)skb_put(skb, 27); |
| 204 | memcpy(action_frame->da, da, ETH_ALEN); |
| 205 | memcpy(action_frame->sa, sdata->dev->dev_addr, ETH_ALEN); |
| 206 | memcpy(action_frame->bssid, bssid, ETH_ALEN); |
| 207 | action_frame->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | |
| 208 | IEEE80211_STYPE_ACTION); |
| 209 | action_frame->u.action.category = WLAN_CATEGORY_HT; |
| 210 | action_frame->u.action.u.ht_smps.action = WLAN_HT_ACTION_SMPS; |
| 211 | switch (smps) { |
| 212 | case IEEE80211_SMPS_AUTOMATIC: |
| 213 | case IEEE80211_SMPS_NUM_MODES: |
| 214 | WARN_ON(1); |
| 215 | case IEEE80211_SMPS_OFF: |
| 216 | action_frame->u.action.u.ht_smps.smps_control = |
| 217 | WLAN_HT_SMPS_CONTROL_DISABLED; |
| 218 | break; |
| 219 | case IEEE80211_SMPS_STATIC: |
| 220 | action_frame->u.action.u.ht_smps.smps_control = |
| 221 | WLAN_HT_SMPS_CONTROL_STATIC; |
| 222 | break; |
| 223 | case IEEE80211_SMPS_DYNAMIC: |
| 224 | action_frame->u.action.u.ht_smps.smps_control = |
| 225 | WLAN_HT_SMPS_CONTROL_DYNAMIC; |
| 226 | break; |
| 227 | } |
| 228 | |
| 229 | /* we'll do more on status of this frame */ |
| 230 | IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS; |
| 231 | ieee80211_tx_skb(sdata, skb); |
| 232 | |
| 233 | return 0; |
| 234 | } |