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