2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include <net/mac80211.h>
12 #include <net/ieee80211_radiotap.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/netdevice.h>
16 #include <linux/types.h>
17 #include <linux/slab.h>
18 #include <linux/skbuff.h>
19 #include <linux/etherdevice.h>
20 #include <linux/if_arp.h>
21 #include <linux/wireless.h>
22 #include <linux/rtnetlink.h>
23 #include <net/iw_handler.h>
24 #include <linux/compiler.h>
25 #include <linux/bitmap.h>
26 #include <net/cfg80211.h>
27 #include <asm/unaligned.h>
29 #include "ieee80211_common.h"
30 #include "ieee80211_i.h"
31 #include "ieee80211_rate.h"
37 #include "ieee80211_led.h"
38 #include "ieee80211_cfg.h"
40 #include "debugfs_netdev.h"
41 #include "debugfs_key.h"
43 /* privid for wiphys to determine whether they belong to us or not */
44 void *mac80211_wiphy_privid
= &mac80211_wiphy_privid
;
46 /* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */
47 /* Ethernet-II snap header (RFC1042 for most EtherTypes) */
48 const unsigned char rfc1042_header
[] =
49 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
51 /* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
52 const unsigned char bridge_tunnel_header
[] =
53 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
55 /* No encapsulation header if EtherType < 0x600 (=length) */
56 static const unsigned char eapol_header
[] =
57 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x88, 0x8e };
61 * For seeing transmitted packets on monitor interfaces
62 * we have a radiotap header too.
64 struct ieee80211_tx_status_rtap_hdr
{
65 struct ieee80211_radiotap_header hdr
;
68 } __attribute__ ((packed
));
71 static inline void ieee80211_include_sequence(struct ieee80211_sub_if_data
*sdata
,
72 struct ieee80211_hdr
*hdr
)
74 /* Set the sequence number for this frame. */
75 hdr
->seq_ctrl
= cpu_to_le16(sdata
->sequence
);
77 /* Increase the sequence number. */
78 sdata
->sequence
= (sdata
->sequence
+ 0x10) & IEEE80211_SCTL_SEQ
;
81 struct ieee80211_key_conf
*
82 ieee80211_key_data2conf(struct ieee80211_local
*local
,
83 const struct ieee80211_key
*data
)
85 struct ieee80211_key_conf
*conf
;
87 conf
= kmalloc(sizeof(*conf
) + data
->keylen
, GFP_ATOMIC
);
91 conf
->hw_key_idx
= data
->hw_key_idx
;
92 conf
->alg
= data
->alg
;
93 conf
->keylen
= data
->keylen
;
95 if (data
->force_sw_encrypt
)
96 conf
->flags
|= IEEE80211_KEY_FORCE_SW_ENCRYPT
;
97 conf
->keyidx
= data
->keyidx
;
98 if (data
->default_tx_key
)
99 conf
->flags
|= IEEE80211_KEY_DEFAULT_TX_KEY
;
100 if (local
->default_wep_only
)
101 conf
->flags
|= IEEE80211_KEY_DEFAULT_WEP_ONLY
;
102 memcpy(conf
->key
, data
->key
, data
->keylen
);
107 struct ieee80211_key
*ieee80211_key_alloc(struct ieee80211_sub_if_data
*sdata
,
108 int idx
, size_t key_len
, gfp_t flags
)
110 struct ieee80211_key
*key
;
112 key
= kzalloc(sizeof(struct ieee80211_key
) + key_len
, flags
);
115 kref_init(&key
->kref
);
119 static void ieee80211_key_release(struct kref
*kref
)
121 struct ieee80211_key
*key
;
123 key
= container_of(kref
, struct ieee80211_key
, kref
);
124 if (key
->alg
== ALG_CCMP
)
125 ieee80211_aes_key_free(key
->u
.ccmp
.tfm
);
126 ieee80211_debugfs_key_remove(key
);
130 void ieee80211_key_free(struct ieee80211_key
*key
)
133 kref_put(&key
->kref
, ieee80211_key_release
);
136 static int rate_list_match(const int *rate_list
, int rate
)
143 for (i
= 0; rate_list
[i
] >= 0; i
++)
144 if (rate_list
[i
] == rate
)
151 void ieee80211_prepare_rates(struct ieee80211_local
*local
,
152 struct ieee80211_hw_mode
*mode
)
156 for (i
= 0; i
< mode
->num_rates
; i
++) {
157 struct ieee80211_rate
*rate
= &mode
->rates
[i
];
159 rate
->flags
&= ~(IEEE80211_RATE_SUPPORTED
|
160 IEEE80211_RATE_BASIC
);
162 if (local
->supp_rates
[mode
->mode
]) {
163 if (!rate_list_match(local
->supp_rates
[mode
->mode
],
168 rate
->flags
|= IEEE80211_RATE_SUPPORTED
;
170 /* Use configured basic rate set if it is available. If not,
171 * use defaults that are sane for most cases. */
172 if (local
->basic_rates
[mode
->mode
]) {
173 if (rate_list_match(local
->basic_rates
[mode
->mode
],
175 rate
->flags
|= IEEE80211_RATE_BASIC
;
176 } else switch (mode
->mode
) {
177 case MODE_IEEE80211A
:
178 if (rate
->rate
== 60 || rate
->rate
== 120 ||
180 rate
->flags
|= IEEE80211_RATE_BASIC
;
182 case MODE_IEEE80211B
:
183 if (rate
->rate
== 10 || rate
->rate
== 20)
184 rate
->flags
|= IEEE80211_RATE_BASIC
;
186 case MODE_ATHEROS_TURBO
:
187 if (rate
->rate
== 120 || rate
->rate
== 240 ||
189 rate
->flags
|= IEEE80211_RATE_BASIC
;
191 case MODE_IEEE80211G
:
192 if (rate
->rate
== 10 || rate
->rate
== 20 ||
193 rate
->rate
== 55 || rate
->rate
== 110)
194 rate
->flags
|= IEEE80211_RATE_BASIC
;
198 /* Set ERP and MANDATORY flags based on phymode */
199 switch (mode
->mode
) {
200 case MODE_IEEE80211A
:
201 if (rate
->rate
== 60 || rate
->rate
== 120 ||
203 rate
->flags
|= IEEE80211_RATE_MANDATORY
;
205 case MODE_IEEE80211B
:
206 if (rate
->rate
== 10)
207 rate
->flags
|= IEEE80211_RATE_MANDATORY
;
209 case MODE_ATHEROS_TURBO
:
211 case MODE_IEEE80211G
:
212 if (rate
->rate
== 10 || rate
->rate
== 20 ||
213 rate
->rate
== 55 || rate
->rate
== 110 ||
214 rate
->rate
== 60 || rate
->rate
== 120 ||
216 rate
->flags
|= IEEE80211_RATE_MANDATORY
;
219 if (ieee80211_is_erp_rate(mode
->mode
, rate
->rate
))
220 rate
->flags
|= IEEE80211_RATE_ERP
;
225 void ieee80211_key_threshold_notify(struct net_device
*dev
,
226 struct ieee80211_key
*key
,
227 struct sta_info
*sta
)
229 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
231 struct ieee80211_msg_key_notification
*msg
;
233 /* if no one will get it anyway, don't even allocate it.
234 * unlikely because this is only relevant for APs
235 * where the device must be open... */
236 if (unlikely(!local
->apdev
))
239 skb
= dev_alloc_skb(sizeof(struct ieee80211_frame_info
) +
240 sizeof(struct ieee80211_msg_key_notification
));
244 skb_reserve(skb
, sizeof(struct ieee80211_frame_info
));
245 msg
= (struct ieee80211_msg_key_notification
*)
246 skb_put(skb
, sizeof(struct ieee80211_msg_key_notification
));
247 msg
->tx_rx_count
= key
->tx_rx_count
;
248 memcpy(msg
->ifname
, dev
->name
, IFNAMSIZ
);
250 memcpy(msg
->addr
, sta
->addr
, ETH_ALEN
);
252 memset(msg
->addr
, 0xff, ETH_ALEN
);
254 key
->tx_rx_count
= 0;
256 ieee80211_rx_mgmt(local
, skb
, NULL
,
257 ieee80211_msg_key_threshold_notification
);
261 u8
*ieee80211_get_bssid(struct ieee80211_hdr
*hdr
, size_t len
)
268 fc
= le16_to_cpu(hdr
->frame_control
);
270 switch (fc
& IEEE80211_FCTL_FTYPE
) {
271 case IEEE80211_FTYPE_DATA
:
272 switch (fc
& (IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
)) {
273 case IEEE80211_FCTL_TODS
:
275 case (IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
):
277 case IEEE80211_FCTL_FROMDS
:
283 case IEEE80211_FTYPE_MGMT
:
285 case IEEE80211_FTYPE_CTL
:
286 if ((fc
& IEEE80211_FCTL_STYPE
) == IEEE80211_STYPE_PSPOLL
)
295 int ieee80211_get_hdrlen(u16 fc
)
299 switch (fc
& IEEE80211_FCTL_FTYPE
) {
300 case IEEE80211_FTYPE_DATA
:
301 if ((fc
& IEEE80211_FCTL_FROMDS
) && (fc
& IEEE80211_FCTL_TODS
))
302 hdrlen
= 30; /* Addr4 */
304 * The QoS Control field is two bytes and its presence is
305 * indicated by the IEEE80211_STYPE_QOS_DATA bit. Add 2 to
306 * hdrlen if that bit is set.
307 * This works by masking out the bit and shifting it to
308 * bit position 1 so the result has the value 0 or 2.
310 hdrlen
+= (fc
& IEEE80211_STYPE_QOS_DATA
)
311 >> (ilog2(IEEE80211_STYPE_QOS_DATA
)-1);
313 case IEEE80211_FTYPE_CTL
:
315 * ACK and CTS are 10 bytes, all others 16. To see how
316 * to get this condition consider
317 * subtype mask: 0b0000000011110000 (0x00F0)
318 * ACK subtype: 0b0000000011010000 (0x00D0)
319 * CTS subtype: 0b0000000011000000 (0x00C0)
320 * bits that matter: ^^^ (0x00E0)
321 * value of those: 0b0000000011000000 (0x00C0)
323 if ((fc
& 0xE0) == 0xC0)
332 EXPORT_SYMBOL(ieee80211_get_hdrlen
);
334 int ieee80211_get_hdrlen_from_skb(const struct sk_buff
*skb
)
336 const struct ieee80211_hdr
*hdr
= (const struct ieee80211_hdr
*) skb
->data
;
339 if (unlikely(skb
->len
< 10))
341 hdrlen
= ieee80211_get_hdrlen(le16_to_cpu(hdr
->frame_control
));
342 if (unlikely(hdrlen
> skb
->len
))
346 EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb
);
349 #ifdef CONFIG_MAC80211_LOWTX_FRAME_DUMP
350 static void ieee80211_dump_frame(const char *ifname
, const char *title
,
351 const struct sk_buff
*skb
)
353 const struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
357 printk(KERN_DEBUG
"%s: %s (len=%d)", ifname
, title
, skb
->len
);
363 fc
= le16_to_cpu(hdr
->frame_control
);
364 hdrlen
= ieee80211_get_hdrlen(fc
);
365 if (hdrlen
> skb
->len
)
368 printk(" FC=0x%04x DUR=0x%04x",
369 fc
, le16_to_cpu(hdr
->duration_id
));
371 printk(" A1=" MAC_FMT
, MAC_ARG(hdr
->addr1
));
373 printk(" A2=" MAC_FMT
, MAC_ARG(hdr
->addr2
));
375 printk(" A3=" MAC_FMT
, MAC_ARG(hdr
->addr3
));
377 printk(" A4=" MAC_FMT
, MAC_ARG(hdr
->addr4
));
380 #else /* CONFIG_MAC80211_LOWTX_FRAME_DUMP */
381 static inline void ieee80211_dump_frame(const char *ifname
, const char *title
,
385 #endif /* CONFIG_MAC80211_LOWTX_FRAME_DUMP */
388 int ieee80211_is_eapol(const struct sk_buff
*skb
)
390 const struct ieee80211_hdr
*hdr
;
394 if (unlikely(skb
->len
< 10))
397 hdr
= (const struct ieee80211_hdr
*) skb
->data
;
398 fc
= le16_to_cpu(hdr
->frame_control
);
400 if (unlikely(!WLAN_FC_DATA_PRESENT(fc
)))
403 hdrlen
= ieee80211_get_hdrlen(fc
);
405 if (unlikely(skb
->len
>= hdrlen
+ sizeof(eapol_header
) &&
406 memcmp(skb
->data
+ hdrlen
, eapol_header
,
407 sizeof(eapol_header
)) == 0))
414 static ieee80211_txrx_result
415 ieee80211_tx_h_rate_ctrl(struct ieee80211_txrx_data
*tx
)
417 struct rate_control_extra extra
;
419 memset(&extra
, 0, sizeof(extra
));
420 extra
.mode
= tx
->u
.tx
.mode
;
421 extra
.mgmt_data
= tx
->sdata
&&
422 tx
->sdata
->type
== IEEE80211_IF_TYPE_MGMT
;
423 extra
.ethertype
= tx
->ethertype
;
425 tx
->u
.tx
.rate
= rate_control_get_rate(tx
->local
, tx
->dev
, tx
->skb
,
427 if (unlikely(extra
.probe
!= NULL
)) {
428 tx
->u
.tx
.control
->flags
|= IEEE80211_TXCTL_RATE_CTRL_PROBE
;
429 tx
->u
.tx
.probe_last_frag
= 1;
430 tx
->u
.tx
.control
->alt_retry_rate
= tx
->u
.tx
.rate
->val
;
431 tx
->u
.tx
.rate
= extra
.probe
;
433 tx
->u
.tx
.control
->alt_retry_rate
= -1;
437 if (tx
->u
.tx
.mode
->mode
== MODE_IEEE80211G
&&
438 tx
->sdata
->use_protection
&& tx
->fragmented
&&
440 tx
->u
.tx
.last_frag_rate
= tx
->u
.tx
.rate
;
441 tx
->u
.tx
.probe_last_frag
= extra
.probe
? 1 : 0;
443 tx
->u
.tx
.rate
= extra
.nonerp
;
444 tx
->u
.tx
.control
->rate
= extra
.nonerp
;
445 tx
->u
.tx
.control
->flags
&= ~IEEE80211_TXCTL_RATE_CTRL_PROBE
;
447 tx
->u
.tx
.last_frag_rate
= tx
->u
.tx
.rate
;
448 tx
->u
.tx
.control
->rate
= tx
->u
.tx
.rate
;
450 tx
->u
.tx
.control
->tx_rate
= tx
->u
.tx
.rate
->val
;
451 if ((tx
->u
.tx
.rate
->flags
& IEEE80211_RATE_PREAMBLE2
) &&
452 tx
->local
->short_preamble
&&
453 (!tx
->sta
|| (tx
->sta
->flags
& WLAN_STA_SHORT_PREAMBLE
))) {
454 tx
->u
.tx
.short_preamble
= 1;
455 tx
->u
.tx
.control
->tx_rate
= tx
->u
.tx
.rate
->val2
;
458 return TXRX_CONTINUE
;
462 static ieee80211_txrx_result
463 ieee80211_tx_h_select_key(struct ieee80211_txrx_data
*tx
)
466 tx
->u
.tx
.control
->key_idx
= tx
->sta
->key_idx_compression
;
468 tx
->u
.tx
.control
->key_idx
= HW_KEY_IDX_INVALID
;
470 if (unlikely(tx
->u
.tx
.control
->flags
& IEEE80211_TXCTL_DO_NOT_ENCRYPT
))
472 else if (tx
->sta
&& tx
->sta
->key
)
473 tx
->key
= tx
->sta
->key
;
474 else if (tx
->sdata
->default_key
)
475 tx
->key
= tx
->sdata
->default_key
;
476 else if (tx
->sdata
->drop_unencrypted
&&
477 !(tx
->sdata
->eapol
&& ieee80211_is_eapol(tx
->skb
))) {
478 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_unencrypted
);
484 tx
->key
->tx_rx_count
++;
485 if (unlikely(tx
->local
->key_tx_rx_threshold
&&
486 tx
->key
->tx_rx_count
>
487 tx
->local
->key_tx_rx_threshold
)) {
488 ieee80211_key_threshold_notify(tx
->dev
, tx
->key
,
493 return TXRX_CONTINUE
;
497 static ieee80211_txrx_result
498 ieee80211_tx_h_fragment(struct ieee80211_txrx_data
*tx
)
500 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) tx
->skb
->data
;
501 size_t hdrlen
, per_fragm
, num_fragm
, payload_len
, left
;
502 struct sk_buff
**frags
, *first
, *frag
;
506 int frag_threshold
= tx
->local
->fragmentation_threshold
;
509 return TXRX_CONTINUE
;
513 hdrlen
= ieee80211_get_hdrlen(tx
->fc
);
514 payload_len
= first
->len
- hdrlen
;
515 per_fragm
= frag_threshold
- hdrlen
- FCS_LEN
;
516 num_fragm
= (payload_len
+ per_fragm
- 1) / per_fragm
;
518 frags
= kzalloc(num_fragm
* sizeof(struct sk_buff
*), GFP_ATOMIC
);
522 hdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_MOREFRAGS
);
523 seq
= le16_to_cpu(hdr
->seq_ctrl
) & IEEE80211_SCTL_SEQ
;
524 pos
= first
->data
+ hdrlen
+ per_fragm
;
525 left
= payload_len
- per_fragm
;
526 for (i
= 0; i
< num_fragm
- 1; i
++) {
527 struct ieee80211_hdr
*fhdr
;
533 /* reserve enough extra head and tail room for possible
536 dev_alloc_skb(tx
->local
->tx_headroom
+
538 IEEE80211_ENCRYPT_HEADROOM
+
539 IEEE80211_ENCRYPT_TAILROOM
);
542 /* Make sure that all fragments use the same priority so
543 * that they end up using the same TX queue */
544 frag
->priority
= first
->priority
;
545 skb_reserve(frag
, tx
->local
->tx_headroom
+
546 IEEE80211_ENCRYPT_HEADROOM
);
547 fhdr
= (struct ieee80211_hdr
*) skb_put(frag
, hdrlen
);
548 memcpy(fhdr
, first
->data
, hdrlen
);
549 if (i
== num_fragm
- 2)
550 fhdr
->frame_control
&= cpu_to_le16(~IEEE80211_FCTL_MOREFRAGS
);
551 fhdr
->seq_ctrl
= cpu_to_le16(seq
| ((i
+ 1) & IEEE80211_SCTL_FRAG
));
552 copylen
= left
> per_fragm
? per_fragm
: left
;
553 memcpy(skb_put(frag
, copylen
), pos
, copylen
);
558 skb_trim(first
, hdrlen
+ per_fragm
);
560 tx
->u
.tx
.num_extra_frag
= num_fragm
- 1;
561 tx
->u
.tx
.extra_frag
= frags
;
563 return TXRX_CONTINUE
;
566 printk(KERN_DEBUG
"%s: failed to fragment frame\n", tx
->dev
->name
);
568 for (i
= 0; i
< num_fragm
- 1; i
++)
570 dev_kfree_skb(frags
[i
]);
573 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_fragment
);
578 static int wep_encrypt_skb(struct ieee80211_txrx_data
*tx
, struct sk_buff
*skb
)
580 if (tx
->key
->force_sw_encrypt
) {
581 if (ieee80211_wep_encrypt(tx
->local
, skb
, tx
->key
))
584 tx
->u
.tx
.control
->key_idx
= tx
->key
->hw_key_idx
;
585 if (tx
->local
->hw
.flags
& IEEE80211_HW_WEP_INCLUDE_IV
) {
586 if (ieee80211_wep_add_iv(tx
->local
, skb
, tx
->key
) ==
595 void ieee80211_tx_set_iswep(struct ieee80211_txrx_data
*tx
)
597 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) tx
->skb
->data
;
599 hdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
600 if (tx
->u
.tx
.extra_frag
) {
601 struct ieee80211_hdr
*fhdr
;
603 for (i
= 0; i
< tx
->u
.tx
.num_extra_frag
; i
++) {
604 fhdr
= (struct ieee80211_hdr
*)
605 tx
->u
.tx
.extra_frag
[i
]->data
;
606 fhdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
612 static ieee80211_txrx_result
613 ieee80211_tx_h_wep_encrypt(struct ieee80211_txrx_data
*tx
)
615 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) tx
->skb
->data
;
618 fc
= le16_to_cpu(hdr
->frame_control
);
620 if (!tx
->key
|| tx
->key
->alg
!= ALG_WEP
||
621 ((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
&&
622 ((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_MGMT
||
623 (fc
& IEEE80211_FCTL_STYPE
) != IEEE80211_STYPE_AUTH
)))
624 return TXRX_CONTINUE
;
626 tx
->u
.tx
.control
->iv_len
= WEP_IV_LEN
;
627 tx
->u
.tx
.control
->icv_len
= WEP_ICV_LEN
;
628 ieee80211_tx_set_iswep(tx
);
630 if (wep_encrypt_skb(tx
, tx
->skb
) < 0) {
631 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_wep
);
635 if (tx
->u
.tx
.extra_frag
) {
637 for (i
= 0; i
< tx
->u
.tx
.num_extra_frag
; i
++) {
638 if (wep_encrypt_skb(tx
, tx
->u
.tx
.extra_frag
[i
]) < 0) {
639 I802_DEBUG_INC(tx
->local
->
640 tx_handlers_drop_wep
);
646 return TXRX_CONTINUE
;
650 static int ieee80211_frame_duration(struct ieee80211_local
*local
, size_t len
,
651 int rate
, int erp
, int short_preamble
)
655 /* calculate duration (in microseconds, rounded up to next higher
656 * integer if it includes a fractional microsecond) to send frame of
657 * len bytes (does not include FCS) at the given rate. Duration will
660 * rate is in 100 kbps, so divident is multiplied by 10 in the
661 * DIV_ROUND_UP() operations.
664 if (local
->hw
.conf
.phymode
== MODE_IEEE80211A
|| erp
||
665 local
->hw
.conf
.phymode
== MODE_ATHEROS_TURBO
) {
669 * N_DBPS = DATARATE x 4
670 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
671 * (16 = SIGNAL time, 6 = tail bits)
672 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
675 * 802.11a - 17.5.2: aSIFSTime = 16 usec
676 * 802.11g - 19.8.4: aSIFSTime = 10 usec +
677 * signal ext = 6 usec
679 /* FIX: Atheros Turbo may have different (shorter) duration? */
680 dur
= 16; /* SIFS + signal ext */
681 dur
+= 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */
682 dur
+= 4; /* 17.3.2.3: T_SIGNAL = 4 usec */
683 dur
+= 4 * DIV_ROUND_UP((16 + 8 * (len
+ 4) + 6) * 10,
684 4 * rate
); /* T_SYM x N_SYM */
687 * 802.11b or 802.11g with 802.11b compatibility:
688 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
689 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
691 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
692 * aSIFSTime = 10 usec
693 * aPreambleLength = 144 usec or 72 usec with short preamble
694 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
696 dur
= 10; /* aSIFSTime = 10 usec */
697 dur
+= short_preamble
? (72 + 24) : (144 + 48);
699 dur
+= DIV_ROUND_UP(8 * (len
+ 4) * 10, rate
);
706 /* Exported duration function for driver use */
707 __le16
ieee80211_generic_frame_duration(struct ieee80211_hw
*hw
,
708 size_t frame_len
, int rate
)
710 struct ieee80211_local
*local
= hw_to_local(hw
);
714 erp
= ieee80211_is_erp_rate(hw
->conf
.phymode
, rate
);
715 dur
= ieee80211_frame_duration(local
, frame_len
, rate
,
716 erp
, local
->short_preamble
);
718 return cpu_to_le16(dur
);
720 EXPORT_SYMBOL(ieee80211_generic_frame_duration
);
723 static u16
ieee80211_duration(struct ieee80211_txrx_data
*tx
, int group_addr
,
726 int rate
, mrate
, erp
, dur
, i
;
727 struct ieee80211_rate
*txrate
= tx
->u
.tx
.rate
;
728 struct ieee80211_local
*local
= tx
->local
;
729 struct ieee80211_hw_mode
*mode
= tx
->u
.tx
.mode
;
731 erp
= txrate
->flags
& IEEE80211_RATE_ERP
;
734 * data and mgmt (except PS Poll):
735 * - during CFP: 32768
736 * - during contention period:
737 * if addr1 is group address: 0
738 * if more fragments = 0 and addr1 is individual address: time to
739 * transmit one ACK plus SIFS
740 * if more fragments = 1 and addr1 is individual address: time to
741 * transmit next fragment plus 2 x ACK plus 3 x SIFS
744 * - control response frame (CTS or ACK) shall be transmitted using the
745 * same rate as the immediately previous frame in the frame exchange
746 * sequence, if this rate belongs to the PHY mandatory rates, or else
747 * at the highest possible rate belonging to the PHY rates in the
751 if ((tx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_CTL
) {
752 /* TODO: These control frames are not currently sent by
753 * 80211.o, but should they be implemented, this function
754 * needs to be updated to support duration field calculation.
756 * RTS: time needed to transmit pending data/mgmt frame plus
757 * one CTS frame plus one ACK frame plus 3 x SIFS
758 * CTS: duration of immediately previous RTS minus time
759 * required to transmit CTS and its SIFS
760 * ACK: 0 if immediately previous directed data/mgmt had
761 * more=0, with more=1 duration in ACK frame is duration
762 * from previous frame minus time needed to transmit ACK
764 * PS Poll: BIT(15) | BIT(14) | aid
770 if (0 /* FIX: data/mgmt during CFP */)
773 if (group_addr
) /* Group address as the destination - no ACK */
776 /* Individual destination address:
777 * IEEE 802.11, Ch. 9.6 (after IEEE 802.11g changes)
778 * CTS and ACK frames shall be transmitted using the highest rate in
779 * basic rate set that is less than or equal to the rate of the
780 * immediately previous frame and that is using the same modulation
781 * (CCK or OFDM). If no basic rate set matches with these requirements,
782 * the highest mandatory rate of the PHY that is less than or equal to
783 * the rate of the previous frame is used.
784 * Mandatory rates for IEEE 802.11g PHY: 1, 2, 5.5, 11, 6, 12, 24 Mbps
787 mrate
= 10; /* use 1 Mbps if everything fails */
788 for (i
= 0; i
< mode
->num_rates
; i
++) {
789 struct ieee80211_rate
*r
= &mode
->rates
[i
];
790 if (r
->rate
> txrate
->rate
)
793 if (IEEE80211_RATE_MODULATION(txrate
->flags
) !=
794 IEEE80211_RATE_MODULATION(r
->flags
))
797 if (r
->flags
& IEEE80211_RATE_BASIC
)
799 else if (r
->flags
& IEEE80211_RATE_MANDATORY
)
803 /* No matching basic rate found; use highest suitable mandatory
808 /* Time needed to transmit ACK
809 * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
810 * to closest integer */
812 dur
= ieee80211_frame_duration(local
, 10, rate
, erp
,
813 local
->short_preamble
);
816 /* Frame is fragmented: duration increases with time needed to
817 * transmit next fragment plus ACK and 2 x SIFS. */
818 dur
*= 2; /* ACK + SIFS */
820 dur
+= ieee80211_frame_duration(local
, next_frag_len
,
822 local
->short_preamble
);
829 static ieee80211_txrx_result
830 ieee80211_tx_h_misc(struct ieee80211_txrx_data
*tx
)
832 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) tx
->skb
->data
;
834 struct ieee80211_tx_control
*control
= tx
->u
.tx
.control
;
835 struct ieee80211_hw_mode
*mode
= tx
->u
.tx
.mode
;
837 if (!is_multicast_ether_addr(hdr
->addr1
)) {
838 if (tx
->skb
->len
+ FCS_LEN
> tx
->local
->rts_threshold
&&
839 tx
->local
->rts_threshold
< IEEE80211_MAX_RTS_THRESHOLD
) {
840 control
->flags
|= IEEE80211_TXCTL_USE_RTS_CTS
;
841 control
->retry_limit
=
842 tx
->local
->long_retry_limit
;
844 control
->retry_limit
=
845 tx
->local
->short_retry_limit
;
848 control
->retry_limit
= 1;
851 if (tx
->fragmented
) {
852 /* Do not use multiple retry rates when sending fragmented
854 * TODO: The last fragment could still use multiple retry
856 control
->alt_retry_rate
= -1;
859 /* Use CTS protection for unicast frames sent using extended rates if
860 * there are associated non-ERP stations and RTS/CTS is not configured
862 if (mode
->mode
== MODE_IEEE80211G
&&
863 (tx
->u
.tx
.rate
->flags
& IEEE80211_RATE_ERP
) &&
864 tx
->u
.tx
.unicast
&& tx
->sdata
->use_protection
&&
865 !(control
->flags
& IEEE80211_TXCTL_USE_RTS_CTS
))
866 control
->flags
|= IEEE80211_TXCTL_USE_CTS_PROTECT
;
868 /* Setup duration field for the first fragment of the frame. Duration
869 * for remaining fragments will be updated when they are being sent
870 * to low-level driver in ieee80211_tx(). */
871 dur
= ieee80211_duration(tx
, is_multicast_ether_addr(hdr
->addr1
),
872 tx
->fragmented
? tx
->u
.tx
.extra_frag
[0]->len
:
874 hdr
->duration_id
= cpu_to_le16(dur
);
876 if ((control
->flags
& IEEE80211_TXCTL_USE_RTS_CTS
) ||
877 (control
->flags
& IEEE80211_TXCTL_USE_CTS_PROTECT
)) {
878 struct ieee80211_rate
*rate
;
880 /* Do not use multiple retry rates when using RTS/CTS */
881 control
->alt_retry_rate
= -1;
883 /* Use min(data rate, max base rate) as CTS/RTS rate */
884 rate
= tx
->u
.tx
.rate
;
885 while (rate
> mode
->rates
&&
886 !(rate
->flags
& IEEE80211_RATE_BASIC
))
889 control
->rts_cts_rate
= rate
->val
;
890 control
->rts_rate
= rate
;
894 tx
->sta
->tx_packets
++;
895 tx
->sta
->tx_fragments
++;
896 tx
->sta
->tx_bytes
+= tx
->skb
->len
;
897 if (tx
->u
.tx
.extra_frag
) {
899 tx
->sta
->tx_fragments
+= tx
->u
.tx
.num_extra_frag
;
900 for (i
= 0; i
< tx
->u
.tx
.num_extra_frag
; i
++) {
902 tx
->u
.tx
.extra_frag
[i
]->len
;
907 return TXRX_CONTINUE
;
911 static ieee80211_txrx_result
912 ieee80211_tx_h_check_assoc(struct ieee80211_txrx_data
*tx
)
914 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
915 struct sk_buff
*skb
= tx
->skb
;
916 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
917 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
920 if (unlikely(tx
->local
->sta_scanning
!= 0) &&
921 ((tx
->fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_MGMT
||
922 (tx
->fc
& IEEE80211_FCTL_STYPE
) != IEEE80211_STYPE_PROBE_REQ
))
925 if (tx
->u
.tx
.ps_buffered
)
926 return TXRX_CONTINUE
;
928 sta_flags
= tx
->sta
? tx
->sta
->flags
: 0;
930 if (likely(tx
->u
.tx
.unicast
)) {
931 if (unlikely(!(sta_flags
& WLAN_STA_ASSOC
) &&
932 tx
->sdata
->type
!= IEEE80211_IF_TYPE_IBSS
&&
933 (tx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
)) {
934 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
935 printk(KERN_DEBUG
"%s: dropped data frame to not "
936 "associated station " MAC_FMT
"\n",
937 tx
->dev
->name
, MAC_ARG(hdr
->addr1
));
938 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
939 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_not_assoc
);
943 if (unlikely((tx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
&&
944 tx
->local
->num_sta
== 0 &&
945 !tx
->local
->allow_broadcast_always
&&
946 tx
->sdata
->type
!= IEEE80211_IF_TYPE_IBSS
)) {
948 * No associated STAs - no need to send multicast
953 return TXRX_CONTINUE
;
956 if (unlikely(!tx
->u
.tx
.mgmt_interface
&& tx
->sdata
->ieee802_1x
&&
957 !(sta_flags
& WLAN_STA_AUTHORIZED
))) {
958 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
959 printk(KERN_DEBUG
"%s: dropped frame to " MAC_FMT
960 " (unauthorized port)\n", tx
->dev
->name
,
961 MAC_ARG(hdr
->addr1
));
963 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_unauth_port
);
967 return TXRX_CONTINUE
;
970 static ieee80211_txrx_result
971 ieee80211_tx_h_sequence(struct ieee80211_txrx_data
*tx
)
973 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)tx
->skb
->data
;
975 if (ieee80211_get_hdrlen(le16_to_cpu(hdr
->frame_control
)) >= 24)
976 ieee80211_include_sequence(tx
->sdata
, hdr
);
978 return TXRX_CONTINUE
;
981 /* This function is called whenever the AP is about to exceed the maximum limit
982 * of buffered frames for power saving STAs. This situation should not really
983 * happen often during normal operation, so dropping the oldest buffered packet
984 * from each queue should be OK to make some room for new frames. */
985 static void purge_old_ps_buffers(struct ieee80211_local
*local
)
987 int total
= 0, purged
= 0;
989 struct ieee80211_sub_if_data
*sdata
;
990 struct sta_info
*sta
;
992 read_lock(&local
->sub_if_lock
);
993 list_for_each_entry(sdata
, &local
->sub_if_list
, list
) {
994 struct ieee80211_if_ap
*ap
;
995 if (sdata
->dev
== local
->mdev
||
996 sdata
->type
!= IEEE80211_IF_TYPE_AP
)
999 skb
= skb_dequeue(&ap
->ps_bc_buf
);
1004 total
+= skb_queue_len(&ap
->ps_bc_buf
);
1006 read_unlock(&local
->sub_if_lock
);
1008 spin_lock_bh(&local
->sta_lock
);
1009 list_for_each_entry(sta
, &local
->sta_list
, list
) {
1010 skb
= skb_dequeue(&sta
->ps_tx_buf
);
1015 total
+= skb_queue_len(&sta
->ps_tx_buf
);
1017 spin_unlock_bh(&local
->sta_lock
);
1019 local
->total_ps_buffered
= total
;
1020 printk(KERN_DEBUG
"%s: PS buffers full - purged %d frames\n",
1021 local
->mdev
->name
, purged
);
1025 static inline ieee80211_txrx_result
1026 ieee80211_tx_h_multicast_ps_buf(struct ieee80211_txrx_data
*tx
)
1028 /* broadcast/multicast frame */
1029 /* If any of the associated stations is in power save mode,
1030 * the frame is buffered to be sent after DTIM beacon frame */
1031 if ((tx
->local
->hw
.flags
& IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING
) &&
1032 tx
->sdata
->type
!= IEEE80211_IF_TYPE_WDS
&&
1033 tx
->sdata
->bss
&& atomic_read(&tx
->sdata
->bss
->num_sta_ps
) &&
1034 !(tx
->fc
& IEEE80211_FCTL_ORDER
)) {
1035 if (tx
->local
->total_ps_buffered
>= TOTAL_MAX_TX_BUFFER
)
1036 purge_old_ps_buffers(tx
->local
);
1037 if (skb_queue_len(&tx
->sdata
->bss
->ps_bc_buf
) >=
1039 if (net_ratelimit()) {
1040 printk(KERN_DEBUG
"%s: BC TX buffer full - "
1041 "dropping the oldest frame\n",
1044 dev_kfree_skb(skb_dequeue(&tx
->sdata
->bss
->ps_bc_buf
));
1046 tx
->local
->total_ps_buffered
++;
1047 skb_queue_tail(&tx
->sdata
->bss
->ps_bc_buf
, tx
->skb
);
1051 return TXRX_CONTINUE
;
1055 static inline ieee80211_txrx_result
1056 ieee80211_tx_h_unicast_ps_buf(struct ieee80211_txrx_data
*tx
)
1058 struct sta_info
*sta
= tx
->sta
;
1060 if (unlikely(!sta
||
1061 ((tx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_MGMT
&&
1062 (tx
->fc
& IEEE80211_FCTL_STYPE
) == IEEE80211_STYPE_PROBE_RESP
)))
1063 return TXRX_CONTINUE
;
1065 if (unlikely((sta
->flags
& WLAN_STA_PS
) && !sta
->pspoll
)) {
1066 struct ieee80211_tx_packet_data
*pkt_data
;
1067 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
1068 printk(KERN_DEBUG
"STA " MAC_FMT
" aid %d: PS buffer (entries "
1070 MAC_ARG(sta
->addr
), sta
->aid
,
1071 skb_queue_len(&sta
->ps_tx_buf
));
1072 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
1073 sta
->flags
|= WLAN_STA_TIM
;
1074 if (tx
->local
->total_ps_buffered
>= TOTAL_MAX_TX_BUFFER
)
1075 purge_old_ps_buffers(tx
->local
);
1076 if (skb_queue_len(&sta
->ps_tx_buf
) >= STA_MAX_TX_BUFFER
) {
1077 struct sk_buff
*old
= skb_dequeue(&sta
->ps_tx_buf
);
1078 if (net_ratelimit()) {
1079 printk(KERN_DEBUG
"%s: STA " MAC_FMT
" TX "
1080 "buffer full - dropping oldest frame\n",
1081 tx
->dev
->name
, MAC_ARG(sta
->addr
));
1085 tx
->local
->total_ps_buffered
++;
1086 /* Queue frame to be sent after STA sends an PS Poll frame */
1087 if (skb_queue_empty(&sta
->ps_tx_buf
)) {
1088 if (tx
->local
->ops
->set_tim
)
1089 tx
->local
->ops
->set_tim(local_to_hw(tx
->local
),
1092 bss_tim_set(tx
->local
, tx
->sdata
->bss
, sta
->aid
);
1094 pkt_data
= (struct ieee80211_tx_packet_data
*)tx
->skb
->cb
;
1095 pkt_data
->jiffies
= jiffies
;
1096 skb_queue_tail(&sta
->ps_tx_buf
, tx
->skb
);
1099 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
1100 else if (unlikely(sta
->flags
& WLAN_STA_PS
)) {
1101 printk(KERN_DEBUG
"%s: STA " MAC_FMT
" in PS mode, but pspoll "
1102 "set -> send frame\n", tx
->dev
->name
,
1103 MAC_ARG(sta
->addr
));
1105 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
1108 return TXRX_CONTINUE
;
1112 static ieee80211_txrx_result
1113 ieee80211_tx_h_ps_buf(struct ieee80211_txrx_data
*tx
)
1115 if (unlikely(tx
->u
.tx
.ps_buffered
))
1116 return TXRX_CONTINUE
;
1118 if (tx
->u
.tx
.unicast
)
1119 return ieee80211_tx_h_unicast_ps_buf(tx
);
1121 return ieee80211_tx_h_multicast_ps_buf(tx
);
1126 * deal with packet injection down monitor interface
1127 * with Radiotap Header -- only called for monitor mode interface
1130 static ieee80211_txrx_result
1131 __ieee80211_parse_tx_radiotap(
1132 struct ieee80211_txrx_data
*tx
,
1133 struct sk_buff
*skb
, struct ieee80211_tx_control
*control
)
1136 * this is the moment to interpret and discard the radiotap header that
1137 * must be at the start of the packet injected in Monitor mode
1139 * Need to take some care with endian-ness since radiotap
1140 * args are little-endian
1143 struct ieee80211_radiotap_iterator iterator
;
1144 struct ieee80211_radiotap_header
*rthdr
=
1145 (struct ieee80211_radiotap_header
*) skb
->data
;
1146 struct ieee80211_hw_mode
*mode
= tx
->local
->hw
.conf
.mode
;
1147 int ret
= ieee80211_radiotap_iterator_init(&iterator
, rthdr
, skb
->len
);
1150 * default control situation for all injected packets
1151 * FIXME: this does not suit all usage cases, expand to allow control
1154 control
->retry_limit
= 1; /* no retry */
1155 control
->key_idx
= -1; /* no encryption key */
1156 control
->flags
&= ~(IEEE80211_TXCTL_USE_RTS_CTS
|
1157 IEEE80211_TXCTL_USE_CTS_PROTECT
);
1158 control
->flags
|= IEEE80211_TXCTL_DO_NOT_ENCRYPT
|
1159 IEEE80211_TXCTL_NO_ACK
;
1160 control
->antenna_sel_tx
= 0; /* default to default antenna */
1163 * for every radiotap entry that is present
1164 * (ieee80211_radiotap_iterator_next returns -ENOENT when no more
1165 * entries present, or -EINVAL on error)
1171 ret
= ieee80211_radiotap_iterator_next(&iterator
);
1176 /* see if this argument is something we can use */
1177 switch (iterator
.this_arg_index
) {
1179 * You must take care when dereferencing iterator.this_arg
1180 * for multibyte types... the pointer is not aligned. Use
1181 * get_unaligned((type *)iterator.this_arg) to dereference
1182 * iterator.this_arg for type "type" safely on all arches.
1184 case IEEE80211_RADIOTAP_RATE
:
1186 * radiotap rate u8 is in 500kbps units eg, 0x02=1Mbps
1187 * ieee80211 rate int is in 100kbps units eg, 0x0a=1Mbps
1189 target_rate
= (*iterator
.this_arg
) * 5;
1190 for (i
= 0; i
< mode
->num_rates
; i
++) {
1191 struct ieee80211_rate
*r
= &mode
->rates
[i
];
1193 if (r
->rate
> target_rate
)
1198 if (r
->flags
& IEEE80211_RATE_PREAMBLE2
)
1199 control
->tx_rate
= r
->val2
;
1201 control
->tx_rate
= r
->val
;
1203 /* end on exact match */
1204 if (r
->rate
== target_rate
)
1205 i
= mode
->num_rates
;
1209 case IEEE80211_RADIOTAP_ANTENNA
:
1211 * radiotap uses 0 for 1st ant, mac80211 is 1 for
1214 control
->antenna_sel_tx
= (*iterator
.this_arg
) + 1;
1217 case IEEE80211_RADIOTAP_DBM_TX_POWER
:
1218 control
->power_level
= *iterator
.this_arg
;
1221 case IEEE80211_RADIOTAP_FLAGS
:
1222 if (*iterator
.this_arg
& IEEE80211_RADIOTAP_F_FCS
) {
1224 * this indicates that the skb we have been
1225 * handed has the 32-bit FCS CRC at the end...
1226 * we should react to that by snipping it off
1227 * because it will be recomputed and added
1230 if (skb
->len
< (iterator
.max_length
+ FCS_LEN
))
1233 skb_trim(skb
, skb
->len
- FCS_LEN
);
1242 if (ret
!= -ENOENT
) /* ie, if we didn't simply run out of fields */
1246 * remove the radiotap header
1247 * iterator->max_length was sanity-checked against
1248 * skb->len by iterator init
1250 skb_pull(skb
, iterator
.max_length
);
1252 return TXRX_CONTINUE
;
1256 static ieee80211_txrx_result
inline
1257 __ieee80211_tx_prepare(struct ieee80211_txrx_data
*tx
,
1258 struct sk_buff
*skb
,
1259 struct net_device
*dev
,
1260 struct ieee80211_tx_control
*control
)
1262 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1263 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
1264 struct ieee80211_sub_if_data
*sdata
;
1265 ieee80211_txrx_result res
= TXRX_CONTINUE
;
1269 memset(tx
, 0, sizeof(*tx
));
1271 tx
->dev
= dev
; /* use original interface */
1273 tx
->sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1274 tx
->sta
= sta_info_get(local
, hdr
->addr1
);
1275 tx
->fc
= le16_to_cpu(hdr
->frame_control
);
1278 * set defaults for things that can be set by
1279 * injected radiotap headers
1281 control
->power_level
= local
->hw
.conf
.power_level
;
1282 control
->antenna_sel_tx
= local
->hw
.conf
.antenna_sel_tx
;
1283 if (local
->sta_antenna_sel
!= STA_ANTENNA_SEL_AUTO
&& tx
->sta
)
1284 control
->antenna_sel_tx
= tx
->sta
->antenna_sel_tx
;
1286 /* process and remove the injection radiotap header */
1287 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1288 if (unlikely(sdata
->type
== IEEE80211_IF_TYPE_MNTR
)) {
1289 if (__ieee80211_parse_tx_radiotap(tx
, skb
, control
) ==
1294 * we removed the radiotap header after this point,
1295 * we filled control with what we could use
1296 * set to the actual ieee header now
1298 hdr
= (struct ieee80211_hdr
*) skb
->data
;
1299 res
= TXRX_QUEUED
; /* indication it was monitor packet */
1302 tx
->u
.tx
.control
= control
;
1303 tx
->u
.tx
.unicast
= !is_multicast_ether_addr(hdr
->addr1
);
1304 if (is_multicast_ether_addr(hdr
->addr1
))
1305 control
->flags
|= IEEE80211_TXCTL_NO_ACK
;
1307 control
->flags
&= ~IEEE80211_TXCTL_NO_ACK
;
1308 tx
->fragmented
= local
->fragmentation_threshold
<
1309 IEEE80211_MAX_FRAG_THRESHOLD
&& tx
->u
.tx
.unicast
&&
1310 skb
->len
+ FCS_LEN
> local
->fragmentation_threshold
&&
1311 (!local
->ops
->set_frag_threshold
);
1313 control
->flags
|= IEEE80211_TXCTL_CLEAR_DST_MASK
;
1314 else if (tx
->sta
->clear_dst_mask
) {
1315 control
->flags
|= IEEE80211_TXCTL_CLEAR_DST_MASK
;
1316 tx
->sta
->clear_dst_mask
= 0;
1318 hdrlen
= ieee80211_get_hdrlen(tx
->fc
);
1319 if (skb
->len
> hdrlen
+ sizeof(rfc1042_header
) + 2) {
1320 u8
*pos
= &skb
->data
[hdrlen
+ sizeof(rfc1042_header
)];
1321 tx
->ethertype
= (pos
[0] << 8) | pos
[1];
1323 control
->flags
|= IEEE80211_TXCTL_FIRST_FRAGMENT
;
1328 static int inline is_ieee80211_device(struct net_device
*dev
,
1329 struct net_device
*master
)
1331 return (wdev_priv(dev
->ieee80211_ptr
) ==
1332 wdev_priv(master
->ieee80211_ptr
));
1335 /* Device in tx->dev has a reference added; use dev_put(tx->dev) when
1336 * finished with it. */
1337 static int inline ieee80211_tx_prepare(struct ieee80211_txrx_data
*tx
,
1338 struct sk_buff
*skb
,
1339 struct net_device
*mdev
,
1340 struct ieee80211_tx_control
*control
)
1342 struct ieee80211_tx_packet_data
*pkt_data
;
1343 struct net_device
*dev
;
1345 pkt_data
= (struct ieee80211_tx_packet_data
*)skb
->cb
;
1346 dev
= dev_get_by_index(pkt_data
->ifindex
);
1347 if (unlikely(dev
&& !is_ieee80211_device(dev
, mdev
))) {
1353 __ieee80211_tx_prepare(tx
, skb
, dev
, control
);
1357 static inline int __ieee80211_queue_stopped(const struct ieee80211_local
*local
,
1360 return test_bit(IEEE80211_LINK_STATE_XOFF
, &local
->state
[queue
]);
1363 static inline int __ieee80211_queue_pending(const struct ieee80211_local
*local
,
1366 return test_bit(IEEE80211_LINK_STATE_PENDING
, &local
->state
[queue
]);
1369 #define IEEE80211_TX_OK 0
1370 #define IEEE80211_TX_AGAIN 1
1371 #define IEEE80211_TX_FRAG_AGAIN 2
1373 static int __ieee80211_tx(struct ieee80211_local
*local
, struct sk_buff
*skb
,
1374 struct ieee80211_txrx_data
*tx
)
1376 struct ieee80211_tx_control
*control
= tx
->u
.tx
.control
;
1379 if (!ieee80211_qdisc_installed(local
->mdev
) &&
1380 __ieee80211_queue_stopped(local
, 0)) {
1381 netif_stop_queue(local
->mdev
);
1382 return IEEE80211_TX_AGAIN
;
1385 ieee80211_dump_frame(local
->mdev
->name
, "TX to low-level driver", skb
);
1386 ret
= local
->ops
->tx(local_to_hw(local
), skb
, control
);
1388 return IEEE80211_TX_AGAIN
;
1389 local
->mdev
->trans_start
= jiffies
;
1390 ieee80211_led_tx(local
, 1);
1392 if (tx
->u
.tx
.extra_frag
) {
1393 control
->flags
&= ~(IEEE80211_TXCTL_USE_RTS_CTS
|
1394 IEEE80211_TXCTL_USE_CTS_PROTECT
|
1395 IEEE80211_TXCTL_CLEAR_DST_MASK
|
1396 IEEE80211_TXCTL_FIRST_FRAGMENT
);
1397 for (i
= 0; i
< tx
->u
.tx
.num_extra_frag
; i
++) {
1398 if (!tx
->u
.tx
.extra_frag
[i
])
1400 if (__ieee80211_queue_stopped(local
, control
->queue
))
1401 return IEEE80211_TX_FRAG_AGAIN
;
1402 if (i
== tx
->u
.tx
.num_extra_frag
) {
1403 control
->tx_rate
= tx
->u
.tx
.last_frag_hwrate
;
1404 control
->rate
= tx
->u
.tx
.last_frag_rate
;
1405 if (tx
->u
.tx
.probe_last_frag
)
1407 IEEE80211_TXCTL_RATE_CTRL_PROBE
;
1410 ~IEEE80211_TXCTL_RATE_CTRL_PROBE
;
1413 ieee80211_dump_frame(local
->mdev
->name
,
1414 "TX to low-level driver",
1415 tx
->u
.tx
.extra_frag
[i
]);
1416 ret
= local
->ops
->tx(local_to_hw(local
),
1417 tx
->u
.tx
.extra_frag
[i
],
1420 return IEEE80211_TX_FRAG_AGAIN
;
1421 local
->mdev
->trans_start
= jiffies
;
1422 ieee80211_led_tx(local
, 1);
1423 tx
->u
.tx
.extra_frag
[i
] = NULL
;
1425 kfree(tx
->u
.tx
.extra_frag
);
1426 tx
->u
.tx
.extra_frag
= NULL
;
1428 return IEEE80211_TX_OK
;
1431 static int ieee80211_tx(struct net_device
*dev
, struct sk_buff
*skb
,
1432 struct ieee80211_tx_control
*control
, int mgmt
)
1434 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1435 struct sta_info
*sta
;
1436 ieee80211_tx_handler
*handler
;
1437 struct ieee80211_txrx_data tx
;
1438 ieee80211_txrx_result res
= TXRX_DROP
, res_prepare
;
1441 WARN_ON(__ieee80211_queue_pending(local
, control
->queue
));
1443 if (unlikely(skb
->len
< 10)) {
1448 res_prepare
= __ieee80211_tx_prepare(&tx
, skb
, dev
, control
);
1450 if (res_prepare
== TXRX_DROP
) {
1456 tx
.u
.tx
.mgmt_interface
= mgmt
;
1457 tx
.u
.tx
.mode
= local
->hw
.conf
.mode
;
1459 if (res_prepare
== TXRX_QUEUED
) { /* if it was an injected packet */
1460 res
= TXRX_CONTINUE
;
1462 for (handler
= local
->tx_handlers
; *handler
!= NULL
;
1464 res
= (*handler
)(&tx
);
1465 if (res
!= TXRX_CONTINUE
)
1470 skb
= tx
.skb
; /* handlers are allowed to change skb */
1475 if (unlikely(res
== TXRX_DROP
)) {
1476 I802_DEBUG_INC(local
->tx_handlers_drop
);
1480 if (unlikely(res
== TXRX_QUEUED
)) {
1481 I802_DEBUG_INC(local
->tx_handlers_queued
);
1485 if (tx
.u
.tx
.extra_frag
) {
1486 for (i
= 0; i
< tx
.u
.tx
.num_extra_frag
; i
++) {
1488 struct ieee80211_hdr
*hdr
=
1489 (struct ieee80211_hdr
*)
1490 tx
.u
.tx
.extra_frag
[i
]->data
;
1492 if (i
+ 1 < tx
.u
.tx
.num_extra_frag
) {
1493 next_len
= tx
.u
.tx
.extra_frag
[i
+ 1]->len
;
1496 tx
.u
.tx
.rate
= tx
.u
.tx
.last_frag_rate
;
1497 tx
.u
.tx
.last_frag_hwrate
= tx
.u
.tx
.rate
->val
;
1499 dur
= ieee80211_duration(&tx
, 0, next_len
);
1500 hdr
->duration_id
= cpu_to_le16(dur
);
1505 ret
= __ieee80211_tx(local
, skb
, &tx
);
1507 struct ieee80211_tx_stored_packet
*store
=
1508 &local
->pending_packet
[control
->queue
];
1510 if (ret
== IEEE80211_TX_FRAG_AGAIN
)
1512 set_bit(IEEE80211_LINK_STATE_PENDING
,
1513 &local
->state
[control
->queue
]);
1515 /* When the driver gets out of buffers during sending of
1516 * fragments and calls ieee80211_stop_queue, there is
1517 * a small window between IEEE80211_LINK_STATE_XOFF and
1518 * IEEE80211_LINK_STATE_PENDING flags are set. If a buffer
1519 * gets available in that window (i.e. driver calls
1520 * ieee80211_wake_queue), we would end up with ieee80211_tx
1521 * called with IEEE80211_LINK_STATE_PENDING. Prevent this by
1522 * continuing transmitting here when that situation is
1523 * possible to have happened. */
1524 if (!__ieee80211_queue_stopped(local
, control
->queue
)) {
1525 clear_bit(IEEE80211_LINK_STATE_PENDING
,
1526 &local
->state
[control
->queue
]);
1529 memcpy(&store
->control
, control
,
1530 sizeof(struct ieee80211_tx_control
));
1532 store
->extra_frag
= tx
.u
.tx
.extra_frag
;
1533 store
->num_extra_frag
= tx
.u
.tx
.num_extra_frag
;
1534 store
->last_frag_hwrate
= tx
.u
.tx
.last_frag_hwrate
;
1535 store
->last_frag_rate
= tx
.u
.tx
.last_frag_rate
;
1536 store
->last_frag_rate_ctrl_probe
= tx
.u
.tx
.probe_last_frag
;
1543 for (i
= 0; i
< tx
.u
.tx
.num_extra_frag
; i
++)
1544 if (tx
.u
.tx
.extra_frag
[i
])
1545 dev_kfree_skb(tx
.u
.tx
.extra_frag
[i
]);
1546 kfree(tx
.u
.tx
.extra_frag
);
1550 static void ieee80211_tx_pending(unsigned long data
)
1552 struct ieee80211_local
*local
= (struct ieee80211_local
*)data
;
1553 struct net_device
*dev
= local
->mdev
;
1554 struct ieee80211_tx_stored_packet
*store
;
1555 struct ieee80211_txrx_data tx
;
1556 int i
, ret
, reschedule
= 0;
1558 netif_tx_lock_bh(dev
);
1559 for (i
= 0; i
< local
->hw
.queues
; i
++) {
1560 if (__ieee80211_queue_stopped(local
, i
))
1562 if (!__ieee80211_queue_pending(local
, i
)) {
1566 store
= &local
->pending_packet
[i
];
1567 tx
.u
.tx
.control
= &store
->control
;
1568 tx
.u
.tx
.extra_frag
= store
->extra_frag
;
1569 tx
.u
.tx
.num_extra_frag
= store
->num_extra_frag
;
1570 tx
.u
.tx
.last_frag_hwrate
= store
->last_frag_hwrate
;
1571 tx
.u
.tx
.last_frag_rate
= store
->last_frag_rate
;
1572 tx
.u
.tx
.probe_last_frag
= store
->last_frag_rate_ctrl_probe
;
1573 ret
= __ieee80211_tx(local
, store
->skb
, &tx
);
1575 if (ret
== IEEE80211_TX_FRAG_AGAIN
)
1578 clear_bit(IEEE80211_LINK_STATE_PENDING
,
1583 netif_tx_unlock_bh(dev
);
1585 if (!ieee80211_qdisc_installed(dev
)) {
1586 if (!__ieee80211_queue_stopped(local
, 0))
1587 netif_wake_queue(dev
);
1589 netif_schedule(dev
);
1593 static void ieee80211_clear_tx_pending(struct ieee80211_local
*local
)
1596 struct ieee80211_tx_stored_packet
*store
;
1598 for (i
= 0; i
< local
->hw
.queues
; i
++) {
1599 if (!__ieee80211_queue_pending(local
, i
))
1601 store
= &local
->pending_packet
[i
];
1602 kfree_skb(store
->skb
);
1603 for (j
= 0; j
< store
->num_extra_frag
; j
++)
1604 kfree_skb(store
->extra_frag
[j
]);
1605 kfree(store
->extra_frag
);
1606 clear_bit(IEEE80211_LINK_STATE_PENDING
, &local
->state
[i
]);
1610 static int ieee80211_master_start_xmit(struct sk_buff
*skb
,
1611 struct net_device
*dev
)
1613 struct ieee80211_tx_control control
;
1614 struct ieee80211_tx_packet_data
*pkt_data
;
1615 struct net_device
*odev
= NULL
;
1616 struct ieee80211_sub_if_data
*osdata
;
1621 * copy control out of the skb so other people can use skb->cb
1623 pkt_data
= (struct ieee80211_tx_packet_data
*)skb
->cb
;
1624 memset(&control
, 0, sizeof(struct ieee80211_tx_control
));
1626 if (pkt_data
->ifindex
)
1627 odev
= dev_get_by_index(pkt_data
->ifindex
);
1628 if (unlikely(odev
&& !is_ieee80211_device(odev
, dev
))) {
1632 if (unlikely(!odev
)) {
1633 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1634 printk(KERN_DEBUG
"%s: Discarded packet with nonexistent "
1635 "originating device\n", dev
->name
);
1640 osdata
= IEEE80211_DEV_TO_SUB_IF(odev
);
1642 headroom
= osdata
->local
->tx_headroom
+ IEEE80211_ENCRYPT_HEADROOM
;
1643 if (skb_headroom(skb
) < headroom
) {
1644 if (pskb_expand_head(skb
, headroom
, 0, GFP_ATOMIC
)) {
1651 control
.ifindex
= odev
->ifindex
;
1652 control
.type
= osdata
->type
;
1653 if (pkt_data
->req_tx_status
)
1654 control
.flags
|= IEEE80211_TXCTL_REQ_TX_STATUS
;
1655 if (pkt_data
->do_not_encrypt
)
1656 control
.flags
|= IEEE80211_TXCTL_DO_NOT_ENCRYPT
;
1657 if (pkt_data
->requeue
)
1658 control
.flags
|= IEEE80211_TXCTL_REQUEUE
;
1659 control
.queue
= pkt_data
->queue
;
1661 ret
= ieee80211_tx(odev
, skb
, &control
,
1662 control
.type
== IEEE80211_IF_TYPE_MGMT
);
1669 int ieee80211_monitor_start_xmit(struct sk_buff
*skb
,
1670 struct net_device
*dev
)
1672 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1673 struct ieee80211_tx_packet_data
*pkt_data
;
1674 struct ieee80211_radiotap_header
*prthdr
=
1675 (struct ieee80211_radiotap_header
*)skb
->data
;
1679 * there must be a radiotap header at the
1680 * start in this case
1682 if (unlikely(prthdr
->it_version
)) {
1683 /* only version 0 is supported */
1685 return NETDEV_TX_OK
;
1688 skb
->dev
= local
->mdev
;
1690 pkt_data
= (struct ieee80211_tx_packet_data
*)skb
->cb
;
1691 memset(pkt_data
, 0, sizeof(*pkt_data
));
1692 pkt_data
->ifindex
= dev
->ifindex
;
1693 pkt_data
->mgmt_iface
= 0;
1694 pkt_data
->do_not_encrypt
= 1;
1696 /* above needed because we set skb device to master */
1699 * fix up the pointers accounting for the radiotap
1700 * header still being in there. We are being given
1701 * a precooked IEEE80211 header so no need for
1704 len
= le16_to_cpu(get_unaligned(&prthdr
->it_len
));
1705 skb_set_mac_header(skb
, len
);
1706 skb_set_network_header(skb
, len
+ sizeof(struct ieee80211_hdr
));
1707 skb_set_transport_header(skb
, len
+ sizeof(struct ieee80211_hdr
));
1710 * pass the radiotap header up to
1711 * the next stage intact
1713 dev_queue_xmit(skb
);
1715 return NETDEV_TX_OK
;
1720 * ieee80211_subif_start_xmit - netif start_xmit function for Ethernet-type
1721 * subinterfaces (wlan#, WDS, and VLAN interfaces)
1722 * @skb: packet to be sent
1723 * @dev: incoming interface
1725 * Returns: 0 on success (and frees skb in this case) or 1 on failure (skb will
1726 * not be freed, and caller is responsible for either retrying later or freeing
1729 * This function takes in an Ethernet header and encapsulates it with suitable
1730 * IEEE 802.11 header based on which interface the packet is coming in. The
1731 * encapsulated packet will then be passed to master interface, wlan#.11, for
1732 * transmission (through low-level driver).
1734 int ieee80211_subif_start_xmit(struct sk_buff
*skb
,
1735 struct net_device
*dev
)
1737 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1738 struct ieee80211_tx_packet_data
*pkt_data
;
1739 struct ieee80211_sub_if_data
*sdata
;
1740 int ret
= 1, head_need
;
1741 u16 ethertype
, hdrlen
, fc
;
1742 struct ieee80211_hdr hdr
;
1743 const u8
*encaps_data
;
1744 int encaps_len
, skip_header_bytes
;
1745 int nh_pos
, h_pos
, no_encrypt
= 0;
1746 struct sta_info
*sta
;
1748 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1749 if (unlikely(skb
->len
< ETH_HLEN
)) {
1750 printk(KERN_DEBUG
"%s: short skb (len=%d)\n",
1751 dev
->name
, skb
->len
);
1756 nh_pos
= skb_network_header(skb
) - skb
->data
;
1757 h_pos
= skb_transport_header(skb
) - skb
->data
;
1759 /* convert Ethernet header to proper 802.11 header (based on
1760 * operation mode) */
1761 ethertype
= (skb
->data
[12] << 8) | skb
->data
[13];
1762 /* TODO: handling for 802.1x authorized/unauthorized port */
1763 fc
= IEEE80211_FTYPE_DATA
| IEEE80211_STYPE_DATA
;
1765 if (likely(sdata
->type
== IEEE80211_IF_TYPE_AP
||
1766 sdata
->type
== IEEE80211_IF_TYPE_VLAN
)) {
1767 fc
|= IEEE80211_FCTL_FROMDS
;
1769 memcpy(hdr
.addr1
, skb
->data
, ETH_ALEN
);
1770 memcpy(hdr
.addr2
, dev
->dev_addr
, ETH_ALEN
);
1771 memcpy(hdr
.addr3
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
1773 } else if (sdata
->type
== IEEE80211_IF_TYPE_WDS
) {
1774 fc
|= IEEE80211_FCTL_FROMDS
| IEEE80211_FCTL_TODS
;
1776 memcpy(hdr
.addr1
, sdata
->u
.wds
.remote_addr
, ETH_ALEN
);
1777 memcpy(hdr
.addr2
, dev
->dev_addr
, ETH_ALEN
);
1778 memcpy(hdr
.addr3
, skb
->data
, ETH_ALEN
);
1779 memcpy(hdr
.addr4
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
1781 } else if (sdata
->type
== IEEE80211_IF_TYPE_STA
) {
1782 fc
|= IEEE80211_FCTL_TODS
;
1784 memcpy(hdr
.addr1
, sdata
->u
.sta
.bssid
, ETH_ALEN
);
1785 memcpy(hdr
.addr2
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
1786 memcpy(hdr
.addr3
, skb
->data
, ETH_ALEN
);
1788 } else if (sdata
->type
== IEEE80211_IF_TYPE_IBSS
) {
1790 memcpy(hdr
.addr1
, skb
->data
, ETH_ALEN
);
1791 memcpy(hdr
.addr2
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
1792 memcpy(hdr
.addr3
, sdata
->u
.sta
.bssid
, ETH_ALEN
);
1799 /* receiver is QoS enabled, use a QoS type frame */
1800 sta
= sta_info_get(local
, hdr
.addr1
);
1802 if (sta
->flags
& WLAN_STA_WME
) {
1803 fc
|= IEEE80211_STYPE_QOS_DATA
;
1809 hdr
.frame_control
= cpu_to_le16(fc
);
1810 hdr
.duration_id
= 0;
1813 skip_header_bytes
= ETH_HLEN
;
1814 if (ethertype
== ETH_P_AARP
|| ethertype
== ETH_P_IPX
) {
1815 encaps_data
= bridge_tunnel_header
;
1816 encaps_len
= sizeof(bridge_tunnel_header
);
1817 skip_header_bytes
-= 2;
1818 } else if (ethertype
>= 0x600) {
1819 encaps_data
= rfc1042_header
;
1820 encaps_len
= sizeof(rfc1042_header
);
1821 skip_header_bytes
-= 2;
1827 skb_pull(skb
, skip_header_bytes
);
1828 nh_pos
-= skip_header_bytes
;
1829 h_pos
-= skip_header_bytes
;
1831 /* TODO: implement support for fragments so that there is no need to
1832 * reallocate and copy payload; it might be enough to support one
1833 * extra fragment that would be copied in the beginning of the frame
1834 * data.. anyway, it would be nice to include this into skb structure
1837 * There are few options for this:
1838 * use skb->cb as an extra space for 802.11 header
1839 * allocate new buffer if not enough headroom
1840 * make sure that there is enough headroom in every skb by increasing
1841 * build in headroom in __dev_alloc_skb() (linux/skbuff.h) and
1842 * alloc_skb() (net/core/skbuff.c)
1844 head_need
= hdrlen
+ encaps_len
+ local
->tx_headroom
;
1845 head_need
-= skb_headroom(skb
);
1847 /* We are going to modify skb data, so make a copy of it if happens to
1848 * be cloned. This could happen, e.g., with Linux bridge code passing
1849 * us broadcast frames. */
1851 if (head_need
> 0 || skb_cloned(skb
)) {
1853 printk(KERN_DEBUG
"%s: need to reallocate buffer for %d bytes "
1854 "of headroom\n", dev
->name
, head_need
);
1857 if (skb_cloned(skb
))
1858 I802_DEBUG_INC(local
->tx_expand_skb_head_cloned
);
1860 I802_DEBUG_INC(local
->tx_expand_skb_head
);
1861 /* Since we have to reallocate the buffer, make sure that there
1862 * is enough room for possible WEP IV/ICV and TKIP (8 bytes
1863 * before payload and 12 after). */
1864 if (pskb_expand_head(skb
, (head_need
> 0 ? head_need
+ 8 : 8),
1866 printk(KERN_DEBUG
"%s: failed to reallocate TX buffer"
1873 memcpy(skb_push(skb
, encaps_len
), encaps_data
, encaps_len
);
1874 nh_pos
+= encaps_len
;
1875 h_pos
+= encaps_len
;
1877 memcpy(skb_push(skb
, hdrlen
), &hdr
, hdrlen
);
1881 pkt_data
= (struct ieee80211_tx_packet_data
*)skb
->cb
;
1882 memset(pkt_data
, 0, sizeof(struct ieee80211_tx_packet_data
));
1883 pkt_data
->ifindex
= dev
->ifindex
;
1884 pkt_data
->mgmt_iface
= (sdata
->type
== IEEE80211_IF_TYPE_MGMT
);
1885 pkt_data
->do_not_encrypt
= no_encrypt
;
1887 skb
->dev
= local
->mdev
;
1888 sdata
->stats
.tx_packets
++;
1889 sdata
->stats
.tx_bytes
+= skb
->len
;
1891 /* Update skb pointers to various headers since this modified frame
1892 * is going to go through Linux networking code that may potentially
1893 * need things like pointer to IP header. */
1894 skb_set_mac_header(skb
, 0);
1895 skb_set_network_header(skb
, nh_pos
);
1896 skb_set_transport_header(skb
, h_pos
);
1898 dev
->trans_start
= jiffies
;
1899 dev_queue_xmit(skb
);
1912 * This is the transmit routine for the 802.11 type interfaces
1913 * called by upper layers of the linux networking
1914 * stack when it has a frame to transmit
1917 ieee80211_mgmt_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1919 struct ieee80211_sub_if_data
*sdata
;
1920 struct ieee80211_tx_packet_data
*pkt_data
;
1921 struct ieee80211_hdr
*hdr
;
1924 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1926 if (skb
->len
< 10) {
1931 if (skb_headroom(skb
) < sdata
->local
->tx_headroom
) {
1932 if (pskb_expand_head(skb
, sdata
->local
->tx_headroom
,
1939 hdr
= (struct ieee80211_hdr
*) skb
->data
;
1940 fc
= le16_to_cpu(hdr
->frame_control
);
1942 pkt_data
= (struct ieee80211_tx_packet_data
*) skb
->cb
;
1943 memset(pkt_data
, 0, sizeof(struct ieee80211_tx_packet_data
));
1944 pkt_data
->ifindex
= sdata
->dev
->ifindex
;
1945 pkt_data
->mgmt_iface
= (sdata
->type
== IEEE80211_IF_TYPE_MGMT
);
1947 skb
->priority
= 20; /* use hardcoded priority for mgmt TX queue */
1948 skb
->dev
= sdata
->local
->mdev
;
1951 * We're using the protocol field of the the frame control header
1952 * to request TX callback for hostapd. BIT(1) is checked.
1954 if ((fc
& BIT(1)) == BIT(1)) {
1955 pkt_data
->req_tx_status
= 1;
1957 hdr
->frame_control
= cpu_to_le16(fc
);
1960 pkt_data
->do_not_encrypt
= !(fc
& IEEE80211_FCTL_PROTECTED
);
1962 sdata
->stats
.tx_packets
++;
1963 sdata
->stats
.tx_bytes
+= skb
->len
;
1965 dev_queue_xmit(skb
);
1971 static void ieee80211_beacon_add_tim(struct ieee80211_local
*local
,
1972 struct ieee80211_if_ap
*bss
,
1973 struct sk_buff
*skb
)
1977 int i
, have_bits
= 0, n1
, n2
;
1979 /* Generate bitmap for TIM only if there are any STAs in power save
1981 spin_lock_bh(&local
->sta_lock
);
1982 if (atomic_read(&bss
->num_sta_ps
) > 0)
1983 /* in the hope that this is faster than
1984 * checking byte-for-byte */
1985 have_bits
= !bitmap_empty((unsigned long*)bss
->tim
,
1986 IEEE80211_MAX_AID
+1);
1988 if (bss
->dtim_count
== 0)
1989 bss
->dtim_count
= bss
->dtim_period
- 1;
1993 tim
= pos
= (u8
*) skb_put(skb
, 6);
1994 *pos
++ = WLAN_EID_TIM
;
1996 *pos
++ = bss
->dtim_count
;
1997 *pos
++ = bss
->dtim_period
;
1999 if (bss
->dtim_count
== 0 && !skb_queue_empty(&bss
->ps_bc_buf
))
2003 /* Find largest even number N1 so that bits numbered 1 through
2004 * (N1 x 8) - 1 in the bitmap are 0 and number N2 so that bits
2005 * (N2 + 1) x 8 through 2007 are 0. */
2007 for (i
= 0; i
< IEEE80211_MAX_TIM_LEN
; i
++) {
2014 for (i
= IEEE80211_MAX_TIM_LEN
- 1; i
>= n1
; i
--) {
2021 /* Bitmap control */
2023 /* Part Virt Bitmap */
2024 memcpy(pos
, bss
->tim
+ n1
, n2
- n1
+ 1);
2026 tim
[1] = n2
- n1
+ 4;
2027 skb_put(skb
, n2
- n1
);
2029 *pos
++ = aid0
; /* Bitmap control */
2030 *pos
++ = 0; /* Part Virt Bitmap */
2032 spin_unlock_bh(&local
->sta_lock
);
2036 struct sk_buff
* ieee80211_beacon_get(struct ieee80211_hw
*hw
, int if_id
,
2037 struct ieee80211_tx_control
*control
)
2039 struct ieee80211_local
*local
= hw_to_local(hw
);
2040 struct sk_buff
*skb
;
2041 struct net_device
*bdev
;
2042 struct ieee80211_sub_if_data
*sdata
= NULL
;
2043 struct ieee80211_if_ap
*ap
= NULL
;
2044 struct ieee80211_rate
*rate
;
2045 struct rate_control_extra extra
;
2046 u8
*b_head
, *b_tail
;
2049 bdev
= dev_get_by_index(if_id
);
2051 sdata
= IEEE80211_DEV_TO_SUB_IF(bdev
);
2056 if (!ap
|| sdata
->type
!= IEEE80211_IF_TYPE_AP
||
2058 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2059 if (net_ratelimit())
2060 printk(KERN_DEBUG
"no beacon data avail for idx=%d "
2061 "(%s)\n", if_id
, bdev
? bdev
->name
: "N/A");
2062 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
2066 /* Assume we are generating the normal beacon locally */
2067 b_head
= ap
->beacon_head
;
2068 b_tail
= ap
->beacon_tail
;
2069 bh_len
= ap
->beacon_head_len
;
2070 bt_len
= ap
->beacon_tail_len
;
2072 skb
= dev_alloc_skb(local
->tx_headroom
+
2073 bh_len
+ bt_len
+ 256 /* maximum TIM len */);
2077 skb_reserve(skb
, local
->tx_headroom
);
2078 memcpy(skb_put(skb
, bh_len
), b_head
, bh_len
);
2080 ieee80211_include_sequence(sdata
, (struct ieee80211_hdr
*)skb
->data
);
2082 ieee80211_beacon_add_tim(local
, ap
, skb
);
2085 memcpy(skb_put(skb
, bt_len
), b_tail
, bt_len
);
2089 memset(&extra
, 0, sizeof(extra
));
2090 extra
.mode
= local
->oper_hw_mode
;
2092 rate
= rate_control_get_rate(local
, local
->mdev
, skb
, &extra
);
2094 if (net_ratelimit()) {
2095 printk(KERN_DEBUG
"%s: ieee80211_beacon_get: no rate "
2096 "found\n", local
->mdev
->name
);
2102 control
->tx_rate
= (local
->short_preamble
&&
2103 (rate
->flags
& IEEE80211_RATE_PREAMBLE2
)) ?
2104 rate
->val2
: rate
->val
;
2105 control
->antenna_sel_tx
= local
->hw
.conf
.antenna_sel_tx
;
2106 control
->power_level
= local
->hw
.conf
.power_level
;
2107 control
->flags
|= IEEE80211_TXCTL_NO_ACK
;
2108 control
->retry_limit
= 1;
2109 control
->flags
|= IEEE80211_TXCTL_CLEAR_DST_MASK
;
2115 EXPORT_SYMBOL(ieee80211_beacon_get
);
2117 __le16
ieee80211_rts_duration(struct ieee80211_hw
*hw
,
2119 const struct ieee80211_tx_control
*frame_txctl
)
2121 struct ieee80211_local
*local
= hw_to_local(hw
);
2122 struct ieee80211_rate
*rate
;
2123 int short_preamble
= local
->short_preamble
;
2127 rate
= frame_txctl
->rts_rate
;
2128 erp
= !!(rate
->flags
& IEEE80211_RATE_ERP
);
2131 dur
= ieee80211_frame_duration(local
, 10, rate
->rate
,
2132 erp
, short_preamble
);
2133 /* Data frame duration */
2134 dur
+= ieee80211_frame_duration(local
, frame_len
, rate
->rate
,
2135 erp
, short_preamble
);
2137 dur
+= ieee80211_frame_duration(local
, 10, rate
->rate
,
2138 erp
, short_preamble
);
2140 return cpu_to_le16(dur
);
2142 EXPORT_SYMBOL(ieee80211_rts_duration
);
2145 __le16
ieee80211_ctstoself_duration(struct ieee80211_hw
*hw
,
2147 const struct ieee80211_tx_control
*frame_txctl
)
2149 struct ieee80211_local
*local
= hw_to_local(hw
);
2150 struct ieee80211_rate
*rate
;
2151 int short_preamble
= local
->short_preamble
;
2155 rate
= frame_txctl
->rts_rate
;
2156 erp
= !!(rate
->flags
& IEEE80211_RATE_ERP
);
2158 /* Data frame duration */
2159 dur
= ieee80211_frame_duration(local
, frame_len
, rate
->rate
,
2160 erp
, short_preamble
);
2161 if (!(frame_txctl
->flags
& IEEE80211_TXCTL_NO_ACK
)) {
2163 dur
+= ieee80211_frame_duration(local
, 10, rate
->rate
,
2164 erp
, short_preamble
);
2167 return cpu_to_le16(dur
);
2169 EXPORT_SYMBOL(ieee80211_ctstoself_duration
);
2171 void ieee80211_rts_get(struct ieee80211_hw
*hw
,
2172 const void *frame
, size_t frame_len
,
2173 const struct ieee80211_tx_control
*frame_txctl
,
2174 struct ieee80211_rts
*rts
)
2176 const struct ieee80211_hdr
*hdr
= frame
;
2179 fctl
= IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_RTS
;
2180 rts
->frame_control
= cpu_to_le16(fctl
);
2181 rts
->duration
= ieee80211_rts_duration(hw
, frame_len
, frame_txctl
);
2182 memcpy(rts
->ra
, hdr
->addr1
, sizeof(rts
->ra
));
2183 memcpy(rts
->ta
, hdr
->addr2
, sizeof(rts
->ta
));
2185 EXPORT_SYMBOL(ieee80211_rts_get
);
2187 void ieee80211_ctstoself_get(struct ieee80211_hw
*hw
,
2188 const void *frame
, size_t frame_len
,
2189 const struct ieee80211_tx_control
*frame_txctl
,
2190 struct ieee80211_cts
*cts
)
2192 const struct ieee80211_hdr
*hdr
= frame
;
2195 fctl
= IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_CTS
;
2196 cts
->frame_control
= cpu_to_le16(fctl
);
2197 cts
->duration
= ieee80211_ctstoself_duration(hw
, frame_len
, frame_txctl
);
2198 memcpy(cts
->ra
, hdr
->addr1
, sizeof(cts
->ra
));
2200 EXPORT_SYMBOL(ieee80211_ctstoself_get
);
2203 ieee80211_get_buffered_bc(struct ieee80211_hw
*hw
, int if_id
,
2204 struct ieee80211_tx_control
*control
)
2206 struct ieee80211_local
*local
= hw_to_local(hw
);
2207 struct sk_buff
*skb
;
2208 struct sta_info
*sta
;
2209 ieee80211_tx_handler
*handler
;
2210 struct ieee80211_txrx_data tx
;
2211 ieee80211_txrx_result res
= TXRX_DROP
;
2212 struct net_device
*bdev
;
2213 struct ieee80211_sub_if_data
*sdata
;
2214 struct ieee80211_if_ap
*bss
= NULL
;
2216 bdev
= dev_get_by_index(if_id
);
2218 sdata
= IEEE80211_DEV_TO_SUB_IF(bdev
);
2222 if (!bss
|| sdata
->type
!= IEEE80211_IF_TYPE_AP
|| !bss
->beacon_head
)
2225 if (bss
->dtim_count
!= 0)
2226 return NULL
; /* send buffered bc/mc only after DTIM beacon */
2227 memset(control
, 0, sizeof(*control
));
2229 skb
= skb_dequeue(&bss
->ps_bc_buf
);
2232 local
->total_ps_buffered
--;
2234 if (!skb_queue_empty(&bss
->ps_bc_buf
) && skb
->len
>= 2) {
2235 struct ieee80211_hdr
*hdr
=
2236 (struct ieee80211_hdr
*) skb
->data
;
2237 /* more buffered multicast/broadcast frames ==> set
2238 * MoreData flag in IEEE 802.11 header to inform PS
2240 hdr
->frame_control
|=
2241 cpu_to_le16(IEEE80211_FCTL_MOREDATA
);
2244 if (ieee80211_tx_prepare(&tx
, skb
, local
->mdev
, control
) == 0)
2246 dev_kfree_skb_any(skb
);
2249 tx
.u
.tx
.ps_buffered
= 1;
2251 for (handler
= local
->tx_handlers
; *handler
!= NULL
; handler
++) {
2252 res
= (*handler
)(&tx
);
2253 if (res
== TXRX_DROP
|| res
== TXRX_QUEUED
)
2257 skb
= tx
.skb
; /* handlers are allowed to change skb */
2259 if (res
== TXRX_DROP
) {
2260 I802_DEBUG_INC(local
->tx_handlers_drop
);
2263 } else if (res
== TXRX_QUEUED
) {
2264 I802_DEBUG_INC(local
->tx_handlers_queued
);
2273 EXPORT_SYMBOL(ieee80211_get_buffered_bc
);
2275 static int __ieee80211_if_config(struct net_device
*dev
,
2276 struct sk_buff
*beacon
,
2277 struct ieee80211_tx_control
*control
)
2279 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2280 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2281 struct ieee80211_if_conf conf
;
2282 static u8 scan_bssid
[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2284 if (!local
->ops
->config_interface
|| !netif_running(dev
))
2287 memset(&conf
, 0, sizeof(conf
));
2288 conf
.type
= sdata
->type
;
2289 if (sdata
->type
== IEEE80211_IF_TYPE_STA
||
2290 sdata
->type
== IEEE80211_IF_TYPE_IBSS
) {
2291 if (local
->sta_scanning
&&
2292 local
->scan_dev
== dev
)
2293 conf
.bssid
= scan_bssid
;
2295 conf
.bssid
= sdata
->u
.sta
.bssid
;
2296 conf
.ssid
= sdata
->u
.sta
.ssid
;
2297 conf
.ssid_len
= sdata
->u
.sta
.ssid_len
;
2298 conf
.generic_elem
= sdata
->u
.sta
.extra_ie
;
2299 conf
.generic_elem_len
= sdata
->u
.sta
.extra_ie_len
;
2300 } else if (sdata
->type
== IEEE80211_IF_TYPE_AP
) {
2301 conf
.ssid
= sdata
->u
.ap
.ssid
;
2302 conf
.ssid_len
= sdata
->u
.ap
.ssid_len
;
2303 conf
.generic_elem
= sdata
->u
.ap
.generic_elem
;
2304 conf
.generic_elem_len
= sdata
->u
.ap
.generic_elem_len
;
2305 conf
.beacon
= beacon
;
2306 conf
.beacon_control
= control
;
2308 return local
->ops
->config_interface(local_to_hw(local
),
2309 dev
->ifindex
, &conf
);
2312 int ieee80211_if_config(struct net_device
*dev
)
2314 return __ieee80211_if_config(dev
, NULL
, NULL
);
2317 int ieee80211_if_config_beacon(struct net_device
*dev
)
2319 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2320 struct ieee80211_tx_control control
;
2321 struct sk_buff
*skb
;
2323 if (!(local
->hw
.flags
& IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE
))
2325 skb
= ieee80211_beacon_get(local_to_hw(local
), dev
->ifindex
, &control
);
2328 return __ieee80211_if_config(dev
, skb
, &control
);
2331 int ieee80211_hw_config(struct ieee80211_local
*local
)
2333 struct ieee80211_hw_mode
*mode
;
2334 struct ieee80211_channel
*chan
;
2337 if (local
->sta_scanning
) {
2338 chan
= local
->scan_channel
;
2339 mode
= local
->scan_hw_mode
;
2341 chan
= local
->oper_channel
;
2342 mode
= local
->oper_hw_mode
;
2345 local
->hw
.conf
.channel
= chan
->chan
;
2346 local
->hw
.conf
.channel_val
= chan
->val
;
2347 local
->hw
.conf
.power_level
= chan
->power_level
;
2348 local
->hw
.conf
.freq
= chan
->freq
;
2349 local
->hw
.conf
.phymode
= mode
->mode
;
2350 local
->hw
.conf
.antenna_max
= chan
->antenna_max
;
2351 local
->hw
.conf
.chan
= chan
;
2352 local
->hw
.conf
.mode
= mode
;
2354 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2355 printk(KERN_DEBUG
"HW CONFIG: channel=%d freq=%d "
2356 "phymode=%d\n", local
->hw
.conf
.channel
, local
->hw
.conf
.freq
,
2357 local
->hw
.conf
.phymode
);
2358 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
2360 if (local
->ops
->config
)
2361 ret
= local
->ops
->config(local_to_hw(local
), &local
->hw
.conf
);
2367 static int ieee80211_change_mtu(struct net_device
*dev
, int new_mtu
)
2369 /* FIX: what would be proper limits for MTU?
2370 * This interface uses 802.3 frames. */
2371 if (new_mtu
< 256 || new_mtu
> IEEE80211_MAX_DATA_LEN
- 24 - 6) {
2372 printk(KERN_WARNING
"%s: invalid MTU %d\n",
2373 dev
->name
, new_mtu
);
2377 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2378 printk(KERN_DEBUG
"%s: setting MTU %d\n", dev
->name
, new_mtu
);
2379 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
2385 static int ieee80211_change_mtu_apdev(struct net_device
*dev
, int new_mtu
)
2387 /* FIX: what would be proper limits for MTU?
2388 * This interface uses 802.11 frames. */
2389 if (new_mtu
< 256 || new_mtu
> IEEE80211_MAX_DATA_LEN
) {
2390 printk(KERN_WARNING
"%s: invalid MTU %d\n",
2391 dev
->name
, new_mtu
);
2395 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2396 printk(KERN_DEBUG
"%s: setting MTU %d\n", dev
->name
, new_mtu
);
2397 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
2402 enum netif_tx_lock_class
{
2407 static inline void netif_tx_lock_nested(struct net_device
*dev
, int subclass
)
2409 spin_lock_nested(&dev
->_xmit_lock
, subclass
);
2410 dev
->xmit_lock_owner
= smp_processor_id();
2413 static void ieee80211_set_multicast_list(struct net_device
*dev
)
2415 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2416 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2417 unsigned short flags
;
2419 netif_tx_lock_nested(local
->mdev
, TX_LOCK_MASTER
);
2420 if (((dev
->flags
& IFF_ALLMULTI
) != 0) ^ (sdata
->allmulti
!= 0)) {
2421 if (sdata
->allmulti
) {
2422 sdata
->allmulti
= 0;
2423 local
->iff_allmultis
--;
2425 sdata
->allmulti
= 1;
2426 local
->iff_allmultis
++;
2429 if (((dev
->flags
& IFF_PROMISC
) != 0) ^ (sdata
->promisc
!= 0)) {
2430 if (sdata
->promisc
) {
2432 local
->iff_promiscs
--;
2435 local
->iff_promiscs
++;
2438 if (dev
->mc_count
!= sdata
->mc_count
) {
2439 local
->mc_count
= local
->mc_count
- sdata
->mc_count
+
2441 sdata
->mc_count
= dev
->mc_count
;
2443 if (local
->ops
->set_multicast_list
) {
2444 flags
= local
->mdev
->flags
;
2445 if (local
->iff_allmultis
)
2446 flags
|= IFF_ALLMULTI
;
2447 if (local
->iff_promiscs
)
2448 flags
|= IFF_PROMISC
;
2449 read_lock(&local
->sub_if_lock
);
2450 local
->ops
->set_multicast_list(local_to_hw(local
), flags
,
2452 read_unlock(&local
->sub_if_lock
);
2454 netif_tx_unlock(local
->mdev
);
2457 struct dev_mc_list
*ieee80211_get_mc_list_item(struct ieee80211_hw
*hw
,
2458 struct dev_mc_list
*prev
,
2461 struct ieee80211_local
*local
= hw_to_local(hw
);
2462 struct ieee80211_sub_if_data
*sdata
= *ptr
;
2463 struct dev_mc_list
*mc
;
2469 if (!prev
|| !prev
->next
) {
2471 sdata
= list_entry(sdata
->list
.next
,
2472 struct ieee80211_sub_if_data
, list
);
2474 sdata
= list_entry(local
->sub_if_list
.next
,
2475 struct ieee80211_sub_if_data
, list
);
2476 if (&sdata
->list
!= &local
->sub_if_list
)
2477 mc
= sdata
->dev
->mc_list
;
2486 EXPORT_SYMBOL(ieee80211_get_mc_list_item
);
2488 static struct net_device_stats
*ieee80211_get_stats(struct net_device
*dev
)
2490 struct ieee80211_sub_if_data
*sdata
;
2491 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2492 return &(sdata
->stats
);
2495 static void ieee80211_if_shutdown(struct net_device
*dev
)
2497 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2498 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2501 switch (sdata
->type
) {
2502 case IEEE80211_IF_TYPE_STA
:
2503 case IEEE80211_IF_TYPE_IBSS
:
2504 sdata
->u
.sta
.state
= IEEE80211_DISABLED
;
2505 del_timer_sync(&sdata
->u
.sta
.timer
);
2506 skb_queue_purge(&sdata
->u
.sta
.skb_queue
);
2507 if (!local
->ops
->hw_scan
&&
2508 local
->scan_dev
== sdata
->dev
) {
2509 local
->sta_scanning
= 0;
2510 cancel_delayed_work(&local
->scan_work
);
2512 flush_workqueue(local
->hw
.workqueue
);
2517 static inline int identical_mac_addr_allowed(int type1
, int type2
)
2519 return (type1
== IEEE80211_IF_TYPE_MNTR
||
2520 type2
== IEEE80211_IF_TYPE_MNTR
||
2521 (type1
== IEEE80211_IF_TYPE_AP
&&
2522 type2
== IEEE80211_IF_TYPE_WDS
) ||
2523 (type1
== IEEE80211_IF_TYPE_WDS
&&
2524 (type2
== IEEE80211_IF_TYPE_WDS
||
2525 type2
== IEEE80211_IF_TYPE_AP
)) ||
2526 (type1
== IEEE80211_IF_TYPE_AP
&&
2527 type2
== IEEE80211_IF_TYPE_VLAN
) ||
2528 (type1
== IEEE80211_IF_TYPE_VLAN
&&
2529 (type2
== IEEE80211_IF_TYPE_AP
||
2530 type2
== IEEE80211_IF_TYPE_VLAN
)));
2533 static int ieee80211_master_open(struct net_device
*dev
)
2535 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2536 struct ieee80211_sub_if_data
*sdata
;
2537 int res
= -EOPNOTSUPP
;
2539 read_lock(&local
->sub_if_lock
);
2540 list_for_each_entry(sdata
, &local
->sub_if_list
, list
) {
2541 if (sdata
->dev
!= dev
&& netif_running(sdata
->dev
)) {
2546 read_unlock(&local
->sub_if_lock
);
2550 static int ieee80211_master_stop(struct net_device
*dev
)
2552 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2553 struct ieee80211_sub_if_data
*sdata
;
2555 read_lock(&local
->sub_if_lock
);
2556 list_for_each_entry(sdata
, &local
->sub_if_list
, list
)
2557 if (sdata
->dev
!= dev
&& netif_running(sdata
->dev
))
2558 dev_close(sdata
->dev
);
2559 read_unlock(&local
->sub_if_lock
);
2564 static int ieee80211_mgmt_open(struct net_device
*dev
)
2566 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2568 if (!netif_running(local
->mdev
))
2573 static int ieee80211_mgmt_stop(struct net_device
*dev
)
2578 /* Check if running monitor interfaces should go to a "soft monitor" mode
2579 * and switch them if necessary. */
2580 static inline void ieee80211_start_soft_monitor(struct ieee80211_local
*local
)
2582 struct ieee80211_if_init_conf conf
;
2584 if (local
->open_count
&& local
->open_count
== local
->monitors
&&
2585 !(local
->hw
.flags
& IEEE80211_HW_MONITOR_DURING_OPER
) &&
2586 local
->ops
->remove_interface
) {
2588 conf
.type
= IEEE80211_IF_TYPE_MNTR
;
2589 conf
.mac_addr
= NULL
;
2590 local
->ops
->remove_interface(local_to_hw(local
), &conf
);
2594 /* Check if running monitor interfaces should go to a "hard monitor" mode
2595 * and switch them if necessary. */
2596 static void ieee80211_start_hard_monitor(struct ieee80211_local
*local
)
2598 struct ieee80211_if_init_conf conf
;
2600 if (local
->open_count
&& local
->open_count
== local
->monitors
&&
2601 !(local
->hw
.flags
& IEEE80211_HW_MONITOR_DURING_OPER
)) {
2603 conf
.type
= IEEE80211_IF_TYPE_MNTR
;
2604 conf
.mac_addr
= NULL
;
2605 local
->ops
->add_interface(local_to_hw(local
), &conf
);
2609 static int ieee80211_open(struct net_device
*dev
)
2611 struct ieee80211_sub_if_data
*sdata
, *nsdata
;
2612 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2613 struct ieee80211_if_init_conf conf
;
2616 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2617 read_lock(&local
->sub_if_lock
);
2618 list_for_each_entry(nsdata
, &local
->sub_if_list
, list
) {
2619 struct net_device
*ndev
= nsdata
->dev
;
2621 if (ndev
!= dev
&& ndev
!= local
->mdev
&& netif_running(ndev
) &&
2622 compare_ether_addr(dev
->dev_addr
, ndev
->dev_addr
) == 0 &&
2623 !identical_mac_addr_allowed(sdata
->type
, nsdata
->type
)) {
2624 read_unlock(&local
->sub_if_lock
);
2628 read_unlock(&local
->sub_if_lock
);
2630 if (sdata
->type
== IEEE80211_IF_TYPE_WDS
&&
2631 is_zero_ether_addr(sdata
->u
.wds
.remote_addr
))
2634 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
&& local
->open_count
&&
2635 !(local
->hw
.flags
& IEEE80211_HW_MONITOR_DURING_OPER
)) {
2636 /* run the interface in a "soft monitor" mode */
2638 local
->open_count
++;
2639 local
->hw
.conf
.flags
|= IEEE80211_CONF_RADIOTAP
;
2642 ieee80211_start_soft_monitor(local
);
2644 conf
.if_id
= dev
->ifindex
;
2645 conf
.type
= sdata
->type
;
2646 conf
.mac_addr
= dev
->dev_addr
;
2647 res
= local
->ops
->add_interface(local_to_hw(local
), &conf
);
2649 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
)
2650 ieee80211_start_hard_monitor(local
);
2654 if (local
->open_count
== 0) {
2656 tasklet_enable(&local
->tx_pending_tasklet
);
2657 tasklet_enable(&local
->tasklet
);
2658 if (local
->ops
->open
)
2659 res
= local
->ops
->open(local_to_hw(local
));
2661 res
= dev_open(local
->mdev
);
2663 if (local
->ops
->stop
)
2664 local
->ops
->stop(local_to_hw(local
));
2666 res
= ieee80211_hw_config(local
);
2667 if (res
&& local
->ops
->stop
)
2668 local
->ops
->stop(local_to_hw(local
));
2669 else if (!res
&& local
->apdev
)
2670 dev_open(local
->apdev
);
2674 if (local
->ops
->remove_interface
)
2675 local
->ops
->remove_interface(local_to_hw(local
),
2680 local
->open_count
++;
2682 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
) {
2684 local
->hw
.conf
.flags
|= IEEE80211_CONF_RADIOTAP
;
2686 ieee80211_if_config(dev
);
2688 if (sdata
->type
== IEEE80211_IF_TYPE_STA
&&
2689 !local
->user_space_mlme
)
2690 netif_carrier_off(dev
);
2692 netif_carrier_on(dev
);
2694 netif_start_queue(dev
);
2699 static int ieee80211_stop(struct net_device
*dev
)
2701 struct ieee80211_sub_if_data
*sdata
;
2702 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2704 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2706 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
&&
2707 local
->open_count
> 1 &&
2708 !(local
->hw
.flags
& IEEE80211_HW_MONITOR_DURING_OPER
)) {
2709 /* remove "soft monitor" interface */
2710 local
->open_count
--;
2712 if (!local
->monitors
)
2713 local
->hw
.conf
.flags
&= ~IEEE80211_CONF_RADIOTAP
;
2717 netif_stop_queue(dev
);
2718 ieee80211_if_shutdown(dev
);
2720 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
) {
2722 if (!local
->monitors
)
2723 local
->hw
.conf
.flags
&= ~IEEE80211_CONF_RADIOTAP
;
2726 local
->open_count
--;
2727 if (local
->open_count
== 0) {
2728 if (netif_running(local
->mdev
))
2729 dev_close(local
->mdev
);
2731 dev_close(local
->apdev
);
2732 if (local
->ops
->stop
)
2733 local
->ops
->stop(local_to_hw(local
));
2734 tasklet_disable(&local
->tx_pending_tasklet
);
2735 tasklet_disable(&local
->tasklet
);
2737 if (local
->ops
->remove_interface
) {
2738 struct ieee80211_if_init_conf conf
;
2740 conf
.if_id
= dev
->ifindex
;
2741 conf
.type
= sdata
->type
;
2742 conf
.mac_addr
= dev
->dev_addr
;
2743 local
->ops
->remove_interface(local_to_hw(local
), &conf
);
2746 ieee80211_start_hard_monitor(local
);
2752 static int header_parse_80211(struct sk_buff
*skb
, unsigned char *haddr
)
2754 memcpy(haddr
, skb_mac_header(skb
) + 10, ETH_ALEN
); /* addr2 */
2758 struct ieee80211_rate
*
2759 ieee80211_get_rate(struct ieee80211_local
*local
, int phymode
, int hw_rate
)
2761 struct ieee80211_hw_mode
*mode
;
2764 list_for_each_entry(mode
, &local
->modes_list
, list
) {
2765 if (mode
->mode
!= phymode
)
2767 for (r
= 0; r
< mode
->num_rates
; r
++) {
2768 struct ieee80211_rate
*rate
= &mode
->rates
[r
];
2769 if (rate
->val
== hw_rate
||
2770 (rate
->flags
& IEEE80211_RATE_PREAMBLE2
&&
2771 rate
->val2
== hw_rate
))
2780 ieee80211_fill_frame_info(struct ieee80211_local
*local
,
2781 struct ieee80211_frame_info
*fi
,
2782 struct ieee80211_rx_status
*status
)
2786 struct ieee80211_rate
*rate
;
2788 jiffies_to_timespec(jiffies
, &ts
);
2789 fi
->hosttime
= cpu_to_be64((u64
) ts
.tv_sec
* 1000000 +
2791 fi
->mactime
= cpu_to_be64(status
->mactime
);
2792 switch (status
->phymode
) {
2793 case MODE_IEEE80211A
:
2794 fi
->phytype
= htonl(ieee80211_phytype_ofdm_dot11_a
);
2796 case MODE_IEEE80211B
:
2797 fi
->phytype
= htonl(ieee80211_phytype_dsss_dot11_b
);
2799 case MODE_IEEE80211G
:
2800 fi
->phytype
= htonl(ieee80211_phytype_pbcc_dot11_g
);
2802 case MODE_ATHEROS_TURBO
:
2804 htonl(ieee80211_phytype_dsss_dot11_turbo
);
2807 fi
->phytype
= htonl(0xAAAAAAAA);
2810 fi
->channel
= htonl(status
->channel
);
2811 rate
= ieee80211_get_rate(local
, status
->phymode
,
2814 fi
->datarate
= htonl(rate
->rate
);
2815 if (rate
->flags
& IEEE80211_RATE_PREAMBLE2
) {
2816 if (status
->rate
== rate
->val
)
2817 fi
->preamble
= htonl(2); /* long */
2818 else if (status
->rate
== rate
->val2
)
2819 fi
->preamble
= htonl(1); /* short */
2821 fi
->preamble
= htonl(0);
2823 fi
->datarate
= htonl(0);
2824 fi
->preamble
= htonl(0);
2827 fi
->antenna
= htonl(status
->antenna
);
2828 fi
->priority
= htonl(0xffffffff); /* no clue */
2829 fi
->ssi_type
= htonl(ieee80211_ssi_raw
);
2830 fi
->ssi_signal
= htonl(status
->ssi
);
2831 fi
->ssi_noise
= 0x00000000;
2834 /* clear everything because we really don't know.
2835 * the msg_type field isn't present on monitor frames
2836 * so we don't know whether it will be present or not,
2837 * but it's ok to not clear it since it'll be assigned
2839 memset(fi
, 0, sizeof(*fi
) - sizeof(fi
->msg_type
));
2841 fi
->ssi_type
= htonl(ieee80211_ssi_none
);
2843 fi
->version
= htonl(IEEE80211_FI_VERSION
);
2844 fi
->length
= cpu_to_be32(sizeof(*fi
) - sizeof(fi
->msg_type
));
2847 /* this routine is actually not just for this, but also
2848 * for pushing fake 'management' frames into userspace.
2849 * it shall be replaced by a netlink-based system. */
2851 ieee80211_rx_mgmt(struct ieee80211_local
*local
, struct sk_buff
*skb
,
2852 struct ieee80211_rx_status
*status
, u32 msg_type
)
2854 struct ieee80211_frame_info
*fi
;
2855 const size_t hlen
= sizeof(struct ieee80211_frame_info
);
2856 struct ieee80211_sub_if_data
*sdata
;
2858 skb
->dev
= local
->apdev
;
2860 sdata
= IEEE80211_DEV_TO_SUB_IF(local
->apdev
);
2862 if (skb_headroom(skb
) < hlen
) {
2863 I802_DEBUG_INC(local
->rx_expand_skb_head
);
2864 if (pskb_expand_head(skb
, hlen
, 0, GFP_ATOMIC
)) {
2870 fi
= (struct ieee80211_frame_info
*) skb_push(skb
, hlen
);
2872 ieee80211_fill_frame_info(local
, fi
, status
);
2873 fi
->msg_type
= htonl(msg_type
);
2875 sdata
->stats
.rx_packets
++;
2876 sdata
->stats
.rx_bytes
+= skb
->len
;
2878 skb_set_mac_header(skb
, 0);
2879 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
2880 skb
->pkt_type
= PACKET_OTHERHOST
;
2881 skb
->protocol
= htons(ETH_P_802_2
);
2882 memset(skb
->cb
, 0, sizeof(skb
->cb
));
2886 int ieee80211_radar_status(struct ieee80211_hw
*hw
, int channel
,
2887 int radar
, int radar_type
)
2889 struct sk_buff
*skb
;
2890 struct ieee80211_radar_info
*msg
;
2891 struct ieee80211_local
*local
= hw_to_local(hw
);
2896 skb
= dev_alloc_skb(sizeof(struct ieee80211_frame_info
) +
2897 sizeof(struct ieee80211_radar_info
));
2901 skb_reserve(skb
, sizeof(struct ieee80211_frame_info
));
2903 msg
= (struct ieee80211_radar_info
*)
2904 skb_put(skb
, sizeof(struct ieee80211_radar_info
));
2905 msg
->channel
= channel
;
2907 msg
->radar_type
= radar_type
;
2909 ieee80211_rx_mgmt(local
, skb
, NULL
, ieee80211_msg_radar
);
2912 EXPORT_SYMBOL(ieee80211_radar_status
);
2915 static ieee80211_txrx_result
2916 ieee80211_tx_h_load_stats(struct ieee80211_txrx_data
*tx
)
2918 struct ieee80211_local
*local
= tx
->local
;
2919 struct ieee80211_hw_mode
*mode
= tx
->u
.tx
.mode
;
2920 struct sk_buff
*skb
= tx
->skb
;
2921 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
2922 u32 load
= 0, hdrtime
;
2924 /* TODO: this could be part of tx_status handling, so that the number
2925 * of retries would be known; TX rate should in that case be stored
2926 * somewhere with the packet */
2928 /* Estimate total channel use caused by this frame */
2930 /* 1 bit at 1 Mbit/s takes 1 usec; in channel_use values,
2931 * 1 usec = 1/8 * (1080 / 10) = 13.5 */
2933 if (mode
->mode
== MODE_IEEE80211A
||
2934 mode
->mode
== MODE_ATHEROS_TURBO
||
2935 mode
->mode
== MODE_ATHEROS_TURBOG
||
2936 (mode
->mode
== MODE_IEEE80211G
&&
2937 tx
->u
.tx
.rate
->flags
& IEEE80211_RATE_ERP
))
2938 hdrtime
= CHAN_UTIL_HDR_SHORT
;
2940 hdrtime
= CHAN_UTIL_HDR_LONG
;
2943 if (!is_multicast_ether_addr(hdr
->addr1
))
2946 if (tx
->u
.tx
.control
->flags
& IEEE80211_TXCTL_USE_RTS_CTS
)
2947 load
+= 2 * hdrtime
;
2948 else if (tx
->u
.tx
.control
->flags
& IEEE80211_TXCTL_USE_CTS_PROTECT
)
2951 load
+= skb
->len
* tx
->u
.tx
.rate
->rate_inv
;
2953 if (tx
->u
.tx
.extra_frag
) {
2955 for (i
= 0; i
< tx
->u
.tx
.num_extra_frag
; i
++) {
2956 load
+= 2 * hdrtime
;
2957 load
+= tx
->u
.tx
.extra_frag
[i
]->len
*
2958 tx
->u
.tx
.rate
->rate
;
2962 /* Divide channel_use by 8 to avoid wrapping around the counter */
2963 load
>>= CHAN_UTIL_SHIFT
;
2964 local
->channel_use_raw
+= load
;
2966 tx
->sta
->channel_use_raw
+= load
;
2967 tx
->sdata
->channel_use_raw
+= load
;
2969 return TXRX_CONTINUE
;
2973 static void ieee80211_stat_refresh(unsigned long data
)
2975 struct ieee80211_local
*local
= (struct ieee80211_local
*) data
;
2976 struct sta_info
*sta
;
2977 struct ieee80211_sub_if_data
*sdata
;
2979 if (!local
->stat_time
)
2982 /* go through all stations */
2983 spin_lock_bh(&local
->sta_lock
);
2984 list_for_each_entry(sta
, &local
->sta_list
, list
) {
2985 sta
->channel_use
= (sta
->channel_use_raw
/ local
->stat_time
) /
2987 sta
->channel_use_raw
= 0;
2989 spin_unlock_bh(&local
->sta_lock
);
2991 /* go through all subinterfaces */
2992 read_lock(&local
->sub_if_lock
);
2993 list_for_each_entry(sdata
, &local
->sub_if_list
, list
) {
2994 sdata
->channel_use
= (sdata
->channel_use_raw
/
2995 local
->stat_time
) / CHAN_UTIL_PER_10MS
;
2996 sdata
->channel_use_raw
= 0;
2998 read_unlock(&local
->sub_if_lock
);
3000 /* hardware interface */
3001 local
->channel_use
= (local
->channel_use_raw
/
3002 local
->stat_time
) / CHAN_UTIL_PER_10MS
;
3003 local
->channel_use_raw
= 0;
3005 local
->stat_timer
.expires
= jiffies
+ HZ
* local
->stat_time
/ 100;
3006 add_timer(&local
->stat_timer
);
3010 void ieee80211_tx_status_irqsafe(struct ieee80211_hw
*hw
,
3011 struct sk_buff
*skb
,
3012 struct ieee80211_tx_status
*status
)
3014 struct ieee80211_local
*local
= hw_to_local(hw
);
3015 struct ieee80211_tx_status
*saved
;
3018 skb
->dev
= local
->mdev
;
3019 saved
= kmalloc(sizeof(struct ieee80211_tx_status
), GFP_ATOMIC
);
3020 if (unlikely(!saved
)) {
3021 if (net_ratelimit())
3022 printk(KERN_WARNING
"%s: Not enough memory, "
3023 "dropping tx status", skb
->dev
->name
);
3024 /* should be dev_kfree_skb_irq, but due to this function being
3025 * named _irqsafe instead of just _irq we can't be sure that
3026 * people won't call it from non-irq contexts */
3027 dev_kfree_skb_any(skb
);
3030 memcpy(saved
, status
, sizeof(struct ieee80211_tx_status
));
3031 /* copy pointer to saved status into skb->cb for use by tasklet */
3032 memcpy(skb
->cb
, &saved
, sizeof(saved
));
3034 skb
->pkt_type
= IEEE80211_TX_STATUS_MSG
;
3035 skb_queue_tail(status
->control
.flags
& IEEE80211_TXCTL_REQ_TX_STATUS
?
3036 &local
->skb_queue
: &local
->skb_queue_unreliable
, skb
);
3037 tmp
= skb_queue_len(&local
->skb_queue
) +
3038 skb_queue_len(&local
->skb_queue_unreliable
);
3039 while (tmp
> IEEE80211_IRQSAFE_QUEUE_LIMIT
&&
3040 (skb
= skb_dequeue(&local
->skb_queue_unreliable
))) {
3041 memcpy(&saved
, skb
->cb
, sizeof(saved
));
3043 dev_kfree_skb_irq(skb
);
3045 I802_DEBUG_INC(local
->tx_status_drop
);
3047 tasklet_schedule(&local
->tasklet
);
3049 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe
);
3051 static void ieee80211_tasklet_handler(unsigned long data
)
3053 struct ieee80211_local
*local
= (struct ieee80211_local
*) data
;
3054 struct sk_buff
*skb
;
3055 struct ieee80211_rx_status rx_status
;
3056 struct ieee80211_tx_status
*tx_status
;
3058 while ((skb
= skb_dequeue(&local
->skb_queue
)) ||
3059 (skb
= skb_dequeue(&local
->skb_queue_unreliable
))) {
3060 switch (skb
->pkt_type
) {
3061 case IEEE80211_RX_MSG
:
3062 /* status is in skb->cb */
3063 memcpy(&rx_status
, skb
->cb
, sizeof(rx_status
));
3064 /* Clear skb->type in order to not confuse kernel
3067 __ieee80211_rx(local_to_hw(local
), skb
, &rx_status
);
3069 case IEEE80211_TX_STATUS_MSG
:
3070 /* get pointer to saved status out of skb->cb */
3071 memcpy(&tx_status
, skb
->cb
, sizeof(tx_status
));
3073 ieee80211_tx_status(local_to_hw(local
),
3077 default: /* should never get here! */
3078 printk(KERN_ERR
"%s: Unknown message type (%d)\n",
3079 local
->mdev
->name
, skb
->pkt_type
);
3087 /* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to
3088 * make a prepared TX frame (one that has been given to hw) to look like brand
3089 * new IEEE 802.11 frame that is ready to go through TX processing again.
3090 * Also, tx_packet_data in cb is restored from tx_control. */
3091 static void ieee80211_remove_tx_extra(struct ieee80211_local
*local
,
3092 struct ieee80211_key
*key
,
3093 struct sk_buff
*skb
,
3094 struct ieee80211_tx_control
*control
)
3096 int hdrlen
, iv_len
, mic_len
;
3097 struct ieee80211_tx_packet_data
*pkt_data
;
3099 pkt_data
= (struct ieee80211_tx_packet_data
*)skb
->cb
;
3100 pkt_data
->ifindex
= control
->ifindex
;
3101 pkt_data
->mgmt_iface
= (control
->type
== IEEE80211_IF_TYPE_MGMT
);
3102 pkt_data
->req_tx_status
= !!(control
->flags
& IEEE80211_TXCTL_REQ_TX_STATUS
);
3103 pkt_data
->do_not_encrypt
= !!(control
->flags
& IEEE80211_TXCTL_DO_NOT_ENCRYPT
);
3104 pkt_data
->requeue
= !!(control
->flags
& IEEE80211_TXCTL_REQUEUE
);
3105 pkt_data
->queue
= control
->queue
;
3107 hdrlen
= ieee80211_get_hdrlen_from_skb(skb
);
3114 iv_len
= WEP_IV_LEN
;
3115 mic_len
= WEP_ICV_LEN
;
3118 iv_len
= TKIP_IV_LEN
;
3119 mic_len
= TKIP_ICV_LEN
;
3122 iv_len
= CCMP_HDR_LEN
;
3123 mic_len
= CCMP_MIC_LEN
;
3129 if (skb
->len
>= mic_len
&& key
->force_sw_encrypt
)
3130 skb_trim(skb
, skb
->len
- mic_len
);
3131 if (skb
->len
>= iv_len
&& skb
->len
> hdrlen
) {
3132 memmove(skb
->data
+ iv_len
, skb
->data
, hdrlen
);
3133 skb_pull(skb
, iv_len
);
3138 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
3139 u16 fc
= le16_to_cpu(hdr
->frame_control
);
3140 if ((fc
& 0x8C) == 0x88) /* QoS Control Field */ {
3141 fc
&= ~IEEE80211_STYPE_QOS_DATA
;
3142 hdr
->frame_control
= cpu_to_le16(fc
);
3143 memmove(skb
->data
+ 2, skb
->data
, hdrlen
- 2);
3150 void ieee80211_tx_status(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
3151 struct ieee80211_tx_status
*status
)
3153 struct sk_buff
*skb2
;
3154 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
3155 struct ieee80211_local
*local
= hw_to_local(hw
);
3158 struct ieee80211_tx_status_rtap_hdr
*rthdr
;
3159 struct ieee80211_sub_if_data
*sdata
;
3164 "%s: ieee80211_tx_status called with NULL status\n",
3170 if (status
->excessive_retries
) {
3171 struct sta_info
*sta
;
3172 sta
= sta_info_get(local
, hdr
->addr1
);
3174 if (sta
->flags
& WLAN_STA_PS
) {
3175 /* The STA is in power save mode, so assume
3176 * that this TX packet failed because of that.
3178 status
->excessive_retries
= 0;
3179 status
->flags
|= IEEE80211_TX_STATUS_TX_FILTERED
;
3185 if (status
->flags
& IEEE80211_TX_STATUS_TX_FILTERED
) {
3186 struct sta_info
*sta
;
3187 sta
= sta_info_get(local
, hdr
->addr1
);
3189 sta
->tx_filtered_count
++;
3191 /* Clear the TX filter mask for this STA when sending
3192 * the next packet. If the STA went to power save mode,
3193 * this will happen when it is waking up for the next
3195 sta
->clear_dst_mask
= 1;
3197 /* TODO: Is the WLAN_STA_PS flag always set here or is
3198 * the race between RX and TX status causing some
3199 * packets to be filtered out before 80211.o gets an
3200 * update for PS status? This seems to be the case, so
3201 * no changes are likely to be needed. */
3202 if (sta
->flags
& WLAN_STA_PS
&&
3203 skb_queue_len(&sta
->tx_filtered
) <
3204 STA_MAX_TX_BUFFER
) {
3205 ieee80211_remove_tx_extra(local
, sta
->key
,
3208 skb_queue_tail(&sta
->tx_filtered
, skb
);
3209 } else if (!(sta
->flags
& WLAN_STA_PS
) &&
3210 !(status
->control
.flags
& IEEE80211_TXCTL_REQUEUE
)) {
3211 /* Software retry the packet once */
3212 status
->control
.flags
|= IEEE80211_TXCTL_REQUEUE
;
3213 ieee80211_remove_tx_extra(local
, sta
->key
,
3216 dev_queue_xmit(skb
);
3218 if (net_ratelimit()) {
3219 printk(KERN_DEBUG
"%s: dropped TX "
3220 "filtered frame queue_len=%d "
3225 !!(sta
->flags
& WLAN_STA_PS
),
3234 /* FIXME: STUPID to call this with both local and local->mdev */
3235 rate_control_tx_status(local
, local
->mdev
, skb
, status
);
3238 ieee80211_led_tx(local
, 0);
3241 * Fragments are passed to low-level drivers as separate skbs, so these
3242 * are actually fragments, not frames. Update frame counters only for
3243 * the first fragment of the frame. */
3245 frag
= le16_to_cpu(hdr
->seq_ctrl
) & IEEE80211_SCTL_FRAG
;
3246 type
= le16_to_cpu(hdr
->frame_control
) & IEEE80211_FCTL_FTYPE
;
3248 if (status
->flags
& IEEE80211_TX_STATUS_ACK
) {
3250 local
->dot11TransmittedFrameCount
++;
3251 if (is_multicast_ether_addr(hdr
->addr1
))
3252 local
->dot11MulticastTransmittedFrameCount
++;
3253 if (status
->retry_count
> 0)
3254 local
->dot11RetryCount
++;
3255 if (status
->retry_count
> 1)
3256 local
->dot11MultipleRetryCount
++;
3259 /* This counter shall be incremented for an acknowledged MPDU
3260 * with an individual address in the address 1 field or an MPDU
3261 * with a multicast address in the address 1 field of type Data
3263 if (!is_multicast_ether_addr(hdr
->addr1
) ||
3264 type
== IEEE80211_FTYPE_DATA
||
3265 type
== IEEE80211_FTYPE_MGMT
)
3266 local
->dot11TransmittedFragmentCount
++;
3269 local
->dot11FailedCount
++;
3272 msg_type
= (status
->flags
& IEEE80211_TX_STATUS_ACK
) ?
3273 ieee80211_msg_tx_callback_ack
: ieee80211_msg_tx_callback_fail
;
3275 /* this was a transmitted frame, but now we want to reuse it */
3278 if ((status
->control
.flags
& IEEE80211_TXCTL_REQ_TX_STATUS
) &&
3280 if (local
->monitors
) {
3281 skb2
= skb_clone(skb
, GFP_ATOMIC
);
3288 /* Send frame to hostapd */
3289 ieee80211_rx_mgmt(local
, skb2
, NULL
, msg_type
);
3295 if (!local
->monitors
) {
3300 /* send frame to monitor interfaces now */
3302 if (skb_headroom(skb
) < sizeof(*rthdr
)) {
3303 printk(KERN_ERR
"ieee80211_tx_status: headroom too small\n");
3308 rthdr
= (struct ieee80211_tx_status_rtap_hdr
*)
3309 skb_push(skb
, sizeof(*rthdr
));
3311 memset(rthdr
, 0, sizeof(*rthdr
));
3312 rthdr
->hdr
.it_len
= cpu_to_le16(sizeof(*rthdr
));
3313 rthdr
->hdr
.it_present
=
3314 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS
) |
3315 (1 << IEEE80211_RADIOTAP_DATA_RETRIES
));
3317 if (!(status
->flags
& IEEE80211_TX_STATUS_ACK
) &&
3318 !is_multicast_ether_addr(hdr
->addr1
))
3319 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL
);
3321 if ((status
->control
.flags
& IEEE80211_TXCTL_USE_RTS_CTS
) &&
3322 (status
->control
.flags
& IEEE80211_TXCTL_USE_CTS_PROTECT
))
3323 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS
);
3324 else if (status
->control
.flags
& IEEE80211_TXCTL_USE_RTS_CTS
)
3325 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS
);
3327 rthdr
->data_retries
= status
->retry_count
;
3329 read_lock(&local
->sub_if_lock
);
3330 monitors
= local
->monitors
;
3331 list_for_each_entry(sdata
, &local
->sub_if_list
, list
) {
3333 * Using the monitors counter is possibly racy, but
3334 * if the value is wrong we simply either clone the skb
3335 * once too much or forget sending it to one monitor iface
3336 * The latter case isn't nice but fixing the race is much
3339 if (!monitors
|| !skb
)
3342 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
) {
3343 if (!netif_running(sdata
->dev
))
3347 skb2
= skb_clone(skb
, GFP_KERNEL
);
3350 skb
->dev
= sdata
->dev
;
3351 /* XXX: is this sufficient for BPF? */
3352 skb_set_mac_header(skb
, 0);
3353 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
3354 skb
->pkt_type
= PACKET_OTHERHOST
;
3355 skb
->protocol
= htons(ETH_P_802_2
);
3356 memset(skb
->cb
, 0, sizeof(skb
->cb
));
3362 read_unlock(&local
->sub_if_lock
);
3366 EXPORT_SYMBOL(ieee80211_tx_status
);
3368 /* TODO: implement register/unregister functions for adding TX/RX handlers
3369 * into ordered list */
3371 static ieee80211_tx_handler ieee80211_tx_handlers
[] =
3373 ieee80211_tx_h_check_assoc
,
3374 ieee80211_tx_h_sequence
,
3375 ieee80211_tx_h_ps_buf
,
3376 ieee80211_tx_h_select_key
,
3377 ieee80211_tx_h_michael_mic_add
,
3378 ieee80211_tx_h_fragment
,
3379 ieee80211_tx_h_tkip_encrypt
,
3380 ieee80211_tx_h_ccmp_encrypt
,
3381 ieee80211_tx_h_wep_encrypt
,
3382 ieee80211_tx_h_rate_ctrl
,
3383 ieee80211_tx_h_misc
,
3384 ieee80211_tx_h_load_stats
,
3389 int ieee80211_if_update_wds(struct net_device
*dev
, u8
*remote_addr
)
3391 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3392 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3393 struct sta_info
*sta
;
3395 if (compare_ether_addr(remote_addr
, sdata
->u
.wds
.remote_addr
) == 0)
3398 /* Create STA entry for the new peer */
3399 sta
= sta_info_add(local
, dev
, remote_addr
, GFP_KERNEL
);
3404 /* Remove STA entry for the old peer */
3405 sta
= sta_info_get(local
, sdata
->u
.wds
.remote_addr
);
3408 sta_info_free(sta
, 0);
3410 printk(KERN_DEBUG
"%s: could not find STA entry for WDS link "
3411 "peer " MAC_FMT
"\n",
3412 dev
->name
, MAC_ARG(sdata
->u
.wds
.remote_addr
));
3415 /* Update WDS link data */
3416 memcpy(&sdata
->u
.wds
.remote_addr
, remote_addr
, ETH_ALEN
);
3421 /* Must not be called for mdev and apdev */
3422 void ieee80211_if_setup(struct net_device
*dev
)
3425 dev
->hard_start_xmit
= ieee80211_subif_start_xmit
;
3426 dev
->wireless_handlers
= &ieee80211_iw_handler_def
;
3427 dev
->set_multicast_list
= ieee80211_set_multicast_list
;
3428 dev
->change_mtu
= ieee80211_change_mtu
;
3429 dev
->get_stats
= ieee80211_get_stats
;
3430 dev
->open
= ieee80211_open
;
3431 dev
->stop
= ieee80211_stop
;
3432 dev
->uninit
= ieee80211_if_reinit
;
3433 dev
->destructor
= ieee80211_if_free
;
3436 void ieee80211_if_mgmt_setup(struct net_device
*dev
)
3439 dev
->hard_start_xmit
= ieee80211_mgmt_start_xmit
;
3440 dev
->change_mtu
= ieee80211_change_mtu_apdev
;
3441 dev
->get_stats
= ieee80211_get_stats
;
3442 dev
->open
= ieee80211_mgmt_open
;
3443 dev
->stop
= ieee80211_mgmt_stop
;
3444 dev
->type
= ARPHRD_IEEE80211_PRISM
;
3445 dev
->hard_header_parse
= header_parse_80211
;
3446 dev
->uninit
= ieee80211_if_reinit
;
3447 dev
->destructor
= ieee80211_if_free
;
3450 int ieee80211_init_rate_ctrl_alg(struct ieee80211_local
*local
,
3453 struct rate_control_ref
*ref
, *old
;
3456 if (local
->open_count
|| netif_running(local
->mdev
) ||
3457 (local
->apdev
&& netif_running(local
->apdev
)))
3460 ref
= rate_control_alloc(name
, local
);
3462 printk(KERN_WARNING
"%s: Failed to select rate control "
3463 "algorithm\n", local
->mdev
->name
);
3467 old
= local
->rate_ctrl
;
3468 local
->rate_ctrl
= ref
;
3470 rate_control_put(old
);
3471 sta_info_flush(local
, NULL
);
3474 printk(KERN_DEBUG
"%s: Selected rate control "
3475 "algorithm '%s'\n", local
->mdev
->name
,
3482 static void rate_control_deinitialize(struct ieee80211_local
*local
)
3484 struct rate_control_ref
*ref
;
3486 ref
= local
->rate_ctrl
;
3487 local
->rate_ctrl
= NULL
;
3488 rate_control_put(ref
);
3491 struct ieee80211_hw
*ieee80211_alloc_hw(size_t priv_data_len
,
3492 const struct ieee80211_ops
*ops
)
3494 struct net_device
*mdev
;
3495 struct ieee80211_local
*local
;
3496 struct ieee80211_sub_if_data
*sdata
;
3498 struct wiphy
*wiphy
;
3500 /* Ensure 32-byte alignment of our private data and hw private data.
3501 * We use the wiphy priv data for both our ieee80211_local and for
3502 * the driver's private data
3504 * In memory it'll be like this:
3506 * +-------------------------+
3508 * +-------------------------+
3509 * | struct ieee80211_local |
3510 * +-------------------------+
3511 * | driver's private data |
3512 * +-------------------------+
3515 priv_size
= ((sizeof(struct ieee80211_local
) +
3516 NETDEV_ALIGN_CONST
) & ~NETDEV_ALIGN_CONST
) +
3519 wiphy
= wiphy_new(&mac80211_config_ops
, priv_size
);
3524 wiphy
->privid
= mac80211_wiphy_privid
;
3526 local
= wiphy_priv(wiphy
);
3527 local
->hw
.wiphy
= wiphy
;
3529 local
->hw
.priv
= (char *)local
+
3530 ((sizeof(struct ieee80211_local
) +
3531 NETDEV_ALIGN_CONST
) & ~NETDEV_ALIGN_CONST
);
3534 BUG_ON(!ops
->config
);
3535 BUG_ON(!ops
->add_interface
);
3538 /* for now, mdev needs sub_if_data :/ */
3539 mdev
= alloc_netdev(sizeof(struct ieee80211_sub_if_data
),
3540 "wmaster%d", ether_setup
);
3546 sdata
= IEEE80211_DEV_TO_SUB_IF(mdev
);
3547 mdev
->ieee80211_ptr
= &sdata
->wdev
;
3548 sdata
->wdev
.wiphy
= wiphy
;
3550 local
->hw
.queues
= 1; /* default */
3553 local
->rx_pre_handlers
= ieee80211_rx_pre_handlers
;
3554 local
->rx_handlers
= ieee80211_rx_handlers
;
3555 local
->tx_handlers
= ieee80211_tx_handlers
;
3557 local
->bridge_packets
= 1;
3559 local
->rts_threshold
= IEEE80211_MAX_RTS_THRESHOLD
;
3560 local
->fragmentation_threshold
= IEEE80211_MAX_FRAG_THRESHOLD
;
3561 local
->short_retry_limit
= 7;
3562 local
->long_retry_limit
= 4;
3563 local
->hw
.conf
.radio_enabled
= 1;
3565 local
->enabled_modes
= (unsigned int) -1;
3567 INIT_LIST_HEAD(&local
->modes_list
);
3569 rwlock_init(&local
->sub_if_lock
);
3570 INIT_LIST_HEAD(&local
->sub_if_list
);
3572 INIT_DELAYED_WORK(&local
->scan_work
, ieee80211_sta_scan_work
);
3573 init_timer(&local
->stat_timer
);
3574 local
->stat_timer
.function
= ieee80211_stat_refresh
;
3575 local
->stat_timer
.data
= (unsigned long) local
;
3576 ieee80211_rx_bss_list_init(mdev
);
3578 sta_info_init(local
);
3580 mdev
->hard_start_xmit
= ieee80211_master_start_xmit
;
3581 mdev
->open
= ieee80211_master_open
;
3582 mdev
->stop
= ieee80211_master_stop
;
3583 mdev
->type
= ARPHRD_IEEE80211
;
3584 mdev
->hard_header_parse
= header_parse_80211
;
3586 sdata
->type
= IEEE80211_IF_TYPE_AP
;
3588 sdata
->local
= local
;
3589 sdata
->u
.ap
.force_unicast_rateidx
= -1;
3590 sdata
->u
.ap
.max_ratectrl_rateidx
= -1;
3591 ieee80211_if_sdata_init(sdata
);
3592 list_add_tail(&sdata
->list
, &local
->sub_if_list
);
3594 tasklet_init(&local
->tx_pending_tasklet
, ieee80211_tx_pending
,
3595 (unsigned long)local
);
3596 tasklet_disable(&local
->tx_pending_tasklet
);
3598 tasklet_init(&local
->tasklet
,
3599 ieee80211_tasklet_handler
,
3600 (unsigned long) local
);
3601 tasklet_disable(&local
->tasklet
);
3603 skb_queue_head_init(&local
->skb_queue
);
3604 skb_queue_head_init(&local
->skb_queue_unreliable
);
3606 return local_to_hw(local
);
3608 EXPORT_SYMBOL(ieee80211_alloc_hw
);
3610 int ieee80211_register_hw(struct ieee80211_hw
*hw
)
3612 struct ieee80211_local
*local
= hw_to_local(hw
);
3616 result
= wiphy_register(local
->hw
.wiphy
);
3620 name
= wiphy_dev(local
->hw
.wiphy
)->driver
->name
;
3621 local
->hw
.workqueue
= create_singlethread_workqueue(name
);
3622 if (!local
->hw
.workqueue
) {
3624 goto fail_workqueue
;
3628 * The hardware needs headroom for sending the frame,
3629 * and we need some headroom for passing the frame to monitor
3630 * interfaces, but never both at the same time.
3632 local
->tx_headroom
= max_t(unsigned int , local
->hw
.extra_tx_headroom
,
3633 sizeof(struct ieee80211_tx_status_rtap_hdr
));
3635 debugfs_hw_add(local
);
3637 local
->hw
.conf
.beacon_int
= 1000;
3639 local
->wstats_flags
|= local
->hw
.max_rssi
?
3640 IW_QUAL_LEVEL_UPDATED
: IW_QUAL_LEVEL_INVALID
;
3641 local
->wstats_flags
|= local
->hw
.max_signal
?
3642 IW_QUAL_QUAL_UPDATED
: IW_QUAL_QUAL_INVALID
;
3643 local
->wstats_flags
|= local
->hw
.max_noise
?
3644 IW_QUAL_NOISE_UPDATED
: IW_QUAL_NOISE_INVALID
;
3645 if (local
->hw
.max_rssi
< 0 || local
->hw
.max_noise
< 0)
3646 local
->wstats_flags
|= IW_QUAL_DBM
;
3648 result
= sta_info_start(local
);
3653 result
= dev_alloc_name(local
->mdev
, local
->mdev
->name
);
3657 memcpy(local
->mdev
->dev_addr
, local
->hw
.wiphy
->perm_addr
, ETH_ALEN
);
3658 SET_NETDEV_DEV(local
->mdev
, wiphy_dev(local
->hw
.wiphy
));
3660 result
= register_netdevice(local
->mdev
);
3664 ieee80211_debugfs_add_netdev(IEEE80211_DEV_TO_SUB_IF(local
->mdev
));
3666 result
= ieee80211_init_rate_ctrl_alg(local
, NULL
);
3668 printk(KERN_DEBUG
"%s: Failed to initialize rate control "
3669 "algorithm\n", local
->mdev
->name
);
3673 result
= ieee80211_wep_init(local
);
3676 printk(KERN_DEBUG
"%s: Failed to initialize wep\n",
3681 ieee80211_install_qdisc(local
->mdev
);
3683 /* add one default STA interface */
3684 result
= ieee80211_if_add(local
->mdev
, "wlan%d", NULL
,
3685 IEEE80211_IF_TYPE_STA
);
3687 printk(KERN_WARNING
"%s: Failed to add default virtual iface\n",
3690 local
->reg_state
= IEEE80211_DEV_REGISTERED
;
3693 ieee80211_led_init(local
);
3698 rate_control_deinitialize(local
);
3700 ieee80211_debugfs_remove_netdev(IEEE80211_DEV_TO_SUB_IF(local
->mdev
));
3701 unregister_netdevice(local
->mdev
);
3704 sta_info_stop(local
);
3706 debugfs_hw_del(local
);
3707 destroy_workqueue(local
->hw
.workqueue
);
3709 wiphy_unregister(local
->hw
.wiphy
);
3712 EXPORT_SYMBOL(ieee80211_register_hw
);
3714 int ieee80211_register_hwmode(struct ieee80211_hw
*hw
,
3715 struct ieee80211_hw_mode
*mode
)
3717 struct ieee80211_local
*local
= hw_to_local(hw
);
3718 struct ieee80211_rate
*rate
;
3721 INIT_LIST_HEAD(&mode
->list
);
3722 list_add_tail(&mode
->list
, &local
->modes_list
);
3724 local
->hw_modes
|= (1 << mode
->mode
);
3725 for (i
= 0; i
< mode
->num_rates
; i
++) {
3726 rate
= &(mode
->rates
[i
]);
3727 rate
->rate_inv
= CHAN_UTIL_RATE_LCM
/ rate
->rate
;
3729 ieee80211_prepare_rates(local
, mode
);
3731 if (!local
->oper_hw_mode
) {
3732 /* Default to this mode */
3733 local
->hw
.conf
.phymode
= mode
->mode
;
3734 local
->oper_hw_mode
= local
->scan_hw_mode
= mode
;
3735 local
->oper_channel
= local
->scan_channel
= &mode
->channels
[0];
3736 local
->hw
.conf
.mode
= local
->oper_hw_mode
;
3737 local
->hw
.conf
.chan
= local
->oper_channel
;
3740 if (!(hw
->flags
& IEEE80211_HW_DEFAULT_REG_DOMAIN_CONFIGURED
))
3741 ieee80211_set_default_regdomain(mode
);
3745 EXPORT_SYMBOL(ieee80211_register_hwmode
);
3747 void ieee80211_unregister_hw(struct ieee80211_hw
*hw
)
3749 struct ieee80211_local
*local
= hw_to_local(hw
);
3750 struct ieee80211_sub_if_data
*sdata
, *tmp
;
3751 struct list_head tmp_list
;
3754 tasklet_kill(&local
->tx_pending_tasklet
);
3755 tasklet_kill(&local
->tasklet
);
3759 BUG_ON(local
->reg_state
!= IEEE80211_DEV_REGISTERED
);
3761 local
->reg_state
= IEEE80211_DEV_UNREGISTERED
;
3763 ieee80211_if_del_mgmt(local
);
3765 write_lock_bh(&local
->sub_if_lock
);
3766 list_replace_init(&local
->sub_if_list
, &tmp_list
);
3767 write_unlock_bh(&local
->sub_if_lock
);
3769 list_for_each_entry_safe(sdata
, tmp
, &tmp_list
, list
)
3770 __ieee80211_if_del(local
, sdata
);
3774 if (local
->stat_time
)
3775 del_timer_sync(&local
->stat_timer
);
3777 ieee80211_rx_bss_list_deinit(local
->mdev
);
3778 ieee80211_clear_tx_pending(local
);
3779 sta_info_stop(local
);
3780 rate_control_deinitialize(local
);
3781 debugfs_hw_del(local
);
3783 for (i
= 0; i
< NUM_IEEE80211_MODES
; i
++) {
3784 kfree(local
->supp_rates
[i
]);
3785 kfree(local
->basic_rates
[i
]);
3788 if (skb_queue_len(&local
->skb_queue
)
3789 || skb_queue_len(&local
->skb_queue_unreliable
))
3790 printk(KERN_WARNING
"%s: skb_queue not empty\n",
3792 skb_queue_purge(&local
->skb_queue
);
3793 skb_queue_purge(&local
->skb_queue_unreliable
);
3795 destroy_workqueue(local
->hw
.workqueue
);
3796 wiphy_unregister(local
->hw
.wiphy
);
3797 ieee80211_wep_free(local
);
3798 ieee80211_led_exit(local
);
3800 EXPORT_SYMBOL(ieee80211_unregister_hw
);
3802 void ieee80211_free_hw(struct ieee80211_hw
*hw
)
3804 struct ieee80211_local
*local
= hw_to_local(hw
);
3806 ieee80211_if_free(local
->mdev
);
3807 wiphy_free(local
->hw
.wiphy
);
3809 EXPORT_SYMBOL(ieee80211_free_hw
);
3811 void ieee80211_wake_queue(struct ieee80211_hw
*hw
, int queue
)
3813 struct ieee80211_local
*local
= hw_to_local(hw
);
3815 if (test_and_clear_bit(IEEE80211_LINK_STATE_XOFF
,
3816 &local
->state
[queue
])) {
3817 if (test_bit(IEEE80211_LINK_STATE_PENDING
,
3818 &local
->state
[queue
]))
3819 tasklet_schedule(&local
->tx_pending_tasklet
);
3821 if (!ieee80211_qdisc_installed(local
->mdev
)) {
3823 netif_wake_queue(local
->mdev
);
3825 __netif_schedule(local
->mdev
);
3828 EXPORT_SYMBOL(ieee80211_wake_queue
);
3830 void ieee80211_stop_queue(struct ieee80211_hw
*hw
, int queue
)
3832 struct ieee80211_local
*local
= hw_to_local(hw
);
3834 if (!ieee80211_qdisc_installed(local
->mdev
) && queue
== 0)
3835 netif_stop_queue(local
->mdev
);
3836 set_bit(IEEE80211_LINK_STATE_XOFF
, &local
->state
[queue
]);
3838 EXPORT_SYMBOL(ieee80211_stop_queue
);
3840 void ieee80211_start_queues(struct ieee80211_hw
*hw
)
3842 struct ieee80211_local
*local
= hw_to_local(hw
);
3845 for (i
= 0; i
< local
->hw
.queues
; i
++)
3846 clear_bit(IEEE80211_LINK_STATE_XOFF
, &local
->state
[i
]);
3847 if (!ieee80211_qdisc_installed(local
->mdev
))
3848 netif_start_queue(local
->mdev
);
3850 EXPORT_SYMBOL(ieee80211_start_queues
);
3852 void ieee80211_stop_queues(struct ieee80211_hw
*hw
)
3856 for (i
= 0; i
< hw
->queues
; i
++)
3857 ieee80211_stop_queue(hw
, i
);
3859 EXPORT_SYMBOL(ieee80211_stop_queues
);
3861 void ieee80211_wake_queues(struct ieee80211_hw
*hw
)
3865 for (i
= 0; i
< hw
->queues
; i
++)
3866 ieee80211_wake_queue(hw
, i
);
3868 EXPORT_SYMBOL(ieee80211_wake_queues
);
3870 struct net_device_stats
*ieee80211_dev_stats(struct net_device
*dev
)
3872 struct ieee80211_sub_if_data
*sdata
;
3873 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3874 return &sdata
->stats
;
3877 static int __init
ieee80211_init(void)
3879 struct sk_buff
*skb
;
3882 BUILD_BUG_ON(sizeof(struct ieee80211_tx_packet_data
) > sizeof(skb
->cb
));
3884 ret
= ieee80211_wme_register();
3886 printk(KERN_DEBUG
"ieee80211_init: failed to "
3887 "initialize WME (err=%d)\n", ret
);
3891 ieee80211_debugfs_netdev_init();
3892 ieee80211_regdomain_init();
3898 static void __exit
ieee80211_exit(void)
3900 ieee80211_wme_unregister();
3901 ieee80211_debugfs_netdev_exit();
3905 subsys_initcall(ieee80211_init
);
3906 module_exit(ieee80211_exit
);
3908 MODULE_DESCRIPTION("IEEE 802.11 subsystem");
3909 MODULE_LICENSE("GPL");