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 static 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 static 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 static 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 static 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
);
348 static int ieee80211_get_radiotap_len(struct sk_buff
*skb
)
350 struct ieee80211_radiotap_header
*hdr
=
351 (struct ieee80211_radiotap_header
*) skb
->data
;
353 return le16_to_cpu(get_unaligned(&hdr
->it_len
));
356 #ifdef CONFIG_MAC80211_LOWTX_FRAME_DUMP
357 static void ieee80211_dump_frame(const char *ifname
, const char *title
,
358 const struct sk_buff
*skb
)
360 const struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
364 printk(KERN_DEBUG
"%s: %s (len=%d)", ifname
, title
, skb
->len
);
370 fc
= le16_to_cpu(hdr
->frame_control
);
371 hdrlen
= ieee80211_get_hdrlen(fc
);
372 if (hdrlen
> skb
->len
)
375 printk(" FC=0x%04x DUR=0x%04x",
376 fc
, le16_to_cpu(hdr
->duration_id
));
378 printk(" A1=" MAC_FMT
, MAC_ARG(hdr
->addr1
));
380 printk(" A2=" MAC_FMT
, MAC_ARG(hdr
->addr2
));
382 printk(" A3=" MAC_FMT
, MAC_ARG(hdr
->addr3
));
384 printk(" A4=" MAC_FMT
, MAC_ARG(hdr
->addr4
));
387 #else /* CONFIG_MAC80211_LOWTX_FRAME_DUMP */
388 static inline void ieee80211_dump_frame(const char *ifname
, const char *title
,
392 #endif /* CONFIG_MAC80211_LOWTX_FRAME_DUMP */
395 static int ieee80211_is_eapol(const struct sk_buff
*skb
)
397 const struct ieee80211_hdr
*hdr
;
401 if (unlikely(skb
->len
< 10))
404 hdr
= (const struct ieee80211_hdr
*) skb
->data
;
405 fc
= le16_to_cpu(hdr
->frame_control
);
407 if (unlikely(!WLAN_FC_DATA_PRESENT(fc
)))
410 hdrlen
= ieee80211_get_hdrlen(fc
);
412 if (unlikely(skb
->len
>= hdrlen
+ sizeof(eapol_header
) &&
413 memcmp(skb
->data
+ hdrlen
, eapol_header
,
414 sizeof(eapol_header
)) == 0))
421 static ieee80211_txrx_result
422 ieee80211_tx_h_rate_ctrl(struct ieee80211_txrx_data
*tx
)
424 struct rate_control_extra extra
;
426 memset(&extra
, 0, sizeof(extra
));
427 extra
.mode
= tx
->u
.tx
.mode
;
428 extra
.mgmt_data
= tx
->sdata
&&
429 tx
->sdata
->type
== IEEE80211_IF_TYPE_MGMT
;
430 extra
.ethertype
= tx
->ethertype
;
432 tx
->u
.tx
.rate
= rate_control_get_rate(tx
->local
, tx
->dev
, tx
->skb
,
434 if (unlikely(extra
.probe
!= NULL
)) {
435 tx
->u
.tx
.control
->flags
|= IEEE80211_TXCTL_RATE_CTRL_PROBE
;
436 tx
->u
.tx
.probe_last_frag
= 1;
437 tx
->u
.tx
.control
->alt_retry_rate
= tx
->u
.tx
.rate
->val
;
438 tx
->u
.tx
.rate
= extra
.probe
;
440 tx
->u
.tx
.control
->alt_retry_rate
= -1;
444 if (tx
->u
.tx
.mode
->mode
== MODE_IEEE80211G
&&
445 tx
->sdata
->use_protection
&& tx
->fragmented
&&
447 tx
->u
.tx
.last_frag_rate
= tx
->u
.tx
.rate
;
448 tx
->u
.tx
.probe_last_frag
= extra
.probe
? 1 : 0;
450 tx
->u
.tx
.rate
= extra
.nonerp
;
451 tx
->u
.tx
.control
->rate
= extra
.nonerp
;
452 tx
->u
.tx
.control
->flags
&= ~IEEE80211_TXCTL_RATE_CTRL_PROBE
;
454 tx
->u
.tx
.last_frag_rate
= tx
->u
.tx
.rate
;
455 tx
->u
.tx
.control
->rate
= tx
->u
.tx
.rate
;
457 tx
->u
.tx
.control
->tx_rate
= tx
->u
.tx
.rate
->val
;
458 if ((tx
->u
.tx
.rate
->flags
& IEEE80211_RATE_PREAMBLE2
) &&
459 tx
->local
->short_preamble
&&
460 (!tx
->sta
|| (tx
->sta
->flags
& WLAN_STA_SHORT_PREAMBLE
))) {
461 tx
->u
.tx
.short_preamble
= 1;
462 tx
->u
.tx
.control
->tx_rate
= tx
->u
.tx
.rate
->val2
;
465 return TXRX_CONTINUE
;
469 static ieee80211_txrx_result
470 ieee80211_tx_h_select_key(struct ieee80211_txrx_data
*tx
)
473 tx
->u
.tx
.control
->key_idx
= tx
->sta
->key_idx_compression
;
475 tx
->u
.tx
.control
->key_idx
= HW_KEY_IDX_INVALID
;
477 if (unlikely(tx
->u
.tx
.control
->flags
& IEEE80211_TXCTL_DO_NOT_ENCRYPT
))
479 else if (tx
->sta
&& tx
->sta
->key
)
480 tx
->key
= tx
->sta
->key
;
481 else if (tx
->sdata
->default_key
)
482 tx
->key
= tx
->sdata
->default_key
;
483 else if (tx
->sdata
->drop_unencrypted
&&
484 !(tx
->sdata
->eapol
&& ieee80211_is_eapol(tx
->skb
))) {
485 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_unencrypted
);
491 tx
->key
->tx_rx_count
++;
492 if (unlikely(tx
->local
->key_tx_rx_threshold
&&
493 tx
->key
->tx_rx_count
>
494 tx
->local
->key_tx_rx_threshold
)) {
495 ieee80211_key_threshold_notify(tx
->dev
, tx
->key
,
500 return TXRX_CONTINUE
;
504 static ieee80211_txrx_result
505 ieee80211_tx_h_fragment(struct ieee80211_txrx_data
*tx
)
507 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) tx
->skb
->data
;
508 size_t hdrlen
, per_fragm
, num_fragm
, payload_len
, left
;
509 struct sk_buff
**frags
, *first
, *frag
;
513 int frag_threshold
= tx
->local
->fragmentation_threshold
;
516 return TXRX_CONTINUE
;
520 hdrlen
= ieee80211_get_hdrlen(tx
->fc
);
521 payload_len
= first
->len
- hdrlen
;
522 per_fragm
= frag_threshold
- hdrlen
- FCS_LEN
;
523 num_fragm
= (payload_len
+ per_fragm
- 1) / per_fragm
;
525 frags
= kzalloc(num_fragm
* sizeof(struct sk_buff
*), GFP_ATOMIC
);
529 hdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_MOREFRAGS
);
530 seq
= le16_to_cpu(hdr
->seq_ctrl
) & IEEE80211_SCTL_SEQ
;
531 pos
= first
->data
+ hdrlen
+ per_fragm
;
532 left
= payload_len
- per_fragm
;
533 for (i
= 0; i
< num_fragm
- 1; i
++) {
534 struct ieee80211_hdr
*fhdr
;
540 /* reserve enough extra head and tail room for possible
543 dev_alloc_skb(tx
->local
->tx_headroom
+
545 IEEE80211_ENCRYPT_HEADROOM
+
546 IEEE80211_ENCRYPT_TAILROOM
);
549 /* Make sure that all fragments use the same priority so
550 * that they end up using the same TX queue */
551 frag
->priority
= first
->priority
;
552 skb_reserve(frag
, tx
->local
->tx_headroom
+
553 IEEE80211_ENCRYPT_HEADROOM
);
554 fhdr
= (struct ieee80211_hdr
*) skb_put(frag
, hdrlen
);
555 memcpy(fhdr
, first
->data
, hdrlen
);
556 if (i
== num_fragm
- 2)
557 fhdr
->frame_control
&= cpu_to_le16(~IEEE80211_FCTL_MOREFRAGS
);
558 fhdr
->seq_ctrl
= cpu_to_le16(seq
| ((i
+ 1) & IEEE80211_SCTL_FRAG
));
559 copylen
= left
> per_fragm
? per_fragm
: left
;
560 memcpy(skb_put(frag
, copylen
), pos
, copylen
);
565 skb_trim(first
, hdrlen
+ per_fragm
);
567 tx
->u
.tx
.num_extra_frag
= num_fragm
- 1;
568 tx
->u
.tx
.extra_frag
= frags
;
570 return TXRX_CONTINUE
;
573 printk(KERN_DEBUG
"%s: failed to fragment frame\n", tx
->dev
->name
);
575 for (i
= 0; i
< num_fragm
- 1; i
++)
577 dev_kfree_skb(frags
[i
]);
580 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_fragment
);
585 static int wep_encrypt_skb(struct ieee80211_txrx_data
*tx
, struct sk_buff
*skb
)
587 if (tx
->key
->force_sw_encrypt
) {
588 if (ieee80211_wep_encrypt(tx
->local
, skb
, tx
->key
))
591 tx
->u
.tx
.control
->key_idx
= tx
->key
->hw_key_idx
;
592 if (tx
->local
->hw
.flags
& IEEE80211_HW_WEP_INCLUDE_IV
) {
593 if (ieee80211_wep_add_iv(tx
->local
, skb
, tx
->key
) ==
602 void ieee80211_tx_set_iswep(struct ieee80211_txrx_data
*tx
)
604 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) tx
->skb
->data
;
606 hdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
607 if (tx
->u
.tx
.extra_frag
) {
608 struct ieee80211_hdr
*fhdr
;
610 for (i
= 0; i
< tx
->u
.tx
.num_extra_frag
; i
++) {
611 fhdr
= (struct ieee80211_hdr
*)
612 tx
->u
.tx
.extra_frag
[i
]->data
;
613 fhdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
619 static ieee80211_txrx_result
620 ieee80211_tx_h_wep_encrypt(struct ieee80211_txrx_data
*tx
)
622 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) tx
->skb
->data
;
625 fc
= le16_to_cpu(hdr
->frame_control
);
627 if (!tx
->key
|| tx
->key
->alg
!= ALG_WEP
||
628 ((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
&&
629 ((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_MGMT
||
630 (fc
& IEEE80211_FCTL_STYPE
) != IEEE80211_STYPE_AUTH
)))
631 return TXRX_CONTINUE
;
633 tx
->u
.tx
.control
->iv_len
= WEP_IV_LEN
;
634 tx
->u
.tx
.control
->icv_len
= WEP_ICV_LEN
;
635 ieee80211_tx_set_iswep(tx
);
637 if (wep_encrypt_skb(tx
, tx
->skb
) < 0) {
638 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_wep
);
642 if (tx
->u
.tx
.extra_frag
) {
644 for (i
= 0; i
< tx
->u
.tx
.num_extra_frag
; i
++) {
645 if (wep_encrypt_skb(tx
, tx
->u
.tx
.extra_frag
[i
]) < 0) {
646 I802_DEBUG_INC(tx
->local
->
647 tx_handlers_drop_wep
);
653 return TXRX_CONTINUE
;
657 static int ieee80211_frame_duration(struct ieee80211_local
*local
, size_t len
,
658 int rate
, int erp
, int short_preamble
)
662 /* calculate duration (in microseconds, rounded up to next higher
663 * integer if it includes a fractional microsecond) to send frame of
664 * len bytes (does not include FCS) at the given rate. Duration will
667 * rate is in 100 kbps, so divident is multiplied by 10 in the
668 * DIV_ROUND_UP() operations.
671 if (local
->hw
.conf
.phymode
== MODE_IEEE80211A
|| erp
||
672 local
->hw
.conf
.phymode
== MODE_ATHEROS_TURBO
) {
676 * N_DBPS = DATARATE x 4
677 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
678 * (16 = SIGNAL time, 6 = tail bits)
679 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
682 * 802.11a - 17.5.2: aSIFSTime = 16 usec
683 * 802.11g - 19.8.4: aSIFSTime = 10 usec +
684 * signal ext = 6 usec
686 /* FIX: Atheros Turbo may have different (shorter) duration? */
687 dur
= 16; /* SIFS + signal ext */
688 dur
+= 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */
689 dur
+= 4; /* 17.3.2.3: T_SIGNAL = 4 usec */
690 dur
+= 4 * DIV_ROUND_UP((16 + 8 * (len
+ 4) + 6) * 10,
691 4 * rate
); /* T_SYM x N_SYM */
694 * 802.11b or 802.11g with 802.11b compatibility:
695 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
696 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
698 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
699 * aSIFSTime = 10 usec
700 * aPreambleLength = 144 usec or 72 usec with short preamble
701 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
703 dur
= 10; /* aSIFSTime = 10 usec */
704 dur
+= short_preamble
? (72 + 24) : (144 + 48);
706 dur
+= DIV_ROUND_UP(8 * (len
+ 4) * 10, rate
);
713 /* Exported duration function for driver use */
714 __le16
ieee80211_generic_frame_duration(struct ieee80211_hw
*hw
,
715 size_t frame_len
, int rate
)
717 struct ieee80211_local
*local
= hw_to_local(hw
);
721 erp
= ieee80211_is_erp_rate(hw
->conf
.phymode
, rate
);
722 dur
= ieee80211_frame_duration(local
, frame_len
, rate
,
723 erp
, local
->short_preamble
);
725 return cpu_to_le16(dur
);
727 EXPORT_SYMBOL(ieee80211_generic_frame_duration
);
730 static u16
ieee80211_duration(struct ieee80211_txrx_data
*tx
, int group_addr
,
733 int rate
, mrate
, erp
, dur
, i
;
734 struct ieee80211_rate
*txrate
= tx
->u
.tx
.rate
;
735 struct ieee80211_local
*local
= tx
->local
;
736 struct ieee80211_hw_mode
*mode
= tx
->u
.tx
.mode
;
738 erp
= txrate
->flags
& IEEE80211_RATE_ERP
;
741 * data and mgmt (except PS Poll):
742 * - during CFP: 32768
743 * - during contention period:
744 * if addr1 is group address: 0
745 * if more fragments = 0 and addr1 is individual address: time to
746 * transmit one ACK plus SIFS
747 * if more fragments = 1 and addr1 is individual address: time to
748 * transmit next fragment plus 2 x ACK plus 3 x SIFS
751 * - control response frame (CTS or ACK) shall be transmitted using the
752 * same rate as the immediately previous frame in the frame exchange
753 * sequence, if this rate belongs to the PHY mandatory rates, or else
754 * at the highest possible rate belonging to the PHY rates in the
758 if ((tx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_CTL
) {
759 /* TODO: These control frames are not currently sent by
760 * 80211.o, but should they be implemented, this function
761 * needs to be updated to support duration field calculation.
763 * RTS: time needed to transmit pending data/mgmt frame plus
764 * one CTS frame plus one ACK frame plus 3 x SIFS
765 * CTS: duration of immediately previous RTS minus time
766 * required to transmit CTS and its SIFS
767 * ACK: 0 if immediately previous directed data/mgmt had
768 * more=0, with more=1 duration in ACK frame is duration
769 * from previous frame minus time needed to transmit ACK
771 * PS Poll: BIT(15) | BIT(14) | aid
777 if (0 /* FIX: data/mgmt during CFP */)
780 if (group_addr
) /* Group address as the destination - no ACK */
783 /* Individual destination address:
784 * IEEE 802.11, Ch. 9.6 (after IEEE 802.11g changes)
785 * CTS and ACK frames shall be transmitted using the highest rate in
786 * basic rate set that is less than or equal to the rate of the
787 * immediately previous frame and that is using the same modulation
788 * (CCK or OFDM). If no basic rate set matches with these requirements,
789 * the highest mandatory rate of the PHY that is less than or equal to
790 * the rate of the previous frame is used.
791 * Mandatory rates for IEEE 802.11g PHY: 1, 2, 5.5, 11, 6, 12, 24 Mbps
794 mrate
= 10; /* use 1 Mbps if everything fails */
795 for (i
= 0; i
< mode
->num_rates
; i
++) {
796 struct ieee80211_rate
*r
= &mode
->rates
[i
];
797 if (r
->rate
> txrate
->rate
)
800 if (IEEE80211_RATE_MODULATION(txrate
->flags
) !=
801 IEEE80211_RATE_MODULATION(r
->flags
))
804 if (r
->flags
& IEEE80211_RATE_BASIC
)
806 else if (r
->flags
& IEEE80211_RATE_MANDATORY
)
810 /* No matching basic rate found; use highest suitable mandatory
815 /* Time needed to transmit ACK
816 * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
817 * to closest integer */
819 dur
= ieee80211_frame_duration(local
, 10, rate
, erp
,
820 local
->short_preamble
);
823 /* Frame is fragmented: duration increases with time needed to
824 * transmit next fragment plus ACK and 2 x SIFS. */
825 dur
*= 2; /* ACK + SIFS */
827 dur
+= ieee80211_frame_duration(local
, next_frag_len
,
829 local
->short_preamble
);
836 static ieee80211_txrx_result
837 ieee80211_tx_h_misc(struct ieee80211_txrx_data
*tx
)
839 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) tx
->skb
->data
;
841 struct ieee80211_tx_control
*control
= tx
->u
.tx
.control
;
842 struct ieee80211_hw_mode
*mode
= tx
->u
.tx
.mode
;
844 if (!is_multicast_ether_addr(hdr
->addr1
)) {
845 if (tx
->skb
->len
+ FCS_LEN
> tx
->local
->rts_threshold
&&
846 tx
->local
->rts_threshold
< IEEE80211_MAX_RTS_THRESHOLD
) {
847 control
->flags
|= IEEE80211_TXCTL_USE_RTS_CTS
;
848 control
->retry_limit
=
849 tx
->local
->long_retry_limit
;
851 control
->retry_limit
=
852 tx
->local
->short_retry_limit
;
855 control
->retry_limit
= 1;
858 if (tx
->fragmented
) {
859 /* Do not use multiple retry rates when sending fragmented
861 * TODO: The last fragment could still use multiple retry
863 control
->alt_retry_rate
= -1;
866 /* Use CTS protection for unicast frames sent using extended rates if
867 * there are associated non-ERP stations and RTS/CTS is not configured
869 if (mode
->mode
== MODE_IEEE80211G
&&
870 (tx
->u
.tx
.rate
->flags
& IEEE80211_RATE_ERP
) &&
871 tx
->u
.tx
.unicast
&& tx
->sdata
->use_protection
&&
872 !(control
->flags
& IEEE80211_TXCTL_USE_RTS_CTS
))
873 control
->flags
|= IEEE80211_TXCTL_USE_CTS_PROTECT
;
875 /* Setup duration field for the first fragment of the frame. Duration
876 * for remaining fragments will be updated when they are being sent
877 * to low-level driver in ieee80211_tx(). */
878 dur
= ieee80211_duration(tx
, is_multicast_ether_addr(hdr
->addr1
),
879 tx
->fragmented
? tx
->u
.tx
.extra_frag
[0]->len
:
881 hdr
->duration_id
= cpu_to_le16(dur
);
883 if ((control
->flags
& IEEE80211_TXCTL_USE_RTS_CTS
) ||
884 (control
->flags
& IEEE80211_TXCTL_USE_CTS_PROTECT
)) {
885 struct ieee80211_rate
*rate
;
887 /* Do not use multiple retry rates when using RTS/CTS */
888 control
->alt_retry_rate
= -1;
890 /* Use min(data rate, max base rate) as CTS/RTS rate */
891 rate
= tx
->u
.tx
.rate
;
892 while (rate
> mode
->rates
&&
893 !(rate
->flags
& IEEE80211_RATE_BASIC
))
896 control
->rts_cts_rate
= rate
->val
;
897 control
->rts_rate
= rate
;
901 tx
->sta
->tx_packets
++;
902 tx
->sta
->tx_fragments
++;
903 tx
->sta
->tx_bytes
+= tx
->skb
->len
;
904 if (tx
->u
.tx
.extra_frag
) {
906 tx
->sta
->tx_fragments
+= tx
->u
.tx
.num_extra_frag
;
907 for (i
= 0; i
< tx
->u
.tx
.num_extra_frag
; i
++) {
909 tx
->u
.tx
.extra_frag
[i
]->len
;
914 return TXRX_CONTINUE
;
918 static ieee80211_txrx_result
919 ieee80211_tx_h_check_assoc(struct ieee80211_txrx_data
*tx
)
921 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
922 struct sk_buff
*skb
= tx
->skb
;
923 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
924 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
927 if (unlikely(tx
->local
->sta_scanning
!= 0) &&
928 ((tx
->fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_MGMT
||
929 (tx
->fc
& IEEE80211_FCTL_STYPE
) != IEEE80211_STYPE_PROBE_REQ
))
932 if (tx
->u
.tx
.ps_buffered
)
933 return TXRX_CONTINUE
;
935 sta_flags
= tx
->sta
? tx
->sta
->flags
: 0;
937 if (likely(tx
->u
.tx
.unicast
)) {
938 if (unlikely(!(sta_flags
& WLAN_STA_ASSOC
) &&
939 tx
->sdata
->type
!= IEEE80211_IF_TYPE_IBSS
&&
940 (tx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
)) {
941 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
942 printk(KERN_DEBUG
"%s: dropped data frame to not "
943 "associated station " MAC_FMT
"\n",
944 tx
->dev
->name
, MAC_ARG(hdr
->addr1
));
945 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
946 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_not_assoc
);
950 if (unlikely((tx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
&&
951 tx
->local
->num_sta
== 0 &&
952 !tx
->local
->allow_broadcast_always
&&
953 tx
->sdata
->type
!= IEEE80211_IF_TYPE_IBSS
)) {
955 * No associated STAs - no need to send multicast
960 return TXRX_CONTINUE
;
963 if (unlikely(!tx
->u
.tx
.mgmt_interface
&& tx
->sdata
->ieee802_1x
&&
964 !(sta_flags
& WLAN_STA_AUTHORIZED
))) {
965 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
966 printk(KERN_DEBUG
"%s: dropped frame to " MAC_FMT
967 " (unauthorized port)\n", tx
->dev
->name
,
968 MAC_ARG(hdr
->addr1
));
970 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_unauth_port
);
974 return TXRX_CONTINUE
;
977 static ieee80211_txrx_result
978 ieee80211_tx_h_sequence(struct ieee80211_txrx_data
*tx
)
980 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)tx
->skb
->data
;
982 if (ieee80211_get_hdrlen(le16_to_cpu(hdr
->frame_control
)) >= 24)
983 ieee80211_include_sequence(tx
->sdata
, hdr
);
985 return TXRX_CONTINUE
;
988 /* This function is called whenever the AP is about to exceed the maximum limit
989 * of buffered frames for power saving STAs. This situation should not really
990 * happen often during normal operation, so dropping the oldest buffered packet
991 * from each queue should be OK to make some room for new frames. */
992 static void purge_old_ps_buffers(struct ieee80211_local
*local
)
994 int total
= 0, purged
= 0;
996 struct ieee80211_sub_if_data
*sdata
;
997 struct sta_info
*sta
;
999 read_lock(&local
->sub_if_lock
);
1000 list_for_each_entry(sdata
, &local
->sub_if_list
, list
) {
1001 struct ieee80211_if_ap
*ap
;
1002 if (sdata
->dev
== local
->mdev
||
1003 sdata
->type
!= IEEE80211_IF_TYPE_AP
)
1006 skb
= skb_dequeue(&ap
->ps_bc_buf
);
1011 total
+= skb_queue_len(&ap
->ps_bc_buf
);
1013 read_unlock(&local
->sub_if_lock
);
1015 spin_lock_bh(&local
->sta_lock
);
1016 list_for_each_entry(sta
, &local
->sta_list
, list
) {
1017 skb
= skb_dequeue(&sta
->ps_tx_buf
);
1022 total
+= skb_queue_len(&sta
->ps_tx_buf
);
1024 spin_unlock_bh(&local
->sta_lock
);
1026 local
->total_ps_buffered
= total
;
1027 printk(KERN_DEBUG
"%s: PS buffers full - purged %d frames\n",
1028 local
->mdev
->name
, purged
);
1032 static inline ieee80211_txrx_result
1033 ieee80211_tx_h_multicast_ps_buf(struct ieee80211_txrx_data
*tx
)
1035 /* broadcast/multicast frame */
1036 /* If any of the associated stations is in power save mode,
1037 * the frame is buffered to be sent after DTIM beacon frame */
1038 if ((tx
->local
->hw
.flags
& IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING
) &&
1039 tx
->sdata
->type
!= IEEE80211_IF_TYPE_WDS
&&
1040 tx
->sdata
->bss
&& atomic_read(&tx
->sdata
->bss
->num_sta_ps
) &&
1041 !(tx
->fc
& IEEE80211_FCTL_ORDER
)) {
1042 if (tx
->local
->total_ps_buffered
>= TOTAL_MAX_TX_BUFFER
)
1043 purge_old_ps_buffers(tx
->local
);
1044 if (skb_queue_len(&tx
->sdata
->bss
->ps_bc_buf
) >=
1046 if (net_ratelimit()) {
1047 printk(KERN_DEBUG
"%s: BC TX buffer full - "
1048 "dropping the oldest frame\n",
1051 dev_kfree_skb(skb_dequeue(&tx
->sdata
->bss
->ps_bc_buf
));
1053 tx
->local
->total_ps_buffered
++;
1054 skb_queue_tail(&tx
->sdata
->bss
->ps_bc_buf
, tx
->skb
);
1058 return TXRX_CONTINUE
;
1062 static inline ieee80211_txrx_result
1063 ieee80211_tx_h_unicast_ps_buf(struct ieee80211_txrx_data
*tx
)
1065 struct sta_info
*sta
= tx
->sta
;
1067 if (unlikely(!sta
||
1068 ((tx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_MGMT
&&
1069 (tx
->fc
& IEEE80211_FCTL_STYPE
) == IEEE80211_STYPE_PROBE_RESP
)))
1070 return TXRX_CONTINUE
;
1072 if (unlikely((sta
->flags
& WLAN_STA_PS
) && !sta
->pspoll
)) {
1073 struct ieee80211_tx_packet_data
*pkt_data
;
1074 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
1075 printk(KERN_DEBUG
"STA " MAC_FMT
" aid %d: PS buffer (entries "
1077 MAC_ARG(sta
->addr
), sta
->aid
,
1078 skb_queue_len(&sta
->ps_tx_buf
));
1079 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
1080 sta
->flags
|= WLAN_STA_TIM
;
1081 if (tx
->local
->total_ps_buffered
>= TOTAL_MAX_TX_BUFFER
)
1082 purge_old_ps_buffers(tx
->local
);
1083 if (skb_queue_len(&sta
->ps_tx_buf
) >= STA_MAX_TX_BUFFER
) {
1084 struct sk_buff
*old
= skb_dequeue(&sta
->ps_tx_buf
);
1085 if (net_ratelimit()) {
1086 printk(KERN_DEBUG
"%s: STA " MAC_FMT
" TX "
1087 "buffer full - dropping oldest frame\n",
1088 tx
->dev
->name
, MAC_ARG(sta
->addr
));
1092 tx
->local
->total_ps_buffered
++;
1093 /* Queue frame to be sent after STA sends an PS Poll frame */
1094 if (skb_queue_empty(&sta
->ps_tx_buf
)) {
1095 if (tx
->local
->ops
->set_tim
)
1096 tx
->local
->ops
->set_tim(local_to_hw(tx
->local
),
1099 bss_tim_set(tx
->local
, tx
->sdata
->bss
, sta
->aid
);
1101 pkt_data
= (struct ieee80211_tx_packet_data
*)tx
->skb
->cb
;
1102 pkt_data
->jiffies
= jiffies
;
1103 skb_queue_tail(&sta
->ps_tx_buf
, tx
->skb
);
1106 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
1107 else if (unlikely(sta
->flags
& WLAN_STA_PS
)) {
1108 printk(KERN_DEBUG
"%s: STA " MAC_FMT
" in PS mode, but pspoll "
1109 "set -> send frame\n", tx
->dev
->name
,
1110 MAC_ARG(sta
->addr
));
1112 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
1115 return TXRX_CONTINUE
;
1119 static ieee80211_txrx_result
1120 ieee80211_tx_h_ps_buf(struct ieee80211_txrx_data
*tx
)
1122 if (unlikely(tx
->u
.tx
.ps_buffered
))
1123 return TXRX_CONTINUE
;
1125 if (tx
->u
.tx
.unicast
)
1126 return ieee80211_tx_h_unicast_ps_buf(tx
);
1128 return ieee80211_tx_h_multicast_ps_buf(tx
);
1133 * deal with packet injection down monitor interface
1134 * with Radiotap Header -- only called for monitor mode interface
1137 static ieee80211_txrx_result
1138 __ieee80211_parse_tx_radiotap(
1139 struct ieee80211_txrx_data
*tx
,
1140 struct sk_buff
*skb
, struct ieee80211_tx_control
*control
)
1143 * this is the moment to interpret and discard the radiotap header that
1144 * must be at the start of the packet injected in Monitor mode
1146 * Need to take some care with endian-ness since radiotap
1147 * args are little-endian
1150 struct ieee80211_radiotap_iterator iterator
;
1151 struct ieee80211_radiotap_header
*rthdr
=
1152 (struct ieee80211_radiotap_header
*) skb
->data
;
1153 struct ieee80211_hw_mode
*mode
= tx
->local
->hw
.conf
.mode
;
1154 int ret
= ieee80211_radiotap_iterator_init(&iterator
, rthdr
, skb
->len
);
1157 * default control situation for all injected packets
1158 * FIXME: this does not suit all usage cases, expand to allow control
1161 control
->retry_limit
= 1; /* no retry */
1162 control
->key_idx
= -1; /* no encryption key */
1163 control
->flags
&= ~(IEEE80211_TXCTL_USE_RTS_CTS
|
1164 IEEE80211_TXCTL_USE_CTS_PROTECT
);
1165 control
->flags
|= IEEE80211_TXCTL_DO_NOT_ENCRYPT
|
1166 IEEE80211_TXCTL_NO_ACK
;
1167 control
->antenna_sel_tx
= 0; /* default to default antenna */
1170 * for every radiotap entry that is present
1171 * (ieee80211_radiotap_iterator_next returns -ENOENT when no more
1172 * entries present, or -EINVAL on error)
1178 ret
= ieee80211_radiotap_iterator_next(&iterator
);
1183 /* see if this argument is something we can use */
1184 switch (iterator
.this_arg_index
) {
1186 * You must take care when dereferencing iterator.this_arg
1187 * for multibyte types... the pointer is not aligned. Use
1188 * get_unaligned((type *)iterator.this_arg) to dereference
1189 * iterator.this_arg for type "type" safely on all arches.
1191 case IEEE80211_RADIOTAP_RATE
:
1193 * radiotap rate u8 is in 500kbps units eg, 0x02=1Mbps
1194 * ieee80211 rate int is in 100kbps units eg, 0x0a=1Mbps
1196 target_rate
= (*iterator
.this_arg
) * 5;
1197 for (i
= 0; i
< mode
->num_rates
; i
++) {
1198 struct ieee80211_rate
*r
= &mode
->rates
[i
];
1200 if (r
->rate
> target_rate
)
1205 if (r
->flags
& IEEE80211_RATE_PREAMBLE2
)
1206 control
->tx_rate
= r
->val2
;
1208 control
->tx_rate
= r
->val
;
1210 /* end on exact match */
1211 if (r
->rate
== target_rate
)
1212 i
= mode
->num_rates
;
1216 case IEEE80211_RADIOTAP_ANTENNA
:
1218 * radiotap uses 0 for 1st ant, mac80211 is 1 for
1221 control
->antenna_sel_tx
= (*iterator
.this_arg
) + 1;
1224 case IEEE80211_RADIOTAP_DBM_TX_POWER
:
1225 control
->power_level
= *iterator
.this_arg
;
1228 case IEEE80211_RADIOTAP_FLAGS
:
1229 if (*iterator
.this_arg
& IEEE80211_RADIOTAP_F_FCS
) {
1231 * this indicates that the skb we have been
1232 * handed has the 32-bit FCS CRC at the end...
1233 * we should react to that by snipping it off
1234 * because it will be recomputed and added
1237 if (skb
->len
< (iterator
.max_length
+ FCS_LEN
))
1240 skb_trim(skb
, skb
->len
- FCS_LEN
);
1249 if (ret
!= -ENOENT
) /* ie, if we didn't simply run out of fields */
1253 * remove the radiotap header
1254 * iterator->max_length was sanity-checked against
1255 * skb->len by iterator init
1257 skb_pull(skb
, iterator
.max_length
);
1259 return TXRX_CONTINUE
;
1263 static ieee80211_txrx_result
inline
1264 __ieee80211_tx_prepare(struct ieee80211_txrx_data
*tx
,
1265 struct sk_buff
*skb
,
1266 struct net_device
*dev
,
1267 struct ieee80211_tx_control
*control
)
1269 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1270 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
1271 struct ieee80211_sub_if_data
*sdata
;
1272 ieee80211_txrx_result res
= TXRX_CONTINUE
;
1276 memset(tx
, 0, sizeof(*tx
));
1278 tx
->dev
= dev
; /* use original interface */
1280 tx
->sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1281 tx
->sta
= sta_info_get(local
, hdr
->addr1
);
1282 tx
->fc
= le16_to_cpu(hdr
->frame_control
);
1285 * set defaults for things that can be set by
1286 * injected radiotap headers
1288 control
->power_level
= local
->hw
.conf
.power_level
;
1289 control
->antenna_sel_tx
= local
->hw
.conf
.antenna_sel_tx
;
1290 if (local
->sta_antenna_sel
!= STA_ANTENNA_SEL_AUTO
&& tx
->sta
)
1291 control
->antenna_sel_tx
= tx
->sta
->antenna_sel_tx
;
1293 /* process and remove the injection radiotap header */
1294 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1295 if (unlikely(sdata
->type
== IEEE80211_IF_TYPE_MNTR
)) {
1296 if (__ieee80211_parse_tx_radiotap(tx
, skb
, control
) ==
1301 * we removed the radiotap header after this point,
1302 * we filled control with what we could use
1303 * set to the actual ieee header now
1305 hdr
= (struct ieee80211_hdr
*) skb
->data
;
1306 res
= TXRX_QUEUED
; /* indication it was monitor packet */
1309 tx
->u
.tx
.control
= control
;
1310 tx
->u
.tx
.unicast
= !is_multicast_ether_addr(hdr
->addr1
);
1311 if (is_multicast_ether_addr(hdr
->addr1
))
1312 control
->flags
|= IEEE80211_TXCTL_NO_ACK
;
1314 control
->flags
&= ~IEEE80211_TXCTL_NO_ACK
;
1315 tx
->fragmented
= local
->fragmentation_threshold
<
1316 IEEE80211_MAX_FRAG_THRESHOLD
&& tx
->u
.tx
.unicast
&&
1317 skb
->len
+ FCS_LEN
> local
->fragmentation_threshold
&&
1318 (!local
->ops
->set_frag_threshold
);
1320 control
->flags
|= IEEE80211_TXCTL_CLEAR_DST_MASK
;
1321 else if (tx
->sta
->clear_dst_mask
) {
1322 control
->flags
|= IEEE80211_TXCTL_CLEAR_DST_MASK
;
1323 tx
->sta
->clear_dst_mask
= 0;
1325 hdrlen
= ieee80211_get_hdrlen(tx
->fc
);
1326 if (skb
->len
> hdrlen
+ sizeof(rfc1042_header
) + 2) {
1327 u8
*pos
= &skb
->data
[hdrlen
+ sizeof(rfc1042_header
)];
1328 tx
->ethertype
= (pos
[0] << 8) | pos
[1];
1330 control
->flags
|= IEEE80211_TXCTL_FIRST_FRAGMENT
;
1335 static int inline is_ieee80211_device(struct net_device
*dev
,
1336 struct net_device
*master
)
1338 return (wdev_priv(dev
->ieee80211_ptr
) ==
1339 wdev_priv(master
->ieee80211_ptr
));
1342 /* Device in tx->dev has a reference added; use dev_put(tx->dev) when
1343 * finished with it. */
1344 static int inline ieee80211_tx_prepare(struct ieee80211_txrx_data
*tx
,
1345 struct sk_buff
*skb
,
1346 struct net_device
*mdev
,
1347 struct ieee80211_tx_control
*control
)
1349 struct ieee80211_tx_packet_data
*pkt_data
;
1350 struct net_device
*dev
;
1352 pkt_data
= (struct ieee80211_tx_packet_data
*)skb
->cb
;
1353 dev
= dev_get_by_index(pkt_data
->ifindex
);
1354 if (unlikely(dev
&& !is_ieee80211_device(dev
, mdev
))) {
1360 __ieee80211_tx_prepare(tx
, skb
, dev
, control
);
1364 static inline int __ieee80211_queue_stopped(const struct ieee80211_local
*local
,
1367 return test_bit(IEEE80211_LINK_STATE_XOFF
, &local
->state
[queue
]);
1370 static inline int __ieee80211_queue_pending(const struct ieee80211_local
*local
,
1373 return test_bit(IEEE80211_LINK_STATE_PENDING
, &local
->state
[queue
]);
1376 #define IEEE80211_TX_OK 0
1377 #define IEEE80211_TX_AGAIN 1
1378 #define IEEE80211_TX_FRAG_AGAIN 2
1380 static int __ieee80211_tx(struct ieee80211_local
*local
, struct sk_buff
*skb
,
1381 struct ieee80211_txrx_data
*tx
)
1383 struct ieee80211_tx_control
*control
= tx
->u
.tx
.control
;
1386 if (!ieee80211_qdisc_installed(local
->mdev
) &&
1387 __ieee80211_queue_stopped(local
, 0)) {
1388 netif_stop_queue(local
->mdev
);
1389 return IEEE80211_TX_AGAIN
;
1392 ieee80211_dump_frame(local
->mdev
->name
, "TX to low-level driver", skb
);
1393 ret
= local
->ops
->tx(local_to_hw(local
), skb
, control
);
1395 return IEEE80211_TX_AGAIN
;
1396 local
->mdev
->trans_start
= jiffies
;
1397 ieee80211_led_tx(local
, 1);
1399 if (tx
->u
.tx
.extra_frag
) {
1400 control
->flags
&= ~(IEEE80211_TXCTL_USE_RTS_CTS
|
1401 IEEE80211_TXCTL_USE_CTS_PROTECT
|
1402 IEEE80211_TXCTL_CLEAR_DST_MASK
|
1403 IEEE80211_TXCTL_FIRST_FRAGMENT
);
1404 for (i
= 0; i
< tx
->u
.tx
.num_extra_frag
; i
++) {
1405 if (!tx
->u
.tx
.extra_frag
[i
])
1407 if (__ieee80211_queue_stopped(local
, control
->queue
))
1408 return IEEE80211_TX_FRAG_AGAIN
;
1409 if (i
== tx
->u
.tx
.num_extra_frag
) {
1410 control
->tx_rate
= tx
->u
.tx
.last_frag_hwrate
;
1411 control
->rate
= tx
->u
.tx
.last_frag_rate
;
1412 if (tx
->u
.tx
.probe_last_frag
)
1414 IEEE80211_TXCTL_RATE_CTRL_PROBE
;
1417 ~IEEE80211_TXCTL_RATE_CTRL_PROBE
;
1420 ieee80211_dump_frame(local
->mdev
->name
,
1421 "TX to low-level driver",
1422 tx
->u
.tx
.extra_frag
[i
]);
1423 ret
= local
->ops
->tx(local_to_hw(local
),
1424 tx
->u
.tx
.extra_frag
[i
],
1427 return IEEE80211_TX_FRAG_AGAIN
;
1428 local
->mdev
->trans_start
= jiffies
;
1429 ieee80211_led_tx(local
, 1);
1430 tx
->u
.tx
.extra_frag
[i
] = NULL
;
1432 kfree(tx
->u
.tx
.extra_frag
);
1433 tx
->u
.tx
.extra_frag
= NULL
;
1435 return IEEE80211_TX_OK
;
1438 static int ieee80211_tx(struct net_device
*dev
, struct sk_buff
*skb
,
1439 struct ieee80211_tx_control
*control
, int mgmt
)
1441 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1442 struct sta_info
*sta
;
1443 ieee80211_tx_handler
*handler
;
1444 struct ieee80211_txrx_data tx
;
1445 ieee80211_txrx_result res
= TXRX_DROP
, res_prepare
;
1448 WARN_ON(__ieee80211_queue_pending(local
, control
->queue
));
1450 if (unlikely(skb
->len
< 10)) {
1455 res_prepare
= __ieee80211_tx_prepare(&tx
, skb
, dev
, control
);
1457 if (res_prepare
== TXRX_DROP
) {
1463 tx
.u
.tx
.mgmt_interface
= mgmt
;
1464 tx
.u
.tx
.mode
= local
->hw
.conf
.mode
;
1466 if (res_prepare
== TXRX_QUEUED
) { /* if it was an injected packet */
1467 res
= TXRX_CONTINUE
;
1469 for (handler
= local
->tx_handlers
; *handler
!= NULL
;
1471 res
= (*handler
)(&tx
);
1472 if (res
!= TXRX_CONTINUE
)
1477 skb
= tx
.skb
; /* handlers are allowed to change skb */
1482 if (unlikely(res
== TXRX_DROP
)) {
1483 I802_DEBUG_INC(local
->tx_handlers_drop
);
1487 if (unlikely(res
== TXRX_QUEUED
)) {
1488 I802_DEBUG_INC(local
->tx_handlers_queued
);
1492 if (tx
.u
.tx
.extra_frag
) {
1493 for (i
= 0; i
< tx
.u
.tx
.num_extra_frag
; i
++) {
1495 struct ieee80211_hdr
*hdr
=
1496 (struct ieee80211_hdr
*)
1497 tx
.u
.tx
.extra_frag
[i
]->data
;
1499 if (i
+ 1 < tx
.u
.tx
.num_extra_frag
) {
1500 next_len
= tx
.u
.tx
.extra_frag
[i
+ 1]->len
;
1503 tx
.u
.tx
.rate
= tx
.u
.tx
.last_frag_rate
;
1504 tx
.u
.tx
.last_frag_hwrate
= tx
.u
.tx
.rate
->val
;
1506 dur
= ieee80211_duration(&tx
, 0, next_len
);
1507 hdr
->duration_id
= cpu_to_le16(dur
);
1512 ret
= __ieee80211_tx(local
, skb
, &tx
);
1514 struct ieee80211_tx_stored_packet
*store
=
1515 &local
->pending_packet
[control
->queue
];
1517 if (ret
== IEEE80211_TX_FRAG_AGAIN
)
1519 set_bit(IEEE80211_LINK_STATE_PENDING
,
1520 &local
->state
[control
->queue
]);
1522 /* When the driver gets out of buffers during sending of
1523 * fragments and calls ieee80211_stop_queue, there is
1524 * a small window between IEEE80211_LINK_STATE_XOFF and
1525 * IEEE80211_LINK_STATE_PENDING flags are set. If a buffer
1526 * gets available in that window (i.e. driver calls
1527 * ieee80211_wake_queue), we would end up with ieee80211_tx
1528 * called with IEEE80211_LINK_STATE_PENDING. Prevent this by
1529 * continuing transmitting here when that situation is
1530 * possible to have happened. */
1531 if (!__ieee80211_queue_stopped(local
, control
->queue
)) {
1532 clear_bit(IEEE80211_LINK_STATE_PENDING
,
1533 &local
->state
[control
->queue
]);
1536 memcpy(&store
->control
, control
,
1537 sizeof(struct ieee80211_tx_control
));
1539 store
->extra_frag
= tx
.u
.tx
.extra_frag
;
1540 store
->num_extra_frag
= tx
.u
.tx
.num_extra_frag
;
1541 store
->last_frag_hwrate
= tx
.u
.tx
.last_frag_hwrate
;
1542 store
->last_frag_rate
= tx
.u
.tx
.last_frag_rate
;
1543 store
->last_frag_rate_ctrl_probe
= tx
.u
.tx
.probe_last_frag
;
1550 for (i
= 0; i
< tx
.u
.tx
.num_extra_frag
; i
++)
1551 if (tx
.u
.tx
.extra_frag
[i
])
1552 dev_kfree_skb(tx
.u
.tx
.extra_frag
[i
]);
1553 kfree(tx
.u
.tx
.extra_frag
);
1557 static void ieee80211_tx_pending(unsigned long data
)
1559 struct ieee80211_local
*local
= (struct ieee80211_local
*)data
;
1560 struct net_device
*dev
= local
->mdev
;
1561 struct ieee80211_tx_stored_packet
*store
;
1562 struct ieee80211_txrx_data tx
;
1563 int i
, ret
, reschedule
= 0;
1565 netif_tx_lock_bh(dev
);
1566 for (i
= 0; i
< local
->hw
.queues
; i
++) {
1567 if (__ieee80211_queue_stopped(local
, i
))
1569 if (!__ieee80211_queue_pending(local
, i
)) {
1573 store
= &local
->pending_packet
[i
];
1574 tx
.u
.tx
.control
= &store
->control
;
1575 tx
.u
.tx
.extra_frag
= store
->extra_frag
;
1576 tx
.u
.tx
.num_extra_frag
= store
->num_extra_frag
;
1577 tx
.u
.tx
.last_frag_hwrate
= store
->last_frag_hwrate
;
1578 tx
.u
.tx
.last_frag_rate
= store
->last_frag_rate
;
1579 tx
.u
.tx
.probe_last_frag
= store
->last_frag_rate_ctrl_probe
;
1580 ret
= __ieee80211_tx(local
, store
->skb
, &tx
);
1582 if (ret
== IEEE80211_TX_FRAG_AGAIN
)
1585 clear_bit(IEEE80211_LINK_STATE_PENDING
,
1590 netif_tx_unlock_bh(dev
);
1592 if (!ieee80211_qdisc_installed(dev
)) {
1593 if (!__ieee80211_queue_stopped(local
, 0))
1594 netif_wake_queue(dev
);
1596 netif_schedule(dev
);
1600 static void ieee80211_clear_tx_pending(struct ieee80211_local
*local
)
1603 struct ieee80211_tx_stored_packet
*store
;
1605 for (i
= 0; i
< local
->hw
.queues
; i
++) {
1606 if (!__ieee80211_queue_pending(local
, i
))
1608 store
= &local
->pending_packet
[i
];
1609 kfree_skb(store
->skb
);
1610 for (j
= 0; j
< store
->num_extra_frag
; j
++)
1611 kfree_skb(store
->extra_frag
[j
]);
1612 kfree(store
->extra_frag
);
1613 clear_bit(IEEE80211_LINK_STATE_PENDING
, &local
->state
[i
]);
1617 static int ieee80211_master_start_xmit(struct sk_buff
*skb
,
1618 struct net_device
*dev
)
1620 struct ieee80211_tx_control control
;
1621 struct ieee80211_tx_packet_data
*pkt_data
;
1622 struct net_device
*odev
= NULL
;
1623 struct ieee80211_sub_if_data
*osdata
;
1628 * copy control out of the skb so other people can use skb->cb
1630 pkt_data
= (struct ieee80211_tx_packet_data
*)skb
->cb
;
1631 memset(&control
, 0, sizeof(struct ieee80211_tx_control
));
1633 if (pkt_data
->ifindex
)
1634 odev
= dev_get_by_index(pkt_data
->ifindex
);
1635 if (unlikely(odev
&& !is_ieee80211_device(odev
, dev
))) {
1639 if (unlikely(!odev
)) {
1640 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1641 printk(KERN_DEBUG
"%s: Discarded packet with nonexistent "
1642 "originating device\n", dev
->name
);
1647 osdata
= IEEE80211_DEV_TO_SUB_IF(odev
);
1649 headroom
= osdata
->local
->tx_headroom
+ IEEE80211_ENCRYPT_HEADROOM
;
1650 if (skb_headroom(skb
) < headroom
) {
1651 if (pskb_expand_head(skb
, headroom
, 0, GFP_ATOMIC
)) {
1658 control
.ifindex
= odev
->ifindex
;
1659 control
.type
= osdata
->type
;
1660 if (pkt_data
->req_tx_status
)
1661 control
.flags
|= IEEE80211_TXCTL_REQ_TX_STATUS
;
1662 if (pkt_data
->do_not_encrypt
)
1663 control
.flags
|= IEEE80211_TXCTL_DO_NOT_ENCRYPT
;
1664 if (pkt_data
->requeue
)
1665 control
.flags
|= IEEE80211_TXCTL_REQUEUE
;
1666 control
.queue
= pkt_data
->queue
;
1668 ret
= ieee80211_tx(odev
, skb
, &control
,
1669 control
.type
== IEEE80211_IF_TYPE_MGMT
);
1676 int ieee80211_monitor_start_xmit(struct sk_buff
*skb
,
1677 struct net_device
*dev
)
1679 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1680 struct ieee80211_tx_packet_data
*pkt_data
;
1681 struct ieee80211_radiotap_header
*prthdr
=
1682 (struct ieee80211_radiotap_header
*)skb
->data
;
1685 /* check for not even having the fixed radiotap header part */
1686 if (unlikely(skb
->len
< sizeof(struct ieee80211_radiotap_header
)))
1687 goto fail
; /* too short to be possibly valid */
1689 /* is it a header version we can trust to find length from? */
1690 if (unlikely(prthdr
->it_version
))
1691 goto fail
; /* only version 0 is supported */
1693 /* then there must be a radiotap header with a length we can use */
1694 len_rthdr
= ieee80211_get_radiotap_len(skb
);
1696 /* does the skb contain enough to deliver on the alleged length? */
1697 if (unlikely(skb
->len
< len_rthdr
))
1698 goto fail
; /* skb too short for claimed rt header extent */
1700 skb
->dev
= local
->mdev
;
1702 pkt_data
= (struct ieee80211_tx_packet_data
*)skb
->cb
;
1703 memset(pkt_data
, 0, sizeof(*pkt_data
));
1704 /* needed because we set skb device to master */
1705 pkt_data
->ifindex
= dev
->ifindex
;
1707 pkt_data
->mgmt_iface
= 0;
1708 pkt_data
->do_not_encrypt
= 1;
1711 * fix up the pointers accounting for the radiotap
1712 * header still being in there. We are being given
1713 * a precooked IEEE80211 header so no need for
1716 skb_set_mac_header(skb
, len_rthdr
);
1718 * these are just fixed to the end of the rt area since we
1719 * don't have any better information and at this point, nobody cares
1721 skb_set_network_header(skb
, len_rthdr
);
1722 skb_set_transport_header(skb
, len_rthdr
);
1724 /* pass the radiotap header up to the next stage intact */
1725 dev_queue_xmit(skb
);
1726 return NETDEV_TX_OK
;
1730 return NETDEV_TX_OK
; /* meaning, we dealt with the skb */
1735 * ieee80211_subif_start_xmit - netif start_xmit function for Ethernet-type
1736 * subinterfaces (wlan#, WDS, and VLAN interfaces)
1737 * @skb: packet to be sent
1738 * @dev: incoming interface
1740 * Returns: 0 on success (and frees skb in this case) or 1 on failure (skb will
1741 * not be freed, and caller is responsible for either retrying later or freeing
1744 * This function takes in an Ethernet header and encapsulates it with suitable
1745 * IEEE 802.11 header based on which interface the packet is coming in. The
1746 * encapsulated packet will then be passed to master interface, wlan#.11, for
1747 * transmission (through low-level driver).
1749 int ieee80211_subif_start_xmit(struct sk_buff
*skb
,
1750 struct net_device
*dev
)
1752 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1753 struct ieee80211_tx_packet_data
*pkt_data
;
1754 struct ieee80211_sub_if_data
*sdata
;
1755 int ret
= 1, head_need
;
1756 u16 ethertype
, hdrlen
, fc
;
1757 struct ieee80211_hdr hdr
;
1758 const u8
*encaps_data
;
1759 int encaps_len
, skip_header_bytes
;
1760 int nh_pos
, h_pos
, no_encrypt
= 0;
1761 struct sta_info
*sta
;
1763 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1764 if (unlikely(skb
->len
< ETH_HLEN
)) {
1765 printk(KERN_DEBUG
"%s: short skb (len=%d)\n",
1766 dev
->name
, skb
->len
);
1771 nh_pos
= skb_network_header(skb
) - skb
->data
;
1772 h_pos
= skb_transport_header(skb
) - skb
->data
;
1774 /* convert Ethernet header to proper 802.11 header (based on
1775 * operation mode) */
1776 ethertype
= (skb
->data
[12] << 8) | skb
->data
[13];
1777 /* TODO: handling for 802.1x authorized/unauthorized port */
1778 fc
= IEEE80211_FTYPE_DATA
| IEEE80211_STYPE_DATA
;
1780 if (likely(sdata
->type
== IEEE80211_IF_TYPE_AP
||
1781 sdata
->type
== IEEE80211_IF_TYPE_VLAN
)) {
1782 fc
|= IEEE80211_FCTL_FROMDS
;
1784 memcpy(hdr
.addr1
, skb
->data
, ETH_ALEN
);
1785 memcpy(hdr
.addr2
, dev
->dev_addr
, ETH_ALEN
);
1786 memcpy(hdr
.addr3
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
1788 } else if (sdata
->type
== IEEE80211_IF_TYPE_WDS
) {
1789 fc
|= IEEE80211_FCTL_FROMDS
| IEEE80211_FCTL_TODS
;
1791 memcpy(hdr
.addr1
, sdata
->u
.wds
.remote_addr
, ETH_ALEN
);
1792 memcpy(hdr
.addr2
, dev
->dev_addr
, ETH_ALEN
);
1793 memcpy(hdr
.addr3
, skb
->data
, ETH_ALEN
);
1794 memcpy(hdr
.addr4
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
1796 } else if (sdata
->type
== IEEE80211_IF_TYPE_STA
) {
1797 fc
|= IEEE80211_FCTL_TODS
;
1799 memcpy(hdr
.addr1
, sdata
->u
.sta
.bssid
, ETH_ALEN
);
1800 memcpy(hdr
.addr2
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
1801 memcpy(hdr
.addr3
, skb
->data
, ETH_ALEN
);
1803 } else if (sdata
->type
== IEEE80211_IF_TYPE_IBSS
) {
1805 memcpy(hdr
.addr1
, skb
->data
, ETH_ALEN
);
1806 memcpy(hdr
.addr2
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
1807 memcpy(hdr
.addr3
, sdata
->u
.sta
.bssid
, ETH_ALEN
);
1814 /* receiver is QoS enabled, use a QoS type frame */
1815 sta
= sta_info_get(local
, hdr
.addr1
);
1817 if (sta
->flags
& WLAN_STA_WME
) {
1818 fc
|= IEEE80211_STYPE_QOS_DATA
;
1824 hdr
.frame_control
= cpu_to_le16(fc
);
1825 hdr
.duration_id
= 0;
1828 skip_header_bytes
= ETH_HLEN
;
1829 if (ethertype
== ETH_P_AARP
|| ethertype
== ETH_P_IPX
) {
1830 encaps_data
= bridge_tunnel_header
;
1831 encaps_len
= sizeof(bridge_tunnel_header
);
1832 skip_header_bytes
-= 2;
1833 } else if (ethertype
>= 0x600) {
1834 encaps_data
= rfc1042_header
;
1835 encaps_len
= sizeof(rfc1042_header
);
1836 skip_header_bytes
-= 2;
1842 skb_pull(skb
, skip_header_bytes
);
1843 nh_pos
-= skip_header_bytes
;
1844 h_pos
-= skip_header_bytes
;
1846 /* TODO: implement support for fragments so that there is no need to
1847 * reallocate and copy payload; it might be enough to support one
1848 * extra fragment that would be copied in the beginning of the frame
1849 * data.. anyway, it would be nice to include this into skb structure
1852 * There are few options for this:
1853 * use skb->cb as an extra space for 802.11 header
1854 * allocate new buffer if not enough headroom
1855 * make sure that there is enough headroom in every skb by increasing
1856 * build in headroom in __dev_alloc_skb() (linux/skbuff.h) and
1857 * alloc_skb() (net/core/skbuff.c)
1859 head_need
= hdrlen
+ encaps_len
+ local
->tx_headroom
;
1860 head_need
-= skb_headroom(skb
);
1862 /* We are going to modify skb data, so make a copy of it if happens to
1863 * be cloned. This could happen, e.g., with Linux bridge code passing
1864 * us broadcast frames. */
1866 if (head_need
> 0 || skb_cloned(skb
)) {
1868 printk(KERN_DEBUG
"%s: need to reallocate buffer for %d bytes "
1869 "of headroom\n", dev
->name
, head_need
);
1872 if (skb_cloned(skb
))
1873 I802_DEBUG_INC(local
->tx_expand_skb_head_cloned
);
1875 I802_DEBUG_INC(local
->tx_expand_skb_head
);
1876 /* Since we have to reallocate the buffer, make sure that there
1877 * is enough room for possible WEP IV/ICV and TKIP (8 bytes
1878 * before payload and 12 after). */
1879 if (pskb_expand_head(skb
, (head_need
> 0 ? head_need
+ 8 : 8),
1881 printk(KERN_DEBUG
"%s: failed to reallocate TX buffer"
1888 memcpy(skb_push(skb
, encaps_len
), encaps_data
, encaps_len
);
1889 nh_pos
+= encaps_len
;
1890 h_pos
+= encaps_len
;
1892 memcpy(skb_push(skb
, hdrlen
), &hdr
, hdrlen
);
1896 pkt_data
= (struct ieee80211_tx_packet_data
*)skb
->cb
;
1897 memset(pkt_data
, 0, sizeof(struct ieee80211_tx_packet_data
));
1898 pkt_data
->ifindex
= dev
->ifindex
;
1899 pkt_data
->mgmt_iface
= (sdata
->type
== IEEE80211_IF_TYPE_MGMT
);
1900 pkt_data
->do_not_encrypt
= no_encrypt
;
1902 skb
->dev
= local
->mdev
;
1903 sdata
->stats
.tx_packets
++;
1904 sdata
->stats
.tx_bytes
+= skb
->len
;
1906 /* Update skb pointers to various headers since this modified frame
1907 * is going to go through Linux networking code that may potentially
1908 * need things like pointer to IP header. */
1909 skb_set_mac_header(skb
, 0);
1910 skb_set_network_header(skb
, nh_pos
);
1911 skb_set_transport_header(skb
, h_pos
);
1913 dev
->trans_start
= jiffies
;
1914 dev_queue_xmit(skb
);
1927 * This is the transmit routine for the 802.11 type interfaces
1928 * called by upper layers of the linux networking
1929 * stack when it has a frame to transmit
1932 ieee80211_mgmt_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1934 struct ieee80211_sub_if_data
*sdata
;
1935 struct ieee80211_tx_packet_data
*pkt_data
;
1936 struct ieee80211_hdr
*hdr
;
1939 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1941 if (skb
->len
< 10) {
1946 if (skb_headroom(skb
) < sdata
->local
->tx_headroom
) {
1947 if (pskb_expand_head(skb
, sdata
->local
->tx_headroom
,
1954 hdr
= (struct ieee80211_hdr
*) skb
->data
;
1955 fc
= le16_to_cpu(hdr
->frame_control
);
1957 pkt_data
= (struct ieee80211_tx_packet_data
*) skb
->cb
;
1958 memset(pkt_data
, 0, sizeof(struct ieee80211_tx_packet_data
));
1959 pkt_data
->ifindex
= sdata
->dev
->ifindex
;
1960 pkt_data
->mgmt_iface
= (sdata
->type
== IEEE80211_IF_TYPE_MGMT
);
1962 skb
->priority
= 20; /* use hardcoded priority for mgmt TX queue */
1963 skb
->dev
= sdata
->local
->mdev
;
1966 * We're using the protocol field of the the frame control header
1967 * to request TX callback for hostapd. BIT(1) is checked.
1969 if ((fc
& BIT(1)) == BIT(1)) {
1970 pkt_data
->req_tx_status
= 1;
1972 hdr
->frame_control
= cpu_to_le16(fc
);
1975 pkt_data
->do_not_encrypt
= !(fc
& IEEE80211_FCTL_PROTECTED
);
1977 sdata
->stats
.tx_packets
++;
1978 sdata
->stats
.tx_bytes
+= skb
->len
;
1980 dev_queue_xmit(skb
);
1986 static void ieee80211_beacon_add_tim(struct ieee80211_local
*local
,
1987 struct ieee80211_if_ap
*bss
,
1988 struct sk_buff
*skb
)
1992 int i
, have_bits
= 0, n1
, n2
;
1994 /* Generate bitmap for TIM only if there are any STAs in power save
1996 spin_lock_bh(&local
->sta_lock
);
1997 if (atomic_read(&bss
->num_sta_ps
) > 0)
1998 /* in the hope that this is faster than
1999 * checking byte-for-byte */
2000 have_bits
= !bitmap_empty((unsigned long*)bss
->tim
,
2001 IEEE80211_MAX_AID
+1);
2003 if (bss
->dtim_count
== 0)
2004 bss
->dtim_count
= bss
->dtim_period
- 1;
2008 tim
= pos
= (u8
*) skb_put(skb
, 6);
2009 *pos
++ = WLAN_EID_TIM
;
2011 *pos
++ = bss
->dtim_count
;
2012 *pos
++ = bss
->dtim_period
;
2014 if (bss
->dtim_count
== 0 && !skb_queue_empty(&bss
->ps_bc_buf
))
2018 /* Find largest even number N1 so that bits numbered 1 through
2019 * (N1 x 8) - 1 in the bitmap are 0 and number N2 so that bits
2020 * (N2 + 1) x 8 through 2007 are 0. */
2022 for (i
= 0; i
< IEEE80211_MAX_TIM_LEN
; i
++) {
2029 for (i
= IEEE80211_MAX_TIM_LEN
- 1; i
>= n1
; i
--) {
2036 /* Bitmap control */
2038 /* Part Virt Bitmap */
2039 memcpy(pos
, bss
->tim
+ n1
, n2
- n1
+ 1);
2041 tim
[1] = n2
- n1
+ 4;
2042 skb_put(skb
, n2
- n1
);
2044 *pos
++ = aid0
; /* Bitmap control */
2045 *pos
++ = 0; /* Part Virt Bitmap */
2047 spin_unlock_bh(&local
->sta_lock
);
2051 struct sk_buff
* ieee80211_beacon_get(struct ieee80211_hw
*hw
, int if_id
,
2052 struct ieee80211_tx_control
*control
)
2054 struct ieee80211_local
*local
= hw_to_local(hw
);
2055 struct sk_buff
*skb
;
2056 struct net_device
*bdev
;
2057 struct ieee80211_sub_if_data
*sdata
= NULL
;
2058 struct ieee80211_if_ap
*ap
= NULL
;
2059 struct ieee80211_rate
*rate
;
2060 struct rate_control_extra extra
;
2061 u8
*b_head
, *b_tail
;
2064 bdev
= dev_get_by_index(if_id
);
2066 sdata
= IEEE80211_DEV_TO_SUB_IF(bdev
);
2071 if (!ap
|| sdata
->type
!= IEEE80211_IF_TYPE_AP
||
2073 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2074 if (net_ratelimit())
2075 printk(KERN_DEBUG
"no beacon data avail for idx=%d "
2076 "(%s)\n", if_id
, bdev
? bdev
->name
: "N/A");
2077 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
2081 /* Assume we are generating the normal beacon locally */
2082 b_head
= ap
->beacon_head
;
2083 b_tail
= ap
->beacon_tail
;
2084 bh_len
= ap
->beacon_head_len
;
2085 bt_len
= ap
->beacon_tail_len
;
2087 skb
= dev_alloc_skb(local
->tx_headroom
+
2088 bh_len
+ bt_len
+ 256 /* maximum TIM len */);
2092 skb_reserve(skb
, local
->tx_headroom
);
2093 memcpy(skb_put(skb
, bh_len
), b_head
, bh_len
);
2095 ieee80211_include_sequence(sdata
, (struct ieee80211_hdr
*)skb
->data
);
2097 ieee80211_beacon_add_tim(local
, ap
, skb
);
2100 memcpy(skb_put(skb
, bt_len
), b_tail
, bt_len
);
2104 memset(&extra
, 0, sizeof(extra
));
2105 extra
.mode
= local
->oper_hw_mode
;
2107 rate
= rate_control_get_rate(local
, local
->mdev
, skb
, &extra
);
2109 if (net_ratelimit()) {
2110 printk(KERN_DEBUG
"%s: ieee80211_beacon_get: no rate "
2111 "found\n", local
->mdev
->name
);
2117 control
->tx_rate
= (local
->short_preamble
&&
2118 (rate
->flags
& IEEE80211_RATE_PREAMBLE2
)) ?
2119 rate
->val2
: rate
->val
;
2120 control
->antenna_sel_tx
= local
->hw
.conf
.antenna_sel_tx
;
2121 control
->power_level
= local
->hw
.conf
.power_level
;
2122 control
->flags
|= IEEE80211_TXCTL_NO_ACK
;
2123 control
->retry_limit
= 1;
2124 control
->flags
|= IEEE80211_TXCTL_CLEAR_DST_MASK
;
2130 EXPORT_SYMBOL(ieee80211_beacon_get
);
2132 __le16
ieee80211_rts_duration(struct ieee80211_hw
*hw
,
2134 const struct ieee80211_tx_control
*frame_txctl
)
2136 struct ieee80211_local
*local
= hw_to_local(hw
);
2137 struct ieee80211_rate
*rate
;
2138 int short_preamble
= local
->short_preamble
;
2142 rate
= frame_txctl
->rts_rate
;
2143 erp
= !!(rate
->flags
& IEEE80211_RATE_ERP
);
2146 dur
= ieee80211_frame_duration(local
, 10, rate
->rate
,
2147 erp
, short_preamble
);
2148 /* Data frame duration */
2149 dur
+= ieee80211_frame_duration(local
, frame_len
, rate
->rate
,
2150 erp
, short_preamble
);
2152 dur
+= ieee80211_frame_duration(local
, 10, rate
->rate
,
2153 erp
, short_preamble
);
2155 return cpu_to_le16(dur
);
2157 EXPORT_SYMBOL(ieee80211_rts_duration
);
2160 __le16
ieee80211_ctstoself_duration(struct ieee80211_hw
*hw
,
2162 const struct ieee80211_tx_control
*frame_txctl
)
2164 struct ieee80211_local
*local
= hw_to_local(hw
);
2165 struct ieee80211_rate
*rate
;
2166 int short_preamble
= local
->short_preamble
;
2170 rate
= frame_txctl
->rts_rate
;
2171 erp
= !!(rate
->flags
& IEEE80211_RATE_ERP
);
2173 /* Data frame duration */
2174 dur
= ieee80211_frame_duration(local
, frame_len
, rate
->rate
,
2175 erp
, short_preamble
);
2176 if (!(frame_txctl
->flags
& IEEE80211_TXCTL_NO_ACK
)) {
2178 dur
+= ieee80211_frame_duration(local
, 10, rate
->rate
,
2179 erp
, short_preamble
);
2182 return cpu_to_le16(dur
);
2184 EXPORT_SYMBOL(ieee80211_ctstoself_duration
);
2186 void ieee80211_rts_get(struct ieee80211_hw
*hw
,
2187 const void *frame
, size_t frame_len
,
2188 const struct ieee80211_tx_control
*frame_txctl
,
2189 struct ieee80211_rts
*rts
)
2191 const struct ieee80211_hdr
*hdr
= frame
;
2194 fctl
= IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_RTS
;
2195 rts
->frame_control
= cpu_to_le16(fctl
);
2196 rts
->duration
= ieee80211_rts_duration(hw
, frame_len
, frame_txctl
);
2197 memcpy(rts
->ra
, hdr
->addr1
, sizeof(rts
->ra
));
2198 memcpy(rts
->ta
, hdr
->addr2
, sizeof(rts
->ta
));
2200 EXPORT_SYMBOL(ieee80211_rts_get
);
2202 void ieee80211_ctstoself_get(struct ieee80211_hw
*hw
,
2203 const void *frame
, size_t frame_len
,
2204 const struct ieee80211_tx_control
*frame_txctl
,
2205 struct ieee80211_cts
*cts
)
2207 const struct ieee80211_hdr
*hdr
= frame
;
2210 fctl
= IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_CTS
;
2211 cts
->frame_control
= cpu_to_le16(fctl
);
2212 cts
->duration
= ieee80211_ctstoself_duration(hw
, frame_len
, frame_txctl
);
2213 memcpy(cts
->ra
, hdr
->addr1
, sizeof(cts
->ra
));
2215 EXPORT_SYMBOL(ieee80211_ctstoself_get
);
2218 ieee80211_get_buffered_bc(struct ieee80211_hw
*hw
, int if_id
,
2219 struct ieee80211_tx_control
*control
)
2221 struct ieee80211_local
*local
= hw_to_local(hw
);
2222 struct sk_buff
*skb
;
2223 struct sta_info
*sta
;
2224 ieee80211_tx_handler
*handler
;
2225 struct ieee80211_txrx_data tx
;
2226 ieee80211_txrx_result res
= TXRX_DROP
;
2227 struct net_device
*bdev
;
2228 struct ieee80211_sub_if_data
*sdata
;
2229 struct ieee80211_if_ap
*bss
= NULL
;
2231 bdev
= dev_get_by_index(if_id
);
2233 sdata
= IEEE80211_DEV_TO_SUB_IF(bdev
);
2237 if (!bss
|| sdata
->type
!= IEEE80211_IF_TYPE_AP
|| !bss
->beacon_head
)
2240 if (bss
->dtim_count
!= 0)
2241 return NULL
; /* send buffered bc/mc only after DTIM beacon */
2242 memset(control
, 0, sizeof(*control
));
2244 skb
= skb_dequeue(&bss
->ps_bc_buf
);
2247 local
->total_ps_buffered
--;
2249 if (!skb_queue_empty(&bss
->ps_bc_buf
) && skb
->len
>= 2) {
2250 struct ieee80211_hdr
*hdr
=
2251 (struct ieee80211_hdr
*) skb
->data
;
2252 /* more buffered multicast/broadcast frames ==> set
2253 * MoreData flag in IEEE 802.11 header to inform PS
2255 hdr
->frame_control
|=
2256 cpu_to_le16(IEEE80211_FCTL_MOREDATA
);
2259 if (ieee80211_tx_prepare(&tx
, skb
, local
->mdev
, control
) == 0)
2261 dev_kfree_skb_any(skb
);
2264 tx
.u
.tx
.ps_buffered
= 1;
2266 for (handler
= local
->tx_handlers
; *handler
!= NULL
; handler
++) {
2267 res
= (*handler
)(&tx
);
2268 if (res
== TXRX_DROP
|| res
== TXRX_QUEUED
)
2272 skb
= tx
.skb
; /* handlers are allowed to change skb */
2274 if (res
== TXRX_DROP
) {
2275 I802_DEBUG_INC(local
->tx_handlers_drop
);
2278 } else if (res
== TXRX_QUEUED
) {
2279 I802_DEBUG_INC(local
->tx_handlers_queued
);
2288 EXPORT_SYMBOL(ieee80211_get_buffered_bc
);
2290 static int __ieee80211_if_config(struct net_device
*dev
,
2291 struct sk_buff
*beacon
,
2292 struct ieee80211_tx_control
*control
)
2294 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2295 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2296 struct ieee80211_if_conf conf
;
2297 static u8 scan_bssid
[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2299 if (!local
->ops
->config_interface
|| !netif_running(dev
))
2302 memset(&conf
, 0, sizeof(conf
));
2303 conf
.type
= sdata
->type
;
2304 if (sdata
->type
== IEEE80211_IF_TYPE_STA
||
2305 sdata
->type
== IEEE80211_IF_TYPE_IBSS
) {
2306 if (local
->sta_scanning
&&
2307 local
->scan_dev
== dev
)
2308 conf
.bssid
= scan_bssid
;
2310 conf
.bssid
= sdata
->u
.sta
.bssid
;
2311 conf
.ssid
= sdata
->u
.sta
.ssid
;
2312 conf
.ssid_len
= sdata
->u
.sta
.ssid_len
;
2313 conf
.generic_elem
= sdata
->u
.sta
.extra_ie
;
2314 conf
.generic_elem_len
= sdata
->u
.sta
.extra_ie_len
;
2315 } else if (sdata
->type
== IEEE80211_IF_TYPE_AP
) {
2316 conf
.ssid
= sdata
->u
.ap
.ssid
;
2317 conf
.ssid_len
= sdata
->u
.ap
.ssid_len
;
2318 conf
.generic_elem
= sdata
->u
.ap
.generic_elem
;
2319 conf
.generic_elem_len
= sdata
->u
.ap
.generic_elem_len
;
2320 conf
.beacon
= beacon
;
2321 conf
.beacon_control
= control
;
2323 return local
->ops
->config_interface(local_to_hw(local
),
2324 dev
->ifindex
, &conf
);
2327 int ieee80211_if_config(struct net_device
*dev
)
2329 return __ieee80211_if_config(dev
, NULL
, NULL
);
2332 int ieee80211_if_config_beacon(struct net_device
*dev
)
2334 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2335 struct ieee80211_tx_control control
;
2336 struct sk_buff
*skb
;
2338 if (!(local
->hw
.flags
& IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE
))
2340 skb
= ieee80211_beacon_get(local_to_hw(local
), dev
->ifindex
, &control
);
2343 return __ieee80211_if_config(dev
, skb
, &control
);
2346 int ieee80211_hw_config(struct ieee80211_local
*local
)
2348 struct ieee80211_hw_mode
*mode
;
2349 struct ieee80211_channel
*chan
;
2352 if (local
->sta_scanning
) {
2353 chan
= local
->scan_channel
;
2354 mode
= local
->scan_hw_mode
;
2356 chan
= local
->oper_channel
;
2357 mode
= local
->oper_hw_mode
;
2360 local
->hw
.conf
.channel
= chan
->chan
;
2361 local
->hw
.conf
.channel_val
= chan
->val
;
2362 local
->hw
.conf
.power_level
= chan
->power_level
;
2363 local
->hw
.conf
.freq
= chan
->freq
;
2364 local
->hw
.conf
.phymode
= mode
->mode
;
2365 local
->hw
.conf
.antenna_max
= chan
->antenna_max
;
2366 local
->hw
.conf
.chan
= chan
;
2367 local
->hw
.conf
.mode
= mode
;
2369 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2370 printk(KERN_DEBUG
"HW CONFIG: channel=%d freq=%d "
2371 "phymode=%d\n", local
->hw
.conf
.channel
, local
->hw
.conf
.freq
,
2372 local
->hw
.conf
.phymode
);
2373 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
2375 if (local
->ops
->config
)
2376 ret
= local
->ops
->config(local_to_hw(local
), &local
->hw
.conf
);
2382 static int ieee80211_change_mtu(struct net_device
*dev
, int new_mtu
)
2384 /* FIX: what would be proper limits for MTU?
2385 * This interface uses 802.3 frames. */
2386 if (new_mtu
< 256 || new_mtu
> IEEE80211_MAX_DATA_LEN
- 24 - 6) {
2387 printk(KERN_WARNING
"%s: invalid MTU %d\n",
2388 dev
->name
, new_mtu
);
2392 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2393 printk(KERN_DEBUG
"%s: setting MTU %d\n", dev
->name
, new_mtu
);
2394 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
2400 static int ieee80211_change_mtu_apdev(struct net_device
*dev
, int new_mtu
)
2402 /* FIX: what would be proper limits for MTU?
2403 * This interface uses 802.11 frames. */
2404 if (new_mtu
< 256 || new_mtu
> IEEE80211_MAX_DATA_LEN
) {
2405 printk(KERN_WARNING
"%s: invalid MTU %d\n",
2406 dev
->name
, new_mtu
);
2410 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2411 printk(KERN_DEBUG
"%s: setting MTU %d\n", dev
->name
, new_mtu
);
2412 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
2417 enum netif_tx_lock_class
{
2422 static inline void netif_tx_lock_nested(struct net_device
*dev
, int subclass
)
2424 spin_lock_nested(&dev
->_xmit_lock
, subclass
);
2425 dev
->xmit_lock_owner
= smp_processor_id();
2428 static void ieee80211_set_multicast_list(struct net_device
*dev
)
2430 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2431 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2432 unsigned short flags
;
2434 netif_tx_lock_nested(local
->mdev
, TX_LOCK_MASTER
);
2435 if (((dev
->flags
& IFF_ALLMULTI
) != 0) ^ (sdata
->allmulti
!= 0)) {
2436 if (sdata
->allmulti
) {
2437 sdata
->allmulti
= 0;
2438 local
->iff_allmultis
--;
2440 sdata
->allmulti
= 1;
2441 local
->iff_allmultis
++;
2444 if (((dev
->flags
& IFF_PROMISC
) != 0) ^ (sdata
->promisc
!= 0)) {
2445 if (sdata
->promisc
) {
2447 local
->iff_promiscs
--;
2450 local
->iff_promiscs
++;
2453 if (dev
->mc_count
!= sdata
->mc_count
) {
2454 local
->mc_count
= local
->mc_count
- sdata
->mc_count
+
2456 sdata
->mc_count
= dev
->mc_count
;
2458 if (local
->ops
->set_multicast_list
) {
2459 flags
= local
->mdev
->flags
;
2460 if (local
->iff_allmultis
)
2461 flags
|= IFF_ALLMULTI
;
2462 if (local
->iff_promiscs
)
2463 flags
|= IFF_PROMISC
;
2464 read_lock(&local
->sub_if_lock
);
2465 local
->ops
->set_multicast_list(local_to_hw(local
), flags
,
2467 read_unlock(&local
->sub_if_lock
);
2469 netif_tx_unlock(local
->mdev
);
2472 struct dev_mc_list
*ieee80211_get_mc_list_item(struct ieee80211_hw
*hw
,
2473 struct dev_mc_list
*prev
,
2476 struct ieee80211_local
*local
= hw_to_local(hw
);
2477 struct ieee80211_sub_if_data
*sdata
= *ptr
;
2478 struct dev_mc_list
*mc
;
2484 if (!prev
|| !prev
->next
) {
2486 sdata
= list_entry(sdata
->list
.next
,
2487 struct ieee80211_sub_if_data
, list
);
2489 sdata
= list_entry(local
->sub_if_list
.next
,
2490 struct ieee80211_sub_if_data
, list
);
2491 if (&sdata
->list
!= &local
->sub_if_list
)
2492 mc
= sdata
->dev
->mc_list
;
2501 EXPORT_SYMBOL(ieee80211_get_mc_list_item
);
2503 static struct net_device_stats
*ieee80211_get_stats(struct net_device
*dev
)
2505 struct ieee80211_sub_if_data
*sdata
;
2506 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2507 return &(sdata
->stats
);
2510 static void ieee80211_if_shutdown(struct net_device
*dev
)
2512 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2513 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2516 switch (sdata
->type
) {
2517 case IEEE80211_IF_TYPE_STA
:
2518 case IEEE80211_IF_TYPE_IBSS
:
2519 sdata
->u
.sta
.state
= IEEE80211_DISABLED
;
2520 del_timer_sync(&sdata
->u
.sta
.timer
);
2521 skb_queue_purge(&sdata
->u
.sta
.skb_queue
);
2522 if (!local
->ops
->hw_scan
&&
2523 local
->scan_dev
== sdata
->dev
) {
2524 local
->sta_scanning
= 0;
2525 cancel_delayed_work(&local
->scan_work
);
2527 flush_workqueue(local
->hw
.workqueue
);
2532 static inline int identical_mac_addr_allowed(int type1
, int type2
)
2534 return (type1
== IEEE80211_IF_TYPE_MNTR
||
2535 type2
== IEEE80211_IF_TYPE_MNTR
||
2536 (type1
== IEEE80211_IF_TYPE_AP
&&
2537 type2
== IEEE80211_IF_TYPE_WDS
) ||
2538 (type1
== IEEE80211_IF_TYPE_WDS
&&
2539 (type2
== IEEE80211_IF_TYPE_WDS
||
2540 type2
== IEEE80211_IF_TYPE_AP
)) ||
2541 (type1
== IEEE80211_IF_TYPE_AP
&&
2542 type2
== IEEE80211_IF_TYPE_VLAN
) ||
2543 (type1
== IEEE80211_IF_TYPE_VLAN
&&
2544 (type2
== IEEE80211_IF_TYPE_AP
||
2545 type2
== IEEE80211_IF_TYPE_VLAN
)));
2548 static int ieee80211_master_open(struct net_device
*dev
)
2550 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2551 struct ieee80211_sub_if_data
*sdata
;
2552 int res
= -EOPNOTSUPP
;
2554 read_lock(&local
->sub_if_lock
);
2555 list_for_each_entry(sdata
, &local
->sub_if_list
, list
) {
2556 if (sdata
->dev
!= dev
&& netif_running(sdata
->dev
)) {
2561 read_unlock(&local
->sub_if_lock
);
2565 static int ieee80211_master_stop(struct net_device
*dev
)
2567 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2568 struct ieee80211_sub_if_data
*sdata
;
2570 read_lock(&local
->sub_if_lock
);
2571 list_for_each_entry(sdata
, &local
->sub_if_list
, list
)
2572 if (sdata
->dev
!= dev
&& netif_running(sdata
->dev
))
2573 dev_close(sdata
->dev
);
2574 read_unlock(&local
->sub_if_lock
);
2579 static int ieee80211_mgmt_open(struct net_device
*dev
)
2581 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2583 if (!netif_running(local
->mdev
))
2588 static int ieee80211_mgmt_stop(struct net_device
*dev
)
2593 /* Check if running monitor interfaces should go to a "soft monitor" mode
2594 * and switch them if necessary. */
2595 static inline void ieee80211_start_soft_monitor(struct ieee80211_local
*local
)
2597 struct ieee80211_if_init_conf conf
;
2599 if (local
->open_count
&& local
->open_count
== local
->monitors
&&
2600 !(local
->hw
.flags
& IEEE80211_HW_MONITOR_DURING_OPER
) &&
2601 local
->ops
->remove_interface
) {
2603 conf
.type
= IEEE80211_IF_TYPE_MNTR
;
2604 conf
.mac_addr
= NULL
;
2605 local
->ops
->remove_interface(local_to_hw(local
), &conf
);
2609 /* Check if running monitor interfaces should go to a "hard monitor" mode
2610 * and switch them if necessary. */
2611 static void ieee80211_start_hard_monitor(struct ieee80211_local
*local
)
2613 struct ieee80211_if_init_conf conf
;
2615 if (local
->open_count
&& local
->open_count
== local
->monitors
&&
2616 !(local
->hw
.flags
& IEEE80211_HW_MONITOR_DURING_OPER
)) {
2618 conf
.type
= IEEE80211_IF_TYPE_MNTR
;
2619 conf
.mac_addr
= NULL
;
2620 local
->ops
->add_interface(local_to_hw(local
), &conf
);
2624 static int ieee80211_open(struct net_device
*dev
)
2626 struct ieee80211_sub_if_data
*sdata
, *nsdata
;
2627 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2628 struct ieee80211_if_init_conf conf
;
2631 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2632 read_lock(&local
->sub_if_lock
);
2633 list_for_each_entry(nsdata
, &local
->sub_if_list
, list
) {
2634 struct net_device
*ndev
= nsdata
->dev
;
2636 if (ndev
!= dev
&& ndev
!= local
->mdev
&& netif_running(ndev
) &&
2637 compare_ether_addr(dev
->dev_addr
, ndev
->dev_addr
) == 0 &&
2638 !identical_mac_addr_allowed(sdata
->type
, nsdata
->type
)) {
2639 read_unlock(&local
->sub_if_lock
);
2643 read_unlock(&local
->sub_if_lock
);
2645 if (sdata
->type
== IEEE80211_IF_TYPE_WDS
&&
2646 is_zero_ether_addr(sdata
->u
.wds
.remote_addr
))
2649 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
&& local
->open_count
&&
2650 !(local
->hw
.flags
& IEEE80211_HW_MONITOR_DURING_OPER
)) {
2651 /* run the interface in a "soft monitor" mode */
2653 local
->open_count
++;
2654 local
->hw
.conf
.flags
|= IEEE80211_CONF_RADIOTAP
;
2657 ieee80211_start_soft_monitor(local
);
2659 conf
.if_id
= dev
->ifindex
;
2660 conf
.type
= sdata
->type
;
2661 conf
.mac_addr
= dev
->dev_addr
;
2662 res
= local
->ops
->add_interface(local_to_hw(local
), &conf
);
2664 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
)
2665 ieee80211_start_hard_monitor(local
);
2669 if (local
->open_count
== 0) {
2671 tasklet_enable(&local
->tx_pending_tasklet
);
2672 tasklet_enable(&local
->tasklet
);
2673 if (local
->ops
->open
)
2674 res
= local
->ops
->open(local_to_hw(local
));
2676 res
= dev_open(local
->mdev
);
2678 if (local
->ops
->stop
)
2679 local
->ops
->stop(local_to_hw(local
));
2681 res
= ieee80211_hw_config(local
);
2682 if (res
&& local
->ops
->stop
)
2683 local
->ops
->stop(local_to_hw(local
));
2684 else if (!res
&& local
->apdev
)
2685 dev_open(local
->apdev
);
2689 if (local
->ops
->remove_interface
)
2690 local
->ops
->remove_interface(local_to_hw(local
),
2695 local
->open_count
++;
2697 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
) {
2699 local
->hw
.conf
.flags
|= IEEE80211_CONF_RADIOTAP
;
2701 ieee80211_if_config(dev
);
2703 if (sdata
->type
== IEEE80211_IF_TYPE_STA
&&
2704 !local
->user_space_mlme
)
2705 netif_carrier_off(dev
);
2707 netif_carrier_on(dev
);
2709 netif_start_queue(dev
);
2714 static int ieee80211_stop(struct net_device
*dev
)
2716 struct ieee80211_sub_if_data
*sdata
;
2717 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2719 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2721 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
&&
2722 local
->open_count
> 1 &&
2723 !(local
->hw
.flags
& IEEE80211_HW_MONITOR_DURING_OPER
)) {
2724 /* remove "soft monitor" interface */
2725 local
->open_count
--;
2727 if (!local
->monitors
)
2728 local
->hw
.conf
.flags
&= ~IEEE80211_CONF_RADIOTAP
;
2732 netif_stop_queue(dev
);
2733 ieee80211_if_shutdown(dev
);
2735 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
) {
2737 if (!local
->monitors
)
2738 local
->hw
.conf
.flags
&= ~IEEE80211_CONF_RADIOTAP
;
2741 local
->open_count
--;
2742 if (local
->open_count
== 0) {
2743 if (netif_running(local
->mdev
))
2744 dev_close(local
->mdev
);
2746 dev_close(local
->apdev
);
2747 if (local
->ops
->stop
)
2748 local
->ops
->stop(local_to_hw(local
));
2749 tasklet_disable(&local
->tx_pending_tasklet
);
2750 tasklet_disable(&local
->tasklet
);
2752 if (local
->ops
->remove_interface
) {
2753 struct ieee80211_if_init_conf conf
;
2755 conf
.if_id
= dev
->ifindex
;
2756 conf
.type
= sdata
->type
;
2757 conf
.mac_addr
= dev
->dev_addr
;
2758 local
->ops
->remove_interface(local_to_hw(local
), &conf
);
2761 ieee80211_start_hard_monitor(local
);
2767 static int header_parse_80211(struct sk_buff
*skb
, unsigned char *haddr
)
2769 memcpy(haddr
, skb_mac_header(skb
) + 10, ETH_ALEN
); /* addr2 */
2773 static inline int ieee80211_bssid_match(const u8
*raddr
, const u8
*addr
)
2775 return compare_ether_addr(raddr
, addr
) == 0 ||
2776 is_broadcast_ether_addr(raddr
);
2780 static ieee80211_txrx_result
2781 ieee80211_rx_h_data(struct ieee80211_txrx_data
*rx
)
2783 struct net_device
*dev
= rx
->dev
;
2784 struct ieee80211_local
*local
= rx
->local
;
2785 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) rx
->skb
->data
;
2786 u16 fc
, hdrlen
, ethertype
;
2790 struct sk_buff
*skb
= rx
->skb
, *skb2
;
2791 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2794 if (unlikely((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
))
2795 return TXRX_CONTINUE
;
2797 if (unlikely(!WLAN_FC_DATA_PRESENT(fc
)))
2800 hdrlen
= ieee80211_get_hdrlen(fc
);
2802 /* convert IEEE 802.11 header + possible LLC headers into Ethernet
2804 * IEEE 802.11 address fields:
2805 * ToDS FromDS Addr1 Addr2 Addr3 Addr4
2806 * 0 0 DA SA BSSID n/a
2807 * 0 1 DA BSSID SA n/a
2808 * 1 0 BSSID SA DA n/a
2812 switch (fc
& (IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
)) {
2813 case IEEE80211_FCTL_TODS
:
2815 memcpy(dst
, hdr
->addr3
, ETH_ALEN
);
2816 memcpy(src
, hdr
->addr2
, ETH_ALEN
);
2818 if (unlikely(sdata
->type
!= IEEE80211_IF_TYPE_AP
&&
2819 sdata
->type
!= IEEE80211_IF_TYPE_VLAN
)) {
2820 printk(KERN_DEBUG
"%s: dropped ToDS frame (BSSID="
2821 MAC_FMT
" SA=" MAC_FMT
" DA=" MAC_FMT
")\n",
2822 dev
->name
, MAC_ARG(hdr
->addr1
),
2823 MAC_ARG(hdr
->addr2
), MAC_ARG(hdr
->addr3
));
2827 case (IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
):
2829 memcpy(dst
, hdr
->addr3
, ETH_ALEN
);
2830 memcpy(src
, hdr
->addr4
, ETH_ALEN
);
2832 if (unlikely(sdata
->type
!= IEEE80211_IF_TYPE_WDS
)) {
2833 printk(KERN_DEBUG
"%s: dropped FromDS&ToDS frame (RA="
2834 MAC_FMT
" TA=" MAC_FMT
" DA=" MAC_FMT
" SA="
2836 rx
->dev
->name
, MAC_ARG(hdr
->addr1
),
2837 MAC_ARG(hdr
->addr2
), MAC_ARG(hdr
->addr3
),
2838 MAC_ARG(hdr
->addr4
));
2842 case IEEE80211_FCTL_FROMDS
:
2844 memcpy(dst
, hdr
->addr1
, ETH_ALEN
);
2845 memcpy(src
, hdr
->addr3
, ETH_ALEN
);
2847 if (sdata
->type
!= IEEE80211_IF_TYPE_STA
||
2848 (is_multicast_ether_addr(dst
) &&
2849 !compare_ether_addr(src
, dev
->dev_addr
)))
2854 memcpy(dst
, hdr
->addr1
, ETH_ALEN
);
2855 memcpy(src
, hdr
->addr2
, ETH_ALEN
);
2857 if (sdata
->type
!= IEEE80211_IF_TYPE_IBSS
) {
2858 if (net_ratelimit()) {
2859 printk(KERN_DEBUG
"%s: dropped IBSS frame (DA="
2860 MAC_FMT
" SA=" MAC_FMT
" BSSID=" MAC_FMT
2862 dev
->name
, MAC_ARG(hdr
->addr1
),
2863 MAC_ARG(hdr
->addr2
),
2864 MAC_ARG(hdr
->addr3
));
2871 payload
= skb
->data
+ hdrlen
;
2873 if (unlikely(skb
->len
- hdrlen
< 8)) {
2874 if (net_ratelimit()) {
2875 printk(KERN_DEBUG
"%s: RX too short data frame "
2876 "payload\n", dev
->name
);
2881 ethertype
= (payload
[6] << 8) | payload
[7];
2883 if (likely((compare_ether_addr(payload
, rfc1042_header
) == 0 &&
2884 ethertype
!= ETH_P_AARP
&& ethertype
!= ETH_P_IPX
) ||
2885 compare_ether_addr(payload
, bridge_tunnel_header
) == 0)) {
2886 /* remove RFC1042 or Bridge-Tunnel encapsulation and
2887 * replace EtherType */
2888 skb_pull(skb
, hdrlen
+ 6);
2889 memcpy(skb_push(skb
, ETH_ALEN
), src
, ETH_ALEN
);
2890 memcpy(skb_push(skb
, ETH_ALEN
), dst
, ETH_ALEN
);
2892 struct ethhdr
*ehdr
;
2894 skb_pull(skb
, hdrlen
);
2895 len
= htons(skb
->len
);
2896 ehdr
= (struct ethhdr
*) skb_push(skb
, sizeof(struct ethhdr
));
2897 memcpy(ehdr
->h_dest
, dst
, ETH_ALEN
);
2898 memcpy(ehdr
->h_source
, src
, ETH_ALEN
);
2899 ehdr
->h_proto
= len
;
2905 sdata
->stats
.rx_packets
++;
2906 sdata
->stats
.rx_bytes
+= skb
->len
;
2908 if (local
->bridge_packets
&& (sdata
->type
== IEEE80211_IF_TYPE_AP
2909 || sdata
->type
== IEEE80211_IF_TYPE_VLAN
) && rx
->u
.rx
.ra_match
) {
2910 if (is_multicast_ether_addr(skb
->data
)) {
2911 /* send multicast frames both to higher layers in
2912 * local net stack and back to the wireless media */
2913 skb2
= skb_copy(skb
, GFP_ATOMIC
);
2915 printk(KERN_DEBUG
"%s: failed to clone "
2916 "multicast frame\n", dev
->name
);
2918 struct sta_info
*dsta
;
2919 dsta
= sta_info_get(local
, skb
->data
);
2920 if (dsta
&& !dsta
->dev
) {
2921 printk(KERN_DEBUG
"Station with null dev "
2923 } else if (dsta
&& dsta
->dev
== dev
) {
2924 /* Destination station is associated to this
2925 * AP, so send the frame directly to it and
2926 * do not pass the frame to local net stack.
2937 /* deliver to local stack */
2938 skb
->protocol
= eth_type_trans(skb
, dev
);
2939 memset(skb
->cb
, 0, sizeof(skb
->cb
));
2944 /* send to wireless media */
2945 skb2
->protocol
= __constant_htons(ETH_P_802_3
);
2946 skb_set_network_header(skb2
, 0);
2947 skb_set_mac_header(skb2
, 0);
2948 dev_queue_xmit(skb2
);
2955 static struct ieee80211_rate
*
2956 ieee80211_get_rate(struct ieee80211_local
*local
, int phymode
, int hw_rate
)
2958 struct ieee80211_hw_mode
*mode
;
2961 list_for_each_entry(mode
, &local
->modes_list
, list
) {
2962 if (mode
->mode
!= phymode
)
2964 for (r
= 0; r
< mode
->num_rates
; r
++) {
2965 struct ieee80211_rate
*rate
= &mode
->rates
[r
];
2966 if (rate
->val
== hw_rate
||
2967 (rate
->flags
& IEEE80211_RATE_PREAMBLE2
&&
2968 rate
->val2
== hw_rate
))
2977 ieee80211_fill_frame_info(struct ieee80211_local
*local
,
2978 struct ieee80211_frame_info
*fi
,
2979 struct ieee80211_rx_status
*status
)
2983 struct ieee80211_rate
*rate
;
2985 jiffies_to_timespec(jiffies
, &ts
);
2986 fi
->hosttime
= cpu_to_be64((u64
) ts
.tv_sec
* 1000000 +
2988 fi
->mactime
= cpu_to_be64(status
->mactime
);
2989 switch (status
->phymode
) {
2990 case MODE_IEEE80211A
:
2991 fi
->phytype
= htonl(ieee80211_phytype_ofdm_dot11_a
);
2993 case MODE_IEEE80211B
:
2994 fi
->phytype
= htonl(ieee80211_phytype_dsss_dot11_b
);
2996 case MODE_IEEE80211G
:
2997 fi
->phytype
= htonl(ieee80211_phytype_pbcc_dot11_g
);
2999 case MODE_ATHEROS_TURBO
:
3001 htonl(ieee80211_phytype_dsss_dot11_turbo
);
3004 fi
->phytype
= htonl(0xAAAAAAAA);
3007 fi
->channel
= htonl(status
->channel
);
3008 rate
= ieee80211_get_rate(local
, status
->phymode
,
3011 fi
->datarate
= htonl(rate
->rate
);
3012 if (rate
->flags
& IEEE80211_RATE_PREAMBLE2
) {
3013 if (status
->rate
== rate
->val
)
3014 fi
->preamble
= htonl(2); /* long */
3015 else if (status
->rate
== rate
->val2
)
3016 fi
->preamble
= htonl(1); /* short */
3018 fi
->preamble
= htonl(0);
3020 fi
->datarate
= htonl(0);
3021 fi
->preamble
= htonl(0);
3024 fi
->antenna
= htonl(status
->antenna
);
3025 fi
->priority
= htonl(0xffffffff); /* no clue */
3026 fi
->ssi_type
= htonl(ieee80211_ssi_raw
);
3027 fi
->ssi_signal
= htonl(status
->ssi
);
3028 fi
->ssi_noise
= 0x00000000;
3031 /* clear everything because we really don't know.
3032 * the msg_type field isn't present on monitor frames
3033 * so we don't know whether it will be present or not,
3034 * but it's ok to not clear it since it'll be assigned
3036 memset(fi
, 0, sizeof(*fi
) - sizeof(fi
->msg_type
));
3038 fi
->ssi_type
= htonl(ieee80211_ssi_none
);
3040 fi
->version
= htonl(IEEE80211_FI_VERSION
);
3041 fi
->length
= cpu_to_be32(sizeof(*fi
) - sizeof(fi
->msg_type
));
3044 /* this routine is actually not just for this, but also
3045 * for pushing fake 'management' frames into userspace.
3046 * it shall be replaced by a netlink-based system. */
3048 ieee80211_rx_mgmt(struct ieee80211_local
*local
, struct sk_buff
*skb
,
3049 struct ieee80211_rx_status
*status
, u32 msg_type
)
3051 struct ieee80211_frame_info
*fi
;
3052 const size_t hlen
= sizeof(struct ieee80211_frame_info
);
3053 struct ieee80211_sub_if_data
*sdata
;
3055 skb
->dev
= local
->apdev
;
3057 sdata
= IEEE80211_DEV_TO_SUB_IF(local
->apdev
);
3059 if (skb_headroom(skb
) < hlen
) {
3060 I802_DEBUG_INC(local
->rx_expand_skb_head
);
3061 if (pskb_expand_head(skb
, hlen
, 0, GFP_ATOMIC
)) {
3067 fi
= (struct ieee80211_frame_info
*) skb_push(skb
, hlen
);
3069 ieee80211_fill_frame_info(local
, fi
, status
);
3070 fi
->msg_type
= htonl(msg_type
);
3072 sdata
->stats
.rx_packets
++;
3073 sdata
->stats
.rx_bytes
+= skb
->len
;
3075 skb_set_mac_header(skb
, 0);
3076 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
3077 skb
->pkt_type
= PACKET_OTHERHOST
;
3078 skb
->protocol
= htons(ETH_P_802_2
);
3079 memset(skb
->cb
, 0, sizeof(skb
->cb
));
3084 ieee80211_rx_monitor(struct net_device
*dev
, struct sk_buff
*skb
,
3085 struct ieee80211_rx_status
*status
)
3087 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3088 struct ieee80211_sub_if_data
*sdata
;
3089 struct ieee80211_rate
*rate
;
3090 struct ieee80211_rtap_hdr
{
3091 struct ieee80211_radiotap_header hdr
;
3097 } __attribute__ ((packed
)) *rthdr
;
3101 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3103 if (status
->flag
& RX_FLAG_RADIOTAP
)
3106 if (skb_headroom(skb
) < sizeof(*rthdr
)) {
3107 I802_DEBUG_INC(local
->rx_expand_skb_head
);
3108 if (pskb_expand_head(skb
, sizeof(*rthdr
), 0, GFP_ATOMIC
)) {
3114 rthdr
= (struct ieee80211_rtap_hdr
*) skb_push(skb
, sizeof(*rthdr
));
3115 memset(rthdr
, 0, sizeof(*rthdr
));
3116 rthdr
->hdr
.it_len
= cpu_to_le16(sizeof(*rthdr
));
3117 rthdr
->hdr
.it_present
=
3118 cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS
) |
3119 (1 << IEEE80211_RADIOTAP_RATE
) |
3120 (1 << IEEE80211_RADIOTAP_CHANNEL
) |
3121 (1 << IEEE80211_RADIOTAP_DB_ANTSIGNAL
));
3122 rthdr
->flags
= local
->hw
.flags
& IEEE80211_HW_RX_INCLUDES_FCS
?
3123 IEEE80211_RADIOTAP_F_FCS
: 0;
3124 rate
= ieee80211_get_rate(local
, status
->phymode
, status
->rate
);
3126 rthdr
->rate
= rate
->rate
/ 5;
3127 rthdr
->chan_freq
= cpu_to_le16(status
->freq
);
3129 status
->phymode
== MODE_IEEE80211A
?
3130 cpu_to_le16(IEEE80211_CHAN_OFDM
| IEEE80211_CHAN_5GHZ
) :
3131 cpu_to_le16(IEEE80211_CHAN_DYN
| IEEE80211_CHAN_2GHZ
);
3132 rthdr
->antsignal
= status
->ssi
;
3135 sdata
->stats
.rx_packets
++;
3136 sdata
->stats
.rx_bytes
+= skb
->len
;
3138 skb_set_mac_header(skb
, 0);
3139 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
3140 skb
->pkt_type
= PACKET_OTHERHOST
;
3141 skb
->protocol
= htons(ETH_P_802_2
);
3142 memset(skb
->cb
, 0, sizeof(skb
->cb
));
3146 int ieee80211_radar_status(struct ieee80211_hw
*hw
, int channel
,
3147 int radar
, int radar_type
)
3149 struct sk_buff
*skb
;
3150 struct ieee80211_radar_info
*msg
;
3151 struct ieee80211_local
*local
= hw_to_local(hw
);
3156 skb
= dev_alloc_skb(sizeof(struct ieee80211_frame_info
) +
3157 sizeof(struct ieee80211_radar_info
));
3161 skb_reserve(skb
, sizeof(struct ieee80211_frame_info
));
3163 msg
= (struct ieee80211_radar_info
*)
3164 skb_put(skb
, sizeof(struct ieee80211_radar_info
));
3165 msg
->channel
= channel
;
3167 msg
->radar_type
= radar_type
;
3169 ieee80211_rx_mgmt(local
, skb
, NULL
, ieee80211_msg_radar
);
3172 EXPORT_SYMBOL(ieee80211_radar_status
);
3175 static void ap_sta_ps_start(struct net_device
*dev
, struct sta_info
*sta
)
3177 struct ieee80211_sub_if_data
*sdata
;
3178 sdata
= IEEE80211_DEV_TO_SUB_IF(sta
->dev
);
3181 atomic_inc(&sdata
->bss
->num_sta_ps
);
3182 sta
->flags
|= WLAN_STA_PS
;
3184 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
3185 printk(KERN_DEBUG
"%s: STA " MAC_FMT
" aid %d enters power "
3186 "save mode\n", dev
->name
, MAC_ARG(sta
->addr
), sta
->aid
);
3187 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
3191 static int ap_sta_ps_end(struct net_device
*dev
, struct sta_info
*sta
)
3193 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3194 struct sk_buff
*skb
;
3196 struct ieee80211_sub_if_data
*sdata
;
3197 struct ieee80211_tx_packet_data
*pkt_data
;
3199 sdata
= IEEE80211_DEV_TO_SUB_IF(sta
->dev
);
3201 atomic_dec(&sdata
->bss
->num_sta_ps
);
3202 sta
->flags
&= ~(WLAN_STA_PS
| WLAN_STA_TIM
);
3204 if (!skb_queue_empty(&sta
->ps_tx_buf
)) {
3205 if (local
->ops
->set_tim
)
3206 local
->ops
->set_tim(local_to_hw(local
), sta
->aid
, 0);
3208 bss_tim_clear(local
, sdata
->bss
, sta
->aid
);
3210 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
3211 printk(KERN_DEBUG
"%s: STA " MAC_FMT
" aid %d exits power "
3212 "save mode\n", dev
->name
, MAC_ARG(sta
->addr
), sta
->aid
);
3213 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
3214 /* Send all buffered frames to the station */
3215 while ((skb
= skb_dequeue(&sta
->tx_filtered
)) != NULL
) {
3216 pkt_data
= (struct ieee80211_tx_packet_data
*) skb
->cb
;
3218 pkt_data
->requeue
= 1;
3219 dev_queue_xmit(skb
);
3221 while ((skb
= skb_dequeue(&sta
->ps_tx_buf
)) != NULL
) {
3222 pkt_data
= (struct ieee80211_tx_packet_data
*) skb
->cb
;
3223 local
->total_ps_buffered
--;
3225 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
3226 printk(KERN_DEBUG
"%s: STA " MAC_FMT
" aid %d send PS frame "
3227 "since STA not sleeping anymore\n", dev
->name
,
3228 MAC_ARG(sta
->addr
), sta
->aid
);
3229 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
3230 pkt_data
->requeue
= 1;
3231 dev_queue_xmit(skb
);
3238 static ieee80211_txrx_result
3239 ieee80211_rx_h_ps_poll(struct ieee80211_txrx_data
*rx
)
3241 struct sk_buff
*skb
;
3242 int no_pending_pkts
;
3244 if (likely(!rx
->sta
||
3245 (rx
->fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_CTL
||
3246 (rx
->fc
& IEEE80211_FCTL_STYPE
) != IEEE80211_STYPE_PSPOLL
||
3247 !rx
->u
.rx
.ra_match
))
3248 return TXRX_CONTINUE
;
3250 skb
= skb_dequeue(&rx
->sta
->tx_filtered
);
3252 skb
= skb_dequeue(&rx
->sta
->ps_tx_buf
);
3254 rx
->local
->total_ps_buffered
--;
3256 no_pending_pkts
= skb_queue_empty(&rx
->sta
->tx_filtered
) &&
3257 skb_queue_empty(&rx
->sta
->ps_tx_buf
);
3260 struct ieee80211_hdr
*hdr
=
3261 (struct ieee80211_hdr
*) skb
->data
;
3263 /* tell TX path to send one frame even though the STA may
3264 * still remain is PS mode after this frame exchange */
3265 rx
->sta
->pspoll
= 1;
3267 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
3268 printk(KERN_DEBUG
"STA " MAC_FMT
" aid %d: PS Poll (entries "
3270 MAC_ARG(rx
->sta
->addr
), rx
->sta
->aid
,
3271 skb_queue_len(&rx
->sta
->ps_tx_buf
));
3272 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
3274 /* Use MoreData flag to indicate whether there are more
3275 * buffered frames for this STA */
3276 if (no_pending_pkts
) {
3277 hdr
->frame_control
&= cpu_to_le16(~IEEE80211_FCTL_MOREDATA
);
3278 rx
->sta
->flags
&= ~WLAN_STA_TIM
;
3280 hdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_MOREDATA
);
3282 dev_queue_xmit(skb
);
3284 if (no_pending_pkts
) {
3285 if (rx
->local
->ops
->set_tim
)
3286 rx
->local
->ops
->set_tim(local_to_hw(rx
->local
),
3289 bss_tim_clear(rx
->local
, rx
->sdata
->bss
, rx
->sta
->aid
);
3291 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
3292 } else if (!rx
->u
.rx
.sent_ps_buffered
) {
3293 printk(KERN_DEBUG
"%s: STA " MAC_FMT
" sent PS Poll even "
3294 "though there is no buffered frames for it\n",
3295 rx
->dev
->name
, MAC_ARG(rx
->sta
->addr
));
3296 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
3300 /* Free PS Poll skb here instead of returning TXRX_DROP that would
3301 * count as an dropped frame. */
3302 dev_kfree_skb(rx
->skb
);
3308 static inline struct ieee80211_fragment_entry
*
3309 ieee80211_reassemble_add(struct ieee80211_sub_if_data
*sdata
,
3310 unsigned int frag
, unsigned int seq
, int rx_queue
,
3311 struct sk_buff
**skb
)
3313 struct ieee80211_fragment_entry
*entry
;
3316 idx
= sdata
->fragment_next
;
3317 entry
= &sdata
->fragments
[sdata
->fragment_next
++];
3318 if (sdata
->fragment_next
>= IEEE80211_FRAGMENT_MAX
)
3319 sdata
->fragment_next
= 0;
3321 if (!skb_queue_empty(&entry
->skb_list
)) {
3322 #ifdef CONFIG_MAC80211_DEBUG
3323 struct ieee80211_hdr
*hdr
=
3324 (struct ieee80211_hdr
*) entry
->skb_list
.next
->data
;
3325 printk(KERN_DEBUG
"%s: RX reassembly removed oldest "
3326 "fragment entry (idx=%d age=%lu seq=%d last_frag=%d "
3327 "addr1=" MAC_FMT
" addr2=" MAC_FMT
"\n",
3328 sdata
->dev
->name
, idx
,
3329 jiffies
- entry
->first_frag_time
, entry
->seq
,
3330 entry
->last_frag
, MAC_ARG(hdr
->addr1
),
3331 MAC_ARG(hdr
->addr2
));
3332 #endif /* CONFIG_MAC80211_DEBUG */
3333 __skb_queue_purge(&entry
->skb_list
);
3336 __skb_queue_tail(&entry
->skb_list
, *skb
); /* no need for locking */
3338 entry
->first_frag_time
= jiffies
;
3340 entry
->rx_queue
= rx_queue
;
3341 entry
->last_frag
= frag
;
3343 entry
->extra_len
= 0;
3349 static inline struct ieee80211_fragment_entry
*
3350 ieee80211_reassemble_find(struct ieee80211_sub_if_data
*sdata
,
3351 u16 fc
, unsigned int frag
, unsigned int seq
,
3352 int rx_queue
, struct ieee80211_hdr
*hdr
)
3354 struct ieee80211_fragment_entry
*entry
;
3357 idx
= sdata
->fragment_next
;
3358 for (i
= 0; i
< IEEE80211_FRAGMENT_MAX
; i
++) {
3359 struct ieee80211_hdr
*f_hdr
;
3364 idx
= IEEE80211_FRAGMENT_MAX
- 1;
3366 entry
= &sdata
->fragments
[idx
];
3367 if (skb_queue_empty(&entry
->skb_list
) || entry
->seq
!= seq
||
3368 entry
->rx_queue
!= rx_queue
||
3369 entry
->last_frag
+ 1 != frag
)
3372 f_hdr
= (struct ieee80211_hdr
*) entry
->skb_list
.next
->data
;
3373 f_fc
= le16_to_cpu(f_hdr
->frame_control
);
3375 if ((fc
& IEEE80211_FCTL_FTYPE
) != (f_fc
& IEEE80211_FCTL_FTYPE
) ||
3376 compare_ether_addr(hdr
->addr1
, f_hdr
->addr1
) != 0 ||
3377 compare_ether_addr(hdr
->addr2
, f_hdr
->addr2
) != 0)
3380 if (entry
->first_frag_time
+ 2 * HZ
< jiffies
) {
3381 __skb_queue_purge(&entry
->skb_list
);
3391 static ieee80211_txrx_result
3392 ieee80211_rx_h_defragment(struct ieee80211_txrx_data
*rx
)
3394 struct ieee80211_hdr
*hdr
;
3396 unsigned int frag
, seq
;
3397 struct ieee80211_fragment_entry
*entry
;
3398 struct sk_buff
*skb
;
3400 hdr
= (struct ieee80211_hdr
*) rx
->skb
->data
;
3401 sc
= le16_to_cpu(hdr
->seq_ctrl
);
3402 frag
= sc
& IEEE80211_SCTL_FRAG
;
3404 if (likely((!(rx
->fc
& IEEE80211_FCTL_MOREFRAGS
) && frag
== 0) ||
3405 (rx
->skb
)->len
< 24 ||
3406 is_multicast_ether_addr(hdr
->addr1
))) {
3407 /* not fragmented */
3410 I802_DEBUG_INC(rx
->local
->rx_handlers_fragments
);
3412 seq
= (sc
& IEEE80211_SCTL_SEQ
) >> 4;
3415 /* This is the first fragment of a new frame. */
3416 entry
= ieee80211_reassemble_add(rx
->sdata
, frag
, seq
,
3417 rx
->u
.rx
.queue
, &(rx
->skb
));
3418 if (rx
->key
&& rx
->key
->alg
== ALG_CCMP
&&
3419 (rx
->fc
& IEEE80211_FCTL_PROTECTED
)) {
3420 /* Store CCMP PN so that we can verify that the next
3421 * fragment has a sequential PN value. */
3423 memcpy(entry
->last_pn
,
3424 rx
->key
->u
.ccmp
.rx_pn
[rx
->u
.rx
.queue
],
3430 /* This is a fragment for a frame that should already be pending in
3431 * fragment cache. Add this fragment to the end of the pending entry.
3433 entry
= ieee80211_reassemble_find(rx
->sdata
, rx
->fc
, frag
, seq
,
3434 rx
->u
.rx
.queue
, hdr
);
3436 I802_DEBUG_INC(rx
->local
->rx_handlers_drop_defrag
);
3440 /* Verify that MPDUs within one MSDU have sequential PN values.
3441 * (IEEE 802.11i, 8.3.3.4.5) */
3444 u8 pn
[CCMP_PN_LEN
], *rpn
;
3445 if (!rx
->key
|| rx
->key
->alg
!= ALG_CCMP
)
3447 memcpy(pn
, entry
->last_pn
, CCMP_PN_LEN
);
3448 for (i
= CCMP_PN_LEN
- 1; i
>= 0; i
--) {
3453 rpn
= rx
->key
->u
.ccmp
.rx_pn
[rx
->u
.rx
.queue
];
3454 if (memcmp(pn
, rpn
, CCMP_PN_LEN
) != 0) {
3455 printk(KERN_DEBUG
"%s: defrag: CCMP PN not sequential"
3456 " A2=" MAC_FMT
" PN=%02x%02x%02x%02x%02x%02x "
3457 "(expected %02x%02x%02x%02x%02x%02x)\n",
3458 rx
->dev
->name
, MAC_ARG(hdr
->addr2
),
3459 rpn
[0], rpn
[1], rpn
[2], rpn
[3], rpn
[4], rpn
[5],
3460 pn
[0], pn
[1], pn
[2], pn
[3], pn
[4], pn
[5]);
3463 memcpy(entry
->last_pn
, pn
, CCMP_PN_LEN
);
3466 skb_pull(rx
->skb
, ieee80211_get_hdrlen(rx
->fc
));
3467 __skb_queue_tail(&entry
->skb_list
, rx
->skb
);
3468 entry
->last_frag
= frag
;
3469 entry
->extra_len
+= rx
->skb
->len
;
3470 if (rx
->fc
& IEEE80211_FCTL_MOREFRAGS
) {
3475 rx
->skb
= __skb_dequeue(&entry
->skb_list
);
3476 if (skb_tailroom(rx
->skb
) < entry
->extra_len
) {
3477 I802_DEBUG_INC(rx
->local
->rx_expand_skb_head2
);
3478 if (unlikely(pskb_expand_head(rx
->skb
, 0, entry
->extra_len
,
3480 I802_DEBUG_INC(rx
->local
->rx_handlers_drop_defrag
);
3481 __skb_queue_purge(&entry
->skb_list
);
3485 while ((skb
= __skb_dequeue(&entry
->skb_list
))) {
3486 memcpy(skb_put(rx
->skb
, skb
->len
), skb
->data
, skb
->len
);
3490 /* Complete frame has been reassembled - process it now */
3495 rx
->sta
->rx_packets
++;
3496 if (is_multicast_ether_addr(hdr
->addr1
))
3497 rx
->local
->dot11MulticastReceivedFrameCount
++;
3499 ieee80211_led_rx(rx
->local
);
3500 return TXRX_CONTINUE
;
3504 static ieee80211_txrx_result
3505 ieee80211_rx_h_monitor(struct ieee80211_txrx_data
*rx
)
3507 if (rx
->sdata
->type
== IEEE80211_IF_TYPE_MNTR
) {
3508 ieee80211_rx_monitor(rx
->dev
, rx
->skb
, rx
->u
.rx
.status
);
3512 if (rx
->u
.rx
.status
->flag
& RX_FLAG_RADIOTAP
)
3513 skb_pull(rx
->skb
, ieee80211_get_radiotap_len(rx
->skb
));
3515 return TXRX_CONTINUE
;
3519 static ieee80211_txrx_result
3520 ieee80211_rx_h_check(struct ieee80211_txrx_data
*rx
)
3522 struct ieee80211_hdr
*hdr
;
3524 hdr
= (struct ieee80211_hdr
*) rx
->skb
->data
;
3526 /* Drop duplicate 802.11 retransmissions (IEEE 802.11 Chap. 9.2.9) */
3527 if (rx
->sta
&& !is_multicast_ether_addr(hdr
->addr1
)) {
3528 if (unlikely(rx
->fc
& IEEE80211_FCTL_RETRY
&&
3529 rx
->sta
->last_seq_ctrl
[rx
->u
.rx
.queue
] ==
3531 if (rx
->u
.rx
.ra_match
) {
3532 rx
->local
->dot11FrameDuplicateCount
++;
3533 rx
->sta
->num_duplicates
++;
3537 rx
->sta
->last_seq_ctrl
[rx
->u
.rx
.queue
] = hdr
->seq_ctrl
;
3540 if ((rx
->local
->hw
.flags
& IEEE80211_HW_RX_INCLUDES_FCS
) &&
3541 rx
->skb
->len
> FCS_LEN
)
3542 skb_trim(rx
->skb
, rx
->skb
->len
- FCS_LEN
);
3544 if (unlikely(rx
->skb
->len
< 16)) {
3545 I802_DEBUG_INC(rx
->local
->rx_handlers_drop_short
);
3549 if (!rx
->u
.rx
.ra_match
)
3550 rx
->skb
->pkt_type
= PACKET_OTHERHOST
;
3551 else if (compare_ether_addr(rx
->dev
->dev_addr
, hdr
->addr1
) == 0)
3552 rx
->skb
->pkt_type
= PACKET_HOST
;
3553 else if (is_multicast_ether_addr(hdr
->addr1
)) {
3554 if (is_broadcast_ether_addr(hdr
->addr1
))
3555 rx
->skb
->pkt_type
= PACKET_BROADCAST
;
3557 rx
->skb
->pkt_type
= PACKET_MULTICAST
;
3559 rx
->skb
->pkt_type
= PACKET_OTHERHOST
;
3561 /* Drop disallowed frame classes based on STA auth/assoc state;
3562 * IEEE 802.11, Chap 5.5.
3564 * 80211.o does filtering only based on association state, i.e., it
3565 * drops Class 3 frames from not associated stations. hostapd sends
3566 * deauth/disassoc frames when needed. In addition, hostapd is
3567 * responsible for filtering on both auth and assoc states.
3569 if (unlikely(((rx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
||
3570 ((rx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_CTL
&&
3571 (rx
->fc
& IEEE80211_FCTL_STYPE
) == IEEE80211_STYPE_PSPOLL
)) &&
3572 rx
->sdata
->type
!= IEEE80211_IF_TYPE_IBSS
&&
3573 (!rx
->sta
|| !(rx
->sta
->flags
& WLAN_STA_ASSOC
)))) {
3574 if ((!(rx
->fc
& IEEE80211_FCTL_FROMDS
) &&
3575 !(rx
->fc
& IEEE80211_FCTL_TODS
) &&
3576 (rx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
)
3577 || !rx
->u
.rx
.ra_match
) {
3578 /* Drop IBSS frames and frames for other hosts
3583 if (!rx
->local
->apdev
)
3586 ieee80211_rx_mgmt(rx
->local
, rx
->skb
, rx
->u
.rx
.status
,
3587 ieee80211_msg_sta_not_assoc
);
3591 if (rx
->sdata
->type
== IEEE80211_IF_TYPE_STA
)
3596 if (rx
->sta
&& rx
->sta
->key
&& always_sta_key
) {
3597 rx
->key
= rx
->sta
->key
;
3599 if (rx
->sta
&& rx
->sta
->key
)
3600 rx
->key
= rx
->sta
->key
;
3602 rx
->key
= rx
->sdata
->default_key
;
3604 if ((rx
->local
->hw
.flags
& IEEE80211_HW_WEP_INCLUDE_IV
) &&
3605 rx
->fc
& IEEE80211_FCTL_PROTECTED
) {
3606 int keyidx
= ieee80211_wep_get_keyidx(rx
->skb
);
3608 if (keyidx
>= 0 && keyidx
< NUM_DEFAULT_KEYS
&&
3609 (!rx
->sta
|| !rx
->sta
->key
|| keyidx
> 0))
3610 rx
->key
= rx
->sdata
->keys
[keyidx
];
3613 if (!rx
->u
.rx
.ra_match
)
3615 printk(KERN_DEBUG
"%s: RX WEP frame with "
3616 "unknown keyidx %d (A1=" MAC_FMT
" A2="
3617 MAC_FMT
" A3=" MAC_FMT
")\n",
3618 rx
->dev
->name
, keyidx
,
3619 MAC_ARG(hdr
->addr1
),
3620 MAC_ARG(hdr
->addr2
),
3621 MAC_ARG(hdr
->addr3
));
3622 if (!rx
->local
->apdev
)
3625 rx
->local
, rx
->skb
, rx
->u
.rx
.status
,
3626 ieee80211_msg_wep_frame_unknown_key
);
3632 if (rx
->fc
& IEEE80211_FCTL_PROTECTED
&& rx
->key
&& rx
->u
.rx
.ra_match
) {
3633 rx
->key
->tx_rx_count
++;
3634 if (unlikely(rx
->local
->key_tx_rx_threshold
&&
3635 rx
->key
->tx_rx_count
>
3636 rx
->local
->key_tx_rx_threshold
)) {
3637 ieee80211_key_threshold_notify(rx
->dev
, rx
->key
,
3642 return TXRX_CONTINUE
;
3646 static ieee80211_txrx_result
3647 ieee80211_rx_h_sta_process(struct ieee80211_txrx_data
*rx
)
3649 struct sta_info
*sta
= rx
->sta
;
3650 struct net_device
*dev
= rx
->dev
;
3651 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) rx
->skb
->data
;
3654 return TXRX_CONTINUE
;
3656 /* Update last_rx only for IBSS packets which are for the current
3657 * BSSID to avoid keeping the current IBSS network alive in cases where
3658 * other STAs are using different BSSID. */
3659 if (rx
->sdata
->type
== IEEE80211_IF_TYPE_IBSS
) {
3660 u8
*bssid
= ieee80211_get_bssid(hdr
, rx
->skb
->len
);
3661 if (compare_ether_addr(bssid
, rx
->sdata
->u
.sta
.bssid
) == 0)
3662 sta
->last_rx
= jiffies
;
3664 if (!is_multicast_ether_addr(hdr
->addr1
) ||
3665 rx
->sdata
->type
== IEEE80211_IF_TYPE_STA
) {
3666 /* Update last_rx only for unicast frames in order to prevent
3667 * the Probe Request frames (the only broadcast frames from a
3668 * STA in infrastructure mode) from keeping a connection alive.
3670 sta
->last_rx
= jiffies
;
3673 if (!rx
->u
.rx
.ra_match
)
3674 return TXRX_CONTINUE
;
3676 sta
->rx_fragments
++;
3677 sta
->rx_bytes
+= rx
->skb
->len
;
3678 sta
->last_rssi
= (sta
->last_rssi
* 15 +
3679 rx
->u
.rx
.status
->ssi
) / 16;
3680 sta
->last_signal
= (sta
->last_signal
* 15 +
3681 rx
->u
.rx
.status
->signal
) / 16;
3682 sta
->last_noise
= (sta
->last_noise
* 15 +
3683 rx
->u
.rx
.status
->noise
) / 16;
3685 if (!(rx
->fc
& IEEE80211_FCTL_MOREFRAGS
)) {
3686 /* Change STA power saving mode only in the end of a frame
3687 * exchange sequence */
3688 if ((sta
->flags
& WLAN_STA_PS
) && !(rx
->fc
& IEEE80211_FCTL_PM
))
3689 rx
->u
.rx
.sent_ps_buffered
+= ap_sta_ps_end(dev
, sta
);
3690 else if (!(sta
->flags
& WLAN_STA_PS
) &&
3691 (rx
->fc
& IEEE80211_FCTL_PM
))
3692 ap_sta_ps_start(dev
, sta
);
3695 /* Drop data::nullfunc frames silently, since they are used only to
3696 * control station power saving mode. */
3697 if ((rx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
&&
3698 (rx
->fc
& IEEE80211_FCTL_STYPE
) == IEEE80211_STYPE_NULLFUNC
) {
3699 I802_DEBUG_INC(rx
->local
->rx_handlers_drop_nullfunc
);
3700 /* Update counter and free packet here to avoid counting this
3701 * as a dropped packed. */
3703 dev_kfree_skb(rx
->skb
);
3707 return TXRX_CONTINUE
;
3708 } /* ieee80211_rx_h_sta_process */
3711 static ieee80211_txrx_result
3712 ieee80211_rx_h_wep_weak_iv_detection(struct ieee80211_txrx_data
*rx
)
3714 if (!rx
->sta
|| !(rx
->fc
& IEEE80211_FCTL_PROTECTED
) ||
3715 (rx
->fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
||
3716 !rx
->key
|| rx
->key
->alg
!= ALG_WEP
|| !rx
->u
.rx
.ra_match
)
3717 return TXRX_CONTINUE
;
3719 /* Check for weak IVs, if hwaccel did not remove IV from the frame */
3720 if ((rx
->local
->hw
.flags
& IEEE80211_HW_WEP_INCLUDE_IV
) ||
3721 rx
->key
->force_sw_encrypt
) {
3722 u8
*iv
= ieee80211_wep_is_weak_iv(rx
->skb
, rx
->key
);
3724 rx
->sta
->wep_weak_iv_count
++;
3728 return TXRX_CONTINUE
;
3732 static ieee80211_txrx_result
3733 ieee80211_rx_h_wep_decrypt(struct ieee80211_txrx_data
*rx
)
3735 /* If the device handles decryption totally, skip this test */
3736 if (rx
->local
->hw
.flags
& IEEE80211_HW_DEVICE_HIDES_WEP
)
3737 return TXRX_CONTINUE
;
3739 if ((rx
->key
&& rx
->key
->alg
!= ALG_WEP
) ||
3740 !(rx
->fc
& IEEE80211_FCTL_PROTECTED
) ||
3741 ((rx
->fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
&&
3742 ((rx
->fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_MGMT
||
3743 (rx
->fc
& IEEE80211_FCTL_STYPE
) != IEEE80211_STYPE_AUTH
)))
3744 return TXRX_CONTINUE
;
3747 printk(KERN_DEBUG
"%s: RX WEP frame, but no key set\n",
3752 if (!(rx
->u
.rx
.status
->flag
& RX_FLAG_DECRYPTED
) ||
3753 rx
->key
->force_sw_encrypt
) {
3754 if (ieee80211_wep_decrypt(rx
->local
, rx
->skb
, rx
->key
)) {
3755 printk(KERN_DEBUG
"%s: RX WEP frame, decrypt "
3756 "failed\n", rx
->dev
->name
);
3759 } else if (rx
->local
->hw
.flags
& IEEE80211_HW_WEP_INCLUDE_IV
) {
3760 ieee80211_wep_remove_iv(rx
->local
, rx
->skb
, rx
->key
);
3762 skb_trim(rx
->skb
, rx
->skb
->len
- 4);
3765 return TXRX_CONTINUE
;
3769 static ieee80211_txrx_result
3770 ieee80211_rx_h_802_1x_pae(struct ieee80211_txrx_data
*rx
)
3772 if (rx
->sdata
->eapol
&& ieee80211_is_eapol(rx
->skb
) &&
3773 rx
->sdata
->type
!= IEEE80211_IF_TYPE_STA
&& rx
->u
.rx
.ra_match
) {
3774 /* Pass both encrypted and unencrypted EAPOL frames to user
3775 * space for processing. */
3776 if (!rx
->local
->apdev
)
3778 ieee80211_rx_mgmt(rx
->local
, rx
->skb
, rx
->u
.rx
.status
,
3779 ieee80211_msg_normal
);
3783 if (unlikely(rx
->sdata
->ieee802_1x
&&
3784 (rx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
&&
3785 (rx
->fc
& IEEE80211_FCTL_STYPE
) != IEEE80211_STYPE_NULLFUNC
&&
3786 (!rx
->sta
|| !(rx
->sta
->flags
& WLAN_STA_AUTHORIZED
)) &&
3787 !ieee80211_is_eapol(rx
->skb
))) {
3788 #ifdef CONFIG_MAC80211_DEBUG
3789 struct ieee80211_hdr
*hdr
=
3790 (struct ieee80211_hdr
*) rx
->skb
->data
;
3791 printk(KERN_DEBUG
"%s: dropped frame from " MAC_FMT
3792 " (unauthorized port)\n", rx
->dev
->name
,
3793 MAC_ARG(hdr
->addr2
));
3794 #endif /* CONFIG_MAC80211_DEBUG */
3798 return TXRX_CONTINUE
;
3802 static ieee80211_txrx_result
3803 ieee80211_rx_h_drop_unencrypted(struct ieee80211_txrx_data
*rx
)
3805 /* If the device handles decryption totally, skip this test */
3806 if (rx
->local
->hw
.flags
& IEEE80211_HW_DEVICE_HIDES_WEP
)
3807 return TXRX_CONTINUE
;
3809 /* Drop unencrypted frames if key is set. */
3810 if (unlikely(!(rx
->fc
& IEEE80211_FCTL_PROTECTED
) &&
3811 (rx
->fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
&&
3812 (rx
->fc
& IEEE80211_FCTL_STYPE
) != IEEE80211_STYPE_NULLFUNC
&&
3813 (rx
->key
|| rx
->sdata
->drop_unencrypted
) &&
3814 (rx
->sdata
->eapol
== 0 ||
3815 !ieee80211_is_eapol(rx
->skb
)))) {
3816 printk(KERN_DEBUG
"%s: RX non-WEP frame, but expected "
3817 "encryption\n", rx
->dev
->name
);
3820 return TXRX_CONTINUE
;
3824 static ieee80211_txrx_result
3825 ieee80211_rx_h_mgmt(struct ieee80211_txrx_data
*rx
)
3827 struct ieee80211_sub_if_data
*sdata
;
3829 if (!rx
->u
.rx
.ra_match
)
3832 sdata
= IEEE80211_DEV_TO_SUB_IF(rx
->dev
);
3833 if ((sdata
->type
== IEEE80211_IF_TYPE_STA
||
3834 sdata
->type
== IEEE80211_IF_TYPE_IBSS
) &&
3835 !rx
->local
->user_space_mlme
) {
3836 ieee80211_sta_rx_mgmt(rx
->dev
, rx
->skb
, rx
->u
.rx
.status
);
3838 /* Management frames are sent to hostapd for processing */
3839 if (!rx
->local
->apdev
)
3841 ieee80211_rx_mgmt(rx
->local
, rx
->skb
, rx
->u
.rx
.status
,
3842 ieee80211_msg_normal
);
3848 static ieee80211_txrx_result
3849 ieee80211_rx_h_passive_scan(struct ieee80211_txrx_data
*rx
)
3851 struct ieee80211_local
*local
= rx
->local
;
3852 struct sk_buff
*skb
= rx
->skb
;
3854 if (unlikely(local
->sta_scanning
!= 0)) {
3855 ieee80211_sta_rx_scan(rx
->dev
, skb
, rx
->u
.rx
.status
);
3859 if (unlikely(rx
->u
.rx
.in_scan
)) {
3860 /* scanning finished during invoking of handlers */
3861 I802_DEBUG_INC(local
->rx_handlers_drop_passive_scan
);
3865 return TXRX_CONTINUE
;
3869 static void ieee80211_rx_michael_mic_report(struct net_device
*dev
,
3870 struct ieee80211_hdr
*hdr
,
3871 struct sta_info
*sta
,
3872 struct ieee80211_txrx_data
*rx
)
3876 hdrlen
= ieee80211_get_hdrlen_from_skb(rx
->skb
);
3877 if (rx
->skb
->len
>= hdrlen
+ 4)
3878 keyidx
= rx
->skb
->data
[hdrlen
+ 3] >> 6;
3882 /* TODO: verify that this is not triggered by fragmented
3883 * frames (hw does not verify MIC for them). */
3884 printk(KERN_DEBUG
"%s: TKIP hwaccel reported Michael MIC "
3885 "failure from " MAC_FMT
" to " MAC_FMT
" keyidx=%d\n",
3886 dev
->name
, MAC_ARG(hdr
->addr2
), MAC_ARG(hdr
->addr1
), keyidx
);
3889 /* Some hardware versions seem to generate incorrect
3890 * Michael MIC reports; ignore them to avoid triggering
3891 * countermeasures. */
3892 printk(KERN_DEBUG
"%s: ignored spurious Michael MIC "
3893 "error for unknown address " MAC_FMT
"\n",
3894 dev
->name
, MAC_ARG(hdr
->addr2
));
3898 if (!(rx
->fc
& IEEE80211_FCTL_PROTECTED
)) {
3899 printk(KERN_DEBUG
"%s: ignored spurious Michael MIC "
3900 "error for a frame with no ISWEP flag (src "
3901 MAC_FMT
")\n", dev
->name
, MAC_ARG(hdr
->addr2
));
3905 if ((rx
->local
->hw
.flags
& IEEE80211_HW_WEP_INCLUDE_IV
) &&
3906 rx
->sdata
->type
== IEEE80211_IF_TYPE_AP
) {
3907 keyidx
= ieee80211_wep_get_keyidx(rx
->skb
);
3908 /* AP with Pairwise keys support should never receive Michael
3909 * MIC errors for non-zero keyidx because these are reserved
3910 * for group keys and only the AP is sending real multicast
3913 printk(KERN_DEBUG
"%s: ignored Michael MIC error for "
3914 "a frame with non-zero keyidx (%d) (src " MAC_FMT
3915 ")\n", dev
->name
, keyidx
, MAC_ARG(hdr
->addr2
));
3920 if ((rx
->fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
&&
3921 ((rx
->fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_MGMT
||
3922 (rx
->fc
& IEEE80211_FCTL_STYPE
) != IEEE80211_STYPE_AUTH
)) {
3923 printk(KERN_DEBUG
"%s: ignored spurious Michael MIC "
3924 "error for a frame that cannot be encrypted "
3925 "(fc=0x%04x) (src " MAC_FMT
")\n",
3926 dev
->name
, rx
->fc
, MAC_ARG(hdr
->addr2
));
3931 union iwreq_data wrqu
;
3932 char *buf
= kmalloc(128, GFP_ATOMIC
);
3936 /* TODO: needed parameters: count, key type, TSC */
3937 sprintf(buf
, "MLME-MICHAELMICFAILURE.indication("
3938 "keyid=%d %scast addr=" MAC_FMT
")",
3939 keyidx
, hdr
->addr1
[0] & 0x01 ? "broad" : "uni",
3940 MAC_ARG(hdr
->addr2
));
3941 memset(&wrqu
, 0, sizeof(wrqu
));
3942 wrqu
.data
.length
= strlen(buf
);
3943 wireless_send_event(rx
->dev
, IWEVCUSTOM
, &wrqu
, buf
);
3947 /* TODO: consider verifying the MIC error report with software
3948 * implementation if we get too many spurious reports from the
3950 if (!rx
->local
->apdev
)
3952 ieee80211_rx_mgmt(rx
->local
, rx
->skb
, rx
->u
.rx
.status
,
3953 ieee80211_msg_michael_mic_failure
);
3957 dev_kfree_skb(rx
->skb
);
3961 static inline ieee80211_txrx_result
__ieee80211_invoke_rx_handlers(
3962 struct ieee80211_local
*local
,
3963 ieee80211_rx_handler
*handlers
,
3964 struct ieee80211_txrx_data
*rx
,
3965 struct sta_info
*sta
)
3967 ieee80211_rx_handler
*handler
;
3968 ieee80211_txrx_result res
= TXRX_DROP
;
3970 for (handler
= handlers
; *handler
!= NULL
; handler
++) {
3971 res
= (*handler
)(rx
);
3972 if (res
!= TXRX_CONTINUE
) {
3973 if (res
== TXRX_DROP
) {
3974 I802_DEBUG_INC(local
->rx_handlers_drop
);
3978 if (res
== TXRX_QUEUED
)
3979 I802_DEBUG_INC(local
->rx_handlers_queued
);
3984 if (res
== TXRX_DROP
) {
3985 dev_kfree_skb(rx
->skb
);
3990 static inline void ieee80211_invoke_rx_handlers(struct ieee80211_local
*local
,
3991 ieee80211_rx_handler
*handlers
,
3992 struct ieee80211_txrx_data
*rx
,
3993 struct sta_info
*sta
)
3995 if (__ieee80211_invoke_rx_handlers(local
, handlers
, rx
, sta
) ==
3997 dev_kfree_skb(rx
->skb
);
4001 * This is the receive path handler. It is called by a low level driver when an
4002 * 802.11 MPDU is received from the hardware.
4004 void __ieee80211_rx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
4005 struct ieee80211_rx_status
*status
)
4007 struct ieee80211_local
*local
= hw_to_local(hw
);
4008 struct ieee80211_sub_if_data
*sdata
;
4009 struct sta_info
*sta
;
4010 struct ieee80211_hdr
*hdr
;
4011 struct ieee80211_txrx_data rx
;
4014 int radiotap_len
= 0;
4016 if (status
->flag
& RX_FLAG_RADIOTAP
) {
4017 radiotap_len
= ieee80211_get_radiotap_len(skb
);
4018 skb_pull(skb
, radiotap_len
);
4021 hdr
= (struct ieee80211_hdr
*) skb
->data
;
4022 memset(&rx
, 0, sizeof(rx
));
4026 rx
.u
.rx
.status
= status
;
4027 rx
.fc
= skb
->len
>= 2 ? le16_to_cpu(hdr
->frame_control
) : 0;
4028 type
= rx
.fc
& IEEE80211_FCTL_FTYPE
;
4029 if (type
== IEEE80211_FTYPE_DATA
|| type
== IEEE80211_FTYPE_MGMT
)
4030 local
->dot11ReceivedFragmentCount
++;
4031 multicast
= is_multicast_ether_addr(hdr
->addr1
);
4034 sta
= rx
.sta
= sta_info_get(local
, hdr
->addr2
);
4036 sta
= rx
.sta
= NULL
;
4040 rx
.sdata
= IEEE80211_DEV_TO_SUB_IF(rx
.dev
);
4043 if ((status
->flag
& RX_FLAG_MMIC_ERROR
)) {
4044 ieee80211_rx_michael_mic_report(local
->mdev
, hdr
, sta
, &rx
);
4048 if (unlikely(local
->sta_scanning
))
4049 rx
.u
.rx
.in_scan
= 1;
4051 if (__ieee80211_invoke_rx_handlers(local
, local
->rx_pre_handlers
, &rx
,
4052 sta
) != TXRX_CONTINUE
)
4056 skb_push(skb
, radiotap_len
);
4057 if (sta
&& !sta
->assoc_ap
&& !(sta
->flags
& WLAN_STA_WDS
) &&
4058 !local
->iff_promiscs
&& !multicast
) {
4059 rx
.u
.rx
.ra_match
= 1;
4060 ieee80211_invoke_rx_handlers(local
, local
->rx_handlers
, &rx
,
4063 struct ieee80211_sub_if_data
*prev
= NULL
;
4064 struct sk_buff
*skb_new
;
4065 u8
*bssid
= ieee80211_get_bssid(hdr
, skb
->len
- radiotap_len
);
4067 read_lock(&local
->sub_if_lock
);
4068 list_for_each_entry(sdata
, &local
->sub_if_list
, list
) {
4069 rx
.u
.rx
.ra_match
= 1;
4070 switch (sdata
->type
) {
4071 case IEEE80211_IF_TYPE_STA
:
4074 if (!ieee80211_bssid_match(bssid
,
4075 sdata
->u
.sta
.bssid
)) {
4076 if (!rx
.u
.rx
.in_scan
)
4078 rx
.u
.rx
.ra_match
= 0;
4079 } else if (!multicast
&&
4080 compare_ether_addr(sdata
->dev
->dev_addr
,
4082 if (!sdata
->promisc
)
4084 rx
.u
.rx
.ra_match
= 0;
4087 case IEEE80211_IF_TYPE_IBSS
:
4090 if (!ieee80211_bssid_match(bssid
,
4091 sdata
->u
.sta
.bssid
)) {
4092 if (!rx
.u
.rx
.in_scan
)
4094 rx
.u
.rx
.ra_match
= 0;
4095 } else if (!multicast
&&
4096 compare_ether_addr(sdata
->dev
->dev_addr
,
4098 if (!sdata
->promisc
)
4100 rx
.u
.rx
.ra_match
= 0;
4103 ieee80211_ibss_add_sta(sdata
->dev
,
4107 case IEEE80211_IF_TYPE_AP
:
4109 if (compare_ether_addr(sdata
->dev
->dev_addr
,
4112 } else if (!ieee80211_bssid_match(bssid
,
4113 sdata
->dev
->dev_addr
)) {
4114 if (!rx
.u
.rx
.in_scan
)
4116 rx
.u
.rx
.ra_match
= 0;
4118 if (sdata
->dev
== local
->mdev
&&
4120 /* do not receive anything via
4121 * master device when not scanning */
4124 case IEEE80211_IF_TYPE_WDS
:
4126 (rx
.fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
)
4128 if (compare_ether_addr(sdata
->u
.wds
.remote_addr
,
4135 skb_new
= skb_copy(skb
, GFP_ATOMIC
);
4137 if (net_ratelimit())
4138 printk(KERN_DEBUG
"%s: failed to copy "
4139 "multicast frame for %s",
4140 local
->mdev
->name
, prev
->dev
->name
);
4146 ieee80211_invoke_rx_handlers(local
,
4156 ieee80211_invoke_rx_handlers(local
, local
->rx_handlers
,
4160 read_unlock(&local
->sub_if_lock
);
4167 EXPORT_SYMBOL(__ieee80211_rx
);
4169 static ieee80211_txrx_result
4170 ieee80211_tx_h_load_stats(struct ieee80211_txrx_data
*tx
)
4172 struct ieee80211_local
*local
= tx
->local
;
4173 struct ieee80211_hw_mode
*mode
= tx
->u
.tx
.mode
;
4174 struct sk_buff
*skb
= tx
->skb
;
4175 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
4176 u32 load
= 0, hdrtime
;
4178 /* TODO: this could be part of tx_status handling, so that the number
4179 * of retries would be known; TX rate should in that case be stored
4180 * somewhere with the packet */
4182 /* Estimate total channel use caused by this frame */
4184 /* 1 bit at 1 Mbit/s takes 1 usec; in channel_use values,
4185 * 1 usec = 1/8 * (1080 / 10) = 13.5 */
4187 if (mode
->mode
== MODE_IEEE80211A
||
4188 mode
->mode
== MODE_ATHEROS_TURBO
||
4189 mode
->mode
== MODE_ATHEROS_TURBOG
||
4190 (mode
->mode
== MODE_IEEE80211G
&&
4191 tx
->u
.tx
.rate
->flags
& IEEE80211_RATE_ERP
))
4192 hdrtime
= CHAN_UTIL_HDR_SHORT
;
4194 hdrtime
= CHAN_UTIL_HDR_LONG
;
4197 if (!is_multicast_ether_addr(hdr
->addr1
))
4200 if (tx
->u
.tx
.control
->flags
& IEEE80211_TXCTL_USE_RTS_CTS
)
4201 load
+= 2 * hdrtime
;
4202 else if (tx
->u
.tx
.control
->flags
& IEEE80211_TXCTL_USE_CTS_PROTECT
)
4205 load
+= skb
->len
* tx
->u
.tx
.rate
->rate_inv
;
4207 if (tx
->u
.tx
.extra_frag
) {
4209 for (i
= 0; i
< tx
->u
.tx
.num_extra_frag
; i
++) {
4210 load
+= 2 * hdrtime
;
4211 load
+= tx
->u
.tx
.extra_frag
[i
]->len
*
4212 tx
->u
.tx
.rate
->rate
;
4216 /* Divide channel_use by 8 to avoid wrapping around the counter */
4217 load
>>= CHAN_UTIL_SHIFT
;
4218 local
->channel_use_raw
+= load
;
4220 tx
->sta
->channel_use_raw
+= load
;
4221 tx
->sdata
->channel_use_raw
+= load
;
4223 return TXRX_CONTINUE
;
4227 static ieee80211_txrx_result
4228 ieee80211_rx_h_load_stats(struct ieee80211_txrx_data
*rx
)
4230 struct ieee80211_local
*local
= rx
->local
;
4231 struct sk_buff
*skb
= rx
->skb
;
4232 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
4233 u32 load
= 0, hdrtime
;
4234 struct ieee80211_rate
*rate
;
4235 struct ieee80211_hw_mode
*mode
= local
->hw
.conf
.mode
;
4238 /* Estimate total channel use caused by this frame */
4240 if (unlikely(mode
->num_rates
< 0))
4241 return TXRX_CONTINUE
;
4243 rate
= &mode
->rates
[0];
4244 for (i
= 0; i
< mode
->num_rates
; i
++) {
4245 if (mode
->rates
[i
].val
== rx
->u
.rx
.status
->rate
) {
4246 rate
= &mode
->rates
[i
];
4251 /* 1 bit at 1 Mbit/s takes 1 usec; in channel_use values,
4252 * 1 usec = 1/8 * (1080 / 10) = 13.5 */
4254 if (mode
->mode
== MODE_IEEE80211A
||
4255 mode
->mode
== MODE_ATHEROS_TURBO
||
4256 mode
->mode
== MODE_ATHEROS_TURBOG
||
4257 (mode
->mode
== MODE_IEEE80211G
&&
4258 rate
->flags
& IEEE80211_RATE_ERP
))
4259 hdrtime
= CHAN_UTIL_HDR_SHORT
;
4261 hdrtime
= CHAN_UTIL_HDR_LONG
;
4264 if (!is_multicast_ether_addr(hdr
->addr1
))
4267 load
+= skb
->len
* rate
->rate_inv
;
4269 /* Divide channel_use by 8 to avoid wrapping around the counter */
4270 load
>>= CHAN_UTIL_SHIFT
;
4271 local
->channel_use_raw
+= load
;
4273 rx
->sta
->channel_use_raw
+= load
;
4274 rx
->u
.rx
.load
= load
;
4276 return TXRX_CONTINUE
;
4279 static ieee80211_txrx_result
4280 ieee80211_rx_h_if_stats(struct ieee80211_txrx_data
*rx
)
4282 rx
->sdata
->channel_use_raw
+= rx
->u
.rx
.load
;
4283 return TXRX_CONTINUE
;
4286 static void ieee80211_stat_refresh(unsigned long data
)
4288 struct ieee80211_local
*local
= (struct ieee80211_local
*) data
;
4289 struct sta_info
*sta
;
4290 struct ieee80211_sub_if_data
*sdata
;
4292 if (!local
->stat_time
)
4295 /* go through all stations */
4296 spin_lock_bh(&local
->sta_lock
);
4297 list_for_each_entry(sta
, &local
->sta_list
, list
) {
4298 sta
->channel_use
= (sta
->channel_use_raw
/ local
->stat_time
) /
4300 sta
->channel_use_raw
= 0;
4302 spin_unlock_bh(&local
->sta_lock
);
4304 /* go through all subinterfaces */
4305 read_lock(&local
->sub_if_lock
);
4306 list_for_each_entry(sdata
, &local
->sub_if_list
, list
) {
4307 sdata
->channel_use
= (sdata
->channel_use_raw
/
4308 local
->stat_time
) / CHAN_UTIL_PER_10MS
;
4309 sdata
->channel_use_raw
= 0;
4311 read_unlock(&local
->sub_if_lock
);
4313 /* hardware interface */
4314 local
->channel_use
= (local
->channel_use_raw
/
4315 local
->stat_time
) / CHAN_UTIL_PER_10MS
;
4316 local
->channel_use_raw
= 0;
4318 local
->stat_timer
.expires
= jiffies
+ HZ
* local
->stat_time
/ 100;
4319 add_timer(&local
->stat_timer
);
4323 /* This is a version of the rx handler that can be called from hard irq
4324 * context. Post the skb on the queue and schedule the tasklet */
4325 void ieee80211_rx_irqsafe(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
4326 struct ieee80211_rx_status
*status
)
4328 struct ieee80211_local
*local
= hw_to_local(hw
);
4330 BUILD_BUG_ON(sizeof(struct ieee80211_rx_status
) > sizeof(skb
->cb
));
4332 skb
->dev
= local
->mdev
;
4333 /* copy status into skb->cb for use by tasklet */
4334 memcpy(skb
->cb
, status
, sizeof(*status
));
4335 skb
->pkt_type
= IEEE80211_RX_MSG
;
4336 skb_queue_tail(&local
->skb_queue
, skb
);
4337 tasklet_schedule(&local
->tasklet
);
4339 EXPORT_SYMBOL(ieee80211_rx_irqsafe
);
4341 void ieee80211_tx_status_irqsafe(struct ieee80211_hw
*hw
,
4342 struct sk_buff
*skb
,
4343 struct ieee80211_tx_status
*status
)
4345 struct ieee80211_local
*local
= hw_to_local(hw
);
4346 struct ieee80211_tx_status
*saved
;
4349 skb
->dev
= local
->mdev
;
4350 saved
= kmalloc(sizeof(struct ieee80211_tx_status
), GFP_ATOMIC
);
4351 if (unlikely(!saved
)) {
4352 if (net_ratelimit())
4353 printk(KERN_WARNING
"%s: Not enough memory, "
4354 "dropping tx status", skb
->dev
->name
);
4355 /* should be dev_kfree_skb_irq, but due to this function being
4356 * named _irqsafe instead of just _irq we can't be sure that
4357 * people won't call it from non-irq contexts */
4358 dev_kfree_skb_any(skb
);
4361 memcpy(saved
, status
, sizeof(struct ieee80211_tx_status
));
4362 /* copy pointer to saved status into skb->cb for use by tasklet */
4363 memcpy(skb
->cb
, &saved
, sizeof(saved
));
4365 skb
->pkt_type
= IEEE80211_TX_STATUS_MSG
;
4366 skb_queue_tail(status
->control
.flags
& IEEE80211_TXCTL_REQ_TX_STATUS
?
4367 &local
->skb_queue
: &local
->skb_queue_unreliable
, skb
);
4368 tmp
= skb_queue_len(&local
->skb_queue
) +
4369 skb_queue_len(&local
->skb_queue_unreliable
);
4370 while (tmp
> IEEE80211_IRQSAFE_QUEUE_LIMIT
&&
4371 (skb
= skb_dequeue(&local
->skb_queue_unreliable
))) {
4372 memcpy(&saved
, skb
->cb
, sizeof(saved
));
4374 dev_kfree_skb_irq(skb
);
4376 I802_DEBUG_INC(local
->tx_status_drop
);
4378 tasklet_schedule(&local
->tasklet
);
4380 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe
);
4382 static void ieee80211_tasklet_handler(unsigned long data
)
4384 struct ieee80211_local
*local
= (struct ieee80211_local
*) data
;
4385 struct sk_buff
*skb
;
4386 struct ieee80211_rx_status rx_status
;
4387 struct ieee80211_tx_status
*tx_status
;
4389 while ((skb
= skb_dequeue(&local
->skb_queue
)) ||
4390 (skb
= skb_dequeue(&local
->skb_queue_unreliable
))) {
4391 switch (skb
->pkt_type
) {
4392 case IEEE80211_RX_MSG
:
4393 /* status is in skb->cb */
4394 memcpy(&rx_status
, skb
->cb
, sizeof(rx_status
));
4395 /* Clear skb->type in order to not confuse kernel
4398 __ieee80211_rx(local_to_hw(local
), skb
, &rx_status
);
4400 case IEEE80211_TX_STATUS_MSG
:
4401 /* get pointer to saved status out of skb->cb */
4402 memcpy(&tx_status
, skb
->cb
, sizeof(tx_status
));
4404 ieee80211_tx_status(local_to_hw(local
),
4408 default: /* should never get here! */
4409 printk(KERN_ERR
"%s: Unknown message type (%d)\n",
4410 local
->mdev
->name
, skb
->pkt_type
);
4418 /* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to
4419 * make a prepared TX frame (one that has been given to hw) to look like brand
4420 * new IEEE 802.11 frame that is ready to go through TX processing again.
4421 * Also, tx_packet_data in cb is restored from tx_control. */
4422 static void ieee80211_remove_tx_extra(struct ieee80211_local
*local
,
4423 struct ieee80211_key
*key
,
4424 struct sk_buff
*skb
,
4425 struct ieee80211_tx_control
*control
)
4427 int hdrlen
, iv_len
, mic_len
;
4428 struct ieee80211_tx_packet_data
*pkt_data
;
4430 pkt_data
= (struct ieee80211_tx_packet_data
*)skb
->cb
;
4431 pkt_data
->ifindex
= control
->ifindex
;
4432 pkt_data
->mgmt_iface
= (control
->type
== IEEE80211_IF_TYPE_MGMT
);
4433 pkt_data
->req_tx_status
= !!(control
->flags
& IEEE80211_TXCTL_REQ_TX_STATUS
);
4434 pkt_data
->do_not_encrypt
= !!(control
->flags
& IEEE80211_TXCTL_DO_NOT_ENCRYPT
);
4435 pkt_data
->requeue
= !!(control
->flags
& IEEE80211_TXCTL_REQUEUE
);
4436 pkt_data
->queue
= control
->queue
;
4438 hdrlen
= ieee80211_get_hdrlen_from_skb(skb
);
4445 iv_len
= WEP_IV_LEN
;
4446 mic_len
= WEP_ICV_LEN
;
4449 iv_len
= TKIP_IV_LEN
;
4450 mic_len
= TKIP_ICV_LEN
;
4453 iv_len
= CCMP_HDR_LEN
;
4454 mic_len
= CCMP_MIC_LEN
;
4460 if (skb
->len
>= mic_len
&& key
->force_sw_encrypt
)
4461 skb_trim(skb
, skb
->len
- mic_len
);
4462 if (skb
->len
>= iv_len
&& skb
->len
> hdrlen
) {
4463 memmove(skb
->data
+ iv_len
, skb
->data
, hdrlen
);
4464 skb_pull(skb
, iv_len
);
4469 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
4470 u16 fc
= le16_to_cpu(hdr
->frame_control
);
4471 if ((fc
& 0x8C) == 0x88) /* QoS Control Field */ {
4472 fc
&= ~IEEE80211_STYPE_QOS_DATA
;
4473 hdr
->frame_control
= cpu_to_le16(fc
);
4474 memmove(skb
->data
+ 2, skb
->data
, hdrlen
- 2);
4481 void ieee80211_tx_status(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
4482 struct ieee80211_tx_status
*status
)
4484 struct sk_buff
*skb2
;
4485 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
4486 struct ieee80211_local
*local
= hw_to_local(hw
);
4489 struct ieee80211_tx_status_rtap_hdr
*rthdr
;
4490 struct ieee80211_sub_if_data
*sdata
;
4495 "%s: ieee80211_tx_status called with NULL status\n",
4501 if (status
->excessive_retries
) {
4502 struct sta_info
*sta
;
4503 sta
= sta_info_get(local
, hdr
->addr1
);
4505 if (sta
->flags
& WLAN_STA_PS
) {
4506 /* The STA is in power save mode, so assume
4507 * that this TX packet failed because of that.
4509 status
->excessive_retries
= 0;
4510 status
->flags
|= IEEE80211_TX_STATUS_TX_FILTERED
;
4516 if (status
->flags
& IEEE80211_TX_STATUS_TX_FILTERED
) {
4517 struct sta_info
*sta
;
4518 sta
= sta_info_get(local
, hdr
->addr1
);
4520 sta
->tx_filtered_count
++;
4522 /* Clear the TX filter mask for this STA when sending
4523 * the next packet. If the STA went to power save mode,
4524 * this will happen when it is waking up for the next
4526 sta
->clear_dst_mask
= 1;
4528 /* TODO: Is the WLAN_STA_PS flag always set here or is
4529 * the race between RX and TX status causing some
4530 * packets to be filtered out before 80211.o gets an
4531 * update for PS status? This seems to be the case, so
4532 * no changes are likely to be needed. */
4533 if (sta
->flags
& WLAN_STA_PS
&&
4534 skb_queue_len(&sta
->tx_filtered
) <
4535 STA_MAX_TX_BUFFER
) {
4536 ieee80211_remove_tx_extra(local
, sta
->key
,
4539 skb_queue_tail(&sta
->tx_filtered
, skb
);
4540 } else if (!(sta
->flags
& WLAN_STA_PS
) &&
4541 !(status
->control
.flags
& IEEE80211_TXCTL_REQUEUE
)) {
4542 /* Software retry the packet once */
4543 status
->control
.flags
|= IEEE80211_TXCTL_REQUEUE
;
4544 ieee80211_remove_tx_extra(local
, sta
->key
,
4547 dev_queue_xmit(skb
);
4549 if (net_ratelimit()) {
4550 printk(KERN_DEBUG
"%s: dropped TX "
4551 "filtered frame queue_len=%d "
4556 !!(sta
->flags
& WLAN_STA_PS
),
4565 /* FIXME: STUPID to call this with both local and local->mdev */
4566 rate_control_tx_status(local
, local
->mdev
, skb
, status
);
4569 ieee80211_led_tx(local
, 0);
4572 * Fragments are passed to low-level drivers as separate skbs, so these
4573 * are actually fragments, not frames. Update frame counters only for
4574 * the first fragment of the frame. */
4576 frag
= le16_to_cpu(hdr
->seq_ctrl
) & IEEE80211_SCTL_FRAG
;
4577 type
= le16_to_cpu(hdr
->frame_control
) & IEEE80211_FCTL_FTYPE
;
4579 if (status
->flags
& IEEE80211_TX_STATUS_ACK
) {
4581 local
->dot11TransmittedFrameCount
++;
4582 if (is_multicast_ether_addr(hdr
->addr1
))
4583 local
->dot11MulticastTransmittedFrameCount
++;
4584 if (status
->retry_count
> 0)
4585 local
->dot11RetryCount
++;
4586 if (status
->retry_count
> 1)
4587 local
->dot11MultipleRetryCount
++;
4590 /* This counter shall be incremented for an acknowledged MPDU
4591 * with an individual address in the address 1 field or an MPDU
4592 * with a multicast address in the address 1 field of type Data
4594 if (!is_multicast_ether_addr(hdr
->addr1
) ||
4595 type
== IEEE80211_FTYPE_DATA
||
4596 type
== IEEE80211_FTYPE_MGMT
)
4597 local
->dot11TransmittedFragmentCount
++;
4600 local
->dot11FailedCount
++;
4603 msg_type
= (status
->flags
& IEEE80211_TX_STATUS_ACK
) ?
4604 ieee80211_msg_tx_callback_ack
: ieee80211_msg_tx_callback_fail
;
4606 /* this was a transmitted frame, but now we want to reuse it */
4609 if ((status
->control
.flags
& IEEE80211_TXCTL_REQ_TX_STATUS
) &&
4611 if (local
->monitors
) {
4612 skb2
= skb_clone(skb
, GFP_ATOMIC
);
4619 /* Send frame to hostapd */
4620 ieee80211_rx_mgmt(local
, skb2
, NULL
, msg_type
);
4626 if (!local
->monitors
) {
4631 /* send frame to monitor interfaces now */
4633 if (skb_headroom(skb
) < sizeof(*rthdr
)) {
4634 printk(KERN_ERR
"ieee80211_tx_status: headroom too small\n");
4639 rthdr
= (struct ieee80211_tx_status_rtap_hdr
*)
4640 skb_push(skb
, sizeof(*rthdr
));
4642 memset(rthdr
, 0, sizeof(*rthdr
));
4643 rthdr
->hdr
.it_len
= cpu_to_le16(sizeof(*rthdr
));
4644 rthdr
->hdr
.it_present
=
4645 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS
) |
4646 (1 << IEEE80211_RADIOTAP_DATA_RETRIES
));
4648 if (!(status
->flags
& IEEE80211_TX_STATUS_ACK
) &&
4649 !is_multicast_ether_addr(hdr
->addr1
))
4650 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL
);
4652 if ((status
->control
.flags
& IEEE80211_TXCTL_USE_RTS_CTS
) &&
4653 (status
->control
.flags
& IEEE80211_TXCTL_USE_CTS_PROTECT
))
4654 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS
);
4655 else if (status
->control
.flags
& IEEE80211_TXCTL_USE_RTS_CTS
)
4656 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS
);
4658 rthdr
->data_retries
= status
->retry_count
;
4660 read_lock(&local
->sub_if_lock
);
4661 monitors
= local
->monitors
;
4662 list_for_each_entry(sdata
, &local
->sub_if_list
, list
) {
4664 * Using the monitors counter is possibly racy, but
4665 * if the value is wrong we simply either clone the skb
4666 * once too much or forget sending it to one monitor iface
4667 * The latter case isn't nice but fixing the race is much
4670 if (!monitors
|| !skb
)
4673 if (sdata
->type
== IEEE80211_IF_TYPE_MNTR
) {
4674 if (!netif_running(sdata
->dev
))
4678 skb2
= skb_clone(skb
, GFP_KERNEL
);
4681 skb
->dev
= sdata
->dev
;
4682 /* XXX: is this sufficient for BPF? */
4683 skb_set_mac_header(skb
, 0);
4684 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
4685 skb
->pkt_type
= PACKET_OTHERHOST
;
4686 skb
->protocol
= htons(ETH_P_802_2
);
4687 memset(skb
->cb
, 0, sizeof(skb
->cb
));
4693 read_unlock(&local
->sub_if_lock
);
4697 EXPORT_SYMBOL(ieee80211_tx_status
);
4699 /* TODO: implement register/unregister functions for adding TX/RX handlers
4700 * into ordered list */
4702 /* rx_pre handlers don't have dev and sdata fields available in
4703 * ieee80211_txrx_data */
4704 static ieee80211_rx_handler ieee80211_rx_pre_handlers
[] =
4706 ieee80211_rx_h_parse_qos
,
4707 ieee80211_rx_h_load_stats
,
4711 static ieee80211_rx_handler ieee80211_rx_handlers
[] =
4713 ieee80211_rx_h_if_stats
,
4714 ieee80211_rx_h_monitor
,
4715 ieee80211_rx_h_passive_scan
,
4716 ieee80211_rx_h_check
,
4717 ieee80211_rx_h_sta_process
,
4718 ieee80211_rx_h_ccmp_decrypt
,
4719 ieee80211_rx_h_tkip_decrypt
,
4720 ieee80211_rx_h_wep_weak_iv_detection
,
4721 ieee80211_rx_h_wep_decrypt
,
4722 ieee80211_rx_h_defragment
,
4723 ieee80211_rx_h_ps_poll
,
4724 ieee80211_rx_h_michael_mic_verify
,
4725 /* this must be after decryption - so header is counted in MPDU mic
4726 * must be before pae and data, so QOS_DATA format frames
4727 * are not passed to user space by these functions
4729 ieee80211_rx_h_remove_qos_control
,
4730 ieee80211_rx_h_802_1x_pae
,
4731 ieee80211_rx_h_drop_unencrypted
,
4732 ieee80211_rx_h_data
,
4733 ieee80211_rx_h_mgmt
,
4737 static ieee80211_tx_handler ieee80211_tx_handlers
[] =
4739 ieee80211_tx_h_check_assoc
,
4740 ieee80211_tx_h_sequence
,
4741 ieee80211_tx_h_ps_buf
,
4742 ieee80211_tx_h_select_key
,
4743 ieee80211_tx_h_michael_mic_add
,
4744 ieee80211_tx_h_fragment
,
4745 ieee80211_tx_h_tkip_encrypt
,
4746 ieee80211_tx_h_ccmp_encrypt
,
4747 ieee80211_tx_h_wep_encrypt
,
4748 ieee80211_tx_h_rate_ctrl
,
4749 ieee80211_tx_h_misc
,
4750 ieee80211_tx_h_load_stats
,
4755 int ieee80211_if_update_wds(struct net_device
*dev
, u8
*remote_addr
)
4757 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
4758 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
4759 struct sta_info
*sta
;
4761 if (compare_ether_addr(remote_addr
, sdata
->u
.wds
.remote_addr
) == 0)
4764 /* Create STA entry for the new peer */
4765 sta
= sta_info_add(local
, dev
, remote_addr
, GFP_KERNEL
);
4770 /* Remove STA entry for the old peer */
4771 sta
= sta_info_get(local
, sdata
->u
.wds
.remote_addr
);
4774 sta_info_free(sta
, 0);
4776 printk(KERN_DEBUG
"%s: could not find STA entry for WDS link "
4777 "peer " MAC_FMT
"\n",
4778 dev
->name
, MAC_ARG(sdata
->u
.wds
.remote_addr
));
4781 /* Update WDS link data */
4782 memcpy(&sdata
->u
.wds
.remote_addr
, remote_addr
, ETH_ALEN
);
4787 /* Must not be called for mdev and apdev */
4788 void ieee80211_if_setup(struct net_device
*dev
)
4791 dev
->hard_start_xmit
= ieee80211_subif_start_xmit
;
4792 dev
->wireless_handlers
= &ieee80211_iw_handler_def
;
4793 dev
->set_multicast_list
= ieee80211_set_multicast_list
;
4794 dev
->change_mtu
= ieee80211_change_mtu
;
4795 dev
->get_stats
= ieee80211_get_stats
;
4796 dev
->open
= ieee80211_open
;
4797 dev
->stop
= ieee80211_stop
;
4798 dev
->uninit
= ieee80211_if_reinit
;
4799 dev
->destructor
= ieee80211_if_free
;
4802 void ieee80211_if_mgmt_setup(struct net_device
*dev
)
4805 dev
->hard_start_xmit
= ieee80211_mgmt_start_xmit
;
4806 dev
->change_mtu
= ieee80211_change_mtu_apdev
;
4807 dev
->get_stats
= ieee80211_get_stats
;
4808 dev
->open
= ieee80211_mgmt_open
;
4809 dev
->stop
= ieee80211_mgmt_stop
;
4810 dev
->type
= ARPHRD_IEEE80211_PRISM
;
4811 dev
->hard_header_parse
= header_parse_80211
;
4812 dev
->uninit
= ieee80211_if_reinit
;
4813 dev
->destructor
= ieee80211_if_free
;
4816 int ieee80211_init_rate_ctrl_alg(struct ieee80211_local
*local
,
4819 struct rate_control_ref
*ref
, *old
;
4822 if (local
->open_count
|| netif_running(local
->mdev
) ||
4823 (local
->apdev
&& netif_running(local
->apdev
)))
4826 ref
= rate_control_alloc(name
, local
);
4828 printk(KERN_WARNING
"%s: Failed to select rate control "
4829 "algorithm\n", local
->mdev
->name
);
4833 old
= local
->rate_ctrl
;
4834 local
->rate_ctrl
= ref
;
4836 rate_control_put(old
);
4837 sta_info_flush(local
, NULL
);
4840 printk(KERN_DEBUG
"%s: Selected rate control "
4841 "algorithm '%s'\n", local
->mdev
->name
,
4848 static void rate_control_deinitialize(struct ieee80211_local
*local
)
4850 struct rate_control_ref
*ref
;
4852 ref
= local
->rate_ctrl
;
4853 local
->rate_ctrl
= NULL
;
4854 rate_control_put(ref
);
4857 struct ieee80211_hw
*ieee80211_alloc_hw(size_t priv_data_len
,
4858 const struct ieee80211_ops
*ops
)
4860 struct net_device
*mdev
;
4861 struct ieee80211_local
*local
;
4862 struct ieee80211_sub_if_data
*sdata
;
4864 struct wiphy
*wiphy
;
4866 /* Ensure 32-byte alignment of our private data and hw private data.
4867 * We use the wiphy priv data for both our ieee80211_local and for
4868 * the driver's private data
4870 * In memory it'll be like this:
4872 * +-------------------------+
4874 * +-------------------------+
4875 * | struct ieee80211_local |
4876 * +-------------------------+
4877 * | driver's private data |
4878 * +-------------------------+
4881 priv_size
= ((sizeof(struct ieee80211_local
) +
4882 NETDEV_ALIGN_CONST
) & ~NETDEV_ALIGN_CONST
) +
4885 wiphy
= wiphy_new(&mac80211_config_ops
, priv_size
);
4890 wiphy
->privid
= mac80211_wiphy_privid
;
4892 local
= wiphy_priv(wiphy
);
4893 local
->hw
.wiphy
= wiphy
;
4895 local
->hw
.priv
= (char *)local
+
4896 ((sizeof(struct ieee80211_local
) +
4897 NETDEV_ALIGN_CONST
) & ~NETDEV_ALIGN_CONST
);
4900 BUG_ON(!ops
->config
);
4901 BUG_ON(!ops
->add_interface
);
4904 /* for now, mdev needs sub_if_data :/ */
4905 mdev
= alloc_netdev(sizeof(struct ieee80211_sub_if_data
),
4906 "wmaster%d", ether_setup
);
4912 sdata
= IEEE80211_DEV_TO_SUB_IF(mdev
);
4913 mdev
->ieee80211_ptr
= &sdata
->wdev
;
4914 sdata
->wdev
.wiphy
= wiphy
;
4916 local
->hw
.queues
= 1; /* default */
4919 local
->rx_pre_handlers
= ieee80211_rx_pre_handlers
;
4920 local
->rx_handlers
= ieee80211_rx_handlers
;
4921 local
->tx_handlers
= ieee80211_tx_handlers
;
4923 local
->bridge_packets
= 1;
4925 local
->rts_threshold
= IEEE80211_MAX_RTS_THRESHOLD
;
4926 local
->fragmentation_threshold
= IEEE80211_MAX_FRAG_THRESHOLD
;
4927 local
->short_retry_limit
= 7;
4928 local
->long_retry_limit
= 4;
4929 local
->hw
.conf
.radio_enabled
= 1;
4931 local
->enabled_modes
= (unsigned int) -1;
4933 INIT_LIST_HEAD(&local
->modes_list
);
4935 rwlock_init(&local
->sub_if_lock
);
4936 INIT_LIST_HEAD(&local
->sub_if_list
);
4938 INIT_DELAYED_WORK(&local
->scan_work
, ieee80211_sta_scan_work
);
4939 init_timer(&local
->stat_timer
);
4940 local
->stat_timer
.function
= ieee80211_stat_refresh
;
4941 local
->stat_timer
.data
= (unsigned long) local
;
4942 ieee80211_rx_bss_list_init(mdev
);
4944 sta_info_init(local
);
4946 mdev
->hard_start_xmit
= ieee80211_master_start_xmit
;
4947 mdev
->open
= ieee80211_master_open
;
4948 mdev
->stop
= ieee80211_master_stop
;
4949 mdev
->type
= ARPHRD_IEEE80211
;
4950 mdev
->hard_header_parse
= header_parse_80211
;
4952 sdata
->type
= IEEE80211_IF_TYPE_AP
;
4954 sdata
->local
= local
;
4955 sdata
->u
.ap
.force_unicast_rateidx
= -1;
4956 sdata
->u
.ap
.max_ratectrl_rateidx
= -1;
4957 ieee80211_if_sdata_init(sdata
);
4958 list_add_tail(&sdata
->list
, &local
->sub_if_list
);
4960 tasklet_init(&local
->tx_pending_tasklet
, ieee80211_tx_pending
,
4961 (unsigned long)local
);
4962 tasklet_disable(&local
->tx_pending_tasklet
);
4964 tasklet_init(&local
->tasklet
,
4965 ieee80211_tasklet_handler
,
4966 (unsigned long) local
);
4967 tasklet_disable(&local
->tasklet
);
4969 skb_queue_head_init(&local
->skb_queue
);
4970 skb_queue_head_init(&local
->skb_queue_unreliable
);
4972 return local_to_hw(local
);
4974 EXPORT_SYMBOL(ieee80211_alloc_hw
);
4976 int ieee80211_register_hw(struct ieee80211_hw
*hw
)
4978 struct ieee80211_local
*local
= hw_to_local(hw
);
4982 result
= wiphy_register(local
->hw
.wiphy
);
4986 name
= wiphy_dev(local
->hw
.wiphy
)->driver
->name
;
4987 local
->hw
.workqueue
= create_singlethread_workqueue(name
);
4988 if (!local
->hw
.workqueue
) {
4990 goto fail_workqueue
;
4994 * The hardware needs headroom for sending the frame,
4995 * and we need some headroom for passing the frame to monitor
4996 * interfaces, but never both at the same time.
4998 local
->tx_headroom
= max_t(unsigned int , local
->hw
.extra_tx_headroom
,
4999 sizeof(struct ieee80211_tx_status_rtap_hdr
));
5001 debugfs_hw_add(local
);
5003 local
->hw
.conf
.beacon_int
= 1000;
5005 local
->wstats_flags
|= local
->hw
.max_rssi
?
5006 IW_QUAL_LEVEL_UPDATED
: IW_QUAL_LEVEL_INVALID
;
5007 local
->wstats_flags
|= local
->hw
.max_signal
?
5008 IW_QUAL_QUAL_UPDATED
: IW_QUAL_QUAL_INVALID
;
5009 local
->wstats_flags
|= local
->hw
.max_noise
?
5010 IW_QUAL_NOISE_UPDATED
: IW_QUAL_NOISE_INVALID
;
5011 if (local
->hw
.max_rssi
< 0 || local
->hw
.max_noise
< 0)
5012 local
->wstats_flags
|= IW_QUAL_DBM
;
5014 result
= sta_info_start(local
);
5019 result
= dev_alloc_name(local
->mdev
, local
->mdev
->name
);
5023 memcpy(local
->mdev
->dev_addr
, local
->hw
.wiphy
->perm_addr
, ETH_ALEN
);
5024 SET_NETDEV_DEV(local
->mdev
, wiphy_dev(local
->hw
.wiphy
));
5026 result
= register_netdevice(local
->mdev
);
5030 ieee80211_debugfs_add_netdev(IEEE80211_DEV_TO_SUB_IF(local
->mdev
));
5032 result
= ieee80211_init_rate_ctrl_alg(local
, NULL
);
5034 printk(KERN_DEBUG
"%s: Failed to initialize rate control "
5035 "algorithm\n", local
->mdev
->name
);
5039 result
= ieee80211_wep_init(local
);
5042 printk(KERN_DEBUG
"%s: Failed to initialize wep\n",
5047 ieee80211_install_qdisc(local
->mdev
);
5049 /* add one default STA interface */
5050 result
= ieee80211_if_add(local
->mdev
, "wlan%d", NULL
,
5051 IEEE80211_IF_TYPE_STA
);
5053 printk(KERN_WARNING
"%s: Failed to add default virtual iface\n",
5056 local
->reg_state
= IEEE80211_DEV_REGISTERED
;
5059 ieee80211_led_init(local
);
5064 rate_control_deinitialize(local
);
5066 ieee80211_debugfs_remove_netdev(IEEE80211_DEV_TO_SUB_IF(local
->mdev
));
5067 unregister_netdevice(local
->mdev
);
5070 sta_info_stop(local
);
5072 debugfs_hw_del(local
);
5073 destroy_workqueue(local
->hw
.workqueue
);
5075 wiphy_unregister(local
->hw
.wiphy
);
5078 EXPORT_SYMBOL(ieee80211_register_hw
);
5080 int ieee80211_register_hwmode(struct ieee80211_hw
*hw
,
5081 struct ieee80211_hw_mode
*mode
)
5083 struct ieee80211_local
*local
= hw_to_local(hw
);
5084 struct ieee80211_rate
*rate
;
5087 INIT_LIST_HEAD(&mode
->list
);
5088 list_add_tail(&mode
->list
, &local
->modes_list
);
5090 local
->hw_modes
|= (1 << mode
->mode
);
5091 for (i
= 0; i
< mode
->num_rates
; i
++) {
5092 rate
= &(mode
->rates
[i
]);
5093 rate
->rate_inv
= CHAN_UTIL_RATE_LCM
/ rate
->rate
;
5095 ieee80211_prepare_rates(local
, mode
);
5097 if (!local
->oper_hw_mode
) {
5098 /* Default to this mode */
5099 local
->hw
.conf
.phymode
= mode
->mode
;
5100 local
->oper_hw_mode
= local
->scan_hw_mode
= mode
;
5101 local
->oper_channel
= local
->scan_channel
= &mode
->channels
[0];
5102 local
->hw
.conf
.mode
= local
->oper_hw_mode
;
5103 local
->hw
.conf
.chan
= local
->oper_channel
;
5106 if (!(hw
->flags
& IEEE80211_HW_DEFAULT_REG_DOMAIN_CONFIGURED
))
5107 ieee80211_set_default_regdomain(mode
);
5111 EXPORT_SYMBOL(ieee80211_register_hwmode
);
5113 void ieee80211_unregister_hw(struct ieee80211_hw
*hw
)
5115 struct ieee80211_local
*local
= hw_to_local(hw
);
5116 struct ieee80211_sub_if_data
*sdata
, *tmp
;
5117 struct list_head tmp_list
;
5120 tasklet_kill(&local
->tx_pending_tasklet
);
5121 tasklet_kill(&local
->tasklet
);
5125 BUG_ON(local
->reg_state
!= IEEE80211_DEV_REGISTERED
);
5127 local
->reg_state
= IEEE80211_DEV_UNREGISTERED
;
5129 ieee80211_if_del_mgmt(local
);
5131 write_lock_bh(&local
->sub_if_lock
);
5132 list_replace_init(&local
->sub_if_list
, &tmp_list
);
5133 write_unlock_bh(&local
->sub_if_lock
);
5135 list_for_each_entry_safe(sdata
, tmp
, &tmp_list
, list
)
5136 __ieee80211_if_del(local
, sdata
);
5140 if (local
->stat_time
)
5141 del_timer_sync(&local
->stat_timer
);
5143 ieee80211_rx_bss_list_deinit(local
->mdev
);
5144 ieee80211_clear_tx_pending(local
);
5145 sta_info_stop(local
);
5146 rate_control_deinitialize(local
);
5147 debugfs_hw_del(local
);
5149 for (i
= 0; i
< NUM_IEEE80211_MODES
; i
++) {
5150 kfree(local
->supp_rates
[i
]);
5151 kfree(local
->basic_rates
[i
]);
5154 if (skb_queue_len(&local
->skb_queue
)
5155 || skb_queue_len(&local
->skb_queue_unreliable
))
5156 printk(KERN_WARNING
"%s: skb_queue not empty\n",
5158 skb_queue_purge(&local
->skb_queue
);
5159 skb_queue_purge(&local
->skb_queue_unreliable
);
5161 destroy_workqueue(local
->hw
.workqueue
);
5162 wiphy_unregister(local
->hw
.wiphy
);
5163 ieee80211_wep_free(local
);
5164 ieee80211_led_exit(local
);
5166 EXPORT_SYMBOL(ieee80211_unregister_hw
);
5168 void ieee80211_free_hw(struct ieee80211_hw
*hw
)
5170 struct ieee80211_local
*local
= hw_to_local(hw
);
5172 ieee80211_if_free(local
->mdev
);
5173 wiphy_free(local
->hw
.wiphy
);
5175 EXPORT_SYMBOL(ieee80211_free_hw
);
5177 void ieee80211_wake_queue(struct ieee80211_hw
*hw
, int queue
)
5179 struct ieee80211_local
*local
= hw_to_local(hw
);
5181 if (test_and_clear_bit(IEEE80211_LINK_STATE_XOFF
,
5182 &local
->state
[queue
])) {
5183 if (test_bit(IEEE80211_LINK_STATE_PENDING
,
5184 &local
->state
[queue
]))
5185 tasklet_schedule(&local
->tx_pending_tasklet
);
5187 if (!ieee80211_qdisc_installed(local
->mdev
)) {
5189 netif_wake_queue(local
->mdev
);
5191 __netif_schedule(local
->mdev
);
5194 EXPORT_SYMBOL(ieee80211_wake_queue
);
5196 void ieee80211_stop_queue(struct ieee80211_hw
*hw
, int queue
)
5198 struct ieee80211_local
*local
= hw_to_local(hw
);
5200 if (!ieee80211_qdisc_installed(local
->mdev
) && queue
== 0)
5201 netif_stop_queue(local
->mdev
);
5202 set_bit(IEEE80211_LINK_STATE_XOFF
, &local
->state
[queue
]);
5204 EXPORT_SYMBOL(ieee80211_stop_queue
);
5206 void ieee80211_start_queues(struct ieee80211_hw
*hw
)
5208 struct ieee80211_local
*local
= hw_to_local(hw
);
5211 for (i
= 0; i
< local
->hw
.queues
; i
++)
5212 clear_bit(IEEE80211_LINK_STATE_XOFF
, &local
->state
[i
]);
5213 if (!ieee80211_qdisc_installed(local
->mdev
))
5214 netif_start_queue(local
->mdev
);
5216 EXPORT_SYMBOL(ieee80211_start_queues
);
5218 void ieee80211_stop_queues(struct ieee80211_hw
*hw
)
5222 for (i
= 0; i
< hw
->queues
; i
++)
5223 ieee80211_stop_queue(hw
, i
);
5225 EXPORT_SYMBOL(ieee80211_stop_queues
);
5227 void ieee80211_wake_queues(struct ieee80211_hw
*hw
)
5231 for (i
= 0; i
< hw
->queues
; i
++)
5232 ieee80211_wake_queue(hw
, i
);
5234 EXPORT_SYMBOL(ieee80211_wake_queues
);
5236 struct net_device_stats
*ieee80211_dev_stats(struct net_device
*dev
)
5238 struct ieee80211_sub_if_data
*sdata
;
5239 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
5240 return &sdata
->stats
;
5243 static int __init
ieee80211_init(void)
5245 struct sk_buff
*skb
;
5248 BUILD_BUG_ON(sizeof(struct ieee80211_tx_packet_data
) > sizeof(skb
->cb
));
5250 ret
= ieee80211_wme_register();
5252 printk(KERN_DEBUG
"ieee80211_init: failed to "
5253 "initialize WME (err=%d)\n", ret
);
5257 ieee80211_debugfs_netdev_init();
5258 ieee80211_regdomain_init();
5264 static void __exit
ieee80211_exit(void)
5266 ieee80211_wme_unregister();
5267 ieee80211_debugfs_netdev_exit();
5271 subsys_initcall(ieee80211_init
);
5272 module_exit(ieee80211_exit
);
5274 MODULE_DESCRIPTION("IEEE 802.11 subsystem");
5275 MODULE_LICENSE("GPL");