2 * Copyright (c) 2001 Atsushi Onoe
3 * Copyright (c) 2002-2008 Sam Leffler, Errno Consulting
4 * Copyright (c) 2012 IEEE
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
32 * IEEE 802.11 protocol support.
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/kernel.h>
41 #include <sys/malloc.h>
43 #include <sys/socket.h>
44 #include <sys/sockio.h>
47 #include <net/if_var.h>
48 #include <net/if_media.h>
49 #include <net/ethernet.h> /* XXX for ether_sprintf */
51 #if defined(__DragonFly__)
52 #include <net/ifq_var.h>
55 #include <netproto/802_11/ieee80211_var.h>
56 #include <netproto/802_11/ieee80211_adhoc.h>
57 #include <netproto/802_11/ieee80211_sta.h>
58 #include <netproto/802_11/ieee80211_hostap.h>
59 #include <netproto/802_11/ieee80211_wds.h>
60 #ifdef IEEE80211_SUPPORT_MESH
61 #include <netproto/802_11/ieee80211_mesh.h>
63 #include <netproto/802_11/ieee80211_monitor.h>
64 #include <netproto/802_11/ieee80211_input.h>
67 #define AGGRESSIVE_MODE_SWITCH_HYSTERESIS 3 /* pkts / 100ms */
68 #define HIGH_PRI_SWITCH_THRESH 10 /* pkts / 100ms */
70 const char *mgt_subtype_name
[] = {
71 "assoc_req", "assoc_resp", "reassoc_req", "reassoc_resp",
72 "probe_req", "probe_resp", "timing_adv", "reserved#7",
73 "beacon", "atim", "disassoc", "auth",
74 "deauth", "action", "action_noack", "reserved#15"
76 const char *ctl_subtype_name
[] = {
77 "reserved#0", "reserved#1", "reserved#2", "reserved#3",
78 "reserved#4", "reserved#5", "reserved#6", "control_wrap",
79 "bar", "ba", "ps_poll", "rts",
80 "cts", "ack", "cf_end", "cf_end_ack"
82 const char *ieee80211_opmode_name
[IEEE80211_OPMODE_MAX
] = {
83 "IBSS", /* IEEE80211_M_IBSS */
84 "STA", /* IEEE80211_M_STA */
85 "WDS", /* IEEE80211_M_WDS */
86 "AHDEMO", /* IEEE80211_M_AHDEMO */
87 "HOSTAP", /* IEEE80211_M_HOSTAP */
88 "MONITOR", /* IEEE80211_M_MONITOR */
89 "MBSS" /* IEEE80211_M_MBSS */
91 const char *ieee80211_state_name
[IEEE80211_S_MAX
] = {
92 "INIT", /* IEEE80211_S_INIT */
93 "SCAN", /* IEEE80211_S_SCAN */
94 "AUTH", /* IEEE80211_S_AUTH */
95 "ASSOC", /* IEEE80211_S_ASSOC */
96 "CAC", /* IEEE80211_S_CAC */
97 "RUN", /* IEEE80211_S_RUN */
98 "CSA", /* IEEE80211_S_CSA */
99 "SLEEP", /* IEEE80211_S_SLEEP */
101 const char *ieee80211_wme_acnames
[] = {
111 * Reason code descriptions were (mostly) obtained from
112 * IEEE Std 802.11-2012, pp. 442-445 Table 8-36.
115 ieee80211_reason_to_string(uint16_t reason
)
118 case IEEE80211_REASON_UNSPECIFIED
:
119 return ("unspecified");
120 case IEEE80211_REASON_AUTH_EXPIRE
:
121 return ("previous authentication is expired");
122 case IEEE80211_REASON_AUTH_LEAVE
:
123 return ("sending STA is leaving/has left IBSS or ESS");
124 case IEEE80211_REASON_ASSOC_EXPIRE
:
125 return ("disassociated due to inactivity");
126 case IEEE80211_REASON_ASSOC_TOOMANY
:
127 return ("too many associated STAs");
128 case IEEE80211_REASON_NOT_AUTHED
:
129 return ("class 2 frame received from nonauthenticated STA");
130 case IEEE80211_REASON_NOT_ASSOCED
:
131 return ("class 3 frame received from nonassociated STA");
132 case IEEE80211_REASON_ASSOC_LEAVE
:
133 return ("sending STA is leaving/has left BSS");
134 case IEEE80211_REASON_ASSOC_NOT_AUTHED
:
135 return ("STA requesting (re)association is not authenticated");
136 case IEEE80211_REASON_DISASSOC_PWRCAP_BAD
:
137 return ("information in the Power Capability element is "
139 case IEEE80211_REASON_DISASSOC_SUPCHAN_BAD
:
140 return ("information in the Supported Channels element is "
142 case IEEE80211_REASON_IE_INVALID
:
143 return ("invalid element");
144 case IEEE80211_REASON_MIC_FAILURE
:
145 return ("MIC failure");
146 case IEEE80211_REASON_4WAY_HANDSHAKE_TIMEOUT
:
147 return ("4-Way handshake timeout");
148 case IEEE80211_REASON_GROUP_KEY_UPDATE_TIMEOUT
:
149 return ("group key update timeout");
150 case IEEE80211_REASON_IE_IN_4WAY_DIFFERS
:
151 return ("element in 4-Way handshake different from "
152 "(re)association request/probe response/beacon frame");
153 case IEEE80211_REASON_GROUP_CIPHER_INVALID
:
154 return ("invalid group cipher");
155 case IEEE80211_REASON_PAIRWISE_CIPHER_INVALID
:
156 return ("invalid pairwise cipher");
157 case IEEE80211_REASON_AKMP_INVALID
:
158 return ("invalid AKMP");
159 case IEEE80211_REASON_UNSUPP_RSN_IE_VERSION
:
160 return ("unsupported version in RSN IE");
161 case IEEE80211_REASON_INVALID_RSN_IE_CAP
:
162 return ("invalid capabilities in RSN IE");
163 case IEEE80211_REASON_802_1X_AUTH_FAILED
:
164 return ("IEEE 802.1X authentication failed");
165 case IEEE80211_REASON_CIPHER_SUITE_REJECTED
:
166 return ("cipher suite rejected because of the security "
168 case IEEE80211_REASON_UNSPECIFIED_QOS
:
169 return ("unspecified (QoS-related)");
170 case IEEE80211_REASON_INSUFFICIENT_BW
:
171 return ("QoS AP lacks sufficient bandwidth for this QoS STA");
172 case IEEE80211_REASON_TOOMANY_FRAMES
:
173 return ("too many frames need to be acknowledged");
174 case IEEE80211_REASON_OUTSIDE_TXOP
:
175 return ("STA is transmitting outside the limits of its TXOPs");
176 case IEEE80211_REASON_LEAVING_QBSS
:
177 return ("requested from peer STA (the STA is "
178 "resetting/leaving the BSS)");
179 case IEEE80211_REASON_BAD_MECHANISM
:
180 return ("requested from peer STA (it does not want to use "
182 case IEEE80211_REASON_SETUP_NEEDED
:
183 return ("requested from peer STA (setup is required for the "
185 case IEEE80211_REASON_TIMEOUT
:
186 return ("requested from peer STA (timeout)");
187 case IEEE80211_REASON_PEER_LINK_CANCELED
:
188 return ("SME cancels the mesh peering instance (not related "
189 "to the maximum number of peer mesh STAs)");
190 case IEEE80211_REASON_MESH_MAX_PEERS
:
191 return ("maximum number of peer mesh STAs was reached");
192 case IEEE80211_REASON_MESH_CPVIOLATION
:
193 return ("the received information violates the Mesh "
194 "Configuration policy configured in the mesh STA "
196 case IEEE80211_REASON_MESH_CLOSE_RCVD
:
197 return ("the mesh STA has received a Mesh Peering Close "
198 "message requesting to close the mesh peering");
199 case IEEE80211_REASON_MESH_MAX_RETRIES
:
200 return ("the mesh STA has resent dot11MeshMaxRetries Mesh "
201 "Peering Open messages, without receiving a Mesh "
202 "Peering Confirm message");
203 case IEEE80211_REASON_MESH_CONFIRM_TIMEOUT
:
204 return ("the confirmTimer for the mesh peering instance times "
206 case IEEE80211_REASON_MESH_INVALID_GTK
:
207 return ("the mesh STA fails to unwrap the GTK or the values "
208 "in the wrapped contents do not match");
209 case IEEE80211_REASON_MESH_INCONS_PARAMS
:
210 return ("the mesh STA receives inconsistent information about "
211 "the mesh parameters between Mesh Peering Management "
213 case IEEE80211_REASON_MESH_INVALID_SECURITY
:
214 return ("the mesh STA fails the authenticated mesh peering "
215 "exchange because due to failure in selecting "
216 "pairwise/group ciphersuite");
217 case IEEE80211_REASON_MESH_PERR_NO_PROXY
:
218 return ("the mesh STA does not have proxy information for "
219 "this external destination");
220 case IEEE80211_REASON_MESH_PERR_NO_FI
:
221 return ("the mesh STA does not have forwarding information "
222 "for this destination");
223 case IEEE80211_REASON_MESH_PERR_DEST_UNREACH
:
224 return ("the mesh STA determines that the link to the next "
225 "hop of an active path in its forwarding information "
226 "is no longer usable");
227 case IEEE80211_REASON_MESH_MAC_ALRDY_EXISTS_MBSS
:
228 return ("the MAC address of the STA already exists in the "
230 case IEEE80211_REASON_MESH_CHAN_SWITCH_REG
:
231 return ("the mesh STA performs channel switch to meet "
232 "regulatory requirements");
233 case IEEE80211_REASON_MESH_CHAN_SWITCH_UNSPEC
:
234 return ("the mesh STA performs channel switch with "
235 "unspecified reason");
237 return ("reserved/unknown");
241 static void beacon_miss(void *, int);
242 static void beacon_swmiss(void *, int);
243 static void parent_updown(void *, int);
244 static void update_mcast(void *, int);
245 static void update_promisc(void *, int);
246 static void update_channel(void *, int);
247 static void update_chw(void *, int);
248 static void update_wme(void *, int);
249 static void restart_vaps(void *, int);
250 static void ieee80211_newstate_cb(void *, int);
253 null_raw_xmit(struct ieee80211_node
*ni
, struct mbuf
*m
,
254 const struct ieee80211_bpf_params
*params
)
257 ic_printf(ni
->ni_ic
, "missing ic_raw_xmit callback, drop frame\n");
263 ieee80211_proto_attach(struct ieee80211com
*ic
)
267 /* override the 802.3 setting */
268 hdrlen
= ic
->ic_headroom
269 + sizeof(struct ieee80211_qosframe_addr4
)
270 + IEEE80211_WEP_IVLEN
+ IEEE80211_WEP_KIDLEN
271 + IEEE80211_WEP_EXTIVLEN
;
272 /* XXX no way to recalculate on ifdetach */
273 if (ALIGN(hdrlen
) > max_linkhdr
) {
274 /* XXX sanity check... */
275 max_linkhdr
= ALIGN(hdrlen
);
276 max_hdr
= max_linkhdr
+ max_protohdr
;
277 max_datalen
= MHLEN
- max_hdr
;
279 ic
->ic_protmode
= IEEE80211_PROT_CTSONLY
;
281 TASK_INIT(&ic
->ic_parent_task
, 0, parent_updown
, ic
);
282 TASK_INIT(&ic
->ic_mcast_task
, 0, update_mcast
, ic
);
283 TASK_INIT(&ic
->ic_promisc_task
, 0, update_promisc
, ic
);
284 TASK_INIT(&ic
->ic_chan_task
, 0, update_channel
, ic
);
285 TASK_INIT(&ic
->ic_bmiss_task
, 0, beacon_miss
, ic
);
286 TASK_INIT(&ic
->ic_chw_task
, 0, update_chw
, ic
);
287 TASK_INIT(&ic
->ic_wme_task
, 0, update_wme
, ic
);
288 TASK_INIT(&ic
->ic_restart_task
, 0, restart_vaps
, ic
);
290 ic
->ic_wme
.wme_hipri_switch_hysteresis
=
291 AGGRESSIVE_MODE_SWITCH_HYSTERESIS
;
293 /* initialize management frame handlers */
294 ic
->ic_send_mgmt
= ieee80211_send_mgmt
;
295 ic
->ic_raw_xmit
= null_raw_xmit
;
297 ieee80211_adhoc_attach(ic
);
298 ieee80211_sta_attach(ic
);
299 ieee80211_wds_attach(ic
);
300 ieee80211_hostap_attach(ic
);
301 #ifdef IEEE80211_SUPPORT_MESH
302 ieee80211_mesh_attach(ic
);
304 ieee80211_monitor_attach(ic
);
308 ieee80211_proto_detach(struct ieee80211com
*ic
)
310 ieee80211_monitor_detach(ic
);
311 #ifdef IEEE80211_SUPPORT_MESH
312 ieee80211_mesh_detach(ic
);
314 ieee80211_hostap_detach(ic
);
315 ieee80211_wds_detach(ic
);
316 ieee80211_adhoc_detach(ic
);
317 ieee80211_sta_detach(ic
);
321 null_update_beacon(struct ieee80211vap
*vap
, int item
)
326 ieee80211_proto_vattach(struct ieee80211vap
*vap
)
328 struct ieee80211com
*ic
= vap
->iv_ic
;
329 struct ifnet
*ifp
= vap
->iv_ifp
;
332 /* override the 802.3 setting */
333 ifp
->if_hdrlen
= ic
->ic_headroom
334 + sizeof(struct ieee80211_qosframe_addr4
)
335 + IEEE80211_WEP_IVLEN
+ IEEE80211_WEP_KIDLEN
336 + IEEE80211_WEP_EXTIVLEN
;
338 vap
->iv_rtsthreshold
= IEEE80211_RTS_DEFAULT
;
339 vap
->iv_fragthreshold
= IEEE80211_FRAG_DEFAULT
;
340 vap
->iv_bmiss_max
= IEEE80211_BMISS_MAX
;
341 callout_init_mtx(&vap
->iv_swbmiss
, IEEE80211_LOCK_OBJ(ic
), 0);
342 #if defined(__DragonFly__)
343 callout_init_mp(&vap
->iv_mgtsend
);
345 callout_init(&vap
->iv_mgtsend
, 1);
347 TASK_INIT(&vap
->iv_nstate_task
, 0, ieee80211_newstate_cb
, vap
);
348 TASK_INIT(&vap
->iv_swbmiss_task
, 0, beacon_swmiss
, vap
);
350 * Install default tx rate handling: no fixed rate, lowest
351 * supported rate for mgmt and multicast frames. Default
352 * max retry count. These settings can be changed by the
353 * driver and/or user applications.
355 for (i
= IEEE80211_MODE_11A
; i
< IEEE80211_MODE_MAX
; i
++) {
356 const struct ieee80211_rateset
*rs
= &ic
->ic_sup_rates
[i
];
358 vap
->iv_txparms
[i
].ucastrate
= IEEE80211_FIXED_RATE_NONE
;
361 * Setting the management rate to MCS 0 assumes that the
362 * BSS Basic rate set is empty and the BSS Basic MCS set
365 * Since we're not checking this, default to the lowest
366 * defined rate for this mode.
368 * At least one 11n AP (DLINK DIR-825) is reported to drop
369 * some MCS management traffic (eg BA response frames.)
371 * See also: 9.6.0 of the 802.11n-2009 specification.
374 if (i
== IEEE80211_MODE_11NA
|| i
== IEEE80211_MODE_11NG
) {
375 vap
->iv_txparms
[i
].mgmtrate
= 0 | IEEE80211_RATE_MCS
;
376 vap
->iv_txparms
[i
].mcastrate
= 0 | IEEE80211_RATE_MCS
;
378 vap
->iv_txparms
[i
].mgmtrate
=
379 rs
->rs_rates
[0] & IEEE80211_RATE_VAL
;
380 vap
->iv_txparms
[i
].mcastrate
=
381 rs
->rs_rates
[0] & IEEE80211_RATE_VAL
;
384 vap
->iv_txparms
[i
].mgmtrate
= rs
->rs_rates
[0] & IEEE80211_RATE_VAL
;
385 vap
->iv_txparms
[i
].mcastrate
= rs
->rs_rates
[0] & IEEE80211_RATE_VAL
;
386 vap
->iv_txparms
[i
].maxretry
= IEEE80211_TXMAX_DEFAULT
;
388 vap
->iv_roaming
= IEEE80211_ROAMING_AUTO
;
390 vap
->iv_update_beacon
= null_update_beacon
;
391 vap
->iv_deliver_data
= ieee80211_deliver_data
;
393 /* attach support for operating mode */
394 ic
->ic_vattach
[vap
->iv_opmode
](vap
);
398 ieee80211_proto_vdetach(struct ieee80211vap
*vap
)
400 #define FREEAPPIE(ie) do { \
402 IEEE80211_FREE(ie, M_80211_NODE_IE); \
405 * Detach operating mode module.
407 if (vap
->iv_opdetach
!= NULL
)
408 vap
->iv_opdetach(vap
);
410 * This should not be needed as we detach when reseting
411 * the state but be conservative here since the
412 * authenticator may do things like spawn kernel threads.
414 if (vap
->iv_auth
->ia_detach
!= NULL
)
415 vap
->iv_auth
->ia_detach(vap
);
417 * Detach any ACL'ator.
419 if (vap
->iv_acl
!= NULL
)
420 vap
->iv_acl
->iac_detach(vap
);
422 FREEAPPIE(vap
->iv_appie_beacon
);
423 FREEAPPIE(vap
->iv_appie_probereq
);
424 FREEAPPIE(vap
->iv_appie_proberesp
);
425 FREEAPPIE(vap
->iv_appie_assocreq
);
426 FREEAPPIE(vap
->iv_appie_assocresp
);
427 FREEAPPIE(vap
->iv_appie_wpa
);
432 * Simple-minded authenticator module support.
435 #define IEEE80211_AUTH_MAX (IEEE80211_AUTH_WPA+1)
436 /* XXX well-known names */
437 static const char *auth_modnames
[IEEE80211_AUTH_MAX
] = {
438 "wlan_internal", /* IEEE80211_AUTH_NONE */
439 "wlan_internal", /* IEEE80211_AUTH_OPEN */
440 "wlan_internal", /* IEEE80211_AUTH_SHARED */
441 "wlan_xauth", /* IEEE80211_AUTH_8021X */
442 "wlan_internal", /* IEEE80211_AUTH_AUTO */
443 "wlan_xauth", /* IEEE80211_AUTH_WPA */
445 static const struct ieee80211_authenticator
*authenticators
[IEEE80211_AUTH_MAX
];
447 static const struct ieee80211_authenticator auth_internal
= {
448 .ia_name
= "wlan_internal",
451 .ia_node_join
= NULL
,
452 .ia_node_leave
= NULL
,
456 * Setup internal authenticators once; they are never unregistered.
459 ieee80211_auth_setup(void)
461 ieee80211_authenticator_register(IEEE80211_AUTH_OPEN
, &auth_internal
);
462 ieee80211_authenticator_register(IEEE80211_AUTH_SHARED
, &auth_internal
);
463 ieee80211_authenticator_register(IEEE80211_AUTH_AUTO
, &auth_internal
);
465 SYSINIT(wlan_auth
, SI_SUB_DRIVERS
, SI_ORDER_FIRST
, ieee80211_auth_setup
, NULL
);
467 const struct ieee80211_authenticator
*
468 ieee80211_authenticator_get(int auth
)
470 if (auth
>= IEEE80211_AUTH_MAX
)
472 if (authenticators
[auth
] == NULL
)
473 ieee80211_load_module(auth_modnames
[auth
]);
474 return authenticators
[auth
];
478 ieee80211_authenticator_register(int type
,
479 const struct ieee80211_authenticator
*auth
)
481 if (type
>= IEEE80211_AUTH_MAX
)
483 authenticators
[type
] = auth
;
487 ieee80211_authenticator_unregister(int type
)
490 if (type
>= IEEE80211_AUTH_MAX
)
492 authenticators
[type
] = NULL
;
496 * Very simple-minded ACL module support.
498 /* XXX just one for now */
499 static const struct ieee80211_aclator
*acl
= NULL
;
502 ieee80211_aclator_register(const struct ieee80211_aclator
*iac
)
504 kprintf("wlan: %s acl policy registered\n", iac
->iac_name
);
509 ieee80211_aclator_unregister(const struct ieee80211_aclator
*iac
)
513 kprintf("wlan: %s acl policy unregistered\n", iac
->iac_name
);
516 const struct ieee80211_aclator
*
517 ieee80211_aclator_get(const char *name
)
520 ieee80211_load_module("wlan_acl");
521 return acl
!= NULL
&& strcmp(acl
->iac_name
, name
) == 0 ? acl
: NULL
;
525 ieee80211_print_essid(const uint8_t *essid
, int len
)
530 if (len
> IEEE80211_NWID_LEN
)
531 len
= IEEE80211_NWID_LEN
;
532 /* determine printable or not */
533 for (i
= 0, p
= essid
; i
< len
; i
++, p
++) {
534 if (*p
< ' ' || *p
> 0x7e)
539 for (i
= 0, p
= essid
; i
< len
; i
++, p
++)
544 for (i
= 0, p
= essid
; i
< len
; i
++, p
++)
550 ieee80211_dump_pkt(struct ieee80211com
*ic
,
551 const uint8_t *buf
, int len
, int rate
, int rssi
)
553 const struct ieee80211_frame
*wh
;
556 wh
= (const struct ieee80211_frame
*)buf
;
557 switch (wh
->i_fc
[1] & IEEE80211_FC1_DIR_MASK
) {
558 case IEEE80211_FC1_DIR_NODS
:
559 kprintf("NODS %s", ether_sprintf(wh
->i_addr2
));
560 kprintf("->%s", ether_sprintf(wh
->i_addr1
));
561 kprintf("(%s)", ether_sprintf(wh
->i_addr3
));
563 case IEEE80211_FC1_DIR_TODS
:
564 kprintf("TODS %s", ether_sprintf(wh
->i_addr2
));
565 kprintf("->%s", ether_sprintf(wh
->i_addr3
));
566 kprintf("(%s)", ether_sprintf(wh
->i_addr1
));
568 case IEEE80211_FC1_DIR_FROMDS
:
569 kprintf("FRDS %s", ether_sprintf(wh
->i_addr3
));
570 kprintf("->%s", ether_sprintf(wh
->i_addr1
));
571 kprintf("(%s)", ether_sprintf(wh
->i_addr2
));
573 case IEEE80211_FC1_DIR_DSTODS
:
574 kprintf("DSDS %s", ether_sprintf((const uint8_t *)&wh
[1]));
575 kprintf("->%s", ether_sprintf(wh
->i_addr3
));
576 kprintf("(%s", ether_sprintf(wh
->i_addr2
));
577 kprintf("->%s)", ether_sprintf(wh
->i_addr1
));
580 switch (wh
->i_fc
[0] & IEEE80211_FC0_TYPE_MASK
) {
581 case IEEE80211_FC0_TYPE_DATA
:
584 case IEEE80211_FC0_TYPE_MGT
:
585 kprintf(" %s", ieee80211_mgt_subtype_name(wh
->i_fc
[0]));
588 kprintf(" type#%d", wh
->i_fc
[0] & IEEE80211_FC0_TYPE_MASK
);
591 if (IEEE80211_QOS_HAS_SEQ(wh
)) {
592 const struct ieee80211_qosframe
*qwh
=
593 (const struct ieee80211_qosframe
*)buf
;
594 kprintf(" QoS [TID %u%s]", qwh
->i_qos
[0] & IEEE80211_QOS_TID
,
595 qwh
->i_qos
[0] & IEEE80211_QOS_ACKPOLICY
? " ACM" : "");
597 if (wh
->i_fc
[1] & IEEE80211_FC1_PROTECTED
) {
600 off
= ieee80211_anyhdrspace(ic
, wh
);
601 kprintf(" WEP [IV %.02x %.02x %.02x",
602 buf
[off
+0], buf
[off
+1], buf
[off
+2]);
603 if (buf
[off
+IEEE80211_WEP_IVLEN
] & IEEE80211_WEP_EXTIV
)
604 kprintf(" %.02x %.02x %.02x",
605 buf
[off
+4], buf
[off
+5], buf
[off
+6]);
606 kprintf(" KID %u]", buf
[off
+IEEE80211_WEP_IVLEN
] >> 6);
609 kprintf(" %dM", rate
/ 2);
611 kprintf(" +%d", rssi
);
614 for (i
= 0; i
< len
; i
++) {
617 kprintf("%02x", buf
[i
]);
624 findrix(const struct ieee80211_rateset
*rs
, int r
)
628 for (i
= 0; i
< rs
->rs_nrates
; i
++)
629 if ((rs
->rs_rates
[i
] & IEEE80211_RATE_VAL
) == r
)
635 ieee80211_fix_rate(struct ieee80211_node
*ni
,
636 struct ieee80211_rateset
*nrs
, int flags
)
638 struct ieee80211vap
*vap
= ni
->ni_vap
;
639 struct ieee80211com
*ic
= ni
->ni_ic
;
640 int i
, j
, rix
, error
;
641 int okrate
, badrate
, fixedrate
, ucastrate
;
642 const struct ieee80211_rateset
*srs
;
646 okrate
= badrate
= 0;
647 ucastrate
= vap
->iv_txparms
[ieee80211_chan2mode(ni
->ni_chan
)].ucastrate
;
648 if (ucastrate
!= IEEE80211_FIXED_RATE_NONE
) {
650 * Workaround awkwardness with fixed rate. We are called
651 * to check both the legacy rate set and the HT rate set
652 * but we must apply any legacy fixed rate check only to the
653 * legacy rate set and vice versa. We cannot tell what type
654 * of rate set we've been given (legacy or HT) but we can
655 * distinguish the fixed rate type (MCS have 0x80 set).
656 * So to deal with this the caller communicates whether to
657 * check MCS or legacy rate using the flags and we use the
658 * type of any fixed rate to avoid applying an MCS to a
659 * legacy rate and vice versa.
661 if (ucastrate
& 0x80) {
662 if (flags
& IEEE80211_F_DOFRATE
)
663 flags
&= ~IEEE80211_F_DOFRATE
;
664 } else if ((ucastrate
& 0x80) == 0) {
665 if (flags
& IEEE80211_F_DOFMCS
)
666 flags
&= ~IEEE80211_F_DOFMCS
;
668 /* NB: required to make MCS match below work */
669 ucastrate
&= IEEE80211_RATE_VAL
;
671 fixedrate
= IEEE80211_FIXED_RATE_NONE
;
673 * XXX we are called to process both MCS and legacy rates;
674 * we must use the appropriate basic rate set or chaos will
675 * ensue; for now callers that want MCS must supply
676 * IEEE80211_F_DOBRS; at some point we'll need to split this
677 * function so there are two variants, one for MCS and one
680 if (flags
& IEEE80211_F_DOBRS
)
681 srs
= (const struct ieee80211_rateset
*)
682 ieee80211_get_suphtrates(ic
, ni
->ni_chan
);
684 srs
= ieee80211_get_suprates(ic
, ni
->ni_chan
);
685 for (i
= 0; i
< nrs
->rs_nrates
; ) {
686 if (flags
& IEEE80211_F_DOSORT
) {
690 for (j
= i
+ 1; j
< nrs
->rs_nrates
; j
++) {
691 if (IEEE80211_RV(nrs
->rs_rates
[i
]) >
692 IEEE80211_RV(nrs
->rs_rates
[j
])) {
693 r
= nrs
->rs_rates
[i
];
694 nrs
->rs_rates
[i
] = nrs
->rs_rates
[j
];
695 nrs
->rs_rates
[j
] = r
;
699 r
= nrs
->rs_rates
[i
] & IEEE80211_RATE_VAL
;
702 * Check for fixed rate.
707 * Check against supported rates.
709 rix
= findrix(srs
, r
);
710 if (flags
& IEEE80211_F_DONEGO
) {
713 * A rate in the node's rate set is not
714 * supported. If this is a basic rate and we
715 * are operating as a STA then this is an error.
716 * Otherwise we just discard/ignore the rate.
718 if ((flags
& IEEE80211_F_JOIN
) &&
719 (nrs
->rs_rates
[i
] & IEEE80211_RATE_BASIC
))
721 } else if ((flags
& IEEE80211_F_JOIN
) == 0) {
723 * Overwrite with the supported rate
724 * value so any basic rate bit is set.
726 nrs
->rs_rates
[i
] = srs
->rs_rates
[rix
];
729 if ((flags
& IEEE80211_F_DODEL
) && rix
< 0) {
731 * Delete unacceptable rates.
734 for (j
= i
; j
< nrs
->rs_nrates
; j
++)
735 nrs
->rs_rates
[j
] = nrs
->rs_rates
[j
+ 1];
736 nrs
->rs_rates
[j
] = 0;
740 okrate
= nrs
->rs_rates
[i
];
743 if (okrate
== 0 || error
!= 0 ||
744 ((flags
& (IEEE80211_F_DOFRATE
|IEEE80211_F_DOFMCS
)) &&
745 fixedrate
!= ucastrate
)) {
746 IEEE80211_NOTE(vap
, IEEE80211_MSG_XRATE
| IEEE80211_MSG_11N
, ni
,
747 "%s: flags 0x%x okrate %d error %d fixedrate 0x%x "
748 "ucastrate %x\n", __func__
, flags
, okrate
, error
,
749 fixedrate
, ucastrate
);
750 return badrate
| IEEE80211_RATE_BASIC
;
752 return IEEE80211_RV(okrate
);
756 * Reset 11g-related state.
759 ieee80211_reset_erp(struct ieee80211com
*ic
)
761 ic
->ic_flags
&= ~IEEE80211_F_USEPROT
;
762 ic
->ic_nonerpsta
= 0;
763 ic
->ic_longslotsta
= 0;
765 * Short slot time is enabled only when operating in 11g
766 * and not in an IBSS. We must also honor whether or not
767 * the driver is capable of doing it.
769 ieee80211_set_shortslottime(ic
,
770 IEEE80211_IS_CHAN_A(ic
->ic_curchan
) ||
771 IEEE80211_IS_CHAN_HT(ic
->ic_curchan
) ||
772 (IEEE80211_IS_CHAN_ANYG(ic
->ic_curchan
) &&
773 ic
->ic_opmode
== IEEE80211_M_HOSTAP
&&
774 (ic
->ic_caps
& IEEE80211_C_SHSLOT
)));
776 * Set short preamble and ERP barker-preamble flags.
778 if (IEEE80211_IS_CHAN_A(ic
->ic_curchan
) ||
779 (ic
->ic_caps
& IEEE80211_C_SHPREAMBLE
)) {
780 ic
->ic_flags
|= IEEE80211_F_SHPREAMBLE
;
781 ic
->ic_flags
&= ~IEEE80211_F_USEBARKER
;
783 ic
->ic_flags
&= ~IEEE80211_F_SHPREAMBLE
;
784 ic
->ic_flags
|= IEEE80211_F_USEBARKER
;
789 * Set the short slot time state and notify the driver.
792 ieee80211_set_shortslottime(struct ieee80211com
*ic
, int onoff
)
795 ic
->ic_flags
|= IEEE80211_F_SHSLOT
;
797 ic
->ic_flags
&= ~IEEE80211_F_SHSLOT
;
799 if (ic
->ic_updateslot
!= NULL
)
800 ic
->ic_updateslot(ic
);
804 * Check if the specified rate set supports ERP.
805 * NB: the rate set is assumed to be sorted.
808 ieee80211_iserp_rateset(const struct ieee80211_rateset
*rs
)
810 static const int rates
[] = { 2, 4, 11, 22, 12, 24, 48 };
813 if (rs
->rs_nrates
< nitems(rates
))
815 for (i
= 0; i
< nitems(rates
); i
++) {
816 for (j
= 0; j
< rs
->rs_nrates
; j
++) {
817 int r
= rs
->rs_rates
[j
] & IEEE80211_RATE_VAL
;
831 * Mark the basic rates for the rate table based on the
832 * operating mode. For real 11g we mark all the 11b rates
833 * and 6, 12, and 24 OFDM. For 11b compatibility we mark only
834 * 11b rates. There's also a pseudo 11a-mode used to mark only
835 * the basic OFDM rates.
838 setbasicrates(struct ieee80211_rateset
*rs
,
839 enum ieee80211_phymode mode
, int add
)
841 static const struct ieee80211_rateset basic
[IEEE80211_MODE_MAX
] = {
842 [IEEE80211_MODE_11A
] = { 3, { 12, 24, 48 } },
843 [IEEE80211_MODE_11B
] = { 2, { 2, 4 } },
845 [IEEE80211_MODE_11G
] = { 4, { 2, 4, 11, 22 } },
846 [IEEE80211_MODE_TURBO_A
] = { 3, { 12, 24, 48 } },
847 [IEEE80211_MODE_TURBO_G
] = { 4, { 2, 4, 11, 22 } },
848 [IEEE80211_MODE_STURBO_A
] = { 3, { 12, 24, 48 } },
849 [IEEE80211_MODE_HALF
] = { 3, { 6, 12, 24 } },
850 [IEEE80211_MODE_QUARTER
] = { 3, { 3, 6, 12 } },
851 [IEEE80211_MODE_11NA
] = { 3, { 12, 24, 48 } },
853 [IEEE80211_MODE_11NG
] = { 4, { 2, 4, 11, 22 } },
857 for (i
= 0; i
< rs
->rs_nrates
; i
++) {
859 rs
->rs_rates
[i
] &= IEEE80211_RATE_VAL
;
860 for (j
= 0; j
< basic
[mode
].rs_nrates
; j
++)
861 if (basic
[mode
].rs_rates
[j
] == rs
->rs_rates
[i
]) {
862 rs
->rs_rates
[i
] |= IEEE80211_RATE_BASIC
;
869 * Set the basic rates in a rate set.
872 ieee80211_setbasicrates(struct ieee80211_rateset
*rs
,
873 enum ieee80211_phymode mode
)
875 setbasicrates(rs
, mode
, 0);
879 * Add basic rates to a rate set.
882 ieee80211_addbasicrates(struct ieee80211_rateset
*rs
,
883 enum ieee80211_phymode mode
)
885 setbasicrates(rs
, mode
, 1);
889 * WME protocol support.
891 * The default 11a/b/g/n parameters come from the WiFi Alliance WMM
892 * System Interopability Test Plan (v1.4, Appendix F) and the 802.11n
893 * Draft 2.0 Test Plan (Appendix D).
895 * Static/Dynamic Turbo mode settings come from Atheros.
897 typedef struct phyParamType
{
905 static const struct phyParamType phyParamForAC_BE
[IEEE80211_MODE_MAX
] = {
906 [IEEE80211_MODE_AUTO
] = { 3, 4, 6, 0, 0 },
907 [IEEE80211_MODE_11A
] = { 3, 4, 6, 0, 0 },
908 [IEEE80211_MODE_11B
] = { 3, 4, 6, 0, 0 },
909 [IEEE80211_MODE_11G
] = { 3, 4, 6, 0, 0 },
910 [IEEE80211_MODE_FH
] = { 3, 4, 6, 0, 0 },
911 [IEEE80211_MODE_TURBO_A
]= { 2, 3, 5, 0, 0 },
912 [IEEE80211_MODE_TURBO_G
]= { 2, 3, 5, 0, 0 },
913 [IEEE80211_MODE_STURBO_A
]={ 2, 3, 5, 0, 0 },
914 [IEEE80211_MODE_HALF
] = { 3, 4, 6, 0, 0 },
915 [IEEE80211_MODE_QUARTER
]= { 3, 4, 6, 0, 0 },
916 [IEEE80211_MODE_11NA
] = { 3, 4, 6, 0, 0 },
917 [IEEE80211_MODE_11NG
] = { 3, 4, 6, 0, 0 },
919 static const struct phyParamType phyParamForAC_BK
[IEEE80211_MODE_MAX
] = {
920 [IEEE80211_MODE_AUTO
] = { 7, 4, 10, 0, 0 },
921 [IEEE80211_MODE_11A
] = { 7, 4, 10, 0, 0 },
922 [IEEE80211_MODE_11B
] = { 7, 4, 10, 0, 0 },
923 [IEEE80211_MODE_11G
] = { 7, 4, 10, 0, 0 },
924 [IEEE80211_MODE_FH
] = { 7, 4, 10, 0, 0 },
925 [IEEE80211_MODE_TURBO_A
]= { 7, 3, 10, 0, 0 },
926 [IEEE80211_MODE_TURBO_G
]= { 7, 3, 10, 0, 0 },
927 [IEEE80211_MODE_STURBO_A
]={ 7, 3, 10, 0, 0 },
928 [IEEE80211_MODE_HALF
] = { 7, 4, 10, 0, 0 },
929 [IEEE80211_MODE_QUARTER
]= { 7, 4, 10, 0, 0 },
930 [IEEE80211_MODE_11NA
] = { 7, 4, 10, 0, 0 },
931 [IEEE80211_MODE_11NG
] = { 7, 4, 10, 0, 0 },
933 static const struct phyParamType phyParamForAC_VI
[IEEE80211_MODE_MAX
] = {
934 [IEEE80211_MODE_AUTO
] = { 1, 3, 4, 94, 0 },
935 [IEEE80211_MODE_11A
] = { 1, 3, 4, 94, 0 },
936 [IEEE80211_MODE_11B
] = { 1, 3, 4, 188, 0 },
937 [IEEE80211_MODE_11G
] = { 1, 3, 4, 94, 0 },
938 [IEEE80211_MODE_FH
] = { 1, 3, 4, 188, 0 },
939 [IEEE80211_MODE_TURBO_A
]= { 1, 2, 3, 94, 0 },
940 [IEEE80211_MODE_TURBO_G
]= { 1, 2, 3, 94, 0 },
941 [IEEE80211_MODE_STURBO_A
]={ 1, 2, 3, 94, 0 },
942 [IEEE80211_MODE_HALF
] = { 1, 3, 4, 94, 0 },
943 [IEEE80211_MODE_QUARTER
]= { 1, 3, 4, 94, 0 },
944 [IEEE80211_MODE_11NA
] = { 1, 3, 4, 94, 0 },
945 [IEEE80211_MODE_11NG
] = { 1, 3, 4, 94, 0 },
947 static const struct phyParamType phyParamForAC_VO
[IEEE80211_MODE_MAX
] = {
948 [IEEE80211_MODE_AUTO
] = { 1, 2, 3, 47, 0 },
949 [IEEE80211_MODE_11A
] = { 1, 2, 3, 47, 0 },
950 [IEEE80211_MODE_11B
] = { 1, 2, 3, 102, 0 },
951 [IEEE80211_MODE_11G
] = { 1, 2, 3, 47, 0 },
952 [IEEE80211_MODE_FH
] = { 1, 2, 3, 102, 0 },
953 [IEEE80211_MODE_TURBO_A
]= { 1, 2, 2, 47, 0 },
954 [IEEE80211_MODE_TURBO_G
]= { 1, 2, 2, 47, 0 },
955 [IEEE80211_MODE_STURBO_A
]={ 1, 2, 2, 47, 0 },
956 [IEEE80211_MODE_HALF
] = { 1, 2, 3, 47, 0 },
957 [IEEE80211_MODE_QUARTER
]= { 1, 2, 3, 47, 0 },
958 [IEEE80211_MODE_11NA
] = { 1, 2, 3, 47, 0 },
959 [IEEE80211_MODE_11NG
] = { 1, 2, 3, 47, 0 },
962 static const struct phyParamType bssPhyParamForAC_BE
[IEEE80211_MODE_MAX
] = {
963 [IEEE80211_MODE_AUTO
] = { 3, 4, 10, 0, 0 },
964 [IEEE80211_MODE_11A
] = { 3, 4, 10, 0, 0 },
965 [IEEE80211_MODE_11B
] = { 3, 4, 10, 0, 0 },
966 [IEEE80211_MODE_11G
] = { 3, 4, 10, 0, 0 },
967 [IEEE80211_MODE_FH
] = { 3, 4, 10, 0, 0 },
968 [IEEE80211_MODE_TURBO_A
]= { 2, 3, 10, 0, 0 },
969 [IEEE80211_MODE_TURBO_G
]= { 2, 3, 10, 0, 0 },
970 [IEEE80211_MODE_STURBO_A
]={ 2, 3, 10, 0, 0 },
971 [IEEE80211_MODE_HALF
] = { 3, 4, 10, 0, 0 },
972 [IEEE80211_MODE_QUARTER
]= { 3, 4, 10, 0, 0 },
973 [IEEE80211_MODE_11NA
] = { 3, 4, 10, 0, 0 },
974 [IEEE80211_MODE_11NG
] = { 3, 4, 10, 0, 0 },
976 static const struct phyParamType bssPhyParamForAC_VI
[IEEE80211_MODE_MAX
] = {
977 [IEEE80211_MODE_AUTO
] = { 2, 3, 4, 94, 0 },
978 [IEEE80211_MODE_11A
] = { 2, 3, 4, 94, 0 },
979 [IEEE80211_MODE_11B
] = { 2, 3, 4, 188, 0 },
980 [IEEE80211_MODE_11G
] = { 2, 3, 4, 94, 0 },
981 [IEEE80211_MODE_FH
] = { 2, 3, 4, 188, 0 },
982 [IEEE80211_MODE_TURBO_A
]= { 2, 2, 3, 94, 0 },
983 [IEEE80211_MODE_TURBO_G
]= { 2, 2, 3, 94, 0 },
984 [IEEE80211_MODE_STURBO_A
]={ 2, 2, 3, 94, 0 },
985 [IEEE80211_MODE_HALF
] = { 2, 3, 4, 94, 0 },
986 [IEEE80211_MODE_QUARTER
]= { 2, 3, 4, 94, 0 },
987 [IEEE80211_MODE_11NA
] = { 2, 3, 4, 94, 0 },
988 [IEEE80211_MODE_11NG
] = { 2, 3, 4, 94, 0 },
990 static const struct phyParamType bssPhyParamForAC_VO
[IEEE80211_MODE_MAX
] = {
991 [IEEE80211_MODE_AUTO
] = { 2, 2, 3, 47, 0 },
992 [IEEE80211_MODE_11A
] = { 2, 2, 3, 47, 0 },
993 [IEEE80211_MODE_11B
] = { 2, 2, 3, 102, 0 },
994 [IEEE80211_MODE_11G
] = { 2, 2, 3, 47, 0 },
995 [IEEE80211_MODE_FH
] = { 2, 2, 3, 102, 0 },
996 [IEEE80211_MODE_TURBO_A
]= { 1, 2, 2, 47, 0 },
997 [IEEE80211_MODE_TURBO_G
]= { 1, 2, 2, 47, 0 },
998 [IEEE80211_MODE_STURBO_A
]={ 1, 2, 2, 47, 0 },
999 [IEEE80211_MODE_HALF
] = { 2, 2, 3, 47, 0 },
1000 [IEEE80211_MODE_QUARTER
]= { 2, 2, 3, 47, 0 },
1001 [IEEE80211_MODE_11NA
] = { 2, 2, 3, 47, 0 },
1002 [IEEE80211_MODE_11NG
] = { 2, 2, 3, 47, 0 },
1006 _setifsparams(struct wmeParams
*wmep
, const paramType
*phy
)
1008 wmep
->wmep_aifsn
= phy
->aifsn
;
1009 wmep
->wmep_logcwmin
= phy
->logcwmin
;
1010 wmep
->wmep_logcwmax
= phy
->logcwmax
;
1011 wmep
->wmep_txopLimit
= phy
->txopLimit
;
1015 setwmeparams(struct ieee80211vap
*vap
, const char *type
, int ac
,
1016 struct wmeParams
*wmep
, const paramType
*phy
)
1018 wmep
->wmep_acm
= phy
->acm
;
1019 _setifsparams(wmep
, phy
);
1021 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_WME
,
1022 "set %s (%s) [acm %u aifsn %u logcwmin %u logcwmax %u txop %u]\n",
1023 ieee80211_wme_acnames
[ac
], type
,
1024 wmep
->wmep_acm
, wmep
->wmep_aifsn
, wmep
->wmep_logcwmin
,
1025 wmep
->wmep_logcwmax
, wmep
->wmep_txopLimit
);
1029 ieee80211_wme_initparams_locked(struct ieee80211vap
*vap
)
1031 struct ieee80211com
*ic
= vap
->iv_ic
;
1032 struct ieee80211_wme_state
*wme
= &ic
->ic_wme
;
1033 const paramType
*pPhyParam
, *pBssPhyParam
;
1034 struct wmeParams
*wmep
;
1035 enum ieee80211_phymode mode
;
1038 IEEE80211_LOCK_ASSERT(ic
);
1040 if ((ic
->ic_caps
& IEEE80211_C_WME
) == 0 || ic
->ic_nrunning
> 1)
1044 * Clear the wme cap_info field so a qoscount from a previous
1045 * vap doesn't confuse later code which only parses the beacon
1046 * field and updates hardware when said field changes.
1047 * Otherwise the hardware is programmed with defaults, not what
1048 * the beacon actually announces.
1050 wme
->wme_wmeChanParams
.cap_info
= 0;
1053 * Select mode; we can be called early in which case we
1054 * always use auto mode. We know we'll be called when
1055 * entering the RUN state with bsschan setup properly
1056 * so state will eventually get set correctly
1058 if (ic
->ic_bsschan
!= IEEE80211_CHAN_ANYC
)
1059 mode
= ieee80211_chan2mode(ic
->ic_bsschan
);
1061 mode
= IEEE80211_MODE_AUTO
;
1062 for (i
= 0; i
< WME_NUM_AC
; i
++) {
1065 pPhyParam
= &phyParamForAC_BK
[mode
];
1066 pBssPhyParam
= &phyParamForAC_BK
[mode
];
1069 pPhyParam
= &phyParamForAC_VI
[mode
];
1070 pBssPhyParam
= &bssPhyParamForAC_VI
[mode
];
1073 pPhyParam
= &phyParamForAC_VO
[mode
];
1074 pBssPhyParam
= &bssPhyParamForAC_VO
[mode
];
1078 pPhyParam
= &phyParamForAC_BE
[mode
];
1079 pBssPhyParam
= &bssPhyParamForAC_BE
[mode
];
1082 wmep
= &wme
->wme_wmeChanParams
.cap_wmeParams
[i
];
1083 if (ic
->ic_opmode
== IEEE80211_M_HOSTAP
) {
1084 setwmeparams(vap
, "chan", i
, wmep
, pPhyParam
);
1086 setwmeparams(vap
, "chan", i
, wmep
, pBssPhyParam
);
1088 wmep
= &wme
->wme_wmeBssChanParams
.cap_wmeParams
[i
];
1089 setwmeparams(vap
, "bss ", i
, wmep
, pBssPhyParam
);
1091 /* NB: check ic_bss to avoid NULL deref on initial attach */
1092 if (vap
->iv_bss
!= NULL
) {
1094 * Calculate aggressive mode switching threshold based
1095 * on beacon interval. This doesn't need locking since
1096 * we're only called before entering the RUN state at
1097 * which point we start sending beacon frames.
1099 wme
->wme_hipri_switch_thresh
=
1100 (HIGH_PRI_SWITCH_THRESH
* vap
->iv_bss
->ni_intval
) / 100;
1101 wme
->wme_flags
&= ~WME_F_AGGRMODE
;
1102 ieee80211_wme_updateparams(vap
);
1107 ieee80211_wme_initparams(struct ieee80211vap
*vap
)
1109 struct ieee80211com
*ic
= vap
->iv_ic
;
1112 ieee80211_wme_initparams_locked(vap
);
1113 IEEE80211_UNLOCK(ic
);
1117 * Update WME parameters for ourself and the BSS.
1120 ieee80211_wme_updateparams_locked(struct ieee80211vap
*vap
)
1122 static const paramType aggrParam
[IEEE80211_MODE_MAX
] = {
1123 [IEEE80211_MODE_AUTO
] = { 2, 4, 10, 64, 0 },
1124 [IEEE80211_MODE_11A
] = { 2, 4, 10, 64, 0 },
1125 [IEEE80211_MODE_11B
] = { 2, 5, 10, 64, 0 },
1126 [IEEE80211_MODE_11G
] = { 2, 4, 10, 64, 0 },
1127 [IEEE80211_MODE_FH
] = { 2, 5, 10, 64, 0 },
1128 [IEEE80211_MODE_TURBO_A
] = { 1, 3, 10, 64, 0 },
1129 [IEEE80211_MODE_TURBO_G
] = { 1, 3, 10, 64, 0 },
1130 [IEEE80211_MODE_STURBO_A
] = { 1, 3, 10, 64, 0 },
1131 [IEEE80211_MODE_HALF
] = { 2, 4, 10, 64, 0 },
1132 [IEEE80211_MODE_QUARTER
] = { 2, 4, 10, 64, 0 },
1133 [IEEE80211_MODE_11NA
] = { 2, 4, 10, 64, 0 }, /* XXXcheck*/
1134 [IEEE80211_MODE_11NG
] = { 2, 4, 10, 64, 0 }, /* XXXcheck*/
1136 struct ieee80211com
*ic
= vap
->iv_ic
;
1137 struct ieee80211_wme_state
*wme
= &ic
->ic_wme
;
1138 const struct wmeParams
*wmep
;
1139 struct wmeParams
*chanp
, *bssp
;
1140 enum ieee80211_phymode mode
;
1142 int do_aggrmode
= 0;
1145 * Set up the channel access parameters for the physical
1146 * device. First populate the configured settings.
1148 for (i
= 0; i
< WME_NUM_AC
; i
++) {
1149 chanp
= &wme
->wme_chanParams
.cap_wmeParams
[i
];
1150 wmep
= &wme
->wme_wmeChanParams
.cap_wmeParams
[i
];
1151 chanp
->wmep_aifsn
= wmep
->wmep_aifsn
;
1152 chanp
->wmep_logcwmin
= wmep
->wmep_logcwmin
;
1153 chanp
->wmep_logcwmax
= wmep
->wmep_logcwmax
;
1154 chanp
->wmep_txopLimit
= wmep
->wmep_txopLimit
;
1156 chanp
= &wme
->wme_bssChanParams
.cap_wmeParams
[i
];
1157 wmep
= &wme
->wme_wmeBssChanParams
.cap_wmeParams
[i
];
1158 chanp
->wmep_aifsn
= wmep
->wmep_aifsn
;
1159 chanp
->wmep_logcwmin
= wmep
->wmep_logcwmin
;
1160 chanp
->wmep_logcwmax
= wmep
->wmep_logcwmax
;
1161 chanp
->wmep_txopLimit
= wmep
->wmep_txopLimit
;
1165 * Select mode; we can be called early in which case we
1166 * always use auto mode. We know we'll be called when
1167 * entering the RUN state with bsschan setup properly
1168 * so state will eventually get set correctly
1170 if (ic
->ic_bsschan
!= IEEE80211_CHAN_ANYC
)
1171 mode
= ieee80211_chan2mode(ic
->ic_bsschan
);
1173 mode
= IEEE80211_MODE_AUTO
;
1176 * This implements aggressive mode as found in certain
1177 * vendors' AP's. When there is significant high
1178 * priority (VI/VO) traffic in the BSS throttle back BE
1179 * traffic by using conservative parameters. Otherwise
1180 * BE uses aggressive params to optimize performance of
1181 * legacy/non-QoS traffic.
1184 /* Hostap? Only if aggressive mode is enabled */
1185 if (vap
->iv_opmode
== IEEE80211_M_HOSTAP
&&
1186 (wme
->wme_flags
& WME_F_AGGRMODE
) != 0)
1190 * Station? Only if we're in a non-QoS BSS.
1192 else if ((vap
->iv_opmode
== IEEE80211_M_STA
&&
1193 (vap
->iv_bss
->ni_flags
& IEEE80211_NODE_QOS
) == 0))
1197 * IBSS? Only if we we have WME enabled.
1199 else if ((vap
->iv_opmode
== IEEE80211_M_IBSS
) &&
1200 (vap
->iv_flags
& IEEE80211_F_WME
))
1204 * If WME is disabled on this VAP, default to aggressive mode
1205 * regardless of the configuration.
1207 if ((vap
->iv_flags
& IEEE80211_F_WME
) == 0)
1215 chanp
= &wme
->wme_chanParams
.cap_wmeParams
[WME_AC_BE
];
1216 bssp
= &wme
->wme_bssChanParams
.cap_wmeParams
[WME_AC_BE
];
1218 chanp
->wmep_aifsn
= bssp
->wmep_aifsn
= aggrParam
[mode
].aifsn
;
1219 chanp
->wmep_logcwmin
= bssp
->wmep_logcwmin
=
1220 aggrParam
[mode
].logcwmin
;
1221 chanp
->wmep_logcwmax
= bssp
->wmep_logcwmax
=
1222 aggrParam
[mode
].logcwmax
;
1223 chanp
->wmep_txopLimit
= bssp
->wmep_txopLimit
=
1224 (vap
->iv_flags
& IEEE80211_F_BURST
) ?
1225 aggrParam
[mode
].txopLimit
: 0;
1226 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_WME
,
1227 "update %s (chan+bss) [acm %u aifsn %u logcwmin %u "
1228 "logcwmax %u txop %u]\n", ieee80211_wme_acnames
[WME_AC_BE
],
1229 chanp
->wmep_acm
, chanp
->wmep_aifsn
, chanp
->wmep_logcwmin
,
1230 chanp
->wmep_logcwmax
, chanp
->wmep_txopLimit
);
1235 * Change the contention window based on the number of associated
1236 * stations. If the number of associated stations is 1 and
1237 * aggressive mode is enabled, lower the contention window even
1240 if (vap
->iv_opmode
== IEEE80211_M_HOSTAP
&&
1241 ic
->ic_sta_assoc
< 2 && (wme
->wme_flags
& WME_F_AGGRMODE
) != 0) {
1242 static const uint8_t logCwMin
[IEEE80211_MODE_MAX
] = {
1243 [IEEE80211_MODE_AUTO
] = 3,
1244 [IEEE80211_MODE_11A
] = 3,
1245 [IEEE80211_MODE_11B
] = 4,
1246 [IEEE80211_MODE_11G
] = 3,
1247 [IEEE80211_MODE_FH
] = 4,
1248 [IEEE80211_MODE_TURBO_A
] = 3,
1249 [IEEE80211_MODE_TURBO_G
] = 3,
1250 [IEEE80211_MODE_STURBO_A
] = 3,
1251 [IEEE80211_MODE_HALF
] = 3,
1252 [IEEE80211_MODE_QUARTER
] = 3,
1253 [IEEE80211_MODE_11NA
] = 3,
1254 [IEEE80211_MODE_11NG
] = 3,
1256 chanp
= &wme
->wme_chanParams
.cap_wmeParams
[WME_AC_BE
];
1257 bssp
= &wme
->wme_bssChanParams
.cap_wmeParams
[WME_AC_BE
];
1259 chanp
->wmep_logcwmin
= bssp
->wmep_logcwmin
= logCwMin
[mode
];
1260 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_WME
,
1261 "update %s (chan+bss) logcwmin %u\n",
1262 ieee80211_wme_acnames
[WME_AC_BE
], chanp
->wmep_logcwmin
);
1266 * Arrange for the beacon update.
1268 * XXX what about MBSS, WDS?
1270 if (vap
->iv_opmode
== IEEE80211_M_HOSTAP
1271 || vap
->iv_opmode
== IEEE80211_M_IBSS
) {
1273 * Arrange for a beacon update and bump the parameter
1274 * set number so associated stations load the new values.
1276 wme
->wme_bssChanParams
.cap_info
=
1277 (wme
->wme_bssChanParams
.cap_info
+1) & WME_QOSINFO_COUNT
;
1278 ieee80211_beacon_notify(vap
, IEEE80211_BEACON_WME
);
1281 /* schedule the deferred WME update */
1282 ieee80211_runtask(ic
, &ic
->ic_wme_task
);
1284 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_WME
,
1285 "%s: WME params updated, cap_info 0x%x\n", __func__
,
1286 vap
->iv_opmode
== IEEE80211_M_STA
?
1287 wme
->wme_wmeChanParams
.cap_info
:
1288 wme
->wme_bssChanParams
.cap_info
);
1292 ieee80211_wme_updateparams(struct ieee80211vap
*vap
)
1294 struct ieee80211com
*ic
= vap
->iv_ic
;
1296 if (ic
->ic_caps
& IEEE80211_C_WME
) {
1298 ieee80211_wme_updateparams_locked(vap
);
1299 IEEE80211_UNLOCK(ic
);
1304 parent_updown(void *arg
, int npending
)
1306 struct ieee80211com
*ic
= arg
;
1312 update_mcast(void *arg
, int npending
)
1314 struct ieee80211com
*ic
= arg
;
1316 ic
->ic_update_mcast(ic
);
1320 update_promisc(void *arg
, int npending
)
1322 struct ieee80211com
*ic
= arg
;
1324 ic
->ic_update_promisc(ic
);
1328 update_channel(void *arg
, int npending
)
1330 struct ieee80211com
*ic
= arg
;
1332 ic
->ic_set_channel(ic
);
1333 ieee80211_radiotap_chan_change(ic
);
1337 update_chw(void *arg
, int npending
)
1339 struct ieee80211com
*ic
= arg
;
1342 * XXX should we defer the channel width _config_ update until now?
1344 ic
->ic_update_chw(ic
);
1348 update_wme(void *arg
, int npending
)
1350 struct ieee80211com
*ic
= arg
;
1353 * XXX should we defer the WME configuration update until now?
1355 ic
->ic_wme
.wme_update(ic
);
1359 restart_vaps(void *arg
, int npending
)
1361 struct ieee80211com
*ic
= arg
;
1363 ieee80211_suspend_all(ic
);
1364 ieee80211_resume_all(ic
);
1368 * Block until the parent is in a known state. This is
1369 * used after any operations that dispatch a task (e.g.
1370 * to auto-configure the parent device up/down).
1373 ieee80211_waitfor_parent(struct ieee80211com
*ic
)
1375 taskqueue_block(ic
->ic_tq
);
1376 ieee80211_draintask(ic
, &ic
->ic_parent_task
);
1377 ieee80211_draintask(ic
, &ic
->ic_mcast_task
);
1378 ieee80211_draintask(ic
, &ic
->ic_promisc_task
);
1379 ieee80211_draintask(ic
, &ic
->ic_chan_task
);
1380 ieee80211_draintask(ic
, &ic
->ic_bmiss_task
);
1381 ieee80211_draintask(ic
, &ic
->ic_chw_task
);
1382 ieee80211_draintask(ic
, &ic
->ic_wme_task
);
1383 taskqueue_unblock(ic
->ic_tq
);
1387 * Check to see whether the current channel needs reset.
1389 * Some devices don't handle being given an invalid channel
1390 * in their operating mode very well (eg wpi(4) will throw a
1391 * firmware exception.)
1393 * Return 0 if we're ok, 1 if the channel needs to be reset.
1395 * See PR kern/202502.
1398 ieee80211_start_check_reset_chan(struct ieee80211vap
*vap
)
1400 struct ieee80211com
*ic
= vap
->iv_ic
;
1402 if ((vap
->iv_opmode
== IEEE80211_M_IBSS
&&
1403 IEEE80211_IS_CHAN_NOADHOC(ic
->ic_curchan
)) ||
1404 (vap
->iv_opmode
== IEEE80211_M_HOSTAP
&&
1405 IEEE80211_IS_CHAN_NOHOSTAP(ic
->ic_curchan
)))
1411 * Reset the curchan to a known good state.
1414 ieee80211_start_reset_chan(struct ieee80211vap
*vap
)
1416 struct ieee80211com
*ic
= vap
->iv_ic
;
1418 ic
->ic_curchan
= &ic
->ic_channels
[0];
1422 * Start a vap running. If this is the first vap to be
1423 * set running on the underlying device then we
1424 * automatically bring the device up.
1427 ieee80211_start_locked(struct ieee80211vap
*vap
)
1429 struct ifnet
*ifp
= vap
->iv_ifp
;
1430 struct ieee80211com
*ic
= vap
->iv_ic
;
1432 IEEE80211_LOCK_ASSERT(ic
);
1434 IEEE80211_DPRINTF(vap
,
1435 IEEE80211_MSG_STATE
| IEEE80211_MSG_DEBUG
,
1436 "start running, %d vaps running\n", ic
->ic_nrunning
);
1438 if ((ifp
->if_drv_flags
& IFF_DRV_RUNNING
) == 0) {
1440 * Mark us running. Note that it's ok to do this first;
1441 * if we need to bring the parent device up we defer that
1442 * to avoid dropping the com lock. We expect the device
1443 * to respond to being marked up by calling back into us
1444 * through ieee80211_start_all at which point we'll come
1445 * back in here and complete the work.
1447 ifp
->if_drv_flags
|= IFF_DRV_RUNNING
;
1449 * We are not running; if this we are the first vap
1450 * to be brought up auto-up the parent if necessary.
1452 if (ic
->ic_nrunning
++ == 0) {
1454 /* reset the channel to a known good channel */
1455 if (ieee80211_start_check_reset_chan(vap
))
1456 ieee80211_start_reset_chan(vap
);
1458 IEEE80211_DPRINTF(vap
,
1459 IEEE80211_MSG_STATE
| IEEE80211_MSG_DEBUG
,
1460 "%s: up parent %s\n", __func__
, ic
->ic_name
);
1461 ieee80211_runtask(ic
, &ic
->ic_parent_task
);
1466 * If the parent is up and running, then kick the
1467 * 802.11 state machine as appropriate.
1469 if (vap
->iv_roaming
!= IEEE80211_ROAMING_MANUAL
) {
1470 if (vap
->iv_opmode
== IEEE80211_M_STA
) {
1472 /* XXX bypasses scan too easily; disable for now */
1474 * Try to be intelligent about clocking the state
1475 * machine. If we're currently in RUN state then
1476 * we should be able to apply any new state/parameters
1477 * simply by re-associating. Otherwise we need to
1478 * re-scan to select an appropriate ap.
1480 if (vap
->iv_state
>= IEEE80211_S_RUN
)
1481 ieee80211_new_state_locked(vap
,
1482 IEEE80211_S_ASSOC
, 1);
1485 ieee80211_new_state_locked(vap
,
1486 IEEE80211_S_SCAN
, 0);
1489 * For monitor+wds mode there's nothing to do but
1490 * start running. Otherwise if this is the first
1491 * vap to be brought up, start a scan which may be
1492 * preempted if the station is locked to a particular
1495 vap
->iv_flags_ext
|= IEEE80211_FEXT_REINIT
;
1496 if (vap
->iv_opmode
== IEEE80211_M_MONITOR
||
1497 vap
->iv_opmode
== IEEE80211_M_WDS
)
1498 ieee80211_new_state_locked(vap
,
1499 IEEE80211_S_RUN
, -1);
1501 ieee80211_new_state_locked(vap
,
1502 IEEE80211_S_SCAN
, 0);
1508 * Start a single vap.
1511 ieee80211_init(void *arg
)
1513 struct ieee80211vap
*vap
= arg
;
1515 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
| IEEE80211_MSG_DEBUG
,
1518 IEEE80211_LOCK(vap
->iv_ic
);
1519 ieee80211_start_locked(vap
);
1520 IEEE80211_UNLOCK(vap
->iv_ic
);
1524 * Start all runnable vap's on a device.
1527 ieee80211_start_all(struct ieee80211com
*ic
)
1529 struct ieee80211vap
*vap
;
1532 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
) {
1533 struct ifnet
*ifp
= vap
->iv_ifp
;
1534 if (IFNET_IS_UP_RUNNING(ifp
)) /* NB: avoid recursion */
1535 ieee80211_start_locked(vap
);
1537 IEEE80211_UNLOCK(ic
);
1541 * Stop a vap. We force it down using the state machine
1542 * then mark it's ifnet not running. If this is the last
1543 * vap running on the underlying device then we close it
1544 * too to insure it will be properly initialized when the
1545 * next vap is brought up.
1548 ieee80211_stop_locked(struct ieee80211vap
*vap
)
1550 struct ieee80211com
*ic
= vap
->iv_ic
;
1551 struct ifnet
*ifp
= vap
->iv_ifp
;
1553 IEEE80211_LOCK_ASSERT(ic
);
1555 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
| IEEE80211_MSG_DEBUG
,
1556 "stop running, %d vaps running\n", ic
->ic_nrunning
);
1558 ieee80211_new_state_locked(vap
, IEEE80211_S_INIT
, -1);
1559 if (ifp
->if_drv_flags
& IFF_DRV_RUNNING
) {
1560 ifp
->if_drv_flags
&= ~IFF_DRV_RUNNING
; /* mark us stopped */
1561 if (--ic
->ic_nrunning
== 0) {
1562 IEEE80211_DPRINTF(vap
,
1563 IEEE80211_MSG_STATE
| IEEE80211_MSG_DEBUG
,
1564 "down parent %s\n", ic
->ic_name
);
1565 ieee80211_runtask(ic
, &ic
->ic_parent_task
);
1571 ieee80211_stop(struct ieee80211vap
*vap
)
1573 struct ieee80211com
*ic
= vap
->iv_ic
;
1576 ieee80211_stop_locked(vap
);
1577 IEEE80211_UNLOCK(ic
);
1581 * Stop all vap's running on a device.
1584 ieee80211_stop_all(struct ieee80211com
*ic
)
1586 struct ieee80211vap
*vap
;
1589 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
) {
1590 struct ifnet
*ifp
= vap
->iv_ifp
;
1591 if (IFNET_IS_UP_RUNNING(ifp
)) /* NB: avoid recursion */
1592 ieee80211_stop_locked(vap
);
1594 IEEE80211_UNLOCK(ic
);
1596 ieee80211_waitfor_parent(ic
);
1600 * Stop all vap's running on a device and arrange
1601 * for those that were running to be resumed.
1604 ieee80211_suspend_all(struct ieee80211com
*ic
)
1606 struct ieee80211vap
*vap
;
1609 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
) {
1610 struct ifnet
*ifp
= vap
->iv_ifp
;
1611 if (IFNET_IS_UP_RUNNING(ifp
)) { /* NB: avoid recursion */
1612 vap
->iv_flags_ext
|= IEEE80211_FEXT_RESUME
;
1613 ieee80211_stop_locked(vap
);
1616 IEEE80211_UNLOCK(ic
);
1618 ieee80211_waitfor_parent(ic
);
1622 * Start all vap's marked for resume.
1625 ieee80211_resume_all(struct ieee80211com
*ic
)
1627 struct ieee80211vap
*vap
;
1630 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
) {
1631 struct ifnet
*ifp
= vap
->iv_ifp
;
1632 if (!IFNET_IS_UP_RUNNING(ifp
) &&
1633 (vap
->iv_flags_ext
& IEEE80211_FEXT_RESUME
)) {
1634 vap
->iv_flags_ext
&= ~IEEE80211_FEXT_RESUME
;
1635 ieee80211_start_locked(vap
);
1638 IEEE80211_UNLOCK(ic
);
1642 * Restart all vap's running on a device.
1645 ieee80211_restart_all(struct ieee80211com
*ic
)
1648 * NB: do not use ieee80211_runtask here, we will
1649 * block & drain net80211 taskqueue.
1651 #if defined(__DragonFly__)
1652 taskqueue_enqueue(taskqueue_thread
[0], &ic
->ic_restart_task
);
1654 taskqueue_enqueue(taskqueue_thread
, &ic
->ic_restart_task
);
1659 ieee80211_beacon_miss(struct ieee80211com
*ic
)
1662 if ((ic
->ic_flags
& IEEE80211_F_SCAN
) == 0) {
1663 /* Process in a taskq, the handler may reenter the driver */
1664 ieee80211_runtask(ic
, &ic
->ic_bmiss_task
);
1666 IEEE80211_UNLOCK(ic
);
1670 beacon_miss(void *arg
, int npending
)
1672 struct ieee80211com
*ic
= arg
;
1673 struct ieee80211vap
*vap
;
1676 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
) {
1678 * We only pass events through for sta vap's in RUN+ state;
1679 * may be too restrictive but for now this saves all the
1680 * handlers duplicating these checks.
1682 if (vap
->iv_opmode
== IEEE80211_M_STA
&&
1683 vap
->iv_state
>= IEEE80211_S_RUN
&&
1684 vap
->iv_bmiss
!= NULL
)
1687 IEEE80211_UNLOCK(ic
);
1691 beacon_swmiss(void *arg
, int npending
)
1693 struct ieee80211vap
*vap
= arg
;
1694 struct ieee80211com
*ic
= vap
->iv_ic
;
1697 if (vap
->iv_state
>= IEEE80211_S_RUN
) {
1698 /* XXX Call multiple times if npending > zero? */
1701 IEEE80211_UNLOCK(ic
);
1705 * Software beacon miss handling. Check if any beacons
1706 * were received in the last period. If not post a
1707 * beacon miss; otherwise reset the counter.
1710 ieee80211_swbmiss(void *arg
)
1712 struct ieee80211vap
*vap
= arg
;
1713 struct ieee80211com
*ic
= vap
->iv_ic
;
1715 IEEE80211_LOCK_ASSERT(ic
);
1717 KASSERT(vap
->iv_state
>= IEEE80211_S_RUN
,
1718 ("wrong state %d", vap
->iv_state
));
1720 if (ic
->ic_flags
& IEEE80211_F_SCAN
) {
1722 * If scanning just ignore and reset state. If we get a
1723 * bmiss after coming out of scan because we haven't had
1724 * time to receive a beacon then we should probe the AP
1725 * before posting a real bmiss (unless iv_bmiss_max has
1726 * been artifiically lowered). A cleaner solution might
1727 * be to disable the timer on scan start/end but to handle
1728 * case of multiple sta vap's we'd need to disable the
1729 * timers of all affected vap's.
1731 vap
->iv_swbmiss_count
= 0;
1732 } else if (vap
->iv_swbmiss_count
== 0) {
1733 if (vap
->iv_bmiss
!= NULL
)
1734 ieee80211_runtask(ic
, &vap
->iv_swbmiss_task
);
1736 vap
->iv_swbmiss_count
= 0;
1737 callout_reset(&vap
->iv_swbmiss
, vap
->iv_swbmiss_period
,
1738 ieee80211_swbmiss
, vap
);
1742 * Start an 802.11h channel switch. We record the parameters,
1743 * mark the operation pending, notify each vap through the
1744 * beacon update mechanism so it can update the beacon frame
1745 * contents, and then switch vap's to CSA state to block outbound
1746 * traffic. Devices that handle CSA directly can use the state
1747 * switch to do the right thing so long as they call
1748 * ieee80211_csa_completeswitch when it's time to complete the
1749 * channel change. Devices that depend on the net80211 layer can
1750 * use ieee80211_beacon_update to handle the countdown and the
1754 ieee80211_csa_startswitch(struct ieee80211com
*ic
,
1755 struct ieee80211_channel
*c
, int mode
, int count
)
1757 struct ieee80211vap
*vap
;
1759 IEEE80211_LOCK_ASSERT(ic
);
1761 ic
->ic_csa_newchan
= c
;
1762 ic
->ic_csa_mode
= mode
;
1763 ic
->ic_csa_count
= count
;
1764 ic
->ic_flags
|= IEEE80211_F_CSAPENDING
;
1765 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
) {
1766 if (vap
->iv_opmode
== IEEE80211_M_HOSTAP
||
1767 vap
->iv_opmode
== IEEE80211_M_IBSS
||
1768 vap
->iv_opmode
== IEEE80211_M_MBSS
)
1769 ieee80211_beacon_notify(vap
, IEEE80211_BEACON_CSA
);
1770 /* switch to CSA state to block outbound traffic */
1771 if (vap
->iv_state
== IEEE80211_S_RUN
)
1772 ieee80211_new_state_locked(vap
, IEEE80211_S_CSA
, 0);
1774 ieee80211_notify_csa(ic
, c
, mode
, count
);
1778 * Complete the channel switch by transitioning all CSA VAPs to RUN.
1779 * This is called by both the completion and cancellation functions
1780 * so each VAP is placed back in the RUN state and can thus transmit.
1783 csa_completeswitch(struct ieee80211com
*ic
)
1785 struct ieee80211vap
*vap
;
1787 ic
->ic_csa_newchan
= NULL
;
1788 ic
->ic_flags
&= ~IEEE80211_F_CSAPENDING
;
1790 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
)
1791 if (vap
->iv_state
== IEEE80211_S_CSA
)
1792 ieee80211_new_state_locked(vap
, IEEE80211_S_RUN
, 0);
1796 * Complete an 802.11h channel switch started by ieee80211_csa_startswitch.
1797 * We clear state and move all vap's in CSA state to RUN state
1798 * so they can again transmit.
1800 * Although this may not be completely correct, update the BSS channel
1801 * for each VAP to the newly configured channel. The setcurchan sets
1802 * the current operating channel for the interface (so the radio does
1803 * switch over) but the VAP BSS isn't updated, leading to incorrectly
1804 * reported information via ioctl.
1807 ieee80211_csa_completeswitch(struct ieee80211com
*ic
)
1809 struct ieee80211vap
*vap
;
1811 IEEE80211_LOCK_ASSERT(ic
);
1813 KASSERT(ic
->ic_flags
& IEEE80211_F_CSAPENDING
, ("csa not pending"));
1815 ieee80211_setcurchan(ic
, ic
->ic_csa_newchan
);
1816 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
)
1817 if (vap
->iv_state
== IEEE80211_S_CSA
)
1818 vap
->iv_bss
->ni_chan
= ic
->ic_curchan
;
1820 csa_completeswitch(ic
);
1824 * Cancel an 802.11h channel switch started by ieee80211_csa_startswitch.
1825 * We clear state and move all vap's in CSA state to RUN state
1826 * so they can again transmit.
1829 ieee80211_csa_cancelswitch(struct ieee80211com
*ic
)
1831 IEEE80211_LOCK_ASSERT(ic
);
1833 csa_completeswitch(ic
);
1837 * Complete a DFS CAC started by ieee80211_dfs_cac_start.
1838 * We clear state and move all vap's in CAC state to RUN state.
1841 ieee80211_cac_completeswitch(struct ieee80211vap
*vap0
)
1843 struct ieee80211com
*ic
= vap0
->iv_ic
;
1844 struct ieee80211vap
*vap
;
1848 * Complete CAC state change for lead vap first; then
1849 * clock all the other vap's waiting.
1851 KASSERT(vap0
->iv_state
== IEEE80211_S_CAC
,
1852 ("wrong state %d", vap0
->iv_state
));
1853 ieee80211_new_state_locked(vap0
, IEEE80211_S_RUN
, 0);
1855 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
)
1856 if (vap
->iv_state
== IEEE80211_S_CAC
)
1857 ieee80211_new_state_locked(vap
, IEEE80211_S_RUN
, 0);
1858 IEEE80211_UNLOCK(ic
);
1862 * Force all vap's other than the specified vap to the INIT state
1863 * and mark them as waiting for a scan to complete. These vaps
1864 * will be brought up when the scan completes and the scanning vap
1865 * reaches RUN state by wakeupwaiting.
1868 markwaiting(struct ieee80211vap
*vap0
)
1870 struct ieee80211com
*ic
= vap0
->iv_ic
;
1871 struct ieee80211vap
*vap
;
1873 IEEE80211_LOCK_ASSERT(ic
);
1876 * A vap list entry can not disappear since we are running on the
1877 * taskqueue and a vap destroy will queue and drain another state
1880 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
) {
1883 if (vap
->iv_state
!= IEEE80211_S_INIT
) {
1884 /* NB: iv_newstate may drop the lock */
1885 vap
->iv_newstate(vap
, IEEE80211_S_INIT
, 0);
1886 IEEE80211_LOCK_ASSERT(ic
);
1887 vap
->iv_flags_ext
|= IEEE80211_FEXT_SCANWAIT
;
1893 * Wakeup all vap's waiting for a scan to complete. This is the
1894 * companion to markwaiting (above) and is used to coordinate
1895 * multiple vaps scanning.
1896 * This is called from the state taskqueue.
1899 wakeupwaiting(struct ieee80211vap
*vap0
)
1901 struct ieee80211com
*ic
= vap0
->iv_ic
;
1902 struct ieee80211vap
*vap
;
1904 IEEE80211_LOCK_ASSERT(ic
);
1907 * A vap list entry can not disappear since we are running on the
1908 * taskqueue and a vap destroy will queue and drain another state
1911 TAILQ_FOREACH(vap
, &ic
->ic_vaps
, iv_next
) {
1914 if (vap
->iv_flags_ext
& IEEE80211_FEXT_SCANWAIT
) {
1915 vap
->iv_flags_ext
&= ~IEEE80211_FEXT_SCANWAIT
;
1916 /* NB: sta's cannot go INIT->RUN */
1917 /* NB: iv_newstate may drop the lock */
1918 vap
->iv_newstate(vap
,
1919 vap
->iv_opmode
== IEEE80211_M_STA
?
1920 IEEE80211_S_SCAN
: IEEE80211_S_RUN
, 0);
1921 IEEE80211_LOCK_ASSERT(ic
);
1927 * Handle post state change work common to all operating modes.
1930 ieee80211_newstate_cb(void *xvap
, int npending
)
1932 struct ieee80211vap
*vap
= xvap
;
1933 struct ieee80211com
*ic
= vap
->iv_ic
;
1934 enum ieee80211_state nstate
, ostate
;
1938 nstate
= vap
->iv_nstate
;
1939 arg
= vap
->iv_nstate_arg
;
1941 if (vap
->iv_flags_ext
& IEEE80211_FEXT_REINIT
) {
1943 * We have been requested to drop back to the INIT before
1944 * proceeding to the new state.
1946 /* Deny any state changes while we are here. */
1947 vap
->iv_nstate
= IEEE80211_S_INIT
;
1948 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
,
1949 "%s: %s -> %s arg %d\n", __func__
,
1950 ieee80211_state_name
[vap
->iv_state
],
1951 ieee80211_state_name
[vap
->iv_nstate
], arg
);
1952 vap
->iv_newstate(vap
, vap
->iv_nstate
, 0);
1953 IEEE80211_LOCK_ASSERT(ic
);
1954 vap
->iv_flags_ext
&= ~(IEEE80211_FEXT_REINIT
|
1955 IEEE80211_FEXT_STATEWAIT
);
1956 /* enqueue new state transition after cancel_scan() task */
1957 ieee80211_new_state_locked(vap
, nstate
, arg
);
1961 ostate
= vap
->iv_state
;
1962 if (nstate
== IEEE80211_S_SCAN
&& ostate
!= IEEE80211_S_INIT
) {
1964 * SCAN was forced; e.g. on beacon miss. Force other running
1965 * vap's to INIT state and mark them as waiting for the scan to
1966 * complete. This insures they don't interfere with our
1967 * scanning. Since we are single threaded the vaps can not
1968 * transition again while we are executing.
1970 * XXX not always right, assumes ap follows sta
1974 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
,
1975 "%s: %s -> %s arg %d\n", __func__
,
1976 ieee80211_state_name
[ostate
], ieee80211_state_name
[nstate
], arg
);
1978 rc
= vap
->iv_newstate(vap
, nstate
, arg
);
1979 IEEE80211_LOCK_ASSERT(ic
);
1980 vap
->iv_flags_ext
&= ~IEEE80211_FEXT_STATEWAIT
;
1982 /* State transition failed */
1983 KASSERT(rc
!= EINPROGRESS
, ("iv_newstate was deferred"));
1984 KASSERT(nstate
!= IEEE80211_S_INIT
,
1985 ("INIT state change failed"));
1986 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
,
1987 "%s: %s returned error %d\n", __func__
,
1988 ieee80211_state_name
[nstate
], rc
);
1992 /* No actual transition, skip post processing */
1993 if (ostate
== nstate
)
1996 if (nstate
== IEEE80211_S_RUN
) {
1998 * OACTIVE may be set on the vap if the upper layer
1999 * tried to transmit (e.g. IPv6 NDP) before we reach
2000 * RUN state. Clear it and restart xmit.
2002 * Note this can also happen as a result of SLEEP->RUN
2003 * (i.e. coming out of power save mode).
2005 #if defined(__DragonFly__)
2006 struct ifaltq_subque
*ifsq
;
2009 ifsq
= ifq_get_subq_default(&vap
->iv_ifp
->if_snd
);
2010 ifsq_clr_oactive(ifsq
);
2011 wst
= wlan_serialize_push();
2012 vap
->iv_ifp
->if_start(vap
->iv_ifp
, ifsq
);
2013 wlan_serialize_pop(wst
);
2015 vap
->iv_ifp
->if_drv_flags
&= ~IFF_DRV_OACTIVE
;
2019 * XXX TODO Kick-start a VAP queue - this should be a method!
2022 /* bring up any vaps waiting on us */
2024 } else if (nstate
== IEEE80211_S_INIT
) {
2026 * Flush the scan cache if we did the last scan (XXX?)
2027 * and flush any frames on send queues from this vap.
2028 * Note the mgt q is used only for legacy drivers and
2029 * will go away shortly.
2031 ieee80211_scan_flush(vap
);
2034 * XXX TODO: ic/vap queue flush
2038 IEEE80211_UNLOCK(ic
);
2042 * Public interface for initiating a state machine change.
2043 * This routine single-threads the request and coordinates
2044 * the scheduling of multiple vaps for the purpose of selecting
2045 * an operating channel. Specifically the following scenarios
2047 * o only one vap can be selecting a channel so on transition to
2048 * SCAN state if another vap is already scanning then
2049 * mark the caller for later processing and return without
2050 * doing anything (XXX? expectations by caller of synchronous operation)
2051 * o only one vap can be doing CAC of a channel so on transition to
2052 * CAC state if another vap is already scanning for radar then
2053 * mark the caller for later processing and return without
2054 * doing anything (XXX? expectations by caller of synchronous operation)
2055 * o if another vap is already running when a request is made
2056 * to SCAN then an operating channel has been chosen; bypass
2057 * the scan and just join the channel
2059 * Note that the state change call is done through the iv_newstate
2060 * method pointer so any driver routine gets invoked. The driver
2061 * will normally call back into operating mode-specific
2062 * ieee80211_newstate routines (below) unless it needs to completely
2063 * bypass the state machine (e.g. because the firmware has it's
2064 * own idea how things should work). Bypassing the net80211 layer
2065 * is usually a mistake and indicates lack of proper integration
2066 * with the net80211 layer.
2069 ieee80211_new_state_locked(struct ieee80211vap
*vap
,
2070 enum ieee80211_state nstate
, int arg
)
2072 struct ieee80211com
*ic
= vap
->iv_ic
;
2073 struct ieee80211vap
*vp
;
2074 enum ieee80211_state ostate
;
2075 int nrunning
, nscanning
;
2077 IEEE80211_LOCK_ASSERT(ic
);
2079 if (vap
->iv_flags_ext
& IEEE80211_FEXT_STATEWAIT
) {
2080 if (vap
->iv_nstate
== IEEE80211_S_INIT
||
2081 ((vap
->iv_state
== IEEE80211_S_INIT
||
2082 (vap
->iv_flags_ext
& IEEE80211_FEXT_REINIT
)) &&
2083 vap
->iv_nstate
== IEEE80211_S_SCAN
&&
2084 nstate
> IEEE80211_S_SCAN
)) {
2086 * XXX The vap is being stopped/started,
2087 * do not allow any other state changes
2088 * until this is completed.
2090 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
,
2091 "%s: %s -> %s (%s) transition discarded\n",
2093 ieee80211_state_name
[vap
->iv_state
],
2094 ieee80211_state_name
[nstate
],
2095 ieee80211_state_name
[vap
->iv_nstate
]);
2097 } else if (vap
->iv_state
!= vap
->iv_nstate
) {
2099 /* Warn if the previous state hasn't completed. */
2100 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
,
2101 "%s: pending %s -> %s transition lost\n", __func__
,
2102 ieee80211_state_name
[vap
->iv_state
],
2103 ieee80211_state_name
[vap
->iv_nstate
]);
2105 /* XXX temporarily enable to identify issues */
2106 if_printf(vap
->iv_ifp
,
2107 "%s: pending %s -> %s transition lost\n",
2108 __func__
, ieee80211_state_name
[vap
->iv_state
],
2109 ieee80211_state_name
[vap
->iv_nstate
]);
2114 nrunning
= nscanning
= 0;
2115 /* XXX can track this state instead of calculating */
2116 TAILQ_FOREACH(vp
, &ic
->ic_vaps
, iv_next
) {
2118 if (vp
->iv_state
>= IEEE80211_S_RUN
)
2120 /* XXX doesn't handle bg scan */
2121 /* NB: CAC+AUTH+ASSOC treated like SCAN */
2122 else if (vp
->iv_state
> IEEE80211_S_INIT
)
2126 ostate
= vap
->iv_state
;
2127 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
,
2128 "%s: %s -> %s (nrunning %d nscanning %d)\n", __func__
,
2129 ieee80211_state_name
[ostate
], ieee80211_state_name
[nstate
],
2130 nrunning
, nscanning
);
2132 case IEEE80211_S_SCAN
:
2133 if (ostate
== IEEE80211_S_INIT
) {
2135 * INIT -> SCAN happens on initial bringup.
2137 KASSERT(!(nscanning
&& nrunning
),
2138 ("%d scanning and %d running", nscanning
, nrunning
));
2141 * Someone is scanning, defer our state
2142 * change until the work has completed.
2144 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
,
2145 "%s: defer %s -> %s\n",
2146 __func__
, ieee80211_state_name
[ostate
],
2147 ieee80211_state_name
[nstate
]);
2148 vap
->iv_flags_ext
|= IEEE80211_FEXT_SCANWAIT
;
2153 * Someone is operating; just join the channel
2157 /* XXX check each opmode, adhoc? */
2158 if (vap
->iv_opmode
== IEEE80211_M_STA
)
2159 nstate
= IEEE80211_S_SCAN
;
2161 nstate
= IEEE80211_S_RUN
;
2162 #ifdef IEEE80211_DEBUG
2163 if (nstate
!= IEEE80211_S_SCAN
) {
2164 IEEE80211_DPRINTF(vap
,
2165 IEEE80211_MSG_STATE
,
2166 "%s: override, now %s -> %s\n",
2168 ieee80211_state_name
[ostate
],
2169 ieee80211_state_name
[nstate
]);
2175 case IEEE80211_S_RUN
:
2176 if (vap
->iv_opmode
== IEEE80211_M_WDS
&&
2177 (vap
->iv_flags_ext
& IEEE80211_FEXT_WDSLEGACY
) &&
2180 * Legacy WDS with someone else scanning; don't
2181 * go online until that completes as we should
2182 * follow the other vap to the channel they choose.
2184 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
,
2185 "%s: defer %s -> %s (legacy WDS)\n", __func__
,
2186 ieee80211_state_name
[ostate
],
2187 ieee80211_state_name
[nstate
]);
2188 vap
->iv_flags_ext
|= IEEE80211_FEXT_SCANWAIT
;
2191 if (vap
->iv_opmode
== IEEE80211_M_HOSTAP
&&
2192 IEEE80211_IS_CHAN_DFS(ic
->ic_bsschan
) &&
2193 (vap
->iv_flags_ext
& IEEE80211_FEXT_DFS
) &&
2194 !IEEE80211_IS_CHAN_CACDONE(ic
->ic_bsschan
)) {
2196 * This is a DFS channel, transition to CAC state
2197 * instead of RUN. This allows us to initiate
2198 * Channel Availability Check (CAC) as specified
2201 nstate
= IEEE80211_S_CAC
;
2202 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_STATE
,
2203 "%s: override %s -> %s (DFS)\n", __func__
,
2204 ieee80211_state_name
[ostate
],
2205 ieee80211_state_name
[nstate
]);
2208 case IEEE80211_S_INIT
:
2209 /* cancel any scan in progress */
2210 ieee80211_cancel_scan(vap
);
2211 if (ostate
== IEEE80211_S_INIT
) {
2212 /* XXX don't believe this */
2213 /* INIT -> INIT. nothing to do */
2214 vap
->iv_flags_ext
&= ~IEEE80211_FEXT_SCANWAIT
;
2220 /* defer the state change to a thread */
2221 vap
->iv_nstate
= nstate
;
2222 vap
->iv_nstate_arg
= arg
;
2223 vap
->iv_flags_ext
|= IEEE80211_FEXT_STATEWAIT
;
2224 ieee80211_runtask(ic
, &vap
->iv_nstate_task
);
2229 ieee80211_new_state(struct ieee80211vap
*vap
,
2230 enum ieee80211_state nstate
, int arg
)
2232 struct ieee80211com
*ic
= vap
->iv_ic
;
2236 rc
= ieee80211_new_state_locked(vap
, nstate
, arg
);
2237 IEEE80211_UNLOCK(ic
);