net/mac80211/ht.c

   1 /*
   2  * HT handling
   3  *
   4  * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
   5  * Copyright 2004, Instant802 Networks, Inc.
   6  * Copyright 2005, Devicescape Software, Inc.
   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>
  17 #include <net/wireless.h>
  18 #include <net/mac80211.h>
  19 #include "ieee80211_i.h"
  20 #include "sta_info.h"
  21
  22 int ieee80211_ht_cap_ie_to_ht_info(struct ieee80211_ht_cap *ht_cap_ie,
  23                                    struct ieee80211_ht_info *ht_info)
  24 {
  25
  26         if (ht_info == NULL)
  27                 return -EINVAL;
  28
  29         memset(ht_info, 0, sizeof(*ht_info));
  30
  31         if (ht_cap_ie) {
  32                 u8 ampdu_info = ht_cap_ie->ampdu_params_info;
  33
  34                 ht_info->ht_supported = 1;
  35                 ht_info->cap = le16_to_cpu(ht_cap_ie->cap_info);
  36                 ht_info->ampdu_factor =
  37                         ampdu_info & IEEE80211_HT_CAP_AMPDU_FACTOR;
  38                 ht_info->ampdu_density =
  39                         (ampdu_info & IEEE80211_HT_CAP_AMPDU_DENSITY) >> 2;
  40                 memcpy(ht_info->supp_mcs_set, ht_cap_ie->supp_mcs_set, 16);
  41         } else
  42                 ht_info->ht_supported = 0;
  43
  44         return 0;
  45 }
  46
  47 int ieee80211_ht_addt_info_ie_to_ht_bss_info(
  48                         struct ieee80211_ht_addt_info *ht_add_info_ie,
  49                         struct ieee80211_ht_bss_info *bss_info)
  50 {
  51         if (bss_info == NULL)
  52                 return -EINVAL;
  53
  54         memset(bss_info, 0, sizeof(*bss_info));
  55
  56         if (ht_add_info_ie) {
  57                 u16 op_mode;
  58                 op_mode = le16_to_cpu(ht_add_info_ie->operation_mode);
  59
  60                 bss_info->primary_channel = ht_add_info_ie->control_chan;
  61                 bss_info->bss_cap = ht_add_info_ie->ht_param;
  62                 bss_info->bss_op_mode = (u8)(op_mode & 0xff);
  63         }
  64
  65         return 0;
  66 }
  67
  68 void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata, const u8 *da,
  69                                 u16 tid, u8 dialog_token, u16 start_seq_num,
  70                                 u16 agg_size, u16 timeout)
  71 {
  72         struct ieee80211_local *local = sdata->local;
  73         struct ieee80211_if_sta *ifsta = &sdata->u.sta;
  74         struct sk_buff *skb;
  75         struct ieee80211_mgmt *mgmt;
  76         u16 capab;
  77
  78         skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
  79
  80         if (!skb) {
  81                 printk(KERN_ERR "%s: failed to allocate buffer "
  82                                 "for addba request frame\n", sdata->dev->name);
  83                 return;
  84         }
  85         skb_reserve(skb, local->hw.extra_tx_headroom);
  86         mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
  87         memset(mgmt, 0, 24);
  88         memcpy(mgmt->da, da, ETH_ALEN);
  89         memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
  90         if (sdata->vif.type == IEEE80211_IF_TYPE_AP)
  91                 memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN);
  92         else
  93                 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
  94
  95         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
  96                                           IEEE80211_STYPE_ACTION);
  97
  98         skb_put(skb, 1 + sizeof(mgmt->u.action.u.addba_req));
  99
 100         mgmt->u.action.category = WLAN_CATEGORY_BACK;
 101         mgmt->u.action.u.addba_req.action_code = WLAN_ACTION_ADDBA_REQ;
 102
 103         mgmt->u.action.u.addba_req.dialog_token = dialog_token;
 104         capab = (u16)(1 << 1);          /* bit 1 aggregation policy */
 105         capab |= (u16)(tid << 2);       /* bit 5:2 TID number */
 106         capab |= (u16)(agg_size << 6);  /* bit 15:6 max size of aggergation */
 107
 108         mgmt->u.action.u.addba_req.capab = cpu_to_le16(capab);
 109
 110         mgmt->u.action.u.addba_req.timeout = cpu_to_le16(timeout);
 111         mgmt->u.action.u.addba_req.start_seq_num =
 112                                         cpu_to_le16(start_seq_num << 4);
 113
 114         ieee80211_sta_tx(sdata, skb, 0);
 115 }
 116
 117 void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata, const u8 *da, u16 tid,
 118                           u16 initiator, u16 reason_code)
 119 {
 120         struct ieee80211_local *local = sdata->local;
 121         struct ieee80211_if_sta *ifsta = &sdata->u.sta;
 122         struct sk_buff *skb;
 123         struct ieee80211_mgmt *mgmt;
 124         u16 params;
 125
 126         skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
 127
 128         if (!skb) {
 129                 printk(KERN_ERR "%s: failed to allocate buffer "
 130                                         "for delba frame\n", sdata->dev->name);
 131                 return;
 132         }
 133
 134         skb_reserve(skb, local->hw.extra_tx_headroom);
 135         mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
 136         memset(mgmt, 0, 24);
 137         memcpy(mgmt->da, da, ETH_ALEN);
 138         memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
 139         if (sdata->vif.type == IEEE80211_IF_TYPE_AP)
 140                 memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN);
 141         else
 142                 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
 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
 156         ieee80211_sta_tx(sdata, skb, 0);
 157 }
 158
 159 void ieee80211_send_bar(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid, u16 ssn)
 160 {
 161         struct ieee80211_local *local = sdata->local;
 162         struct sk_buff *skb;
 163         struct ieee80211_bar *bar;
 164         u16 bar_control = 0;
 165
 166         skb = dev_alloc_skb(sizeof(*bar) + local->hw.extra_tx_headroom);
 167         if (!skb) {
 168                 printk(KERN_ERR "%s: failed to allocate buffer for "
 169                         "bar frame\n", sdata->dev->name);
 170                 return;
 171         }
 172         skb_reserve(skb, local->hw.extra_tx_headroom);
 173         bar = (struct ieee80211_bar *)skb_put(skb, sizeof(*bar));
 174         memset(bar, 0, sizeof(*bar));
 175         bar->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
 176                                          IEEE80211_STYPE_BACK_REQ);
 177         memcpy(bar->ra, ra, ETH_ALEN);
 178         memcpy(bar->ta, sdata->dev->dev_addr, ETH_ALEN);
 179         bar_control |= (u16)IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL;
 180         bar_control |= (u16)IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA;
 181         bar_control |= (u16)(tid << 12);
 182         bar->control = cpu_to_le16(bar_control);
 183         bar->start_seq_num = cpu_to_le16(ssn);
 184
 185         ieee80211_sta_tx(sdata, skb, 0);
 186 }
 187
 188 void ieee80211_sta_stop_rx_ba_session(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid,
 189                                         u16 initiator, u16 reason)
 190 {
 191         struct ieee80211_local *local = sdata->local;
 192         struct ieee80211_hw *hw = &local->hw;
 193         struct sta_info *sta;
 194         int ret, i;
 195         DECLARE_MAC_BUF(mac);
 196
 197         rcu_read_lock();
 198
 199         sta = sta_info_get(local, ra);
 200         if (!sta) {
 201                 rcu_read_unlock();
 202                 return;
 203         }
 204
 205         /* check if TID is in operational state */
 206         spin_lock_bh(&sta->lock);
 207         if (sta->ampdu_mlme.tid_state_rx[tid]
 208                                 != HT_AGG_STATE_OPERATIONAL) {
 209                 spin_unlock_bh(&sta->lock);
 210                 rcu_read_unlock();
 211                 return;
 212         }
 213         sta->ampdu_mlme.tid_state_rx[tid] =
 214                 HT_AGG_STATE_REQ_STOP_BA_MSK |
 215                 (initiator << HT_AGG_STATE_INITIATOR_SHIFT);
 216         spin_unlock_bh(&sta->lock);
 217
 218         /* stop HW Rx aggregation. ampdu_action existence
 219          * already verified in session init so we add the BUG_ON */
 220         BUG_ON(!local->ops->ampdu_action);
 221
 222 #ifdef CONFIG_MAC80211_HT_DEBUG
 223         printk(KERN_DEBUG "Rx BA session stop requested for %s tid %u\n",
 224                                 print_mac(mac, ra), tid);
 225 #endif /* CONFIG_MAC80211_HT_DEBUG */
 226
 227         ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_RX_STOP,
 228                                         ra, tid, NULL);
 229         if (ret)
 230                 printk(KERN_DEBUG "HW problem - can not stop rx "
 231                                 "aggregation for tid %d\n", tid);
 232
 233         /* shutdown timer has not expired */
 234         if (initiator != WLAN_BACK_TIMER)
 235                 del_timer_sync(&sta->ampdu_mlme.tid_rx[tid]->session_timer);
 236
 237         /* check if this is a self generated aggregation halt */
 238         if (initiator == WLAN_BACK_RECIPIENT || initiator == WLAN_BACK_TIMER)
 239                 ieee80211_send_delba(sdata, ra, tid, 0, reason);
 240
 241         /* free the reordering buffer */
 242         for (i = 0; i < sta->ampdu_mlme.tid_rx[tid]->buf_size; i++) {
 243                 if (sta->ampdu_mlme.tid_rx[tid]->reorder_buf[i]) {
 244                         /* release the reordered frames */
 245                         dev_kfree_skb(sta->ampdu_mlme.tid_rx[tid]->reorder_buf[i]);
 246                         sta->ampdu_mlme.tid_rx[tid]->stored_mpdu_num--;
 247                         sta->ampdu_mlme.tid_rx[tid]->reorder_buf[i] = NULL;
 248                 }
 249         }
 250         /* free resources */
 251         kfree(sta->ampdu_mlme.tid_rx[tid]->reorder_buf);
 252         kfree(sta->ampdu_mlme.tid_rx[tid]);
 253         sta->ampdu_mlme.tid_rx[tid] = NULL;
 254         sta->ampdu_mlme.tid_state_rx[tid] = HT_AGG_STATE_IDLE;
 255
 256         rcu_read_unlock();
 257 }
 258
 259
 260 /*
 261  * After sending add Block Ack request we activated a timer until
 262  * add Block Ack response will arrive from the recipient.
 263  * If this timer expires sta_addba_resp_timer_expired will be executed.
 264  */
 265 void sta_addba_resp_timer_expired(unsigned long data)
 266 {
 267         /* not an elegant detour, but there is no choice as the timer passes
 268          * only one argument, and both sta_info and TID are needed, so init
 269          * flow in sta_info_create gives the TID as data, while the timer_to_id
 270          * array gives the sta through container_of */
 271         u16 tid = *(u8 *)data;
 272         struct sta_info *temp_sta = container_of((void *)data,
 273                 struct sta_info, timer_to_tid[tid]);
 274
 275         struct ieee80211_local *local = temp_sta->local;
 276         struct ieee80211_hw *hw = &local->hw;
 277         struct sta_info *sta;
 278         u8 *state;
 279
 280         rcu_read_lock();
 281
 282         sta = sta_info_get(local, temp_sta->addr);
 283         if (!sta) {
 284                 rcu_read_unlock();
 285                 return;
 286         }
 287
 288         state = &sta->ampdu_mlme.tid_state_tx[tid];
 289         /* check if the TID waits for addBA response */
 290         spin_lock_bh(&sta->lock);
 291         if (!(*state & HT_ADDBA_REQUESTED_MSK)) {
 292                 spin_unlock_bh(&sta->lock);
 293                 *state = HT_AGG_STATE_IDLE;
 294 #ifdef CONFIG_MAC80211_HT_DEBUG
 295                 printk(KERN_DEBUG "timer expired on tid %d but we are not "
 296                                 "expecting addBA response there", tid);
 297 #endif
 298                 goto timer_expired_exit;
 299         }
 300
 301 #ifdef CONFIG_MAC80211_HT_DEBUG
 302         printk(KERN_DEBUG "addBA response timer expired on tid %d\n", tid);
 303 #endif
 304
 305         /* go through the state check in stop_BA_session */
 306         *state = HT_AGG_STATE_OPERATIONAL;
 307         spin_unlock_bh(&sta->lock);
 308         ieee80211_stop_tx_ba_session(hw, temp_sta->addr, tid,
 309                                      WLAN_BACK_INITIATOR);
 310
 311 timer_expired_exit:
 312         rcu_read_unlock();
 313 }
 314
 315 void ieee80211_sta_tear_down_BA_sessions(struct ieee80211_sub_if_data *sdata, u8 *addr)
 316 {
 317         struct ieee80211_local *local = sdata->local;
 318         int i;
 319
 320         for (i = 0; i <  STA_TID_NUM; i++) {
 321                 ieee80211_stop_tx_ba_session(&local->hw, addr, i,
 322                                              WLAN_BACK_INITIATOR);
 323                 ieee80211_sta_stop_rx_ba_session(sdata, addr, i,
 324                                                  WLAN_BACK_RECIPIENT,
 325                                                  WLAN_REASON_QSTA_LEAVE_QBSS);
 326         }
 327 }
 328