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