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