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