2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
5 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * utilities for mac80211
14 #include <net/mac80211.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/bitmap.h>
22 #include <linux/crc32.h>
23 #include <net/net_namespace.h>
24 #include <net/cfg80211.h>
25 #include <net/rtnetlink.h>
27 #include "ieee80211_i.h"
28 #include "driver-ops.h"
35 /* privid for wiphys to determine whether they belong to us or not */
36 void *mac80211_wiphy_privid
= &mac80211_wiphy_privid
;
38 struct ieee80211_hw
*wiphy_to_ieee80211_hw(struct wiphy
*wiphy
)
40 struct ieee80211_local
*local
;
43 local
= wiphy_priv(wiphy
);
46 EXPORT_SYMBOL(wiphy_to_ieee80211_hw
);
48 u8
*ieee80211_get_bssid(struct ieee80211_hdr
*hdr
, size_t len
,
49 enum nl80211_iftype type
)
51 __le16 fc
= hdr
->frame_control
;
53 /* drop ACK/CTS frames and incorrect hdr len (ctrl) */
57 if (ieee80211_is_data(fc
)) {
58 if (len
< 24) /* drop incorrect hdr len (data) */
61 if (ieee80211_has_a4(fc
))
63 if (ieee80211_has_tods(fc
))
65 if (ieee80211_has_fromds(fc
))
71 if (ieee80211_is_mgmt(fc
)) {
72 if (len
< 24) /* drop incorrect hdr len (mgmt) */
77 if (ieee80211_is_ctl(fc
)) {
78 if(ieee80211_is_pspoll(fc
))
81 if (ieee80211_is_back_req(fc
)) {
83 case NL80211_IFTYPE_STATION
:
85 case NL80211_IFTYPE_AP
:
86 case NL80211_IFTYPE_AP_VLAN
:
89 break; /* fall through to the return */
97 void ieee80211_tx_set_protected(struct ieee80211_tx_data
*tx
)
99 struct sk_buff
*skb
= tx
->skb
;
100 struct ieee80211_hdr
*hdr
;
103 hdr
= (struct ieee80211_hdr
*) skb
->data
;
104 hdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
105 } while ((skb
= skb
->next
));
108 int ieee80211_frame_duration(struct ieee80211_local
*local
, size_t len
,
109 int rate
, int erp
, int short_preamble
)
113 /* calculate duration (in microseconds, rounded up to next higher
114 * integer if it includes a fractional microsecond) to send frame of
115 * len bytes (does not include FCS) at the given rate. Duration will
118 * rate is in 100 kbps, so divident is multiplied by 10 in the
119 * DIV_ROUND_UP() operations.
122 if (local
->hw
.conf
.channel
->band
== IEEE80211_BAND_5GHZ
|| erp
) {
126 * N_DBPS = DATARATE x 4
127 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
128 * (16 = SIGNAL time, 6 = tail bits)
129 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
132 * 802.11a - 17.5.2: aSIFSTime = 16 usec
133 * 802.11g - 19.8.4: aSIFSTime = 10 usec +
134 * signal ext = 6 usec
136 dur
= 16; /* SIFS + signal ext */
137 dur
+= 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */
138 dur
+= 4; /* 17.3.2.3: T_SIGNAL = 4 usec */
139 dur
+= 4 * DIV_ROUND_UP((16 + 8 * (len
+ 4) + 6) * 10,
140 4 * rate
); /* T_SYM x N_SYM */
143 * 802.11b or 802.11g with 802.11b compatibility:
144 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
145 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
147 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
148 * aSIFSTime = 10 usec
149 * aPreambleLength = 144 usec or 72 usec with short preamble
150 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
152 dur
= 10; /* aSIFSTime = 10 usec */
153 dur
+= short_preamble
? (72 + 24) : (144 + 48);
155 dur
+= DIV_ROUND_UP(8 * (len
+ 4) * 10, rate
);
161 /* Exported duration function for driver use */
162 __le16
ieee80211_generic_frame_duration(struct ieee80211_hw
*hw
,
163 struct ieee80211_vif
*vif
,
165 struct ieee80211_rate
*rate
)
167 struct ieee80211_local
*local
= hw_to_local(hw
);
168 struct ieee80211_sub_if_data
*sdata
;
171 bool short_preamble
= false;
175 sdata
= vif_to_sdata(vif
);
176 short_preamble
= sdata
->vif
.bss_conf
.use_short_preamble
;
177 if (sdata
->flags
& IEEE80211_SDATA_OPERATING_GMODE
)
178 erp
= rate
->flags
& IEEE80211_RATE_ERP_G
;
181 dur
= ieee80211_frame_duration(local
, frame_len
, rate
->bitrate
, erp
,
184 return cpu_to_le16(dur
);
186 EXPORT_SYMBOL(ieee80211_generic_frame_duration
);
188 __le16
ieee80211_rts_duration(struct ieee80211_hw
*hw
,
189 struct ieee80211_vif
*vif
, size_t frame_len
,
190 const struct ieee80211_tx_info
*frame_txctl
)
192 struct ieee80211_local
*local
= hw_to_local(hw
);
193 struct ieee80211_rate
*rate
;
194 struct ieee80211_sub_if_data
*sdata
;
198 struct ieee80211_supported_band
*sband
;
200 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
202 short_preamble
= false;
204 rate
= &sband
->bitrates
[frame_txctl
->control
.rts_cts_rate_idx
];
208 sdata
= vif_to_sdata(vif
);
209 short_preamble
= sdata
->vif
.bss_conf
.use_short_preamble
;
210 if (sdata
->flags
& IEEE80211_SDATA_OPERATING_GMODE
)
211 erp
= rate
->flags
& IEEE80211_RATE_ERP_G
;
215 dur
= ieee80211_frame_duration(local
, 10, rate
->bitrate
,
216 erp
, short_preamble
);
217 /* Data frame duration */
218 dur
+= ieee80211_frame_duration(local
, frame_len
, rate
->bitrate
,
219 erp
, short_preamble
);
221 dur
+= ieee80211_frame_duration(local
, 10, rate
->bitrate
,
222 erp
, short_preamble
);
224 return cpu_to_le16(dur
);
226 EXPORT_SYMBOL(ieee80211_rts_duration
);
228 __le16
ieee80211_ctstoself_duration(struct ieee80211_hw
*hw
,
229 struct ieee80211_vif
*vif
,
231 const struct ieee80211_tx_info
*frame_txctl
)
233 struct ieee80211_local
*local
= hw_to_local(hw
);
234 struct ieee80211_rate
*rate
;
235 struct ieee80211_sub_if_data
*sdata
;
239 struct ieee80211_supported_band
*sband
;
241 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
243 short_preamble
= false;
245 rate
= &sband
->bitrates
[frame_txctl
->control
.rts_cts_rate_idx
];
248 sdata
= vif_to_sdata(vif
);
249 short_preamble
= sdata
->vif
.bss_conf
.use_short_preamble
;
250 if (sdata
->flags
& IEEE80211_SDATA_OPERATING_GMODE
)
251 erp
= rate
->flags
& IEEE80211_RATE_ERP_G
;
254 /* Data frame duration */
255 dur
= ieee80211_frame_duration(local
, frame_len
, rate
->bitrate
,
256 erp
, short_preamble
);
257 if (!(frame_txctl
->flags
& IEEE80211_TX_CTL_NO_ACK
)) {
259 dur
+= ieee80211_frame_duration(local
, 10, rate
->bitrate
,
260 erp
, short_preamble
);
263 return cpu_to_le16(dur
);
265 EXPORT_SYMBOL(ieee80211_ctstoself_duration
);
267 static void __ieee80211_wake_queue(struct ieee80211_hw
*hw
, int queue
,
268 enum queue_stop_reason reason
)
270 struct ieee80211_local
*local
= hw_to_local(hw
);
271 struct ieee80211_sub_if_data
*sdata
;
273 trace_wake_queue(local
, queue
, reason
);
275 if (WARN_ON(queue
>= hw
->queues
))
278 __clear_bit(reason
, &local
->queue_stop_reasons
[queue
]);
280 if (local
->queue_stop_reasons
[queue
] != 0)
281 /* someone still has this queue stopped */
284 if (skb_queue_empty(&local
->pending
[queue
])) {
286 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
287 if (test_bit(SDATA_STATE_OFFCHANNEL
, &sdata
->state
))
289 netif_wake_subqueue(sdata
->dev
, queue
);
293 tasklet_schedule(&local
->tx_pending_tasklet
);
296 void ieee80211_wake_queue_by_reason(struct ieee80211_hw
*hw
, int queue
,
297 enum queue_stop_reason reason
)
299 struct ieee80211_local
*local
= hw_to_local(hw
);
302 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
303 __ieee80211_wake_queue(hw
, queue
, reason
);
304 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
307 void ieee80211_wake_queue(struct ieee80211_hw
*hw
, int queue
)
309 ieee80211_wake_queue_by_reason(hw
, queue
,
310 IEEE80211_QUEUE_STOP_REASON_DRIVER
);
312 EXPORT_SYMBOL(ieee80211_wake_queue
);
314 static void __ieee80211_stop_queue(struct ieee80211_hw
*hw
, int queue
,
315 enum queue_stop_reason reason
)
317 struct ieee80211_local
*local
= hw_to_local(hw
);
318 struct ieee80211_sub_if_data
*sdata
;
320 trace_stop_queue(local
, queue
, reason
);
322 if (WARN_ON(queue
>= hw
->queues
))
325 __set_bit(reason
, &local
->queue_stop_reasons
[queue
]);
328 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
)
329 netif_stop_subqueue(sdata
->dev
, queue
);
333 void ieee80211_stop_queue_by_reason(struct ieee80211_hw
*hw
, int queue
,
334 enum queue_stop_reason reason
)
336 struct ieee80211_local
*local
= hw_to_local(hw
);
339 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
340 __ieee80211_stop_queue(hw
, queue
, reason
);
341 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
344 void ieee80211_stop_queue(struct ieee80211_hw
*hw
, int queue
)
346 ieee80211_stop_queue_by_reason(hw
, queue
,
347 IEEE80211_QUEUE_STOP_REASON_DRIVER
);
349 EXPORT_SYMBOL(ieee80211_stop_queue
);
351 void ieee80211_add_pending_skb(struct ieee80211_local
*local
,
354 struct ieee80211_hw
*hw
= &local
->hw
;
356 int queue
= skb_get_queue_mapping(skb
);
357 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
359 if (WARN_ON(!info
->control
.vif
)) {
364 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
365 __ieee80211_stop_queue(hw
, queue
, IEEE80211_QUEUE_STOP_REASON_SKB_ADD
);
366 __skb_queue_tail(&local
->pending
[queue
], skb
);
367 __ieee80211_wake_queue(hw
, queue
, IEEE80211_QUEUE_STOP_REASON_SKB_ADD
);
368 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
371 int ieee80211_add_pending_skbs_fn(struct ieee80211_local
*local
,
372 struct sk_buff_head
*skbs
,
373 void (*fn
)(void *data
), void *data
)
375 struct ieee80211_hw
*hw
= &local
->hw
;
378 int queue
, ret
= 0, i
;
380 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
381 for (i
= 0; i
< hw
->queues
; i
++)
382 __ieee80211_stop_queue(hw
, i
,
383 IEEE80211_QUEUE_STOP_REASON_SKB_ADD
);
385 while ((skb
= skb_dequeue(skbs
))) {
386 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
388 if (WARN_ON(!info
->control
.vif
)) {
394 queue
= skb_get_queue_mapping(skb
);
395 __skb_queue_tail(&local
->pending
[queue
], skb
);
401 for (i
= 0; i
< hw
->queues
; i
++)
402 __ieee80211_wake_queue(hw
, i
,
403 IEEE80211_QUEUE_STOP_REASON_SKB_ADD
);
404 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
409 int ieee80211_add_pending_skbs(struct ieee80211_local
*local
,
410 struct sk_buff_head
*skbs
)
412 return ieee80211_add_pending_skbs_fn(local
, skbs
, NULL
, NULL
);
415 void ieee80211_stop_queues_by_reason(struct ieee80211_hw
*hw
,
416 enum queue_stop_reason reason
)
418 struct ieee80211_local
*local
= hw_to_local(hw
);
422 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
424 for (i
= 0; i
< hw
->queues
; i
++)
425 __ieee80211_stop_queue(hw
, i
, reason
);
427 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
430 void ieee80211_stop_queues(struct ieee80211_hw
*hw
)
432 ieee80211_stop_queues_by_reason(hw
,
433 IEEE80211_QUEUE_STOP_REASON_DRIVER
);
435 EXPORT_SYMBOL(ieee80211_stop_queues
);
437 int ieee80211_queue_stopped(struct ieee80211_hw
*hw
, int queue
)
439 struct ieee80211_local
*local
= hw_to_local(hw
);
443 if (WARN_ON(queue
>= hw
->queues
))
446 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
447 ret
= !!local
->queue_stop_reasons
[queue
];
448 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
451 EXPORT_SYMBOL(ieee80211_queue_stopped
);
453 void ieee80211_wake_queues_by_reason(struct ieee80211_hw
*hw
,
454 enum queue_stop_reason reason
)
456 struct ieee80211_local
*local
= hw_to_local(hw
);
460 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
462 for (i
= 0; i
< hw
->queues
; i
++)
463 __ieee80211_wake_queue(hw
, i
, reason
);
465 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
468 void ieee80211_wake_queues(struct ieee80211_hw
*hw
)
470 ieee80211_wake_queues_by_reason(hw
, IEEE80211_QUEUE_STOP_REASON_DRIVER
);
472 EXPORT_SYMBOL(ieee80211_wake_queues
);
474 void ieee80211_iterate_active_interfaces(
475 struct ieee80211_hw
*hw
,
476 void (*iterator
)(void *data
, u8
*mac
,
477 struct ieee80211_vif
*vif
),
480 struct ieee80211_local
*local
= hw_to_local(hw
);
481 struct ieee80211_sub_if_data
*sdata
;
483 mutex_lock(&local
->iflist_mtx
);
485 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
486 switch (sdata
->vif
.type
) {
487 case NL80211_IFTYPE_MONITOR
:
488 case NL80211_IFTYPE_AP_VLAN
:
493 if (ieee80211_sdata_running(sdata
))
494 iterator(data
, sdata
->vif
.addr
,
498 mutex_unlock(&local
->iflist_mtx
);
500 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces
);
502 void ieee80211_iterate_active_interfaces_atomic(
503 struct ieee80211_hw
*hw
,
504 void (*iterator
)(void *data
, u8
*mac
,
505 struct ieee80211_vif
*vif
),
508 struct ieee80211_local
*local
= hw_to_local(hw
);
509 struct ieee80211_sub_if_data
*sdata
;
513 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
514 switch (sdata
->vif
.type
) {
515 case NL80211_IFTYPE_MONITOR
:
516 case NL80211_IFTYPE_AP_VLAN
:
521 if (ieee80211_sdata_running(sdata
))
522 iterator(data
, sdata
->vif
.addr
,
528 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic
);
531 * Nothing should have been stuffed into the workqueue during
532 * the suspend->resume cycle. If this WARN is seen then there
533 * is a bug with either the driver suspend or something in
534 * mac80211 stuffing into the workqueue which we haven't yet
535 * cleared during mac80211's suspend cycle.
537 static bool ieee80211_can_queue_work(struct ieee80211_local
*local
)
539 if (WARN(local
->suspended
&& !local
->resuming
,
540 "queueing ieee80211 work while going to suspend\n"))
546 void ieee80211_queue_work(struct ieee80211_hw
*hw
, struct work_struct
*work
)
548 struct ieee80211_local
*local
= hw_to_local(hw
);
550 if (!ieee80211_can_queue_work(local
))
553 queue_work(local
->workqueue
, work
);
555 EXPORT_SYMBOL(ieee80211_queue_work
);
557 void ieee80211_queue_delayed_work(struct ieee80211_hw
*hw
,
558 struct delayed_work
*dwork
,
561 struct ieee80211_local
*local
= hw_to_local(hw
);
563 if (!ieee80211_can_queue_work(local
))
566 queue_delayed_work(local
->workqueue
, dwork
, delay
);
568 EXPORT_SYMBOL(ieee80211_queue_delayed_work
);
570 void ieee802_11_parse_elems(u8
*start
, size_t len
,
571 struct ieee802_11_elems
*elems
)
573 ieee802_11_parse_elems_crc(start
, len
, elems
, 0, 0);
576 u32
ieee802_11_parse_elems_crc(u8
*start
, size_t len
,
577 struct ieee802_11_elems
*elems
,
582 bool calc_crc
= filter
!= 0;
584 memset(elems
, 0, sizeof(*elems
));
585 elems
->ie_start
= start
;
586 elems
->total_len
= len
;
598 if (calc_crc
&& id
< 64 && (filter
& (1ULL << id
)))
599 crc
= crc32_be(crc
, pos
- 2, elen
+ 2);
604 elems
->ssid_len
= elen
;
606 case WLAN_EID_SUPP_RATES
:
607 elems
->supp_rates
= pos
;
608 elems
->supp_rates_len
= elen
;
610 case WLAN_EID_FH_PARAMS
:
611 elems
->fh_params
= pos
;
612 elems
->fh_params_len
= elen
;
614 case WLAN_EID_DS_PARAMS
:
615 elems
->ds_params
= pos
;
616 elems
->ds_params_len
= elen
;
618 case WLAN_EID_CF_PARAMS
:
619 elems
->cf_params
= pos
;
620 elems
->cf_params_len
= elen
;
623 if (elen
>= sizeof(struct ieee80211_tim_ie
)) {
624 elems
->tim
= (void *)pos
;
625 elems
->tim_len
= elen
;
628 case WLAN_EID_IBSS_PARAMS
:
629 elems
->ibss_params
= pos
;
630 elems
->ibss_params_len
= elen
;
632 case WLAN_EID_CHALLENGE
:
633 elems
->challenge
= pos
;
634 elems
->challenge_len
= elen
;
636 case WLAN_EID_VENDOR_SPECIFIC
:
637 if (elen
>= 4 && pos
[0] == 0x00 && pos
[1] == 0x50 &&
639 /* Microsoft OUI (00:50:F2) */
642 crc
= crc32_be(crc
, pos
- 2, elen
+ 2);
645 /* OUI Type 1 - WPA IE */
647 elems
->wpa_len
= elen
;
648 } else if (elen
>= 5 && pos
[3] == 2) {
649 /* OUI Type 2 - WMM IE */
651 elems
->wmm_info
= pos
;
652 elems
->wmm_info_len
= elen
;
653 } else if (pos
[4] == 1) {
654 elems
->wmm_param
= pos
;
655 elems
->wmm_param_len
= elen
;
662 elems
->rsn_len
= elen
;
664 case WLAN_EID_ERP_INFO
:
665 elems
->erp_info
= pos
;
666 elems
->erp_info_len
= elen
;
668 case WLAN_EID_EXT_SUPP_RATES
:
669 elems
->ext_supp_rates
= pos
;
670 elems
->ext_supp_rates_len
= elen
;
672 case WLAN_EID_HT_CAPABILITY
:
673 if (elen
>= sizeof(struct ieee80211_ht_cap
))
674 elems
->ht_cap_elem
= (void *)pos
;
676 case WLAN_EID_HT_INFORMATION
:
677 if (elen
>= sizeof(struct ieee80211_ht_info
))
678 elems
->ht_info_elem
= (void *)pos
;
680 case WLAN_EID_MESH_ID
:
681 elems
->mesh_id
= pos
;
682 elems
->mesh_id_len
= elen
;
684 case WLAN_EID_MESH_CONFIG
:
685 if (elen
>= sizeof(struct ieee80211_meshconf_ie
))
686 elems
->mesh_config
= (void *)pos
;
688 case WLAN_EID_PEER_LINK
:
689 elems
->peer_link
= pos
;
690 elems
->peer_link_len
= elen
;
694 elems
->preq_len
= elen
;
698 elems
->prep_len
= elen
;
702 elems
->perr_len
= elen
;
705 if (elen
>= sizeof(struct ieee80211_rann_ie
))
706 elems
->rann
= (void *)pos
;
708 case WLAN_EID_CHANNEL_SWITCH
:
709 elems
->ch_switch_elem
= pos
;
710 elems
->ch_switch_elem_len
= elen
;
713 if (!elems
->quiet_elem
) {
714 elems
->quiet_elem
= pos
;
715 elems
->quiet_elem_len
= elen
;
717 elems
->num_of_quiet_elem
++;
719 case WLAN_EID_COUNTRY
:
720 elems
->country_elem
= pos
;
721 elems
->country_elem_len
= elen
;
723 case WLAN_EID_PWR_CONSTRAINT
:
724 elems
->pwr_constr_elem
= pos
;
725 elems
->pwr_constr_elem_len
= elen
;
727 case WLAN_EID_TIMEOUT_INTERVAL
:
728 elems
->timeout_int
= pos
;
729 elems
->timeout_int_len
= elen
;
742 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data
*sdata
)
744 struct ieee80211_local
*local
= sdata
->local
;
745 struct ieee80211_tx_queue_params qparam
;
750 if (!local
->ops
->conf_tx
)
753 memset(&qparam
, 0, sizeof(qparam
));
755 use_11b
= (local
->hw
.conf
.channel
->band
== IEEE80211_BAND_2GHZ
) &&
756 !(sdata
->flags
& IEEE80211_SDATA_OPERATING_GMODE
);
758 for (queue
= 0; queue
< local_to_hw(local
)->queues
; queue
++) {
759 /* Set defaults according to 802.11-2007 Table 7-37 */
768 qparam
.cw_max
= aCWmax
;
769 qparam
.cw_min
= aCWmin
;
773 default: /* never happens but let's not leave undefined */
775 qparam
.cw_max
= aCWmax
;
776 qparam
.cw_min
= aCWmin
;
781 qparam
.cw_max
= aCWmin
;
782 qparam
.cw_min
= (aCWmin
+ 1) / 2 - 1;
784 qparam
.txop
= 6016/32;
786 qparam
.txop
= 3008/32;
790 qparam
.cw_max
= (aCWmin
+ 1) / 2 - 1;
791 qparam
.cw_min
= (aCWmin
+ 1) / 4 - 1;
793 qparam
.txop
= 3264/32;
795 qparam
.txop
= 1504/32;
800 qparam
.uapsd
= false;
802 drv_conf_tx(local
, queue
, &qparam
);
805 /* after reinitialize QoS TX queues setting to default,
806 * disable QoS at all */
808 if (sdata
->vif
.type
!= NL80211_IFTYPE_MONITOR
) {
809 sdata
->vif
.bss_conf
.qos
=
810 sdata
->vif
.type
!= NL80211_IFTYPE_STATION
;
811 ieee80211_bss_info_change_notify(sdata
, BSS_CHANGED_QOS
);
815 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data
*sdata
,
816 const size_t supp_rates_len
,
817 const u8
*supp_rates
)
819 struct ieee80211_local
*local
= sdata
->local
;
820 int i
, have_higher_than_11mbit
= 0;
822 /* cf. IEEE 802.11 9.2.12 */
823 for (i
= 0; i
< supp_rates_len
; i
++)
824 if ((supp_rates
[i
] & 0x7f) * 5 > 110)
825 have_higher_than_11mbit
= 1;
827 if (local
->hw
.conf
.channel
->band
== IEEE80211_BAND_2GHZ
&&
828 have_higher_than_11mbit
)
829 sdata
->flags
|= IEEE80211_SDATA_OPERATING_GMODE
;
831 sdata
->flags
&= ~IEEE80211_SDATA_OPERATING_GMODE
;
833 ieee80211_set_wmm_default(sdata
);
836 u32
ieee80211_mandatory_rates(struct ieee80211_local
*local
,
837 enum ieee80211_band band
)
839 struct ieee80211_supported_band
*sband
;
840 struct ieee80211_rate
*bitrates
;
842 enum ieee80211_rate_flags mandatory_flag
;
845 sband
= local
->hw
.wiphy
->bands
[band
];
848 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
851 if (band
== IEEE80211_BAND_2GHZ
)
852 mandatory_flag
= IEEE80211_RATE_MANDATORY_B
;
854 mandatory_flag
= IEEE80211_RATE_MANDATORY_A
;
856 bitrates
= sband
->bitrates
;
858 for (i
= 0; i
< sband
->n_bitrates
; i
++)
859 if (bitrates
[i
].flags
& mandatory_flag
)
860 mandatory_rates
|= BIT(i
);
861 return mandatory_rates
;
864 void ieee80211_send_auth(struct ieee80211_sub_if_data
*sdata
,
865 u16 transaction
, u16 auth_alg
,
866 u8
*extra
, size_t extra_len
, const u8
*bssid
,
867 const u8
*key
, u8 key_len
, u8 key_idx
)
869 struct ieee80211_local
*local
= sdata
->local
;
871 struct ieee80211_mgmt
*mgmt
;
874 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+
875 sizeof(*mgmt
) + 6 + extra_len
);
877 printk(KERN_DEBUG
"%s: failed to allocate buffer for auth "
878 "frame\n", sdata
->name
);
881 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
883 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24 + 6);
884 memset(mgmt
, 0, 24 + 6);
885 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
886 IEEE80211_STYPE_AUTH
);
887 memcpy(mgmt
->da
, bssid
, ETH_ALEN
);
888 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
889 memcpy(mgmt
->bssid
, bssid
, ETH_ALEN
);
890 mgmt
->u
.auth
.auth_alg
= cpu_to_le16(auth_alg
);
891 mgmt
->u
.auth
.auth_transaction
= cpu_to_le16(transaction
);
892 mgmt
->u
.auth
.status_code
= cpu_to_le16(0);
894 memcpy(skb_put(skb
, extra_len
), extra
, extra_len
);
896 if (auth_alg
== WLAN_AUTH_SHARED_KEY
&& transaction
== 3) {
897 mgmt
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
898 err
= ieee80211_wep_encrypt(local
, skb
, key
, key_len
, key_idx
);
902 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_INTFL_DONT_ENCRYPT
;
903 ieee80211_tx_skb(sdata
, skb
);
906 int ieee80211_build_preq_ies(struct ieee80211_local
*local
, u8
*buffer
,
907 const u8
*ie
, size_t ie_len
,
908 enum ieee80211_band band
, u32 rate_mask
,
911 struct ieee80211_supported_band
*sband
;
913 size_t offset
= 0, noffset
;
914 int supp_rates_len
, i
;
919 sband
= local
->hw
.wiphy
->bands
[band
];
924 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
925 if ((BIT(i
) & rate_mask
) == 0)
926 continue; /* skip rate */
927 rates
[num_rates
++] = (u8
) (sband
->bitrates
[i
].bitrate
/ 5);
930 supp_rates_len
= min_t(int, num_rates
, 8);
932 *pos
++ = WLAN_EID_SUPP_RATES
;
933 *pos
++ = supp_rates_len
;
934 memcpy(pos
, rates
, supp_rates_len
);
935 pos
+= supp_rates_len
;
937 /* insert "request information" if in custom IEs */
939 static const u8 before_extrates
[] = {
944 noffset
= ieee80211_ie_split(ie
, ie_len
,
946 ARRAY_SIZE(before_extrates
),
948 memcpy(pos
, ie
+ offset
, noffset
- offset
);
949 pos
+= noffset
- offset
;
953 ext_rates_len
= num_rates
- supp_rates_len
;
954 if (ext_rates_len
> 0) {
955 *pos
++ = WLAN_EID_EXT_SUPP_RATES
;
956 *pos
++ = ext_rates_len
;
957 memcpy(pos
, rates
+ supp_rates_len
, ext_rates_len
);
958 pos
+= ext_rates_len
;
961 if (channel
&& sband
->band
== IEEE80211_BAND_2GHZ
) {
962 *pos
++ = WLAN_EID_DS_PARAMS
;
967 /* insert custom IEs that go before HT */
969 static const u8 before_ht
[] = {
973 WLAN_EID_EXT_SUPP_RATES
,
975 WLAN_EID_SUPPORTED_REGULATORY_CLASSES
,
977 noffset
= ieee80211_ie_split(ie
, ie_len
,
978 before_ht
, ARRAY_SIZE(before_ht
),
980 memcpy(pos
, ie
+ offset
, noffset
- offset
);
981 pos
+= noffset
- offset
;
985 if (sband
->ht_cap
.ht_supported
) {
986 u16 cap
= sband
->ht_cap
.cap
;
989 *pos
++ = WLAN_EID_HT_CAPABILITY
;
990 *pos
++ = sizeof(struct ieee80211_ht_cap
);
991 memset(pos
, 0, sizeof(struct ieee80211_ht_cap
));
992 tmp
= cpu_to_le16(cap
);
993 memcpy(pos
, &tmp
, sizeof(u16
));
995 *pos
++ = sband
->ht_cap
.ampdu_factor
|
996 (sband
->ht_cap
.ampdu_density
<<
997 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT
);
998 memcpy(pos
, &sband
->ht_cap
.mcs
, sizeof(sband
->ht_cap
.mcs
));
999 pos
+= sizeof(sband
->ht_cap
.mcs
);
1000 pos
+= 2 + 4 + 1; /* ext info, BF cap, antsel */
1004 * If adding more here, adjust code in main.c
1005 * that calculates local->scan_ies_len.
1008 /* add any remaining custom IEs */
1011 memcpy(pos
, ie
+ offset
, noffset
- offset
);
1012 pos
+= noffset
- offset
;
1015 return pos
- buffer
;
1018 struct sk_buff
*ieee80211_build_probe_req(struct ieee80211_sub_if_data
*sdata
,
1020 const u8
*ssid
, size_t ssid_len
,
1021 const u8
*ie
, size_t ie_len
,
1024 struct ieee80211_local
*local
= sdata
->local
;
1025 struct sk_buff
*skb
;
1026 struct ieee80211_mgmt
*mgmt
;
1031 /* FIXME: come up with a proper value */
1032 buf
= kmalloc(200 + ie_len
, GFP_KERNEL
);
1034 printk(KERN_DEBUG
"%s: failed to allocate temporary IE "
1035 "buffer\n", sdata
->name
);
1040 * Do not send DS Channel parameter for directed probe requests
1041 * in order to maximize the chance that we get a response. Some
1042 * badly-behaved APs don't respond when this parameter is included.
1047 chan
= ieee80211_frequency_to_channel(
1048 local
->hw
.conf
.channel
->center_freq
);
1050 buf_len
= ieee80211_build_preq_ies(local
, buf
, ie
, ie_len
,
1051 local
->hw
.conf
.channel
->band
,
1052 sdata
->rc_rateidx_mask
1053 [local
->hw
.conf
.channel
->band
],
1056 skb
= ieee80211_probereq_get(&local
->hw
, &sdata
->vif
,
1061 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
1062 memcpy(mgmt
->da
, dst
, ETH_ALEN
);
1063 memcpy(mgmt
->bssid
, dst
, ETH_ALEN
);
1066 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_INTFL_DONT_ENCRYPT
;
1072 void ieee80211_send_probe_req(struct ieee80211_sub_if_data
*sdata
, u8
*dst
,
1073 const u8
*ssid
, size_t ssid_len
,
1074 const u8
*ie
, size_t ie_len
,
1077 struct sk_buff
*skb
;
1079 skb
= ieee80211_build_probe_req(sdata
, dst
, ssid
, ssid_len
, ie
, ie_len
,
1082 ieee80211_tx_skb(sdata
, skb
);
1085 u32
ieee80211_sta_get_rates(struct ieee80211_local
*local
,
1086 struct ieee802_11_elems
*elems
,
1087 enum ieee80211_band band
)
1089 struct ieee80211_supported_band
*sband
;
1090 struct ieee80211_rate
*bitrates
;
1094 sband
= local
->hw
.wiphy
->bands
[band
];
1098 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
1101 bitrates
= sband
->bitrates
;
1102 num_rates
= sband
->n_bitrates
;
1104 for (i
= 0; i
< elems
->supp_rates_len
+
1105 elems
->ext_supp_rates_len
; i
++) {
1108 if (i
< elems
->supp_rates_len
)
1109 rate
= elems
->supp_rates
[i
];
1110 else if (elems
->ext_supp_rates
)
1111 rate
= elems
->ext_supp_rates
1112 [i
- elems
->supp_rates_len
];
1113 own_rate
= 5 * (rate
& 0x7f);
1114 for (j
= 0; j
< num_rates
; j
++)
1115 if (bitrates
[j
].bitrate
== own_rate
)
1116 supp_rates
|= BIT(j
);
1121 void ieee80211_stop_device(struct ieee80211_local
*local
)
1123 ieee80211_led_radio(local
, false);
1124 ieee80211_mod_tpt_led_trig(local
, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO
);
1126 cancel_work_sync(&local
->reconfig_filter
);
1128 flush_workqueue(local
->workqueue
);
1132 int ieee80211_reconfig(struct ieee80211_local
*local
)
1134 struct ieee80211_hw
*hw
= &local
->hw
;
1135 struct ieee80211_sub_if_data
*sdata
;
1136 struct sta_info
*sta
;
1140 if (local
->suspended
)
1141 local
->resuming
= true;
1143 if (local
->wowlan
) {
1144 local
->wowlan
= false;
1145 res
= drv_resume(local
);
1147 local
->resuming
= false;
1154 * res is 1, which means the driver requested
1155 * to go through a regular reset on wakeup.
1160 /* restart hardware */
1161 if (local
->open_count
) {
1163 * Upon resume hardware can sometimes be goofy due to
1164 * various platform / driver / bus issues, so restarting
1165 * the device may at times not work immediately. Propagate
1168 res
= drv_start(local
);
1170 WARN(local
->suspended
, "Hardware became unavailable "
1171 "upon resume. This could be a software issue "
1172 "prior to suspend or a hardware issue.\n");
1176 ieee80211_led_radio(local
, true);
1177 ieee80211_mod_tpt_led_trig(local
,
1178 IEEE80211_TPT_LEDTRIG_FL_RADIO
, 0);
1181 /* add interfaces */
1182 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
1183 if (sdata
->vif
.type
!= NL80211_IFTYPE_AP_VLAN
&&
1184 sdata
->vif
.type
!= NL80211_IFTYPE_MONITOR
&&
1185 ieee80211_sdata_running(sdata
))
1186 res
= drv_add_interface(local
, &sdata
->vif
);
1190 mutex_lock(&local
->sta_mtx
);
1191 list_for_each_entry(sta
, &local
->sta_list
, list
) {
1192 if (sta
->uploaded
) {
1194 if (sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
)
1195 sdata
= container_of(sdata
->bss
,
1196 struct ieee80211_sub_if_data
,
1199 WARN_ON(drv_sta_add(local
, sdata
, &sta
->sta
));
1202 mutex_unlock(&local
->sta_mtx
);
1204 /* setup fragmentation threshold */
1205 drv_set_frag_threshold(local
, hw
->wiphy
->frag_threshold
);
1207 /* setup RTS threshold */
1208 drv_set_rts_threshold(local
, hw
->wiphy
->rts_threshold
);
1210 /* reconfigure hardware */
1211 ieee80211_hw_config(local
, ~0);
1213 ieee80211_configure_filter(local
);
1215 /* Finally also reconfigure all the BSS information */
1216 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
1219 if (!ieee80211_sdata_running(sdata
))
1222 /* common change flags for all interface types */
1223 changed
= BSS_CHANGED_ERP_CTS_PROT
|
1224 BSS_CHANGED_ERP_PREAMBLE
|
1225 BSS_CHANGED_ERP_SLOT
|
1227 BSS_CHANGED_BASIC_RATES
|
1228 BSS_CHANGED_BEACON_INT
|
1233 switch (sdata
->vif
.type
) {
1234 case NL80211_IFTYPE_STATION
:
1235 changed
|= BSS_CHANGED_ASSOC
;
1236 mutex_lock(&sdata
->u
.mgd
.mtx
);
1237 ieee80211_bss_info_change_notify(sdata
, changed
);
1238 mutex_unlock(&sdata
->u
.mgd
.mtx
);
1240 case NL80211_IFTYPE_ADHOC
:
1241 changed
|= BSS_CHANGED_IBSS
;
1243 case NL80211_IFTYPE_AP
:
1244 case NL80211_IFTYPE_MESH_POINT
:
1245 changed
|= BSS_CHANGED_BEACON
|
1246 BSS_CHANGED_BEACON_ENABLED
;
1247 ieee80211_bss_info_change_notify(sdata
, changed
);
1249 case NL80211_IFTYPE_WDS
:
1251 case NL80211_IFTYPE_AP_VLAN
:
1252 case NL80211_IFTYPE_MONITOR
:
1253 /* ignore virtual */
1255 case NL80211_IFTYPE_UNSPECIFIED
:
1256 case NUM_NL80211_IFTYPES
:
1257 case NL80211_IFTYPE_P2P_CLIENT
:
1258 case NL80211_IFTYPE_P2P_GO
:
1265 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
1266 * sessions can be established after a resume.
1268 * Also tear down aggregation sessions since reconfiguring
1269 * them in a hardware restart scenario is not easily done
1270 * right now, and the hardware will have lost information
1271 * about the sessions, but we and the AP still think they
1272 * are active. This is really a workaround though.
1274 if (hw
->flags
& IEEE80211_HW_AMPDU_AGGREGATION
) {
1275 mutex_lock(&local
->sta_mtx
);
1277 list_for_each_entry(sta
, &local
->sta_list
, list
) {
1278 ieee80211_sta_tear_down_BA_sessions(sta
, true);
1279 clear_sta_flags(sta
, WLAN_STA_BLOCK_BA
);
1282 mutex_unlock(&local
->sta_mtx
);
1286 list_for_each_entry(sdata
, &local
->interfaces
, list
)
1287 if (ieee80211_sdata_running(sdata
))
1288 ieee80211_enable_keys(sdata
);
1293 ieee80211_wake_queues_by_reason(hw
,
1294 IEEE80211_QUEUE_STOP_REASON_SUSPEND
);
1297 * If this is for hw restart things are still running.
1298 * We may want to change that later, however.
1300 if (!local
->suspended
)
1304 /* first set suspended false, then resuming */
1305 local
->suspended
= false;
1307 local
->resuming
= false;
1309 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
1310 switch(sdata
->vif
.type
) {
1311 case NL80211_IFTYPE_STATION
:
1312 ieee80211_sta_restart(sdata
);
1314 case NL80211_IFTYPE_ADHOC
:
1315 ieee80211_ibss_restart(sdata
);
1317 case NL80211_IFTYPE_MESH_POINT
:
1318 ieee80211_mesh_restart(sdata
);
1325 mod_timer(&local
->sta_cleanup
, jiffies
+ 1);
1327 mutex_lock(&local
->sta_mtx
);
1328 list_for_each_entry(sta
, &local
->sta_list
, list
)
1329 mesh_plink_restart(sta
);
1330 mutex_unlock(&local
->sta_mtx
);
1337 static int check_mgd_smps(struct ieee80211_if_managed
*ifmgd
,
1338 enum ieee80211_smps_mode
*smps_mode
)
1340 if (ifmgd
->associated
) {
1341 *smps_mode
= ifmgd
->ap_smps
;
1343 if (*smps_mode
== IEEE80211_SMPS_AUTOMATIC
) {
1344 if (ifmgd
->powersave
)
1345 *smps_mode
= IEEE80211_SMPS_DYNAMIC
;
1347 *smps_mode
= IEEE80211_SMPS_OFF
;
1356 /* must hold iflist_mtx */
1357 void ieee80211_recalc_smps(struct ieee80211_local
*local
)
1359 struct ieee80211_sub_if_data
*sdata
;
1360 enum ieee80211_smps_mode smps_mode
= IEEE80211_SMPS_OFF
;
1363 lockdep_assert_held(&local
->iflist_mtx
);
1366 * This function could be improved to handle multiple
1367 * interfaces better, but right now it makes any
1368 * non-station interfaces force SM PS to be turned
1369 * off. If there are multiple station interfaces it
1370 * could also use the best possible mode, e.g. if
1371 * one is in static and the other in dynamic then
1375 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
1376 if (!ieee80211_sdata_running(sdata
))
1378 if (sdata
->vif
.type
!= NL80211_IFTYPE_STATION
)
1381 count
+= check_mgd_smps(&sdata
->u
.mgd
, &smps_mode
);
1384 smps_mode
= IEEE80211_SMPS_OFF
;
1389 if (smps_mode
== local
->smps_mode
)
1393 local
->smps_mode
= smps_mode
;
1394 /* changed flag is auto-detected for this */
1395 ieee80211_hw_config(local
, 0);
1398 static bool ieee80211_id_in_list(const u8
*ids
, int n_ids
, u8 id
)
1402 for (i
= 0; i
< n_ids
; i
++)
1409 * ieee80211_ie_split - split an IE buffer according to ordering
1411 * @ies: the IE buffer
1412 * @ielen: the length of the IE buffer
1413 * @ids: an array with element IDs that are allowed before
1415 * @n_ids: the size of the element ID array
1416 * @offset: offset where to start splitting in the buffer
1418 * This function splits an IE buffer by updating the @offset
1419 * variable to point to the location where the buffer should be
1422 * It assumes that the given IE buffer is well-formed, this
1423 * has to be guaranteed by the caller!
1425 * It also assumes that the IEs in the buffer are ordered
1426 * correctly, if not the result of using this function will not
1427 * be ordered correctly either, i.e. it does no reordering.
1429 * The function returns the offset where the next part of the
1430 * buffer starts, which may be @ielen if the entire (remainder)
1431 * of the buffer should be used.
1433 size_t ieee80211_ie_split(const u8
*ies
, size_t ielen
,
1434 const u8
*ids
, int n_ids
, size_t offset
)
1436 size_t pos
= offset
;
1438 while (pos
< ielen
&& ieee80211_id_in_list(ids
, n_ids
, ies
[pos
]))
1439 pos
+= 2 + ies
[pos
+ 1];
1444 size_t ieee80211_ie_split_vendor(const u8
*ies
, size_t ielen
, size_t offset
)
1446 size_t pos
= offset
;
1448 while (pos
< ielen
&& ies
[pos
] != WLAN_EID_VENDOR_SPECIFIC
)
1449 pos
+= 2 + ies
[pos
+ 1];