wi.c revision 1.151
1 /* $NetBSD: wi.c,v 1.151 2004/02/10 00:47:41 dyoung Exp $ */ 2 3 /* 4 * Copyright (c) 1997, 1998, 1999 5 * Bill Paul <wpaul (at) ctr.columbia.edu>. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Bill Paul. 18 * 4. Neither the name of the author nor the names of any co-contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD 26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 32 * THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 /* 36 * Lucent WaveLAN/IEEE 802.11 PCMCIA driver for NetBSD. 37 * 38 * Original FreeBSD driver written by Bill Paul <wpaul (at) ctr.columbia.edu> 39 * Electrical Engineering Department 40 * Columbia University, New York City 41 */ 42 43 /* 44 * The WaveLAN/IEEE adapter is the second generation of the WaveLAN 45 * from Lucent. Unlike the older cards, the new ones are programmed 46 * entirely via a firmware-driven controller called the Hermes. 47 * Unfortunately, Lucent will not release the Hermes programming manual 48 * without an NDA (if at all). What they do release is an API library 49 * called the HCF (Hardware Control Functions) which is supposed to 50 * do the device-specific operations of a device driver for you. The 51 * publically available version of the HCF library (the 'HCF Light') is 52 * a) extremely gross, b) lacks certain features, particularly support 53 * for 802.11 frames, and c) is contaminated by the GNU Public License. 54 * 55 * This driver does not use the HCF or HCF Light at all. Instead, it 56 * programs the Hermes controller directly, using information gleaned 57 * from the HCF Light code and corresponding documentation. 58 * 59 * This driver supports both the PCMCIA and ISA versions of the 60 * WaveLAN/IEEE cards. Note however that the ISA card isn't really 61 * anything of the sort: it's actually a PCMCIA bridge adapter 62 * that fits into an ISA slot, into which a PCMCIA WaveLAN card is 63 * inserted. Consequently, you need to use the pccard support for 64 * both the ISA and PCMCIA adapters. 65 */ 66 67 /* 68 * FreeBSD driver ported to NetBSD by Bill Sommerfeld in the back of the 69 * Oslo IETF plenary meeting. 70 */ 71 72 #include <sys/cdefs.h> 73 __KERNEL_RCSID(0, "$NetBSD: wi.c,v 1.151 2004/02/10 00:47:41 dyoung Exp $"); 74 75 #define WI_HERMES_AUTOINC_WAR /* Work around data write autoinc bug. */ 76 #define WI_HERMES_STATS_WAR /* Work around stats counter bug. */ 77 78 #include "bpfilter.h" 79 80 #include <sys/param.h> 81 #include <sys/systm.h> 82 #include <sys/callout.h> 83 #include <sys/device.h> 84 #include <sys/socket.h> 85 #include <sys/mbuf.h> 86 #include <sys/ioctl.h> 87 #include <sys/kernel.h> /* for hz */ 88 #include <sys/proc.h> 89 90 #include <net/if.h> 91 #include <net/if_dl.h> 92 #include <net/if_llc.h> 93 #include <net/if_media.h> 94 #include <net/if_ether.h> 95 96 #include <net80211/ieee80211_var.h> 97 #include <net80211/ieee80211_compat.h> 98 #include <net80211/ieee80211_ioctl.h> 99 #include <net80211/ieee80211_radiotap.h> 100 #include <net80211/ieee80211_rssadapt.h> 101 102 #if NBPFILTER > 0 103 #include <net/bpf.h> 104 #include <net/bpfdesc.h> 105 #endif 106 107 #include <machine/bus.h> 108 109 #include <dev/ic/wi_ieee.h> 110 #include <dev/ic/wireg.h> 111 #include <dev/ic/wivar.h> 112 113 static int wi_init(struct ifnet *); 114 static void wi_stop(struct ifnet *, int); 115 static void wi_start(struct ifnet *); 116 static int wi_reset(struct wi_softc *); 117 static void wi_watchdog(struct ifnet *); 118 static int wi_ioctl(struct ifnet *, u_long, caddr_t); 119 static int wi_media_change(struct ifnet *); 120 static void wi_media_status(struct ifnet *, struct ifmediareq *); 121 122 static struct ieee80211_node *wi_node_alloc(struct ieee80211com *); 123 static void wi_node_copy(struct ieee80211com *, struct ieee80211_node *, 124 const struct ieee80211_node *); 125 static void wi_node_free(struct ieee80211com *, struct ieee80211_node *); 126 127 static void wi_raise_rate(struct ieee80211com *, struct ieee80211_rssdesc *); 128 static void wi_lower_rate(struct ieee80211com *, struct ieee80211_rssdesc *); 129 static void wi_choose_rate(struct ieee80211com *, struct ieee80211_node *, 130 struct ieee80211_frame *, u_int); 131 static void wi_rssadapt_updatestats_cb(void *, struct ieee80211_node *); 132 static void wi_rssadapt_updatestats(void *); 133 134 static void wi_rx_intr(struct wi_softc *); 135 static void wi_txalloc_intr(struct wi_softc *); 136 static void wi_tx_intr(struct wi_softc *); 137 static void wi_tx_ex_intr(struct wi_softc *); 138 static void wi_info_intr(struct wi_softc *); 139 140 static int wi_get_cfg(struct ifnet *, u_long, caddr_t); 141 static int wi_set_cfg(struct ifnet *, u_long, caddr_t); 142 static int wi_cfg_txrate(struct wi_softc *); 143 static int wi_write_txrate(struct wi_softc *, int); 144 static int wi_write_wep(struct wi_softc *); 145 static int wi_write_multi(struct wi_softc *); 146 static int wi_alloc_fid(struct wi_softc *, int, int *); 147 static void wi_read_nicid(struct wi_softc *); 148 static int wi_write_ssid(struct wi_softc *, int, u_int8_t *, int); 149 150 static int wi_cmd(struct wi_softc *, int, int, int, int); 151 static int wi_seek_bap(struct wi_softc *, int, int); 152 static int wi_read_bap(struct wi_softc *, int, int, void *, int); 153 static int wi_write_bap(struct wi_softc *, int, int, void *, int); 154 static int wi_mwrite_bap(struct wi_softc *, int, int, struct mbuf *, int); 155 static int wi_read_rid(struct wi_softc *, int, void *, int *); 156 static int wi_write_rid(struct wi_softc *, int, void *, int); 157 158 static int wi_newstate(struct ieee80211com *, enum ieee80211_state, int); 159 static int wi_set_tim(struct ieee80211com *, int, int); 160 161 static int wi_scan_ap(struct wi_softc *, u_int16_t, u_int16_t); 162 static void wi_scan_result(struct wi_softc *, int, int); 163 164 static void wi_dump_pkt(struct wi_frame *, struct ieee80211_node *, int rssi); 165 166 static inline int 167 wi_write_val(struct wi_softc *sc, int rid, u_int16_t val) 168 { 169 170 val = htole16(val); 171 return wi_write_rid(sc, rid, &val, sizeof(val)); 172 } 173 174 static struct timeval lasttxerror; /* time of last tx error msg */ 175 static int curtxeps = 0; /* current tx error msgs/sec */ 176 static int wi_txerate = 0; /* tx error rate: max msgs/sec */ 177 178 #ifdef WI_DEBUG 179 int wi_debug = 0; 180 181 #define DPRINTF(X) if (wi_debug) printf X 182 #define DPRINTF2(X) if (wi_debug > 1) printf X 183 #define IFF_DUMPPKTS(_ifp) \ 184 (((_ifp)->if_flags & (IFF_DEBUG|IFF_LINK2)) == (IFF_DEBUG|IFF_LINK2)) 185 #else 186 #define DPRINTF(X) 187 #define DPRINTF2(X) 188 #define IFF_DUMPPKTS(_ifp) 0 189 #endif 190 191 #define WI_INTRS (WI_EV_RX | WI_EV_ALLOC | WI_EV_INFO) 192 193 struct wi_card_ident 194 wi_card_ident[] = { 195 /* CARD_ID CARD_NAME FIRM_TYPE */ 196 { WI_NIC_LUCENT_ID, WI_NIC_LUCENT_STR, WI_LUCENT }, 197 { WI_NIC_SONY_ID, WI_NIC_SONY_STR, WI_LUCENT }, 198 { WI_NIC_LUCENT_EMB_ID, WI_NIC_LUCENT_EMB_STR, WI_LUCENT }, 199 { WI_NIC_EVB2_ID, WI_NIC_EVB2_STR, WI_INTERSIL }, 200 { WI_NIC_HWB3763_ID, WI_NIC_HWB3763_STR, WI_INTERSIL }, 201 { WI_NIC_HWB3163_ID, WI_NIC_HWB3163_STR, WI_INTERSIL }, 202 { WI_NIC_HWB3163B_ID, WI_NIC_HWB3163B_STR, WI_INTERSIL }, 203 { WI_NIC_EVB3_ID, WI_NIC_EVB3_STR, WI_INTERSIL }, 204 { WI_NIC_HWB1153_ID, WI_NIC_HWB1153_STR, WI_INTERSIL }, 205 { WI_NIC_P2_SST_ID, WI_NIC_P2_SST_STR, WI_INTERSIL }, 206 { WI_NIC_EVB2_SST_ID, WI_NIC_EVB2_SST_STR, WI_INTERSIL }, 207 { WI_NIC_3842_EVA_ID, WI_NIC_3842_EVA_STR, WI_INTERSIL }, 208 { WI_NIC_3842_PCMCIA_AMD_ID, WI_NIC_3842_PCMCIA_STR, WI_INTERSIL }, 209 { WI_NIC_3842_PCMCIA_SST_ID, WI_NIC_3842_PCMCIA_STR, WI_INTERSIL }, 210 { WI_NIC_3842_PCMCIA_ATM_ID, WI_NIC_3842_PCMCIA_STR, WI_INTERSIL }, 211 { WI_NIC_3842_MINI_AMD_ID, WI_NIC_3842_MINI_STR, WI_INTERSIL }, 212 { WI_NIC_3842_MINI_SST_ID, WI_NIC_3842_MINI_STR, WI_INTERSIL }, 213 { WI_NIC_3842_MINI_ATM_ID, WI_NIC_3842_MINI_STR, WI_INTERSIL }, 214 { WI_NIC_3842_PCI_AMD_ID, WI_NIC_3842_PCI_STR, WI_INTERSIL }, 215 { WI_NIC_3842_PCI_SST_ID, WI_NIC_3842_PCI_STR, WI_INTERSIL }, 216 { WI_NIC_3842_PCI_ATM_ID, WI_NIC_3842_PCI_STR, WI_INTERSIL }, 217 { WI_NIC_P3_PCMCIA_AMD_ID, WI_NIC_P3_PCMCIA_STR, WI_INTERSIL }, 218 { WI_NIC_P3_PCMCIA_SST_ID, WI_NIC_P3_PCMCIA_STR, WI_INTERSIL }, 219 { WI_NIC_P3_MINI_AMD_ID, WI_NIC_P3_MINI_STR, WI_INTERSIL }, 220 { WI_NIC_P3_MINI_SST_ID, WI_NIC_P3_MINI_STR, WI_INTERSIL }, 221 { 0, NULL, 0 }, 222 }; 223 224 int 225 wi_attach(struct wi_softc *sc) 226 { 227 struct ieee80211com *ic = &sc->sc_ic; 228 struct ifnet *ifp = &ic->ic_if; 229 int chan, nrate, buflen; 230 u_int16_t val, chanavail; 231 struct { 232 u_int16_t nrates; 233 char rates[IEEE80211_RATE_SIZE]; 234 } ratebuf; 235 static const u_int8_t empty_macaddr[IEEE80211_ADDR_LEN] = { 236 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 237 }; 238 int s; 239 240 s = splnet(); 241 242 /* Make sure interrupts are disabled. */ 243 CSR_WRITE_2(sc, WI_INT_EN, 0); 244 CSR_WRITE_2(sc, WI_EVENT_ACK, ~0); 245 246 sc->sc_invalid = 0; 247 248 /* Reset the NIC. */ 249 if (wi_reset(sc) != 0) { 250 sc->sc_invalid = 1; 251 splx(s); 252 return 1; 253 } 254 255 buflen = IEEE80211_ADDR_LEN; 256 if (wi_read_rid(sc, WI_RID_MAC_NODE, ic->ic_myaddr, &buflen) != 0 || 257 IEEE80211_ADDR_EQ(ic->ic_myaddr, empty_macaddr)) { 258 printf(" could not get mac address, attach failed\n"); 259 splx(s); 260 return 1; 261 } 262 263 printf(" 802.11 address %s\n", ether_sprintf(ic->ic_myaddr)); 264 265 /* Read NIC identification */ 266 wi_read_nicid(sc); 267 268 memcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ); 269 ifp->if_softc = sc; 270 ifp->if_start = wi_start; 271 ifp->if_ioctl = wi_ioctl; 272 ifp->if_watchdog = wi_watchdog; 273 ifp->if_init = wi_init; 274 ifp->if_stop = wi_stop; 275 ifp->if_flags = 276 IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST | IFF_NOTRAILERS; 277 IFQ_SET_READY(&ifp->if_snd); 278 279 ic->ic_phytype = IEEE80211_T_DS; 280 ic->ic_opmode = IEEE80211_M_STA; 281 ic->ic_caps = IEEE80211_C_PMGT | IEEE80211_C_AHDEMO; 282 ic->ic_state = IEEE80211_S_INIT; 283 ic->ic_max_aid = WI_MAX_AID; 284 285 /* Find available channel */ 286 buflen = sizeof(chanavail); 287 if (wi_read_rid(sc, WI_RID_CHANNEL_LIST, &chanavail, &buflen) != 0) 288 chanavail = htole16(0x1fff); /* assume 1-11 */ 289 for (chan = 16; chan > 0; chan--) { 290 if (!isset((u_int8_t*)&chanavail, chan - 1)) 291 continue; 292 ic->ic_ibss_chan = &ic->ic_channels[chan]; 293 ic->ic_channels[chan].ic_freq = 294 ieee80211_ieee2mhz(chan, IEEE80211_CHAN_2GHZ); 295 ic->ic_channels[chan].ic_flags = IEEE80211_CHAN_B; 296 } 297 298 /* Find default IBSS channel */ 299 buflen = sizeof(val); 300 if (wi_read_rid(sc, WI_RID_OWN_CHNL, &val, &buflen) == 0) { 301 chan = le16toh(val); 302 if (isset((u_int8_t*)&chanavail, chan - 1)) 303 ic->ic_ibss_chan = &ic->ic_channels[chan]; 304 } 305 if (ic->ic_ibss_chan == NULL) 306 panic("%s: no available channel\n", sc->sc_dev.dv_xname); 307 308 if (sc->sc_firmware_type == WI_LUCENT) { 309 sc->sc_dbm_offset = WI_LUCENT_DBM_OFFSET; 310 } else { 311 buflen = sizeof(val); 312 if ((sc->sc_flags & WI_FLAGS_HAS_DBMADJUST) && 313 wi_read_rid(sc, WI_RID_DBM_ADJUST, &val, &buflen) == 0) 314 sc->sc_dbm_offset = le16toh(val); 315 else 316 sc->sc_dbm_offset = WI_PRISM_DBM_OFFSET; 317 } 318 319 /* 320 * Set flags based on firmware version. 321 */ 322 switch (sc->sc_firmware_type) { 323 case WI_LUCENT: 324 sc->sc_flags |= WI_FLAGS_HAS_SYSSCALE; 325 #ifdef WI_HERMES_AUTOINC_WAR 326 /* XXX: not confirmed, but never seen for recent firmware */ 327 if (sc->sc_sta_firmware_ver < 40000) { 328 sc->sc_flags |= WI_FLAGS_BUG_AUTOINC; 329 } 330 #endif 331 if (sc->sc_sta_firmware_ver >= 60000) 332 sc->sc_flags |= WI_FLAGS_HAS_MOR; 333 if (sc->sc_sta_firmware_ver >= 60006) { 334 ic->ic_caps |= IEEE80211_C_IBSS; 335 ic->ic_caps |= IEEE80211_C_MONITOR; 336 } 337 sc->sc_ibss_port = 1; 338 break; 339 340 case WI_INTERSIL: 341 sc->sc_flags |= WI_FLAGS_HAS_FRAGTHR; 342 sc->sc_flags |= WI_FLAGS_HAS_ROAMING; 343 sc->sc_flags |= WI_FLAGS_HAS_SYSSCALE; 344 if (sc->sc_sta_firmware_ver > 10101) 345 sc->sc_flags |= WI_FLAGS_HAS_DBMADJUST; 346 if (sc->sc_sta_firmware_ver >= 800) { 347 if (sc->sc_sta_firmware_ver != 10402) 348 ic->ic_caps |= IEEE80211_C_HOSTAP; 349 ic->ic_caps |= IEEE80211_C_IBSS; 350 ic->ic_caps |= IEEE80211_C_MONITOR; 351 } 352 sc->sc_ibss_port = 0; 353 sc->sc_alt_retry = 2; 354 break; 355 356 case WI_SYMBOL: 357 sc->sc_flags |= WI_FLAGS_HAS_DIVERSITY; 358 if (sc->sc_sta_firmware_ver >= 20000) 359 ic->ic_caps |= IEEE80211_C_IBSS; 360 sc->sc_ibss_port = 4; 361 break; 362 } 363 364 /* start out doing RSS link adaptation. */ 365 sc->sc_flags |= WI_FLAGS_RSSADAPT; 366 367 /* 368 * Find out if we support WEP on this card. 369 */ 370 buflen = sizeof(val); 371 if (wi_read_rid(sc, WI_RID_WEP_AVAIL, &val, &buflen) == 0 && 372 val != htole16(0)) 373 ic->ic_caps |= IEEE80211_C_WEP; 374 375 /* Find supported rates. */ 376 buflen = sizeof(ratebuf); 377 if (wi_read_rid(sc, WI_RID_DATA_RATES, &ratebuf, &buflen) == 0) { 378 nrate = le16toh(ratebuf.nrates); 379 if (nrate > IEEE80211_RATE_SIZE) 380 nrate = IEEE80211_RATE_SIZE; 381 memcpy(ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates, 382 &ratebuf.rates[0], nrate); 383 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_nrates = nrate; 384 } 385 buflen = sizeof(val); 386 387 sc->sc_max_datalen = 2304; 388 sc->sc_rts_thresh = 2347; 389 sc->sc_frag_thresh = 2346; 390 sc->sc_system_scale = 1; 391 sc->sc_cnfauthmode = IEEE80211_AUTH_OPEN; 392 sc->sc_roaming_mode = 1; 393 394 callout_init(&sc->sc_rssadapt_ch); 395 396 /* 397 * Call MI attach routines. 398 */ 399 if_attach(ifp); 400 ieee80211_ifattach(ifp); 401 402 sc->sc_newstate = ic->ic_newstate; 403 ic->ic_newstate = wi_newstate; 404 ic->ic_node_alloc = wi_node_alloc; 405 ic->ic_node_free = wi_node_free; 406 ic->ic_node_copy = wi_node_copy; 407 ic->ic_set_tim = wi_set_tim; 408 409 ieee80211_media_init(ifp, wi_media_change, wi_media_status); 410 411 #if NBPFILTER > 0 412 bpfattach2(ifp, DLT_IEEE802_11_RADIO, 413 sizeof(struct ieee80211_frame) + 64, &sc->sc_drvbpf); 414 #endif 415 416 memset(&sc->sc_rxtapu, 0, sizeof(sc->sc_rxtapu)); 417 sc->sc_rxtap.wr_ihdr.it_len = sizeof(sc->sc_rxtapu); 418 sc->sc_rxtap.wr_ihdr.it_present = WI_RX_RADIOTAP_PRESENT; 419 420 memset(&sc->sc_txtapu, 0, sizeof(sc->sc_txtapu)); 421 sc->sc_txtap.wt_ihdr.it_len = sizeof(sc->sc_txtapu); 422 sc->sc_txtap.wt_ihdr.it_present = WI_TX_RADIOTAP_PRESENT; 423 424 /* Attach is successful. */ 425 sc->sc_attached = 1; 426 427 splx(s); 428 return 0; 429 } 430 431 int 432 wi_detach(struct wi_softc *sc) 433 { 434 struct ifnet *ifp = &sc->sc_ic.ic_if; 435 int s; 436 437 if (!sc->sc_attached) 438 return 0; 439 440 s = splnet(); 441 442 sc->sc_invalid = 1; 443 wi_stop(ifp, 1); 444 445 /* Delete all remaining media. */ 446 ifmedia_delete_instance(&sc->sc_ic.ic_media, IFM_INST_ANY); 447 448 ieee80211_ifdetach(ifp); 449 if_detach(ifp); 450 splx(s); 451 return 0; 452 } 453 454 #ifdef __NetBSD__ 455 int 456 wi_activate(struct device *self, enum devact act) 457 { 458 struct wi_softc *sc = (struct wi_softc *)self; 459 int rv = 0, s; 460 461 s = splnet(); 462 switch (act) { 463 case DVACT_ACTIVATE: 464 rv = EOPNOTSUPP; 465 break; 466 467 case DVACT_DEACTIVATE: 468 if_deactivate(&sc->sc_ic.ic_if); 469 break; 470 } 471 splx(s); 472 return rv; 473 } 474 475 void 476 wi_power(struct wi_softc *sc, int why) 477 { 478 struct ifnet *ifp = &sc->sc_ic.ic_if; 479 int s; 480 481 s = splnet(); 482 switch (why) { 483 case PWR_SUSPEND: 484 case PWR_STANDBY: 485 wi_stop(ifp, 1); 486 break; 487 case PWR_RESUME: 488 if (ifp->if_flags & IFF_UP) { 489 wi_init(ifp); 490 (void)wi_intr(sc); 491 } 492 break; 493 case PWR_SOFTSUSPEND: 494 case PWR_SOFTSTANDBY: 495 case PWR_SOFTRESUME: 496 break; 497 } 498 splx(s); 499 } 500 #endif /* __NetBSD__ */ 501 502 void 503 wi_shutdown(struct wi_softc *sc) 504 { 505 struct ifnet *ifp = &sc->sc_ic.ic_if; 506 507 if (sc->sc_attached) 508 wi_stop(ifp, 1); 509 } 510 511 int 512 wi_intr(void *arg) 513 { 514 int i; 515 struct wi_softc *sc = arg; 516 struct ifnet *ifp = &sc->sc_ic.ic_if; 517 u_int16_t status; 518 519 if (sc->sc_enabled == 0 || 520 (sc->sc_dev.dv_flags & DVF_ACTIVE) == 0 || 521 (ifp->if_flags & IFF_RUNNING) == 0) 522 return 0; 523 524 if ((ifp->if_flags & IFF_UP) == 0) { 525 CSR_WRITE_2(sc, WI_INT_EN, 0); 526 CSR_WRITE_2(sc, WI_EVENT_ACK, ~0); 527 return 1; 528 } 529 530 /* This is superfluous on Prism, but Lucent breaks if we 531 * do not disable interrupts. 532 */ 533 CSR_WRITE_2(sc, WI_INT_EN, 0); 534 535 /* maximum 10 loops per interrupt */ 536 for (i = 0; i < 10; i++) { 537 /* 538 * Only believe a status bit when we enter wi_intr, or when 539 * the bit was "off" the last time through the loop. This is 540 * my strategy to avoid racing the hardware/firmware if I 541 * can re-read the event status register more quickly than 542 * it is updated. 543 */ 544 status = CSR_READ_2(sc, WI_EVENT_STAT); 545 if ((status & WI_INTRS) == 0) 546 break; 547 548 if (status & WI_EV_RX) 549 wi_rx_intr(sc); 550 551 if (status & WI_EV_ALLOC) 552 wi_txalloc_intr(sc); 553 554 if (status & WI_EV_TX) 555 wi_tx_intr(sc); 556 557 if (status & WI_EV_TX_EXC) 558 wi_tx_ex_intr(sc); 559 560 if (status & WI_EV_INFO) 561 wi_info_intr(sc); 562 563 if ((ifp->if_flags & IFF_OACTIVE) == 0 && 564 (sc->sc_flags & WI_FLAGS_OUTRANGE) == 0 && 565 !IFQ_IS_EMPTY(&ifp->if_snd)) 566 wi_start(ifp); 567 } 568 569 /* re-enable interrupts */ 570 CSR_WRITE_2(sc, WI_INT_EN, WI_INTRS); 571 572 return 1; 573 } 574 575 #define arraylen(a) (sizeof(a) / sizeof((a)[0])) 576 577 static void 578 wi_rssdescs_init(struct wi_rssdesc (*rssd)[WI_NTXRSS], wi_rssdescq_t *rssdfree) 579 { 580 int i; 581 SLIST_INIT(rssdfree); 582 for (i = 0; i < arraylen(*rssd); i++) { 583 SLIST_INSERT_HEAD(rssdfree, &(*rssd)[i], rd_next); 584 } 585 } 586 587 static void 588 wi_rssdescs_reset(struct ieee80211com *ic, struct wi_rssdesc (*rssd)[WI_NTXRSS], 589 wi_rssdescq_t *rssdfree, u_int8_t (*txpending)[IEEE80211_RATE_MAXSIZE]) 590 { 591 struct ieee80211_node *ni; 592 int i; 593 for (i = 0; i < arraylen(*rssd); i++) { 594 ni = (*rssd)[i].rd_desc.id_node; 595 (*rssd)[i].rd_desc.id_node = NULL; 596 if (ni != NULL && (ic->ic_if.if_flags & IFF_DEBUG) != 0) 597 printf("%s: cleaning outstanding rssadapt " 598 "descriptor for %s\n", 599 ic->ic_if.if_xname, ether_sprintf(ni->ni_macaddr)); 600 if (ni != NULL && ni != ic->ic_bss) 601 ieee80211_free_node(ic, ni); 602 } 603 memset(*txpending, 0, sizeof(*txpending)); 604 wi_rssdescs_init(rssd, rssdfree); 605 } 606 607 static int 608 wi_init(struct ifnet *ifp) 609 { 610 struct wi_softc *sc = ifp->if_softc; 611 struct ieee80211com *ic = &sc->sc_ic; 612 struct wi_joinreq join; 613 int i; 614 int error = 0, wasenabled; 615 616 DPRINTF(("wi_init: enabled %d\n", sc->sc_enabled)); 617 wasenabled = sc->sc_enabled; 618 if (!sc->sc_enabled) { 619 if ((error = (*sc->sc_enable)(sc)) != 0) 620 goto out; 621 sc->sc_enabled = 1; 622 } else 623 wi_stop(ifp, 0); 624 625 /* Symbol firmware cannot be initialized more than once */ 626 if (sc->sc_firmware_type != WI_SYMBOL || !wasenabled) 627 if ((error = wi_reset(sc)) != 0) 628 goto out; 629 630 /* common 802.11 configuration */ 631 ic->ic_flags &= ~IEEE80211_F_IBSSON; 632 sc->sc_flags &= ~WI_FLAGS_OUTRANGE; 633 switch (ic->ic_opmode) { 634 case IEEE80211_M_STA: 635 wi_write_val(sc, WI_RID_PORTTYPE, WI_PORTTYPE_BSS); 636 break; 637 case IEEE80211_M_IBSS: 638 wi_write_val(sc, WI_RID_PORTTYPE, sc->sc_ibss_port); 639 ic->ic_flags |= IEEE80211_F_IBSSON; 640 sc->sc_syn_timer = 5; 641 ifp->if_timer = 1; 642 break; 643 case IEEE80211_M_AHDEMO: 644 wi_write_val(sc, WI_RID_PORTTYPE, WI_PORTTYPE_ADHOC); 645 break; 646 case IEEE80211_M_HOSTAP: 647 wi_write_val(sc, WI_RID_PORTTYPE, WI_PORTTYPE_HOSTAP); 648 break; 649 case IEEE80211_M_MONITOR: 650 if (sc->sc_firmware_type == WI_LUCENT) 651 wi_write_val(sc, WI_RID_PORTTYPE, WI_PORTTYPE_ADHOC); 652 wi_cmd(sc, WI_CMD_TEST | (WI_TEST_MONITOR << 8), 0, 0, 0); 653 break; 654 } 655 656 /* Intersil interprets this RID as joining ESS even in IBSS mode */ 657 if (sc->sc_firmware_type == WI_LUCENT && 658 (ic->ic_flags & IEEE80211_F_IBSSON) && ic->ic_des_esslen > 0) 659 wi_write_val(sc, WI_RID_CREATE_IBSS, 1); 660 else 661 wi_write_val(sc, WI_RID_CREATE_IBSS, 0); 662 wi_write_val(sc, WI_RID_MAX_SLEEP, ic->ic_lintval); 663 wi_write_ssid(sc, WI_RID_DESIRED_SSID, ic->ic_des_essid, 664 ic->ic_des_esslen); 665 wi_write_val(sc, WI_RID_OWN_CHNL, 666 ieee80211_chan2ieee(ic, ic->ic_ibss_chan)); 667 wi_write_ssid(sc, WI_RID_OWN_SSID, ic->ic_des_essid, ic->ic_des_esslen); 668 IEEE80211_ADDR_COPY(ic->ic_myaddr, LLADDR(ifp->if_sadl)); 669 wi_write_rid(sc, WI_RID_MAC_NODE, ic->ic_myaddr, IEEE80211_ADDR_LEN); 670 wi_write_val(sc, WI_RID_PM_ENABLED, 671 (ic->ic_flags & IEEE80211_F_PMGTON) ? 1 : 0); 672 673 /* not yet common 802.11 configuration */ 674 wi_write_val(sc, WI_RID_MAX_DATALEN, sc->sc_max_datalen); 675 wi_write_val(sc, WI_RID_RTS_THRESH, sc->sc_rts_thresh); 676 if (sc->sc_flags & WI_FLAGS_HAS_FRAGTHR) 677 wi_write_val(sc, WI_RID_FRAG_THRESH, sc->sc_frag_thresh); 678 679 /* driver specific 802.11 configuration */ 680 if (sc->sc_flags & WI_FLAGS_HAS_SYSSCALE) 681 wi_write_val(sc, WI_RID_SYSTEM_SCALE, sc->sc_system_scale); 682 if (sc->sc_flags & WI_FLAGS_HAS_ROAMING) 683 wi_write_val(sc, WI_RID_ROAMING_MODE, sc->sc_roaming_mode); 684 if (sc->sc_flags & WI_FLAGS_HAS_MOR) 685 wi_write_val(sc, WI_RID_MICROWAVE_OVEN, sc->sc_microwave_oven); 686 wi_cfg_txrate(sc); 687 wi_write_ssid(sc, WI_RID_NODENAME, sc->sc_nodename, sc->sc_nodelen); 688 689 if (ic->ic_opmode == IEEE80211_M_HOSTAP && 690 sc->sc_firmware_type == WI_INTERSIL) { 691 wi_write_val(sc, WI_RID_OWN_BEACON_INT, ic->ic_lintval); 692 wi_write_val(sc, WI_RID_BASIC_RATE, 0x03); /* 1, 2 */ 693 wi_write_val(sc, WI_RID_SUPPORT_RATE, 0x0f); /* 1, 2, 5.5, 11 */ 694 wi_write_val(sc, WI_RID_DTIM_PERIOD, 1); 695 } 696 697 if (sc->sc_firmware_type == WI_INTERSIL && 698 (sc->sc_flags & WI_FLAGS_RSSADAPT) != 0) 699 wi_write_val(sc, WI_RID_ALT_RETRY_COUNT, sc->sc_alt_retry); 700 701 /* 702 * Initialize promisc mode. 703 * Being in Host-AP mode causes a great 704 * deal of pain if promiscuous mode is set. 705 * Therefore we avoid confusing the firmware 706 * and always reset promisc mode in Host-AP 707 * mode. Host-AP sees all the packets anyway. 708 */ 709 if (ic->ic_opmode != IEEE80211_M_HOSTAP && 710 (ifp->if_flags & IFF_PROMISC) != 0) { 711 wi_write_val(sc, WI_RID_PROMISC, 1); 712 } else { 713 wi_write_val(sc, WI_RID_PROMISC, 0); 714 } 715 716 /* Configure WEP. */ 717 if (ic->ic_caps & IEEE80211_C_WEP) 718 wi_write_wep(sc); 719 720 /* Set multicast filter. */ 721 wi_write_multi(sc); 722 723 if (sc->sc_firmware_type != WI_SYMBOL || !wasenabled) { 724 sc->sc_buflen = IEEE80211_MAX_LEN + sizeof(struct wi_frame); 725 if (sc->sc_firmware_type == WI_SYMBOL) 726 sc->sc_buflen = 1585; /* XXX */ 727 for (i = 0; i < WI_NTXBUF; i++) { 728 error = wi_alloc_fid(sc, sc->sc_buflen, 729 &sc->sc_txd[i].d_fid); 730 if (error) { 731 printf("%s: tx buffer allocation failed\n", 732 sc->sc_dev.dv_xname); 733 goto out; 734 } 735 DPRINTF2(("wi_init: txbuf %d allocated %x\n", i, 736 sc->sc_txd[i].d_fid)); 737 sc->sc_txd[i].d_len = 0; 738 } 739 } 740 sc->sc_txcur = sc->sc_txnext = 0; 741 742 wi_rssdescs_init(&sc->sc_rssd, &sc->sc_rssdfree); 743 744 /* Enable desired port */ 745 wi_cmd(sc, WI_CMD_ENABLE | sc->sc_portnum, 0, 0, 0); 746 ifp->if_flags |= IFF_RUNNING; 747 ifp->if_flags &= ~IFF_OACTIVE; 748 ic->ic_state = IEEE80211_S_INIT; 749 750 if (ic->ic_opmode == IEEE80211_M_AHDEMO || 751 ic->ic_opmode == IEEE80211_M_MONITOR || 752 ic->ic_opmode == IEEE80211_M_HOSTAP) 753 ieee80211_new_state(ic, IEEE80211_S_RUN, -1); 754 755 /* Enable interrupts */ 756 CSR_WRITE_2(sc, WI_INT_EN, WI_INTRS); 757 758 if (!wasenabled && 759 ic->ic_opmode == IEEE80211_M_HOSTAP && 760 sc->sc_firmware_type == WI_INTERSIL) { 761 /* XXX: some card need to be re-enabled for hostap */ 762 wi_cmd(sc, WI_CMD_DISABLE | WI_PORT0, 0, 0, 0); 763 wi_cmd(sc, WI_CMD_ENABLE | WI_PORT0, 0, 0, 0); 764 } 765 766 if (ic->ic_opmode == IEEE80211_M_STA && 767 ((ic->ic_flags & IEEE80211_F_DESBSSID) || 768 ic->ic_des_chan != IEEE80211_CHAN_ANYC)) { 769 memset(&join, 0, sizeof(join)); 770 if (ic->ic_flags & IEEE80211_F_DESBSSID) 771 IEEE80211_ADDR_COPY(&join.wi_bssid, ic->ic_des_bssid); 772 if (ic->ic_des_chan != IEEE80211_CHAN_ANYC) 773 join.wi_chan = 774 htole16(ieee80211_chan2ieee(ic, ic->ic_des_chan)); 775 /* Lucent firmware does not support the JOIN RID. */ 776 if (sc->sc_firmware_type != WI_LUCENT) 777 wi_write_rid(sc, WI_RID_JOIN_REQ, &join, sizeof(join)); 778 } 779 780 out: 781 if (error) { 782 printf("%s: interface not running\n", sc->sc_dev.dv_xname); 783 wi_stop(ifp, 0); 784 } 785 DPRINTF(("wi_init: return %d\n", error)); 786 return error; 787 } 788 789 static void 790 wi_stop(struct ifnet *ifp, int disable) 791 { 792 struct wi_softc *sc = ifp->if_softc; 793 struct ieee80211com *ic = &sc->sc_ic; 794 int s; 795 796 if (!sc->sc_enabled) 797 return; 798 799 s = splnet(); 800 801 DPRINTF(("wi_stop: disable %d\n", disable)); 802 803 ieee80211_new_state(ic, IEEE80211_S_INIT, -1); 804 if (!sc->sc_invalid) { 805 CSR_WRITE_2(sc, WI_INT_EN, 0); 806 wi_cmd(sc, WI_CMD_DISABLE | sc->sc_portnum, 0, 0, 0); 807 } 808 809 wi_rssdescs_reset(ic, &sc->sc_rssd, &sc->sc_rssdfree, 810 &sc->sc_txpending); 811 812 sc->sc_tx_timer = 0; 813 sc->sc_scan_timer = 0; 814 sc->sc_syn_timer = 0; 815 sc->sc_false_syns = 0; 816 sc->sc_naps = 0; 817 ifp->if_flags &= ~(IFF_OACTIVE | IFF_RUNNING); 818 ifp->if_timer = 0; 819 820 if (disable) { 821 if (sc->sc_disable) 822 (*sc->sc_disable)(sc); 823 sc->sc_enabled = 0; 824 } 825 splx(s); 826 } 827 828 /* 829 * Choose a data rate for a packet len bytes long that suits the packet 830 * type and, if WI_FLAGS_RSSADAPT, the wireless conditions. 831 * 832 * TBD Adapt fragmentation threshold. 833 */ 834 static void 835 wi_choose_rate(struct ieee80211com *ic, struct ieee80211_node *ni, 836 struct ieee80211_frame *wh, u_int len) 837 { 838 struct wi_softc *sc = ic->ic_if.if_softc; 839 struct ieee80211_rssadapt *ra; 840 u_int16_t (*thrs)[IEEE80211_RATE_SIZE]; 841 struct wi_node *wn; 842 int flags = 0, i, rateidx = 0, s, thridx, top; 843 struct ieee80211_rateset *rs; 844 845 s = splnet(); 846 847 wn = (void*)ni; 848 ra = &wn->wn_rssadapt; 849 rs = &ni->ni_rates; 850 851 if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_CTL) 852 flags |= IEEE80211_RATE_BASIC; 853 854 for (i = 0, top = IEEE80211_RSSADAPT_BKT0; 855 i < IEEE80211_RSSADAPT_BKTS; 856 i++, top <<= IEEE80211_RSSADAPT_BKTPOWER) { 857 thridx = i; 858 if (len <= top) 859 break; 860 } 861 862 thrs = &ra->ra_rate_thresh[thridx]; 863 864 if (ic->ic_fixed_rate != -1) { 865 if ((rs->rs_rates[ic->ic_fixed_rate] & flags) == flags) { 866 ni->ni_txrate = ic->ic_fixed_rate; 867 return; 868 } 869 flags |= IEEE80211_RATE_BASIC; 870 i = ic->ic_fixed_rate; 871 } else 872 i = rs->rs_nrates; 873 874 while (--i >= 0) { 875 rateidx = i; 876 if ((rs->rs_rates[i] & flags) != flags) 877 continue; 878 if ((sc->sc_flags & WI_FLAGS_RSSADAPT) == 0) 879 break; 880 if ((*thrs)[i] < ra->ra_avg_rssi) 881 break; 882 } 883 884 if (ic->ic_if.if_flags & IFF_DEBUG) 885 printf("%s: dst %s threshold[%d, %d.%d] %d < %d\n", 886 ic->ic_if.if_xname, ether_sprintf(wh->i_addr1), len, 887 (rs->rs_rates[rateidx] & IEEE80211_RATE_VAL) / 2, 888 (rs->rs_rates[rateidx] & IEEE80211_RATE_VAL) * 5 % 10, 889 (*thrs)[rateidx], ra->ra_avg_rssi); 890 if (ic->ic_opmode != IEEE80211_M_HOSTAP) { 891 /* choose the slowest pending rate so that we don't 892 * accidentally send a packet on the MAC's queue 893 * too fast. TBD find out if the MAC labels Tx 894 * packets w/ rate when enqueued or dequeued. 895 */ 896 for (i = 0; i < rateidx && sc->sc_txpending[i] == 0; i++); 897 ni->ni_txrate = i; 898 } else 899 ni->ni_txrate = rateidx; 900 splx(s); 901 return; 902 } 903 904 static void 905 wi_raise_rate(struct ieee80211com *ic, struct ieee80211_rssdesc *id) 906 { 907 struct wi_node *wn; 908 if (id->id_node == NULL) 909 return; 910 911 wn = (void*)id->id_node; 912 ieee80211_rssadapt_raise_rate(ic, &wn->wn_rssadapt, id); 913 } 914 915 static void 916 wi_lower_rate(struct ieee80211com *ic, struct ieee80211_rssdesc *id) 917 { 918 struct ieee80211_node *ni; 919 struct wi_node *wn; 920 int s; 921 922 s = splnet(); 923 924 if ((ni = id->id_node) == NULL) { 925 DPRINTF(("wi_lower_rate: missing node\n")); 926 goto out; 927 } 928 929 wn = (void *)ni; 930 931 ieee80211_rssadapt_lower_rate(ic, ni, &wn->wn_rssadapt, id); 932 out: 933 splx(s); 934 return; 935 } 936 937 static void 938 wi_start(struct ifnet *ifp) 939 { 940 struct wi_softc *sc = ifp->if_softc; 941 struct ieee80211com *ic = &sc->sc_ic; 942 struct ieee80211_node *ni; 943 struct ieee80211_frame *wh; 944 struct ieee80211_rateset *rs; 945 struct wi_rssdesc *rd; 946 struct ieee80211_rssdesc *id; 947 struct mbuf *m0; 948 struct wi_frame frmhdr; 949 int cur, fid, off; 950 951 if (!sc->sc_enabled || sc->sc_invalid) 952 return; 953 if (sc->sc_flags & WI_FLAGS_OUTRANGE) 954 return; 955 956 memset(&frmhdr, 0, sizeof(frmhdr)); 957 cur = sc->sc_txnext; 958 for (;;) { 959 ni = ic->ic_bss; 960 if (!IF_IS_EMPTY(&ic->ic_mgtq)) { 961 if (sc->sc_txd[cur].d_len != 0 || 962 SLIST_EMPTY(&sc->sc_rssdfree)) { 963 ifp->if_flags |= IFF_OACTIVE; 964 break; 965 } 966 IF_DEQUEUE(&ic->ic_mgtq, m0); 967 m_copydata(m0, 4, ETHER_ADDR_LEN * 2, 968 (caddr_t)&frmhdr.wi_ehdr); 969 frmhdr.wi_ehdr.ether_type = 0; 970 wh = mtod(m0, struct ieee80211_frame *); 971 ni = (struct ieee80211_node *)m0->m_pkthdr.rcvif; 972 m0->m_pkthdr.rcvif = NULL; 973 } else if (!IF_IS_EMPTY(&ic->ic_pwrsaveq)) { 974 struct llc *llc; 975 976 /* 977 * Should these packets be processed after the 978 * regular packets or before? Since they are being 979 * probed for, they are probably less time critical 980 * than other packets, but, on the other hand, 981 * we want the power saving nodes to go back to 982 * sleep as quickly as possible to save power... 983 */ 984 985 if (ic->ic_state != IEEE80211_S_RUN) 986 break; 987 988 if (sc->sc_txd[cur].d_len != 0 || 989 SLIST_EMPTY(&sc->sc_rssdfree)) { 990 ifp->if_flags |= IFF_OACTIVE; 991 break; 992 } 993 IF_DEQUEUE(&ic->ic_pwrsaveq, m0); 994 wh = mtod(m0, struct ieee80211_frame *); 995 llc = (struct llc *) (wh + 1); 996 m_copydata(m0, 4, ETHER_ADDR_LEN * 2, 997 (caddr_t)&frmhdr.wi_ehdr); 998 frmhdr.wi_ehdr.ether_type = llc->llc_snap.ether_type; 999 ni = (struct ieee80211_node *)m0->m_pkthdr.rcvif; 1000 m0->m_pkthdr.rcvif = NULL; 1001 } else { 1002 if (ic->ic_state != IEEE80211_S_RUN) { 1003 break; 1004 } 1005 IFQ_POLL(&ifp->if_snd, m0); 1006 if (m0 == NULL) { 1007 break; 1008 } 1009 if (sc->sc_txd[cur].d_len != 0 || 1010 SLIST_EMPTY(&sc->sc_rssdfree)) { 1011 ifp->if_flags |= IFF_OACTIVE; 1012 break; 1013 } 1014 IFQ_DEQUEUE(&ifp->if_snd, m0); 1015 ifp->if_opackets++; 1016 m_copydata(m0, 0, ETHER_HDR_LEN, 1017 (caddr_t)&frmhdr.wi_ehdr); 1018 #if NBPFILTER > 0 1019 if (ifp->if_bpf) 1020 bpf_mtap(ifp->if_bpf, m0); 1021 #endif 1022 1023 if ((m0 = ieee80211_encap(ifp, m0, &ni)) == NULL) { 1024 ifp->if_oerrors++; 1025 continue; 1026 } 1027 wh = mtod(m0, struct ieee80211_frame *); 1028 if (ic->ic_flags & IEEE80211_F_WEPON) 1029 wh->i_fc[1] |= IEEE80211_FC1_WEP; 1030 if (ic->ic_opmode == IEEE80211_M_HOSTAP && 1031 !IEEE80211_IS_MULTICAST(wh->i_addr1) && 1032 (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) == 1033 IEEE80211_FC0_TYPE_DATA) { 1034 if (ni->ni_associd == 0) { 1035 m_freem(m0); 1036 ifp->if_oerrors++; 1037 goto next; 1038 } 1039 if (ni->ni_pwrsave & IEEE80211_PS_SLEEP) { 1040 ieee80211_pwrsave(ic, ni, m0); 1041 continue; /* don't free node. */ 1042 } 1043 } 1044 } 1045 #if NBPFILTER > 0 1046 if (ic->ic_rawbpf) 1047 bpf_mtap(ic->ic_rawbpf, m0); 1048 #endif 1049 frmhdr.wi_tx_ctl = 1050 htole16(WI_ENC_TX_802_11|WI_TXCNTL_TX_EX|WI_TXCNTL_TX_OK); 1051 if (ic->ic_opmode == IEEE80211_M_HOSTAP && 1052 (wh->i_fc[1] & IEEE80211_FC1_WEP)) { 1053 if ((m0 = ieee80211_wep_crypt(ifp, m0, 1)) == NULL) { 1054 ifp->if_oerrors++; 1055 goto next; 1056 } 1057 frmhdr.wi_tx_ctl |= htole16(WI_TXCNTL_NOCRYPT); 1058 } 1059 1060 wi_choose_rate(ic, ni, wh, m0->m_pkthdr.len); 1061 1062 #if NBPFILTER > 0 1063 if (sc->sc_drvbpf) { 1064 struct mbuf mb; 1065 1066 struct wi_tx_radiotap_header *tap = &sc->sc_txtap; 1067 1068 tap->wt_rate = ni->ni_rates.rs_rates[ni->ni_txrate]; 1069 tap->wt_chan_freq = 1070 htole16(ic->ic_bss->ni_chan->ic_freq); 1071 tap->wt_chan_flags = 1072 htole16(ic->ic_bss->ni_chan->ic_flags); 1073 1074 /* TBD tap->wt_flags */ 1075 1076 M_COPY_PKTHDR(&mb, m0); 1077 mb.m_data = (caddr_t)tap; 1078 mb.m_len = tap->wt_ihdr.it_len; 1079 mb.m_next = m0; 1080 mb.m_pkthdr.len += mb.m_len; 1081 bpf_mtap(sc->sc_drvbpf, &mb); 1082 } 1083 #endif 1084 rs = &ni->ni_rates; 1085 rd = SLIST_FIRST(&sc->sc_rssdfree); 1086 id = &rd->rd_desc; 1087 id->id_len = m0->m_pkthdr.len; 1088 sc->sc_txd[cur].d_rate = id->id_rateidx = ni->ni_txrate; 1089 id->id_rssi = ni->ni_rssi; 1090 1091 frmhdr.wi_tx_idx = rd - sc->sc_rssd; 1092 1093 if (ic->ic_opmode == IEEE80211_M_HOSTAP) 1094 frmhdr.wi_tx_rate = 5 * (rs->rs_rates[ni->ni_txrate] & 1095 IEEE80211_RATE_VAL); 1096 else if (sc->sc_flags & WI_FLAGS_RSSADAPT) 1097 (void)wi_write_txrate(sc, rs->rs_rates[ni->ni_txrate]); 1098 1099 m_copydata(m0, 0, sizeof(struct ieee80211_frame), 1100 (caddr_t)&frmhdr.wi_whdr); 1101 m_adj(m0, sizeof(struct ieee80211_frame)); 1102 frmhdr.wi_dat_len = htole16(m0->m_pkthdr.len); 1103 if (IFF_DUMPPKTS(ifp)) 1104 wi_dump_pkt(&frmhdr, ni, -1); 1105 fid = sc->sc_txd[cur].d_fid; 1106 off = sizeof(frmhdr); 1107 if (wi_write_bap(sc, fid, 0, &frmhdr, sizeof(frmhdr)) != 0 || 1108 wi_mwrite_bap(sc, fid, off, m0, m0->m_pkthdr.len) != 0) { 1109 ifp->if_oerrors++; 1110 m_freem(m0); 1111 goto next; 1112 } 1113 m_freem(m0); 1114 sc->sc_txd[cur].d_len = off; 1115 if (sc->sc_txcur == cur) { 1116 if (wi_cmd(sc, WI_CMD_TX | WI_RECLAIM, fid, 0, 0)) { 1117 printf("%s: xmit failed\n", 1118 sc->sc_dev.dv_xname); 1119 sc->sc_txd[cur].d_len = 0; 1120 goto next; 1121 } 1122 sc->sc_txpending[ni->ni_txrate]++; 1123 sc->sc_tx_timer = 5; 1124 ifp->if_timer = 1; 1125 } 1126 sc->sc_txnext = cur = (cur + 1) % WI_NTXBUF; 1127 SLIST_REMOVE_HEAD(&sc->sc_rssdfree, rd_next); 1128 if (sc->sc_flags & WI_FLAGS_RSSADAPT) { 1129 id->id_node = ni; 1130 } else 1131 next: 1132 if (ni != NULL && ni != ic->ic_bss) 1133 ieee80211_free_node(ic, ni); 1134 } 1135 } 1136 1137 1138 static int 1139 wi_reset(struct wi_softc *sc) 1140 { 1141 int i, error; 1142 1143 DPRINTF(("wi_reset\n")); 1144 1145 if (sc->sc_reset) 1146 (*sc->sc_reset)(sc); 1147 1148 error = 0; 1149 for (i = 0; i < 5; i++) { 1150 DELAY(20*1000); /* XXX: way too long! */ 1151 if ((error = wi_cmd(sc, WI_CMD_INI, 0, 0, 0)) == 0) 1152 break; 1153 } 1154 if (error) { 1155 printf("%s: init failed\n", sc->sc_dev.dv_xname); 1156 return error; 1157 } 1158 CSR_WRITE_2(sc, WI_INT_EN, 0); 1159 CSR_WRITE_2(sc, WI_EVENT_ACK, ~0); 1160 1161 /* Calibrate timer. */ 1162 wi_write_val(sc, WI_RID_TICK_TIME, 0); 1163 return 0; 1164 } 1165 1166 static void 1167 wi_watchdog(struct ifnet *ifp) 1168 { 1169 struct wi_softc *sc = ifp->if_softc; 1170 struct ieee80211com *ic = &sc->sc_ic; 1171 1172 ifp->if_timer = 0; 1173 if (!sc->sc_enabled) 1174 return; 1175 1176 if (sc->sc_tx_timer) { 1177 if (--sc->sc_tx_timer == 0) { 1178 printf("%s: device timeout\n", ifp->if_xname); 1179 ifp->if_oerrors++; 1180 wi_init(ifp); 1181 return; 1182 } 1183 ifp->if_timer = 1; 1184 } 1185 1186 if (sc->sc_scan_timer) { 1187 if (--sc->sc_scan_timer <= WI_SCAN_WAIT - WI_SCAN_INQWAIT && 1188 sc->sc_firmware_type == WI_INTERSIL) { 1189 DPRINTF(("wi_watchdog: inquire scan\n")); 1190 wi_cmd(sc, WI_CMD_INQUIRE, WI_INFO_SCAN_RESULTS, 0, 0); 1191 } 1192 if (sc->sc_scan_timer) 1193 ifp->if_timer = 1; 1194 } 1195 1196 if (sc->sc_syn_timer) { 1197 if (--sc->sc_syn_timer == 0) { 1198 DPRINTF2(("%s: %d false syns\n", 1199 sc->sc_dev.dv_xname, sc->sc_false_syns)); 1200 sc->sc_false_syns = 0; 1201 ieee80211_new_state(ic, IEEE80211_S_RUN, -1); 1202 sc->sc_syn_timer = 5; 1203 } 1204 ifp->if_timer = 1; 1205 } 1206 1207 /* TODO: rate control */ 1208 ieee80211_watchdog(ifp); 1209 } 1210 1211 static int 1212 wi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 1213 { 1214 struct wi_softc *sc = ifp->if_softc; 1215 struct ieee80211com *ic = &sc->sc_ic; 1216 struct ifreq *ifr = (struct ifreq *)data; 1217 int s, error = 0; 1218 1219 if ((sc->sc_dev.dv_flags & DVF_ACTIVE) == 0) 1220 return ENXIO; 1221 1222 s = splnet(); 1223 1224 switch (cmd) { 1225 case SIOCSIFFLAGS: 1226 /* 1227 * Can't do promisc and hostap at the same time. If all that's 1228 * changing is the promisc flag, try to short-circuit a call to 1229 * wi_init() by just setting PROMISC in the hardware. 1230 */ 1231 if (ifp->if_flags & IFF_UP) { 1232 if (sc->sc_enabled) { 1233 if (ic->ic_opmode != IEEE80211_M_HOSTAP && 1234 (ifp->if_flags & IFF_PROMISC) != 0) 1235 wi_write_val(sc, WI_RID_PROMISC, 1); 1236 else 1237 wi_write_val(sc, WI_RID_PROMISC, 0); 1238 } else 1239 error = wi_init(ifp); 1240 } else if (sc->sc_enabled) 1241 wi_stop(ifp, 1); 1242 break; 1243 case SIOCSIFMEDIA: 1244 case SIOCGIFMEDIA: 1245 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd); 1246 break; 1247 case SIOCADDMULTI: 1248 case SIOCDELMULTI: 1249 error = (cmd == SIOCADDMULTI) ? 1250 ether_addmulti(ifr, &sc->sc_ic.ic_ec) : 1251 ether_delmulti(ifr, &sc->sc_ic.ic_ec); 1252 if (error == ENETRESET) { 1253 if (sc->sc_enabled) { 1254 /* do not rescan */ 1255 error = wi_write_multi(sc); 1256 } else 1257 error = 0; 1258 } 1259 break; 1260 case SIOCGIFGENERIC: 1261 error = wi_get_cfg(ifp, cmd, data); 1262 break; 1263 case SIOCSIFGENERIC: 1264 error = suser(curproc->p_ucred, &curproc->p_acflag); 1265 if (error) 1266 break; 1267 error = wi_set_cfg(ifp, cmd, data); 1268 if (error == ENETRESET) { 1269 if (sc->sc_enabled) 1270 error = wi_init(ifp); 1271 else 1272 error = 0; 1273 } 1274 break; 1275 case SIOCS80211BSSID: 1276 if (sc->sc_firmware_type == WI_LUCENT) { 1277 error = ENODEV; 1278 break; 1279 } 1280 /* fall through */ 1281 default: 1282 error = ieee80211_ioctl(ifp, cmd, data); 1283 if (error == ENETRESET) { 1284 if (sc->sc_enabled) 1285 error = wi_init(ifp); 1286 else 1287 error = 0; 1288 } 1289 break; 1290 } 1291 splx(s); 1292 return error; 1293 } 1294 1295 /* TBD factor with ieee80211_media_change */ 1296 static int 1297 wi_media_change(struct ifnet *ifp) 1298 { 1299 struct wi_softc *sc = ifp->if_softc; 1300 struct ieee80211com *ic = &sc->sc_ic; 1301 struct ifmedia_entry *ime; 1302 enum ieee80211_opmode newmode; 1303 int i, rate, error = 0; 1304 1305 ime = ic->ic_media.ifm_cur; 1306 if (IFM_SUBTYPE(ime->ifm_media) == IFM_AUTO) { 1307 i = -1; 1308 } else { 1309 struct ieee80211_rateset *rs = 1310 &ic->ic_sup_rates[ieee80211_chan2mode(ic, 1311 ic->ic_bss->ni_chan)]; 1312 rate = ieee80211_media2rate(ime->ifm_media); 1313 if (rate == 0) 1314 return EINVAL; 1315 for (i = 0; i < rs->rs_nrates; i++) { 1316 if ((rs->rs_rates[i] & IEEE80211_RATE_VAL) == rate) 1317 break; 1318 } 1319 if (i == rs->rs_nrates) 1320 return EINVAL; 1321 } 1322 if (ic->ic_fixed_rate != i) { 1323 ic->ic_fixed_rate = i; 1324 error = ENETRESET; 1325 } 1326 1327 if ((ime->ifm_media & IFM_IEEE80211_ADHOC) && 1328 (ime->ifm_media & IFM_FLAG0)) 1329 newmode = IEEE80211_M_AHDEMO; 1330 else if (ime->ifm_media & IFM_IEEE80211_ADHOC) 1331 newmode = IEEE80211_M_IBSS; 1332 else if (ime->ifm_media & IFM_IEEE80211_HOSTAP) 1333 newmode = IEEE80211_M_HOSTAP; 1334 else if (ime->ifm_media & IFM_IEEE80211_MONITOR) 1335 newmode = IEEE80211_M_MONITOR; 1336 else 1337 newmode = IEEE80211_M_STA; 1338 if (ic->ic_opmode != newmode) { 1339 ic->ic_opmode = newmode; 1340 error = ENETRESET; 1341 } 1342 if (error == ENETRESET) { 1343 if (sc->sc_enabled) 1344 error = wi_init(ifp); 1345 else 1346 error = 0; 1347 } 1348 ifp->if_baudrate = ifmedia_baudrate(ic->ic_media.ifm_cur->ifm_media); 1349 1350 return error; 1351 } 1352 1353 static void 1354 wi_media_status(struct ifnet *ifp, struct ifmediareq *imr) 1355 { 1356 struct wi_softc *sc = ifp->if_softc; 1357 struct ieee80211com *ic = &sc->sc_ic; 1358 u_int16_t val; 1359 int rate, len; 1360 1361 if (sc->sc_enabled == 0) { 1362 imr->ifm_active = IFM_IEEE80211 | IFM_NONE; 1363 imr->ifm_status = 0; 1364 return; 1365 } 1366 1367 imr->ifm_status = IFM_AVALID; 1368 imr->ifm_active = IFM_IEEE80211; 1369 if (ic->ic_state == IEEE80211_S_RUN && 1370 (sc->sc_flags & WI_FLAGS_OUTRANGE) == 0) 1371 imr->ifm_status |= IFM_ACTIVE; 1372 len = sizeof(val); 1373 if (wi_read_rid(sc, WI_RID_CUR_TX_RATE, &val, &len) != 0) 1374 rate = 0; 1375 else { 1376 /* convert to 802.11 rate */ 1377 val = le16toh(val); 1378 rate = val * 2; 1379 if (sc->sc_firmware_type == WI_LUCENT) { 1380 if (rate == 10) 1381 rate = 11; /* 5.5Mbps */ 1382 } else { 1383 if (rate == 4*2) 1384 rate = 11; /* 5.5Mbps */ 1385 else if (rate == 8*2) 1386 rate = 22; /* 11Mbps */ 1387 } 1388 } 1389 imr->ifm_active |= ieee80211_rate2media(ic, rate, IEEE80211_MODE_11B); 1390 switch (ic->ic_opmode) { 1391 case IEEE80211_M_STA: 1392 break; 1393 case IEEE80211_M_IBSS: 1394 imr->ifm_active |= IFM_IEEE80211_ADHOC; 1395 break; 1396 case IEEE80211_M_AHDEMO: 1397 imr->ifm_active |= IFM_IEEE80211_ADHOC | IFM_FLAG0; 1398 break; 1399 case IEEE80211_M_HOSTAP: 1400 imr->ifm_active |= IFM_IEEE80211_HOSTAP; 1401 break; 1402 case IEEE80211_M_MONITOR: 1403 imr->ifm_active |= IFM_IEEE80211_MONITOR; 1404 break; 1405 } 1406 } 1407 1408 static struct ieee80211_node * 1409 wi_node_alloc(struct ieee80211com *ic) 1410 { 1411 struct wi_node *wn = 1412 malloc(sizeof(struct wi_node), M_DEVBUF, M_NOWAIT | M_ZERO); 1413 return wn ? &wn->wn_node : NULL; 1414 } 1415 1416 static void 1417 wi_node_free(struct ieee80211com *ic, struct ieee80211_node *ni) 1418 { 1419 struct wi_softc *sc = ic->ic_if.if_softc; 1420 int i; 1421 1422 for (i = 0; i < WI_NTXRSS; i++) { 1423 if (sc->sc_rssd[i].rd_desc.id_node == ni) 1424 sc->sc_rssd[i].rd_desc.id_node = NULL; 1425 } 1426 free(ni, M_DEVBUF); 1427 } 1428 1429 static void 1430 wi_node_copy(struct ieee80211com *ic, struct ieee80211_node *dst, 1431 const struct ieee80211_node *src) 1432 { 1433 *(struct wi_node *)dst = *(const struct wi_node *)src; 1434 } 1435 1436 static void 1437 wi_sync_bssid(struct wi_softc *sc, u_int8_t new_bssid[IEEE80211_ADDR_LEN]) 1438 { 1439 struct ieee80211com *ic = &sc->sc_ic; 1440 struct ieee80211_node *ni = ic->ic_bss; 1441 struct ifnet *ifp = &ic->ic_if; 1442 1443 if (IEEE80211_ADDR_EQ(new_bssid, ni->ni_bssid)) 1444 return; 1445 1446 DPRINTF(("wi_sync_bssid: bssid %s -> ", ether_sprintf(ni->ni_bssid))); 1447 DPRINTF(("%s ?\n", ether_sprintf(new_bssid))); 1448 1449 /* In promiscuous mode, the BSSID field is not a reliable 1450 * indicator of the firmware's BSSID. Damp spurious 1451 * change-of-BSSID indications. 1452 */ 1453 if ((ifp->if_flags & IFF_PROMISC) != 0 && 1454 sc->sc_false_syns >= WI_MAX_FALSE_SYNS) 1455 return; 1456 1457 ieee80211_new_state(ic, IEEE80211_S_RUN, -1); 1458 } 1459 1460 static __inline void 1461 wi_rssadapt_input(struct ieee80211com *ic, struct ieee80211_node *ni, 1462 struct ieee80211_frame *wh, int rssi) 1463 { 1464 struct wi_node *wn; 1465 1466 if (ni == NULL) { 1467 printf("%s: null node", __func__); 1468 return; 1469 } 1470 1471 wn = (void*)ni; 1472 ieee80211_rssadapt_input(ic, ni, &wn->wn_rssadapt, rssi); 1473 } 1474 1475 static void 1476 wi_rx_intr(struct wi_softc *sc) 1477 { 1478 struct ieee80211com *ic = &sc->sc_ic; 1479 struct ifnet *ifp = &ic->ic_if; 1480 struct ieee80211_node *ni; 1481 struct wi_frame frmhdr; 1482 struct mbuf *m; 1483 struct ieee80211_frame *wh; 1484 int fid, len, off, rssi; 1485 u_int8_t dir; 1486 u_int16_t status; 1487 u_int32_t rstamp; 1488 1489 fid = CSR_READ_2(sc, WI_RX_FID); 1490 1491 /* First read in the frame header */ 1492 if (wi_read_bap(sc, fid, 0, &frmhdr, sizeof(frmhdr))) { 1493 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX); 1494 ifp->if_ierrors++; 1495 DPRINTF(("wi_rx_intr: read fid %x failed\n", fid)); 1496 return; 1497 } 1498 1499 if (IFF_DUMPPKTS(ifp)) 1500 wi_dump_pkt(&frmhdr, NULL, frmhdr.wi_rx_signal); 1501 1502 /* 1503 * Drop undecryptable or packets with receive errors here 1504 */ 1505 status = le16toh(frmhdr.wi_status); 1506 if ((status & WI_STAT_ERRSTAT) != 0 && 1507 ic->ic_opmode != IEEE80211_M_MONITOR) { 1508 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX); 1509 ifp->if_ierrors++; 1510 DPRINTF(("wi_rx_intr: fid %x error status %x\n", fid, status)); 1511 return; 1512 } 1513 rssi = frmhdr.wi_rx_signal; 1514 rstamp = (le16toh(frmhdr.wi_rx_tstamp0) << 16) | 1515 le16toh(frmhdr.wi_rx_tstamp1); 1516 1517 len = le16toh(frmhdr.wi_dat_len); 1518 off = ALIGN(sizeof(struct ieee80211_frame)); 1519 1520 /* Sometimes the PRISM2.x returns bogusly large frames. Except 1521 * in monitor mode, just throw them away. 1522 */ 1523 if (off + len > MCLBYTES) { 1524 if (ic->ic_opmode != IEEE80211_M_MONITOR) { 1525 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX); 1526 ifp->if_ierrors++; 1527 DPRINTF(("wi_rx_intr: oversized packet\n")); 1528 return; 1529 } else 1530 len = 0; 1531 } 1532 1533 MGETHDR(m, M_DONTWAIT, MT_DATA); 1534 if (m == NULL) { 1535 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX); 1536 ifp->if_ierrors++; 1537 DPRINTF(("wi_rx_intr: MGET failed\n")); 1538 return; 1539 } 1540 if (off + len > MHLEN) { 1541 MCLGET(m, M_DONTWAIT); 1542 if ((m->m_flags & M_EXT) == 0) { 1543 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX); 1544 m_freem(m); 1545 ifp->if_ierrors++; 1546 DPRINTF(("wi_rx_intr: MCLGET failed\n")); 1547 return; 1548 } 1549 } 1550 1551 m->m_data += off - sizeof(struct ieee80211_frame); 1552 memcpy(m->m_data, &frmhdr.wi_whdr, sizeof(struct ieee80211_frame)); 1553 wi_read_bap(sc, fid, sizeof(frmhdr), 1554 m->m_data + sizeof(struct ieee80211_frame), len); 1555 m->m_pkthdr.len = m->m_len = sizeof(struct ieee80211_frame) + len; 1556 m->m_pkthdr.rcvif = ifp; 1557 1558 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX); 1559 1560 #if NBPFILTER > 0 1561 if (sc->sc_drvbpf) { 1562 struct mbuf mb; 1563 struct wi_rx_radiotap_header *tap = &sc->sc_rxtap; 1564 1565 tap->wr_rate = frmhdr.wi_rx_rate / 5; 1566 tap->wr_antsignal = WI_RSSI_TO_DBM(sc, frmhdr.wi_rx_signal); 1567 tap->wr_antnoise = WI_RSSI_TO_DBM(sc, frmhdr.wi_rx_silence); 1568 1569 tap->wr_chan_freq = htole16(ic->ic_bss->ni_chan->ic_freq); 1570 tap->wr_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags); 1571 if (frmhdr.wi_status & WI_STAT_PCF) 1572 tap->wr_flags |= IEEE80211_RADIOTAP_F_CFP; 1573 1574 M_COPY_PKTHDR(&mb, m); 1575 mb.m_data = (caddr_t)tap; 1576 mb.m_len = tap->wr_ihdr.it_len; 1577 mb.m_next = m; 1578 mb.m_pkthdr.len += mb.m_len; 1579 bpf_mtap(sc->sc_drvbpf, &mb); 1580 } 1581 #endif 1582 wh = mtod(m, struct ieee80211_frame *); 1583 if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 1584 /* 1585 * WEP is decrypted by hardware. Clear WEP bit 1586 * header for ieee80211_input(). 1587 */ 1588 wh->i_fc[1] &= ~IEEE80211_FC1_WEP; 1589 } 1590 1591 /* synchronize driver's BSSID with firmware's BSSID */ 1592 dir = wh->i_fc[1] & IEEE80211_FC1_DIR_MASK; 1593 if (ic->ic_opmode == IEEE80211_M_IBSS && dir == IEEE80211_FC1_DIR_NODS) 1594 wi_sync_bssid(sc, wh->i_addr3); 1595 1596 ni = ieee80211_find_rxnode(ic, wh); 1597 1598 ieee80211_input(ifp, m, ni, rssi, rstamp); 1599 1600 wi_rssadapt_input(ic, ni, wh, rssi); 1601 1602 /* 1603 * The frame may have caused the node to be marked for 1604 * reclamation (e.g. in response to a DEAUTH message) 1605 * so use free_node here instead of unref_node. 1606 */ 1607 if (ni == ic->ic_bss) 1608 ieee80211_unref_node(&ni); 1609 else 1610 ieee80211_free_node(ic, ni); 1611 } 1612 1613 static void 1614 wi_tx_ex_intr(struct wi_softc *sc) 1615 { 1616 struct ieee80211com *ic = &sc->sc_ic; 1617 struct ifnet *ifp = &ic->ic_if; 1618 struct ieee80211_node *ni; 1619 struct ieee80211_rssdesc *id; 1620 struct wi_rssdesc *rssd; 1621 struct wi_frame frmhdr; 1622 int fid; 1623 u_int16_t status; 1624 1625 fid = CSR_READ_2(sc, WI_TX_CMP_FID); 1626 /* Read in the frame header */ 1627 if (wi_read_bap(sc, fid, 0, &frmhdr, sizeof(frmhdr)) != 0) { 1628 printf("wi_tx_ex_intr: read fid %x failed\n", fid); 1629 goto bad_header; 1630 } 1631 1632 if (frmhdr.wi_tx_idx >= WI_NTXRSS) { 1633 printf("%s: bad idx %02x\n", 1634 sc->sc_dev.dv_xname, frmhdr.wi_tx_idx); 1635 goto bad_header; 1636 } 1637 1638 status = le16toh(frmhdr.wi_status); 1639 1640 /* 1641 * Spontaneous station disconnects appear as xmit 1642 * errors. Don't announce them and/or count them 1643 * as an output error. 1644 */ 1645 if (ppsratecheck(&lasttxerror, &curtxeps, wi_txerate)) { 1646 printf("%s: tx failed", sc->sc_dev.dv_xname); 1647 if (status & WI_TXSTAT_RET_ERR) 1648 printf(", retry limit exceeded"); 1649 if (status & WI_TXSTAT_AGED_ERR) 1650 printf(", max transmit lifetime exceeded"); 1651 if (status & WI_TXSTAT_DISCONNECT) 1652 printf(", port disconnected"); 1653 if (status & WI_TXSTAT_FORM_ERR) 1654 printf(", invalid format (data len %u src %s)", 1655 le16toh(frmhdr.wi_dat_len), 1656 ether_sprintf(frmhdr.wi_ehdr.ether_shost)); 1657 if (status & ~0xf) 1658 printf(", status=0x%x", status); 1659 printf("\n"); 1660 } 1661 ifp->if_oerrors++; 1662 rssd = &sc->sc_rssd[frmhdr.wi_tx_idx]; 1663 id = &rssd->rd_desc; 1664 if ((status & WI_TXSTAT_RET_ERR) != 0) 1665 wi_lower_rate(ic, id); 1666 1667 ni = id->id_node; 1668 id->id_node = NULL; 1669 1670 if (sc->sc_txpending[id->id_rateidx]-- == 0) { 1671 printf("%s: txpending[%i] wraparound", __func__, 1672 id->id_rateidx); 1673 sc->sc_txpending[id->id_rateidx] = 0; 1674 } 1675 if (ni != NULL && ni != ic->ic_bss) 1676 ieee80211_free_node(ic, ni); 1677 SLIST_INSERT_HEAD(&sc->sc_rssdfree, rssd, rd_next); 1678 ifp->if_flags &= ~IFF_OACTIVE; 1679 bad_header: 1680 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_TX_EXC); 1681 } 1682 1683 static void 1684 wi_txalloc_intr(struct wi_softc *sc) 1685 { 1686 struct ieee80211com *ic = &sc->sc_ic; 1687 struct ifnet *ifp = &ic->ic_if; 1688 int fid, cur; 1689 1690 fid = CSR_READ_2(sc, WI_ALLOC_FID); 1691 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_ALLOC); 1692 1693 cur = sc->sc_txcur; 1694 if (sc->sc_txd[cur].d_fid != fid) { 1695 printf("%s: bad alloc %x != %x, cur %d nxt %d\n", 1696 sc->sc_dev.dv_xname, fid, sc->sc_txd[cur].d_fid, cur, 1697 sc->sc_txnext); 1698 return; 1699 } 1700 sc->sc_tx_timer = 0; 1701 sc->sc_txd[cur].d_len = 0; 1702 sc->sc_txcur = cur = (cur + 1) % WI_NTXBUF; 1703 if (sc->sc_txd[cur].d_len == 0) 1704 ifp->if_flags &= ~IFF_OACTIVE; 1705 else { 1706 if (wi_cmd(sc, WI_CMD_TX | WI_RECLAIM, sc->sc_txd[cur].d_fid, 1707 0, 0)) { 1708 printf("%s: xmit failed\n", sc->sc_dev.dv_xname); 1709 sc->sc_txd[cur].d_len = 0; 1710 } else { 1711 sc->sc_txpending[sc->sc_txd[cur].d_rate]++; 1712 sc->sc_tx_timer = 5; 1713 ifp->if_timer = 1; 1714 } 1715 } 1716 } 1717 1718 static void 1719 wi_tx_intr(struct wi_softc *sc) 1720 { 1721 struct ieee80211com *ic = &sc->sc_ic; 1722 struct ifnet *ifp = &ic->ic_if; 1723 struct ieee80211_node *ni; 1724 struct ieee80211_rssdesc *id; 1725 struct wi_rssdesc *rssd; 1726 struct wi_frame frmhdr; 1727 int fid; 1728 1729 fid = CSR_READ_2(sc, WI_TX_CMP_FID); 1730 /* Read in the frame header */ 1731 if (wi_read_bap(sc, fid, 0, &frmhdr, sizeof(frmhdr)) != 0) { 1732 printf("wi_tx_intr: read fid %x failed\n", fid); 1733 goto out; 1734 } 1735 1736 if (frmhdr.wi_tx_idx >= WI_NTXRSS) { 1737 printf("%s: bad idx %02x\n", 1738 sc->sc_dev.dv_xname, frmhdr.wi_tx_idx); 1739 goto out; 1740 } 1741 1742 rssd = &sc->sc_rssd[frmhdr.wi_tx_idx]; 1743 id = &rssd->rd_desc; 1744 wi_raise_rate(ic, id); 1745 1746 ni = id->id_node; 1747 id->id_node = NULL; 1748 1749 if (sc->sc_txpending[id->id_rateidx]-- == 0) { 1750 printf("%s: txpending[%i] wraparound", __func__, id->id_rateidx); 1751 sc->sc_txpending[id->id_rateidx] = 0; 1752 } 1753 if (ni != NULL && ni != ic->ic_bss) 1754 ieee80211_free_node(ic, ni); 1755 SLIST_INSERT_HEAD(&sc->sc_rssdfree, rssd, rd_next); 1756 ifp->if_flags &= ~IFF_OACTIVE; 1757 out: 1758 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_TX); 1759 } 1760 1761 static void 1762 wi_info_intr(struct wi_softc *sc) 1763 { 1764 struct ieee80211com *ic = &sc->sc_ic; 1765 struct ifnet *ifp = &ic->ic_if; 1766 int i, fid, len, off; 1767 u_int16_t ltbuf[2]; 1768 u_int16_t stat; 1769 u_int32_t *ptr; 1770 1771 fid = CSR_READ_2(sc, WI_INFO_FID); 1772 wi_read_bap(sc, fid, 0, ltbuf, sizeof(ltbuf)); 1773 1774 switch (le16toh(ltbuf[1])) { 1775 1776 case WI_INFO_LINK_STAT: 1777 wi_read_bap(sc, fid, sizeof(ltbuf), &stat, sizeof(stat)); 1778 DPRINTF(("wi_info_intr: LINK_STAT 0x%x\n", le16toh(stat))); 1779 switch (le16toh(stat)) { 1780 case CONNECTED: 1781 sc->sc_flags &= ~WI_FLAGS_OUTRANGE; 1782 if (ic->ic_state == IEEE80211_S_RUN && 1783 ic->ic_opmode != IEEE80211_M_IBSS) 1784 break; 1785 /* FALLTHROUGH */ 1786 case AP_CHANGE: 1787 ieee80211_new_state(ic, IEEE80211_S_RUN, -1); 1788 break; 1789 case AP_IN_RANGE: 1790 sc->sc_flags &= ~WI_FLAGS_OUTRANGE; 1791 break; 1792 case AP_OUT_OF_RANGE: 1793 if (sc->sc_firmware_type == WI_SYMBOL && 1794 sc->sc_scan_timer > 0) { 1795 if (wi_cmd(sc, WI_CMD_INQUIRE, 1796 WI_INFO_HOST_SCAN_RESULTS, 0, 0) != 0) 1797 sc->sc_scan_timer = 0; 1798 break; 1799 } 1800 if (ic->ic_opmode == IEEE80211_M_STA) 1801 sc->sc_flags |= WI_FLAGS_OUTRANGE; 1802 break; 1803 case DISCONNECTED: 1804 case ASSOC_FAILED: 1805 if (ic->ic_opmode == IEEE80211_M_STA) 1806 ieee80211_new_state(ic, IEEE80211_S_INIT, -1); 1807 break; 1808 } 1809 break; 1810 1811 case WI_INFO_COUNTERS: 1812 /* some card versions have a larger stats structure */ 1813 len = min(le16toh(ltbuf[0]) - 1, sizeof(sc->sc_stats) / 4); 1814 ptr = (u_int32_t *)&sc->sc_stats; 1815 off = sizeof(ltbuf); 1816 for (i = 0; i < len; i++, off += 2, ptr++) { 1817 wi_read_bap(sc, fid, off, &stat, sizeof(stat)); 1818 stat = le16toh(stat); 1819 #ifdef WI_HERMES_STATS_WAR 1820 if (stat & 0xf000) 1821 stat = ~stat; 1822 #endif 1823 *ptr += stat; 1824 } 1825 ifp->if_collisions = sc->sc_stats.wi_tx_single_retries + 1826 sc->sc_stats.wi_tx_multi_retries + 1827 sc->sc_stats.wi_tx_retry_limit; 1828 break; 1829 1830 case WI_INFO_SCAN_RESULTS: 1831 case WI_INFO_HOST_SCAN_RESULTS: 1832 wi_scan_result(sc, fid, le16toh(ltbuf[0])); 1833 break; 1834 1835 default: 1836 DPRINTF(("wi_info_intr: got fid %x type %x len %d\n", fid, 1837 le16toh(ltbuf[1]), le16toh(ltbuf[0]))); 1838 break; 1839 } 1840 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_INFO); 1841 } 1842 1843 static int 1844 wi_write_multi(struct wi_softc *sc) 1845 { 1846 struct ifnet *ifp = &sc->sc_ic.ic_if; 1847 int n; 1848 struct wi_mcast mlist; 1849 struct ether_multi *enm; 1850 struct ether_multistep estep; 1851 1852 if ((ifp->if_flags & IFF_PROMISC) != 0) { 1853 allmulti: 1854 ifp->if_flags |= IFF_ALLMULTI; 1855 memset(&mlist, 0, sizeof(mlist)); 1856 return wi_write_rid(sc, WI_RID_MCAST_LIST, &mlist, 1857 sizeof(mlist)); 1858 } 1859 1860 n = 0; 1861 ETHER_FIRST_MULTI(estep, &sc->sc_ic.ic_ec, enm); 1862 while (enm != NULL) { 1863 /* Punt on ranges or too many multicast addresses. */ 1864 if (!IEEE80211_ADDR_EQ(enm->enm_addrlo, enm->enm_addrhi) || 1865 n >= sizeof(mlist) / sizeof(mlist.wi_mcast[0])) 1866 goto allmulti; 1867 1868 IEEE80211_ADDR_COPY(&mlist.wi_mcast[n], enm->enm_addrlo); 1869 n++; 1870 ETHER_NEXT_MULTI(estep, enm); 1871 } 1872 ifp->if_flags &= ~IFF_ALLMULTI; 1873 return wi_write_rid(sc, WI_RID_MCAST_LIST, &mlist, 1874 IEEE80211_ADDR_LEN * n); 1875 } 1876 1877 1878 static void 1879 wi_read_nicid(struct wi_softc *sc) 1880 { 1881 struct wi_card_ident *id; 1882 char *p; 1883 int len; 1884 u_int16_t ver[4]; 1885 1886 /* getting chip identity */ 1887 memset(ver, 0, sizeof(ver)); 1888 len = sizeof(ver); 1889 wi_read_rid(sc, WI_RID_CARD_ID, ver, &len); 1890 printf("%s: using ", sc->sc_dev.dv_xname); 1891 DPRINTF2(("wi_read_nicid: CARD_ID: %x %x %x %x\n", le16toh(ver[0]), le16toh(ver[1]), le16toh(ver[2]), le16toh(ver[3]))); 1892 1893 sc->sc_firmware_type = WI_NOTYPE; 1894 for (id = wi_card_ident; id->card_name != NULL; id++) { 1895 if (le16toh(ver[0]) == id->card_id) { 1896 printf("%s", id->card_name); 1897 sc->sc_firmware_type = id->firm_type; 1898 break; 1899 } 1900 } 1901 if (sc->sc_firmware_type == WI_NOTYPE) { 1902 if (le16toh(ver[0]) & 0x8000) { 1903 printf("Unknown PRISM2 chip"); 1904 sc->sc_firmware_type = WI_INTERSIL; 1905 } else { 1906 printf("Unknown Lucent chip"); 1907 sc->sc_firmware_type = WI_LUCENT; 1908 } 1909 } 1910 1911 /* get primary firmware version (Only Prism chips) */ 1912 if (sc->sc_firmware_type != WI_LUCENT) { 1913 memset(ver, 0, sizeof(ver)); 1914 len = sizeof(ver); 1915 wi_read_rid(sc, WI_RID_PRI_IDENTITY, ver, &len); 1916 sc->sc_pri_firmware_ver = le16toh(ver[2]) * 10000 + 1917 le16toh(ver[3]) * 100 + le16toh(ver[1]); 1918 } 1919 1920 /* get station firmware version */ 1921 memset(ver, 0, sizeof(ver)); 1922 len = sizeof(ver); 1923 wi_read_rid(sc, WI_RID_STA_IDENTITY, ver, &len); 1924 sc->sc_sta_firmware_ver = le16toh(ver[2]) * 10000 + 1925 le16toh(ver[3]) * 100 + le16toh(ver[1]); 1926 if (sc->sc_firmware_type == WI_INTERSIL && 1927 (sc->sc_sta_firmware_ver == 10102 || 1928 sc->sc_sta_firmware_ver == 20102)) { 1929 char ident[12]; 1930 memset(ident, 0, sizeof(ident)); 1931 len = sizeof(ident); 1932 /* value should be the format like "V2.00-11" */ 1933 if (wi_read_rid(sc, WI_RID_SYMBOL_IDENTITY, ident, &len) == 0 && 1934 *(p = (char *)ident) >= 'A' && 1935 p[2] == '.' && p[5] == '-' && p[8] == '\0') { 1936 sc->sc_firmware_type = WI_SYMBOL; 1937 sc->sc_sta_firmware_ver = (p[1] - '0') * 10000 + 1938 (p[3] - '0') * 1000 + (p[4] - '0') * 100 + 1939 (p[6] - '0') * 10 + (p[7] - '0'); 1940 } 1941 } 1942 1943 printf("\n%s: %s Firmware: ", sc->sc_dev.dv_xname, 1944 sc->sc_firmware_type == WI_LUCENT ? "Lucent" : 1945 (sc->sc_firmware_type == WI_SYMBOL ? "Symbol" : "Intersil")); 1946 if (sc->sc_firmware_type != WI_LUCENT) /* XXX */ 1947 printf("Primary (%u.%u.%u), ", 1948 sc->sc_pri_firmware_ver / 10000, 1949 (sc->sc_pri_firmware_ver % 10000) / 100, 1950 sc->sc_pri_firmware_ver % 100); 1951 printf("Station (%u.%u.%u)\n", 1952 sc->sc_sta_firmware_ver / 10000, 1953 (sc->sc_sta_firmware_ver % 10000) / 100, 1954 sc->sc_sta_firmware_ver % 100); 1955 } 1956 1957 static int 1958 wi_write_ssid(struct wi_softc *sc, int rid, u_int8_t *buf, int buflen) 1959 { 1960 struct wi_ssid ssid; 1961 1962 if (buflen > IEEE80211_NWID_LEN) 1963 return ENOBUFS; 1964 memset(&ssid, 0, sizeof(ssid)); 1965 ssid.wi_len = htole16(buflen); 1966 memcpy(ssid.wi_ssid, buf, buflen); 1967 return wi_write_rid(sc, rid, &ssid, sizeof(ssid)); 1968 } 1969 1970 static int 1971 wi_get_cfg(struct ifnet *ifp, u_long cmd, caddr_t data) 1972 { 1973 struct wi_softc *sc = ifp->if_softc; 1974 struct ieee80211com *ic = &sc->sc_ic; 1975 struct ifreq *ifr = (struct ifreq *)data; 1976 struct wi_req wreq; 1977 int len, n, error; 1978 1979 error = copyin(ifr->ifr_data, &wreq, sizeof(wreq)); 1980 if (error) 1981 return error; 1982 len = (wreq.wi_len - 1) * 2; 1983 if (len < sizeof(u_int16_t)) 1984 return ENOSPC; 1985 if (len > sizeof(wreq.wi_val)) 1986 len = sizeof(wreq.wi_val); 1987 1988 switch (wreq.wi_type) { 1989 1990 case WI_RID_IFACE_STATS: 1991 memcpy(wreq.wi_val, &sc->sc_stats, sizeof(sc->sc_stats)); 1992 if (len < sizeof(sc->sc_stats)) 1993 error = ENOSPC; 1994 else 1995 len = sizeof(sc->sc_stats); 1996 break; 1997 1998 case WI_RID_ENCRYPTION: 1999 case WI_RID_TX_CRYPT_KEY: 2000 case WI_RID_DEFLT_CRYPT_KEYS: 2001 case WI_RID_TX_RATE: 2002 return ieee80211_cfgget(ifp, cmd, data); 2003 2004 case WI_RID_MICROWAVE_OVEN: 2005 if (sc->sc_enabled && (sc->sc_flags & WI_FLAGS_HAS_MOR)) { 2006 error = wi_read_rid(sc, wreq.wi_type, wreq.wi_val, 2007 &len); 2008 break; 2009 } 2010 wreq.wi_val[0] = htole16(sc->sc_microwave_oven); 2011 len = sizeof(u_int16_t); 2012 break; 2013 2014 case WI_RID_DBM_ADJUST: 2015 if (sc->sc_enabled && (sc->sc_flags & WI_FLAGS_HAS_DBMADJUST)) { 2016 error = wi_read_rid(sc, wreq.wi_type, wreq.wi_val, 2017 &len); 2018 break; 2019 } 2020 wreq.wi_val[0] = htole16(sc->sc_dbm_offset); 2021 len = sizeof(u_int16_t); 2022 break; 2023 2024 case WI_RID_ROAMING_MODE: 2025 if (sc->sc_enabled && (sc->sc_flags & WI_FLAGS_HAS_ROAMING)) { 2026 error = wi_read_rid(sc, wreq.wi_type, wreq.wi_val, 2027 &len); 2028 break; 2029 } 2030 wreq.wi_val[0] = htole16(sc->sc_roaming_mode); 2031 len = sizeof(u_int16_t); 2032 break; 2033 2034 case WI_RID_SYSTEM_SCALE: 2035 if (sc->sc_enabled && (sc->sc_flags & WI_FLAGS_HAS_SYSSCALE)) { 2036 error = wi_read_rid(sc, wreq.wi_type, wreq.wi_val, 2037 &len); 2038 break; 2039 } 2040 wreq.wi_val[0] = htole16(sc->sc_system_scale); 2041 len = sizeof(u_int16_t); 2042 break; 2043 2044 case WI_RID_FRAG_THRESH: 2045 if (sc->sc_enabled && (sc->sc_flags & WI_FLAGS_HAS_FRAGTHR)) { 2046 error = wi_read_rid(sc, wreq.wi_type, wreq.wi_val, 2047 &len); 2048 break; 2049 } 2050 wreq.wi_val[0] = htole16(sc->sc_frag_thresh); 2051 len = sizeof(u_int16_t); 2052 break; 2053 2054 case WI_RID_READ_APS: 2055 if (ic->ic_opmode == IEEE80211_M_HOSTAP) 2056 return ieee80211_cfgget(ifp, cmd, data); 2057 if (sc->sc_scan_timer > 0) { 2058 error = EINPROGRESS; 2059 break; 2060 } 2061 n = sc->sc_naps; 2062 if (len < sizeof(n)) { 2063 error = ENOSPC; 2064 break; 2065 } 2066 if (len < sizeof(n) + sizeof(struct wi_apinfo) * n) 2067 n = (len - sizeof(n)) / sizeof(struct wi_apinfo); 2068 len = sizeof(n) + sizeof(struct wi_apinfo) * n; 2069 memcpy(wreq.wi_val, &n, sizeof(n)); 2070 memcpy((caddr_t)wreq.wi_val + sizeof(n), sc->sc_aps, 2071 sizeof(struct wi_apinfo) * n); 2072 break; 2073 2074 default: 2075 if (sc->sc_enabled) { 2076 error = wi_read_rid(sc, wreq.wi_type, wreq.wi_val, 2077 &len); 2078 break; 2079 } 2080 switch (wreq.wi_type) { 2081 case WI_RID_MAX_DATALEN: 2082 wreq.wi_val[0] = htole16(sc->sc_max_datalen); 2083 len = sizeof(u_int16_t); 2084 break; 2085 case WI_RID_FRAG_THRESH: 2086 wreq.wi_val[0] = htole16(sc->sc_frag_thresh); 2087 len = sizeof(u_int16_t); 2088 break; 2089 case WI_RID_RTS_THRESH: 2090 wreq.wi_val[0] = htole16(sc->sc_rts_thresh); 2091 len = sizeof(u_int16_t); 2092 break; 2093 case WI_RID_CNFAUTHMODE: 2094 wreq.wi_val[0] = htole16(sc->sc_cnfauthmode); 2095 len = sizeof(u_int16_t); 2096 break; 2097 case WI_RID_NODENAME: 2098 if (len < sc->sc_nodelen + sizeof(u_int16_t)) { 2099 error = ENOSPC; 2100 break; 2101 } 2102 len = sc->sc_nodelen + sizeof(u_int16_t); 2103 wreq.wi_val[0] = htole16((sc->sc_nodelen + 1) / 2); 2104 memcpy(&wreq.wi_val[1], sc->sc_nodename, 2105 sc->sc_nodelen); 2106 break; 2107 default: 2108 return ieee80211_cfgget(ifp, cmd, data); 2109 } 2110 break; 2111 } 2112 if (error) 2113 return error; 2114 wreq.wi_len = (len + 1) / 2 + 1; 2115 return copyout(&wreq, ifr->ifr_data, (wreq.wi_len + 1) * 2); 2116 } 2117 2118 static int 2119 wi_set_cfg(struct ifnet *ifp, u_long cmd, caddr_t data) 2120 { 2121 struct wi_softc *sc = ifp->if_softc; 2122 struct ieee80211com *ic = &sc->sc_ic; 2123 struct ifreq *ifr = (struct ifreq *)data; 2124 struct ieee80211_rateset *rs = &ic->ic_sup_rates[IEEE80211_MODE_11B]; 2125 struct wi_req wreq; 2126 struct mbuf *m; 2127 int i, len, error; 2128 2129 error = copyin(ifr->ifr_data, &wreq, sizeof(wreq)); 2130 if (error) 2131 return error; 2132 len = (wreq.wi_len - 1) * 2; 2133 switch (wreq.wi_type) { 2134 case WI_RID_DBM_ADJUST: 2135 return ENODEV; 2136 2137 case WI_RID_NODENAME: 2138 if (le16toh(wreq.wi_val[0]) * 2 > len || 2139 le16toh(wreq.wi_val[0]) > sizeof(sc->sc_nodename)) { 2140 error = ENOSPC; 2141 break; 2142 } 2143 if (sc->sc_enabled) { 2144 error = wi_write_rid(sc, wreq.wi_type, wreq.wi_val, 2145 len); 2146 if (error) 2147 break; 2148 } 2149 sc->sc_nodelen = le16toh(wreq.wi_val[0]) * 2; 2150 memcpy(sc->sc_nodename, &wreq.wi_val[1], sc->sc_nodelen); 2151 break; 2152 2153 case WI_RID_MICROWAVE_OVEN: 2154 case WI_RID_ROAMING_MODE: 2155 case WI_RID_SYSTEM_SCALE: 2156 case WI_RID_FRAG_THRESH: 2157 if (wreq.wi_type == WI_RID_MICROWAVE_OVEN && 2158 (sc->sc_flags & WI_FLAGS_HAS_MOR) == 0) 2159 break; 2160 if (wreq.wi_type == WI_RID_ROAMING_MODE && 2161 (sc->sc_flags & WI_FLAGS_HAS_ROAMING) == 0) 2162 break; 2163 if (wreq.wi_type == WI_RID_SYSTEM_SCALE && 2164 (sc->sc_flags & WI_FLAGS_HAS_SYSSCALE) == 0) 2165 break; 2166 if (wreq.wi_type == WI_RID_FRAG_THRESH && 2167 (sc->sc_flags & WI_FLAGS_HAS_FRAGTHR) == 0) 2168 break; 2169 /* FALLTHROUGH */ 2170 case WI_RID_RTS_THRESH: 2171 case WI_RID_CNFAUTHMODE: 2172 case WI_RID_MAX_DATALEN: 2173 if (sc->sc_enabled) { 2174 error = wi_write_rid(sc, wreq.wi_type, wreq.wi_val, 2175 sizeof(u_int16_t)); 2176 if (error) 2177 break; 2178 } 2179 switch (wreq.wi_type) { 2180 case WI_RID_FRAG_THRESH: 2181 sc->sc_frag_thresh = le16toh(wreq.wi_val[0]); 2182 break; 2183 case WI_RID_RTS_THRESH: 2184 sc->sc_rts_thresh = le16toh(wreq.wi_val[0]); 2185 break; 2186 case WI_RID_MICROWAVE_OVEN: 2187 sc->sc_microwave_oven = le16toh(wreq.wi_val[0]); 2188 break; 2189 case WI_RID_ROAMING_MODE: 2190 sc->sc_roaming_mode = le16toh(wreq.wi_val[0]); 2191 break; 2192 case WI_RID_SYSTEM_SCALE: 2193 sc->sc_system_scale = le16toh(wreq.wi_val[0]); 2194 break; 2195 case WI_RID_CNFAUTHMODE: 2196 sc->sc_cnfauthmode = le16toh(wreq.wi_val[0]); 2197 break; 2198 case WI_RID_MAX_DATALEN: 2199 sc->sc_max_datalen = le16toh(wreq.wi_val[0]); 2200 break; 2201 } 2202 break; 2203 2204 case WI_RID_TX_RATE: 2205 switch (le16toh(wreq.wi_val[0])) { 2206 case 3: 2207 ic->ic_fixed_rate = -1; 2208 break; 2209 default: 2210 for (i = 0; i < IEEE80211_RATE_SIZE; i++) { 2211 if ((rs->rs_rates[i] & IEEE80211_RATE_VAL) 2212 / 2 == le16toh(wreq.wi_val[0])) 2213 break; 2214 } 2215 if (i == IEEE80211_RATE_SIZE) 2216 return EINVAL; 2217 ic->ic_fixed_rate = i; 2218 } 2219 if (sc->sc_enabled) 2220 error = wi_cfg_txrate(sc); 2221 break; 2222 2223 case WI_RID_SCAN_APS: 2224 if (sc->sc_enabled && ic->ic_opmode != IEEE80211_M_HOSTAP) 2225 error = wi_scan_ap(sc, 0x3fff, 0x000f); 2226 break; 2227 2228 case WI_RID_MGMT_XMIT: 2229 if (!sc->sc_enabled) { 2230 error = ENETDOWN; 2231 break; 2232 } 2233 if (ic->ic_mgtq.ifq_len > 5) { 2234 error = EAGAIN; 2235 break; 2236 } 2237 /* XXX wi_len looks in u_int8_t, not in u_int16_t */ 2238 m = m_devget((char *)&wreq.wi_val, wreq.wi_len, 0, ifp, NULL); 2239 if (m == NULL) { 2240 error = ENOMEM; 2241 break; 2242 } 2243 IF_ENQUEUE(&ic->ic_mgtq, m); 2244 break; 2245 2246 default: 2247 if (sc->sc_enabled) { 2248 error = wi_write_rid(sc, wreq.wi_type, wreq.wi_val, 2249 len); 2250 if (error) 2251 break; 2252 } 2253 error = ieee80211_cfgset(ifp, cmd, data); 2254 break; 2255 } 2256 return error; 2257 } 2258 2259 /* Rate is 0 for hardware auto-select, otherwise rate is 2260 * 2, 4, 11, or 22 (units of 500Kbps). 2261 */ 2262 static int 2263 wi_write_txrate(struct wi_softc *sc, int rate) 2264 { 2265 u_int16_t hwrate; 2266 int i; 2267 2268 rate = (rate & IEEE80211_RATE_VAL) / 2; 2269 2270 /* rate: 0, 1, 2, 5, 11 */ 2271 switch (sc->sc_firmware_type) { 2272 case WI_LUCENT: 2273 switch (rate) { 2274 case 0: 2275 hwrate = 3; /* auto */ 2276 break; 2277 case 5: 2278 hwrate = 4; 2279 break; 2280 case 11: 2281 hwrate = 5; 2282 break; 2283 default: 2284 hwrate = rate; 2285 break; 2286 } 2287 break; 2288 default: 2289 /* Choose a bit according to this table. 2290 * 2291 * bit | data rate 2292 * ----+------------------- 2293 * 0 | 1Mbps 2294 * 1 | 2Mbps 2295 * 2 | 5.5Mbps 2296 * 3 | 11Mbps 2297 */ 2298 for (i = 8; i > 0; i >>= 1) { 2299 if (rate >= i) 2300 break; 2301 } 2302 if (i == 0) 2303 hwrate = 0xf; /* auto */ 2304 else 2305 hwrate = i; 2306 break; 2307 } 2308 2309 if (sc->sc_tx_rate == hwrate) 2310 return 0; 2311 2312 if (sc->sc_if.if_flags & IFF_DEBUG) 2313 printf("%s: tx rate %d -> %d (%d)\n", __func__, sc->sc_tx_rate, 2314 hwrate, rate); 2315 2316 sc->sc_tx_rate = hwrate; 2317 2318 return wi_write_val(sc, WI_RID_TX_RATE, sc->sc_tx_rate); 2319 } 2320 2321 static int 2322 wi_cfg_txrate(struct wi_softc *sc) 2323 { 2324 struct ieee80211com *ic = &sc->sc_ic; 2325 struct ieee80211_rateset *rs; 2326 int rate; 2327 2328 rs = &ic->ic_sup_rates[IEEE80211_MODE_11B]; 2329 2330 sc->sc_tx_rate = 0; /* force write to RID */ 2331 2332 if (ic->ic_fixed_rate < 0) 2333 rate = 0; /* auto */ 2334 else 2335 rate = rs->rs_rates[ic->ic_fixed_rate]; 2336 2337 return wi_write_txrate(sc, rate); 2338 } 2339 2340 static int 2341 wi_write_wep(struct wi_softc *sc) 2342 { 2343 struct ieee80211com *ic = &sc->sc_ic; 2344 int error = 0; 2345 int i, keylen; 2346 u_int16_t val; 2347 struct wi_key wkey[IEEE80211_WEP_NKID]; 2348 2349 switch (sc->sc_firmware_type) { 2350 case WI_LUCENT: 2351 val = (ic->ic_flags & IEEE80211_F_WEPON) ? 1 : 0; 2352 error = wi_write_val(sc, WI_RID_ENCRYPTION, val); 2353 if (error) 2354 break; 2355 error = wi_write_val(sc, WI_RID_TX_CRYPT_KEY, ic->ic_wep_txkey); 2356 if (error) 2357 break; 2358 memset(wkey, 0, sizeof(wkey)); 2359 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 2360 keylen = ic->ic_nw_keys[i].wk_len; 2361 wkey[i].wi_keylen = htole16(keylen); 2362 memcpy(wkey[i].wi_keydat, ic->ic_nw_keys[i].wk_key, 2363 keylen); 2364 } 2365 error = wi_write_rid(sc, WI_RID_DEFLT_CRYPT_KEYS, 2366 wkey, sizeof(wkey)); 2367 break; 2368 2369 case WI_INTERSIL: 2370 case WI_SYMBOL: 2371 if (ic->ic_flags & IEEE80211_F_WEPON) { 2372 /* 2373 * ONLY HWB3163 EVAL-CARD Firmware version 2374 * less than 0.8 variant2 2375 * 2376 * If promiscuous mode disable, Prism2 chip 2377 * does not work with WEP . 2378 * It is under investigation for details. 2379 * (ichiro (at) NetBSD.org) 2380 */ 2381 if (sc->sc_firmware_type == WI_INTERSIL && 2382 sc->sc_sta_firmware_ver < 802 ) { 2383 /* firm ver < 0.8 variant 2 */ 2384 wi_write_val(sc, WI_RID_PROMISC, 1); 2385 } 2386 wi_write_val(sc, WI_RID_CNFAUTHMODE, 2387 sc->sc_cnfauthmode); 2388 val = PRIVACY_INVOKED | EXCLUDE_UNENCRYPTED; 2389 /* 2390 * Encryption firmware has a bug for HostAP mode. 2391 */ 2392 if (sc->sc_firmware_type == WI_INTERSIL && 2393 ic->ic_opmode == IEEE80211_M_HOSTAP) 2394 val |= HOST_ENCRYPT; 2395 } else { 2396 wi_write_val(sc, WI_RID_CNFAUTHMODE, 2397 IEEE80211_AUTH_OPEN); 2398 val = HOST_ENCRYPT | HOST_DECRYPT; 2399 } 2400 error = wi_write_val(sc, WI_RID_P2_ENCRYPTION, val); 2401 if (error) 2402 break; 2403 error = wi_write_val(sc, WI_RID_P2_TX_CRYPT_KEY, 2404 ic->ic_wep_txkey); 2405 if (error) 2406 break; 2407 /* 2408 * It seems that the firmware accept 104bit key only if 2409 * all the keys have 104bit length. We get the length of 2410 * the transmit key and use it for all other keys. 2411 * Perhaps we should use software WEP for such situation. 2412 */ 2413 keylen = ic->ic_nw_keys[ic->ic_wep_txkey].wk_len; 2414 if (keylen > IEEE80211_WEP_KEYLEN) 2415 keylen = 13; /* 104bit keys */ 2416 else 2417 keylen = IEEE80211_WEP_KEYLEN; 2418 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 2419 error = wi_write_rid(sc, WI_RID_P2_CRYPT_KEY0 + i, 2420 ic->ic_nw_keys[i].wk_key, keylen); 2421 if (error) 2422 break; 2423 } 2424 break; 2425 } 2426 return error; 2427 } 2428 2429 /* Must be called at proper protection level! */ 2430 static int 2431 wi_cmd(struct wi_softc *sc, int cmd, int val0, int val1, int val2) 2432 { 2433 int i, status; 2434 2435 /* wait for the busy bit to clear */ 2436 for (i = 500; i > 0; i--) { /* 5s */ 2437 if ((CSR_READ_2(sc, WI_COMMAND) & WI_CMD_BUSY) == 0) 2438 break; 2439 DELAY(10*1000); /* 10 m sec */ 2440 } 2441 if (i == 0) { 2442 printf("%s: wi_cmd: busy bit won't clear.\n", 2443 sc->sc_dev.dv_xname); 2444 return(ETIMEDOUT); 2445 } 2446 CSR_WRITE_2(sc, WI_PARAM0, val0); 2447 CSR_WRITE_2(sc, WI_PARAM1, val1); 2448 CSR_WRITE_2(sc, WI_PARAM2, val2); 2449 CSR_WRITE_2(sc, WI_COMMAND, cmd); 2450 2451 if (cmd == WI_CMD_INI) { 2452 /* XXX: should sleep here. */ 2453 DELAY(100*1000); 2454 } 2455 /* wait for the cmd completed bit */ 2456 for (i = 0; i < WI_TIMEOUT; i++) { 2457 if (CSR_READ_2(sc, WI_EVENT_STAT) & WI_EV_CMD) 2458 break; 2459 DELAY(WI_DELAY); 2460 } 2461 2462 status = CSR_READ_2(sc, WI_STATUS); 2463 2464 /* Ack the command */ 2465 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_CMD); 2466 2467 if (i == WI_TIMEOUT) { 2468 printf("%s: command timed out, cmd=0x%x, arg=0x%x\n", 2469 sc->sc_dev.dv_xname, cmd, val0); 2470 return ETIMEDOUT; 2471 } 2472 2473 if (status & WI_STAT_CMD_RESULT) { 2474 printf("%s: command failed, cmd=0x%x, arg=0x%x\n", 2475 sc->sc_dev.dv_xname, cmd, val0); 2476 return EIO; 2477 } 2478 return 0; 2479 } 2480 2481 static int 2482 wi_seek_bap(struct wi_softc *sc, int id, int off) 2483 { 2484 int i, status; 2485 2486 CSR_WRITE_2(sc, WI_SEL0, id); 2487 CSR_WRITE_2(sc, WI_OFF0, off); 2488 2489 for (i = 0; ; i++) { 2490 status = CSR_READ_2(sc, WI_OFF0); 2491 if ((status & WI_OFF_BUSY) == 0) 2492 break; 2493 if (i == WI_TIMEOUT) { 2494 printf("%s: timeout in wi_seek to %x/%x\n", 2495 sc->sc_dev.dv_xname, id, off); 2496 sc->sc_bap_off = WI_OFF_ERR; /* invalidate */ 2497 return ETIMEDOUT; 2498 } 2499 DELAY(1); 2500 } 2501 if (status & WI_OFF_ERR) { 2502 printf("%s: failed in wi_seek to %x/%x\n", 2503 sc->sc_dev.dv_xname, id, off); 2504 sc->sc_bap_off = WI_OFF_ERR; /* invalidate */ 2505 return EIO; 2506 } 2507 sc->sc_bap_id = id; 2508 sc->sc_bap_off = off; 2509 return 0; 2510 } 2511 2512 static int 2513 wi_read_bap(struct wi_softc *sc, int id, int off, void *buf, int buflen) 2514 { 2515 int error, cnt; 2516 2517 if (buflen == 0) 2518 return 0; 2519 if (id != sc->sc_bap_id || off != sc->sc_bap_off) { 2520 if ((error = wi_seek_bap(sc, id, off)) != 0) 2521 return error; 2522 } 2523 cnt = (buflen + 1) / 2; 2524 CSR_READ_MULTI_STREAM_2(sc, WI_DATA0, (u_int16_t *)buf, cnt); 2525 sc->sc_bap_off += cnt * 2; 2526 return 0; 2527 } 2528 2529 static int 2530 wi_write_bap(struct wi_softc *sc, int id, int off, void *buf, int buflen) 2531 { 2532 int error, cnt; 2533 2534 if (buflen == 0) 2535 return 0; 2536 2537 #ifdef WI_HERMES_AUTOINC_WAR 2538 again: 2539 #endif 2540 if (id != sc->sc_bap_id || off != sc->sc_bap_off) { 2541 if ((error = wi_seek_bap(sc, id, off)) != 0) 2542 return error; 2543 } 2544 cnt = (buflen + 1) / 2; 2545 CSR_WRITE_MULTI_STREAM_2(sc, WI_DATA0, (u_int16_t *)buf, cnt); 2546 sc->sc_bap_off += cnt * 2; 2547 2548 #ifdef WI_HERMES_AUTOINC_WAR 2549 /* 2550 * According to the comments in the HCF Light code, there is a bug 2551 * in the Hermes (or possibly in certain Hermes firmware revisions) 2552 * where the chip's internal autoincrement counter gets thrown off 2553 * during data writes: the autoincrement is missed, causing one 2554 * data word to be overwritten and subsequent words to be written to 2555 * the wrong memory locations. The end result is that we could end 2556 * up transmitting bogus frames without realizing it. The workaround 2557 * for this is to write a couple of extra guard words after the end 2558 * of the transfer, then attempt to read then back. If we fail to 2559 * locate the guard words where we expect them, we preform the 2560 * transfer over again. 2561 */ 2562 if ((sc->sc_flags & WI_FLAGS_BUG_AUTOINC) && (id & 0xf000) == 0) { 2563 CSR_WRITE_2(sc, WI_DATA0, 0x1234); 2564 CSR_WRITE_2(sc, WI_DATA0, 0x5678); 2565 wi_seek_bap(sc, id, sc->sc_bap_off); 2566 sc->sc_bap_off = WI_OFF_ERR; /* invalidate */ 2567 if (CSR_READ_2(sc, WI_DATA0) != 0x1234 || 2568 CSR_READ_2(sc, WI_DATA0) != 0x5678) { 2569 printf("%s: detect auto increment bug, try again\n", 2570 sc->sc_dev.dv_xname); 2571 goto again; 2572 } 2573 } 2574 #endif 2575 return 0; 2576 } 2577 2578 static int 2579 wi_mwrite_bap(struct wi_softc *sc, int id, int off, struct mbuf *m0, int totlen) 2580 { 2581 int error, len; 2582 struct mbuf *m; 2583 2584 for (m = m0; m != NULL && totlen > 0; m = m->m_next) { 2585 if (m->m_len == 0) 2586 continue; 2587 2588 len = min(m->m_len, totlen); 2589 2590 if (((u_long)m->m_data) % 2 != 0 || len % 2 != 0) { 2591 m_copydata(m, 0, totlen, (caddr_t)&sc->sc_txbuf); 2592 return wi_write_bap(sc, id, off, (caddr_t)&sc->sc_txbuf, 2593 totlen); 2594 } 2595 2596 if ((error = wi_write_bap(sc, id, off, m->m_data, len)) != 0) 2597 return error; 2598 2599 off += m->m_len; 2600 totlen -= len; 2601 } 2602 return 0; 2603 } 2604 2605 static int 2606 wi_alloc_fid(struct wi_softc *sc, int len, int *idp) 2607 { 2608 int i; 2609 2610 if (wi_cmd(sc, WI_CMD_ALLOC_MEM, len, 0, 0)) { 2611 printf("%s: failed to allocate %d bytes on NIC\n", 2612 sc->sc_dev.dv_xname, len); 2613 return ENOMEM; 2614 } 2615 2616 for (i = 0; i < WI_TIMEOUT; i++) { 2617 if (CSR_READ_2(sc, WI_EVENT_STAT) & WI_EV_ALLOC) 2618 break; 2619 if (i == WI_TIMEOUT) { 2620 printf("%s: timeout in alloc\n", sc->sc_dev.dv_xname); 2621 return ETIMEDOUT; 2622 } 2623 DELAY(1); 2624 } 2625 *idp = CSR_READ_2(sc, WI_ALLOC_FID); 2626 CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_ALLOC); 2627 return 0; 2628 } 2629 2630 static int 2631 wi_read_rid(struct wi_softc *sc, int rid, void *buf, int *buflenp) 2632 { 2633 int error, len; 2634 u_int16_t ltbuf[2]; 2635 2636 /* Tell the NIC to enter record read mode. */ 2637 error = wi_cmd(sc, WI_CMD_ACCESS | WI_ACCESS_READ, rid, 0, 0); 2638 if (error) 2639 return error; 2640 2641 error = wi_read_bap(sc, rid, 0, ltbuf, sizeof(ltbuf)); 2642 if (error) 2643 return error; 2644 2645 if (le16toh(ltbuf[1]) != rid) { 2646 printf("%s: record read mismatch, rid=%x, got=%x\n", 2647 sc->sc_dev.dv_xname, rid, le16toh(ltbuf[1])); 2648 return EIO; 2649 } 2650 len = (le16toh(ltbuf[0]) - 1) * 2; /* already got rid */ 2651 if (*buflenp < len) { 2652 printf("%s: record buffer is too small, " 2653 "rid=%x, size=%d, len=%d\n", 2654 sc->sc_dev.dv_xname, rid, *buflenp, len); 2655 return ENOSPC; 2656 } 2657 *buflenp = len; 2658 return wi_read_bap(sc, rid, sizeof(ltbuf), buf, len); 2659 } 2660 2661 static int 2662 wi_write_rid(struct wi_softc *sc, int rid, void *buf, int buflen) 2663 { 2664 int error; 2665 u_int16_t ltbuf[2]; 2666 2667 ltbuf[0] = htole16((buflen + 1) / 2 + 1); /* includes rid */ 2668 ltbuf[1] = htole16(rid); 2669 2670 error = wi_write_bap(sc, rid, 0, ltbuf, sizeof(ltbuf)); 2671 if (error) 2672 return error; 2673 error = wi_write_bap(sc, rid, sizeof(ltbuf), buf, buflen); 2674 if (error) 2675 return error; 2676 2677 return wi_cmd(sc, WI_CMD_ACCESS | WI_ACCESS_WRITE, rid, 0, 0); 2678 } 2679 2680 static void 2681 wi_rssadapt_updatestats_cb(void *arg, struct ieee80211_node *ni) 2682 { 2683 struct wi_node *wn = (void*)ni; 2684 ieee80211_rssadapt_updatestats(&wn->wn_rssadapt); 2685 } 2686 2687 static void 2688 wi_rssadapt_updatestats(void *arg) 2689 { 2690 struct wi_softc *sc = arg; 2691 struct ieee80211com *ic = &sc->sc_ic; 2692 ieee80211_iterate_nodes(ic, wi_rssadapt_updatestats_cb, arg); 2693 if (ic->ic_opmode != IEEE80211_M_MONITOR && 2694 ic->ic_state == IEEE80211_S_RUN) 2695 callout_reset(&sc->sc_rssadapt_ch, hz / 10, 2696 wi_rssadapt_updatestats, arg); 2697 } 2698 2699 static int 2700 wi_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg) 2701 { 2702 struct wi_softc *sc = ic->ic_softc; 2703 struct ieee80211_node *ni = ic->ic_bss; 2704 int buflen; 2705 u_int16_t val; 2706 struct wi_ssid ssid; 2707 struct wi_macaddr bssid, old_bssid; 2708 enum ieee80211_state ostate; 2709 #ifdef WI_DEBUG 2710 static const char *stname[] = 2711 { "INIT", "SCAN", "AUTH", "ASSOC", "RUN" }; 2712 #endif /* WI_DEBUG */ 2713 2714 ostate = ic->ic_state; 2715 DPRINTF(("wi_newstate: %s -> %s\n", stname[ostate], stname[nstate])); 2716 2717 switch (nstate) { 2718 case IEEE80211_S_INIT: 2719 if (ic->ic_opmode != IEEE80211_M_MONITOR) 2720 callout_stop(&sc->sc_rssadapt_ch); 2721 ic->ic_flags &= ~IEEE80211_F_SIBSS; 2722 sc->sc_flags &= ~WI_FLAGS_OUTRANGE; 2723 return (*sc->sc_newstate)(ic, nstate, arg); 2724 2725 case IEEE80211_S_RUN: 2726 sc->sc_flags &= ~WI_FLAGS_OUTRANGE; 2727 buflen = IEEE80211_ADDR_LEN; 2728 IEEE80211_ADDR_COPY(old_bssid.wi_mac_addr, ni->ni_bssid); 2729 wi_read_rid(sc, WI_RID_CURRENT_BSSID, &bssid, &buflen); 2730 IEEE80211_ADDR_COPY(ni->ni_bssid, &bssid); 2731 IEEE80211_ADDR_COPY(ni->ni_macaddr, &bssid); 2732 buflen = sizeof(val); 2733 wi_read_rid(sc, WI_RID_CURRENT_CHAN, &val, &buflen); 2734 if (!isset(ic->ic_chan_avail, le16toh(val))) 2735 panic("%s: invalid channel %d\n", sc->sc_dev.dv_xname, 2736 le16toh(val)); 2737 ni->ni_chan = &ic->ic_channels[le16toh(val)]; 2738 2739 if (IEEE80211_ADDR_EQ(old_bssid.wi_mac_addr, ni->ni_bssid)) 2740 sc->sc_false_syns++; 2741 else 2742 sc->sc_false_syns = 0; 2743 2744 if (ic->ic_opmode == IEEE80211_M_HOSTAP) { 2745 ni->ni_esslen = ic->ic_des_esslen; 2746 memcpy(ni->ni_essid, ic->ic_des_essid, ni->ni_esslen); 2747 ni->ni_rates = ic->ic_sup_rates[ 2748 ieee80211_chan2mode(ic, ni->ni_chan)]; 2749 ni->ni_intval = ic->ic_lintval; 2750 ni->ni_capinfo = IEEE80211_CAPINFO_ESS; 2751 if (ic->ic_flags & IEEE80211_F_WEPON) 2752 ni->ni_capinfo |= IEEE80211_CAPINFO_PRIVACY; 2753 } else { 2754 buflen = sizeof(ssid); 2755 wi_read_rid(sc, WI_RID_CURRENT_SSID, &ssid, &buflen); 2756 ni->ni_esslen = le16toh(ssid.wi_len); 2757 if (ni->ni_esslen > IEEE80211_NWID_LEN) 2758 ni->ni_esslen = IEEE80211_NWID_LEN; /*XXX*/ 2759 memcpy(ni->ni_essid, ssid.wi_ssid, ni->ni_esslen); 2760 ni->ni_rates = ic->ic_sup_rates[ 2761 ieee80211_chan2mode(ic, ni->ni_chan)]; /*XXX*/ 2762 } 2763 if (ic->ic_opmode != IEEE80211_M_MONITOR) 2764 callout_reset(&sc->sc_rssadapt_ch, hz / 10, 2765 wi_rssadapt_updatestats, sc); 2766 break; 2767 2768 case IEEE80211_S_SCAN: 2769 case IEEE80211_S_AUTH: 2770 case IEEE80211_S_ASSOC: 2771 break; 2772 } 2773 2774 ic->ic_state = nstate; 2775 /* skip standard ieee80211 handling */ 2776 return 0; 2777 } 2778 2779 static int 2780 wi_set_tim(struct ieee80211com *ic, int aid, int which) 2781 { 2782 struct wi_softc *sc = ic->ic_softc; 2783 2784 aid &= ~0xc000; 2785 if (which) 2786 aid |= 0x8000; 2787 2788 return wi_write_val(sc, WI_RID_SET_TIM, aid); 2789 } 2790 2791 static int 2792 wi_scan_ap(struct wi_softc *sc, u_int16_t chanmask, u_int16_t txrate) 2793 { 2794 int error = 0; 2795 u_int16_t val[2]; 2796 2797 if (!sc->sc_enabled) 2798 return ENXIO; 2799 switch (sc->sc_firmware_type) { 2800 case WI_LUCENT: 2801 (void)wi_cmd(sc, WI_CMD_INQUIRE, WI_INFO_SCAN_RESULTS, 0, 0); 2802 break; 2803 case WI_INTERSIL: 2804 val[0] = htole16(chanmask); /* channel */ 2805 val[1] = htole16(txrate); /* tx rate */ 2806 error = wi_write_rid(sc, WI_RID_SCAN_REQ, val, sizeof(val)); 2807 break; 2808 case WI_SYMBOL: 2809 /* 2810 * XXX only supported on 3.x ? 2811 */ 2812 val[0] = BSCAN_BCAST | BSCAN_ONETIME; 2813 error = wi_write_rid(sc, WI_RID_BCAST_SCAN_REQ, 2814 val, sizeof(val[0])); 2815 break; 2816 } 2817 if (error == 0) { 2818 sc->sc_scan_timer = WI_SCAN_WAIT; 2819 sc->sc_ic.ic_if.if_timer = 1; 2820 DPRINTF(("wi_scan_ap: start scanning, " 2821 "chanmask 0x%x txrate 0x%x\n", chanmask, txrate)); 2822 } 2823 return error; 2824 } 2825 2826 static void 2827 wi_scan_result(struct wi_softc *sc, int fid, int cnt) 2828 { 2829 #define N(a) (sizeof (a) / sizeof (a[0])) 2830 int i, naps, off, szbuf; 2831 struct wi_scan_header ws_hdr; /* Prism2 header */ 2832 struct wi_scan_data_p2 ws_dat; /* Prism2 scantable*/ 2833 struct wi_apinfo *ap; 2834 2835 off = sizeof(u_int16_t) * 2; 2836 memset(&ws_hdr, 0, sizeof(ws_hdr)); 2837 switch (sc->sc_firmware_type) { 2838 case WI_INTERSIL: 2839 wi_read_bap(sc, fid, off, &ws_hdr, sizeof(ws_hdr)); 2840 off += sizeof(ws_hdr); 2841 szbuf = sizeof(struct wi_scan_data_p2); 2842 break; 2843 case WI_SYMBOL: 2844 szbuf = sizeof(struct wi_scan_data_p2) + 6; 2845 break; 2846 case WI_LUCENT: 2847 szbuf = sizeof(struct wi_scan_data); 2848 break; 2849 default: 2850 printf("%s: wi_scan_result: unknown firmware type %u\n", 2851 sc->sc_dev.dv_xname, sc->sc_firmware_type); 2852 naps = 0; 2853 goto done; 2854 } 2855 naps = (cnt * 2 + 2 - off) / szbuf; 2856 if (naps > N(sc->sc_aps)) 2857 naps = N(sc->sc_aps); 2858 sc->sc_naps = naps; 2859 /* Read Data */ 2860 ap = sc->sc_aps; 2861 memset(&ws_dat, 0, sizeof(ws_dat)); 2862 for (i = 0; i < naps; i++, ap++) { 2863 wi_read_bap(sc, fid, off, &ws_dat, 2864 (sizeof(ws_dat) < szbuf ? sizeof(ws_dat) : szbuf)); 2865 DPRINTF2(("wi_scan_result: #%d: off %d bssid %s\n", i, off, 2866 ether_sprintf(ws_dat.wi_bssid))); 2867 off += szbuf; 2868 ap->scanreason = le16toh(ws_hdr.wi_reason); 2869 memcpy(ap->bssid, ws_dat.wi_bssid, sizeof(ap->bssid)); 2870 ap->channel = le16toh(ws_dat.wi_chid); 2871 ap->signal = le16toh(ws_dat.wi_signal); 2872 ap->noise = le16toh(ws_dat.wi_noise); 2873 ap->quality = ap->signal - ap->noise; 2874 ap->capinfo = le16toh(ws_dat.wi_capinfo); 2875 ap->interval = le16toh(ws_dat.wi_interval); 2876 ap->rate = le16toh(ws_dat.wi_rate); 2877 ap->namelen = le16toh(ws_dat.wi_namelen); 2878 if (ap->namelen > sizeof(ap->name)) 2879 ap->namelen = sizeof(ap->name); 2880 memcpy(ap->name, ws_dat.wi_name, ap->namelen); 2881 } 2882 done: 2883 /* Done scanning */ 2884 sc->sc_scan_timer = 0; 2885 DPRINTF(("wi_scan_result: scan complete: ap %d\n", naps)); 2886 #undef N 2887 } 2888 2889 static void 2890 wi_dump_pkt(struct wi_frame *wh, struct ieee80211_node *ni, int rssi) 2891 { 2892 ieee80211_dump_pkt((u_int8_t *) &wh->wi_whdr, sizeof(wh->wi_whdr), 2893 ni ? ni->ni_rates.rs_rates[ni->ni_txrate] & IEEE80211_RATE_VAL 2894 : -1, 2895 rssi); 2896 printf(" status 0x%x rx_tstamp1 %u rx_tstamp0 0x%u rx_silence %u\n", 2897 le16toh(wh->wi_status), le16toh(wh->wi_rx_tstamp1), 2898 le16toh(wh->wi_rx_tstamp0), wh->wi_rx_silence); 2899 printf(" rx_signal %u rx_rate %u rx_flow %u\n", 2900 wh->wi_rx_signal, wh->wi_rx_rate, wh->wi_rx_flow); 2901 printf(" tx_rtry %u tx_rate %u tx_ctl 0x%x dat_len %u\n", 2902 wh->wi_tx_rtry, wh->wi_tx_rate, 2903 le16toh(wh->wi_tx_ctl), le16toh(wh->wi_dat_len)); 2904 printf(" ehdr dst %s src %s type 0x%x\n", 2905 ether_sprintf(wh->wi_ehdr.ether_dhost), 2906 ether_sprintf(wh->wi_ehdr.ether_shost), 2907 wh->wi_ehdr.ether_type); 2908 } 2909
Indexes created Thu Oct 16 14:10:15 GMT 2025