wme.c revision 51cb6db0f5654f08a4a6bfa3888dc36a51c2df3e
1/* 2 * Copyright 2004, Instant802 Networks, Inc. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 as 6 * published by the Free Software Foundation. 7 */ 8 9#include <linux/netdevice.h> 10#include <linux/skbuff.h> 11#include <linux/module.h> 12#include <linux/if_arp.h> 13#include <linux/types.h> 14#include <net/ip.h> 15#include <net/pkt_sched.h> 16 17#include <net/mac80211.h> 18#include "ieee80211_i.h" 19#include "wme.h" 20 21/* Default mapping in classifier to work with default 22 * queue setup. 23 */ 24const int ieee802_1d_to_ac[8] = { 2, 3, 3, 2, 1, 1, 0, 0 }; 25 26static const char llc_ip_hdr[8] = {0xAA, 0xAA, 0x3, 0, 0, 0, 0x08, 0}; 27 28/* Given a data frame determine the 802.1p/1d tag to use. */ 29static unsigned int classify_1d(struct sk_buff *skb) 30{ 31 unsigned int dscp; 32 33 /* skb->priority values from 256->263 are magic values to 34 * directly indicate a specific 802.1d priority. This is used 35 * to allow 802.1d priority to be passed directly in from VLAN 36 * tags, etc. 37 */ 38 if (skb->priority >= 256 && skb->priority <= 263) 39 return skb->priority - 256; 40 41 switch (skb->protocol) { 42 case __constant_htons(ETH_P_IP): 43 dscp = ip_hdr(skb)->tos & 0xfc; 44 break; 45 46 default: 47 return 0; 48 } 49 50 if (dscp & 0x1c) 51 return 0; 52 return dscp >> 5; 53} 54 55 56static int wme_downgrade_ac(struct sk_buff *skb) 57{ 58 switch (skb->priority) { 59 case 6: 60 case 7: 61 skb->priority = 5; /* VO -> VI */ 62 return 0; 63 case 4: 64 case 5: 65 skb->priority = 3; /* VI -> BE */ 66 return 0; 67 case 0: 68 case 3: 69 skb->priority = 2; /* BE -> BK */ 70 return 0; 71 default: 72 return -1; 73 } 74} 75 76 77/* Indicate which queue to use. */ 78static u16 classify80211(struct sk_buff *skb, struct net_device *dev) 79{ 80 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 81 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 82 83 if (!ieee80211_is_data(hdr->frame_control)) { 84 /* management frames go on AC_VO queue, but are sent 85 * without QoS control fields */ 86 return 0; 87 } 88 89 if (0 /* injected */) { 90 /* use AC from radiotap */ 91 } 92 93 if (!ieee80211_is_data_qos(hdr->frame_control)) { 94 skb->priority = 0; /* required for correct WPA/11i MIC */ 95 return ieee802_1d_to_ac[skb->priority]; 96 } 97 98 /* use the data classifier to determine what 802.1d tag the 99 * data frame has */ 100 skb->priority = classify_1d(skb); 101 102 /* in case we are a client verify acm is not set for this ac */ 103 while (unlikely(local->wmm_acm & BIT(skb->priority))) { 104 if (wme_downgrade_ac(skb)) { 105 /* The old code would drop the packet in this 106 * case. 107 */ 108 return 0; 109 } 110 } 111 112 /* look up which queue to use for frames with this 1d tag */ 113 return ieee802_1d_to_ac[skb->priority]; 114} 115 116u16 ieee80211_select_queue(struct net_device *dev, struct sk_buff *skb) 117{ 118 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 119 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 120 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 121 struct sta_info *sta; 122 u16 queue; 123 u8 tid; 124 125 queue = classify80211(skb, dev); 126 if (unlikely(queue >= local->hw.queues)) 127 queue = local->hw.queues - 1; 128 129 if (info->flags & IEEE80211_TX_CTL_REQUEUE) { 130 rcu_read_lock(); 131 sta = sta_info_get(local, hdr->addr1); 132 tid = skb->priority & IEEE80211_QOS_CTL_TAG1D_MASK; 133 if (sta) { 134 struct ieee80211_hw *hw = &local->hw; 135 int ampdu_queue = sta->tid_to_tx_q[tid]; 136 137 if ((ampdu_queue < ieee80211_num_queues(hw)) && 138 test_bit(ampdu_queue, local->queue_pool)) { 139 queue = ampdu_queue; 140 info->flags |= IEEE80211_TX_CTL_AMPDU; 141 } else { 142 info->flags &= ~IEEE80211_TX_CTL_AMPDU; 143 } 144 } 145 rcu_read_unlock(); 146 147 return queue; 148 } 149 150 /* Now we know the 1d priority, fill in the QoS header if 151 * there is one. 152 */ 153 if (ieee80211_is_data_qos(hdr->frame_control)) { 154 u8 *p = ieee80211_get_qos_ctl(hdr); 155 u8 ack_policy = 0; 156 tid = skb->priority & IEEE80211_QOS_CTL_TAG1D_MASK; 157 if (local->wifi_wme_noack_test) 158 ack_policy |= QOS_CONTROL_ACK_POLICY_NOACK << 159 QOS_CONTROL_ACK_POLICY_SHIFT; 160 /* qos header is 2 bytes, second reserved */ 161 *p++ = ack_policy | tid; 162 *p = 0; 163 164 rcu_read_lock(); 165 166 sta = sta_info_get(local, hdr->addr1); 167 if (sta) { 168 int ampdu_queue = sta->tid_to_tx_q[tid]; 169 struct ieee80211_hw *hw = &local->hw; 170 171 if ((ampdu_queue < ieee80211_num_queues(hw)) && 172 test_bit(ampdu_queue, local->queue_pool)) { 173 queue = ampdu_queue; 174 info->flags |= IEEE80211_TX_CTL_AMPDU; 175 } else { 176 info->flags &= ~IEEE80211_TX_CTL_AMPDU; 177 } 178 } 179 180 rcu_read_unlock(); 181 } 182 183 return queue; 184} 185 186int ieee80211_ht_agg_queue_add(struct ieee80211_local *local, 187 struct sta_info *sta, u16 tid) 188{ 189 int i; 190 191 /* prepare the filter and save it for the SW queue 192 * matching the received HW queue */ 193 194 if (!local->hw.ampdu_queues) 195 return -EPERM; 196 197 /* try to get a Qdisc from the pool */ 198 for (i = local->hw.queues; i < ieee80211_num_queues(&local->hw); i++) 199 if (!test_and_set_bit(i, local->queue_pool)) { 200 ieee80211_stop_queue(local_to_hw(local), i); 201 sta->tid_to_tx_q[tid] = i; 202 203 /* IF there are already pending packets 204 * on this tid first we need to drain them 205 * on the previous queue 206 * since HT is strict in order */ 207#ifdef CONFIG_MAC80211_HT_DEBUG 208 if (net_ratelimit()) { 209 DECLARE_MAC_BUF(mac); 210 printk(KERN_DEBUG "allocated aggregation queue" 211 " %d tid %d addr %s pool=0x%lX\n", 212 i, tid, print_mac(mac, sta->addr), 213 local->queue_pool[0]); 214 } 215#endif /* CONFIG_MAC80211_HT_DEBUG */ 216 return 0; 217 } 218 219 return -EAGAIN; 220} 221 222/** 223 * the caller needs to hold netdev_get_tx_queue(local->mdev, X)->lock 224 */ 225void ieee80211_ht_agg_queue_remove(struct ieee80211_local *local, 226 struct sta_info *sta, u16 tid, 227 u8 requeue) 228{ 229 int agg_queue = sta->tid_to_tx_q[tid]; 230 struct ieee80211_hw *hw = &local->hw; 231 232 /* return the qdisc to the pool */ 233 clear_bit(agg_queue, local->queue_pool); 234 sta->tid_to_tx_q[tid] = ieee80211_num_queues(hw); 235 236 if (requeue) { 237 ieee80211_requeue(local, agg_queue); 238 } else { 239 struct netdev_queue *txq; 240 241 txq = netdev_get_tx_queue(local->mdev, agg_queue); 242 243 spin_lock_bh(&txq->lock); 244 qdisc_reset(txq->qdisc); 245 spin_unlock_bh(&txq->lock); 246 } 247} 248 249void ieee80211_requeue(struct ieee80211_local *local, int queue) 250{ 251 struct netdev_queue *txq = netdev_get_tx_queue(local->mdev, queue); 252 struct sk_buff_head list; 253 struct Qdisc *qdisc; 254 u32 len; 255 256 rcu_read_lock_bh(); 257 258 qdisc = rcu_dereference(txq->qdisc); 259 if (!qdisc || !qdisc->dequeue) 260 goto out_unlock; 261 262 skb_queue_head_init(&list); 263 264 spin_lock(&txq->lock); 265 for (len = qdisc->q.qlen; len > 0; len--) { 266 struct sk_buff *skb = qdisc->dequeue(qdisc); 267 268 if (skb) 269 __skb_queue_tail(&list, skb); 270 } 271 spin_unlock(&txq->lock); 272 273 for (len = list.qlen; len > 0; len--) { 274 struct sk_buff *skb = __skb_dequeue(&list); 275 u16 new_queue; 276 277 BUG_ON(!skb); 278 new_queue = ieee80211_select_queue(local->mdev, skb); 279 skb_set_queue_mapping(skb, new_queue); 280 281 txq = netdev_get_tx_queue(local->mdev, new_queue); 282 283 spin_lock(&txq->lock); 284 285 qdisc = rcu_dereference(txq->qdisc); 286 qdisc->enqueue(skb, qdisc); 287 288 spin_unlock(&txq->lock); 289 } 290 291out_unlock: 292 rcu_read_unlock_bh(); 293} 294