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