Home | History | Annotate | Line # | Download | only in ic
an.c revision 1.61
      1 /*	$NetBSD: an.c,v 1.60 2013/09/12 11:42:26 martin Exp $	*/
      2 /*
      3  * Copyright (c) 1997, 1998, 1999
      4  *	Bill Paul <wpaul (at) ctr.columbia.edu>.  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  * 3. All advertising materials mentioning features or use of this software
     15  *    must display the following acknowledgement:
     16  *	This product includes software developed by Bill Paul.
     17  * 4. Neither the name of the author nor the names of any co-contributors
     18  *    may be used to endorse or promote products derived from this software
     19  *    without specific prior written permission.
     20  *
     21  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
     22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
     25  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31  * THE POSSIBILITY OF SUCH DAMAGE.
     32  *
     33  * $FreeBSD: src/sys/dev/an/if_an.c,v 1.12 2000/11/13 23:04:12 wpaul Exp $
     34  */
     35 /*
     36  * Copyright (c) 2004, 2005 David Young.  All rights reserved.
     37  * Copyright (c) 2004, 2005 OJC Technologies.  All rights reserved.
     38  * Copyright (c) 2004, 2005 Dayton Data Center Services, LLC.  All
     39  *     rights reserved.
     40  *
     41  * Redistribution and use in source and binary forms, with or without
     42  * modification, are permitted provided that the following conditions
     43  * are met:
     44  * 1. Redistributions of source code must retain the above copyright
     45  *    notice, this list of conditions and the following disclaimer.
     46  * 2. Redistributions in binary form must reproduce the above copyright
     47  *    notice, this list of conditions and the following disclaimer in the
     48  *    documentation and/or other materials provided with the distribution.
     49  * 3. Neither the name of the author nor the names of any co-contributors
     50  *    may be used to endorse or promote products derived from this software
     51  *    without specific prior written permission.
     52  *
     53  * THIS SOFTWARE IS PROVIDED BY David Young AND CONTRIBUTORS ``AS IS'' AND
     54  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     55  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     56  * ARE DISCLAIMED.  IN NO EVENT SHALL David Young AND CONTRIBUTORS
     57  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     58  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     59  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     60  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     61  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     62  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     63  * THE POSSIBILITY OF SUCH DAMAGE.
     64  */
     65 
     66 /*
     67  * Aironet 4500/4800 802.11 PCMCIA/ISA/PCI driver for FreeBSD.
     68  *
     69  * Written by Bill Paul <wpaul (at) ctr.columbia.edu>
     70  * Electrical Engineering Department
     71  * Columbia University, New York City
     72  */
     73 
     74 /*
     75  * Ported to NetBSD from FreeBSD by Atsushi Onoe at the San Diego
     76  * IETF meeting.
     77  */
     78 
     79 #include <sys/cdefs.h>
     80 __KERNEL_RCSID(0, "$NetBSD: an.c,v 1.60 2013/09/12 11:42:26 martin Exp $");
     81 
     82 
     83 #include <sys/param.h>
     84 #include <sys/callout.h>
     85 #include <sys/sysctl.h>
     86 #include <sys/systm.h>
     87 #include <sys/sockio.h>
     88 #include <sys/mbuf.h>
     89 #include <sys/kernel.h>
     90 #include <sys/ucred.h>
     91 #include <sys/socket.h>
     92 #include <sys/device.h>
     93 #include <sys/proc.h>
     94 #include <sys/md4.h>
     95 #include <sys/endian.h>
     96 #include <sys/kauth.h>
     97 
     98 #include <sys/bus.h>
     99 
    100 #include <net/if.h>
    101 #include <net/if_dl.h>
    102 #include <net/if_ether.h>
    103 #include <net/if_llc.h>
    104 #include <net/if_media.h>
    105 #include <net/if_types.h>
    106 
    107 #include <net80211/ieee80211_netbsd.h>
    108 #include <net80211/ieee80211_var.h>
    109 #include <net80211/ieee80211_radiotap.h>
    110 
    111 #include <net/bpf.h>
    112 #include <net/bpfdesc.h>
    113 
    114 #include <dev/ic/anreg.h>
    115 #include <dev/ic/anvar.h>
    116 
    117 static int	an_reset(struct an_softc *);
    118 static void	an_wait(struct an_softc *);
    119 static int	an_init(struct ifnet *);
    120 static void	an_stop(struct ifnet *, int);
    121 static void	an_start(struct ifnet *);
    122 static void	an_watchdog(struct ifnet *);
    123 static int	an_ioctl(struct ifnet *, u_long, void *);
    124 static int	an_media_change(struct ifnet *);
    125 static void	an_media_status(struct ifnet *, struct ifmediareq *);
    126 
    127 static int	an_set_nwkey(struct an_softc *, struct ieee80211_nwkey *);
    128 static int	an_set_nwkey_wep(struct an_softc *, struct ieee80211_nwkey *);
    129 static int	an_set_nwkey_eap(struct an_softc *, struct ieee80211_nwkey *);
    130 static int	an_get_nwkey(struct an_softc *, struct ieee80211_nwkey *);
    131 static int	an_write_wepkey(struct an_softc *, int, struct an_wepkey *,
    132 				int);
    133 
    134 static void	an_rx_intr(struct an_softc *);
    135 static void	an_tx_intr(struct an_softc *, int);
    136 static void	an_linkstat_intr(struct an_softc *);
    137 
    138 static int	an_cmd(struct an_softc *, int, int);
    139 static int	an_seek_bap(struct an_softc *, int, int);
    140 static int	an_read_bap(struct an_softc *, int, int, void *, int);
    141 static int	an_write_bap(struct an_softc *, int, int, void *, int);
    142 static int	an_mwrite_bap(struct an_softc *, int, int, struct mbuf *, int);
    143 static int	an_read_rid(struct an_softc *, int, void *, int *);
    144 static int	an_write_rid(struct an_softc *, int, void *, int);
    145 
    146 static int	an_alloc_fid(struct an_softc *, int, int *);
    147 
    148 static int	an_newstate(struct ieee80211com *, enum ieee80211_state, int);
    149 
    150 #ifdef AN_DEBUG
    151 int an_debug = 0;
    152 
    153 #define	DPRINTF(X)	if (an_debug) printf X
    154 #define	DPRINTF2(X)	if (an_debug > 1) printf X
    155 static int an_sysctl_verify(SYSCTLFN_PROTO, int lower, int upper);
    156 static int an_sysctl_verify_debug(SYSCTLFN_PROTO);
    157 #else
    158 #define	DPRINTF(X)
    159 #define	DPRINTF2(X)
    160 #endif
    161 
    162 int
    163 an_attach(struct an_softc *sc)
    164 {
    165 	struct ieee80211com *ic = &sc->sc_ic;
    166 	struct ifnet *ifp = &sc->sc_if;
    167 	int i, s;
    168 	struct an_rid_wepkey *akey;
    169 	int buflen, kid, rid;
    170 	int chan, chan_min, chan_max;
    171 
    172 	s = splnet();
    173 
    174 	an_wait(sc);
    175 	if (an_reset(sc) != 0) {
    176 		config_deactivate(sc->sc_dev);
    177 		splx(s);
    178 		return 1;
    179 	}
    180 
    181 	/* Load factory config */
    182 	if (an_cmd(sc, AN_CMD_READCFG, 0) != 0) {
    183 		splx(s);
    184 		aprint_error_dev(sc->sc_dev, "failed to load config data\n");
    185 		return 1;
    186 	}
    187 
    188 	/* Read the current configuration */
    189 	buflen = sizeof(sc->sc_config);
    190 	if (an_read_rid(sc, AN_RID_GENCONFIG, &sc->sc_config, &buflen) != 0) {
    191 		splx(s);
    192 		aprint_error_dev(sc->sc_dev, "read config failed\n");
    193 		return 1;
    194 	}
    195 
    196 	/* Read the card capabilities */
    197 	buflen = sizeof(sc->sc_caps);
    198 	if (an_read_rid(sc, AN_RID_CAPABILITIES, &sc->sc_caps, &buflen) != 0) {
    199 		splx(s);
    200 		aprint_error_dev(sc->sc_dev, "read caps failed\n");
    201 		return 1;
    202 	}
    203 
    204 #ifdef AN_DEBUG
    205 	if (an_debug) {
    206 		static const int dumprid[] = {
    207 		    AN_RID_GENCONFIG, AN_RID_CAPABILITIES, AN_RID_SSIDLIST,
    208 		    AN_RID_APLIST, AN_RID_STATUS, AN_RID_ENCAP
    209 		};
    210 
    211 		for (rid = 0; rid < sizeof(dumprid)/sizeof(dumprid[0]); rid++) {
    212 			buflen = sizeof(sc->sc_buf);
    213 			if (an_read_rid(sc, dumprid[rid], &sc->sc_buf, &buflen)
    214 			    != 0)
    215 				continue;
    216 			printf("%04x (%d):\n", dumprid[rid], buflen);
    217 			for (i = 0; i < (buflen + 1) / 2; i++)
    218 				printf(" %04x", sc->sc_buf.sc_val[i]);
    219 			printf("\n");
    220 		}
    221 	}
    222 #endif
    223 
    224 	/* Read WEP settings from persistent memory */
    225 	akey = &sc->sc_buf.sc_wepkey;
    226 	buflen = sizeof(struct an_rid_wepkey);
    227 	rid = AN_RID_WEP_VOLATILE;	/* first persistent key */
    228 	while (an_read_rid(sc, rid, akey, &buflen) == 0) {
    229 		kid = le16toh(akey->an_key_index);
    230 		DPRINTF(("an_attach: wep rid=0x%x len=%d(%zu) index=0x%04x "
    231 		    "mac[0]=%02x keylen=%d\n",
    232 		    rid, buflen, sizeof(*akey), kid,
    233 		    akey->an_mac_addr[0], le16toh(akey->an_key_len)));
    234 		if (kid == 0xffff) {
    235 			sc->sc_tx_perskey = akey->an_mac_addr[0];
    236 			sc->sc_tx_key = -1;
    237 			break;
    238 		}
    239 		if (kid >= IEEE80211_WEP_NKID)
    240 			break;
    241 		sc->sc_perskeylen[kid] = le16toh(akey->an_key_len);
    242 		sc->sc_wepkeys[kid].an_wep_keylen = -1;
    243 		rid = AN_RID_WEP_PERSISTENT;	/* for next key */
    244 		buflen = sizeof(struct an_rid_wepkey);
    245 	}
    246 
    247 	aprint_normal_dev(sc->sc_dev, "%s %s (firmware %s)\n",
    248 	    sc->sc_caps.an_manufname, sc->sc_caps.an_prodname,
    249 	    sc->sc_caps.an_prodvers);
    250 
    251 	memcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
    252 
    253 	ifp->if_softc = sc;
    254 	ifp->if_flags = IFF_BROADCAST | IFF_NOTRAILERS | IFF_SIMPLEX |
    255 	    IFF_MULTICAST | IFF_ALLMULTI;
    256 	ifp->if_ioctl = an_ioctl;
    257 	ifp->if_start = an_start;
    258 	ifp->if_init = an_init;
    259 	ifp->if_stop = an_stop;
    260 	ifp->if_watchdog = an_watchdog;
    261 	IFQ_SET_READY(&ifp->if_snd);
    262 
    263 	ic->ic_ifp = ifp;
    264 	ic->ic_phytype = IEEE80211_T_DS;
    265 	ic->ic_opmode = IEEE80211_M_STA;
    266 	ic->ic_caps = IEEE80211_C_WEP | IEEE80211_C_PMGT | IEEE80211_C_IBSS |
    267 	    IEEE80211_C_MONITOR;
    268 	ic->ic_state = IEEE80211_S_INIT;
    269 	IEEE80211_ADDR_COPY(ic->ic_myaddr, sc->sc_caps.an_oemaddr);
    270 
    271 	switch (le16toh(sc->sc_caps.an_regdomain)) {
    272 	default:
    273 	case AN_REGDOMAIN_USA:
    274 	case AN_REGDOMAIN_CANADA:
    275 		chan_min = 1; chan_max = 11; break;
    276 	case AN_REGDOMAIN_EUROPE:
    277 	case AN_REGDOMAIN_AUSTRALIA:
    278 		chan_min = 1; chan_max = 13; break;
    279 	case AN_REGDOMAIN_JAPAN:
    280 		chan_min = 14; chan_max = 14; break;
    281 	case AN_REGDOMAIN_SPAIN:
    282 		chan_min = 10; chan_max = 11; break;
    283 	case AN_REGDOMAIN_FRANCE:
    284 		chan_min = 10; chan_max = 13; break;
    285 	case AN_REGDOMAIN_JAPANWIDE:
    286 		chan_min = 1; chan_max = 14; break;
    287 	}
    288 
    289 	for (chan = chan_min; chan <= chan_max; chan++) {
    290 		ic->ic_channels[chan].ic_freq =
    291 		    ieee80211_ieee2mhz(chan, IEEE80211_CHAN_2GHZ);
    292 		ic->ic_channels[chan].ic_flags = IEEE80211_CHAN_B;
    293 	}
    294 	ic->ic_ibss_chan = &ic->ic_channels[chan_min];
    295 
    296 	aprint_normal("%s: 802.11 address: %s, channel: %d-%d\n",
    297 	    ifp->if_xname, ether_sprintf(ic->ic_myaddr), chan_min, chan_max);
    298 
    299 	/* Find supported rate */
    300 	for (i = 0; i < sizeof(sc->sc_caps.an_rates); i++) {
    301 		if (sc->sc_caps.an_rates[i] == 0)
    302 			continue;
    303 		ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[
    304 		    ic->ic_sup_rates[IEEE80211_MODE_11B].rs_nrates++] =
    305 		    sc->sc_caps.an_rates[i];
    306 	}
    307 
    308 	/*
    309 	 * Call MI attach routine.
    310 	 */
    311 	if_attach(ifp);
    312 	ieee80211_ifattach(ic);
    313 
    314 	sc->sc_newstate = ic->ic_newstate;
    315 	ic->ic_newstate = an_newstate;
    316 
    317 	ieee80211_media_init(ic, an_media_change, an_media_status);
    318 
    319 	/*
    320 	 * radiotap BPF device
    321 	 */
    322 	bpf_attach2(ifp, DLT_IEEE802_11_RADIO,
    323 	    sizeof(struct ieee80211_frame) + 64, &sc->sc_drvbpf);
    324 
    325 	memset(&sc->sc_rxtapu, 0, sizeof(sc->sc_rxtapu));
    326 	sc->sc_rxtap.ar_ihdr.it_len = htole16(sizeof(sc->sc_rxtapu));
    327 	sc->sc_rxtap.ar_ihdr.it_present = htole32(AN_RX_RADIOTAP_PRESENT);
    328 
    329 	memset(&sc->sc_txtapu, 0, sizeof(sc->sc_txtapu));
    330 	sc->sc_txtap.at_ihdr.it_len = htole16(sizeof(sc->sc_txtapu));
    331 	sc->sc_txtap.at_ihdr.it_present = htole32(AN_TX_RADIOTAP_PRESENT);
    332 
    333 	sc->sc_attached = 1;
    334 	splx(s);
    335 
    336 	ieee80211_announce(ic);
    337 	return 0;
    338 }
    339 
    340 #ifdef AN_DEBUG
    341 /*
    342  * Setup sysctl(3) MIB, hw.an.*
    343  *
    344  * TBD condition CTLFLAG_PERMANENT on being a module or not
    345  */
    346 SYSCTL_SETUP(sysctl_an, "sysctl an(4) subtree setup")
    347 {
    348 	int rc;
    349 	const struct sysctlnode *cnode, *rnode;
    350 
    351 	if ((rc = sysctl_createv(clog, 0, NULL, &rnode,
    352 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "an",
    353 	    "Cisco/Aironet 802.11 controls",
    354 	    NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0)
    355 		goto err;
    356 
    357 	/* control debugging printfs */
    358 	if ((rc = sysctl_createv(clog, 0, &rnode, &cnode,
    359 	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT,
    360 	    "debug", SYSCTL_DESCR("Enable Cisco/Aironet debugging output"),
    361 	    an_sysctl_verify_debug, 0, &an_debug, 0,
    362 	    CTL_CREATE, CTL_EOL)) != 0)
    363 		goto err;
    364 
    365 	return;
    366 err:
    367 	printf("%s: sysctl_createv failed (rc = %d)\n", __func__, rc);
    368 }
    369 
    370 static int
    371 an_sysctl_verify(SYSCTLFN_ARGS, int lower, int upper)
    372 {
    373 	int error, t;
    374 	struct sysctlnode node;
    375 
    376 	node = *rnode;
    377 	t = *(int*)rnode->sysctl_data;
    378 	node.sysctl_data = &t;
    379 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    380 	if (error || newp == NULL)
    381 		return (error);
    382 
    383 	if (t < lower || t > upper)
    384 		return (EINVAL);
    385 
    386 	*(int*)rnode->sysctl_data = t;
    387 
    388 	return (0);
    389 }
    390 
    391 static int
    392 an_sysctl_verify_debug(SYSCTLFN_ARGS)
    393 {
    394 	return an_sysctl_verify(SYSCTLFN_CALL(rnode), 0, 2);
    395 }
    396 #endif /* AN_DEBUG */
    397 
    398 int
    399 an_detach(struct an_softc *sc)
    400 {
    401 	struct ieee80211com *ic = &sc->sc_ic;
    402 	struct ifnet *ifp = &sc->sc_if;
    403 	int s;
    404 
    405 	if (!sc->sc_attached)
    406 		return 0;
    407 
    408 	s = splnet();
    409 	an_stop(ifp, 1);
    410 	ieee80211_ifdetach(ic);
    411 	if_detach(ifp);
    412 	splx(s);
    413 	return 0;
    414 }
    415 
    416 int
    417 an_activate(device_t self, enum devact act)
    418 {
    419 	struct an_softc *sc = device_private(self);
    420 
    421 	switch (act) {
    422 	case DVACT_DEACTIVATE:
    423 		if_deactivate(&sc->sc_if);
    424 		return 0;
    425 	default:
    426 		return EOPNOTSUPP;
    427 	}
    428 }
    429 
    430 int
    431 an_intr(void *arg)
    432 {
    433 	struct an_softc *sc = arg;
    434 	struct ifnet *ifp = &sc->sc_if;
    435 	int i;
    436 	u_int16_t status;
    437 
    438 	if (!sc->sc_enabled || !device_is_active(sc->sc_dev) ||
    439 	    (ifp->if_flags & IFF_RUNNING) == 0)
    440 		return 0;
    441 
    442 	if ((ifp->if_flags & IFF_UP) == 0) {
    443 		CSR_WRITE_2(sc, AN_INT_EN, 0);
    444 		CSR_WRITE_2(sc, AN_EVENT_ACK, ~0);
    445 		return 1;
    446 	}
    447 
    448 	/* maximum 10 loops per interrupt */
    449 	for (i = 0; i < 10; i++) {
    450 		if (!sc->sc_enabled || !device_is_active(sc->sc_dev))
    451 			return 1;
    452 		if (CSR_READ_2(sc, AN_SW0) != AN_MAGIC) {
    453 			DPRINTF(("an_intr: magic number changed: %x\n",
    454 			    CSR_READ_2(sc, AN_SW0)));
    455 			config_deactivate(sc->sc_dev);
    456 			return 1;
    457 		}
    458 		status = CSR_READ_2(sc, AN_EVENT_STAT);
    459 		CSR_WRITE_2(sc, AN_EVENT_ACK, status & ~(AN_INTRS));
    460 		if ((status & AN_INTRS) == 0)
    461 			break;
    462 
    463 		if (status & AN_EV_RX)
    464 			an_rx_intr(sc);
    465 
    466 		if (status & (AN_EV_TX | AN_EV_TX_EXC))
    467 			an_tx_intr(sc, status);
    468 
    469 		if (status & AN_EV_LINKSTAT)
    470 			an_linkstat_intr(sc);
    471 
    472 		if ((ifp->if_flags & IFF_OACTIVE) == 0 &&
    473 		    sc->sc_ic.ic_state == IEEE80211_S_RUN &&
    474 		    !IFQ_IS_EMPTY(&ifp->if_snd))
    475 			an_start(ifp);
    476 	}
    477 
    478 	return 1;
    479 }
    480 
    481 static int
    482 an_init(struct ifnet *ifp)
    483 {
    484 	struct an_softc *sc = ifp->if_softc;
    485 	struct ieee80211com *ic = &sc->sc_ic;
    486 	int i, error, fid;
    487 
    488 	DPRINTF(("an_init: enabled %d\n", sc->sc_enabled));
    489 	if (!sc->sc_enabled) {
    490 		if (sc->sc_enable)
    491 			(*sc->sc_enable)(sc);
    492 		an_wait(sc);
    493 		sc->sc_enabled = 1;
    494 	} else {
    495 		an_stop(ifp, 0);
    496 		if ((error = an_reset(sc)) != 0) {
    497 			printf("%s: failed to reset\n", ifp->if_xname);
    498 			an_stop(ifp, 1);
    499 			return error;
    500 		}
    501 	}
    502 	CSR_WRITE_2(sc, AN_SW0, AN_MAGIC);
    503 
    504 	/* Allocate the TX buffers */
    505 	for (i = 0; i < AN_TX_RING_CNT; i++) {
    506 		if ((error = an_alloc_fid(sc, AN_TX_MAX_LEN, &fid)) != 0) {
    507 			printf("%s: failed to allocate nic memory\n",
    508 			    ifp->if_xname);
    509 			an_stop(ifp, 1);
    510 			return error;
    511 		}
    512 		DPRINTF2(("an_init: txbuf %d allocated %x\n", i, fid));
    513 		sc->sc_txd[i].d_fid = fid;
    514 		sc->sc_txd[i].d_inuse = 0;
    515 	}
    516 	sc->sc_txcur = sc->sc_txnext = 0;
    517 
    518 	IEEE80211_ADDR_COPY(sc->sc_config.an_macaddr, ic->ic_myaddr);
    519 	sc->sc_config.an_scanmode = htole16(AN_SCANMODE_ACTIVE);
    520 	sc->sc_config.an_authtype = htole16(AN_AUTHTYPE_OPEN);	/*XXX*/
    521 	if (ic->ic_flags & IEEE80211_F_PRIVACY) {
    522 		sc->sc_config.an_authtype |=
    523 		    htole16(AN_AUTHTYPE_PRIVACY_IN_USE);
    524 		if (sc->sc_use_leap)
    525 			sc->sc_config.an_authtype |=
    526 			    htole16(AN_AUTHTYPE_LEAP);
    527 	}
    528 	sc->sc_config.an_listen_interval = htole16(ic->ic_lintval);
    529 	sc->sc_config.an_beacon_period = htole16(ic->ic_lintval);
    530 	if (ic->ic_flags & IEEE80211_F_PMGTON)
    531 		sc->sc_config.an_psave_mode = htole16(AN_PSAVE_PSP);
    532 	else
    533 		sc->sc_config.an_psave_mode = htole16(AN_PSAVE_CAM);
    534 	sc->sc_config.an_ds_channel =
    535 	    htole16(ieee80211_chan2ieee(ic, ic->ic_ibss_chan));
    536 
    537 	switch (ic->ic_opmode) {
    538 	case IEEE80211_M_STA:
    539 		sc->sc_config.an_opmode =
    540 		    htole16(AN_OPMODE_INFRASTRUCTURE_STATION);
    541 		sc->sc_config.an_rxmode = htole16(AN_RXMODE_BC_MC_ADDR);
    542 		break;
    543 	case IEEE80211_M_IBSS:
    544 		sc->sc_config.an_opmode = htole16(AN_OPMODE_IBSS_ADHOC);
    545 		sc->sc_config.an_rxmode = htole16(AN_RXMODE_BC_MC_ADDR);
    546 		break;
    547 	case IEEE80211_M_MONITOR:
    548 		sc->sc_config.an_opmode =
    549 		    htole16(AN_OPMODE_INFRASTRUCTURE_STATION);
    550 		sc->sc_config.an_rxmode =
    551 		    htole16(AN_RXMODE_80211_MONITOR_ANYBSS);
    552 		sc->sc_config.an_authtype = htole16(AN_AUTHTYPE_NONE);
    553 		if (ic->ic_flags & IEEE80211_F_PRIVACY)
    554 			sc->sc_config.an_authtype |=
    555 			    htole16(AN_AUTHTYPE_PRIVACY_IN_USE |
    556 		            AN_AUTHTYPE_ALLOW_UNENCRYPTED);
    557 		break;
    558 	default:
    559 		printf("%s: bad opmode %d\n", ifp->if_xname, ic->ic_opmode);
    560 		an_stop(ifp, 1);
    561 		return EIO;
    562 	}
    563 	sc->sc_config.an_rxmode |= htole16(AN_RXMODE_NO_8023_HEADER);
    564 
    565 	/* Set the ssid list */
    566 	memset(&sc->sc_buf, 0, sizeof(sc->sc_buf.sc_ssidlist));
    567 	sc->sc_buf.sc_ssidlist.an_entry[0].an_ssid_len =
    568 	    htole16(ic->ic_des_esslen);
    569 	if (ic->ic_des_esslen)
    570 		memcpy(sc->sc_buf.sc_ssidlist.an_entry[0].an_ssid,
    571 		    ic->ic_des_essid, ic->ic_des_esslen);
    572 	if (an_write_rid(sc, AN_RID_SSIDLIST, &sc->sc_buf,
    573 	    sizeof(sc->sc_buf.sc_ssidlist)) != 0) {
    574 		printf("%s: failed to write ssid list\n", ifp->if_xname);
    575 		an_stop(ifp, 1);
    576 		return error;
    577 	}
    578 
    579 	/* Set the AP list */
    580 	memset(&sc->sc_buf, 0, sizeof(sc->sc_buf.sc_aplist));
    581 	(void)an_write_rid(sc, AN_RID_APLIST, &sc->sc_buf,
    582 	    sizeof(sc->sc_buf.sc_aplist));
    583 
    584 	/* Set the encapsulation */
    585 	for (i = 0; i < AN_ENCAP_NENTS; i++) {
    586 		sc->sc_buf.sc_encap.an_entry[i].an_ethertype = htole16(0);
    587 		sc->sc_buf.sc_encap.an_entry[i].an_action =
    588 		    htole16(AN_RXENCAP_RFC1024 | AN_TXENCAP_RFC1024);
    589 	}
    590 	(void)an_write_rid(sc, AN_RID_ENCAP, &sc->sc_buf,
    591 	    sizeof(sc->sc_buf.sc_encap));
    592 
    593 	/* Set the WEP Keys */
    594 	if (ic->ic_flags & IEEE80211_F_PRIVACY)
    595 		an_write_wepkey(sc, AN_RID_WEP_VOLATILE, sc->sc_wepkeys,
    596 		    sc->sc_tx_key);
    597 
    598 	/* Set the configuration */
    599 #ifdef AN_DEBUG
    600 	if (an_debug) {
    601 		printf("write config:\n");
    602 		for (i = 0; i < sizeof(sc->sc_config) / 2; i++)
    603 			printf(" %04x", ((u_int16_t *)&sc->sc_config)[i]);
    604 		printf("\n");
    605 	}
    606 #endif
    607 	if (an_write_rid(sc, AN_RID_GENCONFIG, &sc->sc_config,
    608 	    sizeof(sc->sc_config)) != 0) {
    609 		printf("%s: failed to write config\n", ifp->if_xname);
    610 		an_stop(ifp, 1);
    611 		return error;
    612 	}
    613 
    614 	/* Enable the MAC */
    615 	if (an_cmd(sc, AN_CMD_ENABLE, 0)) {
    616 		aprint_error_dev(sc->sc_dev, "failed to enable MAC\n");
    617 		an_stop(ifp, 1);
    618 		return ENXIO;
    619 	}
    620 	if (ifp->if_flags & IFF_PROMISC)
    621 		an_cmd(sc, AN_CMD_SET_MODE, 0xffff);
    622 
    623 	ifp->if_flags |= IFF_RUNNING;
    624 	ifp->if_flags &= ~IFF_OACTIVE;
    625 	ic->ic_state = IEEE80211_S_INIT;
    626 	if (ic->ic_opmode == IEEE80211_M_MONITOR)
    627 		ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
    628 
    629 	/* enable interrupts */
    630 	CSR_WRITE_2(sc, AN_INT_EN, AN_INTRS);
    631 	return 0;
    632 }
    633 
    634 static void
    635 an_stop(struct ifnet *ifp, int disable)
    636 {
    637 	struct an_softc *sc = ifp->if_softc;
    638 	int i, s;
    639 
    640 	if (!sc->sc_enabled)
    641 		return;
    642 
    643 	DPRINTF(("an_stop: disable %d\n", disable));
    644 
    645 	s = splnet();
    646 	ieee80211_new_state(&sc->sc_ic, IEEE80211_S_INIT, -1);
    647 	if (device_is_active(sc->sc_dev)) {
    648 		an_cmd(sc, AN_CMD_FORCE_SYNCLOSS, 0);
    649 		CSR_WRITE_2(sc, AN_INT_EN, 0);
    650 		an_cmd(sc, AN_CMD_DISABLE, 0);
    651 
    652 		for (i = 0; i < AN_TX_RING_CNT; i++)
    653 			an_cmd(sc, AN_CMD_DEALLOC_MEM, sc->sc_txd[i].d_fid);
    654 	}
    655 
    656 	sc->sc_tx_timer = 0;
    657 	ifp->if_timer = 0;
    658 	ifp->if_flags &= ~(IFF_RUNNING|IFF_OACTIVE);
    659 
    660 	if (disable) {
    661 		if (sc->sc_disable)
    662 			(*sc->sc_disable)(sc);
    663 		sc->sc_enabled = 0;
    664 	}
    665 	splx(s);
    666 }
    667 
    668 static void
    669 an_start(struct ifnet *ifp)
    670 {
    671 	struct an_softc *sc = (struct an_softc *)ifp->if_softc;
    672 	struct ieee80211com *ic = &sc->sc_ic;
    673 	struct ieee80211_node *ni;
    674 	struct ieee80211_frame *wh;
    675 	struct an_txframe frmhdr;
    676 	struct ether_header *eh;
    677 	struct mbuf *m;
    678 	u_int16_t len;
    679 	int cur, fid;
    680 
    681 	if (!sc->sc_enabled || !device_is_active(sc->sc_dev)) {
    682 		DPRINTF(("an_start: noop: enabled %d invalid %d\n",
    683 		    sc->sc_enabled, !device_is_active(sc->sc_dev)));
    684 		return;
    685 	}
    686 
    687 	memset(&frmhdr, 0, sizeof(frmhdr));
    688 	cur = sc->sc_txnext;
    689 	for (;;) {
    690 		if (ic->ic_state != IEEE80211_S_RUN) {
    691 			DPRINTF(("an_start: not running %d\n", ic->ic_state));
    692 			break;
    693 		}
    694 		IFQ_POLL(&ifp->if_snd, m);
    695 		if (m == NULL) {
    696 			DPRINTF2(("an_start: no pending mbuf\n"));
    697 			break;
    698 		}
    699 		if (sc->sc_txd[cur].d_inuse) {
    700 			DPRINTF2(("an_start: %x/%d busy\n",
    701 			    sc->sc_txd[cur].d_fid, cur));
    702 			ifp->if_flags |= IFF_OACTIVE;
    703 			break;
    704 		}
    705 		IFQ_DEQUEUE(&ifp->if_snd, m);
    706 		ifp->if_opackets++;
    707 		bpf_mtap(ifp, m);
    708 		eh = mtod(m, struct ether_header *);
    709 		ni = ieee80211_find_txnode(ic, eh->ether_dhost);
    710 		if (ni == NULL) {
    711 			/* NB: ieee80211_find_txnode does stat+msg */
    712 			goto bad;
    713 		}
    714 		if ((m = ieee80211_encap(ic, m, ni)) == NULL)
    715 			goto bad;
    716 		ieee80211_free_node(ni);
    717 		bpf_mtap3(ic->ic_rawbpf, m);
    718 
    719 		wh = mtod(m, struct ieee80211_frame *);
    720 		if (ic->ic_flags & IEEE80211_F_PRIVACY)
    721 			wh->i_fc[1] |= IEEE80211_FC1_WEP;
    722 		m_copydata(m, 0, sizeof(struct ieee80211_frame),
    723 		    (void *)&frmhdr.an_whdr);
    724 
    725 		/* insert payload length in front of llc/snap */
    726 		len = htons(m->m_pkthdr.len - sizeof(struct ieee80211_frame));
    727 		m_adj(m, sizeof(struct ieee80211_frame) - sizeof(len));
    728 		if (mtod(m, u_long) & 0x01)
    729 			memcpy(mtod(m, void *), &len, sizeof(len));
    730 		else
    731 			*mtod(m, u_int16_t *) = len;
    732 
    733 		/*
    734 		 * XXX Aironet firmware apparently convert the packet
    735 		 * with longer than 1500 bytes in length into LLC/SNAP.
    736 		 * If we have 1500 bytes in ethernet payload, it is
    737 		 * 1508 bytes including LLC/SNAP and will be inserted
    738 		 * additional LLC/SNAP header with 1501-1508 in its
    739 		 * ethertype !!
    740 		 * So we skip LLC/SNAP header and force firmware to
    741 		 * convert it to LLC/SNAP again.
    742 		 */
    743 		m_adj(m, sizeof(struct llc));
    744 
    745 		frmhdr.an_tx_ctl = htole16(AN_TXCTL_80211);
    746 		frmhdr.an_tx_payload_len = htole16(m->m_pkthdr.len);
    747 		frmhdr.an_gaplen = htole16(AN_TXGAP_802_11);
    748 
    749 		if (ic->ic_fixed_rate != -1)
    750 			frmhdr.an_tx_rate =
    751 			    ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[
    752 			    ic->ic_fixed_rate] & IEEE80211_RATE_VAL;
    753 		else
    754 			frmhdr.an_tx_rate = 0;
    755 
    756 		/* XXX radiotap for tx must be completed */
    757 		if (sc->sc_drvbpf) {
    758 			struct an_tx_radiotap_header *tap = &sc->sc_txtap;
    759 			tap->at_rate = ic->ic_bss->ni_rates.rs_rates[ic->ic_bss->ni_txrate];
    760 			tap->at_chan_freq = htole16(ic->ic_bss->ni_chan->ic_freq);
    761 			tap->at_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags);
    762 			/* TBD tap->wt_flags */
    763 			bpf_mtap2(sc->sc_drvbpf, tap, tap->at_ihdr.it_len, m);
    764 		}
    765 
    766 #ifdef AN_DEBUG
    767 		if ((ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) ==
    768 		    (IFF_DEBUG|IFF_LINK2)) {
    769 			ieee80211_dump_pkt((u_int8_t *)&frmhdr.an_whdr,
    770 			    sizeof(struct ieee80211_frame), -1, 0);
    771 			printf(" txctl 0x%x plen %u\n",
    772 			    le16toh(frmhdr.an_tx_ctl),
    773 			    le16toh(frmhdr.an_tx_payload_len));
    774 		}
    775 #endif
    776 		if (sizeof(frmhdr) + AN_TXGAP_802_11 + sizeof(len) +
    777 		    m->m_pkthdr.len > AN_TX_MAX_LEN)
    778 			goto bad;
    779 
    780 		fid = sc->sc_txd[cur].d_fid;
    781 		if (an_write_bap(sc, fid, 0, &frmhdr, sizeof(frmhdr)) != 0)
    782 			goto bad;
    783 		/* dummy write to avoid seek. */
    784 		an_write_bap(sc, fid, -1, &frmhdr, AN_TXGAP_802_11);
    785 		an_mwrite_bap(sc, fid, -1, m, m->m_pkthdr.len);
    786 		m_freem(m);
    787 
    788 		DPRINTF2(("an_start: send %zu byte via %x/%d\n",
    789 		    ntohs(len) + sizeof(struct ieee80211_frame),
    790 		    fid, cur));
    791 		sc->sc_txd[cur].d_inuse = 1;
    792 		if (an_cmd(sc, AN_CMD_TX, fid)) {
    793 			printf("%s: xmit failed\n", ifp->if_xname);
    794 			sc->sc_txd[cur].d_inuse = 0;
    795 			continue;
    796 		}
    797 		sc->sc_tx_timer = 5;
    798 		ifp->if_timer = 1;
    799 		AN_INC(cur, AN_TX_RING_CNT);
    800 		sc->sc_txnext = cur;
    801 		continue;
    802 bad:
    803 		ifp->if_oerrors++;
    804 		m_freem(m);
    805 	}
    806 }
    807 
    808 static int
    809 an_reset(struct an_softc *sc)
    810 {
    811 
    812 	DPRINTF(("an_reset\n"));
    813 
    814 	if (!sc->sc_enabled)
    815 		return ENXIO;
    816 
    817 	an_cmd(sc, AN_CMD_ENABLE, 0);
    818 	an_cmd(sc, AN_CMD_FW_RESTART, 0);
    819 	an_cmd(sc, AN_CMD_NOOP2, 0);
    820 
    821 	if (an_cmd(sc, AN_CMD_FORCE_SYNCLOSS, 0) == ETIMEDOUT) {
    822 		aprint_error_dev(sc->sc_dev, "reset failed\n");
    823 		return ETIMEDOUT;
    824 	}
    825 
    826 	an_cmd(sc, AN_CMD_DISABLE, 0);
    827 	return 0;
    828 }
    829 
    830 static void
    831 an_watchdog(struct ifnet *ifp)
    832 {
    833 	struct an_softc *sc = ifp->if_softc;
    834 
    835 	if (!sc->sc_enabled)
    836 		return;
    837 
    838 	if (sc->sc_tx_timer) {
    839 		if (--sc->sc_tx_timer == 0) {
    840 			printf("%s: device timeout\n", ifp->if_xname);
    841 			ifp->if_oerrors++;
    842 			an_init(ifp);
    843 			return;
    844 		}
    845 		ifp->if_timer = 1;
    846 	}
    847 	ieee80211_watchdog(&sc->sc_ic);
    848 }
    849 
    850 static int
    851 an_ioctl(struct ifnet *ifp, u_long command, void *data)
    852 {
    853 	struct an_softc *sc = ifp->if_softc;
    854 	int s, error = 0;
    855 
    856 	if (!device_is_active(sc->sc_dev))
    857 		return ENXIO;
    858 
    859 	s = splnet();
    860 
    861 	switch (command) {
    862 	case SIOCSIFFLAGS:
    863 		if ((error = ifioctl_common(ifp, command, data)) != 0)
    864 			break;
    865 		if (ifp->if_flags & IFF_UP) {
    866 			if (sc->sc_enabled) {
    867 				/*
    868 				 * To avoid rescanning another access point,
    869 				 * do not call an_init() here.  Instead, only
    870 				 * reflect promisc mode settings.
    871 				 */
    872 				error = an_cmd(sc, AN_CMD_SET_MODE,
    873 				    (ifp->if_flags & IFF_PROMISC) ? 0xffff : 0);
    874 			} else
    875 				error = an_init(ifp);
    876 		} else if (sc->sc_enabled)
    877 			an_stop(ifp, 1);
    878 		break;
    879 	case SIOCADDMULTI:
    880 	case SIOCDELMULTI:
    881 		error = ether_ioctl(ifp, command, data);
    882 		if (error == ENETRESET) {
    883 			/* we don't have multicast filter. */
    884 			error = 0;
    885 		}
    886 		break;
    887 	case SIOCS80211NWKEY:
    888 		error = an_set_nwkey(sc, (struct ieee80211_nwkey *)data);
    889 			break;
    890 	case SIOCG80211NWKEY:
    891 		error = an_get_nwkey(sc, (struct ieee80211_nwkey *)data);
    892 		break;
    893 	default:
    894 		error = ieee80211_ioctl(&sc->sc_ic, command, data);
    895 		break;
    896 	}
    897 	if (error == ENETRESET) {
    898 		if (sc->sc_enabled)
    899 			error = an_init(ifp);
    900 		else
    901 			error = 0;
    902 	}
    903 	splx(s);
    904 	return error;
    905 }
    906 
    907 /* TBD factor with ieee80211_media_change */
    908 static int
    909 an_media_change(struct ifnet *ifp)
    910 {
    911 	struct an_softc *sc = ifp->if_softc;
    912 	struct ieee80211com *ic = &sc->sc_ic;
    913 	struct ifmedia_entry *ime;
    914 	enum ieee80211_opmode newmode;
    915 	int i, rate, error = 0;
    916 
    917 	ime = ic->ic_media.ifm_cur;
    918 	if (IFM_SUBTYPE(ime->ifm_media) == IFM_AUTO) {
    919 		i = -1;
    920 	} else {
    921 		struct ieee80211_rateset *rs =
    922 		    &ic->ic_sup_rates[IEEE80211_MODE_11B];
    923 		rate = ieee80211_media2rate(ime->ifm_media);
    924 		if (rate == 0)
    925 			return EINVAL;
    926 		for (i = 0; i < rs->rs_nrates; i++) {
    927 			if ((rs->rs_rates[i] & IEEE80211_RATE_VAL) == rate)
    928 				break;
    929 		}
    930 		if (i == rs->rs_nrates)
    931 			return EINVAL;
    932 	}
    933 	if (ic->ic_fixed_rate != i) {
    934 		ic->ic_fixed_rate = i;
    935 		error = ENETRESET;
    936 	}
    937 
    938 	if (ime->ifm_media & IFM_IEEE80211_ADHOC)
    939 		newmode = IEEE80211_M_IBSS;
    940 	else if (ime->ifm_media & IFM_IEEE80211_HOSTAP)
    941 		newmode = IEEE80211_M_HOSTAP;
    942 	else if (ime->ifm_media & IFM_IEEE80211_MONITOR)
    943 		newmode = IEEE80211_M_MONITOR;
    944 	else
    945 		newmode = IEEE80211_M_STA;
    946 	if (ic->ic_opmode != newmode) {
    947 		ic->ic_opmode = newmode;
    948 		error = ENETRESET;
    949 	}
    950 	if (error == ENETRESET) {
    951 		if (sc->sc_enabled)
    952 			error = an_init(ifp);
    953 		else
    954 			error = 0;
    955 	}
    956 	ifp->if_baudrate = ifmedia_baudrate(ic->ic_media.ifm_cur->ifm_media);
    957 
    958 	return error;
    959 }
    960 
    961 static void
    962 an_media_status(struct ifnet *ifp, struct ifmediareq *imr)
    963 {
    964 	struct an_softc *sc = ifp->if_softc;
    965 	struct ieee80211com *ic = &sc->sc_ic;
    966 	int rate, buflen;
    967 
    968 	if (sc->sc_enabled == 0) {
    969 		imr->ifm_active = IFM_IEEE80211 | IFM_NONE;
    970 		imr->ifm_status = 0;
    971 		return;
    972 	}
    973 
    974 	imr->ifm_status = IFM_AVALID;
    975 	imr->ifm_active = IFM_IEEE80211;
    976 	if (ic->ic_state == IEEE80211_S_RUN)
    977 		imr->ifm_status |= IFM_ACTIVE;
    978 	buflen = sizeof(sc->sc_buf);
    979 	if (ic->ic_fixed_rate != -1)
    980 		rate = ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[
    981 		    ic->ic_fixed_rate] & IEEE80211_RATE_VAL;
    982 	else if (an_read_rid(sc, AN_RID_STATUS, &sc->sc_buf, &buflen) != 0)
    983 		rate = 0;
    984 	else
    985 		rate = le16toh(sc->sc_buf.sc_status.an_current_tx_rate);
    986 	imr->ifm_active |= ieee80211_rate2media(ic, rate, IEEE80211_MODE_11B);
    987 	switch (ic->ic_opmode) {
    988 	case IEEE80211_M_STA:
    989 		break;
    990 	case IEEE80211_M_IBSS:
    991 		imr->ifm_active |= IFM_IEEE80211_ADHOC;
    992 		break;
    993 	case IEEE80211_M_HOSTAP:
    994 		imr->ifm_active |= IFM_IEEE80211_HOSTAP;
    995 		break;
    996 	case IEEE80211_M_MONITOR:
    997 		imr->ifm_active |= IFM_IEEE80211_MONITOR;
    998 		break;
    999 	default:
   1000 		break;
   1001 	}
   1002 }
   1003 
   1004 static int
   1005 an_set_nwkey(struct an_softc *sc, struct ieee80211_nwkey *nwkey)
   1006 {
   1007 	int error;
   1008 	struct ieee80211com *ic = &sc->sc_ic;
   1009 	u_int16_t prevauth;
   1010 
   1011 	error = 0;
   1012 	prevauth = sc->sc_config.an_authtype;
   1013 
   1014 	switch (nwkey->i_wepon) {
   1015 	case IEEE80211_NWKEY_OPEN:
   1016 		sc->sc_config.an_authtype = AN_AUTHTYPE_OPEN;
   1017 		ic->ic_flags &= ~IEEE80211_F_PRIVACY;
   1018 		break;
   1019 
   1020 	case IEEE80211_NWKEY_WEP:
   1021 	case IEEE80211_NWKEY_WEP | IEEE80211_NWKEY_PERSIST:
   1022 		error = an_set_nwkey_wep(sc, nwkey);
   1023 		if (error == 0 || error == ENETRESET) {
   1024 			sc->sc_config.an_authtype =
   1025 			    AN_AUTHTYPE_OPEN | AN_AUTHTYPE_PRIVACY_IN_USE;
   1026 			ic->ic_flags |= IEEE80211_F_PRIVACY;
   1027 		}
   1028 		break;
   1029 
   1030 	case IEEE80211_NWKEY_EAP:
   1031 		error = an_set_nwkey_eap(sc, nwkey);
   1032 		if (error == 0 || error == ENETRESET) {
   1033 			sc->sc_config.an_authtype = AN_AUTHTYPE_OPEN |
   1034 			    AN_AUTHTYPE_PRIVACY_IN_USE | AN_AUTHTYPE_LEAP;
   1035 			ic->ic_flags |= IEEE80211_F_PRIVACY;
   1036 		}
   1037 		break;
   1038 	default:
   1039 		error = EINVAL;
   1040 		break;
   1041 	}
   1042 	if (error == 0 && prevauth != sc->sc_config.an_authtype)
   1043 		error = ENETRESET;
   1044 	return error;
   1045 }
   1046 
   1047 static int
   1048 an_set_nwkey_wep(struct an_softc *sc, struct ieee80211_nwkey *nwkey)
   1049 {
   1050 	int i, txkey, anysetkey, needreset, error;
   1051 	struct an_wepkey keys[IEEE80211_WEP_NKID];
   1052 
   1053 	error = 0;
   1054 	memset(keys, 0, sizeof(keys));
   1055 	anysetkey = needreset = 0;
   1056 
   1057 	/* load argument and sanity check */
   1058 	for (i = 0; i < IEEE80211_WEP_NKID; i++) {
   1059 		keys[i].an_wep_keylen = nwkey->i_key[i].i_keylen;
   1060 		if (keys[i].an_wep_keylen < 0)
   1061 			continue;
   1062 		if (keys[i].an_wep_keylen != 0 &&
   1063 		    keys[i].an_wep_keylen < IEEE80211_WEP_KEYLEN)
   1064 			return EINVAL;
   1065 		if (keys[i].an_wep_keylen > sizeof(keys[i].an_wep_key))
   1066 			return EINVAL;
   1067 		if ((error = copyin(nwkey->i_key[i].i_keydat,
   1068 		    keys[i].an_wep_key, keys[i].an_wep_keylen)) != 0)
   1069 			return error;
   1070 		anysetkey++;
   1071 	}
   1072 	txkey = nwkey->i_defkid - 1;
   1073 	if (txkey >= 0) {
   1074 		if (txkey >= IEEE80211_WEP_NKID)
   1075 			return EINVAL;
   1076 		/* default key must have a valid value */
   1077 		if (keys[txkey].an_wep_keylen == 0 ||
   1078 		    (keys[txkey].an_wep_keylen < 0 &&
   1079 		    sc->sc_perskeylen[txkey] == 0))
   1080 			return EINVAL;
   1081 		anysetkey++;
   1082 	}
   1083 	DPRINTF(("an_set_nwkey_wep: %s: %sold(%d:%d,%d,%d,%d) "
   1084 	    "pers(%d:%d,%d,%d,%d) new(%d:%d,%d,%d,%d)\n",
   1085 	    device_xname(sc->sc_dev),
   1086 	    ((nwkey->i_wepon & IEEE80211_NWKEY_PERSIST) ? "persist: " : ""),
   1087 	    sc->sc_tx_key,
   1088 	    sc->sc_wepkeys[0].an_wep_keylen, sc->sc_wepkeys[1].an_wep_keylen,
   1089 	    sc->sc_wepkeys[2].an_wep_keylen, sc->sc_wepkeys[3].an_wep_keylen,
   1090 	    sc->sc_tx_perskey,
   1091 	    sc->sc_perskeylen[0], sc->sc_perskeylen[1],
   1092 	    sc->sc_perskeylen[2], sc->sc_perskeylen[3],
   1093 	    txkey,
   1094 	    keys[0].an_wep_keylen, keys[1].an_wep_keylen,
   1095 	    keys[2].an_wep_keylen, keys[3].an_wep_keylen));
   1096 	if (!(nwkey->i_wepon & IEEE80211_NWKEY_PERSIST)) {
   1097 		/* set temporary keys */
   1098 		sc->sc_tx_key = txkey;
   1099 		for (i = 0; i < IEEE80211_WEP_NKID; i++) {
   1100 			if (keys[i].an_wep_keylen < 0)
   1101 				continue;
   1102 			memcpy(&sc->sc_wepkeys[i], &keys[i], sizeof(keys[i]));
   1103 		}
   1104 	} else {
   1105 		/* set persist keys */
   1106 		if (anysetkey) {
   1107 			/* prepare to write nvram */
   1108 			if (!sc->sc_enabled) {
   1109 				if (sc->sc_enable)
   1110 					(*sc->sc_enable)(sc);
   1111 				an_wait(sc);
   1112 				sc->sc_enabled = 1;
   1113 				error = an_write_wepkey(sc,
   1114 				    AN_RID_WEP_PERSISTENT, keys, txkey);
   1115 				if (sc->sc_disable)
   1116 					(*sc->sc_disable)(sc);
   1117 				sc->sc_enabled = 0;
   1118 			} else {
   1119 				an_cmd(sc, AN_CMD_DISABLE, 0);
   1120 				error = an_write_wepkey(sc,
   1121 				    AN_RID_WEP_PERSISTENT, keys, txkey);
   1122 				an_cmd(sc, AN_CMD_ENABLE, 0);
   1123 			}
   1124 			if (error)
   1125 				return error;
   1126 		}
   1127 		if (txkey >= 0)
   1128 			sc->sc_tx_perskey = txkey;
   1129 		if (sc->sc_tx_key >= 0) {
   1130 			sc->sc_tx_key = -1;
   1131 			needreset++;
   1132 		}
   1133 		for (i = 0; i < IEEE80211_WEP_NKID; i++) {
   1134 			if (sc->sc_wepkeys[i].an_wep_keylen >= 0) {
   1135 				memset(&sc->sc_wepkeys[i].an_wep_key, 0,
   1136 				    sizeof(sc->sc_wepkeys[i].an_wep_key));
   1137 				sc->sc_wepkeys[i].an_wep_keylen = -1;
   1138 				needreset++;
   1139 			}
   1140 			if (keys[i].an_wep_keylen >= 0)
   1141 				sc->sc_perskeylen[i] = keys[i].an_wep_keylen;
   1142 		}
   1143 	}
   1144 	if (needreset) {
   1145 		/* firmware restart to reload persistent key */
   1146 		an_reset(sc);
   1147 	}
   1148 	if (anysetkey || needreset)
   1149 		error = ENETRESET;
   1150 	return error;
   1151 }
   1152 
   1153 static int
   1154 an_set_nwkey_eap(struct an_softc *sc, struct ieee80211_nwkey *nwkey)
   1155 {
   1156 	int i, error, len;
   1157 	struct ifnet *ifp = &sc->sc_if;
   1158 	struct an_rid_leapkey *key;
   1159 	u_int16_t unibuf[sizeof(key->an_key)];
   1160 	static const int leap_rid[] = { AN_RID_LEAP_PASS, AN_RID_LEAP_USER };
   1161 	MD4_CTX ctx;
   1162 
   1163 	error = 0;
   1164 
   1165 	if (nwkey->i_key[0].i_keydat == NULL &&
   1166 	    nwkey->i_key[1].i_keydat == NULL)
   1167 		return 0;
   1168 	if (!sc->sc_enabled)
   1169 		return ENXIO;
   1170 	an_cmd(sc, AN_CMD_DISABLE, 0);
   1171 	key = &sc->sc_buf.sc_leapkey;
   1172 	for (i = 0; i < 2; i++) {
   1173 		if (nwkey->i_key[i].i_keydat == NULL)
   1174 			continue;
   1175 		len = nwkey->i_key[i].i_keylen;
   1176 		if (len > sizeof(key->an_key))
   1177 			return EINVAL;
   1178 		memset(key, 0, sizeof(*key));
   1179 		key->an_key_len = htole16(len);
   1180 		if ((error = copyin(nwkey->i_key[i].i_keydat, key->an_key,
   1181 		    len)) != 0)
   1182 			return error;
   1183 		if (i == 1) {
   1184 			/*
   1185 			 * Cisco seems to use PasswordHash and PasswordHashHash
   1186 			 * in RFC-2759 (MS-CHAP-V2).
   1187 			 */
   1188 			memset(unibuf, 0, sizeof(unibuf));
   1189 			/* XXX: convert password to unicode */
   1190 			for (i = 0; i < len; i++)
   1191 				unibuf[i] = key->an_key[i];
   1192 			/* set PasswordHash */
   1193 			MD4Init(&ctx);
   1194 			MD4Update(&ctx, (u_int8_t *)unibuf, len * 2);
   1195 			MD4Final(key->an_key, &ctx);
   1196 			/* set PasswordHashHash */
   1197 			MD4Init(&ctx);
   1198 			MD4Update(&ctx, key->an_key, 16);
   1199 			MD4Final(key->an_key + 16, &ctx);
   1200 			key->an_key_len = htole16(32);
   1201 		}
   1202 		if ((error = an_write_rid(sc, leap_rid[i], key,
   1203 		    sizeof(*key))) != 0) {
   1204 			printf("%s: LEAP set failed\n", ifp->if_xname);
   1205 			return error;
   1206 		}
   1207 	}
   1208 	error = an_cmd(sc, AN_CMD_ENABLE, 0);
   1209 	if (error)
   1210 		printf("%s: an_set_nwkey: failed to enable MAC\n",
   1211 		    ifp->if_xname);
   1212 	else
   1213 		error = ENETRESET;
   1214 	return error;
   1215 }
   1216 
   1217 static int
   1218 an_get_nwkey(struct an_softc *sc, struct ieee80211_nwkey *nwkey)
   1219 {
   1220 	int i, error;
   1221 
   1222 	error = 0;
   1223 	if (sc->sc_config.an_authtype & AN_AUTHTYPE_LEAP)
   1224 		nwkey->i_wepon = IEEE80211_NWKEY_EAP;
   1225 	else if (sc->sc_config.an_authtype & AN_AUTHTYPE_PRIVACY_IN_USE)
   1226 		nwkey->i_wepon = IEEE80211_NWKEY_WEP;
   1227 	else
   1228 		nwkey->i_wepon = IEEE80211_NWKEY_OPEN;
   1229 	if (sc->sc_tx_key == -1)
   1230 		nwkey->i_defkid = sc->sc_tx_perskey + 1;
   1231 	else
   1232 		nwkey->i_defkid = sc->sc_tx_key + 1;
   1233 	if (nwkey->i_key[0].i_keydat == NULL)
   1234 		return 0;
   1235 	for (i = 0; i < IEEE80211_WEP_NKID; i++) {
   1236 		if (nwkey->i_key[i].i_keydat == NULL)
   1237 			continue;
   1238 		/* do not show any keys to non-root user */
   1239 		/* XXX-elad: why is this inside a loop? */
   1240 		if ((error = kauth_authorize_network(curlwp->l_cred,
   1241 		    KAUTH_NETWORK_INTERFACE,
   1242 		    KAUTH_REQ_NETWORK_INTERFACE_GETPRIV, sc->sc_ic.ic_ifp,
   1243 		    KAUTH_ARG(SIOCG80211NWKEY), NULL)) != 0)
   1244 			break;
   1245 		nwkey->i_key[i].i_keylen = sc->sc_wepkeys[i].an_wep_keylen;
   1246 		if (nwkey->i_key[i].i_keylen < 0) {
   1247 			if (sc->sc_perskeylen[i] == 0)
   1248 				nwkey->i_key[i].i_keylen = 0;
   1249 			continue;
   1250 		}
   1251 		if ((error = copyout(sc->sc_wepkeys[i].an_wep_key,
   1252 		    nwkey->i_key[i].i_keydat,
   1253 		    sc->sc_wepkeys[i].an_wep_keylen)) != 0)
   1254 			break;
   1255 	}
   1256 	return error;
   1257 }
   1258 
   1259 static int
   1260 an_write_wepkey(struct an_softc *sc, int type, struct an_wepkey *keys, int kid)
   1261 {
   1262 	int i, error;
   1263 	struct an_rid_wepkey *akey;
   1264 
   1265 	error = 0;
   1266 	akey = &sc->sc_buf.sc_wepkey;
   1267 	memset(akey, 0, sizeof(struct an_rid_wepkey));
   1268 	for (i = 0; i < IEEE80211_WEP_NKID; i++) {
   1269 		if (keys[i].an_wep_keylen < 0 ||
   1270 		    keys[i].an_wep_keylen > sizeof(akey->an_key))
   1271 			continue;
   1272 		akey->an_key_len = htole16(keys[i].an_wep_keylen);
   1273 		akey->an_key_index = htole16(i);
   1274 		akey->an_mac_addr[0] = 1;	/* default mac */
   1275 		memcpy(akey->an_key, keys[i].an_wep_key, keys[i].an_wep_keylen);
   1276 		if ((error = an_write_rid(sc, type, akey, sizeof(*akey))) != 0)
   1277 			return error;
   1278 	}
   1279 	if (kid >= 0) {
   1280 		akey->an_key_index = htole16(0xffff);
   1281 		akey->an_mac_addr[0] = kid;
   1282 		akey->an_key_len = htole16(0);
   1283 		memset(akey->an_key, 0, sizeof(akey->an_key));
   1284 		error = an_write_rid(sc, type, akey, sizeof(*akey));
   1285 	}
   1286 	return error;
   1287 }
   1288 
   1289 #ifdef AN_DEBUG
   1290 static void
   1291 an_dump_pkt(const char *devname, struct mbuf *m)
   1292 {
   1293 	int col, col0, i;
   1294 	uint8_t *pkt = mtod(m, uint8_t *);
   1295 	const char *delim = "";
   1296 	int delimw = 0;
   1297 
   1298 	printf("%s: pkt ", devname);
   1299 	col = col0 = strlen(devname) + strlen(": pkt ");
   1300 	for (i = 0; i < m->m_len; i++) {
   1301 		printf("%s%02x", delim, pkt[i]);
   1302 		delim = ":";
   1303 		delimw = 1;
   1304 		col += delimw + 2;
   1305 		if (col >= 72) {
   1306 			printf("\n%*s", col0, "");
   1307 			col = col0;
   1308 			delim = "";
   1309 			delimw = 0;
   1310 		}
   1311 	}
   1312 	if (col != 0)
   1313 		printf("\n");
   1314 }
   1315 #endif /* AN_DEBUG */
   1316 
   1317 /*
   1318  * Low level functions
   1319  */
   1320 
   1321 static void
   1322 an_rx_intr(struct an_softc *sc)
   1323 {
   1324 	struct ieee80211com *ic = &sc->sc_ic;
   1325 	struct ifnet *ifp = &sc->sc_if;
   1326 	struct ieee80211_frame_min *wh;
   1327 	struct ieee80211_node *ni;
   1328 	struct an_rxframe frmhdr;
   1329 	struct mbuf *m;
   1330 	u_int16_t status;
   1331 	int fid, gaplen, len, off;
   1332 	uint8_t *gap;
   1333 
   1334 	fid = CSR_READ_2(sc, AN_RX_FID);
   1335 
   1336 	/* First read in the frame header */
   1337 	if (an_read_bap(sc, fid, 0, &frmhdr, sizeof(frmhdr)) != 0) {
   1338 		CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX);
   1339 		ifp->if_ierrors++;
   1340 		DPRINTF(("an_rx_intr: read fid %x failed\n", fid));
   1341 		return;
   1342 	}
   1343 
   1344 #ifdef AN_DEBUG
   1345 	if ((ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) == (IFF_DEBUG|IFF_LINK2)) {
   1346 		ieee80211_dump_pkt((u_int8_t *)&frmhdr.an_whdr,
   1347 		    sizeof(struct ieee80211_frame), frmhdr.an_rx_rate,
   1348 		    frmhdr.an_rx_signal_strength);
   1349 		printf(" time 0x%x status 0x%x plen %u chan %u"
   1350 		    " plcp %02x %02x %02x %02x gap %u\n",
   1351 		    le32toh(frmhdr.an_rx_time), le16toh(frmhdr.an_rx_status),
   1352 		    le16toh(frmhdr.an_rx_payload_len), frmhdr.an_rx_chan,
   1353 		    frmhdr.an_plcp_hdr[0], frmhdr.an_plcp_hdr[1],
   1354 		    frmhdr.an_plcp_hdr[2], frmhdr.an_plcp_hdr[3],
   1355 		    le16toh(frmhdr.an_gaplen));
   1356 	}
   1357 #endif
   1358 
   1359 	status = le16toh(frmhdr.an_rx_status);
   1360 	if ((status & AN_STAT_ERRSTAT) != 0 &&
   1361 	    ic->ic_opmode != IEEE80211_M_MONITOR) {
   1362 		CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX);
   1363 		ifp->if_ierrors++;
   1364 		DPRINTF(("an_rx_intr: fid %x status %x\n", fid, status));
   1365 		return;
   1366 	}
   1367 
   1368 	/* the payload length field includes a 16-bit "mystery field" */
   1369 	len = le16toh(frmhdr.an_rx_payload_len) - sizeof(uint16_t);
   1370 	off = ALIGN(sizeof(struct ieee80211_frame));
   1371 
   1372 	if (off + len > MCLBYTES) {
   1373 		if (ic->ic_opmode != IEEE80211_M_MONITOR) {
   1374 			CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX);
   1375 			ifp->if_ierrors++;
   1376 			DPRINTF(("an_rx_intr: oversized packet %d\n", len));
   1377 			return;
   1378 		}
   1379 		len = 0;
   1380 	}
   1381 
   1382 	MGETHDR(m, M_DONTWAIT, MT_DATA);
   1383 	if (m == NULL) {
   1384 		CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX);
   1385 		ifp->if_ierrors++;
   1386 		DPRINTF(("an_rx_intr: MGET failed\n"));
   1387 		return;
   1388 	}
   1389 	if (off + len + AN_GAPLEN_MAX > MHLEN) {
   1390 		MCLGET(m, M_DONTWAIT);
   1391 		if ((m->m_flags & M_EXT) == 0) {
   1392 			CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX);
   1393 			m_freem(m);
   1394 			ifp->if_ierrors++;
   1395 			DPRINTF(("an_rx_intr: MCLGET failed\n"));
   1396 			return;
   1397 		}
   1398 	}
   1399 	m->m_data += off - sizeof(struct ieee80211_frame);
   1400 
   1401 	if (ic->ic_opmode != IEEE80211_M_MONITOR) {
   1402 		gaplen = le16toh(frmhdr.an_gaplen);
   1403 		if (gaplen > AN_GAPLEN_MAX) {
   1404 			CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX);
   1405 			m_freem(m);
   1406 			ifp->if_ierrors++;
   1407 			DPRINTF(("%s: gap too long\n", __func__));
   1408 			return;
   1409 		}
   1410 		/*
   1411 		 * We don't need the 16-bit mystery field (payload length?),
   1412 		 * so read it into the region reserved for the 802.11 header.
   1413 		 *
   1414 		 * When Cisco Aironet 350 cards w/ firmware version 5 or
   1415 		 * greater operate with certain Cisco 350 APs,
   1416 		 * the "gap" is filled with the SNAP header.  Read
   1417 		 * it in after the 802.11 header.
   1418 		 */
   1419 		gap = m->m_data + sizeof(struct ieee80211_frame) -
   1420 		    sizeof(uint16_t);
   1421 		an_read_bap(sc, fid, -1, gap, gaplen + sizeof(u_int16_t));
   1422 #ifdef AN_DEBUG
   1423 		if ((ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) ==
   1424 		    (IFF_DEBUG|IFF_LINK2)) {
   1425 			int i;
   1426 			printf(" gap&len");
   1427 			for (i = 0; i < gaplen + sizeof(u_int16_t); i++)
   1428 				printf(" %02x", gap[i]);
   1429 			printf("\n");
   1430 		}
   1431 #endif
   1432 	} else
   1433 		gaplen = 0;
   1434 
   1435 	an_read_bap(sc, fid, -1,
   1436 	    m->m_data + sizeof(struct ieee80211_frame) + gaplen, len);
   1437 	m->m_pkthdr.len = m->m_len = sizeof(struct ieee80211_frame) + gaplen +
   1438 	    len;
   1439 
   1440 	memcpy(m->m_data, &frmhdr.an_whdr, sizeof(struct ieee80211_frame));
   1441 	m->m_pkthdr.rcvif = ifp;
   1442 	CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX);
   1443 
   1444 	if (sc->sc_drvbpf) {
   1445 		struct an_rx_radiotap_header *tap = &sc->sc_rxtap;
   1446 
   1447 		tap->ar_rate = frmhdr.an_rx_rate;
   1448 		tap->ar_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags);
   1449 		tap->ar_chan_freq = htole16(ic->ic_bss->ni_chan->ic_freq);
   1450 		tap->ar_antsignal = frmhdr.an_rx_signal_strength;
   1451 		if ((le16toh(frmhdr.an_rx_status) & AN_STAT_BADCRC) ||
   1452 		    (le16toh(frmhdr.an_rx_status) & AN_STAT_ERRSTAT) ||
   1453 		    (le16toh(frmhdr.an_rx_status) & AN_STAT_UNDECRYPTABLE))
   1454 		    tap->ar_flags |= IEEE80211_RADIOTAP_F_BADFCS;
   1455 
   1456 		bpf_mtap2(sc->sc_drvbpf, tap, tap->ar_ihdr.it_len, m);
   1457 	}
   1458 	wh = mtod(m, struct ieee80211_frame_min *);
   1459 	if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
   1460 		/*
   1461 		 * WEP is decrypted by hardware. Clear WEP bit
   1462 		 * header for ieee80211_input().
   1463 		 */
   1464 		wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
   1465 	}
   1466 
   1467 #ifdef AN_DEBUG
   1468 	if (an_debug > 1)
   1469 		an_dump_pkt(device_xname(sc->sc_dev), m);
   1470 #endif /* AN_DEBUG */
   1471 
   1472 	ni = ieee80211_find_rxnode(ic, wh);
   1473 	ieee80211_input(ic, m, ni, frmhdr.an_rx_signal_strength,
   1474 	    le32toh(frmhdr.an_rx_time));
   1475 	ieee80211_free_node(ni);
   1476 }
   1477 
   1478 static void
   1479 an_tx_intr(struct an_softc *sc, int status)
   1480 {
   1481 	struct ifnet *ifp = &sc->sc_if;
   1482 	int cur, fid;
   1483 
   1484 	sc->sc_tx_timer = 0;
   1485 	ifp->if_flags &= ~IFF_OACTIVE;
   1486 
   1487 	fid = CSR_READ_2(sc, AN_TX_CMP_FID);
   1488 	CSR_WRITE_2(sc, AN_EVENT_ACK, status & (AN_EV_TX | AN_EV_TX_EXC));
   1489 
   1490 	if (status & AN_EV_TX_EXC)
   1491 		ifp->if_oerrors++;
   1492 	else
   1493 		ifp->if_opackets++;
   1494 
   1495 	cur = sc->sc_txcur;
   1496 	if (sc->sc_txd[cur].d_fid == fid) {
   1497 		sc->sc_txd[cur].d_inuse = 0;
   1498 		DPRINTF2(("an_tx_intr: sent %x/%d\n", fid, cur));
   1499 		AN_INC(cur, AN_TX_RING_CNT);
   1500 		sc->sc_txcur = cur;
   1501 	} else {
   1502 		for (cur = 0; cur < AN_TX_RING_CNT; cur++) {
   1503 			if (fid == sc->sc_txd[cur].d_fid) {
   1504 				sc->sc_txd[cur].d_inuse = 0;
   1505 				break;
   1506 			}
   1507 		}
   1508 		if (ifp->if_flags & IFF_DEBUG)
   1509 			printf("%s: tx mismatch: "
   1510 			    "expected %x(%d), actual %x(%d)\n",
   1511 			    device_xname(sc->sc_dev),
   1512 			    sc->sc_txd[sc->sc_txcur].d_fid, sc->sc_txcur,
   1513 			    fid, cur);
   1514 	}
   1515 
   1516 	return;
   1517 }
   1518 
   1519 static void
   1520 an_linkstat_intr(struct an_softc *sc)
   1521 {
   1522 	struct ieee80211com *ic = &sc->sc_ic;
   1523 	u_int16_t status;
   1524 
   1525 	status = CSR_READ_2(sc, AN_LINKSTAT);
   1526 	CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_LINKSTAT);
   1527 	DPRINTF(("an_linkstat_intr: status 0x%x\n", status));
   1528 
   1529 	if (status == AN_LINKSTAT_ASSOCIATED) {
   1530 		if (ic->ic_state != IEEE80211_S_RUN ||
   1531 		    ic->ic_opmode == IEEE80211_M_IBSS)
   1532 			ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
   1533 	} else {
   1534 		if (ic->ic_opmode == IEEE80211_M_STA)
   1535 			ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
   1536 	}
   1537 }
   1538 
   1539 /* Must be called at proper protection level! */
   1540 static int
   1541 an_cmd(struct an_softc *sc, int cmd, int val)
   1542 {
   1543 	int i, status;
   1544 
   1545 	/* make sure that previous command completed */
   1546 	if (CSR_READ_2(sc, AN_COMMAND) & AN_CMD_BUSY) {
   1547 		if (sc->sc_if.if_flags & IFF_DEBUG)
   1548 			printf("%s: command 0x%x busy\n", device_xname(sc->sc_dev),
   1549 			    CSR_READ_2(sc, AN_COMMAND));
   1550 		CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_CLR_STUCK_BUSY);
   1551 	}
   1552 
   1553 	CSR_WRITE_2(sc, AN_PARAM0, val);
   1554 	CSR_WRITE_2(sc, AN_PARAM1, 0);
   1555 	CSR_WRITE_2(sc, AN_PARAM2, 0);
   1556 	CSR_WRITE_2(sc, AN_COMMAND, cmd);
   1557 
   1558 	if (cmd == AN_CMD_FW_RESTART) {
   1559 		/* XXX: should sleep here */
   1560 		DELAY(100*1000);
   1561 	}
   1562 
   1563 	for (i = 0; i < AN_TIMEOUT; i++) {
   1564 		if (CSR_READ_2(sc, AN_EVENT_STAT) & AN_EV_CMD)
   1565 			break;
   1566 		DELAY(10);
   1567 	}
   1568 
   1569 	status = CSR_READ_2(sc, AN_STATUS);
   1570 
   1571 	/* clear stuck command busy if necessary */
   1572 	if (CSR_READ_2(sc, AN_COMMAND) & AN_CMD_BUSY)
   1573 		CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_CLR_STUCK_BUSY);
   1574 
   1575 	/* Ack the command */
   1576 	CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_CMD);
   1577 
   1578 	if (i == AN_TIMEOUT) {
   1579 		if (sc->sc_if.if_flags & IFF_DEBUG)
   1580 			printf("%s: command 0x%x param 0x%x timeout\n",
   1581 			    device_xname(sc->sc_dev), cmd, val);
   1582 		return ETIMEDOUT;
   1583 	}
   1584 	if (status & AN_STAT_CMD_RESULT) {
   1585 		if (sc->sc_if.if_flags & IFF_DEBUG)
   1586 			printf("%s: command 0x%x param 0x%x status 0x%x "
   1587 			    "resp 0x%x 0x%x 0x%x\n",
   1588 			    device_xname(sc->sc_dev), cmd, val, status,
   1589 			    CSR_READ_2(sc, AN_RESP0), CSR_READ_2(sc, AN_RESP1),
   1590 			    CSR_READ_2(sc, AN_RESP2));
   1591 		return EIO;
   1592 	}
   1593 
   1594 	return 0;
   1595 }
   1596 
   1597 
   1598 /*
   1599  * Wait for firmware come up after power enabled.
   1600  */
   1601 static void
   1602 an_wait(struct an_softc *sc)
   1603 {
   1604 	int i;
   1605 
   1606 	CSR_WRITE_2(sc, AN_COMMAND, AN_CMD_NOOP2);
   1607 	for (i = 0; i < 3*hz; i++) {
   1608 		if (CSR_READ_2(sc, AN_EVENT_STAT) & AN_EV_CMD)
   1609 			break;
   1610 		(void)tsleep(sc, PWAIT, "anatch", 1);
   1611 	}
   1612 	CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_CMD);
   1613 }
   1614 
   1615 static int
   1616 an_seek_bap(struct an_softc *sc, int id, int off)
   1617 {
   1618 	int i, status;
   1619 
   1620 	CSR_WRITE_2(sc, AN_SEL0, id);
   1621 	CSR_WRITE_2(sc, AN_OFF0, off);
   1622 
   1623 	for (i = 0; ; i++) {
   1624 		status = CSR_READ_2(sc, AN_OFF0);
   1625 		if ((status & AN_OFF_BUSY) == 0)
   1626 			break;
   1627 		if (i == AN_TIMEOUT) {
   1628 			printf("%s: timeout in an_seek_bap to 0x%x/0x%x\n",
   1629 			    device_xname(sc->sc_dev), id, off);
   1630 			sc->sc_bap_off = AN_OFF_ERR;	/* invalidate */
   1631 			return ETIMEDOUT;
   1632 		}
   1633 		DELAY(10);
   1634 	}
   1635 	if (status & AN_OFF_ERR) {
   1636 		aprint_error_dev(sc->sc_dev, "failed in an_seek_bap to 0x%x/0x%x\n",
   1637 		    id, off);
   1638 		sc->sc_bap_off = AN_OFF_ERR;	/* invalidate */
   1639 		return EIO;
   1640 	}
   1641 	sc->sc_bap_id = id;
   1642 	sc->sc_bap_off = off;
   1643 	return 0;
   1644 }
   1645 
   1646 static int
   1647 an_read_bap(struct an_softc *sc, int id, int off, void *buf, int buflen)
   1648 {
   1649 	int error, cnt;
   1650 
   1651 	if (buflen == 0)
   1652 		return 0;
   1653 	if (off == -1)
   1654 		off = sc->sc_bap_off;
   1655 	if (id != sc->sc_bap_id || off != sc->sc_bap_off) {
   1656 		if ((error = an_seek_bap(sc, id, off)) != 0)
   1657 			return EIO;
   1658 	}
   1659 
   1660 	cnt = (buflen + 1) / 2;
   1661 	CSR_READ_MULTI_STREAM_2(sc, AN_DATA0, (u_int16_t *)buf, cnt);
   1662 	sc->sc_bap_off += cnt * 2;
   1663 	return 0;
   1664 }
   1665 
   1666 static int
   1667 an_write_bap(struct an_softc *sc, int id, int off, void *buf, int buflen)
   1668 {
   1669 	int error, cnt;
   1670 
   1671 	if (buflen == 0)
   1672 		return 0;
   1673 	if (off == -1)
   1674 		off = sc->sc_bap_off;
   1675 	if (id != sc->sc_bap_id || off != sc->sc_bap_off) {
   1676 		if ((error = an_seek_bap(sc, id, off)) != 0)
   1677 			return EIO;
   1678 	}
   1679 
   1680 	cnt = (buflen + 1) / 2;
   1681 	CSR_WRITE_MULTI_STREAM_2(sc, AN_DATA0, (u_int16_t *)buf, cnt);
   1682 	sc->sc_bap_off += cnt * 2;
   1683 	return 0;
   1684 }
   1685 
   1686 static int
   1687 an_mwrite_bap(struct an_softc *sc, int id, int off, struct mbuf *m, int totlen)
   1688 {
   1689 	int error, len, cnt;
   1690 
   1691 	if (off == -1)
   1692 		off = sc->sc_bap_off;
   1693 	if (id != sc->sc_bap_id || off != sc->sc_bap_off) {
   1694 		if ((error = an_seek_bap(sc, id, off)) != 0)
   1695 			return EIO;
   1696 	}
   1697 
   1698 	for (len = 0; m != NULL; m = m->m_next) {
   1699 		if (m->m_len == 0)
   1700 			continue;
   1701 		len = min(m->m_len, totlen);
   1702 
   1703 		if ((mtod(m, u_long) & 0x1) || (len & 0x1)) {
   1704 			m_copydata(m, 0, totlen, (void *)&sc->sc_buf.sc_txbuf);
   1705 			cnt = (totlen + 1) / 2;
   1706 			CSR_WRITE_MULTI_STREAM_2(sc, AN_DATA0,
   1707 			    sc->sc_buf.sc_val, cnt);
   1708 			off += cnt * 2;
   1709 			break;
   1710 		}
   1711 		cnt = len / 2;
   1712 		CSR_WRITE_MULTI_STREAM_2(sc, AN_DATA0, mtod(m, u_int16_t *),
   1713 		    cnt);
   1714 		off += len;
   1715 		totlen -= len;
   1716 	}
   1717 	sc->sc_bap_off = off;
   1718 	return 0;
   1719 }
   1720 
   1721 static int
   1722 an_alloc_fid(struct an_softc *sc, int len, int *idp)
   1723 {
   1724 	int i;
   1725 
   1726 	if (an_cmd(sc, AN_CMD_ALLOC_MEM, len)) {
   1727 		aprint_error_dev(sc->sc_dev, "failed to allocate %d bytes on NIC\n",
   1728 		    len);
   1729 		return ENOMEM;
   1730 	}
   1731 
   1732 	for (i = 0; i < AN_TIMEOUT; i++) {
   1733 		if (CSR_READ_2(sc, AN_EVENT_STAT) & AN_EV_ALLOC)
   1734 			break;
   1735 		if (i == AN_TIMEOUT) {
   1736 			printf("%s: timeout in alloc\n", device_xname(sc->sc_dev));
   1737 			return ETIMEDOUT;
   1738 		}
   1739 		DELAY(10);
   1740 	}
   1741 
   1742 	*idp = CSR_READ_2(sc, AN_ALLOC_FID);
   1743 	CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_ALLOC);
   1744 	return 0;
   1745 }
   1746 
   1747 static int
   1748 an_read_rid(struct an_softc *sc, int rid, void *buf, int *buflenp)
   1749 {
   1750 	int error;
   1751 	u_int16_t len;
   1752 
   1753 	/* Tell the NIC to enter record read mode. */
   1754 	error = an_cmd(sc, AN_CMD_ACCESS | AN_ACCESS_READ, rid);
   1755 	if (error)
   1756 		return error;
   1757 
   1758 	/* length in byte, including length itself */
   1759 	error = an_read_bap(sc, rid, 0, &len, sizeof(len));
   1760 	if (error)
   1761 		return error;
   1762 
   1763 	len = le16toh(len) - 2;
   1764 	if (*buflenp < len) {
   1765 		aprint_error_dev(sc->sc_dev, "record buffer is too small, "
   1766 		    "rid=%x, size=%d, len=%d\n",
   1767 		    rid, *buflenp, len);
   1768 		return ENOSPC;
   1769 	}
   1770 	*buflenp = len;
   1771 	return an_read_bap(sc, rid, sizeof(len), buf, len);
   1772 }
   1773 
   1774 static int
   1775 an_write_rid(struct an_softc *sc, int rid, void *buf, int buflen)
   1776 {
   1777 	int error;
   1778 	u_int16_t len;
   1779 
   1780 	/* length in byte, including length itself */
   1781 	len = htole16(buflen + 2);
   1782 
   1783 	error = an_write_bap(sc, rid, 0, &len, sizeof(len));
   1784 	if (error)
   1785 		return error;
   1786 	error = an_write_bap(sc, rid, sizeof(len), buf, buflen);
   1787 	if (error)
   1788 		return error;
   1789 
   1790 	return an_cmd(sc, AN_CMD_ACCESS | AN_ACCESS_WRITE, rid);
   1791 }
   1792 
   1793 static int
   1794 an_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
   1795 {
   1796 	struct an_softc *sc = (struct an_softc *)ic->ic_ifp->if_softc;
   1797 	struct ieee80211_node *ni = ic->ic_bss;
   1798 	int buflen;
   1799 
   1800 	DPRINTF(("an_newstate: %s -> %s\n", ieee80211_state_name[ic->ic_state],
   1801 	    ieee80211_state_name[nstate]));
   1802 
   1803 	switch (nstate) {
   1804 	case IEEE80211_S_INIT:
   1805 		ic->ic_flags &= ~IEEE80211_F_IBSSON;
   1806 		return (*sc->sc_newstate)(ic, nstate, arg);
   1807 
   1808 	case IEEE80211_S_SCAN:
   1809 	case IEEE80211_S_AUTH:
   1810 	case IEEE80211_S_ASSOC:
   1811 		ic->ic_state = nstate; /* NB: skip normal ieee80211 handling */
   1812 		return 0;
   1813 
   1814 	case IEEE80211_S_RUN:
   1815 		buflen = sizeof(sc->sc_buf);
   1816 		an_read_rid(sc, AN_RID_STATUS, &sc->sc_buf, &buflen);
   1817 		IEEE80211_ADDR_COPY(ni->ni_bssid,
   1818 		    sc->sc_buf.sc_status.an_cur_bssid);
   1819 		IEEE80211_ADDR_COPY(ni->ni_macaddr, ni->ni_bssid);
   1820 		ni->ni_chan = &ic->ic_channels[
   1821 		    le16toh(sc->sc_buf.sc_status.an_cur_channel)];
   1822 		ni->ni_esslen = le16toh(sc->sc_buf.sc_status.an_ssidlen);
   1823 		if (ni->ni_esslen > IEEE80211_NWID_LEN)
   1824 			ni->ni_esslen = IEEE80211_NWID_LEN;	/*XXX*/
   1825 		memcpy(ni->ni_essid, sc->sc_buf.sc_status.an_ssid,
   1826 		    ni->ni_esslen);
   1827 		ni->ni_rates = ic->ic_sup_rates[IEEE80211_MODE_11B];	/*XXX*/
   1828 		if (ic->ic_ifp->if_flags & IFF_DEBUG) {
   1829 			printf("%s: ", device_xname(sc->sc_dev));
   1830 			if (ic->ic_opmode == IEEE80211_M_STA)
   1831 				printf("associated ");
   1832 			else
   1833 				printf("synchronized ");
   1834 			printf("with %s ssid ", ether_sprintf(ni->ni_bssid));
   1835 			ieee80211_print_essid(ni->ni_essid, ni->ni_esslen);
   1836 			printf(" channel %u start %uMb\n",
   1837 			    le16toh(sc->sc_buf.sc_status.an_cur_channel),
   1838 			    le16toh(sc->sc_buf.sc_status.an_current_tx_rate)/2);
   1839 		}
   1840 		break;
   1841 
   1842 	default:
   1843 		break;
   1844 	}
   1845 	return (*sc->sc_newstate)(ic, nstate, arg);
   1846 }
   1847