xref: /freebsd/sys/net80211/ieee80211.c (revision 6dbd16f1cc8590080e0e332ac9799d95d4e4484e)
11a1e1d21SSam Leffler /*-
27535e66aSSam Leffler  * Copyright (c) 2001 Atsushi Onoe
31f1d7810SSam Leffler  * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting
41a1e1d21SSam Leffler  * All rights reserved.
51a1e1d21SSam Leffler  *
61a1e1d21SSam Leffler  * Redistribution and use in source and binary forms, with or without
71a1e1d21SSam Leffler  * modification, are permitted provided that the following conditions
81a1e1d21SSam Leffler  * are met:
91a1e1d21SSam Leffler  * 1. Redistributions of source code must retain the above copyright
107535e66aSSam Leffler  *    notice, this list of conditions and the following disclaimer.
117535e66aSSam Leffler  * 2. Redistributions in binary form must reproduce the above copyright
127535e66aSSam Leffler  *    notice, this list of conditions and the following disclaimer in the
137535e66aSSam Leffler  *    documentation and/or other materials provided with the distribution.
147535e66aSSam Leffler  * 3. The name of the author may not be used to endorse or promote products
157535e66aSSam Leffler  *    derived from this software without specific prior written permission.
161a1e1d21SSam Leffler  *
171a1e1d21SSam Leffler  * Alternatively, this software may be distributed under the terms of the
181a1e1d21SSam Leffler  * GNU General Public License ("GPL") version 2 as published by the Free
191a1e1d21SSam Leffler  * Software Foundation.
201a1e1d21SSam Leffler  *
217535e66aSSam Leffler  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
227535e66aSSam Leffler  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
237535e66aSSam Leffler  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
247535e66aSSam Leffler  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
257535e66aSSam Leffler  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
267535e66aSSam Leffler  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
277535e66aSSam Leffler  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
287535e66aSSam Leffler  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
297535e66aSSam Leffler  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
307535e66aSSam Leffler  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
311a1e1d21SSam Leffler  */
321a1e1d21SSam Leffler 
331a1e1d21SSam Leffler #include <sys/cdefs.h>
341a1e1d21SSam Leffler __FBSDID("$FreeBSD$");
351a1e1d21SSam Leffler 
361a1e1d21SSam Leffler /*
371a1e1d21SSam Leffler  * IEEE 802.11 generic handler
381a1e1d21SSam Leffler  */
391a1e1d21SSam Leffler 
401a1e1d21SSam Leffler #include <sys/param.h>
411a1e1d21SSam Leffler #include <sys/systm.h>
421a1e1d21SSam Leffler #include <sys/kernel.h>
431a1e1d21SSam Leffler 
448a1b9b6aSSam Leffler #include <sys/socket.h>
451a1e1d21SSam Leffler 
461a1e1d21SSam Leffler #include <net/if.h>
471a1e1d21SSam Leffler #include <net/if_media.h>
481a1e1d21SSam Leffler #include <net/ethernet.h>
491a1e1d21SSam Leffler 
501a1e1d21SSam Leffler #include <net80211/ieee80211_var.h>
511a1e1d21SSam Leffler 
521a1e1d21SSam Leffler #include <net/bpf.h>
531a1e1d21SSam Leffler 
548da7b74fSSam Leffler const char *ieee80211_phymode_name[] = {
551a1e1d21SSam Leffler 	"auto",		/* IEEE80211_MODE_AUTO */
561a1e1d21SSam Leffler 	"11a",		/* IEEE80211_MODE_11A */
571a1e1d21SSam Leffler 	"11b",		/* IEEE80211_MODE_11B */
581a1e1d21SSam Leffler 	"11g",		/* IEEE80211_MODE_11G */
594844aa7dSAtsushi Onoe 	"FH",		/* IEEE80211_MODE_FH */
608a1b9b6aSSam Leffler 	"turboA",	/* IEEE80211_MODE_TURBO_A */
618a1b9b6aSSam Leffler 	"turboG",	/* IEEE80211_MODE_TURBO_G */
621a1e1d21SSam Leffler };
631a1e1d21SSam Leffler 
64aadecb1aSSam Leffler /*
65aadecb1aSSam Leffler  * Default supported rates for 802.11 operation (in IEEE .5Mb units).
66aadecb1aSSam Leffler  */
67aadecb1aSSam Leffler #define	B(r)	((r) | IEEE80211_RATE_BASIC)
68aadecb1aSSam Leffler static const struct ieee80211_rateset ieee80211_rateset_11a =
69aadecb1aSSam Leffler 	{ 8, { B(12), 18, B(24), 36, B(48), 72, 96, 108 } };
7041b3c790SSam Leffler static const struct ieee80211_rateset ieee80211_rateset_half =
7141b3c790SSam Leffler 	{ 8, { B(6), 9, B(12), 18, B(24), 36, 48, 54 } };
7241b3c790SSam Leffler static const struct ieee80211_rateset ieee80211_rateset_quarter =
7341b3c790SSam Leffler 	{ 8, { B(3), 4, B(6), 9, B(12), 18, 24, 27 } };
74aadecb1aSSam Leffler static const struct ieee80211_rateset ieee80211_rateset_11b =
75aadecb1aSSam Leffler 	{ 4, { B(2), B(4), B(11), B(22) } };
76aadecb1aSSam Leffler /* NB: OFDM rates are handled specially based on mode */
77aadecb1aSSam Leffler static const struct ieee80211_rateset ieee80211_rateset_11g =
78aadecb1aSSam Leffler 	{ 12, { B(2), B(4), B(11), B(22), 12, 18, 24, 36, 48, 72, 96, 108 } };
79aadecb1aSSam Leffler #undef B
80aadecb1aSSam Leffler 
818a1b9b6aSSam Leffler /* list of all instances */
828a1b9b6aSSam Leffler SLIST_HEAD(ieee80211_list, ieee80211com);
838a1b9b6aSSam Leffler static struct ieee80211_list ieee80211_list =
848a1b9b6aSSam Leffler 	SLIST_HEAD_INITIALIZER(ieee80211_list);
858a1b9b6aSSam Leffler static u_int8_t ieee80211_vapmap[32];		/* enough for 256 */
868a1b9b6aSSam Leffler static struct mtx ieee80211_vap_mtx;
878a1b9b6aSSam Leffler MTX_SYSINIT(ieee80211, &ieee80211_vap_mtx, "net80211 instances", MTX_DEF);
888a1b9b6aSSam Leffler 
898a1b9b6aSSam Leffler static void
908a1b9b6aSSam Leffler ieee80211_add_vap(struct ieee80211com *ic)
911a1e1d21SSam Leffler {
928a1b9b6aSSam Leffler #define	N(a)	(sizeof(a)/sizeof(a[0]))
938a1b9b6aSSam Leffler 	int i;
948a1b9b6aSSam Leffler 	u_int8_t b;
958a1b9b6aSSam Leffler 
968a1b9b6aSSam Leffler 	mtx_lock(&ieee80211_vap_mtx);
978a1b9b6aSSam Leffler 	ic->ic_vap = 0;
988a1b9b6aSSam Leffler 	for (i = 0; i < N(ieee80211_vapmap) && ieee80211_vapmap[i] == 0xff; i++)
998a1b9b6aSSam Leffler 		ic->ic_vap += NBBY;
1008a1b9b6aSSam Leffler 	if (i == N(ieee80211_vapmap))
1018a1b9b6aSSam Leffler 		panic("vap table full");
1028a1b9b6aSSam Leffler 	for (b = ieee80211_vapmap[i]; b & 1; b >>= 1)
1038a1b9b6aSSam Leffler 		ic->ic_vap++;
1048a1b9b6aSSam Leffler 	setbit(ieee80211_vapmap, ic->ic_vap);
1058a1b9b6aSSam Leffler 	SLIST_INSERT_HEAD(&ieee80211_list, ic, ic_next);
1068a1b9b6aSSam Leffler 	mtx_unlock(&ieee80211_vap_mtx);
1078a1b9b6aSSam Leffler #undef N
1088a1b9b6aSSam Leffler }
1098a1b9b6aSSam Leffler 
1108a1b9b6aSSam Leffler static void
1118a1b9b6aSSam Leffler ieee80211_remove_vap(struct ieee80211com *ic)
1128a1b9b6aSSam Leffler {
1138a1b9b6aSSam Leffler 	mtx_lock(&ieee80211_vap_mtx);
1148a1b9b6aSSam Leffler 	SLIST_REMOVE(&ieee80211_list, ic, ieee80211com, ic_next);
1158a1b9b6aSSam Leffler 	KASSERT(ic->ic_vap < sizeof(ieee80211_vapmap)*NBBY,
1168a1b9b6aSSam Leffler 		("invalid vap id %d", ic->ic_vap));
1178a1b9b6aSSam Leffler 	KASSERT(isset(ieee80211_vapmap, ic->ic_vap),
1188a1b9b6aSSam Leffler 		("vap id %d not allocated", ic->ic_vap));
1198a1b9b6aSSam Leffler 	clrbit(ieee80211_vapmap, ic->ic_vap);
1208a1b9b6aSSam Leffler 	mtx_unlock(&ieee80211_vap_mtx);
1218a1b9b6aSSam Leffler }
1228a1b9b6aSSam Leffler 
123badaf7bbSSam Leffler /*
124badaf7bbSSam Leffler  * Default reset method for use with the ioctl support.  This
125badaf7bbSSam Leffler  * method is invoked after any state change in the 802.11
126badaf7bbSSam Leffler  * layer that should be propagated to the hardware but not
127badaf7bbSSam Leffler  * require re-initialization of the 802.11 state machine (e.g
128badaf7bbSSam Leffler  * rescanning for an ap).  We always return ENETRESET which
129badaf7bbSSam Leffler  * should cause the driver to re-initialize the device. Drivers
130badaf7bbSSam Leffler  * can override this method to implement more optimized support.
131badaf7bbSSam Leffler  */
132badaf7bbSSam Leffler static int
133badaf7bbSSam Leffler ieee80211_default_reset(struct ifnet *ifp)
134badaf7bbSSam Leffler {
135badaf7bbSSam Leffler 	return ENETRESET;
136badaf7bbSSam Leffler }
137badaf7bbSSam Leffler 
1381a1e1d21SSam Leffler /*
1391a1e1d21SSam Leffler  * Fill in 802.11 available channel set, mark
1401a1e1d21SSam Leffler  * all available channels as active, and pick
1411a1e1d21SSam Leffler  * a default channel if not already specified.
1421a1e1d21SSam Leffler  */
14341b3c790SSam Leffler static void
14441b3c790SSam Leffler ieee80211_chan_init(struct ieee80211com *ic)
14541b3c790SSam Leffler {
14641b3c790SSam Leffler #define	DEFAULTRATES(m, def) do { \
1476dbd16f1SSam Leffler 	if (isset(ic->ic_modecaps, m) && ic->ic_sup_rates[m].rs_nrates == 0) \
14845fa8b0eSSam Leffler 		ic->ic_sup_rates[m] = def; \
14941b3c790SSam Leffler } while (0)
15041b3c790SSam Leffler 	struct ifnet *ifp = ic->ic_ifp;
15141b3c790SSam Leffler 	struct ieee80211_channel *c;
15241b3c790SSam Leffler 	int i;
15341b3c790SSam Leffler 
1541a1e1d21SSam Leffler 	memset(ic->ic_chan_avail, 0, sizeof(ic->ic_chan_avail));
1556dbd16f1SSam Leffler 	setbit(ic->ic_modecaps, IEEE80211_MODE_AUTO);
1561a1e1d21SSam Leffler 	for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
1571a1e1d21SSam Leffler 		c = &ic->ic_channels[i];
1581a1e1d21SSam Leffler 		if (c->ic_flags) {
1591a1e1d21SSam Leffler 			/*
1601a1e1d21SSam Leffler 			 * Verify driver passed us valid data.
1611a1e1d21SSam Leffler 			 */
1621a1e1d21SSam Leffler 			if (i != ieee80211_chan2ieee(ic, c)) {
1631a1e1d21SSam Leffler 				if_printf(ifp, "bad channel ignored; "
1641a1e1d21SSam Leffler 					"freq %u flags %x number %u\n",
1651a1e1d21SSam Leffler 					c->ic_freq, c->ic_flags, i);
1661a1e1d21SSam Leffler 				c->ic_flags = 0;	/* NB: remove */
1671a1e1d21SSam Leffler 				continue;
1681a1e1d21SSam Leffler 			}
1691a1e1d21SSam Leffler 			setbit(ic->ic_chan_avail, i);
1701a1e1d21SSam Leffler 			/*
1711a1e1d21SSam Leffler 			 * Identify mode capabilities.
1721a1e1d21SSam Leffler 			 */
1731a1e1d21SSam Leffler 			if (IEEE80211_IS_CHAN_A(c))
1746dbd16f1SSam Leffler 				setbit(ic->ic_modecaps, IEEE80211_MODE_11A);
1751a1e1d21SSam Leffler 			if (IEEE80211_IS_CHAN_B(c))
1766dbd16f1SSam Leffler 				setbit(ic->ic_modecaps, IEEE80211_MODE_11B);
17745fa8b0eSSam Leffler 			if (IEEE80211_IS_CHAN_ANYG(c))
1786dbd16f1SSam Leffler 				setbit(ic->ic_modecaps, IEEE80211_MODE_11G);
1794844aa7dSAtsushi Onoe 			if (IEEE80211_IS_CHAN_FHSS(c))
1806dbd16f1SSam Leffler 				setbit(ic->ic_modecaps, IEEE80211_MODE_FH);
1811a1e1d21SSam Leffler 			if (IEEE80211_IS_CHAN_T(c))
1826dbd16f1SSam Leffler 				setbit(ic->ic_modecaps, IEEE80211_MODE_TURBO_A);
1838a1b9b6aSSam Leffler 			if (IEEE80211_IS_CHAN_108G(c))
1846dbd16f1SSam Leffler 				setbit(ic->ic_modecaps, IEEE80211_MODE_TURBO_G);
185b5c99415SSam Leffler 			if (ic->ic_curchan == NULL) {
186b5c99415SSam Leffler 				/* arbitrarily pick the first channel */
187b5c99415SSam Leffler 				ic->ic_curchan = &ic->ic_channels[i];
188b5c99415SSam Leffler 			}
1891a1e1d21SSam Leffler 		}
1901a1e1d21SSam Leffler 	}
191aadecb1aSSam Leffler 
192aadecb1aSSam Leffler 	/* fillin well-known rate sets if driver has not specified */
19341b3c790SSam Leffler 	DEFAULTRATES(IEEE80211_MODE_11B,	 ieee80211_rateset_11b);
19441b3c790SSam Leffler 	DEFAULTRATES(IEEE80211_MODE_11G,	 ieee80211_rateset_11g);
19541b3c790SSam Leffler 	DEFAULTRATES(IEEE80211_MODE_11A,	 ieee80211_rateset_11a);
19641b3c790SSam Leffler 	DEFAULTRATES(IEEE80211_MODE_TURBO_A,	 ieee80211_rateset_11a);
19741b3c790SSam Leffler 	DEFAULTRATES(IEEE80211_MODE_TURBO_G,	 ieee80211_rateset_11g);
19841b3c790SSam Leffler 
19941b3c790SSam Leffler 	/*
20041b3c790SSam Leffler 	 * Set auto mode to reset active channel state and any desired channel.
20141b3c790SSam Leffler 	 */
20241b3c790SSam Leffler 	(void) ieee80211_setmode(ic, IEEE80211_MODE_AUTO);
20341b3c790SSam Leffler #undef DEFAULTRATES
20441b3c790SSam Leffler }
20541b3c790SSam Leffler 
20641b3c790SSam Leffler void
20741b3c790SSam Leffler ieee80211_ifattach(struct ieee80211com *ic)
20841b3c790SSam Leffler {
20941b3c790SSam Leffler 	struct ifnet *ifp = ic->ic_ifp;
21041b3c790SSam Leffler 
21141b3c790SSam Leffler 	ether_ifattach(ifp, ic->ic_myaddr);
21241b3c790SSam Leffler 	ifp->if_output = ieee80211_output;
21341b3c790SSam Leffler 
21441b3c790SSam Leffler 	bpfattach2(ifp, DLT_IEEE802_11,
21541b3c790SSam Leffler 	    sizeof(struct ieee80211_frame_addr4), &ic->ic_rawbpf);
21641b3c790SSam Leffler 
21741b3c790SSam Leffler 	ieee80211_crypto_attach(ic);
21841b3c790SSam Leffler 
21941b3c790SSam Leffler 	ic->ic_des_chan = IEEE80211_CHAN_ANYC;
22041b3c790SSam Leffler 	/*
22141b3c790SSam Leffler 	 * Fill in 802.11 available channel set, mark all
22241b3c790SSam Leffler 	 * available channels as active, and pick a default
22341b3c790SSam Leffler 	 * channel if not already specified.
22441b3c790SSam Leffler 	 */
22541b3c790SSam Leffler 	ieee80211_chan_init(ic);
2267076eda0SSam Leffler #if 0
2278a1b9b6aSSam Leffler 	/*
2288a1b9b6aSSam Leffler 	 * Enable WME by default if we're capable.
2298a1b9b6aSSam Leffler 	 */
2308a1b9b6aSSam Leffler 	if (ic->ic_caps & IEEE80211_C_WME)
2318a1b9b6aSSam Leffler 		ic->ic_flags |= IEEE80211_F_WME;
2327076eda0SSam Leffler #endif
233c27e4e31SSam Leffler 	if (ic->ic_caps & IEEE80211_C_BURST)
234c27e4e31SSam Leffler 		ic->ic_flags |= IEEE80211_F_BURST;
2351a1e1d21SSam Leffler 
236d365f9c7SSam Leffler 	ic->ic_bintval = IEEE80211_BINTVAL_DEFAULT;
23797bcffbdSSam Leffler 	ic->ic_bmissthreshold = IEEE80211_HWBMISS_DEFAULT;
2388a1b9b6aSSam Leffler 	ic->ic_dtim_period = IEEE80211_DTIM_DEFAULT;
2398a1b9b6aSSam Leffler 	IEEE80211_BEACON_LOCK_INIT(ic, "beacon");
2401a1e1d21SSam Leffler 
241d365f9c7SSam Leffler 	ic->ic_lintval = ic->ic_bintval;
2428a1b9b6aSSam Leffler 	ic->ic_txpowlimit = IEEE80211_TXPOWER_MAX;
2438a1b9b6aSSam Leffler 
2448a1b9b6aSSam Leffler 	ieee80211_node_attach(ic);
2458a1b9b6aSSam Leffler 	ieee80211_proto_attach(ic);
2468a1b9b6aSSam Leffler 
2478a1b9b6aSSam Leffler 	ieee80211_add_vap(ic);
2488a1b9b6aSSam Leffler 
2498a1b9b6aSSam Leffler 	ieee80211_sysctl_attach(ic);		/* NB: requires ic_vap */
250badaf7bbSSam Leffler 
251badaf7bbSSam Leffler 	/*
252badaf7bbSSam Leffler 	 * Install a default reset method for the ioctl support.
253badaf7bbSSam Leffler 	 * The driver is expected to fill this in before calling us.
254badaf7bbSSam Leffler 	 */
255badaf7bbSSam Leffler 	if (ic->ic_reset == NULL)
256badaf7bbSSam Leffler 		ic->ic_reset = ieee80211_default_reset;
257246b5467SSam Leffler 
258246b5467SSam Leffler 	KASSERT(ifp->if_spare2 == NULL, ("oops, hosed"));
259246b5467SSam Leffler 	ifp->if_spare2 = ic;			/* XXX temp backpointer */
2601a1e1d21SSam Leffler }
2611a1e1d21SSam Leffler 
2621a1e1d21SSam Leffler void
2638a1b9b6aSSam Leffler ieee80211_ifdetach(struct ieee80211com *ic)
2641a1e1d21SSam Leffler {
2658a1b9b6aSSam Leffler 	struct ifnet *ifp = ic->ic_ifp;
2661a1e1d21SSam Leffler 
2678a1b9b6aSSam Leffler 	ieee80211_remove_vap(ic);
2688a1b9b6aSSam Leffler 
2698a1b9b6aSSam Leffler 	ieee80211_sysctl_detach(ic);
270ca4ac7aeSSam Leffler 	/* NB: must be called before ieee80211_node_detach */
2718a1b9b6aSSam Leffler 	ieee80211_proto_detach(ic);
2728a1b9b6aSSam Leffler 	ieee80211_crypto_detach(ic);
2738a1b9b6aSSam Leffler 	ieee80211_node_detach(ic);
2741a1e1d21SSam Leffler 	ifmedia_removeall(&ic->ic_media);
2758a1b9b6aSSam Leffler 
2768a1b9b6aSSam Leffler 	IEEE80211_BEACON_LOCK_DESTROY(ic);
2778a1b9b6aSSam Leffler 
2781a1e1d21SSam Leffler 	bpfdetach(ifp);
2791a1e1d21SSam Leffler 	ether_ifdetach(ifp);
2801a1e1d21SSam Leffler }
2811a1e1d21SSam Leffler 
282ca4ac7aeSSam Leffler static __inline int
283ca4ac7aeSSam Leffler mapgsm(u_int freq, u_int flags)
284ca4ac7aeSSam Leffler {
285ca4ac7aeSSam Leffler 	freq *= 10;
286ca4ac7aeSSam Leffler 	if (flags & IEEE80211_CHAN_QUARTER)
287ca4ac7aeSSam Leffler 		freq += 5;
288ca4ac7aeSSam Leffler 	else if (flags & IEEE80211_CHAN_HALF)
289ca4ac7aeSSam Leffler 		freq += 10;
290ca4ac7aeSSam Leffler 	else
291ca4ac7aeSSam Leffler 		freq += 20;
292ca4ac7aeSSam Leffler 	/* NB: there is no 907/20 wide but leave room */
293ca4ac7aeSSam Leffler 	return (freq - 906*10) / 5;
294ca4ac7aeSSam Leffler }
295ca4ac7aeSSam Leffler 
296ca4ac7aeSSam Leffler static __inline int
297ca4ac7aeSSam Leffler mappsb(u_int freq, u_int flags)
298ca4ac7aeSSam Leffler {
299ca4ac7aeSSam Leffler 	return 37 + ((freq * 10) + ((freq % 5) == 2 ? 5 : 0) - 49400) / 5;
300ca4ac7aeSSam Leffler }
301ca4ac7aeSSam Leffler 
3021a1e1d21SSam Leffler /*
3031a1e1d21SSam Leffler  * Convert MHz frequency to IEEE channel number.
3041a1e1d21SSam Leffler  */
3056f322b78SSam Leffler int
3061a1e1d21SSam Leffler ieee80211_mhz2ieee(u_int freq, u_int flags)
3071a1e1d21SSam Leffler {
30811df4239SSam Leffler #define	IS_FREQ_IN_PSB(_freq) ((_freq) > 4940 && (_freq) < 4990)
309ca4ac7aeSSam Leffler 	if (flags & IEEE80211_CHAN_GSM)
310ca4ac7aeSSam Leffler 		return mapgsm(freq, flags);
3111a1e1d21SSam Leffler 	if (flags & IEEE80211_CHAN_2GHZ) {	/* 2GHz band */
3121a1e1d21SSam Leffler 		if (freq == 2484)
3131a1e1d21SSam Leffler 			return 14;
3141a1e1d21SSam Leffler 		if (freq < 2484)
3156f322b78SSam Leffler 			return ((int) freq - 2407) / 5;
3161a1e1d21SSam Leffler 		else
3171a1e1d21SSam Leffler 			return 15 + ((freq - 2512) / 20);
318c032abb5SSam Leffler 	} else if (flags & IEEE80211_CHAN_5GHZ) {	/* 5Ghz band */
31941b3c790SSam Leffler 		if (freq <= 5000) {
32011df4239SSam Leffler 			if (IS_FREQ_IN_PSB(freq))
321ca4ac7aeSSam Leffler 				return mappsb(freq, flags);
3226f322b78SSam Leffler 			return (freq - 4000) / 5;
32341b3c790SSam Leffler 		} else
3241a1e1d21SSam Leffler 			return (freq - 5000) / 5;
3251a1e1d21SSam Leffler 	} else {				/* either, guess */
3261a1e1d21SSam Leffler 		if (freq == 2484)
3271a1e1d21SSam Leffler 			return 14;
328ca4ac7aeSSam Leffler 		if (freq < 2484) {
329ca4ac7aeSSam Leffler 			if (907 <= freq && freq <= 922)
330ca4ac7aeSSam Leffler 				return mapgsm(freq, flags);
3316f322b78SSam Leffler 			return ((int) freq - 2407) / 5;
332ca4ac7aeSSam Leffler 		}
3336f322b78SSam Leffler 		if (freq < 5000) {
33411df4239SSam Leffler 			if (IS_FREQ_IN_PSB(freq))
335ca4ac7aeSSam Leffler 				return mappsb(freq, flags);
33641b3c790SSam Leffler 			else if (freq > 4900)
3376f322b78SSam Leffler 				return (freq - 4000) / 5;
3386f322b78SSam Leffler 			else
3391a1e1d21SSam Leffler 				return 15 + ((freq - 2512) / 20);
3406f322b78SSam Leffler 		}
3411a1e1d21SSam Leffler 		return (freq - 5000) / 5;
3421a1e1d21SSam Leffler 	}
34311df4239SSam Leffler #undef IS_FREQ_IN_PSB
3441a1e1d21SSam Leffler }
3451a1e1d21SSam Leffler 
3461a1e1d21SSam Leffler /*
3471a1e1d21SSam Leffler  * Convert channel to IEEE channel number.
3481a1e1d21SSam Leffler  */
3496f322b78SSam Leffler int
35038da1496SMatt Jacob ieee80211_chan2ieee(struct ieee80211com *ic, const struct ieee80211_channel *c)
3511a1e1d21SSam Leffler {
3521a1e1d21SSam Leffler 	if (ic->ic_channels <= c && c <= &ic->ic_channels[IEEE80211_CHAN_MAX])
3531a1e1d21SSam Leffler 		return c - ic->ic_channels;
3541a1e1d21SSam Leffler 	else if (c == IEEE80211_CHAN_ANYC)
3551a1e1d21SSam Leffler 		return IEEE80211_CHAN_ANY;
3568be0d570SSam Leffler 	else if (c != NULL) {
3578a1b9b6aSSam Leffler 		if_printf(ic->ic_ifp, "invalid channel freq %u flags %x\n",
3581a1e1d21SSam Leffler 			c->ic_freq, c->ic_flags);
3591a1e1d21SSam Leffler 		return 0;		/* XXX */
3608be0d570SSam Leffler 	} else {
3618a1b9b6aSSam Leffler 		if_printf(ic->ic_ifp, "invalid channel (NULL)\n");
3628be0d570SSam Leffler 		return 0;		/* XXX */
3631a1e1d21SSam Leffler 	}
3641a1e1d21SSam Leffler }
3651a1e1d21SSam Leffler 
3661a1e1d21SSam Leffler /*
3671a1e1d21SSam Leffler  * Convert IEEE channel number to MHz frequency.
3681a1e1d21SSam Leffler  */
3691a1e1d21SSam Leffler u_int
3701a1e1d21SSam Leffler ieee80211_ieee2mhz(u_int chan, u_int flags)
3711a1e1d21SSam Leffler {
372ca4ac7aeSSam Leffler 	if (flags & IEEE80211_CHAN_GSM)
373ca4ac7aeSSam Leffler 		return 907 + 5 * (chan / 10);
3741a1e1d21SSam Leffler 	if (flags & IEEE80211_CHAN_2GHZ) {	/* 2GHz band */
3751a1e1d21SSam Leffler 		if (chan == 14)
3761a1e1d21SSam Leffler 			return 2484;
3771a1e1d21SSam Leffler 		if (chan < 14)
3781a1e1d21SSam Leffler 			return 2407 + chan*5;
3791a1e1d21SSam Leffler 		else
3801a1e1d21SSam Leffler 			return 2512 + ((chan-15)*20);
3811a1e1d21SSam Leffler 	} else if (flags & IEEE80211_CHAN_5GHZ) {/* 5Ghz band */
38241b3c790SSam Leffler 		if (flags & (IEEE80211_CHAN_HALF|IEEE80211_CHAN_QUARTER)) {
38341b3c790SSam Leffler 			chan -= 37;
38441b3c790SSam Leffler 			return 4940 + chan*5 + (chan % 5 ? 2 : 0);
38541b3c790SSam Leffler 		}
3861a1e1d21SSam Leffler 		return 5000 + (chan*5);
3871a1e1d21SSam Leffler 	} else {				/* either, guess */
388ca4ac7aeSSam Leffler 		/* XXX can't distinguish PSB+GSM channels */
3891a1e1d21SSam Leffler 		if (chan == 14)
3901a1e1d21SSam Leffler 			return 2484;
3911a1e1d21SSam Leffler 		if (chan < 14)			/* 0-13 */
3921a1e1d21SSam Leffler 			return 2407 + chan*5;
3931a1e1d21SSam Leffler 		if (chan < 27)			/* 15-26 */
3941a1e1d21SSam Leffler 			return 2512 + ((chan-15)*20);
3951a1e1d21SSam Leffler 		return 5000 + (chan*5);
3961a1e1d21SSam Leffler 	}
3971a1e1d21SSam Leffler }
3981a1e1d21SSam Leffler 
3991a1e1d21SSam Leffler /*
4001a1e1d21SSam Leffler  * Setup the media data structures according to the channel and
4011a1e1d21SSam Leffler  * rate tables.  This must be called by the driver after
4021a1e1d21SSam Leffler  * ieee80211_attach and before most anything else.
4031a1e1d21SSam Leffler  */
4041a1e1d21SSam Leffler void
4058a1b9b6aSSam Leffler ieee80211_media_init(struct ieee80211com *ic,
4061a1e1d21SSam Leffler 	ifm_change_cb_t media_change, ifm_stat_cb_t media_stat)
4071a1e1d21SSam Leffler {
4081a1e1d21SSam Leffler #define	ADD(_ic, _s, _o) \
4091a1e1d21SSam Leffler 	ifmedia_add(&(_ic)->ic_media, \
4101a1e1d21SSam Leffler 		IFM_MAKEWORD(IFM_IEEE80211, (_s), (_o), 0), 0, NULL)
4118a1b9b6aSSam Leffler 	struct ifnet *ifp = ic->ic_ifp;
4121a1e1d21SSam Leffler 	struct ifmediareq imr;
4131a1e1d21SSam Leffler 	int i, j, mode, rate, maxrate, mword, mopt, r;
4141a1e1d21SSam Leffler 	struct ieee80211_rateset *rs;
4151a1e1d21SSam Leffler 	struct ieee80211_rateset allrates;
4161a1e1d21SSam Leffler 
41741b3c790SSam Leffler 	/* NB: this works because the structure is initialized to zero */
41841b3c790SSam Leffler 	if (LIST_EMPTY(&ic->ic_media.ifm_list)) {
4191a1e1d21SSam Leffler 		/*
4202692bb26SSam Leffler 		 * Do late attach work that must wait for any subclass
4212692bb26SSam Leffler 		 * (i.e. driver) work such as overriding methods.
4222692bb26SSam Leffler 		 */
4238a1b9b6aSSam Leffler 		ieee80211_node_lateattach(ic);
42441b3c790SSam Leffler 	} else {
42541b3c790SSam Leffler 		/*
42641b3c790SSam Leffler 		 * We are re-initializing the channel list; clear
42741b3c790SSam Leffler 		 * the existing media state as the media routines
42841b3c790SSam Leffler 		 * don't suppress duplicates.
42941b3c790SSam Leffler 		 */
43041b3c790SSam Leffler 		ifmedia_removeall(&ic->ic_media);
43141b3c790SSam Leffler 		ieee80211_chan_init(ic);
43241b3c790SSam Leffler 	}
4332692bb26SSam Leffler 
4342692bb26SSam Leffler 	/*
4351a1e1d21SSam Leffler 	 * Fill in media characteristics.
4361a1e1d21SSam Leffler 	 */
4371a1e1d21SSam Leffler 	ifmedia_init(&ic->ic_media, 0, media_change, media_stat);
4381a1e1d21SSam Leffler 	maxrate = 0;
4391a1e1d21SSam Leffler 	memset(&allrates, 0, sizeof(allrates));
4401a1e1d21SSam Leffler 	for (mode = IEEE80211_MODE_AUTO; mode < IEEE80211_MODE_MAX; mode++) {
4411a1e1d21SSam Leffler 		static const u_int mopts[] = {
4421a1e1d21SSam Leffler 			IFM_AUTO,
4434844aa7dSAtsushi Onoe 			IFM_IEEE80211_11A,
4444844aa7dSAtsushi Onoe 			IFM_IEEE80211_11B,
4454844aa7dSAtsushi Onoe 			IFM_IEEE80211_11G,
4464844aa7dSAtsushi Onoe 			IFM_IEEE80211_FH,
4474844aa7dSAtsushi Onoe 			IFM_IEEE80211_11A | IFM_IEEE80211_TURBO,
4488a1b9b6aSSam Leffler 			IFM_IEEE80211_11G | IFM_IEEE80211_TURBO,
4491a1e1d21SSam Leffler 		};
4506dbd16f1SSam Leffler 		if (isclr(ic->ic_modecaps, mode))
4511a1e1d21SSam Leffler 			continue;
4521a1e1d21SSam Leffler 		mopt = mopts[mode];
4531a1e1d21SSam Leffler 		ADD(ic, IFM_AUTO, mopt);	/* e.g. 11a auto */
4541a1e1d21SSam Leffler 		if (ic->ic_caps & IEEE80211_C_IBSS)
4551a1e1d21SSam Leffler 			ADD(ic, IFM_AUTO, mopt | IFM_IEEE80211_ADHOC);
4561a1e1d21SSam Leffler 		if (ic->ic_caps & IEEE80211_C_HOSTAP)
4571a1e1d21SSam Leffler 			ADD(ic, IFM_AUTO, mopt | IFM_IEEE80211_HOSTAP);
4581a1e1d21SSam Leffler 		if (ic->ic_caps & IEEE80211_C_AHDEMO)
4591a1e1d21SSam Leffler 			ADD(ic, IFM_AUTO, mopt | IFM_IEEE80211_ADHOC | IFM_FLAG0);
4602bbe529dSSam Leffler 		if (ic->ic_caps & IEEE80211_C_MONITOR)
4612bbe529dSSam Leffler 			ADD(ic, IFM_AUTO, mopt | IFM_IEEE80211_MONITOR);
4621a1e1d21SSam Leffler 		if (mode == IEEE80211_MODE_AUTO)
4631a1e1d21SSam Leffler 			continue;
4641a1e1d21SSam Leffler 		rs = &ic->ic_sup_rates[mode];
4651a1e1d21SSam Leffler 		for (i = 0; i < rs->rs_nrates; i++) {
4661a1e1d21SSam Leffler 			rate = rs->rs_rates[i];
4671a1e1d21SSam Leffler 			mword = ieee80211_rate2media(ic, rate, mode);
4681a1e1d21SSam Leffler 			if (mword == 0)
4691a1e1d21SSam Leffler 				continue;
4701a1e1d21SSam Leffler 			ADD(ic, mword, mopt);
4711a1e1d21SSam Leffler 			if (ic->ic_caps & IEEE80211_C_IBSS)
4721a1e1d21SSam Leffler 				ADD(ic, mword, mopt | IFM_IEEE80211_ADHOC);
4731a1e1d21SSam Leffler 			if (ic->ic_caps & IEEE80211_C_HOSTAP)
4741a1e1d21SSam Leffler 				ADD(ic, mword, mopt | IFM_IEEE80211_HOSTAP);
4751a1e1d21SSam Leffler 			if (ic->ic_caps & IEEE80211_C_AHDEMO)
4761a1e1d21SSam Leffler 				ADD(ic, mword, mopt | IFM_IEEE80211_ADHOC | IFM_FLAG0);
4772bbe529dSSam Leffler 			if (ic->ic_caps & IEEE80211_C_MONITOR)
4782bbe529dSSam Leffler 				ADD(ic, mword, mopt | IFM_IEEE80211_MONITOR);
4791a1e1d21SSam Leffler 			/*
4801a1e1d21SSam Leffler 			 * Add rate to the collection of all rates.
4811a1e1d21SSam Leffler 			 */
4821a1e1d21SSam Leffler 			r = rate & IEEE80211_RATE_VAL;
4831a1e1d21SSam Leffler 			for (j = 0; j < allrates.rs_nrates; j++)
4841a1e1d21SSam Leffler 				if (allrates.rs_rates[j] == r)
4851a1e1d21SSam Leffler 					break;
4861a1e1d21SSam Leffler 			if (j == allrates.rs_nrates) {
4871a1e1d21SSam Leffler 				/* unique, add to the set */
4881a1e1d21SSam Leffler 				allrates.rs_rates[j] = r;
4891a1e1d21SSam Leffler 				allrates.rs_nrates++;
4901a1e1d21SSam Leffler 			}
4911a1e1d21SSam Leffler 			rate = (rate & IEEE80211_RATE_VAL) / 2;
4921a1e1d21SSam Leffler 			if (rate > maxrate)
4931a1e1d21SSam Leffler 				maxrate = rate;
4941a1e1d21SSam Leffler 		}
4951a1e1d21SSam Leffler 	}
4961a1e1d21SSam Leffler 	for (i = 0; i < allrates.rs_nrates; i++) {
4971a1e1d21SSam Leffler 		mword = ieee80211_rate2media(ic, allrates.rs_rates[i],
4981a1e1d21SSam Leffler 				IEEE80211_MODE_AUTO);
4991a1e1d21SSam Leffler 		if (mword == 0)
5001a1e1d21SSam Leffler 			continue;
5011a1e1d21SSam Leffler 		mword = IFM_SUBTYPE(mword);	/* remove media options */
5021a1e1d21SSam Leffler 		ADD(ic, mword, 0);
5031a1e1d21SSam Leffler 		if (ic->ic_caps & IEEE80211_C_IBSS)
5041a1e1d21SSam Leffler 			ADD(ic, mword, IFM_IEEE80211_ADHOC);
5051a1e1d21SSam Leffler 		if (ic->ic_caps & IEEE80211_C_HOSTAP)
5061a1e1d21SSam Leffler 			ADD(ic, mword, IFM_IEEE80211_HOSTAP);
5071a1e1d21SSam Leffler 		if (ic->ic_caps & IEEE80211_C_AHDEMO)
5081a1e1d21SSam Leffler 			ADD(ic, mword, IFM_IEEE80211_ADHOC | IFM_FLAG0);
5092bbe529dSSam Leffler 		if (ic->ic_caps & IEEE80211_C_MONITOR)
5102bbe529dSSam Leffler 			ADD(ic, mword, IFM_IEEE80211_MONITOR);
5111a1e1d21SSam Leffler 	}
5121a1e1d21SSam Leffler 	ieee80211_media_status(ifp, &imr);
5131a1e1d21SSam Leffler 	ifmedia_set(&ic->ic_media, imr.ifm_active);
5141a1e1d21SSam Leffler 
5151a1e1d21SSam Leffler 	if (maxrate)
5161a1e1d21SSam Leffler 		ifp->if_baudrate = IF_Mbps(maxrate);
5171a1e1d21SSam Leffler #undef ADD
5181a1e1d21SSam Leffler }
5191a1e1d21SSam Leffler 
52041b3c790SSam Leffler const struct ieee80211_rateset *
52141b3c790SSam Leffler ieee80211_get_suprates(struct ieee80211com *ic, const struct ieee80211_channel *c)
52241b3c790SSam Leffler {
52341b3c790SSam Leffler 	enum ieee80211_phymode mode = ieee80211_chan2mode(ic, c);
52441b3c790SSam Leffler 
52541b3c790SSam Leffler 	if (IEEE80211_IS_CHAN_HALF(c))
52641b3c790SSam Leffler 		return &ieee80211_rateset_half;
52741b3c790SSam Leffler 	if (IEEE80211_IS_CHAN_QUARTER(c))
52841b3c790SSam Leffler 		return &ieee80211_rateset_quarter;
52941b3c790SSam Leffler 	return &ic->ic_sup_rates[mode];
53041b3c790SSam Leffler }
53141b3c790SSam Leffler 
5328a1b9b6aSSam Leffler void
5338a1b9b6aSSam Leffler ieee80211_announce(struct ieee80211com *ic)
5348a1b9b6aSSam Leffler {
5358a1b9b6aSSam Leffler 	struct ifnet *ifp = ic->ic_ifp;
5368a1b9b6aSSam Leffler 	int i, mode, rate, mword;
5378a1b9b6aSSam Leffler 	struct ieee80211_rateset *rs;
5388a1b9b6aSSam Leffler 
5398a1b9b6aSSam Leffler 	for (mode = IEEE80211_MODE_11A; mode < IEEE80211_MODE_MAX; mode++) {
5406dbd16f1SSam Leffler 		if (isclr(ic->ic_modecaps, mode))
5418a1b9b6aSSam Leffler 			continue;
5428a1b9b6aSSam Leffler 		if_printf(ifp, "%s rates: ", ieee80211_phymode_name[mode]);
5438a1b9b6aSSam Leffler 		rs = &ic->ic_sup_rates[mode];
5448a1b9b6aSSam Leffler 		for (i = 0; i < rs->rs_nrates; i++) {
5458a1b9b6aSSam Leffler 			rate = rs->rs_rates[i];
5468a1b9b6aSSam Leffler 			mword = ieee80211_rate2media(ic, rate, mode);
5478a1b9b6aSSam Leffler 			if (mword == 0)
5488a1b9b6aSSam Leffler 				continue;
5498a1b9b6aSSam Leffler 			printf("%s%d%sMbps", (i != 0 ? " " : ""),
5508a1b9b6aSSam Leffler 			    (rate & IEEE80211_RATE_VAL) / 2,
5518a1b9b6aSSam Leffler 			    ((rate & 0x1) != 0 ? ".5" : ""));
5528a1b9b6aSSam Leffler 		}
5538a1b9b6aSSam Leffler 		printf("\n");
5548a1b9b6aSSam Leffler 	}
5558a1b9b6aSSam Leffler }
5568a1b9b6aSSam Leffler 
5571a1e1d21SSam Leffler static int
5581a1e1d21SSam Leffler findrate(struct ieee80211com *ic, enum ieee80211_phymode mode, int rate)
5591a1e1d21SSam Leffler {
5601a1e1d21SSam Leffler #define	IEEERATE(_ic,_m,_i) \
5611a1e1d21SSam Leffler 	((_ic)->ic_sup_rates[_m].rs_rates[_i] & IEEE80211_RATE_VAL)
5621a1e1d21SSam Leffler 	int i, nrates = ic->ic_sup_rates[mode].rs_nrates;
5631a1e1d21SSam Leffler 	for (i = 0; i < nrates; i++)
5641a1e1d21SSam Leffler 		if (IEEERATE(ic, mode, i) == rate)
5651a1e1d21SSam Leffler 			return i;
5661a1e1d21SSam Leffler 	return -1;
5671a1e1d21SSam Leffler #undef IEEERATE
5681a1e1d21SSam Leffler }
5691a1e1d21SSam Leffler 
5701a1e1d21SSam Leffler /*
5718a1b9b6aSSam Leffler  * Find an instance by it's mac address.
5728a1b9b6aSSam Leffler  */
5738a1b9b6aSSam Leffler struct ieee80211com *
5748a1b9b6aSSam Leffler ieee80211_find_vap(const u_int8_t mac[IEEE80211_ADDR_LEN])
5758a1b9b6aSSam Leffler {
5768a1b9b6aSSam Leffler 	struct ieee80211com *ic;
5778a1b9b6aSSam Leffler 
5788a1b9b6aSSam Leffler 	/* XXX lock */
5798a1b9b6aSSam Leffler 	SLIST_FOREACH(ic, &ieee80211_list, ic_next)
5808a1b9b6aSSam Leffler 		if (IEEE80211_ADDR_EQ(mac, ic->ic_myaddr))
5818a1b9b6aSSam Leffler 			return ic;
5828a1b9b6aSSam Leffler 	return NULL;
5838a1b9b6aSSam Leffler }
5848a1b9b6aSSam Leffler 
5858a1b9b6aSSam Leffler static struct ieee80211com *
5868a1b9b6aSSam Leffler ieee80211_find_instance(struct ifnet *ifp)
5878a1b9b6aSSam Leffler {
5888a1b9b6aSSam Leffler 	struct ieee80211com *ic;
5898a1b9b6aSSam Leffler 
5908a1b9b6aSSam Leffler 	/* XXX lock */
5918a1b9b6aSSam Leffler 	/* XXX not right for multiple instances but works for now */
5928a1b9b6aSSam Leffler 	SLIST_FOREACH(ic, &ieee80211_list, ic_next)
5938a1b9b6aSSam Leffler 		if (ic->ic_ifp == ifp)
5948a1b9b6aSSam Leffler 			return ic;
5958a1b9b6aSSam Leffler 	return NULL;
5968a1b9b6aSSam Leffler }
5978a1b9b6aSSam Leffler 
5988a1b9b6aSSam Leffler /*
5991a1e1d21SSam Leffler  * Handle a media change request.
6001a1e1d21SSam Leffler  */
6011a1e1d21SSam Leffler int
6021a1e1d21SSam Leffler ieee80211_media_change(struct ifnet *ifp)
6031a1e1d21SSam Leffler {
6048a1b9b6aSSam Leffler 	struct ieee80211com *ic;
6051a1e1d21SSam Leffler 	struct ifmedia_entry *ime;
6061a1e1d21SSam Leffler 	enum ieee80211_opmode newopmode;
6071a1e1d21SSam Leffler 	enum ieee80211_phymode newphymode;
6081a1e1d21SSam Leffler 	int i, j, newrate, error = 0;
6091a1e1d21SSam Leffler 
6108a1b9b6aSSam Leffler 	ic = ieee80211_find_instance(ifp);
6118a1b9b6aSSam Leffler 	if (!ic) {
6128a1b9b6aSSam Leffler 		if_printf(ifp, "%s: no 802.11 instance!\n", __func__);
6138a1b9b6aSSam Leffler 		return EINVAL;
6148a1b9b6aSSam Leffler 	}
6151a1e1d21SSam Leffler 	ime = ic->ic_media.ifm_cur;
6161a1e1d21SSam Leffler 	/*
6171a1e1d21SSam Leffler 	 * First, identify the phy mode.
6181a1e1d21SSam Leffler 	 */
6191a1e1d21SSam Leffler 	switch (IFM_MODE(ime->ifm_media)) {
6201a1e1d21SSam Leffler 	case IFM_IEEE80211_11A:
6211a1e1d21SSam Leffler 		newphymode = IEEE80211_MODE_11A;
6221a1e1d21SSam Leffler 		break;
6231a1e1d21SSam Leffler 	case IFM_IEEE80211_11B:
6241a1e1d21SSam Leffler 		newphymode = IEEE80211_MODE_11B;
6251a1e1d21SSam Leffler 		break;
6261a1e1d21SSam Leffler 	case IFM_IEEE80211_11G:
6271a1e1d21SSam Leffler 		newphymode = IEEE80211_MODE_11G;
6281a1e1d21SSam Leffler 		break;
6294844aa7dSAtsushi Onoe 	case IFM_IEEE80211_FH:
6304844aa7dSAtsushi Onoe 		newphymode = IEEE80211_MODE_FH;
6314844aa7dSAtsushi Onoe 		break;
6321a1e1d21SSam Leffler 	case IFM_AUTO:
6331a1e1d21SSam Leffler 		newphymode = IEEE80211_MODE_AUTO;
6341a1e1d21SSam Leffler 		break;
6351a1e1d21SSam Leffler 	default:
6361a1e1d21SSam Leffler 		return EINVAL;
6371a1e1d21SSam Leffler 	}
6381a1e1d21SSam Leffler 	/*
6398a1b9b6aSSam Leffler 	 * Turbo mode is an ``option''.
6408a1b9b6aSSam Leffler 	 * XXX does not apply to AUTO
6411a1e1d21SSam Leffler 	 */
6421a1e1d21SSam Leffler 	if (ime->ifm_media & IFM_IEEE80211_TURBO) {
6438a1b9b6aSSam Leffler 		if (newphymode == IEEE80211_MODE_11A)
6448a1b9b6aSSam Leffler 			newphymode = IEEE80211_MODE_TURBO_A;
6458a1b9b6aSSam Leffler 		else if (newphymode == IEEE80211_MODE_11G)
6468a1b9b6aSSam Leffler 			newphymode = IEEE80211_MODE_TURBO_G;
6478a1b9b6aSSam Leffler 		else
6481a1e1d21SSam Leffler 			return EINVAL;
6491a1e1d21SSam Leffler 	}
6501a1e1d21SSam Leffler 	/*
6511a1e1d21SSam Leffler 	 * Validate requested mode is available.
6521a1e1d21SSam Leffler 	 */
6536dbd16f1SSam Leffler 	if (isclr(ic->ic_modecaps, newphymode))
6541a1e1d21SSam Leffler 		return EINVAL;
6551a1e1d21SSam Leffler 
6561a1e1d21SSam Leffler 	/*
6571a1e1d21SSam Leffler 	 * Next, the fixed/variable rate.
6581a1e1d21SSam Leffler 	 */
6591a1e1d21SSam Leffler 	i = -1;
6601a1e1d21SSam Leffler 	if (IFM_SUBTYPE(ime->ifm_media) != IFM_AUTO) {
6611a1e1d21SSam Leffler 		/*
6621a1e1d21SSam Leffler 		 * Convert media subtype to rate.
6631a1e1d21SSam Leffler 		 */
6641a1e1d21SSam Leffler 		newrate = ieee80211_media2rate(ime->ifm_media);
6651a1e1d21SSam Leffler 		if (newrate == 0)
6661a1e1d21SSam Leffler 			return EINVAL;
6671a1e1d21SSam Leffler 		/*
6681a1e1d21SSam Leffler 		 * Check the rate table for the specified/current phy.
6691a1e1d21SSam Leffler 		 */
6701a1e1d21SSam Leffler 		if (newphymode == IEEE80211_MODE_AUTO) {
6711a1e1d21SSam Leffler 			/*
6721a1e1d21SSam Leffler 			 * In autoselect mode search for the rate.
6731a1e1d21SSam Leffler 			 */
6741a1e1d21SSam Leffler 			for (j = IEEE80211_MODE_11A;
6751a1e1d21SSam Leffler 			     j < IEEE80211_MODE_MAX; j++) {
6766dbd16f1SSam Leffler 				if (isclr(ic->ic_modecaps, j))
6771a1e1d21SSam Leffler 					continue;
6781a1e1d21SSam Leffler 				i = findrate(ic, j, newrate);
6791a1e1d21SSam Leffler 				if (i != -1) {
6801a1e1d21SSam Leffler 					/* lock mode too */
6811a1e1d21SSam Leffler 					newphymode = j;
6821a1e1d21SSam Leffler 					break;
6831a1e1d21SSam Leffler 				}
6841a1e1d21SSam Leffler 			}
6851a1e1d21SSam Leffler 		} else {
6861a1e1d21SSam Leffler 			i = findrate(ic, newphymode, newrate);
6871a1e1d21SSam Leffler 		}
6881a1e1d21SSam Leffler 		if (i == -1)			/* mode/rate mismatch */
6891a1e1d21SSam Leffler 			return EINVAL;
6901a1e1d21SSam Leffler 	}
6911a1e1d21SSam Leffler 	/* NB: defer rate setting to later */
6921a1e1d21SSam Leffler 
6931a1e1d21SSam Leffler 	/*
6941a1e1d21SSam Leffler 	 * Deduce new operating mode but don't install it just yet.
6951a1e1d21SSam Leffler 	 */
6961a1e1d21SSam Leffler 	if ((ime->ifm_media & (IFM_IEEE80211_ADHOC|IFM_FLAG0)) ==
6971a1e1d21SSam Leffler 	    (IFM_IEEE80211_ADHOC|IFM_FLAG0))
6981a1e1d21SSam Leffler 		newopmode = IEEE80211_M_AHDEMO;
6991a1e1d21SSam Leffler 	else if (ime->ifm_media & IFM_IEEE80211_HOSTAP)
7001a1e1d21SSam Leffler 		newopmode = IEEE80211_M_HOSTAP;
7011a1e1d21SSam Leffler 	else if (ime->ifm_media & IFM_IEEE80211_ADHOC)
7021a1e1d21SSam Leffler 		newopmode = IEEE80211_M_IBSS;
7032bbe529dSSam Leffler 	else if (ime->ifm_media & IFM_IEEE80211_MONITOR)
7042bbe529dSSam Leffler 		newopmode = IEEE80211_M_MONITOR;
7051a1e1d21SSam Leffler 	else
7061a1e1d21SSam Leffler 		newopmode = IEEE80211_M_STA;
7071a1e1d21SSam Leffler 
7081a1e1d21SSam Leffler 	/*
7091a1e1d21SSam Leffler 	 * Autoselect doesn't make sense when operating as an AP.
7101a1e1d21SSam Leffler 	 * If no phy mode has been selected, pick one and lock it
7111a1e1d21SSam Leffler 	 * down so rate tables can be used in forming beacon frames
7121a1e1d21SSam Leffler 	 * and the like.
7131a1e1d21SSam Leffler 	 */
7141a1e1d21SSam Leffler 	if (newopmode == IEEE80211_M_HOSTAP &&
7151a1e1d21SSam Leffler 	    newphymode == IEEE80211_MODE_AUTO) {
7161a1e1d21SSam Leffler 		for (j = IEEE80211_MODE_11A; j < IEEE80211_MODE_MAX; j++)
7176dbd16f1SSam Leffler 			if (isset(ic->ic_modecaps, j)) {
7181a1e1d21SSam Leffler 				newphymode = j;
7191a1e1d21SSam Leffler 				break;
7201a1e1d21SSam Leffler 			}
7211a1e1d21SSam Leffler 	}
7221a1e1d21SSam Leffler 
7231a1e1d21SSam Leffler 	/*
7241a1e1d21SSam Leffler 	 * Handle phy mode change.
7251a1e1d21SSam Leffler 	 */
7261a1e1d21SSam Leffler 	if (ic->ic_curmode != newphymode) {		/* change phy mode */
7271a1e1d21SSam Leffler 		error = ieee80211_setmode(ic, newphymode);
7281a1e1d21SSam Leffler 		if (error != 0)
7291a1e1d21SSam Leffler 			return error;
7301a1e1d21SSam Leffler 		error = ENETRESET;
7311a1e1d21SSam Leffler 	}
7321a1e1d21SSam Leffler 
7331a1e1d21SSam Leffler 	/*
7341a1e1d21SSam Leffler 	 * Committed to changes, install the rate setting.
7351a1e1d21SSam Leffler 	 */
7361a1e1d21SSam Leffler 	if (ic->ic_fixed_rate != i) {
7371a1e1d21SSam Leffler 		ic->ic_fixed_rate = i;			/* set fixed tx rate */
7381a1e1d21SSam Leffler 		error = ENETRESET;
7391a1e1d21SSam Leffler 	}
7401a1e1d21SSam Leffler 
7411a1e1d21SSam Leffler 	/*
7421a1e1d21SSam Leffler 	 * Handle operating mode change.
7431a1e1d21SSam Leffler 	 */
7441a1e1d21SSam Leffler 	if (ic->ic_opmode != newopmode) {
7451a1e1d21SSam Leffler 		ic->ic_opmode = newopmode;
7461a1e1d21SSam Leffler 		switch (newopmode) {
7471a1e1d21SSam Leffler 		case IEEE80211_M_AHDEMO:
7481a1e1d21SSam Leffler 		case IEEE80211_M_HOSTAP:
7491a1e1d21SSam Leffler 		case IEEE80211_M_STA:
7502bbe529dSSam Leffler 		case IEEE80211_M_MONITOR:
7511a1e1d21SSam Leffler 			ic->ic_flags &= ~IEEE80211_F_IBSSON;
7521a1e1d21SSam Leffler 			break;
7531a1e1d21SSam Leffler 		case IEEE80211_M_IBSS:
7541a1e1d21SSam Leffler 			ic->ic_flags |= IEEE80211_F_IBSSON;
7551a1e1d21SSam Leffler 			break;
7561a1e1d21SSam Leffler 		}
7578a1b9b6aSSam Leffler 		/*
7588a1b9b6aSSam Leffler 		 * Yech, slot time may change depending on the
7598a1b9b6aSSam Leffler 		 * operating mode so reset it to be sure everything
7608a1b9b6aSSam Leffler 		 * is setup appropriately.
7618a1b9b6aSSam Leffler 		 */
7628a1b9b6aSSam Leffler 		ieee80211_reset_erp(ic);
7638a1b9b6aSSam Leffler 		ieee80211_wme_initparams(ic);	/* after opmode change */
7641a1e1d21SSam Leffler 		error = ENETRESET;
7651a1e1d21SSam Leffler 	}
7661a1e1d21SSam Leffler #ifdef notdef
7671a1e1d21SSam Leffler 	if (error == 0)
7681a1e1d21SSam Leffler 		ifp->if_baudrate = ifmedia_baudrate(ime->ifm_media);
7691a1e1d21SSam Leffler #endif
7701a1e1d21SSam Leffler 	return error;
7711a1e1d21SSam Leffler }
7721a1e1d21SSam Leffler 
7731a1e1d21SSam Leffler void
7741a1e1d21SSam Leffler ieee80211_media_status(struct ifnet *ifp, struct ifmediareq *imr)
7751a1e1d21SSam Leffler {
7768a1b9b6aSSam Leffler 	struct ieee80211com *ic;
77741b3c790SSam Leffler 	const struct ieee80211_rateset *rs;
7781a1e1d21SSam Leffler 
7798a1b9b6aSSam Leffler 	ic = ieee80211_find_instance(ifp);
7808a1b9b6aSSam Leffler 	if (!ic) {
7818a1b9b6aSSam Leffler 		if_printf(ifp, "%s: no 802.11 instance!\n", __func__);
7828a1b9b6aSSam Leffler 		return;
7838a1b9b6aSSam Leffler 	}
7841a1e1d21SSam Leffler 	imr->ifm_status = IFM_AVALID;
7851a1e1d21SSam Leffler 	imr->ifm_active = IFM_IEEE80211;
7868a1b9b6aSSam Leffler 	if (ic->ic_state == IEEE80211_S_RUN)
7871a1e1d21SSam Leffler 		imr->ifm_status |= IFM_ACTIVE;
7888a1b9b6aSSam Leffler 	/*
7898a1b9b6aSSam Leffler 	 * Calculate a current rate if possible.
7908a1b9b6aSSam Leffler 	 */
7912c39b32cSSam Leffler 	if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE) {
7928a1b9b6aSSam Leffler 		/*
7938a1b9b6aSSam Leffler 		 * A fixed rate is set, report that.
7948a1b9b6aSSam Leffler 		 */
795ca4ac7aeSSam Leffler 		rs = ieee80211_get_suprates(ic, ic->ic_curchan);
7968a1b9b6aSSam Leffler 		imr->ifm_active |= ieee80211_rate2media(ic,
7978a1b9b6aSSam Leffler 			rs->rs_rates[ic->ic_fixed_rate], ic->ic_curmode);
7988a1b9b6aSSam Leffler 	} else if (ic->ic_opmode == IEEE80211_M_STA) {
7998a1b9b6aSSam Leffler 		/*
8008a1b9b6aSSam Leffler 		 * In station mode report the current transmit rate.
8018a1b9b6aSSam Leffler 		 */
8028a1b9b6aSSam Leffler 		rs = &ic->ic_bss->ni_rates;
8038a1b9b6aSSam Leffler 		imr->ifm_active |= ieee80211_rate2media(ic,
8048a1b9b6aSSam Leffler 			rs->rs_rates[ic->ic_bss->ni_txrate], ic->ic_curmode);
805ba99a9b1SAndre Oppermann 	} else
8061a1e1d21SSam Leffler 		imr->ifm_active |= IFM_AUTO;
8071a1e1d21SSam Leffler 	switch (ic->ic_opmode) {
8081a1e1d21SSam Leffler 	case IEEE80211_M_STA:
8091a1e1d21SSam Leffler 		break;
8101a1e1d21SSam Leffler 	case IEEE80211_M_IBSS:
8111a1e1d21SSam Leffler 		imr->ifm_active |= IFM_IEEE80211_ADHOC;
8121a1e1d21SSam Leffler 		break;
8131a1e1d21SSam Leffler 	case IEEE80211_M_AHDEMO:
8141a1e1d21SSam Leffler 		/* should not come here */
8151a1e1d21SSam Leffler 		break;
8161a1e1d21SSam Leffler 	case IEEE80211_M_HOSTAP:
8171a1e1d21SSam Leffler 		imr->ifm_active |= IFM_IEEE80211_HOSTAP;
8181a1e1d21SSam Leffler 		break;
8192bbe529dSSam Leffler 	case IEEE80211_M_MONITOR:
8202bbe529dSSam Leffler 		imr->ifm_active |= IFM_IEEE80211_MONITOR;
8212bbe529dSSam Leffler 		break;
8221a1e1d21SSam Leffler 	}
8231a1e1d21SSam Leffler 	switch (ic->ic_curmode) {
8241a1e1d21SSam Leffler 	case IEEE80211_MODE_11A:
8254844aa7dSAtsushi Onoe 		imr->ifm_active |= IFM_IEEE80211_11A;
8261a1e1d21SSam Leffler 		break;
8271a1e1d21SSam Leffler 	case IEEE80211_MODE_11B:
8284844aa7dSAtsushi Onoe 		imr->ifm_active |= IFM_IEEE80211_11B;
8291a1e1d21SSam Leffler 		break;
8301a1e1d21SSam Leffler 	case IEEE80211_MODE_11G:
8314844aa7dSAtsushi Onoe 		imr->ifm_active |= IFM_IEEE80211_11G;
8324844aa7dSAtsushi Onoe 		break;
8334844aa7dSAtsushi Onoe 	case IEEE80211_MODE_FH:
8344844aa7dSAtsushi Onoe 		imr->ifm_active |= IFM_IEEE80211_FH;
8351a1e1d21SSam Leffler 		break;
8368a1b9b6aSSam Leffler 	case IEEE80211_MODE_TURBO_A:
8374844aa7dSAtsushi Onoe 		imr->ifm_active |= IFM_IEEE80211_11A
8381a1e1d21SSam Leffler 				|  IFM_IEEE80211_TURBO;
8391a1e1d21SSam Leffler 		break;
8408a1b9b6aSSam Leffler 	case IEEE80211_MODE_TURBO_G:
8418a1b9b6aSSam Leffler 		imr->ifm_active |= IFM_IEEE80211_11G
8428a1b9b6aSSam Leffler 				|  IFM_IEEE80211_TURBO;
8431a1e1d21SSam Leffler 		break;
8441a1e1d21SSam Leffler 	}
8451a1e1d21SSam Leffler }
8468a1b9b6aSSam Leffler 
8478a1b9b6aSSam Leffler void
8488a1b9b6aSSam Leffler ieee80211_watchdog(struct ieee80211com *ic)
8498a1b9b6aSSam Leffler {
8508a1b9b6aSSam Leffler 	struct ieee80211_node_table *nt;
8518a1b9b6aSSam Leffler 	int need_inact_timer = 0;
8528a1b9b6aSSam Leffler 
8538a1b9b6aSSam Leffler 	if (ic->ic_state != IEEE80211_S_INIT) {
8548a1b9b6aSSam Leffler 		if (ic->ic_mgt_timer && --ic->ic_mgt_timer == 0)
8558a1b9b6aSSam Leffler 			ieee80211_new_state(ic, IEEE80211_S_SCAN, 0);
8568a1b9b6aSSam Leffler 		nt = &ic->ic_scan;
8578a1b9b6aSSam Leffler 		if (nt->nt_inact_timer) {
8588a1b9b6aSSam Leffler 			if (--nt->nt_inact_timer == 0)
8598a1b9b6aSSam Leffler 				nt->nt_timeout(nt);
8608a1b9b6aSSam Leffler 			need_inact_timer += nt->nt_inact_timer;
8618a1b9b6aSSam Leffler 		}
862acc4f7f5SSam Leffler 		nt = &ic->ic_sta;
863acc4f7f5SSam Leffler 		if (nt->nt_inact_timer) {
8648a1b9b6aSSam Leffler 			if (--nt->nt_inact_timer == 0)
8658a1b9b6aSSam Leffler 				nt->nt_timeout(nt);
8668a1b9b6aSSam Leffler 			need_inact_timer += nt->nt_inact_timer;
8678a1b9b6aSSam Leffler 		}
8688a1b9b6aSSam Leffler 	}
8698a1b9b6aSSam Leffler 	if (ic->ic_mgt_timer != 0 || need_inact_timer)
8708a1b9b6aSSam Leffler 		ic->ic_ifp->if_timer = 1;
8711a1e1d21SSam Leffler }
8721a1e1d21SSam Leffler 
8731a1e1d21SSam Leffler /*
8741a1e1d21SSam Leffler  * Set the current phy mode and recalculate the active channel
8751a1e1d21SSam Leffler  * set based on the available channels for this mode.  Also
8761a1e1d21SSam Leffler  * select a new default/current channel if the current one is
8771a1e1d21SSam Leffler  * inappropriate for this mode.
8781a1e1d21SSam Leffler  */
8791a1e1d21SSam Leffler int
8801a1e1d21SSam Leffler ieee80211_setmode(struct ieee80211com *ic, enum ieee80211_phymode mode)
8811a1e1d21SSam Leffler {
8821a1e1d21SSam Leffler #define	N(a)	(sizeof(a) / sizeof(a[0]))
8831a1e1d21SSam Leffler 	static const u_int chanflags[] = {
8841a1e1d21SSam Leffler 		0,			/* IEEE80211_MODE_AUTO */
8851a1e1d21SSam Leffler 		IEEE80211_CHAN_A,	/* IEEE80211_MODE_11A */
8861a1e1d21SSam Leffler 		IEEE80211_CHAN_B,	/* IEEE80211_MODE_11B */
8871a1e1d21SSam Leffler 		IEEE80211_CHAN_PUREG,	/* IEEE80211_MODE_11G */
8884844aa7dSAtsushi Onoe 		IEEE80211_CHAN_FHSS,	/* IEEE80211_MODE_FH */
8898a1b9b6aSSam Leffler 		IEEE80211_CHAN_T,	/* IEEE80211_MODE_TURBO_A */
8908a1b9b6aSSam Leffler 		IEEE80211_CHAN_108G,	/* IEEE80211_MODE_TURBO_G */
8911a1e1d21SSam Leffler 	};
8921a1e1d21SSam Leffler 	struct ieee80211_channel *c;
8931a1e1d21SSam Leffler 	u_int modeflags;
8941a1e1d21SSam Leffler 	int i;
8951a1e1d21SSam Leffler 
8961a1e1d21SSam Leffler 	/* validate new mode */
8976dbd16f1SSam Leffler 	if (isclr(ic->ic_modecaps, mode)) {
8988a1b9b6aSSam Leffler 		IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
8998a1b9b6aSSam Leffler 			"%s: mode %u not supported (caps 0x%x)\n",
9008a1b9b6aSSam Leffler 			__func__, mode, ic->ic_modecaps);
9011a1e1d21SSam Leffler 		return EINVAL;
9021a1e1d21SSam Leffler 	}
9031a1e1d21SSam Leffler 
9041a1e1d21SSam Leffler 	/*
9051a1e1d21SSam Leffler 	 * Verify at least one channel is present in the available
9061a1e1d21SSam Leffler 	 * channel list before committing to the new mode.
9071a1e1d21SSam Leffler 	 */
90863beab83SSam Leffler 	KASSERT(mode < N(chanflags), ("Unexpected mode %u", mode));
9091a1e1d21SSam Leffler 	modeflags = chanflags[mode];
9101a1e1d21SSam Leffler 	for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
9111a1e1d21SSam Leffler 		c = &ic->ic_channels[i];
9126cfac107SSam Leffler 		if (c->ic_flags == 0)
9136cfac107SSam Leffler 			continue;
9141a1e1d21SSam Leffler 		if (mode == IEEE80211_MODE_AUTO) {
915399178c9SSam Leffler 			/* ignore static turbo channels for autoselect */
916399178c9SSam Leffler 			if (!IEEE80211_IS_CHAN_T(c))
9171a1e1d21SSam Leffler 				break;
9181a1e1d21SSam Leffler 		} else {
9191a1e1d21SSam Leffler 			if ((c->ic_flags & modeflags) == modeflags)
9201a1e1d21SSam Leffler 				break;
9211a1e1d21SSam Leffler 		}
9221a1e1d21SSam Leffler 	}
9231a1e1d21SSam Leffler 	if (i > IEEE80211_CHAN_MAX) {
9248a1b9b6aSSam Leffler 		IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
9258a1b9b6aSSam Leffler 			"%s: no channels found for mode %u\n", __func__, mode);
9261a1e1d21SSam Leffler 		return EINVAL;
9271a1e1d21SSam Leffler 	}
9281a1e1d21SSam Leffler 
9291a1e1d21SSam Leffler 	/*
9301a1e1d21SSam Leffler 	 * Calculate the active channel set.
9311a1e1d21SSam Leffler 	 */
9321a1e1d21SSam Leffler 	memset(ic->ic_chan_active, 0, sizeof(ic->ic_chan_active));
9331a1e1d21SSam Leffler 	for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
9341a1e1d21SSam Leffler 		c = &ic->ic_channels[i];
9356cfac107SSam Leffler 		if (c->ic_flags == 0)
9366cfac107SSam Leffler 			continue;
9371a1e1d21SSam Leffler 		if (mode == IEEE80211_MODE_AUTO) {
938399178c9SSam Leffler 			/* take anything but static turbo channels */
939399178c9SSam Leffler 			if (!IEEE80211_IS_CHAN_T(c))
9401a1e1d21SSam Leffler 				setbit(ic->ic_chan_active, i);
9411a1e1d21SSam Leffler 		} else {
9421a1e1d21SSam Leffler 			if ((c->ic_flags & modeflags) == modeflags)
9431a1e1d21SSam Leffler 				setbit(ic->ic_chan_active, i);
9441a1e1d21SSam Leffler 		}
9451a1e1d21SSam Leffler 	}
9461a1e1d21SSam Leffler 	/*
9471a1e1d21SSam Leffler 	 * If no current/default channel is setup or the current
9481a1e1d21SSam Leffler 	 * channel is wrong for the mode then pick the first
9491a1e1d21SSam Leffler 	 * available channel from the active list.  This is likely
9501a1e1d21SSam Leffler 	 * not the right one.
9511a1e1d21SSam Leffler 	 */
952ca4ac7aeSSam Leffler 	if (isclr(ic->ic_chan_active, ieee80211_chan2ieee(ic, ic->ic_curchan))) {
953ca4ac7aeSSam Leffler 		ic->ic_curchan = NULL;
9541a1e1d21SSam Leffler 		for (i = 0; i <= IEEE80211_CHAN_MAX; i++)
9551a1e1d21SSam Leffler 			if (isset(ic->ic_chan_active, i)) {
956ca4ac7aeSSam Leffler 				ic->ic_curchan = &ic->ic_channels[i];
9571a1e1d21SSam Leffler 				break;
9581a1e1d21SSam Leffler 			}
959ca4ac7aeSSam Leffler 		KASSERT(ic->ic_curchan != NULL, ("no current channel"));
9601a1e1d21SSam Leffler 	}
961ca4ac7aeSSam Leffler 	if (ic->ic_ibss_chan == NULL ||
962ca4ac7aeSSam Leffler 	    isclr(ic->ic_chan_active, ieee80211_chan2ieee(ic, ic->ic_ibss_chan)))
963ca4ac7aeSSam Leffler 		ic->ic_ibss_chan = ic->ic_curchan;
9648a1b9b6aSSam Leffler 	/*
9658a1b9b6aSSam Leffler 	 * If the desired channel is set but no longer valid then reset it.
9668a1b9b6aSSam Leffler 	 */
9678a1b9b6aSSam Leffler 	if (ic->ic_des_chan != IEEE80211_CHAN_ANYC &&
9688a1b9b6aSSam Leffler 	    isclr(ic->ic_chan_active, ieee80211_chan2ieee(ic, ic->ic_des_chan)))
9698a1b9b6aSSam Leffler 		ic->ic_des_chan = IEEE80211_CHAN_ANYC;
9701a1e1d21SSam Leffler 
9711a1e1d21SSam Leffler 	/*
972ca4ac7aeSSam Leffler 	 * Adjust basic rates in 11b/11g supported rate set.
973ca4ac7aeSSam Leffler 	 * Note that if operating on a hal/quarter rate channel
974ca4ac7aeSSam Leffler 	 * this is a noop as those rates sets are different
975ca4ac7aeSSam Leffler 	 * and used instead.
9761a1e1d21SSam Leffler 	 */
977ca4ac7aeSSam Leffler 	if (mode == IEEE80211_MODE_11G || mode == IEEE80211_MODE_11B)
978ca4ac7aeSSam Leffler 		ieee80211_set11gbasicrates(&ic->ic_sup_rates[mode], mode);
979ca4ac7aeSSam Leffler 
9808a1b9b6aSSam Leffler 	/*
9818a1b9b6aSSam Leffler 	 * Setup an initial rate set according to the
9828a1b9b6aSSam Leffler 	 * current/default channel selected above.  This
9838a1b9b6aSSam Leffler 	 * will be changed when scanning but must exist
9848a1b9b6aSSam Leffler 	 * now so driver have a consistent state of ic_ibss_chan.
9858a1b9b6aSSam Leffler 	 */
986ca4ac7aeSSam Leffler 	if (ic->ic_bss != NULL)	/* NB: can be called before lateattach */
9878a1b9b6aSSam Leffler 		ic->ic_bss->ni_rates = ic->ic_sup_rates[mode];
9881a1e1d21SSam Leffler 
9891a1e1d21SSam Leffler 	ic->ic_curmode = mode;
9908a1b9b6aSSam Leffler 	ieee80211_reset_erp(ic);	/* reset ERP state */
9918a1b9b6aSSam Leffler 	ieee80211_wme_initparams(ic);	/* reset WME stat */
9928a1b9b6aSSam Leffler 
9931a1e1d21SSam Leffler 	return 0;
9941a1e1d21SSam Leffler #undef N
9951a1e1d21SSam Leffler }
9961a1e1d21SSam Leffler 
9971a1e1d21SSam Leffler /*
9981a1e1d21SSam Leffler  * Return the phy mode for with the specified channel so the
9998a1b9b6aSSam Leffler  * caller can select a rate set.  This is problematic for channels
10008a1b9b6aSSam Leffler  * where multiple operating modes are possible (e.g. 11g+11b).
10018a1b9b6aSSam Leffler  * In those cases we defer to the current operating mode when set.
10021a1e1d21SSam Leffler  */
10031a1e1d21SSam Leffler enum ieee80211_phymode
100441b3c790SSam Leffler ieee80211_chan2mode(struct ieee80211com *ic, const struct ieee80211_channel *chan)
10051a1e1d21SSam Leffler {
10066cfac107SSam Leffler 	if (IEEE80211_IS_CHAN_T(chan)) {
10078a1b9b6aSSam Leffler 		return IEEE80211_MODE_TURBO_A;
10086cfac107SSam Leffler 	} else if (IEEE80211_IS_CHAN_5GHZ(chan)) {
10091a1e1d21SSam Leffler 		return IEEE80211_MODE_11A;
10108a1b9b6aSSam Leffler 	} else if (IEEE80211_IS_CHAN_FHSS(chan))
10114844aa7dSAtsushi Onoe 		return IEEE80211_MODE_FH;
10128a1b9b6aSSam Leffler 	else if (chan->ic_flags & (IEEE80211_CHAN_OFDM|IEEE80211_CHAN_DYN)) {
10138a1b9b6aSSam Leffler 		/*
10148a1b9b6aSSam Leffler 		 * This assumes all 11g channels are also usable
10158a1b9b6aSSam Leffler 		 * for 11b, which is currently true.
10168a1b9b6aSSam Leffler 		 */
10178a1b9b6aSSam Leffler 		if (ic->ic_curmode == IEEE80211_MODE_TURBO_G)
10188a1b9b6aSSam Leffler 			return IEEE80211_MODE_TURBO_G;
10198a1b9b6aSSam Leffler 		if (ic->ic_curmode == IEEE80211_MODE_11B)
10208a1b9b6aSSam Leffler 			return IEEE80211_MODE_11B;
10211a1e1d21SSam Leffler 		return IEEE80211_MODE_11G;
10228a1b9b6aSSam Leffler 	} else
10231a1e1d21SSam Leffler 		return IEEE80211_MODE_11B;
10241a1e1d21SSam Leffler }
10251a1e1d21SSam Leffler 
10261a1e1d21SSam Leffler /*
10271a1e1d21SSam Leffler  * convert IEEE80211 rate value to ifmedia subtype.
10281a1e1d21SSam Leffler  * ieee80211 rate is in unit of 0.5Mbps.
10291a1e1d21SSam Leffler  */
10301a1e1d21SSam Leffler int
10311a1e1d21SSam Leffler ieee80211_rate2media(struct ieee80211com *ic, int rate, enum ieee80211_phymode mode)
10321a1e1d21SSam Leffler {
10331a1e1d21SSam Leffler #define	N(a)	(sizeof(a) / sizeof(a[0]))
10341a1e1d21SSam Leffler 	static const struct {
10351a1e1d21SSam Leffler 		u_int	m;	/* rate + mode */
10361a1e1d21SSam Leffler 		u_int	r;	/* if_media rate */
10371a1e1d21SSam Leffler 	} rates[] = {
10384844aa7dSAtsushi Onoe 		{   2 | IFM_IEEE80211_FH, IFM_IEEE80211_FH1 },
10394844aa7dSAtsushi Onoe 		{   4 | IFM_IEEE80211_FH, IFM_IEEE80211_FH2 },
10404844aa7dSAtsushi Onoe 		{   2 | IFM_IEEE80211_11B, IFM_IEEE80211_DS1 },
10414844aa7dSAtsushi Onoe 		{   4 | IFM_IEEE80211_11B, IFM_IEEE80211_DS2 },
10424844aa7dSAtsushi Onoe 		{  11 | IFM_IEEE80211_11B, IFM_IEEE80211_DS5 },
10434844aa7dSAtsushi Onoe 		{  22 | IFM_IEEE80211_11B, IFM_IEEE80211_DS11 },
10444844aa7dSAtsushi Onoe 		{  44 | IFM_IEEE80211_11B, IFM_IEEE80211_DS22 },
10454844aa7dSAtsushi Onoe 		{  12 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM6 },
10464844aa7dSAtsushi Onoe 		{  18 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM9 },
10474844aa7dSAtsushi Onoe 		{  24 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM12 },
10484844aa7dSAtsushi Onoe 		{  36 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM18 },
10494844aa7dSAtsushi Onoe 		{  48 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM24 },
10504844aa7dSAtsushi Onoe 		{  72 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM36 },
10514844aa7dSAtsushi Onoe 		{  96 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM48 },
10524844aa7dSAtsushi Onoe 		{ 108 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM54 },
10534844aa7dSAtsushi Onoe 		{   2 | IFM_IEEE80211_11G, IFM_IEEE80211_DS1 },
10544844aa7dSAtsushi Onoe 		{   4 | IFM_IEEE80211_11G, IFM_IEEE80211_DS2 },
10554844aa7dSAtsushi Onoe 		{  11 | IFM_IEEE80211_11G, IFM_IEEE80211_DS5 },
10564844aa7dSAtsushi Onoe 		{  22 | IFM_IEEE80211_11G, IFM_IEEE80211_DS11 },
10574844aa7dSAtsushi Onoe 		{  12 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM6 },
10584844aa7dSAtsushi Onoe 		{  18 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM9 },
10594844aa7dSAtsushi Onoe 		{  24 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM12 },
10604844aa7dSAtsushi Onoe 		{  36 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM18 },
10614844aa7dSAtsushi Onoe 		{  48 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM24 },
10624844aa7dSAtsushi Onoe 		{  72 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM36 },
10634844aa7dSAtsushi Onoe 		{  96 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM48 },
10644844aa7dSAtsushi Onoe 		{ 108 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM54 },
106541b3c790SSam Leffler 		{   6 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM3 },
106641b3c790SSam Leffler 		{   9 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM4 },
106741b3c790SSam Leffler 		{  54 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM27 },
10681a1e1d21SSam Leffler 		/* NB: OFDM72 doesn't realy exist so we don't handle it */
10691a1e1d21SSam Leffler 	};
10701a1e1d21SSam Leffler 	u_int mask, i;
10711a1e1d21SSam Leffler 
10721a1e1d21SSam Leffler 	mask = rate & IEEE80211_RATE_VAL;
10731a1e1d21SSam Leffler 	switch (mode) {
10741a1e1d21SSam Leffler 	case IEEE80211_MODE_11A:
10758a1b9b6aSSam Leffler 	case IEEE80211_MODE_TURBO_A:
10764844aa7dSAtsushi Onoe 		mask |= IFM_IEEE80211_11A;
10771a1e1d21SSam Leffler 		break;
10781a1e1d21SSam Leffler 	case IEEE80211_MODE_11B:
10794844aa7dSAtsushi Onoe 		mask |= IFM_IEEE80211_11B;
10804844aa7dSAtsushi Onoe 		break;
10814844aa7dSAtsushi Onoe 	case IEEE80211_MODE_FH:
10824844aa7dSAtsushi Onoe 		mask |= IFM_IEEE80211_FH;
10831a1e1d21SSam Leffler 		break;
10841a1e1d21SSam Leffler 	case IEEE80211_MODE_AUTO:
10851a1e1d21SSam Leffler 		/* NB: ic may be NULL for some drivers */
10861a1e1d21SSam Leffler 		if (ic && ic->ic_phytype == IEEE80211_T_FH) {
10874844aa7dSAtsushi Onoe 			mask |= IFM_IEEE80211_FH;
10884844aa7dSAtsushi Onoe 			break;
10891a1e1d21SSam Leffler 		}
10901a1e1d21SSam Leffler 		/* NB: hack, 11g matches both 11b+11a rates */
10911a1e1d21SSam Leffler 		/* fall thru... */
10921a1e1d21SSam Leffler 	case IEEE80211_MODE_11G:
10938a1b9b6aSSam Leffler 	case IEEE80211_MODE_TURBO_G:
10944844aa7dSAtsushi Onoe 		mask |= IFM_IEEE80211_11G;
10951a1e1d21SSam Leffler 		break;
10961a1e1d21SSam Leffler 	}
10971a1e1d21SSam Leffler 	for (i = 0; i < N(rates); i++)
10981a1e1d21SSam Leffler 		if (rates[i].m == mask)
10991a1e1d21SSam Leffler 			return rates[i].r;
11001a1e1d21SSam Leffler 	return IFM_AUTO;
11011a1e1d21SSam Leffler #undef N
11021a1e1d21SSam Leffler }
11031a1e1d21SSam Leffler 
11041a1e1d21SSam Leffler int
11051a1e1d21SSam Leffler ieee80211_media2rate(int mword)
11061a1e1d21SSam Leffler {
11071a1e1d21SSam Leffler #define	N(a)	(sizeof(a) / sizeof(a[0]))
11081a1e1d21SSam Leffler 	static const int ieeerates[] = {
11091a1e1d21SSam Leffler 		-1,		/* IFM_AUTO */
11101a1e1d21SSam Leffler 		0,		/* IFM_MANUAL */
11111a1e1d21SSam Leffler 		0,		/* IFM_NONE */
11121a1e1d21SSam Leffler 		2,		/* IFM_IEEE80211_FH1 */
11131a1e1d21SSam Leffler 		4,		/* IFM_IEEE80211_FH2 */
11141a1e1d21SSam Leffler 		2,		/* IFM_IEEE80211_DS1 */
11151a1e1d21SSam Leffler 		4,		/* IFM_IEEE80211_DS2 */
11161a1e1d21SSam Leffler 		11,		/* IFM_IEEE80211_DS5 */
11171a1e1d21SSam Leffler 		22,		/* IFM_IEEE80211_DS11 */
11181a1e1d21SSam Leffler 		44,		/* IFM_IEEE80211_DS22 */
11191a1e1d21SSam Leffler 		12,		/* IFM_IEEE80211_OFDM6 */
11201a1e1d21SSam Leffler 		18,		/* IFM_IEEE80211_OFDM9 */
11211a1e1d21SSam Leffler 		24,		/* IFM_IEEE80211_OFDM12 */
11221a1e1d21SSam Leffler 		36,		/* IFM_IEEE80211_OFDM18 */
11231a1e1d21SSam Leffler 		48,		/* IFM_IEEE80211_OFDM24 */
11241a1e1d21SSam Leffler 		72,		/* IFM_IEEE80211_OFDM36 */
11251a1e1d21SSam Leffler 		96,		/* IFM_IEEE80211_OFDM48 */
11261a1e1d21SSam Leffler 		108,		/* IFM_IEEE80211_OFDM54 */
11271a1e1d21SSam Leffler 		144,		/* IFM_IEEE80211_OFDM72 */
112841b3c790SSam Leffler 		0,		/* IFM_IEEE80211_DS354k */
112941b3c790SSam Leffler 		0,		/* IFM_IEEE80211_DS512k */
113041b3c790SSam Leffler 		6,		/* IFM_IEEE80211_OFDM3 */
113141b3c790SSam Leffler 		9,		/* IFM_IEEE80211_OFDM4 */
113241b3c790SSam Leffler 		54,		/* IFM_IEEE80211_OFDM27 */
11331a1e1d21SSam Leffler 	};
11341a1e1d21SSam Leffler 	return IFM_SUBTYPE(mword) < N(ieeerates) ?
11351a1e1d21SSam Leffler 		ieeerates[IFM_SUBTYPE(mword)] : 0;
11361a1e1d21SSam Leffler #undef N
11371a1e1d21SSam Leffler }
1138