2 * Wireless utility functions
4 * Copyright 2007-2009 Johannes Berg <johannes@sipsolutions.net>
6 #include <linux/export.h>
7 #include <linux/bitops.h>
8 #include <linux/etherdevice.h>
9 #include <linux/slab.h>
10 #include <net/cfg80211.h>
12 #include <net/dsfield.h>
15 struct ieee80211_rate
*
16 ieee80211_get_response_rate(struct ieee80211_supported_band
*sband
,
17 u32 basic_rates
, int bitrate
)
19 struct ieee80211_rate
*result
= &sband
->bitrates
[0];
22 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
23 if (!(basic_rates
& BIT(i
)))
25 if (sband
->bitrates
[i
].bitrate
> bitrate
)
27 result
= &sband
->bitrates
[i
];
32 EXPORT_SYMBOL(ieee80211_get_response_rate
);
34 int ieee80211_channel_to_frequency(int chan
, enum ieee80211_band band
)
36 /* see 802.11 17.3.8.3.2 and Annex J
37 * there are overlapping channel numbers in 5GHz and 2GHz bands */
39 return 0; /* not supported */
41 case IEEE80211_BAND_2GHZ
:
45 return 2407 + chan
* 5;
47 case IEEE80211_BAND_5GHZ
:
48 if (chan
>= 182 && chan
<= 196)
49 return 4000 + chan
* 5;
51 return 5000 + chan
* 5;
53 case IEEE80211_BAND_60GHZ
:
55 return 56160 + chan
* 2160;
60 return 0; /* not supported */
62 EXPORT_SYMBOL(ieee80211_channel_to_frequency
);
64 int ieee80211_frequency_to_channel(int freq
)
66 /* see 802.11 17.3.8.3.2 and Annex J */
70 return (freq
- 2407) / 5;
71 else if (freq
>= 4910 && freq
<= 4980)
72 return (freq
- 4000) / 5;
73 else if (freq
<= 45000) /* DMG band lower limit */
74 return (freq
- 5000) / 5;
75 else if (freq
>= 58320 && freq
<= 64800)
76 return (freq
- 56160) / 2160;
80 EXPORT_SYMBOL(ieee80211_frequency_to_channel
);
82 struct ieee80211_channel
*__ieee80211_get_channel(struct wiphy
*wiphy
,
85 enum ieee80211_band band
;
86 struct ieee80211_supported_band
*sband
;
89 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
90 sband
= wiphy
->bands
[band
];
95 for (i
= 0; i
< sband
->n_channels
; i
++) {
96 if (sband
->channels
[i
].center_freq
== freq
)
97 return &sband
->channels
[i
];
103 EXPORT_SYMBOL(__ieee80211_get_channel
);
105 static void set_mandatory_flags_band(struct ieee80211_supported_band
*sband
,
106 enum ieee80211_band band
)
111 case IEEE80211_BAND_5GHZ
:
113 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
114 if (sband
->bitrates
[i
].bitrate
== 60 ||
115 sband
->bitrates
[i
].bitrate
== 120 ||
116 sband
->bitrates
[i
].bitrate
== 240) {
117 sband
->bitrates
[i
].flags
|=
118 IEEE80211_RATE_MANDATORY_A
;
124 case IEEE80211_BAND_2GHZ
:
126 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
127 if (sband
->bitrates
[i
].bitrate
== 10) {
128 sband
->bitrates
[i
].flags
|=
129 IEEE80211_RATE_MANDATORY_B
|
130 IEEE80211_RATE_MANDATORY_G
;
134 if (sband
->bitrates
[i
].bitrate
== 20 ||
135 sband
->bitrates
[i
].bitrate
== 55 ||
136 sband
->bitrates
[i
].bitrate
== 110 ||
137 sband
->bitrates
[i
].bitrate
== 60 ||
138 sband
->bitrates
[i
].bitrate
== 120 ||
139 sband
->bitrates
[i
].bitrate
== 240) {
140 sband
->bitrates
[i
].flags
|=
141 IEEE80211_RATE_MANDATORY_G
;
145 if (sband
->bitrates
[i
].bitrate
!= 10 &&
146 sband
->bitrates
[i
].bitrate
!= 20 &&
147 sband
->bitrates
[i
].bitrate
!= 55 &&
148 sband
->bitrates
[i
].bitrate
!= 110)
149 sband
->bitrates
[i
].flags
|=
150 IEEE80211_RATE_ERP_G
;
152 WARN_ON(want
!= 0 && want
!= 3 && want
!= 6);
154 case IEEE80211_BAND_60GHZ
:
155 /* check for mandatory HT MCS 1..4 */
156 WARN_ON(!sband
->ht_cap
.ht_supported
);
157 WARN_ON((sband
->ht_cap
.mcs
.rx_mask
[0] & 0x1e) != 0x1e);
159 case IEEE80211_NUM_BANDS
:
165 void ieee80211_set_bitrate_flags(struct wiphy
*wiphy
)
167 enum ieee80211_band band
;
169 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++)
170 if (wiphy
->bands
[band
])
171 set_mandatory_flags_band(wiphy
->bands
[band
], band
);
174 bool cfg80211_supported_cipher_suite(struct wiphy
*wiphy
, u32 cipher
)
177 for (i
= 0; i
< wiphy
->n_cipher_suites
; i
++)
178 if (cipher
== wiphy
->cipher_suites
[i
])
183 int cfg80211_validate_key_settings(struct cfg80211_registered_device
*rdev
,
184 struct key_params
*params
, int key_idx
,
185 bool pairwise
, const u8
*mac_addr
)
190 if (!pairwise
&& mac_addr
&& !(rdev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
))
193 if (pairwise
&& !mac_addr
)
197 * Disallow pairwise keys with non-zero index unless it's WEP
198 * or a vendor specific cipher (because current deployments use
199 * pairwise WEP keys with non-zero indices and for vendor specific
200 * ciphers this should be validated in the driver or hardware level
201 * - but 802.11i clearly specifies to use zero)
203 if (pairwise
&& key_idx
&&
204 ((params
->cipher
== WLAN_CIPHER_SUITE_TKIP
) ||
205 (params
->cipher
== WLAN_CIPHER_SUITE_CCMP
) ||
206 (params
->cipher
== WLAN_CIPHER_SUITE_AES_CMAC
)))
209 switch (params
->cipher
) {
210 case WLAN_CIPHER_SUITE_WEP40
:
211 if (params
->key_len
!= WLAN_KEY_LEN_WEP40
)
214 case WLAN_CIPHER_SUITE_TKIP
:
215 if (params
->key_len
!= WLAN_KEY_LEN_TKIP
)
218 case WLAN_CIPHER_SUITE_CCMP
:
219 if (params
->key_len
!= WLAN_KEY_LEN_CCMP
)
222 case WLAN_CIPHER_SUITE_WEP104
:
223 if (params
->key_len
!= WLAN_KEY_LEN_WEP104
)
226 case WLAN_CIPHER_SUITE_AES_CMAC
:
227 if (params
->key_len
!= WLAN_KEY_LEN_AES_CMAC
)
232 * We don't know anything about this algorithm,
233 * allow using it -- but the driver must check
234 * all parameters! We still check below whether
235 * or not the driver supports this algorithm,
242 switch (params
->cipher
) {
243 case WLAN_CIPHER_SUITE_WEP40
:
244 case WLAN_CIPHER_SUITE_WEP104
:
245 /* These ciphers do not use key sequence */
247 case WLAN_CIPHER_SUITE_TKIP
:
248 case WLAN_CIPHER_SUITE_CCMP
:
249 case WLAN_CIPHER_SUITE_AES_CMAC
:
250 if (params
->seq_len
!= 6)
256 if (!cfg80211_supported_cipher_suite(&rdev
->wiphy
, params
->cipher
))
262 unsigned int __attribute_const__
ieee80211_hdrlen(__le16 fc
)
264 unsigned int hdrlen
= 24;
266 if (ieee80211_is_data(fc
)) {
267 if (ieee80211_has_a4(fc
))
269 if (ieee80211_is_data_qos(fc
)) {
270 hdrlen
+= IEEE80211_QOS_CTL_LEN
;
271 if (ieee80211_has_order(fc
))
272 hdrlen
+= IEEE80211_HT_CTL_LEN
;
277 if (ieee80211_is_ctl(fc
)) {
279 * ACK and CTS are 10 bytes, all others 16. To see how
280 * to get this condition consider
281 * subtype mask: 0b0000000011110000 (0x00F0)
282 * ACK subtype: 0b0000000011010000 (0x00D0)
283 * CTS subtype: 0b0000000011000000 (0x00C0)
284 * bits that matter: ^^^ (0x00E0)
285 * value of those: 0b0000000011000000 (0x00C0)
287 if ((fc
& cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0))
295 EXPORT_SYMBOL(ieee80211_hdrlen
);
297 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff
*skb
)
299 const struct ieee80211_hdr
*hdr
=
300 (const struct ieee80211_hdr
*)skb
->data
;
303 if (unlikely(skb
->len
< 10))
305 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
306 if (unlikely(hdrlen
> skb
->len
))
310 EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb
);
312 static int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr
*meshhdr
)
314 int ae
= meshhdr
->flags
& MESH_FLAGS_AE
;
319 case MESH_FLAGS_AE_A4
:
321 case MESH_FLAGS_AE_A5_A6
:
323 case (MESH_FLAGS_AE_A4
| MESH_FLAGS_AE_A5_A6
):
330 int ieee80211_data_to_8023(struct sk_buff
*skb
, const u8
*addr
,
331 enum nl80211_iftype iftype
)
333 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
334 u16 hdrlen
, ethertype
;
337 u8 src
[ETH_ALEN
] __aligned(2);
339 if (unlikely(!ieee80211_is_data_present(hdr
->frame_control
)))
342 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
344 /* convert IEEE 802.11 header + possible LLC headers into Ethernet
346 * IEEE 802.11 address fields:
347 * ToDS FromDS Addr1 Addr2 Addr3 Addr4
348 * 0 0 DA SA BSSID n/a
349 * 0 1 DA BSSID SA n/a
350 * 1 0 BSSID SA DA n/a
353 memcpy(dst
, ieee80211_get_DA(hdr
), ETH_ALEN
);
354 memcpy(src
, ieee80211_get_SA(hdr
), ETH_ALEN
);
356 switch (hdr
->frame_control
&
357 cpu_to_le16(IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
)) {
358 case cpu_to_le16(IEEE80211_FCTL_TODS
):
359 if (unlikely(iftype
!= NL80211_IFTYPE_AP
&&
360 iftype
!= NL80211_IFTYPE_AP_VLAN
&&
361 iftype
!= NL80211_IFTYPE_P2P_GO
))
364 case cpu_to_le16(IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
):
365 if (unlikely(iftype
!= NL80211_IFTYPE_WDS
&&
366 iftype
!= NL80211_IFTYPE_MESH_POINT
&&
367 iftype
!= NL80211_IFTYPE_AP_VLAN
&&
368 iftype
!= NL80211_IFTYPE_STATION
))
370 if (iftype
== NL80211_IFTYPE_MESH_POINT
) {
371 struct ieee80211s_hdr
*meshdr
=
372 (struct ieee80211s_hdr
*) (skb
->data
+ hdrlen
);
373 /* make sure meshdr->flags is on the linear part */
374 if (!pskb_may_pull(skb
, hdrlen
+ 1))
376 if (meshdr
->flags
& MESH_FLAGS_AE_A5_A6
) {
377 skb_copy_bits(skb
, hdrlen
+
378 offsetof(struct ieee80211s_hdr
, eaddr1
),
380 skb_copy_bits(skb
, hdrlen
+
381 offsetof(struct ieee80211s_hdr
, eaddr2
),
384 hdrlen
+= ieee80211_get_mesh_hdrlen(meshdr
);
387 case cpu_to_le16(IEEE80211_FCTL_FROMDS
):
388 if ((iftype
!= NL80211_IFTYPE_STATION
&&
389 iftype
!= NL80211_IFTYPE_P2P_CLIENT
&&
390 iftype
!= NL80211_IFTYPE_MESH_POINT
) ||
391 (is_multicast_ether_addr(dst
) &&
392 ether_addr_equal(src
, addr
)))
394 if (iftype
== NL80211_IFTYPE_MESH_POINT
) {
395 struct ieee80211s_hdr
*meshdr
=
396 (struct ieee80211s_hdr
*) (skb
->data
+ hdrlen
);
397 /* make sure meshdr->flags is on the linear part */
398 if (!pskb_may_pull(skb
, hdrlen
+ 1))
400 if (meshdr
->flags
& MESH_FLAGS_AE_A4
)
401 skb_copy_bits(skb
, hdrlen
+
402 offsetof(struct ieee80211s_hdr
, eaddr1
),
404 hdrlen
+= ieee80211_get_mesh_hdrlen(meshdr
);
408 if (iftype
!= NL80211_IFTYPE_ADHOC
&&
409 iftype
!= NL80211_IFTYPE_STATION
)
414 if (!pskb_may_pull(skb
, hdrlen
+ 8))
417 payload
= skb
->data
+ hdrlen
;
418 ethertype
= (payload
[6] << 8) | payload
[7];
420 if (likely((ether_addr_equal(payload
, rfc1042_header
) &&
421 ethertype
!= ETH_P_AARP
&& ethertype
!= ETH_P_IPX
) ||
422 ether_addr_equal(payload
, bridge_tunnel_header
))) {
423 /* remove RFC1042 or Bridge-Tunnel encapsulation and
424 * replace EtherType */
425 skb_pull(skb
, hdrlen
+ 6);
426 memcpy(skb_push(skb
, ETH_ALEN
), src
, ETH_ALEN
);
427 memcpy(skb_push(skb
, ETH_ALEN
), dst
, ETH_ALEN
);
432 skb_pull(skb
, hdrlen
);
433 len
= htons(skb
->len
);
434 ehdr
= (struct ethhdr
*) skb_push(skb
, sizeof(struct ethhdr
));
435 memcpy(ehdr
->h_dest
, dst
, ETH_ALEN
);
436 memcpy(ehdr
->h_source
, src
, ETH_ALEN
);
441 EXPORT_SYMBOL(ieee80211_data_to_8023
);
443 int ieee80211_data_from_8023(struct sk_buff
*skb
, const u8
*addr
,
444 enum nl80211_iftype iftype
, u8
*bssid
, bool qos
)
446 struct ieee80211_hdr hdr
;
447 u16 hdrlen
, ethertype
;
449 const u8
*encaps_data
;
450 int encaps_len
, skip_header_bytes
;
454 if (unlikely(skb
->len
< ETH_HLEN
))
457 nh_pos
= skb_network_header(skb
) - skb
->data
;
458 h_pos
= skb_transport_header(skb
) - skb
->data
;
460 /* convert Ethernet header to proper 802.11 header (based on
462 ethertype
= (skb
->data
[12] << 8) | skb
->data
[13];
463 fc
= cpu_to_le16(IEEE80211_FTYPE_DATA
| IEEE80211_STYPE_DATA
);
466 case NL80211_IFTYPE_AP
:
467 case NL80211_IFTYPE_AP_VLAN
:
468 case NL80211_IFTYPE_P2P_GO
:
469 fc
|= cpu_to_le16(IEEE80211_FCTL_FROMDS
);
471 memcpy(hdr
.addr1
, skb
->data
, ETH_ALEN
);
472 memcpy(hdr
.addr2
, addr
, ETH_ALEN
);
473 memcpy(hdr
.addr3
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
476 case NL80211_IFTYPE_STATION
:
477 case NL80211_IFTYPE_P2P_CLIENT
:
478 fc
|= cpu_to_le16(IEEE80211_FCTL_TODS
);
480 memcpy(hdr
.addr1
, bssid
, ETH_ALEN
);
481 memcpy(hdr
.addr2
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
482 memcpy(hdr
.addr3
, skb
->data
, ETH_ALEN
);
485 case NL80211_IFTYPE_ADHOC
:
487 memcpy(hdr
.addr1
, skb
->data
, ETH_ALEN
);
488 memcpy(hdr
.addr2
, skb
->data
+ ETH_ALEN
, ETH_ALEN
);
489 memcpy(hdr
.addr3
, bssid
, ETH_ALEN
);
497 fc
|= cpu_to_le16(IEEE80211_STYPE_QOS_DATA
);
501 hdr
.frame_control
= fc
;
505 skip_header_bytes
= ETH_HLEN
;
506 if (ethertype
== ETH_P_AARP
|| ethertype
== ETH_P_IPX
) {
507 encaps_data
= bridge_tunnel_header
;
508 encaps_len
= sizeof(bridge_tunnel_header
);
509 skip_header_bytes
-= 2;
510 } else if (ethertype
> 0x600) {
511 encaps_data
= rfc1042_header
;
512 encaps_len
= sizeof(rfc1042_header
);
513 skip_header_bytes
-= 2;
519 skb_pull(skb
, skip_header_bytes
);
520 nh_pos
-= skip_header_bytes
;
521 h_pos
-= skip_header_bytes
;
523 head_need
= hdrlen
+ encaps_len
- skb_headroom(skb
);
525 if (head_need
> 0 || skb_cloned(skb
)) {
526 head_need
= max(head_need
, 0);
530 if (pskb_expand_head(skb
, head_need
, 0, GFP_ATOMIC
))
533 skb
->truesize
+= head_need
;
537 memcpy(skb_push(skb
, encaps_len
), encaps_data
, encaps_len
);
538 nh_pos
+= encaps_len
;
542 memcpy(skb_push(skb
, hdrlen
), &hdr
, hdrlen
);
547 /* Update skb pointers to various headers since this modified frame
548 * is going to go through Linux networking code that may potentially
549 * need things like pointer to IP header. */
550 skb_set_mac_header(skb
, 0);
551 skb_set_network_header(skb
, nh_pos
);
552 skb_set_transport_header(skb
, h_pos
);
556 EXPORT_SYMBOL(ieee80211_data_from_8023
);
559 void ieee80211_amsdu_to_8023s(struct sk_buff
*skb
, struct sk_buff_head
*list
,
560 const u8
*addr
, enum nl80211_iftype iftype
,
561 const unsigned int extra_headroom
,
562 bool has_80211_header
)
564 struct sk_buff
*frame
= NULL
;
567 const struct ethhdr
*eth
;
569 u8 dst
[ETH_ALEN
], src
[ETH_ALEN
];
571 if (has_80211_header
) {
572 err
= ieee80211_data_to_8023(skb
, addr
, iftype
);
576 /* skip the wrapping header */
577 eth
= (struct ethhdr
*) skb_pull(skb
, sizeof(struct ethhdr
));
581 eth
= (struct ethhdr
*) skb
->data
;
584 while (skb
!= frame
) {
586 __be16 len
= eth
->h_proto
;
587 unsigned int subframe_len
= sizeof(struct ethhdr
) + ntohs(len
);
589 remaining
= skb
->len
;
590 memcpy(dst
, eth
->h_dest
, ETH_ALEN
);
591 memcpy(src
, eth
->h_source
, ETH_ALEN
);
593 padding
= (4 - subframe_len
) & 0x3;
594 /* the last MSDU has no padding */
595 if (subframe_len
> remaining
)
598 skb_pull(skb
, sizeof(struct ethhdr
));
599 /* reuse skb for the last subframe */
600 if (remaining
<= subframe_len
+ padding
)
603 unsigned int hlen
= ALIGN(extra_headroom
, 4);
605 * Allocate and reserve two bytes more for payload
606 * alignment since sizeof(struct ethhdr) is 14.
608 frame
= dev_alloc_skb(hlen
+ subframe_len
+ 2);
612 skb_reserve(frame
, hlen
+ sizeof(struct ethhdr
) + 2);
613 memcpy(skb_put(frame
, ntohs(len
)), skb
->data
,
616 eth
= (struct ethhdr
*)skb_pull(skb
, ntohs(len
) +
619 dev_kfree_skb(frame
);
624 skb_reset_network_header(frame
);
625 frame
->dev
= skb
->dev
;
626 frame
->priority
= skb
->priority
;
628 payload
= frame
->data
;
629 ethertype
= (payload
[6] << 8) | payload
[7];
631 if (likely((ether_addr_equal(payload
, rfc1042_header
) &&
632 ethertype
!= ETH_P_AARP
&& ethertype
!= ETH_P_IPX
) ||
633 ether_addr_equal(payload
, bridge_tunnel_header
))) {
634 /* remove RFC1042 or Bridge-Tunnel
635 * encapsulation and replace EtherType */
637 memcpy(skb_push(frame
, ETH_ALEN
), src
, ETH_ALEN
);
638 memcpy(skb_push(frame
, ETH_ALEN
), dst
, ETH_ALEN
);
640 memcpy(skb_push(frame
, sizeof(__be16
)), &len
,
642 memcpy(skb_push(frame
, ETH_ALEN
), src
, ETH_ALEN
);
643 memcpy(skb_push(frame
, ETH_ALEN
), dst
, ETH_ALEN
);
645 __skb_queue_tail(list
, frame
);
651 __skb_queue_purge(list
);
655 EXPORT_SYMBOL(ieee80211_amsdu_to_8023s
);
657 /* Given a data frame determine the 802.1p/1d tag to use. */
658 unsigned int cfg80211_classify8021d(struct sk_buff
*skb
)
662 /* skb->priority values from 256->263 are magic values to
663 * directly indicate a specific 802.1d priority. This is used
664 * to allow 802.1d priority to be passed directly in from VLAN
667 if (skb
->priority
>= 256 && skb
->priority
<= 263)
668 return skb
->priority
- 256;
670 switch (skb
->protocol
) {
671 case htons(ETH_P_IP
):
672 dscp
= ipv4_get_dsfield(ip_hdr(skb
)) & 0xfc;
674 case htons(ETH_P_IPV6
):
675 dscp
= ipv6_get_dsfield(ipv6_hdr(skb
)) & 0xfc;
683 EXPORT_SYMBOL(cfg80211_classify8021d
);
685 const u8
*ieee80211_bss_get_ie(struct cfg80211_bss
*bss
, u8 ie
)
687 if (bss
->information_elements
== NULL
)
689 return cfg80211_find_ie(ie
, bss
->information_elements
,
690 bss
->len_information_elements
);
692 EXPORT_SYMBOL(ieee80211_bss_get_ie
);
694 void cfg80211_upload_connect_keys(struct wireless_dev
*wdev
)
696 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
697 struct net_device
*dev
= wdev
->netdev
;
700 if (!wdev
->connect_keys
)
703 for (i
= 0; i
< 6; i
++) {
704 if (!wdev
->connect_keys
->params
[i
].cipher
)
706 if (rdev
->ops
->add_key(wdev
->wiphy
, dev
, i
, false, NULL
,
707 &wdev
->connect_keys
->params
[i
])) {
708 netdev_err(dev
, "failed to set key %d\n", i
);
711 if (wdev
->connect_keys
->def
== i
)
712 if (rdev
->ops
->set_default_key(wdev
->wiphy
, dev
,
714 netdev_err(dev
, "failed to set defkey %d\n", i
);
717 if (wdev
->connect_keys
->defmgmt
== i
)
718 if (rdev
->ops
->set_default_mgmt_key(wdev
->wiphy
, dev
, i
))
719 netdev_err(dev
, "failed to set mgtdef %d\n", i
);
722 kfree(wdev
->connect_keys
);
723 wdev
->connect_keys
= NULL
;
726 void cfg80211_process_wdev_events(struct wireless_dev
*wdev
)
728 struct cfg80211_event
*ev
;
730 const u8
*bssid
= NULL
;
732 spin_lock_irqsave(&wdev
->event_lock
, flags
);
733 while (!list_empty(&wdev
->event_list
)) {
734 ev
= list_first_entry(&wdev
->event_list
,
735 struct cfg80211_event
, list
);
737 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
741 case EVENT_CONNECT_RESULT
:
742 if (!is_zero_ether_addr(ev
->cr
.bssid
))
743 bssid
= ev
->cr
.bssid
;
744 __cfg80211_connect_result(
746 ev
->cr
.req_ie
, ev
->cr
.req_ie_len
,
747 ev
->cr
.resp_ie
, ev
->cr
.resp_ie_len
,
749 ev
->cr
.status
== WLAN_STATUS_SUCCESS
,
753 __cfg80211_roamed(wdev
, ev
->rm
.bss
, ev
->rm
.req_ie
,
754 ev
->rm
.req_ie_len
, ev
->rm
.resp_ie
,
757 case EVENT_DISCONNECTED
:
758 __cfg80211_disconnected(wdev
->netdev
,
759 ev
->dc
.ie
, ev
->dc
.ie_len
,
760 ev
->dc
.reason
, true);
762 case EVENT_IBSS_JOINED
:
763 __cfg80211_ibss_joined(wdev
->netdev
, ev
->ij
.bssid
);
770 spin_lock_irqsave(&wdev
->event_lock
, flags
);
772 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
775 void cfg80211_process_rdev_events(struct cfg80211_registered_device
*rdev
)
777 struct wireless_dev
*wdev
;
780 ASSERT_RDEV_LOCK(rdev
);
782 mutex_lock(&rdev
->devlist_mtx
);
784 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
)
785 cfg80211_process_wdev_events(wdev
);
787 mutex_unlock(&rdev
->devlist_mtx
);
790 int cfg80211_change_iface(struct cfg80211_registered_device
*rdev
,
791 struct net_device
*dev
, enum nl80211_iftype ntype
,
792 u32
*flags
, struct vif_params
*params
)
795 enum nl80211_iftype otype
= dev
->ieee80211_ptr
->iftype
;
797 ASSERT_RDEV_LOCK(rdev
);
799 /* don't support changing VLANs, you just re-create them */
800 if (otype
== NL80211_IFTYPE_AP_VLAN
)
803 /* cannot change into P2P device type */
804 if (ntype
== NL80211_IFTYPE_P2P_DEVICE
)
807 if (!rdev
->ops
->change_virtual_intf
||
808 !(rdev
->wiphy
.interface_modes
& (1 << ntype
)))
811 /* if it's part of a bridge, reject changing type to station/ibss */
812 if ((dev
->priv_flags
& IFF_BRIDGE_PORT
) &&
813 (ntype
== NL80211_IFTYPE_ADHOC
||
814 ntype
== NL80211_IFTYPE_STATION
||
815 ntype
== NL80211_IFTYPE_P2P_CLIENT
))
818 if (ntype
!= otype
&& netif_running(dev
)) {
819 mutex_lock(&rdev
->devlist_mtx
);
820 err
= cfg80211_can_change_interface(rdev
, dev
->ieee80211_ptr
,
822 mutex_unlock(&rdev
->devlist_mtx
);
826 dev
->ieee80211_ptr
->use_4addr
= false;
827 dev
->ieee80211_ptr
->mesh_id_up_len
= 0;
830 case NL80211_IFTYPE_AP
:
831 cfg80211_stop_ap(rdev
, dev
);
833 case NL80211_IFTYPE_ADHOC
:
834 cfg80211_leave_ibss(rdev
, dev
, false);
836 case NL80211_IFTYPE_STATION
:
837 case NL80211_IFTYPE_P2P_CLIENT
:
838 cfg80211_disconnect(rdev
, dev
,
839 WLAN_REASON_DEAUTH_LEAVING
, true);
841 case NL80211_IFTYPE_MESH_POINT
:
842 /* mesh should be handled? */
848 cfg80211_process_rdev_events(rdev
);
851 err
= rdev
->ops
->change_virtual_intf(&rdev
->wiphy
, dev
,
852 ntype
, flags
, params
);
854 WARN_ON(!err
&& dev
->ieee80211_ptr
->iftype
!= ntype
);
856 if (!err
&& params
&& params
->use_4addr
!= -1)
857 dev
->ieee80211_ptr
->use_4addr
= params
->use_4addr
;
860 dev
->priv_flags
&= ~IFF_DONT_BRIDGE
;
862 case NL80211_IFTYPE_STATION
:
863 if (dev
->ieee80211_ptr
->use_4addr
)
866 case NL80211_IFTYPE_P2P_CLIENT
:
867 case NL80211_IFTYPE_ADHOC
:
868 dev
->priv_flags
|= IFF_DONT_BRIDGE
;
870 case NL80211_IFTYPE_P2P_GO
:
871 case NL80211_IFTYPE_AP
:
872 case NL80211_IFTYPE_AP_VLAN
:
873 case NL80211_IFTYPE_WDS
:
874 case NL80211_IFTYPE_MESH_POINT
:
877 case NL80211_IFTYPE_MONITOR
:
878 /* monitor can't bridge anyway */
880 case NL80211_IFTYPE_UNSPECIFIED
:
881 case NUM_NL80211_IFTYPES
:
884 case NL80211_IFTYPE_P2P_DEVICE
:
890 if (!err
&& ntype
!= otype
&& netif_running(dev
)) {
891 cfg80211_update_iface_num(rdev
, ntype
, 1);
892 cfg80211_update_iface_num(rdev
, otype
, -1);
898 static u32
cfg80211_calculate_bitrate_60g(struct rate_info
*rate
)
900 static const u32 __mcs2bitrate
[] = {
908 [5] = 12512, /* 1251.25 mbps */
918 [14] = 8662, /* 866.25 mbps */
928 [24] = 67568, /* 6756.75 mbps */
939 if (WARN_ON_ONCE(rate
->mcs
>= ARRAY_SIZE(__mcs2bitrate
)))
942 return __mcs2bitrate
[rate
->mcs
];
945 u32
cfg80211_calculate_bitrate(struct rate_info
*rate
)
947 int modulation
, streams
, bitrate
;
949 if (!(rate
->flags
& RATE_INFO_FLAGS_MCS
))
951 if (rate
->flags
& RATE_INFO_FLAGS_60G
)
952 return cfg80211_calculate_bitrate_60g(rate
);
954 /* the formula below does only work for MCS values smaller than 32 */
955 if (WARN_ON_ONCE(rate
->mcs
>= 32))
958 modulation
= rate
->mcs
& 7;
959 streams
= (rate
->mcs
>> 3) + 1;
961 bitrate
= (rate
->flags
& RATE_INFO_FLAGS_40_MHZ_WIDTH
) ?
965 bitrate
*= (modulation
+ 1);
966 else if (modulation
== 4)
967 bitrate
*= (modulation
+ 2);
969 bitrate
*= (modulation
+ 3);
973 if (rate
->flags
& RATE_INFO_FLAGS_SHORT_GI
)
974 bitrate
= (bitrate
/ 9) * 10;
976 /* do NOT round down here */
977 return (bitrate
+ 50000) / 100000;
979 EXPORT_SYMBOL(cfg80211_calculate_bitrate
);
981 int cfg80211_validate_beacon_int(struct cfg80211_registered_device
*rdev
,
984 struct wireless_dev
*wdev
;
990 mutex_lock(&rdev
->devlist_mtx
);
992 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
993 if (!wdev
->beacon_interval
)
995 if (wdev
->beacon_interval
!= beacon_int
) {
1001 mutex_unlock(&rdev
->devlist_mtx
);
1006 int cfg80211_can_use_iftype_chan(struct cfg80211_registered_device
*rdev
,
1007 struct wireless_dev
*wdev
,
1008 enum nl80211_iftype iftype
,
1009 struct ieee80211_channel
*chan
,
1010 enum cfg80211_chan_mode chanmode
)
1012 struct wireless_dev
*wdev_iter
;
1013 u32 used_iftypes
= BIT(iftype
);
1014 int num
[NUM_NL80211_IFTYPES
];
1015 struct ieee80211_channel
1016 *used_channels
[CFG80211_MAX_NUM_DIFFERENT_CHANNELS
];
1017 struct ieee80211_channel
*ch
;
1018 enum cfg80211_chan_mode chmode
;
1019 int num_different_channels
= 0;
1024 lockdep_assert_held(&rdev
->devlist_mtx
);
1026 /* Always allow software iftypes */
1027 if (rdev
->wiphy
.software_iftypes
& BIT(iftype
))
1030 memset(num
, 0, sizeof(num
));
1031 memset(used_channels
, 0, sizeof(used_channels
));
1036 case CHAN_MODE_UNDEFINED
:
1038 case CHAN_MODE_SHARED
:
1040 used_channels
[0] = chan
;
1041 num_different_channels
++;
1043 case CHAN_MODE_EXCLUSIVE
:
1044 num_different_channels
++;
1048 list_for_each_entry(wdev_iter
, &rdev
->wdev_list
, list
) {
1049 if (wdev_iter
== wdev
)
1051 if (wdev_iter
->netdev
) {
1052 if (!netif_running(wdev_iter
->netdev
))
1054 } else if (wdev_iter
->iftype
== NL80211_IFTYPE_P2P_DEVICE
) {
1055 if (!wdev_iter
->p2p_started
)
1061 if (rdev
->wiphy
.software_iftypes
& BIT(wdev_iter
->iftype
))
1065 * We may be holding the "wdev" mutex, but now need to lock
1066 * wdev_iter. This is OK because once we get here wdev_iter
1067 * is not wdev (tested above), but we need to use the nested
1068 * locking for lockdep.
1070 mutex_lock_nested(&wdev_iter
->mtx
, 1);
1071 __acquire(wdev_iter
->mtx
);
1072 cfg80211_get_chan_state(wdev_iter
, &ch
, &chmode
);
1073 wdev_unlock(wdev_iter
);
1076 case CHAN_MODE_UNDEFINED
:
1078 case CHAN_MODE_SHARED
:
1079 for (i
= 0; i
< CFG80211_MAX_NUM_DIFFERENT_CHANNELS
; i
++)
1080 if (!used_channels
[i
] || used_channels
[i
] == ch
)
1083 if (i
== CFG80211_MAX_NUM_DIFFERENT_CHANNELS
)
1086 if (used_channels
[i
] == NULL
) {
1087 used_channels
[i
] = ch
;
1088 num_different_channels
++;
1091 case CHAN_MODE_EXCLUSIVE
:
1092 num_different_channels
++;
1096 num
[wdev_iter
->iftype
]++;
1098 used_iftypes
|= BIT(wdev_iter
->iftype
);
1104 for (i
= 0; i
< rdev
->wiphy
.n_iface_combinations
; i
++) {
1105 const struct ieee80211_iface_combination
*c
;
1106 struct ieee80211_iface_limit
*limits
;
1107 u32 all_iftypes
= 0;
1109 c
= &rdev
->wiphy
.iface_combinations
[i
];
1111 if (total
> c
->max_interfaces
)
1113 if (num_different_channels
> c
->num_different_channels
)
1116 limits
= kmemdup(c
->limits
, sizeof(limits
[0]) * c
->n_limits
,
1121 for (iftype
= 0; iftype
< NUM_NL80211_IFTYPES
; iftype
++) {
1122 if (rdev
->wiphy
.software_iftypes
& BIT(iftype
))
1124 for (j
= 0; j
< c
->n_limits
; j
++) {
1125 all_iftypes
|= limits
[j
].types
;
1126 if (!(limits
[j
].types
& BIT(iftype
)))
1128 if (limits
[j
].max
< num
[iftype
])
1130 limits
[j
].max
-= num
[iftype
];
1135 * Finally check that all iftypes that we're currently
1136 * using are actually part of this combination. If they
1137 * aren't then we can't use this combination and have
1138 * to continue to the next.
1140 if ((all_iftypes
& used_iftypes
) != used_iftypes
)
1144 * This combination covered all interface types and
1145 * supported the requested numbers, so we're good.
1156 int ieee80211_get_ratemask(struct ieee80211_supported_band
*sband
,
1157 const u8
*rates
, unsigned int n_rates
,
1165 if (n_rates
== 0 || n_rates
> NL80211_MAX_SUPP_RATES
)
1170 for (i
= 0; i
< n_rates
; i
++) {
1171 int rate
= (rates
[i
] & 0x7f) * 5;
1174 for (j
= 0; j
< sband
->n_bitrates
; j
++) {
1175 if (sband
->bitrates
[j
].bitrate
== rate
) {
1186 * mask must have at least one bit set here since we
1187 * didn't accept a 0-length rates array nor allowed
1188 * entries in the array that didn't exist
1194 /* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */
1195 /* Ethernet-II snap header (RFC1042 for most EtherTypes) */
1196 const unsigned char rfc1042_header
[] __aligned(2) =
1197 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
1198 EXPORT_SYMBOL(rfc1042_header
);
1200 /* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
1201 const unsigned char bridge_tunnel_header
[] __aligned(2) =
1202 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
1203 EXPORT_SYMBOL(bridge_tunnel_header
);