Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[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
184 static ieee80211_tx_result debug_noinline
185 ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx)
186 {
187
188         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
189         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
190         u32 sta_flags;
191
192         if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED))
193                 return TX_CONTINUE;
194
195         if (unlikely(tx->local->sw_scanning) &&
196             !ieee80211_is_probe_req(hdr->frame_control) &&
197             !ieee80211_is_nullfunc(hdr->frame_control))
198                 /*
199                  * When software scanning only nullfunc frames (to notify
200                  * the sleep state to the AP) and probe requests (for the
201                  * active scan) are allowed, all other frames should not be
202                  * sent and we should not get here, but if we do
203                  * nonetheless, drop them to avoid sending them
204                  * off-channel. See the link below and
205                  * ieee80211_start_scan() for more.
206                  *
207                  * http://article.gmane.org/gmane.linux.kernel.wireless.general/30089
208                  */
209                 return TX_DROP;
210
211         if (tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
212                 return TX_CONTINUE;
213
214         if (tx->flags & IEEE80211_TX_PS_BUFFERED)
215                 return TX_CONTINUE;
216
217         sta_flags = tx->sta ? get_sta_flags(tx->sta) : 0;
218
219         if (likely(tx->flags & IEEE80211_TX_UNICAST)) {
220                 if (unlikely(!(sta_flags & WLAN_STA_ASSOC) &&
221                              tx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
222                              ieee80211_is_data(hdr->frame_control))) {
223 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
224                         printk(KERN_DEBUG "%s: dropped data frame to not "
225                                "associated station %pM\n",
226                                tx->dev->name, hdr->addr1);
227 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
228                         I802_DEBUG_INC(tx->local->tx_handlers_drop_not_assoc);
229                         return TX_DROP;
230                 }
231         } else {
232                 if (unlikely(ieee80211_is_data(hdr->frame_control) &&
233                              tx->local->num_sta == 0 &&
234                              tx->sdata->vif.type != NL80211_IFTYPE_ADHOC)) {
235                         /*
236                          * No associated STAs - no need to send multicast
237                          * frames.
238                          */
239                         return TX_DROP;
240                 }
241                 return TX_CONTINUE;
242         }
243
244         return TX_CONTINUE;
245 }
246
247 /* This function is called whenever the AP is about to exceed the maximum limit
248  * of buffered frames for power saving STAs. This situation should not really
249  * happen often during normal operation, so dropping the oldest buffered packet
250  * from each queue should be OK to make some room for new frames. */
251 static void purge_old_ps_buffers(struct ieee80211_local *local)
252 {
253         int total = 0, purged = 0;
254         struct sk_buff *skb;
255         struct ieee80211_sub_if_data *sdata;
256         struct sta_info *sta;
257
258         /*
259          * virtual interfaces are protected by RCU
260          */
261         rcu_read_lock();
262
263         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
264                 struct ieee80211_if_ap *ap;
265                 if (sdata->vif.type != NL80211_IFTYPE_AP)
266                         continue;
267                 ap = &sdata->u.ap;
268                 skb = skb_dequeue(&ap->ps_bc_buf);
269                 if (skb) {
270                         purged++;
271                         dev_kfree_skb(skb);
272                 }
273                 total += skb_queue_len(&ap->ps_bc_buf);
274         }
275
276         list_for_each_entry_rcu(sta, &local->sta_list, list) {
277                 skb = skb_dequeue(&sta->ps_tx_buf);
278                 if (skb) {
279                         purged++;
280                         dev_kfree_skb(skb);
281                 }
282                 total += skb_queue_len(&sta->ps_tx_buf);
283         }
284
285         rcu_read_unlock();
286
287         local->total_ps_buffered = total;
288 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
289         printk(KERN_DEBUG "%s: PS buffers full - purged %d frames\n",
290                wiphy_name(local->hw.wiphy), purged);
291 #endif
292 }
293
294 static ieee80211_tx_result
295 ieee80211_tx_h_multicast_ps_buf(struct ieee80211_tx_data *tx)
296 {
297         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
298         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
299
300         /*
301          * broadcast/multicast frame
302          *
303          * If any of the associated stations is in power save mode,
304          * the frame is buffered to be sent after DTIM beacon frame.
305          * This is done either by the hardware or us.
306          */
307
308         /* powersaving STAs only in AP/VLAN mode */
309         if (!tx->sdata->bss)
310                 return TX_CONTINUE;
311
312         /* no buffering for ordered frames */
313         if (ieee80211_has_order(hdr->frame_control))
314                 return TX_CONTINUE;
315
316         /* no stations in PS mode */
317         if (!atomic_read(&tx->sdata->bss->num_sta_ps))
318                 return TX_CONTINUE;
319
320         /* buffered in mac80211 */
321         if (tx->local->hw.flags & IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING) {
322                 if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
323                         purge_old_ps_buffers(tx->local);
324                 if (skb_queue_len(&tx->sdata->bss->ps_bc_buf) >=
325                     AP_MAX_BC_BUFFER) {
326 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
327                         if (net_ratelimit()) {
328                                 printk(KERN_DEBUG "%s: BC TX buffer full - "
329                                        "dropping the oldest frame\n",
330                                        tx->dev->name);
331                         }
332 #endif
333                         dev_kfree_skb(skb_dequeue(&tx->sdata->bss->ps_bc_buf));
334                 } else
335                         tx->local->total_ps_buffered++;
336                 skb_queue_tail(&tx->sdata->bss->ps_bc_buf, tx->skb);
337                 return TX_QUEUED;
338         }
339
340         /* buffered in hardware */
341         info->flags |= IEEE80211_TX_CTL_SEND_AFTER_DTIM;
342
343         return TX_CONTINUE;
344 }
345
346 static int ieee80211_use_mfp(__le16 fc, struct sta_info *sta,
347                              struct sk_buff *skb)
348 {
349         if (!ieee80211_is_mgmt(fc))
350                 return 0;
351
352         if (sta == NULL || !test_sta_flags(sta, WLAN_STA_MFP))
353                 return 0;
354
355         if (!ieee80211_is_robust_mgmt_frame((struct ieee80211_hdr *)
356                                             skb->data))
357                 return 0;
358
359         return 1;
360 }
361
362 static ieee80211_tx_result
363 ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx)
364 {
365         struct sta_info *sta = tx->sta;
366         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
367         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
368         u32 staflags;
369
370         if (unlikely(!sta || ieee80211_is_probe_resp(hdr->frame_control)))
371                 return TX_CONTINUE;
372
373         staflags = get_sta_flags(sta);
374
375         if (unlikely((staflags & WLAN_STA_PS) &&
376                      !(staflags & WLAN_STA_PSPOLL))) {
377 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
378                 printk(KERN_DEBUG "STA %pM aid %d: PS buffer (entries "
379                        "before %d)\n",
380                        sta->sta.addr, sta->sta.aid,
381                        skb_queue_len(&sta->ps_tx_buf));
382 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
383                 if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
384                         purge_old_ps_buffers(tx->local);
385                 if (skb_queue_len(&sta->ps_tx_buf) >= STA_MAX_TX_BUFFER) {
386                         struct sk_buff *old = skb_dequeue(&sta->ps_tx_buf);
387 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
388                         if (net_ratelimit()) {
389                                 printk(KERN_DEBUG "%s: STA %pM TX "
390                                        "buffer full - dropping oldest frame\n",
391                                        tx->dev->name, sta->sta.addr);
392                         }
393 #endif
394                         dev_kfree_skb(old);
395                 } else
396                         tx->local->total_ps_buffered++;
397
398                 /* Queue frame to be sent after STA sends an PS Poll frame */
399                 if (skb_queue_empty(&sta->ps_tx_buf))
400                         sta_info_set_tim_bit(sta);
401
402                 info->control.jiffies = jiffies;
403                 info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
404                 skb_queue_tail(&sta->ps_tx_buf, tx->skb);
405                 return TX_QUEUED;
406         }
407 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
408         else if (unlikely(test_sta_flags(sta, WLAN_STA_PS))) {
409                 printk(KERN_DEBUG "%s: STA %pM in PS mode, but pspoll "
410                        "set -> send frame\n", tx->dev->name,
411                        sta->sta.addr);
412         }
413 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
414         if (test_and_clear_sta_flags(sta, WLAN_STA_PSPOLL)) {
415                 /*
416                  * The sleeping station with pending data is now snoozing.
417                  * It queried us for its buffered frames and will go back
418                  * to deep sleep once it got everything.
419                  *
420                  * inform the driver, in case the hardware does powersave
421                  * frame filtering and keeps a station  blacklist on its own
422                  * (e.g: p54), so that frames can be delivered unimpeded.
423                  *
424                  * Note: It should be safe to disable the filter now.
425                  * As, it is really unlikely that we still have any pending
426                  * frame for this station in the hw's buffers/fifos left,
427                  * that is not rejected with a unsuccessful tx_status yet.
428                  */
429
430                 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
431         }
432         return TX_CONTINUE;
433 }
434
435 static ieee80211_tx_result debug_noinline
436 ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx)
437 {
438         if (unlikely(tx->flags & IEEE80211_TX_PS_BUFFERED))
439                 return TX_CONTINUE;
440
441         if (tx->flags & IEEE80211_TX_UNICAST)
442                 return ieee80211_tx_h_unicast_ps_buf(tx);
443         else
444                 return ieee80211_tx_h_multicast_ps_buf(tx);
445 }
446
447 static ieee80211_tx_result debug_noinline
448 ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx)
449 {
450         struct ieee80211_key *key = NULL;
451         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
452         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
453
454         if (unlikely(tx->skb->do_not_encrypt))
455                 tx->key = NULL;
456         else if (tx->sta && (key = rcu_dereference(tx->sta->key)))
457                 tx->key = key;
458         else if (ieee80211_is_mgmt(hdr->frame_control) &&
459                  (key = rcu_dereference(tx->sdata->default_mgmt_key)))
460                 tx->key = key;
461         else if ((key = rcu_dereference(tx->sdata->default_key)))
462                 tx->key = key;
463         else if (tx->sdata->drop_unencrypted &&
464                  (tx->skb->protocol != cpu_to_be16(ETH_P_PAE)) &&
465                  !(info->flags & IEEE80211_TX_CTL_INJECTED) &&
466                  (!ieee80211_is_robust_mgmt_frame(hdr) ||
467                   (ieee80211_is_action(hdr->frame_control) &&
468                    tx->sta && test_sta_flags(tx->sta, WLAN_STA_MFP)))) {
469                 I802_DEBUG_INC(tx->local->tx_handlers_drop_unencrypted);
470                 return TX_DROP;
471         } else
472                 tx->key = NULL;
473
474         if (tx->key) {
475                 tx->key->tx_rx_count++;
476                 /* TODO: add threshold stuff again */
477
478                 switch (tx->key->conf.alg) {
479                 case ALG_WEP:
480                         if (ieee80211_is_auth(hdr->frame_control))
481                                 break;
482                 case ALG_TKIP:
483                         if (!ieee80211_is_data_present(hdr->frame_control))
484                                 tx->key = NULL;
485                         break;
486                 case ALG_CCMP:
487                         if (!ieee80211_is_data_present(hdr->frame_control) &&
488                             !ieee80211_use_mfp(hdr->frame_control, tx->sta,
489                                                tx->skb))
490                                 tx->key = NULL;
491                         break;
492                 case ALG_AES_CMAC:
493                         if (!ieee80211_is_mgmt(hdr->frame_control))
494                                 tx->key = NULL;
495                         break;
496                 }
497         }
498
499         if (!tx->key || !(tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
500                 tx->skb->do_not_encrypt = 1;
501
502         return TX_CONTINUE;
503 }
504
505 static ieee80211_tx_result debug_noinline
506 ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
507 {
508         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
509         struct ieee80211_hdr *hdr = (void *)tx->skb->data;
510         struct ieee80211_supported_band *sband;
511         struct ieee80211_rate *rate;
512         int i, len;
513         bool inval = false, rts = false, short_preamble = false;
514         struct ieee80211_tx_rate_control txrc;
515
516         memset(&txrc, 0, sizeof(txrc));
517
518         sband = tx->local->hw.wiphy->bands[tx->channel->band];
519
520         len = min_t(int, tx->skb->len + FCS_LEN,
521                          tx->local->hw.wiphy->frag_threshold);
522
523         /* set up the tx rate control struct we give the RC algo */
524         txrc.hw = local_to_hw(tx->local);
525         txrc.sband = sband;
526         txrc.bss_conf = &tx->sdata->vif.bss_conf;
527         txrc.skb = tx->skb;
528         txrc.reported_rate.idx = -1;
529         txrc.max_rate_idx = tx->sdata->max_ratectrl_rateidx;
530
531         /* set up RTS protection if desired */
532         if (len > tx->local->hw.wiphy->rts_threshold) {
533                 txrc.rts = rts = true;
534         }
535
536         /*
537          * Use short preamble if the BSS can handle it, but not for
538          * management frames unless we know the receiver can handle
539          * that -- the management frame might be to a station that
540          * just wants a probe response.
541          */
542         if (tx->sdata->vif.bss_conf.use_short_preamble &&
543             (ieee80211_is_data(hdr->frame_control) ||
544              (tx->sta && test_sta_flags(tx->sta, WLAN_STA_SHORT_PREAMBLE))))
545                 txrc.short_preamble = short_preamble = true;
546
547
548         rate_control_get_rate(tx->sdata, tx->sta, &txrc);
549
550         if (unlikely(info->control.rates[0].idx < 0))
551                 return TX_DROP;
552
553         if (txrc.reported_rate.idx < 0)
554                 txrc.reported_rate = info->control.rates[0];
555
556         if (tx->sta)
557                 tx->sta->last_tx_rate = txrc.reported_rate;
558
559         if (unlikely(!info->control.rates[0].count))
560                 info->control.rates[0].count = 1;
561
562         if (WARN_ON_ONCE((info->control.rates[0].count > 1) &&
563                          (info->flags & IEEE80211_TX_CTL_NO_ACK)))
564                 info->control.rates[0].count = 1;
565
566         if (is_multicast_ether_addr(hdr->addr1)) {
567                 /*
568                  * XXX: verify the rate is in the basic rateset
569                  */
570                 return TX_CONTINUE;
571         }
572
573         /*
574          * set up the RTS/CTS rate as the fastest basic rate
575          * that is not faster than the data rate
576          *
577          * XXX: Should this check all retry rates?
578          */
579         if (!(info->control.rates[0].flags & IEEE80211_TX_RC_MCS)) {
580                 s8 baserate = 0;
581
582                 rate = &sband->bitrates[info->control.rates[0].idx];
583
584                 for (i = 0; i < sband->n_bitrates; i++) {
585                         /* must be a basic rate */
586                         if (!(tx->sdata->vif.bss_conf.basic_rates & BIT(i)))
587                                 continue;
588                         /* must not be faster than the data rate */
589                         if (sband->bitrates[i].bitrate > rate->bitrate)
590                                 continue;
591                         /* maximum */
592                         if (sband->bitrates[baserate].bitrate <
593                              sband->bitrates[i].bitrate)
594                                 baserate = i;
595                 }
596
597                 info->control.rts_cts_rate_idx = baserate;
598         }
599
600         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
601                 /*
602                  * make sure there's no valid rate following
603                  * an invalid one, just in case drivers don't
604                  * take the API seriously to stop at -1.
605                  */
606                 if (inval) {
607                         info->control.rates[i].idx = -1;
608                         continue;
609                 }
610                 if (info->control.rates[i].idx < 0) {
611                         inval = true;
612                         continue;
613                 }
614
615                 /*
616                  * For now assume MCS is already set up correctly, this
617                  * needs to be fixed.
618                  */
619                 if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS) {
620                         WARN_ON(info->control.rates[i].idx > 76);
621                         continue;
622                 }
623
624                 /* set up RTS protection if desired */
625                 if (rts)
626                         info->control.rates[i].flags |=
627                                 IEEE80211_TX_RC_USE_RTS_CTS;
628
629                 /* RC is busted */
630                 if (WARN_ON_ONCE(info->control.rates[i].idx >=
631                                  sband->n_bitrates)) {
632                         info->control.rates[i].idx = -1;
633                         continue;
634                 }
635
636                 rate = &sband->bitrates[info->control.rates[i].idx];
637
638                 /* set up short preamble */
639                 if (short_preamble &&
640                     rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
641                         info->control.rates[i].flags |=
642                                 IEEE80211_TX_RC_USE_SHORT_PREAMBLE;
643
644                 /* set up G protection */
645                 if (!rts && tx->sdata->vif.bss_conf.use_cts_prot &&
646                     rate->flags & IEEE80211_RATE_ERP_G)
647                         info->control.rates[i].flags |=
648                                 IEEE80211_TX_RC_USE_CTS_PROTECT;
649         }
650
651         return TX_CONTINUE;
652 }
653
654 static ieee80211_tx_result debug_noinline
655 ieee80211_tx_h_misc(struct ieee80211_tx_data *tx)
656 {
657         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
658
659         if (tx->sta)
660                 info->control.sta = &tx->sta->sta;
661
662         return TX_CONTINUE;
663 }
664
665 static ieee80211_tx_result debug_noinline
666 ieee80211_tx_h_sequence(struct ieee80211_tx_data *tx)
667 {
668         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
669         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
670         u16 *seq;
671         u8 *qc;
672         int tid;
673
674         /*
675          * Packet injection may want to control the sequence
676          * number, if we have no matching interface then we
677          * neither assign one ourselves nor ask the driver to.
678          */
679         if (unlikely(!info->control.vif))
680                 return TX_CONTINUE;
681
682         if (unlikely(ieee80211_is_ctl(hdr->frame_control)))
683                 return TX_CONTINUE;
684
685         if (ieee80211_hdrlen(hdr->frame_control) < 24)
686                 return TX_CONTINUE;
687
688         /*
689          * Anything but QoS data that has a sequence number field
690          * (is long enough) gets a sequence number from the global
691          * counter.
692          */
693         if (!ieee80211_is_data_qos(hdr->frame_control)) {
694                 /* driver should assign sequence number */
695                 info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
696                 /* for pure STA mode without beacons, we can do it */
697                 hdr->seq_ctrl = cpu_to_le16(tx->sdata->sequence_number);
698                 tx->sdata->sequence_number += 0x10;
699                 tx->sdata->sequence_number &= IEEE80211_SCTL_SEQ;
700                 return TX_CONTINUE;
701         }
702
703         /*
704          * This should be true for injected/management frames only, for
705          * management frames we have set the IEEE80211_TX_CTL_ASSIGN_SEQ
706          * above since they are not QoS-data frames.
707          */
708         if (!tx->sta)
709                 return TX_CONTINUE;
710
711         /* include per-STA, per-TID sequence counter */
712
713         qc = ieee80211_get_qos_ctl(hdr);
714         tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
715         seq = &tx->sta->tid_seq[tid];
716
717         hdr->seq_ctrl = cpu_to_le16(*seq);
718
719         /* Increase the sequence number. */
720         *seq = (*seq + 0x10) & IEEE80211_SCTL_SEQ;
721
722         return TX_CONTINUE;
723 }
724
725 static int ieee80211_fragment(struct ieee80211_local *local,
726                               struct sk_buff *skb, int hdrlen,
727                               int frag_threshold)
728 {
729         struct sk_buff *tail = skb, *tmp;
730         int per_fragm = frag_threshold - hdrlen - FCS_LEN;
731         int pos = hdrlen + per_fragm;
732         int rem = skb->len - hdrlen - per_fragm;
733
734         if (WARN_ON(rem < 0))
735                 return -EINVAL;
736
737         while (rem) {
738                 int fraglen = per_fragm;
739
740                 if (fraglen > rem)
741                         fraglen = rem;
742                 rem -= fraglen;
743                 tmp = dev_alloc_skb(local->tx_headroom +
744                                     frag_threshold +
745                                     IEEE80211_ENCRYPT_HEADROOM +
746                                     IEEE80211_ENCRYPT_TAILROOM);
747                 if (!tmp)
748                         return -ENOMEM;
749                 tail->next = tmp;
750                 tail = tmp;
751                 skb_reserve(tmp, local->tx_headroom +
752                                  IEEE80211_ENCRYPT_HEADROOM);
753                 /* copy control information */
754                 memcpy(tmp->cb, skb->cb, sizeof(tmp->cb));
755                 skb_copy_queue_mapping(tmp, skb);
756                 tmp->priority = skb->priority;
757                 tmp->do_not_encrypt = skb->do_not_encrypt;
758                 tmp->dev = skb->dev;
759                 tmp->iif = skb->iif;
760
761                 /* copy header and data */
762                 memcpy(skb_put(tmp, hdrlen), skb->data, hdrlen);
763                 memcpy(skb_put(tmp, fraglen), skb->data + pos, fraglen);
764
765                 pos += fraglen;
766         }
767
768         skb->len = hdrlen + per_fragm;
769         return 0;
770 }
771
772 static ieee80211_tx_result debug_noinline
773 ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx)
774 {
775         struct sk_buff *skb = tx->skb;
776         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
777         struct ieee80211_hdr *hdr = (void *)skb->data;
778         int frag_threshold = tx->local->hw.wiphy->frag_threshold;
779         int hdrlen;
780         int fragnum;
781
782         if (!(tx->flags & IEEE80211_TX_FRAGMENTED))
783                 return TX_CONTINUE;
784
785         /*
786          * Warn when submitting a fragmented A-MPDU frame and drop it.
787          * This scenario is handled in __ieee80211_tx_prepare but extra
788          * caution taken here as fragmented ampdu may cause Tx stop.
789          */
790         if (WARN_ON(info->flags & IEEE80211_TX_CTL_AMPDU))
791                 return TX_DROP;
792
793         hdrlen = ieee80211_hdrlen(hdr->frame_control);
794
795         /* internal error, why is TX_FRAGMENTED set? */
796         if (WARN_ON(skb->len + FCS_LEN <= frag_threshold))
797                 return TX_DROP;
798
799         /*
800          * Now fragment the frame. This will allocate all the fragments and
801          * chain them (using skb as the first fragment) to skb->next.
802          * During transmission, we will remove the successfully transmitted
803          * fragments from this list. When the low-level driver rejects one
804          * of the fragments then we will simply pretend to accept the skb
805          * but store it away as pending.
806          */
807         if (ieee80211_fragment(tx->local, skb, hdrlen, frag_threshold))
808                 return TX_DROP;
809
810         /* update duration/seq/flags of fragments */
811         fragnum = 0;
812         do {
813                 int next_len;
814                 const __le16 morefrags = cpu_to_le16(IEEE80211_FCTL_MOREFRAGS);
815
816                 hdr = (void *)skb->data;
817                 info = IEEE80211_SKB_CB(skb);
818
819                 if (skb->next) {
820                         hdr->frame_control |= morefrags;
821                         next_len = skb->next->len;
822                         /*
823                          * No multi-rate retries for fragmented frames, that
824                          * would completely throw off the NAV at other STAs.
825                          */
826                         info->control.rates[1].idx = -1;
827                         info->control.rates[2].idx = -1;
828                         info->control.rates[3].idx = -1;
829                         info->control.rates[4].idx = -1;
830                         BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 5);
831                         info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
832                 } else {
833                         hdr->frame_control &= ~morefrags;
834                         next_len = 0;
835                 }
836                 hdr->duration_id = ieee80211_duration(tx, 0, next_len);
837                 hdr->seq_ctrl |= cpu_to_le16(fragnum & IEEE80211_SCTL_FRAG);
838                 fragnum++;
839         } while ((skb = skb->next));
840
841         return TX_CONTINUE;
842 }
843
844 static ieee80211_tx_result debug_noinline
845 ieee80211_tx_h_encrypt(struct ieee80211_tx_data *tx)
846 {
847         if (!tx->key)
848                 return TX_CONTINUE;
849
850         switch (tx->key->conf.alg) {
851         case ALG_WEP:
852                 return ieee80211_crypto_wep_encrypt(tx);
853         case ALG_TKIP:
854                 return ieee80211_crypto_tkip_encrypt(tx);
855         case ALG_CCMP:
856                 return ieee80211_crypto_ccmp_encrypt(tx);
857         case ALG_AES_CMAC:
858                 return ieee80211_crypto_aes_cmac_encrypt(tx);
859         }
860
861         /* not reached */
862         WARN_ON(1);
863         return TX_DROP;
864 }
865
866 static ieee80211_tx_result debug_noinline
867 ieee80211_tx_h_calculate_duration(struct ieee80211_tx_data *tx)
868 {
869         struct sk_buff *skb = tx->skb;
870         struct ieee80211_hdr *hdr;
871         int next_len;
872         bool group_addr;
873
874         do {
875                 hdr = (void *) skb->data;
876                 if (unlikely(ieee80211_is_pspoll(hdr->frame_control)))
877                         break; /* must not overwrite AID */
878                 next_len = skb->next ? skb->next->len : 0;
879                 group_addr = is_multicast_ether_addr(hdr->addr1);
880
881                 hdr->duration_id =
882                         ieee80211_duration(tx, group_addr, next_len);
883         } while ((skb = skb->next));
884
885         return TX_CONTINUE;
886 }
887
888 static ieee80211_tx_result debug_noinline
889 ieee80211_tx_h_stats(struct ieee80211_tx_data *tx)
890 {
891         struct sk_buff *skb = tx->skb;
892
893         if (!tx->sta)
894                 return TX_CONTINUE;
895
896         tx->sta->tx_packets++;
897         do {
898                 tx->sta->tx_fragments++;
899                 tx->sta->tx_bytes += skb->len;
900         } while ((skb = skb->next));
901
902         return TX_CONTINUE;
903 }
904
905 /* actual transmit path */
906
907 /*
908  * deal with packet injection down monitor interface
909  * with Radiotap Header -- only called for monitor mode interface
910  */
911 static bool __ieee80211_parse_tx_radiotap(struct ieee80211_tx_data *tx,
912                                           struct sk_buff *skb)
913 {
914         /*
915          * this is the moment to interpret and discard the radiotap header that
916          * must be at the start of the packet injected in Monitor mode
917          *
918          * Need to take some care with endian-ness since radiotap
919          * args are little-endian
920          */
921
922         struct ieee80211_radiotap_iterator iterator;
923         struct ieee80211_radiotap_header *rthdr =
924                 (struct ieee80211_radiotap_header *) skb->data;
925         struct ieee80211_supported_band *sband;
926         int ret = ieee80211_radiotap_iterator_init(&iterator, rthdr, skb->len);
927
928         sband = tx->local->hw.wiphy->bands[tx->channel->band];
929
930         skb->do_not_encrypt = 1;
931         tx->flags &= ~IEEE80211_TX_FRAGMENTED;
932
933         /*
934          * for every radiotap entry that is present
935          * (ieee80211_radiotap_iterator_next returns -ENOENT when no more
936          * entries present, or -EINVAL on error)
937          */
938
939         while (!ret) {
940                 ret = ieee80211_radiotap_iterator_next(&iterator);
941
942                 if (ret)
943                         continue;
944
945                 /* see if this argument is something we can use */
946                 switch (iterator.this_arg_index) {
947                 /*
948                  * You must take care when dereferencing iterator.this_arg
949                  * for multibyte types... the pointer is not aligned.  Use
950                  * get_unaligned((type *)iterator.this_arg) to dereference
951                  * iterator.this_arg for type "type" safely on all arches.
952                 */
953                 case IEEE80211_RADIOTAP_FLAGS:
954                         if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) {
955                                 /*
956                                  * this indicates that the skb we have been
957                                  * handed has the 32-bit FCS CRC at the end...
958                                  * we should react to that by snipping it off
959                                  * because it will be recomputed and added
960                                  * on transmission
961                                  */
962                                 if (skb->len < (iterator.max_length + FCS_LEN))
963                                         return false;
964
965                                 skb_trim(skb, skb->len - FCS_LEN);
966                         }
967                         if (*iterator.this_arg & IEEE80211_RADIOTAP_F_WEP)
968                                 tx->skb->do_not_encrypt = 0;
969                         if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FRAG)
970                                 tx->flags |= IEEE80211_TX_FRAGMENTED;
971                         break;
972
973                 /*
974                  * Please update the file
975                  * Documentation/networking/mac80211-injection.txt
976                  * when parsing new fields here.
977                  */
978
979                 default:
980                         break;
981                 }
982         }
983
984         if (ret != -ENOENT) /* ie, if we didn't simply run out of fields */
985                 return false;
986
987         /*
988          * remove the radiotap header
989          * iterator->max_length was sanity-checked against
990          * skb->len by iterator init
991          */
992         skb_pull(skb, iterator.max_length);
993
994         return true;
995 }
996
997 /*
998  * initialises @tx
999  */
1000 static ieee80211_tx_result
1001 __ieee80211_tx_prepare(struct ieee80211_tx_data *tx,
1002                        struct sk_buff *skb,
1003                        struct net_device *dev)
1004 {
1005         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1006         struct ieee80211_hdr *hdr;
1007         struct ieee80211_sub_if_data *sdata;
1008         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1009         int hdrlen, tid;
1010         u8 *qc, *state;
1011         bool queued = false;
1012
1013         memset(tx, 0, sizeof(*tx));
1014         tx->skb = skb;
1015         tx->dev = dev; /* use original interface */
1016         tx->local = local;
1017         tx->sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1018         tx->channel = local->hw.conf.channel;
1019         /*
1020          * Set this flag (used below to indicate "automatic fragmentation"),
1021          * it will be cleared/left by radiotap as desired.
1022          */
1023         tx->flags |= IEEE80211_TX_FRAGMENTED;
1024
1025         /* process and remove the injection radiotap header */
1026         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1027         if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED)) {
1028                 if (!__ieee80211_parse_tx_radiotap(tx, skb))
1029                         return TX_DROP;
1030
1031                 /*
1032                  * __ieee80211_parse_tx_radiotap has now removed
1033                  * the radiotap header that was present and pre-filled
1034                  * 'tx' with tx control information.
1035                  */
1036         }
1037
1038         /*
1039          * If this flag is set to true anywhere, and we get here,
1040          * we are doing the needed processing, so remove the flag
1041          * now.
1042          */
1043         info->flags &= ~IEEE80211_TX_INTFL_NEED_TXPROCESSING;
1044
1045         hdr = (struct ieee80211_hdr *) skb->data;
1046
1047         tx->sta = sta_info_get(local, hdr->addr1);
1048
1049         if (tx->sta && ieee80211_is_data_qos(hdr->frame_control) &&
1050             (local->hw.flags & IEEE80211_HW_AMPDU_AGGREGATION)) {
1051                 unsigned long flags;
1052                 struct tid_ampdu_tx *tid_tx;
1053
1054                 qc = ieee80211_get_qos_ctl(hdr);
1055                 tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
1056
1057                 spin_lock_irqsave(&tx->sta->lock, flags);
1058                 /*
1059                  * XXX: This spinlock could be fairly expensive, but see the
1060                  *      comment in agg-tx.c:ieee80211_agg_tx_operational().
1061                  *      One way to solve this would be to do something RCU-like
1062                  *      for managing the tid_tx struct and using atomic bitops
1063                  *      for the actual state -- by introducing an actual
1064                  *      'operational' bit that would be possible. It would
1065                  *      require changing ieee80211_agg_tx_operational() to
1066                  *      set that bit, and changing the way tid_tx is managed
1067                  *      everywhere, including races between that bit and
1068                  *      tid_tx going away (tid_tx being added can be easily
1069                  *      committed to memory before the 'operational' bit).
1070                  */
1071                 tid_tx = tx->sta->ampdu_mlme.tid_tx[tid];
1072                 state = &tx->sta->ampdu_mlme.tid_state_tx[tid];
1073                 if (*state == HT_AGG_STATE_OPERATIONAL) {
1074                         info->flags |= IEEE80211_TX_CTL_AMPDU;
1075                 } else if (*state != HT_AGG_STATE_IDLE) {
1076                         /* in progress */
1077                         queued = true;
1078                         info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
1079                         __skb_queue_tail(&tid_tx->pending, skb);
1080                 }
1081                 spin_unlock_irqrestore(&tx->sta->lock, flags);
1082
1083                 if (unlikely(queued))
1084                         return TX_QUEUED;
1085         }
1086
1087         if (is_multicast_ether_addr(hdr->addr1)) {
1088                 tx->flags &= ~IEEE80211_TX_UNICAST;
1089                 info->flags |= IEEE80211_TX_CTL_NO_ACK;
1090         } else {
1091                 tx->flags |= IEEE80211_TX_UNICAST;
1092                 if (unlikely(local->wifi_wme_noack_test))
1093                         info->flags |= IEEE80211_TX_CTL_NO_ACK;
1094                 else
1095                         info->flags &= ~IEEE80211_TX_CTL_NO_ACK;
1096         }
1097
1098         if (tx->flags & IEEE80211_TX_FRAGMENTED) {
1099                 if ((tx->flags & IEEE80211_TX_UNICAST) &&
1100                     skb->len + FCS_LEN > local->hw.wiphy->frag_threshold &&
1101                     !(info->flags & IEEE80211_TX_CTL_AMPDU))
1102                         tx->flags |= IEEE80211_TX_FRAGMENTED;
1103                 else
1104                         tx->flags &= ~IEEE80211_TX_FRAGMENTED;
1105         }
1106
1107         if (!tx->sta)
1108                 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
1109         else if (test_and_clear_sta_flags(tx->sta, WLAN_STA_CLEAR_PS_FILT))
1110                 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
1111
1112         hdrlen = ieee80211_hdrlen(hdr->frame_control);
1113         if (skb->len > hdrlen + sizeof(rfc1042_header) + 2) {
1114                 u8 *pos = &skb->data[hdrlen + sizeof(rfc1042_header)];
1115                 tx->ethertype = (pos[0] << 8) | pos[1];
1116         }
1117         info->flags |= IEEE80211_TX_CTL_FIRST_FRAGMENT;
1118
1119         return TX_CONTINUE;
1120 }
1121
1122 /*
1123  * NB: @tx is uninitialised when passed in here
1124  */
1125 static int ieee80211_tx_prepare(struct ieee80211_local *local,
1126                                 struct ieee80211_tx_data *tx,
1127                                 struct sk_buff *skb)
1128 {
1129         struct net_device *dev;
1130
1131         dev = dev_get_by_index(&init_net, skb->iif);
1132         if (unlikely(dev && !is_ieee80211_device(local, dev))) {
1133                 dev_put(dev);
1134                 dev = NULL;
1135         }
1136         if (unlikely(!dev))
1137                 return -ENODEV;
1138         /*
1139          * initialises tx with control
1140          *
1141          * return value is safe to ignore here because this function
1142          * can only be invoked for multicast frames
1143          *
1144          * XXX: clean up
1145          */
1146         __ieee80211_tx_prepare(tx, skb, dev);
1147         dev_put(dev);
1148         return 0;
1149 }
1150
1151 static int __ieee80211_tx(struct ieee80211_local *local,
1152                           struct sk_buff **skbp,
1153                           struct sta_info *sta)
1154 {
1155         struct sk_buff *skb = *skbp, *next;
1156         struct ieee80211_tx_info *info;
1157         int ret, len;
1158         bool fragm = false;
1159
1160         local->mdev->trans_start = jiffies;
1161
1162         while (skb) {
1163                 if (ieee80211_queue_stopped(&local->hw,
1164                                             skb_get_queue_mapping(skb)))
1165                         return IEEE80211_TX_PENDING;
1166
1167                 info = IEEE80211_SKB_CB(skb);
1168
1169                 if (fragm)
1170                         info->flags &= ~(IEEE80211_TX_CTL_CLEAR_PS_FILT |
1171                                          IEEE80211_TX_CTL_FIRST_FRAGMENT);
1172
1173                 next = skb->next;
1174                 len = skb->len;
1175                 ret = drv_tx(local, skb);
1176                 if (WARN_ON(ret != NETDEV_TX_OK && skb->len != len)) {
1177                         dev_kfree_skb(skb);
1178                         ret = NETDEV_TX_OK;
1179                 }
1180                 if (ret != NETDEV_TX_OK)
1181                         return IEEE80211_TX_AGAIN;
1182                 *skbp = skb = next;
1183                 ieee80211_led_tx(local, 1);
1184                 fragm = true;
1185         }
1186
1187         return IEEE80211_TX_OK;
1188 }
1189
1190 /*
1191  * Invoke TX handlers, return 0 on success and non-zero if the
1192  * frame was dropped or queued.
1193  */
1194 static int invoke_tx_handlers(struct ieee80211_tx_data *tx)
1195 {
1196         struct sk_buff *skb = tx->skb;
1197         ieee80211_tx_result res = TX_DROP;
1198
1199 #define CALL_TXH(txh)           \
1200         res = txh(tx);          \
1201         if (res != TX_CONTINUE) \
1202                 goto txh_done;
1203
1204         CALL_TXH(ieee80211_tx_h_check_assoc)
1205         CALL_TXH(ieee80211_tx_h_ps_buf)
1206         CALL_TXH(ieee80211_tx_h_select_key)
1207         CALL_TXH(ieee80211_tx_h_michael_mic_add)
1208         CALL_TXH(ieee80211_tx_h_rate_ctrl)
1209         CALL_TXH(ieee80211_tx_h_misc)
1210         CALL_TXH(ieee80211_tx_h_sequence)
1211         CALL_TXH(ieee80211_tx_h_fragment)
1212         /* handlers after fragment must be aware of tx info fragmentation! */
1213         CALL_TXH(ieee80211_tx_h_encrypt)
1214         CALL_TXH(ieee80211_tx_h_calculate_duration)
1215         CALL_TXH(ieee80211_tx_h_stats)
1216 #undef CALL_TXH
1217
1218  txh_done:
1219         if (unlikely(res == TX_DROP)) {
1220                 I802_DEBUG_INC(tx->local->tx_handlers_drop);
1221                 while (skb) {
1222                         struct sk_buff *next;
1223
1224                         next = skb->next;
1225                         dev_kfree_skb(skb);
1226                         skb = next;
1227                 }
1228                 return -1;
1229         } else if (unlikely(res == TX_QUEUED)) {
1230                 I802_DEBUG_INC(tx->local->tx_handlers_queued);
1231                 return -1;
1232         }
1233
1234         return 0;
1235 }
1236
1237 static void ieee80211_tx(struct net_device *dev, struct sk_buff *skb,
1238                          bool txpending)
1239 {
1240         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1241         struct ieee80211_tx_data tx;
1242         ieee80211_tx_result res_prepare;
1243         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1244         struct sk_buff *next;
1245         unsigned long flags;
1246         int ret, retries;
1247         u16 queue;
1248
1249         queue = skb_get_queue_mapping(skb);
1250
1251         WARN_ON(!txpending && !skb_queue_empty(&local->pending[queue]));
1252
1253         if (unlikely(skb->len < 10)) {
1254                 dev_kfree_skb(skb);
1255                 return;
1256         }
1257
1258         rcu_read_lock();
1259
1260         /* initialises tx */
1261         res_prepare = __ieee80211_tx_prepare(&tx, skb, dev);
1262
1263         if (unlikely(res_prepare == TX_DROP)) {
1264                 dev_kfree_skb(skb);
1265                 rcu_read_unlock();
1266                 return;
1267         } else if (unlikely(res_prepare == TX_QUEUED)) {
1268                 rcu_read_unlock();
1269                 return;
1270         }
1271
1272         tx.channel = local->hw.conf.channel;
1273         info->band = tx.channel->band;
1274
1275         if (invoke_tx_handlers(&tx))
1276                 goto out;
1277
1278         retries = 0;
1279  retry:
1280         ret = __ieee80211_tx(local, &tx.skb, tx.sta);
1281         switch (ret) {
1282         case IEEE80211_TX_OK:
1283                 break;
1284         case IEEE80211_TX_AGAIN:
1285                 /*
1286                  * Since there are no fragmented frames on A-MPDU
1287                  * queues, there's no reason for a driver to reject
1288                  * a frame there, warn and drop it.
1289                  */
1290                 if (WARN_ON(info->flags & IEEE80211_TX_CTL_AMPDU))
1291                         goto drop;
1292                 /* fall through */
1293         case IEEE80211_TX_PENDING:
1294                 skb = tx.skb;
1295
1296                 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
1297
1298                 if (__netif_subqueue_stopped(local->mdev, queue)) {
1299                         do {
1300                                 next = skb->next;
1301                                 skb->next = NULL;
1302                                 if (unlikely(txpending))
1303                                         skb_queue_head(&local->pending[queue],
1304                                                        skb);
1305                                 else
1306                                         skb_queue_tail(&local->pending[queue],
1307                                                        skb);
1308                         } while ((skb = next));
1309
1310                         /*
1311                          * Make sure nobody will enable the queue on us
1312                          * (without going through the tasklet) nor disable the
1313                          * netdev queue underneath the pending handling code.
1314                          */
1315                         __set_bit(IEEE80211_QUEUE_STOP_REASON_PENDING,
1316                                   &local->queue_stop_reasons[queue]);
1317
1318                         spin_unlock_irqrestore(&local->queue_stop_reason_lock,
1319                                                flags);
1320                 } else {
1321                         spin_unlock_irqrestore(&local->queue_stop_reason_lock,
1322                                                flags);
1323
1324                         retries++;
1325                         if (WARN(retries > 10, "tx refused but queue active"))
1326                                 goto drop;
1327                         goto retry;
1328                 }
1329         }
1330  out:
1331         rcu_read_unlock();
1332         return;
1333
1334  drop:
1335         rcu_read_unlock();
1336
1337         skb = tx.skb;
1338         while (skb) {
1339                 next = skb->next;
1340                 dev_kfree_skb(skb);
1341                 skb = next;
1342         }
1343 }
1344
1345 /* device xmit handlers */
1346
1347 static int ieee80211_skb_resize(struct ieee80211_local *local,
1348                                 struct sk_buff *skb,
1349                                 int head_need, bool may_encrypt)
1350 {
1351         int tail_need = 0;
1352
1353         /*
1354          * This could be optimised, devices that do full hardware
1355          * crypto (including TKIP MMIC) need no tailroom... But we
1356          * have no drivers for such devices currently.
1357          */
1358         if (may_encrypt) {
1359                 tail_need = IEEE80211_ENCRYPT_TAILROOM;
1360                 tail_need -= skb_tailroom(skb);
1361                 tail_need = max_t(int, tail_need, 0);
1362         }
1363
1364         if (head_need || tail_need) {
1365                 /* Sorry. Can't account for this any more */
1366                 skb_orphan(skb);
1367         }
1368
1369         if (skb_header_cloned(skb))
1370                 I802_DEBUG_INC(local->tx_expand_skb_head_cloned);
1371         else
1372                 I802_DEBUG_INC(local->tx_expand_skb_head);
1373
1374         if (pskb_expand_head(skb, head_need, tail_need, GFP_ATOMIC)) {
1375                 printk(KERN_DEBUG "%s: failed to reallocate TX buffer\n",
1376                        wiphy_name(local->hw.wiphy));
1377                 return -ENOMEM;
1378         }
1379
1380         /* update truesize too */
1381         skb->truesize += head_need + tail_need;
1382
1383         return 0;
1384 }
1385
1386 int ieee80211_master_start_xmit(struct sk_buff *skb, struct net_device *dev)
1387 {
1388         struct ieee80211_master_priv *mpriv = netdev_priv(dev);
1389         struct ieee80211_local *local = mpriv->local;
1390         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1391         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1392         struct net_device *odev = NULL;
1393         struct ieee80211_sub_if_data *osdata;
1394         int headroom;
1395         bool may_encrypt;
1396         enum {
1397                 NOT_MONITOR,
1398                 FOUND_SDATA,
1399                 UNKNOWN_ADDRESS,
1400         } monitor_iface = NOT_MONITOR;
1401
1402         if (skb->iif)
1403                 odev = dev_get_by_index(&init_net, skb->iif);
1404         if (unlikely(odev && !is_ieee80211_device(local, odev))) {
1405                 dev_put(odev);
1406                 odev = NULL;
1407         }
1408         if (unlikely(!odev)) {
1409 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1410                 printk(KERN_DEBUG "%s: Discarded packet with nonexistent "
1411                        "originating device\n", dev->name);
1412 #endif
1413                 dev_kfree_skb(skb);
1414                 return NETDEV_TX_OK;
1415         }
1416
1417         if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
1418             local->hw.conf.dynamic_ps_timeout > 0 &&
1419             !local->sw_scanning && !local->hw_scanning && local->ps_sdata) {
1420                 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
1421                         ieee80211_stop_queues_by_reason(&local->hw,
1422                                         IEEE80211_QUEUE_STOP_REASON_PS);
1423                         queue_work(local->hw.workqueue,
1424                                         &local->dynamic_ps_disable_work);
1425                 }
1426
1427                 mod_timer(&local->dynamic_ps_timer, jiffies +
1428                         msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
1429         }
1430
1431         memset(info, 0, sizeof(*info));
1432
1433         info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS;
1434
1435         osdata = IEEE80211_DEV_TO_SUB_IF(odev);
1436
1437         if (ieee80211_vif_is_mesh(&osdata->vif) &&
1438             ieee80211_is_data(hdr->frame_control)) {
1439                 if (is_multicast_ether_addr(hdr->addr3))
1440                         memcpy(hdr->addr1, hdr->addr3, ETH_ALEN);
1441                 else
1442                         if (mesh_nexthop_lookup(skb, osdata)) {
1443                                 dev_put(odev);
1444                                 return NETDEV_TX_OK;
1445                         }
1446                 if (memcmp(odev->dev_addr, hdr->addr4, ETH_ALEN) != 0)
1447                         IEEE80211_IFSTA_MESH_CTR_INC(&osdata->u.mesh,
1448                                                             fwded_frames);
1449         } else if (unlikely(osdata->vif.type == NL80211_IFTYPE_MONITOR)) {
1450                 struct ieee80211_sub_if_data *sdata;
1451                 int hdrlen;
1452                 u16 len_rthdr;
1453
1454                 info->flags |= IEEE80211_TX_CTL_INJECTED;
1455                 monitor_iface = UNKNOWN_ADDRESS;
1456
1457                 len_rthdr = ieee80211_get_radiotap_len(skb->data);
1458                 hdr = (struct ieee80211_hdr *)(skb->data + len_rthdr);
1459                 hdrlen = ieee80211_hdrlen(hdr->frame_control);
1460
1461                 /* check the header is complete in the frame */
1462                 if (likely(skb->len >= len_rthdr + hdrlen)) {
1463                         /*
1464                          * We process outgoing injected frames that have a
1465                          * local address we handle as though they are our
1466                          * own frames.
1467                          * This code here isn't entirely correct, the local
1468                          * MAC address is not necessarily enough to find
1469                          * the interface to use; for that proper VLAN/WDS
1470                          * support we will need a different mechanism.
1471                          */
1472
1473                         rcu_read_lock();
1474                         list_for_each_entry_rcu(sdata, &local->interfaces,
1475                                                 list) {
1476                                 if (!netif_running(sdata->dev))
1477                                         continue;
1478                                 if (sdata->vif.type != NL80211_IFTYPE_AP)
1479                                         continue;
1480                                 if (compare_ether_addr(sdata->dev->dev_addr,
1481                                                        hdr->addr2)) {
1482                                         dev_hold(sdata->dev);
1483                                         dev_put(odev);
1484                                         osdata = sdata;
1485                                         odev = osdata->dev;
1486                                         skb->iif = sdata->dev->ifindex;
1487                                         monitor_iface = FOUND_SDATA;
1488                                         break;
1489                                 }
1490                         }
1491                         rcu_read_unlock();
1492                 }
1493         }
1494
1495         may_encrypt = !skb->do_not_encrypt;
1496
1497         headroom = osdata->local->tx_headroom;
1498         if (may_encrypt)
1499                 headroom += IEEE80211_ENCRYPT_HEADROOM;
1500         headroom -= skb_headroom(skb);
1501         headroom = max_t(int, 0, headroom);
1502
1503         if (ieee80211_skb_resize(osdata->local, skb, headroom, may_encrypt)) {
1504                 dev_kfree_skb(skb);
1505                 dev_put(odev);
1506                 return NETDEV_TX_OK;
1507         }
1508
1509         if (osdata->vif.type == NL80211_IFTYPE_AP_VLAN)
1510                 osdata = container_of(osdata->bss,
1511                                       struct ieee80211_sub_if_data,
1512                                       u.ap);
1513         if (likely(monitor_iface != UNKNOWN_ADDRESS))
1514                 info->control.vif = &osdata->vif;
1515
1516         ieee80211_tx(odev, skb, false);
1517         dev_put(odev);
1518
1519         return NETDEV_TX_OK;
1520 }
1521
1522 int ieee80211_monitor_start_xmit(struct sk_buff *skb,
1523                                  struct net_device *dev)
1524 {
1525         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1526         struct ieee80211_channel *chan = local->hw.conf.channel;
1527         struct ieee80211_radiotap_header *prthdr =
1528                 (struct ieee80211_radiotap_header *)skb->data;
1529         u16 len_rthdr;
1530
1531         /*
1532          * Frame injection is not allowed if beaconing is not allowed
1533          * or if we need radar detection. Beaconing is usually not allowed when
1534          * the mode or operation (Adhoc, AP, Mesh) does not support DFS.
1535          * Passive scan is also used in world regulatory domains where
1536          * your country is not known and as such it should be treated as
1537          * NO TX unless the channel is explicitly allowed in which case
1538          * your current regulatory domain would not have the passive scan
1539          * flag.
1540          *
1541          * Since AP mode uses monitor interfaces to inject/TX management
1542          * frames we can make AP mode the exception to this rule once it
1543          * supports radar detection as its implementation can deal with
1544          * radar detection by itself. We can do that later by adding a
1545          * monitor flag interfaces used for AP support.
1546          */
1547         if ((chan->flags & (IEEE80211_CHAN_NO_IBSS | IEEE80211_CHAN_RADAR |
1548              IEEE80211_CHAN_PASSIVE_SCAN)))
1549                 goto fail;
1550
1551         /* check for not even having the fixed radiotap header part */
1552         if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
1553                 goto fail; /* too short to be possibly valid */
1554
1555         /* is it a header version we can trust to find length from? */
1556         if (unlikely(prthdr->it_version))
1557                 goto fail; /* only version 0 is supported */
1558
1559         /* then there must be a radiotap header with a length we can use */
1560         len_rthdr = ieee80211_get_radiotap_len(skb->data);
1561
1562         /* does the skb contain enough to deliver on the alleged length? */
1563         if (unlikely(skb->len < len_rthdr))
1564                 goto fail; /* skb too short for claimed rt header extent */
1565
1566         skb->dev = local->mdev;
1567
1568         /* needed because we set skb device to master */
1569         skb->iif = dev->ifindex;
1570
1571         /* sometimes we do encrypt injected frames, will be fixed
1572          * up in radiotap parser if not wanted */
1573         skb->do_not_encrypt = 0;
1574
1575         /*
1576          * fix up the pointers accounting for the radiotap
1577          * header still being in there.  We are being given
1578          * a precooked IEEE80211 header so no need for
1579          * normal processing
1580          */
1581         skb_set_mac_header(skb, len_rthdr);
1582         /*
1583          * these are just fixed to the end of the rt area since we
1584          * don't have any better information and at this point, nobody cares
1585          */
1586         skb_set_network_header(skb, len_rthdr);
1587         skb_set_transport_header(skb, len_rthdr);
1588
1589         /* pass the radiotap header up to the next stage intact */
1590         dev_queue_xmit(skb);
1591         return NETDEV_TX_OK;
1592
1593 fail:
1594         dev_kfree_skb(skb);
1595         return NETDEV_TX_OK; /* meaning, we dealt with the skb */
1596 }
1597
1598 /**
1599  * ieee80211_subif_start_xmit - netif start_xmit function for Ethernet-type
1600  * subinterfaces (wlan#, WDS, and VLAN interfaces)
1601  * @skb: packet to be sent
1602  * @dev: incoming interface
1603  *
1604  * Returns: 0 on success (and frees skb in this case) or 1 on failure (skb will
1605  * not be freed, and caller is responsible for either retrying later or freeing
1606  * skb).
1607  *
1608  * This function takes in an Ethernet header and encapsulates it with suitable
1609  * IEEE 802.11 header based on which interface the packet is coming in. The
1610  * encapsulated packet will then be passed to master interface, wlan#.11, for
1611  * transmission (through low-level driver).
1612  */
1613 int ieee80211_subif_start_xmit(struct sk_buff *skb,
1614                                struct net_device *dev)
1615 {
1616         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1617         struct ieee80211_local *local = sdata->local;
1618         int ret = NETDEV_TX_BUSY, head_need;
1619         u16 ethertype, hdrlen,  meshhdrlen = 0;
1620         __le16 fc;
1621         struct ieee80211_hdr hdr;
1622         struct ieee80211s_hdr mesh_hdr;
1623         const u8 *encaps_data;
1624         int encaps_len, skip_header_bytes;
1625         int nh_pos, h_pos;
1626         struct sta_info *sta;
1627         u32 sta_flags = 0;
1628
1629         if (unlikely(skb->len < ETH_HLEN)) {
1630                 ret = NETDEV_TX_OK;
1631                 goto fail;
1632         }
1633
1634         nh_pos = skb_network_header(skb) - skb->data;
1635         h_pos = skb_transport_header(skb) - skb->data;
1636
1637         /* convert Ethernet header to proper 802.11 header (based on
1638          * operation mode) */
1639         ethertype = (skb->data[12] << 8) | skb->data[13];
1640         fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
1641
1642         switch (sdata->vif.type) {
1643         case NL80211_IFTYPE_AP:
1644         case NL80211_IFTYPE_AP_VLAN:
1645                 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
1646                 /* DA BSSID SA */
1647                 memcpy(hdr.addr1, skb->data, ETH_ALEN);
1648                 memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
1649                 memcpy(hdr.addr3, skb->data + ETH_ALEN, ETH_ALEN);
1650                 hdrlen = 24;
1651                 break;
1652         case NL80211_IFTYPE_WDS:
1653                 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
1654                 /* RA TA DA SA */
1655                 memcpy(hdr.addr1, sdata->u.wds.remote_addr, ETH_ALEN);
1656                 memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
1657                 memcpy(hdr.addr3, skb->data, ETH_ALEN);
1658                 memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
1659                 hdrlen = 30;
1660                 break;
1661 #ifdef CONFIG_MAC80211_MESH
1662         case NL80211_IFTYPE_MESH_POINT:
1663                 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
1664                 if (!sdata->u.mesh.mshcfg.dot11MeshTTL) {
1665                         /* Do not send frames with mesh_ttl == 0 */
1666                         sdata->u.mesh.mshstats.dropped_frames_ttl++;
1667                         ret = NETDEV_TX_OK;
1668                         goto fail;
1669                 }
1670                 memset(&mesh_hdr, 0, sizeof(mesh_hdr));
1671
1672                 if (compare_ether_addr(dev->dev_addr,
1673                                           skb->data + ETH_ALEN) == 0) {
1674                         /* RA TA DA SA */
1675                         memset(hdr.addr1, 0, ETH_ALEN);
1676                         memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
1677                         memcpy(hdr.addr3, skb->data, ETH_ALEN);
1678                         memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
1679                         meshhdrlen = ieee80211_new_mesh_header(&mesh_hdr, sdata);
1680                 } else {
1681                         /* packet from other interface */
1682                         struct mesh_path *mppath;
1683
1684                         memset(hdr.addr1, 0, ETH_ALEN);
1685                         memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
1686                         memcpy(hdr.addr4, dev->dev_addr, ETH_ALEN);
1687
1688                         if (is_multicast_ether_addr(skb->data))
1689                                 memcpy(hdr.addr3, skb->data, ETH_ALEN);
1690                         else {
1691                                 rcu_read_lock();
1692                                 mppath = mpp_path_lookup(skb->data, sdata);
1693                                 if (mppath)
1694                                         memcpy(hdr.addr3, mppath->mpp, ETH_ALEN);
1695                                 else
1696                                         memset(hdr.addr3, 0xff, ETH_ALEN);
1697                                 rcu_read_unlock();
1698                         }
1699
1700                         mesh_hdr.flags |= MESH_FLAGS_AE_A5_A6;
1701                         mesh_hdr.ttl = sdata->u.mesh.mshcfg.dot11MeshTTL;
1702                         put_unaligned(cpu_to_le32(sdata->u.mesh.mesh_seqnum), &mesh_hdr.seqnum);
1703                         memcpy(mesh_hdr.eaddr1, skb->data, ETH_ALEN);
1704                         memcpy(mesh_hdr.eaddr2, skb->data + ETH_ALEN, ETH_ALEN);
1705                         sdata->u.mesh.mesh_seqnum++;
1706                         meshhdrlen = 18;
1707                 }
1708                 hdrlen = 30;
1709                 break;
1710 #endif
1711         case NL80211_IFTYPE_STATION:
1712                 fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
1713                 /* BSSID SA DA */
1714                 memcpy(hdr.addr1, sdata->u.mgd.bssid, ETH_ALEN);
1715                 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
1716                 memcpy(hdr.addr3, skb->data, ETH_ALEN);
1717                 hdrlen = 24;
1718                 break;
1719         case NL80211_IFTYPE_ADHOC:
1720                 /* DA SA BSSID */
1721                 memcpy(hdr.addr1, skb->data, ETH_ALEN);
1722                 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
1723                 memcpy(hdr.addr3, sdata->u.ibss.bssid, ETH_ALEN);
1724                 hdrlen = 24;
1725                 break;
1726         default:
1727                 ret = NETDEV_TX_OK;
1728                 goto fail;
1729         }
1730
1731         /*
1732          * There's no need to try to look up the destination
1733          * if it is a multicast address (which can only happen
1734          * in AP mode)
1735          */
1736         if (!is_multicast_ether_addr(hdr.addr1)) {
1737                 rcu_read_lock();
1738                 sta = sta_info_get(local, hdr.addr1);
1739                 if (sta)
1740                         sta_flags = get_sta_flags(sta);
1741                 rcu_read_unlock();
1742         }
1743
1744         /* receiver and we are QoS enabled, use a QoS type frame */
1745         if ((sta_flags & WLAN_STA_WME) && local->hw.queues >= 4) {
1746                 fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
1747                 hdrlen += 2;
1748         }
1749
1750         /*
1751          * Drop unicast frames to unauthorised stations unless they are
1752          * EAPOL frames from the local station.
1753          */
1754         if (!ieee80211_vif_is_mesh(&sdata->vif) &&
1755                 unlikely(!is_multicast_ether_addr(hdr.addr1) &&
1756                       !(sta_flags & WLAN_STA_AUTHORIZED) &&
1757                       !(ethertype == ETH_P_PAE &&
1758                        compare_ether_addr(dev->dev_addr,
1759                                           skb->data + ETH_ALEN) == 0))) {
1760 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1761                 if (net_ratelimit())
1762                         printk(KERN_DEBUG "%s: dropped frame to %pM"
1763                                " (unauthorized port)\n", dev->name,
1764                                hdr.addr1);
1765 #endif
1766
1767                 I802_DEBUG_INC(local->tx_handlers_drop_unauth_port);
1768
1769                 ret = NETDEV_TX_OK;
1770                 goto fail;
1771         }
1772
1773         hdr.frame_control = fc;
1774         hdr.duration_id = 0;
1775         hdr.seq_ctrl = 0;
1776
1777         skip_header_bytes = ETH_HLEN;
1778         if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) {
1779                 encaps_data = bridge_tunnel_header;
1780                 encaps_len = sizeof(bridge_tunnel_header);
1781                 skip_header_bytes -= 2;
1782         } else if (ethertype >= 0x600) {
1783                 encaps_data = rfc1042_header;
1784                 encaps_len = sizeof(rfc1042_header);
1785                 skip_header_bytes -= 2;
1786         } else {
1787                 encaps_data = NULL;
1788                 encaps_len = 0;
1789         }
1790
1791         skb_pull(skb, skip_header_bytes);
1792         nh_pos -= skip_header_bytes;
1793         h_pos -= skip_header_bytes;
1794
1795         head_need = hdrlen + encaps_len + meshhdrlen - skb_headroom(skb);
1796
1797         /*
1798          * So we need to modify the skb header and hence need a copy of
1799          * that. The head_need variable above doesn't, so far, include
1800          * the needed header space that we don't need right away. If we
1801          * can, then we don't reallocate right now but only after the
1802          * frame arrives at the master device (if it does...)
1803          *
1804          * If we cannot, however, then we will reallocate to include all
1805          * the ever needed space. Also, if we need to reallocate it anyway,
1806          * make it big enough for everything we may ever need.
1807          */
1808
1809         if (head_need > 0 || skb_cloned(skb)) {
1810                 head_need += IEEE80211_ENCRYPT_HEADROOM;
1811                 head_need += local->tx_headroom;
1812                 head_need = max_t(int, 0, head_need);
1813                 if (ieee80211_skb_resize(local, skb, head_need, true))
1814                         goto fail;
1815         }
1816
1817         if (encaps_data) {
1818                 memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len);
1819                 nh_pos += encaps_len;
1820                 h_pos += encaps_len;
1821         }
1822
1823         if (meshhdrlen > 0) {
1824                 memcpy(skb_push(skb, meshhdrlen), &mesh_hdr, meshhdrlen);
1825                 nh_pos += meshhdrlen;
1826                 h_pos += meshhdrlen;
1827         }
1828
1829         if (ieee80211_is_data_qos(fc)) {
1830                 __le16 *qos_control;
1831
1832                 qos_control = (__le16*) skb_push(skb, 2);
1833                 memcpy(skb_push(skb, hdrlen - 2), &hdr, hdrlen - 2);
1834                 /*
1835                  * Maybe we could actually set some fields here, for now just
1836                  * initialise to zero to indicate no special operation.
1837                  */
1838                 *qos_control = 0;
1839         } else
1840                 memcpy(skb_push(skb, hdrlen), &hdr, hdrlen);
1841
1842         nh_pos += hdrlen;
1843         h_pos += hdrlen;
1844
1845         skb->iif = dev->ifindex;
1846
1847         skb->dev = local->mdev;
1848         dev->stats.tx_packets++;
1849         dev->stats.tx_bytes += skb->len;
1850
1851         /* Update skb pointers to various headers since this modified frame
1852          * is going to go through Linux networking code that may potentially
1853          * need things like pointer to IP header. */
1854         skb_set_mac_header(skb, 0);
1855         skb_set_network_header(skb, nh_pos);
1856         skb_set_transport_header(skb, h_pos);
1857
1858         dev->trans_start = jiffies;
1859         dev_queue_xmit(skb);
1860
1861         return NETDEV_TX_OK;
1862
1863  fail:
1864         if (ret == NETDEV_TX_OK)
1865                 dev_kfree_skb(skb);
1866
1867         return ret;
1868 }
1869
1870
1871 /*
1872  * ieee80211_clear_tx_pending may not be called in a context where
1873  * it is possible that it packets could come in again.
1874  */
1875 void ieee80211_clear_tx_pending(struct ieee80211_local *local)
1876 {
1877         int i;
1878
1879         for (i = 0; i < local->hw.queues; i++)
1880                 skb_queue_purge(&local->pending[i]);
1881 }
1882
1883 static bool ieee80211_tx_pending_skb(struct ieee80211_local *local,
1884                                      struct sk_buff *skb)
1885 {
1886         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1887         struct ieee80211_sub_if_data *sdata;
1888         struct sta_info *sta;
1889         struct ieee80211_hdr *hdr;
1890         struct net_device *dev;
1891         int ret;
1892         bool result = true;
1893
1894         /* does interface still exist? */
1895         dev = dev_get_by_index(&init_net, skb->iif);
1896         if (!dev) {
1897                 dev_kfree_skb(skb);
1898                 return true;
1899         }
1900
1901         /* validate info->control.vif against skb->iif */
1902         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1903         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
1904                 sdata = container_of(sdata->bss,
1905                                      struct ieee80211_sub_if_data,
1906                                      u.ap);
1907
1908         if (unlikely(info->control.vif && info->control.vif != &sdata->vif)) {
1909                 dev_kfree_skb(skb);
1910                 result = true;
1911                 goto out;
1912         }
1913
1914         if (info->flags & IEEE80211_TX_INTFL_NEED_TXPROCESSING) {
1915                 ieee80211_tx(dev, skb, true);
1916         } else {
1917                 hdr = (struct ieee80211_hdr *)skb->data;
1918                 sta = sta_info_get(local, hdr->addr1);
1919
1920                 ret = __ieee80211_tx(local, &skb, sta);
1921                 if (ret != IEEE80211_TX_OK)
1922                         result = false;
1923         }
1924
1925  out:
1926         dev_put(dev);
1927
1928         return result;
1929 }
1930
1931 /*
1932  * Transmit all pending packets. Called from tasklet, locks master device
1933  * TX lock so that no new packets can come in.
1934  */
1935 void ieee80211_tx_pending(unsigned long data)
1936 {
1937         struct ieee80211_local *local = (struct ieee80211_local *)data;
1938         struct net_device *dev = local->mdev;
1939         unsigned long flags;
1940         int i;
1941         bool next;
1942
1943         rcu_read_lock();
1944         netif_tx_lock_bh(dev);
1945
1946         for (i = 0; i < local->hw.queues; i++) {
1947                 /*
1948                  * If queue is stopped by something other than due to pending
1949                  * frames, or we have no pending frames, proceed to next queue.
1950                  */
1951                 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
1952                 next = false;
1953                 if (local->queue_stop_reasons[i] !=
1954                         BIT(IEEE80211_QUEUE_STOP_REASON_PENDING) ||
1955                     skb_queue_empty(&local->pending[i]))
1956                         next = true;
1957                 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
1958
1959                 if (next)
1960                         continue;
1961
1962                 /*
1963                  * start the queue now to allow processing our packets,
1964                  * we're under the tx lock here anyway so nothing will
1965                  * happen as a result of this
1966                  */
1967                 netif_start_subqueue(local->mdev, i);
1968
1969                 while (!skb_queue_empty(&local->pending[i])) {
1970                         struct sk_buff *skb = skb_dequeue(&local->pending[i]);
1971
1972                         if (!ieee80211_tx_pending_skb(local, skb)) {
1973                                 skb_queue_head(&local->pending[i], skb);
1974                                 break;
1975                         }
1976                 }
1977
1978                 /* Start regular packet processing again. */
1979                 if (skb_queue_empty(&local->pending[i]))
1980                         ieee80211_wake_queue_by_reason(&local->hw, i,
1981                                         IEEE80211_QUEUE_STOP_REASON_PENDING);
1982         }
1983
1984         netif_tx_unlock_bh(dev);
1985         rcu_read_unlock();
1986 }
1987
1988 /* functions for drivers to get certain frames */
1989
1990 static void ieee80211_beacon_add_tim(struct ieee80211_if_ap *bss,
1991                                      struct sk_buff *skb,
1992                                      struct beacon_data *beacon)
1993 {
1994         u8 *pos, *tim;
1995         int aid0 = 0;
1996         int i, have_bits = 0, n1, n2;
1997
1998         /* Generate bitmap for TIM only if there are any STAs in power save
1999          * mode. */
2000         if (atomic_read(&bss->num_sta_ps) > 0)
2001                 /* in the hope that this is faster than
2002                  * checking byte-for-byte */
2003                 have_bits = !bitmap_empty((unsigned long*)bss->tim,
2004                                           IEEE80211_MAX_AID+1);
2005
2006         if (bss->dtim_count == 0)
2007                 bss->dtim_count = beacon->dtim_period - 1;
2008         else
2009                 bss->dtim_count--;
2010
2011         tim = pos = (u8 *) skb_put(skb, 6);
2012         *pos++ = WLAN_EID_TIM;
2013         *pos++ = 4;
2014         *pos++ = bss->dtim_count;
2015         *pos++ = beacon->dtim_period;
2016
2017         if (bss->dtim_count == 0 && !skb_queue_empty(&bss->ps_bc_buf))
2018                 aid0 = 1;
2019
2020         if (have_bits) {
2021                 /* Find largest even number N1 so that bits numbered 1 through
2022                  * (N1 x 8) - 1 in the bitmap are 0 and number N2 so that bits
2023                  * (N2 + 1) x 8 through 2007 are 0. */
2024                 n1 = 0;
2025                 for (i = 0; i < IEEE80211_MAX_TIM_LEN; i++) {
2026                         if (bss->tim[i]) {
2027                                 n1 = i & 0xfe;
2028                                 break;
2029                         }
2030                 }
2031                 n2 = n1;
2032                 for (i = IEEE80211_MAX_TIM_LEN - 1; i >= n1; i--) {
2033                         if (bss->tim[i]) {
2034                                 n2 = i;
2035                                 break;
2036                         }
2037                 }
2038
2039                 /* Bitmap control */
2040                 *pos++ = n1 | aid0;
2041                 /* Part Virt Bitmap */
2042                 memcpy(pos, bss->tim + n1, n2 - n1 + 1);
2043
2044                 tim[1] = n2 - n1 + 4;
2045                 skb_put(skb, n2 - n1);
2046         } else {
2047                 *pos++ = aid0; /* Bitmap control */
2048                 *pos++ = 0; /* Part Virt Bitmap */
2049         }
2050 }
2051
2052 struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
2053                                      struct ieee80211_vif *vif)
2054 {
2055         struct ieee80211_local *local = hw_to_local(hw);
2056         struct sk_buff *skb = NULL;
2057         struct ieee80211_tx_info *info;
2058         struct ieee80211_sub_if_data *sdata = NULL;
2059         struct ieee80211_if_ap *ap = NULL;
2060         struct beacon_data *beacon;
2061         struct ieee80211_supported_band *sband;
2062         enum ieee80211_band band = local->hw.conf.channel->band;
2063
2064         sband = local->hw.wiphy->bands[band];
2065
2066         rcu_read_lock();
2067
2068         sdata = vif_to_sdata(vif);
2069
2070         if (sdata->vif.type == NL80211_IFTYPE_AP) {
2071                 ap = &sdata->u.ap;
2072                 beacon = rcu_dereference(ap->beacon);
2073                 if (ap && beacon) {
2074                         /*
2075                          * headroom, head length,
2076                          * tail length and maximum TIM length
2077                          */
2078                         skb = dev_alloc_skb(local->tx_headroom +
2079                                             beacon->head_len +
2080                                             beacon->tail_len + 256);
2081                         if (!skb)
2082                                 goto out;
2083
2084                         skb_reserve(skb, local->tx_headroom);
2085                         memcpy(skb_put(skb, beacon->head_len), beacon->head,
2086                                beacon->head_len);
2087
2088                         /*
2089                          * Not very nice, but we want to allow the driver to call
2090                          * ieee80211_beacon_get() as a response to the set_tim()
2091                          * callback. That, however, is already invoked under the
2092                          * sta_lock to guarantee consistent and race-free update
2093                          * of the tim bitmap in mac80211 and the driver.
2094                          */
2095                         if (local->tim_in_locked_section) {
2096                                 ieee80211_beacon_add_tim(ap, skb, beacon);
2097                         } else {
2098                                 unsigned long flags;
2099
2100                                 spin_lock_irqsave(&local->sta_lock, flags);
2101                                 ieee80211_beacon_add_tim(ap, skb, beacon);
2102                                 spin_unlock_irqrestore(&local->sta_lock, flags);
2103                         }
2104
2105                         if (beacon->tail)
2106                                 memcpy(skb_put(skb, beacon->tail_len),
2107                                        beacon->tail, beacon->tail_len);
2108                 } else
2109                         goto out;
2110         } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
2111                 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
2112                 struct ieee80211_hdr *hdr;
2113                 struct sk_buff *presp = rcu_dereference(ifibss->presp);
2114
2115                 if (!presp)
2116                         goto out;
2117
2118                 skb = skb_copy(presp, GFP_ATOMIC);
2119                 if (!skb)
2120                         goto out;
2121
2122                 hdr = (struct ieee80211_hdr *) skb->data;
2123                 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2124                                                  IEEE80211_STYPE_BEACON);
2125         } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
2126                 struct ieee80211_mgmt *mgmt;
2127                 u8 *pos;
2128
2129                 /* headroom, head length, tail length and maximum TIM length */
2130                 skb = dev_alloc_skb(local->tx_headroom + 400);
2131                 if (!skb)
2132                         goto out;
2133
2134                 skb_reserve(skb, local->hw.extra_tx_headroom);
2135                 mgmt = (struct ieee80211_mgmt *)
2136                         skb_put(skb, 24 + sizeof(mgmt->u.beacon));
2137                 memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon));
2138                 mgmt->frame_control =
2139                     cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_BEACON);
2140                 memset(mgmt->da, 0xff, ETH_ALEN);
2141                 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
2142                 /* BSSID is left zeroed, wildcard value */
2143                 mgmt->u.beacon.beacon_int =
2144                         cpu_to_le16(sdata->vif.bss_conf.beacon_int);
2145                 mgmt->u.beacon.capab_info = 0x0; /* 0x0 for MPs */
2146
2147                 pos = skb_put(skb, 2);
2148                 *pos++ = WLAN_EID_SSID;
2149                 *pos++ = 0x0;
2150
2151                 mesh_mgmt_ies_add(skb, sdata);
2152         } else {
2153                 WARN_ON(1);
2154                 goto out;
2155         }
2156
2157         info = IEEE80211_SKB_CB(skb);
2158
2159         skb->do_not_encrypt = 1;
2160
2161         info->band = band;
2162         /*
2163          * XXX: For now, always use the lowest rate
2164          */
2165         info->control.rates[0].idx = 0;
2166         info->control.rates[0].count = 1;
2167         info->control.rates[1].idx = -1;
2168         info->control.rates[2].idx = -1;
2169         info->control.rates[3].idx = -1;
2170         info->control.rates[4].idx = -1;
2171         BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 5);
2172
2173         info->control.vif = vif;
2174
2175         info->flags |= IEEE80211_TX_CTL_NO_ACK;
2176         info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
2177         info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
2178  out:
2179         rcu_read_unlock();
2180         return skb;
2181 }
2182 EXPORT_SYMBOL(ieee80211_beacon_get);
2183
2184 void ieee80211_rts_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2185                        const void *frame, size_t frame_len,
2186                        const struct ieee80211_tx_info *frame_txctl,
2187                        struct ieee80211_rts *rts)
2188 {
2189         const struct ieee80211_hdr *hdr = frame;
2190
2191         rts->frame_control =
2192             cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
2193         rts->duration = ieee80211_rts_duration(hw, vif, frame_len,
2194                                                frame_txctl);
2195         memcpy(rts->ra, hdr->addr1, sizeof(rts->ra));
2196         memcpy(rts->ta, hdr->addr2, sizeof(rts->ta));
2197 }
2198 EXPORT_SYMBOL(ieee80211_rts_get);
2199
2200 void ieee80211_ctstoself_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2201                              const void *frame, size_t frame_len,
2202                              const struct ieee80211_tx_info *frame_txctl,
2203                              struct ieee80211_cts *cts)
2204 {
2205         const struct ieee80211_hdr *hdr = frame;
2206
2207         cts->frame_control =
2208             cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS);
2209         cts->duration = ieee80211_ctstoself_duration(hw, vif,
2210                                                      frame_len, frame_txctl);
2211         memcpy(cts->ra, hdr->addr1, sizeof(cts->ra));
2212 }
2213 EXPORT_SYMBOL(ieee80211_ctstoself_get);
2214
2215 struct sk_buff *
2216 ieee80211_get_buffered_bc(struct ieee80211_hw *hw,
2217                           struct ieee80211_vif *vif)
2218 {
2219         struct ieee80211_local *local = hw_to_local(hw);
2220         struct sk_buff *skb = NULL;
2221         struct sta_info *sta;
2222         struct ieee80211_tx_data tx;
2223         struct ieee80211_sub_if_data *sdata;
2224         struct ieee80211_if_ap *bss = NULL;
2225         struct beacon_data *beacon;
2226         struct ieee80211_tx_info *info;
2227
2228         sdata = vif_to_sdata(vif);
2229         bss = &sdata->u.ap;
2230
2231         if (!bss)
2232                 return NULL;
2233
2234         rcu_read_lock();
2235         beacon = rcu_dereference(bss->beacon);
2236
2237         if (sdata->vif.type != NL80211_IFTYPE_AP || !beacon || !beacon->head)
2238                 goto out;
2239
2240         if (bss->dtim_count != 0)
2241                 goto out; /* send buffered bc/mc only after DTIM beacon */
2242
2243         while (1) {
2244                 skb = skb_dequeue(&bss->ps_bc_buf);
2245                 if (!skb)
2246                         goto out;
2247                 local->total_ps_buffered--;
2248
2249                 if (!skb_queue_empty(&bss->ps_bc_buf) && skb->len >= 2) {
2250                         struct ieee80211_hdr *hdr =
2251                                 (struct ieee80211_hdr *) skb->data;
2252                         /* more buffered multicast/broadcast frames ==> set
2253                          * MoreData flag in IEEE 802.11 header to inform PS
2254                          * STAs */
2255                         hdr->frame_control |=
2256                                 cpu_to_le16(IEEE80211_FCTL_MOREDATA);
2257                 }
2258
2259                 if (!ieee80211_tx_prepare(local, &tx, skb))
2260                         break;
2261                 dev_kfree_skb_any(skb);
2262         }
2263
2264         info = IEEE80211_SKB_CB(skb);
2265
2266         sta = tx.sta;
2267         tx.flags |= IEEE80211_TX_PS_BUFFERED;
2268         tx.channel = local->hw.conf.channel;
2269         info->band = tx.channel->band;
2270
2271         if (invoke_tx_handlers(&tx))
2272                 skb = NULL;
2273  out:
2274         rcu_read_unlock();
2275
2276         return skb;
2277 }
2278 EXPORT_SYMBOL(ieee80211_get_buffered_bc);