1 /*-
2 * Copyright (c) 2001 Atsushi Onoe
3 * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29
30 /*
31 * IEEE 802.11 generic handler
32 */
33 #include "opt_wlan.h"
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
38 #include <sys/malloc.h>
39 #include <sys/socket.h>
40 #include <sys/sbuf.h>
41
42 #include <machine/stdarg.h>
43
44 #include <net/if.h>
45 #include <net/if_var.h>
46 #include <net/if_dl.h>
47 #include <net/if_media.h>
48 #include <net/if_types.h>
49 #include <net/ethernet.h>
50
51 #include <netproto/802_11/ieee80211_var.h>
52 #include <netproto/802_11/ieee80211_regdomain.h>
53 #ifdef IEEE80211_SUPPORT_SUPERG
54 #include <netproto/802_11/ieee80211_superg.h>
55 #endif
56 #include <netproto/802_11/ieee80211_ratectl.h>
57
58 #include <net/bpf.h>
59
60 const char *ieee80211_phymode_name[IEEE80211_MODE_MAX] = {
61 [IEEE80211_MODE_AUTO] = "auto",
62 [IEEE80211_MODE_11A] = "11a",
63 [IEEE80211_MODE_11B] = "11b",
64 [IEEE80211_MODE_11G] = "11g",
65 [IEEE80211_MODE_FH] = "FH",
66 [IEEE80211_MODE_TURBO_A] = "turboA",
67 [IEEE80211_MODE_TURBO_G] = "turboG",
68 [IEEE80211_MODE_STURBO_A] = "sturboA",
69 [IEEE80211_MODE_HALF] = "half",
70 [IEEE80211_MODE_QUARTER] = "quarter",
71 [IEEE80211_MODE_11NA] = "11na",
72 [IEEE80211_MODE_11NG] = "11ng",
73 [IEEE80211_MODE_VHT_2GHZ] = "11acg",
74 [IEEE80211_MODE_VHT_5GHZ] = "11ac",
75 };
76 /* map ieee80211_opmode to the corresponding capability bit */
77 const int ieee80211_opcap[IEEE80211_OPMODE_MAX] = {
78 [IEEE80211_M_IBSS] = IEEE80211_C_IBSS,
79 [IEEE80211_M_WDS] = IEEE80211_C_WDS,
80 [IEEE80211_M_STA] = IEEE80211_C_STA,
81 [IEEE80211_M_AHDEMO] = IEEE80211_C_AHDEMO,
82 [IEEE80211_M_HOSTAP] = IEEE80211_C_HOSTAP,
83 [IEEE80211_M_MONITOR] = IEEE80211_C_MONITOR,
84 #ifdef IEEE80211_SUPPORT_MESH
85 [IEEE80211_M_MBSS] = IEEE80211_C_MBSS,
86 #endif
87 };
88
89 const uint8_t ieee80211broadcastaddr[IEEE80211_ADDR_LEN] =
90 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
91
92 static void ieee80211_syncflag_locked(struct ieee80211com *ic, int flag);
93 static void ieee80211_syncflag_ht_locked(struct ieee80211com *ic, int flag);
94 static void ieee80211_syncflag_ext_locked(struct ieee80211com *ic, int flag);
95 static int ieee80211_media_setup(struct ieee80211com *ic,
96 struct ifmedia *media, int caps, int addsta,
97 ifm_change_cb_t media_change, ifm_stat_cb_t media_stat);
98 static int media_status(enum ieee80211_opmode,
99 const struct ieee80211_channel *);
100 #if defined(__DragonFly__)
101 #else
102 static uint64_t ieee80211_get_counter(struct ifnet *, ift_counter);
103 #endif
104
105 MALLOC_DEFINE(M_80211_VAP, "80211vap", "802.11 vap state");
106
107 /*
108 * Default supported rates for 802.11 operation (in IEEE .5Mb units).
109 */
110 #define B(r) ((r) | IEEE80211_RATE_BASIC)
111 static const struct ieee80211_rateset ieee80211_rateset_11a =
112 { 8, { B(12), 18, B(24), 36, B(48), 72, 96, 108 } };
113 static const struct ieee80211_rateset ieee80211_rateset_half =
114 { 8, { B(6), 9, B(12), 18, B(24), 36, 48, 54 } };
115 static const struct ieee80211_rateset ieee80211_rateset_quarter =
116 { 8, { B(3), 4, B(6), 9, B(12), 18, 24, 27 } };
117 static const struct ieee80211_rateset ieee80211_rateset_11b =
118 { 4, { B(2), B(4), B(11), B(22) } };
119 /* NB: OFDM rates are handled specially based on mode */
120 static const struct ieee80211_rateset ieee80211_rateset_11g =
121 { 12, { B(2), B(4), B(11), B(22), 12, 18, 24, 36, 48, 72, 96, 108 } };
122 #undef B
123
124 /*
125 * Fill in 802.11 available channel set, mark
126 * all available channels as active, and pick
127 * a default channel if not already specified.
128 */
129 void
ieee80211_chan_init(struct ieee80211com * ic)130 ieee80211_chan_init(struct ieee80211com *ic)
131 {
132 #define DEFAULTRATES(m, def) do { \
133 if (ic->ic_sup_rates[m].rs_nrates == 0) \
134 ic->ic_sup_rates[m] = def; \
135 } while (0)
136 struct ieee80211_channel *c;
137 int i;
138
139 KASSERT(0 < ic->ic_nchans && ic->ic_nchans <= IEEE80211_CHAN_MAX,
140 ("invalid number of channels specified: %u", ic->ic_nchans));
141 memset(ic->ic_chan_avail, 0, sizeof(ic->ic_chan_avail));
142 memset(ic->ic_modecaps, 0, sizeof(ic->ic_modecaps));
143 setbit(ic->ic_modecaps, IEEE80211_MODE_AUTO);
144 for (i = 0; i < ic->ic_nchans; i++) {
145 c = &ic->ic_channels[i];
146 KASSERT(c->ic_flags != 0, ("channel with no flags"));
147 /*
148 * Help drivers that work only with frequencies by filling
149 * in IEEE channel #'s if not already calculated. Note this
150 * mimics similar work done in ieee80211_setregdomain when
151 * changing regulatory state.
152 */
153 if (c->ic_ieee == 0)
154 c->ic_ieee = ieee80211_mhz2ieee(c->ic_freq,c->ic_flags);
155 if (IEEE80211_IS_CHAN_HT40(c) && c->ic_extieee == 0)
156 c->ic_extieee = ieee80211_mhz2ieee(c->ic_freq +
157 (IEEE80211_IS_CHAN_HT40U(c) ? 20 : -20),
158 c->ic_flags);
159 /* default max tx power to max regulatory */
160 if (c->ic_maxpower == 0)
161 c->ic_maxpower = 2*c->ic_maxregpower;
162 setbit(ic->ic_chan_avail, c->ic_ieee);
163 /*
164 * Identify mode capabilities.
165 */
166 if (IEEE80211_IS_CHAN_A(c))
167 setbit(ic->ic_modecaps, IEEE80211_MODE_11A);
168 if (IEEE80211_IS_CHAN_B(c))
169 setbit(ic->ic_modecaps, IEEE80211_MODE_11B);
170 if (IEEE80211_IS_CHAN_ANYG(c))
171 setbit(ic->ic_modecaps, IEEE80211_MODE_11G);
172 if (IEEE80211_IS_CHAN_FHSS(c))
173 setbit(ic->ic_modecaps, IEEE80211_MODE_FH);
174 if (IEEE80211_IS_CHAN_108A(c))
175 setbit(ic->ic_modecaps, IEEE80211_MODE_TURBO_A);
176 if (IEEE80211_IS_CHAN_108G(c))
177 setbit(ic->ic_modecaps, IEEE80211_MODE_TURBO_G);
178 if (IEEE80211_IS_CHAN_ST(c))
179 setbit(ic->ic_modecaps, IEEE80211_MODE_STURBO_A);
180 if (IEEE80211_IS_CHAN_HALF(c))
181 setbit(ic->ic_modecaps, IEEE80211_MODE_HALF);
182 if (IEEE80211_IS_CHAN_QUARTER(c))
183 setbit(ic->ic_modecaps, IEEE80211_MODE_QUARTER);
184 if (IEEE80211_IS_CHAN_HTA(c))
185 setbit(ic->ic_modecaps, IEEE80211_MODE_11NA);
186 if (IEEE80211_IS_CHAN_HTG(c))
187 setbit(ic->ic_modecaps, IEEE80211_MODE_11NG);
188 }
189 /* initialize candidate channels to all available */
190 memcpy(ic->ic_chan_active, ic->ic_chan_avail,
191 sizeof(ic->ic_chan_avail));
192
193 /* sort channel table to allow lookup optimizations */
194 ieee80211_sort_channels(ic->ic_channels, ic->ic_nchans);
195
196 /* invalidate any previous state */
197 ic->ic_bsschan = IEEE80211_CHAN_ANYC;
198 ic->ic_prevchan = NULL;
199 ic->ic_csa_newchan = NULL;
200 /* arbitrarily pick the first channel */
201 ic->ic_curchan = &ic->ic_channels[0];
202 ic->ic_rt = ieee80211_get_ratetable(ic->ic_curchan);
203
204 /* fillin well-known rate sets if driver has not specified */
205 DEFAULTRATES(IEEE80211_MODE_11B, ieee80211_rateset_11b);
206 DEFAULTRATES(IEEE80211_MODE_11G, ieee80211_rateset_11g);
207 DEFAULTRATES(IEEE80211_MODE_11A, ieee80211_rateset_11a);
208 DEFAULTRATES(IEEE80211_MODE_TURBO_A, ieee80211_rateset_11a);
209 DEFAULTRATES(IEEE80211_MODE_TURBO_G, ieee80211_rateset_11g);
210 DEFAULTRATES(IEEE80211_MODE_STURBO_A, ieee80211_rateset_11a);
211 DEFAULTRATES(IEEE80211_MODE_HALF, ieee80211_rateset_half);
212 DEFAULTRATES(IEEE80211_MODE_QUARTER, ieee80211_rateset_quarter);
213 DEFAULTRATES(IEEE80211_MODE_11NA, ieee80211_rateset_11a);
214 DEFAULTRATES(IEEE80211_MODE_11NG, ieee80211_rateset_11g);
215
216 /*
217 * Setup required information to fill the mcsset field, if driver did
218 * not. Assume a 2T2R setup for historic reasons.
219 */
220 if (ic->ic_rxstream == 0)
221 ic->ic_rxstream = 2;
222 if (ic->ic_txstream == 0)
223 ic->ic_txstream = 2;
224
225 /*
226 * Set auto mode to reset active channel state and any desired channel.
227 */
228 (void) ieee80211_setmode(ic, IEEE80211_MODE_AUTO);
229 #undef DEFAULTRATES
230 }
231
232 static void
null_update_mcast(struct ieee80211com * ic)233 null_update_mcast(struct ieee80211com *ic)
234 {
235
236 ic_printf(ic, "need multicast update callback\n");
237 }
238
239 static void
null_update_promisc(struct ieee80211com * ic)240 null_update_promisc(struct ieee80211com *ic)
241 {
242
243 ic_printf(ic, "need promiscuous mode update callback\n");
244 }
245
246 static void
null_update_chw(struct ieee80211com * ic)247 null_update_chw(struct ieee80211com *ic)
248 {
249
250 ic_printf(ic, "%s: need callback\n", __func__);
251 }
252
253 int
ic_printf(struct ieee80211com * ic,const char * fmt,...)254 ic_printf(struct ieee80211com *ic, const char * fmt, ...)
255 {
256 #if defined(__DragonFly__)
257 osdep_va_list ap;
258 int retval;
259
260 retval = kprintf("%s: ", ic->ic_name);
261 osdep_va_start(ap, fmt);
262 retval += kvprintf(fmt, ap);
263 osdep_va_end(ap);
264 #else
265 va_list ap;
266 int retval;
267
268 retval = printf("%s: ", ic->ic_name);
269 va_start(ap, fmt);
270 retval += vprintf(fmt, ap);
271 va_end(ap);
272 #endif
273 return (retval);
274 }
275
276 static LIST_HEAD(, ieee80211com) ic_head = LIST_HEAD_INITIALIZER(ic_head);
277 #if defined(__DragonFly__)
278 static struct lock ic_list_lock =
279 LOCK_INITIALIZER("80211list", 0, LK_CANRECURSE);
280 #else
281 static struct mtx ic_list_mtx;
282 MTX_SYSINIT(ic_list, &ic_list_mtx, "ieee80211com list", MTX_DEF);
283 #endif
284
285 static int
sysctl_ieee80211coms(SYSCTL_HANDLER_ARGS)286 sysctl_ieee80211coms(SYSCTL_HANDLER_ARGS)
287 {
288 struct ieee80211com *ic;
289 struct sbuf sb;
290 char *sp;
291 int error;
292
293 #if defined(__DragonFly__)
294 #else
295 error = sysctl_wire_old_buffer(req, 0);
296 if (error)
297 return (error);
298 #endif
299 sbuf_new_for_sysctl(&sb, NULL, 8, req);
300 #if defined(__DragonFly__)
301 #else
302 sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
303 #endif
304 sp = "";
305 #if defined(__DragonFly__)
306 lockmgr(&ic_list_lock, LK_EXCLUSIVE);
307 #else
308 mtx_lock(&ic_list_mtx);
309 #endif
310 LIST_FOREACH(ic, &ic_head, ic_next) {
311 sbuf_printf(&sb, "%s%s", sp, ic->ic_name);
312 sp = " ";
313 }
314 #if defined(__DragonFly__)
315 lockmgr(&ic_list_lock, LK_RELEASE);
316 #else
317 mtx_unlock(&ic_list_mtx);
318 #endif
319 error = sbuf_finish(&sb);
320 sbuf_delete(&sb);
321 return (error);
322 }
323
324 #if defined(__DragonFly__)
325 SYSCTL_PROC(_net_wlan, OID_AUTO, devices,
326 CTLTYPE_STRING | CTLFLAG_RD, NULL, 0,
327 sysctl_ieee80211coms, "A", "names of available 802.11 devices");
328 #else
329 SYSCTL_PROC(_net_wlan, OID_AUTO, devices,
330 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
331 sysctl_ieee80211coms, "A", "names of available 802.11 devices");
332 #endif
333
334
335 /*
336 * Attach/setup the common net80211 state. Called by
337 * the driver on attach to prior to creating any vap's.
338 */
339 void
ieee80211_ifattach(struct ieee80211com * ic)340 ieee80211_ifattach(struct ieee80211com *ic)
341 {
342
343 IEEE80211_LOCK_INIT(ic, ic->ic_name);
344 IEEE80211_TX_LOCK_INIT(ic, ic->ic_name);
345 TAILQ_INIT(&ic->ic_vaps);
346
347 /* Create a taskqueue for all state changes */
348 ic->ic_tq = taskqueue_create("ic_taskq", M_WAITOK | M_ZERO,
349 taskqueue_thread_enqueue, &ic->ic_tq);
350 #if defined(__DragonFly__)
351 taskqueue_start_threads(&ic->ic_tq, 1, TDPRI_KERN_DAEMON, -1,
352 "%s net80211 taskq", ic->ic_name);
353 #else
354 taskqueue_start_threads(&ic->ic_tq, 1, PI_NET, "%s net80211 taskq",
355 ic->ic_name);
356 ic->ic_ierrors = counter_u64_alloc(M_WAITOK);
357 ic->ic_oerrors = counter_u64_alloc(M_WAITOK);
358 #endif
359 /*
360 * Fill in 802.11 available channel set, mark all
361 * available channels as active, and pick a default
362 * channel if not already specified.
363 */
364 ieee80211_chan_init(ic);
365
366 ic->ic_update_mcast = null_update_mcast;
367 ic->ic_update_promisc = null_update_promisc;
368 ic->ic_update_chw = null_update_chw;
369
370 ic->ic_hash_key = arc4random();
371 ic->ic_bintval = IEEE80211_BINTVAL_DEFAULT;
372 ic->ic_lintval = ic->ic_bintval;
373 ic->ic_txpowlimit = IEEE80211_TXPOWER_MAX;
374
375 ieee80211_crypto_attach(ic);
376 ieee80211_node_attach(ic);
377 ieee80211_power_attach(ic);
378 ieee80211_proto_attach(ic);
379 #ifdef IEEE80211_SUPPORT_SUPERG
380 ieee80211_superg_attach(ic);
381 #endif
382 ieee80211_ht_attach(ic);
383 ieee80211_scan_attach(ic);
384 ieee80211_regdomain_attach(ic);
385 ieee80211_dfs_attach(ic);
386
387 ieee80211_sysctl_attach(ic);
388
389 #if defined(__DragonFly__)
390 lockmgr(&ic_list_lock, LK_EXCLUSIVE);
391 #else
392 mtx_lock(&ic_list_mtx);
393 #endif
394 LIST_INSERT_HEAD(&ic_head, ic, ic_next);
395 #if defined(__DragonFly__)
396 lockmgr(&ic_list_lock, LK_RELEASE);
397 #else
398 mtx_unlock(&ic_list_mtx);
399 #endif
400 }
401
402 /*
403 * Detach net80211 state on device detach. Tear down
404 * all vap's and reclaim all common state prior to the
405 * device state going away. Note we may call back into
406 * driver; it must be prepared for this.
407 */
408 void
ieee80211_ifdetach(struct ieee80211com * ic)409 ieee80211_ifdetach(struct ieee80211com *ic)
410 {
411 struct ieee80211vap *vap;
412
413 #if defined(__DragonFly__)
414 wlan_serialize_enter();
415 #endif
416
417 #if defined(__DragonFly__)
418 lockmgr(&ic_list_lock, LK_EXCLUSIVE);
419 #else
420 mtx_lock(&ic_list_mtx);
421 #endif
422 LIST_REMOVE(ic, ic_next);
423 #if defined(__DragonFly__)
424 lockmgr(&ic_list_lock, LK_RELEASE);
425 #else
426 mtx_unlock(&ic_list_mtx);
427 #endif
428
429 #if defined(__DragonFly__)
430 taskqueue_drain(taskqueue_thread[0], &ic->ic_restart_task);
431 #else
432 taskqueue_drain(taskqueue_thread, &ic->ic_restart_task);
433 #endif
434
435 /*
436 * The VAP is responsible for setting and clearing
437 * the VIMAGE context.
438 */
439 while ((vap = TAILQ_FIRST(&ic->ic_vaps)) != NULL)
440 ieee80211_vap_destroy(vap);
441 ieee80211_waitfor_parent(ic);
442
443 ieee80211_sysctl_detach(ic);
444 ieee80211_dfs_detach(ic);
445 ieee80211_regdomain_detach(ic);
446 ieee80211_scan_detach(ic);
447 #ifdef IEEE80211_SUPPORT_SUPERG
448 ieee80211_superg_detach(ic);
449 #endif
450 ieee80211_ht_detach(ic);
451 /* NB: must be called before ieee80211_node_detach */
452 ieee80211_proto_detach(ic);
453 ieee80211_crypto_detach(ic);
454 ieee80211_power_detach(ic);
455 ieee80211_node_detach(ic);
456
457 #if defined(__DragonFly__)
458 #else
459 counter_u64_free(ic->ic_ierrors);
460 counter_u64_free(ic->ic_oerrors);
461 #endif
462
463 taskqueue_free(ic->ic_tq);
464 IEEE80211_TX_LOCK_DESTROY(ic);
465 IEEE80211_LOCK_DESTROY(ic);
466
467 #if defined(__DragonFly__)
468 wlan_serialize_exit();
469 #endif
470 }
471
472 struct ieee80211com *
ieee80211_find_com(const char * name)473 ieee80211_find_com(const char *name)
474 {
475 struct ieee80211com *ic;
476
477 #if defined(__DragonFly__)
478 lockmgr(&ic_list_lock, LK_EXCLUSIVE);
479 #else
480 mtx_lock(&ic_list_mtx);
481 #endif
482 LIST_FOREACH(ic, &ic_head, ic_next) {
483 if (strcmp(ic->ic_name, name) == 0)
484 break;
485 }
486 #if defined(__DragonFly__)
487 lockmgr(&ic_list_lock, LK_RELEASE);
488 #else
489 mtx_unlock(&ic_list_mtx);
490 #endif
491
492 return(ic);
493 }
494
495 /*
496 * Default reset method for use with the ioctl support. This
497 * method is invoked after any state change in the 802.11
498 * layer that should be propagated to the hardware but not
499 * require re-initialization of the 802.11 state machine (e.g
500 * rescanning for an ap). We always return ENETRESET which
501 * should cause the driver to re-initialize the device. Drivers
502 * can override this method to implement more optimized support.
503 */
504 static int
default_reset(struct ieee80211vap * vap,u_long cmd)505 default_reset(struct ieee80211vap *vap, u_long cmd)
506 {
507 return ENETRESET;
508 }
509
510 #if defined(__DragonFly__)
511 #else
512 /*
513 * Add underlying device errors to vap errors.
514 */
515 static uint64_t
ieee80211_get_counter(struct ifnet * ifp,ift_counter cnt)516 ieee80211_get_counter(struct ifnet *ifp, ift_counter cnt)
517 {
518 struct ieee80211vap *vap = ifp->if_softc;
519 struct ieee80211com *ic = vap->iv_ic;
520 uint64_t rv;
521
522 rv = if_get_counter_default(ifp, cnt);
523 switch (cnt) {
524 case IFCOUNTER_OERRORS:
525 rv += counter_u64_fetch(ic->ic_oerrors);
526 break;
527 case IFCOUNTER_IERRORS:
528 rv += counter_u64_fetch(ic->ic_ierrors);
529 break;
530 default:
531 break;
532 }
533
534 return (rv);
535 }
536
537 #endif
538
539 /*
540 * Prepare a vap for use. Drivers use this call to
541 * setup net80211 state in new vap's prior attaching
542 * them with ieee80211_vap_attach (below).
543 */
544 int
ieee80211_vap_setup(struct ieee80211com * ic,struct ieee80211vap * vap,const char name[IFNAMSIZ],int unit,enum ieee80211_opmode opmode,int flags,const uint8_t bssid[IEEE80211_ADDR_LEN])545 ieee80211_vap_setup(struct ieee80211com *ic, struct ieee80211vap *vap,
546 const char name[IFNAMSIZ], int unit, enum ieee80211_opmode opmode,
547 int flags, const uint8_t bssid[IEEE80211_ADDR_LEN])
548 {
549 struct ifnet *ifp;
550
551 ifp = if_alloc(IFT_ETHER);
552 if (ifp == NULL) {
553 ic_printf(ic, "%s: unable to allocate ifnet\n",
554 __func__);
555 return ENOMEM;
556 }
557 if_initname(ifp, name, unit);
558 ifp->if_softc = vap; /* back pointer */
559 ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
560 #if defined(__DragonFly__)
561 ifp->if_start = ieee80211_vap_start;
562 #else
563 ifp->if_transmit = ieee80211_vap_transmit;
564 ifp->if_qflush = ieee80211_vap_qflush;
565 #endif
566 ifp->if_ioctl = ieee80211_ioctl;
567 ifp->if_init = ieee80211_init;
568 #if defined(__DragonFly__)
569 #else
570 ifp->if_get_counter = ieee80211_get_counter;
571 #endif
572
573 vap->iv_ifp = ifp;
574 vap->iv_ic = ic;
575 vap->iv_flags = ic->ic_flags; /* propagate common flags */
576 vap->iv_flags_ext = ic->ic_flags_ext;
577 vap->iv_flags_ven = ic->ic_flags_ven;
578 vap->iv_caps = ic->ic_caps &~ IEEE80211_C_OPMODE;
579 vap->iv_htcaps = ic->ic_htcaps;
580 vap->iv_htextcaps = ic->ic_htextcaps;
581 vap->iv_opmode = opmode;
582 vap->iv_caps |= ieee80211_opcap[opmode];
583 IEEE80211_ADDR_COPY(vap->iv_myaddr, ic->ic_macaddr);
584 switch (opmode) {
585 case IEEE80211_M_WDS:
586 /*
587 * WDS links must specify the bssid of the far end.
588 * For legacy operation this is a static relationship.
589 * For non-legacy operation the station must associate
590 * and be authorized to pass traffic. Plumbing the
591 * vap to the proper node happens when the vap
592 * transitions to RUN state.
593 */
594 IEEE80211_ADDR_COPY(vap->iv_des_bssid, bssid);
595 vap->iv_flags |= IEEE80211_F_DESBSSID;
596 if (flags & IEEE80211_CLONE_WDSLEGACY)
597 vap->iv_flags_ext |= IEEE80211_FEXT_WDSLEGACY;
598 break;
599 #ifdef IEEE80211_SUPPORT_TDMA
600 case IEEE80211_M_AHDEMO:
601 if (flags & IEEE80211_CLONE_TDMA) {
602 /* NB: checked before clone operation allowed */
603 KASSERT(ic->ic_caps & IEEE80211_C_TDMA,
604 ("not TDMA capable, ic_caps 0x%x", ic->ic_caps));
605 /*
606 * Propagate TDMA capability to mark vap; this
607 * cannot be removed and is used to distinguish
608 * regular ahdemo operation from ahdemo+tdma.
609 */
610 vap->iv_caps |= IEEE80211_C_TDMA;
611 }
612 break;
613 #endif
614 default:
615 break;
616 }
617 /* auto-enable s/w beacon miss support */
618 if (flags & IEEE80211_CLONE_NOBEACONS)
619 vap->iv_flags_ext |= IEEE80211_FEXT_SWBMISS;
620 /* auto-generated or user supplied MAC address */
621 if (flags & (IEEE80211_CLONE_BSSID|IEEE80211_CLONE_MACADDR))
622 vap->iv_flags_ext |= IEEE80211_FEXT_UNIQMAC;
623 /*
624 * Enable various functionality by default if we're
625 * capable; the driver can override us if it knows better.
626 */
627 if (vap->iv_caps & IEEE80211_C_WME)
628 vap->iv_flags |= IEEE80211_F_WME;
629 if (vap->iv_caps & IEEE80211_C_BURST)
630 vap->iv_flags |= IEEE80211_F_BURST;
631 /* NB: bg scanning only makes sense for station mode right now */
632 #if defined(__DragonFly__)
633 /*
634 * DISABLE BGSCAN BY DEFAULT, many issues can crop up including
635 * the link going dead.
636 */
637 /* empty */
638 #else
639 if (vap->iv_opmode == IEEE80211_M_STA &&
640 (vap->iv_caps & IEEE80211_C_BGSCAN))
641 vap->iv_flags |= IEEE80211_F_BGSCAN;
642 #endif
643 vap->iv_flags |= IEEE80211_F_DOTH; /* XXX no cap, just ena */
644 /* NB: DFS support only makes sense for ap mode right now */
645 if (vap->iv_opmode == IEEE80211_M_HOSTAP &&
646 (vap->iv_caps & IEEE80211_C_DFS))
647 vap->iv_flags_ext |= IEEE80211_FEXT_DFS;
648
649 vap->iv_des_chan = IEEE80211_CHAN_ANYC; /* any channel is ok */
650 vap->iv_bmissthreshold = IEEE80211_HWBMISS_DEFAULT;
651 vap->iv_dtim_period = IEEE80211_DTIM_DEFAULT;
652 /*
653 * Install a default reset method for the ioctl support;
654 * the driver can override this.
655 */
656 vap->iv_reset = default_reset;
657
658 ieee80211_sysctl_vattach(vap);
659 ieee80211_crypto_vattach(vap);
660 ieee80211_node_vattach(vap);
661 ieee80211_power_vattach(vap);
662 ieee80211_proto_vattach(vap);
663 #ifdef IEEE80211_SUPPORT_SUPERG
664 ieee80211_superg_vattach(vap);
665 #endif
666 ieee80211_ht_vattach(vap);
667 ieee80211_scan_vattach(vap);
668 ieee80211_regdomain_vattach(vap);
669 ieee80211_radiotap_vattach(vap);
670 ieee80211_ratectl_set(vap, IEEE80211_RATECTL_NONE);
671
672 return 0;
673 }
674
675 /*
676 * Activate a vap. State should have been prepared with a
677 * call to ieee80211_vap_setup and by the driver. On return
678 * from this call the vap is ready for use.
679 */
680 int
ieee80211_vap_attach(struct ieee80211vap * vap,ifm_change_cb_t media_change,ifm_stat_cb_t media_stat,const uint8_t macaddr[IEEE80211_ADDR_LEN])681 ieee80211_vap_attach(struct ieee80211vap *vap, ifm_change_cb_t media_change,
682 ifm_stat_cb_t media_stat, const uint8_t macaddr[IEEE80211_ADDR_LEN])
683 {
684 struct ifnet *ifp = vap->iv_ifp;
685 struct ieee80211com *ic = vap->iv_ic;
686 struct ifmediareq imr;
687 int maxrate;
688
689 #if defined(__DragonFly__)
690 /*
691 * This function must _not_ be serialized by the WLAN serializer,
692 * since it could dead-lock the domsg to netisrs in ether_ifattach().
693 */
694 wlan_assert_notserialized();
695 #endif
696 IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE,
697 "%s: %s parent %s flags 0x%x flags_ext 0x%x\n",
698 __func__, ieee80211_opmode_name[vap->iv_opmode],
699 ic->ic_name, vap->iv_flags, vap->iv_flags_ext);
700
701 /*
702 * Do late attach work that cannot happen until after
703 * the driver has had a chance to override defaults.
704 */
705 ieee80211_node_latevattach(vap);
706 ieee80211_power_latevattach(vap);
707
708 maxrate = ieee80211_media_setup(ic, &vap->iv_media, vap->iv_caps,
709 vap->iv_opmode == IEEE80211_M_STA, media_change, media_stat);
710 ieee80211_media_status(ifp, &imr);
711 /* NB: strip explicit mode; we're actually in autoselect */
712 ifmedia_set(&vap->iv_media,
713 imr.ifm_active &~ (IFM_MMASK | IFM_IEEE80211_TURBO));
714 if (maxrate)
715 ifp->if_baudrate = IF_Mbps(maxrate);
716
717 #if defined(__DragonFly__)
718 ether_ifattach(ifp, macaddr, &wlan_global_serializer);
719 #else
720 ether_ifattach(ifp, macaddr);
721 #endif
722 IEEE80211_ADDR_COPY(vap->iv_myaddr, IF_LLADDR(ifp));
723 /* hook output method setup by ether_ifattach */
724 vap->iv_output = ifp->if_output;
725 ifp->if_output = ieee80211_output;
726 /* NB: if_mtu set by ether_ifattach to ETHERMTU */
727
728 IEEE80211_LOCK(ic);
729 TAILQ_INSERT_TAIL(&ic->ic_vaps, vap, iv_next);
730 ieee80211_syncflag_locked(ic, IEEE80211_F_WME);
731 #ifdef IEEE80211_SUPPORT_SUPERG
732 ieee80211_syncflag_locked(ic, IEEE80211_F_TURBOP);
733 #endif
734 ieee80211_syncflag_locked(ic, IEEE80211_F_PCF);
735 ieee80211_syncflag_locked(ic, IEEE80211_F_BURST);
736 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_HT);
737 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_USEHT40);
738 IEEE80211_UNLOCK(ic);
739
740 return 1;
741 }
742
743 /*
744 * Tear down vap state and reclaim the ifnet.
745 * The driver is assumed to have prepared for
746 * this; e.g. by turning off interrupts for the
747 * underlying device.
748 */
749 void
ieee80211_vap_detach(struct ieee80211vap * vap)750 ieee80211_vap_detach(struct ieee80211vap *vap)
751 {
752 struct ieee80211com *ic = vap->iv_ic;
753 struct ifnet *ifp = vap->iv_ifp;
754
755 #if defined(__DragonFly__)
756 /*
757 * This function must _not_ be serialized by the WLAN serializer,
758 * since it could dead-lock the domsg to netisrs in ether_ifdettach().
759 */
760 wlan_assert_notserialized();
761 #endif
762 CURVNET_SET(ifp->if_vnet);
763
764 IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s parent %s\n",
765 __func__, ieee80211_opmode_name[vap->iv_opmode], ic->ic_name);
766
767 /* NB: bpfdetach is called by ether_ifdetach and claims all taps */
768 ether_ifdetach(ifp);
769
770 ieee80211_stop(vap);
771
772 /*
773 * Flush any deferred vap tasks.
774 */
775 ieee80211_draintask(ic, &vap->iv_nstate_task);
776 ieee80211_draintask(ic, &vap->iv_swbmiss_task);
777
778 #if defined(__DragonFly__)
779 /* XXX hmm, not sure what we should do here */
780 #else
781 /* XXX band-aid until ifnet handles this for us */
782 taskqueue_drain(taskqueue_swi, &ifp->if_linktask);
783 #endif
784
785 IEEE80211_LOCK(ic);
786 KASSERT(vap->iv_state == IEEE80211_S_INIT , ("vap still running"));
787 TAILQ_REMOVE(&ic->ic_vaps, vap, iv_next);
788 ieee80211_syncflag_locked(ic, IEEE80211_F_WME);
789 #ifdef IEEE80211_SUPPORT_SUPERG
790 ieee80211_syncflag_locked(ic, IEEE80211_F_TURBOP);
791 #endif
792 ieee80211_syncflag_locked(ic, IEEE80211_F_PCF);
793 ieee80211_syncflag_locked(ic, IEEE80211_F_BURST);
794 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_HT);
795 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_USEHT40);
796 /* NB: this handles the bpfdetach done below */
797 ieee80211_syncflag_ext_locked(ic, IEEE80211_FEXT_BPF);
798 #if defined(__DragonFly__)
799 if (vap->iv_ifflags & IFF_PROMISC)
800 ieee80211_promisc(vap, 0);
801 if (vap->iv_ifflags & IFF_ALLMULTI)
802 ieee80211_allmulti(vap, 0);
803 #else
804 if (vap->iv_ifflags & IFF_PROMISC)
805 ieee80211_promisc(vap, false);
806 if (vap->iv_ifflags & IFF_ALLMULTI)
807 ieee80211_allmulti(vap, false);
808 #endif
809 IEEE80211_UNLOCK(ic);
810
811 ifmedia_removeall(&vap->iv_media);
812
813 ieee80211_radiotap_vdetach(vap);
814 ieee80211_regdomain_vdetach(vap);
815 ieee80211_scan_vdetach(vap);
816 #ifdef IEEE80211_SUPPORT_SUPERG
817 ieee80211_superg_vdetach(vap);
818 #endif
819 ieee80211_ht_vdetach(vap);
820 /* NB: must be before ieee80211_node_vdetach */
821 ieee80211_proto_vdetach(vap);
822 ieee80211_crypto_vdetach(vap);
823 ieee80211_power_vdetach(vap);
824 ieee80211_node_vdetach(vap);
825 ieee80211_sysctl_vdetach(vap);
826
827 if_free(ifp);
828
829 CURVNET_RESTORE();
830 }
831
832 /*
833 * Count number of vaps in promisc, and issue promisc on
834 * parent respectively.
835 */
836 #if defined(__DragonFly__)
837 void
ieee80211_promisc(struct ieee80211vap * vap,int on)838 ieee80211_promisc(struct ieee80211vap *vap, int on)
839 #else
840 void
841 ieee80211_promisc(struct ieee80211vap *vap, bool on)
842 #endif
843 {
844 struct ieee80211com *ic = vap->iv_ic;
845
846 IEEE80211_LOCK_ASSERT(ic);
847
848 if (on) {
849 if (++ic->ic_promisc == 1)
850 ieee80211_runtask(ic, &ic->ic_promisc_task);
851 } else {
852 KASSERT(ic->ic_promisc > 0, ("%s: ic %p not promisc",
853 __func__, ic));
854 if (--ic->ic_promisc == 0)
855 ieee80211_runtask(ic, &ic->ic_promisc_task);
856 }
857 }
858
859 /*
860 * Count number of vaps in allmulti, and issue allmulti on
861 * parent respectively.
862 */
863 #if defined(__DragonFly__)
864 void
ieee80211_allmulti(struct ieee80211vap * vap,int on)865 ieee80211_allmulti(struct ieee80211vap *vap, int on)
866 #else
867 void
868 ieee80211_allmulti(struct ieee80211vap *vap, bool on)
869 #endif
870 {
871 struct ieee80211com *ic = vap->iv_ic;
872
873 IEEE80211_LOCK_ASSERT(ic);
874
875 if (on) {
876 if (++ic->ic_allmulti == 1)
877 ieee80211_runtask(ic, &ic->ic_mcast_task);
878 } else {
879 KASSERT(ic->ic_allmulti > 0, ("%s: ic %p not allmulti",
880 __func__, ic));
881 if (--ic->ic_allmulti == 0)
882 ieee80211_runtask(ic, &ic->ic_mcast_task);
883 }
884 }
885
886 /*
887 * Synchronize flag bit state in the com structure
888 * according to the state of all vap's. This is used,
889 * for example, to handle state changes via ioctls.
890 */
891 static void
ieee80211_syncflag_locked(struct ieee80211com * ic,int flag)892 ieee80211_syncflag_locked(struct ieee80211com *ic, int flag)
893 {
894 struct ieee80211vap *vap;
895 int bit;
896
897 IEEE80211_LOCK_ASSERT(ic);
898
899 bit = 0;
900 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
901 if (vap->iv_flags & flag) {
902 bit = 1;
903 break;
904 }
905 if (bit)
906 ic->ic_flags |= flag;
907 else
908 ic->ic_flags &= ~flag;
909 }
910
911 void
ieee80211_syncflag(struct ieee80211vap * vap,int flag)912 ieee80211_syncflag(struct ieee80211vap *vap, int flag)
913 {
914 struct ieee80211com *ic = vap->iv_ic;
915
916 IEEE80211_LOCK(ic);
917 if (flag < 0) {
918 flag = -flag;
919 vap->iv_flags &= ~flag;
920 } else
921 vap->iv_flags |= flag;
922 ieee80211_syncflag_locked(ic, flag);
923 IEEE80211_UNLOCK(ic);
924 }
925
926 /*
927 * Synchronize flags_ht bit state in the com structure
928 * according to the state of all vap's. This is used,
929 * for example, to handle state changes via ioctls.
930 */
931 static void
ieee80211_syncflag_ht_locked(struct ieee80211com * ic,int flag)932 ieee80211_syncflag_ht_locked(struct ieee80211com *ic, int flag)
933 {
934 struct ieee80211vap *vap;
935 int bit;
936
937 IEEE80211_LOCK_ASSERT(ic);
938
939 bit = 0;
940 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
941 if (vap->iv_flags_ht & flag) {
942 bit = 1;
943 break;
944 }
945 if (bit)
946 ic->ic_flags_ht |= flag;
947 else
948 ic->ic_flags_ht &= ~flag;
949 }
950
951 void
ieee80211_syncflag_ht(struct ieee80211vap * vap,int flag)952 ieee80211_syncflag_ht(struct ieee80211vap *vap, int flag)
953 {
954 struct ieee80211com *ic = vap->iv_ic;
955
956 IEEE80211_LOCK(ic);
957 if (flag < 0) {
958 flag = -flag;
959 vap->iv_flags_ht &= ~flag;
960 } else
961 vap->iv_flags_ht |= flag;
962 ieee80211_syncflag_ht_locked(ic, flag);
963 IEEE80211_UNLOCK(ic);
964 }
965
966 /*
967 * Synchronize flags_ext bit state in the com structure
968 * according to the state of all vap's. This is used,
969 * for example, to handle state changes via ioctls.
970 */
971 static void
ieee80211_syncflag_ext_locked(struct ieee80211com * ic,int flag)972 ieee80211_syncflag_ext_locked(struct ieee80211com *ic, int flag)
973 {
974 struct ieee80211vap *vap;
975 int bit;
976
977 IEEE80211_LOCK_ASSERT(ic);
978
979 bit = 0;
980 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
981 if (vap->iv_flags_ext & flag) {
982 bit = 1;
983 break;
984 }
985 if (bit)
986 ic->ic_flags_ext |= flag;
987 else
988 ic->ic_flags_ext &= ~flag;
989 }
990
991 void
ieee80211_syncflag_ext(struct ieee80211vap * vap,int flag)992 ieee80211_syncflag_ext(struct ieee80211vap *vap, int flag)
993 {
994 struct ieee80211com *ic = vap->iv_ic;
995
996 IEEE80211_LOCK(ic);
997 if (flag < 0) {
998 flag = -flag;
999 vap->iv_flags_ext &= ~flag;
1000 } else
1001 vap->iv_flags_ext |= flag;
1002 ieee80211_syncflag_ext_locked(ic, flag);
1003 IEEE80211_UNLOCK(ic);
1004 }
1005
1006 static __inline int
mapgsm(u_int freq,u_int flags)1007 mapgsm(u_int freq, u_int flags)
1008 {
1009 freq *= 10;
1010 if (flags & IEEE80211_CHAN_QUARTER)
1011 freq += 5;
1012 else if (flags & IEEE80211_CHAN_HALF)
1013 freq += 10;
1014 else
1015 freq += 20;
1016 /* NB: there is no 907/20 wide but leave room */
1017 return (freq - 906*10) / 5;
1018 }
1019
1020 static __inline int
mappsb(u_int freq,u_int flags)1021 mappsb(u_int freq, u_int flags)
1022 {
1023 return 37 + ((freq * 10) + ((freq % 5) == 2 ? 5 : 0) - 49400) / 5;
1024 }
1025
1026 /*
1027 * Convert MHz frequency to IEEE channel number.
1028 */
1029 int
ieee80211_mhz2ieee(u_int freq,u_int flags)1030 ieee80211_mhz2ieee(u_int freq, u_int flags)
1031 {
1032 #define IS_FREQ_IN_PSB(_freq) ((_freq) > 4940 && (_freq) < 4990)
1033 if (flags & IEEE80211_CHAN_GSM)
1034 return mapgsm(freq, flags);
1035 if (flags & IEEE80211_CHAN_2GHZ) { /* 2GHz band */
1036 if (freq == 2484)
1037 return 14;
1038 if (freq < 2484)
1039 return ((int) freq - 2407) / 5;
1040 else
1041 return 15 + ((freq - 2512) / 20);
1042 } else if (flags & IEEE80211_CHAN_5GHZ) { /* 5Ghz band */
1043 if (freq <= 5000) {
1044 /* XXX check regdomain? */
1045 if (IS_FREQ_IN_PSB(freq))
1046 return mappsb(freq, flags);
1047 return (freq - 4000) / 5;
1048 } else
1049 return (freq - 5000) / 5;
1050 } else { /* either, guess */
1051 if (freq == 2484)
1052 return 14;
1053 if (freq < 2484) {
1054 if (907 <= freq && freq <= 922)
1055 return mapgsm(freq, flags);
1056 return ((int) freq - 2407) / 5;
1057 }
1058 if (freq < 5000) {
1059 if (IS_FREQ_IN_PSB(freq))
1060 return mappsb(freq, flags);
1061 else if (freq > 4900)
1062 return (freq - 4000) / 5;
1063 else
1064 return 15 + ((freq - 2512) / 20);
1065 }
1066 return (freq - 5000) / 5;
1067 }
1068 #undef IS_FREQ_IN_PSB
1069 }
1070
1071 /*
1072 * Convert channel to IEEE channel number.
1073 */
1074 int
ieee80211_chan2ieee(struct ieee80211com * ic,const struct ieee80211_channel * c)1075 ieee80211_chan2ieee(struct ieee80211com *ic, const struct ieee80211_channel *c)
1076 {
1077 if (c == NULL) {
1078 ic_printf(ic, "invalid channel (NULL)\n");
1079 return 0; /* XXX */
1080 }
1081 return (c == IEEE80211_CHAN_ANYC ? IEEE80211_CHAN_ANY : c->ic_ieee);
1082 }
1083
1084 /*
1085 * Convert IEEE channel number to MHz frequency.
1086 */
1087 u_int
ieee80211_ieee2mhz(u_int chan,u_int flags)1088 ieee80211_ieee2mhz(u_int chan, u_int flags)
1089 {
1090 if (flags & IEEE80211_CHAN_GSM)
1091 return 907 + 5 * (chan / 10);
1092 if (flags & IEEE80211_CHAN_2GHZ) { /* 2GHz band */
1093 if (chan == 14)
1094 return 2484;
1095 if (chan < 14)
1096 return 2407 + chan*5;
1097 else
1098 return 2512 + ((chan-15)*20);
1099 } else if (flags & IEEE80211_CHAN_5GHZ) {/* 5Ghz band */
1100 if (flags & (IEEE80211_CHAN_HALF|IEEE80211_CHAN_QUARTER)) {
1101 chan -= 37;
1102 return 4940 + chan*5 + (chan % 5 ? 2 : 0);
1103 }
1104 return 5000 + (chan*5);
1105 } else { /* either, guess */
1106 /* XXX can't distinguish PSB+GSM channels */
1107 if (chan == 14)
1108 return 2484;
1109 if (chan < 14) /* 0-13 */
1110 return 2407 + chan*5;
1111 if (chan < 27) /* 15-26 */
1112 return 2512 + ((chan-15)*20);
1113 return 5000 + (chan*5);
1114 }
1115 }
1116
1117 static __inline void
set_extchan(struct ieee80211_channel * c)1118 set_extchan(struct ieee80211_channel *c)
1119 {
1120
1121 /*
1122 * IEEE Std 802.11-2012, page 1738, subclause 20.3.15.4:
1123 * "the secondary channel number shall be 'N + [1,-1] * 4'
1124 */
1125 if (c->ic_flags & IEEE80211_CHAN_HT40U)
1126 c->ic_extieee = c->ic_ieee + 4;
1127 else if (c->ic_flags & IEEE80211_CHAN_HT40D)
1128 c->ic_extieee = c->ic_ieee - 4;
1129 else
1130 c->ic_extieee = 0;
1131 }
1132
1133 static int
addchan(struct ieee80211_channel chans[],int maxchans,int * nchans,uint8_t ieee,uint16_t freq,int8_t maxregpower,uint32_t flags)1134 addchan(struct ieee80211_channel chans[], int maxchans, int *nchans,
1135 uint8_t ieee, uint16_t freq, int8_t maxregpower, uint32_t flags)
1136 {
1137 struct ieee80211_channel *c;
1138
1139 if (*nchans >= maxchans)
1140 return (ENOBUFS);
1141
1142 c = &chans[(*nchans)++];
1143 c->ic_ieee = ieee;
1144 c->ic_freq = freq != 0 ? freq : ieee80211_ieee2mhz(ieee, flags);
1145 c->ic_maxregpower = maxregpower;
1146 c->ic_maxpower = 2 * maxregpower;
1147 c->ic_flags = flags;
1148 set_extchan(c);
1149
1150 return (0);
1151 }
1152
1153 static int
copychan_prev(struct ieee80211_channel chans[],int maxchans,int * nchans,uint32_t flags)1154 copychan_prev(struct ieee80211_channel chans[], int maxchans, int *nchans,
1155 uint32_t flags)
1156 {
1157 struct ieee80211_channel *c;
1158
1159 KASSERT(*nchans > 0, ("channel list is empty\n"));
1160
1161 if (*nchans >= maxchans)
1162 return (ENOBUFS);
1163
1164 c = &chans[(*nchans)++];
1165 c[0] = c[-1];
1166 c->ic_flags = flags;
1167 set_extchan(c);
1168
1169 return (0);
1170 }
1171
1172 static void
getflags_2ghz(const uint8_t bands[],uint32_t flags[],int ht40)1173 getflags_2ghz(const uint8_t bands[], uint32_t flags[], int ht40)
1174 {
1175 int nmodes;
1176
1177 nmodes = 0;
1178 if (isset(bands, IEEE80211_MODE_11B))
1179 flags[nmodes++] = IEEE80211_CHAN_B;
1180 if (isset(bands, IEEE80211_MODE_11G))
1181 flags[nmodes++] = IEEE80211_CHAN_G;
1182 if (isset(bands, IEEE80211_MODE_11NG))
1183 flags[nmodes++] = IEEE80211_CHAN_G | IEEE80211_CHAN_HT20;
1184 if (ht40) {
1185 flags[nmodes++] = IEEE80211_CHAN_G | IEEE80211_CHAN_HT40U;
1186 flags[nmodes++] = IEEE80211_CHAN_G | IEEE80211_CHAN_HT40D;
1187 }
1188 flags[nmodes] = 0;
1189 }
1190
1191 static void
getflags_5ghz(const uint8_t bands[],uint32_t flags[],int ht40)1192 getflags_5ghz(const uint8_t bands[], uint32_t flags[], int ht40)
1193 {
1194 int nmodes;
1195
1196 nmodes = 0;
1197 if (isset(bands, IEEE80211_MODE_11A))
1198 flags[nmodes++] = IEEE80211_CHAN_A;
1199 if (isset(bands, IEEE80211_MODE_11NA))
1200 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20;
1201 if (ht40) {
1202 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40U;
1203 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40D;
1204 }
1205 flags[nmodes] = 0;
1206 }
1207
1208 static void
getflags(const uint8_t bands[],uint32_t flags[],int ht40)1209 getflags(const uint8_t bands[], uint32_t flags[], int ht40)
1210 {
1211
1212 flags[0] = 0;
1213 if (isset(bands, IEEE80211_MODE_11A) ||
1214 isset(bands, IEEE80211_MODE_11NA)) {
1215 if (isset(bands, IEEE80211_MODE_11B) ||
1216 isset(bands, IEEE80211_MODE_11G) ||
1217 isset(bands, IEEE80211_MODE_11NG))
1218 return;
1219
1220 getflags_5ghz(bands, flags, ht40);
1221 } else
1222 getflags_2ghz(bands, flags, ht40);
1223 }
1224
1225 /*
1226 * Add one 20 MHz channel into specified channel list.
1227 */
1228 int
ieee80211_add_channel(struct ieee80211_channel chans[],int maxchans,int * nchans,uint8_t ieee,uint16_t freq,int8_t maxregpower,uint32_t chan_flags,const uint8_t bands[])1229 ieee80211_add_channel(struct ieee80211_channel chans[], int maxchans,
1230 int *nchans, uint8_t ieee, uint16_t freq, int8_t maxregpower,
1231 uint32_t chan_flags, const uint8_t bands[])
1232 {
1233 uint32_t flags[IEEE80211_MODE_MAX];
1234 int i, error;
1235
1236 getflags(bands, flags, 0);
1237 KASSERT(flags[0] != 0, ("%s: no correct mode provided\n", __func__));
1238
1239 error = addchan(chans, maxchans, nchans, ieee, freq, maxregpower,
1240 flags[0] | chan_flags);
1241 for (i = 1; flags[i] != 0 && error == 0; i++) {
1242 error = copychan_prev(chans, maxchans, nchans,
1243 flags[i] | chan_flags);
1244 }
1245
1246 return (error);
1247 }
1248
1249 static struct ieee80211_channel *
findchannel(struct ieee80211_channel chans[],int nchans,uint16_t freq,uint32_t flags)1250 findchannel(struct ieee80211_channel chans[], int nchans, uint16_t freq,
1251 uint32_t flags)
1252 {
1253 struct ieee80211_channel *c;
1254 int i;
1255
1256 flags &= IEEE80211_CHAN_ALLTURBO;
1257 /* brute force search */
1258 for (i = 0; i < nchans; i++) {
1259 c = &chans[i];
1260 if (c->ic_freq == freq &&
1261 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags)
1262 return c;
1263 }
1264 return NULL;
1265 }
1266
1267 /*
1268 * Add 40 MHz channel pair into specified channel list.
1269 */
1270 int
ieee80211_add_channel_ht40(struct ieee80211_channel chans[],int maxchans,int * nchans,uint8_t ieee,int8_t maxregpower,uint32_t flags)1271 ieee80211_add_channel_ht40(struct ieee80211_channel chans[], int maxchans,
1272 int *nchans, uint8_t ieee, int8_t maxregpower, uint32_t flags)
1273 {
1274 struct ieee80211_channel *cent, *extc;
1275 uint16_t freq;
1276 int error;
1277
1278 freq = ieee80211_ieee2mhz(ieee, flags);
1279
1280 /*
1281 * Each entry defines an HT40 channel pair; find the
1282 * center channel, then the extension channel above.
1283 */
1284 flags |= IEEE80211_CHAN_HT20;
1285 cent = findchannel(chans, *nchans, freq, flags);
1286 if (cent == NULL)
1287 return (EINVAL);
1288
1289 extc = findchannel(chans, *nchans, freq + 20, flags);
1290 if (extc == NULL)
1291 return (ENOENT);
1292
1293 flags &= ~IEEE80211_CHAN_HT;
1294 error = addchan(chans, maxchans, nchans, cent->ic_ieee, cent->ic_freq,
1295 maxregpower, flags | IEEE80211_CHAN_HT40U);
1296 if (error != 0)
1297 return (error);
1298
1299 error = addchan(chans, maxchans, nchans, extc->ic_ieee, extc->ic_freq,
1300 maxregpower, flags | IEEE80211_CHAN_HT40D);
1301
1302 return (error);
1303 }
1304
1305 /*
1306 * Adds channels into specified channel list (ieee[] array must be sorted).
1307 * Channels are already sorted.
1308 */
1309 static int
add_chanlist(struct ieee80211_channel chans[],int maxchans,int * nchans,const uint8_t ieee[],int nieee,uint32_t flags[])1310 add_chanlist(struct ieee80211_channel chans[], int maxchans, int *nchans,
1311 const uint8_t ieee[], int nieee, uint32_t flags[])
1312 {
1313 uint16_t freq;
1314 int i, j, error;
1315
1316 #if defined(__DragonFly__)
1317 error = 0; /* work-around GCC uninitialized variable warning */
1318 #endif
1319 for (i = 0; i < nieee; i++) {
1320 freq = ieee80211_ieee2mhz(ieee[i], flags[0]);
1321 for (j = 0; flags[j] != 0; j++) {
1322 if (flags[j] & IEEE80211_CHAN_HT40D)
1323 if (i == 0 || ieee[i] < ieee[0] + 4 ||
1324 freq - 20 !=
1325 ieee80211_ieee2mhz(ieee[i] - 4, flags[j]))
1326 continue;
1327 if (flags[j] & IEEE80211_CHAN_HT40U)
1328 if (i == nieee - 1 ||
1329 ieee[i] + 4 > ieee[nieee - 1] ||
1330 freq + 20 !=
1331 ieee80211_ieee2mhz(ieee[i] + 4, flags[j]))
1332 continue;
1333
1334 if (j == 0) {
1335 error = addchan(chans, maxchans, nchans,
1336 ieee[i], freq, 0, flags[j]);
1337 } else {
1338 error = copychan_prev(chans, maxchans, nchans,
1339 flags[j]);
1340 }
1341 if (error != 0)
1342 return (error);
1343 }
1344 }
1345
1346 return (error);
1347 }
1348
1349 int
ieee80211_add_channel_list_2ghz(struct ieee80211_channel chans[],int maxchans,int * nchans,const uint8_t ieee[],int nieee,const uint8_t bands[],int ht40)1350 ieee80211_add_channel_list_2ghz(struct ieee80211_channel chans[], int maxchans,
1351 int *nchans, const uint8_t ieee[], int nieee, const uint8_t bands[],
1352 int ht40)
1353 {
1354 uint32_t flags[IEEE80211_MODE_MAX];
1355
1356 getflags_2ghz(bands, flags, ht40);
1357 KASSERT(flags[0] != 0, ("%s: no correct mode provided\n", __func__));
1358
1359 return (add_chanlist(chans, maxchans, nchans, ieee, nieee, flags));
1360 }
1361
1362 int
ieee80211_add_channel_list_5ghz(struct ieee80211_channel chans[],int maxchans,int * nchans,const uint8_t ieee[],int nieee,const uint8_t bands[],int ht40)1363 ieee80211_add_channel_list_5ghz(struct ieee80211_channel chans[], int maxchans,
1364 int *nchans, const uint8_t ieee[], int nieee, const uint8_t bands[],
1365 int ht40)
1366 {
1367 uint32_t flags[IEEE80211_MODE_MAX];
1368
1369 getflags_5ghz(bands, flags, ht40);
1370 KASSERT(flags[0] != 0, ("%s: no correct mode provided\n", __func__));
1371
1372 return (add_chanlist(chans, maxchans, nchans, ieee, nieee, flags));
1373 }
1374
1375 /*
1376 * Locate a channel given a frequency+flags. We cache
1377 * the previous lookup to optimize switching between two
1378 * channels--as happens with dynamic turbo.
1379 */
1380 struct ieee80211_channel *
ieee80211_find_channel(struct ieee80211com * ic,int freq,int flags)1381 ieee80211_find_channel(struct ieee80211com *ic, int freq, int flags)
1382 {
1383 struct ieee80211_channel *c;
1384
1385 flags &= IEEE80211_CHAN_ALLTURBO;
1386 c = ic->ic_prevchan;
1387 if (c != NULL && c->ic_freq == freq &&
1388 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags)
1389 return c;
1390 /* brute force search */
1391 return (findchannel(ic->ic_channels, ic->ic_nchans, freq, flags));
1392 }
1393
1394 /*
1395 * Locate a channel given a channel number+flags. We cache
1396 * the previous lookup to optimize switching between two
1397 * channels--as happens with dynamic turbo.
1398 */
1399 struct ieee80211_channel *
ieee80211_find_channel_byieee(struct ieee80211com * ic,int ieee,int flags)1400 ieee80211_find_channel_byieee(struct ieee80211com *ic, int ieee, int flags)
1401 {
1402 struct ieee80211_channel *c;
1403 int i;
1404
1405 flags &= IEEE80211_CHAN_ALLTURBO;
1406 c = ic->ic_prevchan;
1407 if (c != NULL && c->ic_ieee == ieee &&
1408 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags)
1409 return c;
1410 /* brute force search */
1411 for (i = 0; i < ic->ic_nchans; i++) {
1412 c = &ic->ic_channels[i];
1413 if (c->ic_ieee == ieee &&
1414 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags)
1415 return c;
1416 }
1417 return NULL;
1418 }
1419
1420 /*
1421 * Lookup a channel suitable for the given rx status.
1422 *
1423 * This is used to find a channel for a frame (eg beacon, probe
1424 * response) based purely on the received PHY information.
1425 *
1426 * For now it tries to do it based on R_FREQ / R_IEEE.
1427 * This is enough for 11bg and 11a (and thus 11ng/11na)
1428 * but it will not be enough for GSM, PSB channels and the
1429 * like. It also doesn't know about legacy-turbog and
1430 * legacy-turbo modes, which some offload NICs actually
1431 * support in weird ways.
1432 *
1433 * Takes the ic and rxstatus; returns the channel or NULL
1434 * if not found.
1435 *
1436 * XXX TODO: Add support for that when the need arises.
1437 */
1438 struct ieee80211_channel *
ieee80211_lookup_channel_rxstatus(struct ieee80211vap * vap,const struct ieee80211_rx_stats * rxs)1439 ieee80211_lookup_channel_rxstatus(struct ieee80211vap *vap,
1440 const struct ieee80211_rx_stats *rxs)
1441 {
1442 struct ieee80211com *ic = vap->iv_ic;
1443 uint32_t flags;
1444 struct ieee80211_channel *c;
1445
1446 if (rxs == NULL)
1447 return (NULL);
1448
1449 /*
1450 * Strictly speaking we only use freq for now,
1451 * however later on we may wish to just store
1452 * the ieee for verification.
1453 */
1454 if ((rxs->r_flags & IEEE80211_R_FREQ) == 0)
1455 return (NULL);
1456 if ((rxs->r_flags & IEEE80211_R_IEEE) == 0)
1457 return (NULL);
1458
1459 /*
1460 * If the rx status contains a valid ieee/freq, then
1461 * ensure we populate the correct channel information
1462 * in rxchan before passing it up to the scan infrastructure.
1463 * Offload NICs will pass up beacons from all channels
1464 * during background scans.
1465 */
1466
1467 /* Determine a band */
1468 /* XXX should be done by the driver? */
1469 if (rxs->c_freq < 3000) {
1470 flags = IEEE80211_CHAN_G;
1471 } else {
1472 flags = IEEE80211_CHAN_A;
1473 }
1474
1475 /* Channel lookup */
1476 c = ieee80211_find_channel(ic, rxs->c_freq, flags);
1477
1478 IEEE80211_DPRINTF(vap, IEEE80211_MSG_INPUT,
1479 "%s: freq=%d, ieee=%d, flags=0x%08x; c=%p\n",
1480 __func__,
1481 (int) rxs->c_freq,
1482 (int) rxs->c_ieee,
1483 flags,
1484 c);
1485
1486 return (c);
1487 }
1488
1489 static void
addmedia(struct ifmedia * media,int caps,int addsta,int mode,int mword)1490 addmedia(struct ifmedia *media, int caps, int addsta, int mode, int mword)
1491 {
1492 #define ADD(_ic, _s, _o) \
1493 ifmedia_add(media, \
1494 IFM_MAKEWORD(IFM_IEEE80211, (_s), (_o), 0), 0, NULL)
1495 static const u_int mopts[IEEE80211_MODE_MAX] = {
1496 [IEEE80211_MODE_AUTO] = IFM_AUTO,
1497 [IEEE80211_MODE_11A] = IFM_IEEE80211_11A,
1498 [IEEE80211_MODE_11B] = IFM_IEEE80211_11B,
1499 [IEEE80211_MODE_11G] = IFM_IEEE80211_11G,
1500 [IEEE80211_MODE_FH] = IFM_IEEE80211_FH,
1501 [IEEE80211_MODE_TURBO_A] = IFM_IEEE80211_11A|IFM_IEEE80211_TURBO,
1502 [IEEE80211_MODE_TURBO_G] = IFM_IEEE80211_11G|IFM_IEEE80211_TURBO,
1503 [IEEE80211_MODE_STURBO_A] = IFM_IEEE80211_11A|IFM_IEEE80211_TURBO,
1504 [IEEE80211_MODE_HALF] = IFM_IEEE80211_11A, /* XXX */
1505 [IEEE80211_MODE_QUARTER] = IFM_IEEE80211_11A, /* XXX */
1506 [IEEE80211_MODE_11NA] = IFM_IEEE80211_11NA,
1507 [IEEE80211_MODE_11NG] = IFM_IEEE80211_11NG,
1508 };
1509 u_int mopt;
1510
1511 mopt = mopts[mode];
1512 if (addsta)
1513 ADD(ic, mword, mopt); /* STA mode has no cap */
1514 if (caps & IEEE80211_C_IBSS)
1515 ADD(media, mword, mopt | IFM_IEEE80211_ADHOC);
1516 if (caps & IEEE80211_C_HOSTAP)
1517 ADD(media, mword, mopt | IFM_IEEE80211_HOSTAP);
1518 if (caps & IEEE80211_C_AHDEMO)
1519 ADD(media, mword, mopt | IFM_IEEE80211_ADHOC | IFM_FLAG0);
1520 if (caps & IEEE80211_C_MONITOR)
1521 ADD(media, mword, mopt | IFM_IEEE80211_MONITOR);
1522 if (caps & IEEE80211_C_WDS)
1523 ADD(media, mword, mopt | IFM_IEEE80211_WDS);
1524 if (caps & IEEE80211_C_MBSS)
1525 ADD(media, mword, mopt | IFM_IEEE80211_MBSS);
1526 #undef ADD
1527 }
1528
1529 /*
1530 * Setup the media data structures according to the channel and
1531 * rate tables.
1532 */
1533 static int
ieee80211_media_setup(struct ieee80211com * ic,struct ifmedia * media,int caps,int addsta,ifm_change_cb_t media_change,ifm_stat_cb_t media_stat)1534 ieee80211_media_setup(struct ieee80211com *ic,
1535 struct ifmedia *media, int caps, int addsta,
1536 ifm_change_cb_t media_change, ifm_stat_cb_t media_stat)
1537 {
1538 int i, j, rate, maxrate, mword, r;
1539 enum ieee80211_phymode mode;
1540 const struct ieee80211_rateset *rs;
1541 struct ieee80211_rateset allrates;
1542
1543 /*
1544 * Fill in media characteristics.
1545 */
1546 ifmedia_init(media, 0, media_change, media_stat);
1547 maxrate = 0;
1548 /*
1549 * Add media for legacy operating modes.
1550 */
1551 memset(&allrates, 0, sizeof(allrates));
1552 for (mode = IEEE80211_MODE_AUTO; mode < IEEE80211_MODE_11NA; mode++) {
1553 if (isclr(ic->ic_modecaps, mode))
1554 continue;
1555 addmedia(media, caps, addsta, mode, IFM_AUTO);
1556 if (mode == IEEE80211_MODE_AUTO)
1557 continue;
1558 rs = &ic->ic_sup_rates[mode];
1559 for (i = 0; i < rs->rs_nrates; i++) {
1560 rate = rs->rs_rates[i];
1561 mword = ieee80211_rate2media(ic, rate, mode);
1562 if (mword == 0)
1563 continue;
1564 addmedia(media, caps, addsta, mode, mword);
1565 /*
1566 * Add legacy rate to the collection of all rates.
1567 */
1568 r = rate & IEEE80211_RATE_VAL;
1569 for (j = 0; j < allrates.rs_nrates; j++)
1570 if (allrates.rs_rates[j] == r)
1571 break;
1572 if (j == allrates.rs_nrates) {
1573 /* unique, add to the set */
1574 allrates.rs_rates[j] = r;
1575 allrates.rs_nrates++;
1576 }
1577 rate = (rate & IEEE80211_RATE_VAL) / 2;
1578 if (rate > maxrate)
1579 maxrate = rate;
1580 }
1581 }
1582 for (i = 0; i < allrates.rs_nrates; i++) {
1583 mword = ieee80211_rate2media(ic, allrates.rs_rates[i],
1584 IEEE80211_MODE_AUTO);
1585 if (mword == 0)
1586 continue;
1587 /* NB: remove media options from mword */
1588 addmedia(media, caps, addsta,
1589 IEEE80211_MODE_AUTO, IFM_SUBTYPE(mword));
1590 }
1591 /*
1592 * Add HT/11n media. Note that we do not have enough
1593 * bits in the media subtype to express the MCS so we
1594 * use a "placeholder" media subtype and any fixed MCS
1595 * must be specified with a different mechanism.
1596 */
1597 for (; mode <= IEEE80211_MODE_11NG; mode++) {
1598 if (isclr(ic->ic_modecaps, mode))
1599 continue;
1600 addmedia(media, caps, addsta, mode, IFM_AUTO);
1601 addmedia(media, caps, addsta, mode, IFM_IEEE80211_MCS);
1602 }
1603 if (isset(ic->ic_modecaps, IEEE80211_MODE_11NA) ||
1604 isset(ic->ic_modecaps, IEEE80211_MODE_11NG)) {
1605 addmedia(media, caps, addsta,
1606 IEEE80211_MODE_AUTO, IFM_IEEE80211_MCS);
1607 i = ic->ic_txstream * 8 - 1;
1608 if ((ic->ic_htcaps & IEEE80211_HTCAP_CHWIDTH40) &&
1609 (ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI40))
1610 rate = ieee80211_htrates[i].ht40_rate_400ns;
1611 else if ((ic->ic_htcaps & IEEE80211_HTCAP_CHWIDTH40))
1612 rate = ieee80211_htrates[i].ht40_rate_800ns;
1613 else if ((ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI20))
1614 rate = ieee80211_htrates[i].ht20_rate_400ns;
1615 else
1616 rate = ieee80211_htrates[i].ht20_rate_800ns;
1617 if (rate > maxrate)
1618 maxrate = rate;
1619 }
1620 return maxrate;
1621 }
1622
1623 /* XXX inline or eliminate? */
1624 const struct ieee80211_rateset *
ieee80211_get_suprates(struct ieee80211com * ic,const struct ieee80211_channel * c)1625 ieee80211_get_suprates(struct ieee80211com *ic, const struct ieee80211_channel *c)
1626 {
1627 /* XXX does this work for 11ng basic rates? */
1628 return &ic->ic_sup_rates[ieee80211_chan2mode(c)];
1629 }
1630
1631 void
ieee80211_announce(struct ieee80211com * ic)1632 ieee80211_announce(struct ieee80211com *ic)
1633 {
1634 int i, rate, mword;
1635 enum ieee80211_phymode mode;
1636 const struct ieee80211_rateset *rs;
1637
1638 /* NB: skip AUTO since it has no rates */
1639 for (mode = IEEE80211_MODE_AUTO+1; mode < IEEE80211_MODE_11NA; mode++) {
1640 if (isclr(ic->ic_modecaps, mode))
1641 continue;
1642 ic_printf(ic, "%s rates: ", ieee80211_phymode_name[mode]);
1643 rs = &ic->ic_sup_rates[mode];
1644 for (i = 0; i < rs->rs_nrates; i++) {
1645 mword = ieee80211_rate2media(ic, rs->rs_rates[i], mode);
1646 if (mword == 0)
1647 continue;
1648 rate = ieee80211_media2rate(mword);
1649 kprintf("%s%d%sMbps", (i != 0 ? " " : ""),
1650 rate / 2, ((rate & 0x1) != 0 ? ".5" : ""));
1651 }
1652 kprintf("\n");
1653 }
1654 ieee80211_ht_announce(ic);
1655 }
1656
1657 void
ieee80211_announce_channels(struct ieee80211com * ic)1658 ieee80211_announce_channels(struct ieee80211com *ic)
1659 {
1660 const struct ieee80211_channel *c;
1661 char type;
1662 int i, cw;
1663
1664 kprintf("Chan Freq CW RegPwr MinPwr MaxPwr\n");
1665 for (i = 0; i < ic->ic_nchans; i++) {
1666 c = &ic->ic_channels[i];
1667 if (IEEE80211_IS_CHAN_ST(c))
1668 type = 'S';
1669 else if (IEEE80211_IS_CHAN_108A(c))
1670 type = 'T';
1671 else if (IEEE80211_IS_CHAN_108G(c))
1672 type = 'G';
1673 else if (IEEE80211_IS_CHAN_HT(c))
1674 type = 'n';
1675 else if (IEEE80211_IS_CHAN_A(c))
1676 type = 'a';
1677 else if (IEEE80211_IS_CHAN_ANYG(c))
1678 type = 'g';
1679 else if (IEEE80211_IS_CHAN_B(c))
1680 type = 'b';
1681 else
1682 type = 'f';
1683 if (IEEE80211_IS_CHAN_HT40(c) || IEEE80211_IS_CHAN_TURBO(c))
1684 cw = 40;
1685 else if (IEEE80211_IS_CHAN_HALF(c))
1686 cw = 10;
1687 else if (IEEE80211_IS_CHAN_QUARTER(c))
1688 cw = 5;
1689 else
1690 cw = 20;
1691 kprintf("%4d %4d%c %2d%c %6d %4d.%d %4d.%d\n"
1692 , c->ic_ieee, c->ic_freq, type
1693 , cw
1694 , IEEE80211_IS_CHAN_HT40U(c) ? '+' :
1695 IEEE80211_IS_CHAN_HT40D(c) ? '-' : ' '
1696 , c->ic_maxregpower
1697 , c->ic_minpower / 2, c->ic_minpower & 1 ? 5 : 0
1698 , c->ic_maxpower / 2, c->ic_maxpower & 1 ? 5 : 0
1699 );
1700 }
1701 }
1702
1703 static int
media2mode(const struct ifmedia_entry * ime,uint32_t flags,uint16_t * mode)1704 media2mode(const struct ifmedia_entry *ime, uint32_t flags, uint16_t *mode)
1705 {
1706 switch (IFM_MODE(ime->ifm_media)) {
1707 case IFM_IEEE80211_11A:
1708 *mode = IEEE80211_MODE_11A;
1709 break;
1710 case IFM_IEEE80211_11B:
1711 *mode = IEEE80211_MODE_11B;
1712 break;
1713 case IFM_IEEE80211_11G:
1714 *mode = IEEE80211_MODE_11G;
1715 break;
1716 case IFM_IEEE80211_FH:
1717 *mode = IEEE80211_MODE_FH;
1718 break;
1719 case IFM_IEEE80211_11NA:
1720 *mode = IEEE80211_MODE_11NA;
1721 break;
1722 case IFM_IEEE80211_11NG:
1723 *mode = IEEE80211_MODE_11NG;
1724 break;
1725 case IFM_AUTO:
1726 *mode = IEEE80211_MODE_AUTO;
1727 break;
1728 default:
1729 return 0;
1730 }
1731 /*
1732 * Turbo mode is an ``option''.
1733 * XXX does not apply to AUTO
1734 */
1735 if (ime->ifm_media & IFM_IEEE80211_TURBO) {
1736 if (*mode == IEEE80211_MODE_11A) {
1737 if (flags & IEEE80211_F_TURBOP)
1738 *mode = IEEE80211_MODE_TURBO_A;
1739 else
1740 *mode = IEEE80211_MODE_STURBO_A;
1741 } else if (*mode == IEEE80211_MODE_11G)
1742 *mode = IEEE80211_MODE_TURBO_G;
1743 else
1744 return 0;
1745 }
1746 /* XXX HT40 +/- */
1747 return 1;
1748 }
1749
1750 /*
1751 * Handle a media change request on the vap interface.
1752 */
1753 int
ieee80211_media_change(struct ifnet * ifp)1754 ieee80211_media_change(struct ifnet *ifp)
1755 {
1756 struct ieee80211vap *vap = ifp->if_softc;
1757 struct ifmedia_entry *ime = vap->iv_media.ifm_cur;
1758 uint16_t newmode;
1759
1760 if (!media2mode(ime, vap->iv_flags, &newmode))
1761 return EINVAL;
1762 if (vap->iv_des_mode != newmode) {
1763 vap->iv_des_mode = newmode;
1764 /* XXX kick state machine if up+running */
1765 }
1766 return 0;
1767 }
1768
1769 /*
1770 * Common code to calculate the media status word
1771 * from the operating mode and channel state.
1772 */
1773 static int
media_status(enum ieee80211_opmode opmode,const struct ieee80211_channel * chan)1774 media_status(enum ieee80211_opmode opmode, const struct ieee80211_channel *chan)
1775 {
1776 int status;
1777
1778 status = IFM_IEEE80211;
1779 switch (opmode) {
1780 case IEEE80211_M_STA:
1781 break;
1782 case IEEE80211_M_IBSS:
1783 status |= IFM_IEEE80211_ADHOC;
1784 break;
1785 case IEEE80211_M_HOSTAP:
1786 status |= IFM_IEEE80211_HOSTAP;
1787 break;
1788 case IEEE80211_M_MONITOR:
1789 status |= IFM_IEEE80211_MONITOR;
1790 break;
1791 case IEEE80211_M_AHDEMO:
1792 status |= IFM_IEEE80211_ADHOC | IFM_FLAG0;
1793 break;
1794 case IEEE80211_M_WDS:
1795 status |= IFM_IEEE80211_WDS;
1796 break;
1797 case IEEE80211_M_MBSS:
1798 status |= IFM_IEEE80211_MBSS;
1799 break;
1800 }
1801 if (IEEE80211_IS_CHAN_HTA(chan)) {
1802 status |= IFM_IEEE80211_11NA;
1803 } else if (IEEE80211_IS_CHAN_HTG(chan)) {
1804 status |= IFM_IEEE80211_11NG;
1805 } else if (IEEE80211_IS_CHAN_A(chan)) {
1806 status |= IFM_IEEE80211_11A;
1807 } else if (IEEE80211_IS_CHAN_B(chan)) {
1808 status |= IFM_IEEE80211_11B;
1809 } else if (IEEE80211_IS_CHAN_ANYG(chan)) {
1810 status |= IFM_IEEE80211_11G;
1811 } else if (IEEE80211_IS_CHAN_FHSS(chan)) {
1812 status |= IFM_IEEE80211_FH;
1813 }
1814 /* XXX else complain? */
1815
1816 if (IEEE80211_IS_CHAN_TURBO(chan))
1817 status |= IFM_IEEE80211_TURBO;
1818 #if 0
1819 if (IEEE80211_IS_CHAN_HT20(chan))
1820 status |= IFM_IEEE80211_HT20;
1821 if (IEEE80211_IS_CHAN_HT40(chan))
1822 status |= IFM_IEEE80211_HT40;
1823 #endif
1824 return status;
1825 }
1826
1827 void
ieee80211_media_status(struct ifnet * ifp,struct ifmediareq * imr)1828 ieee80211_media_status(struct ifnet *ifp, struct ifmediareq *imr)
1829 {
1830 struct ieee80211vap *vap = ifp->if_softc;
1831 struct ieee80211com *ic = vap->iv_ic;
1832 enum ieee80211_phymode mode;
1833
1834 imr->ifm_status = IFM_AVALID;
1835 /*
1836 * NB: use the current channel's mode to lock down a xmit
1837 * rate only when running; otherwise we may have a mismatch
1838 * in which case the rate will not be convertible.
1839 */
1840 if (vap->iv_state == IEEE80211_S_RUN ||
1841 vap->iv_state == IEEE80211_S_SLEEP) {
1842 imr->ifm_status |= IFM_ACTIVE;
1843 mode = ieee80211_chan2mode(ic->ic_curchan);
1844 } else
1845 mode = IEEE80211_MODE_AUTO;
1846 imr->ifm_active = media_status(vap->iv_opmode, ic->ic_curchan);
1847 /*
1848 * Calculate a current rate if possible.
1849 */
1850 if (vap->iv_txparms[mode].ucastrate != IEEE80211_FIXED_RATE_NONE) {
1851 /*
1852 * A fixed rate is set, report that.
1853 */
1854 imr->ifm_active |= ieee80211_rate2media(ic,
1855 vap->iv_txparms[mode].ucastrate, mode);
1856 } else if (vap->iv_opmode == IEEE80211_M_STA) {
1857 /*
1858 * In station mode report the current transmit rate.
1859 */
1860 imr->ifm_active |= ieee80211_rate2media(ic,
1861 vap->iv_bss->ni_txrate, mode);
1862 } else
1863 imr->ifm_active |= IFM_AUTO;
1864 if (imr->ifm_status & IFM_ACTIVE)
1865 imr->ifm_current = imr->ifm_active;
1866 }
1867
1868 /*
1869 * Set the current phy mode and recalculate the active channel
1870 * set based on the available channels for this mode. Also
1871 * select a new default/current channel if the current one is
1872 * inappropriate for this mode.
1873 */
1874 int
ieee80211_setmode(struct ieee80211com * ic,enum ieee80211_phymode mode)1875 ieee80211_setmode(struct ieee80211com *ic, enum ieee80211_phymode mode)
1876 {
1877 /*
1878 * Adjust basic rates in 11b/11g supported rate set.
1879 * Note that if operating on a hal/quarter rate channel
1880 * this is a noop as those rates sets are different
1881 * and used instead.
1882 */
1883 if (mode == IEEE80211_MODE_11G || mode == IEEE80211_MODE_11B)
1884 ieee80211_setbasicrates(&ic->ic_sup_rates[mode], mode);
1885
1886 ic->ic_curmode = mode;
1887 ieee80211_reset_erp(ic); /* reset ERP state */
1888
1889 return 0;
1890 }
1891
1892 /*
1893 * Return the phy mode for with the specified channel.
1894 */
1895 enum ieee80211_phymode
ieee80211_chan2mode(const struct ieee80211_channel * chan)1896 ieee80211_chan2mode(const struct ieee80211_channel *chan)
1897 {
1898
1899 if (IEEE80211_IS_CHAN_HTA(chan))
1900 return IEEE80211_MODE_11NA;
1901 else if (IEEE80211_IS_CHAN_HTG(chan))
1902 return IEEE80211_MODE_11NG;
1903 else if (IEEE80211_IS_CHAN_108G(chan))
1904 return IEEE80211_MODE_TURBO_G;
1905 else if (IEEE80211_IS_CHAN_ST(chan))
1906 return IEEE80211_MODE_STURBO_A;
1907 else if (IEEE80211_IS_CHAN_TURBO(chan))
1908 return IEEE80211_MODE_TURBO_A;
1909 else if (IEEE80211_IS_CHAN_HALF(chan))
1910 return IEEE80211_MODE_HALF;
1911 else if (IEEE80211_IS_CHAN_QUARTER(chan))
1912 return IEEE80211_MODE_QUARTER;
1913 else if (IEEE80211_IS_CHAN_A(chan))
1914 return IEEE80211_MODE_11A;
1915 else if (IEEE80211_IS_CHAN_ANYG(chan))
1916 return IEEE80211_MODE_11G;
1917 else if (IEEE80211_IS_CHAN_B(chan))
1918 return IEEE80211_MODE_11B;
1919 else if (IEEE80211_IS_CHAN_FHSS(chan))
1920 return IEEE80211_MODE_FH;
1921
1922 /* NB: should not get here */
1923 kprintf("%s: cannot map channel to mode; freq %u flags 0x%x\n",
1924 __func__, chan->ic_freq, chan->ic_flags);
1925 return IEEE80211_MODE_11B;
1926 }
1927
1928 struct ratemedia {
1929 u_int match; /* rate + mode */
1930 u_int media; /* if_media rate */
1931 };
1932
1933 static int
findmedia(const struct ratemedia rates[],int n,u_int match)1934 findmedia(const struct ratemedia rates[], int n, u_int match)
1935 {
1936 int i;
1937
1938 for (i = 0; i < n; i++)
1939 if (rates[i].match == match)
1940 return rates[i].media;
1941 return IFM_AUTO;
1942 }
1943
1944 /*
1945 * Convert IEEE80211 rate value to ifmedia subtype.
1946 * Rate is either a legacy rate in units of 0.5Mbps
1947 * or an MCS index.
1948 */
1949 int
ieee80211_rate2media(struct ieee80211com * ic,int rate,enum ieee80211_phymode mode)1950 ieee80211_rate2media(struct ieee80211com *ic, int rate, enum ieee80211_phymode mode)
1951 {
1952 static const struct ratemedia rates[] = {
1953 { 2 | IFM_IEEE80211_FH, IFM_IEEE80211_FH1 },
1954 { 4 | IFM_IEEE80211_FH, IFM_IEEE80211_FH2 },
1955 { 2 | IFM_IEEE80211_11B, IFM_IEEE80211_DS1 },
1956 { 4 | IFM_IEEE80211_11B, IFM_IEEE80211_DS2 },
1957 { 11 | IFM_IEEE80211_11B, IFM_IEEE80211_DS5 },
1958 { 22 | IFM_IEEE80211_11B, IFM_IEEE80211_DS11 },
1959 { 44 | IFM_IEEE80211_11B, IFM_IEEE80211_DS22 },
1960 { 12 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM6 },
1961 { 18 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM9 },
1962 { 24 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM12 },
1963 { 36 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM18 },
1964 { 48 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM24 },
1965 { 72 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM36 },
1966 { 96 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM48 },
1967 { 108 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM54 },
1968 { 2 | IFM_IEEE80211_11G, IFM_IEEE80211_DS1 },
1969 { 4 | IFM_IEEE80211_11G, IFM_IEEE80211_DS2 },
1970 { 11 | IFM_IEEE80211_11G, IFM_IEEE80211_DS5 },
1971 { 22 | IFM_IEEE80211_11G, IFM_IEEE80211_DS11 },
1972 { 12 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM6 },
1973 { 18 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM9 },
1974 { 24 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM12 },
1975 { 36 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM18 },
1976 { 48 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM24 },
1977 { 72 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM36 },
1978 { 96 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM48 },
1979 { 108 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM54 },
1980 { 6 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM3 },
1981 { 9 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM4 },
1982 { 54 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM27 },
1983 /* NB: OFDM72 doesn't really exist so we don't handle it */
1984 };
1985 static const struct ratemedia htrates[] = {
1986 { 0, IFM_IEEE80211_MCS },
1987 { 1, IFM_IEEE80211_MCS },
1988 { 2, IFM_IEEE80211_MCS },
1989 { 3, IFM_IEEE80211_MCS },
1990 { 4, IFM_IEEE80211_MCS },
1991 { 5, IFM_IEEE80211_MCS },
1992 { 6, IFM_IEEE80211_MCS },
1993 { 7, IFM_IEEE80211_MCS },
1994 { 8, IFM_IEEE80211_MCS },
1995 { 9, IFM_IEEE80211_MCS },
1996 { 10, IFM_IEEE80211_MCS },
1997 { 11, IFM_IEEE80211_MCS },
1998 { 12, IFM_IEEE80211_MCS },
1999 { 13, IFM_IEEE80211_MCS },
2000 { 14, IFM_IEEE80211_MCS },
2001 { 15, IFM_IEEE80211_MCS },
2002 { 16, IFM_IEEE80211_MCS },
2003 { 17, IFM_IEEE80211_MCS },
2004 { 18, IFM_IEEE80211_MCS },
2005 { 19, IFM_IEEE80211_MCS },
2006 { 20, IFM_IEEE80211_MCS },
2007 { 21, IFM_IEEE80211_MCS },
2008 { 22, IFM_IEEE80211_MCS },
2009 { 23, IFM_IEEE80211_MCS },
2010 { 24, IFM_IEEE80211_MCS },
2011 { 25, IFM_IEEE80211_MCS },
2012 { 26, IFM_IEEE80211_MCS },
2013 { 27, IFM_IEEE80211_MCS },
2014 { 28, IFM_IEEE80211_MCS },
2015 { 29, IFM_IEEE80211_MCS },
2016 { 30, IFM_IEEE80211_MCS },
2017 { 31, IFM_IEEE80211_MCS },
2018 { 32, IFM_IEEE80211_MCS },
2019 { 33, IFM_IEEE80211_MCS },
2020 { 34, IFM_IEEE80211_MCS },
2021 { 35, IFM_IEEE80211_MCS },
2022 { 36, IFM_IEEE80211_MCS },
2023 { 37, IFM_IEEE80211_MCS },
2024 { 38, IFM_IEEE80211_MCS },
2025 { 39, IFM_IEEE80211_MCS },
2026 { 40, IFM_IEEE80211_MCS },
2027 { 41, IFM_IEEE80211_MCS },
2028 { 42, IFM_IEEE80211_MCS },
2029 { 43, IFM_IEEE80211_MCS },
2030 { 44, IFM_IEEE80211_MCS },
2031 { 45, IFM_IEEE80211_MCS },
2032 { 46, IFM_IEEE80211_MCS },
2033 { 47, IFM_IEEE80211_MCS },
2034 { 48, IFM_IEEE80211_MCS },
2035 { 49, IFM_IEEE80211_MCS },
2036 { 50, IFM_IEEE80211_MCS },
2037 { 51, IFM_IEEE80211_MCS },
2038 { 52, IFM_IEEE80211_MCS },
2039 { 53, IFM_IEEE80211_MCS },
2040 { 54, IFM_IEEE80211_MCS },
2041 { 55, IFM_IEEE80211_MCS },
2042 { 56, IFM_IEEE80211_MCS },
2043 { 57, IFM_IEEE80211_MCS },
2044 { 58, IFM_IEEE80211_MCS },
2045 { 59, IFM_IEEE80211_MCS },
2046 { 60, IFM_IEEE80211_MCS },
2047 { 61, IFM_IEEE80211_MCS },
2048 { 62, IFM_IEEE80211_MCS },
2049 { 63, IFM_IEEE80211_MCS },
2050 { 64, IFM_IEEE80211_MCS },
2051 { 65, IFM_IEEE80211_MCS },
2052 { 66, IFM_IEEE80211_MCS },
2053 { 67, IFM_IEEE80211_MCS },
2054 { 68, IFM_IEEE80211_MCS },
2055 { 69, IFM_IEEE80211_MCS },
2056 { 70, IFM_IEEE80211_MCS },
2057 { 71, IFM_IEEE80211_MCS },
2058 { 72, IFM_IEEE80211_MCS },
2059 { 73, IFM_IEEE80211_MCS },
2060 { 74, IFM_IEEE80211_MCS },
2061 { 75, IFM_IEEE80211_MCS },
2062 { 76, IFM_IEEE80211_MCS },
2063 };
2064 int m;
2065
2066 /*
2067 * Check 11n rates first for match as an MCS.
2068 */
2069 if (mode == IEEE80211_MODE_11NA) {
2070 if (rate & IEEE80211_RATE_MCS) {
2071 rate &= ~IEEE80211_RATE_MCS;
2072 m = findmedia(htrates, nitems(htrates), rate);
2073 if (m != IFM_AUTO)
2074 return m | IFM_IEEE80211_11NA;
2075 }
2076 } else if (mode == IEEE80211_MODE_11NG) {
2077 /* NB: 12 is ambiguous, it will be treated as an MCS */
2078 if (rate & IEEE80211_RATE_MCS) {
2079 rate &= ~IEEE80211_RATE_MCS;
2080 m = findmedia(htrates, nitems(htrates), rate);
2081 if (m != IFM_AUTO)
2082 return m | IFM_IEEE80211_11NG;
2083 }
2084 }
2085 rate &= IEEE80211_RATE_VAL;
2086 switch (mode) {
2087 case IEEE80211_MODE_11A:
2088 case IEEE80211_MODE_HALF: /* XXX good 'nuf */
2089 case IEEE80211_MODE_QUARTER:
2090 case IEEE80211_MODE_11NA:
2091 case IEEE80211_MODE_TURBO_A:
2092 case IEEE80211_MODE_STURBO_A:
2093 return findmedia(rates, nitems(rates),
2094 rate | IFM_IEEE80211_11A);
2095 case IEEE80211_MODE_11B:
2096 return findmedia(rates, nitems(rates),
2097 rate | IFM_IEEE80211_11B);
2098 case IEEE80211_MODE_FH:
2099 return findmedia(rates, nitems(rates),
2100 rate | IFM_IEEE80211_FH);
2101 case IEEE80211_MODE_AUTO:
2102 /* NB: ic may be NULL for some drivers */
2103 if (ic != NULL && ic->ic_phytype == IEEE80211_T_FH)
2104 return findmedia(rates, nitems(rates),
2105 rate | IFM_IEEE80211_FH);
2106 /* NB: hack, 11g matches both 11b+11a rates */
2107 /* fall thru... */
2108 case IEEE80211_MODE_11G:
2109 case IEEE80211_MODE_11NG:
2110 case IEEE80211_MODE_TURBO_G:
2111 return findmedia(rates, nitems(rates), rate | IFM_IEEE80211_11G);
2112 case IEEE80211_MODE_VHT_2GHZ:
2113 case IEEE80211_MODE_VHT_5GHZ:
2114 /* XXX TODO: need to figure out mapping for VHT rates */
2115 return IFM_AUTO;
2116 }
2117 return IFM_AUTO;
2118 }
2119
2120 int
ieee80211_media2rate(int mword)2121 ieee80211_media2rate(int mword)
2122 {
2123 static const int ieeerates[] = {
2124 -1, /* IFM_AUTO */
2125 0, /* IFM_MANUAL */
2126 0, /* IFM_NONE */
2127 2, /* IFM_IEEE80211_FH1 */
2128 4, /* IFM_IEEE80211_FH2 */
2129 2, /* IFM_IEEE80211_DS1 */
2130 4, /* IFM_IEEE80211_DS2 */
2131 11, /* IFM_IEEE80211_DS5 */
2132 22, /* IFM_IEEE80211_DS11 */
2133 44, /* IFM_IEEE80211_DS22 */
2134 12, /* IFM_IEEE80211_OFDM6 */
2135 18, /* IFM_IEEE80211_OFDM9 */
2136 24, /* IFM_IEEE80211_OFDM12 */
2137 36, /* IFM_IEEE80211_OFDM18 */
2138 48, /* IFM_IEEE80211_OFDM24 */
2139 72, /* IFM_IEEE80211_OFDM36 */
2140 96, /* IFM_IEEE80211_OFDM48 */
2141 108, /* IFM_IEEE80211_OFDM54 */
2142 144, /* IFM_IEEE80211_OFDM72 */
2143 0, /* IFM_IEEE80211_DS354k */
2144 0, /* IFM_IEEE80211_DS512k */
2145 6, /* IFM_IEEE80211_OFDM3 */
2146 9, /* IFM_IEEE80211_OFDM4 */
2147 54, /* IFM_IEEE80211_OFDM27 */
2148 -1, /* IFM_IEEE80211_MCS */
2149 };
2150 return IFM_SUBTYPE(mword) < nitems(ieeerates) ?
2151 ieeerates[IFM_SUBTYPE(mword)] : 0;
2152 }
2153
2154 /*
2155 * The following hash function is adapted from "Hash Functions" by Bob Jenkins
2156 * ("Algorithm Alley", Dr. Dobbs Journal, September 1997).
2157 */
2158 #define mix(a, b, c) \
2159 do { \
2160 a -= b; a -= c; a ^= (c >> 13); \
2161 b -= c; b -= a; b ^= (a << 8); \
2162 c -= a; c -= b; c ^= (b >> 13); \
2163 a -= b; a -= c; a ^= (c >> 12); \
2164 b -= c; b -= a; b ^= (a << 16); \
2165 c -= a; c -= b; c ^= (b >> 5); \
2166 a -= b; a -= c; a ^= (c >> 3); \
2167 b -= c; b -= a; b ^= (a << 10); \
2168 c -= a; c -= b; c ^= (b >> 15); \
2169 } while (/*CONSTCOND*/0)
2170
2171 uint32_t
ieee80211_mac_hash(const struct ieee80211com * ic,const uint8_t addr[IEEE80211_ADDR_LEN])2172 ieee80211_mac_hash(const struct ieee80211com *ic,
2173 const uint8_t addr[IEEE80211_ADDR_LEN])
2174 {
2175 uint32_t a = 0x9e3779b9, b = 0x9e3779b9, c = ic->ic_hash_key;
2176
2177 b += addr[5] << 8;
2178 b += addr[4];
2179 a += addr[3] << 24;
2180 a += addr[2] << 16;
2181 a += addr[1] << 8;
2182 a += addr[0];
2183
2184 mix(a, b, c);
2185
2186 return c;
2187 }
2188 #undef mix
2189
2190 char
ieee80211_channel_type_char(const struct ieee80211_channel * c)2191 ieee80211_channel_type_char(const struct ieee80211_channel *c)
2192 {
2193 if (IEEE80211_IS_CHAN_ST(c))
2194 return 'S';
2195 if (IEEE80211_IS_CHAN_108A(c))
2196 return 'T';
2197 if (IEEE80211_IS_CHAN_108G(c))
2198 return 'G';
2199 if (IEEE80211_IS_CHAN_HT(c))
2200 return 'n';
2201 if (IEEE80211_IS_CHAN_A(c))
2202 return 'a';
2203 if (IEEE80211_IS_CHAN_ANYG(c))
2204 return 'g';
2205 if (IEEE80211_IS_CHAN_B(c))
2206 return 'b';
2207 return 'f';
2208 }
2209