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
)
100 struct ieee80211_hdr
*hdr
;
102 skb_queue_walk(&tx
->skbs
, skb
) {
103 hdr
= (struct ieee80211_hdr
*) skb
->data
;
104 hdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
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 void 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
;
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
)) {
393 queue
= skb_get_queue_mapping(skb
);
394 __skb_queue_tail(&local
->pending
[queue
], skb
);
400 for (i
= 0; i
< hw
->queues
; i
++)
401 __ieee80211_wake_queue(hw
, i
,
402 IEEE80211_QUEUE_STOP_REASON_SKB_ADD
);
403 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
406 void ieee80211_add_pending_skbs(struct ieee80211_local
*local
,
407 struct sk_buff_head
*skbs
)
409 ieee80211_add_pending_skbs_fn(local
, skbs
, NULL
, NULL
);
412 void ieee80211_stop_queues_by_reason(struct ieee80211_hw
*hw
,
413 enum queue_stop_reason reason
)
415 struct ieee80211_local
*local
= hw_to_local(hw
);
419 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
421 for (i
= 0; i
< hw
->queues
; i
++)
422 __ieee80211_stop_queue(hw
, i
, reason
);
424 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
427 void ieee80211_stop_queues(struct ieee80211_hw
*hw
)
429 ieee80211_stop_queues_by_reason(hw
,
430 IEEE80211_QUEUE_STOP_REASON_DRIVER
);
432 EXPORT_SYMBOL(ieee80211_stop_queues
);
434 int ieee80211_queue_stopped(struct ieee80211_hw
*hw
, int queue
)
436 struct ieee80211_local
*local
= hw_to_local(hw
);
440 if (WARN_ON(queue
>= hw
->queues
))
443 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
444 ret
= !!local
->queue_stop_reasons
[queue
];
445 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
448 EXPORT_SYMBOL(ieee80211_queue_stopped
);
450 void ieee80211_wake_queues_by_reason(struct ieee80211_hw
*hw
,
451 enum queue_stop_reason reason
)
453 struct ieee80211_local
*local
= hw_to_local(hw
);
457 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
459 for (i
= 0; i
< hw
->queues
; i
++)
460 __ieee80211_wake_queue(hw
, i
, reason
);
462 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
465 void ieee80211_wake_queues(struct ieee80211_hw
*hw
)
467 ieee80211_wake_queues_by_reason(hw
, IEEE80211_QUEUE_STOP_REASON_DRIVER
);
469 EXPORT_SYMBOL(ieee80211_wake_queues
);
471 void ieee80211_iterate_active_interfaces(
472 struct ieee80211_hw
*hw
,
473 void (*iterator
)(void *data
, u8
*mac
,
474 struct ieee80211_vif
*vif
),
477 struct ieee80211_local
*local
= hw_to_local(hw
);
478 struct ieee80211_sub_if_data
*sdata
;
480 mutex_lock(&local
->iflist_mtx
);
482 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
483 switch (sdata
->vif
.type
) {
484 case NL80211_IFTYPE_MONITOR
:
485 case NL80211_IFTYPE_AP_VLAN
:
490 if (ieee80211_sdata_running(sdata
))
491 iterator(data
, sdata
->vif
.addr
,
495 mutex_unlock(&local
->iflist_mtx
);
497 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces
);
499 void ieee80211_iterate_active_interfaces_atomic(
500 struct ieee80211_hw
*hw
,
501 void (*iterator
)(void *data
, u8
*mac
,
502 struct ieee80211_vif
*vif
),
505 struct ieee80211_local
*local
= hw_to_local(hw
);
506 struct ieee80211_sub_if_data
*sdata
;
510 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
511 switch (sdata
->vif
.type
) {
512 case NL80211_IFTYPE_MONITOR
:
513 case NL80211_IFTYPE_AP_VLAN
:
518 if (ieee80211_sdata_running(sdata
))
519 iterator(data
, sdata
->vif
.addr
,
525 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic
);
528 * Nothing should have been stuffed into the workqueue during
529 * the suspend->resume cycle. If this WARN is seen then there
530 * is a bug with either the driver suspend or something in
531 * mac80211 stuffing into the workqueue which we haven't yet
532 * cleared during mac80211's suspend cycle.
534 static bool ieee80211_can_queue_work(struct ieee80211_local
*local
)
536 if (WARN(local
->suspended
&& !local
->resuming
,
537 "queueing ieee80211 work while going to suspend\n"))
543 void ieee80211_queue_work(struct ieee80211_hw
*hw
, struct work_struct
*work
)
545 struct ieee80211_local
*local
= hw_to_local(hw
);
547 if (!ieee80211_can_queue_work(local
))
550 queue_work(local
->workqueue
, work
);
552 EXPORT_SYMBOL(ieee80211_queue_work
);
554 void ieee80211_queue_delayed_work(struct ieee80211_hw
*hw
,
555 struct delayed_work
*dwork
,
558 struct ieee80211_local
*local
= hw_to_local(hw
);
560 if (!ieee80211_can_queue_work(local
))
563 queue_delayed_work(local
->workqueue
, dwork
, delay
);
565 EXPORT_SYMBOL(ieee80211_queue_delayed_work
);
567 u32
ieee802_11_parse_elems_crc(u8
*start
, size_t len
,
568 struct ieee802_11_elems
*elems
,
573 bool calc_crc
= filter
!= 0;
575 memset(elems
, 0, sizeof(*elems
));
576 elems
->ie_start
= start
;
577 elems
->total_len
= len
;
589 if (calc_crc
&& id
< 64 && (filter
& (1ULL << id
)))
590 crc
= crc32_be(crc
, pos
- 2, elen
+ 2);
595 elems
->ssid_len
= elen
;
597 case WLAN_EID_SUPP_RATES
:
598 elems
->supp_rates
= pos
;
599 elems
->supp_rates_len
= elen
;
601 case WLAN_EID_FH_PARAMS
:
602 elems
->fh_params
= pos
;
603 elems
->fh_params_len
= elen
;
605 case WLAN_EID_DS_PARAMS
:
606 elems
->ds_params
= pos
;
607 elems
->ds_params_len
= elen
;
609 case WLAN_EID_CF_PARAMS
:
610 elems
->cf_params
= pos
;
611 elems
->cf_params_len
= elen
;
614 if (elen
>= sizeof(struct ieee80211_tim_ie
)) {
615 elems
->tim
= (void *)pos
;
616 elems
->tim_len
= elen
;
619 case WLAN_EID_IBSS_PARAMS
:
620 elems
->ibss_params
= pos
;
621 elems
->ibss_params_len
= elen
;
623 case WLAN_EID_CHALLENGE
:
624 elems
->challenge
= pos
;
625 elems
->challenge_len
= elen
;
627 case WLAN_EID_VENDOR_SPECIFIC
:
628 if (elen
>= 4 && pos
[0] == 0x00 && pos
[1] == 0x50 &&
630 /* Microsoft OUI (00:50:F2) */
633 crc
= crc32_be(crc
, pos
- 2, elen
+ 2);
636 /* OUI Type 1 - WPA IE */
638 elems
->wpa_len
= elen
;
639 } else if (elen
>= 5 && pos
[3] == 2) {
640 /* OUI Type 2 - WMM IE */
642 elems
->wmm_info
= pos
;
643 elems
->wmm_info_len
= elen
;
644 } else if (pos
[4] == 1) {
645 elems
->wmm_param
= pos
;
646 elems
->wmm_param_len
= elen
;
653 elems
->rsn_len
= elen
;
655 case WLAN_EID_ERP_INFO
:
656 elems
->erp_info
= pos
;
657 elems
->erp_info_len
= elen
;
659 case WLAN_EID_EXT_SUPP_RATES
:
660 elems
->ext_supp_rates
= pos
;
661 elems
->ext_supp_rates_len
= elen
;
663 case WLAN_EID_HT_CAPABILITY
:
664 if (elen
>= sizeof(struct ieee80211_ht_cap
))
665 elems
->ht_cap_elem
= (void *)pos
;
667 case WLAN_EID_HT_INFORMATION
:
668 if (elen
>= sizeof(struct ieee80211_ht_info
))
669 elems
->ht_info_elem
= (void *)pos
;
671 case WLAN_EID_MESH_ID
:
672 elems
->mesh_id
= pos
;
673 elems
->mesh_id_len
= elen
;
675 case WLAN_EID_MESH_CONFIG
:
676 if (elen
>= sizeof(struct ieee80211_meshconf_ie
))
677 elems
->mesh_config
= (void *)pos
;
679 case WLAN_EID_PEER_MGMT
:
680 elems
->peering
= pos
;
681 elems
->peering_len
= elen
;
685 elems
->preq_len
= elen
;
689 elems
->prep_len
= elen
;
693 elems
->perr_len
= elen
;
696 if (elen
>= sizeof(struct ieee80211_rann_ie
))
697 elems
->rann
= (void *)pos
;
699 case WLAN_EID_CHANNEL_SWITCH
:
700 elems
->ch_switch_elem
= pos
;
701 elems
->ch_switch_elem_len
= elen
;
704 if (!elems
->quiet_elem
) {
705 elems
->quiet_elem
= pos
;
706 elems
->quiet_elem_len
= elen
;
708 elems
->num_of_quiet_elem
++;
710 case WLAN_EID_COUNTRY
:
711 elems
->country_elem
= pos
;
712 elems
->country_elem_len
= elen
;
714 case WLAN_EID_PWR_CONSTRAINT
:
715 elems
->pwr_constr_elem
= pos
;
716 elems
->pwr_constr_elem_len
= elen
;
718 case WLAN_EID_TIMEOUT_INTERVAL
:
719 elems
->timeout_int
= pos
;
720 elems
->timeout_int_len
= elen
;
733 void ieee802_11_parse_elems(u8
*start
, size_t len
,
734 struct ieee802_11_elems
*elems
)
736 ieee802_11_parse_elems_crc(start
, len
, elems
, 0, 0);
739 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data
*sdata
)
741 struct ieee80211_local
*local
= sdata
->local
;
742 struct ieee80211_tx_queue_params qparam
;
747 if (!local
->ops
->conf_tx
)
750 memset(&qparam
, 0, sizeof(qparam
));
752 use_11b
= (local
->hw
.conf
.channel
->band
== IEEE80211_BAND_2GHZ
) &&
753 !(sdata
->flags
& IEEE80211_SDATA_OPERATING_GMODE
);
755 for (queue
= 0; queue
< local_to_hw(local
)->queues
; queue
++) {
756 /* Set defaults according to 802.11-2007 Table 7-37 */
765 qparam
.cw_max
= aCWmax
;
766 qparam
.cw_min
= aCWmin
;
770 default: /* never happens but let's not leave undefined */
772 qparam
.cw_max
= aCWmax
;
773 qparam
.cw_min
= aCWmin
;
778 qparam
.cw_max
= aCWmin
;
779 qparam
.cw_min
= (aCWmin
+ 1) / 2 - 1;
781 qparam
.txop
= 6016/32;
783 qparam
.txop
= 3008/32;
787 qparam
.cw_max
= (aCWmin
+ 1) / 2 - 1;
788 qparam
.cw_min
= (aCWmin
+ 1) / 4 - 1;
790 qparam
.txop
= 3264/32;
792 qparam
.txop
= 1504/32;
797 qparam
.uapsd
= false;
799 sdata
->tx_conf
[queue
] = qparam
;
800 drv_conf_tx(local
, sdata
, queue
, &qparam
);
803 /* after reinitialize QoS TX queues setting to default,
804 * disable QoS at all */
806 if (sdata
->vif
.type
!= NL80211_IFTYPE_MONITOR
) {
807 sdata
->vif
.bss_conf
.qos
=
808 sdata
->vif
.type
!= NL80211_IFTYPE_STATION
;
809 ieee80211_bss_info_change_notify(sdata
, BSS_CHANGED_QOS
);
813 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data
*sdata
,
814 const size_t supp_rates_len
,
815 const u8
*supp_rates
)
817 struct ieee80211_local
*local
= sdata
->local
;
818 int i
, have_higher_than_11mbit
= 0;
820 /* cf. IEEE 802.11 9.2.12 */
821 for (i
= 0; i
< supp_rates_len
; i
++)
822 if ((supp_rates
[i
] & 0x7f) * 5 > 110)
823 have_higher_than_11mbit
= 1;
825 if (local
->hw
.conf
.channel
->band
== IEEE80211_BAND_2GHZ
&&
826 have_higher_than_11mbit
)
827 sdata
->flags
|= IEEE80211_SDATA_OPERATING_GMODE
;
829 sdata
->flags
&= ~IEEE80211_SDATA_OPERATING_GMODE
;
831 ieee80211_set_wmm_default(sdata
);
834 u32
ieee80211_mandatory_rates(struct ieee80211_local
*local
,
835 enum ieee80211_band band
)
837 struct ieee80211_supported_band
*sband
;
838 struct ieee80211_rate
*bitrates
;
840 enum ieee80211_rate_flags mandatory_flag
;
843 sband
= local
->hw
.wiphy
->bands
[band
];
846 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
849 if (band
== IEEE80211_BAND_2GHZ
)
850 mandatory_flag
= IEEE80211_RATE_MANDATORY_B
;
852 mandatory_flag
= IEEE80211_RATE_MANDATORY_A
;
854 bitrates
= sband
->bitrates
;
856 for (i
= 0; i
< sband
->n_bitrates
; i
++)
857 if (bitrates
[i
].flags
& mandatory_flag
)
858 mandatory_rates
|= BIT(i
);
859 return mandatory_rates
;
862 void ieee80211_send_auth(struct ieee80211_sub_if_data
*sdata
,
863 u16 transaction
, u16 auth_alg
,
864 u8
*extra
, size_t extra_len
, const u8
*bssid
,
865 const u8
*key
, u8 key_len
, u8 key_idx
)
867 struct ieee80211_local
*local
= sdata
->local
;
869 struct ieee80211_mgmt
*mgmt
;
872 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+
873 sizeof(*mgmt
) + 6 + extra_len
);
877 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
879 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24 + 6);
880 memset(mgmt
, 0, 24 + 6);
881 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
882 IEEE80211_STYPE_AUTH
);
883 memcpy(mgmt
->da
, bssid
, ETH_ALEN
);
884 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
885 memcpy(mgmt
->bssid
, bssid
, ETH_ALEN
);
886 mgmt
->u
.auth
.auth_alg
= cpu_to_le16(auth_alg
);
887 mgmt
->u
.auth
.auth_transaction
= cpu_to_le16(transaction
);
888 mgmt
->u
.auth
.status_code
= cpu_to_le16(0);
890 memcpy(skb_put(skb
, extra_len
), extra
, extra_len
);
892 if (auth_alg
== WLAN_AUTH_SHARED_KEY
&& transaction
== 3) {
893 mgmt
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
894 err
= ieee80211_wep_encrypt(local
, skb
, key
, key_len
, key_idx
);
898 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_INTFL_DONT_ENCRYPT
;
899 ieee80211_tx_skb(sdata
, skb
);
902 int ieee80211_build_preq_ies(struct ieee80211_local
*local
, u8
*buffer
,
903 const u8
*ie
, size_t ie_len
,
904 enum ieee80211_band band
, u32 rate_mask
,
907 struct ieee80211_supported_band
*sband
;
909 size_t offset
= 0, noffset
;
910 int supp_rates_len
, i
;
915 sband
= local
->hw
.wiphy
->bands
[band
];
920 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
921 if ((BIT(i
) & rate_mask
) == 0)
922 continue; /* skip rate */
923 rates
[num_rates
++] = (u8
) (sband
->bitrates
[i
].bitrate
/ 5);
926 supp_rates_len
= min_t(int, num_rates
, 8);
928 *pos
++ = WLAN_EID_SUPP_RATES
;
929 *pos
++ = supp_rates_len
;
930 memcpy(pos
, rates
, supp_rates_len
);
931 pos
+= supp_rates_len
;
933 /* insert "request information" if in custom IEs */
935 static const u8 before_extrates
[] = {
940 noffset
= ieee80211_ie_split(ie
, ie_len
,
942 ARRAY_SIZE(before_extrates
),
944 memcpy(pos
, ie
+ offset
, noffset
- offset
);
945 pos
+= noffset
- offset
;
949 ext_rates_len
= num_rates
- supp_rates_len
;
950 if (ext_rates_len
> 0) {
951 *pos
++ = WLAN_EID_EXT_SUPP_RATES
;
952 *pos
++ = ext_rates_len
;
953 memcpy(pos
, rates
+ supp_rates_len
, ext_rates_len
);
954 pos
+= ext_rates_len
;
957 if (channel
&& sband
->band
== IEEE80211_BAND_2GHZ
) {
958 *pos
++ = WLAN_EID_DS_PARAMS
;
963 /* insert custom IEs that go before HT */
965 static const u8 before_ht
[] = {
969 WLAN_EID_EXT_SUPP_RATES
,
971 WLAN_EID_SUPPORTED_REGULATORY_CLASSES
,
973 noffset
= ieee80211_ie_split(ie
, ie_len
,
974 before_ht
, ARRAY_SIZE(before_ht
),
976 memcpy(pos
, ie
+ offset
, noffset
- offset
);
977 pos
+= noffset
- offset
;
981 if (sband
->ht_cap
.ht_supported
)
982 pos
= ieee80211_ie_build_ht_cap(pos
, &sband
->ht_cap
,
986 * If adding more here, adjust code in main.c
987 * that calculates local->scan_ies_len.
990 /* add any remaining custom IEs */
993 memcpy(pos
, ie
+ offset
, noffset
- offset
);
994 pos
+= noffset
- offset
;
1000 struct sk_buff
*ieee80211_build_probe_req(struct ieee80211_sub_if_data
*sdata
,
1001 u8
*dst
, u32 ratemask
,
1002 const u8
*ssid
, size_t ssid_len
,
1003 const u8
*ie
, size_t ie_len
,
1006 struct ieee80211_local
*local
= sdata
->local
;
1007 struct sk_buff
*skb
;
1008 struct ieee80211_mgmt
*mgmt
;
1013 /* FIXME: come up with a proper value */
1014 buf
= kmalloc(200 + ie_len
, GFP_KERNEL
);
1019 * Do not send DS Channel parameter for directed probe requests
1020 * in order to maximize the chance that we get a response. Some
1021 * badly-behaved APs don't respond when this parameter is included.
1026 chan
= ieee80211_frequency_to_channel(
1027 local
->hw
.conf
.channel
->center_freq
);
1029 buf_len
= ieee80211_build_preq_ies(local
, buf
, ie
, ie_len
,
1030 local
->hw
.conf
.channel
->band
,
1033 skb
= ieee80211_probereq_get(&local
->hw
, &sdata
->vif
,
1038 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
1039 memcpy(mgmt
->da
, dst
, ETH_ALEN
);
1040 memcpy(mgmt
->bssid
, dst
, ETH_ALEN
);
1043 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_INTFL_DONT_ENCRYPT
;
1049 void ieee80211_send_probe_req(struct ieee80211_sub_if_data
*sdata
, u8
*dst
,
1050 const u8
*ssid
, size_t ssid_len
,
1051 const u8
*ie
, size_t ie_len
,
1052 u32 ratemask
, bool directed
, bool no_cck
)
1054 struct sk_buff
*skb
;
1056 skb
= ieee80211_build_probe_req(sdata
, dst
, ratemask
, ssid
, ssid_len
,
1057 ie
, ie_len
, directed
);
1060 IEEE80211_SKB_CB(skb
)->flags
|=
1061 IEEE80211_TX_CTL_NO_CCK_RATE
;
1062 ieee80211_tx_skb(sdata
, skb
);
1066 u32
ieee80211_sta_get_rates(struct ieee80211_local
*local
,
1067 struct ieee802_11_elems
*elems
,
1068 enum ieee80211_band band
)
1070 struct ieee80211_supported_band
*sband
;
1071 struct ieee80211_rate
*bitrates
;
1075 sband
= local
->hw
.wiphy
->bands
[band
];
1079 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
1082 bitrates
= sband
->bitrates
;
1083 num_rates
= sband
->n_bitrates
;
1085 for (i
= 0; i
< elems
->supp_rates_len
+
1086 elems
->ext_supp_rates_len
; i
++) {
1089 if (i
< elems
->supp_rates_len
)
1090 rate
= elems
->supp_rates
[i
];
1091 else if (elems
->ext_supp_rates
)
1092 rate
= elems
->ext_supp_rates
1093 [i
- elems
->supp_rates_len
];
1094 own_rate
= 5 * (rate
& 0x7f);
1095 for (j
= 0; j
< num_rates
; j
++)
1096 if (bitrates
[j
].bitrate
== own_rate
)
1097 supp_rates
|= BIT(j
);
1102 void ieee80211_stop_device(struct ieee80211_local
*local
)
1104 ieee80211_led_radio(local
, false);
1105 ieee80211_mod_tpt_led_trig(local
, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO
);
1107 cancel_work_sync(&local
->reconfig_filter
);
1109 flush_workqueue(local
->workqueue
);
1113 int ieee80211_reconfig(struct ieee80211_local
*local
)
1115 struct ieee80211_hw
*hw
= &local
->hw
;
1116 struct ieee80211_sub_if_data
*sdata
;
1117 struct sta_info
*sta
;
1121 if (local
->suspended
)
1122 local
->resuming
= true;
1124 if (local
->wowlan
) {
1125 local
->wowlan
= false;
1126 res
= drv_resume(local
);
1128 local
->resuming
= false;
1135 * res is 1, which means the driver requested
1136 * to go through a regular reset on wakeup.
1141 /* setup fragmentation threshold */
1142 drv_set_frag_threshold(local
, hw
->wiphy
->frag_threshold
);
1144 /* setup RTS threshold */
1145 drv_set_rts_threshold(local
, hw
->wiphy
->rts_threshold
);
1147 /* reset coverage class */
1148 drv_set_coverage_class(local
, hw
->wiphy
->coverage_class
);
1150 /* everything else happens only if HW was up & running */
1151 if (!local
->open_count
)
1155 * Upon resume hardware can sometimes be goofy due to
1156 * various platform / driver / bus issues, so restarting
1157 * the device may at times not work immediately. Propagate
1160 res
= drv_start(local
);
1162 WARN(local
->suspended
, "Hardware became unavailable "
1163 "upon resume. This could be a software issue "
1164 "prior to suspend or a hardware issue.\n");
1168 ieee80211_led_radio(local
, true);
1169 ieee80211_mod_tpt_led_trig(local
,
1170 IEEE80211_TPT_LEDTRIG_FL_RADIO
, 0);
1172 /* add interfaces */
1173 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
1174 if (sdata
->vif
.type
!= NL80211_IFTYPE_AP_VLAN
&&
1175 sdata
->vif
.type
!= NL80211_IFTYPE_MONITOR
&&
1176 ieee80211_sdata_running(sdata
))
1177 res
= drv_add_interface(local
, sdata
);
1181 mutex_lock(&local
->sta_mtx
);
1182 list_for_each_entry(sta
, &local
->sta_list
, list
) {
1183 if (sta
->uploaded
) {
1185 if (sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
)
1186 sdata
= container_of(sdata
->bss
,
1187 struct ieee80211_sub_if_data
,
1190 memset(&sta
->sta
.drv_priv
, 0, hw
->sta_data_size
);
1191 WARN_ON(drv_sta_add(local
, sdata
, &sta
->sta
));
1194 mutex_unlock(&local
->sta_mtx
);
1196 /* reconfigure tx conf */
1197 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
1198 if (sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
||
1199 sdata
->vif
.type
== NL80211_IFTYPE_MONITOR
||
1200 !ieee80211_sdata_running(sdata
))
1203 for (i
= 0; i
< hw
->queues
; i
++)
1204 drv_conf_tx(local
, sdata
, i
, &sdata
->tx_conf
[i
]);
1207 /* reconfigure hardware */
1208 ieee80211_hw_config(local
, ~0);
1210 ieee80211_configure_filter(local
);
1212 /* Finally also reconfigure all the BSS information */
1213 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
1216 if (!ieee80211_sdata_running(sdata
))
1219 /* common change flags for all interface types */
1220 changed
= BSS_CHANGED_ERP_CTS_PROT
|
1221 BSS_CHANGED_ERP_PREAMBLE
|
1222 BSS_CHANGED_ERP_SLOT
|
1224 BSS_CHANGED_BASIC_RATES
|
1225 BSS_CHANGED_BEACON_INT
|
1231 switch (sdata
->vif
.type
) {
1232 case NL80211_IFTYPE_STATION
:
1233 changed
|= BSS_CHANGED_ASSOC
;
1234 mutex_lock(&sdata
->u
.mgd
.mtx
);
1235 ieee80211_bss_info_change_notify(sdata
, changed
);
1236 mutex_unlock(&sdata
->u
.mgd
.mtx
);
1238 case NL80211_IFTYPE_ADHOC
:
1239 changed
|= BSS_CHANGED_IBSS
;
1241 case NL80211_IFTYPE_AP
:
1242 changed
|= BSS_CHANGED_SSID
|
1243 BSS_CHANGED_AP_PROBE_RESP
;
1245 case NL80211_IFTYPE_MESH_POINT
:
1246 changed
|= BSS_CHANGED_BEACON
|
1247 BSS_CHANGED_BEACON_ENABLED
;
1248 ieee80211_bss_info_change_notify(sdata
, changed
);
1250 case NL80211_IFTYPE_WDS
:
1252 case NL80211_IFTYPE_AP_VLAN
:
1253 case NL80211_IFTYPE_MONITOR
:
1254 /* ignore virtual */
1256 case NL80211_IFTYPE_UNSPECIFIED
:
1257 case NUM_NL80211_IFTYPES
:
1258 case NL80211_IFTYPE_P2P_CLIENT
:
1259 case NL80211_IFTYPE_P2P_GO
:
1265 ieee80211_recalc_ps(local
, -1);
1268 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
1269 * sessions can be established after a resume.
1271 * Also tear down aggregation sessions since reconfiguring
1272 * them in a hardware restart scenario is not easily done
1273 * right now, and the hardware will have lost information
1274 * about the sessions, but we and the AP still think they
1275 * are active. This is really a workaround though.
1277 if (hw
->flags
& IEEE80211_HW_AMPDU_AGGREGATION
) {
1278 mutex_lock(&local
->sta_mtx
);
1280 list_for_each_entry(sta
, &local
->sta_list
, list
) {
1281 ieee80211_sta_tear_down_BA_sessions(sta
, true);
1282 clear_sta_flag(sta
, WLAN_STA_BLOCK_BA
);
1285 mutex_unlock(&local
->sta_mtx
);
1289 list_for_each_entry(sdata
, &local
->interfaces
, list
)
1290 if (ieee80211_sdata_running(sdata
))
1291 ieee80211_enable_keys(sdata
);
1294 ieee80211_wake_queues_by_reason(hw
,
1295 IEEE80211_QUEUE_STOP_REASON_SUSPEND
);
1298 * If this is for hw restart things are still running.
1299 * We may want to change that later, however.
1301 if (!local
->suspended
)
1305 /* first set suspended false, then resuming */
1306 local
->suspended
= false;
1308 local
->resuming
= false;
1310 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
1311 switch(sdata
->vif
.type
) {
1312 case NL80211_IFTYPE_STATION
:
1313 ieee80211_sta_restart(sdata
);
1315 case NL80211_IFTYPE_ADHOC
:
1316 ieee80211_ibss_restart(sdata
);
1318 case NL80211_IFTYPE_MESH_POINT
:
1319 ieee80211_mesh_restart(sdata
);
1326 mod_timer(&local
->sta_cleanup
, jiffies
+ 1);
1328 mutex_lock(&local
->sta_mtx
);
1329 list_for_each_entry(sta
, &local
->sta_list
, list
)
1330 mesh_plink_restart(sta
);
1331 mutex_unlock(&local
->sta_mtx
);
1338 void ieee80211_resume_disconnect(struct ieee80211_vif
*vif
)
1340 struct ieee80211_sub_if_data
*sdata
;
1341 struct ieee80211_local
*local
;
1342 struct ieee80211_key
*key
;
1347 sdata
= vif_to_sdata(vif
);
1348 local
= sdata
->local
;
1350 if (WARN_ON(!local
->resuming
))
1353 if (WARN_ON(vif
->type
!= NL80211_IFTYPE_STATION
))
1356 sdata
->flags
|= IEEE80211_SDATA_DISCONNECT_RESUME
;
1358 mutex_lock(&local
->key_mtx
);
1359 list_for_each_entry(key
, &sdata
->key_list
, list
)
1360 key
->flags
|= KEY_FLAG_TAINTED
;
1361 mutex_unlock(&local
->key_mtx
);
1363 EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect
);
1365 static int check_mgd_smps(struct ieee80211_if_managed
*ifmgd
,
1366 enum ieee80211_smps_mode
*smps_mode
)
1368 if (ifmgd
->associated
) {
1369 *smps_mode
= ifmgd
->ap_smps
;
1371 if (*smps_mode
== IEEE80211_SMPS_AUTOMATIC
) {
1372 if (ifmgd
->powersave
)
1373 *smps_mode
= IEEE80211_SMPS_DYNAMIC
;
1375 *smps_mode
= IEEE80211_SMPS_OFF
;
1384 /* must hold iflist_mtx */
1385 void ieee80211_recalc_smps(struct ieee80211_local
*local
)
1387 struct ieee80211_sub_if_data
*sdata
;
1388 enum ieee80211_smps_mode smps_mode
= IEEE80211_SMPS_OFF
;
1391 lockdep_assert_held(&local
->iflist_mtx
);
1394 * This function could be improved to handle multiple
1395 * interfaces better, but right now it makes any
1396 * non-station interfaces force SM PS to be turned
1397 * off. If there are multiple station interfaces it
1398 * could also use the best possible mode, e.g. if
1399 * one is in static and the other in dynamic then
1403 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
1404 if (!ieee80211_sdata_running(sdata
))
1406 if (sdata
->vif
.type
!= NL80211_IFTYPE_STATION
)
1409 count
+= check_mgd_smps(&sdata
->u
.mgd
, &smps_mode
);
1412 smps_mode
= IEEE80211_SMPS_OFF
;
1417 if (smps_mode
== local
->smps_mode
)
1421 local
->smps_mode
= smps_mode
;
1422 /* changed flag is auto-detected for this */
1423 ieee80211_hw_config(local
, 0);
1426 static bool ieee80211_id_in_list(const u8
*ids
, int n_ids
, u8 id
)
1430 for (i
= 0; i
< n_ids
; i
++)
1437 * ieee80211_ie_split - split an IE buffer according to ordering
1439 * @ies: the IE buffer
1440 * @ielen: the length of the IE buffer
1441 * @ids: an array with element IDs that are allowed before
1443 * @n_ids: the size of the element ID array
1444 * @offset: offset where to start splitting in the buffer
1446 * This function splits an IE buffer by updating the @offset
1447 * variable to point to the location where the buffer should be
1450 * It assumes that the given IE buffer is well-formed, this
1451 * has to be guaranteed by the caller!
1453 * It also assumes that the IEs in the buffer are ordered
1454 * correctly, if not the result of using this function will not
1455 * be ordered correctly either, i.e. it does no reordering.
1457 * The function returns the offset where the next part of the
1458 * buffer starts, which may be @ielen if the entire (remainder)
1459 * of the buffer should be used.
1461 size_t ieee80211_ie_split(const u8
*ies
, size_t ielen
,
1462 const u8
*ids
, int n_ids
, size_t offset
)
1464 size_t pos
= offset
;
1466 while (pos
< ielen
&& ieee80211_id_in_list(ids
, n_ids
, ies
[pos
]))
1467 pos
+= 2 + ies
[pos
+ 1];
1472 size_t ieee80211_ie_split_vendor(const u8
*ies
, size_t ielen
, size_t offset
)
1474 size_t pos
= offset
;
1476 while (pos
< ielen
&& ies
[pos
] != WLAN_EID_VENDOR_SPECIFIC
)
1477 pos
+= 2 + ies
[pos
+ 1];
1482 static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data
*sdata
,
1486 trace_api_enable_rssi_reports(sdata
, rssi_min_thold
, rssi_max_thold
);
1488 if (WARN_ON(sdata
->vif
.type
!= NL80211_IFTYPE_STATION
))
1492 * Scale up threshold values before storing it, as the RSSI averaging
1493 * algorithm uses a scaled up value as well. Change this scaling
1494 * factor if the RSSI averaging algorithm changes.
1496 sdata
->u
.mgd
.rssi_min_thold
= rssi_min_thold
*16;
1497 sdata
->u
.mgd
.rssi_max_thold
= rssi_max_thold
*16;
1500 void ieee80211_enable_rssi_reports(struct ieee80211_vif
*vif
,
1504 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
1506 WARN_ON(rssi_min_thold
== rssi_max_thold
||
1507 rssi_min_thold
> rssi_max_thold
);
1509 _ieee80211_enable_rssi_reports(sdata
, rssi_min_thold
,
1512 EXPORT_SYMBOL(ieee80211_enable_rssi_reports
);
1514 void ieee80211_disable_rssi_reports(struct ieee80211_vif
*vif
)
1516 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
1518 _ieee80211_enable_rssi_reports(sdata
, 0, 0);
1520 EXPORT_SYMBOL(ieee80211_disable_rssi_reports
);
1522 u8
*ieee80211_ie_build_ht_cap(u8
*pos
, struct ieee80211_sta_ht_cap
*ht_cap
,
1527 *pos
++ = WLAN_EID_HT_CAPABILITY
;
1528 *pos
++ = sizeof(struct ieee80211_ht_cap
);
1529 memset(pos
, 0, sizeof(struct ieee80211_ht_cap
));
1531 /* capability flags */
1532 tmp
= cpu_to_le16(cap
);
1533 memcpy(pos
, &tmp
, sizeof(u16
));
1536 /* AMPDU parameters */
1537 *pos
++ = ht_cap
->ampdu_factor
|
1538 (ht_cap
->ampdu_density
<<
1539 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT
);
1542 memcpy(pos
, &ht_cap
->mcs
, sizeof(ht_cap
->mcs
));
1543 pos
+= sizeof(ht_cap
->mcs
);
1545 /* extended capabilities */
1546 pos
+= sizeof(__le16
);
1548 /* BF capabilities */
1549 pos
+= sizeof(__le32
);
1551 /* antenna selection */
1557 u8
*ieee80211_ie_build_ht_info(u8
*pos
,
1558 struct ieee80211_sta_ht_cap
*ht_cap
,
1559 struct ieee80211_channel
*channel
,
1560 enum nl80211_channel_type channel_type
)
1562 struct ieee80211_ht_info
*ht_info
;
1563 /* Build HT Information */
1564 *pos
++ = WLAN_EID_HT_INFORMATION
;
1565 *pos
++ = sizeof(struct ieee80211_ht_info
);
1566 ht_info
= (struct ieee80211_ht_info
*)pos
;
1567 ht_info
->control_chan
=
1568 ieee80211_frequency_to_channel(channel
->center_freq
);
1569 switch (channel_type
) {
1570 case NL80211_CHAN_HT40MINUS
:
1571 ht_info
->ht_param
= IEEE80211_HT_PARAM_CHA_SEC_BELOW
;
1573 case NL80211_CHAN_HT40PLUS
:
1574 ht_info
->ht_param
= IEEE80211_HT_PARAM_CHA_SEC_ABOVE
;
1576 case NL80211_CHAN_HT20
:
1578 ht_info
->ht_param
= IEEE80211_HT_PARAM_CHA_SEC_NONE
;
1581 if (ht_cap
->cap
& IEEE80211_HT_CAP_SUP_WIDTH_20_40
)
1582 ht_info
->ht_param
|= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY
;
1583 ht_info
->operation_mode
= 0x0000;
1584 ht_info
->stbc_param
= 0x0000;
1586 /* It seems that Basic MCS set and Supported MCS set
1587 are identical for the first 10 bytes */
1588 memset(&ht_info
->basic_set
, 0, 16);
1589 memcpy(&ht_info
->basic_set
, &ht_cap
->mcs
, 10);
1591 return pos
+ sizeof(struct ieee80211_ht_info
);
1594 enum nl80211_channel_type
1595 ieee80211_ht_info_to_channel_type(struct ieee80211_ht_info
*ht_info
)
1597 enum nl80211_channel_type channel_type
;
1600 return NL80211_CHAN_NO_HT
;
1602 switch (ht_info
->ht_param
& IEEE80211_HT_PARAM_CHA_SEC_OFFSET
) {
1603 case IEEE80211_HT_PARAM_CHA_SEC_NONE
:
1604 channel_type
= NL80211_CHAN_HT20
;
1606 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE
:
1607 channel_type
= NL80211_CHAN_HT40PLUS
;
1609 case IEEE80211_HT_PARAM_CHA_SEC_BELOW
:
1610 channel_type
= NL80211_CHAN_HT40MINUS
;
1613 channel_type
= NL80211_CHAN_NO_HT
;
1616 return channel_type
;
1619 int ieee80211_add_srates_ie(struct ieee80211_vif
*vif
, struct sk_buff
*skb
)
1621 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
1622 struct ieee80211_local
*local
= sdata
->local
;
1623 struct ieee80211_supported_band
*sband
;
1627 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
1628 rates
= sband
->n_bitrates
;
1632 if (skb_tailroom(skb
) < rates
+ 2)
1635 pos
= skb_put(skb
, rates
+ 2);
1636 *pos
++ = WLAN_EID_SUPP_RATES
;
1638 for (i
= 0; i
< rates
; i
++) {
1639 rate
= sband
->bitrates
[i
].bitrate
;
1640 *pos
++ = (u8
) (rate
/ 5);
1646 int ieee80211_add_ext_srates_ie(struct ieee80211_vif
*vif
, struct sk_buff
*skb
)
1648 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
1649 struct ieee80211_local
*local
= sdata
->local
;
1650 struct ieee80211_supported_band
*sband
;
1652 u8 i
, exrates
, *pos
;
1654 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
1655 exrates
= sband
->n_bitrates
;
1661 if (skb_tailroom(skb
) < exrates
+ 2)
1665 pos
= skb_put(skb
, exrates
+ 2);
1666 *pos
++ = WLAN_EID_EXT_SUPP_RATES
;
1668 for (i
= 8; i
< sband
->n_bitrates
; i
++) {
1669 rate
= sband
->bitrates
[i
].bitrate
;
1670 *pos
++ = (u8
) (rate
/ 5);