FreeBSD/Linux Kernel Cross Reference
sys/dev/ic/awi.c
1 /* $NetBSD: awi.c,v 1.67 2005/02/27 00:27:00 perry Exp $ */
2
3 /*-
4 * Copyright (c) 1999,2000,2001 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Bill Sommerfeld
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the NetBSD
21 * Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 * contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38 /*
39 * Driver for AMD 802.11 firmware.
40 * Uses am79c930 chip driver to talk to firmware running on the am79c930.
41 *
42 * More-or-less a generic ethernet-like if driver, with 802.11 gorp added.
43 */
44
45 /*
46 * todo:
47 * - flush tx queue on resynch.
48 * - clear oactive on "down".
49 * - rewrite copy-into-mbuf code
50 * - mgmt state machine gets stuck retransmitting assoc requests.
51 * - multicast filter.
52 * - fix device reset so it's more likely to work
53 * - show status goo through ifmedia.
54 *
55 * more todo:
56 * - deal with more 802.11 frames.
57 * - send reassoc request
58 * - deal with reassoc response
59 * - send/deal with disassociation
60 * - deal with "full" access points (no room for me).
61 * - power save mode
62 *
63 * later:
64 * - SSID preferences
65 * - need ioctls for poking at the MIBs
66 * - implement ad-hoc mode (including bss creation).
67 * - decide when to do "ad hoc" vs. infrastructure mode (IFF_LINK flags?)
68 * (focus on inf. mode since that will be needed for ietf)
69 * - deal with DH vs. FH versions of the card
70 * - deal with faster cards (2mb/s)
71 * - ?WEP goo (mmm, rc4) (it looks not particularly useful).
72 * - ifmedia revision.
73 * - common 802.11 mibish things.
74 * - common 802.11 media layer.
75 */
76
77 /*
78 * Driver for AMD 802.11 PCnetMobile firmware.
79 * Uses am79c930 chip driver to talk to firmware running on the am79c930.
80 *
81 * The initial version of the driver was written by
82 * Bill Sommerfeld <sommerfeld@NetBSD.org>.
83 * Then the driver module completely rewritten to support cards with DS phy
84 * and to support adhoc mode by Atsushi Onoe <onoe@NetBSD.org>
85 */
86
87 #include <sys/cdefs.h>
88 #ifdef __NetBSD__
89 __KERNEL_RCSID(0, "$NetBSD: awi.c,v 1.67 2005/02/27 00:27:00 perry Exp $");
90 #endif
91 #ifdef __FreeBSD__
92 __FBSDID("$FreeBSD: src/sys/dev/awi/awi.c,v 1.30 2004/01/15 13:30:06 onoe Exp $");
93 #endif
94
95 #include "opt_inet.h"
96 #ifdef __NetBSD__
97 #include "bpfilter.h"
98 #endif
99 #ifdef __FreeBSD__
100 #define NBPFILTER 1
101 #endif
102
103 #include <sys/param.h>
104 #include <sys/systm.h>
105 #include <sys/kernel.h>
106 #include <sys/mbuf.h>
107 #include <sys/malloc.h>
108 #include <sys/proc.h>
109 #include <sys/socket.h>
110 #include <sys/sockio.h>
111 #include <sys/errno.h>
112 #include <sys/endian.h>
113 #ifdef __FreeBSD__
114 #include <sys/bus.h>
115 #endif
116 #ifdef __NetBSD__
117 #include <sys/device.h>
118 #endif
119
120 #include <net/if.h>
121 #include <net/if_dl.h>
122 #ifdef __NetBSD__
123 #include <net/if_ether.h>
124 #endif
125 #ifdef __FreeBSD__
126 #include <net/ethernet.h>
127 #include <net/if_arp.h>
128 #endif
129 #include <net/if_media.h>
130 #include <net/if_llc.h>
131
132 #include <net80211/ieee80211_var.h>
133 #ifdef __NetBSD__
134 #include <net80211/ieee80211_compat.h>
135 #endif
136
137 #if NBPFILTER > 0
138 #include <net/bpf.h>
139 #endif
140
141 #include <machine/cpu.h>
142 #include <machine/bus.h>
143
144 #ifdef __NetBSD__
145 #include <dev/ic/am79c930reg.h>
146 #include <dev/ic/am79c930var.h>
147 #include <dev/ic/awireg.h>
148 #include <dev/ic/awivar.h>
149 #endif
150 #ifdef __FreeBSD__
151 #include <dev/awi/am79c930reg.h>
152 #include <dev/awi/am79c930var.h>
153 #include <dev/awi/awireg.h>
154 #include <dev/awi/awivar.h>
155 #endif
156
157 #ifdef __FreeBSD__
158 static void awi_init0(void *);
159 #endif
160 static int awi_init(struct ifnet *);
161 static void awi_stop(struct ifnet *, int);
162 static void awi_start(struct ifnet *);
163 static void awi_watchdog(struct ifnet *);
164 static int awi_ioctl(struct ifnet *, u_long, caddr_t);
165 static int awi_media_change(struct ifnet *);
166 static void awi_media_status(struct ifnet *, struct ifmediareq *);
167 static int awi_mode_init(struct awi_softc *);
168 static void awi_rx_int(struct awi_softc *);
169 static void awi_tx_int(struct awi_softc *);
170 static struct mbuf *awi_devget(struct awi_softc *, u_int32_t, u_int16_t);
171 static int awi_hw_init(struct awi_softc *);
172 static int awi_init_mibs(struct awi_softc *);
173 static int awi_mib(struct awi_softc *, u_int8_t, u_int8_t, int);
174 static int awi_cmd(struct awi_softc *, u_int8_t, int);
175 static int awi_cmd_wait(struct awi_softc *);
176 static void awi_cmd_done(struct awi_softc *);
177 static int awi_next_txd(struct awi_softc *, int, u_int32_t *, u_int32_t *);
178 static int awi_lock(struct awi_softc *);
179 static void awi_unlock(struct awi_softc *);
180 static int awi_intr_lock(struct awi_softc *);
181 static void awi_intr_unlock(struct awi_softc *);
182 static int awi_newstate(struct ieee80211com *, enum ieee80211_state, int);
183 static void awi_recv_mgmt(struct ieee80211com *, struct mbuf *,
184 struct ieee80211_node *, int, int, u_int32_t);
185 static int awi_send_mgmt(struct ieee80211com *, struct ieee80211_node *, int,
186 int);
187 static struct mbuf *awi_ether_encap(struct awi_softc *, struct mbuf *);
188 static struct mbuf *awi_ether_modcap(struct awi_softc *, struct mbuf *);
189
190 /* unaligned little endian access */
191 #define LE_READ_2(p) \
192 ((((u_int8_t *)(p))[0] ) | (((u_int8_t *)(p))[1] << 8))
193 #define LE_READ_4(p) \
194 ((((u_int8_t *)(p))[0] ) | (((u_int8_t *)(p))[1] << 8) | \
195 (((u_int8_t *)(p))[2] << 16) | (((u_int8_t *)(p))[3] << 24))
196 #define LE_WRITE_2(p, v) \
197 ((((u_int8_t *)(p))[0] = (((u_int32_t)(v) ) & 0xff)), \
198 (((u_int8_t *)(p))[1] = (((u_int32_t)(v) >> 8) & 0xff)))
199 #define LE_WRITE_4(p, v) \
200 ((((u_int8_t *)(p))[0] = (((u_int32_t)(v) ) & 0xff)), \
201 (((u_int8_t *)(p))[1] = (((u_int32_t)(v) >> 8) & 0xff)), \
202 (((u_int8_t *)(p))[2] = (((u_int32_t)(v) >> 16) & 0xff)), \
203 (((u_int8_t *)(p))[3] = (((u_int32_t)(v) >> 24) & 0xff)))
204
205 struct awi_chanset awi_chanset[] = {
206 /* PHY type domain min max def */
207 { AWI_PHY_TYPE_FH, AWI_REG_DOMAIN_JP, 6, 17, 6 },
208 { AWI_PHY_TYPE_FH, AWI_REG_DOMAIN_ES, 0, 26, 1 },
209 { AWI_PHY_TYPE_FH, AWI_REG_DOMAIN_FR, 0, 32, 1 },
210 { AWI_PHY_TYPE_FH, AWI_REG_DOMAIN_US, 0, 77, 1 },
211 { AWI_PHY_TYPE_FH, AWI_REG_DOMAIN_CA, 0, 77, 1 },
212 { AWI_PHY_TYPE_FH, AWI_REG_DOMAIN_EU, 0, 77, 1 },
213 { AWI_PHY_TYPE_DS, AWI_REG_DOMAIN_JP, 14, 14, 14 },
214 { AWI_PHY_TYPE_DS, AWI_REG_DOMAIN_ES, 10, 11, 10 },
215 { AWI_PHY_TYPE_DS, AWI_REG_DOMAIN_FR, 10, 13, 10 },
216 { AWI_PHY_TYPE_DS, AWI_REG_DOMAIN_US, 1, 11, 3 },
217 { AWI_PHY_TYPE_DS, AWI_REG_DOMAIN_CA, 1, 11, 3 },
218 { AWI_PHY_TYPE_DS, AWI_REG_DOMAIN_EU, 1, 13, 3 },
219 { 0, 0 }
220 };
221
222 #ifdef __FreeBSD__
223 devclass_t awi_devclass;
224
225 #if __FreeBSD_version < 500043
226 static char *ether_sprintf(u_int8_t *);
227
228 static char *
229 ether_sprintf(u_int8_t *enaddr)
230 {
231 static char strbuf[18];
232
233 sprintf(strbuf, "%6D", enaddr, ":");
234 return strbuf;
235 }
236 #endif
237
238 #define IFQ_PURGE(ifq) IF_DRAIN(ifq)
239 #define IF_POLL(ifq, m) ((m) = (ifq)->ifq_head)
240 #define IFQ_POLL(ifq, m) IF_POLL((ifq), (m))
241 #define IFQ_DEQUEUE(ifq, m) IF_DEQUEUE((ifq), (m))
242
243 #endif
244
245 #ifdef AWI_DEBUG
246 int awi_debug = 0;
247
248 #define DPRINTF(X) if (awi_debug) printf X
249 #define DPRINTF2(X) if (awi_debug > 1) printf X
250 #else
251 #define DPRINTF(X)
252 #define DPRINTF2(X)
253 #endif
254
255 int
256 awi_attach(struct awi_softc *sc)
257 {
258 struct ieee80211com *ic = &sc->sc_ic;
259 struct ifnet *ifp = &ic->ic_if;
260 int s, i, error, nrate;
261 int mword;
262 enum ieee80211_phymode mode;
263
264 s = splnet();
265 sc->sc_busy = 1;
266 sc->sc_attached = 0;
267 sc->sc_substate = AWI_ST_NONE;
268 if ((error = awi_hw_init(sc)) != 0) {
269 sc->sc_invalid = 1;
270 splx(s);
271 return error;
272 }
273 error = awi_init_mibs(sc);
274 if (error != 0) {
275 sc->sc_invalid = 1;
276 splx(s);
277 return error;
278 }
279 ifp->if_softc = sc;
280 ifp->if_flags =
281 #ifdef IFF_NOTRAILERS
282 IFF_NOTRAILERS |
283 #endif
284 IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
285 ifp->if_ioctl = awi_ioctl;
286 ifp->if_start = awi_start;
287 ifp->if_watchdog = awi_watchdog;
288 #ifdef __NetBSD__
289 ifp->if_init = awi_init;
290 ifp->if_stop = awi_stop;
291 IFQ_SET_READY(&ifp->if_snd);
292 memcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
293 #endif
294 #ifdef __FreeBSD__
295 ifp->if_init = awi_init0;
296 ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
297 if_initname(ifp, device_get_name(sc->sc_dev),
298 device_get_unit(sc->sc_dev));
299 #endif
300
301 ic->ic_caps = IEEE80211_C_WEP | IEEE80211_C_IBSS | IEEE80211_C_HOSTAP;
302 if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH) {
303 ic->ic_phytype = IEEE80211_T_FH;
304 mode = IEEE80211_MODE_FH;
305 } else {
306 ic->ic_phytype = IEEE80211_T_DS;
307 ic->ic_caps |= IEEE80211_C_AHDEMO;
308 mode = IEEE80211_MODE_11B;
309 }
310 ic->ic_opmode = IEEE80211_M_STA;
311 nrate = sc->sc_mib_phy.aSuprt_Data_Rates[1];
312 memcpy(ic->ic_sup_rates[mode].rs_rates,
313 sc->sc_mib_phy.aSuprt_Data_Rates + 2, nrate);
314 ic->ic_sup_rates[mode].rs_nrates = nrate;
315 IEEE80211_ADDR_COPY(ic->ic_myaddr, sc->sc_mib_addr.aMAC_Address);
316
317 printf("%s: IEEE802.11 %s (firmware %s)\n", ifp->if_xname,
318 (ic->ic_phytype == IEEE80211_T_FH) ? "FH" : "DS", sc->sc_banner);
319 printf("%s: 802.11 address: %s\n", ifp->if_xname,
320 ether_sprintf(ic->ic_myaddr));
321
322 #ifdef __NetBSD__
323 if_attach(ifp);
324 #endif
325 ieee80211_ifattach(ifp);
326
327 sc->sc_newstate = ic->ic_newstate;
328 ic->ic_newstate = awi_newstate;
329
330 sc->sc_recv_mgmt = ic->ic_recv_mgmt;
331 ic->ic_recv_mgmt = awi_recv_mgmt;
332
333 sc->sc_send_mgmt = ic->ic_send_mgmt;
334 ic->ic_send_mgmt = awi_send_mgmt;
335
336 ieee80211_media_init(ifp, awi_media_change, awi_media_status);
337
338 /* Melco compatibility mode. */
339 #define ADD(s, o) ifmedia_add(&ic->ic_media, \
340 IFM_MAKEWORD(IFM_IEEE80211, (s), (o), 0), 0, NULL)
341 ADD(IFM_AUTO, IFM_FLAG0);
342
343 for (i = 0; i < nrate; i++) {
344 mword = ieee80211_rate2media(ic,
345 ic->ic_sup_rates[mode].rs_rates[i], mode);
346 if (mword == 0)
347 continue;
348 ADD(mword, IFM_FLAG0);
349 }
350 #undef ADD
351
352 #ifdef __NetBSD__
353 if ((sc->sc_sdhook = shutdownhook_establish(awi_shutdown, sc)) == NULL)
354 printf("%s: WARNING: unable to establish shutdown hook\n",
355 ifp->if_xname);
356 if ((sc->sc_powerhook = powerhook_establish(awi_power, sc)) == NULL)
357 printf("%s: WARNING: unable to establish power hook\n",
358 ifp->if_xname);
359 #endif
360 sc->sc_attached = 1;
361 splx(s);
362
363 /* ready to accept ioctl */
364 awi_unlock(sc);
365
366 return 0;
367 }
368
369 int
370 awi_detach(struct awi_softc *sc)
371 {
372 struct ifnet *ifp = &sc->sc_ic.ic_if;
373 int s;
374
375 if (!sc->sc_attached)
376 return 0;
377
378 s = splnet();
379 sc->sc_invalid = 1;
380 awi_stop(ifp, 1);
381
382 while (sc->sc_sleep_cnt > 0) {
383 wakeup(sc);
384 (void)tsleep(sc, PWAIT, "awidet", 1);
385 }
386 sc->sc_attached = 0;
387 ieee80211_ifdetach(ifp);
388 #ifdef __NetBSD__
389 if_detach(ifp);
390 shutdownhook_disestablish(sc->sc_sdhook);
391 powerhook_disestablish(sc->sc_powerhook);
392 #endif
393 splx(s);
394 return 0;
395 }
396
397 #ifdef __NetBSD__
398 int
399 awi_activate(struct device *self, enum devact act)
400 {
401 struct awi_softc *sc = (struct awi_softc *)self;
402 struct ifnet *ifp = &sc->sc_ic.ic_if;
403 int s, error = 0;
404
405 s = splnet();
406 switch (act) {
407 case DVACT_ACTIVATE:
408 error = EOPNOTSUPP;
409 break;
410 case DVACT_DEACTIVATE:
411 sc->sc_invalid = 1;
412 if_deactivate(ifp);
413 break;
414 }
415 splx(s);
416 return error;
417 }
418
419 void
420 awi_power(int why, void *arg)
421 {
422 struct awi_softc *sc = arg;
423 struct ifnet *ifp = &sc->sc_ic.ic_if;
424 int s;
425 int ocansleep;
426
427 DPRINTF(("awi_power: %d\n", why));
428 s = splnet();
429 ocansleep = sc->sc_cansleep;
430 sc->sc_cansleep = 0;
431 switch (why) {
432 case PWR_SUSPEND:
433 case PWR_STANDBY:
434 awi_stop(ifp, 1);
435 break;
436 case PWR_RESUME:
437 if (ifp->if_flags & IFF_UP) {
438 awi_init(ifp);
439 (void)awi_intr(sc); /* make sure */
440 }
441 break;
442 case PWR_SOFTSUSPEND:
443 case PWR_SOFTSTANDBY:
444 case PWR_SOFTRESUME:
445 break;
446 }
447 sc->sc_cansleep = ocansleep;
448 splx(s);
449 }
450 #endif /* __NetBSD__ */
451
452 void
453 awi_shutdown(void *arg)
454 {
455 struct awi_softc *sc = arg;
456 struct ifnet *ifp = &sc->sc_ic.ic_if;
457
458 if (sc->sc_attached)
459 awi_stop(ifp, 1);
460 }
461
462 int
463 awi_intr(void *arg)
464 {
465 struct awi_softc *sc = arg;
466 u_int16_t status;
467 int handled = 0, ocansleep;
468 #ifdef AWI_DEBUG
469 static const char *intname[] = {
470 "CMD", "RX", "TX", "SCAN_CMPLT",
471 "CFP_START", "DTIM", "CFP_ENDING", "GROGGY",
472 "TXDATA", "TXBCAST", "TXPS", "TXCF",
473 "TXMGT", "#13", "RXDATA", "RXMGT"
474 };
475 #endif
476
477 if (!sc->sc_enabled || !sc->sc_enab_intr || sc->sc_invalid) {
478 DPRINTF(("awi_intr: stray interrupt: "
479 "enabled %d enab_intr %d invalid %d\n",
480 sc->sc_enabled, sc->sc_enab_intr, sc->sc_invalid));
481 return 0;
482 }
483
484 am79c930_gcr_setbits(&sc->sc_chip,
485 AM79C930_GCR_DISPWDN | AM79C930_GCR_ECINT);
486 awi_write_1(sc, AWI_DIS_PWRDN, 1);
487 ocansleep = sc->sc_cansleep;
488 sc->sc_cansleep = 0;
489
490 for (;;) {
491 if (awi_intr_lock(sc) != 0)
492 break;
493 status = awi_read_1(sc, AWI_INTSTAT);
494 awi_write_1(sc, AWI_INTSTAT, 0);
495 awi_write_1(sc, AWI_INTSTAT, 0);
496 status |= awi_read_1(sc, AWI_INTSTAT2) << 8;
497 awi_write_1(sc, AWI_INTSTAT2, 0);
498 DELAY(10);
499 awi_intr_unlock(sc);
500 if (!sc->sc_cmd_inprog)
501 status &= ~AWI_INT_CMD; /* make sure */
502 if (status == 0)
503 break;
504 #ifdef AWI_DEBUG
505 if (awi_debug > 1) {
506 int i;
507
508 printf("awi_intr: status 0x%04x", status);
509 for (i = 0; i < sizeof(intname)/sizeof(intname[0]);
510 i++) {
511 if (status & (1 << i))
512 printf(" %s", intname[i]);
513 }
514 printf("\n");
515 }
516 #endif
517 handled = 1;
518 if (status & AWI_INT_RX)
519 awi_rx_int(sc);
520 if (status & AWI_INT_TX)
521 awi_tx_int(sc);
522 if (status & AWI_INT_CMD)
523 awi_cmd_done(sc);
524 if (status & AWI_INT_SCAN_CMPLT) {
525 if (sc->sc_ic.ic_state == IEEE80211_S_SCAN &&
526 sc->sc_substate == AWI_ST_NONE)
527 ieee80211_next_scan(&sc->sc_ic);
528 }
529 }
530 sc->sc_cansleep = ocansleep;
531 am79c930_gcr_clearbits(&sc->sc_chip, AM79C930_GCR_DISPWDN);
532 awi_write_1(sc, AWI_DIS_PWRDN, 0);
533 return handled;
534 }
535
536 #ifdef __FreeBSD__
537 static void
538 awi_init0(void *arg)
539 {
540 struct awi_softc *sc = arg;
541
542 (void)awi_init(&sc->sc_ic.ic_if);
543 }
544 #endif
545
546 static int
547 awi_init(struct ifnet *ifp)
548 {
549 struct awi_softc *sc = ifp->if_softc;
550 struct ieee80211com *ic = &sc->sc_ic;
551 struct ieee80211_node *ni = ic->ic_bss;
552 struct ieee80211_rateset *rs;
553 int error, rate, i;
554
555 DPRINTF(("awi_init: enabled=%d\n", sc->sc_enabled));
556 if (sc->sc_enabled) {
557 awi_stop(ifp, 0);
558 } else {
559 if (sc->sc_enable)
560 (*sc->sc_enable)(sc);
561 sc->sc_enabled = 1;
562 if ((error = awi_hw_init(sc)) != 0) {
563 if (sc->sc_disable)
564 (*sc->sc_disable)(sc);
565 sc->sc_enabled = 0;
566 return error;
567 }
568 }
569 ic->ic_state = IEEE80211_S_INIT;
570
571 ic->ic_flags &= ~IEEE80211_F_IBSSON;
572 switch (ic->ic_opmode) {
573 case IEEE80211_M_STA:
574 sc->sc_mib_local.Network_Mode = 1;
575 sc->sc_mib_local.Acting_as_AP = 0;
576 break;
577 case IEEE80211_M_IBSS:
578 ic->ic_flags |= IEEE80211_F_IBSSON;
579 /* FALLTHRU */
580 case IEEE80211_M_AHDEMO:
581 sc->sc_mib_local.Network_Mode = 0;
582 sc->sc_mib_local.Acting_as_AP = 0;
583 break;
584 case IEEE80211_M_HOSTAP:
585 sc->sc_mib_local.Network_Mode = 1;
586 sc->sc_mib_local.Acting_as_AP = 1;
587 break;
588 case IEEE80211_M_MONITOR:
589 return ENODEV;
590 }
591 #if 0
592 IEEE80211_ADDR_COPY(ic->ic_myaddr, LLADDR(ifp->if_sadl));
593 #endif
594 memset(&sc->sc_mib_mac.aDesired_ESS_ID, 0, AWI_ESS_ID_SIZE);
595 sc->sc_mib_mac.aDesired_ESS_ID[0] = IEEE80211_ELEMID_SSID;
596 sc->sc_mib_mac.aDesired_ESS_ID[1] = ic->ic_des_esslen;
597 memcpy(&sc->sc_mib_mac.aDesired_ESS_ID[2], ic->ic_des_essid,
598 ic->ic_des_esslen);
599
600 /* configure basic rate */
601 if (ic->ic_phytype == IEEE80211_T_FH)
602 rs = &ic->ic_sup_rates[IEEE80211_MODE_FH];
603 else
604 rs = &ic->ic_sup_rates[IEEE80211_MODE_11B];
605 if (ic->ic_fixed_rate != -1) {
606 rate = rs->rs_rates[ic->ic_fixed_rate] & IEEE80211_RATE_VAL;
607 } else {
608 rate = 0;
609 for (i = 0; i < rs->rs_nrates; i++) {
610 if ((rs->rs_rates[i] & IEEE80211_RATE_BASIC) &&
611 rate < (rs->rs_rates[i] & IEEE80211_RATE_VAL))
612 rate = rs->rs_rates[i] & IEEE80211_RATE_VAL;
613 }
614 }
615 rate *= 5;
616 LE_WRITE_2(&sc->sc_mib_mac.aStation_Basic_Rate, rate);
617
618 if ((error = awi_mode_init(sc)) != 0) {
619 DPRINTF(("awi_init: awi_mode_init failed %d\n", error));
620 awi_stop(ifp, 1);
621 return error;
622 }
623
624 /* start transmitter */
625 sc->sc_txdone = sc->sc_txnext = sc->sc_txbase;
626 awi_write_4(sc, sc->sc_txbase + AWI_TXD_START, 0);
627 awi_write_4(sc, sc->sc_txbase + AWI_TXD_NEXT, 0);
628 awi_write_4(sc, sc->sc_txbase + AWI_TXD_LENGTH, 0);
629 awi_write_1(sc, sc->sc_txbase + AWI_TXD_RATE, 0);
630 awi_write_4(sc, sc->sc_txbase + AWI_TXD_NDA, 0);
631 awi_write_4(sc, sc->sc_txbase + AWI_TXD_NRA, 0);
632 awi_write_1(sc, sc->sc_txbase + AWI_TXD_STATE, 0);
633 awi_write_4(sc, AWI_CA_TX_DATA, sc->sc_txbase);
634 awi_write_4(sc, AWI_CA_TX_MGT, 0);
635 awi_write_4(sc, AWI_CA_TX_BCAST, 0);
636 awi_write_4(sc, AWI_CA_TX_PS, 0);
637 awi_write_4(sc, AWI_CA_TX_CF, 0);
638 if ((error = awi_cmd(sc, AWI_CMD_INIT_TX, AWI_WAIT)) != 0) {
639 DPRINTF(("awi_init: failed to start transmitter: %d\n", error));
640 awi_stop(ifp, 1);
641 return error;
642 }
643
644 /* start receiver */
645 if ((error = awi_cmd(sc, AWI_CMD_INIT_RX, AWI_WAIT)) != 0) {
646 DPRINTF(("awi_init: failed to start receiver: %d\n", error));
647 awi_stop(ifp, 1);
648 return error;
649 }
650 sc->sc_rxdoff = awi_read_4(sc, AWI_CA_IRX_DATA_DESC);
651 sc->sc_rxmoff = awi_read_4(sc, AWI_CA_IRX_PS_DESC);
652
653 ifp->if_flags |= IFF_RUNNING;
654 ifp->if_flags &= ~IFF_OACTIVE;
655 ic->ic_state = IEEE80211_S_INIT;
656
657 if (ic->ic_opmode == IEEE80211_M_AHDEMO ||
658 ic->ic_opmode == IEEE80211_M_HOSTAP) {
659 ni->ni_chan = ic->ic_ibss_chan;
660 ni->ni_intval = ic->ic_lintval;
661 ni->ni_rssi = 0;
662 ni->ni_rstamp = 0;
663 memset(ni->ni_tstamp, 0, sizeof(ni->ni_tstamp));
664 ni->ni_rates =
665 ic->ic_sup_rates[ieee80211_chan2mode(ic, ni->ni_chan)];
666 IEEE80211_ADDR_COPY(ni->ni_macaddr, ic->ic_myaddr);
667 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
668 IEEE80211_ADDR_COPY(ni->ni_bssid, ic->ic_myaddr);
669 ni->ni_esslen = ic->ic_des_esslen;
670 memcpy(ni->ni_essid, ic->ic_des_essid, ni->ni_esslen);
671 ni->ni_capinfo = IEEE80211_CAPINFO_ESS;
672 if (ic->ic_phytype == IEEE80211_T_FH) {
673 ni->ni_fhdwell = 200; /* XXX */
674 ni->ni_fhindex = 1;
675 }
676 } else {
677 ni->ni_capinfo = IEEE80211_CAPINFO_IBSS;
678 memset(ni->ni_bssid, 0, IEEE80211_ADDR_LEN);
679 ni->ni_esslen = 0;
680 }
681 if (ic->ic_flags & IEEE80211_F_PRIVACY)
682 ni->ni_capinfo |= IEEE80211_CAPINFO_PRIVACY;
683 if (ic->ic_opmode != IEEE80211_M_AHDEMO)
684 ic->ic_flags |= IEEE80211_F_SIBSS;
685 ic->ic_state = IEEE80211_S_SCAN; /*XXX*/
686 sc->sc_substate = AWI_ST_NONE;
687 ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
688 } else {
689 /* XXX check sc->sc_cur_chan */
690 ni->ni_chan = &ic->ic_channels[sc->sc_cur_chan];
691 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
692 }
693 return 0;
694 }
695
696 static void
697 awi_stop(struct ifnet *ifp, int disable)
698 {
699 struct awi_softc *sc = ifp->if_softc;
700
701 if (!sc->sc_enabled)
702 return;
703
704 DPRINTF(("awi_stop(%d)\n", disable));
705
706 ieee80211_new_state(&sc->sc_ic, IEEE80211_S_INIT, -1);
707
708 if (!sc->sc_invalid) {
709 if (sc->sc_cmd_inprog)
710 (void)awi_cmd_wait(sc);
711 (void)awi_cmd(sc, AWI_CMD_KILL_RX, AWI_WAIT);
712 sc->sc_cmd_inprog = AWI_CMD_FLUSH_TX;
713 awi_write_1(sc, AWI_CA_FTX_DATA, 1);
714 awi_write_1(sc, AWI_CA_FTX_MGT, 0);
715 awi_write_1(sc, AWI_CA_FTX_BCAST, 0);
716 awi_write_1(sc, AWI_CA_FTX_PS, 0);
717 awi_write_1(sc, AWI_CA_FTX_CF, 0);
718 (void)awi_cmd(sc, AWI_CMD_FLUSH_TX, AWI_WAIT);
719 }
720 ifp->if_flags &= ~(IFF_RUNNING|IFF_OACTIVE);
721 ifp->if_timer = 0;
722 sc->sc_tx_timer = sc->sc_rx_timer = 0;
723 if (sc->sc_rxpend != NULL) {
724 m_freem(sc->sc_rxpend);
725 sc->sc_rxpend = NULL;
726 }
727 IFQ_PURGE(&ifp->if_snd);
728
729 if (disable) {
730 if (!sc->sc_invalid)
731 am79c930_gcr_setbits(&sc->sc_chip,
732 AM79C930_GCR_CORESET);
733 if (sc->sc_disable)
734 (*sc->sc_disable)(sc);
735 sc->sc_enabled = 0;
736 }
737 }
738
739 static void
740 awi_start(struct ifnet *ifp)
741 {
742 struct awi_softc *sc = ifp->if_softc;
743 struct ieee80211com *ic = &sc->sc_ic;
744 struct ieee80211_node *ni;
745 struct ieee80211_frame *wh;
746 struct mbuf *m, *m0;
747 int len, dowep;
748 u_int32_t txd, frame, ntxd;
749 u_int8_t rate;
750
751 if (!sc->sc_enabled || sc->sc_invalid)
752 return;
753
754 for (;;) {
755 txd = sc->sc_txnext;
756 IF_POLL(&ic->ic_mgtq, m0);
757 dowep = 0;
758 if (m0 != NULL) {
759 len = m0->m_pkthdr.len;
760 if (awi_next_txd(sc, len, &frame, &ntxd)) {
761 ifp->if_flags |= IFF_OACTIVE;
762 break;
763 }
764 IF_DEQUEUE(&ic->ic_mgtq, m0);
765 } else {
766 if (ic->ic_state != IEEE80211_S_RUN)
767 break;
768 IFQ_POLL(&ifp->if_snd, m0);
769 if (m0 == NULL)
770 break;
771 /*
772 * Need to calculate the real length to determine
773 * if the transmit buffer has a room for the packet.
774 */
775 len = m0->m_pkthdr.len + sizeof(struct ieee80211_frame);
776 if (!(ifp->if_flags & IFF_LINK0) && !sc->sc_adhoc_ap)
777 len += sizeof(struct llc) -
778 sizeof(struct ether_header);
779 if (ic->ic_flags & IEEE80211_F_PRIVACY) {
780 dowep = 1;
781 len += IEEE80211_WEP_IVLEN +
782 IEEE80211_WEP_KIDLEN + IEEE80211_WEP_CRCLEN;
783 }
784 if (awi_next_txd(sc, len, &frame, &ntxd)) {
785 ifp->if_flags |= IFF_OACTIVE;
786 break;
787 }
788 IFQ_DEQUEUE(&ifp->if_snd, m0);
789 ifp->if_opackets++;
790 #if NBPFILTER > 0
791 if (ifp->if_bpf)
792 bpf_mtap(ifp->if_bpf, m0);
793 #endif
794 if ((ifp->if_flags & IFF_LINK0) || sc->sc_adhoc_ap)
795 m0 = awi_ether_encap(sc, m0);
796 else
797 m0 = ieee80211_encap(ifp, m0, &ni);
798 if (m0 == NULL) {
799 ifp->if_oerrors++;
800 continue;
801 }
802 if (ni != NULL)
803 ieee80211_release_node(ic, ni);
804 wh = mtod(m0, struct ieee80211_frame *);
805 if (!IEEE80211_IS_MULTICAST(wh->i_addr1) &&
806 (ic->ic_opmode == IEEE80211_M_HOSTAP ||
807 ic->ic_opmode == IEEE80211_M_IBSS) &&
808 sc->sc_adhoc_ap == 0 &&
809 (ifp->if_flags & IFF_LINK0) == 0 &&
810 (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
811 IEEE80211_FC0_TYPE_DATA && ni == NULL) {
812 m_freem(m0);
813 ifp->if_oerrors++;
814 continue;
815 }
816 }
817 #if NBPFILTER > 0
818 if (ic->ic_rawbpf)
819 bpf_mtap(ic->ic_rawbpf, m0);
820 #endif
821 if (dowep) {
822 if ((m0 = ieee80211_wep_crypt(ifp, m0, 1)) == NULL) {
823 ifp->if_oerrors++;
824 continue;
825 }
826 }
827 #ifdef DIAGNOSTIC
828 if (m0->m_pkthdr.len != len) {
829 printf("%s: length %d should be %d\n",
830 ic->ic_if.if_xname, m0->m_pkthdr.len, len);
831 m_freem(m0);
832 ifp->if_oerrors++;
833 continue;
834 }
835 #endif
836
837 if ((ifp->if_flags & IFF_DEBUG) && (ifp->if_flags & IFF_LINK2))
838 ieee80211_dump_pkt(m0->m_data, m0->m_len,
839 ic->ic_bss->ni_rates.
840 rs_rates[ic->ic_bss->ni_txrate] &
841 IEEE80211_RATE_VAL, -1);
842
843 for (m = m0, len = 0; m != NULL; m = m->m_next) {
844 awi_write_bytes(sc, frame + len, mtod(m, u_int8_t *),
845 m->m_len);
846 len += m->m_len;
847 }
848 m_freem(m0);
849 rate = (ic->ic_bss->ni_rates.rs_rates[ic->ic_bss->ni_txrate] &
850 IEEE80211_RATE_VAL) * 5;
851 awi_write_1(sc, ntxd + AWI_TXD_STATE, 0);
852 awi_write_4(sc, txd + AWI_TXD_START, frame);
853 awi_write_4(sc, txd + AWI_TXD_NEXT, ntxd);
854 awi_write_4(sc, txd + AWI_TXD_LENGTH, len);
855 awi_write_1(sc, txd + AWI_TXD_RATE, rate);
856 awi_write_4(sc, txd + AWI_TXD_NDA, 0);
857 awi_write_4(sc, txd + AWI_TXD_NRA, 0);
858 awi_write_1(sc, txd + AWI_TXD_STATE, AWI_TXD_ST_OWN);
859 sc->sc_txnext = ntxd;
860
861 sc->sc_tx_timer = 5;
862 ifp->if_timer = 1;
863 }
864 }
865
866 static void
867 awi_watchdog(struct ifnet *ifp)
868 {
869 struct awi_softc *sc = ifp->if_softc;
870 u_int32_t prevdone;
871 int ocansleep;
872
873 ifp->if_timer = 0;
874 if (!sc->sc_enabled || sc->sc_invalid)
875 return;
876
877 ocansleep = sc->sc_cansleep;
878 sc->sc_cansleep = 0;
879 if (sc->sc_tx_timer) {
880 if (--sc->sc_tx_timer == 0) {
881 printf("%s: device timeout\n", ifp->if_xname);
882 prevdone = sc->sc_txdone;
883 awi_tx_int(sc);
884 if (sc->sc_txdone == prevdone) {
885 ifp->if_oerrors++;
886 awi_init(ifp);
887 goto out;
888 }
889 }
890 ifp->if_timer = 1;
891 }
892 if (sc->sc_rx_timer) {
893 if (--sc->sc_rx_timer == 0) {
894 if (sc->sc_ic.ic_state == IEEE80211_S_RUN) {
895 ieee80211_new_state(&sc->sc_ic,
896 IEEE80211_S_SCAN, -1);
897 goto out;
898 }
899 } else
900 ifp->if_timer = 1;
901 }
902 /* TODO: rate control */
903 ieee80211_watchdog(ifp);
904 out:
905 sc->sc_cansleep = ocansleep;
906 }
907
908 static int
909 awi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
910 {
911 struct awi_softc *sc = ifp->if_softc;
912 struct ifreq *ifr = (struct ifreq *)data;
913 int s, error;
914
915 s = splnet();
916 /* serialize ioctl, since we may sleep */
917 if ((error = awi_lock(sc)) != 0)
918 goto cantlock;
919
920 switch (cmd) {
921 case SIOCSIFFLAGS:
922 if (ifp->if_flags & IFF_UP) {
923 if (sc->sc_enabled) {
924 /*
925 * To avoid rescanning another access point,
926 * do not call awi_init() here. Instead,
927 * only reflect promisc mode settings.
928 */
929 error = awi_mode_init(sc);
930 } else
931 error = awi_init(ifp);
932 } else if (sc->sc_enabled)
933 awi_stop(ifp, 1);
934 break;
935 case SIOCSIFMEDIA:
936 case SIOCGIFMEDIA:
937 error = ifmedia_ioctl(ifp, ifr, &sc->sc_ic.ic_media, cmd);
938 break;
939 case SIOCADDMULTI:
940 case SIOCDELMULTI:
941 #ifdef __FreeBSD__
942 error = ENETRESET; /* XXX */
943 #else
944 error = (cmd == SIOCADDMULTI) ?
945 ether_addmulti(ifr, &sc->sc_ic.ic_ec) :
946 ether_delmulti(ifr, &sc->sc_ic.ic_ec);
947 #endif
948 if (error == ENETRESET) {
949 /* do not rescan */
950 if (ifp->if_flags & IFF_RUNNING)
951 error = awi_mode_init(sc);
952 else
953 error = 0;
954 }
955 break;
956 default:
957 error = ieee80211_ioctl(ifp, cmd, data);
958 if (error == ENETRESET) {
959 if (sc->sc_enabled)
960 error = awi_init(ifp);
961 else
962 error = 0;
963 }
964 break;
965 }
966 awi_unlock(sc);
967 cantlock:
968 splx(s);
969 return error;
970 }
971
972 /*
973 * Called from ifmedia_ioctl via awi_ioctl with lock obtained.
974 *
975 * TBD factor with ieee80211_media_change
976 */
977 static int
978 awi_media_change(struct ifnet *ifp)
979 {
980 struct awi_softc *sc = ifp->if_softc;
981 struct ieee80211com *ic = &sc->sc_ic;
982 struct ifmedia_entry *ime;
983 enum ieee80211_opmode newmode;
984 int i, rate, newadhoc_ap, error = 0;
985
986 ime = ic->ic_media.ifm_cur;
987 if (IFM_SUBTYPE(ime->ifm_media) == IFM_AUTO) {
988 i = -1;
989 } else {
990 struct ieee80211_rateset *rs =
991 &ic->ic_sup_rates[(ic->ic_phytype == IEEE80211_T_FH)
992 ? IEEE80211_MODE_FH : IEEE80211_MODE_11B];
993 rate = ieee80211_media2rate(ime->ifm_media);
994 if (rate == 0)
995 return EINVAL;
996 for (i = 0; i < rs->rs_nrates; i++) {
997 if ((rs->rs_rates[i] & IEEE80211_RATE_VAL) == rate)
998 break;
999 }
1000 if (i == rs->rs_nrates)
1001 return EINVAL;
1002 }
1003 if (ic->ic_fixed_rate != i) {
1004 ic->ic_fixed_rate = i;
1005 error = ENETRESET;
1006 }
1007
1008 /*
1009 * combination of mediaopt
1010 *
1011 * hostap adhoc flag0 opmode adhoc_ap comment
1012 * + - - HOSTAP 0 HostAP
1013 * - + - IBSS 0 IBSS
1014 * - + + AHDEMO 0 WaveLAN adhoc
1015 * - - + IBSS 1 Melco old Sta
1016 * also LINK0
1017 * - - - STA 0 Infra Station
1018 */
1019 newadhoc_ap = 0;
1020 if (ime->ifm_media & IFM_IEEE80211_HOSTAP)
1021 newmode = IEEE80211_M_HOSTAP;
1022 else if (ime->ifm_media & IFM_IEEE80211_ADHOC) {
1023 if (ic->ic_phytype == IEEE80211_T_DS &&
1024 (ime->ifm_media & IFM_FLAG0))
1025 newmode = IEEE80211_M_AHDEMO;
1026 else
1027 newmode = IEEE80211_M_IBSS;
1028 } else if (ime->ifm_media & IFM_FLAG0) {
1029 newmode = IEEE80211_M_IBSS;
1030 newadhoc_ap = 1;
1031 } else
1032 newmode = IEEE80211_M_STA;
1033 if (ic->ic_opmode != newmode || sc->sc_adhoc_ap != newadhoc_ap) {
1034 ic->ic_opmode = newmode;
1035 sc->sc_adhoc_ap = newadhoc_ap;
1036 error = ENETRESET;
1037 }
1038
1039 if (error == ENETRESET) {
1040 if (sc->sc_enabled)
1041 error = awi_init(ifp);
1042 else
1043 error = 0;
1044 }
1045 return error;
1046 }
1047
1048 static void
1049 awi_media_status(struct ifnet *ifp, struct ifmediareq *imr)
1050 {
1051 struct awi_softc *sc = ifp->if_softc;
1052 struct ieee80211com *ic = &sc->sc_ic;
1053 int rate;
1054 enum ieee80211_phymode mode;
1055
1056 imr->ifm_status = IFM_AVALID;
1057 if (ic->ic_state == IEEE80211_S_RUN)
1058 imr->ifm_status |= IFM_ACTIVE;
1059 imr->ifm_active = IFM_IEEE80211;
1060 if (ic->ic_phytype == IEEE80211_T_FH)
1061 mode = IEEE80211_MODE_FH;
1062 else
1063 mode = IEEE80211_MODE_11B;
1064 if (ic->ic_state == IEEE80211_S_RUN) {
1065 rate = ic->ic_bss->ni_rates.rs_rates[ic->ic_bss->ni_txrate] &
1066 IEEE80211_RATE_VAL;
1067 } else {
1068 if (ic->ic_fixed_rate == -1)
1069 rate = 0;
1070 else
1071 rate = ic->ic_sup_rates[mode].
1072 rs_rates[ic->ic_fixed_rate] & IEEE80211_RATE_VAL;
1073 }
1074 imr->ifm_active |= ieee80211_rate2media(ic, rate, mode);
1075 switch (ic->ic_opmode) {
1076 case IEEE80211_M_MONITOR: /* we should never reach here */
1077 break;
1078 case IEEE80211_M_STA:
1079 break;
1080 case IEEE80211_M_IBSS:
1081 if (sc->sc_adhoc_ap)
1082 imr->ifm_active |= IFM_FLAG0;
1083 else
1084 imr->ifm_active |= IFM_IEEE80211_ADHOC;
1085 break;
1086 case IEEE80211_M_AHDEMO:
1087 imr->ifm_active |= IFM_IEEE80211_ADHOC | IFM_FLAG0;
1088 break;
1089 case IEEE80211_M_HOSTAP:
1090 imr->ifm_active |= IFM_IEEE80211_HOSTAP;
1091 break;
1092 }
1093 }
1094
1095 static int
1096 awi_mode_init(struct awi_softc *sc)
1097 {
1098 struct ifnet *ifp = &sc->sc_ic.ic_if;
1099 int n, error;
1100 #ifdef __FreeBSD__
1101 struct ifmultiaddr *ifma;
1102 #else
1103 struct ether_multi *enm;
1104 struct ether_multistep step;
1105 #endif
1106
1107 /* reinitialize muticast filter */
1108 n = 0;
1109 sc->sc_mib_local.Accept_All_Multicast_Dis = 0;
1110 if (sc->sc_ic.ic_opmode != IEEE80211_M_HOSTAP &&
1111 (ifp->if_flags & IFF_PROMISC)) {
1112 sc->sc_mib_mac.aPromiscuous_Enable = 1;
1113 goto set_mib;
1114 }
1115 sc->sc_mib_mac.aPromiscuous_Enable = 0;
1116 #ifdef __FreeBSD__
1117 if (ifp->if_amcount != 0)
1118 goto set_mib;
1119 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1120 if (ifma->ifma_addr->sa_family != AF_LINK)
1121 continue;
1122 if (n == AWI_GROUP_ADDR_SIZE)
1123 goto set_mib;
1124 IEEE80211_ADDR_COPY(sc->sc_mib_addr.aGroup_Addresses[n],
1125 LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1126 n++;
1127 }
1128 #else
1129 ETHER_FIRST_MULTI(step, &sc->sc_ic.ic_ec, enm);
1130 while (enm != NULL) {
1131 if (n == AWI_GROUP_ADDR_SIZE ||
1132 !IEEE80211_ADDR_EQ(enm->enm_addrlo, enm->enm_addrhi))
1133 goto set_mib;
1134 IEEE80211_ADDR_COPY(sc->sc_mib_addr.aGroup_Addresses[n],
1135 enm->enm_addrlo);
1136 n++;
1137 ETHER_NEXT_MULTI(step, enm);
1138 }
1139 #endif
1140 for (; n < AWI_GROUP_ADDR_SIZE; n++)
1141 memset(sc->sc_mib_addr.aGroup_Addresses[n], 0,
1142 IEEE80211_ADDR_LEN);
1143 sc->sc_mib_local.Accept_All_Multicast_Dis = 1;
1144
1145 set_mib:
1146 if (sc->sc_mib_local.Accept_All_Multicast_Dis)
1147 ifp->if_flags &= ~IFF_ALLMULTI;
1148 else
1149 ifp->if_flags |= IFF_ALLMULTI;
1150 sc->sc_mib_mgt.Wep_Required =
1151 (sc->sc_ic.ic_flags & IEEE80211_F_PRIVACY) ? AWI_WEP_ON : AWI_WEP_OFF;
1152
1153 if ((error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_LOCAL, AWI_WAIT)) ||
1154 (error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_ADDR, AWI_WAIT)) ||
1155 (error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_MAC, AWI_WAIT)) ||
1156 (error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_MGT, AWI_WAIT)) ||
1157 (error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_PHY, AWI_WAIT))) {
1158 DPRINTF(("awi_mode_init: MIB set failed: %d\n", error));
1159 return error;
1160 }
1161 return 0;
1162 }
1163
1164 static void
1165 awi_rx_int(struct awi_softc *sc)
1166 {
1167 struct ieee80211com *ic = &sc->sc_ic;
1168 struct ifnet *ifp = &ic->ic_if;
1169 struct ieee80211_frame *wh;
1170 struct ieee80211_node *ni;
1171 u_int8_t state, rate, rssi;
1172 u_int16_t len;
1173 u_int32_t frame, next, rstamp, rxoff;
1174 struct mbuf *m;
1175
1176 rxoff = sc->sc_rxdoff;
1177 for (;;) {
1178 state = awi_read_1(sc, rxoff + AWI_RXD_HOST_DESC_STATE);
1179 if (state & AWI_RXD_ST_OWN)
1180 break;
1181 if (!(state & AWI_RXD_ST_CONSUMED)) {
1182 if (sc->sc_substate != AWI_ST_NONE)
1183 goto rx_next;
1184 if (state & AWI_RXD_ST_RXERROR) {
1185 ifp->if_ierrors++;
1186 goto rx_next;
1187 }
1188 len = awi_read_2(sc, rxoff + AWI_RXD_LEN);
1189 rate = awi_read_1(sc, rxoff + AWI_RXD_RATE);
1190 rssi = awi_read_1(sc, rxoff + AWI_RXD_RSSI);
1191 frame = awi_read_4(sc, rxoff + AWI_RXD_START_FRAME) &
1192 0x7fff;
1193 rstamp = awi_read_4(sc, rxoff + AWI_RXD_LOCALTIME);
1194 m = awi_devget(sc, frame, len);
1195 if (m == NULL) {
1196 ifp->if_ierrors++;
1197 goto rx_next;
1198 }
1199 if (state & AWI_RXD_ST_LF) {
1200 /* TODO check my bss */
1201 if (!(sc->sc_ic.ic_flags & IEEE80211_F_SIBSS) &&
1202 sc->sc_ic.ic_state == IEEE80211_S_RUN) {
1203 sc->sc_rx_timer = 10;
1204 ifp->if_timer = 1;
1205 }
1206 if ((ifp->if_flags & IFF_DEBUG) &&
1207 (ifp->if_flags & IFF_LINK2))
1208 ieee80211_dump_pkt(m->m_data, m->m_len,
1209 rate / 5, rssi);
1210 if ((ifp->if_flags & IFF_LINK0) ||
1211 sc->sc_adhoc_ap)
1212 m = awi_ether_modcap(sc, m);
1213 else
1214 m = m_pullup(m, sizeof(*wh));
1215 if (m == NULL) {
1216 ifp->if_ierrors++;
1217 goto rx_next;
1218 }
1219 wh = mtod(m, struct ieee80211_frame *);
1220 ni = ieee80211_find_rxnode(ic, wh);
1221 ieee80211_input(ifp, m, ni, rssi, rstamp);
1222 /*
1223 * The frame may have caused the
1224 * node to be marked for reclamation
1225 * (e.g. in response to a DEAUTH
1226 * message) so use release_node here
1227 * instead of unref_node.
1228 */
1229 ieee80211_release_node(ic, ni);
1230 } else
1231 sc->sc_rxpend = m;
1232 rx_next:
1233 state |= AWI_RXD_ST_CONSUMED;
1234 awi_write_1(sc, rxoff + AWI_RXD_HOST_DESC_STATE, state);
1235 }
1236 next = awi_read_4(sc, rxoff + AWI_RXD_NEXT);
1237 if (next & AWI_RXD_NEXT_LAST)
1238 break;
1239 /* make sure the next pointer is correct */
1240 if (next != awi_read_4(sc, rxoff + AWI_RXD_NEXT))
1241 break;
1242 state |= AWI_RXD_ST_OWN;
1243 awi_write_1(sc, rxoff + AWI_RXD_HOST_DESC_STATE, state);
1244 rxoff = next & 0x7fff;
1245 }
1246 sc->sc_rxdoff = rxoff;
1247 }
1248
1249 static void
1250 awi_tx_int(struct awi_softc *sc)
1251 {
1252 struct ifnet *ifp = &sc->sc_ic.ic_if;
1253 u_int8_t flags;
1254
1255 while (sc->sc_txdone != sc->sc_txnext) {
1256 flags = awi_read_1(sc, sc->sc_txdone + AWI_TXD_STATE);
1257 if ((flags & AWI_TXD_ST_OWN) || !(flags & AWI_TXD_ST_DONE))
1258 break;
1259 if (flags & AWI_TXD_ST_ERROR)
1260 ifp->if_oerrors++;
1261 sc->sc_txdone = awi_read_4(sc, sc->sc_txdone + AWI_TXD_NEXT) &
1262 0x7fff;
1263 }
1264 DPRINTF2(("awi_txint: txdone %d txnext %d txbase %d txend %d\n",
1265 sc->sc_txdone, sc->sc_txnext, sc->sc_txbase, sc->sc_txend));
1266 sc->sc_tx_timer = 0;
1267 ifp->if_flags &= ~IFF_OACTIVE;
1268 awi_start(ifp);
1269 }
1270
1271 static struct mbuf *
1272 awi_devget(struct awi_softc *sc, u_int32_t off, u_int16_t len)
1273 {
1274 struct ifnet *ifp = &sc->sc_ic.ic_if;
1275 struct mbuf *m;
1276 struct mbuf *top, **mp;
1277 u_int tlen;
1278
1279 top = sc->sc_rxpend;
1280 mp = ⊤
1281 if (top != NULL) {
1282 sc->sc_rxpend = NULL;
1283 top->m_pkthdr.len += len;
1284 m = top;
1285 while (*mp != NULL) {
1286 m = *mp;
1287 mp = &m->m_next;
1288 }
1289 if (m->m_flags & M_EXT)
1290 tlen = m->m_ext.ext_size;
1291 else if (m->m_flags & M_PKTHDR)
1292 tlen = MHLEN;
1293 else
1294 tlen = MLEN;
1295 tlen -= m->m_len;
1296 if (tlen > len)
1297 tlen = len;
1298 awi_read_bytes(sc, off, mtod(m, u_int8_t *) + m->m_len, tlen);
1299 off += tlen;
1300 len -= tlen;
1301 }
1302
1303 while (len > 0) {
1304 if (top == NULL) {
1305 MGETHDR(m, M_DONTWAIT, MT_DATA);
1306 if (m == NULL)
1307 return NULL;
1308 m->m_pkthdr.rcvif = ifp;
1309 m->m_pkthdr.len = len;
1310 m->m_len = MHLEN;
1311 m->m_flags |= M_HASFCS;
1312 } else {
1313 MGET(m, M_DONTWAIT, MT_DATA);
1314 if (m == NULL) {
1315 m_freem(top);
1316 return NULL;
1317 }
1318 m->m_len = MLEN;
1319 }
1320 if (len >= MINCLSIZE) {
1321 MCLGET(m, M_DONTWAIT);
1322 if (m->m_flags & M_EXT)
1323 m->m_len = m->m_ext.ext_size;
1324 }
1325 if (top == NULL) {
1326 int hdrlen = sizeof(struct ieee80211_frame) +
1327 sizeof(struct llc);
1328 caddr_t newdata = (caddr_t)
1329 ALIGN(m->m_data + hdrlen) - hdrlen;
1330 m->m_len -= newdata - m->m_data;
1331 m->m_data = newdata;
1332 }
1333 if (m->m_len > len)
1334 m->m_len = len;
1335 awi_read_bytes(sc, off, mtod(m, u_int8_t *), m->m_len);
1336 off += m->m_len;
1337 len -= m->m_len;
1338 *mp = m;
1339 mp = &m->m_next;
1340 }
1341 return top;
1342 }
1343
1344 /*
1345 * Initialize hardware and start firmware to accept commands.
1346 * Called everytime after power on firmware.
1347 */
1348
1349 static int
1350 awi_hw_init(struct awi_softc *sc)
1351 {
1352 u_int8_t status;
1353 u_int16_t intmask;
1354 int i, error;
1355
1356 sc->sc_enab_intr = 0;
1357 sc->sc_invalid = 0; /* XXX: really? */
1358 awi_drvstate(sc, AWI_DRV_RESET);
1359
1360 /* reset firmware */
1361 am79c930_gcr_setbits(&sc->sc_chip, AM79C930_GCR_CORESET);
1362 DELAY(100);
1363 awi_write_1(sc, AWI_SELFTEST, 0);
1364 awi_write_1(sc, AWI_CMD, 0);
1365 awi_write_1(sc, AWI_BANNER, 0);
1366 am79c930_gcr_clearbits(&sc->sc_chip, AM79C930_GCR_CORESET);
1367 DELAY(100);
1368
1369 /* wait for selftest completion */
1370 for (i = 0; ; i++) {
1371 if (sc->sc_invalid)
1372 return ENXIO;
1373 if (i >= AWI_SELFTEST_TIMEOUT*hz/1000) {
1374 printf("%s: failed to complete selftest (timeout)\n",
1375 sc->sc_ic.ic_if.if_xname);
1376 return ENXIO;
1377 }
1378 status = awi_read_1(sc, AWI_SELFTEST);
1379 if ((status & 0xf0) == 0xf0)
1380 break;
1381 if (sc->sc_cansleep) {
1382 sc->sc_sleep_cnt++;
1383 (void)tsleep(sc, PWAIT, "awitst", 1);
1384 sc->sc_sleep_cnt--;
1385 } else {
1386 DELAY(1000*1000/hz);
1387 }
1388 }
1389 if (status != AWI_SELFTEST_PASSED) {
1390 printf("%s: failed to complete selftest (code %x)\n",
1391 sc->sc_ic.ic_if.if_xname, status);
1392 return ENXIO;
1393 }
1394
1395 /* check banner to confirm firmware write it */
1396 awi_read_bytes(sc, AWI_BANNER, sc->sc_banner, AWI_BANNER_LEN);
1397 if (memcmp(sc->sc_banner, "PCnetMobile:", 12) != 0) {
1398 printf("%s: failed to complete selftest (bad banner)\n",
1399 sc->sc_ic.ic_if.if_xname);
1400 for (i = 0; i < AWI_BANNER_LEN; i++)
1401 printf("%s%02x", i ? ":" : "\t", sc->sc_banner[i]);
1402 printf("\n");
1403 return ENXIO;
1404 }
1405
1406 /* initializing interrupt */
1407 sc->sc_enab_intr = 1;
1408 error = awi_intr_lock(sc);
1409 if (error)
1410 return error;
1411 intmask = AWI_INT_GROGGY | AWI_INT_SCAN_CMPLT |
1412 AWI_INT_TX | AWI_INT_RX | AWI_INT_CMD;
1413 awi_write_1(sc, AWI_INTMASK, ~intmask & 0xff);
1414 awi_write_1(sc, AWI_INTMASK2, 0);
1415 awi_write_1(sc, AWI_INTSTAT, 0);
1416 awi_write_1(sc, AWI_INTSTAT2, 0);
1417 awi_intr_unlock(sc);
1418 am79c930_gcr_setbits(&sc->sc_chip, AM79C930_GCR_ENECINT);
1419
1420 /* issuing interface test command */
1421 error = awi_cmd(sc, AWI_CMD_NOP, AWI_WAIT);
1422 if (error) {
1423 printf("%s: failed to complete selftest",
1424 sc->sc_ic.ic_if.if_xname);
1425 if (error == ENXIO)
1426 printf(" (no hardware)\n");
1427 else if (error != EWOULDBLOCK)
1428 printf(" (error %d)\n", error);
1429 else if (sc->sc_cansleep)
1430 printf(" (lost interrupt)\n");
1431 else
1432 printf(" (command timeout)\n");
1433 return error;
1434 }
1435
1436 /* Initialize VBM */
1437 awi_write_1(sc, AWI_VBM_OFFSET, 0);
1438 awi_write_1(sc, AWI_VBM_LENGTH, 1);
1439 awi_write_1(sc, AWI_VBM_BITMAP, 0);
1440 return 0;
1441 }
1442
1443 /*
1444 * Extract the factory default MIB value from firmware and assign the driver
1445 * default value.
1446 * Called once at attaching the interface.
1447 */
1448
1449 static int
1450 awi_init_mibs(struct awi_softc *sc)
1451 {
1452 int chan, i, error;
1453 struct ieee80211com *ic = &sc->sc_ic;
1454 struct awi_chanset *cs;
1455
1456 if ((error = awi_mib(sc, AWI_CMD_GET_MIB, AWI_MIB_LOCAL, AWI_WAIT)) ||
1457 (error = awi_mib(sc, AWI_CMD_GET_MIB, AWI_MIB_ADDR, AWI_WAIT)) ||
1458 (error = awi_mib(sc, AWI_CMD_GET_MIB, AWI_MIB_MAC, AWI_WAIT)) ||
1459 (error = awi_mib(sc, AWI_CMD_GET_MIB, AWI_MIB_MGT, AWI_WAIT)) ||
1460 (error = awi_mib(sc, AWI_CMD_GET_MIB, AWI_MIB_PHY, AWI_WAIT))) {
1461 printf("%s: failed to get default mib value (error %d)\n",
1462 ic->ic_if.if_xname, error);
1463 return error;
1464 }
1465
1466 memset(&sc->sc_ic.ic_chan_avail, 0, sizeof(sc->sc_ic.ic_chan_avail));
1467 for (cs = awi_chanset; ; cs++) {
1468 if (cs->cs_type == 0) {
1469 printf("%s: failed to set available channel\n",
1470 ic->ic_if.if_xname);
1471 return ENXIO;
1472 }
1473 if (cs->cs_type == sc->sc_mib_phy.IEEE_PHY_Type &&
1474 cs->cs_region == sc->sc_mib_phy.aCurrent_Reg_Domain)
1475 break;
1476 }
1477 if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH) {
1478 for (i = cs->cs_min; i <= cs->cs_max; i++) {
1479 chan = IEEE80211_FH_CHAN(i % 3 + 1, i);
1480 setbit(sc->sc_ic.ic_chan_avail, chan);
1481 /* XXX for FHSS, does frequency matter? */
1482 ic->ic_channels[chan].ic_freq = 0;
1483 ic->ic_channels[chan].ic_flags = IEEE80211_CHAN_FHSS;
1484 /*
1485 * According to the IEEE 802.11 specification,
1486 * hop pattern parameter for FH phy should be
1487 * incremented by 3 for given hop chanset, i.e.,
1488 * the chanset parameter is calculated for given
1489 * hop patter. However, BayStack 650 Access Points
1490 * apparently use fixed hop chanset parameter value
1491 * 1 for any hop pattern. So we also try this
1492 * combination of hop chanset and pattern.
1493 */
1494 chan = IEEE80211_FH_CHAN(1, i);
1495 setbit(sc->sc_ic.ic_chan_avail, chan);
1496 ic->ic_channels[chan].ic_freq = 0; /* XXX */
1497 ic->ic_channels[chan].ic_flags = IEEE80211_CHAN_FHSS;
1498 }
1499 } else {
1500 for (i = cs->cs_min; i <= cs->cs_max; i++) {
1501 setbit(sc->sc_ic.ic_chan_avail, i);
1502 ic->ic_channels[i].ic_freq =
1503 ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
1504 ic->ic_channels[i].ic_flags = IEEE80211_CHAN_B;
1505 }
1506 }
1507 sc->sc_cur_chan = cs->cs_def;
1508 ic->ic_ibss_chan = &ic->ic_channels[cs->cs_def];
1509
1510 sc->sc_mib_local.Fragmentation_Dis = 1;
1511 sc->sc_mib_local.Add_PLCP_Dis = 0;
1512 sc->sc_mib_local.MAC_Hdr_Prsv = 0;
1513 sc->sc_mib_local.Rx_Mgmt_Que_En = 0;
1514 sc->sc_mib_local.Re_Assembly_Dis = 1;
1515 sc->sc_mib_local.Strip_PLCP_Dis = 0;
1516 sc->sc_mib_local.Power_Saving_Mode_Dis = 1;
1517 sc->sc_mib_local.Accept_All_Multicast_Dis = 1;
1518 sc->sc_mib_local.Check_Seq_Cntl_Dis = 0;
1519 sc->sc_mib_local.Flush_CFP_Queue_On_CF_End = 0;
1520 sc->sc_mib_local.Network_Mode = 1;
1521 sc->sc_mib_local.PWD_Lvl = 0;
1522 sc->sc_mib_local.CFP_Mode = 0;
1523
1524 /* allocate buffers */
1525 sc->sc_txbase = AWI_BUFFERS;
1526 sc->sc_txend = sc->sc_txbase +
1527 (AWI_TXD_SIZE + sizeof(struct ieee80211_frame) +
1528 sizeof(struct ether_header) + ETHERMTU) * AWI_NTXBUFS;
1529 LE_WRITE_4(&sc->sc_mib_local.Tx_Buffer_Offset, sc->sc_txbase);
1530 LE_WRITE_4(&sc->sc_mib_local.Tx_Buffer_Size,
1531 sc->sc_txend - sc->sc_txbase);
1532 LE_WRITE_4(&sc->sc_mib_local.Rx_Buffer_Offset, sc->sc_txend);
1533 LE_WRITE_4(&sc->sc_mib_local.Rx_Buffer_Size,
1534 AWI_BUFFERS_END - sc->sc_txend);
1535 sc->sc_mib_local.Acting_as_AP = 0;
1536 sc->sc_mib_local.Fill_CFP = 0;
1537
1538 memset(&sc->sc_mib_mac.aDesired_ESS_ID, 0, AWI_ESS_ID_SIZE);
1539 sc->sc_mib_mac.aDesired_ESS_ID[0] = IEEE80211_ELEMID_SSID;
1540
1541 sc->sc_mib_mgt.aPower_Mgt_Mode = 0;
1542 sc->sc_mib_mgt.aDTIM_Period = 1;
1543 LE_WRITE_2(&sc->sc_mib_mgt.aATIM_Window, 0);
1544 return 0;
1545 }
1546
1547 static int
1548 awi_mib(struct awi_softc *sc, u_int8_t cmd, u_int8_t mib, int wflag)
1549 {
1550 int error;
1551 u_int8_t size, *ptr;
1552
1553 switch (mib) {
1554 case AWI_MIB_LOCAL:
1555 ptr = (u_int8_t *)&sc->sc_mib_local;
1556 size = sizeof(sc->sc_mib_local);
1557 break;
1558 case AWI_MIB_ADDR:
1559 ptr = (u_int8_t *)&sc->sc_mib_addr;
1560 size = sizeof(sc->sc_mib_addr);
1561 break;
1562 case AWI_MIB_MAC:
1563 ptr = (u_int8_t *)&sc->sc_mib_mac;
1564 size = sizeof(sc->sc_mib_mac);
1565 break;
1566 case AWI_MIB_STAT:
1567 ptr = (u_int8_t *)&sc->sc_mib_stat;
1568 size = sizeof(sc->sc_mib_stat);
1569 break;
1570 case AWI_MIB_MGT:
1571 ptr = (u_int8_t *)&sc->sc_mib_mgt;
1572 size = sizeof(sc->sc_mib_mgt);
1573 break;
1574 case AWI_MIB_PHY:
1575 ptr = (u_int8_t *)&sc->sc_mib_phy;
1576 size = sizeof(sc->sc_mib_phy);
1577 break;
1578 default:
1579 return EINVAL;
1580 }
1581 if (sc->sc_cmd_inprog) {
1582 if ((error = awi_cmd_wait(sc)) != 0) {
1583 if (error == EWOULDBLOCK)
1584 DPRINTF(("awi_mib: cmd %d inprog",
1585 sc->sc_cmd_inprog));
1586 return error;
1587 }
1588 }
1589 sc->sc_cmd_inprog = cmd;
1590 if (cmd == AWI_CMD_SET_MIB)
1591 awi_write_bytes(sc, AWI_CA_MIB_DATA, ptr, size);
1592 awi_write_1(sc, AWI_CA_MIB_TYPE, mib);
1593 awi_write_1(sc, AWI_CA_MIB_SIZE, size);
1594 awi_write_1(sc, AWI_CA_MIB_INDEX, 0);
1595 if ((error = awi_cmd(sc, cmd, wflag)) != 0)
1596 return error;
1597 if (cmd == AWI_CMD_GET_MIB) {
1598 awi_read_bytes(sc, AWI_CA_MIB_DATA, ptr, size);
1599 #ifdef AWI_DEBUG
1600 if (awi_debug) {
1601 int i;
1602
1603 printf("awi_mib: #%d:", mib);
1604 for (i = 0; i < size; i++)
1605 printf(" %02x", ptr[i]);
1606 printf("\n");
1607 }
1608 #endif
1609 }
1610 return 0;
1611 }
1612
1613 static int
1614 awi_cmd(struct awi_softc *sc, u_int8_t cmd, int wflag)
1615 {
1616 u_int8_t status;
1617 int error = 0;
1618 #ifdef AWI_DEBUG
1619 static const char *cmdname[] = {
1620 "IDLE", "NOP", "SET_MIB", "INIT_TX", "FLUSH_TX", "INIT_RX",
1621 "KILL_RX", "SLEEP", "WAKE", "GET_MIB", "SCAN", "SYNC", "RESUME"
1622 };
1623 #endif
1624
1625 #ifdef AWI_DEBUG
1626 if (awi_debug > 1) {
1627 if (cmd >= sizeof(cmdname)/sizeof(cmdname[0]))
1628 printf("awi_cmd: #%d", cmd);
1629 else
1630 printf("awi_cmd: %s", cmdname[cmd]);
1631 printf(" %s\n", wflag == AWI_NOWAIT ? "nowait" : "wait");
1632 }
1633 #endif
1634 sc->sc_cmd_inprog = cmd;
1635 awi_write_1(sc, AWI_CMD_STATUS, AWI_STAT_IDLE);
1636 awi_write_1(sc, AWI_CMD, cmd);
1637 if (wflag == AWI_NOWAIT)
1638 return EINPROGRESS;
1639 if ((error = awi_cmd_wait(sc)) != 0)
1640 return error;
1641 status = awi_read_1(sc, AWI_CMD_STATUS);
1642 awi_write_1(sc, AWI_CMD, 0);
1643 switch (status) {
1644 case AWI_STAT_OK:
1645 break;
1646 case AWI_STAT_BADPARM:
1647 return EINVAL;
1648 default:
1649 printf("%s: command %d failed %x\n",
1650 sc->sc_ic.ic_if.if_xname, cmd, status);
1651 return ENXIO;
1652 }
1653 return 0;
1654 }
1655
1656 static int
1657 awi_cmd_wait(struct awi_softc *sc)
1658 {
1659 int i, error = 0;
1660
1661 i = 0;
1662 while (sc->sc_cmd_inprog) {
1663 if (sc->sc_invalid)
1664 return ENXIO;
1665 if (awi_read_1(sc, AWI_CMD) != sc->sc_cmd_inprog) {
1666 printf("%s: failed to access hardware\n",
1667 sc->sc_ic.ic_if.if_xname);
1668 sc->sc_invalid = 1;
1669 return ENXIO;
1670 }
1671 if (sc->sc_cansleep) {
1672 sc->sc_sleep_cnt++;
1673 error = tsleep(sc, PWAIT, "awicmd",
1674 AWI_CMD_TIMEOUT*hz/1000);
1675 sc->sc_sleep_cnt--;
1676 } else {
1677 if (awi_read_1(sc, AWI_CMD_STATUS) != AWI_STAT_IDLE) {
1678 awi_cmd_done(sc);
1679 break;
1680 }
1681 if (i++ >= AWI_CMD_TIMEOUT*1000/10)
1682 error = EWOULDBLOCK;
1683 else
1684 DELAY(10);
1685 }
1686 if (error)
1687 break;
1688 }
1689 if (error) {
1690 DPRINTF(("awi_cmd_wait: cmd 0x%x, error %d\n",
1691 sc->sc_cmd_inprog, error));
1692 }
1693 return error;
1694 }
1695
1696 static void
1697 awi_cmd_done(struct awi_softc *sc)
1698 {
1699 u_int8_t cmd, status;
1700
1701 status = awi_read_1(sc, AWI_CMD_STATUS);
1702 if (status == AWI_STAT_IDLE)
1703 return; /* stray interrupt */
1704
1705 cmd = sc->sc_cmd_inprog;
1706 sc->sc_cmd_inprog = 0;
1707 wakeup(sc);
1708 awi_write_1(sc, AWI_CMD, 0);
1709
1710 if (status != AWI_STAT_OK) {
1711 printf("%s: command %d failed %x\n",
1712 sc->sc_ic.ic_if.if_xname, cmd, status);
1713 sc->sc_substate = AWI_ST_NONE;
1714 return;
1715 }
1716 if (sc->sc_substate != AWI_ST_NONE)
1717 (void)ieee80211_new_state(&sc->sc_ic, sc->sc_nstate, -1);
1718 }
1719
1720 static int
1721 awi_next_txd(struct awi_softc *sc, int len, u_int32_t *framep, u_int32_t *ntxdp)
1722 {
1723 u_int32_t txd, ntxd, frame;
1724
1725 txd = sc->sc_txnext;
1726 frame = txd + AWI_TXD_SIZE;
1727 if (frame + len > sc->sc_txend)
1728 frame = sc->sc_txbase;
1729 ntxd = frame + len;
1730 if (ntxd + AWI_TXD_SIZE > sc->sc_txend)
1731 ntxd = sc->sc_txbase;
1732 *framep = frame;
1733 *ntxdp = ntxd;
1734 /*
1735 * Determine if there are any room in ring buffer.
1736 * --- send wait, === new data, +++ conflict (ENOBUFS)
1737 * base........................end
1738 * done----txd=====ntxd OK
1739 * --txd=====done++++ntxd-- full
1740 * --txd=====ntxd done-- OK
1741 * ==ntxd done----txd=== OK
1742 * ==done++++ntxd----txd=== full
1743 * ++ntxd txd=====done++ full
1744 */
1745 if (txd < ntxd) {
1746 if (txd < sc->sc_txdone && ntxd + AWI_TXD_SIZE > sc->sc_txdone)
1747 return ENOBUFS;
1748 } else {
1749 if (txd < sc->sc_txdone || ntxd + AWI_TXD_SIZE > sc->sc_txdone)
1750 return ENOBUFS;
1751 }
1752 return 0;
1753 }
1754
1755 static int
1756 awi_lock(struct awi_softc *sc)
1757 {
1758 int error = 0;
1759
1760 #ifdef __NetBSD__
1761 if (curlwp == NULL)
1762 #else
1763 if (curproc == NULL)
1764 #endif
1765 {
1766 /*
1767 * XXX
1768 * Though driver ioctl should be called with context,
1769 * KAME ipv6 stack calls ioctl in interrupt for now.
1770 * We simply abort the request if there are other
1771 * ioctl requests in progress.
1772 */
1773 if (sc->sc_busy) {
1774 if (sc->sc_invalid)
1775 return ENXIO;
1776 return EWOULDBLOCK;
1777 }
1778 sc->sc_busy = 1;
1779 sc->sc_cansleep = 0;
1780 return 0;
1781 }
1782 while (sc->sc_busy) {
1783 if (sc->sc_invalid)
1784 return ENXIO;
1785 sc->sc_sleep_cnt++;
1786 error = tsleep(sc, PWAIT | PCATCH, "awilck", 0);
1787 sc->sc_sleep_cnt--;
1788 if (error)
1789 return error;
1790 }
1791 sc->sc_busy = 1;
1792 sc->sc_cansleep = 1;
1793 return 0;
1794 }
1795
1796 static void
1797 awi_unlock(struct awi_softc *sc)
1798 {
1799 sc->sc_busy = 0;
1800 sc->sc_cansleep = 0;
1801 if (sc->sc_sleep_cnt)
1802 wakeup(sc);
1803 }
1804
1805 static int
1806 awi_intr_lock(struct awi_softc *sc)
1807 {
1808 u_int8_t status;
1809 int i, retry;
1810
1811 status = 1;
1812 for (retry = 0; retry < 10; retry++) {
1813 for (i = 0; i < AWI_LOCKOUT_TIMEOUT*1000/5; i++) {
1814 if ((status = awi_read_1(sc, AWI_LOCKOUT_HOST)) == 0)
1815 break;
1816 DELAY(5);
1817 }
1818 if (status != 0)
1819 break;
1820 awi_write_1(sc, AWI_LOCKOUT_MAC, 1);
1821 if ((status = awi_read_1(sc, AWI_LOCKOUT_HOST)) == 0)
1822 break;
1823 awi_write_1(sc, AWI_LOCKOUT_MAC, 0);
1824 }
1825 if (status != 0) {
1826 printf("%s: failed to lock interrupt\n",
1827 sc->sc_ic.ic_if.if_xname);
1828 return ENXIO;
1829 }
1830 return 0;
1831 }
1832
1833 static void
1834 awi_intr_unlock(struct awi_softc *sc)
1835 {
1836
1837 awi_write_1(sc, AWI_LOCKOUT_MAC, 0);
1838 }
1839
1840 static int
1841 awi_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
1842 {
1843 struct awi_softc *sc = ic->ic_softc;
1844 struct ieee80211_node *ni;
1845 struct ifnet *ifp = &ic->ic_if;
1846 int error;
1847 u_int8_t newmode;
1848 enum ieee80211_state ostate;
1849 #ifdef AWI_DEBUG
1850 static const char *stname[] =
1851 { "INIT", "SCAN", "AUTH", "ASSOC", "RUN" };
1852 static const char *substname[] =
1853 { "NONE", "SCAN_INIT", "SCAN_SETMIB", "SCAN_SCCMD",
1854 "SUB_INIT", "SUB_SETSS", "SUB_SYNC" };
1855 #endif /* AWI_DEBUG */
1856
1857 ostate = ic->ic_state;
1858 DPRINTF(("awi_newstate: %s (%s/%s) -> %s\n", stname[ostate],
1859 stname[sc->sc_nstate], substname[sc->sc_substate], stname[nstate]));
1860
1861 /* set LED */
1862 switch (nstate) {
1863 case IEEE80211_S_INIT:
1864 awi_drvstate(sc, AWI_DRV_RESET);
1865 break;
1866 case IEEE80211_S_SCAN:
1867 if (ic->ic_opmode == IEEE80211_M_IBSS ||
1868 ic->ic_opmode == IEEE80211_M_AHDEMO)
1869 awi_drvstate(sc, AWI_DRV_ADHSC);
1870 else
1871 awi_drvstate(sc, AWI_DRV_INFSY);
1872 break;
1873 case IEEE80211_S_AUTH:
1874 awi_drvstate(sc, AWI_DRV_INFSY);
1875 break;
1876 case IEEE80211_S_ASSOC:
1877 awi_drvstate(sc, AWI_DRV_INFAUTH);
1878 break;
1879 case IEEE80211_S_RUN:
1880 if (ic->ic_opmode == IEEE80211_M_IBSS ||
1881 ic->ic_opmode == IEEE80211_M_AHDEMO)
1882 awi_drvstate(sc, AWI_DRV_ADHSY);
1883 else
1884 awi_drvstate(sc, AWI_DRV_INFASSOC);
1885 break;
1886 }
1887
1888 if (nstate == IEEE80211_S_INIT) {
1889 sc->sc_substate = AWI_ST_NONE;
1890 ic->ic_flags &= ~IEEE80211_F_SIBSS;
1891 return (*sc->sc_newstate)(ic, nstate, arg);
1892 }
1893
1894 /* state transition */
1895 if (nstate == IEEE80211_S_SCAN) {
1896 /* SCAN substate */
1897 if (sc->sc_substate == AWI_ST_NONE) {
1898 sc->sc_nstate = nstate; /* next state in transition */
1899 sc->sc_substate = AWI_ST_SCAN_INIT;
1900 }
1901 switch (sc->sc_substate) {
1902 case AWI_ST_SCAN_INIT:
1903 sc->sc_substate = AWI_ST_SCAN_SETMIB;
1904 switch (ostate) {
1905 case IEEE80211_S_RUN:
1906 /* beacon miss */
1907 if (ifp->if_flags & IFF_DEBUG)
1908 printf("%s: no recent beacons from %s;"
1909 " rescanning\n",
1910 ifp->if_xname,
1911 ether_sprintf(ic->ic_bss->ni_bssid));
1912 /* FALLTHRU */
1913 case IEEE80211_S_AUTH:
1914 case IEEE80211_S_ASSOC:
1915 case IEEE80211_S_INIT:
1916 ieee80211_begin_scan(ic);
1917 /* FALLTHRU */
1918 case IEEE80211_S_SCAN:
1919 /* scan next */
1920 break;
1921 }
1922 if (ic->ic_flags & IEEE80211_F_ASCAN)
1923 newmode = AWI_SCAN_ACTIVE;
1924 else
1925 newmode = AWI_SCAN_PASSIVE;
1926 if (sc->sc_mib_mgt.aScan_Mode != newmode) {
1927 sc->sc_mib_mgt.aScan_Mode = newmode;
1928 if ((error = awi_mib(sc, AWI_CMD_SET_MIB,
1929 AWI_MIB_MGT, AWI_NOWAIT)) != 0)
1930 break;
1931 }
1932 /* FALLTHRU */
1933 case AWI_ST_SCAN_SETMIB:
1934 sc->sc_substate = AWI_ST_SCAN_SCCMD;
1935 if (sc->sc_cmd_inprog) {
1936 if ((error = awi_cmd_wait(sc)) != 0)
1937 break;
1938 }
1939 sc->sc_cmd_inprog = AWI_CMD_SCAN;
1940 ni = ic->ic_bss;
1941 awi_write_2(sc, AWI_CA_SCAN_DURATION,
1942 (ic->ic_flags & IEEE80211_F_ASCAN) ?
1943 AWI_ASCAN_DURATION : AWI_PSCAN_DURATION);
1944 if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH) {
1945 awi_write_1(sc, AWI_CA_SCAN_SET,
1946 IEEE80211_FH_CHANSET(
1947 ieee80211_chan2ieee(ic, ni->ni_chan)));
1948 awi_write_1(sc, AWI_CA_SCAN_PATTERN,
1949 IEEE80211_FH_CHANPAT(
1950 ieee80211_chan2ieee(ic, ni->ni_chan)));
1951 awi_write_1(sc, AWI_CA_SCAN_IDX, 1);
1952 } else {
1953 awi_write_1(sc, AWI_CA_SCAN_SET,
1954 ieee80211_chan2ieee(ic, ni->ni_chan));
1955 awi_write_1(sc, AWI_CA_SCAN_PATTERN, 0);
1956 awi_write_1(sc, AWI_CA_SCAN_IDX, 0);
1957 }
1958 awi_write_1(sc, AWI_CA_SCAN_SUSP, 0);
1959 sc->sc_cur_chan = ieee80211_chan2ieee(ic, ni->ni_chan);
1960 if ((error = awi_cmd(sc, AWI_CMD_SCAN, AWI_NOWAIT))
1961 != 0)
1962 break;
1963 /* FALLTHRU */
1964 case AWI_ST_SCAN_SCCMD:
1965 ic->ic_state = nstate;
1966 sc->sc_substate = AWI_ST_NONE;
1967 error = EINPROGRESS;
1968 break;
1969 default:
1970 DPRINTF(("awi_newstate: unexpected state %s/%s\n",
1971 stname[nstate], substname[sc->sc_substate]));
1972 sc->sc_substate = AWI_ST_NONE;
1973 error = EIO;
1974 break;
1975 }
1976 goto out;
1977 }
1978
1979 if (ostate == IEEE80211_S_SCAN) {
1980 /* set SSID and channel */
1981 /* substate */
1982 if (sc->sc_substate == AWI_ST_NONE) {
1983 sc->sc_nstate = nstate; /* next state in transition */
1984 sc->sc_substate = AWI_ST_SUB_INIT;
1985 }
1986 ni = ic->ic_bss;
1987 switch (sc->sc_substate) {
1988 case AWI_ST_SUB_INIT:
1989 sc->sc_substate = AWI_ST_SUB_SETSS;
1990 IEEE80211_ADDR_COPY(&sc->sc_mib_mgt.aCurrent_BSS_ID,
1991 ni->ni_bssid);
1992 memset(&sc->sc_mib_mgt.aCurrent_ESS_ID, 0,
1993 AWI_ESS_ID_SIZE);
1994 sc->sc_mib_mgt.aCurrent_ESS_ID[0] =
1995 IEEE80211_ELEMID_SSID;
1996 sc->sc_mib_mgt.aCurrent_ESS_ID[1] = ni->ni_esslen;
1997 memcpy(&sc->sc_mib_mgt.aCurrent_ESS_ID[2],
1998 ni->ni_essid, ni->ni_esslen);
1999 LE_WRITE_2(&sc->sc_mib_mgt.aBeacon_Period,
2000 ni->ni_intval);
2001 if ((error = awi_mib(sc, AWI_CMD_SET_MIB, AWI_MIB_MGT,
2002 AWI_NOWAIT)) != 0)
2003 break;
2004 /* FALLTHRU */
2005 case AWI_ST_SUB_SETSS:
2006 sc->sc_substate = AWI_ST_SUB_SYNC;
2007 if (sc->sc_cmd_inprog) {
2008 if ((error = awi_cmd_wait(sc)) != 0)
2009 break;
2010 }
2011 sc->sc_cmd_inprog = AWI_CMD_SYNC;
2012 if (sc->sc_mib_phy.IEEE_PHY_Type == AWI_PHY_TYPE_FH) {
2013 awi_write_1(sc, AWI_CA_SYNC_SET,
2014 IEEE80211_FH_CHANSET(
2015 ieee80211_chan2ieee(ic, ni->ni_chan)));
2016 awi_write_1(sc, AWI_CA_SYNC_PATTERN,
2017 IEEE80211_FH_CHANPAT(
2018 ieee80211_chan2ieee(ic, ni->ni_chan)));
2019 awi_write_1(sc, AWI_CA_SYNC_IDX,
2020 ni->ni_fhindex);
2021 awi_write_2(sc, AWI_CA_SYNC_DWELL,
2022 ni->ni_fhdwell);
2023 } else {
2024 awi_write_1(sc, AWI_CA_SYNC_SET,
2025 ieee80211_chan2ieee(ic, ni->ni_chan));
2026 awi_write_1(sc, AWI_CA_SYNC_PATTERN, 0);
2027 awi_write_1(sc, AWI_CA_SYNC_IDX, 0);
2028 awi_write_2(sc, AWI_CA_SYNC_DWELL, 0);
2029 }
2030 if (ic->ic_flags & IEEE80211_F_SIBSS) {
2031 memset(ni->ni_tstamp, 0, sizeof(ni->ni_tstamp));
2032 ni->ni_rstamp = 0;
2033 awi_write_1(sc, AWI_CA_SYNC_STARTBSS, 1);
2034 } else
2035 awi_write_1(sc, AWI_CA_SYNC_STARTBSS, 0);
2036 awi_write_2(sc, AWI_CA_SYNC_MBZ, 0);
2037 awi_write_bytes(sc, AWI_CA_SYNC_TIMESTAMP,
2038 ni->ni_tstamp, 8);
2039 awi_write_4(sc, AWI_CA_SYNC_REFTIME, ni->ni_rstamp);
2040 sc->sc_cur_chan = ieee80211_chan2ieee(ic, ni->ni_chan);
2041 if ((error = awi_cmd(sc, AWI_CMD_SYNC, AWI_NOWAIT))
2042 != 0)
2043 break;
2044 /* FALLTHRU */
2045 case AWI_ST_SUB_SYNC:
2046 sc->sc_substate = AWI_ST_NONE;
2047 if (ic->ic_flags & IEEE80211_F_SIBSS) {
2048 if ((error = awi_mib(sc, AWI_CMD_GET_MIB,
2049 AWI_MIB_MGT, AWI_WAIT)) != 0)
2050 break;
2051 IEEE80211_ADDR_COPY(ni->ni_bssid,
2052 &sc->sc_mib_mgt.aCurrent_BSS_ID);
2053 } else {
2054 if (nstate == IEEE80211_S_RUN) {
2055 sc->sc_rx_timer = 10;
2056 ifp->if_timer = 1;
2057 }
2058 }
2059 error = 0;
2060 break;
2061 default:
2062 DPRINTF(("awi_newstate: unexpected state %s/%s\n",
2063 stname[nstate], substname[sc->sc_substate]));
2064 sc->sc_substate = AWI_ST_NONE;
2065 error = EIO;
2066 break;
2067 }
2068 goto out;
2069 }
2070
2071 sc->sc_substate = AWI_ST_NONE;
2072
2073 return (*sc->sc_newstate)(ic, nstate, arg);
2074 out:
2075 if (error != 0) {
2076 if (error == EINPROGRESS)
2077 error = 0;
2078 return error;
2079 }
2080 return (*sc->sc_newstate)(ic, nstate, arg);
2081 }
2082
2083 static void
2084 awi_recv_mgmt(struct ieee80211com *ic, struct mbuf *m0,
2085 struct ieee80211_node *ni,
2086 int subtype, int rssi, u_int32_t rstamp)
2087 {
2088 struct awi_softc *sc = ic->ic_softc;
2089
2090 /* probe request is handled by hardware */
2091 if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_REQ)
2092 return;
2093 (*sc->sc_recv_mgmt)(ic, m0, ni, subtype, rssi, rstamp);
2094 }
2095
2096 static int
2097 awi_send_mgmt(struct ieee80211com *ic, struct ieee80211_node *ni,
2098 int type, int arg)
2099 {
2100 struct awi_softc *sc = ic->ic_softc;
2101
2102 /* probe request is handled by hardware */
2103 if (type == IEEE80211_FC0_SUBTYPE_PROBE_REQ)
2104 return 0;
2105 return (*sc->sc_send_mgmt)(ic, ni, type, arg);
2106 }
2107
2108 static struct mbuf *
2109 awi_ether_encap(struct awi_softc *sc, struct mbuf *m)
2110 {
2111 struct ieee80211com *ic = &sc->sc_ic;
2112 struct ieee80211_node *ni = ic->ic_bss;
2113 struct ether_header *eh;
2114 struct ieee80211_frame *wh;
2115
2116 if (m->m_len < sizeof(struct ether_header)) {
2117 m = m_pullup(m, sizeof(struct ether_header));
2118 if (m == NULL)
2119 return NULL;
2120 }
2121 eh = mtod(m, struct ether_header *);
2122 M_PREPEND(m, sizeof(struct ieee80211_frame), M_DONTWAIT);
2123 if (m == NULL)
2124 return NULL;
2125 wh = mtod(m, struct ieee80211_frame *);
2126 wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA;
2127 *(u_int16_t *)wh->i_dur = 0;
2128 *(u_int16_t *)wh->i_seq =
2129 htole16(ni->ni_txseq << IEEE80211_SEQ_SEQ_SHIFT);
2130 ni->ni_txseq++;
2131 if (ic->ic_opmode == IEEE80211_M_IBSS ||
2132 ic->ic_opmode == IEEE80211_M_AHDEMO) {
2133 wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
2134 if (sc->sc_adhoc_ap)
2135 IEEE80211_ADDR_COPY(wh->i_addr1, ni->ni_macaddr);
2136 else
2137 IEEE80211_ADDR_COPY(wh->i_addr1, eh->ether_dhost);
2138 IEEE80211_ADDR_COPY(wh->i_addr2, eh->ether_shost);
2139 IEEE80211_ADDR_COPY(wh->i_addr3, ni->ni_bssid);
2140 } else {
2141 wh->i_fc[1] = IEEE80211_FC1_DIR_TODS;
2142 IEEE80211_ADDR_COPY(wh->i_addr1, ni->ni_bssid);
2143 IEEE80211_ADDR_COPY(wh->i_addr2, eh->ether_shost);
2144 IEEE80211_ADDR_COPY(wh->i_addr3, eh->ether_dhost);
2145 }
2146 return m;
2147 }
2148
2149 static struct mbuf *
2150 awi_ether_modcap(struct awi_softc *sc, struct mbuf *m)
2151 {
2152 struct ieee80211com *ic = &sc->sc_ic;
2153 struct ether_header eh;
2154 struct ieee80211_frame wh;
2155 struct llc *llc;
2156
2157 if (m->m_len < sizeof(wh) + sizeof(eh)) {
2158 m = m_pullup(m, sizeof(wh) + sizeof(eh));
2159 if (m == NULL)
2160 return NULL;
2161 }
2162 memcpy(&wh, mtod(m, caddr_t), sizeof(wh));
2163 if (wh.i_fc[0] != (IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA))
2164 return m;
2165 memcpy(&eh, mtod(m, caddr_t) + sizeof(wh), sizeof(eh));
2166 m_adj(m, sizeof(eh) - sizeof(*llc));
2167 if (ic->ic_opmode == IEEE80211_M_IBSS ||
2168 ic->ic_opmode == IEEE80211_M_AHDEMO)
2169 IEEE80211_ADDR_COPY(wh.i_addr2, eh.ether_shost);
2170 memcpy(mtod(m, caddr_t), &wh, sizeof(wh));
2171 llc = (struct llc *)(mtod(m, caddr_t) + sizeof(wh));
2172 llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
2173 llc->llc_control = LLC_UI;
2174 llc->llc_snap.org_code[0] = 0;
2175 llc->llc_snap.org_code[1] = 0;
2176 llc->llc_snap.org_code[2] = 0;
2177 llc->llc_snap.ether_type = eh.ether_type;
2178 return m;
2179 }
Cache object: 123ea4af3ec046900e9448e808205d73
|