![[BACK]](/icons/back.gif){kind=icon}
Return to awi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to awi.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: awi.c,v 1.23 2007/02/11 20:29:22 miod Exp $ */
2: /* $NetBSD: awi.c,v 1.26 2000/07/21 04:48:55 onoe Exp $ */
3:
4: /*-
5: * Copyright (c) 1999 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Bill Sommerfeld
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39: /*
40: * Driver for AMD 802.11 firmware.
41: * Uses am79c930 chip driver to talk to firmware running on the am79c930.
42: *
43: * More-or-less a generic ethernet-like if driver, with 802.11 gorp added.
44: */
45:
46: /*
47: * todo:
48: * - flush tx queue on resynch.
49: * - clear oactive on "down".
50: * - rewrite copy-into-mbuf code
51: * - mgmt state machine gets stuck retransmitting assoc requests.
52: * - multicast filter.
53: * - fix device reset so it's more likely to work
54: * - show status goo through ifmedia.
55: *
56: * more todo:
57: * - deal with more 802.11 frames.
58: * - send reassoc request
59: * - deal with reassoc response
60: * - send/deal with disassociation
61: * - deal with "full" access points (no room for me).
62: * - power save mode
63: *
64: * later:
65: * - SSID preferences
66: * - need ioctls for poking at the MIBs
67: * - implement ad-hoc mode (including bss creation).
68: * - decide when to do "ad hoc" vs. infrastructure mode (IFF_LINK flags?)
69: * (focus on inf. mode since that will be needed for ietf)
70: * - deal with DH vs. FH versions of the card
71: * - deal with faster cards (2mb/s)
72: * - ?WEP goo (mmm, rc4) (it looks not particularly useful).
73: * - ifmedia revision.
74: * - common 802.11 mibish things.
75: * - common 802.11 media layer.
76: */
77:
78: /*
79: * Driver for AMD 802.11 PCnetMobile firmware.
80: * Uses am79c930 chip driver to talk to firmware running on the am79c930.
81: *
82: * The initial version of the driver was written by
83: * Bill Sommerfeld <sommerfeld@netbsd.org>.
84: * Then the driver module completely rewritten to support cards with DS phy
85: * and to support adhoc mode by Atsushi Onoe <onoe@netbsd.org>
86: */
87:
88: #if defined(__FreeBSD__) && __FreeBSD__ >= 4
89: #define NBPFILTER 1
90: #elif defined(__FreeBSD__) && __FreeBSD__ >= 3
91: #include "bpf.h"
92: #define NBPFILTER NBPF
93: #else
94: #include "bpfilter.h"
95: #endif
96:
97: #include <sys/param.h>
98: #include <sys/systm.h>
99: #include <sys/kernel.h>
100: #include <sys/mbuf.h>
101: #include <sys/malloc.h>
102: #include <sys/proc.h>
103: #include <sys/socket.h>
104: #include <sys/sockio.h>
105: #include <sys/errno.h>
106: #include <sys/syslog.h>
107: #if defined(__FreeBSD__) && __FreeBSD__ >= 4
108: #include <sys/bus.h>
109: #else
110: #include <sys/device.h>
111: #endif
112:
113: #include <net/if.h>
114: #include <net/if_dl.h>
115: #ifndef __OpenBSD__
116: #ifdef __FreeBSD__
117: #include <net/ethernet.h>
118: #else
119: #include <net/if_ether.h>
120: #endif
121: #endif
122: #include <net/if_media.h>
123: #include <net/if_llc.h>
124:
125: #ifdef INET
126: #include <netinet/in.h>
127: #include <netinet/in_systm.h>
128: #include <netinet/in_var.h>
129: #include <netinet/ip.h>
130: #ifdef __NetBSD__
131: #include <netinet/if_inarp.h>
132: #else
133: #include <netinet/if_ether.h>
134: #endif
135: #endif
136:
137: #include <net80211/ieee80211.h>
138: #include <net80211/ieee80211_ioctl.h>
139:
140: #if NBPFILTER > 0
141: #include <net/bpf.h>
142: #endif
143:
144: #include <machine/cpu.h>
145: #include <machine/bus.h>
146: #ifdef __NetBSD__
147: #include <machine/intr.h>
148: #endif
149: #ifdef __FreeBSD__
150: #include <machine/clock.h>
151: #endif
152:
153: #if defined(__NetBSD__) || defined(__OpenBSD__)
154: #include <dev/ic/am79c930reg.h>
155: #include <dev/ic/am79c930var.h>
156: #include <dev/ic/awireg.h>
157: #include <dev/ic/awivar.h>
158: #endif
159: #ifdef __FreeBSD__
160: #include <dev/awi/am79c930reg.h>
161: #include <dev/awi/am79c930var.h>
162: #include <dev/awi/awireg.h>
163: #include <dev/awi/awivar.h>
164: #endif
165:
166: static int awi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
167: #ifdef IFM_IEEE80211
168: static int awi_media_rate2opt(struct awi_softc *sc, int rate);
169: static int awi_media_opt2rate(struct awi_softc *sc, int opt);
170: static int awi_media_change(struct ifnet *ifp);
171: static void awi_media_status(struct ifnet *ifp, struct ifmediareq *imr);
172: #endif
173: static void awi_watchdog(struct ifnet *ifp);
174: static void awi_start(struct ifnet *ifp);
175: static void awi_txint(struct awi_softc *sc);
176: static struct mbuf * awi_fix_txhdr(struct awi_softc *sc, struct mbuf *m0);
177: static struct mbuf * awi_fix_rxhdr(struct awi_softc *sc, struct mbuf *m0);
178: static void awi_input(struct awi_softc *sc, struct mbuf *m, u_int32_t rxts, u_int8_t rssi);
179: static void awi_rxint(struct awi_softc *sc);
180: static struct mbuf * awi_devget(struct awi_softc *sc, u_int32_t off, u_int16_t len);
181: static int awi_init_hw(struct awi_softc *sc);
182: static int awi_init_mibs(struct awi_softc *sc);
183: static int awi_init_txrx(struct awi_softc *sc);
184: static void awi_stop_txrx(struct awi_softc *sc);
185: static int awi_start_scan(struct awi_softc *sc);
186: static int awi_next_scan(struct awi_softc *sc);
187: static void awi_stop_scan(struct awi_softc *sc);
188: static void awi_recv_beacon(struct awi_softc *sc, struct mbuf *m0, u_int32_t rxts, u_int8_t rssi);
189: static int awi_set_ss(struct awi_softc *sc);
190: static void awi_try_sync(struct awi_softc *sc);
191: static void awi_sync_done(struct awi_softc *sc);
192: static void awi_send_deauth(struct awi_softc *sc);
193: static void awi_send_auth(struct awi_softc *sc, int seq);
194: static void awi_recv_auth(struct awi_softc *sc, struct mbuf *m0);
195: static void awi_send_asreq(struct awi_softc *sc, int reassoc);
196: static void awi_recv_asresp(struct awi_softc *sc, struct mbuf *m0);
197: static int awi_mib(struct awi_softc *sc, u_int8_t cmd, u_int8_t mib);
198: static int awi_cmd_scan(struct awi_softc *sc);
199: static int awi_cmd(struct awi_softc *sc, u_int8_t cmd);
200: static void awi_cmd_done(struct awi_softc *sc);
201: static int awi_next_txd(struct awi_softc *sc, int len, u_int32_t *framep, u_int32_t*ntxdp);
202: static int awi_lock(struct awi_softc *sc);
203: static void awi_unlock(struct awi_softc *sc);
204: static int awi_intr_lock(struct awi_softc *sc);
205: static void awi_intr_unlock(struct awi_softc *sc);
206: static int awi_cmd_wait(struct awi_softc *sc);
207: static void awi_print_essid(u_int8_t *essid);
208:
209: #ifdef AWI_DEBUG
210: static void awi_dump_pkt(struct awi_softc *sc, struct mbuf *m, int rssi);
211: int awi_verbose = 0;
212: int awi_dump = 0;
213: #define AWI_DUMP_MASK(fc0) (1 << (((fc0) & IEEE80211_FC0_SUBTYPE_MASK) >> 4))
214: int awi_dump_mask = AWI_DUMP_MASK(IEEE80211_FC0_SUBTYPE_BEACON);
215: int awi_dump_hdr = 0;
216: int awi_dump_len = 28;
217: #endif
218:
219: #if NBPFILTER > 0
220: #define AWI_BPF_NORM 0
221: #define AWI_BPF_RAW 1
222: #ifdef __FreeBSD__
223: #define AWI_BPF_MTAP(sc, m, raw, dir) do { \
224: if ((sc)->sc_ifp->if_bpf && (sc)->sc_rawbpf == (raw)) \
225: bpf_mtap((sc)->sc_ifp, (m)); \
226: } while (0);
227: #else
228: #define AWI_BPF_MTAP(sc, m, raw, dir) do { \
229: if ((sc)->sc_ifp->if_bpf && (sc)->sc_rawbpf == (raw)) \
230: bpf_mtap((sc)->sc_ifp->if_bpf, (m), dir); \
231: } while (0);
232: #endif
233: #else
234: #define AWI_BPF_MTAP(sc, m, raw, dir)
235: #endif
236:
237: #ifndef llc_snap
238: #define llc_snap llc_un.type_snap
239: #endif
240:
241: #ifdef __OpenBSD__
242: struct cfdriver awi_cd = {
243: NULL, "awi", DV_IFNET
244: };
245: #endif
246:
247: #ifdef __FreeBSD__
248: #if __FreeBSD__ >= 4
249: devclass_t awi_devclass;
250: #endif
251:
252: /* NetBSD compatible functions */
253: static char * ether_sprintf(u_int8_t *);
254:
255: static char *
256: ether_sprintf(enaddr)
257: u_int8_t *enaddr;
258: {
259: static char strbuf[18];
260:
261: snprintf(strbuf, sizeof strbuf, "%6D", enaddr, ":");
262: return strbuf;
263: }
264: #endif
265:
266: int
267: awi_attach(sc)
268: struct awi_softc *sc;
269: {
270: struct ifnet *ifp = sc->sc_ifp;
271: int s;
272: int error;
273: #ifdef IFM_IEEE80211
274: int i;
275: u_int8_t *phy_rates;
276: int mword;
277: struct ifmediareq imr;
278: #endif
279:
280: s = splnet();
281: /*
282: * Even if we can sleep in initialization state,
283: * all other processes (e.g. ifconfig) have to wait for
284: * completion of attaching interface.
285: */
286: sc->sc_busy = 1;
287: sc->sc_status = AWI_ST_INIT;
288: TAILQ_INIT(&sc->sc_scan);
289: error = awi_init_hw(sc);
290: if (error) {
291: sc->sc_invalid = 1;
292: splx(s);
293: return error;
294: }
295: error = awi_init_mibs(sc);
296: splx(s);
297: if (error) {
298: sc->sc_invalid = 1;
299: return error;
300: }
301:
302: ifp->if_softc = sc;
303: ifp->if_start = awi_start;
304: ifp->if_ioctl = awi_ioctl;
305: ifp->if_watchdog = awi_watchdog;
306: ifp->if_hdrlen = sizeof(struct ieee80211_frame) +
307: sizeof(struct ether_header);
308: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
309: #ifdef IFF_NOTRAILERS
310: ifp->if_flags |= IFF_NOTRAILERS;
311: #endif
312: #if defined(__NetBSD__) || defined(__OpenBSD__)
313: memcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
314: #endif
315: #ifdef __FreeBSD__
316: ifp->if_output = ether_output;
317: IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
318: memcpy(sc->sc_ec.ac_enaddr, sc->sc_mib_addr.aMAC_Address,
319: ETHER_ADDR_LEN);
320: #endif
321: IFQ_SET_READY(&ifp->if_snd);
322:
323: printf("%s: IEEE802.11 %s %dMbps (firmware %s)\n",
324: sc->sc_dev.dv_xname,
325: sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH ? "FH" : "DS",
326: sc->sc_tx_rate / 10, sc->sc_banner);
327: printf("%s: address %s\n",
328: sc->sc_dev.dv_xname, ether_sprintf(sc->sc_mib_addr.aMAC_Address));
329: if_attach(ifp);
330: #ifdef __OpenBSD__
331: ether_ifattach(ifp);
332: #elif defined(__FreeBSD__)
333: ether_ifattach(ifp);
334: #if NBPFILTER > 0
335: bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
336: #endif
337: #elif defined(__NetBSD__)
338: ether_ifattach(ifp, sc->sc_mib_addr.aMAC_Address);
339: #endif
340:
341: #ifdef IFM_IEEE80211
342: ifmedia_init(&sc->sc_media, 0, awi_media_change, awi_media_status);
343: phy_rates = sc->sc_mib_phy.aSuprt_Data_Rates;
344: for (i = 0; i < phy_rates[1]; i++) {
345: mword = awi_media_rate2opt(sc, AWI_80211_RATE(phy_rates[2 + i]));
346: if (mword == 0)
347: continue;
348: mword |= IFM_IEEE80211;
349: ifmedia_add(&sc->sc_media, mword, 0, NULL);
350: ifmedia_add(&sc->sc_media,
351: mword | IFM_IEEE80211_ADHOC, 0, NULL);
352: if (sc->sc_mib_phy.IEEE_PHY_Type != AWI_PHY_TYPE_FH)
353: ifmedia_add(&sc->sc_media,
354: mword | IFM_IEEE80211_ADHOC | IFM_FLAG0, 0, NULL);
355: }
356: awi_media_status(ifp, &imr);
357: ifmedia_set(&sc->sc_media, imr.ifm_active);
358: #endif
359:
360: /* ready to accept ioctl */
361: awi_unlock(sc);
362:
363: /* Attach is successful. */
364: sc->sc_attached = 1;
365: return 0;
366: }
367:
368: #ifndef __FreeBSD__
369: int
370: awi_detach(sc)
371: struct awi_softc *sc;
372: {
373: struct ifnet *ifp = sc->sc_ifp;
374: int s;
375:
376: /* Succeed if there is no work to do. */
377: if (!sc->sc_attached)
378: return (0);
379:
380: s = splnet();
381: sc->sc_invalid = 1;
382: awi_stop(sc);
383: while (sc->sc_sleep_cnt > 0) {
384: wakeup(sc);
385: (void)tsleep(sc, PWAIT, "awidet", 1);
386: }
387: if (sc->sc_wep_ctx != NULL)
388: free(sc->sc_wep_ctx, M_DEVBUF);
389: #ifdef IFM_IEEE80211
390: ifmedia_delete_instance(&sc->sc_media, IFM_INST_ANY);
391: #endif
392: ether_ifdetach(ifp);
393: if_detach(ifp);
394: if (sc->sc_enabled) {
395: if (sc->sc_disable)
396: (*sc->sc_disable)(sc);
397: sc->sc_enabled = 0;
398: }
399: splx(s);
400: return 0;
401: }
402:
403: int
404: awi_activate(self, act)
405: struct device *self;
406: enum devact act;
407: {
408: struct awi_softc *sc = (struct awi_softc *)self;
409: int s, error = 0;
410:
411: s = splnet();
412: switch (act) {
413: case DVACT_ACTIVATE:
414: break;
415:
416: case DVACT_DEACTIVATE:
417: sc->sc_invalid = 1;
418: #ifdef __NetBSD__
419: if (sc->sc_ifp)
420: if_deactivate(sc->sc_ifp);
421: #endif
422: break;
423: }
424: splx(s);
425:
426: return error;
427: }
428:
429: void
430: awi_power(sc, why)
431: struct awi_softc *sc;
432: int why;
433: {
434: int s;
435: int ocansleep;
436:
437: if (!sc->sc_enabled)
438: return;
439:
440: s = splnet();
441: ocansleep = sc->sc_cansleep;
442: sc->sc_cansleep = 0;
443: #ifdef needtobefixed /*ONOE*/
444: if (why == PWR_RESUME) {
445: sc->sc_enabled = 0;
446: awi_init(sc);
447: (void)awi_intr(sc);
448: } else {
449: awi_stop(sc);
450: if (sc->sc_disable)
451: (*sc->sc_disable)(sc);
452: }
453: #endif
454: sc->sc_cansleep = ocansleep;
455: splx(s);
456: }
457: #endif /* __NetBSD__ */
458:
459: static int
460: awi_ioctl(ifp, cmd, data)
461: struct ifnet *ifp;
462: u_long cmd;
463: caddr_t data;
464: {
465: struct awi_softc *sc = ifp->if_softc;
466: struct ifreq *ifr = (struct ifreq *)data;
467: struct ifaddr *ifa = (struct ifaddr *)data;
468: int s, error;
469: struct ieee80211_nwid nwid;
470: u_int8_t *p;
471:
472: s = splnet();
473:
474: #ifdef __OpenBSD__
475: if ((error = ether_ioctl(ifp, &sc->sc_arpcom, cmd, data)) > 0) {
476: splx(s);
477: return (error);
478: }
479: #endif
480:
481: /* serialize ioctl */
482: error = awi_lock(sc);
483: if (error)
484: goto cantlock;
485: switch (cmd) {
486: case SIOCSIFADDR:
487: ifp->if_flags |= IFF_UP;
488: switch (ifa->ifa_addr->sa_family) {
489: #ifdef INET
490: case AF_INET:
491: arp_ifinit((void *)ifp, ifa);
492: break;
493: #endif
494: }
495: /* FALLTHROUGH */
496: case SIOCSIFFLAGS:
497: sc->sc_format_llc = !(ifp->if_flags & IFF_LINK0);
498: if (!(ifp->if_flags & IFF_UP)) {
499: if (sc->sc_enabled) {
500: awi_stop(sc);
501: if (sc->sc_disable)
502: (*sc->sc_disable)(sc);
503: sc->sc_enabled = 0;
504: }
505: break;
506: }
507: error = awi_init(sc);
508: break;
509:
510: case SIOCADDMULTI:
511: case SIOCDELMULTI:
512: #ifdef __FreeBSD__
513: error = ENETRESET; /*XXX*/
514: #else
515: error = (cmd == SIOCADDMULTI) ?
516: ether_addmulti(ifr, &sc->sc_arpcom) :
517: ether_delmulti(ifr, &sc->sc_arpcom);
518: #endif
519: /*
520: * Do not rescan BSS. Rather, just reset multicast filter.
521: */
522: if (error == ENETRESET) {
523: if (ifp->if_flags & IFF_RUNNING)
524: error = awi_init(sc);
525: else
526: error = 0;
527: }
528: break;
529: case SIOCSIFMTU:
530: if (ifr->ifr_mtu > ETHERMTU)
531: error = EINVAL;
532: else
533: ifp->if_mtu = ifr->ifr_mtu;
534: break;
535: case SIOCS80211NWID:
536: if ((error = suser(curproc, 0)) != 0)
537: break;
538: error = copyin(ifr->ifr_data, &nwid, sizeof(nwid));
539: if (error)
540: break;
541: if (nwid.i_len > IEEE80211_NWID_LEN) {
542: error = EINVAL;
543: break;
544: }
545: if (sc->sc_mib_mac.aDesired_ESS_ID[1] == nwid.i_len &&
546: memcmp(&sc->sc_mib_mac.aDesired_ESS_ID[2], nwid.i_nwid,
547: nwid.i_len) == 0)
548: break;
549: memset(sc->sc_mib_mac.aDesired_ESS_ID, 0, AWI_ESS_ID_SIZE);
550: sc->sc_mib_mac.aDesired_ESS_ID[0] = IEEE80211_ELEMID_SSID;
551: sc->sc_mib_mac.aDesired_ESS_ID[1] = nwid.i_len;
552: memcpy(&sc->sc_mib_mac.aDesired_ESS_ID[2], nwid.i_nwid,
553: nwid.i_len);
554: if (sc->sc_enabled) {
555: awi_stop(sc);
556: error = awi_init(sc);
557: }
558: break;
559: case SIOCG80211NWID:
560: if (ifp->if_flags & IFF_RUNNING)
561: p = sc->sc_bss.essid;
562: else
563: p = sc->sc_mib_mac.aDesired_ESS_ID;
564: error = copyout(p + 1, ifr->ifr_data, 1 + IEEE80211_NWID_LEN);
565: break;
566: case SIOCS80211NWKEY:
567: if ((error = suser(curproc, 0)) != 0)
568: break;
569: error = awi_wep_setnwkey(sc, (struct ieee80211_nwkey *)data);
570: break;
571: case SIOCG80211NWKEY:
572: error = awi_wep_getnwkey(sc, (struct ieee80211_nwkey *)data);
573: break;
574: #ifdef IFM_IEEE80211
575: case SIOCSIFMEDIA:
576: case SIOCGIFMEDIA:
577: error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
578: break;
579: #endif
580: default:
581: #ifdef notyet
582: error = awi_wicfg(ifp, cmd, data);
583: #else
584: error = EINVAL;
585: #endif
586: break;
587: }
588: awi_unlock(sc);
589: cantlock:
590: splx(s);
591: return error;
592: }
593:
594: #ifdef IFM_IEEE80211
595: static int
596: awi_media_rate2opt(sc, rate)
597: struct awi_softc *sc;
598: int rate;
599: {
600: int mword;
601:
602: mword = 0;
603: switch (rate) {
604: case 10:
605: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH)
606: mword = IFM_IEEE80211_FH1;
607: else
608: mword = IFM_IEEE80211_DS1;
609: break;
610: case 20:
611: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH)
612: mword = IFM_IEEE80211_FH2;
613: else
614: mword = IFM_IEEE80211_DS2;
615: break;
616: case 55:
617: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_DS)
618: mword = IFM_IEEE80211_DS5;
619: break;
620: case 110:
621: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_DS)
622: mword = IFM_IEEE80211_DS11;
623: break;
624: }
625: return mword;
626: }
627:
628: static int
629: awi_media_opt2rate(sc, opt)
630: struct awi_softc *sc;
631: int opt;
632: {
633: int rate;
634:
635: rate = 0;
636: switch (IFM_SUBTYPE(opt)) {
637: case IFM_IEEE80211_FH1:
638: case IFM_IEEE80211_FH2:
639: if (sc->sc_mib_phy.IEEE_PHY_Type != AWI_PHY_TYPE_FH)
640: return 0;
641: break;
642: case IFM_IEEE80211_DS1:
643: case IFM_IEEE80211_DS2:
644: case IFM_IEEE80211_DS5:
645: case IFM_IEEE80211_DS11:
646: if (sc->sc_mib_phy.IEEE_PHY_Type != AWI_PHY_TYPE_DS)
647: return 0;
648: break;
649: }
650:
651: switch (IFM_SUBTYPE(opt)) {
652: case IFM_IEEE80211_FH1:
653: case IFM_IEEE80211_DS1:
654: rate = 10;
655: break;
656: case IFM_IEEE80211_FH2:
657: case IFM_IEEE80211_DS2:
658: rate = 20;
659: break;
660: case IFM_IEEE80211_DS5:
661: rate = 55;
662: break;
663: case IFM_IEEE80211_DS11:
664: rate = 110;
665: break;
666: }
667: return rate;
668: }
669:
670: /*
671: * Called from ifmedia_ioctl via awi_ioctl with lock obtained.
672: */
673: static int
674: awi_media_change(ifp)
675: struct ifnet *ifp;
676: {
677: struct awi_softc *sc = ifp->if_softc;
678: struct ifmedia_entry *ime;
679: u_int8_t *phy_rates;
680: int i, rate, error;
681:
682: error = 0;
683: ime = sc->sc_media.ifm_cur;
684: rate = awi_media_opt2rate(sc, ime->ifm_media);
685: if (rate == 0)
686: return EINVAL;
687: if (rate != sc->sc_tx_rate) {
688: phy_rates = sc->sc_mib_phy.aSuprt_Data_Rates;
689: for (i = 0; i < phy_rates[1]; i++) {
690: if (rate == AWI_80211_RATE(phy_rates[2 + i]))
691: break;
692: }
693: if (i == phy_rates[1])
694: return EINVAL;
695: }
696: if (ime->ifm_media & IFM_IEEE80211_ADHOC) {
697: sc->sc_mib_local.Network_Mode = 0;
698: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH)
699: sc->sc_no_bssid = 0;
700: else
701: sc->sc_no_bssid = (ime->ifm_media & IFM_FLAG0) ? 1 : 0;
702: } else {
703: sc->sc_mib_local.Network_Mode = 1;
704: }
705: if (sc->sc_enabled) {
706: awi_stop(sc);
707: error = awi_init(sc);
708: }
709: return error;
710: }
711:
712: static void
713: awi_media_status(ifp, imr)
714: struct ifnet *ifp;
715: struct ifmediareq *imr;
716: {
717: struct awi_softc *sc = ifp->if_softc;
718:
719: imr->ifm_status = IFM_AVALID;
720: if (ifp->if_flags & IFF_RUNNING)
721: imr->ifm_status |= IFM_ACTIVE;
722: imr->ifm_active = IFM_IEEE80211;
723: imr->ifm_active |= awi_media_rate2opt(sc, sc->sc_tx_rate);
724: if (sc->sc_mib_local.Network_Mode == 0) {
725: imr->ifm_active |= IFM_IEEE80211_ADHOC;
726: if (sc->sc_no_bssid)
727: imr->ifm_active |= IFM_FLAG0;
728: }
729: }
730: #endif /* IFM_IEEE80211 */
731:
732: int
733: awi_intr(arg)
734: void *arg;
735: {
736: struct awi_softc *sc = arg;
737: u_int16_t status;
738: int error, handled = 0, ocansleep;
739:
740: if (!sc->sc_enabled || !sc->sc_enab_intr || sc->sc_invalid)
741: return 0;
742:
743: am79c930_gcr_setbits(&sc->sc_chip,
744: AM79C930_GCR_DISPWDN | AM79C930_GCR_ECINT);
745: awi_write_1(sc, AWI_DIS_PWRDN, 1);
746: ocansleep = sc->sc_cansleep;
747: sc->sc_cansleep = 0;
748:
749: for (;;) {
750: error = awi_intr_lock(sc);
751: if (error)
752: break;
753: status = awi_read_1(sc, AWI_INTSTAT);
754: awi_write_1(sc, AWI_INTSTAT, 0);
755: awi_write_1(sc, AWI_INTSTAT, 0);
756: status |= awi_read_1(sc, AWI_INTSTAT2) << 8;
757: awi_write_1(sc, AWI_INTSTAT2, 0);
758: DELAY(10);
759: awi_intr_unlock(sc);
760: if (!sc->sc_cmd_inprog)
761: status &= ~AWI_INT_CMD; /* make sure */
762: if (status == 0)
763: break;
764: handled = 1;
765: if (status & AWI_INT_RX)
766: awi_rxint(sc);
767: if (status & AWI_INT_TX)
768: awi_txint(sc);
769: if (status & AWI_INT_CMD)
770: awi_cmd_done(sc);
771: if (status & AWI_INT_SCAN_CMPLT) {
772: if (sc->sc_status == AWI_ST_SCAN &&
773: sc->sc_mgt_timer > 0)
774: (void)awi_next_scan(sc);
775: }
776: }
777: sc->sc_cansleep = ocansleep;
778: am79c930_gcr_clearbits(&sc->sc_chip, AM79C930_GCR_DISPWDN);
779: awi_write_1(sc, AWI_DIS_PWRDN, 0);
780: return handled;
781: }
782:
783: int
784: awi_init(sc)
785: struct awi_softc *sc;
786: {
787: int error, ostatus;
788: int n;
789: struct ifnet *ifp = sc->sc_ifp;
790: #ifdef __FreeBSD__
791: struct ifmultiaddr *ifma;
792: #else
793: struct ether_multi *enm;
794: struct ether_multistep step;
795: #endif
796:
797: /* reinitialize muticast filter */
798: n = 0;
799: ifp->if_flags |= IFF_ALLMULTI;
800: sc->sc_mib_local.Accept_All_Multicast_Dis = 0;
801: if (ifp->if_flags & IFF_PROMISC) {
802: sc->sc_mib_mac.aPromiscuous_Enable = 1;
803: goto set_mib;
804: }
805: sc->sc_mib_mac.aPromiscuous_Enable = 0;
806: #ifdef __FreeBSD__
807: if (ifp->if_amcount != 0)
808: goto set_mib;
809: for (ifma = LIST_FIRST(&ifp->if_multiaddrs); ifma != NULL;
810: ifma = LIST_NEXT(ifma, ifma_link)) {
811: if (ifma->ifma_addr->sa_family != AF_LINK)
812: continue;
813: if (n == AWI_GROUP_ADDR_SIZE)
814: goto set_mib;
815: memcpy(sc->sc_mib_addr.aGroup_Addresses[n],
816: LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
817: ETHER_ADDR_LEN);
818: n++;
819: }
820: #else
821: ETHER_FIRST_MULTI(step, &sc->sc_arpcom, enm);
822: while (enm != NULL) {
823: if (n == AWI_GROUP_ADDR_SIZE ||
824: memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)
825: != 0)
826: goto set_mib;
827: memcpy(sc->sc_mib_addr.aGroup_Addresses[n], enm->enm_addrlo,
828: ETHER_ADDR_LEN);
829: n++;
830: ETHER_NEXT_MULTI(step, enm);
831: }
832: #endif
833: for (; n < AWI_GROUP_ADDR_SIZE; n++)
834: memset(sc->sc_mib_addr.aGroup_Addresses[n], 0, ETHER_ADDR_LEN);
835: ifp->if_flags &= ~IFF_ALLMULTI;
836: sc->sc_mib_local.Accept_All_Multicast_Dis = 1;
837:
838: set_mib:
839: #ifdef notdef /* allow non-encrypted frame for receiving. */
840: sc->sc_mib_mgt.Wep_Required = sc->sc_wep_algo != NULL ? 1 : 0;
841: #endif
842: if (!sc->sc_enabled) {
843: sc->sc_enabled = 1;
844: if (sc->sc_enable)
845: (*sc->sc_enable)(sc);
846: sc->sc_status = AWI_ST_INIT;
847: error = awi_init_hw(sc);
848: if (error)
849: return error;
850: }
851: ostatus = sc->sc_status;
852: sc->sc_status = AWI_ST_INIT;
853: if ((error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_LOCAL)) != 0 ||
854: (error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_ADDR)) != 0 ||
855: (error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_MAC)) != 0 ||
856: (error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_MGT)) != 0 ||
857: (error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_PHY)) != 0) {
858: awi_stop(sc);
859: return error;
860: }
861: if (ifp->if_flags & IFF_RUNNING)
862: sc->sc_status = AWI_ST_RUNNING;
863: else {
864: if (ostatus == AWI_ST_INIT) {
865: error = awi_init_txrx(sc);
866: if (error)
867: return error;
868: }
869: error = awi_start_scan(sc);
870: }
871: return error;
872: }
873:
874: void
875: awi_stop(sc)
876: struct awi_softc *sc;
877: {
878: struct ifnet *ifp = sc->sc_ifp;
879: struct awi_bss *bp;
880: struct mbuf *m;
881:
882: sc->sc_status = AWI_ST_INIT;
883: if (!sc->sc_invalid) {
884: (void)awi_cmd_wait(sc);
885: if (sc->sc_mib_local.Network_Mode &&
886: sc->sc_status > AWI_ST_AUTH)
887: awi_send_deauth(sc);
888: awi_stop_txrx(sc);
889: }
890: ifp->if_flags &= ~(IFF_RUNNING|IFF_OACTIVE);
891: ifp->if_timer = 0;
892: sc->sc_tx_timer = sc->sc_rx_timer = sc->sc_mgt_timer = 0;
893: for (;;) {
894: IF_DEQUEUE(&sc->sc_mgtq, m);
895: if (m == NULL)
896: break;
897: m_freem(m);
898: }
899: IFQ_PURGE(&ifp->if_snd);
900: while ((bp = TAILQ_FIRST(&sc->sc_scan)) != NULL) {
901: TAILQ_REMOVE(&sc->sc_scan, bp, list);
902: free(bp, M_DEVBUF);
903: }
904: }
905:
906: static void
907: awi_watchdog(ifp)
908: struct ifnet *ifp;
909: {
910: struct awi_softc *sc = ifp->if_softc;
911: int ocansleep;
912:
913: if (sc->sc_invalid) {
914: ifp->if_timer = 0;
915: return;
916: }
917:
918: ocansleep = sc->sc_cansleep;
919: sc->sc_cansleep = 0;
920: if (sc->sc_tx_timer && --sc->sc_tx_timer == 0) {
921: printf("%s: transmit timeout\n", sc->sc_dev.dv_xname);
922: awi_txint(sc);
923: }
924: if (sc->sc_rx_timer && --sc->sc_rx_timer == 0) {
925: if (ifp->if_flags & IFF_DEBUG) {
926: printf("%s: no recent beacons from %s; rescanning\n",
927: sc->sc_dev.dv_xname,
928: ether_sprintf(sc->sc_bss.bssid));
929: }
930: ifp->if_flags &= ~IFF_RUNNING;
931: awi_start_scan(sc);
932: }
933: if (sc->sc_mgt_timer && --sc->sc_mgt_timer == 0) {
934: switch (sc->sc_status) {
935: case AWI_ST_SCAN:
936: awi_stop_scan(sc);
937: break;
938: case AWI_ST_AUTH:
939: case AWI_ST_ASSOC:
940: /* restart scan */
941: awi_start_scan(sc);
942: break;
943: default:
944: break;
945: }
946: }
947:
948: if (sc->sc_tx_timer == 0 && sc->sc_rx_timer == 0 &&
949: sc->sc_mgt_timer == 0)
950: ifp->if_timer = 0;
951: else
952: ifp->if_timer = 1;
953: sc->sc_cansleep = ocansleep;
954: }
955:
956: static void
957: awi_start(ifp)
958: struct ifnet *ifp;
959: {
960: struct awi_softc *sc = ifp->if_softc;
961: struct mbuf *m0, *m;
962: u_int32_t txd, frame, ntxd;
963: u_int8_t rate;
964: int len, sent = 0;
965:
966: for (;;) {
967: txd = sc->sc_txnext;
968: IF_DEQUEUE(&sc->sc_mgtq, m0);
969: if (m0 != NULL) {
970: if (awi_next_txd(sc, m0->m_pkthdr.len, &frame, &ntxd)) {
971: IF_PREPEND(&sc->sc_mgtq, m0);
972: ifp->if_flags |= IFF_OACTIVE;
973: break;
974: }
975: } else {
976: if (!(ifp->if_flags & IFF_RUNNING))
977: break;
978: IFQ_POLL(&ifp->if_snd, m0);
979: if (m0 == NULL)
980: break;
981: len = m0->m_pkthdr.len + sizeof(struct ieee80211_frame);
982: if (sc->sc_format_llc)
983: len += sizeof(struct llc) -
984: sizeof(struct ether_header);
985: if (sc->sc_wep_algo != NULL)
986: len += IEEE80211_WEP_IVLEN +
987: IEEE80211_WEP_KIDLEN + IEEE80211_WEP_CRCLEN;
988: if (awi_next_txd(sc, len, &frame, &ntxd)) {
989: ifp->if_flags |= IFF_OACTIVE;
990: break;
991: }
992: IFQ_DEQUEUE(&ifp->if_snd, m0);
993: AWI_BPF_MTAP(sc, m0, AWI_BPF_NORM, BPF_DIRECTION_OUT);
994: m0 = awi_fix_txhdr(sc, m0);
995: if (sc->sc_wep_algo != NULL && m0 != NULL)
996: m0 = awi_wep_encrypt(sc, m0, 1);
997: if (m0 == NULL) {
998: ifp->if_oerrors++;
999: continue;
1000: }
1001: ifp->if_opackets++;
1002: }
1003: #ifdef AWI_DEBUG
1004: if (awi_dump)
1005: awi_dump_pkt(sc, m0, -1);
1006: #endif
1007: AWI_BPF_MTAP(sc, m0, AWI_BPF_RAW, BPF_DIRECTION_OUT);
1008: len = 0;
1009: for (m = m0; m != NULL; m = m->m_next) {
1010: awi_write_bytes(sc, frame + len, mtod(m, u_int8_t *),
1011: m->m_len);
1012: len += m->m_len;
1013: }
1014: m_freem(m0);
1015: rate = sc->sc_tx_rate; /*XXX*/
1016: awi_write_1(sc, ntxd + AWI_TXD_STATE, 0);
1017: awi_write_4(sc, txd + AWI_TXD_START, frame);
1018: awi_write_4(sc, txd + AWI_TXD_NEXT, ntxd);
1019: awi_write_4(sc, txd + AWI_TXD_LENGTH, len);
1020: awi_write_1(sc, txd + AWI_TXD_RATE, rate);
1021: awi_write_4(sc, txd + AWI_TXD_NDA, 0);
1022: awi_write_4(sc, txd + AWI_TXD_NRA, 0);
1023: awi_write_1(sc, txd + AWI_TXD_STATE, AWI_TXD_ST_OWN);
1024: sc->sc_txnext = ntxd;
1025: sent++;
1026: }
1027: if (sent) {
1028: if (sc->sc_tx_timer == 0)
1029: sc->sc_tx_timer = 5;
1030: ifp->if_timer = 1;
1031: #ifdef AWI_DEBUG
1032: if (awi_verbose)
1033: printf("awi_start: sent %d txdone %d txnext %d txbase %d txend %d\n", sent, sc->sc_txdone, sc->sc_txnext, sc->sc_txbase, sc->sc_txend);
1034: #endif
1035: }
1036: }
1037:
1038: static void
1039: awi_txint(sc)
1040: struct awi_softc *sc;
1041: {
1042: struct ifnet *ifp = sc->sc_ifp;
1043: u_int8_t flags;
1044:
1045: while (sc->sc_txdone != sc->sc_txnext) {
1046: flags = awi_read_1(sc, sc->sc_txdone + AWI_TXD_STATE);
1047: if ((flags & AWI_TXD_ST_OWN) || !(flags & AWI_TXD_ST_DONE))
1048: break;
1049: if (flags & AWI_TXD_ST_ERROR)
1050: ifp->if_oerrors++;
1051: sc->sc_txdone = awi_read_4(sc, sc->sc_txdone + AWI_TXD_NEXT) &
1052: 0x7fff;
1053: }
1054: sc->sc_tx_timer = 0;
1055: ifp->if_flags &= ~IFF_OACTIVE;
1056: #ifdef AWI_DEBUG
1057: if (awi_verbose)
1058: printf("awi_txint: txdone %d txnext %d txbase %d txend %d\n",
1059: sc->sc_txdone, sc->sc_txnext, sc->sc_txbase, sc->sc_txend);
1060: #endif
1061: awi_start(ifp);
1062: }
1063:
1064: static struct mbuf *
1065: awi_fix_txhdr(sc, m0)
1066: struct awi_softc *sc;
1067: struct mbuf *m0;
1068: {
1069: struct ether_header eh;
1070: struct ieee80211_frame *wh;
1071: struct llc *llc;
1072:
1073: if (m0->m_len < sizeof(eh)) {
1074: m0 = m_pullup(m0, sizeof(eh));
1075: if (m0 == NULL)
1076: return NULL;
1077: }
1078: memcpy(&eh, mtod(m0, caddr_t), sizeof(eh));
1079: if (sc->sc_format_llc) {
1080: m_adj(m0, sizeof(struct ether_header) - sizeof(struct llc));
1081: llc = mtod(m0, struct llc *);
1082: llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
1083: llc->llc_control = LLC_UI;
1084: llc->llc_snap.org_code[0] = llc->llc_snap.org_code[1] =
1085: llc->llc_snap.org_code[2] = 0;
1086: llc->llc_snap.ether_type = eh.ether_type;
1087: }
1088: M_PREPEND(m0, sizeof(struct ieee80211_frame), M_DONTWAIT);
1089: if (m0 == NULL)
1090: return NULL;
1091: wh = mtod(m0, struct ieee80211_frame *);
1092:
1093: wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA;
1094: LE_WRITE_2(wh->i_dur, 0);
1095: LE_WRITE_2(wh->i_seq, 0);
1096: if (sc->sc_mib_local.Network_Mode) {
1097: wh->i_fc[1] = IEEE80211_FC1_DIR_TODS;
1098: memcpy(wh->i_addr1, sc->sc_bss.bssid, ETHER_ADDR_LEN);
1099: memcpy(wh->i_addr2, eh.ether_shost, ETHER_ADDR_LEN);
1100: memcpy(wh->i_addr3, eh.ether_dhost, ETHER_ADDR_LEN);
1101: } else {
1102: wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
1103: memcpy(wh->i_addr1, eh.ether_dhost, ETHER_ADDR_LEN);
1104: memcpy(wh->i_addr2, eh.ether_shost, ETHER_ADDR_LEN);
1105: memcpy(wh->i_addr3, sc->sc_bss.bssid, ETHER_ADDR_LEN);
1106: }
1107: return m0;
1108: }
1109:
1110: static struct mbuf *
1111: awi_fix_rxhdr(sc, m0)
1112: struct awi_softc *sc;
1113: struct mbuf *m0;
1114: {
1115: struct ieee80211_frame wh;
1116: struct ether_header *eh;
1117: struct llc *llc;
1118:
1119: if (m0->m_len < sizeof(wh)) {
1120: m_freem(m0);
1121: return NULL;
1122: }
1123: llc = (struct llc *)(mtod(m0, caddr_t) + sizeof(wh));
1124: if (llc->llc_dsap == LLC_SNAP_LSAP &&
1125: llc->llc_ssap == LLC_SNAP_LSAP &&
1126: llc->llc_control == LLC_UI &&
1127: llc->llc_snap.org_code[0] == 0 &&
1128: llc->llc_snap.org_code[1] == 0 &&
1129: llc->llc_snap.org_code[2] == 0) {
1130: memcpy(&wh, mtod(m0, caddr_t), sizeof(wh));
1131: m_adj(m0, sizeof(wh) + sizeof(*llc) - sizeof(*eh));
1132: eh = mtod(m0, struct ether_header *);
1133: switch (wh.i_fc[1] & IEEE80211_FC1_DIR_MASK) {
1134: case IEEE80211_FC1_DIR_NODS:
1135: memcpy(eh->ether_dhost, wh.i_addr1, ETHER_ADDR_LEN);
1136: memcpy(eh->ether_shost, wh.i_addr2, ETHER_ADDR_LEN);
1137: break;
1138: case IEEE80211_FC1_DIR_TODS:
1139: memcpy(eh->ether_dhost, wh.i_addr3, ETHER_ADDR_LEN);
1140: memcpy(eh->ether_shost, wh.i_addr2, ETHER_ADDR_LEN);
1141: break;
1142: case IEEE80211_FC1_DIR_FROMDS:
1143: memcpy(eh->ether_dhost, wh.i_addr1, ETHER_ADDR_LEN);
1144: memcpy(eh->ether_shost, wh.i_addr3, ETHER_ADDR_LEN);
1145: break;
1146: case IEEE80211_FC1_DIR_DSTODS:
1147: m_freem(m0);
1148: return NULL;
1149: }
1150: } else {
1151: /* assuming ethernet encapsulation, just strip 802.11 header */
1152: m_adj(m0, sizeof(wh));
1153: }
1154: if (ALIGN(mtod(m0, caddr_t) + sizeof(struct ether_header)) !=
1155: (u_int)(mtod(m0, caddr_t) + sizeof(struct ether_header))) {
1156: /* XXX: we lose to estimate the type of encapsulation */
1157: struct mbuf *n, *n0, **np;
1158: caddr_t newdata;
1159: int off, oldmlen;
1160:
1161: n0 = NULL;
1162: np = &n0;
1163: off = 0;
1164: oldmlen = m0->m_pkthdr.len;
1165: while (oldmlen > off) {
1166: if (n0 == NULL) {
1167: MGETHDR(n, M_DONTWAIT, MT_DATA);
1168: if (n == NULL) {
1169: m_freem(m0);
1170: return NULL;
1171: }
1172: M_MOVE_PKTHDR(n, m0);
1173: n->m_len = MHLEN;
1174: } else {
1175: MGET(n, M_DONTWAIT, MT_DATA);
1176: if (n == NULL) {
1177: m_freem(m0);
1178: m_freem(n0);
1179: return NULL;
1180: }
1181: n->m_len = MLEN;
1182: }
1183: if (oldmlen - off >= MINCLSIZE) {
1184: MCLGET(n, M_DONTWAIT);
1185: if (n->m_flags & M_EXT)
1186: n->m_len = n->m_ext.ext_size;
1187: }
1188: if (n0 == NULL) {
1189: newdata = (caddr_t)
1190: ALIGN(n->m_data
1191: + sizeof(struct ether_header))
1192: - sizeof(struct ether_header);
1193: n->m_len -= newdata - n->m_data;
1194: n->m_data = newdata;
1195: }
1196: if (n->m_len > oldmlen - off)
1197: n->m_len = oldmlen - off;
1198: m_copydata(m0, off, n->m_len, mtod(n, caddr_t));
1199: off += n->m_len;
1200: *np = n;
1201: np = &n->m_next;
1202: }
1203: m_freem(m0);
1204: m0 = n0;
1205: }
1206: return m0;
1207: }
1208:
1209: static void
1210: awi_input(sc, m, rxts, rssi)
1211: struct awi_softc *sc;
1212: struct mbuf *m;
1213: u_int32_t rxts;
1214: u_int8_t rssi;
1215: {
1216: struct ifnet *ifp = sc->sc_ifp;
1217: struct ieee80211_frame *wh;
1218:
1219: /* trim CRC here for WEP can find its own CRC at the end of packet. */
1220: m_adj(m, -ETHER_CRC_LEN);
1221: AWI_BPF_MTAP(sc, m, AWI_BPF_RAW, BPF_DIRECTION_IN);
1222: wh = mtod(m, struct ieee80211_frame *);
1223: if ((wh->i_fc[0] & IEEE80211_FC0_VERSION_MASK) !=
1224: IEEE80211_FC0_VERSION_0) {
1225: printf("%s; receive packet with wrong version: %x\n",
1226: sc->sc_dev.dv_xname, wh->i_fc[0]);
1227: m_freem(m);
1228: ifp->if_ierrors++;
1229: return;
1230: }
1231: if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
1232: m = awi_wep_encrypt(sc, m, 0);
1233: if (m == NULL) {
1234: ifp->if_ierrors++;
1235: return;
1236: }
1237: wh = mtod(m, struct ieee80211_frame *);
1238: }
1239: #ifdef AWI_DEBUG
1240: if (awi_dump)
1241: awi_dump_pkt(sc, m, rssi);
1242: #endif
1243:
1244: if ((sc->sc_mib_local.Network_Mode || !sc->sc_no_bssid) &&
1245: sc->sc_status == AWI_ST_RUNNING) {
1246: if (memcmp(wh->i_addr2, sc->sc_bss.bssid, ETHER_ADDR_LEN) == 0) {
1247: sc->sc_rx_timer = 10;
1248: sc->sc_bss.rssi = rssi;
1249: }
1250: }
1251: switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) {
1252: case IEEE80211_FC0_TYPE_DATA:
1253: if (sc->sc_mib_local.Network_Mode) {
1254: if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) !=
1255: IEEE80211_FC1_DIR_FROMDS) {
1256: m_freem(m);
1257: return;
1258: }
1259: } else {
1260: if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) !=
1261: IEEE80211_FC1_DIR_NODS) {
1262: m_freem(m);
1263: return;
1264: }
1265: }
1266: m = awi_fix_rxhdr(sc, m);
1267: if (m == NULL) {
1268: ifp->if_ierrors++;
1269: break;
1270: }
1271: ifp->if_ipackets++;
1272: #if !(defined(__FreeBSD__) && __FreeBSD__ >= 4)
1273: AWI_BPF_MTAP(sc, m, AWI_BPF_NORM, BPF_DIRECTION_IN);
1274: #endif
1275: #ifdef __NetBSD__
1276: (*ifp->if_input)(ifp, m);
1277: #else
1278: ether_input_mbuf(ifp, m);
1279: #endif
1280: break;
1281: case IEEE80211_FC0_TYPE_MGT:
1282: if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) !=
1283: IEEE80211_FC1_DIR_NODS) {
1284: m_freem(m);
1285: return;
1286: }
1287: switch (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) {
1288: case IEEE80211_FC0_SUBTYPE_PROBE_RESP:
1289: case IEEE80211_FC0_SUBTYPE_BEACON:
1290: awi_recv_beacon(sc, m, rxts, rssi);
1291: break;
1292: case IEEE80211_FC0_SUBTYPE_AUTH:
1293: awi_recv_auth(sc, m);
1294: break;
1295: case IEEE80211_FC0_SUBTYPE_ASSOC_RESP:
1296: case IEEE80211_FC0_SUBTYPE_REASSOC_RESP:
1297: awi_recv_asresp(sc, m);
1298: break;
1299: case IEEE80211_FC0_SUBTYPE_DEAUTH:
1300: if (sc->sc_mib_local.Network_Mode)
1301: awi_send_auth(sc, 1);
1302: break;
1303: case IEEE80211_FC0_SUBTYPE_DISASSOC:
1304: if (sc->sc_mib_local.Network_Mode)
1305: awi_send_asreq(sc, 1);
1306: break;
1307: }
1308: m_freem(m);
1309: break;
1310: case IEEE80211_FC0_TYPE_CTL:
1311: default:
1312: /* should not come here */
1313: m_freem(m);
1314: break;
1315: }
1316: }
1317:
1318: static void
1319: awi_rxint(sc)
1320: struct awi_softc *sc;
1321: {
1322: u_int8_t state, rate, rssi;
1323: u_int16_t len;
1324: u_int32_t frame, next, rxts, rxoff;
1325: struct mbuf *m;
1326:
1327: rxoff = sc->sc_rxdoff;
1328: for (;;) {
1329: state = awi_read_1(sc, rxoff + AWI_RXD_HOST_DESC_STATE);
1330: if (state & AWI_RXD_ST_OWN)
1331: break;
1332: if (!(state & AWI_RXD_ST_CONSUMED)) {
1333: if (state & AWI_RXD_ST_RXERROR)
1334: sc->sc_ifp->if_ierrors++;
1335: else {
1336: len = awi_read_2(sc, rxoff + AWI_RXD_LEN);
1337: rate = awi_read_1(sc, rxoff + AWI_RXD_RATE);
1338: rssi = awi_read_1(sc, rxoff + AWI_RXD_RSSI);
1339: frame = awi_read_4(sc, rxoff + AWI_RXD_START_FRAME) & 0x7fff;
1340: rxts = awi_read_4(sc, rxoff + AWI_RXD_LOCALTIME);
1341: m = awi_devget(sc, frame, len);
1342: if (state & AWI_RXD_ST_LF)
1343: awi_input(sc, m, rxts, rssi);
1344: else
1345: sc->sc_rxpend = m;
1346: }
1347: state |= AWI_RXD_ST_CONSUMED;
1348: awi_write_1(sc, rxoff + AWI_RXD_HOST_DESC_STATE, state);
1349: }
1350: next = awi_read_4(sc, rxoff + AWI_RXD_NEXT);
1351: if (next & AWI_RXD_NEXT_LAST)
1352: break;
1353: /* make sure the next pointer is correct */
1354: if (next != awi_read_4(sc, rxoff + AWI_RXD_NEXT))
1355: break;
1356: state |= AWI_RXD_ST_OWN;
1357: awi_write_1(sc, rxoff + AWI_RXD_HOST_DESC_STATE, state);
1358: rxoff = next & 0x7fff;
1359: }
1360: sc->sc_rxdoff = rxoff;
1361: }
1362:
1363: static struct mbuf *
1364: awi_devget(sc, off, len)
1365: struct awi_softc *sc;
1366: u_int32_t off;
1367: u_int16_t len;
1368: {
1369: struct mbuf *m;
1370: struct mbuf *top, **mp;
1371: u_int tlen;
1372:
1373: top = sc->sc_rxpend;
1374: mp = ⊤
1375: if (top != NULL) {
1376: sc->sc_rxpend = NULL;
1377: top->m_pkthdr.len += len;
1378: m = top;
1379: while (*mp != NULL) {
1380: m = *mp;
1381: mp = &m->m_next;
1382: }
1383: if (m->m_flags & M_EXT)
1384: tlen = m->m_ext.ext_size;
1385: else if (m->m_flags & M_PKTHDR)
1386: tlen = MHLEN;
1387: else
1388: tlen = MLEN;
1389: tlen -= m->m_len;
1390: if (tlen > len)
1391: tlen = len;
1392: awi_read_bytes(sc, off, mtod(m, u_int8_t *) + m->m_len, tlen);
1393: off += tlen;
1394: len -= tlen;
1395: }
1396:
1397: while (len > 0) {
1398: if (top == NULL) {
1399: MGETHDR(m, M_DONTWAIT, MT_DATA);
1400: if (m == NULL)
1401: return NULL;
1402: m->m_pkthdr.rcvif = sc->sc_ifp;
1403: m->m_pkthdr.len = len;
1404: m->m_len = MHLEN;
1405: } else {
1406: MGET(m, M_DONTWAIT, MT_DATA);
1407: if (m == NULL) {
1408: m_freem(top);
1409: return NULL;
1410: }
1411: m->m_len = MLEN;
1412: }
1413: if (len >= MINCLSIZE) {
1414: MCLGET(m, M_DONTWAIT);
1415: if (m->m_flags & M_EXT)
1416: m->m_len = m->m_ext.ext_size;
1417: }
1418: if (top == NULL) {
1419: int hdrlen = sizeof(struct ieee80211_frame) +
1420: (sc->sc_format_llc ? sizeof(struct llc) :
1421: sizeof(struct ether_header));
1422: caddr_t newdata = (caddr_t)
1423: ALIGN(m->m_data + hdrlen) - hdrlen;
1424: m->m_len -= newdata - m->m_data;
1425: m->m_data = newdata;
1426: }
1427: if (m->m_len > len)
1428: m->m_len = len;
1429: awi_read_bytes(sc, off, mtod(m, u_int8_t *), m->m_len);
1430: off += m->m_len;
1431: len -= m->m_len;
1432: *mp = m;
1433: mp = &m->m_next;
1434: }
1435: return top;
1436: }
1437:
1438: /*
1439: * Initialize hardware and start firmware to accept commands.
1440: * Called everytime after power on firmware.
1441: */
1442:
1443: static int
1444: awi_init_hw(sc)
1445: struct awi_softc *sc;
1446: {
1447: u_int8_t status;
1448: u_int16_t intmask;
1449: int i, error;
1450:
1451: sc->sc_enab_intr = 0;
1452: sc->sc_invalid = 0; /* XXX: really? */
1453: awi_drvstate(sc, AWI_DRV_RESET);
1454:
1455: /* reset firmware */
1456: am79c930_gcr_setbits(&sc->sc_chip, AM79C930_GCR_CORESET);
1457: DELAY(100);
1458: awi_write_1(sc, AWI_SELFTEST, 0);
1459: awi_write_1(sc, AWI_CMD, 0);
1460: awi_write_1(sc, AWI_BANNER, 0);
1461: am79c930_gcr_clearbits(&sc->sc_chip, AM79C930_GCR_CORESET);
1462: DELAY(100);
1463:
1464: /* wait for selftest completion */
1465: for (i = 0; ; i++) {
1466: if (i >= AWI_SELFTEST_TIMEOUT*hz/1000) {
1467: printf("%s: failed to complete selftest (timeout)\n",
1468: sc->sc_dev.dv_xname);
1469: return ENXIO;
1470: }
1471: status = awi_read_1(sc, AWI_SELFTEST);
1472: if ((status & 0xf0) == 0xf0)
1473: break;
1474: if (sc->sc_cansleep) {
1475: sc->sc_sleep_cnt++;
1476: (void)tsleep(sc, PWAIT, "awitst", 1);
1477: sc->sc_sleep_cnt--;
1478: } else {
1479: DELAY(1000*1000/hz);
1480: }
1481: }
1482: if (status != AWI_SELFTEST_PASSED) {
1483: printf("%s: failed to complete selftest (code %x)\n",
1484: sc->sc_dev.dv_xname, status);
1485: return ENXIO;
1486: }
1487:
1488: /* check banner to confirm firmware write it */
1489: awi_read_bytes(sc, AWI_BANNER, sc->sc_banner, AWI_BANNER_LEN);
1490: if (memcmp(sc->sc_banner, "PCnetMobile:", 12) != 0) {
1491: printf("%s: failed to complete selftest (bad banner)\n",
1492: sc->sc_dev.dv_xname);
1493: for (i = 0; i < AWI_BANNER_LEN; i++)
1494: printf("%s%02x", i ? ":" : "\t", sc->sc_banner[i]);
1495: printf("\n");
1496: return ENXIO;
1497: }
1498:
1499: /* initializing interrupt */
1500: sc->sc_enab_intr = 1;
1501: error = awi_intr_lock(sc);
1502: if (error)
1503: return error;
1504: intmask = AWI_INT_GROGGY | AWI_INT_SCAN_CMPLT |
1505: AWI_INT_TX | AWI_INT_RX | AWI_INT_CMD;
1506: awi_write_1(sc, AWI_INTMASK, ~intmask & 0xff);
1507: awi_write_1(sc, AWI_INTMASK2, 0);
1508: awi_write_1(sc, AWI_INTSTAT, 0);
1509: awi_write_1(sc, AWI_INTSTAT2, 0);
1510: awi_intr_unlock(sc);
1511: am79c930_gcr_setbits(&sc->sc_chip, AM79C930_GCR_ENECINT);
1512:
1513: /* issueing interface test command */
1514: error = awi_cmd(sc, AWI_CMD_NOP);
1515: if (error) {
1516: printf("%s: failed to complete selftest", sc->sc_dev.dv_xname);
1517: if (error == ENXIO)
1518: printf(" (no hardware)\n");
1519: else if (error != EWOULDBLOCK)
1520: printf(" (error %d)\n", error);
1521: else if (sc->sc_cansleep)
1522: printf(" (lost interrupt)\n");
1523: else
1524: printf(" (command timeout)\n");
1525: }
1526: return error;
1527: }
1528:
1529: /*
1530: * Extract the factory default MIB value from firmware and assign the driver
1531: * default value.
1532: * Called once at attaching the interface.
1533: */
1534:
1535: static int
1536: awi_init_mibs(sc)
1537: struct awi_softc *sc;
1538: {
1539: int i, error;
1540: u_int8_t *rate;
1541:
1542: if ((error = awi_mib(sc, AWI_CMD_GET_MIB, AWI_MIB_LOCAL)) != 0 ||
1543: (error = awi_mib(sc, AWI_CMD_GET_MIB, AWI_MIB_ADDR)) != 0 ||
1544: (error = awi_mib(sc, AWI_CMD_GET_MIB, AWI_MIB_MAC)) != 0 ||
1545: (error = awi_mib(sc, AWI_CMD_GET_MIB, AWI_MIB_MGT)) != 0 ||
1546: (error = awi_mib(sc, AWI_CMD_GET_MIB, AWI_MIB_PHY)) != 0) {
1547: printf("%s: failed to get default mib value (error %d)\n",
1548: sc->sc_dev.dv_xname, error);
1549: return error;
1550: }
1551:
1552: rate = sc->sc_mib_phy.aSuprt_Data_Rates;
1553: sc->sc_tx_rate = AWI_RATE_1MBIT;
1554: for (i = 0; i < rate[1]; i++) {
1555: if (AWI_80211_RATE(rate[2 + i]) > sc->sc_tx_rate)
1556: sc->sc_tx_rate = AWI_80211_RATE(rate[2 + i]);
1557: }
1558: awi_init_region(sc);
1559: memset(&sc->sc_mib_mac.aDesired_ESS_ID, 0, AWI_ESS_ID_SIZE);
1560: sc->sc_mib_mac.aDesired_ESS_ID[0] = IEEE80211_ELEMID_SSID;
1561: sc->sc_mib_local.Fragmentation_Dis = 1;
1562: sc->sc_mib_local.Accept_All_Multicast_Dis = 1;
1563: sc->sc_mib_local.Power_Saving_Mode_Dis = 1;
1564:
1565: /* allocate buffers */
1566: sc->sc_txbase = AWI_BUFFERS;
1567: sc->sc_txend = sc->sc_txbase +
1568: (AWI_TXD_SIZE + sizeof(struct ieee80211_frame) +
1569: sizeof(struct ether_header) + ETHERMTU) * AWI_NTXBUFS;
1570: LE_WRITE_4(&sc->sc_mib_local.Tx_Buffer_Offset, sc->sc_txbase);
1571: LE_WRITE_4(&sc->sc_mib_local.Tx_Buffer_Size,
1572: sc->sc_txend - sc->sc_txbase);
1573: LE_WRITE_4(&sc->sc_mib_local.Rx_Buffer_Offset, sc->sc_txend);
1574: LE_WRITE_4(&sc->sc_mib_local.Rx_Buffer_Size,
1575: AWI_BUFFERS_END - sc->sc_txend);
1576: sc->sc_mib_local.Network_Mode = 1;
1577: sc->sc_mib_local.Acting_as_AP = 0;
1578: return 0;
1579: }
1580:
1581: /*
1582: * Start transmitter and receiver of firmware
1583: * Called after awi_init_hw() to start operation.
1584: */
1585:
1586: static int
1587: awi_init_txrx(sc)
1588: struct awi_softc *sc;
1589: {
1590: int error;
1591:
1592: /* start transmitter */
1593: sc->sc_txdone = sc->sc_txnext = sc->sc_txbase;
1594: awi_write_4(sc, sc->sc_txbase + AWI_TXD_START, 0);
1595: awi_write_4(sc, sc->sc_txbase + AWI_TXD_NEXT, 0);
1596: awi_write_4(sc, sc->sc_txbase + AWI_TXD_LENGTH, 0);
1597: awi_write_1(sc, sc->sc_txbase + AWI_TXD_RATE, 0);
1598: awi_write_4(sc, sc->sc_txbase + AWI_TXD_NDA, 0);
1599: awi_write_4(sc, sc->sc_txbase + AWI_TXD_NRA, 0);
1600: awi_write_1(sc, sc->sc_txbase + AWI_TXD_STATE, 0);
1601: awi_write_4(sc, AWI_CMD_PARAMS+AWI_CA_TX_DATA, sc->sc_txbase);
1602: awi_write_4(sc, AWI_CMD_PARAMS+AWI_CA_TX_MGT, 0);
1603: awi_write_4(sc, AWI_CMD_PARAMS+AWI_CA_TX_BCAST, 0);
1604: awi_write_4(sc, AWI_CMD_PARAMS+AWI_CA_TX_PS, 0);
1605: awi_write_4(sc, AWI_CMD_PARAMS+AWI_CA_TX_CF, 0);
1606: error = awi_cmd(sc, AWI_CMD_INIT_TX);
1607: if (error)
1608: return error;
1609:
1610: /* start receiver */
1611: if (sc->sc_rxpend) {
1612: m_freem(sc->sc_rxpend);
1613: sc->sc_rxpend = NULL;
1614: }
1615: error = awi_cmd(sc, AWI_CMD_INIT_RX);
1616: if (error)
1617: return error;
1618: sc->sc_rxdoff = awi_read_4(sc, AWI_CMD_PARAMS+AWI_CA_IRX_DATA_DESC);
1619: sc->sc_rxmoff = awi_read_4(sc, AWI_CMD_PARAMS+AWI_CA_IRX_PS_DESC);
1620: return 0;
1621: }
1622:
1623: static void
1624: awi_stop_txrx(sc)
1625: struct awi_softc *sc;
1626: {
1627:
1628: if (sc->sc_cmd_inprog)
1629: (void)awi_cmd_wait(sc);
1630: (void)awi_cmd(sc, AWI_CMD_KILL_RX);
1631: (void)awi_cmd_wait(sc);
1632: sc->sc_cmd_inprog = AWI_CMD_FLUSH_TX;
1633: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_FTX_DATA, 1);
1634: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_FTX_MGT, 0);
1635: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_FTX_BCAST, 0);
1636: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_FTX_PS, 0);
1637: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_FTX_CF, 0);
1638: (void)awi_cmd(sc, AWI_CMD_FLUSH_TX);
1639: (void)awi_cmd_wait(sc);
1640: }
1641:
1642: int
1643: awi_init_region(sc)
1644: struct awi_softc *sc;
1645: {
1646:
1647: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH) {
1648: switch (sc->sc_mib_phy.aCurrent_Reg_Domain) {
1649: case AWI_REG_DOMAIN_US:
1650: case AWI_REG_DOMAIN_CA:
1651: case AWI_REG_DOMAIN_EU:
1652: sc->sc_scan_min = 0;
1653: sc->sc_scan_max = 77;
1654: break;
1655: case AWI_REG_DOMAIN_ES:
1656: sc->sc_scan_min = 0;
1657: sc->sc_scan_max = 26;
1658: break;
1659: case AWI_REG_DOMAIN_FR:
1660: sc->sc_scan_min = 0;
1661: sc->sc_scan_max = 32;
1662: break;
1663: case AWI_REG_DOMAIN_JP:
1664: sc->sc_scan_min = 6;
1665: sc->sc_scan_max = 17;
1666: break;
1667: default:
1668: return EINVAL;
1669: }
1670: sc->sc_scan_set = sc->sc_scan_cur % 3 + 1;
1671: } else {
1672: switch (sc->sc_mib_phy.aCurrent_Reg_Domain) {
1673: case AWI_REG_DOMAIN_US:
1674: case AWI_REG_DOMAIN_CA:
1675: sc->sc_scan_min = 1;
1676: sc->sc_scan_max = 11;
1677: sc->sc_scan_cur = 3;
1678: break;
1679: case AWI_REG_DOMAIN_EU:
1680: sc->sc_scan_min = 1;
1681: sc->sc_scan_max = 13;
1682: sc->sc_scan_cur = 3;
1683: break;
1684: case AWI_REG_DOMAIN_ES:
1685: sc->sc_scan_min = 10;
1686: sc->sc_scan_max = 11;
1687: sc->sc_scan_cur = 10;
1688: break;
1689: case AWI_REG_DOMAIN_FR:
1690: sc->sc_scan_min = 10;
1691: sc->sc_scan_max = 13;
1692: sc->sc_scan_cur = 10;
1693: break;
1694: case AWI_REG_DOMAIN_JP:
1695: sc->sc_scan_min = 14;
1696: sc->sc_scan_max = 14;
1697: sc->sc_scan_cur = 14;
1698: break;
1699: default:
1700: return EINVAL;
1701: }
1702: }
1703: sc->sc_ownch = sc->sc_scan_cur;
1704: return 0;
1705: }
1706:
1707: static int
1708: awi_start_scan(sc)
1709: struct awi_softc *sc;
1710: {
1711: int error = 0;
1712: struct awi_bss *bp;
1713:
1714: while ((bp = TAILQ_FIRST(&sc->sc_scan)) != NULL) {
1715: TAILQ_REMOVE(&sc->sc_scan, bp, list);
1716: free(bp, M_DEVBUF);
1717: }
1718: if (!sc->sc_mib_local.Network_Mode && sc->sc_no_bssid) {
1719: memset(&sc->sc_bss, 0, sizeof(sc->sc_bss));
1720: sc->sc_bss.essid[0] = IEEE80211_ELEMID_SSID;
1721: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH) {
1722: sc->sc_bss.chanset = sc->sc_ownch % 3 + 1;
1723: sc->sc_bss.pattern = sc->sc_ownch;
1724: sc->sc_bss.index = 1;
1725: sc->sc_bss.dwell_time = 200; /*XXX*/
1726: } else
1727: sc->sc_bss.chanset = sc->sc_ownch;
1728: sc->sc_status = AWI_ST_SETSS;
1729: error = awi_set_ss(sc);
1730: } else {
1731: if (sc->sc_mib_local.Network_Mode)
1732: awi_drvstate(sc, AWI_DRV_INFSC);
1733: else
1734: awi_drvstate(sc, AWI_DRV_ADHSC);
1735: sc->sc_start_bss = 0;
1736: sc->sc_active_scan = 1;
1737: sc->sc_mgt_timer = AWI_ASCAN_WAIT / 1000;
1738: sc->sc_ifp->if_timer = 1;
1739: sc->sc_status = AWI_ST_SCAN;
1740: error = awi_cmd_scan(sc);
1741: }
1742: return error;
1743: }
1744:
1745: static int
1746: awi_next_scan(sc)
1747: struct awi_softc *sc;
1748: {
1749: int error;
1750:
1751: for (;;) {
1752: /*
1753: * The pattern parameter for FH phy should be incremented
1754: * by 3. But BayStack 650 Access Points apparently always
1755: * assign hop pattern set parameter to 1 for any pattern.
1756: * So we try all combinations of pattern/set parameters.
1757: * Since this causes no error, it may be a bug of
1758: * PCnetMobile firmware.
1759: */
1760: sc->sc_scan_cur++;
1761: if (sc->sc_scan_cur > sc->sc_scan_max) {
1762: sc->sc_scan_cur = sc->sc_scan_min;
1763: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH)
1764: sc->sc_scan_set = sc->sc_scan_set % 3 + 1;
1765: }
1766: error = awi_cmd_scan(sc);
1767: if (error != EINVAL)
1768: break;
1769: }
1770: return error;
1771: }
1772:
1773: static void
1774: awi_stop_scan(sc)
1775: struct awi_softc *sc;
1776: {
1777: struct ifnet *ifp = sc->sc_ifp;
1778: struct awi_bss *bp, *sbp;
1779: int fail;
1780:
1781: bp = TAILQ_FIRST(&sc->sc_scan);
1782: if (bp == NULL) {
1783: notfound:
1784: if (sc->sc_active_scan) {
1785: if (ifp->if_flags & IFF_DEBUG)
1786: printf("%s: entering passive scan mode\n",
1787: sc->sc_dev.dv_xname);
1788: sc->sc_active_scan = 0;
1789: }
1790: sc->sc_mgt_timer = AWI_PSCAN_WAIT / 1000;
1791: ifp->if_timer = 1;
1792: (void)awi_next_scan(sc);
1793: return;
1794: }
1795: sbp = NULL;
1796: if (ifp->if_flags & IFF_DEBUG)
1797: printf("%s:\tmacaddr ch/pat sig flag wep essid\n",
1798: sc->sc_dev.dv_xname);
1799: for (; bp != NULL; bp = TAILQ_NEXT(bp, list)) {
1800: if (bp->fails) {
1801: /*
1802: * The configuration of the access points may change
1803: * during my scan. So we retries to associate with
1804: * it unless there are any suitable AP.
1805: */
1806: if (bp->fails++ < 3)
1807: continue;
1808: bp->fails = 0;
1809: }
1810: fail = 0;
1811: /*
1812: * Since the firmware apparently scans not only the specified
1813: * channel of SCAN command but all available channel within
1814: * the region, we should filter out unnecessary responses here.
1815: */
1816: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH) {
1817: if (bp->pattern < sc->sc_scan_min ||
1818: bp->pattern > sc->sc_scan_max)
1819: fail |= 0x01;
1820: } else {
1821: if (bp->chanset < sc->sc_scan_min ||
1822: bp->chanset > sc->sc_scan_max)
1823: fail |= 0x01;
1824: }
1825: if (sc->sc_mib_local.Network_Mode) {
1826: if (!(bp->capinfo & IEEE80211_CAPINFO_ESS) ||
1827: (bp->capinfo & IEEE80211_CAPINFO_IBSS))
1828: fail |= 0x02;
1829: } else {
1830: if ((bp->capinfo & IEEE80211_CAPINFO_ESS) ||
1831: !(bp->capinfo & IEEE80211_CAPINFO_IBSS))
1832: fail |= 0x02;
1833: }
1834: if (sc->sc_wep_algo == NULL) {
1835: if (bp->capinfo & IEEE80211_CAPINFO_PRIVACY)
1836: fail |= 0x04;
1837: } else {
1838: if (!(bp->capinfo & IEEE80211_CAPINFO_PRIVACY))
1839: fail |= 0x04;
1840: }
1841: if (sc->sc_mib_mac.aDesired_ESS_ID[1] != 0 &&
1842: memcmp(&sc->sc_mib_mac.aDesired_ESS_ID, bp->essid,
1843: sizeof(bp->essid)) != 0)
1844: fail |= 0x08;
1845: if (ifp->if_flags & IFF_DEBUG) {
1846: printf(" %c %s", fail ? '-' : '+',
1847: ether_sprintf(bp->esrc));
1848: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH)
1849: printf(" %2d/%d%c", bp->pattern, bp->chanset,
1850: fail & 0x01 ? '!' : ' ');
1851: else
1852: printf(" %4d%c", bp->chanset,
1853: fail & 0x01 ? '!' : ' ');
1854: printf(" %+4d", bp->rssi);
1855: printf(" %4s%c",
1856: (bp->capinfo & IEEE80211_CAPINFO_ESS) ? "ess" :
1857: (bp->capinfo & IEEE80211_CAPINFO_IBSS) ? "ibss" :
1858: "????",
1859: fail & 0x02 ? '!' : ' ');
1860: printf(" %3s%c ",
1861: (bp->capinfo & IEEE80211_CAPINFO_PRIVACY) ? "wep" :
1862: "no",
1863: fail & 0x04 ? '!' : ' ');
1864: awi_print_essid(bp->essid);
1865: printf("%s\n", fail & 0x08 ? "!" : "");
1866: }
1867: if (!fail) {
1868: if (sbp == NULL || bp->rssi > sbp->rssi)
1869: sbp = bp;
1870: }
1871: }
1872: if (sbp == NULL)
1873: goto notfound;
1874: sc->sc_bss = *sbp;
1875: (void)awi_set_ss(sc);
1876: }
1877:
1878: static void
1879: awi_recv_beacon(sc, m0, rxts, rssi)
1880: struct awi_softc *sc;
1881: struct mbuf *m0;
1882: u_int32_t rxts;
1883: u_int8_t rssi;
1884: {
1885: struct ieee80211_frame *wh;
1886: struct awi_bss *bp;
1887: u_int8_t *frame, *eframe;
1888: u_int8_t *tstamp, *bintval, *capinfo, *ssid, *rates, *parms;
1889:
1890: if (sc->sc_status != AWI_ST_SCAN)
1891: return;
1892: wh = mtod(m0, struct ieee80211_frame *);
1893:
1894: frame = (u_int8_t *)&wh[1];
1895: eframe = mtod(m0, u_int8_t *) + m0->m_len;
1896: /*
1897: * XXX:
1898: * timestamp [8]
1899: * beacon interval [2]
1900: * capability information [2]
1901: * ssid [tlv]
1902: * supported rates [tlv]
1903: * parameter set [tlv]
1904: * ...
1905: */
1906: if (frame + 12 > eframe) {
1907: #ifdef AWI_DEBUG
1908: if (awi_verbose)
1909: printf("awi_recv_beacon: frame too short \n");
1910: #endif
1911: return;
1912: }
1913: tstamp = frame;
1914: frame += 8;
1915: bintval = frame;
1916: frame += 2;
1917: capinfo = frame;
1918: frame += 2;
1919:
1920: ssid = rates = parms = NULL;
1921: while (frame < eframe) {
1922: switch (*frame) {
1923: case IEEE80211_ELEMID_SSID:
1924: ssid = frame;
1925: break;
1926: case IEEE80211_ELEMID_RATES:
1927: rates = frame;
1928: break;
1929: case IEEE80211_ELEMID_FHPARMS:
1930: case IEEE80211_ELEMID_DSPARMS:
1931: parms = frame;
1932: break;
1933: }
1934: frame += frame[1] + 2;
1935: }
1936: if (ssid == NULL || rates == NULL || parms == NULL) {
1937: #ifdef AWI_DEBUG
1938: if (awi_verbose)
1939: printf("awi_recv_beacon: ssid=%p, rates=%p, parms=%p\n",
1940: ssid, rates, parms);
1941: #endif
1942: return;
1943: }
1944: if (ssid[1] > IEEE80211_NWID_LEN) {
1945: #ifdef AWI_DEBUG
1946: if (awi_verbose)
1947: printf("awi_recv_beacon: bad ssid len: %d from %s\n",
1948: ssid[1], ether_sprintf(wh->i_addr2));
1949: #endif
1950: return;
1951: }
1952:
1953: for (bp = TAILQ_FIRST(&sc->sc_scan); bp != NULL;
1954: bp = TAILQ_NEXT(bp, list)) {
1955: if (memcmp(bp->esrc, wh->i_addr2, ETHER_ADDR_LEN) == 0 &&
1956: memcmp(bp->bssid, wh->i_addr3, ETHER_ADDR_LEN) == 0)
1957: break;
1958: }
1959: if (bp == NULL) {
1960: bp = malloc(sizeof(struct awi_bss), M_DEVBUF, M_NOWAIT);
1961: if (bp == NULL)
1962: return;
1963: TAILQ_INSERT_TAIL(&sc->sc_scan, bp, list);
1964: memcpy(bp->esrc, wh->i_addr2, ETHER_ADDR_LEN);
1965: memcpy(bp->bssid, wh->i_addr3, ETHER_ADDR_LEN);
1966: memset(bp->essid, 0, sizeof(bp->essid));
1967: memcpy(bp->essid, ssid, 2 + ssid[1]);
1968: }
1969: bp->rssi = rssi;
1970: bp->rxtime = rxts;
1971: memcpy(bp->timestamp, tstamp, sizeof(bp->timestamp));
1972: bp->interval = LE_READ_2(bintval);
1973: bp->capinfo = LE_READ_2(capinfo);
1974: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH) {
1975: bp->chanset = parms[4];
1976: bp->pattern = parms[5];
1977: bp->index = parms[6];
1978: bp->dwell_time = LE_READ_2(parms + 2);
1979: } else {
1980: bp->chanset = parms[2];
1981: bp->pattern = 0;
1982: bp->index = 0;
1983: bp->dwell_time = 0;
1984: }
1985: if (sc->sc_mgt_timer == 0)
1986: awi_stop_scan(sc);
1987: }
1988:
1989: static int
1990: awi_set_ss(sc)
1991: struct awi_softc *sc;
1992: {
1993: struct ifnet *ifp = sc->sc_ifp;
1994: struct awi_bss *bp;
1995: int error;
1996:
1997: sc->sc_status = AWI_ST_SETSS;
1998: bp = &sc->sc_bss;
1999: if (ifp->if_flags & IFF_DEBUG) {
2000: printf("%s: ch %d pat %d id %d dw %d iv %d bss %s ssid ",
2001: sc->sc_dev.dv_xname, bp->chanset,
2002: bp->pattern, bp->index, bp->dwell_time, bp->interval,
2003: ether_sprintf(bp->bssid));
2004: awi_print_essid(bp->essid);
2005: printf("\n");
2006: }
2007: memcpy(&sc->sc_mib_mgt.aCurrent_BSS_ID, bp->bssid, ETHER_ADDR_LEN);
2008: memcpy(&sc->sc_mib_mgt.aCurrent_ESS_ID, bp->essid,
2009: AWI_ESS_ID_SIZE);
2010: LE_WRITE_2(&sc->sc_mib_mgt.aBeacon_Period, bp->interval);
2011: error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_MGT);
2012: return error;
2013: }
2014:
2015: static void
2016: awi_try_sync(sc)
2017: struct awi_softc *sc;
2018: {
2019: struct awi_bss *bp;
2020:
2021: sc->sc_status = AWI_ST_SYNC;
2022: bp = &sc->sc_bss;
2023:
2024: if (sc->sc_cmd_inprog) {
2025: if (awi_cmd_wait(sc))
2026: return;
2027: }
2028: sc->sc_cmd_inprog = AWI_CMD_SYNC;
2029: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_SET, bp->chanset);
2030: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_PATTERN, bp->pattern);
2031: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_IDX, bp->index);
2032: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_STARTBSS,
2033: sc->sc_start_bss ? 1 : 0);
2034: awi_write_2(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_DWELL, bp->dwell_time);
2035: awi_write_2(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_MBZ, 0);
2036: awi_write_bytes(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_TIMESTAMP,
2037: bp->timestamp, 8);
2038: awi_write_4(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_REFTIME, bp->rxtime);
2039: (void)awi_cmd(sc, AWI_CMD_SYNC);
2040: }
2041:
2042: static void
2043: awi_sync_done(sc)
2044: struct awi_softc *sc;
2045: {
2046: struct ifnet *ifp = sc->sc_ifp;
2047:
2048: if (sc->sc_mib_local.Network_Mode) {
2049: awi_drvstate(sc, AWI_DRV_INFSY);
2050: awi_send_auth(sc, 1);
2051: } else {
2052: if (ifp->if_flags & IFF_DEBUG) {
2053: printf("%s: synced with", sc->sc_dev.dv_xname);
2054: if (sc->sc_no_bssid)
2055: printf(" no-bssid");
2056: else {
2057: printf(" %s ssid ",
2058: ether_sprintf(sc->sc_bss.bssid));
2059: awi_print_essid(sc->sc_bss.essid);
2060: }
2061: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH)
2062: printf(" at chanset %d pattern %d\n",
2063: sc->sc_bss.chanset, sc->sc_bss.pattern);
2064: else
2065: printf(" at channel %d\n", sc->sc_bss.chanset);
2066: }
2067: awi_drvstate(sc, AWI_DRV_ADHSY);
2068: sc->sc_status = AWI_ST_RUNNING;
2069: ifp->if_flags |= IFF_RUNNING;
2070: awi_start(ifp);
2071: }
2072: }
2073:
2074: static void
2075: awi_send_deauth(sc)
2076: struct awi_softc *sc;
2077: {
2078: struct ifnet *ifp = sc->sc_ifp;
2079: struct mbuf *m;
2080: struct ieee80211_frame *wh;
2081: u_int8_t *deauth;
2082:
2083: MGETHDR(m, M_DONTWAIT, MT_DATA);
2084: if (m == NULL)
2085: return;
2086: if (ifp->if_flags & IFF_DEBUG)
2087: printf("%s: sending deauth to %s\n", sc->sc_dev.dv_xname,
2088: ether_sprintf(sc->sc_bss.bssid));
2089:
2090: wh = mtod(m, struct ieee80211_frame *);
2091: wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT |
2092: IEEE80211_FC0_SUBTYPE_AUTH;
2093: wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
2094: LE_WRITE_2(wh->i_dur, 0);
2095: LE_WRITE_2(wh->i_seq, 0);
2096: memcpy(wh->i_addr1, sc->sc_bss.bssid, ETHER_ADDR_LEN);
2097: memcpy(wh->i_addr2, sc->sc_mib_addr.aMAC_Address, ETHER_ADDR_LEN);
2098: memcpy(wh->i_addr3, sc->sc_bss.bssid, ETHER_ADDR_LEN);
2099:
2100: deauth = (u_int8_t *)&wh[1];
2101: LE_WRITE_2(deauth, IEEE80211_REASON_AUTH_LEAVE);
2102: deauth += 2;
2103:
2104: m->m_pkthdr.len = m->m_len = deauth - mtod(m, u_int8_t *);
2105: IF_ENQUEUE(&sc->sc_mgtq, m);
2106: awi_start(ifp);
2107: awi_drvstate(sc, AWI_DRV_INFTOSS);
2108: }
2109:
2110: static void
2111: awi_send_auth(sc, seq)
2112: struct awi_softc *sc;
2113: int seq;
2114: {
2115: struct ifnet *ifp = sc->sc_ifp;
2116: struct mbuf *m;
2117: struct ieee80211_frame *wh;
2118: u_int8_t *auth;
2119:
2120: MGETHDR(m, M_DONTWAIT, MT_DATA);
2121: if (m == NULL)
2122: return;
2123: sc->sc_status = AWI_ST_AUTH;
2124: if (ifp->if_flags & IFF_DEBUG)
2125: printf("%s: sending auth to %s\n", sc->sc_dev.dv_xname,
2126: ether_sprintf(sc->sc_bss.bssid));
2127:
2128: wh = mtod(m, struct ieee80211_frame *);
2129: wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT |
2130: IEEE80211_FC0_SUBTYPE_AUTH;
2131: wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
2132: LE_WRITE_2(wh->i_dur, 0);
2133: LE_WRITE_2(wh->i_seq, 0);
2134: memcpy(wh->i_addr1, sc->sc_bss.esrc, ETHER_ADDR_LEN);
2135: memcpy(wh->i_addr2, sc->sc_mib_addr.aMAC_Address, ETHER_ADDR_LEN);
2136: memcpy(wh->i_addr3, sc->sc_bss.bssid, ETHER_ADDR_LEN);
2137:
2138: auth = (u_int8_t *)&wh[1];
2139: /* algorithm number */
2140: LE_WRITE_2(auth, IEEE80211_AUTH_ALG_OPEN);
2141: auth += 2;
2142: /* sequence number */
2143: LE_WRITE_2(auth, seq);
2144: auth += 2;
2145: /* status */
2146: LE_WRITE_2(auth, 0);
2147: auth += 2;
2148:
2149: m->m_pkthdr.len = m->m_len = auth - mtod(m, u_int8_t *);
2150: IF_ENQUEUE(&sc->sc_mgtq, m);
2151: awi_start(ifp);
2152:
2153: sc->sc_mgt_timer = AWI_TRANS_TIMEOUT / 1000;
2154: ifp->if_timer = 1;
2155: }
2156:
2157: static void
2158: awi_recv_auth(sc, m0)
2159: struct awi_softc *sc;
2160: struct mbuf *m0;
2161: {
2162: struct ieee80211_frame *wh;
2163: u_int8_t *auth, *eframe;
2164: struct awi_bss *bp;
2165: u_int16_t status;
2166:
2167: wh = mtod(m0, struct ieee80211_frame *);
2168: auth = (u_int8_t *)&wh[1];
2169: eframe = mtod(m0, u_int8_t *) + m0->m_len;
2170: if (sc->sc_ifp->if_flags & IFF_DEBUG)
2171: printf("%s: receive auth from %s\n", sc->sc_dev.dv_xname,
2172: ether_sprintf(wh->i_addr2));
2173:
2174: /* algorithm number */
2175: if (LE_READ_2(auth) != IEEE80211_AUTH_ALG_OPEN)
2176: return;
2177: auth += 2;
2178: if (!sc->sc_mib_local.Network_Mode) {
2179: if (sc->sc_status != AWI_ST_RUNNING)
2180: return;
2181: if (LE_READ_2(auth) == 1)
2182: awi_send_auth(sc, 2);
2183: return;
2184: }
2185: if (sc->sc_status != AWI_ST_AUTH)
2186: return;
2187: /* sequence number */
2188: if (LE_READ_2(auth) != 2)
2189: return;
2190: auth += 2;
2191: /* status */
2192: status = LE_READ_2(auth);
2193: if (status != 0) {
2194: printf("%s: authentication failed (reason %d)\n",
2195: sc->sc_dev.dv_xname, status);
2196: for (bp = TAILQ_FIRST(&sc->sc_scan); bp != NULL;
2197: bp = TAILQ_NEXT(bp, list)) {
2198: if (memcmp(bp->esrc, sc->sc_bss.esrc, ETHER_ADDR_LEN)
2199: == 0) {
2200: bp->fails++;
2201: break;
2202: }
2203: }
2204: return;
2205: }
2206: sc->sc_mgt_timer = 0;
2207: awi_drvstate(sc, AWI_DRV_INFAUTH);
2208: awi_send_asreq(sc, 0);
2209: }
2210:
2211: static void
2212: awi_send_asreq(sc, reassoc)
2213: struct awi_softc *sc;
2214: int reassoc;
2215: {
2216: struct ifnet *ifp = sc->sc_ifp;
2217: struct mbuf *m;
2218: struct ieee80211_frame *wh;
2219: u_int16_t lintval;
2220: u_int8_t *asreq;
2221:
2222: MGETHDR(m, M_DONTWAIT, MT_DATA);
2223: if (m == NULL)
2224: return;
2225: sc->sc_status = AWI_ST_ASSOC;
2226: if (ifp->if_flags & IFF_DEBUG)
2227: printf("%s: sending %sassoc req to %s\n", sc->sc_dev.dv_xname,
2228: reassoc ? "re" : "",
2229: ether_sprintf(sc->sc_bss.bssid));
2230:
2231: wh = mtod(m, struct ieee80211_frame *);
2232: wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT;
2233: if (reassoc)
2234: wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_REASSOC_REQ;
2235: else
2236: wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_ASSOC_REQ;
2237: wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
2238: LE_WRITE_2(wh->i_dur, 0);
2239: LE_WRITE_2(wh->i_seq, 0);
2240: memcpy(wh->i_addr1, sc->sc_bss.esrc, ETHER_ADDR_LEN);
2241: memcpy(wh->i_addr2, sc->sc_mib_addr.aMAC_Address, ETHER_ADDR_LEN);
2242: memcpy(wh->i_addr3, sc->sc_bss.bssid, ETHER_ADDR_LEN);
2243:
2244: asreq = (u_int8_t *)&wh[1];
2245:
2246: /* capability info */
2247: if (sc->sc_wep_algo == NULL)
2248: LE_WRITE_2(asreq, IEEE80211_CAPINFO_CF_POLLABLE);
2249: else
2250: LE_WRITE_2(asreq,
2251: IEEE80211_CAPINFO_CF_POLLABLE | IEEE80211_CAPINFO_PRIVACY);
2252: asreq += 2;
2253: /* listen interval */
2254: lintval = LE_READ_2(&sc->sc_mib_mgt.aListen_Interval);
2255: LE_WRITE_2(asreq, lintval);
2256: asreq += 2;
2257: if (reassoc) {
2258: /* current AP address */
2259: memcpy(asreq, sc->sc_bss.bssid, ETHER_ADDR_LEN);
2260: asreq += ETHER_ADDR_LEN;
2261: }
2262: /* ssid */
2263: memcpy(asreq, sc->sc_bss.essid, 2 + sc->sc_bss.essid[1]);
2264: asreq += 2 + asreq[1];
2265: /* supported rates */
2266: memcpy(asreq, &sc->sc_mib_phy.aSuprt_Data_Rates, 4);
2267: asreq += 2 + asreq[1];
2268:
2269: m->m_pkthdr.len = m->m_len = asreq - mtod(m, u_int8_t *);
2270: IF_ENQUEUE(&sc->sc_mgtq, m);
2271: awi_start(ifp);
2272:
2273: sc->sc_mgt_timer = AWI_TRANS_TIMEOUT / 1000;
2274: ifp->if_timer = 1;
2275: }
2276:
2277: static void
2278: awi_recv_asresp(sc, m0)
2279: struct awi_softc *sc;
2280: struct mbuf *m0;
2281: {
2282: struct ieee80211_frame *wh;
2283: u_int8_t *asresp, *eframe;
2284: u_int16_t status;
2285: u_int8_t rate, *phy_rates;
2286: struct awi_bss *bp;
2287: int i, j;
2288:
2289: wh = mtod(m0, struct ieee80211_frame *);
2290: asresp = (u_int8_t *)&wh[1];
2291: eframe = mtod(m0, u_int8_t *) + m0->m_len;
2292: if (sc->sc_ifp->if_flags & IFF_DEBUG)
2293: printf("%s: receive assoc resp from %s\n", sc->sc_dev.dv_xname,
2294: ether_sprintf(wh->i_addr2));
2295:
2296: if (!sc->sc_mib_local.Network_Mode)
2297: return;
2298:
2299: if (sc->sc_status != AWI_ST_ASSOC)
2300: return;
2301: /* capability info */
2302: asresp += 2;
2303: /* status */
2304: status = LE_READ_2(asresp);
2305: if (status != 0) {
2306: printf("%s: association failed (reason %d)\n",
2307: sc->sc_dev.dv_xname, status);
2308: for (bp = TAILQ_FIRST(&sc->sc_scan); bp != NULL;
2309: bp = TAILQ_NEXT(bp, list)) {
2310: if (memcmp(bp->esrc, sc->sc_bss.esrc, ETHER_ADDR_LEN)
2311: == 0) {
2312: bp->fails++;
2313: break;
2314: }
2315: }
2316: return;
2317: }
2318: asresp += 2;
2319: /* association id */
2320: asresp += 2;
2321: /* supported rates */
2322: rate = AWI_RATE_1MBIT;
2323: for (i = 0; i < asresp[1]; i++) {
2324: if (AWI_80211_RATE(asresp[2 + i]) <= rate)
2325: continue;
2326: phy_rates = sc->sc_mib_phy.aSuprt_Data_Rates;
2327: for (j = 0; j < phy_rates[1]; j++) {
2328: if (AWI_80211_RATE(asresp[2 + i]) ==
2329: AWI_80211_RATE(phy_rates[2 + j]))
2330: rate = AWI_80211_RATE(asresp[2 + i]);
2331: }
2332: }
2333: if (sc->sc_ifp->if_flags & IFF_DEBUG) {
2334: printf("%s: associated with %s ssid ",
2335: sc->sc_dev.dv_xname, ether_sprintf(sc->sc_bss.bssid));
2336: awi_print_essid(sc->sc_bss.essid);
2337: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH)
2338: printf(" chanset %d pattern %d\n",
2339: sc->sc_bss.chanset, sc->sc_bss.pattern);
2340: else
2341: printf(" channel %d\n", sc->sc_bss.chanset);
2342: }
2343: sc->sc_tx_rate = rate;
2344: sc->sc_mgt_timer = 0;
2345: sc->sc_rx_timer = 10;
2346: sc->sc_ifp->if_timer = 1;
2347: sc->sc_status = AWI_ST_RUNNING;
2348: sc->sc_ifp->if_flags |= IFF_RUNNING;
2349: awi_drvstate(sc, AWI_DRV_INFASSOC);
2350: awi_start(sc->sc_ifp);
2351: }
2352:
2353: static int
2354: awi_mib(sc, cmd, mib)
2355: struct awi_softc *sc;
2356: u_int8_t cmd;
2357: u_int8_t mib;
2358: {
2359: int error;
2360: u_int8_t size, *ptr;
2361:
2362: switch (mib) {
2363: case AWI_MIB_LOCAL:
2364: ptr = (u_int8_t *)&sc->sc_mib_local;
2365: size = sizeof(sc->sc_mib_local);
2366: break;
2367: case AWI_MIB_ADDR:
2368: ptr = (u_int8_t *)&sc->sc_mib_addr;
2369: size = sizeof(sc->sc_mib_addr);
2370: break;
2371: case AWI_MIB_MAC:
2372: ptr = (u_int8_t *)&sc->sc_mib_mac;
2373: size = sizeof(sc->sc_mib_mac);
2374: break;
2375: case AWI_MIB_STAT:
2376: ptr = (u_int8_t *)&sc->sc_mib_stat;
2377: size = sizeof(sc->sc_mib_stat);
2378: break;
2379: case AWI_MIB_MGT:
2380: ptr = (u_int8_t *)&sc->sc_mib_mgt;
2381: size = sizeof(sc->sc_mib_mgt);
2382: break;
2383: case AWI_MIB_PHY:
2384: ptr = (u_int8_t *)&sc->sc_mib_phy;
2385: size = sizeof(sc->sc_mib_phy);
2386: break;
2387: default:
2388: return EINVAL;
2389: }
2390: if (sc->sc_cmd_inprog) {
2391: error = awi_cmd_wait(sc);
2392: if (error) {
2393: if (error == EWOULDBLOCK)
2394: printf("awi_mib: cmd %d inprog",
2395: sc->sc_cmd_inprog);
2396: return error;
2397: }
2398: }
2399: sc->sc_cmd_inprog = cmd;
2400: if (cmd == AWI_CMD_SET_MIB)
2401: awi_write_bytes(sc, AWI_CMD_PARAMS+AWI_CA_MIB_DATA, ptr, size);
2402: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_MIB_TYPE, mib);
2403: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_MIB_SIZE, size);
2404: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_MIB_INDEX, 0);
2405: error = awi_cmd(sc, cmd);
2406: if (error)
2407: return error;
2408: if (cmd == AWI_CMD_GET_MIB) {
2409: awi_read_bytes(sc, AWI_CMD_PARAMS+AWI_CA_MIB_DATA, ptr, size);
2410: #ifdef AWI_DEBUG
2411: if (awi_verbose) {
2412: int i;
2413:
2414: printf("awi_mib: #%d:", mib);
2415: for (i = 0; i < size; i++)
2416: printf(" %02x", ptr[i]);
2417: printf("\n");
2418: }
2419: #endif
2420: }
2421: return 0;
2422: }
2423:
2424: static int
2425: awi_cmd_scan(sc)
2426: struct awi_softc *sc;
2427: {
2428: int error;
2429: u_int8_t scan_mode;
2430:
2431: if (sc->sc_active_scan)
2432: scan_mode = AWI_SCAN_ACTIVE;
2433: else
2434: scan_mode = AWI_SCAN_PASSIVE;
2435: if (sc->sc_mib_mgt.aScan_Mode != scan_mode) {
2436: sc->sc_mib_mgt.aScan_Mode = scan_mode;
2437: error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_MGT);
2438: return error;
2439: }
2440:
2441: if (sc->sc_cmd_inprog) {
2442: error = awi_cmd_wait(sc);
2443: if (error)
2444: return error;
2445: }
2446: sc->sc_cmd_inprog = AWI_CMD_SCAN;
2447: awi_write_2(sc, AWI_CMD_PARAMS+AWI_CA_SCAN_DURATION,
2448: sc->sc_active_scan ? AWI_ASCAN_DURATION : AWI_PSCAN_DURATION);
2449: if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH) {
2450: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SCAN_SET,
2451: sc->sc_scan_set);
2452: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SCAN_PATTERN,
2453: sc->sc_scan_cur);
2454: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SCAN_IDX, 1);
2455: } else {
2456: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SCAN_SET,
2457: sc->sc_scan_cur);
2458: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SCAN_PATTERN, 0);
2459: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SCAN_IDX, 0);
2460: }
2461: awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SCAN_SUSP, 0);
2462: return awi_cmd(sc, AWI_CMD_SCAN);
2463: }
2464:
2465: static int
2466: awi_cmd(sc, cmd)
2467: struct awi_softc *sc;
2468: u_int8_t cmd;
2469: {
2470: u_int8_t status;
2471: int error = 0;
2472:
2473: sc->sc_cmd_inprog = cmd;
2474: awi_write_1(sc, AWI_CMD_STATUS, AWI_STAT_IDLE);
2475: awi_write_1(sc, AWI_CMD, cmd);
2476: if (sc->sc_status != AWI_ST_INIT)
2477: return 0;
2478: error = awi_cmd_wait(sc);
2479: if (error)
2480: return error;
2481: status = awi_read_1(sc, AWI_CMD_STATUS);
2482: awi_write_1(sc, AWI_CMD, 0);
2483: switch (status) {
2484: case AWI_STAT_OK:
2485: break;
2486: case AWI_STAT_BADPARM:
2487: return EINVAL;
2488: default:
2489: printf("%s: command %d failed %x\n",
2490: sc->sc_dev.dv_xname, cmd, status);
2491: return ENXIO;
2492: }
2493: return 0;
2494: }
2495:
2496: static void
2497: awi_cmd_done(sc)
2498: struct awi_softc *sc;
2499: {
2500: u_int8_t cmd, status;
2501:
2502: status = awi_read_1(sc, AWI_CMD_STATUS);
2503: if (status == AWI_STAT_IDLE)
2504: return; /* stray interrupt */
2505:
2506: cmd = sc->sc_cmd_inprog;
2507: sc->sc_cmd_inprog = 0;
2508: if (sc->sc_status == AWI_ST_INIT) {
2509: wakeup(sc);
2510: return;
2511: }
2512: awi_write_1(sc, AWI_CMD, 0);
2513:
2514: if (status != AWI_STAT_OK) {
2515: printf("%s: command %d failed %x\n",
2516: sc->sc_dev.dv_xname, cmd, status);
2517: return;
2518: }
2519: switch (sc->sc_status) {
2520: case AWI_ST_SCAN:
2521: if (cmd == AWI_CMD_SET_MIB)
2522: awi_cmd_scan(sc); /* retry */
2523: break;
2524: case AWI_ST_SETSS:
2525: awi_try_sync(sc);
2526: break;
2527: case AWI_ST_SYNC:
2528: awi_sync_done(sc);
2529: break;
2530: default:
2531: break;
2532: }
2533: }
2534:
2535: static int
2536: awi_next_txd(sc, len, framep, ntxdp)
2537: struct awi_softc *sc;
2538: int len;
2539: u_int32_t *framep, *ntxdp;
2540: {
2541: u_int32_t txd, ntxd, frame;
2542:
2543: txd = sc->sc_txnext;
2544: frame = txd + AWI_TXD_SIZE;
2545: if (frame + len > sc->sc_txend)
2546: frame = sc->sc_txbase;
2547: ntxd = frame + len;
2548: if (ntxd + AWI_TXD_SIZE > sc->sc_txend)
2549: ntxd = sc->sc_txbase;
2550: *framep = frame;
2551: *ntxdp = ntxd;
2552: /*
2553: * Determine if there are any room in ring buffer.
2554: * --- send wait, === new data, +++ conflict (ENOBUFS)
2555: * base........................end
2556: * done----txd=====ntxd OK
2557: * --txd=====done++++ntxd-- full
2558: * --txd=====ntxd done-- OK
2559: * ==ntxd done----txd=== OK
2560: * ==done++++ntxd----txd=== full
2561: * ++ntxd txd=====done++ full
2562: */
2563: if (txd < ntxd) {
2564: if (txd < sc->sc_txdone && ntxd + AWI_TXD_SIZE > sc->sc_txdone)
2565: return ENOBUFS;
2566: } else {
2567: if (txd < sc->sc_txdone || ntxd + AWI_TXD_SIZE > sc->sc_txdone)
2568: return ENOBUFS;
2569: }
2570: return 0;
2571: }
2572:
2573: static int
2574: awi_lock(sc)
2575: struct awi_softc *sc;
2576: {
2577: int error = 0;
2578:
2579: if (curproc == NULL) {
2580: /*
2581: * XXX
2582: * Though driver ioctl should be called with context,
2583: * KAME ipv6 stack calls ioctl in interrupt for now.
2584: * We simply abort the request if there are other
2585: * ioctl requests in progress.
2586: */
2587: if (sc->sc_busy) {
2588: return EWOULDBLOCK;
2589: if (sc->sc_invalid)
2590: return ENXIO;
2591: }
2592: sc->sc_busy = 1;
2593: sc->sc_cansleep = 0;
2594: return 0;
2595: }
2596: while (sc->sc_busy) {
2597: if (sc->sc_invalid)
2598: return ENXIO;
2599: sc->sc_sleep_cnt++;
2600: error = tsleep(sc, PWAIT | PCATCH, "awilck", 0);
2601: sc->sc_sleep_cnt--;
2602: if (error)
2603: return error;
2604: }
2605: sc->sc_busy = 1;
2606: sc->sc_cansleep = 1;
2607: return 0;
2608: }
2609:
2610: static void
2611: awi_unlock(sc)
2612: struct awi_softc *sc;
2613: {
2614: sc->sc_busy = 0;
2615: sc->sc_cansleep = 0;
2616: if (sc->sc_sleep_cnt)
2617: wakeup(sc);
2618: }
2619:
2620: static int
2621: awi_intr_lock(sc)
2622: struct awi_softc *sc;
2623: {
2624: u_int8_t status;
2625: int i, retry;
2626:
2627: status = 1;
2628: for (retry = 0; retry < 10; retry++) {
2629: for (i = 0; i < AWI_LOCKOUT_TIMEOUT*1000/5; i++) {
2630: status = awi_read_1(sc, AWI_LOCKOUT_HOST);
2631: if (status == 0)
2632: break;
2633: DELAY(5);
2634: }
2635: if (status != 0)
2636: break;
2637: awi_write_1(sc, AWI_LOCKOUT_MAC, 1);
2638: status = awi_read_1(sc, AWI_LOCKOUT_HOST);
2639: if (status == 0)
2640: break;
2641: awi_write_1(sc, AWI_LOCKOUT_MAC, 0);
2642: }
2643: if (status != 0) {
2644: printf("%s: failed to lock interrupt\n",
2645: sc->sc_dev.dv_xname);
2646: return ENXIO;
2647: }
2648: return 0;
2649: }
2650:
2651: static void
2652: awi_intr_unlock(sc)
2653: struct awi_softc *sc;
2654: {
2655:
2656: awi_write_1(sc, AWI_LOCKOUT_MAC, 0);
2657: }
2658:
2659: static int
2660: awi_cmd_wait(sc)
2661: struct awi_softc *sc;
2662: {
2663: int i, error = 0;
2664:
2665: i = 0;
2666: while (sc->sc_cmd_inprog) {
2667: if (sc->sc_invalid)
2668: return ENXIO;
2669: if (awi_read_1(sc, AWI_CMD) != sc->sc_cmd_inprog) {
2670: printf("%s: failed to access hardware\n",
2671: sc->sc_dev.dv_xname);
2672: sc->sc_invalid = 1;
2673: return ENXIO;
2674: }
2675: if (sc->sc_cansleep) {
2676: sc->sc_sleep_cnt++;
2677: error = tsleep(sc, PWAIT, "awicmd",
2678: AWI_CMD_TIMEOUT*hz/1000);
2679: sc->sc_sleep_cnt--;
2680: } else {
2681: if (awi_read_1(sc, AWI_CMD_STATUS) != AWI_STAT_IDLE) {
2682: awi_cmd_done(sc);
2683: break;
2684: }
2685: if (i++ >= AWI_CMD_TIMEOUT*1000/10)
2686: error = EWOULDBLOCK;
2687: else
2688: DELAY(10);
2689: }
2690: if (error)
2691: break;
2692: }
2693: return error;
2694: }
2695:
2696: static void
2697: awi_print_essid(essid)
2698: u_int8_t *essid;
2699: {
2700: int i, len;
2701: u_int8_t *p;
2702:
2703: len = essid[1];
2704: if (len > IEEE80211_NWID_LEN)
2705: len = IEEE80211_NWID_LEN; /*XXX*/
2706: /* determine printable or not */
2707: for (i = 0, p = essid + 2; i < len; i++, p++) {
2708: if (*p < ' ' || *p > 0x7e)
2709: break;
2710: }
2711: if (i == len) {
2712: printf("\"");
2713: for (i = 0, p = essid + 2; i < len; i++, p++)
2714: printf("%c", *p);
2715: printf("\"");
2716: } else {
2717: printf("0x");
2718: for (i = 0, p = essid + 2; i < len; i++, p++)
2719: printf("%02x", *p);
2720: }
2721: }
2722:
2723: #ifdef AWI_DEBUG
2724: static void
2725: awi_dump_pkt(sc, m, rssi)
2726: struct awi_softc *sc;
2727: struct mbuf *m;
2728: int rssi;
2729: {
2730: struct ieee80211_frame *wh;
2731: int i, l;
2732:
2733: wh = mtod(m, struct ieee80211_frame *);
2734:
2735: if (awi_dump_mask != 0 &&
2736: ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK)==IEEE80211_FC1_DIR_NODS) &&
2737: ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK)==IEEE80211_FC0_TYPE_MGT)) {
2738: if ((AWI_DUMP_MASK(wh->i_fc[0]) & awi_dump_mask) != 0)
2739: return;
2740: }
2741: if (awi_dump_mask < 0 &&
2742: (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK)==IEEE80211_FC0_TYPE_DATA)
2743: return;
2744:
2745: if (rssi < 0)
2746: printf("tx: ");
2747: else
2748: printf("rx: ");
2749: switch (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
2750: case IEEE80211_FC1_DIR_NODS:
2751: printf("NODS %s", ether_sprintf(wh->i_addr2));
2752: printf("->%s", ether_sprintf(wh->i_addr1));
2753: printf("(%s)", ether_sprintf(wh->i_addr3));
2754: break;
2755: case IEEE80211_FC1_DIR_TODS:
2756: printf("TODS %s", ether_sprintf(wh->i_addr2));
2757: printf("->%s", ether_sprintf(wh->i_addr3));
2758: printf("(%s)", ether_sprintf(wh->i_addr1));
2759: break;
2760: case IEEE80211_FC1_DIR_FROMDS:
2761: printf("FRDS %s", ether_sprintf(wh->i_addr3));
2762: printf("->%s", ether_sprintf(wh->i_addr1));
2763: printf("(%s)", ether_sprintf(wh->i_addr2));
2764: break;
2765: case IEEE80211_FC1_DIR_DSTODS:
2766: printf("DSDS %s", ether_sprintf((u_int8_t *)&wh[1]));
2767: printf("->%s", ether_sprintf(wh->i_addr3));
2768: printf("(%s", ether_sprintf(wh->i_addr2));
2769: printf("->%s)", ether_sprintf(wh->i_addr1));
2770: break;
2771: }
2772: switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) {
2773: case IEEE80211_FC0_TYPE_DATA:
2774: printf(" data");
2775: break;
2776: case IEEE80211_FC0_TYPE_MGT:
2777: switch (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) {
2778: case IEEE80211_FC0_SUBTYPE_PROBE_REQ:
2779: printf(" probe_req");
2780: break;
2781: case IEEE80211_FC0_SUBTYPE_PROBE_RESP:
2782: printf(" probe_resp");
2783: break;
2784: case IEEE80211_FC0_SUBTYPE_BEACON:
2785: printf(" beacon");
2786: break;
2787: case IEEE80211_FC0_SUBTYPE_AUTH:
2788: printf(" auth");
2789: break;
2790: case IEEE80211_FC0_SUBTYPE_ASSOC_REQ:
2791: printf(" assoc_req");
2792: break;
2793: case IEEE80211_FC0_SUBTYPE_ASSOC_RESP:
2794: printf(" assoc_resp");
2795: break;
2796: case IEEE80211_FC0_SUBTYPE_REASSOC_REQ:
2797: printf(" reassoc_req");
2798: break;
2799: case IEEE80211_FC0_SUBTYPE_REASSOC_RESP:
2800: printf(" reassoc_resp");
2801: break;
2802: case IEEE80211_FC0_SUBTYPE_DEAUTH:
2803: printf(" deauth");
2804: break;
2805: case IEEE80211_FC0_SUBTYPE_DISASSOC:
2806: printf(" disassoc");
2807: break;
2808: default:
2809: printf(" mgt#%d",
2810: wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
2811: break;
2812: }
2813: break;
2814: default:
2815: printf(" type#%d",
2816: wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK);
2817: break;
2818: }
2819: if (wh->i_fc[1] & IEEE80211_FC1_WEP)
2820: printf(" WEP");
2821: if (rssi >= 0)
2822: printf(" +%d", rssi);
2823: printf("\n");
2824: if (awi_dump_len > 0) {
2825: l = m->m_len;
2826: if (l > awi_dump_len + sizeof(*wh))
2827: l = awi_dump_len + sizeof(*wh);
2828: i = sizeof(*wh);
2829: if (awi_dump_hdr)
2830: i = 0;
2831: for (; i < l; i++) {
2832: if ((i & 1) == 0)
2833: printf(" ");
2834: printf("%02x", mtod(m, u_int8_t *)[i]);
2835: }
2836: printf("\n");
2837: }
2838: }
2839: #endif