Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 9475af6e44d2c17583243c253e2464467b52fa50

Authored by Tejun Heo
Committed by Linus Torvalds
1 parent 19a101a02e
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

mac80211: convert to idr_alloc() 

Convert to the much saner new idr interface.

Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 2 changed files with 4 additions and 16 deletions Inline Diff

1 /* 1 /*
2 * Copyright 2002-2005, Instant802 Networks, Inc. 2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
5 * 5 *
6 * This program is free software; you can redistribute it and/or modify 6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as 7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation. 8 * published by the Free Software Foundation.
9 */ 9 */
10 10
11 #include <net/mac80211.h> 11 #include <net/mac80211.h>
12 #include <linux/module.h> 12 #include <linux/module.h>
13 #include <linux/init.h> 13 #include <linux/init.h>
14 #include <linux/netdevice.h> 14 #include <linux/netdevice.h>
15 #include <linux/types.h> 15 #include <linux/types.h>
16 #include <linux/slab.h> 16 #include <linux/slab.h>
17 #include <linux/skbuff.h> 17 #include <linux/skbuff.h>
18 #include <linux/etherdevice.h> 18 #include <linux/etherdevice.h>
19 #include <linux/if_arp.h> 19 #include <linux/if_arp.h>
20 #include <linux/rtnetlink.h> 20 #include <linux/rtnetlink.h>
21 #include <linux/bitmap.h> 21 #include <linux/bitmap.h>
22 #include <linux/pm_qos.h> 22 #include <linux/pm_qos.h>
23 #include <linux/inetdevice.h> 23 #include <linux/inetdevice.h>
24 #include <net/net_namespace.h> 24 #include <net/net_namespace.h>
25 #include <net/cfg80211.h> 25 #include <net/cfg80211.h>
26 #include <net/addrconf.h> 26 #include <net/addrconf.h>
27 27
28 #include "ieee80211_i.h" 28 #include "ieee80211_i.h"
29 #include "driver-ops.h" 29 #include "driver-ops.h"
30 #include "rate.h" 30 #include "rate.h"
31 #include "mesh.h" 31 #include "mesh.h"
32 #include "wep.h" 32 #include "wep.h"
33 #include "led.h" 33 #include "led.h"
34 #include "cfg.h" 34 #include "cfg.h"
35 #include "debugfs.h" 35 #include "debugfs.h"
36 36
37 void ieee80211_configure_filter(struct ieee80211_local *local) 37 void ieee80211_configure_filter(struct ieee80211_local *local)
38 { 38 {
39 u64 mc; 39 u64 mc;
40 unsigned int changed_flags; 40 unsigned int changed_flags;
41 unsigned int new_flags = 0; 41 unsigned int new_flags = 0;
42 42
43 if (atomic_read(&local->iff_promiscs)) 43 if (atomic_read(&local->iff_promiscs))
44 new_flags |= FIF_PROMISC_IN_BSS; 44 new_flags |= FIF_PROMISC_IN_BSS;
45 45
46 if (atomic_read(&local->iff_allmultis)) 46 if (atomic_read(&local->iff_allmultis))
47 new_flags |= FIF_ALLMULTI; 47 new_flags |= FIF_ALLMULTI;
48 48
49 if (local->monitors || test_bit(SCAN_SW_SCANNING, &local->scanning) || 49 if (local->monitors || test_bit(SCAN_SW_SCANNING, &local->scanning) ||
50 test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning)) 50 test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning))
51 new_flags |= FIF_BCN_PRBRESP_PROMISC; 51 new_flags |= FIF_BCN_PRBRESP_PROMISC;
52 52
53 if (local->fif_probe_req || local->probe_req_reg) 53 if (local->fif_probe_req || local->probe_req_reg)
54 new_flags |= FIF_PROBE_REQ; 54 new_flags |= FIF_PROBE_REQ;
55 55
56 if (local->fif_fcsfail) 56 if (local->fif_fcsfail)
57 new_flags |= FIF_FCSFAIL; 57 new_flags |= FIF_FCSFAIL;
58 58
59 if (local->fif_plcpfail) 59 if (local->fif_plcpfail)
60 new_flags |= FIF_PLCPFAIL; 60 new_flags |= FIF_PLCPFAIL;
61 61
62 if (local->fif_control) 62 if (local->fif_control)
63 new_flags |= FIF_CONTROL; 63 new_flags |= FIF_CONTROL;
64 64
65 if (local->fif_other_bss) 65 if (local->fif_other_bss)
66 new_flags |= FIF_OTHER_BSS; 66 new_flags |= FIF_OTHER_BSS;
67 67
68 if (local->fif_pspoll) 68 if (local->fif_pspoll)
69 new_flags |= FIF_PSPOLL; 69 new_flags |= FIF_PSPOLL;
70 70
71 spin_lock_bh(&local->filter_lock); 71 spin_lock_bh(&local->filter_lock);
72 changed_flags = local->filter_flags ^ new_flags; 72 changed_flags = local->filter_flags ^ new_flags;
73 73
74 mc = drv_prepare_multicast(local, &local->mc_list); 74 mc = drv_prepare_multicast(local, &local->mc_list);
75 spin_unlock_bh(&local->filter_lock); 75 spin_unlock_bh(&local->filter_lock);
76 76
77 /* be a bit nasty */ 77 /* be a bit nasty */
78 new_flags |= (1<<31); 78 new_flags |= (1<<31);
79 79
80 drv_configure_filter(local, changed_flags, &new_flags, mc); 80 drv_configure_filter(local, changed_flags, &new_flags, mc);
81 81
82 WARN_ON(new_flags & (1<<31)); 82 WARN_ON(new_flags & (1<<31));
83 83
84 local->filter_flags = new_flags & ~(1<<31); 84 local->filter_flags = new_flags & ~(1<<31);
85 } 85 }
86 86
87 static void ieee80211_reconfig_filter(struct work_struct *work) 87 static void ieee80211_reconfig_filter(struct work_struct *work)
88 { 88 {
89 struct ieee80211_local *local = 89 struct ieee80211_local *local =
90 container_of(work, struct ieee80211_local, reconfig_filter); 90 container_of(work, struct ieee80211_local, reconfig_filter);
91 91
92 ieee80211_configure_filter(local); 92 ieee80211_configure_filter(local);
93 } 93 }
94 94
95 static u32 ieee80211_hw_conf_chan(struct ieee80211_local *local) 95 static u32 ieee80211_hw_conf_chan(struct ieee80211_local *local)
96 { 96 {
97 struct ieee80211_sub_if_data *sdata; 97 struct ieee80211_sub_if_data *sdata;
98 struct ieee80211_channel *chan; 98 struct ieee80211_channel *chan;
99 u32 changed = 0; 99 u32 changed = 0;
100 int power; 100 int power;
101 enum nl80211_channel_type channel_type; 101 enum nl80211_channel_type channel_type;
102 u32 offchannel_flag; 102 u32 offchannel_flag;
103 bool scanning = false; 103 bool scanning = false;
104 104
105 offchannel_flag = local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL; 105 offchannel_flag = local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
106 if (local->scan_channel) { 106 if (local->scan_channel) {
107 chan = local->scan_channel; 107 chan = local->scan_channel;
108 /* If scanning on oper channel, use whatever channel-type 108 /* If scanning on oper channel, use whatever channel-type
109 * is currently in use. 109 * is currently in use.
110 */ 110 */
111 if (chan == local->_oper_channel) 111 if (chan == local->_oper_channel)
112 channel_type = local->_oper_channel_type; 112 channel_type = local->_oper_channel_type;
113 else 113 else
114 channel_type = NL80211_CHAN_NO_HT; 114 channel_type = NL80211_CHAN_NO_HT;
115 } else if (local->tmp_channel) { 115 } else if (local->tmp_channel) {
116 chan = local->tmp_channel; 116 chan = local->tmp_channel;
117 channel_type = NL80211_CHAN_NO_HT; 117 channel_type = NL80211_CHAN_NO_HT;
118 } else { 118 } else {
119 chan = local->_oper_channel; 119 chan = local->_oper_channel;
120 channel_type = local->_oper_channel_type; 120 channel_type = local->_oper_channel_type;
121 } 121 }
122 122
123 if (chan != local->_oper_channel || 123 if (chan != local->_oper_channel ||
124 channel_type != local->_oper_channel_type) 124 channel_type != local->_oper_channel_type)
125 local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL; 125 local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL;
126 else 126 else
127 local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL; 127 local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL;
128 128
129 offchannel_flag ^= local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL; 129 offchannel_flag ^= local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
130 130
131 if (offchannel_flag || chan != local->hw.conf.channel || 131 if (offchannel_flag || chan != local->hw.conf.channel ||
132 channel_type != local->hw.conf.channel_type) { 132 channel_type != local->hw.conf.channel_type) {
133 local->hw.conf.channel = chan; 133 local->hw.conf.channel = chan;
134 local->hw.conf.channel_type = channel_type; 134 local->hw.conf.channel_type = channel_type;
135 changed |= IEEE80211_CONF_CHANGE_CHANNEL; 135 changed |= IEEE80211_CONF_CHANGE_CHANNEL;
136 } 136 }
137 137
138 if (!conf_is_ht(&local->hw.conf)) { 138 if (!conf_is_ht(&local->hw.conf)) {
139 /* 139 /*
140 * mac80211.h documents that this is only valid 140 * mac80211.h documents that this is only valid
141 * when the channel is set to an HT type, and 141 * when the channel is set to an HT type, and
142 * that otherwise STATIC is used. 142 * that otherwise STATIC is used.
143 */ 143 */
144 local->hw.conf.smps_mode = IEEE80211_SMPS_STATIC; 144 local->hw.conf.smps_mode = IEEE80211_SMPS_STATIC;
145 } else if (local->hw.conf.smps_mode != local->smps_mode) { 145 } else if (local->hw.conf.smps_mode != local->smps_mode) {
146 local->hw.conf.smps_mode = local->smps_mode; 146 local->hw.conf.smps_mode = local->smps_mode;
147 changed |= IEEE80211_CONF_CHANGE_SMPS; 147 changed |= IEEE80211_CONF_CHANGE_SMPS;
148 } 148 }
149 149
150 scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) || 150 scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
151 test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning) || 151 test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning) ||
152 test_bit(SCAN_HW_SCANNING, &local->scanning); 152 test_bit(SCAN_HW_SCANNING, &local->scanning);
153 power = chan->max_power; 153 power = chan->max_power;
154 154
155 rcu_read_lock(); 155 rcu_read_lock();
156 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 156 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
157 if (!rcu_access_pointer(sdata->vif.chanctx_conf)) 157 if (!rcu_access_pointer(sdata->vif.chanctx_conf))
158 continue; 158 continue;
159 power = min(power, sdata->vif.bss_conf.txpower); 159 power = min(power, sdata->vif.bss_conf.txpower);
160 } 160 }
161 rcu_read_unlock(); 161 rcu_read_unlock();
162 162
163 if (local->hw.conf.power_level != power) { 163 if (local->hw.conf.power_level != power) {
164 changed |= IEEE80211_CONF_CHANGE_POWER; 164 changed |= IEEE80211_CONF_CHANGE_POWER;
165 local->hw.conf.power_level = power; 165 local->hw.conf.power_level = power;
166 } 166 }
167 167
168 return changed; 168 return changed;
169 } 169 }
170 170
171 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed) 171 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
172 { 172 {
173 int ret = 0; 173 int ret = 0;
174 174
175 might_sleep(); 175 might_sleep();
176 176
177 if (!local->use_chanctx) 177 if (!local->use_chanctx)
178 changed |= ieee80211_hw_conf_chan(local); 178 changed |= ieee80211_hw_conf_chan(local);
179 else 179 else
180 changed &= ~(IEEE80211_CONF_CHANGE_CHANNEL | 180 changed &= ~(IEEE80211_CONF_CHANGE_CHANNEL |
181 IEEE80211_CONF_CHANGE_POWER); 181 IEEE80211_CONF_CHANGE_POWER);
182 182
183 if (changed && local->open_count) { 183 if (changed && local->open_count) {
184 ret = drv_config(local, changed); 184 ret = drv_config(local, changed);
185 /* 185 /*
186 * Goal: 186 * Goal:
187 * HW reconfiguration should never fail, the driver has told 187 * HW reconfiguration should never fail, the driver has told
188 * us what it can support so it should live up to that promise. 188 * us what it can support so it should live up to that promise.
189 * 189 *
190 * Current status: 190 * Current status:
191 * rfkill is not integrated with mac80211 and a 191 * rfkill is not integrated with mac80211 and a
192 * configuration command can thus fail if hardware rfkill 192 * configuration command can thus fail if hardware rfkill
193 * is enabled 193 * is enabled
194 * 194 *
195 * FIXME: integrate rfkill with mac80211 and then add this 195 * FIXME: integrate rfkill with mac80211 and then add this
196 * WARN_ON() back 196 * WARN_ON() back
197 * 197 *
198 */ 198 */
199 /* WARN_ON(ret); */ 199 /* WARN_ON(ret); */
200 } 200 }
201 201
202 return ret; 202 return ret;
203 } 203 }
204 204
205 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 205 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
206 u32 changed) 206 u32 changed)
207 { 207 {
208 struct ieee80211_local *local = sdata->local; 208 struct ieee80211_local *local = sdata->local;
209 209
210 if (!changed) 210 if (!changed)
211 return; 211 return;
212 212
213 drv_bss_info_changed(local, sdata, &sdata->vif.bss_conf, changed); 213 drv_bss_info_changed(local, sdata, &sdata->vif.bss_conf, changed);
214 } 214 }
215 215
216 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata) 216 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
217 { 217 {
218 sdata->vif.bss_conf.use_cts_prot = false; 218 sdata->vif.bss_conf.use_cts_prot = false;
219 sdata->vif.bss_conf.use_short_preamble = false; 219 sdata->vif.bss_conf.use_short_preamble = false;
220 sdata->vif.bss_conf.use_short_slot = false; 220 sdata->vif.bss_conf.use_short_slot = false;
221 return BSS_CHANGED_ERP_CTS_PROT | 221 return BSS_CHANGED_ERP_CTS_PROT |
222 BSS_CHANGED_ERP_PREAMBLE | 222 BSS_CHANGED_ERP_PREAMBLE |
223 BSS_CHANGED_ERP_SLOT; 223 BSS_CHANGED_ERP_SLOT;
224 } 224 }
225 225
226 static void ieee80211_tasklet_handler(unsigned long data) 226 static void ieee80211_tasklet_handler(unsigned long data)
227 { 227 {
228 struct ieee80211_local *local = (struct ieee80211_local *) data; 228 struct ieee80211_local *local = (struct ieee80211_local *) data;
229 struct sta_info *sta, *tmp; 229 struct sta_info *sta, *tmp;
230 struct skb_eosp_msg_data *eosp_data; 230 struct skb_eosp_msg_data *eosp_data;
231 struct sk_buff *skb; 231 struct sk_buff *skb;
232 232
233 while ((skb = skb_dequeue(&local->skb_queue)) || 233 while ((skb = skb_dequeue(&local->skb_queue)) ||
234 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 234 (skb = skb_dequeue(&local->skb_queue_unreliable))) {
235 switch (skb->pkt_type) { 235 switch (skb->pkt_type) {
236 case IEEE80211_RX_MSG: 236 case IEEE80211_RX_MSG:
237 /* Clear skb->pkt_type in order to not confuse kernel 237 /* Clear skb->pkt_type in order to not confuse kernel
238 * netstack. */ 238 * netstack. */
239 skb->pkt_type = 0; 239 skb->pkt_type = 0;
240 ieee80211_rx(&local->hw, skb); 240 ieee80211_rx(&local->hw, skb);
241 break; 241 break;
242 case IEEE80211_TX_STATUS_MSG: 242 case IEEE80211_TX_STATUS_MSG:
243 skb->pkt_type = 0; 243 skb->pkt_type = 0;
244 ieee80211_tx_status(&local->hw, skb); 244 ieee80211_tx_status(&local->hw, skb);
245 break; 245 break;
246 case IEEE80211_EOSP_MSG: 246 case IEEE80211_EOSP_MSG:
247 eosp_data = (void *)skb->cb; 247 eosp_data = (void *)skb->cb;
248 for_each_sta_info(local, eosp_data->sta, sta, tmp) { 248 for_each_sta_info(local, eosp_data->sta, sta, tmp) {
249 /* skip wrong virtual interface */ 249 /* skip wrong virtual interface */
250 if (memcmp(eosp_data->iface, 250 if (memcmp(eosp_data->iface,
251 sta->sdata->vif.addr, ETH_ALEN)) 251 sta->sdata->vif.addr, ETH_ALEN))
252 continue; 252 continue;
253 clear_sta_flag(sta, WLAN_STA_SP); 253 clear_sta_flag(sta, WLAN_STA_SP);
254 break; 254 break;
255 } 255 }
256 dev_kfree_skb(skb); 256 dev_kfree_skb(skb);
257 break; 257 break;
258 default: 258 default:
259 WARN(1, "mac80211: Packet is of unknown type %d\n", 259 WARN(1, "mac80211: Packet is of unknown type %d\n",
260 skb->pkt_type); 260 skb->pkt_type);
261 dev_kfree_skb(skb); 261 dev_kfree_skb(skb);
262 break; 262 break;
263 } 263 }
264 } 264 }
265 } 265 }
266 266
267 static void ieee80211_restart_work(struct work_struct *work) 267 static void ieee80211_restart_work(struct work_struct *work)
268 { 268 {
269 struct ieee80211_local *local = 269 struct ieee80211_local *local =
270 container_of(work, struct ieee80211_local, restart_work); 270 container_of(work, struct ieee80211_local, restart_work);
271 271
272 /* wait for scan work complete */ 272 /* wait for scan work complete */
273 flush_workqueue(local->workqueue); 273 flush_workqueue(local->workqueue);
274 274
275 mutex_lock(&local->mtx); 275 mutex_lock(&local->mtx);
276 WARN(test_bit(SCAN_HW_SCANNING, &local->scanning) || 276 WARN(test_bit(SCAN_HW_SCANNING, &local->scanning) ||
277 rcu_dereference_protected(local->sched_scan_sdata, 277 rcu_dereference_protected(local->sched_scan_sdata,
278 lockdep_is_held(&local->mtx)), 278 lockdep_is_held(&local->mtx)),
279 "%s called with hardware scan in progress\n", __func__); 279 "%s called with hardware scan in progress\n", __func__);
280 mutex_unlock(&local->mtx); 280 mutex_unlock(&local->mtx);
281 281
282 rtnl_lock(); 282 rtnl_lock();
283 ieee80211_scan_cancel(local); 283 ieee80211_scan_cancel(local);
284 ieee80211_reconfig(local); 284 ieee80211_reconfig(local);
285 rtnl_unlock(); 285 rtnl_unlock();
286 } 286 }
287 287
288 void ieee80211_restart_hw(struct ieee80211_hw *hw) 288 void ieee80211_restart_hw(struct ieee80211_hw *hw)
289 { 289 {
290 struct ieee80211_local *local = hw_to_local(hw); 290 struct ieee80211_local *local = hw_to_local(hw);
291 291
292 trace_api_restart_hw(local); 292 trace_api_restart_hw(local);
293 293
294 wiphy_info(hw->wiphy, 294 wiphy_info(hw->wiphy,
295 "Hardware restart was requested\n"); 295 "Hardware restart was requested\n");
296 296
297 /* use this reason, ieee80211_reconfig will unblock it */ 297 /* use this reason, ieee80211_reconfig will unblock it */
298 ieee80211_stop_queues_by_reason(hw, 298 ieee80211_stop_queues_by_reason(hw,
299 IEEE80211_QUEUE_STOP_REASON_SUSPEND); 299 IEEE80211_QUEUE_STOP_REASON_SUSPEND);
300 300
301 /* 301 /*
302 * Stop all Rx during the reconfig. We don't want state changes 302 * Stop all Rx during the reconfig. We don't want state changes
303 * or driver callbacks while this is in progress. 303 * or driver callbacks while this is in progress.
304 */ 304 */
305 local->in_reconfig = true; 305 local->in_reconfig = true;
306 barrier(); 306 barrier();
307 307
308 schedule_work(&local->restart_work); 308 schedule_work(&local->restart_work);
309 } 309 }
310 EXPORT_SYMBOL(ieee80211_restart_hw); 310 EXPORT_SYMBOL(ieee80211_restart_hw);
311 311
312 #ifdef CONFIG_INET 312 #ifdef CONFIG_INET
313 static int ieee80211_ifa_changed(struct notifier_block *nb, 313 static int ieee80211_ifa_changed(struct notifier_block *nb,
314 unsigned long data, void *arg) 314 unsigned long data, void *arg)
315 { 315 {
316 struct in_ifaddr *ifa = arg; 316 struct in_ifaddr *ifa = arg;
317 struct ieee80211_local *local = 317 struct ieee80211_local *local =
318 container_of(nb, struct ieee80211_local, 318 container_of(nb, struct ieee80211_local,
319 ifa_notifier); 319 ifa_notifier);
320 struct net_device *ndev = ifa->ifa_dev->dev; 320 struct net_device *ndev = ifa->ifa_dev->dev;
321 struct wireless_dev *wdev = ndev->ieee80211_ptr; 321 struct wireless_dev *wdev = ndev->ieee80211_ptr;
322 struct in_device *idev; 322 struct in_device *idev;
323 struct ieee80211_sub_if_data *sdata; 323 struct ieee80211_sub_if_data *sdata;
324 struct ieee80211_bss_conf *bss_conf; 324 struct ieee80211_bss_conf *bss_conf;
325 struct ieee80211_if_managed *ifmgd; 325 struct ieee80211_if_managed *ifmgd;
326 int c = 0; 326 int c = 0;
327 327
328 /* Make sure it's our interface that got changed */ 328 /* Make sure it's our interface that got changed */
329 if (!wdev) 329 if (!wdev)
330 return NOTIFY_DONE; 330 return NOTIFY_DONE;
331 331
332 if (wdev->wiphy != local->hw.wiphy) 332 if (wdev->wiphy != local->hw.wiphy)
333 return NOTIFY_DONE; 333 return NOTIFY_DONE;
334 334
335 sdata = IEEE80211_DEV_TO_SUB_IF(ndev); 335 sdata = IEEE80211_DEV_TO_SUB_IF(ndev);
336 bss_conf = &sdata->vif.bss_conf; 336 bss_conf = &sdata->vif.bss_conf;
337 337
338 /* ARP filtering is only supported in managed mode */ 338 /* ARP filtering is only supported in managed mode */
339 if (sdata->vif.type != NL80211_IFTYPE_STATION) 339 if (sdata->vif.type != NL80211_IFTYPE_STATION)
340 return NOTIFY_DONE; 340 return NOTIFY_DONE;
341 341
342 idev = __in_dev_get_rtnl(sdata->dev); 342 idev = __in_dev_get_rtnl(sdata->dev);
343 if (!idev) 343 if (!idev)
344 return NOTIFY_DONE; 344 return NOTIFY_DONE;
345 345
346 ifmgd = &sdata->u.mgd; 346 ifmgd = &sdata->u.mgd;
347 mutex_lock(&ifmgd->mtx); 347 mutex_lock(&ifmgd->mtx);
348 348
349 /* Copy the addresses to the bss_conf list */ 349 /* Copy the addresses to the bss_conf list */
350 ifa = idev->ifa_list; 350 ifa = idev->ifa_list;
351 while (ifa) { 351 while (ifa) {
352 if (c < IEEE80211_BSS_ARP_ADDR_LIST_LEN) 352 if (c < IEEE80211_BSS_ARP_ADDR_LIST_LEN)
353 bss_conf->arp_addr_list[c] = ifa->ifa_address; 353 bss_conf->arp_addr_list[c] = ifa->ifa_address;
354 ifa = ifa->ifa_next; 354 ifa = ifa->ifa_next;
355 c++; 355 c++;
356 } 356 }
357 357
358 bss_conf->arp_addr_cnt = c; 358 bss_conf->arp_addr_cnt = c;
359 359
360 /* Configure driver only if associated (which also implies it is up) */ 360 /* Configure driver only if associated (which also implies it is up) */
361 if (ifmgd->associated) 361 if (ifmgd->associated)
362 ieee80211_bss_info_change_notify(sdata, 362 ieee80211_bss_info_change_notify(sdata,
363 BSS_CHANGED_ARP_FILTER); 363 BSS_CHANGED_ARP_FILTER);
364 364
365 mutex_unlock(&ifmgd->mtx); 365 mutex_unlock(&ifmgd->mtx);
366 366
367 return NOTIFY_DONE; 367 return NOTIFY_DONE;
368 } 368 }
369 #endif 369 #endif
370 370
371 #if IS_ENABLED(CONFIG_IPV6) 371 #if IS_ENABLED(CONFIG_IPV6)
372 static int ieee80211_ifa6_changed(struct notifier_block *nb, 372 static int ieee80211_ifa6_changed(struct notifier_block *nb,
373 unsigned long data, void *arg) 373 unsigned long data, void *arg)
374 { 374 {
375 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)arg; 375 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)arg;
376 struct inet6_dev *idev = ifa->idev; 376 struct inet6_dev *idev = ifa->idev;
377 struct net_device *ndev = ifa->idev->dev; 377 struct net_device *ndev = ifa->idev->dev;
378 struct ieee80211_local *local = 378 struct ieee80211_local *local =
379 container_of(nb, struct ieee80211_local, ifa6_notifier); 379 container_of(nb, struct ieee80211_local, ifa6_notifier);
380 struct wireless_dev *wdev = ndev->ieee80211_ptr; 380 struct wireless_dev *wdev = ndev->ieee80211_ptr;
381 struct ieee80211_sub_if_data *sdata; 381 struct ieee80211_sub_if_data *sdata;
382 382
383 /* Make sure it's our interface that got changed */ 383 /* Make sure it's our interface that got changed */
384 if (!wdev || wdev->wiphy != local->hw.wiphy) 384 if (!wdev || wdev->wiphy != local->hw.wiphy)
385 return NOTIFY_DONE; 385 return NOTIFY_DONE;
386 386
387 sdata = IEEE80211_DEV_TO_SUB_IF(ndev); 387 sdata = IEEE80211_DEV_TO_SUB_IF(ndev);
388 388
389 /* 389 /*
390 * For now only support station mode. This is mostly because 390 * For now only support station mode. This is mostly because
391 * doing AP would have to handle AP_VLAN in some way ... 391 * doing AP would have to handle AP_VLAN in some way ...
392 */ 392 */
393 if (sdata->vif.type != NL80211_IFTYPE_STATION) 393 if (sdata->vif.type != NL80211_IFTYPE_STATION)
394 return NOTIFY_DONE; 394 return NOTIFY_DONE;
395 395
396 drv_ipv6_addr_change(local, sdata, idev); 396 drv_ipv6_addr_change(local, sdata, idev);
397 397
398 return NOTIFY_DONE; 398 return NOTIFY_DONE;
399 } 399 }
400 #endif 400 #endif
401 401
402 static int ieee80211_napi_poll(struct napi_struct *napi, int budget) 402 static int ieee80211_napi_poll(struct napi_struct *napi, int budget)
403 { 403 {
404 struct ieee80211_local *local = 404 struct ieee80211_local *local =
405 container_of(napi, struct ieee80211_local, napi); 405 container_of(napi, struct ieee80211_local, napi);
406 406
407 return local->ops->napi_poll(&local->hw, budget); 407 return local->ops->napi_poll(&local->hw, budget);
408 } 408 }
409 409
410 void ieee80211_napi_schedule(struct ieee80211_hw *hw) 410 void ieee80211_napi_schedule(struct ieee80211_hw *hw)
411 { 411 {
412 struct ieee80211_local *local = hw_to_local(hw); 412 struct ieee80211_local *local = hw_to_local(hw);
413 413
414 napi_schedule(&local->napi); 414 napi_schedule(&local->napi);
415 } 415 }
416 EXPORT_SYMBOL(ieee80211_napi_schedule); 416 EXPORT_SYMBOL(ieee80211_napi_schedule);
417 417
418 void ieee80211_napi_complete(struct ieee80211_hw *hw) 418 void ieee80211_napi_complete(struct ieee80211_hw *hw)
419 { 419 {
420 struct ieee80211_local *local = hw_to_local(hw); 420 struct ieee80211_local *local = hw_to_local(hw);
421 421
422 napi_complete(&local->napi); 422 napi_complete(&local->napi);
423 } 423 }
424 EXPORT_SYMBOL(ieee80211_napi_complete); 424 EXPORT_SYMBOL(ieee80211_napi_complete);
425 425
426 /* There isn't a lot of sense in it, but you can transmit anything you like */ 426 /* There isn't a lot of sense in it, but you can transmit anything you like */
427 static const struct ieee80211_txrx_stypes 427 static const struct ieee80211_txrx_stypes
428 ieee80211_default_mgmt_stypes[NUM_NL80211_IFTYPES] = { 428 ieee80211_default_mgmt_stypes[NUM_NL80211_IFTYPES] = {
429 [NL80211_IFTYPE_ADHOC] = { 429 [NL80211_IFTYPE_ADHOC] = {
430 .tx = 0xffff, 430 .tx = 0xffff,
431 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 431 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
432 BIT(IEEE80211_STYPE_AUTH >> 4) | 432 BIT(IEEE80211_STYPE_AUTH >> 4) |
433 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 433 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
434 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 434 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
435 }, 435 },
436 [NL80211_IFTYPE_STATION] = { 436 [NL80211_IFTYPE_STATION] = {
437 .tx = 0xffff, 437 .tx = 0xffff,
438 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 438 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
439 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 439 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
440 }, 440 },
441 [NL80211_IFTYPE_AP] = { 441 [NL80211_IFTYPE_AP] = {
442 .tx = 0xffff, 442 .tx = 0xffff,
443 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 443 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
444 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 444 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
445 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 445 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
446 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 446 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
447 BIT(IEEE80211_STYPE_AUTH >> 4) | 447 BIT(IEEE80211_STYPE_AUTH >> 4) |
448 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 448 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
449 BIT(IEEE80211_STYPE_ACTION >> 4), 449 BIT(IEEE80211_STYPE_ACTION >> 4),
450 }, 450 },
451 [NL80211_IFTYPE_AP_VLAN] = { 451 [NL80211_IFTYPE_AP_VLAN] = {
452 /* copy AP */ 452 /* copy AP */
453 .tx = 0xffff, 453 .tx = 0xffff,
454 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 454 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
455 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 455 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
456 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 456 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
457 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 457 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
458 BIT(IEEE80211_STYPE_AUTH >> 4) | 458 BIT(IEEE80211_STYPE_AUTH >> 4) |
459 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 459 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
460 BIT(IEEE80211_STYPE_ACTION >> 4), 460 BIT(IEEE80211_STYPE_ACTION >> 4),
461 }, 461 },
462 [NL80211_IFTYPE_P2P_CLIENT] = { 462 [NL80211_IFTYPE_P2P_CLIENT] = {
463 .tx = 0xffff, 463 .tx = 0xffff,
464 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 464 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
465 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 465 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
466 }, 466 },
467 [NL80211_IFTYPE_P2P_GO] = { 467 [NL80211_IFTYPE_P2P_GO] = {
468 .tx = 0xffff, 468 .tx = 0xffff,
469 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 469 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
470 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 470 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
471 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 471 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
472 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 472 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
473 BIT(IEEE80211_STYPE_AUTH >> 4) | 473 BIT(IEEE80211_STYPE_AUTH >> 4) |
474 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 474 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
475 BIT(IEEE80211_STYPE_ACTION >> 4), 475 BIT(IEEE80211_STYPE_ACTION >> 4),
476 }, 476 },
477 [NL80211_IFTYPE_MESH_POINT] = { 477 [NL80211_IFTYPE_MESH_POINT] = {
478 .tx = 0xffff, 478 .tx = 0xffff,
479 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 479 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
480 BIT(IEEE80211_STYPE_AUTH >> 4) | 480 BIT(IEEE80211_STYPE_AUTH >> 4) |
481 BIT(IEEE80211_STYPE_DEAUTH >> 4), 481 BIT(IEEE80211_STYPE_DEAUTH >> 4),
482 }, 482 },
483 [NL80211_IFTYPE_P2P_DEVICE] = { 483 [NL80211_IFTYPE_P2P_DEVICE] = {
484 .tx = 0xffff, 484 .tx = 0xffff,
485 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 485 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
486 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 486 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
487 }, 487 },
488 }; 488 };
489 489
490 static const struct ieee80211_ht_cap mac80211_ht_capa_mod_mask = { 490 static const struct ieee80211_ht_cap mac80211_ht_capa_mod_mask = {
491 .ampdu_params_info = IEEE80211_HT_AMPDU_PARM_FACTOR | 491 .ampdu_params_info = IEEE80211_HT_AMPDU_PARM_FACTOR |
492 IEEE80211_HT_AMPDU_PARM_DENSITY, 492 IEEE80211_HT_AMPDU_PARM_DENSITY,
493 493
494 .cap_info = cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 494 .cap_info = cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
495 IEEE80211_HT_CAP_MAX_AMSDU | 495 IEEE80211_HT_CAP_MAX_AMSDU |
496 IEEE80211_HT_CAP_SGI_20 | 496 IEEE80211_HT_CAP_SGI_20 |
497 IEEE80211_HT_CAP_SGI_40), 497 IEEE80211_HT_CAP_SGI_40),
498 .mcs = { 498 .mcs = {
499 .rx_mask = { 0xff, 0xff, 0xff, 0xff, 0xff, 499 .rx_mask = { 0xff, 0xff, 0xff, 0xff, 0xff,
500 0xff, 0xff, 0xff, 0xff, 0xff, }, 500 0xff, 0xff, 0xff, 0xff, 0xff, },
501 }, 501 },
502 }; 502 };
503 503
504 static const u8 extended_capabilities[] = { 504 static const u8 extended_capabilities[] = {
505 0, 0, 0, 0, 0, 0, 0, 505 0, 0, 0, 0, 0, 0, 0,
506 WLAN_EXT_CAPA8_OPMODE_NOTIF, 506 WLAN_EXT_CAPA8_OPMODE_NOTIF,
507 }; 507 };
508 508
509 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len, 509 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
510 const struct ieee80211_ops *ops) 510 const struct ieee80211_ops *ops)
511 { 511 {
512 struct ieee80211_local *local; 512 struct ieee80211_local *local;
513 int priv_size, i; 513 int priv_size, i;
514 struct wiphy *wiphy; 514 struct wiphy *wiphy;
515 bool use_chanctx; 515 bool use_chanctx;
516 516
517 if (WARN_ON(!ops->tx || !ops->start || !ops->stop || !ops->config || 517 if (WARN_ON(!ops->tx || !ops->start || !ops->stop || !ops->config ||
518 !ops->add_interface || !ops->remove_interface || 518 !ops->add_interface || !ops->remove_interface ||
519 !ops->configure_filter)) 519 !ops->configure_filter))
520 return NULL; 520 return NULL;
521 521
522 if (WARN_ON(ops->sta_state && (ops->sta_add || ops->sta_remove))) 522 if (WARN_ON(ops->sta_state && (ops->sta_add || ops->sta_remove)))
523 return NULL; 523 return NULL;
524 524
525 /* check all or no channel context operations exist */ 525 /* check all or no channel context operations exist */
526 i = !!ops->add_chanctx + !!ops->remove_chanctx + 526 i = !!ops->add_chanctx + !!ops->remove_chanctx +
527 !!ops->change_chanctx + !!ops->assign_vif_chanctx + 527 !!ops->change_chanctx + !!ops->assign_vif_chanctx +
528 !!ops->unassign_vif_chanctx; 528 !!ops->unassign_vif_chanctx;
529 if (WARN_ON(i != 0 && i != 5)) 529 if (WARN_ON(i != 0 && i != 5))
530 return NULL; 530 return NULL;
531 use_chanctx = i == 5; 531 use_chanctx = i == 5;
532 532
533 /* Ensure 32-byte alignment of our private data and hw private data. 533 /* Ensure 32-byte alignment of our private data and hw private data.
534 * We use the wiphy priv data for both our ieee80211_local and for 534 * We use the wiphy priv data for both our ieee80211_local and for
535 * the driver's private data 535 * the driver's private data
536 * 536 *
537 * In memory it'll be like this: 537 * In memory it'll be like this:
538 * 538 *
539 * +-------------------------+ 539 * +-------------------------+
540 * | struct wiphy | 540 * | struct wiphy |
541 * +-------------------------+ 541 * +-------------------------+
542 * | struct ieee80211_local | 542 * | struct ieee80211_local |
543 * +-------------------------+ 543 * +-------------------------+
544 * | driver's private data | 544 * | driver's private data |
545 * +-------------------------+ 545 * +-------------------------+
546 * 546 *
547 */ 547 */
548 priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len; 548 priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len;
549 549
550 wiphy = wiphy_new(&mac80211_config_ops, priv_size); 550 wiphy = wiphy_new(&mac80211_config_ops, priv_size);
551 551
552 if (!wiphy) 552 if (!wiphy)
553 return NULL; 553 return NULL;
554 554
555 wiphy->mgmt_stypes = ieee80211_default_mgmt_stypes; 555 wiphy->mgmt_stypes = ieee80211_default_mgmt_stypes;
556 556
557 wiphy->privid = mac80211_wiphy_privid; 557 wiphy->privid = mac80211_wiphy_privid;
558 558
559 wiphy->flags |= WIPHY_FLAG_NETNS_OK | 559 wiphy->flags |= WIPHY_FLAG_NETNS_OK |
560 WIPHY_FLAG_4ADDR_AP | 560 WIPHY_FLAG_4ADDR_AP |
561 WIPHY_FLAG_4ADDR_STATION | 561 WIPHY_FLAG_4ADDR_STATION |
562 WIPHY_FLAG_REPORTS_OBSS | 562 WIPHY_FLAG_REPORTS_OBSS |
563 WIPHY_FLAG_OFFCHAN_TX; 563 WIPHY_FLAG_OFFCHAN_TX;
564 564
565 wiphy->extended_capabilities = extended_capabilities; 565 wiphy->extended_capabilities = extended_capabilities;
566 wiphy->extended_capabilities_mask = extended_capabilities; 566 wiphy->extended_capabilities_mask = extended_capabilities;
567 wiphy->extended_capabilities_len = ARRAY_SIZE(extended_capabilities); 567 wiphy->extended_capabilities_len = ARRAY_SIZE(extended_capabilities);
568 568
569 if (ops->remain_on_channel) 569 if (ops->remain_on_channel)
570 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 570 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
571 571
572 wiphy->features |= NL80211_FEATURE_SK_TX_STATUS | 572 wiphy->features |= NL80211_FEATURE_SK_TX_STATUS |
573 NL80211_FEATURE_SAE | 573 NL80211_FEATURE_SAE |
574 NL80211_FEATURE_HT_IBSS | 574 NL80211_FEATURE_HT_IBSS |
575 NL80211_FEATURE_VIF_TXPOWER; 575 NL80211_FEATURE_VIF_TXPOWER;
576 576
577 if (!ops->hw_scan) 577 if (!ops->hw_scan)
578 wiphy->features |= NL80211_FEATURE_LOW_PRIORITY_SCAN | 578 wiphy->features |= NL80211_FEATURE_LOW_PRIORITY_SCAN |
579 NL80211_FEATURE_AP_SCAN; 579 NL80211_FEATURE_AP_SCAN;
580 580
581 581
582 if (!ops->set_key) 582 if (!ops->set_key)
583 wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 583 wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
584 584
585 wiphy->bss_priv_size = sizeof(struct ieee80211_bss); 585 wiphy->bss_priv_size = sizeof(struct ieee80211_bss);
586 586
587 local = wiphy_priv(wiphy); 587 local = wiphy_priv(wiphy);
588 588
589 local->hw.wiphy = wiphy; 589 local->hw.wiphy = wiphy;
590 590
591 local->hw.priv = (char *)local + ALIGN(sizeof(*local), NETDEV_ALIGN); 591 local->hw.priv = (char *)local + ALIGN(sizeof(*local), NETDEV_ALIGN);
592 592
593 local->ops = ops; 593 local->ops = ops;
594 local->use_chanctx = use_chanctx; 594 local->use_chanctx = use_chanctx;
595 595
596 /* set up some defaults */ 596 /* set up some defaults */
597 local->hw.queues = 1; 597 local->hw.queues = 1;
598 local->hw.max_rates = 1; 598 local->hw.max_rates = 1;
599 local->hw.max_report_rates = 0; 599 local->hw.max_report_rates = 0;
600 local->hw.max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF; 600 local->hw.max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF;
601 local->hw.max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF; 601 local->hw.max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF;
602 local->hw.offchannel_tx_hw_queue = IEEE80211_INVAL_HW_QUEUE; 602 local->hw.offchannel_tx_hw_queue = IEEE80211_INVAL_HW_QUEUE;
603 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long; 603 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
604 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short; 604 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
605 local->hw.radiotap_mcs_details = IEEE80211_RADIOTAP_MCS_HAVE_MCS | 605 local->hw.radiotap_mcs_details = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
606 IEEE80211_RADIOTAP_MCS_HAVE_GI | 606 IEEE80211_RADIOTAP_MCS_HAVE_GI |
607 IEEE80211_RADIOTAP_MCS_HAVE_BW; 607 IEEE80211_RADIOTAP_MCS_HAVE_BW;
608 local->hw.radiotap_vht_details = IEEE80211_RADIOTAP_VHT_KNOWN_GI | 608 local->hw.radiotap_vht_details = IEEE80211_RADIOTAP_VHT_KNOWN_GI |
609 IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH; 609 IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH;
610 local->user_power_level = IEEE80211_UNSET_POWER_LEVEL; 610 local->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
611 wiphy->ht_capa_mod_mask = &mac80211_ht_capa_mod_mask; 611 wiphy->ht_capa_mod_mask = &mac80211_ht_capa_mod_mask;
612 612
613 INIT_LIST_HEAD(&local->interfaces); 613 INIT_LIST_HEAD(&local->interfaces);
614 614
615 __hw_addr_init(&local->mc_list); 615 __hw_addr_init(&local->mc_list);
616 616
617 mutex_init(&local->iflist_mtx); 617 mutex_init(&local->iflist_mtx);
618 mutex_init(&local->mtx); 618 mutex_init(&local->mtx);
619 619
620 mutex_init(&local->key_mtx); 620 mutex_init(&local->key_mtx);
621 spin_lock_init(&local->filter_lock); 621 spin_lock_init(&local->filter_lock);
622 spin_lock_init(&local->rx_path_lock); 622 spin_lock_init(&local->rx_path_lock);
623 spin_lock_init(&local->queue_stop_reason_lock); 623 spin_lock_init(&local->queue_stop_reason_lock);
624 624
625 INIT_LIST_HEAD(&local->chanctx_list); 625 INIT_LIST_HEAD(&local->chanctx_list);
626 mutex_init(&local->chanctx_mtx); 626 mutex_init(&local->chanctx_mtx);
627 627
628 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work); 628 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
629 629
630 INIT_WORK(&local->restart_work, ieee80211_restart_work); 630 INIT_WORK(&local->restart_work, ieee80211_restart_work);
631 631
632 INIT_WORK(&local->radar_detected_work, 632 INIT_WORK(&local->radar_detected_work,
633 ieee80211_dfs_radar_detected_work); 633 ieee80211_dfs_radar_detected_work);
634 634
635 INIT_WORK(&local->reconfig_filter, ieee80211_reconfig_filter); 635 INIT_WORK(&local->reconfig_filter, ieee80211_reconfig_filter);
636 local->smps_mode = IEEE80211_SMPS_OFF; 636 local->smps_mode = IEEE80211_SMPS_OFF;
637 637
638 INIT_WORK(&local->dynamic_ps_enable_work, 638 INIT_WORK(&local->dynamic_ps_enable_work,
639 ieee80211_dynamic_ps_enable_work); 639 ieee80211_dynamic_ps_enable_work);
640 INIT_WORK(&local->dynamic_ps_disable_work, 640 INIT_WORK(&local->dynamic_ps_disable_work,
641 ieee80211_dynamic_ps_disable_work); 641 ieee80211_dynamic_ps_disable_work);
642 setup_timer(&local->dynamic_ps_timer, 642 setup_timer(&local->dynamic_ps_timer,
643 ieee80211_dynamic_ps_timer, (unsigned long) local); 643 ieee80211_dynamic_ps_timer, (unsigned long) local);
644 644
645 INIT_WORK(&local->sched_scan_stopped_work, 645 INIT_WORK(&local->sched_scan_stopped_work,
646 ieee80211_sched_scan_stopped_work); 646 ieee80211_sched_scan_stopped_work);
647 647
648 spin_lock_init(&local->ack_status_lock); 648 spin_lock_init(&local->ack_status_lock);
649 idr_init(&local->ack_status_frames); 649 idr_init(&local->ack_status_frames);
650 /* preallocate at least one entry */
651 idr_pre_get(&local->ack_status_frames, GFP_KERNEL);
652 650
653 sta_info_init(local); 651 sta_info_init(local);
654 652
655 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) { 653 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
656 skb_queue_head_init(&local->pending[i]); 654 skb_queue_head_init(&local->pending[i]);
657 atomic_set(&local->agg_queue_stop[i], 0); 655 atomic_set(&local->agg_queue_stop[i], 0);
658 } 656 }
659 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending, 657 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending,
660 (unsigned long)local); 658 (unsigned long)local);
661 659
662 tasklet_init(&local->tasklet, 660 tasklet_init(&local->tasklet,
663 ieee80211_tasklet_handler, 661 ieee80211_tasklet_handler,
664 (unsigned long) local); 662 (unsigned long) local);
665 663
666 skb_queue_head_init(&local->skb_queue); 664 skb_queue_head_init(&local->skb_queue);
667 skb_queue_head_init(&local->skb_queue_unreliable); 665 skb_queue_head_init(&local->skb_queue_unreliable);
668 666
669 /* init dummy netdev for use w/ NAPI */ 667 /* init dummy netdev for use w/ NAPI */
670 init_dummy_netdev(&local->napi_dev); 668 init_dummy_netdev(&local->napi_dev);
671 669
672 ieee80211_led_names(local); 670 ieee80211_led_names(local);
673 671
674 ieee80211_roc_setup(local); 672 ieee80211_roc_setup(local);
675 673
676 return &local->hw; 674 return &local->hw;
677 } 675 }
678 EXPORT_SYMBOL(ieee80211_alloc_hw); 676 EXPORT_SYMBOL(ieee80211_alloc_hw);
679 677
680 int ieee80211_register_hw(struct ieee80211_hw *hw) 678 int ieee80211_register_hw(struct ieee80211_hw *hw)
681 { 679 {
682 struct ieee80211_local *local = hw_to_local(hw); 680 struct ieee80211_local *local = hw_to_local(hw);
683 int result, i; 681 int result, i;
684 enum ieee80211_band band; 682 enum ieee80211_band band;
685 int channels, max_bitrates; 683 int channels, max_bitrates;
686 bool supp_ht, supp_vht; 684 bool supp_ht, supp_vht;
687 netdev_features_t feature_whitelist; 685 netdev_features_t feature_whitelist;
688 static const u32 cipher_suites[] = { 686 static const u32 cipher_suites[] = {
689 /* keep WEP first, it may be removed below */ 687 /* keep WEP first, it may be removed below */
690 WLAN_CIPHER_SUITE_WEP40, 688 WLAN_CIPHER_SUITE_WEP40,
691 WLAN_CIPHER_SUITE_WEP104, 689 WLAN_CIPHER_SUITE_WEP104,
692 WLAN_CIPHER_SUITE_TKIP, 690 WLAN_CIPHER_SUITE_TKIP,
693 WLAN_CIPHER_SUITE_CCMP, 691 WLAN_CIPHER_SUITE_CCMP,
694 692
695 /* keep last -- depends on hw flags! */ 693 /* keep last -- depends on hw flags! */
696 WLAN_CIPHER_SUITE_AES_CMAC 694 WLAN_CIPHER_SUITE_AES_CMAC
697 }; 695 };
698 696
699 if (hw->flags & IEEE80211_HW_QUEUE_CONTROL && 697 if (hw->flags & IEEE80211_HW_QUEUE_CONTROL &&
700 (local->hw.offchannel_tx_hw_queue == IEEE80211_INVAL_HW_QUEUE || 698 (local->hw.offchannel_tx_hw_queue == IEEE80211_INVAL_HW_QUEUE ||
701 local->hw.offchannel_tx_hw_queue >= local->hw.queues)) 699 local->hw.offchannel_tx_hw_queue >= local->hw.queues))
702 return -EINVAL; 700 return -EINVAL;
703 701
704 #ifdef CONFIG_PM 702 #ifdef CONFIG_PM
705 if ((hw->wiphy->wowlan.flags || hw->wiphy->wowlan.n_patterns) && 703 if ((hw->wiphy->wowlan.flags || hw->wiphy->wowlan.n_patterns) &&
706 (!local->ops->suspend || !local->ops->resume)) 704 (!local->ops->suspend || !local->ops->resume))
707 return -EINVAL; 705 return -EINVAL;
708 #endif 706 #endif
709 707
710 if (!local->use_chanctx) { 708 if (!local->use_chanctx) {
711 for (i = 0; i < local->hw.wiphy->n_iface_combinations; i++) { 709 for (i = 0; i < local->hw.wiphy->n_iface_combinations; i++) {
712 const struct ieee80211_iface_combination *comb; 710 const struct ieee80211_iface_combination *comb;
713 711
714 comb = &local->hw.wiphy->iface_combinations[i]; 712 comb = &local->hw.wiphy->iface_combinations[i];
715 713
716 if (comb->num_different_channels > 1) 714 if (comb->num_different_channels > 1)
717 return -EINVAL; 715 return -EINVAL;
718 } 716 }
719 } else { 717 } else {
720 /* 718 /*
721 * WDS is currently prohibited when channel contexts are used 719 * WDS is currently prohibited when channel contexts are used
722 * because there's no clear definition of which channel WDS 720 * because there's no clear definition of which channel WDS
723 * type interfaces use 721 * type interfaces use
724 */ 722 */
725 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS)) 723 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS))
726 return -EINVAL; 724 return -EINVAL;
727 725
728 /* DFS currently not supported with channel context drivers */ 726 /* DFS currently not supported with channel context drivers */
729 for (i = 0; i < local->hw.wiphy->n_iface_combinations; i++) { 727 for (i = 0; i < local->hw.wiphy->n_iface_combinations; i++) {
730 const struct ieee80211_iface_combination *comb; 728 const struct ieee80211_iface_combination *comb;
731 729
732 comb = &local->hw.wiphy->iface_combinations[i]; 730 comb = &local->hw.wiphy->iface_combinations[i];
733 731
734 if (comb->radar_detect_widths) 732 if (comb->radar_detect_widths)
735 return -EINVAL; 733 return -EINVAL;
736 } 734 }
737 } 735 }
738 736
739 /* Only HW csum features are currently compatible with mac80211 */ 737 /* Only HW csum features are currently compatible with mac80211 */
740 feature_whitelist = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 738 feature_whitelist = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
741 NETIF_F_HW_CSUM; 739 NETIF_F_HW_CSUM;
742 if (WARN_ON(hw->netdev_features & ~feature_whitelist)) 740 if (WARN_ON(hw->netdev_features & ~feature_whitelist))
743 return -EINVAL; 741 return -EINVAL;
744 742
745 if (hw->max_report_rates == 0) 743 if (hw->max_report_rates == 0)
746 hw->max_report_rates = hw->max_rates; 744 hw->max_report_rates = hw->max_rates;
747 745
748 local->rx_chains = 1; 746 local->rx_chains = 1;
749 747
750 /* 748 /*
751 * generic code guarantees at least one band, 749 * generic code guarantees at least one band,
752 * set this very early because much code assumes 750 * set this very early because much code assumes
753 * that hw.conf.channel is assigned 751 * that hw.conf.channel is assigned
754 */ 752 */
755 channels = 0; 753 channels = 0;
756 max_bitrates = 0; 754 max_bitrates = 0;
757 supp_ht = false; 755 supp_ht = false;
758 supp_vht = false; 756 supp_vht = false;
759 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 757 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
760 struct ieee80211_supported_band *sband; 758 struct ieee80211_supported_band *sband;
761 759
762 sband = local->hw.wiphy->bands[band]; 760 sband = local->hw.wiphy->bands[band];
763 if (!sband) 761 if (!sband)
764 continue; 762 continue;
765 if (!local->use_chanctx && !local->_oper_channel) { 763 if (!local->use_chanctx && !local->_oper_channel) {
766 /* init channel we're on */ 764 /* init channel we're on */
767 local->hw.conf.channel = 765 local->hw.conf.channel =
768 local->_oper_channel = &sband->channels[0]; 766 local->_oper_channel = &sband->channels[0];
769 local->hw.conf.channel_type = NL80211_CHAN_NO_HT; 767 local->hw.conf.channel_type = NL80211_CHAN_NO_HT;
770 } 768 }
771 cfg80211_chandef_create(&local->monitor_chandef, 769 cfg80211_chandef_create(&local->monitor_chandef,
772 &sband->channels[0], 770 &sband->channels[0],
773 NL80211_CHAN_NO_HT); 771 NL80211_CHAN_NO_HT);
774 channels += sband->n_channels; 772 channels += sband->n_channels;
775 773
776 if (max_bitrates < sband->n_bitrates) 774 if (max_bitrates < sband->n_bitrates)
777 max_bitrates = sband->n_bitrates; 775 max_bitrates = sband->n_bitrates;
778 supp_ht = supp_ht || sband->ht_cap.ht_supported; 776 supp_ht = supp_ht || sband->ht_cap.ht_supported;
779 supp_vht = supp_vht || sband->vht_cap.vht_supported; 777 supp_vht = supp_vht || sband->vht_cap.vht_supported;
780 778
781 if (sband->ht_cap.ht_supported) 779 if (sband->ht_cap.ht_supported)
782 local->rx_chains = 780 local->rx_chains =
783 max(ieee80211_mcs_to_chains(&sband->ht_cap.mcs), 781 max(ieee80211_mcs_to_chains(&sband->ht_cap.mcs),
784 local->rx_chains); 782 local->rx_chains);
785 783
786 /* TODO: consider VHT for RX chains, hopefully it's the same */ 784 /* TODO: consider VHT for RX chains, hopefully it's the same */
787 } 785 }
788 786
789 local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) + 787 local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) +
790 sizeof(void *) * channels, GFP_KERNEL); 788 sizeof(void *) * channels, GFP_KERNEL);
791 if (!local->int_scan_req) 789 if (!local->int_scan_req)
792 return -ENOMEM; 790 return -ENOMEM;
793 791
794 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 792 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
795 if (!local->hw.wiphy->bands[band]) 793 if (!local->hw.wiphy->bands[band])
796 continue; 794 continue;
797 local->int_scan_req->rates[band] = (u32) -1; 795 local->int_scan_req->rates[band] = (u32) -1;
798 } 796 }
799 797
800 /* if low-level driver supports AP, we also support VLAN */ 798 /* if low-level driver supports AP, we also support VLAN */
801 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) { 799 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
802 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN); 800 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
803 hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN); 801 hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN);
804 } 802 }
805 803
806 /* mac80211 always supports monitor */ 804 /* mac80211 always supports monitor */
807 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR); 805 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
808 hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR); 806 hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR);
809 807
810 /* mac80211 doesn't support more than one IBSS interface right now */ 808 /* mac80211 doesn't support more than one IBSS interface right now */
811 for (i = 0; i < hw->wiphy->n_iface_combinations; i++) { 809 for (i = 0; i < hw->wiphy->n_iface_combinations; i++) {
812 const struct ieee80211_iface_combination *c; 810 const struct ieee80211_iface_combination *c;
813 int j; 811 int j;
814 812
815 c = &hw->wiphy->iface_combinations[i]; 813 c = &hw->wiphy->iface_combinations[i];
816 814
817 for (j = 0; j < c->n_limits; j++) 815 for (j = 0; j < c->n_limits; j++)
818 if ((c->limits[j].types & BIT(NL80211_IFTYPE_ADHOC)) && 816 if ((c->limits[j].types & BIT(NL80211_IFTYPE_ADHOC)) &&
819 c->limits[j].max > 1) 817 c->limits[j].max > 1)
820 return -EINVAL; 818 return -EINVAL;
821 } 819 }
822 820
823 #ifndef CONFIG_MAC80211_MESH 821 #ifndef CONFIG_MAC80211_MESH
824 /* mesh depends on Kconfig, but drivers should set it if they want */ 822 /* mesh depends on Kconfig, but drivers should set it if they want */
825 local->hw.wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MESH_POINT); 823 local->hw.wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MESH_POINT);
826 #endif 824 #endif
827 825
828 /* if the underlying driver supports mesh, mac80211 will (at least) 826 /* if the underlying driver supports mesh, mac80211 will (at least)
829 * provide routing of mesh authentication frames to userspace */ 827 * provide routing of mesh authentication frames to userspace */
830 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_MESH_POINT)) 828 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_MESH_POINT))
831 local->hw.wiphy->flags |= WIPHY_FLAG_MESH_AUTH; 829 local->hw.wiphy->flags |= WIPHY_FLAG_MESH_AUTH;
832 830
833 /* mac80211 supports control port protocol changing */ 831 /* mac80211 supports control port protocol changing */
834 local->hw.wiphy->flags |= WIPHY_FLAG_CONTROL_PORT_PROTOCOL; 832 local->hw.wiphy->flags |= WIPHY_FLAG_CONTROL_PORT_PROTOCOL;
835 833
836 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) 834 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
837 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 835 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
838 else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC) 836 else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
839 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC; 837 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
840 838
841 WARN((local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD) 839 WARN((local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD)
842 && (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK), 840 && (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK),
843 "U-APSD not supported with HW_PS_NULLFUNC_STACK\n"); 841 "U-APSD not supported with HW_PS_NULLFUNC_STACK\n");
844 842
845 /* 843 /*
846 * Calculate scan IE length -- we need this to alloc 844 * Calculate scan IE length -- we need this to alloc
847 * memory and to subtract from the driver limit. It 845 * memory and to subtract from the driver limit. It
848 * includes the DS Params, (extended) supported rates, and HT 846 * includes the DS Params, (extended) supported rates, and HT
849 * information -- SSID is the driver's responsibility. 847 * information -- SSID is the driver's responsibility.
850 */ 848 */
851 local->scan_ies_len = 4 + max_bitrates /* (ext) supp rates */ + 849 local->scan_ies_len = 4 + max_bitrates /* (ext) supp rates */ +
852 3 /* DS Params */; 850 3 /* DS Params */;
853 if (supp_ht) 851 if (supp_ht)
854 local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap); 852 local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap);
855 853
856 if (supp_vht) { 854 if (supp_vht) {
857 local->scan_ies_len += 855 local->scan_ies_len +=
858 2 + sizeof(struct ieee80211_vht_cap); 856 2 + sizeof(struct ieee80211_vht_cap);
859 857
860 /* 858 /*
861 * (for now at least), drivers wanting to use VHT must 859 * (for now at least), drivers wanting to use VHT must
862 * support channel contexts, as they contain all the 860 * support channel contexts, as they contain all the
863 * necessary VHT information and the global hw config 861 * necessary VHT information and the global hw config
864 * doesn't (yet) 862 * doesn't (yet)
865 */ 863 */
866 if (WARN_ON(!local->use_chanctx)) { 864 if (WARN_ON(!local->use_chanctx)) {
867 result = -EINVAL; 865 result = -EINVAL;
868 goto fail_wiphy_register; 866 goto fail_wiphy_register;
869 } 867 }
870 } 868 }
871 869
872 if (!local->ops->hw_scan) { 870 if (!local->ops->hw_scan) {
873 /* For hw_scan, driver needs to set these up. */ 871 /* For hw_scan, driver needs to set these up. */
874 local->hw.wiphy->max_scan_ssids = 4; 872 local->hw.wiphy->max_scan_ssids = 4;
875 local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN; 873 local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
876 } 874 }
877 875
878 /* 876 /*
879 * If the driver supports any scan IEs, then assume the 877 * If the driver supports any scan IEs, then assume the
880 * limit includes the IEs mac80211 will add, otherwise 878 * limit includes the IEs mac80211 will add, otherwise
881 * leave it at zero and let the driver sort it out; we 879 * leave it at zero and let the driver sort it out; we
882 * still pass our IEs to the driver but userspace will 880 * still pass our IEs to the driver but userspace will
883 * not be allowed to in that case. 881 * not be allowed to in that case.
884 */ 882 */
885 if (local->hw.wiphy->max_scan_ie_len) 883 if (local->hw.wiphy->max_scan_ie_len)
886 local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len; 884 local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len;
887 885
888 /* Set up cipher suites unless driver already did */ 886 /* Set up cipher suites unless driver already did */
889 if (!local->hw.wiphy->cipher_suites) { 887 if (!local->hw.wiphy->cipher_suites) {
890 local->hw.wiphy->cipher_suites = cipher_suites; 888 local->hw.wiphy->cipher_suites = cipher_suites;
891 local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 889 local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
892 if (!(local->hw.flags & IEEE80211_HW_MFP_CAPABLE)) 890 if (!(local->hw.flags & IEEE80211_HW_MFP_CAPABLE))
893 local->hw.wiphy->n_cipher_suites--; 891 local->hw.wiphy->n_cipher_suites--;
894 } 892 }
895 if (IS_ERR(local->wep_tx_tfm) || IS_ERR(local->wep_rx_tfm)) { 893 if (IS_ERR(local->wep_tx_tfm) || IS_ERR(local->wep_rx_tfm)) {
896 if (local->hw.wiphy->cipher_suites == cipher_suites) { 894 if (local->hw.wiphy->cipher_suites == cipher_suites) {
897 local->hw.wiphy->cipher_suites += 2; 895 local->hw.wiphy->cipher_suites += 2;
898 local->hw.wiphy->n_cipher_suites -= 2; 896 local->hw.wiphy->n_cipher_suites -= 2;
899 } else { 897 } else {
900 u32 *suites; 898 u32 *suites;
901 int r, w = 0; 899 int r, w = 0;
902 900
903 /* Filter out WEP */ 901 /* Filter out WEP */
904 902
905 suites = kmemdup( 903 suites = kmemdup(
906 local->hw.wiphy->cipher_suites, 904 local->hw.wiphy->cipher_suites,
907 sizeof(u32) * local->hw.wiphy->n_cipher_suites, 905 sizeof(u32) * local->hw.wiphy->n_cipher_suites,
908 GFP_KERNEL); 906 GFP_KERNEL);
909 if (!suites) { 907 if (!suites) {
910 result = -ENOMEM; 908 result = -ENOMEM;
911 goto fail_wiphy_register; 909 goto fail_wiphy_register;
912 } 910 }
913 for (r = 0; r < local->hw.wiphy->n_cipher_suites; r++) { 911 for (r = 0; r < local->hw.wiphy->n_cipher_suites; r++) {
914 u32 suite = local->hw.wiphy->cipher_suites[r]; 912 u32 suite = local->hw.wiphy->cipher_suites[r];
915 if (suite == WLAN_CIPHER_SUITE_WEP40 || 913 if (suite == WLAN_CIPHER_SUITE_WEP40 ||
916 suite == WLAN_CIPHER_SUITE_WEP104) 914 suite == WLAN_CIPHER_SUITE_WEP104)
917 continue; 915 continue;
918 suites[w++] = suite; 916 suites[w++] = suite;
919 } 917 }
920 local->hw.wiphy->cipher_suites = suites; 918 local->hw.wiphy->cipher_suites = suites;
921 local->hw.wiphy->n_cipher_suites = w; 919 local->hw.wiphy->n_cipher_suites = w;
922 local->wiphy_ciphers_allocated = true; 920 local->wiphy_ciphers_allocated = true;
923 } 921 }
924 } 922 }
925 923
926 if (!local->ops->remain_on_channel) 924 if (!local->ops->remain_on_channel)
927 local->hw.wiphy->max_remain_on_channel_duration = 5000; 925 local->hw.wiphy->max_remain_on_channel_duration = 5000;
928 926
929 if (local->ops->sched_scan_start) 927 if (local->ops->sched_scan_start)
930 local->hw.wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN; 928 local->hw.wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
931 929
932 /* mac80211 based drivers don't support internal TDLS setup */ 930 /* mac80211 based drivers don't support internal TDLS setup */
933 if (local->hw.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) 931 if (local->hw.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS)
934 local->hw.wiphy->flags |= WIPHY_FLAG_TDLS_EXTERNAL_SETUP; 932 local->hw.wiphy->flags |= WIPHY_FLAG_TDLS_EXTERNAL_SETUP;
935 933
936 result = wiphy_register(local->hw.wiphy); 934 result = wiphy_register(local->hw.wiphy);
937 if (result < 0) 935 if (result < 0)
938 goto fail_wiphy_register; 936 goto fail_wiphy_register;
939 937
940 /* 938 /*
941 * We use the number of queues for feature tests (QoS, HT) internally 939 * We use the number of queues for feature tests (QoS, HT) internally
942 * so restrict them appropriately. 940 * so restrict them appropriately.
943 */ 941 */
944 if (hw->queues > IEEE80211_MAX_QUEUES) 942 if (hw->queues > IEEE80211_MAX_QUEUES)
945 hw->queues = IEEE80211_MAX_QUEUES; 943 hw->queues = IEEE80211_MAX_QUEUES;
946 944
947 local->workqueue = 945 local->workqueue =
948 alloc_ordered_workqueue(wiphy_name(local->hw.wiphy), 0); 946 alloc_ordered_workqueue(wiphy_name(local->hw.wiphy), 0);
949 if (!local->workqueue) { 947 if (!local->workqueue) {
950 result = -ENOMEM; 948 result = -ENOMEM;
951 goto fail_workqueue; 949 goto fail_workqueue;
952 } 950 }
953 951
954 /* 952 /*
955 * The hardware needs headroom for sending the frame, 953 * The hardware needs headroom for sending the frame,
956 * and we need some headroom for passing the frame to monitor 954 * and we need some headroom for passing the frame to monitor
957 * interfaces, but never both at the same time. 955 * interfaces, but never both at the same time.
958 */ 956 */
959 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom, 957 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
960 IEEE80211_TX_STATUS_HEADROOM); 958 IEEE80211_TX_STATUS_HEADROOM);
961 959
962 debugfs_hw_add(local); 960 debugfs_hw_add(local);
963 961
964 /* 962 /*
965 * if the driver doesn't specify a max listen interval we 963 * if the driver doesn't specify a max listen interval we
966 * use 5 which should be a safe default 964 * use 5 which should be a safe default
967 */ 965 */
968 if (local->hw.max_listen_interval == 0) 966 if (local->hw.max_listen_interval == 0)
969 local->hw.max_listen_interval = 5; 967 local->hw.max_listen_interval = 5;
970 968
971 local->hw.conf.listen_interval = local->hw.max_listen_interval; 969 local->hw.conf.listen_interval = local->hw.max_listen_interval;
972 970
973 local->dynamic_ps_forced_timeout = -1; 971 local->dynamic_ps_forced_timeout = -1;
974 972
975 result = ieee80211_wep_init(local); 973 result = ieee80211_wep_init(local);
976 if (result < 0) 974 if (result < 0)
977 wiphy_debug(local->hw.wiphy, "Failed to initialize wep: %d\n", 975 wiphy_debug(local->hw.wiphy, "Failed to initialize wep: %d\n",
978 result); 976 result);
979 977
980 ieee80211_led_init(local); 978 ieee80211_led_init(local);
981 979
982 rtnl_lock(); 980 rtnl_lock();
983 981
984 result = ieee80211_init_rate_ctrl_alg(local, 982 result = ieee80211_init_rate_ctrl_alg(local,
985 hw->rate_control_algorithm); 983 hw->rate_control_algorithm);
986 if (result < 0) { 984 if (result < 0) {
987 wiphy_debug(local->hw.wiphy, 985 wiphy_debug(local->hw.wiphy,
988 "Failed to initialize rate control algorithm\n"); 986 "Failed to initialize rate control algorithm\n");
989 goto fail_rate; 987 goto fail_rate;
990 } 988 }
991 989
992 /* add one default STA interface if supported */ 990 /* add one default STA interface if supported */
993 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) { 991 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) {
994 result = ieee80211_if_add(local, "wlan%d", NULL, 992 result = ieee80211_if_add(local, "wlan%d", NULL,
995 NL80211_IFTYPE_STATION, NULL); 993 NL80211_IFTYPE_STATION, NULL);
996 if (result) 994 if (result)
997 wiphy_warn(local->hw.wiphy, 995 wiphy_warn(local->hw.wiphy,
998 "Failed to add default virtual iface\n"); 996 "Failed to add default virtual iface\n");
999 } 997 }
1000 998
1001 rtnl_unlock(); 999 rtnl_unlock();
1002 1000
1003 local->network_latency_notifier.notifier_call = 1001 local->network_latency_notifier.notifier_call =
1004 ieee80211_max_network_latency; 1002 ieee80211_max_network_latency;
1005 result = pm_qos_add_notifier(PM_QOS_NETWORK_LATENCY, 1003 result = pm_qos_add_notifier(PM_QOS_NETWORK_LATENCY,
1006 &local->network_latency_notifier); 1004 &local->network_latency_notifier);
1007 if (result) { 1005 if (result) {
1008 rtnl_lock(); 1006 rtnl_lock();
1009 goto fail_pm_qos; 1007 goto fail_pm_qos;
1010 } 1008 }
1011 1009
1012 #ifdef CONFIG_INET 1010 #ifdef CONFIG_INET
1013 local->ifa_notifier.notifier_call = ieee80211_ifa_changed; 1011 local->ifa_notifier.notifier_call = ieee80211_ifa_changed;
1014 result = register_inetaddr_notifier(&local->ifa_notifier); 1012 result = register_inetaddr_notifier(&local->ifa_notifier);
1015 if (result) 1013 if (result)
1016 goto fail_ifa; 1014 goto fail_ifa;
1017 #endif 1015 #endif
1018 1016
1019 #if IS_ENABLED(CONFIG_IPV6) 1017 #if IS_ENABLED(CONFIG_IPV6)
1020 local->ifa6_notifier.notifier_call = ieee80211_ifa6_changed; 1018 local->ifa6_notifier.notifier_call = ieee80211_ifa6_changed;
1021 result = register_inet6addr_notifier(&local->ifa6_notifier); 1019 result = register_inet6addr_notifier(&local->ifa6_notifier);
1022 if (result) 1020 if (result)
1023 goto fail_ifa6; 1021 goto fail_ifa6;
1024 #endif 1022 #endif
1025 1023
1026 netif_napi_add(&local->napi_dev, &local->napi, ieee80211_napi_poll, 1024 netif_napi_add(&local->napi_dev, &local->napi, ieee80211_napi_poll,
1027 local->hw.napi_weight); 1025 local->hw.napi_weight);
1028 1026
1029 return 0; 1027 return 0;
1030 1028
1031 #if IS_ENABLED(CONFIG_IPV6) 1029 #if IS_ENABLED(CONFIG_IPV6)
1032 fail_ifa6: 1030 fail_ifa6:
1033 #ifdef CONFIG_INET 1031 #ifdef CONFIG_INET
1034 unregister_inetaddr_notifier(&local->ifa_notifier); 1032 unregister_inetaddr_notifier(&local->ifa_notifier);
1035 #endif 1033 #endif
1036 #endif 1034 #endif
1037 #if defined(CONFIG_INET) || defined(CONFIG_IPV6) 1035 #if defined(CONFIG_INET) || defined(CONFIG_IPV6)
1038 fail_ifa: 1036 fail_ifa:
1039 pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY, 1037 pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY,
1040 &local->network_latency_notifier); 1038 &local->network_latency_notifier);
1041 rtnl_lock(); 1039 rtnl_lock();
1042 #endif 1040 #endif
1043 fail_pm_qos: 1041 fail_pm_qos:
1044 ieee80211_led_exit(local); 1042 ieee80211_led_exit(local);
1045 ieee80211_remove_interfaces(local); 1043 ieee80211_remove_interfaces(local);
1046 fail_rate: 1044 fail_rate:
1047 rtnl_unlock(); 1045 rtnl_unlock();
1048 ieee80211_wep_free(local); 1046 ieee80211_wep_free(local);
1049 sta_info_stop(local); 1047 sta_info_stop(local);
1050 destroy_workqueue(local->workqueue); 1048 destroy_workqueue(local->workqueue);
1051 fail_workqueue: 1049 fail_workqueue:
1052 wiphy_unregister(local->hw.wiphy); 1050 wiphy_unregister(local->hw.wiphy);
1053 fail_wiphy_register: 1051 fail_wiphy_register:
1054 if (local->wiphy_ciphers_allocated) 1052 if (local->wiphy_ciphers_allocated)
1055 kfree(local->hw.wiphy->cipher_suites); 1053 kfree(local->hw.wiphy->cipher_suites);
1056 kfree(local->int_scan_req); 1054 kfree(local->int_scan_req);
1057 return result; 1055 return result;
1058 } 1056 }
1059 EXPORT_SYMBOL(ieee80211_register_hw); 1057 EXPORT_SYMBOL(ieee80211_register_hw);
1060 1058
1061 void ieee80211_unregister_hw(struct ieee80211_hw *hw) 1059 void ieee80211_unregister_hw(struct ieee80211_hw *hw)
1062 { 1060 {
1063 struct ieee80211_local *local = hw_to_local(hw); 1061 struct ieee80211_local *local = hw_to_local(hw);
1064 1062
1065 tasklet_kill(&local->tx_pending_tasklet); 1063 tasklet_kill(&local->tx_pending_tasklet);
1066 tasklet_kill(&local->tasklet); 1064 tasklet_kill(&local->tasklet);
1067 1065
1068 pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY, 1066 pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY,
1069 &local->network_latency_notifier); 1067 &local->network_latency_notifier);
1070 #ifdef CONFIG_INET 1068 #ifdef CONFIG_INET
1071 unregister_inetaddr_notifier(&local->ifa_notifier); 1069 unregister_inetaddr_notifier(&local->ifa_notifier);
1072 #endif 1070 #endif
1073 #if IS_ENABLED(CONFIG_IPV6) 1071 #if IS_ENABLED(CONFIG_IPV6)
1074 unregister_inet6addr_notifier(&local->ifa6_notifier); 1072 unregister_inet6addr_notifier(&local->ifa6_notifier);
1075 #endif 1073 #endif
1076 1074
1077 rtnl_lock(); 1075 rtnl_lock();
1078 1076
1079 /* 1077 /*
1080 * At this point, interface list manipulations are fine 1078 * At this point, interface list manipulations are fine
1081 * because the driver cannot be handing us frames any 1079 * because the driver cannot be handing us frames any
1082 * more and the tasklet is killed. 1080 * more and the tasklet is killed.
1083 */ 1081 */
1084 ieee80211_remove_interfaces(local); 1082 ieee80211_remove_interfaces(local);
1085 1083
1086 rtnl_unlock(); 1084 rtnl_unlock();
1087 1085
1088 cancel_work_sync(&local->restart_work); 1086 cancel_work_sync(&local->restart_work);
1089 cancel_work_sync(&local->reconfig_filter); 1087 cancel_work_sync(&local->reconfig_filter);
1090 1088
1091 ieee80211_clear_tx_pending(local); 1089 ieee80211_clear_tx_pending(local);
1092 rate_control_deinitialize(local); 1090 rate_control_deinitialize(local);
1093 1091
1094 if (skb_queue_len(&local->skb_queue) || 1092 if (skb_queue_len(&local->skb_queue) ||
1095 skb_queue_len(&local->skb_queue_unreliable)) 1093 skb_queue_len(&local->skb_queue_unreliable))
1096 wiphy_warn(local->hw.wiphy, "skb_queue not empty\n"); 1094 wiphy_warn(local->hw.wiphy, "skb_queue not empty\n");
1097 skb_queue_purge(&local->skb_queue); 1095 skb_queue_purge(&local->skb_queue);
1098 skb_queue_purge(&local->skb_queue_unreliable); 1096 skb_queue_purge(&local->skb_queue_unreliable);
1099 1097
1100 destroy_workqueue(local->workqueue); 1098 destroy_workqueue(local->workqueue);
1101 wiphy_unregister(local->hw.wiphy); 1099 wiphy_unregister(local->hw.wiphy);
1102 sta_info_stop(local); 1100 sta_info_stop(local);
1103 ieee80211_wep_free(local); 1101 ieee80211_wep_free(local);
1104 ieee80211_led_exit(local); 1102 ieee80211_led_exit(local);
1105 kfree(local->int_scan_req); 1103 kfree(local->int_scan_req);
1106 } 1104 }
1107 EXPORT_SYMBOL(ieee80211_unregister_hw); 1105 EXPORT_SYMBOL(ieee80211_unregister_hw);
1108 1106
1109 static int ieee80211_free_ack_frame(int id, void *p, void *data) 1107 static int ieee80211_free_ack_frame(int id, void *p, void *data)
1110 { 1108 {
1111 WARN_ONCE(1, "Have pending ack frames!\n"); 1109 WARN_ONCE(1, "Have pending ack frames!\n");
1112 kfree_skb(p); 1110 kfree_skb(p);
1113 return 0; 1111 return 0;
1114 } 1112 }
1115 1113
1116 void ieee80211_free_hw(struct ieee80211_hw *hw) 1114 void ieee80211_free_hw(struct ieee80211_hw *hw)
1117 { 1115 {
1118 struct ieee80211_local *local = hw_to_local(hw); 1116 struct ieee80211_local *local = hw_to_local(hw);
1119 1117
1120 mutex_destroy(&local->iflist_mtx); 1118 mutex_destroy(&local->iflist_mtx);
1121 mutex_destroy(&local->mtx); 1119 mutex_destroy(&local->mtx);
1122 1120
1123 if (local->wiphy_ciphers_allocated) 1121 if (local->wiphy_ciphers_allocated)
1124 kfree(local->hw.wiphy->cipher_suites); 1122 kfree(local->hw.wiphy->cipher_suites);
1125 1123
1126 idr_for_each(&local->ack_status_frames, 1124 idr_for_each(&local->ack_status_frames,
1127 ieee80211_free_ack_frame, NULL); 1125 ieee80211_free_ack_frame, NULL);
1128 idr_destroy(&local->ack_status_frames); 1126 idr_destroy(&local->ack_status_frames);
1129 1127
1130 wiphy_free(local->hw.wiphy); 1128 wiphy_free(local->hw.wiphy);
1131 } 1129 }
1132 EXPORT_SYMBOL(ieee80211_free_hw); 1130 EXPORT_SYMBOL(ieee80211_free_hw);
1133 1131
1134 static int __init ieee80211_init(void) 1132 static int __init ieee80211_init(void)
1135 { 1133 {
1136 struct sk_buff *skb; 1134 struct sk_buff *skb;
1137 int ret; 1135 int ret;
1138 1136
1139 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb)); 1137 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
1140 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) + 1138 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
1141 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb)); 1139 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
1142 1140
1143 ret = rc80211_minstrel_init(); 1141 ret = rc80211_minstrel_init();
1144 if (ret) 1142 if (ret)
1145 return ret; 1143 return ret;
1146 1144
1147 ret = rc80211_minstrel_ht_init(); 1145 ret = rc80211_minstrel_ht_init();
1148 if (ret) 1146 if (ret)
1149 goto err_minstrel; 1147 goto err_minstrel;
1150 1148
1151 ret = rc80211_pid_init(); 1149 ret = rc80211_pid_init();
1152 if (ret) 1150 if (ret)
1153 goto err_pid; 1151 goto err_pid;
1154 1152
1155 ret = ieee80211_iface_init(); 1153 ret = ieee80211_iface_init();
1156 if (ret) 1154 if (ret)
1157 goto err_netdev; 1155 goto err_netdev;
1158 1156
1159 return 0; 1157 return 0;
1160 err_netdev: 1158 err_netdev:
1161 rc80211_pid_exit(); 1159 rc80211_pid_exit();
1162 err_pid: 1160 err_pid:
1163 rc80211_minstrel_ht_exit(); 1161 rc80211_minstrel_ht_exit();
1164 err_minstrel: 1162 err_minstrel:
1165 rc80211_minstrel_exit(); 1163 rc80211_minstrel_exit();
1166 1164
1167 return ret; 1165 return ret;
1168 } 1166 }
1169 1167
1170 static void __exit ieee80211_exit(void) 1168 static void __exit ieee80211_exit(void)
1171 { 1169 {
1172 rc80211_pid_exit(); 1170 rc80211_pid_exit();
1173 rc80211_minstrel_ht_exit(); 1171 rc80211_minstrel_ht_exit();
1174 rc80211_minstrel_exit(); 1172 rc80211_minstrel_exit();
1175 1173
1176 ieee80211s_stop(); 1174 ieee80211s_stop();
1177 1175
1178 ieee80211_iface_exit(); 1176 ieee80211_iface_exit();
1179 1177
1180 rcu_barrier(); 1178 rcu_barrier();
1181 } 1179 }
1182 1180
1183 1181
1184 subsys_initcall(ieee80211_init); 1182 subsys_initcall(ieee80211_init);
1185 module_exit(ieee80211_exit); 1183 module_exit(ieee80211_exit);
1186 1184
1187 MODULE_DESCRIPTION("IEEE 802.11 subsystem"); 1185 MODULE_DESCRIPTION("IEEE 802.11 subsystem");
1188 MODULE_LICENSE("GPL"); 1186 MODULE_LICENSE("GPL");
1189 1187
1 /* 1 /*
2 * Copyright 2002-2005, Instant802 Networks, Inc. 2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
5 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> 5 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
6 * 6 *
7 * This program is free software; you can redistribute it and/or modify 7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as 8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation. 9 * published by the Free Software Foundation.
10 * 10 *
11 * 11 *
12 * Transmit and frame generation functions. 12 * Transmit and frame generation functions.
13 */ 13 */
14 14
15 #include <linux/kernel.h> 15 #include <linux/kernel.h>
16 #include <linux/slab.h> 16 #include <linux/slab.h>
17 #include <linux/skbuff.h> 17 #include <linux/skbuff.h>
18 #include <linux/etherdevice.h> 18 #include <linux/etherdevice.h>
19 #include <linux/bitmap.h> 19 #include <linux/bitmap.h>
20 #include <linux/rcupdate.h> 20 #include <linux/rcupdate.h>
21 #include <linux/export.h> 21 #include <linux/export.h>
22 #include <net/net_namespace.h> 22 #include <net/net_namespace.h>
23 #include <net/ieee80211_radiotap.h> 23 #include <net/ieee80211_radiotap.h>
24 #include <net/cfg80211.h> 24 #include <net/cfg80211.h>
25 #include <net/mac80211.h> 25 #include <net/mac80211.h>
26 #include <asm/unaligned.h> 26 #include <asm/unaligned.h>
27 27
28 #include "ieee80211_i.h" 28 #include "ieee80211_i.h"
29 #include "driver-ops.h" 29 #include "driver-ops.h"
30 #include "led.h" 30 #include "led.h"
31 #include "mesh.h" 31 #include "mesh.h"
32 #include "wep.h" 32 #include "wep.h"
33 #include "wpa.h" 33 #include "wpa.h"
34 #include "wme.h" 34 #include "wme.h"
35 #include "rate.h" 35 #include "rate.h"
36 36
37 /* misc utils */ 37 /* misc utils */
38 38
39 static __le16 ieee80211_duration(struct ieee80211_tx_data *tx, 39 static __le16 ieee80211_duration(struct ieee80211_tx_data *tx,
40 struct sk_buff *skb, int group_addr, 40 struct sk_buff *skb, int group_addr,
41 int next_frag_len) 41 int next_frag_len)
42 { 42 {
43 int rate, mrate, erp, dur, i; 43 int rate, mrate, erp, dur, i;
44 struct ieee80211_rate *txrate; 44 struct ieee80211_rate *txrate;
45 struct ieee80211_local *local = tx->local; 45 struct ieee80211_local *local = tx->local;
46 struct ieee80211_supported_band *sband; 46 struct ieee80211_supported_band *sband;
47 struct ieee80211_hdr *hdr; 47 struct ieee80211_hdr *hdr;
48 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 48 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
49 49
50 /* assume HW handles this */ 50 /* assume HW handles this */
51 if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS) 51 if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
52 return 0; 52 return 0;
53 53
54 /* uh huh? */ 54 /* uh huh? */
55 if (WARN_ON_ONCE(info->control.rates[0].idx < 0)) 55 if (WARN_ON_ONCE(info->control.rates[0].idx < 0))
56 return 0; 56 return 0;
57 57
58 sband = local->hw.wiphy->bands[info->band]; 58 sband = local->hw.wiphy->bands[info->band];
59 txrate = &sband->bitrates[info->control.rates[0].idx]; 59 txrate = &sband->bitrates[info->control.rates[0].idx];
60 60
61 erp = txrate->flags & IEEE80211_RATE_ERP_G; 61 erp = txrate->flags & IEEE80211_RATE_ERP_G;
62 62
63 /* 63 /*
64 * data and mgmt (except PS Poll): 64 * data and mgmt (except PS Poll):
65 * - during CFP: 32768 65 * - during CFP: 32768
66 * - during contention period: 66 * - during contention period:
67 * if addr1 is group address: 0 67 * if addr1 is group address: 0
68 * if more fragments = 0 and addr1 is individual address: time to 68 * if more fragments = 0 and addr1 is individual address: time to
69 * transmit one ACK plus SIFS 69 * transmit one ACK plus SIFS
70 * if more fragments = 1 and addr1 is individual address: time to 70 * if more fragments = 1 and addr1 is individual address: time to
71 * transmit next fragment plus 2 x ACK plus 3 x SIFS 71 * transmit next fragment plus 2 x ACK plus 3 x SIFS
72 * 72 *
73 * IEEE 802.11, 9.6: 73 * IEEE 802.11, 9.6:
74 * - control response frame (CTS or ACK) shall be transmitted using the 74 * - control response frame (CTS or ACK) shall be transmitted using the
75 * same rate as the immediately previous frame in the frame exchange 75 * same rate as the immediately previous frame in the frame exchange
76 * sequence, if this rate belongs to the PHY mandatory rates, or else 76 * sequence, if this rate belongs to the PHY mandatory rates, or else
77 * at the highest possible rate belonging to the PHY rates in the 77 * at the highest possible rate belonging to the PHY rates in the
78 * BSSBasicRateSet 78 * BSSBasicRateSet
79 */ 79 */
80 hdr = (struct ieee80211_hdr *)skb->data; 80 hdr = (struct ieee80211_hdr *)skb->data;
81 if (ieee80211_is_ctl(hdr->frame_control)) { 81 if (ieee80211_is_ctl(hdr->frame_control)) {
82 /* TODO: These control frames are not currently sent by 82 /* TODO: These control frames are not currently sent by
83 * mac80211, but should they be implemented, this function 83 * mac80211, but should they be implemented, this function
84 * needs to be updated to support duration field calculation. 84 * needs to be updated to support duration field calculation.
85 * 85 *
86 * RTS: time needed to transmit pending data/mgmt frame plus 86 * RTS: time needed to transmit pending data/mgmt frame plus
87 * one CTS frame plus one ACK frame plus 3 x SIFS 87 * one CTS frame plus one ACK frame plus 3 x SIFS
88 * CTS: duration of immediately previous RTS minus time 88 * CTS: duration of immediately previous RTS minus time
89 * required to transmit CTS and its SIFS 89 * required to transmit CTS and its SIFS
90 * ACK: 0 if immediately previous directed data/mgmt had 90 * ACK: 0 if immediately previous directed data/mgmt had
91 * more=0, with more=1 duration in ACK frame is duration 91 * more=0, with more=1 duration in ACK frame is duration
92 * from previous frame minus time needed to transmit ACK 92 * from previous frame minus time needed to transmit ACK
93 * and its SIFS 93 * and its SIFS
94 * PS Poll: BIT(15) | BIT(14) | aid 94 * PS Poll: BIT(15) | BIT(14) | aid
95 */ 95 */
96 return 0; 96 return 0;
97 } 97 }
98 98
99 /* data/mgmt */ 99 /* data/mgmt */
100 if (0 /* FIX: data/mgmt during CFP */) 100 if (0 /* FIX: data/mgmt during CFP */)
101 return cpu_to_le16(32768); 101 return cpu_to_le16(32768);
102 102
103 if (group_addr) /* Group address as the destination - no ACK */ 103 if (group_addr) /* Group address as the destination - no ACK */
104 return 0; 104 return 0;
105 105
106 /* Individual destination address: 106 /* Individual destination address:
107 * IEEE 802.11, Ch. 9.6 (after IEEE 802.11g changes) 107 * IEEE 802.11, Ch. 9.6 (after IEEE 802.11g changes)
108 * CTS and ACK frames shall be transmitted using the highest rate in 108 * CTS and ACK frames shall be transmitted using the highest rate in
109 * basic rate set that is less than or equal to the rate of the 109 * basic rate set that is less than or equal to the rate of the
110 * immediately previous frame and that is using the same modulation 110 * immediately previous frame and that is using the same modulation
111 * (CCK or OFDM). If no basic rate set matches with these requirements, 111 * (CCK or OFDM). If no basic rate set matches with these requirements,
112 * the highest mandatory rate of the PHY that is less than or equal to 112 * the highest mandatory rate of the PHY that is less than or equal to
113 * the rate of the previous frame is used. 113 * the rate of the previous frame is used.
114 * Mandatory rates for IEEE 802.11g PHY: 1, 2, 5.5, 11, 6, 12, 24 Mbps 114 * Mandatory rates for IEEE 802.11g PHY: 1, 2, 5.5, 11, 6, 12, 24 Mbps
115 */ 115 */
116 rate = -1; 116 rate = -1;
117 /* use lowest available if everything fails */ 117 /* use lowest available if everything fails */
118 mrate = sband->bitrates[0].bitrate; 118 mrate = sband->bitrates[0].bitrate;
119 for (i = 0; i < sband->n_bitrates; i++) { 119 for (i = 0; i < sband->n_bitrates; i++) {
120 struct ieee80211_rate *r = &sband->bitrates[i]; 120 struct ieee80211_rate *r = &sband->bitrates[i];
121 121
122 if (r->bitrate > txrate->bitrate) 122 if (r->bitrate > txrate->bitrate)
123 break; 123 break;
124 124
125 if (tx->sdata->vif.bss_conf.basic_rates & BIT(i)) 125 if (tx->sdata->vif.bss_conf.basic_rates & BIT(i))
126 rate = r->bitrate; 126 rate = r->bitrate;
127 127
128 switch (sband->band) { 128 switch (sband->band) {
129 case IEEE80211_BAND_2GHZ: { 129 case IEEE80211_BAND_2GHZ: {
130 u32 flag; 130 u32 flag;
131 if (tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 131 if (tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
132 flag = IEEE80211_RATE_MANDATORY_G; 132 flag = IEEE80211_RATE_MANDATORY_G;
133 else 133 else
134 flag = IEEE80211_RATE_MANDATORY_B; 134 flag = IEEE80211_RATE_MANDATORY_B;
135 if (r->flags & flag) 135 if (r->flags & flag)
136 mrate = r->bitrate; 136 mrate = r->bitrate;
137 break; 137 break;
138 } 138 }
139 case IEEE80211_BAND_5GHZ: 139 case IEEE80211_BAND_5GHZ:
140 if (r->flags & IEEE80211_RATE_MANDATORY_A) 140 if (r->flags & IEEE80211_RATE_MANDATORY_A)
141 mrate = r->bitrate; 141 mrate = r->bitrate;
142 break; 142 break;
143 case IEEE80211_BAND_60GHZ: 143 case IEEE80211_BAND_60GHZ:
144 /* TODO, for now fall through */ 144 /* TODO, for now fall through */
145 case IEEE80211_NUM_BANDS: 145 case IEEE80211_NUM_BANDS:
146 WARN_ON(1); 146 WARN_ON(1);
147 break; 147 break;
148 } 148 }
149 } 149 }
150 if (rate == -1) { 150 if (rate == -1) {
151 /* No matching basic rate found; use highest suitable mandatory 151 /* No matching basic rate found; use highest suitable mandatory
152 * PHY rate */ 152 * PHY rate */
153 rate = mrate; 153 rate = mrate;
154 } 154 }
155 155
156 /* Don't calculate ACKs for QoS Frames with NoAck Policy set */ 156 /* Don't calculate ACKs for QoS Frames with NoAck Policy set */
157 if (ieee80211_is_data_qos(hdr->frame_control) && 157 if (ieee80211_is_data_qos(hdr->frame_control) &&
158 *(ieee80211_get_qos_ctl(hdr)) & IEEE80211_QOS_CTL_ACK_POLICY_NOACK) 158 *(ieee80211_get_qos_ctl(hdr)) & IEEE80211_QOS_CTL_ACK_POLICY_NOACK)
159 dur = 0; 159 dur = 0;
160 else 160 else
161 /* Time needed to transmit ACK 161 /* Time needed to transmit ACK
162 * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up 162 * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
163 * to closest integer */ 163 * to closest integer */
164 dur = ieee80211_frame_duration(sband->band, 10, rate, erp, 164 dur = ieee80211_frame_duration(sband->band, 10, rate, erp,
165 tx->sdata->vif.bss_conf.use_short_preamble); 165 tx->sdata->vif.bss_conf.use_short_preamble);
166 166
167 if (next_frag_len) { 167 if (next_frag_len) {
168 /* Frame is fragmented: duration increases with time needed to 168 /* Frame is fragmented: duration increases with time needed to
169 * transmit next fragment plus ACK and 2 x SIFS. */ 169 * transmit next fragment plus ACK and 2 x SIFS. */
170 dur *= 2; /* ACK + SIFS */ 170 dur *= 2; /* ACK + SIFS */
171 /* next fragment */ 171 /* next fragment */
172 dur += ieee80211_frame_duration(sband->band, next_frag_len, 172 dur += ieee80211_frame_duration(sband->band, next_frag_len,
173 txrate->bitrate, erp, 173 txrate->bitrate, erp,
174 tx->sdata->vif.bss_conf.use_short_preamble); 174 tx->sdata->vif.bss_conf.use_short_preamble);
175 } 175 }
176 176
177 return cpu_to_le16(dur); 177 return cpu_to_le16(dur);
178 } 178 }
179 179
180 /* tx handlers */ 180 /* tx handlers */
181 static ieee80211_tx_result debug_noinline 181 static ieee80211_tx_result debug_noinline
182 ieee80211_tx_h_dynamic_ps(struct ieee80211_tx_data *tx) 182 ieee80211_tx_h_dynamic_ps(struct ieee80211_tx_data *tx)
183 { 183 {
184 struct ieee80211_local *local = tx->local; 184 struct ieee80211_local *local = tx->local;
185 struct ieee80211_if_managed *ifmgd; 185 struct ieee80211_if_managed *ifmgd;
186 186
187 /* driver doesn't support power save */ 187 /* driver doesn't support power save */
188 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) 188 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS))
189 return TX_CONTINUE; 189 return TX_CONTINUE;
190 190
191 /* hardware does dynamic power save */ 191 /* hardware does dynamic power save */
192 if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS) 192 if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)
193 return TX_CONTINUE; 193 return TX_CONTINUE;
194 194
195 /* dynamic power save disabled */ 195 /* dynamic power save disabled */
196 if (local->hw.conf.dynamic_ps_timeout <= 0) 196 if (local->hw.conf.dynamic_ps_timeout <= 0)
197 return TX_CONTINUE; 197 return TX_CONTINUE;
198 198
199 /* we are scanning, don't enable power save */ 199 /* we are scanning, don't enable power save */
200 if (local->scanning) 200 if (local->scanning)
201 return TX_CONTINUE; 201 return TX_CONTINUE;
202 202
203 if (!local->ps_sdata) 203 if (!local->ps_sdata)
204 return TX_CONTINUE; 204 return TX_CONTINUE;
205 205
206 /* No point if we're going to suspend */ 206 /* No point if we're going to suspend */
207 if (local->quiescing) 207 if (local->quiescing)
208 return TX_CONTINUE; 208 return TX_CONTINUE;
209 209
210 /* dynamic ps is supported only in managed mode */ 210 /* dynamic ps is supported only in managed mode */
211 if (tx->sdata->vif.type != NL80211_IFTYPE_STATION) 211 if (tx->sdata->vif.type != NL80211_IFTYPE_STATION)
212 return TX_CONTINUE; 212 return TX_CONTINUE;
213 213
214 ifmgd = &tx->sdata->u.mgd; 214 ifmgd = &tx->sdata->u.mgd;
215 215
216 /* 216 /*
217 * Don't wakeup from power save if u-apsd is enabled, voip ac has 217 * Don't wakeup from power save if u-apsd is enabled, voip ac has
218 * u-apsd enabled and the frame is in voip class. This effectively 218 * u-apsd enabled and the frame is in voip class. This effectively
219 * means that even if all access categories have u-apsd enabled, in 219 * means that even if all access categories have u-apsd enabled, in
220 * practise u-apsd is only used with the voip ac. This is a 220 * practise u-apsd is only used with the voip ac. This is a
221 * workaround for the case when received voip class packets do not 221 * workaround for the case when received voip class packets do not
222 * have correct qos tag for some reason, due the network or the 222 * have correct qos tag for some reason, due the network or the
223 * peer application. 223 * peer application.
224 * 224 *
225 * Note: ifmgd->uapsd_queues access is racy here. If the value is 225 * Note: ifmgd->uapsd_queues access is racy here. If the value is
226 * changed via debugfs, user needs to reassociate manually to have 226 * changed via debugfs, user needs to reassociate manually to have
227 * everything in sync. 227 * everything in sync.
228 */ 228 */
229 if ((ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED) && 229 if ((ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED) &&
230 (ifmgd->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) && 230 (ifmgd->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) &&
231 skb_get_queue_mapping(tx->skb) == IEEE80211_AC_VO) 231 skb_get_queue_mapping(tx->skb) == IEEE80211_AC_VO)
232 return TX_CONTINUE; 232 return TX_CONTINUE;
233 233
234 if (local->hw.conf.flags & IEEE80211_CONF_PS) { 234 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
235 ieee80211_stop_queues_by_reason(&local->hw, 235 ieee80211_stop_queues_by_reason(&local->hw,
236 IEEE80211_QUEUE_STOP_REASON_PS); 236 IEEE80211_QUEUE_STOP_REASON_PS);
237 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED; 237 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
238 ieee80211_queue_work(&local->hw, 238 ieee80211_queue_work(&local->hw,
239 &local->dynamic_ps_disable_work); 239 &local->dynamic_ps_disable_work);
240 } 240 }
241 241
242 /* Don't restart the timer if we're not disassociated */ 242 /* Don't restart the timer if we're not disassociated */
243 if (!ifmgd->associated) 243 if (!ifmgd->associated)
244 return TX_CONTINUE; 244 return TX_CONTINUE;
245 245
246 mod_timer(&local->dynamic_ps_timer, jiffies + 246 mod_timer(&local->dynamic_ps_timer, jiffies +
247 msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout)); 247 msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
248 248
249 return TX_CONTINUE; 249 return TX_CONTINUE;
250 } 250 }
251 251
252 static ieee80211_tx_result debug_noinline 252 static ieee80211_tx_result debug_noinline
253 ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx) 253 ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx)
254 { 254 {
255 255
256 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; 256 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
257 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); 257 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
258 bool assoc = false; 258 bool assoc = false;
259 259
260 if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED)) 260 if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED))
261 return TX_CONTINUE; 261 return TX_CONTINUE;
262 262
263 if (unlikely(test_bit(SCAN_SW_SCANNING, &tx->local->scanning)) && 263 if (unlikely(test_bit(SCAN_SW_SCANNING, &tx->local->scanning)) &&
264 test_bit(SDATA_STATE_OFFCHANNEL, &tx->sdata->state) && 264 test_bit(SDATA_STATE_OFFCHANNEL, &tx->sdata->state) &&
265 !ieee80211_is_probe_req(hdr->frame_control) && 265 !ieee80211_is_probe_req(hdr->frame_control) &&
266 !ieee80211_is_nullfunc(hdr->frame_control)) 266 !ieee80211_is_nullfunc(hdr->frame_control))
267 /* 267 /*
268 * When software scanning only nullfunc frames (to notify 268 * When software scanning only nullfunc frames (to notify
269 * the sleep state to the AP) and probe requests (for the 269 * the sleep state to the AP) and probe requests (for the
270 * active scan) are allowed, all other frames should not be 270 * active scan) are allowed, all other frames should not be
271 * sent and we should not get here, but if we do 271 * sent and we should not get here, but if we do
272 * nonetheless, drop them to avoid sending them 272 * nonetheless, drop them to avoid sending them
273 * off-channel. See the link below and 273 * off-channel. See the link below and
274 * ieee80211_start_scan() for more. 274 * ieee80211_start_scan() for more.
275 * 275 *
276 * http://article.gmane.org/gmane.linux.kernel.wireless.general/30089 276 * http://article.gmane.org/gmane.linux.kernel.wireless.general/30089
277 */ 277 */
278 return TX_DROP; 278 return TX_DROP;
279 279
280 if (tx->sdata->vif.type == NL80211_IFTYPE_WDS) 280 if (tx->sdata->vif.type == NL80211_IFTYPE_WDS)
281 return TX_CONTINUE; 281 return TX_CONTINUE;
282 282
283 if (tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT) 283 if (tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
284 return TX_CONTINUE; 284 return TX_CONTINUE;
285 285
286 if (tx->flags & IEEE80211_TX_PS_BUFFERED) 286 if (tx->flags & IEEE80211_TX_PS_BUFFERED)
287 return TX_CONTINUE; 287 return TX_CONTINUE;
288 288
289 if (tx->sta) 289 if (tx->sta)
290 assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC); 290 assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC);
291 291
292 if (likely(tx->flags & IEEE80211_TX_UNICAST)) { 292 if (likely(tx->flags & IEEE80211_TX_UNICAST)) {
293 if (unlikely(!assoc && 293 if (unlikely(!assoc &&
294 ieee80211_is_data(hdr->frame_control))) { 294 ieee80211_is_data(hdr->frame_control))) {
295 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 295 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
296 sdata_info(tx->sdata, 296 sdata_info(tx->sdata,
297 "dropped data frame to not associated station %pM\n", 297 "dropped data frame to not associated station %pM\n",
298 hdr->addr1); 298 hdr->addr1);
299 #endif 299 #endif
300 I802_DEBUG_INC(tx->local->tx_handlers_drop_not_assoc); 300 I802_DEBUG_INC(tx->local->tx_handlers_drop_not_assoc);
301 return TX_DROP; 301 return TX_DROP;
302 } 302 }
303 } else if (unlikely(tx->sdata->vif.type == NL80211_IFTYPE_AP && 303 } else if (unlikely(tx->sdata->vif.type == NL80211_IFTYPE_AP &&
304 ieee80211_is_data(hdr->frame_control) && 304 ieee80211_is_data(hdr->frame_control) &&
305 !atomic_read(&tx->sdata->u.ap.num_mcast_sta))) { 305 !atomic_read(&tx->sdata->u.ap.num_mcast_sta))) {
306 /* 306 /*
307 * No associated STAs - no need to send multicast 307 * No associated STAs - no need to send multicast
308 * frames. 308 * frames.
309 */ 309 */
310 return TX_DROP; 310 return TX_DROP;
311 } 311 }
312 312
313 return TX_CONTINUE; 313 return TX_CONTINUE;
314 } 314 }
315 315
316 /* This function is called whenever the AP is about to exceed the maximum limit 316 /* This function is called whenever the AP is about to exceed the maximum limit
317 * of buffered frames for power saving STAs. This situation should not really 317 * of buffered frames for power saving STAs. This situation should not really
318 * happen often during normal operation, so dropping the oldest buffered packet 318 * happen often during normal operation, so dropping the oldest buffered packet
319 * from each queue should be OK to make some room for new frames. */ 319 * from each queue should be OK to make some room for new frames. */
320 static void purge_old_ps_buffers(struct ieee80211_local *local) 320 static void purge_old_ps_buffers(struct ieee80211_local *local)
321 { 321 {
322 int total = 0, purged = 0; 322 int total = 0, purged = 0;
323 struct sk_buff *skb; 323 struct sk_buff *skb;
324 struct ieee80211_sub_if_data *sdata; 324 struct ieee80211_sub_if_data *sdata;
325 struct sta_info *sta; 325 struct sta_info *sta;
326 326
327 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 327 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
328 struct ps_data *ps; 328 struct ps_data *ps;
329 329
330 if (sdata->vif.type == NL80211_IFTYPE_AP) 330 if (sdata->vif.type == NL80211_IFTYPE_AP)
331 ps = &sdata->u.ap.ps; 331 ps = &sdata->u.ap.ps;
332 else if (ieee80211_vif_is_mesh(&sdata->vif)) 332 else if (ieee80211_vif_is_mesh(&sdata->vif))
333 ps = &sdata->u.mesh.ps; 333 ps = &sdata->u.mesh.ps;
334 else 334 else
335 continue; 335 continue;
336 336
337 skb = skb_dequeue(&ps->bc_buf); 337 skb = skb_dequeue(&ps->bc_buf);
338 if (skb) { 338 if (skb) {
339 purged++; 339 purged++;
340 dev_kfree_skb(skb); 340 dev_kfree_skb(skb);
341 } 341 }
342 total += skb_queue_len(&ps->bc_buf); 342 total += skb_queue_len(&ps->bc_buf);
343 } 343 }
344 344
345 /* 345 /*
346 * Drop one frame from each station from the lowest-priority 346 * Drop one frame from each station from the lowest-priority
347 * AC that has frames at all. 347 * AC that has frames at all.
348 */ 348 */
349 list_for_each_entry_rcu(sta, &local->sta_list, list) { 349 list_for_each_entry_rcu(sta, &local->sta_list, list) {
350 int ac; 350 int ac;
351 351
352 for (ac = IEEE80211_AC_BK; ac >= IEEE80211_AC_VO; ac--) { 352 for (ac = IEEE80211_AC_BK; ac >= IEEE80211_AC_VO; ac--) {
353 skb = skb_dequeue(&sta->ps_tx_buf[ac]); 353 skb = skb_dequeue(&sta->ps_tx_buf[ac]);
354 total += skb_queue_len(&sta->ps_tx_buf[ac]); 354 total += skb_queue_len(&sta->ps_tx_buf[ac]);
355 if (skb) { 355 if (skb) {
356 purged++; 356 purged++;
357 ieee80211_free_txskb(&local->hw, skb); 357 ieee80211_free_txskb(&local->hw, skb);
358 break; 358 break;
359 } 359 }
360 } 360 }
361 } 361 }
362 362
363 local->total_ps_buffered = total; 363 local->total_ps_buffered = total;
364 ps_dbg_hw(&local->hw, "PS buffers full - purged %d frames\n", purged); 364 ps_dbg_hw(&local->hw, "PS buffers full - purged %d frames\n", purged);
365 } 365 }
366 366
367 static ieee80211_tx_result 367 static ieee80211_tx_result
368 ieee80211_tx_h_multicast_ps_buf(struct ieee80211_tx_data *tx) 368 ieee80211_tx_h_multicast_ps_buf(struct ieee80211_tx_data *tx)
369 { 369 {
370 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); 370 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
371 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; 371 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
372 struct ps_data *ps; 372 struct ps_data *ps;
373 373
374 /* 374 /*
375 * broadcast/multicast frame 375 * broadcast/multicast frame
376 * 376 *
377 * If any of the associated/peer stations is in power save mode, 377 * If any of the associated/peer stations is in power save mode,
378 * the frame is buffered to be sent after DTIM beacon frame. 378 * the frame is buffered to be sent after DTIM beacon frame.
379 * This is done either by the hardware or us. 379 * This is done either by the hardware or us.
380 */ 380 */
381 381
382 /* powersaving STAs currently only in AP/VLAN/mesh mode */ 382 /* powersaving STAs currently only in AP/VLAN/mesh mode */
383 if (tx->sdata->vif.type == NL80211_IFTYPE_AP || 383 if (tx->sdata->vif.type == NL80211_IFTYPE_AP ||
384 tx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN) { 384 tx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
385 if (!tx->sdata->bss) 385 if (!tx->sdata->bss)
386 return TX_CONTINUE; 386 return TX_CONTINUE;
387 387
388 ps = &tx->sdata->bss->ps; 388 ps = &tx->sdata->bss->ps;
389 } else if (ieee80211_vif_is_mesh(&tx->sdata->vif)) { 389 } else if (ieee80211_vif_is_mesh(&tx->sdata->vif)) {
390 ps = &tx->sdata->u.mesh.ps; 390 ps = &tx->sdata->u.mesh.ps;
391 } else { 391 } else {
392 return TX_CONTINUE; 392 return TX_CONTINUE;
393 } 393 }
394 394
395 395
396 /* no buffering for ordered frames */ 396 /* no buffering for ordered frames */
397 if (ieee80211_has_order(hdr->frame_control)) 397 if (ieee80211_has_order(hdr->frame_control))
398 return TX_CONTINUE; 398 return TX_CONTINUE;
399 399
400 /* no stations in PS mode */ 400 /* no stations in PS mode */
401 if (!atomic_read(&ps->num_sta_ps)) 401 if (!atomic_read(&ps->num_sta_ps))
402 return TX_CONTINUE; 402 return TX_CONTINUE;
403 403
404 info->flags |= IEEE80211_TX_CTL_SEND_AFTER_DTIM; 404 info->flags |= IEEE80211_TX_CTL_SEND_AFTER_DTIM;
405 if (tx->local->hw.flags & IEEE80211_HW_QUEUE_CONTROL) 405 if (tx->local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
406 info->hw_queue = tx->sdata->vif.cab_queue; 406 info->hw_queue = tx->sdata->vif.cab_queue;
407 407
408 /* device releases frame after DTIM beacon */ 408 /* device releases frame after DTIM beacon */
409 if (!(tx->local->hw.flags & IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING)) 409 if (!(tx->local->hw.flags & IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING))
410 return TX_CONTINUE; 410 return TX_CONTINUE;
411 411
412 /* buffered in mac80211 */ 412 /* buffered in mac80211 */
413 if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER) 413 if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
414 purge_old_ps_buffers(tx->local); 414 purge_old_ps_buffers(tx->local);
415 415
416 if (skb_queue_len(&ps->bc_buf) >= AP_MAX_BC_BUFFER) { 416 if (skb_queue_len(&ps->bc_buf) >= AP_MAX_BC_BUFFER) {
417 ps_dbg(tx->sdata, 417 ps_dbg(tx->sdata,
418 "BC TX buffer full - dropping the oldest frame\n"); 418 "BC TX buffer full - dropping the oldest frame\n");
419 dev_kfree_skb(skb_dequeue(&ps->bc_buf)); 419 dev_kfree_skb(skb_dequeue(&ps->bc_buf));
420 } else 420 } else
421 tx->local->total_ps_buffered++; 421 tx->local->total_ps_buffered++;
422 422
423 skb_queue_tail(&ps->bc_buf, tx->skb); 423 skb_queue_tail(&ps->bc_buf, tx->skb);
424 424
425 return TX_QUEUED; 425 return TX_QUEUED;
426 } 426 }
427 427
428 static int ieee80211_use_mfp(__le16 fc, struct sta_info *sta, 428 static int ieee80211_use_mfp(__le16 fc, struct sta_info *sta,
429 struct sk_buff *skb) 429 struct sk_buff *skb)
430 { 430 {
431 if (!ieee80211_is_mgmt(fc)) 431 if (!ieee80211_is_mgmt(fc))
432 return 0; 432 return 0;
433 433
434 if (sta == NULL || !test_sta_flag(sta, WLAN_STA_MFP)) 434 if (sta == NULL || !test_sta_flag(sta, WLAN_STA_MFP))
435 return 0; 435 return 0;
436 436
437 if (!ieee80211_is_robust_mgmt_frame((struct ieee80211_hdr *) 437 if (!ieee80211_is_robust_mgmt_frame((struct ieee80211_hdr *)
438 skb->data)) 438 skb->data))
439 return 0; 439 return 0;
440 440
441 return 1; 441 return 1;
442 } 442 }
443 443
444 static ieee80211_tx_result 444 static ieee80211_tx_result
445 ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx) 445 ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx)
446 { 446 {
447 struct sta_info *sta = tx->sta; 447 struct sta_info *sta = tx->sta;
448 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); 448 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
449 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; 449 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
450 struct ieee80211_local *local = tx->local; 450 struct ieee80211_local *local = tx->local;
451 451
452 if (unlikely(!sta)) 452 if (unlikely(!sta))
453 return TX_CONTINUE; 453 return TX_CONTINUE;
454 454
455 if (unlikely((test_sta_flag(sta, WLAN_STA_PS_STA) || 455 if (unlikely((test_sta_flag(sta, WLAN_STA_PS_STA) ||
456 test_sta_flag(sta, WLAN_STA_PS_DRIVER)) && 456 test_sta_flag(sta, WLAN_STA_PS_DRIVER)) &&
457 !(info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER))) { 457 !(info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER))) {
458 int ac = skb_get_queue_mapping(tx->skb); 458 int ac = skb_get_queue_mapping(tx->skb);
459 459
460 /* only deauth, disassoc and action are bufferable MMPDUs */ 460 /* only deauth, disassoc and action are bufferable MMPDUs */
461 if (ieee80211_is_mgmt(hdr->frame_control) && 461 if (ieee80211_is_mgmt(hdr->frame_control) &&
462 !ieee80211_is_deauth(hdr->frame_control) && 462 !ieee80211_is_deauth(hdr->frame_control) &&
463 !ieee80211_is_disassoc(hdr->frame_control) && 463 !ieee80211_is_disassoc(hdr->frame_control) &&
464 !ieee80211_is_action(hdr->frame_control)) { 464 !ieee80211_is_action(hdr->frame_control)) {
465 info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER; 465 info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER;
466 return TX_CONTINUE; 466 return TX_CONTINUE;
467 } 467 }
468 468
469 ps_dbg(sta->sdata, "STA %pM aid %d: PS buffer for AC %d\n", 469 ps_dbg(sta->sdata, "STA %pM aid %d: PS buffer for AC %d\n",
470 sta->sta.addr, sta->sta.aid, ac); 470 sta->sta.addr, sta->sta.aid, ac);
471 if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER) 471 if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
472 purge_old_ps_buffers(tx->local); 472 purge_old_ps_buffers(tx->local);
473 if (skb_queue_len(&sta->ps_tx_buf[ac]) >= STA_MAX_TX_BUFFER) { 473 if (skb_queue_len(&sta->ps_tx_buf[ac]) >= STA_MAX_TX_BUFFER) {
474 struct sk_buff *old = skb_dequeue(&sta->ps_tx_buf[ac]); 474 struct sk_buff *old = skb_dequeue(&sta->ps_tx_buf[ac]);
475 ps_dbg(tx->sdata, 475 ps_dbg(tx->sdata,
476 "STA %pM TX buffer for AC %d full - dropping oldest frame\n", 476 "STA %pM TX buffer for AC %d full - dropping oldest frame\n",
477 sta->sta.addr, ac); 477 sta->sta.addr, ac);
478 ieee80211_free_txskb(&local->hw, old); 478 ieee80211_free_txskb(&local->hw, old);
479 } else 479 } else
480 tx->local->total_ps_buffered++; 480 tx->local->total_ps_buffered++;
481 481
482 info->control.jiffies = jiffies; 482 info->control.jiffies = jiffies;
483 info->control.vif = &tx->sdata->vif; 483 info->control.vif = &tx->sdata->vif;
484 info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING; 484 info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
485 skb_queue_tail(&sta->ps_tx_buf[ac], tx->skb); 485 skb_queue_tail(&sta->ps_tx_buf[ac], tx->skb);
486 486
487 if (!timer_pending(&local->sta_cleanup)) 487 if (!timer_pending(&local->sta_cleanup))
488 mod_timer(&local->sta_cleanup, 488 mod_timer(&local->sta_cleanup,
489 round_jiffies(jiffies + 489 round_jiffies(jiffies +
490 STA_INFO_CLEANUP_INTERVAL)); 490 STA_INFO_CLEANUP_INTERVAL));
491 491
492 /* 492 /*
493 * We queued up some frames, so the TIM bit might 493 * We queued up some frames, so the TIM bit might
494 * need to be set, recalculate it. 494 * need to be set, recalculate it.
495 */ 495 */
496 sta_info_recalc_tim(sta); 496 sta_info_recalc_tim(sta);
497 497
498 return TX_QUEUED; 498 return TX_QUEUED;
499 } else if (unlikely(test_sta_flag(sta, WLAN_STA_PS_STA))) { 499 } else if (unlikely(test_sta_flag(sta, WLAN_STA_PS_STA))) {
500 ps_dbg(tx->sdata, 500 ps_dbg(tx->sdata,
501 "STA %pM in PS mode, but polling/in SP -> send frame\n", 501 "STA %pM in PS mode, but polling/in SP -> send frame\n",
502 sta->sta.addr); 502 sta->sta.addr);
503 } 503 }
504 504
505 return TX_CONTINUE; 505 return TX_CONTINUE;
506 } 506 }
507 507
508 static ieee80211_tx_result debug_noinline 508 static ieee80211_tx_result debug_noinline
509 ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx) 509 ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx)
510 { 510 {
511 if (unlikely(tx->flags & IEEE80211_TX_PS_BUFFERED)) 511 if (unlikely(tx->flags & IEEE80211_TX_PS_BUFFERED))
512 return TX_CONTINUE; 512 return TX_CONTINUE;
513 513
514 if (tx->flags & IEEE80211_TX_UNICAST) 514 if (tx->flags & IEEE80211_TX_UNICAST)
515 return ieee80211_tx_h_unicast_ps_buf(tx); 515 return ieee80211_tx_h_unicast_ps_buf(tx);
516 else 516 else
517 return ieee80211_tx_h_multicast_ps_buf(tx); 517 return ieee80211_tx_h_multicast_ps_buf(tx);
518 } 518 }
519 519
520 static ieee80211_tx_result debug_noinline 520 static ieee80211_tx_result debug_noinline
521 ieee80211_tx_h_check_control_port_protocol(struct ieee80211_tx_data *tx) 521 ieee80211_tx_h_check_control_port_protocol(struct ieee80211_tx_data *tx)
522 { 522 {
523 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); 523 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
524 524
525 if (unlikely(tx->sdata->control_port_protocol == tx->skb->protocol && 525 if (unlikely(tx->sdata->control_port_protocol == tx->skb->protocol &&
526 tx->sdata->control_port_no_encrypt)) 526 tx->sdata->control_port_no_encrypt))
527 info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 527 info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
528 528
529 return TX_CONTINUE; 529 return TX_CONTINUE;
530 } 530 }
531 531
532 static ieee80211_tx_result debug_noinline 532 static ieee80211_tx_result debug_noinline
533 ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx) 533 ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx)
534 { 534 {
535 struct ieee80211_key *key; 535 struct ieee80211_key *key;
536 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); 536 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
537 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; 537 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
538 538
539 if (unlikely(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT)) 539 if (unlikely(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT))
540 tx->key = NULL; 540 tx->key = NULL;
541 else if (tx->sta && (key = rcu_dereference(tx->sta->ptk))) 541 else if (tx->sta && (key = rcu_dereference(tx->sta->ptk)))
542 tx->key = key; 542 tx->key = key;
543 else if (ieee80211_is_mgmt(hdr->frame_control) && 543 else if (ieee80211_is_mgmt(hdr->frame_control) &&
544 is_multicast_ether_addr(hdr->addr1) && 544 is_multicast_ether_addr(hdr->addr1) &&
545 ieee80211_is_robust_mgmt_frame(hdr) && 545 ieee80211_is_robust_mgmt_frame(hdr) &&
546 (key = rcu_dereference(tx->sdata->default_mgmt_key))) 546 (key = rcu_dereference(tx->sdata->default_mgmt_key)))
547 tx->key = key; 547 tx->key = key;
548 else if (is_multicast_ether_addr(hdr->addr1) && 548 else if (is_multicast_ether_addr(hdr->addr1) &&
549 (key = rcu_dereference(tx->sdata->default_multicast_key))) 549 (key = rcu_dereference(tx->sdata->default_multicast_key)))
550 tx->key = key; 550 tx->key = key;
551 else if (!is_multicast_ether_addr(hdr->addr1) && 551 else if (!is_multicast_ether_addr(hdr->addr1) &&
552 (key = rcu_dereference(tx->sdata->default_unicast_key))) 552 (key = rcu_dereference(tx->sdata->default_unicast_key)))
553 tx->key = key; 553 tx->key = key;
554 else if (info->flags & IEEE80211_TX_CTL_INJECTED) 554 else if (info->flags & IEEE80211_TX_CTL_INJECTED)
555 tx->key = NULL; 555 tx->key = NULL;
556 else if (!tx->sdata->drop_unencrypted) 556 else if (!tx->sdata->drop_unencrypted)
557 tx->key = NULL; 557 tx->key = NULL;
558 else if (tx->skb->protocol == tx->sdata->control_port_protocol) 558 else if (tx->skb->protocol == tx->sdata->control_port_protocol)
559 tx->key = NULL; 559 tx->key = NULL;
560 else if (ieee80211_is_robust_mgmt_frame(hdr) && 560 else if (ieee80211_is_robust_mgmt_frame(hdr) &&
561 !(ieee80211_is_action(hdr->frame_control) && 561 !(ieee80211_is_action(hdr->frame_control) &&
562 tx->sta && test_sta_flag(tx->sta, WLAN_STA_MFP))) 562 tx->sta && test_sta_flag(tx->sta, WLAN_STA_MFP)))
563 tx->key = NULL; 563 tx->key = NULL;
564 else if (ieee80211_is_mgmt(hdr->frame_control) && 564 else if (ieee80211_is_mgmt(hdr->frame_control) &&
565 !ieee80211_is_robust_mgmt_frame(hdr)) 565 !ieee80211_is_robust_mgmt_frame(hdr))
566 tx->key = NULL; 566 tx->key = NULL;
567 else { 567 else {
568 I802_DEBUG_INC(tx->local->tx_handlers_drop_unencrypted); 568 I802_DEBUG_INC(tx->local->tx_handlers_drop_unencrypted);
569 return TX_DROP; 569 return TX_DROP;
570 } 570 }
571 571
572 if (tx->key) { 572 if (tx->key) {
573 bool skip_hw = false; 573 bool skip_hw = false;
574 574
575 tx->key->tx_rx_count++; 575 tx->key->tx_rx_count++;
576 /* TODO: add threshold stuff again */ 576 /* TODO: add threshold stuff again */
577 577
578 switch (tx->key->conf.cipher) { 578 switch (tx->key->conf.cipher) {
579 case WLAN_CIPHER_SUITE_WEP40: 579 case WLAN_CIPHER_SUITE_WEP40:
580 case WLAN_CIPHER_SUITE_WEP104: 580 case WLAN_CIPHER_SUITE_WEP104:
581 case WLAN_CIPHER_SUITE_TKIP: 581 case WLAN_CIPHER_SUITE_TKIP:
582 if (!ieee80211_is_data_present(hdr->frame_control)) 582 if (!ieee80211_is_data_present(hdr->frame_control))
583 tx->key = NULL; 583 tx->key = NULL;
584 break; 584 break;
585 case WLAN_CIPHER_SUITE_CCMP: 585 case WLAN_CIPHER_SUITE_CCMP:
586 if (!ieee80211_is_data_present(hdr->frame_control) && 586 if (!ieee80211_is_data_present(hdr->frame_control) &&
587 !ieee80211_use_mfp(hdr->frame_control, tx->sta, 587 !ieee80211_use_mfp(hdr->frame_control, tx->sta,
588 tx->skb)) 588 tx->skb))
589 tx->key = NULL; 589 tx->key = NULL;
590 else 590 else
591 skip_hw = (tx->key->conf.flags & 591 skip_hw = (tx->key->conf.flags &
592 IEEE80211_KEY_FLAG_SW_MGMT_TX) && 592 IEEE80211_KEY_FLAG_SW_MGMT_TX) &&
593 ieee80211_is_mgmt(hdr->frame_control); 593 ieee80211_is_mgmt(hdr->frame_control);
594 break; 594 break;
595 case WLAN_CIPHER_SUITE_AES_CMAC: 595 case WLAN_CIPHER_SUITE_AES_CMAC:
596 if (!ieee80211_is_mgmt(hdr->frame_control)) 596 if (!ieee80211_is_mgmt(hdr->frame_control))
597 tx->key = NULL; 597 tx->key = NULL;
598 break; 598 break;
599 } 599 }
600 600
601 if (unlikely(tx->key && tx->key->flags & KEY_FLAG_TAINTED && 601 if (unlikely(tx->key && tx->key->flags & KEY_FLAG_TAINTED &&
602 !ieee80211_is_deauth(hdr->frame_control))) 602 !ieee80211_is_deauth(hdr->frame_control)))
603 return TX_DROP; 603 return TX_DROP;
604 604
605 if (!skip_hw && tx->key && 605 if (!skip_hw && tx->key &&
606 tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) 606 tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
607 info->control.hw_key = &tx->key->conf; 607 info->control.hw_key = &tx->key->conf;
608 } 608 }
609 609
610 return TX_CONTINUE; 610 return TX_CONTINUE;
611 } 611 }
612 612
613 static ieee80211_tx_result debug_noinline 613 static ieee80211_tx_result debug_noinline
614 ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx) 614 ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
615 { 615 {
616 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); 616 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
617 struct ieee80211_hdr *hdr = (void *)tx->skb->data; 617 struct ieee80211_hdr *hdr = (void *)tx->skb->data;
618 struct ieee80211_supported_band *sband; 618 struct ieee80211_supported_band *sband;
619 struct ieee80211_rate *rate; 619 struct ieee80211_rate *rate;
620 int i; 620 int i;
621 u32 len; 621 u32 len;
622 bool inval = false, rts = false, short_preamble = false; 622 bool inval = false, rts = false, short_preamble = false;
623 struct ieee80211_tx_rate_control txrc; 623 struct ieee80211_tx_rate_control txrc;
624 bool assoc = false; 624 bool assoc = false;
625 625
626 memset(&txrc, 0, sizeof(txrc)); 626 memset(&txrc, 0, sizeof(txrc));
627 627
628 sband = tx->local->hw.wiphy->bands[info->band]; 628 sband = tx->local->hw.wiphy->bands[info->band];
629 629
630 len = min_t(u32, tx->skb->len + FCS_LEN, 630 len = min_t(u32, tx->skb->len + FCS_LEN,
631 tx->local->hw.wiphy->frag_threshold); 631 tx->local->hw.wiphy->frag_threshold);
632 632
633 /* set up the tx rate control struct we give the RC algo */ 633 /* set up the tx rate control struct we give the RC algo */
634 txrc.hw = &tx->local->hw; 634 txrc.hw = &tx->local->hw;
635 txrc.sband = sband; 635 txrc.sband = sband;
636 txrc.bss_conf = &tx->sdata->vif.bss_conf; 636 txrc.bss_conf = &tx->sdata->vif.bss_conf;
637 txrc.skb = tx->skb; 637 txrc.skb = tx->skb;
638 txrc.reported_rate.idx = -1; 638 txrc.reported_rate.idx = -1;
639 txrc.rate_idx_mask = tx->sdata->rc_rateidx_mask[info->band]; 639 txrc.rate_idx_mask = tx->sdata->rc_rateidx_mask[info->band];
640 if (txrc.rate_idx_mask == (1 << sband->n_bitrates) - 1) 640 if (txrc.rate_idx_mask == (1 << sband->n_bitrates) - 1)
641 txrc.max_rate_idx = -1; 641 txrc.max_rate_idx = -1;
642 else 642 else
643 txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1; 643 txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1;
644 memcpy(txrc.rate_idx_mcs_mask, 644 memcpy(txrc.rate_idx_mcs_mask,
645 tx->sdata->rc_rateidx_mcs_mask[info->band], 645 tx->sdata->rc_rateidx_mcs_mask[info->band],
646 sizeof(txrc.rate_idx_mcs_mask)); 646 sizeof(txrc.rate_idx_mcs_mask));
647 txrc.bss = (tx->sdata->vif.type == NL80211_IFTYPE_AP || 647 txrc.bss = (tx->sdata->vif.type == NL80211_IFTYPE_AP ||
648 tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT || 648 tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
649 tx->sdata->vif.type == NL80211_IFTYPE_ADHOC); 649 tx->sdata->vif.type == NL80211_IFTYPE_ADHOC);
650 650
651 /* set up RTS protection if desired */ 651 /* set up RTS protection if desired */
652 if (len > tx->local->hw.wiphy->rts_threshold) { 652 if (len > tx->local->hw.wiphy->rts_threshold) {
653 txrc.rts = rts = true; 653 txrc.rts = rts = true;
654 } 654 }
655 655
656 /* 656 /*
657 * Use short preamble if the BSS can handle it, but not for 657 * Use short preamble if the BSS can handle it, but not for
658 * management frames unless we know the receiver can handle 658 * management frames unless we know the receiver can handle
659 * that -- the management frame might be to a station that 659 * that -- the management frame might be to a station that
660 * just wants a probe response. 660 * just wants a probe response.
661 */ 661 */
662 if (tx->sdata->vif.bss_conf.use_short_preamble && 662 if (tx->sdata->vif.bss_conf.use_short_preamble &&
663 (ieee80211_is_data(hdr->frame_control) || 663 (ieee80211_is_data(hdr->frame_control) ||
664 (tx->sta && test_sta_flag(tx->sta, WLAN_STA_SHORT_PREAMBLE)))) 664 (tx->sta && test_sta_flag(tx->sta, WLAN_STA_SHORT_PREAMBLE))))
665 txrc.short_preamble = short_preamble = true; 665 txrc.short_preamble = short_preamble = true;
666 666
667 if (tx->sta) 667 if (tx->sta)
668 assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC); 668 assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC);
669 669
670 /* 670 /*
671 * Lets not bother rate control if we're associated and cannot 671 * Lets not bother rate control if we're associated and cannot
672 * talk to the sta. This should not happen. 672 * talk to the sta. This should not happen.
673 */ 673 */
674 if (WARN(test_bit(SCAN_SW_SCANNING, &tx->local->scanning) && assoc && 674 if (WARN(test_bit(SCAN_SW_SCANNING, &tx->local->scanning) && assoc &&
675 !rate_usable_index_exists(sband, &tx->sta->sta), 675 !rate_usable_index_exists(sband, &tx->sta->sta),
676 "%s: Dropped data frame as no usable bitrate found while " 676 "%s: Dropped data frame as no usable bitrate found while "
677 "scanning and associated. Target station: " 677 "scanning and associated. Target station: "
678 "%pM on %d GHz band\n", 678 "%pM on %d GHz band\n",
679 tx->sdata->name, hdr->addr1, 679 tx->sdata->name, hdr->addr1,
680 info->band ? 5 : 2)) 680 info->band ? 5 : 2))
681 return TX_DROP; 681 return TX_DROP;
682 682
683 /* 683 /*
684 * If we're associated with the sta at this point we know we can at 684 * If we're associated with the sta at this point we know we can at
685 * least send the frame at the lowest bit rate. 685 * least send the frame at the lowest bit rate.
686 */ 686 */
687 rate_control_get_rate(tx->sdata, tx->sta, &txrc); 687 rate_control_get_rate(tx->sdata, tx->sta, &txrc);
688 688
689 if (unlikely(info->control.rates[0].idx < 0)) 689 if (unlikely(info->control.rates[0].idx < 0))
690 return TX_DROP; 690 return TX_DROP;
691 691
692 if (txrc.reported_rate.idx < 0) { 692 if (txrc.reported_rate.idx < 0) {
693 txrc.reported_rate = info->control.rates[0]; 693 txrc.reported_rate = info->control.rates[0];
694 if (tx->sta && ieee80211_is_data(hdr->frame_control)) 694 if (tx->sta && ieee80211_is_data(hdr->frame_control))
695 tx->sta->last_tx_rate = txrc.reported_rate; 695 tx->sta->last_tx_rate = txrc.reported_rate;
696 } else if (tx->sta) 696 } else if (tx->sta)
697 tx->sta->last_tx_rate = txrc.reported_rate; 697 tx->sta->last_tx_rate = txrc.reported_rate;
698 698
699 if (unlikely(!info->control.rates[0].count)) 699 if (unlikely(!info->control.rates[0].count))
700 info->control.rates[0].count = 1; 700 info->control.rates[0].count = 1;
701 701
702 if (WARN_ON_ONCE((info->control.rates[0].count > 1) && 702 if (WARN_ON_ONCE((info->control.rates[0].count > 1) &&
703 (info->flags & IEEE80211_TX_CTL_NO_ACK))) 703 (info->flags & IEEE80211_TX_CTL_NO_ACK)))
704 info->control.rates[0].count = 1; 704 info->control.rates[0].count = 1;
705 705
706 if (is_multicast_ether_addr(hdr->addr1)) { 706 if (is_multicast_ether_addr(hdr->addr1)) {
707 /* 707 /*
708 * XXX: verify the rate is in the basic rateset 708 * XXX: verify the rate is in the basic rateset
709 */ 709 */
710 return TX_CONTINUE; 710 return TX_CONTINUE;
711 } 711 }
712 712
713 /* 713 /*
714 * set up the RTS/CTS rate as the fastest basic rate 714 * set up the RTS/CTS rate as the fastest basic rate
715 * that is not faster than the data rate 715 * that is not faster than the data rate
716 * 716 *
717 * XXX: Should this check all retry rates? 717 * XXX: Should this check all retry rates?
718 */ 718 */
719 if (!(info->control.rates[0].flags & IEEE80211_TX_RC_MCS)) { 719 if (!(info->control.rates[0].flags & IEEE80211_TX_RC_MCS)) {
720 s8 baserate = 0; 720 s8 baserate = 0;
721 721
722 rate = &sband->bitrates[info->control.rates[0].idx]; 722 rate = &sband->bitrates[info->control.rates[0].idx];
723 723
724 for (i = 0; i < sband->n_bitrates; i++) { 724 for (i = 0; i < sband->n_bitrates; i++) {
725 /* must be a basic rate */ 725 /* must be a basic rate */
726 if (!(tx->sdata->vif.bss_conf.basic_rates & BIT(i))) 726 if (!(tx->sdata->vif.bss_conf.basic_rates & BIT(i)))
727 continue; 727 continue;
728 /* must not be faster than the data rate */ 728 /* must not be faster than the data rate */
729 if (sband->bitrates[i].bitrate > rate->bitrate) 729 if (sband->bitrates[i].bitrate > rate->bitrate)
730 continue; 730 continue;
731 /* maximum */ 731 /* maximum */
732 if (sband->bitrates[baserate].bitrate < 732 if (sband->bitrates[baserate].bitrate <
733 sband->bitrates[i].bitrate) 733 sband->bitrates[i].bitrate)
734 baserate = i; 734 baserate = i;
735 } 735 }
736 736
737 info->control.rts_cts_rate_idx = baserate; 737 info->control.rts_cts_rate_idx = baserate;
738 } 738 }
739 739
740 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) { 740 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
741 /* 741 /*
742 * make sure there's no valid rate following 742 * make sure there's no valid rate following
743 * an invalid one, just in case drivers don't 743 * an invalid one, just in case drivers don't
744 * take the API seriously to stop at -1. 744 * take the API seriously to stop at -1.
745 */ 745 */
746 if (inval) { 746 if (inval) {
747 info->control.rates[i].idx = -1; 747 info->control.rates[i].idx = -1;
748 continue; 748 continue;
749 } 749 }
750 if (info->control.rates[i].idx < 0) { 750 if (info->control.rates[i].idx < 0) {
751 inval = true; 751 inval = true;
752 continue; 752 continue;
753 } 753 }
754 754
755 /* 755 /*
756 * For now assume MCS is already set up correctly, this 756 * For now assume MCS is already set up correctly, this
757 * needs to be fixed. 757 * needs to be fixed.
758 */ 758 */
759 if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS) { 759 if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS) {
760 WARN_ON(info->control.rates[i].idx > 76); 760 WARN_ON(info->control.rates[i].idx > 76);
761 continue; 761 continue;
762 } 762 }
763 763
764 /* set up RTS protection if desired */ 764 /* set up RTS protection if desired */
765 if (rts) 765 if (rts)
766 info->control.rates[i].flags |= 766 info->control.rates[i].flags |=
767 IEEE80211_TX_RC_USE_RTS_CTS; 767 IEEE80211_TX_RC_USE_RTS_CTS;
768 768
769 /* RC is busted */ 769 /* RC is busted */
770 if (WARN_ON_ONCE(info->control.rates[i].idx >= 770 if (WARN_ON_ONCE(info->control.rates[i].idx >=
771 sband->n_bitrates)) { 771 sband->n_bitrates)) {
772 info->control.rates[i].idx = -1; 772 info->control.rates[i].idx = -1;
773 continue; 773 continue;
774 } 774 }
775 775
776 rate = &sband->bitrates[info->control.rates[i].idx]; 776 rate = &sband->bitrates[info->control.rates[i].idx];
777 777
778 /* set up short preamble */ 778 /* set up short preamble */
779 if (short_preamble && 779 if (short_preamble &&
780 rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) 780 rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
781 info->control.rates[i].flags |= 781 info->control.rates[i].flags |=
782 IEEE80211_TX_RC_USE_SHORT_PREAMBLE; 782 IEEE80211_TX_RC_USE_SHORT_PREAMBLE;
783 783
784 /* set up G protection */ 784 /* set up G protection */
785 if (!rts && tx->sdata->vif.bss_conf.use_cts_prot && 785 if (!rts && tx->sdata->vif.bss_conf.use_cts_prot &&
786 rate->flags & IEEE80211_RATE_ERP_G) 786 rate->flags & IEEE80211_RATE_ERP_G)
787 info->control.rates[i].flags |= 787 info->control.rates[i].flags |=
788 IEEE80211_TX_RC_USE_CTS_PROTECT; 788 IEEE80211_TX_RC_USE_CTS_PROTECT;
789 } 789 }
790 790
791 return TX_CONTINUE; 791 return TX_CONTINUE;
792 } 792 }
793 793
794 static ieee80211_tx_result debug_noinline 794 static ieee80211_tx_result debug_noinline
795 ieee80211_tx_h_sequence(struct ieee80211_tx_data *tx) 795 ieee80211_tx_h_sequence(struct ieee80211_tx_data *tx)
796 { 796 {
797 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); 797 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
798 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; 798 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
799 u16 *seq; 799 u16 *seq;
800 u8 *qc; 800 u8 *qc;
801 int tid; 801 int tid;
802 802
803 /* 803 /*
804 * Packet injection may want to control the sequence 804 * Packet injection may want to control the sequence
805 * number, if we have no matching interface then we 805 * number, if we have no matching interface then we
806 * neither assign one ourselves nor ask the driver to. 806 * neither assign one ourselves nor ask the driver to.
807 */ 807 */
808 if (unlikely(info->control.vif->type == NL80211_IFTYPE_MONITOR)) 808 if (unlikely(info->control.vif->type == NL80211_IFTYPE_MONITOR))
809 return TX_CONTINUE; 809 return TX_CONTINUE;
810 810
811 if (unlikely(ieee80211_is_ctl(hdr->frame_control))) 811 if (unlikely(ieee80211_is_ctl(hdr->frame_control)))
812 return TX_CONTINUE; 812 return TX_CONTINUE;
813 813
814 if (ieee80211_hdrlen(hdr->frame_control) < 24) 814 if (ieee80211_hdrlen(hdr->frame_control) < 24)
815 return TX_CONTINUE; 815 return TX_CONTINUE;
816 816
817 if (ieee80211_is_qos_nullfunc(hdr->frame_control)) 817 if (ieee80211_is_qos_nullfunc(hdr->frame_control))
818 return TX_CONTINUE; 818 return TX_CONTINUE;
819 819
820 /* 820 /*
821 * Anything but QoS data that has a sequence number field 821 * Anything but QoS data that has a sequence number field
822 * (is long enough) gets a sequence number from the global 822 * (is long enough) gets a sequence number from the global
823 * counter. 823 * counter.
824 */ 824 */
825 if (!ieee80211_is_data_qos(hdr->frame_control)) { 825 if (!ieee80211_is_data_qos(hdr->frame_control)) {
826 /* driver should assign sequence number */ 826 /* driver should assign sequence number */
827 info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ; 827 info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
828 /* for pure STA mode without beacons, we can do it */ 828 /* for pure STA mode without beacons, we can do it */
829 hdr->seq_ctrl = cpu_to_le16(tx->sdata->sequence_number); 829 hdr->seq_ctrl = cpu_to_le16(tx->sdata->sequence_number);
830 tx->sdata->sequence_number += 0x10; 830 tx->sdata->sequence_number += 0x10;
831 return TX_CONTINUE; 831 return TX_CONTINUE;
832 } 832 }
833 833
834 /* 834 /*
835 * This should be true for injected/management frames only, for 835 * This should be true for injected/management frames only, for
836 * management frames we have set the IEEE80211_TX_CTL_ASSIGN_SEQ 836 * management frames we have set the IEEE80211_TX_CTL_ASSIGN_SEQ
837 * above since they are not QoS-data frames. 837 * above since they are not QoS-data frames.
838 */ 838 */
839 if (!tx->sta) 839 if (!tx->sta)
840 return TX_CONTINUE; 840 return TX_CONTINUE;
841 841
842 /* include per-STA, per-TID sequence counter */ 842 /* include per-STA, per-TID sequence counter */
843 843
844 qc = ieee80211_get_qos_ctl(hdr); 844 qc = ieee80211_get_qos_ctl(hdr);
845 tid = *qc & IEEE80211_QOS_CTL_TID_MASK; 845 tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
846 seq = &tx->sta->tid_seq[tid]; 846 seq = &tx->sta->tid_seq[tid];
847 847
848 hdr->seq_ctrl = cpu_to_le16(*seq); 848 hdr->seq_ctrl = cpu_to_le16(*seq);
849 849
850 /* Increase the sequence number. */ 850 /* Increase the sequence number. */
851 *seq = (*seq + 0x10) & IEEE80211_SCTL_SEQ; 851 *seq = (*seq + 0x10) & IEEE80211_SCTL_SEQ;
852 852
853 return TX_CONTINUE; 853 return TX_CONTINUE;
854 } 854 }
855 855
856 static int ieee80211_fragment(struct ieee80211_tx_data *tx, 856 static int ieee80211_fragment(struct ieee80211_tx_data *tx,
857 struct sk_buff *skb, int hdrlen, 857 struct sk_buff *skb, int hdrlen,
858 int frag_threshold) 858 int frag_threshold)
859 { 859 {
860 struct ieee80211_local *local = tx->local; 860 struct ieee80211_local *local = tx->local;
861 struct ieee80211_tx_info *info; 861 struct ieee80211_tx_info *info;
862 struct sk_buff *tmp; 862 struct sk_buff *tmp;
863 int per_fragm = frag_threshold - hdrlen - FCS_LEN; 863 int per_fragm = frag_threshold - hdrlen - FCS_LEN;
864 int pos = hdrlen + per_fragm; 864 int pos = hdrlen + per_fragm;
865 int rem = skb->len - hdrlen - per_fragm; 865 int rem = skb->len - hdrlen - per_fragm;
866 866
867 if (WARN_ON(rem < 0)) 867 if (WARN_ON(rem < 0))
868 return -EINVAL; 868 return -EINVAL;
869 869
870 /* first fragment was already added to queue by caller */ 870 /* first fragment was already added to queue by caller */
871 871
872 while (rem) { 872 while (rem) {
873 int fraglen = per_fragm; 873 int fraglen = per_fragm;
874 874
875 if (fraglen > rem) 875 if (fraglen > rem)
876 fraglen = rem; 876 fraglen = rem;
877 rem -= fraglen; 877 rem -= fraglen;
878 tmp = dev_alloc_skb(local->tx_headroom + 878 tmp = dev_alloc_skb(local->tx_headroom +
879 frag_threshold + 879 frag_threshold +
880 IEEE80211_ENCRYPT_HEADROOM + 880 IEEE80211_ENCRYPT_HEADROOM +
881 IEEE80211_ENCRYPT_TAILROOM); 881 IEEE80211_ENCRYPT_TAILROOM);
882 if (!tmp) 882 if (!tmp)
883 return -ENOMEM; 883 return -ENOMEM;
884 884
885 __skb_queue_tail(&tx->skbs, tmp); 885 __skb_queue_tail(&tx->skbs, tmp);
886 886
887 skb_reserve(tmp, local->tx_headroom + 887 skb_reserve(tmp, local->tx_headroom +
888 IEEE80211_ENCRYPT_HEADROOM); 888 IEEE80211_ENCRYPT_HEADROOM);
889 /* copy control information */ 889 /* copy control information */
890 memcpy(tmp->cb, skb->cb, sizeof(tmp->cb)); 890 memcpy(tmp->cb, skb->cb, sizeof(tmp->cb));
891 891
892 info = IEEE80211_SKB_CB(tmp); 892 info = IEEE80211_SKB_CB(tmp);
893 info->flags &= ~(IEEE80211_TX_CTL_CLEAR_PS_FILT | 893 info->flags &= ~(IEEE80211_TX_CTL_CLEAR_PS_FILT |
894 IEEE80211_TX_CTL_FIRST_FRAGMENT); 894 IEEE80211_TX_CTL_FIRST_FRAGMENT);
895 895
896 if (rem) 896 if (rem)
897 info->flags |= IEEE80211_TX_CTL_MORE_FRAMES; 897 info->flags |= IEEE80211_TX_CTL_MORE_FRAMES;
898 898
899 skb_copy_queue_mapping(tmp, skb); 899 skb_copy_queue_mapping(tmp, skb);
900 tmp->priority = skb->priority; 900 tmp->priority = skb->priority;
901 tmp->dev = skb->dev; 901 tmp->dev = skb->dev;
902 902
903 /* copy header and data */ 903 /* copy header and data */
904 memcpy(skb_put(tmp, hdrlen), skb->data, hdrlen); 904 memcpy(skb_put(tmp, hdrlen), skb->data, hdrlen);
905 memcpy(skb_put(tmp, fraglen), skb->data + pos, fraglen); 905 memcpy(skb_put(tmp, fraglen), skb->data + pos, fraglen);
906 906
907 pos += fraglen; 907 pos += fraglen;
908 } 908 }
909 909
910 /* adjust first fragment's length */ 910 /* adjust first fragment's length */
911 skb->len = hdrlen + per_fragm; 911 skb->len = hdrlen + per_fragm;
912 return 0; 912 return 0;
913 } 913 }
914 914
915 static ieee80211_tx_result debug_noinline 915 static ieee80211_tx_result debug_noinline
916 ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx) 916 ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx)
917 { 917 {
918 struct sk_buff *skb = tx->skb; 918 struct sk_buff *skb = tx->skb;
919 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 919 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
920 struct ieee80211_hdr *hdr = (void *)skb->data; 920 struct ieee80211_hdr *hdr = (void *)skb->data;
921 int frag_threshold = tx->local->hw.wiphy->frag_threshold; 921 int frag_threshold = tx->local->hw.wiphy->frag_threshold;
922 int hdrlen; 922 int hdrlen;
923 int fragnum; 923 int fragnum;
924 924
925 /* no matter what happens, tx->skb moves to tx->skbs */ 925 /* no matter what happens, tx->skb moves to tx->skbs */
926 __skb_queue_tail(&tx->skbs, skb); 926 __skb_queue_tail(&tx->skbs, skb);
927 tx->skb = NULL; 927 tx->skb = NULL;
928 928
929 if (info->flags & IEEE80211_TX_CTL_DONTFRAG) 929 if (info->flags & IEEE80211_TX_CTL_DONTFRAG)
930 return TX_CONTINUE; 930 return TX_CONTINUE;
931 931
932 if (tx->local->ops->set_frag_threshold) 932 if (tx->local->ops->set_frag_threshold)
933 return TX_CONTINUE; 933 return TX_CONTINUE;
934 934
935 /* 935 /*
936 * Warn when submitting a fragmented A-MPDU frame and drop it. 936 * Warn when submitting a fragmented A-MPDU frame and drop it.
937 * This scenario is handled in ieee80211_tx_prepare but extra 937 * This scenario is handled in ieee80211_tx_prepare but extra
938 * caution taken here as fragmented ampdu may cause Tx stop. 938 * caution taken here as fragmented ampdu may cause Tx stop.
939 */ 939 */
940 if (WARN_ON(info->flags & IEEE80211_TX_CTL_AMPDU)) 940 if (WARN_ON(info->flags & IEEE80211_TX_CTL_AMPDU))
941 return TX_DROP; 941 return TX_DROP;
942 942
943 hdrlen = ieee80211_hdrlen(hdr->frame_control); 943 hdrlen = ieee80211_hdrlen(hdr->frame_control);
944 944
945 /* internal error, why isn't DONTFRAG set? */ 945 /* internal error, why isn't DONTFRAG set? */
946 if (WARN_ON(skb->len + FCS_LEN <= frag_threshold)) 946 if (WARN_ON(skb->len + FCS_LEN <= frag_threshold))
947 return TX_DROP; 947 return TX_DROP;
948 948
949 /* 949 /*
950 * Now fragment the frame. This will allocate all the fragments and 950 * Now fragment the frame. This will allocate all the fragments and
951 * chain them (using skb as the first fragment) to skb->next. 951 * chain them (using skb as the first fragment) to skb->next.
952 * During transmission, we will remove the successfully transmitted 952 * During transmission, we will remove the successfully transmitted
953 * fragments from this list. When the low-level driver rejects one 953 * fragments from this list. When the low-level driver rejects one
954 * of the fragments then we will simply pretend to accept the skb 954 * of the fragments then we will simply pretend to accept the skb
955 * but store it away as pending. 955 * but store it away as pending.
956 */ 956 */
957 if (ieee80211_fragment(tx, skb, hdrlen, frag_threshold)) 957 if (ieee80211_fragment(tx, skb, hdrlen, frag_threshold))
958 return TX_DROP; 958 return TX_DROP;
959 959
960 /* update duration/seq/flags of fragments */ 960 /* update duration/seq/flags of fragments */
961 fragnum = 0; 961 fragnum = 0;
962 962
963 skb_queue_walk(&tx->skbs, skb) { 963 skb_queue_walk(&tx->skbs, skb) {
964 const __le16 morefrags = cpu_to_le16(IEEE80211_FCTL_MOREFRAGS); 964 const __le16 morefrags = cpu_to_le16(IEEE80211_FCTL_MOREFRAGS);
965 965
966 hdr = (void *)skb->data; 966 hdr = (void *)skb->data;
967 info = IEEE80211_SKB_CB(skb); 967 info = IEEE80211_SKB_CB(skb);
968 968
969 if (!skb_queue_is_last(&tx->skbs, skb)) { 969 if (!skb_queue_is_last(&tx->skbs, skb)) {
970 hdr->frame_control |= morefrags; 970 hdr->frame_control |= morefrags;
971 /* 971 /*
972 * No multi-rate retries for fragmented frames, that 972 * No multi-rate retries for fragmented frames, that
973 * would completely throw off the NAV at other STAs. 973 * would completely throw off the NAV at other STAs.
974 */ 974 */
975 info->control.rates[1].idx = -1; 975 info->control.rates[1].idx = -1;
976 info->control.rates[2].idx = -1; 976 info->control.rates[2].idx = -1;
977 info->control.rates[3].idx = -1; 977 info->control.rates[3].idx = -1;
978 BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 4); 978 BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 4);
979 info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE; 979 info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
980 } else { 980 } else {
981 hdr->frame_control &= ~morefrags; 981 hdr->frame_control &= ~morefrags;
982 } 982 }
983 hdr->seq_ctrl |= cpu_to_le16(fragnum & IEEE80211_SCTL_FRAG); 983 hdr->seq_ctrl |= cpu_to_le16(fragnum & IEEE80211_SCTL_FRAG);
984 fragnum++; 984 fragnum++;
985 } 985 }
986 986
987 return TX_CONTINUE; 987 return TX_CONTINUE;
988 } 988 }
989 989
990 static ieee80211_tx_result debug_noinline 990 static ieee80211_tx_result debug_noinline
991 ieee80211_tx_h_stats(struct ieee80211_tx_data *tx) 991 ieee80211_tx_h_stats(struct ieee80211_tx_data *tx)
992 { 992 {
993 struct sk_buff *skb; 993 struct sk_buff *skb;
994 994
995 if (!tx->sta) 995 if (!tx->sta)
996 return TX_CONTINUE; 996 return TX_CONTINUE;
997 997
998 tx->sta->tx_packets++; 998 tx->sta->tx_packets++;
999 skb_queue_walk(&tx->skbs, skb) { 999 skb_queue_walk(&tx->skbs, skb) {
1000 tx->sta->tx_fragments++; 1000 tx->sta->tx_fragments++;
1001 tx->sta->tx_bytes += skb->len; 1001 tx->sta->tx_bytes += skb->len;
1002 } 1002 }
1003 1003
1004 return TX_CONTINUE; 1004 return TX_CONTINUE;
1005 } 1005 }
1006 1006
1007 static ieee80211_tx_result debug_noinline 1007 static ieee80211_tx_result debug_noinline
1008 ieee80211_tx_h_encrypt(struct ieee80211_tx_data *tx) 1008 ieee80211_tx_h_encrypt(struct ieee80211_tx_data *tx)
1009 { 1009 {
1010 if (!tx->key) 1010 if (!tx->key)
1011 return TX_CONTINUE; 1011 return TX_CONTINUE;
1012 1012
1013 switch (tx->key->conf.cipher) { 1013 switch (tx->key->conf.cipher) {
1014 case WLAN_CIPHER_SUITE_WEP40: 1014 case WLAN_CIPHER_SUITE_WEP40:
1015 case WLAN_CIPHER_SUITE_WEP104: 1015 case WLAN_CIPHER_SUITE_WEP104:
1016 return ieee80211_crypto_wep_encrypt(tx); 1016 return ieee80211_crypto_wep_encrypt(tx);
1017 case WLAN_CIPHER_SUITE_TKIP: 1017 case WLAN_CIPHER_SUITE_TKIP:
1018 return ieee80211_crypto_tkip_encrypt(tx); 1018 return ieee80211_crypto_tkip_encrypt(tx);
1019 case WLAN_CIPHER_SUITE_CCMP: 1019 case WLAN_CIPHER_SUITE_CCMP:
1020 return ieee80211_crypto_ccmp_encrypt(tx); 1020 return ieee80211_crypto_ccmp_encrypt(tx);
1021 case WLAN_CIPHER_SUITE_AES_CMAC: 1021 case WLAN_CIPHER_SUITE_AES_CMAC:
1022 return ieee80211_crypto_aes_cmac_encrypt(tx); 1022 return ieee80211_crypto_aes_cmac_encrypt(tx);
1023 default: 1023 default:
1024 return ieee80211_crypto_hw_encrypt(tx); 1024 return ieee80211_crypto_hw_encrypt(tx);
1025 } 1025 }
1026 1026
1027 return TX_DROP; 1027 return TX_DROP;
1028 } 1028 }
1029 1029
1030 static ieee80211_tx_result debug_noinline 1030 static ieee80211_tx_result debug_noinline
1031 ieee80211_tx_h_calculate_duration(struct ieee80211_tx_data *tx) 1031 ieee80211_tx_h_calculate_duration(struct ieee80211_tx_data *tx)
1032 { 1032 {
1033 struct sk_buff *skb; 1033 struct sk_buff *skb;
1034 struct ieee80211_hdr *hdr; 1034 struct ieee80211_hdr *hdr;
1035 int next_len; 1035 int next_len;
1036 bool group_addr; 1036 bool group_addr;
1037 1037
1038 skb_queue_walk(&tx->skbs, skb) { 1038 skb_queue_walk(&tx->skbs, skb) {
1039 hdr = (void *) skb->data; 1039 hdr = (void *) skb->data;
1040 if (unlikely(ieee80211_is_pspoll(hdr->frame_control))) 1040 if (unlikely(ieee80211_is_pspoll(hdr->frame_control)))
1041 break; /* must not overwrite AID */ 1041 break; /* must not overwrite AID */
1042 if (!skb_queue_is_last(&tx->skbs, skb)) { 1042 if (!skb_queue_is_last(&tx->skbs, skb)) {
1043 struct sk_buff *next = skb_queue_next(&tx->skbs, skb); 1043 struct sk_buff *next = skb_queue_next(&tx->skbs, skb);
1044 next_len = next->len; 1044 next_len = next->len;
1045 } else 1045 } else
1046 next_len = 0; 1046 next_len = 0;
1047 group_addr = is_multicast_ether_addr(hdr->addr1); 1047 group_addr = is_multicast_ether_addr(hdr->addr1);
1048 1048
1049 hdr->duration_id = 1049 hdr->duration_id =
1050 ieee80211_duration(tx, skb, group_addr, next_len); 1050 ieee80211_duration(tx, skb, group_addr, next_len);
1051 } 1051 }
1052 1052
1053 return TX_CONTINUE; 1053 return TX_CONTINUE;
1054 } 1054 }
1055 1055
1056 /* actual transmit path */ 1056 /* actual transmit path */
1057 1057
1058 static bool ieee80211_tx_prep_agg(struct ieee80211_tx_data *tx, 1058 static bool ieee80211_tx_prep_agg(struct ieee80211_tx_data *tx,
1059 struct sk_buff *skb, 1059 struct sk_buff *skb,
1060 struct ieee80211_tx_info *info, 1060 struct ieee80211_tx_info *info,
1061 struct tid_ampdu_tx *tid_tx, 1061 struct tid_ampdu_tx *tid_tx,
1062 int tid) 1062 int tid)
1063 { 1063 {
1064 bool queued = false; 1064 bool queued = false;
1065 bool reset_agg_timer = false; 1065 bool reset_agg_timer = false;
1066 struct sk_buff *purge_skb = NULL; 1066 struct sk_buff *purge_skb = NULL;
1067 1067
1068 if (test_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state)) { 1068 if (test_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state)) {
1069 info->flags |= IEEE80211_TX_CTL_AMPDU; 1069 info->flags |= IEEE80211_TX_CTL_AMPDU;
1070 reset_agg_timer = true; 1070 reset_agg_timer = true;
1071 } else if (test_bit(HT_AGG_STATE_WANT_START, &tid_tx->state)) { 1071 } else if (test_bit(HT_AGG_STATE_WANT_START, &tid_tx->state)) {
1072 /* 1072 /*
1073 * nothing -- this aggregation session is being started 1073 * nothing -- this aggregation session is being started
1074 * but that might still fail with the driver 1074 * but that might still fail with the driver
1075 */ 1075 */
1076 } else { 1076 } else {
1077 spin_lock(&tx->sta->lock); 1077 spin_lock(&tx->sta->lock);
1078 /* 1078 /*
1079 * Need to re-check now, because we may get here 1079 * Need to re-check now, because we may get here
1080 * 1080 *
1081 * 1) in the window during which the setup is actually 1081 * 1) in the window during which the setup is actually
1082 * already done, but not marked yet because not all 1082 * already done, but not marked yet because not all
1083 * packets are spliced over to the driver pending 1083 * packets are spliced over to the driver pending
1084 * queue yet -- if this happened we acquire the lock 1084 * queue yet -- if this happened we acquire the lock
1085 * either before or after the splice happens, but 1085 * either before or after the splice happens, but
1086 * need to recheck which of these cases happened. 1086 * need to recheck which of these cases happened.
1087 * 1087 *
1088 * 2) during session teardown, if the OPERATIONAL bit 1088 * 2) during session teardown, if the OPERATIONAL bit
1089 * was cleared due to the teardown but the pointer 1089 * was cleared due to the teardown but the pointer
1090 * hasn't been assigned NULL yet (or we loaded it 1090 * hasn't been assigned NULL yet (or we loaded it
1091 * before it was assigned) -- in this case it may 1091 * before it was assigned) -- in this case it may
1092 * now be NULL which means we should just let the 1092 * now be NULL which means we should just let the
1093 * packet pass through because splicing the frames 1093 * packet pass through because splicing the frames
1094 * back is already done. 1094 * back is already done.
1095 */ 1095 */
1096 tid_tx = rcu_dereference_protected_tid_tx(tx->sta, tid); 1096 tid_tx = rcu_dereference_protected_tid_tx(tx->sta, tid);
1097 1097
1098 if (!tid_tx) { 1098 if (!tid_tx) {
1099 /* do nothing, let packet pass through */ 1099 /* do nothing, let packet pass through */
1100 } else if (test_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state)) { 1100 } else if (test_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state)) {
1101 info->flags |= IEEE80211_TX_CTL_AMPDU; 1101 info->flags |= IEEE80211_TX_CTL_AMPDU;
1102 reset_agg_timer = true; 1102 reset_agg_timer = true;
1103 } else { 1103 } else {
1104 queued = true; 1104 queued = true;
1105 info->control.vif = &tx->sdata->vif; 1105 info->control.vif = &tx->sdata->vif;
1106 info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING; 1106 info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
1107 __skb_queue_tail(&tid_tx->pending, skb); 1107 __skb_queue_tail(&tid_tx->pending, skb);
1108 if (skb_queue_len(&tid_tx->pending) > STA_MAX_TX_BUFFER) 1108 if (skb_queue_len(&tid_tx->pending) > STA_MAX_TX_BUFFER)
1109 purge_skb = __skb_dequeue(&tid_tx->pending); 1109 purge_skb = __skb_dequeue(&tid_tx->pending);
1110 } 1110 }
1111 spin_unlock(&tx->sta->lock); 1111 spin_unlock(&tx->sta->lock);
1112 1112
1113 if (purge_skb) 1113 if (purge_skb)
1114 ieee80211_free_txskb(&tx->local->hw, purge_skb); 1114 ieee80211_free_txskb(&tx->local->hw, purge_skb);
1115 } 1115 }
1116 1116
1117 /* reset session timer */ 1117 /* reset session timer */
1118 if (reset_agg_timer && tid_tx->timeout) 1118 if (reset_agg_timer && tid_tx->timeout)
1119 tid_tx->last_tx = jiffies; 1119 tid_tx->last_tx = jiffies;
1120 1120
1121 return queued; 1121 return queued;
1122 } 1122 }
1123 1123
1124 /* 1124 /*
1125 * initialises @tx 1125 * initialises @tx
1126 */ 1126 */
1127 static ieee80211_tx_result 1127 static ieee80211_tx_result
1128 ieee80211_tx_prepare(struct ieee80211_sub_if_data *sdata, 1128 ieee80211_tx_prepare(struct ieee80211_sub_if_data *sdata,
1129 struct ieee80211_tx_data *tx, 1129 struct ieee80211_tx_data *tx,
1130 struct sk_buff *skb) 1130 struct sk_buff *skb)
1131 { 1131 {
1132 struct ieee80211_local *local = sdata->local; 1132 struct ieee80211_local *local = sdata->local;
1133 struct ieee80211_hdr *hdr; 1133 struct ieee80211_hdr *hdr;
1134 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1134 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1135 int tid; 1135 int tid;
1136 u8 *qc; 1136 u8 *qc;
1137 1137
1138 memset(tx, 0, sizeof(*tx)); 1138 memset(tx, 0, sizeof(*tx));
1139 tx->skb = skb; 1139 tx->skb = skb;
1140 tx->local = local; 1140 tx->local = local;
1141 tx->sdata = sdata; 1141 tx->sdata = sdata;
1142 __skb_queue_head_init(&tx->skbs); 1142 __skb_queue_head_init(&tx->skbs);
1143 1143
1144 /* 1144 /*
1145 * If this flag is set to true anywhere, and we get here, 1145 * If this flag is set to true anywhere, and we get here,
1146 * we are doing the needed processing, so remove the flag 1146 * we are doing the needed processing, so remove the flag
1147 * now. 1147 * now.
1148 */ 1148 */
1149 info->flags &= ~IEEE80211_TX_INTFL_NEED_TXPROCESSING; 1149 info->flags &= ~IEEE80211_TX_INTFL_NEED_TXPROCESSING;
1150 1150
1151 hdr = (struct ieee80211_hdr *) skb->data; 1151 hdr = (struct ieee80211_hdr *) skb->data;
1152 1152
1153 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) { 1153 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
1154 tx->sta = rcu_dereference(sdata->u.vlan.sta); 1154 tx->sta = rcu_dereference(sdata->u.vlan.sta);
1155 if (!tx->sta && sdata->dev->ieee80211_ptr->use_4addr) 1155 if (!tx->sta && sdata->dev->ieee80211_ptr->use_4addr)
1156 return TX_DROP; 1156 return TX_DROP;
1157 } else if (info->flags & IEEE80211_TX_CTL_INJECTED || 1157 } else if (info->flags & IEEE80211_TX_CTL_INJECTED ||
1158 tx->sdata->control_port_protocol == tx->skb->protocol) { 1158 tx->sdata->control_port_protocol == tx->skb->protocol) {
1159 tx->sta = sta_info_get_bss(sdata, hdr->addr1); 1159 tx->sta = sta_info_get_bss(sdata, hdr->addr1);
1160 } 1160 }
1161 if (!tx->sta) 1161 if (!tx->sta)
1162 tx->sta = sta_info_get(sdata, hdr->addr1); 1162 tx->sta = sta_info_get(sdata, hdr->addr1);
1163 1163
1164 if (tx->sta && ieee80211_is_data_qos(hdr->frame_control) && 1164 if (tx->sta && ieee80211_is_data_qos(hdr->frame_control) &&
1165 !ieee80211_is_qos_nullfunc(hdr->frame_control) && 1165 !ieee80211_is_qos_nullfunc(hdr->frame_control) &&
1166 (local->hw.flags & IEEE80211_HW_AMPDU_AGGREGATION) && 1166 (local->hw.flags & IEEE80211_HW_AMPDU_AGGREGATION) &&
1167 !(local->hw.flags & IEEE80211_HW_TX_AMPDU_SETUP_IN_HW)) { 1167 !(local->hw.flags & IEEE80211_HW_TX_AMPDU_SETUP_IN_HW)) {
1168 struct tid_ampdu_tx *tid_tx; 1168 struct tid_ampdu_tx *tid_tx;
1169 1169
1170 qc = ieee80211_get_qos_ctl(hdr); 1170 qc = ieee80211_get_qos_ctl(hdr);
1171 tid = *qc & IEEE80211_QOS_CTL_TID_MASK; 1171 tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
1172 1172
1173 tid_tx = rcu_dereference(tx->sta->ampdu_mlme.tid_tx[tid]); 1173 tid_tx = rcu_dereference(tx->sta->ampdu_mlme.tid_tx[tid]);
1174 if (tid_tx) { 1174 if (tid_tx) {
1175 bool queued; 1175 bool queued;
1176 1176
1177 queued = ieee80211_tx_prep_agg(tx, skb, info, 1177 queued = ieee80211_tx_prep_agg(tx, skb, info,
1178 tid_tx, tid); 1178 tid_tx, tid);
1179 1179
1180 if (unlikely(queued)) 1180 if (unlikely(queued))
1181 return TX_QUEUED; 1181 return TX_QUEUED;
1182 } 1182 }
1183 } 1183 }
1184 1184
1185 if (is_multicast_ether_addr(hdr->addr1)) { 1185 if (is_multicast_ether_addr(hdr->addr1)) {
1186 tx->flags &= ~IEEE80211_TX_UNICAST; 1186 tx->flags &= ~IEEE80211_TX_UNICAST;
1187 info->flags |= IEEE80211_TX_CTL_NO_ACK; 1187 info->flags |= IEEE80211_TX_CTL_NO_ACK;
1188 } else 1188 } else
1189 tx->flags |= IEEE80211_TX_UNICAST; 1189 tx->flags |= IEEE80211_TX_UNICAST;
1190 1190
1191 if (!(info->flags & IEEE80211_TX_CTL_DONTFRAG)) { 1191 if (!(info->flags & IEEE80211_TX_CTL_DONTFRAG)) {
1192 if (!(tx->flags & IEEE80211_TX_UNICAST) || 1192 if (!(tx->flags & IEEE80211_TX_UNICAST) ||
1193 skb->len + FCS_LEN <= local->hw.wiphy->frag_threshold || 1193 skb->len + FCS_LEN <= local->hw.wiphy->frag_threshold ||
1194 info->flags & IEEE80211_TX_CTL_AMPDU) 1194 info->flags & IEEE80211_TX_CTL_AMPDU)
1195 info->flags |= IEEE80211_TX_CTL_DONTFRAG; 1195 info->flags |= IEEE80211_TX_CTL_DONTFRAG;
1196 } 1196 }
1197 1197
1198 if (!tx->sta) 1198 if (!tx->sta)
1199 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT; 1199 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
1200 else if (test_and_clear_sta_flag(tx->sta, WLAN_STA_CLEAR_PS_FILT)) 1200 else if (test_and_clear_sta_flag(tx->sta, WLAN_STA_CLEAR_PS_FILT))
1201 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT; 1201 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
1202 1202
1203 info->flags |= IEEE80211_TX_CTL_FIRST_FRAGMENT; 1203 info->flags |= IEEE80211_TX_CTL_FIRST_FRAGMENT;
1204 1204
1205 return TX_CONTINUE; 1205 return TX_CONTINUE;
1206 } 1206 }
1207 1207
1208 static bool ieee80211_tx_frags(struct ieee80211_local *local, 1208 static bool ieee80211_tx_frags(struct ieee80211_local *local,
1209 struct ieee80211_vif *vif, 1209 struct ieee80211_vif *vif,
1210 struct ieee80211_sta *sta, 1210 struct ieee80211_sta *sta,
1211 struct sk_buff_head *skbs, 1211 struct sk_buff_head *skbs,
1212 bool txpending) 1212 bool txpending)
1213 { 1213 {
1214 struct ieee80211_tx_control control; 1214 struct ieee80211_tx_control control;
1215 struct sk_buff *skb, *tmp; 1215 struct sk_buff *skb, *tmp;
1216 unsigned long flags; 1216 unsigned long flags;
1217 1217
1218 skb_queue_walk_safe(skbs, skb, tmp) { 1218 skb_queue_walk_safe(skbs, skb, tmp) {
1219 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1219 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1220 int q = info->hw_queue; 1220 int q = info->hw_queue;
1221 1221
1222 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 1222 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1223 if (WARN_ON_ONCE(q >= local->hw.queues)) { 1223 if (WARN_ON_ONCE(q >= local->hw.queues)) {
1224 __skb_unlink(skb, skbs); 1224 __skb_unlink(skb, skbs);
1225 ieee80211_free_txskb(&local->hw, skb); 1225 ieee80211_free_txskb(&local->hw, skb);
1226 continue; 1226 continue;
1227 } 1227 }
1228 #endif 1228 #endif
1229 1229
1230 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 1230 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
1231 if (local->queue_stop_reasons[q] || 1231 if (local->queue_stop_reasons[q] ||
1232 (!txpending && !skb_queue_empty(&local->pending[q]))) { 1232 (!txpending && !skb_queue_empty(&local->pending[q]))) {
1233 if (unlikely(info->flags & 1233 if (unlikely(info->flags &
1234 IEEE80211_TX_INTFL_OFFCHAN_TX_OK && 1234 IEEE80211_TX_INTFL_OFFCHAN_TX_OK &&
1235 local->queue_stop_reasons[q] & 1235 local->queue_stop_reasons[q] &
1236 ~BIT(IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL))) { 1236 ~BIT(IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL))) {
1237 /* 1237 /*
1238 * Drop off-channel frames if queues are stopped 1238 * Drop off-channel frames if queues are stopped
1239 * for any reason other than off-channel 1239 * for any reason other than off-channel
1240 * operation. Never queue them. 1240 * operation. Never queue them.
1241 */ 1241 */
1242 spin_unlock_irqrestore( 1242 spin_unlock_irqrestore(
1243 &local->queue_stop_reason_lock, flags); 1243 &local->queue_stop_reason_lock, flags);
1244 ieee80211_purge_tx_queue(&local->hw, skbs); 1244 ieee80211_purge_tx_queue(&local->hw, skbs);
1245 return true; 1245 return true;
1246 } 1246 }
1247 1247
1248 /* 1248 /*
1249 * Since queue is stopped, queue up frames for later 1249 * Since queue is stopped, queue up frames for later
1250 * transmission from the tx-pending tasklet when the 1250 * transmission from the tx-pending tasklet when the
1251 * queue is woken again. 1251 * queue is woken again.
1252 */ 1252 */
1253 if (txpending) 1253 if (txpending)
1254 skb_queue_splice_init(skbs, &local->pending[q]); 1254 skb_queue_splice_init(skbs, &local->pending[q]);
1255 else 1255 else
1256 skb_queue_splice_tail_init(skbs, 1256 skb_queue_splice_tail_init(skbs,
1257 &local->pending[q]); 1257 &local->pending[q]);
1258 1258
1259 spin_unlock_irqrestore(&local->queue_stop_reason_lock, 1259 spin_unlock_irqrestore(&local->queue_stop_reason_lock,
1260 flags); 1260 flags);
1261 return false; 1261 return false;
1262 } 1262 }
1263 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 1263 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
1264 1264
1265 info->control.vif = vif; 1265 info->control.vif = vif;
1266 control.sta = sta; 1266 control.sta = sta;
1267 1267
1268 __skb_unlink(skb, skbs); 1268 __skb_unlink(skb, skbs);
1269 drv_tx(local, &control, skb); 1269 drv_tx(local, &control, skb);
1270 } 1270 }
1271 1271
1272 return true; 1272 return true;
1273 } 1273 }
1274 1274
1275 /* 1275 /*
1276 * Returns false if the frame couldn't be transmitted but was queued instead. 1276 * Returns false if the frame couldn't be transmitted but was queued instead.
1277 */ 1277 */
1278 static bool __ieee80211_tx(struct ieee80211_local *local, 1278 static bool __ieee80211_tx(struct ieee80211_local *local,
1279 struct sk_buff_head *skbs, int led_len, 1279 struct sk_buff_head *skbs, int led_len,
1280 struct sta_info *sta, bool txpending) 1280 struct sta_info *sta, bool txpending)
1281 { 1281 {
1282 struct ieee80211_tx_info *info; 1282 struct ieee80211_tx_info *info;
1283 struct ieee80211_sub_if_data *sdata; 1283 struct ieee80211_sub_if_data *sdata;
1284 struct ieee80211_vif *vif; 1284 struct ieee80211_vif *vif;
1285 struct ieee80211_sta *pubsta; 1285 struct ieee80211_sta *pubsta;
1286 struct sk_buff *skb; 1286 struct sk_buff *skb;
1287 bool result = true; 1287 bool result = true;
1288 __le16 fc; 1288 __le16 fc;
1289 1289
1290 if (WARN_ON(skb_queue_empty(skbs))) 1290 if (WARN_ON(skb_queue_empty(skbs)))
1291 return true; 1291 return true;
1292 1292
1293 skb = skb_peek(skbs); 1293 skb = skb_peek(skbs);
1294 fc = ((struct ieee80211_hdr *)skb->data)->frame_control; 1294 fc = ((struct ieee80211_hdr *)skb->data)->frame_control;
1295 info = IEEE80211_SKB_CB(skb); 1295 info = IEEE80211_SKB_CB(skb);
1296 sdata = vif_to_sdata(info->control.vif); 1296 sdata = vif_to_sdata(info->control.vif);
1297 if (sta && !sta->uploaded) 1297 if (sta && !sta->uploaded)
1298 sta = NULL; 1298 sta = NULL;
1299 1299
1300 if (sta) 1300 if (sta)
1301 pubsta = &sta->sta; 1301 pubsta = &sta->sta;
1302 else 1302 else
1303 pubsta = NULL; 1303 pubsta = NULL;
1304 1304
1305 switch (sdata->vif.type) { 1305 switch (sdata->vif.type) {
1306 case NL80211_IFTYPE_MONITOR: 1306 case NL80211_IFTYPE_MONITOR:
1307 sdata = rcu_dereference(local->monitor_sdata); 1307 sdata = rcu_dereference(local->monitor_sdata);
1308 if (sdata) { 1308 if (sdata) {
1309 vif = &sdata->vif; 1309 vif = &sdata->vif;
1310 info->hw_queue = 1310 info->hw_queue =
1311 vif->hw_queue[skb_get_queue_mapping(skb)]; 1311 vif->hw_queue[skb_get_queue_mapping(skb)];
1312 } else if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL) { 1312 } else if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL) {
1313 dev_kfree_skb(skb); 1313 dev_kfree_skb(skb);
1314 return true; 1314 return true;
1315 } else 1315 } else
1316 vif = NULL; 1316 vif = NULL;
1317 break; 1317 break;
1318 case NL80211_IFTYPE_AP_VLAN: 1318 case NL80211_IFTYPE_AP_VLAN:
1319 sdata = container_of(sdata->bss, 1319 sdata = container_of(sdata->bss,
1320 struct ieee80211_sub_if_data, u.ap); 1320 struct ieee80211_sub_if_data, u.ap);
1321 /* fall through */ 1321 /* fall through */
1322 default: 1322 default:
1323 vif = &sdata->vif; 1323 vif = &sdata->vif;
1324 break; 1324 break;
1325 } 1325 }
1326 1326
1327 result = ieee80211_tx_frags(local, vif, pubsta, skbs, 1327 result = ieee80211_tx_frags(local, vif, pubsta, skbs,
1328 txpending); 1328 txpending);
1329 1329
1330 ieee80211_tpt_led_trig_tx(local, fc, led_len); 1330 ieee80211_tpt_led_trig_tx(local, fc, led_len);
1331 ieee80211_led_tx(local, 1); 1331 ieee80211_led_tx(local, 1);
1332 1332
1333 WARN_ON_ONCE(!skb_queue_empty(skbs)); 1333 WARN_ON_ONCE(!skb_queue_empty(skbs));
1334 1334
1335 return result; 1335 return result;
1336 } 1336 }
1337 1337
1338 /* 1338 /*
1339 * Invoke TX handlers, return 0 on success and non-zero if the 1339 * Invoke TX handlers, return 0 on success and non-zero if the
1340 * frame was dropped or queued. 1340 * frame was dropped or queued.
1341 */ 1341 */
1342 static int invoke_tx_handlers(struct ieee80211_tx_data *tx) 1342 static int invoke_tx_handlers(struct ieee80211_tx_data *tx)
1343 { 1343 {
1344 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); 1344 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
1345 ieee80211_tx_result res = TX_DROP; 1345 ieee80211_tx_result res = TX_DROP;
1346 1346
1347 #define CALL_TXH(txh) \ 1347 #define CALL_TXH(txh) \
1348 do { \ 1348 do { \
1349 res = txh(tx); \ 1349 res = txh(tx); \
1350 if (res != TX_CONTINUE) \ 1350 if (res != TX_CONTINUE) \
1351 goto txh_done; \ 1351 goto txh_done; \
1352 } while (0) 1352 } while (0)
1353 1353
1354 CALL_TXH(ieee80211_tx_h_dynamic_ps); 1354 CALL_TXH(ieee80211_tx_h_dynamic_ps);
1355 CALL_TXH(ieee80211_tx_h_check_assoc); 1355 CALL_TXH(ieee80211_tx_h_check_assoc);
1356 CALL_TXH(ieee80211_tx_h_ps_buf); 1356 CALL_TXH(ieee80211_tx_h_ps_buf);
1357 CALL_TXH(ieee80211_tx_h_check_control_port_protocol); 1357 CALL_TXH(ieee80211_tx_h_check_control_port_protocol);
1358 CALL_TXH(ieee80211_tx_h_select_key); 1358 CALL_TXH(ieee80211_tx_h_select_key);
1359 if (!(tx->local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL)) 1359 if (!(tx->local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL))
1360 CALL_TXH(ieee80211_tx_h_rate_ctrl); 1360 CALL_TXH(ieee80211_tx_h_rate_ctrl);
1361 1361
1362 if (unlikely(info->flags & IEEE80211_TX_INTFL_RETRANSMISSION)) { 1362 if (unlikely(info->flags & IEEE80211_TX_INTFL_RETRANSMISSION)) {
1363 __skb_queue_tail(&tx->skbs, tx->skb); 1363 __skb_queue_tail(&tx->skbs, tx->skb);
1364 tx->skb = NULL; 1364 tx->skb = NULL;
1365 goto txh_done; 1365 goto txh_done;
1366 } 1366 }
1367 1367
1368 CALL_TXH(ieee80211_tx_h_michael_mic_add); 1368 CALL_TXH(ieee80211_tx_h_michael_mic_add);
1369 CALL_TXH(ieee80211_tx_h_sequence); 1369 CALL_TXH(ieee80211_tx_h_sequence);
1370 CALL_TXH(ieee80211_tx_h_fragment); 1370 CALL_TXH(ieee80211_tx_h_fragment);
1371 /* handlers after fragment must be aware of tx info fragmentation! */ 1371 /* handlers after fragment must be aware of tx info fragmentation! */
1372 CALL_TXH(ieee80211_tx_h_stats); 1372 CALL_TXH(ieee80211_tx_h_stats);
1373 CALL_TXH(ieee80211_tx_h_encrypt); 1373 CALL_TXH(ieee80211_tx_h_encrypt);
1374 if (!(tx->local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL)) 1374 if (!(tx->local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL))
1375 CALL_TXH(ieee80211_tx_h_calculate_duration); 1375 CALL_TXH(ieee80211_tx_h_calculate_duration);
1376 #undef CALL_TXH 1376 #undef CALL_TXH
1377 1377
1378 txh_done: 1378 txh_done:
1379 if (unlikely(res == TX_DROP)) { 1379 if (unlikely(res == TX_DROP)) {
1380 I802_DEBUG_INC(tx->local->tx_handlers_drop); 1380 I802_DEBUG_INC(tx->local->tx_handlers_drop);
1381 if (tx->skb) 1381 if (tx->skb)
1382 ieee80211_free_txskb(&tx->local->hw, tx->skb); 1382 ieee80211_free_txskb(&tx->local->hw, tx->skb);
1383 else 1383 else
1384 ieee80211_purge_tx_queue(&tx->local->hw, &tx->skbs); 1384 ieee80211_purge_tx_queue(&tx->local->hw, &tx->skbs);
1385 return -1; 1385 return -1;
1386 } else if (unlikely(res == TX_QUEUED)) { 1386 } else if (unlikely(res == TX_QUEUED)) {
1387 I802_DEBUG_INC(tx->local->tx_handlers_queued); 1387 I802_DEBUG_INC(tx->local->tx_handlers_queued);
1388 return -1; 1388 return -1;
1389 } 1389 }
1390 1390
1391 return 0; 1391 return 0;
1392 } 1392 }
1393 1393
1394 /* 1394 /*
1395 * Returns false if the frame couldn't be transmitted but was queued instead. 1395 * Returns false if the frame couldn't be transmitted but was queued instead.
1396 */ 1396 */
1397 static bool ieee80211_tx(struct ieee80211_sub_if_data *sdata, 1397 static bool ieee80211_tx(struct ieee80211_sub_if_data *sdata,
1398 struct sk_buff *skb, bool txpending, 1398 struct sk_buff *skb, bool txpending,
1399 enum ieee80211_band band) 1399 enum ieee80211_band band)
1400 { 1400 {
1401 struct ieee80211_local *local = sdata->local; 1401 struct ieee80211_local *local = sdata->local;
1402 struct ieee80211_tx_data tx; 1402 struct ieee80211_tx_data tx;
1403 ieee80211_tx_result res_prepare; 1403 ieee80211_tx_result res_prepare;
1404 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1404 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1405 bool result = true; 1405 bool result = true;
1406 int led_len; 1406 int led_len;
1407 1407
1408 if (unlikely(skb->len < 10)) { 1408 if (unlikely(skb->len < 10)) {
1409 dev_kfree_skb(skb); 1409 dev_kfree_skb(skb);
1410 return true; 1410 return true;
1411 } 1411 }
1412 1412
1413 /* initialises tx */ 1413 /* initialises tx */
1414 led_len = skb->len; 1414 led_len = skb->len;
1415 res_prepare = ieee80211_tx_prepare(sdata, &tx, skb); 1415 res_prepare = ieee80211_tx_prepare(sdata, &tx, skb);
1416 1416
1417 if (unlikely(res_prepare == TX_DROP)) { 1417 if (unlikely(res_prepare == TX_DROP)) {
1418 ieee80211_free_txskb(&local->hw, skb); 1418 ieee80211_free_txskb(&local->hw, skb);
1419 return true; 1419 return true;
1420 } else if (unlikely(res_prepare == TX_QUEUED)) { 1420 } else if (unlikely(res_prepare == TX_QUEUED)) {
1421 return true; 1421 return true;
1422 } 1422 }
1423 1423
1424 info->band = band; 1424 info->band = band;
1425 1425
1426 /* set up hw_queue value early */ 1426 /* set up hw_queue value early */
1427 if (!(info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) || 1427 if (!(info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) ||
1428 !(local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)) 1428 !(local->hw.flags & IEEE80211_HW_QUEUE_CONTROL))
1429 info->hw_queue = 1429 info->hw_queue =
1430 sdata->vif.hw_queue[skb_get_queue_mapping(skb)]; 1430 sdata->vif.hw_queue[skb_get_queue_mapping(skb)];
1431 1431
1432 if (!invoke_tx_handlers(&tx)) 1432 if (!invoke_tx_handlers(&tx))
1433 result = __ieee80211_tx(local, &tx.skbs, led_len, 1433 result = __ieee80211_tx(local, &tx.skbs, led_len,
1434 tx.sta, txpending); 1434 tx.sta, txpending);
1435 1435
1436 return result; 1436 return result;
1437 } 1437 }
1438 1438
1439 /* device xmit handlers */ 1439 /* device xmit handlers */
1440 1440
1441 static int ieee80211_skb_resize(struct ieee80211_sub_if_data *sdata, 1441 static int ieee80211_skb_resize(struct ieee80211_sub_if_data *sdata,
1442 struct sk_buff *skb, 1442 struct sk_buff *skb,
1443 int head_need, bool may_encrypt) 1443 int head_need, bool may_encrypt)
1444 { 1444 {
1445 struct ieee80211_local *local = sdata->local; 1445 struct ieee80211_local *local = sdata->local;
1446 int tail_need = 0; 1446 int tail_need = 0;
1447 1447
1448 if (may_encrypt && sdata->crypto_tx_tailroom_needed_cnt) { 1448 if (may_encrypt && sdata->crypto_tx_tailroom_needed_cnt) {
1449 tail_need = IEEE80211_ENCRYPT_TAILROOM; 1449 tail_need = IEEE80211_ENCRYPT_TAILROOM;
1450 tail_need -= skb_tailroom(skb); 1450 tail_need -= skb_tailroom(skb);
1451 tail_need = max_t(int, tail_need, 0); 1451 tail_need = max_t(int, tail_need, 0);
1452 } 1452 }
1453 1453
1454 if (skb_cloned(skb)) 1454 if (skb_cloned(skb))
1455 I802_DEBUG_INC(local->tx_expand_skb_head_cloned); 1455 I802_DEBUG_INC(local->tx_expand_skb_head_cloned);
1456 else if (head_need || tail_need) 1456 else if (head_need || tail_need)
1457 I802_DEBUG_INC(local->tx_expand_skb_head); 1457 I802_DEBUG_INC(local->tx_expand_skb_head);
1458 else 1458 else
1459 return 0; 1459 return 0;
1460 1460
1461 if (pskb_expand_head(skb, head_need, tail_need, GFP_ATOMIC)) { 1461 if (pskb_expand_head(skb, head_need, tail_need, GFP_ATOMIC)) {
1462 wiphy_debug(local->hw.wiphy, 1462 wiphy_debug(local->hw.wiphy,
1463 "failed to reallocate TX buffer\n"); 1463 "failed to reallocate TX buffer\n");
1464 return -ENOMEM; 1464 return -ENOMEM;
1465 } 1465 }
1466 1466
1467 return 0; 1467 return 0;
1468 } 1468 }
1469 1469
1470 void ieee80211_xmit(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb, 1470 void ieee80211_xmit(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
1471 enum ieee80211_band band) 1471 enum ieee80211_band band)
1472 { 1472 {
1473 struct ieee80211_local *local = sdata->local; 1473 struct ieee80211_local *local = sdata->local;
1474 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1474 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1475 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 1475 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1476 int headroom; 1476 int headroom;
1477 bool may_encrypt; 1477 bool may_encrypt;
1478 1478
1479 may_encrypt = !(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT); 1479 may_encrypt = !(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT);
1480 1480
1481 headroom = local->tx_headroom; 1481 headroom = local->tx_headroom;
1482 if (may_encrypt) 1482 if (may_encrypt)
1483 headroom += IEEE80211_ENCRYPT_HEADROOM; 1483 headroom += IEEE80211_ENCRYPT_HEADROOM;
1484 headroom -= skb_headroom(skb); 1484 headroom -= skb_headroom(skb);
1485 headroom = max_t(int, 0, headroom); 1485 headroom = max_t(int, 0, headroom);
1486 1486
1487 if (ieee80211_skb_resize(sdata, skb, headroom, may_encrypt)) { 1487 if (ieee80211_skb_resize(sdata, skb, headroom, may_encrypt)) {
1488 ieee80211_free_txskb(&local->hw, skb); 1488 ieee80211_free_txskb(&local->hw, skb);
1489 return; 1489 return;
1490 } 1490 }
1491 1491
1492 hdr = (struct ieee80211_hdr *) skb->data; 1492 hdr = (struct ieee80211_hdr *) skb->data;
1493 info->control.vif = &sdata->vif; 1493 info->control.vif = &sdata->vif;
1494 1494
1495 if (ieee80211_vif_is_mesh(&sdata->vif)) { 1495 if (ieee80211_vif_is_mesh(&sdata->vif)) {
1496 if (ieee80211_is_data(hdr->frame_control) && 1496 if (ieee80211_is_data(hdr->frame_control) &&
1497 is_unicast_ether_addr(hdr->addr1)) { 1497 is_unicast_ether_addr(hdr->addr1)) {
1498 if (mesh_nexthop_resolve(sdata, skb)) 1498 if (mesh_nexthop_resolve(sdata, skb))
1499 return; /* skb queued: don't free */ 1499 return; /* skb queued: don't free */
1500 } else { 1500 } else {
1501 ieee80211_mps_set_frame_flags(sdata, NULL, hdr); 1501 ieee80211_mps_set_frame_flags(sdata, NULL, hdr);
1502 } 1502 }
1503 } 1503 }
1504 1504
1505 ieee80211_set_qos_hdr(sdata, skb); 1505 ieee80211_set_qos_hdr(sdata, skb);
1506 ieee80211_tx(sdata, skb, false, band); 1506 ieee80211_tx(sdata, skb, false, band);
1507 } 1507 }
1508 1508
1509 static bool ieee80211_parse_tx_radiotap(struct sk_buff *skb) 1509 static bool ieee80211_parse_tx_radiotap(struct sk_buff *skb)
1510 { 1510 {
1511 struct ieee80211_radiotap_iterator iterator; 1511 struct ieee80211_radiotap_iterator iterator;
1512 struct ieee80211_radiotap_header *rthdr = 1512 struct ieee80211_radiotap_header *rthdr =
1513 (struct ieee80211_radiotap_header *) skb->data; 1513 (struct ieee80211_radiotap_header *) skb->data;
1514 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1514 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1515 int ret = ieee80211_radiotap_iterator_init(&iterator, rthdr, skb->len, 1515 int ret = ieee80211_radiotap_iterator_init(&iterator, rthdr, skb->len,
1516 NULL); 1516 NULL);
1517 u16 txflags; 1517 u16 txflags;
1518 1518
1519 info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT | 1519 info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
1520 IEEE80211_TX_CTL_DONTFRAG; 1520 IEEE80211_TX_CTL_DONTFRAG;
1521 1521
1522 /* 1522 /*
1523 * for every radiotap entry that is present 1523 * for every radiotap entry that is present
1524 * (ieee80211_radiotap_iterator_next returns -ENOENT when no more 1524 * (ieee80211_radiotap_iterator_next returns -ENOENT when no more
1525 * entries present, or -EINVAL on error) 1525 * entries present, or -EINVAL on error)
1526 */ 1526 */
1527 1527
1528 while (!ret) { 1528 while (!ret) {
1529 ret = ieee80211_radiotap_iterator_next(&iterator); 1529 ret = ieee80211_radiotap_iterator_next(&iterator);
1530 1530
1531 if (ret) 1531 if (ret)
1532 continue; 1532 continue;
1533 1533
1534 /* see if this argument is something we can use */ 1534 /* see if this argument is something we can use */
1535 switch (iterator.this_arg_index) { 1535 switch (iterator.this_arg_index) {
1536 /* 1536 /*
1537 * You must take care when dereferencing iterator.this_arg 1537 * You must take care when dereferencing iterator.this_arg
1538 * for multibyte types... the pointer is not aligned. Use 1538 * for multibyte types... the pointer is not aligned. Use
1539 * get_unaligned((type *)iterator.this_arg) to dereference 1539 * get_unaligned((type *)iterator.this_arg) to dereference
1540 * iterator.this_arg for type "type" safely on all arches. 1540 * iterator.this_arg for type "type" safely on all arches.
1541 */ 1541 */
1542 case IEEE80211_RADIOTAP_FLAGS: 1542 case IEEE80211_RADIOTAP_FLAGS:
1543 if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) { 1543 if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) {
1544 /* 1544 /*
1545 * this indicates that the skb we have been 1545 * this indicates that the skb we have been
1546 * handed has the 32-bit FCS CRC at the end... 1546 * handed has the 32-bit FCS CRC at the end...
1547 * we should react to that by snipping it off 1547 * we should react to that by snipping it off
1548 * because it will be recomputed and added 1548 * because it will be recomputed and added
1549 * on transmission 1549 * on transmission
1550 */ 1550 */
1551 if (skb->len < (iterator._max_length + FCS_LEN)) 1551 if (skb->len < (iterator._max_length + FCS_LEN))
1552 return false; 1552 return false;
1553 1553
1554 skb_trim(skb, skb->len - FCS_LEN); 1554 skb_trim(skb, skb->len - FCS_LEN);
1555 } 1555 }
1556 if (*iterator.this_arg & IEEE80211_RADIOTAP_F_WEP) 1556 if (*iterator.this_arg & IEEE80211_RADIOTAP_F_WEP)
1557 info->flags &= ~IEEE80211_TX_INTFL_DONT_ENCRYPT; 1557 info->flags &= ~IEEE80211_TX_INTFL_DONT_ENCRYPT;
1558 if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FRAG) 1558 if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FRAG)
1559 info->flags &= ~IEEE80211_TX_CTL_DONTFRAG; 1559 info->flags &= ~IEEE80211_TX_CTL_DONTFRAG;
1560 break; 1560 break;
1561 1561
1562 case IEEE80211_RADIOTAP_TX_FLAGS: 1562 case IEEE80211_RADIOTAP_TX_FLAGS:
1563 txflags = get_unaligned_le16(iterator.this_arg); 1563 txflags = get_unaligned_le16(iterator.this_arg);
1564 if (txflags & IEEE80211_RADIOTAP_F_TX_NOACK) 1564 if (txflags & IEEE80211_RADIOTAP_F_TX_NOACK)
1565 info->flags |= IEEE80211_TX_CTL_NO_ACK; 1565 info->flags |= IEEE80211_TX_CTL_NO_ACK;
1566 break; 1566 break;
1567 1567
1568 /* 1568 /*
1569 * Please update the file 1569 * Please update the file
1570 * Documentation/networking/mac80211-injection.txt 1570 * Documentation/networking/mac80211-injection.txt
1571 * when parsing new fields here. 1571 * when parsing new fields here.
1572 */ 1572 */
1573 1573
1574 default: 1574 default:
1575 break; 1575 break;
1576 } 1576 }
1577 } 1577 }
1578 1578
1579 if (ret != -ENOENT) /* ie, if we didn't simply run out of fields */ 1579 if (ret != -ENOENT) /* ie, if we didn't simply run out of fields */
1580 return false; 1580 return false;
1581 1581
1582 /* 1582 /*
1583 * remove the radiotap header 1583 * remove the radiotap header
1584 * iterator->_max_length was sanity-checked against 1584 * iterator->_max_length was sanity-checked against
1585 * skb->len by iterator init 1585 * skb->len by iterator init
1586 */ 1586 */
1587 skb_pull(skb, iterator._max_length); 1587 skb_pull(skb, iterator._max_length);
1588 1588
1589 return true; 1589 return true;
1590 } 1590 }
1591 1591
1592 netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb, 1592 netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb,
1593 struct net_device *dev) 1593 struct net_device *dev)
1594 { 1594 {
1595 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1595 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1596 struct ieee80211_chanctx_conf *chanctx_conf; 1596 struct ieee80211_chanctx_conf *chanctx_conf;
1597 struct ieee80211_channel *chan; 1597 struct ieee80211_channel *chan;
1598 struct ieee80211_radiotap_header *prthdr = 1598 struct ieee80211_radiotap_header *prthdr =
1599 (struct ieee80211_radiotap_header *)skb->data; 1599 (struct ieee80211_radiotap_header *)skb->data;
1600 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1600 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1601 struct ieee80211_hdr *hdr; 1601 struct ieee80211_hdr *hdr;
1602 struct ieee80211_sub_if_data *tmp_sdata, *sdata; 1602 struct ieee80211_sub_if_data *tmp_sdata, *sdata;
1603 u16 len_rthdr; 1603 u16 len_rthdr;
1604 int hdrlen; 1604 int hdrlen;
1605 1605
1606 /* check for not even having the fixed radiotap header part */ 1606 /* check for not even having the fixed radiotap header part */
1607 if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header))) 1607 if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
1608 goto fail; /* too short to be possibly valid */ 1608 goto fail; /* too short to be possibly valid */
1609 1609
1610 /* is it a header version we can trust to find length from? */ 1610 /* is it a header version we can trust to find length from? */
1611 if (unlikely(prthdr->it_version)) 1611 if (unlikely(prthdr->it_version))
1612 goto fail; /* only version 0 is supported */ 1612 goto fail; /* only version 0 is supported */
1613 1613
1614 /* then there must be a radiotap header with a length we can use */ 1614 /* then there must be a radiotap header with a length we can use */
1615 len_rthdr = ieee80211_get_radiotap_len(skb->data); 1615 len_rthdr = ieee80211_get_radiotap_len(skb->data);
1616 1616
1617 /* does the skb contain enough to deliver on the alleged length? */ 1617 /* does the skb contain enough to deliver on the alleged length? */
1618 if (unlikely(skb->len < len_rthdr)) 1618 if (unlikely(skb->len < len_rthdr))
1619 goto fail; /* skb too short for claimed rt header extent */ 1619 goto fail; /* skb too short for claimed rt header extent */
1620 1620
1621 /* 1621 /*
1622 * fix up the pointers accounting for the radiotap 1622 * fix up the pointers accounting for the radiotap
1623 * header still being in there. We are being given 1623 * header still being in there. We are being given
1624 * a precooked IEEE80211 header so no need for 1624 * a precooked IEEE80211 header so no need for
1625 * normal processing 1625 * normal processing
1626 */ 1626 */
1627 skb_set_mac_header(skb, len_rthdr); 1627 skb_set_mac_header(skb, len_rthdr);
1628 /* 1628 /*
1629 * these are just fixed to the end of the rt area since we 1629 * these are just fixed to the end of the rt area since we
1630 * don't have any better information and at this point, nobody cares 1630 * don't have any better information and at this point, nobody cares
1631 */ 1631 */
1632 skb_set_network_header(skb, len_rthdr); 1632 skb_set_network_header(skb, len_rthdr);
1633 skb_set_transport_header(skb, len_rthdr); 1633 skb_set_transport_header(skb, len_rthdr);
1634 1634
1635 if (skb->len < len_rthdr + 2) 1635 if (skb->len < len_rthdr + 2)
1636 goto fail; 1636 goto fail;
1637 1637
1638 hdr = (struct ieee80211_hdr *)(skb->data + len_rthdr); 1638 hdr = (struct ieee80211_hdr *)(skb->data + len_rthdr);
1639 hdrlen = ieee80211_hdrlen(hdr->frame_control); 1639 hdrlen = ieee80211_hdrlen(hdr->frame_control);
1640 1640
1641 if (skb->len < len_rthdr + hdrlen) 1641 if (skb->len < len_rthdr + hdrlen)
1642 goto fail; 1642 goto fail;
1643 1643
1644 /* 1644 /*
1645 * Initialize skb->protocol if the injected frame is a data frame 1645 * Initialize skb->protocol if the injected frame is a data frame
1646 * carrying a rfc1042 header 1646 * carrying a rfc1042 header
1647 */ 1647 */
1648 if (ieee80211_is_data(hdr->frame_control) && 1648 if (ieee80211_is_data(hdr->frame_control) &&
1649 skb->len >= len_rthdr + hdrlen + sizeof(rfc1042_header) + 2) { 1649 skb->len >= len_rthdr + hdrlen + sizeof(rfc1042_header) + 2) {
1650 u8 *payload = (u8 *)hdr + hdrlen; 1650 u8 *payload = (u8 *)hdr + hdrlen;
1651 1651
1652 if (ether_addr_equal(payload, rfc1042_header)) 1652 if (ether_addr_equal(payload, rfc1042_header))
1653 skb->protocol = cpu_to_be16((payload[6] << 8) | 1653 skb->protocol = cpu_to_be16((payload[6] << 8) |
1654 payload[7]); 1654 payload[7]);
1655 } 1655 }
1656 1656
1657 memset(info, 0, sizeof(*info)); 1657 memset(info, 0, sizeof(*info));
1658 1658
1659 info->flags = IEEE80211_TX_CTL_REQ_TX_STATUS | 1659 info->flags = IEEE80211_TX_CTL_REQ_TX_STATUS |
1660 IEEE80211_TX_CTL_INJECTED; 1660 IEEE80211_TX_CTL_INJECTED;
1661 1661
1662 /* process and remove the injection radiotap header */ 1662 /* process and remove the injection radiotap header */
1663 if (!ieee80211_parse_tx_radiotap(skb)) 1663 if (!ieee80211_parse_tx_radiotap(skb))
1664 goto fail; 1664 goto fail;
1665 1665
1666 rcu_read_lock(); 1666 rcu_read_lock();
1667 1667
1668 /* 1668 /*
1669 * We process outgoing injected frames that have a local address 1669 * We process outgoing injected frames that have a local address
1670 * we handle as though they are non-injected frames. 1670 * we handle as though they are non-injected frames.
1671 * This code here isn't entirely correct, the local MAC address 1671 * This code here isn't entirely correct, the local MAC address
1672 * isn't always enough to find the interface to use; for proper 1672 * isn't always enough to find the interface to use; for proper
1673 * VLAN/WDS support we will need a different mechanism (which 1673 * VLAN/WDS support we will need a different mechanism (which
1674 * likely isn't going to be monitor interfaces). 1674 * likely isn't going to be monitor interfaces).
1675 */ 1675 */
1676 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1676 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1677 1677
1678 list_for_each_entry_rcu(tmp_sdata, &local->interfaces, list) { 1678 list_for_each_entry_rcu(tmp_sdata, &local->interfaces, list) {
1679 if (!ieee80211_sdata_running(tmp_sdata)) 1679 if (!ieee80211_sdata_running(tmp_sdata))
1680 continue; 1680 continue;
1681 if (tmp_sdata->vif.type == NL80211_IFTYPE_MONITOR || 1681 if (tmp_sdata->vif.type == NL80211_IFTYPE_MONITOR ||
1682 tmp_sdata->vif.type == NL80211_IFTYPE_AP_VLAN || 1682 tmp_sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
1683 tmp_sdata->vif.type == NL80211_IFTYPE_WDS) 1683 tmp_sdata->vif.type == NL80211_IFTYPE_WDS)
1684 continue; 1684 continue;
1685 if (ether_addr_equal(tmp_sdata->vif.addr, hdr->addr2)) { 1685 if (ether_addr_equal(tmp_sdata->vif.addr, hdr->addr2)) {
1686 sdata = tmp_sdata; 1686 sdata = tmp_sdata;
1687 break; 1687 break;
1688 } 1688 }
1689 } 1689 }
1690 1690
1691 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 1691 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1692 if (!chanctx_conf) { 1692 if (!chanctx_conf) {
1693 tmp_sdata = rcu_dereference(local->monitor_sdata); 1693 tmp_sdata = rcu_dereference(local->monitor_sdata);
1694 if (tmp_sdata) 1694 if (tmp_sdata)
1695 chanctx_conf = 1695 chanctx_conf =
1696 rcu_dereference(tmp_sdata->vif.chanctx_conf); 1696 rcu_dereference(tmp_sdata->vif.chanctx_conf);
1697 } 1697 }
1698 1698
1699 if (chanctx_conf) 1699 if (chanctx_conf)
1700 chan = chanctx_conf->def.chan; 1700 chan = chanctx_conf->def.chan;
1701 else if (!local->use_chanctx) 1701 else if (!local->use_chanctx)
1702 chan = local->_oper_channel; 1702 chan = local->_oper_channel;
1703 else 1703 else
1704 goto fail_rcu; 1704 goto fail_rcu;
1705 1705
1706 /* 1706 /*
1707 * Frame injection is not allowed if beaconing is not allowed 1707 * Frame injection is not allowed if beaconing is not allowed
1708 * or if we need radar detection. Beaconing is usually not allowed when 1708 * or if we need radar detection. Beaconing is usually not allowed when
1709 * the mode or operation (Adhoc, AP, Mesh) does not support DFS. 1709 * the mode or operation (Adhoc, AP, Mesh) does not support DFS.
1710 * Passive scan is also used in world regulatory domains where 1710 * Passive scan is also used in world regulatory domains where
1711 * your country is not known and as such it should be treated as 1711 * your country is not known and as such it should be treated as
1712 * NO TX unless the channel is explicitly allowed in which case 1712 * NO TX unless the channel is explicitly allowed in which case
1713 * your current regulatory domain would not have the passive scan 1713 * your current regulatory domain would not have the passive scan
1714 * flag. 1714 * flag.
1715 * 1715 *
1716 * Since AP mode uses monitor interfaces to inject/TX management 1716 * Since AP mode uses monitor interfaces to inject/TX management
1717 * frames we can make AP mode the exception to this rule once it 1717 * frames we can make AP mode the exception to this rule once it
1718 * supports radar detection as its implementation can deal with 1718 * supports radar detection as its implementation can deal with
1719 * radar detection by itself. We can do that later by adding a 1719 * radar detection by itself. We can do that later by adding a
1720 * monitor flag interfaces used for AP support. 1720 * monitor flag interfaces used for AP support.
1721 */ 1721 */
1722 if ((chan->flags & (IEEE80211_CHAN_NO_IBSS | IEEE80211_CHAN_RADAR | 1722 if ((chan->flags & (IEEE80211_CHAN_NO_IBSS | IEEE80211_CHAN_RADAR |
1723 IEEE80211_CHAN_PASSIVE_SCAN))) 1723 IEEE80211_CHAN_PASSIVE_SCAN)))
1724 goto fail_rcu; 1724 goto fail_rcu;
1725 1725
1726 ieee80211_xmit(sdata, skb, chan->band); 1726 ieee80211_xmit(sdata, skb, chan->band);
1727 rcu_read_unlock(); 1727 rcu_read_unlock();
1728 1728
1729 return NETDEV_TX_OK; 1729 return NETDEV_TX_OK;
1730 1730
1731 fail_rcu: 1731 fail_rcu:
1732 rcu_read_unlock(); 1732 rcu_read_unlock();
1733 fail: 1733 fail:
1734 dev_kfree_skb(skb); 1734 dev_kfree_skb(skb);
1735 return NETDEV_TX_OK; /* meaning, we dealt with the skb */ 1735 return NETDEV_TX_OK; /* meaning, we dealt with the skb */
1736 } 1736 }
1737 1737
1738 /** 1738 /**
1739 * ieee80211_subif_start_xmit - netif start_xmit function for Ethernet-type 1739 * ieee80211_subif_start_xmit - netif start_xmit function for Ethernet-type
1740 * subinterfaces (wlan#, WDS, and VLAN interfaces) 1740 * subinterfaces (wlan#, WDS, and VLAN interfaces)
1741 * @skb: packet to be sent 1741 * @skb: packet to be sent
1742 * @dev: incoming interface 1742 * @dev: incoming interface
1743 * 1743 *
1744 * Returns: 0 on success (and frees skb in this case) or 1 on failure (skb will 1744 * Returns: 0 on success (and frees skb in this case) or 1 on failure (skb will
1745 * not be freed, and caller is responsible for either retrying later or freeing 1745 * not be freed, and caller is responsible for either retrying later or freeing
1746 * skb). 1746 * skb).
1747 * 1747 *
1748 * This function takes in an Ethernet header and encapsulates it with suitable 1748 * This function takes in an Ethernet header and encapsulates it with suitable
1749 * IEEE 802.11 header based on which interface the packet is coming in. The 1749 * IEEE 802.11 header based on which interface the packet is coming in. The
1750 * encapsulated packet will then be passed to master interface, wlan#.11, for 1750 * encapsulated packet will then be passed to master interface, wlan#.11, for
1751 * transmission (through low-level driver). 1751 * transmission (through low-level driver).
1752 */ 1752 */
1753 netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb, 1753 netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
1754 struct net_device *dev) 1754 struct net_device *dev)
1755 { 1755 {
1756 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1756 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1757 struct ieee80211_local *local = sdata->local; 1757 struct ieee80211_local *local = sdata->local;
1758 struct ieee80211_tx_info *info; 1758 struct ieee80211_tx_info *info;
1759 int head_need; 1759 int head_need;
1760 u16 ethertype, hdrlen, meshhdrlen = 0; 1760 u16 ethertype, hdrlen, meshhdrlen = 0;
1761 __le16 fc; 1761 __le16 fc;
1762 struct ieee80211_hdr hdr; 1762 struct ieee80211_hdr hdr;
1763 struct ieee80211s_hdr mesh_hdr __maybe_unused; 1763 struct ieee80211s_hdr mesh_hdr __maybe_unused;
1764 struct mesh_path __maybe_unused *mppath = NULL, *mpath = NULL; 1764 struct mesh_path __maybe_unused *mppath = NULL, *mpath = NULL;
1765 const u8 *encaps_data; 1765 const u8 *encaps_data;
1766 int encaps_len, skip_header_bytes; 1766 int encaps_len, skip_header_bytes;
1767 int nh_pos, h_pos; 1767 int nh_pos, h_pos;
1768 struct sta_info *sta = NULL; 1768 struct sta_info *sta = NULL;
1769 bool wme_sta = false, authorized = false, tdls_auth = false; 1769 bool wme_sta = false, authorized = false, tdls_auth = false;
1770 bool tdls_direct = false; 1770 bool tdls_direct = false;
1771 bool multicast; 1771 bool multicast;
1772 u32 info_flags = 0; 1772 u32 info_flags = 0;
1773 u16 info_id = 0; 1773 u16 info_id = 0;
1774 struct ieee80211_chanctx_conf *chanctx_conf; 1774 struct ieee80211_chanctx_conf *chanctx_conf;
1775 struct ieee80211_sub_if_data *ap_sdata; 1775 struct ieee80211_sub_if_data *ap_sdata;
1776 enum ieee80211_band band; 1776 enum ieee80211_band band;
1777 1777
1778 if (unlikely(skb->len < ETH_HLEN)) 1778 if (unlikely(skb->len < ETH_HLEN))
1779 goto fail; 1779 goto fail;
1780 1780
1781 /* convert Ethernet header to proper 802.11 header (based on 1781 /* convert Ethernet header to proper 802.11 header (based on
1782 * operation mode) */ 1782 * operation mode) */
1783 ethertype = (skb->data[12] << 8) | skb->data[13]; 1783 ethertype = (skb->data[12] << 8) | skb->data[13];
1784 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA); 1784 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
1785 1785
1786 rcu_read_lock(); 1786 rcu_read_lock();
1787 1787
1788 switch (sdata->vif.type) { 1788 switch (sdata->vif.type) {
1789 case NL80211_IFTYPE_AP_VLAN: 1789 case NL80211_IFTYPE_AP_VLAN:
1790 sta = rcu_dereference(sdata->u.vlan.sta); 1790 sta = rcu_dereference(sdata->u.vlan.sta);
1791 if (sta) { 1791 if (sta) {
1792 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS); 1792 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
1793 /* RA TA DA SA */ 1793 /* RA TA DA SA */
1794 memcpy(hdr.addr1, sta->sta.addr, ETH_ALEN); 1794 memcpy(hdr.addr1, sta->sta.addr, ETH_ALEN);
1795 memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN); 1795 memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
1796 memcpy(hdr.addr3, skb->data, ETH_ALEN); 1796 memcpy(hdr.addr3, skb->data, ETH_ALEN);
1797 memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN); 1797 memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
1798 hdrlen = 30; 1798 hdrlen = 30;
1799 authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED); 1799 authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED);
1800 wme_sta = test_sta_flag(sta, WLAN_STA_WME); 1800 wme_sta = test_sta_flag(sta, WLAN_STA_WME);
1801 } 1801 }
1802 ap_sdata = container_of(sdata->bss, struct ieee80211_sub_if_data, 1802 ap_sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
1803 u.ap); 1803 u.ap);
1804 chanctx_conf = rcu_dereference(ap_sdata->vif.chanctx_conf); 1804 chanctx_conf = rcu_dereference(ap_sdata->vif.chanctx_conf);
1805 if (!chanctx_conf) 1805 if (!chanctx_conf)
1806 goto fail_rcu; 1806 goto fail_rcu;
1807 band = chanctx_conf->def.chan->band; 1807 band = chanctx_conf->def.chan->band;
1808 if (sta) 1808 if (sta)
1809 break; 1809 break;
1810 /* fall through */ 1810 /* fall through */
1811 case NL80211_IFTYPE_AP: 1811 case NL80211_IFTYPE_AP:
1812 if (sdata->vif.type == NL80211_IFTYPE_AP) 1812 if (sdata->vif.type == NL80211_IFTYPE_AP)
1813 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 1813 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1814 if (!chanctx_conf) 1814 if (!chanctx_conf)
1815 goto fail_rcu; 1815 goto fail_rcu;
1816 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS); 1816 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
1817 /* DA BSSID SA */ 1817 /* DA BSSID SA */
1818 memcpy(hdr.addr1, skb->data, ETH_ALEN); 1818 memcpy(hdr.addr1, skb->data, ETH_ALEN);
1819 memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN); 1819 memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
1820 memcpy(hdr.addr3, skb->data + ETH_ALEN, ETH_ALEN); 1820 memcpy(hdr.addr3, skb->data + ETH_ALEN, ETH_ALEN);
1821 hdrlen = 24; 1821 hdrlen = 24;
1822 band = chanctx_conf->def.chan->band; 1822 band = chanctx_conf->def.chan->band;
1823 break; 1823 break;
1824 case NL80211_IFTYPE_WDS: 1824 case NL80211_IFTYPE_WDS:
1825 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS); 1825 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
1826 /* RA TA DA SA */ 1826 /* RA TA DA SA */
1827 memcpy(hdr.addr1, sdata->u.wds.remote_addr, ETH_ALEN); 1827 memcpy(hdr.addr1, sdata->u.wds.remote_addr, ETH_ALEN);
1828 memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN); 1828 memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
1829 memcpy(hdr.addr3, skb->data, ETH_ALEN); 1829 memcpy(hdr.addr3, skb->data, ETH_ALEN);
1830 memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN); 1830 memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
1831 hdrlen = 30; 1831 hdrlen = 30;
1832 /* 1832 /*
1833 * This is the exception! WDS style interfaces are prohibited 1833 * This is the exception! WDS style interfaces are prohibited
1834 * when channel contexts are in used so this must be valid 1834 * when channel contexts are in used so this must be valid
1835 */ 1835 */
1836 band = local->hw.conf.channel->band; 1836 band = local->hw.conf.channel->band;
1837 break; 1837 break;
1838 #ifdef CONFIG_MAC80211_MESH 1838 #ifdef CONFIG_MAC80211_MESH
1839 case NL80211_IFTYPE_MESH_POINT: 1839 case NL80211_IFTYPE_MESH_POINT:
1840 if (!sdata->u.mesh.mshcfg.dot11MeshTTL) { 1840 if (!sdata->u.mesh.mshcfg.dot11MeshTTL) {
1841 /* Do not send frames with mesh_ttl == 0 */ 1841 /* Do not send frames with mesh_ttl == 0 */
1842 sdata->u.mesh.mshstats.dropped_frames_ttl++; 1842 sdata->u.mesh.mshstats.dropped_frames_ttl++;
1843 goto fail_rcu; 1843 goto fail_rcu;
1844 } 1844 }
1845 1845
1846 if (!is_multicast_ether_addr(skb->data)) { 1846 if (!is_multicast_ether_addr(skb->data)) {
1847 mpath = mesh_path_lookup(sdata, skb->data); 1847 mpath = mesh_path_lookup(sdata, skb->data);
1848 if (!mpath) 1848 if (!mpath)
1849 mppath = mpp_path_lookup(sdata, skb->data); 1849 mppath = mpp_path_lookup(sdata, skb->data);
1850 } 1850 }
1851 1851
1852 /* 1852 /*
1853 * Use address extension if it is a packet from 1853 * Use address extension if it is a packet from
1854 * another interface or if we know the destination 1854 * another interface or if we know the destination
1855 * is being proxied by a portal (i.e. portal address 1855 * is being proxied by a portal (i.e. portal address
1856 * differs from proxied address) 1856 * differs from proxied address)
1857 */ 1857 */
1858 if (ether_addr_equal(sdata->vif.addr, skb->data + ETH_ALEN) && 1858 if (ether_addr_equal(sdata->vif.addr, skb->data + ETH_ALEN) &&
1859 !(mppath && !ether_addr_equal(mppath->mpp, skb->data))) { 1859 !(mppath && !ether_addr_equal(mppath->mpp, skb->data))) {
1860 hdrlen = ieee80211_fill_mesh_addresses(&hdr, &fc, 1860 hdrlen = ieee80211_fill_mesh_addresses(&hdr, &fc,
1861 skb->data, skb->data + ETH_ALEN); 1861 skb->data, skb->data + ETH_ALEN);
1862 meshhdrlen = ieee80211_new_mesh_header(sdata, &mesh_hdr, 1862 meshhdrlen = ieee80211_new_mesh_header(sdata, &mesh_hdr,
1863 NULL, NULL); 1863 NULL, NULL);
1864 } else { 1864 } else {
1865 /* DS -> MBSS (802.11-2012 13.11.3.3). 1865 /* DS -> MBSS (802.11-2012 13.11.3.3).
1866 * For unicast with unknown forwarding information, 1866 * For unicast with unknown forwarding information,
1867 * destination might be in the MBSS or if that fails 1867 * destination might be in the MBSS or if that fails
1868 * forwarded to another mesh gate. In either case 1868 * forwarded to another mesh gate. In either case
1869 * resolution will be handled in ieee80211_xmit(), so 1869 * resolution will be handled in ieee80211_xmit(), so
1870 * leave the original DA. This also works for mcast */ 1870 * leave the original DA. This also works for mcast */
1871 const u8 *mesh_da = skb->data; 1871 const u8 *mesh_da = skb->data;
1872 1872
1873 if (mppath) 1873 if (mppath)
1874 mesh_da = mppath->mpp; 1874 mesh_da = mppath->mpp;
1875 else if (mpath) 1875 else if (mpath)
1876 mesh_da = mpath->dst; 1876 mesh_da = mpath->dst;
1877 1877
1878 hdrlen = ieee80211_fill_mesh_addresses(&hdr, &fc, 1878 hdrlen = ieee80211_fill_mesh_addresses(&hdr, &fc,
1879 mesh_da, sdata->vif.addr); 1879 mesh_da, sdata->vif.addr);
1880 if (is_multicast_ether_addr(mesh_da)) 1880 if (is_multicast_ether_addr(mesh_da))
1881 /* DA TA mSA AE:SA */ 1881 /* DA TA mSA AE:SA */
1882 meshhdrlen = ieee80211_new_mesh_header( 1882 meshhdrlen = ieee80211_new_mesh_header(
1883 sdata, &mesh_hdr, 1883 sdata, &mesh_hdr,
1884 skb->data + ETH_ALEN, NULL); 1884 skb->data + ETH_ALEN, NULL);
1885 else 1885 else
1886 /* RA TA mDA mSA AE:DA SA */ 1886 /* RA TA mDA mSA AE:DA SA */
1887 meshhdrlen = ieee80211_new_mesh_header( 1887 meshhdrlen = ieee80211_new_mesh_header(
1888 sdata, &mesh_hdr, skb->data, 1888 sdata, &mesh_hdr, skb->data,
1889 skb->data + ETH_ALEN); 1889 skb->data + ETH_ALEN);
1890 1890
1891 } 1891 }
1892 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 1892 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1893 if (!chanctx_conf) 1893 if (!chanctx_conf)
1894 goto fail_rcu; 1894 goto fail_rcu;
1895 band = chanctx_conf->def.chan->band; 1895 band = chanctx_conf->def.chan->band;
1896 break; 1896 break;
1897 #endif 1897 #endif
1898 case NL80211_IFTYPE_STATION: 1898 case NL80211_IFTYPE_STATION:
1899 if (sdata->wdev.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) { 1899 if (sdata->wdev.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1900 bool tdls_peer = false; 1900 bool tdls_peer = false;
1901 1901
1902 sta = sta_info_get(sdata, skb->data); 1902 sta = sta_info_get(sdata, skb->data);
1903 if (sta) { 1903 if (sta) {
1904 authorized = test_sta_flag(sta, 1904 authorized = test_sta_flag(sta,
1905 WLAN_STA_AUTHORIZED); 1905 WLAN_STA_AUTHORIZED);
1906 wme_sta = test_sta_flag(sta, WLAN_STA_WME); 1906 wme_sta = test_sta_flag(sta, WLAN_STA_WME);
1907 tdls_peer = test_sta_flag(sta, 1907 tdls_peer = test_sta_flag(sta,
1908 WLAN_STA_TDLS_PEER); 1908 WLAN_STA_TDLS_PEER);
1909 tdls_auth = test_sta_flag(sta, 1909 tdls_auth = test_sta_flag(sta,
1910 WLAN_STA_TDLS_PEER_AUTH); 1910 WLAN_STA_TDLS_PEER_AUTH);
1911 } 1911 }
1912 1912
1913 /* 1913 /*
1914 * If the TDLS link is enabled, send everything 1914 * If the TDLS link is enabled, send everything
1915 * directly. Otherwise, allow TDLS setup frames 1915 * directly. Otherwise, allow TDLS setup frames
1916 * to be transmitted indirectly. 1916 * to be transmitted indirectly.
1917 */ 1917 */
1918 tdls_direct = tdls_peer && (tdls_auth || 1918 tdls_direct = tdls_peer && (tdls_auth ||
1919 !(ethertype == ETH_P_TDLS && skb->len > 14 && 1919 !(ethertype == ETH_P_TDLS && skb->len > 14 &&
1920 skb->data[14] == WLAN_TDLS_SNAP_RFTYPE)); 1920 skb->data[14] == WLAN_TDLS_SNAP_RFTYPE));
1921 } 1921 }
1922 1922
1923 if (tdls_direct) { 1923 if (tdls_direct) {
1924 /* link during setup - throw out frames to peer */ 1924 /* link during setup - throw out frames to peer */
1925 if (!tdls_auth) 1925 if (!tdls_auth)
1926 goto fail_rcu; 1926 goto fail_rcu;
1927 1927
1928 /* DA SA BSSID */ 1928 /* DA SA BSSID */
1929 memcpy(hdr.addr1, skb->data, ETH_ALEN); 1929 memcpy(hdr.addr1, skb->data, ETH_ALEN);
1930 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN); 1930 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
1931 memcpy(hdr.addr3, sdata->u.mgd.bssid, ETH_ALEN); 1931 memcpy(hdr.addr3, sdata->u.mgd.bssid, ETH_ALEN);
1932 hdrlen = 24; 1932 hdrlen = 24;
1933 } else if (sdata->u.mgd.use_4addr && 1933 } else if (sdata->u.mgd.use_4addr &&
1934 cpu_to_be16(ethertype) != sdata->control_port_protocol) { 1934 cpu_to_be16(ethertype) != sdata->control_port_protocol) {
1935 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | 1935 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS |
1936 IEEE80211_FCTL_TODS); 1936 IEEE80211_FCTL_TODS);
1937 /* RA TA DA SA */ 1937 /* RA TA DA SA */
1938 memcpy(hdr.addr1, sdata->u.mgd.bssid, ETH_ALEN); 1938 memcpy(hdr.addr1, sdata->u.mgd.bssid, ETH_ALEN);
1939 memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN); 1939 memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
1940 memcpy(hdr.addr3, skb->data, ETH_ALEN); 1940 memcpy(hdr.addr3, skb->data, ETH_ALEN);
1941 memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN); 1941 memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
1942 hdrlen = 30; 1942 hdrlen = 30;
1943 } else { 1943 } else {
1944 fc |= cpu_to_le16(IEEE80211_FCTL_TODS); 1944 fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
1945 /* BSSID SA DA */ 1945 /* BSSID SA DA */
1946 memcpy(hdr.addr1, sdata->u.mgd.bssid, ETH_ALEN); 1946 memcpy(hdr.addr1, sdata->u.mgd.bssid, ETH_ALEN);
1947 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN); 1947 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
1948 memcpy(hdr.addr3, skb->data, ETH_ALEN); 1948 memcpy(hdr.addr3, skb->data, ETH_ALEN);
1949 hdrlen = 24; 1949 hdrlen = 24;
1950 } 1950 }
1951 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 1951 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1952 if (!chanctx_conf) 1952 if (!chanctx_conf)
1953 goto fail_rcu; 1953 goto fail_rcu;
1954 band = chanctx_conf->def.chan->band; 1954 band = chanctx_conf->def.chan->band;
1955 break; 1955 break;
1956 case NL80211_IFTYPE_ADHOC: 1956 case NL80211_IFTYPE_ADHOC:
1957 /* DA SA BSSID */ 1957 /* DA SA BSSID */
1958 memcpy(hdr.addr1, skb->data, ETH_ALEN); 1958 memcpy(hdr.addr1, skb->data, ETH_ALEN);
1959 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN); 1959 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
1960 memcpy(hdr.addr3, sdata->u.ibss.bssid, ETH_ALEN); 1960 memcpy(hdr.addr3, sdata->u.ibss.bssid, ETH_ALEN);
1961 hdrlen = 24; 1961 hdrlen = 24;
1962 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 1962 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1963 if (!chanctx_conf) 1963 if (!chanctx_conf)
1964 goto fail_rcu; 1964 goto fail_rcu;
1965 band = chanctx_conf->def.chan->band; 1965 band = chanctx_conf->def.chan->band;
1966 break; 1966 break;
1967 default: 1967 default:
1968 goto fail_rcu; 1968 goto fail_rcu;
1969 } 1969 }
1970 1970
1971 /* 1971 /*
1972 * There's no need to try to look up the destination 1972 * There's no need to try to look up the destination
1973 * if it is a multicast address (which can only happen 1973 * if it is a multicast address (which can only happen
1974 * in AP mode) 1974 * in AP mode)
1975 */ 1975 */
1976 multicast = is_multicast_ether_addr(hdr.addr1); 1976 multicast = is_multicast_ether_addr(hdr.addr1);
1977 if (!multicast) { 1977 if (!multicast) {
1978 sta = sta_info_get(sdata, hdr.addr1); 1978 sta = sta_info_get(sdata, hdr.addr1);
1979 if (sta) { 1979 if (sta) {
1980 authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED); 1980 authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED);
1981 wme_sta = test_sta_flag(sta, WLAN_STA_WME); 1981 wme_sta = test_sta_flag(sta, WLAN_STA_WME);
1982 } 1982 }
1983 } 1983 }
1984 1984
1985 /* For mesh, the use of the QoS header is mandatory */ 1985 /* For mesh, the use of the QoS header is mandatory */
1986 if (ieee80211_vif_is_mesh(&sdata->vif)) 1986 if (ieee80211_vif_is_mesh(&sdata->vif))
1987 wme_sta = true; 1987 wme_sta = true;
1988 1988
1989 /* receiver and we are QoS enabled, use a QoS type frame */ 1989 /* receiver and we are QoS enabled, use a QoS type frame */
1990 if (wme_sta && local->hw.queues >= IEEE80211_NUM_ACS) { 1990 if (wme_sta && local->hw.queues >= IEEE80211_NUM_ACS) {
1991 fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA); 1991 fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
1992 hdrlen += 2; 1992 hdrlen += 2;
1993 } 1993 }
1994 1994
1995 /* 1995 /*
1996 * Drop unicast frames to unauthorised stations unless they are 1996 * Drop unicast frames to unauthorised stations unless they are
1997 * EAPOL frames from the local station. 1997 * EAPOL frames from the local station.
1998 */ 1998 */
1999 if (unlikely(!ieee80211_vif_is_mesh(&sdata->vif) && 1999 if (unlikely(!ieee80211_vif_is_mesh(&sdata->vif) &&
2000 !is_multicast_ether_addr(hdr.addr1) && !authorized && 2000 !is_multicast_ether_addr(hdr.addr1) && !authorized &&
2001 (cpu_to_be16(ethertype) != sdata->control_port_protocol || 2001 (cpu_to_be16(ethertype) != sdata->control_port_protocol ||
2002 !ether_addr_equal(sdata->vif.addr, skb->data + ETH_ALEN)))) { 2002 !ether_addr_equal(sdata->vif.addr, skb->data + ETH_ALEN)))) {
2003 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 2003 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2004 net_info_ratelimited("%s: dropped frame to %pM (unauthorized port)\n", 2004 net_info_ratelimited("%s: dropped frame to %pM (unauthorized port)\n",
2005 dev->name, hdr.addr1); 2005 dev->name, hdr.addr1);
2006 #endif 2006 #endif
2007 2007
2008 I802_DEBUG_INC(local->tx_handlers_drop_unauth_port); 2008 I802_DEBUG_INC(local->tx_handlers_drop_unauth_port);
2009 2009
2010 goto fail_rcu; 2010 goto fail_rcu;
2011 } 2011 }
2012 2012
2013 if (unlikely(!multicast && skb->sk && 2013 if (unlikely(!multicast && skb->sk &&
2014 skb_shinfo(skb)->tx_flags & SKBTX_WIFI_STATUS)) { 2014 skb_shinfo(skb)->tx_flags & SKBTX_WIFI_STATUS)) {
2015 struct sk_buff *orig_skb = skb; 2015 struct sk_buff *orig_skb = skb;
2016 2016
2017 skb = skb_clone(skb, GFP_ATOMIC); 2017 skb = skb_clone(skb, GFP_ATOMIC);
2018 if (skb) { 2018 if (skb) {
2019 unsigned long flags; 2019 unsigned long flags;
2020 int id, r; 2020 int id;
2021 2021
2022 spin_lock_irqsave(&local->ack_status_lock, flags); 2022 spin_lock_irqsave(&local->ack_status_lock, flags);
2023 r = idr_get_new_above(&local->ack_status_frames, 2023 id = idr_alloc(&local->ack_status_frames, orig_skb,
2024 orig_skb, 1, &id); 2024 1, 0x10000, GFP_ATOMIC);
2025 if (r == -EAGAIN) {
2026 idr_pre_get(&local->ack_status_frames,
2027 GFP_ATOMIC);
2028 r = idr_get_new_above(&local->ack_status_frames,
2029 orig_skb, 1, &id);
2030 }
2031 if (WARN_ON(!id) || id > 0xffff) {
2032 idr_remove(&local->ack_status_frames, id);
2033 r = -ERANGE;
2034 }
2035 spin_unlock_irqrestore(&local->ack_status_lock, flags); 2025 spin_unlock_irqrestore(&local->ack_status_lock, flags);
2036 2026
2037 if (!r) { 2027 if (id >= 0) {
2038 info_id = id; 2028 info_id = id;
2039 info_flags |= IEEE80211_TX_CTL_REQ_TX_STATUS; 2029 info_flags |= IEEE80211_TX_CTL_REQ_TX_STATUS;
2040 } else if (skb_shared(skb)) { 2030 } else if (skb_shared(skb)) {
2041 kfree_skb(orig_skb); 2031 kfree_skb(orig_skb);
2042 } else { 2032 } else {
2043 kfree_skb(skb); 2033 kfree_skb(skb);
2044 skb = orig_skb; 2034 skb = orig_skb;
2045 } 2035 }
2046 } else { 2036 } else {
2047 /* couldn't clone -- lose tx status ... */ 2037 /* couldn't clone -- lose tx status ... */
2048 skb = orig_skb; 2038 skb = orig_skb;
2049 } 2039 }
2050 } 2040 }
2051 2041
2052 /* 2042 /*
2053 * If the skb is shared we need to obtain our own copy. 2043 * If the skb is shared we need to obtain our own copy.
2054 */ 2044 */
2055 if (skb_shared(skb)) { 2045 if (skb_shared(skb)) {
2056 struct sk_buff *tmp_skb = skb; 2046 struct sk_buff *tmp_skb = skb;
2057 2047
2058 /* can't happen -- skb is a clone if info_id != 0 */ 2048 /* can't happen -- skb is a clone if info_id != 0 */
2059 WARN_ON(info_id); 2049 WARN_ON(info_id);
2060 2050
2061 skb = skb_clone(skb, GFP_ATOMIC); 2051 skb = skb_clone(skb, GFP_ATOMIC);
2062 kfree_skb(tmp_skb); 2052 kfree_skb(tmp_skb);
2063 2053
2064 if (!skb) 2054 if (!skb)
2065 goto fail_rcu; 2055 goto fail_rcu;
2066 } 2056 }
2067 2057
2068 hdr.frame_control = fc; 2058 hdr.frame_control = fc;
2069 hdr.duration_id = 0; 2059 hdr.duration_id = 0;
2070 hdr.seq_ctrl = 0; 2060 hdr.seq_ctrl = 0;
2071 2061
2072 skip_header_bytes = ETH_HLEN; 2062 skip_header_bytes = ETH_HLEN;
2073 if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) { 2063 if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) {
2074 encaps_data = bridge_tunnel_header; 2064 encaps_data = bridge_tunnel_header;
2075 encaps_len = sizeof(bridge_tunnel_header); 2065 encaps_len = sizeof(bridge_tunnel_header);
2076 skip_header_bytes -= 2; 2066 skip_header_bytes -= 2;
2077 } else if (ethertype >= 0x600) { 2067 } else if (ethertype >= 0x600) {
2078 encaps_data = rfc1042_header; 2068 encaps_data = rfc1042_header;
2079 encaps_len = sizeof(rfc1042_header); 2069 encaps_len = sizeof(rfc1042_header);
2080 skip_header_bytes -= 2; 2070 skip_header_bytes -= 2;
2081 } else { 2071 } else {
2082 encaps_data = NULL; 2072 encaps_data = NULL;
2083 encaps_len = 0; 2073 encaps_len = 0;
2084 } 2074 }
2085 2075
2086 nh_pos = skb_network_header(skb) - skb->data; 2076 nh_pos = skb_network_header(skb) - skb->data;
2087 h_pos = skb_transport_header(skb) - skb->data; 2077 h_pos = skb_transport_header(skb) - skb->data;
2088 2078
2089 skb_pull(skb, skip_header_bytes); 2079 skb_pull(skb, skip_header_bytes);
2090 nh_pos -= skip_header_bytes; 2080 nh_pos -= skip_header_bytes;
2091 h_pos -= skip_header_bytes; 2081 h_pos -= skip_header_bytes;
2092 2082
2093 head_need = hdrlen + encaps_len + meshhdrlen - skb_headroom(skb); 2083 head_need = hdrlen + encaps_len + meshhdrlen - skb_headroom(skb);
2094 2084
2095 /* 2085 /*
2096 * So we need to modify the skb header and hence need a copy of 2086 * So we need to modify the skb header and hence need a copy of
2097 * that. The head_need variable above doesn't, so far, include 2087 * that. The head_need variable above doesn't, so far, include
2098 * the needed header space that we don't need right away. If we 2088 * the needed header space that we don't need right away. If we
2099 * can, then we don't reallocate right now but only after the 2089 * can, then we don't reallocate right now but only after the
2100 * frame arrives at the master device (if it does...) 2090 * frame arrives at the master device (if it does...)
2101 * 2091 *
2102 * If we cannot, however, then we will reallocate to include all 2092 * If we cannot, however, then we will reallocate to include all
2103 * the ever needed space. Also, if we need to reallocate it anyway, 2093 * the ever needed space. Also, if we need to reallocate it anyway,
2104 * make it big enough for everything we may ever need. 2094 * make it big enough for everything we may ever need.
2105 */ 2095 */
2106 2096
2107 if (head_need > 0 || skb_cloned(skb)) { 2097 if (head_need > 0 || skb_cloned(skb)) {
2108 head_need += IEEE80211_ENCRYPT_HEADROOM; 2098 head_need += IEEE80211_ENCRYPT_HEADROOM;
2109 head_need += local->tx_headroom; 2099 head_need += local->tx_headroom;
2110 head_need = max_t(int, 0, head_need); 2100 head_need = max_t(int, 0, head_need);
2111 if (ieee80211_skb_resize(sdata, skb, head_need, true)) { 2101 if (ieee80211_skb_resize(sdata, skb, head_need, true)) {
2112 ieee80211_free_txskb(&local->hw, skb); 2102 ieee80211_free_txskb(&local->hw, skb);
2113 skb = NULL; 2103 skb = NULL;
2114 goto fail_rcu; 2104 goto fail_rcu;
2115 } 2105 }
2116 } 2106 }
2117 2107
2118 if (encaps_data) { 2108 if (encaps_data) {
2119 memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len); 2109 memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len);
2120 nh_pos += encaps_len; 2110 nh_pos += encaps_len;
2121 h_pos += encaps_len; 2111 h_pos += encaps_len;
2122 } 2112 }
2123 2113
2124 #ifdef CONFIG_MAC80211_MESH 2114 #ifdef CONFIG_MAC80211_MESH
2125 if (meshhdrlen > 0) { 2115 if (meshhdrlen > 0) {
2126 memcpy(skb_push(skb, meshhdrlen), &mesh_hdr, meshhdrlen); 2116 memcpy(skb_push(skb, meshhdrlen), &mesh_hdr, meshhdrlen);
2127 nh_pos += meshhdrlen; 2117 nh_pos += meshhdrlen;
2128 h_pos += meshhdrlen; 2118 h_pos += meshhdrlen;
2129 } 2119 }
2130 #endif 2120 #endif
2131 2121
2132 if (ieee80211_is_data_qos(fc)) { 2122 if (ieee80211_is_data_qos(fc)) {
2133 __le16 *qos_control; 2123 __le16 *qos_control;
2134 2124
2135 qos_control = (__le16*) skb_push(skb, 2); 2125 qos_control = (__le16*) skb_push(skb, 2);
2136 memcpy(skb_push(skb, hdrlen - 2), &hdr, hdrlen - 2); 2126 memcpy(skb_push(skb, hdrlen - 2), &hdr, hdrlen - 2);
2137 /* 2127 /*
2138 * Maybe we could actually set some fields here, for now just 2128 * Maybe we could actually set some fields here, for now just
2139 * initialise to zero to indicate no special operation. 2129 * initialise to zero to indicate no special operation.
2140 */ 2130 */
2141 *qos_control = 0; 2131 *qos_control = 0;
2142 } else 2132 } else
2143 memcpy(skb_push(skb, hdrlen), &hdr, hdrlen); 2133 memcpy(skb_push(skb, hdrlen), &hdr, hdrlen);
2144 2134
2145 nh_pos += hdrlen; 2135 nh_pos += hdrlen;
2146 h_pos += hdrlen; 2136 h_pos += hdrlen;
2147 2137
2148 dev->stats.tx_packets++; 2138 dev->stats.tx_packets++;
2149 dev->stats.tx_bytes += skb->len; 2139 dev->stats.tx_bytes += skb->len;
2150 2140
2151 /* Update skb pointers to various headers since this modified frame 2141 /* Update skb pointers to various headers since this modified frame
2152 * is going to go through Linux networking code that may potentially 2142 * is going to go through Linux networking code that may potentially
2153 * need things like pointer to IP header. */ 2143 * need things like pointer to IP header. */
2154 skb_set_mac_header(skb, 0); 2144 skb_set_mac_header(skb, 0);
2155 skb_set_network_header(skb, nh_pos); 2145 skb_set_network_header(skb, nh_pos);
2156 skb_set_transport_header(skb, h_pos); 2146 skb_set_transport_header(skb, h_pos);
2157 2147
2158 info = IEEE80211_SKB_CB(skb); 2148 info = IEEE80211_SKB_CB(skb);
2159 memset(info, 0, sizeof(*info)); 2149 memset(info, 0, sizeof(*info));
2160 2150
2161 dev->trans_start = jiffies; 2151 dev->trans_start = jiffies;
2162 2152
2163 info->flags = info_flags; 2153 info->flags = info_flags;
2164 info->ack_frame_id = info_id; 2154 info->ack_frame_id = info_id;
2165 2155
2166 ieee80211_xmit(sdata, skb, band); 2156 ieee80211_xmit(sdata, skb, band);
2167 rcu_read_unlock(); 2157 rcu_read_unlock();
2168 2158
2169 return NETDEV_TX_OK; 2159 return NETDEV_TX_OK;
2170 2160
2171 fail_rcu: 2161 fail_rcu:
2172 rcu_read_unlock(); 2162 rcu_read_unlock();
2173 fail: 2163 fail:
2174 dev_kfree_skb(skb); 2164 dev_kfree_skb(skb);
2175 return NETDEV_TX_OK; 2165 return NETDEV_TX_OK;
2176 } 2166 }
2177 2167
2178 2168
2179 /* 2169 /*
2180 * ieee80211_clear_tx_pending may not be called in a context where 2170 * ieee80211_clear_tx_pending may not be called in a context where
2181 * it is possible that it packets could come in again. 2171 * it is possible that it packets could come in again.
2182 */ 2172 */
2183 void ieee80211_clear_tx_pending(struct ieee80211_local *local) 2173 void ieee80211_clear_tx_pending(struct ieee80211_local *local)
2184 { 2174 {
2185 struct sk_buff *skb; 2175 struct sk_buff *skb;
2186 int i; 2176 int i;
2187 2177
2188 for (i = 0; i < local->hw.queues; i++) { 2178 for (i = 0; i < local->hw.queues; i++) {
2189 while ((skb = skb_dequeue(&local->pending[i])) != NULL) 2179 while ((skb = skb_dequeue(&local->pending[i])) != NULL)
2190 ieee80211_free_txskb(&local->hw, skb); 2180 ieee80211_free_txskb(&local->hw, skb);
2191 } 2181 }
2192 } 2182 }
2193 2183
2194 /* 2184 /*
2195 * Returns false if the frame couldn't be transmitted but was queued instead, 2185 * Returns false if the frame couldn't be transmitted but was queued instead,
2196 * which in this case means re-queued -- take as an indication to stop sending 2186 * which in this case means re-queued -- take as an indication to stop sending
2197 * more pending frames. 2187 * more pending frames.
2198 */ 2188 */
2199 static bool ieee80211_tx_pending_skb(struct ieee80211_local *local, 2189 static bool ieee80211_tx_pending_skb(struct ieee80211_local *local,
2200 struct sk_buff *skb) 2190 struct sk_buff *skb)
2201 { 2191 {
2202 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 2192 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2203 struct ieee80211_sub_if_data *sdata; 2193 struct ieee80211_sub_if_data *sdata;
2204 struct sta_info *sta; 2194 struct sta_info *sta;
2205 struct ieee80211_hdr *hdr; 2195 struct ieee80211_hdr *hdr;
2206 bool result; 2196 bool result;
2207 struct ieee80211_chanctx_conf *chanctx_conf; 2197 struct ieee80211_chanctx_conf *chanctx_conf;
2208 2198
2209 sdata = vif_to_sdata(info->control.vif); 2199 sdata = vif_to_sdata(info->control.vif);
2210 2200
2211 if (info->flags & IEEE80211_TX_INTFL_NEED_TXPROCESSING) { 2201 if (info->flags & IEEE80211_TX_INTFL_NEED_TXPROCESSING) {
2212 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 2202 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2213 if (unlikely(!chanctx_conf)) { 2203 if (unlikely(!chanctx_conf)) {
2214 dev_kfree_skb(skb); 2204 dev_kfree_skb(skb);
2215 return true; 2205 return true;
2216 } 2206 }
2217 result = ieee80211_tx(sdata, skb, true, 2207 result = ieee80211_tx(sdata, skb, true,
2218 chanctx_conf->def.chan->band); 2208 chanctx_conf->def.chan->band);
2219 } else { 2209 } else {
2220 struct sk_buff_head skbs; 2210 struct sk_buff_head skbs;
2221 2211
2222 __skb_queue_head_init(&skbs); 2212 __skb_queue_head_init(&skbs);
2223 __skb_queue_tail(&skbs, skb); 2213 __skb_queue_tail(&skbs, skb);
2224 2214
2225 hdr = (struct ieee80211_hdr *)skb->data; 2215 hdr = (struct ieee80211_hdr *)skb->data;
2226 sta = sta_info_get(sdata, hdr->addr1); 2216 sta = sta_info_get(sdata, hdr->addr1);
2227 2217
2228 result = __ieee80211_tx(local, &skbs, skb->len, sta, true); 2218 result = __ieee80211_tx(local, &skbs, skb->len, sta, true);
2229 } 2219 }
2230 2220
2231 return result; 2221 return result;
2232 } 2222 }
2233 2223
2234 /* 2224 /*
2235 * Transmit all pending packets. Called from tasklet. 2225 * Transmit all pending packets. Called from tasklet.
2236 */ 2226 */
2237 void ieee80211_tx_pending(unsigned long data) 2227 void ieee80211_tx_pending(unsigned long data)
2238 { 2228 {
2239 struct ieee80211_local *local = (struct ieee80211_local *)data; 2229 struct ieee80211_local *local = (struct ieee80211_local *)data;
2240 unsigned long flags; 2230 unsigned long flags;
2241 int i; 2231 int i;
2242 bool txok; 2232 bool txok;
2243 2233
2244 rcu_read_lock(); 2234 rcu_read_lock();
2245 2235
2246 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 2236 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
2247 for (i = 0; i < local->hw.queues; i++) { 2237 for (i = 0; i < local->hw.queues; i++) {
2248 /* 2238 /*
2249 * If queue is stopped by something other than due to pending 2239 * If queue is stopped by something other than due to pending
2250 * frames, or we have no pending frames, proceed to next queue. 2240 * frames, or we have no pending frames, proceed to next queue.
2251 */ 2241 */
2252 if (local->queue_stop_reasons[i] || 2242 if (local->queue_stop_reasons[i] ||
2253 skb_queue_empty(&local->pending[i])) 2243 skb_queue_empty(&local->pending[i]))
2254 continue; 2244 continue;
2255 2245
2256 while (!skb_queue_empty(&local->pending[i])) { 2246 while (!skb_queue_empty(&local->pending[i])) {
2257 struct sk_buff *skb = __skb_dequeue(&local->pending[i]); 2247 struct sk_buff *skb = __skb_dequeue(&local->pending[i]);
2258 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 2248 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2259 2249
2260 if (WARN_ON(!info->control.vif)) { 2250 if (WARN_ON(!info->control.vif)) {
2261 ieee80211_free_txskb(&local->hw, skb); 2251 ieee80211_free_txskb(&local->hw, skb);
2262 continue; 2252 continue;
2263 } 2253 }
2264 2254
2265 spin_unlock_irqrestore(&local->queue_stop_reason_lock, 2255 spin_unlock_irqrestore(&local->queue_stop_reason_lock,
2266 flags); 2256 flags);
2267 2257
2268 txok = ieee80211_tx_pending_skb(local, skb); 2258 txok = ieee80211_tx_pending_skb(local, skb);
2269 spin_lock_irqsave(&local->queue_stop_reason_lock, 2259 spin_lock_irqsave(&local->queue_stop_reason_lock,
2270 flags); 2260 flags);
2271 if (!txok) 2261 if (!txok)
2272 break; 2262 break;
2273 } 2263 }
2274 2264
2275 if (skb_queue_empty(&local->pending[i])) 2265 if (skb_queue_empty(&local->pending[i]))
2276 ieee80211_propagate_queue_wake(local, i); 2266 ieee80211_propagate_queue_wake(local, i);
2277 } 2267 }
2278 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 2268 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
2279 2269
2280 rcu_read_unlock(); 2270 rcu_read_unlock();
2281 } 2271 }
2282 2272
2283 /* functions for drivers to get certain frames */ 2273 /* functions for drivers to get certain frames */
2284 2274
2285 static void __ieee80211_beacon_add_tim(struct ieee80211_sub_if_data *sdata, 2275 static void __ieee80211_beacon_add_tim(struct ieee80211_sub_if_data *sdata,
2286 struct ps_data *ps, struct sk_buff *skb) 2276 struct ps_data *ps, struct sk_buff *skb)
2287 { 2277 {
2288 u8 *pos, *tim; 2278 u8 *pos, *tim;
2289 int aid0 = 0; 2279 int aid0 = 0;
2290 int i, have_bits = 0, n1, n2; 2280 int i, have_bits = 0, n1, n2;
2291 2281
2292 /* Generate bitmap for TIM only if there are any STAs in power save 2282 /* Generate bitmap for TIM only if there are any STAs in power save
2293 * mode. */ 2283 * mode. */
2294 if (atomic_read(&ps->num_sta_ps) > 0) 2284 if (atomic_read(&ps->num_sta_ps) > 0)
2295 /* in the hope that this is faster than 2285 /* in the hope that this is faster than
2296 * checking byte-for-byte */ 2286 * checking byte-for-byte */
2297 have_bits = !bitmap_empty((unsigned long*)ps->tim, 2287 have_bits = !bitmap_empty((unsigned long*)ps->tim,
2298 IEEE80211_MAX_AID+1); 2288 IEEE80211_MAX_AID+1);
2299 2289
2300 if (ps->dtim_count == 0) 2290 if (ps->dtim_count == 0)
2301 ps->dtim_count = sdata->vif.bss_conf.dtim_period - 1; 2291 ps->dtim_count = sdata->vif.bss_conf.dtim_period - 1;
2302 else 2292 else
2303 ps->dtim_count--; 2293 ps->dtim_count--;
2304 2294
2305 tim = pos = (u8 *) skb_put(skb, 6); 2295 tim = pos = (u8 *) skb_put(skb, 6);
2306 *pos++ = WLAN_EID_TIM; 2296 *pos++ = WLAN_EID_TIM;
2307 *pos++ = 4; 2297 *pos++ = 4;
2308 *pos++ = ps->dtim_count; 2298 *pos++ = ps->dtim_count;
2309 *pos++ = sdata->vif.bss_conf.dtim_period; 2299 *pos++ = sdata->vif.bss_conf.dtim_period;
2310 2300
2311 if (ps->dtim_count == 0 && !skb_queue_empty(&ps->bc_buf)) 2301 if (ps->dtim_count == 0 && !skb_queue_empty(&ps->bc_buf))
2312 aid0 = 1; 2302 aid0 = 1;
2313 2303
2314 ps->dtim_bc_mc = aid0 == 1; 2304 ps->dtim_bc_mc = aid0 == 1;
2315 2305
2316 if (have_bits) { 2306 if (have_bits) {
2317 /* Find largest even number N1 so that bits numbered 1 through 2307 /* Find largest even number N1 so that bits numbered 1 through
2318 * (N1 x 8) - 1 in the bitmap are 0 and number N2 so that bits 2308 * (N1 x 8) - 1 in the bitmap are 0 and number N2 so that bits
2319 * (N2 + 1) x 8 through 2007 are 0. */ 2309 * (N2 + 1) x 8 through 2007 are 0. */
2320 n1 = 0; 2310 n1 = 0;
2321 for (i = 0; i < IEEE80211_MAX_TIM_LEN; i++) { 2311 for (i = 0; i < IEEE80211_MAX_TIM_LEN; i++) {
2322 if (ps->tim[i]) { 2312 if (ps->tim[i]) {
2323 n1 = i & 0xfe; 2313 n1 = i & 0xfe;
2324 break; 2314 break;
2325 } 2315 }
2326 } 2316 }
2327 n2 = n1; 2317 n2 = n1;
2328 for (i = IEEE80211_MAX_TIM_LEN - 1; i >= n1; i--) { 2318 for (i = IEEE80211_MAX_TIM_LEN - 1; i >= n1; i--) {
2329 if (ps->tim[i]) { 2319 if (ps->tim[i]) {
2330 n2 = i; 2320 n2 = i;
2331 break; 2321 break;
2332 } 2322 }
2333 } 2323 }
2334 2324
2335 /* Bitmap control */ 2325 /* Bitmap control */
2336 *pos++ = n1 | aid0; 2326 *pos++ = n1 | aid0;
2337 /* Part Virt Bitmap */ 2327 /* Part Virt Bitmap */
2338 skb_put(skb, n2 - n1); 2328 skb_put(skb, n2 - n1);
2339 memcpy(pos, ps->tim + n1, n2 - n1 + 1); 2329 memcpy(pos, ps->tim + n1, n2 - n1 + 1);
2340 2330
2341 tim[1] = n2 - n1 + 4; 2331 tim[1] = n2 - n1 + 4;
2342 } else { 2332 } else {
2343 *pos++ = aid0; /* Bitmap control */ 2333 *pos++ = aid0; /* Bitmap control */
2344 *pos++ = 0; /* Part Virt Bitmap */ 2334 *pos++ = 0; /* Part Virt Bitmap */
2345 } 2335 }
2346 } 2336 }
2347 2337
2348 static int ieee80211_beacon_add_tim(struct ieee80211_sub_if_data *sdata, 2338 static int ieee80211_beacon_add_tim(struct ieee80211_sub_if_data *sdata,
2349 struct ps_data *ps, struct sk_buff *skb) 2339 struct ps_data *ps, struct sk_buff *skb)
2350 { 2340 {
2351 struct ieee80211_local *local = sdata->local; 2341 struct ieee80211_local *local = sdata->local;
2352 2342
2353 /* 2343 /*
2354 * Not very nice, but we want to allow the driver to call 2344 * Not very nice, but we want to allow the driver to call
2355 * ieee80211_beacon_get() as a response to the set_tim() 2345 * ieee80211_beacon_get() as a response to the set_tim()
2356 * callback. That, however, is already invoked under the 2346 * callback. That, however, is already invoked under the
2357 * sta_lock to guarantee consistent and race-free update 2347 * sta_lock to guarantee consistent and race-free update
2358 * of the tim bitmap in mac80211 and the driver. 2348 * of the tim bitmap in mac80211 and the driver.
2359 */ 2349 */
2360 if (local->tim_in_locked_section) { 2350 if (local->tim_in_locked_section) {
2361 __ieee80211_beacon_add_tim(sdata, ps, skb); 2351 __ieee80211_beacon_add_tim(sdata, ps, skb);
2362 } else { 2352 } else {
2363 spin_lock(&local->tim_lock); 2353 spin_lock(&local->tim_lock);
2364 __ieee80211_beacon_add_tim(sdata, ps, skb); 2354 __ieee80211_beacon_add_tim(sdata, ps, skb);
2365 spin_unlock(&local->tim_lock); 2355 spin_unlock(&local->tim_lock);
2366 } 2356 }
2367 2357
2368 return 0; 2358 return 0;
2369 } 2359 }
2370 2360
2371 struct sk_buff *ieee80211_beacon_get_tim(struct ieee80211_hw *hw, 2361 struct sk_buff *ieee80211_beacon_get_tim(struct ieee80211_hw *hw,
2372 struct ieee80211_vif *vif, 2362 struct ieee80211_vif *vif,
2373 u16 *tim_offset, u16 *tim_length) 2363 u16 *tim_offset, u16 *tim_length)
2374 { 2364 {
2375 struct ieee80211_local *local = hw_to_local(hw); 2365 struct ieee80211_local *local = hw_to_local(hw);
2376 struct sk_buff *skb = NULL; 2366 struct sk_buff *skb = NULL;
2377 struct ieee80211_tx_info *info; 2367 struct ieee80211_tx_info *info;
2378 struct ieee80211_sub_if_data *sdata = NULL; 2368 struct ieee80211_sub_if_data *sdata = NULL;
2379 enum ieee80211_band band; 2369 enum ieee80211_band band;
2380 struct ieee80211_tx_rate_control txrc; 2370 struct ieee80211_tx_rate_control txrc;
2381 struct ieee80211_chanctx_conf *chanctx_conf; 2371 struct ieee80211_chanctx_conf *chanctx_conf;
2382 2372
2383 rcu_read_lock(); 2373 rcu_read_lock();
2384 2374
2385 sdata = vif_to_sdata(vif); 2375 sdata = vif_to_sdata(vif);
2386 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 2376 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2387 2377
2388 if (!ieee80211_sdata_running(sdata) || !chanctx_conf) 2378 if (!ieee80211_sdata_running(sdata) || !chanctx_conf)
2389 goto out; 2379 goto out;
2390 2380
2391 if (tim_offset) 2381 if (tim_offset)
2392 *tim_offset = 0; 2382 *tim_offset = 0;
2393 if (tim_length) 2383 if (tim_length)
2394 *tim_length = 0; 2384 *tim_length = 0;
2395 2385
2396 if (sdata->vif.type == NL80211_IFTYPE_AP) { 2386 if (sdata->vif.type == NL80211_IFTYPE_AP) {
2397 struct ieee80211_if_ap *ap = &sdata->u.ap; 2387 struct ieee80211_if_ap *ap = &sdata->u.ap;
2398 struct beacon_data *beacon = rcu_dereference(ap->beacon); 2388 struct beacon_data *beacon = rcu_dereference(ap->beacon);
2399 2389
2400 if (beacon) { 2390 if (beacon) {
2401 /* 2391 /*
2402 * headroom, head length, 2392 * headroom, head length,
2403 * tail length and maximum TIM length 2393 * tail length and maximum TIM length
2404 */ 2394 */
2405 skb = dev_alloc_skb(local->tx_headroom + 2395 skb = dev_alloc_skb(local->tx_headroom +
2406 beacon->head_len + 2396 beacon->head_len +
2407 beacon->tail_len + 256); 2397 beacon->tail_len + 256);
2408 if (!skb) 2398 if (!skb)
2409 goto out; 2399 goto out;
2410 2400
2411 skb_reserve(skb, local->tx_headroom); 2401 skb_reserve(skb, local->tx_headroom);
2412 memcpy(skb_put(skb, beacon->head_len), beacon->head, 2402 memcpy(skb_put(skb, beacon->head_len), beacon->head,
2413 beacon->head_len); 2403 beacon->head_len);
2414 2404
2415 ieee80211_beacon_add_tim(sdata, &ap->ps, skb); 2405 ieee80211_beacon_add_tim(sdata, &ap->ps, skb);
2416 2406
2417 if (tim_offset) 2407 if (tim_offset)
2418 *tim_offset = beacon->head_len; 2408 *tim_offset = beacon->head_len;
2419 if (tim_length) 2409 if (tim_length)
2420 *tim_length = skb->len - beacon->head_len; 2410 *tim_length = skb->len - beacon->head_len;
2421 2411
2422 if (beacon->tail) 2412 if (beacon->tail)
2423 memcpy(skb_put(skb, beacon->tail_len), 2413 memcpy(skb_put(skb, beacon->tail_len),
2424 beacon->tail, beacon->tail_len); 2414 beacon->tail, beacon->tail_len);
2425 } else 2415 } else
2426 goto out; 2416 goto out;
2427 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) { 2417 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
2428 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 2418 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
2429 struct ieee80211_hdr *hdr; 2419 struct ieee80211_hdr *hdr;
2430 struct sk_buff *presp = rcu_dereference(ifibss->presp); 2420 struct sk_buff *presp = rcu_dereference(ifibss->presp);
2431 2421
2432 if (!presp) 2422 if (!presp)
2433 goto out; 2423 goto out;
2434 2424
2435 skb = skb_copy(presp, GFP_ATOMIC); 2425 skb = skb_copy(presp, GFP_ATOMIC);
2436 if (!skb) 2426 if (!skb)
2437 goto out; 2427 goto out;
2438 2428
2439 hdr = (struct ieee80211_hdr *) skb->data; 2429 hdr = (struct ieee80211_hdr *) skb->data;
2440 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 2430 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2441 IEEE80211_STYPE_BEACON); 2431 IEEE80211_STYPE_BEACON);
2442 } else if (ieee80211_vif_is_mesh(&sdata->vif)) { 2432 } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
2443 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 2433 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
2444 struct beacon_data *bcn = rcu_dereference(ifmsh->beacon); 2434 struct beacon_data *bcn = rcu_dereference(ifmsh->beacon);
2445 2435
2446 if (!bcn) 2436 if (!bcn)
2447 goto out; 2437 goto out;
2448 2438
2449 if (ifmsh->sync_ops) 2439 if (ifmsh->sync_ops)
2450 ifmsh->sync_ops->adjust_tbtt( 2440 ifmsh->sync_ops->adjust_tbtt(
2451 sdata); 2441 sdata);
2452 2442
2453 skb = dev_alloc_skb(local->tx_headroom + 2443 skb = dev_alloc_skb(local->tx_headroom +
2454 bcn->head_len + 2444 bcn->head_len +
2455 256 + /* TIM IE */ 2445 256 + /* TIM IE */
2456 bcn->tail_len); 2446 bcn->tail_len);
2457 if (!skb) 2447 if (!skb)
2458 goto out; 2448 goto out;
2459 skb_reserve(skb, local->tx_headroom); 2449 skb_reserve(skb, local->tx_headroom);
2460 memcpy(skb_put(skb, bcn->head_len), bcn->head, bcn->head_len); 2450 memcpy(skb_put(skb, bcn->head_len), bcn->head, bcn->head_len);
2461 ieee80211_beacon_add_tim(sdata, &ifmsh->ps, skb); 2451 ieee80211_beacon_add_tim(sdata, &ifmsh->ps, skb);
2462 memcpy(skb_put(skb, bcn->tail_len), bcn->tail, bcn->tail_len); 2452 memcpy(skb_put(skb, bcn->tail_len), bcn->tail, bcn->tail_len);
2463 } else { 2453 } else {
2464 WARN_ON(1); 2454 WARN_ON(1);
2465 goto out; 2455 goto out;
2466 } 2456 }
2467 2457
2468 band = chanctx_conf->def.chan->band; 2458 band = chanctx_conf->def.chan->band;
2469 2459
2470 info = IEEE80211_SKB_CB(skb); 2460 info = IEEE80211_SKB_CB(skb);
2471 2461
2472 info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 2462 info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
2473 info->flags |= IEEE80211_TX_CTL_NO_ACK; 2463 info->flags |= IEEE80211_TX_CTL_NO_ACK;
2474 info->band = band; 2464 info->band = band;
2475 2465
2476 memset(&txrc, 0, sizeof(txrc)); 2466 memset(&txrc, 0, sizeof(txrc));
2477 txrc.hw = hw; 2467 txrc.hw = hw;
2478 txrc.sband = local->hw.wiphy->bands[band]; 2468 txrc.sband = local->hw.wiphy->bands[band];
2479 txrc.bss_conf = &sdata->vif.bss_conf; 2469 txrc.bss_conf = &sdata->vif.bss_conf;
2480 txrc.skb = skb; 2470 txrc.skb = skb;
2481 txrc.reported_rate.idx = -1; 2471 txrc.reported_rate.idx = -1;
2482 txrc.rate_idx_mask = sdata->rc_rateidx_mask[band]; 2472 txrc.rate_idx_mask = sdata->rc_rateidx_mask[band];
2483 if (txrc.rate_idx_mask == (1 << txrc.sband->n_bitrates) - 1) 2473 if (txrc.rate_idx_mask == (1 << txrc.sband->n_bitrates) - 1)
2484 txrc.max_rate_idx = -1; 2474 txrc.max_rate_idx = -1;
2485 else 2475 else
2486 txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1; 2476 txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1;
2487 memcpy(txrc.rate_idx_mcs_mask, sdata->rc_rateidx_mcs_mask[band], 2477 memcpy(txrc.rate_idx_mcs_mask, sdata->rc_rateidx_mcs_mask[band],
2488 sizeof(txrc.rate_idx_mcs_mask)); 2478 sizeof(txrc.rate_idx_mcs_mask));
2489 txrc.bss = true; 2479 txrc.bss = true;
2490 rate_control_get_rate(sdata, NULL, &txrc); 2480 rate_control_get_rate(sdata, NULL, &txrc);
2491 2481
2492 info->control.vif = vif; 2482 info->control.vif = vif;
2493 2483
2494 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT | 2484 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT |
2495 IEEE80211_TX_CTL_ASSIGN_SEQ | 2485 IEEE80211_TX_CTL_ASSIGN_SEQ |
2496 IEEE80211_TX_CTL_FIRST_FRAGMENT; 2486 IEEE80211_TX_CTL_FIRST_FRAGMENT;
2497 out: 2487 out:
2498 rcu_read_unlock(); 2488 rcu_read_unlock();
2499 return skb; 2489 return skb;
2500 } 2490 }
2501 EXPORT_SYMBOL(ieee80211_beacon_get_tim); 2491 EXPORT_SYMBOL(ieee80211_beacon_get_tim);
2502 2492
2503 struct sk_buff *ieee80211_proberesp_get(struct ieee80211_hw *hw, 2493 struct sk_buff *ieee80211_proberesp_get(struct ieee80211_hw *hw,
2504 struct ieee80211_vif *vif) 2494 struct ieee80211_vif *vif)
2505 { 2495 {
2506 struct ieee80211_if_ap *ap = NULL; 2496 struct ieee80211_if_ap *ap = NULL;
2507 struct sk_buff *skb = NULL; 2497 struct sk_buff *skb = NULL;
2508 struct probe_resp *presp = NULL; 2498 struct probe_resp *presp = NULL;
2509 struct ieee80211_hdr *hdr; 2499 struct ieee80211_hdr *hdr;
2510 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 2500 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2511 2501
2512 if (sdata->vif.type != NL80211_IFTYPE_AP) 2502 if (sdata->vif.type != NL80211_IFTYPE_AP)
2513 return NULL; 2503 return NULL;
2514 2504
2515 rcu_read_lock(); 2505 rcu_read_lock();
2516 2506
2517 ap = &sdata->u.ap; 2507 ap = &sdata->u.ap;
2518 presp = rcu_dereference(ap->probe_resp); 2508 presp = rcu_dereference(ap->probe_resp);
2519 if (!presp) 2509 if (!presp)
2520 goto out; 2510 goto out;
2521 2511
2522 skb = dev_alloc_skb(presp->len); 2512 skb = dev_alloc_skb(presp->len);
2523 if (!skb) 2513 if (!skb)
2524 goto out; 2514 goto out;
2525 2515
2526 memcpy(skb_put(skb, presp->len), presp->data, presp->len); 2516 memcpy(skb_put(skb, presp->len), presp->data, presp->len);
2527 2517
2528 hdr = (struct ieee80211_hdr *) skb->data; 2518 hdr = (struct ieee80211_hdr *) skb->data;
2529 memset(hdr->addr1, 0, sizeof(hdr->addr1)); 2519 memset(hdr->addr1, 0, sizeof(hdr->addr1));
2530 2520
2531 out: 2521 out:
2532 rcu_read_unlock(); 2522 rcu_read_unlock();
2533 return skb; 2523 return skb;
2534 } 2524 }
2535 EXPORT_SYMBOL(ieee80211_proberesp_get); 2525 EXPORT_SYMBOL(ieee80211_proberesp_get);
2536 2526
2537 struct sk_buff *ieee80211_pspoll_get(struct ieee80211_hw *hw, 2527 struct sk_buff *ieee80211_pspoll_get(struct ieee80211_hw *hw,
2538 struct ieee80211_vif *vif) 2528 struct ieee80211_vif *vif)
2539 { 2529 {
2540 struct ieee80211_sub_if_data *sdata; 2530 struct ieee80211_sub_if_data *sdata;
2541 struct ieee80211_if_managed *ifmgd; 2531 struct ieee80211_if_managed *ifmgd;
2542 struct ieee80211_pspoll *pspoll; 2532 struct ieee80211_pspoll *pspoll;
2543 struct ieee80211_local *local; 2533 struct ieee80211_local *local;
2544 struct sk_buff *skb; 2534 struct sk_buff *skb;
2545 2535
2546 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION)) 2536 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
2547 return NULL; 2537 return NULL;
2548 2538
2549 sdata = vif_to_sdata(vif); 2539 sdata = vif_to_sdata(vif);
2550 ifmgd = &sdata->u.mgd; 2540 ifmgd = &sdata->u.mgd;
2551 local = sdata->local; 2541 local = sdata->local;
2552 2542
2553 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll)); 2543 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll));
2554 if (!skb) 2544 if (!skb)
2555 return NULL; 2545 return NULL;
2556 2546
2557 skb_reserve(skb, local->hw.extra_tx_headroom); 2547 skb_reserve(skb, local->hw.extra_tx_headroom);
2558 2548
2559 pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll)); 2549 pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll));
2560 memset(pspoll, 0, sizeof(*pspoll)); 2550 memset(pspoll, 0, sizeof(*pspoll));
2561 pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL | 2551 pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
2562 IEEE80211_STYPE_PSPOLL); 2552 IEEE80211_STYPE_PSPOLL);
2563 pspoll->aid = cpu_to_le16(ifmgd->aid); 2553 pspoll->aid = cpu_to_le16(ifmgd->aid);
2564 2554
2565 /* aid in PS-Poll has its two MSBs each set to 1 */ 2555 /* aid in PS-Poll has its two MSBs each set to 1 */
2566 pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14); 2556 pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);
2567 2557
2568 memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN); 2558 memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);
2569 memcpy(pspoll->ta, vif->addr, ETH_ALEN); 2559 memcpy(pspoll->ta, vif->addr, ETH_ALEN);
2570 2560
2571 return skb; 2561 return skb;
2572 } 2562 }
2573 EXPORT_SYMBOL(ieee80211_pspoll_get); 2563 EXPORT_SYMBOL(ieee80211_pspoll_get);
2574 2564
2575 struct sk_buff *ieee80211_nullfunc_get(struct ieee80211_hw *hw, 2565 struct sk_buff *ieee80211_nullfunc_get(struct ieee80211_hw *hw,
2576 struct ieee80211_vif *vif) 2566 struct ieee80211_vif *vif)
2577 { 2567 {
2578 struct ieee80211_hdr_3addr *nullfunc; 2568 struct ieee80211_hdr_3addr *nullfunc;
2579 struct ieee80211_sub_if_data *sdata; 2569 struct ieee80211_sub_if_data *sdata;
2580 struct ieee80211_if_managed *ifmgd; 2570 struct ieee80211_if_managed *ifmgd;
2581 struct ieee80211_local *local; 2571 struct ieee80211_local *local;
2582 struct sk_buff *skb; 2572 struct sk_buff *skb;
2583 2573
2584 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION)) 2574 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
2585 return NULL; 2575 return NULL;
2586 2576
2587 sdata = vif_to_sdata(vif); 2577 sdata = vif_to_sdata(vif);
2588 ifmgd = &sdata->u.mgd; 2578 ifmgd = &sdata->u.mgd;
2589 local = sdata->local; 2579 local = sdata->local;
2590 2580
2591 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*nullfunc)); 2581 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*nullfunc));
2592 if (!skb) 2582 if (!skb)
2593 return NULL; 2583 return NULL;
2594 2584
2595 skb_reserve(skb, local->hw.extra_tx_headroom); 2585 skb_reserve(skb, local->hw.extra_tx_headroom);
2596 2586
2597 nullfunc = (struct ieee80211_hdr_3addr *) skb_put(skb, 2587 nullfunc = (struct ieee80211_hdr_3addr *) skb_put(skb,
2598 sizeof(*nullfunc)); 2588 sizeof(*nullfunc));
2599 memset(nullfunc, 0, sizeof(*nullfunc)); 2589 memset(nullfunc, 0, sizeof(*nullfunc));
2600 nullfunc->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | 2590 nullfunc->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
2601 IEEE80211_STYPE_NULLFUNC | 2591 IEEE80211_STYPE_NULLFUNC |
2602 IEEE80211_FCTL_TODS); 2592 IEEE80211_FCTL_TODS);
2603 memcpy(nullfunc->addr1, ifmgd->bssid, ETH_ALEN); 2593 memcpy(nullfunc->addr1, ifmgd->bssid, ETH_ALEN);
2604 memcpy(nullfunc->addr2, vif->addr, ETH_ALEN); 2594 memcpy(nullfunc->addr2, vif->addr, ETH_ALEN);
2605 memcpy(nullfunc->addr3, ifmgd->bssid, ETH_ALEN); 2595 memcpy(nullfunc->addr3, ifmgd->bssid, ETH_ALEN);
2606 2596
2607 return skb; 2597 return skb;
2608 } 2598 }
2609 EXPORT_SYMBOL(ieee80211_nullfunc_get); 2599 EXPORT_SYMBOL(ieee80211_nullfunc_get);
2610 2600
2611 struct sk_buff *ieee80211_probereq_get(struct ieee80211_hw *hw, 2601 struct sk_buff *ieee80211_probereq_get(struct ieee80211_hw *hw,
2612 struct ieee80211_vif *vif, 2602 struct ieee80211_vif *vif,
2613 const u8 *ssid, size_t ssid_len, 2603 const u8 *ssid, size_t ssid_len,
2614 size_t tailroom) 2604 size_t tailroom)
2615 { 2605 {
2616 struct ieee80211_sub_if_data *sdata; 2606 struct ieee80211_sub_if_data *sdata;
2617 struct ieee80211_local *local; 2607 struct ieee80211_local *local;
2618 struct ieee80211_hdr_3addr *hdr; 2608 struct ieee80211_hdr_3addr *hdr;
2619 struct sk_buff *skb; 2609 struct sk_buff *skb;
2620 size_t ie_ssid_len; 2610 size_t ie_ssid_len;
2621 u8 *pos; 2611 u8 *pos;
2622 2612
2623 sdata = vif_to_sdata(vif); 2613 sdata = vif_to_sdata(vif);
2624 local = sdata->local; 2614 local = sdata->local;
2625 ie_ssid_len = 2 + ssid_len; 2615 ie_ssid_len = 2 + ssid_len;
2626 2616
2627 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*hdr) + 2617 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*hdr) +
2628 ie_ssid_len + tailroom); 2618 ie_ssid_len + tailroom);
2629 if (!skb) 2619 if (!skb)
2630 return NULL; 2620 return NULL;
2631 2621
2632 skb_reserve(skb, local->hw.extra_tx_headroom); 2622 skb_reserve(skb, local->hw.extra_tx_headroom);
2633 2623
2634 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr)); 2624 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
2635 memset(hdr, 0, sizeof(*hdr)); 2625 memset(hdr, 0, sizeof(*hdr));
2636 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 2626 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2637 IEEE80211_STYPE_PROBE_REQ); 2627 IEEE80211_STYPE_PROBE_REQ);
2638 eth_broadcast_addr(hdr->addr1); 2628 eth_broadcast_addr(hdr->addr1);
2639 memcpy(hdr->addr2, vif->addr, ETH_ALEN); 2629 memcpy(hdr->addr2, vif->addr, ETH_ALEN);
2640 eth_broadcast_addr(hdr->addr3); 2630 eth_broadcast_addr(hdr->addr3);
2641 2631
2642 pos = skb_put(skb, ie_ssid_len); 2632 pos = skb_put(skb, ie_ssid_len);
2643 *pos++ = WLAN_EID_SSID; 2633 *pos++ = WLAN_EID_SSID;
2644 *pos++ = ssid_len; 2634 *pos++ = ssid_len;
2645 if (ssid_len) 2635 if (ssid_len)
2646 memcpy(pos, ssid, ssid_len); 2636 memcpy(pos, ssid, ssid_len);
2647 pos += ssid_len; 2637 pos += ssid_len;
2648 2638
2649 return skb; 2639 return skb;
2650 } 2640 }
2651 EXPORT_SYMBOL(ieee80211_probereq_get); 2641 EXPORT_SYMBOL(ieee80211_probereq_get);
2652 2642
2653 void ieee80211_rts_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2643 void ieee80211_rts_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2654 const void *frame, size_t frame_len, 2644 const void *frame, size_t frame_len,
2655 const struct ieee80211_tx_info *frame_txctl, 2645 const struct ieee80211_tx_info *frame_txctl,
2656 struct ieee80211_rts *rts) 2646 struct ieee80211_rts *rts)
2657 { 2647 {
2658 const struct ieee80211_hdr *hdr = frame; 2648 const struct ieee80211_hdr *hdr = frame;
2659 2649
2660 rts->frame_control = 2650 rts->frame_control =
2661 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS); 2651 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
2662 rts->duration = ieee80211_rts_duration(hw, vif, frame_len, 2652 rts->duration = ieee80211_rts_duration(hw, vif, frame_len,
2663 frame_txctl); 2653 frame_txctl);
2664 memcpy(rts->ra, hdr->addr1, sizeof(rts->ra)); 2654 memcpy(rts->ra, hdr->addr1, sizeof(rts->ra));
2665 memcpy(rts->ta, hdr->addr2, sizeof(rts->ta)); 2655 memcpy(rts->ta, hdr->addr2, sizeof(rts->ta));
2666 } 2656 }
2667 EXPORT_SYMBOL(ieee80211_rts_get); 2657 EXPORT_SYMBOL(ieee80211_rts_get);
2668 2658
2669 void ieee80211_ctstoself_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2659 void ieee80211_ctstoself_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2670 const void *frame, size_t frame_len, 2660 const void *frame, size_t frame_len,
2671 const struct ieee80211_tx_info *frame_txctl, 2661 const struct ieee80211_tx_info *frame_txctl,
2672 struct ieee80211_cts *cts) 2662 struct ieee80211_cts *cts)
2673 { 2663 {
2674 const struct ieee80211_hdr *hdr = frame; 2664 const struct ieee80211_hdr *hdr = frame;
2675 2665
2676 cts->frame_control = 2666 cts->frame_control =
2677 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS); 2667 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS);
2678 cts->duration = ieee80211_ctstoself_duration(hw, vif, 2668 cts->duration = ieee80211_ctstoself_duration(hw, vif,
2679 frame_len, frame_txctl); 2669 frame_len, frame_txctl);
2680 memcpy(cts->ra, hdr->addr1, sizeof(cts->ra)); 2670 memcpy(cts->ra, hdr->addr1, sizeof(cts->ra));
2681 } 2671 }
2682 EXPORT_SYMBOL(ieee80211_ctstoself_get); 2672 EXPORT_SYMBOL(ieee80211_ctstoself_get);
2683 2673
2684 struct sk_buff * 2674 struct sk_buff *
2685 ieee80211_get_buffered_bc(struct ieee80211_hw *hw, 2675 ieee80211_get_buffered_bc(struct ieee80211_hw *hw,
2686 struct ieee80211_vif *vif) 2676 struct ieee80211_vif *vif)
2687 { 2677 {
2688 struct ieee80211_local *local = hw_to_local(hw); 2678 struct ieee80211_local *local = hw_to_local(hw);
2689 struct sk_buff *skb = NULL; 2679 struct sk_buff *skb = NULL;
2690 struct ieee80211_tx_data tx; 2680 struct ieee80211_tx_data tx;
2691 struct ieee80211_sub_if_data *sdata; 2681 struct ieee80211_sub_if_data *sdata;
2692 struct ps_data *ps; 2682 struct ps_data *ps;
2693 struct ieee80211_tx_info *info; 2683 struct ieee80211_tx_info *info;
2694 struct ieee80211_chanctx_conf *chanctx_conf; 2684 struct ieee80211_chanctx_conf *chanctx_conf;
2695 2685
2696 sdata = vif_to_sdata(vif); 2686 sdata = vif_to_sdata(vif);
2697 2687
2698 rcu_read_lock(); 2688 rcu_read_lock();
2699 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 2689 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2700 2690
2701 if (!chanctx_conf) 2691 if (!chanctx_conf)
2702 goto out; 2692 goto out;
2703 2693
2704 if (sdata->vif.type == NL80211_IFTYPE_AP) { 2694 if (sdata->vif.type == NL80211_IFTYPE_AP) {
2705 struct beacon_data *beacon = 2695 struct beacon_data *beacon =
2706 rcu_dereference(sdata->u.ap.beacon); 2696 rcu_dereference(sdata->u.ap.beacon);
2707 2697
2708 if (!beacon || !beacon->head) 2698 if (!beacon || !beacon->head)
2709 goto out; 2699 goto out;
2710 2700
2711 ps = &sdata->u.ap.ps; 2701 ps = &sdata->u.ap.ps;
2712 } else if (ieee80211_vif_is_mesh(&sdata->vif)) { 2702 } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
2713 ps = &sdata->u.mesh.ps; 2703 ps = &sdata->u.mesh.ps;
2714 } else { 2704 } else {
2715 goto out; 2705 goto out;
2716 } 2706 }
2717 2707
2718 if (ps->dtim_count != 0 || !ps->dtim_bc_mc) 2708 if (ps->dtim_count != 0 || !ps->dtim_bc_mc)
2719 goto out; /* send buffered bc/mc only after DTIM beacon */ 2709 goto out; /* send buffered bc/mc only after DTIM beacon */
2720 2710
2721 while (1) { 2711 while (1) {
2722 skb = skb_dequeue(&ps->bc_buf); 2712 skb = skb_dequeue(&ps->bc_buf);
2723 if (!skb) 2713 if (!skb)
2724 goto out; 2714 goto out;
2725 local->total_ps_buffered--; 2715 local->total_ps_buffered--;
2726 2716
2727 if (!skb_queue_empty(&ps->bc_buf) && skb->len >= 2) { 2717 if (!skb_queue_empty(&ps->bc_buf) && skb->len >= 2) {
2728 struct ieee80211_hdr *hdr = 2718 struct ieee80211_hdr *hdr =
2729 (struct ieee80211_hdr *) skb->data; 2719 (struct ieee80211_hdr *) skb->data;
2730 /* more buffered multicast/broadcast frames ==> set 2720 /* more buffered multicast/broadcast frames ==> set
2731 * MoreData flag in IEEE 802.11 header to inform PS 2721 * MoreData flag in IEEE 802.11 header to inform PS
2732 * STAs */ 2722 * STAs */
2733 hdr->frame_control |= 2723 hdr->frame_control |=
2734 cpu_to_le16(IEEE80211_FCTL_MOREDATA); 2724 cpu_to_le16(IEEE80211_FCTL_MOREDATA);
2735 } 2725 }
2736 2726
2737 sdata = IEEE80211_DEV_TO_SUB_IF(skb->dev); 2727 sdata = IEEE80211_DEV_TO_SUB_IF(skb->dev);
2738 if (!ieee80211_tx_prepare(sdata, &tx, skb)) 2728 if (!ieee80211_tx_prepare(sdata, &tx, skb))
2739 break; 2729 break;
2740 dev_kfree_skb_any(skb); 2730 dev_kfree_skb_any(skb);
2741 } 2731 }
2742 2732
2743 info = IEEE80211_SKB_CB(skb); 2733 info = IEEE80211_SKB_CB(skb);
2744 2734
2745 tx.flags |= IEEE80211_TX_PS_BUFFERED; 2735 tx.flags |= IEEE80211_TX_PS_BUFFERED;
2746 info->band = chanctx_conf->def.chan->band; 2736 info->band = chanctx_conf->def.chan->band;
2747 2737
2748 if (invoke_tx_handlers(&tx)) 2738 if (invoke_tx_handlers(&tx))
2749 skb = NULL; 2739 skb = NULL;
2750 out: 2740 out:
2751 rcu_read_unlock(); 2741 rcu_read_unlock();
2752 2742
2753 return skb; 2743 return skb;
2754 } 2744 }
2755 EXPORT_SYMBOL(ieee80211_get_buffered_bc); 2745 EXPORT_SYMBOL(ieee80211_get_buffered_bc);
2756 2746
2757 void __ieee80211_tx_skb_tid_band(struct ieee80211_sub_if_data *sdata, 2747 void __ieee80211_tx_skb_tid_band(struct ieee80211_sub_if_data *sdata,
2758 struct sk_buff *skb, int tid, 2748 struct sk_buff *skb, int tid,
2759 enum ieee80211_band band) 2749 enum ieee80211_band band)
2760 { 2750 {
2761 int ac = ieee802_1d_to_ac[tid & 7]; 2751 int ac = ieee802_1d_to_ac[tid & 7];
2762 2752
2763 skb_set_mac_header(skb, 0); 2753 skb_set_mac_header(skb, 0);
2764 skb_set_network_header(skb, 0); 2754 skb_set_network_header(skb, 0);
2765 skb_set_transport_header(skb, 0); 2755 skb_set_transport_header(skb, 0);
2766 2756
2767 skb_set_queue_mapping(skb, ac); 2757 skb_set_queue_mapping(skb, ac);
2768 skb->priority = tid; 2758 skb->priority = tid;
2769 2759
2770 skb->dev = sdata->dev; 2760 skb->dev = sdata->dev;
2771 2761
2772 /* 2762 /*
2773 * The other path calling ieee80211_xmit is from the tasklet, 2763 * The other path calling ieee80211_xmit is from the tasklet,
2774 * and while we can handle concurrent transmissions locking 2764 * and while we can handle concurrent transmissions locking
2775 * requirements are that we do not come into tx with bhs on. 2765 * requirements are that we do not come into tx with bhs on.
2776 */ 2766 */
2777 local_bh_disable(); 2767 local_bh_disable();
2778 ieee80211_xmit(sdata, skb, band); 2768 ieee80211_xmit(sdata, skb, band);
2779 local_bh_enable(); 2769 local_bh_enable();
2780 } 2770 }
2781 2771