1 /*- 2 * Copyright (c) 2007-2009 Sam Leffler, Errno Consulting 3 * Copyright (c) 2007-2008 Marvell Semiconductor, Inc. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer, 11 * without modification. 12 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 13 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 14 * redistribution must be conditioned upon including a substantially 15 * similar Disclaimer requirement for further binary redistribution. 16 * 17 * NO WARRANTY 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 21 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 22 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 23 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 26 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 28 * THE POSSIBILITY OF SUCH DAMAGES. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 /* 35 * Driver for the Marvell 88W8363 Wireless LAN controller. 36 */ 37 38 #include "opt_inet.h" 39 #include "opt_mwl.h" 40 #include "opt_wlan.h" 41 42 #include <sys/param.h> 43 #include <sys/systm.h> 44 #include <sys/sysctl.h> 45 #include <sys/mbuf.h> 46 #include <sys/malloc.h> 47 #include <sys/lock.h> 48 #include <sys/mutex.h> 49 #include <sys/kernel.h> 50 #include <sys/socket.h> 51 #include <sys/sockio.h> 52 #include <sys/errno.h> 53 #include <sys/callout.h> 54 #include <sys/bus.h> 55 #include <sys/endian.h> 56 #include <sys/kthread.h> 57 #include <sys/taskqueue.h> 58 59 #include <machine/bus.h> 60 61 #include <net/if.h> 62 #include <net/if_dl.h> 63 #include <net/if_media.h> 64 #include <net/if_types.h> 65 #include <net/if_arp.h> 66 #include <net/ethernet.h> 67 #include <net/if_llc.h> 68 69 #include <net/bpf.h> 70 71 #include <net80211/ieee80211_var.h> 72 #include <net80211/ieee80211_regdomain.h> 73 74 #ifdef INET 75 #include <netinet/in.h> 76 #include <netinet/if_ether.h> 77 #endif /* INET */ 78 79 #include <dev/mwl/if_mwlvar.h> 80 #include <dev/mwl/mwldiag.h> 81 82 /* idiomatic shorthands: MS = mask+shift, SM = shift+mask */ 83 #define MS(v,x) (((v) & x) >> x##_S) 84 #define SM(v,x) (((v) << x##_S) & x) 85 86 static struct ieee80211vap *mwl_vap_create(struct ieee80211com *, 87 const char [IFNAMSIZ], int, enum ieee80211_opmode, int, 88 const uint8_t [IEEE80211_ADDR_LEN], 89 const uint8_t [IEEE80211_ADDR_LEN]); 90 static void mwl_vap_delete(struct ieee80211vap *); 91 static int mwl_setupdma(struct mwl_softc *); 92 static int mwl_hal_reset(struct mwl_softc *sc); 93 static int mwl_init_locked(struct mwl_softc *); 94 static void mwl_init(void *); 95 static void mwl_stop_locked(struct ifnet *, int); 96 static int mwl_reset(struct ieee80211vap *, u_long); 97 static void mwl_stop(struct ifnet *, int); 98 static void mwl_start(struct ifnet *); 99 static int mwl_raw_xmit(struct ieee80211_node *, struct mbuf *, 100 const struct ieee80211_bpf_params *); 101 static int mwl_media_change(struct ifnet *); 102 static void mwl_watchdog(void *); 103 static int mwl_ioctl(struct ifnet *, u_long, caddr_t); 104 static void mwl_radar_proc(void *, int); 105 static void mwl_chanswitch_proc(void *, int); 106 static void mwl_bawatchdog_proc(void *, int); 107 static int mwl_key_alloc(struct ieee80211vap *, 108 struct ieee80211_key *, 109 ieee80211_keyix *, ieee80211_keyix *); 110 static int mwl_key_delete(struct ieee80211vap *, 111 const struct ieee80211_key *); 112 static int mwl_key_set(struct ieee80211vap *, const struct ieee80211_key *, 113 const uint8_t mac[IEEE80211_ADDR_LEN]); 114 static int mwl_mode_init(struct mwl_softc *); 115 static void mwl_update_mcast(struct ifnet *); 116 static void mwl_update_promisc(struct ifnet *); 117 static void mwl_updateslot(struct ifnet *); 118 static int mwl_beacon_setup(struct ieee80211vap *); 119 static void mwl_beacon_update(struct ieee80211vap *, int); 120 #ifdef MWL_HOST_PS_SUPPORT 121 static void mwl_update_ps(struct ieee80211vap *, int); 122 static int mwl_set_tim(struct ieee80211_node *, int); 123 #endif 124 static int mwl_dma_setup(struct mwl_softc *); 125 static void mwl_dma_cleanup(struct mwl_softc *); 126 static struct ieee80211_node *mwl_node_alloc(struct ieee80211vap *, 127 const uint8_t [IEEE80211_ADDR_LEN]); 128 static void mwl_node_cleanup(struct ieee80211_node *); 129 static void mwl_node_drain(struct ieee80211_node *); 130 static void mwl_node_getsignal(const struct ieee80211_node *, 131 int8_t *, int8_t *); 132 static void mwl_node_getmimoinfo(const struct ieee80211_node *, 133 struct ieee80211_mimo_info *); 134 static int mwl_rxbuf_init(struct mwl_softc *, struct mwl_rxbuf *); 135 static void mwl_rx_proc(void *, int); 136 static void mwl_txq_init(struct mwl_softc *sc, struct mwl_txq *, int); 137 static int mwl_tx_setup(struct mwl_softc *, int, int); 138 static int mwl_wme_update(struct ieee80211com *); 139 static void mwl_tx_cleanupq(struct mwl_softc *, struct mwl_txq *); 140 static void mwl_tx_cleanup(struct mwl_softc *); 141 static uint16_t mwl_calcformat(uint8_t rate, const struct ieee80211_node *); 142 static int mwl_tx_start(struct mwl_softc *, struct ieee80211_node *, 143 struct mwl_txbuf *, struct mbuf *); 144 static void mwl_tx_proc(void *, int); 145 static int mwl_chan_set(struct mwl_softc *, struct ieee80211_channel *); 146 static void mwl_draintxq(struct mwl_softc *); 147 static void mwl_cleartxq(struct mwl_softc *, struct ieee80211vap *); 148 static int mwl_recv_action(struct ieee80211_node *, 149 const struct ieee80211_frame *, 150 const uint8_t *, const uint8_t *); 151 static int mwl_addba_request(struct ieee80211_node *, 152 struct ieee80211_tx_ampdu *, int dialogtoken, 153 int baparamset, int batimeout); 154 static int mwl_addba_response(struct ieee80211_node *, 155 struct ieee80211_tx_ampdu *, int status, 156 int baparamset, int batimeout); 157 static void mwl_addba_stop(struct ieee80211_node *, 158 struct ieee80211_tx_ampdu *); 159 static int mwl_startrecv(struct mwl_softc *); 160 static MWL_HAL_APMODE mwl_getapmode(const struct ieee80211vap *, 161 struct ieee80211_channel *); 162 static int mwl_setapmode(struct ieee80211vap *, struct ieee80211_channel*); 163 static void mwl_scan_start(struct ieee80211com *); 164 static void mwl_scan_end(struct ieee80211com *); 165 static void mwl_set_channel(struct ieee80211com *); 166 static int mwl_peerstadb(struct ieee80211_node *, 167 int aid, int staid, MWL_HAL_PEERINFO *pi); 168 static int mwl_localstadb(struct ieee80211vap *); 169 static int mwl_newstate(struct ieee80211vap *, enum ieee80211_state, int); 170 static int allocstaid(struct mwl_softc *sc, int aid); 171 static void delstaid(struct mwl_softc *sc, int staid); 172 static void mwl_newassoc(struct ieee80211_node *, int); 173 static void mwl_agestations(void *); 174 static int mwl_setregdomain(struct ieee80211com *, 175 struct ieee80211_regdomain *, int, 176 struct ieee80211_channel []); 177 static void mwl_getradiocaps(struct ieee80211com *, int, int *, 178 struct ieee80211_channel []); 179 static int mwl_getchannels(struct mwl_softc *); 180 181 static void mwl_sysctlattach(struct mwl_softc *); 182 static void mwl_announce(struct mwl_softc *); 183 184 SYSCTL_NODE(_hw, OID_AUTO, mwl, CTLFLAG_RD, 0, "Marvell driver parameters"); 185 186 static int mwl_rxdesc = MWL_RXDESC; /* # rx desc's to allocate */ 187 SYSCTL_INT(_hw_mwl, OID_AUTO, rxdesc, CTLFLAG_RW, &mwl_rxdesc, 188 0, "rx descriptors allocated"); 189 static int mwl_rxbuf = MWL_RXBUF; /* # rx buffers to allocate */ 190 SYSCTL_INT(_hw_mwl, OID_AUTO, rxbuf, CTLFLAG_RW, &mwl_rxbuf, 191 0, "rx buffers allocated"); 192 TUNABLE_INT("hw.mwl.rxbuf", &mwl_rxbuf); 193 static int mwl_txbuf = MWL_TXBUF; /* # tx buffers to allocate */ 194 SYSCTL_INT(_hw_mwl, OID_AUTO, txbuf, CTLFLAG_RW, &mwl_txbuf, 195 0, "tx buffers allocated"); 196 TUNABLE_INT("hw.mwl.txbuf", &mwl_txbuf); 197 static int mwl_txcoalesce = 8; /* # tx packets to q before poking f/w*/ 198 SYSCTL_INT(_hw_mwl, OID_AUTO, txcoalesce, CTLFLAG_RW, &mwl_txcoalesce, 199 0, "tx buffers to send at once"); 200 TUNABLE_INT("hw.mwl.txcoalesce", &mwl_txcoalesce); 201 static int mwl_rxquota = MWL_RXBUF; /* # max buffers to process */ 202 SYSCTL_INT(_hw_mwl, OID_AUTO, rxquota, CTLFLAG_RW, &mwl_rxquota, 203 0, "max rx buffers to process per interrupt"); 204 TUNABLE_INT("hw.mwl.rxquota", &mwl_rxquota); 205 static int mwl_rxdmalow = 3; /* # min buffers for wakeup */ 206 SYSCTL_INT(_hw_mwl, OID_AUTO, rxdmalow, CTLFLAG_RW, &mwl_rxdmalow, 207 0, "min free rx buffers before restarting traffic"); 208 TUNABLE_INT("hw.mwl.rxdmalow", &mwl_rxdmalow); 209 210 #ifdef MWL_DEBUG 211 static int mwl_debug = 0; 212 SYSCTL_INT(_hw_mwl, OID_AUTO, debug, CTLFLAG_RW, &mwl_debug, 213 0, "control debugging printfs"); 214 TUNABLE_INT("hw.mwl.debug", &mwl_debug); 215 enum { 216 MWL_DEBUG_XMIT = 0x00000001, /* basic xmit operation */ 217 MWL_DEBUG_XMIT_DESC = 0x00000002, /* xmit descriptors */ 218 MWL_DEBUG_RECV = 0x00000004, /* basic recv operation */ 219 MWL_DEBUG_RECV_DESC = 0x00000008, /* recv descriptors */ 220 MWL_DEBUG_RESET = 0x00000010, /* reset processing */ 221 MWL_DEBUG_BEACON = 0x00000020, /* beacon handling */ 222 MWL_DEBUG_INTR = 0x00000040, /* ISR */ 223 MWL_DEBUG_TX_PROC = 0x00000080, /* tx ISR proc */ 224 MWL_DEBUG_RX_PROC = 0x00000100, /* rx ISR proc */ 225 MWL_DEBUG_KEYCACHE = 0x00000200, /* key cache management */ 226 MWL_DEBUG_STATE = 0x00000400, /* 802.11 state transitions */ 227 MWL_DEBUG_NODE = 0x00000800, /* node management */ 228 MWL_DEBUG_RECV_ALL = 0x00001000, /* trace all frames (beacons) */ 229 MWL_DEBUG_TSO = 0x00002000, /* TSO processing */ 230 MWL_DEBUG_AMPDU = 0x00004000, /* BA stream handling */ 231 MWL_DEBUG_ANY = 0xffffffff 232 }; 233 #define IS_BEACON(wh) \ 234 ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK|IEEE80211_FC0_SUBTYPE_MASK)) == \ 235 (IEEE80211_FC0_TYPE_MGT|IEEE80211_FC0_SUBTYPE_BEACON)) 236 #define IFF_DUMPPKTS_RECV(sc, wh) \ 237 (((sc->sc_debug & MWL_DEBUG_RECV) && \ 238 ((sc->sc_debug & MWL_DEBUG_RECV_ALL) || !IS_BEACON(wh))) || \ 239 (sc->sc_ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) == (IFF_DEBUG|IFF_LINK2)) 240 #define IFF_DUMPPKTS_XMIT(sc) \ 241 ((sc->sc_debug & MWL_DEBUG_XMIT) || \ 242 (sc->sc_ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) == (IFF_DEBUG|IFF_LINK2)) 243 #define DPRINTF(sc, m, fmt, ...) do { \ 244 if (sc->sc_debug & (m)) \ 245 printf(fmt, __VA_ARGS__); \ 246 } while (0) 247 #define KEYPRINTF(sc, hk, mac) do { \ 248 if (sc->sc_debug & MWL_DEBUG_KEYCACHE) \ 249 mwl_keyprint(sc, __func__, hk, mac); \ 250 } while (0) 251 static void mwl_printrxbuf(const struct mwl_rxbuf *bf, u_int ix); 252 static void mwl_printtxbuf(const struct mwl_txbuf *bf, u_int qnum, u_int ix); 253 #else 254 #define IFF_DUMPPKTS_RECV(sc, wh) \ 255 ((sc->sc_ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) == (IFF_DEBUG|IFF_LINK2)) 256 #define IFF_DUMPPKTS_XMIT(sc) \ 257 ((sc->sc_ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) == (IFF_DEBUG|IFF_LINK2)) 258 #define DPRINTF(sc, m, fmt, ...) do { \ 259 (void) sc; \ 260 } while (0) 261 #define KEYPRINTF(sc, k, mac) do { \ 262 (void) sc; \ 263 } while (0) 264 #endif 265 266 static MALLOC_DEFINE(M_MWLDEV, "mwldev", "mwl driver dma buffers"); 267 268 /* 269 * Each packet has fixed front matter: a 2-byte length 270 * of the payload, followed by a 4-address 802.11 header 271 * (regardless of the actual header and always w/o any 272 * QoS header). The payload then follows. 273 */ 274 struct mwltxrec { 275 uint16_t fwlen; 276 struct ieee80211_frame_addr4 wh; 277 } __packed; 278 279 /* 280 * Read/Write shorthands for accesses to BAR 0. Note 281 * that all BAR 1 operations are done in the "hal" and 282 * there should be no reference to them here. 283 */ 284 static __inline uint32_t 285 RD4(struct mwl_softc *sc, bus_size_t off) 286 { 287 return bus_space_read_4(sc->sc_io0t, sc->sc_io0h, off); 288 } 289 290 static __inline void 291 WR4(struct mwl_softc *sc, bus_size_t off, uint32_t val) 292 { 293 bus_space_write_4(sc->sc_io0t, sc->sc_io0h, off, val); 294 } 295 296 int 297 mwl_attach(uint16_t devid, struct mwl_softc *sc) 298 { 299 struct ifnet *ifp; 300 struct ieee80211com *ic; 301 struct mwl_hal *mh; 302 int error = 0; 303 304 DPRINTF(sc, MWL_DEBUG_ANY, "%s: devid 0x%x\n", __func__, devid); 305 306 ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211); 307 if (ifp == NULL) { 308 device_printf(sc->sc_dev, "cannot if_alloc()\n"); 309 return ENOSPC; 310 } 311 ic = ifp->if_l2com; 312 313 /* 314 * Setup the RX free list lock early, so it can be consistently 315 * removed. 316 */ 317 MWL_RXFREE_INIT(sc); 318 319 /* set these up early for if_printf use */ 320 if_initname(ifp, device_get_name(sc->sc_dev), 321 device_get_unit(sc->sc_dev)); 322 323 mh = mwl_hal_attach(sc->sc_dev, devid, 324 sc->sc_io1h, sc->sc_io1t, sc->sc_dmat); 325 if (mh == NULL) { 326 if_printf(ifp, "unable to attach HAL\n"); 327 error = EIO; 328 goto bad; 329 } 330 sc->sc_mh = mh; 331 /* 332 * Load firmware so we can get setup. We arbitrarily 333 * pick station firmware; we'll re-load firmware as 334 * needed so setting up the wrong mode isn't a big deal. 335 */ 336 if (mwl_hal_fwload(mh, NULL) != 0) { 337 if_printf(ifp, "unable to setup builtin firmware\n"); 338 error = EIO; 339 goto bad1; 340 } 341 if (mwl_hal_gethwspecs(mh, &sc->sc_hwspecs) != 0) { 342 if_printf(ifp, "unable to fetch h/w specs\n"); 343 error = EIO; 344 goto bad1; 345 } 346 error = mwl_getchannels(sc); 347 if (error != 0) 348 goto bad1; 349 350 sc->sc_txantenna = 0; /* h/w default */ 351 sc->sc_rxantenna = 0; /* h/w default */ 352 sc->sc_invalid = 0; /* ready to go, enable int handling */ 353 sc->sc_ageinterval = MWL_AGEINTERVAL; 354 355 /* 356 * Allocate tx+rx descriptors and populate the lists. 357 * We immediately push the information to the firmware 358 * as otherwise it gets upset. 359 */ 360 error = mwl_dma_setup(sc); 361 if (error != 0) { 362 if_printf(ifp, "failed to setup descriptors: %d\n", error); 363 goto bad1; 364 } 365 error = mwl_setupdma(sc); /* push to firmware */ 366 if (error != 0) /* NB: mwl_setupdma prints msg */ 367 goto bad1; 368 369 callout_init(&sc->sc_timer, CALLOUT_MPSAFE); 370 callout_init_mtx(&sc->sc_watchdog, &sc->sc_mtx, 0); 371 372 sc->sc_tq = taskqueue_create("mwl_taskq", M_NOWAIT, 373 taskqueue_thread_enqueue, &sc->sc_tq); 374 taskqueue_start_threads(&sc->sc_tq, 1, PI_NET, 375 "%s taskq", ifp->if_xname); 376 377 TASK_INIT(&sc->sc_rxtask, 0, mwl_rx_proc, sc); 378 TASK_INIT(&sc->sc_radartask, 0, mwl_radar_proc, sc); 379 TASK_INIT(&sc->sc_chanswitchtask, 0, mwl_chanswitch_proc, sc); 380 TASK_INIT(&sc->sc_bawatchdogtask, 0, mwl_bawatchdog_proc, sc); 381 382 /* NB: insure BK queue is the lowest priority h/w queue */ 383 if (!mwl_tx_setup(sc, WME_AC_BK, MWL_WME_AC_BK)) { 384 if_printf(ifp, "unable to setup xmit queue for %s traffic!\n", 385 ieee80211_wme_acnames[WME_AC_BK]); 386 error = EIO; 387 goto bad2; 388 } 389 if (!mwl_tx_setup(sc, WME_AC_BE, MWL_WME_AC_BE) || 390 !mwl_tx_setup(sc, WME_AC_VI, MWL_WME_AC_VI) || 391 !mwl_tx_setup(sc, WME_AC_VO, MWL_WME_AC_VO)) { 392 /* 393 * Not enough hardware tx queues to properly do WME; 394 * just punt and assign them all to the same h/w queue. 395 * We could do a better job of this if, for example, 396 * we allocate queues when we switch from station to 397 * AP mode. 398 */ 399 if (sc->sc_ac2q[WME_AC_VI] != NULL) 400 mwl_tx_cleanupq(sc, sc->sc_ac2q[WME_AC_VI]); 401 if (sc->sc_ac2q[WME_AC_BE] != NULL) 402 mwl_tx_cleanupq(sc, sc->sc_ac2q[WME_AC_BE]); 403 sc->sc_ac2q[WME_AC_BE] = sc->sc_ac2q[WME_AC_BK]; 404 sc->sc_ac2q[WME_AC_VI] = sc->sc_ac2q[WME_AC_BK]; 405 sc->sc_ac2q[WME_AC_VO] = sc->sc_ac2q[WME_AC_BK]; 406 } 407 TASK_INIT(&sc->sc_txtask, 0, mwl_tx_proc, sc); 408 409 ifp->if_softc = sc; 410 ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST; 411 ifp->if_start = mwl_start; 412 ifp->if_ioctl = mwl_ioctl; 413 ifp->if_init = mwl_init; 414 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); 415 ifp->if_snd.ifq_drv_maxlen = ifqmaxlen; 416 IFQ_SET_READY(&ifp->if_snd); 417 418 ic->ic_ifp = ifp; 419 /* XXX not right but it's not used anywhere important */ 420 ic->ic_phytype = IEEE80211_T_OFDM; 421 ic->ic_opmode = IEEE80211_M_STA; 422 ic->ic_caps = 423 IEEE80211_C_STA /* station mode supported */ 424 | IEEE80211_C_HOSTAP /* hostap mode */ 425 | IEEE80211_C_MONITOR /* monitor mode */ 426 #if 0 427 | IEEE80211_C_IBSS /* ibss, nee adhoc, mode */ 428 | IEEE80211_C_AHDEMO /* adhoc demo mode */ 429 #endif 430 | IEEE80211_C_MBSS /* mesh point link mode */ 431 | IEEE80211_C_WDS /* WDS supported */ 432 | IEEE80211_C_SHPREAMBLE /* short preamble supported */ 433 | IEEE80211_C_SHSLOT /* short slot time supported */ 434 | IEEE80211_C_WME /* WME/WMM supported */ 435 | IEEE80211_C_BURST /* xmit bursting supported */ 436 | IEEE80211_C_WPA /* capable of WPA1+WPA2 */ 437 | IEEE80211_C_BGSCAN /* capable of bg scanning */ 438 | IEEE80211_C_TXFRAG /* handle tx frags */ 439 | IEEE80211_C_TXPMGT /* capable of txpow mgt */ 440 | IEEE80211_C_DFS /* DFS supported */ 441 ; 442 443 ic->ic_htcaps = 444 IEEE80211_HTCAP_SMPS_ENA /* SM PS mode enabled */ 445 | IEEE80211_HTCAP_CHWIDTH40 /* 40MHz channel width */ 446 | IEEE80211_HTCAP_SHORTGI20 /* short GI in 20MHz */ 447 | IEEE80211_HTCAP_SHORTGI40 /* short GI in 40MHz */ 448 | IEEE80211_HTCAP_RXSTBC_2STREAM/* 1-2 spatial streams */ 449 #if MWL_AGGR_SIZE == 7935 450 | IEEE80211_HTCAP_MAXAMSDU_7935 /* max A-MSDU length */ 451 #else 452 | IEEE80211_HTCAP_MAXAMSDU_3839 /* max A-MSDU length */ 453 #endif 454 #if 0 455 | IEEE80211_HTCAP_PSMP /* PSMP supported */ 456 | IEEE80211_HTCAP_40INTOLERANT /* 40MHz intolerant */ 457 #endif 458 /* s/w capabilities */ 459 | IEEE80211_HTC_HT /* HT operation */ 460 | IEEE80211_HTC_AMPDU /* tx A-MPDU */ 461 | IEEE80211_HTC_AMSDU /* tx A-MSDU */ 462 | IEEE80211_HTC_SMPS /* SMPS available */ 463 ; 464 465 /* 466 * Mark h/w crypto support. 467 * XXX no way to query h/w support. 468 */ 469 ic->ic_cryptocaps |= IEEE80211_CRYPTO_WEP 470 | IEEE80211_CRYPTO_AES_CCM 471 | IEEE80211_CRYPTO_TKIP 472 | IEEE80211_CRYPTO_TKIPMIC 473 ; 474 /* 475 * Transmit requires space in the packet for a special 476 * format transmit record and optional padding between 477 * this record and the payload. Ask the net80211 layer 478 * to arrange this when encapsulating packets so we can 479 * add it efficiently. 480 */ 481 ic->ic_headroom = sizeof(struct mwltxrec) - 482 sizeof(struct ieee80211_frame); 483 484 /* call MI attach routine. */ 485 ieee80211_ifattach(ic, sc->sc_hwspecs.macAddr); 486 ic->ic_setregdomain = mwl_setregdomain; 487 ic->ic_getradiocaps = mwl_getradiocaps; 488 /* override default methods */ 489 ic->ic_raw_xmit = mwl_raw_xmit; 490 ic->ic_newassoc = mwl_newassoc; 491 ic->ic_updateslot = mwl_updateslot; 492 ic->ic_update_mcast = mwl_update_mcast; 493 ic->ic_update_promisc = mwl_update_promisc; 494 ic->ic_wme.wme_update = mwl_wme_update; 495 496 ic->ic_node_alloc = mwl_node_alloc; 497 sc->sc_node_cleanup = ic->ic_node_cleanup; 498 ic->ic_node_cleanup = mwl_node_cleanup; 499 sc->sc_node_drain = ic->ic_node_drain; 500 ic->ic_node_drain = mwl_node_drain; 501 ic->ic_node_getsignal = mwl_node_getsignal; 502 ic->ic_node_getmimoinfo = mwl_node_getmimoinfo; 503 504 ic->ic_scan_start = mwl_scan_start; 505 ic->ic_scan_end = mwl_scan_end; 506 ic->ic_set_channel = mwl_set_channel; 507 508 sc->sc_recv_action = ic->ic_recv_action; 509 ic->ic_recv_action = mwl_recv_action; 510 sc->sc_addba_request = ic->ic_addba_request; 511 ic->ic_addba_request = mwl_addba_request; 512 sc->sc_addba_response = ic->ic_addba_response; 513 ic->ic_addba_response = mwl_addba_response; 514 sc->sc_addba_stop = ic->ic_addba_stop; 515 ic->ic_addba_stop = mwl_addba_stop; 516 517 ic->ic_vap_create = mwl_vap_create; 518 ic->ic_vap_delete = mwl_vap_delete; 519 520 ieee80211_radiotap_attach(ic, 521 &sc->sc_tx_th.wt_ihdr, sizeof(sc->sc_tx_th), 522 MWL_TX_RADIOTAP_PRESENT, 523 &sc->sc_rx_th.wr_ihdr, sizeof(sc->sc_rx_th), 524 MWL_RX_RADIOTAP_PRESENT); 525 /* 526 * Setup dynamic sysctl's now that country code and 527 * regdomain are available from the hal. 528 */ 529 mwl_sysctlattach(sc); 530 531 if (bootverbose) 532 ieee80211_announce(ic); 533 mwl_announce(sc); 534 return 0; 535 bad2: 536 mwl_dma_cleanup(sc); 537 bad1: 538 mwl_hal_detach(mh); 539 bad: 540 MWL_RXFREE_DESTROY(sc); 541 if_free(ifp); 542 sc->sc_invalid = 1; 543 return error; 544 } 545 546 int 547 mwl_detach(struct mwl_softc *sc) 548 { 549 struct ifnet *ifp = sc->sc_ifp; 550 struct ieee80211com *ic = ifp->if_l2com; 551 552 DPRINTF(sc, MWL_DEBUG_ANY, "%s: if_flags %x\n", 553 __func__, ifp->if_flags); 554 555 mwl_stop(ifp, 1); 556 /* 557 * NB: the order of these is important: 558 * o call the 802.11 layer before detaching the hal to 559 * insure callbacks into the driver to delete global 560 * key cache entries can be handled 561 * o reclaim the tx queue data structures after calling 562 * the 802.11 layer as we'll get called back to reclaim 563 * node state and potentially want to use them 564 * o to cleanup the tx queues the hal is called, so detach 565 * it last 566 * Other than that, it's straightforward... 567 */ 568 ieee80211_ifdetach(ic); 569 callout_drain(&sc->sc_watchdog); 570 mwl_dma_cleanup(sc); 571 MWL_RXFREE_DESTROY(sc); 572 mwl_tx_cleanup(sc); 573 mwl_hal_detach(sc->sc_mh); 574 if_free(ifp); 575 576 return 0; 577 } 578 579 /* 580 * MAC address handling for multiple BSS on the same radio. 581 * The first vap uses the MAC address from the EEPROM. For 582 * subsequent vap's we set the U/L bit (bit 1) in the MAC 583 * address and use the next six bits as an index. 584 */ 585 static void 586 assign_address(struct mwl_softc *sc, uint8_t mac[IEEE80211_ADDR_LEN], int clone) 587 { 588 int i; 589 590 if (clone && mwl_hal_ismbsscapable(sc->sc_mh)) { 591 /* NB: we only do this if h/w supports multiple bssid */ 592 for (i = 0; i < 32; i++) 593 if ((sc->sc_bssidmask & (1<<i)) == 0) 594 break; 595 if (i != 0) 596 mac[0] |= (i << 2)|0x2; 597 } else 598 i = 0; 599 sc->sc_bssidmask |= 1<<i; 600 if (i == 0) 601 sc->sc_nbssid0++; 602 } 603 604 static void 605 reclaim_address(struct mwl_softc *sc, uint8_t mac[IEEE80211_ADDR_LEN]) 606 { 607 int i = mac[0] >> 2; 608 if (i != 0 || --sc->sc_nbssid0 == 0) 609 sc->sc_bssidmask &= ~(1<<i); 610 } 611 612 static struct ieee80211vap * 613 mwl_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit, 614 enum ieee80211_opmode opmode, int flags, 615 const uint8_t bssid[IEEE80211_ADDR_LEN], 616 const uint8_t mac0[IEEE80211_ADDR_LEN]) 617 { 618 struct ifnet *ifp = ic->ic_ifp; 619 struct mwl_softc *sc = ifp->if_softc; 620 struct mwl_hal *mh = sc->sc_mh; 621 struct ieee80211vap *vap, *apvap; 622 struct mwl_hal_vap *hvap; 623 struct mwl_vap *mvp; 624 uint8_t mac[IEEE80211_ADDR_LEN]; 625 626 IEEE80211_ADDR_COPY(mac, mac0); 627 switch (opmode) { 628 case IEEE80211_M_HOSTAP: 629 case IEEE80211_M_MBSS: 630 if ((flags & IEEE80211_CLONE_MACADDR) == 0) 631 assign_address(sc, mac, flags & IEEE80211_CLONE_BSSID); 632 hvap = mwl_hal_newvap(mh, MWL_HAL_AP, mac); 633 if (hvap == NULL) { 634 if ((flags & IEEE80211_CLONE_MACADDR) == 0) 635 reclaim_address(sc, mac); 636 return NULL; 637 } 638 break; 639 case IEEE80211_M_STA: 640 if ((flags & IEEE80211_CLONE_MACADDR) == 0) 641 assign_address(sc, mac, flags & IEEE80211_CLONE_BSSID); 642 hvap = mwl_hal_newvap(mh, MWL_HAL_STA, mac); 643 if (hvap == NULL) { 644 if ((flags & IEEE80211_CLONE_MACADDR) == 0) 645 reclaim_address(sc, mac); 646 return NULL; 647 } 648 /* no h/w beacon miss support; always use s/w */ 649 flags |= IEEE80211_CLONE_NOBEACONS; 650 break; 651 case IEEE80211_M_WDS: 652 hvap = NULL; /* NB: we use associated AP vap */ 653 if (sc->sc_napvaps == 0) 654 return NULL; /* no existing AP vap */ 655 break; 656 case IEEE80211_M_MONITOR: 657 hvap = NULL; 658 break; 659 case IEEE80211_M_IBSS: 660 case IEEE80211_M_AHDEMO: 661 default: 662 return NULL; 663 } 664 665 mvp = (struct mwl_vap *) malloc(sizeof(struct mwl_vap), 666 M_80211_VAP, M_NOWAIT | M_ZERO); 667 if (mvp == NULL) { 668 if (hvap != NULL) { 669 mwl_hal_delvap(hvap); 670 if ((flags & IEEE80211_CLONE_MACADDR) == 0) 671 reclaim_address(sc, mac); 672 } 673 /* XXX msg */ 674 return NULL; 675 } 676 mvp->mv_hvap = hvap; 677 if (opmode == IEEE80211_M_WDS) { 678 /* 679 * WDS vaps must have an associated AP vap; find one. 680 * XXX not right. 681 */ 682 TAILQ_FOREACH(apvap, &ic->ic_vaps, iv_next) 683 if (apvap->iv_opmode == IEEE80211_M_HOSTAP) { 684 mvp->mv_ap_hvap = MWL_VAP(apvap)->mv_hvap; 685 break; 686 } 687 KASSERT(mvp->mv_ap_hvap != NULL, ("no ap vap")); 688 } 689 vap = &mvp->mv_vap; 690 ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac); 691 if (hvap != NULL) 692 IEEE80211_ADDR_COPY(vap->iv_myaddr, mac); 693 /* override with driver methods */ 694 mvp->mv_newstate = vap->iv_newstate; 695 vap->iv_newstate = mwl_newstate; 696 vap->iv_max_keyix = 0; /* XXX */ 697 vap->iv_key_alloc = mwl_key_alloc; 698 vap->iv_key_delete = mwl_key_delete; 699 vap->iv_key_set = mwl_key_set; 700 #ifdef MWL_HOST_PS_SUPPORT 701 if (opmode == IEEE80211_M_HOSTAP || opmode == IEEE80211_M_MBSS) { 702 vap->iv_update_ps = mwl_update_ps; 703 mvp->mv_set_tim = vap->iv_set_tim; 704 vap->iv_set_tim = mwl_set_tim; 705 } 706 #endif 707 vap->iv_reset = mwl_reset; 708 vap->iv_update_beacon = mwl_beacon_update; 709 710 /* override max aid so sta's cannot assoc when we're out of sta id's */ 711 vap->iv_max_aid = MWL_MAXSTAID; 712 /* override default A-MPDU rx parameters */ 713 vap->iv_ampdu_rxmax = IEEE80211_HTCAP_MAXRXAMPDU_64K; 714 vap->iv_ampdu_density = IEEE80211_HTCAP_MPDUDENSITY_4; 715 716 /* complete setup */ 717 ieee80211_vap_attach(vap, mwl_media_change, ieee80211_media_status); 718 719 switch (vap->iv_opmode) { 720 case IEEE80211_M_HOSTAP: 721 case IEEE80211_M_MBSS: 722 case IEEE80211_M_STA: 723 /* 724 * Setup sta db entry for local address. 725 */ 726 mwl_localstadb(vap); 727 if (vap->iv_opmode == IEEE80211_M_HOSTAP || 728 vap->iv_opmode == IEEE80211_M_MBSS) 729 sc->sc_napvaps++; 730 else 731 sc->sc_nstavaps++; 732 break; 733 case IEEE80211_M_WDS: 734 sc->sc_nwdsvaps++; 735 break; 736 default: 737 break; 738 } 739 /* 740 * Setup overall operating mode. 741 */ 742 if (sc->sc_napvaps) 743 ic->ic_opmode = IEEE80211_M_HOSTAP; 744 else if (sc->sc_nstavaps) 745 ic->ic_opmode = IEEE80211_M_STA; 746 else 747 ic->ic_opmode = opmode; 748 749 return vap; 750 } 751 752 static void 753 mwl_vap_delete(struct ieee80211vap *vap) 754 { 755 struct mwl_vap *mvp = MWL_VAP(vap); 756 struct ifnet *parent = vap->iv_ic->ic_ifp; 757 struct mwl_softc *sc = parent->if_softc; 758 struct mwl_hal *mh = sc->sc_mh; 759 struct mwl_hal_vap *hvap = mvp->mv_hvap; 760 enum ieee80211_opmode opmode = vap->iv_opmode; 761 762 /* XXX disallow ap vap delete if WDS still present */ 763 if (parent->if_drv_flags & IFF_DRV_RUNNING) { 764 /* quiesce h/w while we remove the vap */ 765 mwl_hal_intrset(mh, 0); /* disable interrupts */ 766 } 767 ieee80211_vap_detach(vap); 768 switch (opmode) { 769 case IEEE80211_M_HOSTAP: 770 case IEEE80211_M_MBSS: 771 case IEEE80211_M_STA: 772 KASSERT(hvap != NULL, ("no hal vap handle")); 773 (void) mwl_hal_delstation(hvap, vap->iv_myaddr); 774 mwl_hal_delvap(hvap); 775 if (opmode == IEEE80211_M_HOSTAP || opmode == IEEE80211_M_MBSS) 776 sc->sc_napvaps--; 777 else 778 sc->sc_nstavaps--; 779 /* XXX don't do it for IEEE80211_CLONE_MACADDR */ 780 reclaim_address(sc, vap->iv_myaddr); 781 break; 782 case IEEE80211_M_WDS: 783 sc->sc_nwdsvaps--; 784 break; 785 default: 786 break; 787 } 788 mwl_cleartxq(sc, vap); 789 free(mvp, M_80211_VAP); 790 if (parent->if_drv_flags & IFF_DRV_RUNNING) 791 mwl_hal_intrset(mh, sc->sc_imask); 792 } 793 794 void 795 mwl_suspend(struct mwl_softc *sc) 796 { 797 struct ifnet *ifp = sc->sc_ifp; 798 799 DPRINTF(sc, MWL_DEBUG_ANY, "%s: if_flags %x\n", 800 __func__, ifp->if_flags); 801 802 mwl_stop(ifp, 1); 803 } 804 805 void 806 mwl_resume(struct mwl_softc *sc) 807 { 808 struct ifnet *ifp = sc->sc_ifp; 809 810 DPRINTF(sc, MWL_DEBUG_ANY, "%s: if_flags %x\n", 811 __func__, ifp->if_flags); 812 813 if (ifp->if_flags & IFF_UP) 814 mwl_init(sc); 815 } 816 817 void 818 mwl_shutdown(void *arg) 819 { 820 struct mwl_softc *sc = arg; 821 822 mwl_stop(sc->sc_ifp, 1); 823 } 824 825 /* 826 * Interrupt handler. Most of the actual processing is deferred. 827 */ 828 void 829 mwl_intr(void *arg) 830 { 831 struct mwl_softc *sc = arg; 832 struct mwl_hal *mh = sc->sc_mh; 833 uint32_t status; 834 835 if (sc->sc_invalid) { 836 /* 837 * The hardware is not ready/present, don't touch anything. 838 * Note this can happen early on if the IRQ is shared. 839 */ 840 DPRINTF(sc, MWL_DEBUG_ANY, "%s: invalid; ignored\n", __func__); 841 return; 842 } 843 /* 844 * Figure out the reason(s) for the interrupt. 845 */ 846 mwl_hal_getisr(mh, &status); /* NB: clears ISR too */ 847 if (status == 0) /* must be a shared irq */ 848 return; 849 850 DPRINTF(sc, MWL_DEBUG_INTR, "%s: status 0x%x imask 0x%x\n", 851 __func__, status, sc->sc_imask); 852 if (status & MACREG_A2HRIC_BIT_RX_RDY) 853 taskqueue_enqueue(sc->sc_tq, &sc->sc_rxtask); 854 if (status & MACREG_A2HRIC_BIT_TX_DONE) 855 taskqueue_enqueue(sc->sc_tq, &sc->sc_txtask); 856 if (status & MACREG_A2HRIC_BIT_BA_WATCHDOG) 857 taskqueue_enqueue(sc->sc_tq, &sc->sc_bawatchdogtask); 858 if (status & MACREG_A2HRIC_BIT_OPC_DONE) 859 mwl_hal_cmddone(mh); 860 if (status & MACREG_A2HRIC_BIT_MAC_EVENT) { 861 ; 862 } 863 if (status & MACREG_A2HRIC_BIT_ICV_ERROR) { 864 /* TKIP ICV error */ 865 sc->sc_stats.mst_rx_badtkipicv++; 866 } 867 if (status & MACREG_A2HRIC_BIT_QUEUE_EMPTY) { 868 /* 11n aggregation queue is empty, re-fill */ 869 ; 870 } 871 if (status & MACREG_A2HRIC_BIT_QUEUE_FULL) { 872 ; 873 } 874 if (status & MACREG_A2HRIC_BIT_RADAR_DETECT) { 875 /* radar detected, process event */ 876 taskqueue_enqueue(sc->sc_tq, &sc->sc_radartask); 877 } 878 if (status & MACREG_A2HRIC_BIT_CHAN_SWITCH) { 879 /* DFS channel switch */ 880 taskqueue_enqueue(sc->sc_tq, &sc->sc_chanswitchtask); 881 } 882 } 883 884 static void 885 mwl_radar_proc(void *arg, int pending) 886 { 887 struct mwl_softc *sc = arg; 888 struct ifnet *ifp = sc->sc_ifp; 889 struct ieee80211com *ic = ifp->if_l2com; 890 891 DPRINTF(sc, MWL_DEBUG_ANY, "%s: radar detected, pending %u\n", 892 __func__, pending); 893 894 sc->sc_stats.mst_radardetect++; 895 /* XXX stop h/w BA streams? */ 896 897 IEEE80211_LOCK(ic); 898 ieee80211_dfs_notify_radar(ic, ic->ic_curchan); 899 IEEE80211_UNLOCK(ic); 900 } 901 902 static void 903 mwl_chanswitch_proc(void *arg, int pending) 904 { 905 struct mwl_softc *sc = arg; 906 struct ifnet *ifp = sc->sc_ifp; 907 struct ieee80211com *ic = ifp->if_l2com; 908 909 DPRINTF(sc, MWL_DEBUG_ANY, "%s: channel switch notice, pending %u\n", 910 __func__, pending); 911 912 IEEE80211_LOCK(ic); 913 sc->sc_csapending = 0; 914 ieee80211_csa_completeswitch(ic); 915 IEEE80211_UNLOCK(ic); 916 } 917 918 static void 919 mwl_bawatchdog(const MWL_HAL_BASTREAM *sp) 920 { 921 struct ieee80211_node *ni = sp->data[0]; 922 923 /* send DELBA and drop the stream */ 924 ieee80211_ampdu_stop(ni, sp->data[1], IEEE80211_REASON_UNSPECIFIED); 925 } 926 927 static void 928 mwl_bawatchdog_proc(void *arg, int pending) 929 { 930 struct mwl_softc *sc = arg; 931 struct mwl_hal *mh = sc->sc_mh; 932 const MWL_HAL_BASTREAM *sp; 933 uint8_t bitmap, n; 934 935 sc->sc_stats.mst_bawatchdog++; 936 937 if (mwl_hal_getwatchdogbitmap(mh, &bitmap) != 0) { 938 DPRINTF(sc, MWL_DEBUG_AMPDU, 939 "%s: could not get bitmap\n", __func__); 940 sc->sc_stats.mst_bawatchdog_failed++; 941 return; 942 } 943 DPRINTF(sc, MWL_DEBUG_AMPDU, "%s: bitmap 0x%x\n", __func__, bitmap); 944 if (bitmap == 0xff) { 945 n = 0; 946 /* disable all ba streams */ 947 for (bitmap = 0; bitmap < 8; bitmap++) { 948 sp = mwl_hal_bastream_lookup(mh, bitmap); 949 if (sp != NULL) { 950 mwl_bawatchdog(sp); 951 n++; 952 } 953 } 954 if (n == 0) { 955 DPRINTF(sc, MWL_DEBUG_AMPDU, 956 "%s: no BA streams found\n", __func__); 957 sc->sc_stats.mst_bawatchdog_empty++; 958 } 959 } else if (bitmap != 0xaa) { 960 /* disable a single ba stream */ 961 sp = mwl_hal_bastream_lookup(mh, bitmap); 962 if (sp != NULL) { 963 mwl_bawatchdog(sp); 964 } else { 965 DPRINTF(sc, MWL_DEBUG_AMPDU, 966 "%s: no BA stream %d\n", __func__, bitmap); 967 sc->sc_stats.mst_bawatchdog_notfound++; 968 } 969 } 970 } 971 972 /* 973 * Convert net80211 channel to a HAL channel. 974 */ 975 static void 976 mwl_mapchan(MWL_HAL_CHANNEL *hc, const struct ieee80211_channel *chan) 977 { 978 hc->channel = chan->ic_ieee; 979 980 *(uint32_t *)&hc->channelFlags = 0; 981 if (IEEE80211_IS_CHAN_2GHZ(chan)) 982 hc->channelFlags.FreqBand = MWL_FREQ_BAND_2DOT4GHZ; 983 else if (IEEE80211_IS_CHAN_5GHZ(chan)) 984 hc->channelFlags.FreqBand = MWL_FREQ_BAND_5GHZ; 985 if (IEEE80211_IS_CHAN_HT40(chan)) { 986 hc->channelFlags.ChnlWidth = MWL_CH_40_MHz_WIDTH; 987 if (IEEE80211_IS_CHAN_HT40U(chan)) 988 hc->channelFlags.ExtChnlOffset = MWL_EXT_CH_ABOVE_CTRL_CH; 989 else 990 hc->channelFlags.ExtChnlOffset = MWL_EXT_CH_BELOW_CTRL_CH; 991 } else 992 hc->channelFlags.ChnlWidth = MWL_CH_20_MHz_WIDTH; 993 /* XXX 10MHz channels */ 994 } 995 996 /* 997 * Inform firmware of our tx/rx dma setup. The BAR 0 998 * writes below are for compatibility with older firmware. 999 * For current firmware we send this information with a 1000 * cmd block via mwl_hal_sethwdma. 1001 */ 1002 static int 1003 mwl_setupdma(struct mwl_softc *sc) 1004 { 1005 int error, i; 1006 1007 sc->sc_hwdma.rxDescRead = sc->sc_rxdma.dd_desc_paddr; 1008 WR4(sc, sc->sc_hwspecs.rxDescRead, sc->sc_hwdma.rxDescRead); 1009 WR4(sc, sc->sc_hwspecs.rxDescWrite, sc->sc_hwdma.rxDescRead); 1010 1011 for (i = 0; i < MWL_NUM_TX_QUEUES-MWL_NUM_ACK_QUEUES; i++) { 1012 struct mwl_txq *txq = &sc->sc_txq[i]; 1013 sc->sc_hwdma.wcbBase[i] = txq->dma.dd_desc_paddr; 1014 WR4(sc, sc->sc_hwspecs.wcbBase[i], sc->sc_hwdma.wcbBase[i]); 1015 } 1016 sc->sc_hwdma.maxNumTxWcb = mwl_txbuf; 1017 sc->sc_hwdma.maxNumWCB = MWL_NUM_TX_QUEUES-MWL_NUM_ACK_QUEUES; 1018 1019 error = mwl_hal_sethwdma(sc->sc_mh, &sc->sc_hwdma); 1020 if (error != 0) { 1021 device_printf(sc->sc_dev, 1022 "unable to setup tx/rx dma; hal status %u\n", error); 1023 /* XXX */ 1024 } 1025 return error; 1026 } 1027 1028 /* 1029 * Inform firmware of tx rate parameters. 1030 * Called after a channel change. 1031 */ 1032 static int 1033 mwl_setcurchanrates(struct mwl_softc *sc) 1034 { 1035 struct ifnet *ifp = sc->sc_ifp; 1036 struct ieee80211com *ic = ifp->if_l2com; 1037 const struct ieee80211_rateset *rs; 1038 MWL_HAL_TXRATE rates; 1039 1040 memset(&rates, 0, sizeof(rates)); 1041 rs = ieee80211_get_suprates(ic, ic->ic_curchan); 1042 /* rate used to send management frames */ 1043 rates.MgtRate = rs->rs_rates[0] & IEEE80211_RATE_VAL; 1044 /* rate used to send multicast frames */ 1045 rates.McastRate = rates.MgtRate; 1046 1047 return mwl_hal_settxrate_auto(sc->sc_mh, &rates); 1048 } 1049 1050 /* 1051 * Inform firmware of tx rate parameters. Called whenever 1052 * user-settable params change and after a channel change. 1053 */ 1054 static int 1055 mwl_setrates(struct ieee80211vap *vap) 1056 { 1057 struct mwl_vap *mvp = MWL_VAP(vap); 1058 struct ieee80211_node *ni = vap->iv_bss; 1059 const struct ieee80211_txparam *tp = ni->ni_txparms; 1060 MWL_HAL_TXRATE rates; 1061 1062 KASSERT(vap->iv_state == IEEE80211_S_RUN, ("state %d", vap->iv_state)); 1063 1064 /* 1065 * Update the h/w rate map. 1066 * NB: 0x80 for MCS is passed through unchanged 1067 */ 1068 memset(&rates, 0, sizeof(rates)); 1069 /* rate used to send management frames */ 1070 rates.MgtRate = tp->mgmtrate; 1071 /* rate used to send multicast frames */ 1072 rates.McastRate = tp->mcastrate; 1073 1074 /* while here calculate EAPOL fixed rate cookie */ 1075 mvp->mv_eapolformat = htole16(mwl_calcformat(rates.MgtRate, ni)); 1076 1077 return mwl_hal_settxrate(mvp->mv_hvap, 1078 tp->ucastrate != IEEE80211_FIXED_RATE_NONE ? 1079 RATE_FIXED : RATE_AUTO, &rates); 1080 } 1081 1082 /* 1083 * Setup a fixed xmit rate cookie for EAPOL frames. 1084 */ 1085 static void 1086 mwl_seteapolformat(struct ieee80211vap *vap) 1087 { 1088 struct mwl_vap *mvp = MWL_VAP(vap); 1089 struct ieee80211_node *ni = vap->iv_bss; 1090 enum ieee80211_phymode mode; 1091 uint8_t rate; 1092 1093 KASSERT(vap->iv_state == IEEE80211_S_RUN, ("state %d", vap->iv_state)); 1094 1095 mode = ieee80211_chan2mode(ni->ni_chan); 1096 /* 1097 * Use legacy rates when operating a mixed HT+non-HT bss. 1098 * NB: this may violate POLA for sta and wds vap's. 1099 */ 1100 if (mode == IEEE80211_MODE_11NA && 1101 (vap->iv_flags_ht & IEEE80211_FHT_PUREN) == 0) 1102 rate = vap->iv_txparms[IEEE80211_MODE_11A].mgmtrate; 1103 else if (mode == IEEE80211_MODE_11NG && 1104 (vap->iv_flags_ht & IEEE80211_FHT_PUREN) == 0) 1105 rate = vap->iv_txparms[IEEE80211_MODE_11G].mgmtrate; 1106 else 1107 rate = vap->iv_txparms[mode].mgmtrate; 1108 1109 mvp->mv_eapolformat = htole16(mwl_calcformat(rate, ni)); 1110 } 1111 1112 /* 1113 * Map SKU+country code to region code for radar bin'ing. 1114 */ 1115 static int 1116 mwl_map2regioncode(const struct ieee80211_regdomain *rd) 1117 { 1118 switch (rd->regdomain) { 1119 case SKU_FCC: 1120 case SKU_FCC3: 1121 return DOMAIN_CODE_FCC; 1122 case SKU_CA: 1123 return DOMAIN_CODE_IC; 1124 case SKU_ETSI: 1125 case SKU_ETSI2: 1126 case SKU_ETSI3: 1127 if (rd->country == CTRY_SPAIN) 1128 return DOMAIN_CODE_SPAIN; 1129 if (rd->country == CTRY_FRANCE || rd->country == CTRY_FRANCE2) 1130 return DOMAIN_CODE_FRANCE; 1131 /* XXX force 1.3.1 radar type */ 1132 return DOMAIN_CODE_ETSI_131; 1133 case SKU_JAPAN: 1134 return DOMAIN_CODE_MKK; 1135 case SKU_ROW: 1136 return DOMAIN_CODE_DGT; /* Taiwan */ 1137 case SKU_APAC: 1138 case SKU_APAC2: 1139 case SKU_APAC3: 1140 return DOMAIN_CODE_AUS; /* Australia */ 1141 } 1142 /* XXX KOREA? */ 1143 return DOMAIN_CODE_FCC; /* XXX? */ 1144 } 1145 1146 static int 1147 mwl_hal_reset(struct mwl_softc *sc) 1148 { 1149 struct ifnet *ifp = sc->sc_ifp; 1150 struct ieee80211com *ic = ifp->if_l2com; 1151 struct mwl_hal *mh = sc->sc_mh; 1152 1153 mwl_hal_setantenna(mh, WL_ANTENNATYPE_RX, sc->sc_rxantenna); 1154 mwl_hal_setantenna(mh, WL_ANTENNATYPE_TX, sc->sc_txantenna); 1155 mwl_hal_setradio(mh, 1, WL_AUTO_PREAMBLE); 1156 mwl_hal_setwmm(sc->sc_mh, (ic->ic_flags & IEEE80211_F_WME) != 0); 1157 mwl_chan_set(sc, ic->ic_curchan); 1158 /* NB: RF/RA performance tuned for indoor mode */ 1159 mwl_hal_setrateadaptmode(mh, 0); 1160 mwl_hal_setoptimizationlevel(mh, 1161 (ic->ic_flags & IEEE80211_F_BURST) != 0); 1162 1163 mwl_hal_setregioncode(mh, mwl_map2regioncode(&ic->ic_regdomain)); 1164 1165 mwl_hal_setaggampduratemode(mh, 1, 80); /* XXX */ 1166 mwl_hal_setcfend(mh, 0); /* XXX */ 1167 1168 return 1; 1169 } 1170 1171 static int 1172 mwl_init_locked(struct mwl_softc *sc) 1173 { 1174 struct ifnet *ifp = sc->sc_ifp; 1175 struct mwl_hal *mh = sc->sc_mh; 1176 int error = 0; 1177 1178 DPRINTF(sc, MWL_DEBUG_ANY, "%s: if_flags 0x%x\n", 1179 __func__, ifp->if_flags); 1180 1181 MWL_LOCK_ASSERT(sc); 1182 1183 /* 1184 * Stop anything previously setup. This is safe 1185 * whether this is the first time through or not. 1186 */ 1187 mwl_stop_locked(ifp, 0); 1188 1189 /* 1190 * Push vap-independent state to the firmware. 1191 */ 1192 if (!mwl_hal_reset(sc)) { 1193 if_printf(ifp, "unable to reset hardware\n"); 1194 return EIO; 1195 } 1196 1197 /* 1198 * Setup recv (once); transmit is already good to go. 1199 */ 1200 error = mwl_startrecv(sc); 1201 if (error != 0) { 1202 if_printf(ifp, "unable to start recv logic\n"); 1203 return error; 1204 } 1205 1206 /* 1207 * Enable interrupts. 1208 */ 1209 sc->sc_imask = MACREG_A2HRIC_BIT_RX_RDY 1210 | MACREG_A2HRIC_BIT_TX_DONE 1211 | MACREG_A2HRIC_BIT_OPC_DONE 1212 #if 0 1213 | MACREG_A2HRIC_BIT_MAC_EVENT 1214 #endif 1215 | MACREG_A2HRIC_BIT_ICV_ERROR 1216 | MACREG_A2HRIC_BIT_RADAR_DETECT 1217 | MACREG_A2HRIC_BIT_CHAN_SWITCH 1218 #if 0 1219 | MACREG_A2HRIC_BIT_QUEUE_EMPTY 1220 #endif 1221 | MACREG_A2HRIC_BIT_BA_WATCHDOG 1222 | MACREQ_A2HRIC_BIT_TX_ACK 1223 ; 1224 1225 ifp->if_drv_flags |= IFF_DRV_RUNNING; 1226 mwl_hal_intrset(mh, sc->sc_imask); 1227 callout_reset(&sc->sc_watchdog, hz, mwl_watchdog, sc); 1228 1229 return 0; 1230 } 1231 1232 static void 1233 mwl_init(void *arg) 1234 { 1235 struct mwl_softc *sc = arg; 1236 struct ifnet *ifp = sc->sc_ifp; 1237 struct ieee80211com *ic = ifp->if_l2com; 1238 int error = 0; 1239 1240 DPRINTF(sc, MWL_DEBUG_ANY, "%s: if_flags 0x%x\n", 1241 __func__, ifp->if_flags); 1242 1243 MWL_LOCK(sc); 1244 error = mwl_init_locked(sc); 1245 MWL_UNLOCK(sc); 1246 1247 if (error == 0) 1248 ieee80211_start_all(ic); /* start all vap's */ 1249 } 1250 1251 static void 1252 mwl_stop_locked(struct ifnet *ifp, int disable) 1253 { 1254 struct mwl_softc *sc = ifp->if_softc; 1255 1256 DPRINTF(sc, MWL_DEBUG_ANY, "%s: invalid %u if_flags 0x%x\n", 1257 __func__, sc->sc_invalid, ifp->if_flags); 1258 1259 MWL_LOCK_ASSERT(sc); 1260 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 1261 /* 1262 * Shutdown the hardware and driver. 1263 */ 1264 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 1265 callout_stop(&sc->sc_watchdog); 1266 sc->sc_tx_timer = 0; 1267 mwl_draintxq(sc); 1268 } 1269 } 1270 1271 static void 1272 mwl_stop(struct ifnet *ifp, int disable) 1273 { 1274 struct mwl_softc *sc = ifp->if_softc; 1275 1276 MWL_LOCK(sc); 1277 mwl_stop_locked(ifp, disable); 1278 MWL_UNLOCK(sc); 1279 } 1280 1281 static int 1282 mwl_reset_vap(struct ieee80211vap *vap, int state) 1283 { 1284 struct mwl_hal_vap *hvap = MWL_VAP(vap)->mv_hvap; 1285 struct ieee80211com *ic = vap->iv_ic; 1286 1287 if (state == IEEE80211_S_RUN) 1288 mwl_setrates(vap); 1289 /* XXX off by 1? */ 1290 mwl_hal_setrtsthreshold(hvap, vap->iv_rtsthreshold); 1291 /* XXX auto? 20/40 split? */ 1292 mwl_hal_sethtgi(hvap, (vap->iv_flags_ht & 1293 (IEEE80211_FHT_SHORTGI20|IEEE80211_FHT_SHORTGI40)) ? 1 : 0); 1294 mwl_hal_setnprot(hvap, ic->ic_htprotmode == IEEE80211_PROT_NONE ? 1295 HTPROTECT_NONE : HTPROTECT_AUTO); 1296 /* XXX txpower cap */ 1297 1298 /* re-setup beacons */ 1299 if (state == IEEE80211_S_RUN && 1300 (vap->iv_opmode == IEEE80211_M_HOSTAP || 1301 vap->iv_opmode == IEEE80211_M_MBSS || 1302 vap->iv_opmode == IEEE80211_M_IBSS)) { 1303 mwl_setapmode(vap, vap->iv_bss->ni_chan); 1304 mwl_hal_setnprotmode(hvap, 1305 MS(ic->ic_curhtprotmode, IEEE80211_HTINFO_OPMODE)); 1306 return mwl_beacon_setup(vap); 1307 } 1308 return 0; 1309 } 1310 1311 /* 1312 * Reset the hardware w/o losing operational state. 1313 * Used to to reset or reload hardware state for a vap. 1314 */ 1315 static int 1316 mwl_reset(struct ieee80211vap *vap, u_long cmd) 1317 { 1318 struct mwl_hal_vap *hvap = MWL_VAP(vap)->mv_hvap; 1319 int error = 0; 1320 1321 if (hvap != NULL) { /* WDS, MONITOR, etc. */ 1322 struct ieee80211com *ic = vap->iv_ic; 1323 struct ifnet *ifp = ic->ic_ifp; 1324 struct mwl_softc *sc = ifp->if_softc; 1325 struct mwl_hal *mh = sc->sc_mh; 1326 1327 /* XXX handle DWDS sta vap change */ 1328 /* XXX do we need to disable interrupts? */ 1329 mwl_hal_intrset(mh, 0); /* disable interrupts */ 1330 error = mwl_reset_vap(vap, vap->iv_state); 1331 mwl_hal_intrset(mh, sc->sc_imask); 1332 } 1333 return error; 1334 } 1335 1336 /* 1337 * Allocate a tx buffer for sending a frame. The 1338 * packet is assumed to have the WME AC stored so 1339 * we can use it to select the appropriate h/w queue. 1340 */ 1341 static struct mwl_txbuf * 1342 mwl_gettxbuf(struct mwl_softc *sc, struct mwl_txq *txq) 1343 { 1344 struct mwl_txbuf *bf; 1345 1346 /* 1347 * Grab a TX buffer and associated resources. 1348 */ 1349 MWL_TXQ_LOCK(txq); 1350 bf = STAILQ_FIRST(&txq->free); 1351 if (bf != NULL) { 1352 STAILQ_REMOVE_HEAD(&txq->free, bf_list); 1353 txq->nfree--; 1354 } 1355 MWL_TXQ_UNLOCK(txq); 1356 if (bf == NULL) 1357 DPRINTF(sc, MWL_DEBUG_XMIT, 1358 "%s: out of xmit buffers on q %d\n", __func__, txq->qnum); 1359 return bf; 1360 } 1361 1362 /* 1363 * Return a tx buffer to the queue it came from. Note there 1364 * are two cases because we must preserve the order of buffers 1365 * as it reflects the fixed order of descriptors in memory 1366 * (the firmware pre-fetches descriptors so we cannot reorder). 1367 */ 1368 static void 1369 mwl_puttxbuf_head(struct mwl_txq *txq, struct mwl_txbuf *bf) 1370 { 1371 bf->bf_m = NULL; 1372 bf->bf_node = NULL; 1373 MWL_TXQ_LOCK(txq); 1374 STAILQ_INSERT_HEAD(&txq->free, bf, bf_list); 1375 txq->nfree++; 1376 MWL_TXQ_UNLOCK(txq); 1377 } 1378 1379 static void 1380 mwl_puttxbuf_tail(struct mwl_txq *txq, struct mwl_txbuf *bf) 1381 { 1382 bf->bf_m = NULL; 1383 bf->bf_node = NULL; 1384 MWL_TXQ_LOCK(txq); 1385 STAILQ_INSERT_TAIL(&txq->free, bf, bf_list); 1386 txq->nfree++; 1387 MWL_TXQ_UNLOCK(txq); 1388 } 1389 1390 static void 1391 mwl_start(struct ifnet *ifp) 1392 { 1393 struct mwl_softc *sc = ifp->if_softc; 1394 struct ieee80211_node *ni; 1395 struct mwl_txbuf *bf; 1396 struct mbuf *m; 1397 struct mwl_txq *txq = NULL; /* XXX silence gcc */ 1398 int nqueued; 1399 1400 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || sc->sc_invalid) 1401 return; 1402 nqueued = 0; 1403 for (;;) { 1404 bf = NULL; 1405 IFQ_DEQUEUE(&ifp->if_snd, m); 1406 if (m == NULL) 1407 break; 1408 /* 1409 * Grab the node for the destination. 1410 */ 1411 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif; 1412 KASSERT(ni != NULL, ("no node")); 1413 m->m_pkthdr.rcvif = NULL; /* committed, clear ref */ 1414 /* 1415 * Grab a TX buffer and associated resources. 1416 * We honor the classification by the 802.11 layer. 1417 */ 1418 txq = sc->sc_ac2q[M_WME_GETAC(m)]; 1419 bf = mwl_gettxbuf(sc, txq); 1420 if (bf == NULL) { 1421 m_freem(m); 1422 ieee80211_free_node(ni); 1423 #ifdef MWL_TX_NODROP 1424 sc->sc_stats.mst_tx_qstop++; 1425 /* XXX blocks other traffic */ 1426 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 1427 break; 1428 #else 1429 DPRINTF(sc, MWL_DEBUG_XMIT, 1430 "%s: tail drop on q %d\n", __func__, txq->qnum); 1431 sc->sc_stats.mst_tx_qdrop++; 1432 continue; 1433 #endif /* MWL_TX_NODROP */ 1434 } 1435 1436 /* 1437 * Pass the frame to the h/w for transmission. 1438 */ 1439 if (mwl_tx_start(sc, ni, bf, m)) { 1440 ifp->if_oerrors++; 1441 mwl_puttxbuf_head(txq, bf); 1442 ieee80211_free_node(ni); 1443 continue; 1444 } 1445 nqueued++; 1446 if (nqueued >= mwl_txcoalesce) { 1447 /* 1448 * Poke the firmware to process queued frames; 1449 * see below about (lack of) locking. 1450 */ 1451 nqueued = 0; 1452 mwl_hal_txstart(sc->sc_mh, 0/*XXX*/); 1453 } 1454 } 1455 if (nqueued) { 1456 /* 1457 * NB: We don't need to lock against tx done because 1458 * this just prods the firmware to check the transmit 1459 * descriptors. The firmware will also start fetching 1460 * descriptors by itself if it notices new ones are 1461 * present when it goes to deliver a tx done interrupt 1462 * to the host. So if we race with tx done processing 1463 * it's ok. Delivering the kick here rather than in 1464 * mwl_tx_start is an optimization to avoid poking the 1465 * firmware for each packet. 1466 * 1467 * NB: the queue id isn't used so 0 is ok. 1468 */ 1469 mwl_hal_txstart(sc->sc_mh, 0/*XXX*/); 1470 } 1471 } 1472 1473 static int 1474 mwl_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 1475 const struct ieee80211_bpf_params *params) 1476 { 1477 struct ieee80211com *ic = ni->ni_ic; 1478 struct ifnet *ifp = ic->ic_ifp; 1479 struct mwl_softc *sc = ifp->if_softc; 1480 struct mwl_txbuf *bf; 1481 struct mwl_txq *txq; 1482 1483 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || sc->sc_invalid) { 1484 ieee80211_free_node(ni); 1485 m_freem(m); 1486 return ENETDOWN; 1487 } 1488 /* 1489 * Grab a TX buffer and associated resources. 1490 * Note that we depend on the classification 1491 * by the 802.11 layer to get to the right h/w 1492 * queue. Management frames must ALWAYS go on 1493 * queue 1 but we cannot just force that here 1494 * because we may receive non-mgt frames. 1495 */ 1496 txq = sc->sc_ac2q[M_WME_GETAC(m)]; 1497 bf = mwl_gettxbuf(sc, txq); 1498 if (bf == NULL) { 1499 sc->sc_stats.mst_tx_qstop++; 1500 /* XXX blocks other traffic */ 1501 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 1502 ieee80211_free_node(ni); 1503 m_freem(m); 1504 return ENOBUFS; 1505 } 1506 /* 1507 * Pass the frame to the h/w for transmission. 1508 */ 1509 if (mwl_tx_start(sc, ni, bf, m)) { 1510 ifp->if_oerrors++; 1511 mwl_puttxbuf_head(txq, bf); 1512 1513 ieee80211_free_node(ni); 1514 return EIO; /* XXX */ 1515 } 1516 /* 1517 * NB: We don't need to lock against tx done because 1518 * this just prods the firmware to check the transmit 1519 * descriptors. The firmware will also start fetching 1520 * descriptors by itself if it notices new ones are 1521 * present when it goes to deliver a tx done interrupt 1522 * to the host. So if we race with tx done processing 1523 * it's ok. Delivering the kick here rather than in 1524 * mwl_tx_start is an optimization to avoid poking the 1525 * firmware for each packet. 1526 * 1527 * NB: the queue id isn't used so 0 is ok. 1528 */ 1529 mwl_hal_txstart(sc->sc_mh, 0/*XXX*/); 1530 return 0; 1531 } 1532 1533 static int 1534 mwl_media_change(struct ifnet *ifp) 1535 { 1536 struct ieee80211vap *vap = ifp->if_softc; 1537 int error; 1538 1539 error = ieee80211_media_change(ifp); 1540 /* NB: only the fixed rate can change and that doesn't need a reset */ 1541 if (error == ENETRESET) { 1542 mwl_setrates(vap); 1543 error = 0; 1544 } 1545 return error; 1546 } 1547 1548 #ifdef MWL_DEBUG 1549 static void 1550 mwl_keyprint(struct mwl_softc *sc, const char *tag, 1551 const MWL_HAL_KEYVAL *hk, const uint8_t mac[IEEE80211_ADDR_LEN]) 1552 { 1553 static const char *ciphers[] = { 1554 "WEP", 1555 "TKIP", 1556 "AES-CCM", 1557 }; 1558 int i, n; 1559 1560 printf("%s: [%u] %-7s", tag, hk->keyIndex, ciphers[hk->keyTypeId]); 1561 for (i = 0, n = hk->keyLen; i < n; i++) 1562 printf(" %02x", hk->key.aes[i]); 1563 printf(" mac %s", ether_sprintf(mac)); 1564 if (hk->keyTypeId == KEY_TYPE_ID_TKIP) { 1565 printf(" %s", "rxmic"); 1566 for (i = 0; i < sizeof(hk->key.tkip.rxMic); i++) 1567 printf(" %02x", hk->key.tkip.rxMic[i]); 1568 printf(" txmic"); 1569 for (i = 0; i < sizeof(hk->key.tkip.txMic); i++) 1570 printf(" %02x", hk->key.tkip.txMic[i]); 1571 } 1572 printf(" flags 0x%x\n", hk->keyFlags); 1573 } 1574 #endif 1575 1576 /* 1577 * Allocate a key cache slot for a unicast key. The 1578 * firmware handles key allocation and every station is 1579 * guaranteed key space so we are always successful. 1580 */ 1581 static int 1582 mwl_key_alloc(struct ieee80211vap *vap, struct ieee80211_key *k, 1583 ieee80211_keyix *keyix, ieee80211_keyix *rxkeyix) 1584 { 1585 struct mwl_softc *sc = vap->iv_ic->ic_ifp->if_softc; 1586 1587 if (k->wk_keyix != IEEE80211_KEYIX_NONE || 1588 (k->wk_flags & IEEE80211_KEY_GROUP)) { 1589 if (!(&vap->iv_nw_keys[0] <= k && 1590 k < &vap->iv_nw_keys[IEEE80211_WEP_NKID])) { 1591 /* should not happen */ 1592 DPRINTF(sc, MWL_DEBUG_KEYCACHE, 1593 "%s: bogus group key\n", __func__); 1594 return 0; 1595 } 1596 /* give the caller what they requested */ 1597 *keyix = *rxkeyix = k - vap->iv_nw_keys; 1598 } else { 1599 /* 1600 * Firmware handles key allocation. 1601 */ 1602 *keyix = *rxkeyix = 0; 1603 } 1604 return 1; 1605 } 1606 1607 /* 1608 * Delete a key entry allocated by mwl_key_alloc. 1609 */ 1610 static int 1611 mwl_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k) 1612 { 1613 struct mwl_softc *sc = vap->iv_ic->ic_ifp->if_softc; 1614 struct mwl_hal_vap *hvap = MWL_VAP(vap)->mv_hvap; 1615 MWL_HAL_KEYVAL hk; 1616 const uint8_t bcastaddr[IEEE80211_ADDR_LEN] = 1617 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 1618 1619 if (hvap == NULL) { 1620 if (vap->iv_opmode != IEEE80211_M_WDS) { 1621 /* XXX monitor mode? */ 1622 DPRINTF(sc, MWL_DEBUG_KEYCACHE, 1623 "%s: no hvap for opmode %d\n", __func__, 1624 vap->iv_opmode); 1625 return 0; 1626 } 1627 hvap = MWL_VAP(vap)->mv_ap_hvap; 1628 } 1629 1630 DPRINTF(sc, MWL_DEBUG_KEYCACHE, "%s: delete key %u\n", 1631 __func__, k->wk_keyix); 1632 1633 memset(&hk, 0, sizeof(hk)); 1634 hk.keyIndex = k->wk_keyix; 1635 switch (k->wk_cipher->ic_cipher) { 1636 case IEEE80211_CIPHER_WEP: 1637 hk.keyTypeId = KEY_TYPE_ID_WEP; 1638 break; 1639 case IEEE80211_CIPHER_TKIP: 1640 hk.keyTypeId = KEY_TYPE_ID_TKIP; 1641 break; 1642 case IEEE80211_CIPHER_AES_CCM: 1643 hk.keyTypeId = KEY_TYPE_ID_AES; 1644 break; 1645 default: 1646 /* XXX should not happen */ 1647 DPRINTF(sc, MWL_DEBUG_KEYCACHE, "%s: unknown cipher %d\n", 1648 __func__, k->wk_cipher->ic_cipher); 1649 return 0; 1650 } 1651 return (mwl_hal_keyreset(hvap, &hk, bcastaddr) == 0); /*XXX*/ 1652 } 1653 1654 static __inline int 1655 addgroupflags(MWL_HAL_KEYVAL *hk, const struct ieee80211_key *k) 1656 { 1657 if (k->wk_flags & IEEE80211_KEY_GROUP) { 1658 if (k->wk_flags & IEEE80211_KEY_XMIT) 1659 hk->keyFlags |= KEY_FLAG_TXGROUPKEY; 1660 if (k->wk_flags & IEEE80211_KEY_RECV) 1661 hk->keyFlags |= KEY_FLAG_RXGROUPKEY; 1662 return 1; 1663 } else 1664 return 0; 1665 } 1666 1667 /* 1668 * Set the key cache contents for the specified key. Key cache 1669 * slot(s) must already have been allocated by mwl_key_alloc. 1670 */ 1671 static int 1672 mwl_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k, 1673 const uint8_t mac[IEEE80211_ADDR_LEN]) 1674 { 1675 #define GRPXMIT (IEEE80211_KEY_XMIT | IEEE80211_KEY_GROUP) 1676 /* NB: static wep keys are marked GROUP+tx/rx; GTK will be tx or rx */ 1677 #define IEEE80211_IS_STATICKEY(k) \ 1678 (((k)->wk_flags & (GRPXMIT|IEEE80211_KEY_RECV)) == \ 1679 (GRPXMIT|IEEE80211_KEY_RECV)) 1680 struct mwl_softc *sc = vap->iv_ic->ic_ifp->if_softc; 1681 struct mwl_hal_vap *hvap = MWL_VAP(vap)->mv_hvap; 1682 const struct ieee80211_cipher *cip = k->wk_cipher; 1683 const uint8_t *macaddr; 1684 MWL_HAL_KEYVAL hk; 1685 1686 KASSERT((k->wk_flags & IEEE80211_KEY_SWCRYPT) == 0, 1687 ("s/w crypto set?")); 1688 1689 if (hvap == NULL) { 1690 if (vap->iv_opmode != IEEE80211_M_WDS) { 1691 /* XXX monitor mode? */ 1692 DPRINTF(sc, MWL_DEBUG_KEYCACHE, 1693 "%s: no hvap for opmode %d\n", __func__, 1694 vap->iv_opmode); 1695 return 0; 1696 } 1697 hvap = MWL_VAP(vap)->mv_ap_hvap; 1698 } 1699 memset(&hk, 0, sizeof(hk)); 1700 hk.keyIndex = k->wk_keyix; 1701 switch (cip->ic_cipher) { 1702 case IEEE80211_CIPHER_WEP: 1703 hk.keyTypeId = KEY_TYPE_ID_WEP; 1704 hk.keyLen = k->wk_keylen; 1705 if (k->wk_keyix == vap->iv_def_txkey) 1706 hk.keyFlags = KEY_FLAG_WEP_TXKEY; 1707 if (!IEEE80211_IS_STATICKEY(k)) { 1708 /* NB: WEP is never used for the PTK */ 1709 (void) addgroupflags(&hk, k); 1710 } 1711 break; 1712 case IEEE80211_CIPHER_TKIP: 1713 hk.keyTypeId = KEY_TYPE_ID_TKIP; 1714 hk.key.tkip.tsc.high = (uint32_t)(k->wk_keytsc >> 16); 1715 hk.key.tkip.tsc.low = (uint16_t)k->wk_keytsc; 1716 hk.keyFlags = KEY_FLAG_TSC_VALID | KEY_FLAG_MICKEY_VALID; 1717 hk.keyLen = k->wk_keylen + IEEE80211_MICBUF_SIZE; 1718 if (!addgroupflags(&hk, k)) 1719 hk.keyFlags |= KEY_FLAG_PAIRWISE; 1720 break; 1721 case IEEE80211_CIPHER_AES_CCM: 1722 hk.keyTypeId = KEY_TYPE_ID_AES; 1723 hk.keyLen = k->wk_keylen; 1724 if (!addgroupflags(&hk, k)) 1725 hk.keyFlags |= KEY_FLAG_PAIRWISE; 1726 break; 1727 default: 1728 /* XXX should not happen */ 1729 DPRINTF(sc, MWL_DEBUG_KEYCACHE, "%s: unknown cipher %d\n", 1730 __func__, k->wk_cipher->ic_cipher); 1731 return 0; 1732 } 1733 /* 1734 * NB: tkip mic keys get copied here too; the layout 1735 * just happens to match that in ieee80211_key. 1736 */ 1737 memcpy(hk.key.aes, k->wk_key, hk.keyLen); 1738 1739 /* 1740 * Locate address of sta db entry for writing key; 1741 * the convention unfortunately is somewhat different 1742 * than how net80211, hostapd, and wpa_supplicant think. 1743 */ 1744 if (vap->iv_opmode == IEEE80211_M_STA) { 1745 /* 1746 * NB: keys plumbed before the sta reaches AUTH state 1747 * will be discarded or written to the wrong sta db 1748 * entry because iv_bss is meaningless. This is ok 1749 * (right now) because we handle deferred plumbing of 1750 * WEP keys when the sta reaches AUTH state. 1751 */ 1752 macaddr = vap->iv_bss->ni_bssid; 1753 if ((k->wk_flags & IEEE80211_KEY_GROUP) == 0) { 1754 /* XXX plumb to local sta db too for static key wep */ 1755 mwl_hal_keyset(hvap, &hk, vap->iv_myaddr); 1756 } 1757 } else if (vap->iv_opmode == IEEE80211_M_WDS && 1758 vap->iv_state != IEEE80211_S_RUN) { 1759 /* 1760 * Prior to RUN state a WDS vap will not it's BSS node 1761 * setup so we will plumb the key to the wrong mac 1762 * address (it'll be our local address). Workaround 1763 * this for the moment by grabbing the correct address. 1764 */ 1765 macaddr = vap->iv_des_bssid; 1766 } else if ((k->wk_flags & GRPXMIT) == GRPXMIT) 1767 macaddr = vap->iv_myaddr; 1768 else 1769 macaddr = mac; 1770 KEYPRINTF(sc, &hk, macaddr); 1771 return (mwl_hal_keyset(hvap, &hk, macaddr) == 0); 1772 #undef IEEE80211_IS_STATICKEY 1773 #undef GRPXMIT 1774 } 1775 1776 /* unaligned little endian access */ 1777 #define LE_READ_2(p) \ 1778 ((uint16_t) \ 1779 ((((const uint8_t *)(p))[0] ) | \ 1780 (((const uint8_t *)(p))[1] << 8))) 1781 #define LE_READ_4(p) \ 1782 ((uint32_t) \ 1783 ((((const uint8_t *)(p))[0] ) | \ 1784 (((const uint8_t *)(p))[1] << 8) | \ 1785 (((const uint8_t *)(p))[2] << 16) | \ 1786 (((const uint8_t *)(p))[3] << 24))) 1787 1788 /* 1789 * Set the multicast filter contents into the hardware. 1790 * XXX f/w has no support; just defer to the os. 1791 */ 1792 static void 1793 mwl_setmcastfilter(struct mwl_softc *sc) 1794 { 1795 struct ifnet *ifp = sc->sc_ifp; 1796 #if 0 1797 struct ether_multi *enm; 1798 struct ether_multistep estep; 1799 uint8_t macs[IEEE80211_ADDR_LEN*MWL_HAL_MCAST_MAX];/* XXX stack use */ 1800 uint8_t *mp; 1801 int nmc; 1802 1803 mp = macs; 1804 nmc = 0; 1805 ETHER_FIRST_MULTI(estep, &sc->sc_ec, enm); 1806 while (enm != NULL) { 1807 /* XXX Punt on ranges. */ 1808 if (nmc == MWL_HAL_MCAST_MAX || 1809 !IEEE80211_ADDR_EQ(enm->enm_addrlo, enm->enm_addrhi)) { 1810 ifp->if_flags |= IFF_ALLMULTI; 1811 return; 1812 } 1813 IEEE80211_ADDR_COPY(mp, enm->enm_addrlo); 1814 mp += IEEE80211_ADDR_LEN, nmc++; 1815 ETHER_NEXT_MULTI(estep, enm); 1816 } 1817 ifp->if_flags &= ~IFF_ALLMULTI; 1818 mwl_hal_setmcast(sc->sc_mh, nmc, macs); 1819 #else 1820 /* XXX no mcast filter support; we get everything */ 1821 ifp->if_flags |= IFF_ALLMULTI; 1822 #endif 1823 } 1824 1825 static int 1826 mwl_mode_init(struct mwl_softc *sc) 1827 { 1828 struct ifnet *ifp = sc->sc_ifp; 1829 struct ieee80211com *ic = ifp->if_l2com; 1830 struct mwl_hal *mh = sc->sc_mh; 1831 1832 /* 1833 * NB: Ignore promisc in hostap mode; it's set by the 1834 * bridge. This is wrong but we have no way to 1835 * identify internal requests (from the bridge) 1836 * versus external requests such as for tcpdump. 1837 */ 1838 mwl_hal_setpromisc(mh, (ifp->if_flags & IFF_PROMISC) && 1839 ic->ic_opmode != IEEE80211_M_HOSTAP); 1840 mwl_setmcastfilter(sc); 1841 1842 return 0; 1843 } 1844 1845 /* 1846 * Callback from the 802.11 layer after a multicast state change. 1847 */ 1848 static void 1849 mwl_update_mcast(struct ifnet *ifp) 1850 { 1851 struct mwl_softc *sc = ifp->if_softc; 1852 1853 mwl_setmcastfilter(sc); 1854 } 1855 1856 /* 1857 * Callback from the 802.11 layer after a promiscuous mode change. 1858 * Note this interface does not check the operating mode as this 1859 * is an internal callback and we are expected to honor the current 1860 * state (e.g. this is used for setting the interface in promiscuous 1861 * mode when operating in hostap mode to do ACS). 1862 */ 1863 static void 1864 mwl_update_promisc(struct ifnet *ifp) 1865 { 1866 struct mwl_softc *sc = ifp->if_softc; 1867 1868 mwl_hal_setpromisc(sc->sc_mh, (ifp->if_flags & IFF_PROMISC) != 0); 1869 } 1870 1871 /* 1872 * Callback from the 802.11 layer to update the slot time 1873 * based on the current setting. We use it to notify the 1874 * firmware of ERP changes and the f/w takes care of things 1875 * like slot time and preamble. 1876 */ 1877 static void 1878 mwl_updateslot(struct ifnet *ifp) 1879 { 1880 struct mwl_softc *sc = ifp->if_softc; 1881 struct ieee80211com *ic = ifp->if_l2com; 1882 struct mwl_hal *mh = sc->sc_mh; 1883 int prot; 1884 1885 /* NB: can be called early; suppress needless cmds */ 1886 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 1887 return; 1888 1889 /* 1890 * Calculate the ERP flags. The firwmare will use 1891 * this to carry out the appropriate measures. 1892 */ 1893 prot = 0; 1894 if (IEEE80211_IS_CHAN_ANYG(ic->ic_curchan)) { 1895 if ((ic->ic_flags & IEEE80211_F_SHSLOT) == 0) 1896 prot |= IEEE80211_ERP_NON_ERP_PRESENT; 1897 if (ic->ic_flags & IEEE80211_F_USEPROT) 1898 prot |= IEEE80211_ERP_USE_PROTECTION; 1899 if (ic->ic_flags & IEEE80211_F_USEBARKER) 1900 prot |= IEEE80211_ERP_LONG_PREAMBLE; 1901 } 1902 1903 DPRINTF(sc, MWL_DEBUG_RESET, 1904 "%s: chan %u MHz/flags 0x%x %s slot, (prot 0x%x ic_flags 0x%x)\n", 1905 __func__, ic->ic_curchan->ic_freq, ic->ic_curchan->ic_flags, 1906 ic->ic_flags & IEEE80211_F_SHSLOT ? "short" : "long", prot, 1907 ic->ic_flags); 1908 1909 mwl_hal_setgprot(mh, prot); 1910 } 1911 1912 /* 1913 * Setup the beacon frame. 1914 */ 1915 static int 1916 mwl_beacon_setup(struct ieee80211vap *vap) 1917 { 1918 struct mwl_hal_vap *hvap = MWL_VAP(vap)->mv_hvap; 1919 struct ieee80211_node *ni = vap->iv_bss; 1920 struct ieee80211_beacon_offsets bo; 1921 struct mbuf *m; 1922 1923 m = ieee80211_beacon_alloc(ni, &bo); 1924 if (m == NULL) 1925 return ENOBUFS; 1926 mwl_hal_setbeacon(hvap, mtod(m, const void *), m->m_len); 1927 m_free(m); 1928 1929 return 0; 1930 } 1931 1932 /* 1933 * Update the beacon frame in response to a change. 1934 */ 1935 static void 1936 mwl_beacon_update(struct ieee80211vap *vap, int item) 1937 { 1938 struct mwl_hal_vap *hvap = MWL_VAP(vap)->mv_hvap; 1939 struct ieee80211com *ic = vap->iv_ic; 1940 1941 KASSERT(hvap != NULL, ("no beacon")); 1942 switch (item) { 1943 case IEEE80211_BEACON_ERP: 1944 mwl_updateslot(ic->ic_ifp); 1945 break; 1946 case IEEE80211_BEACON_HTINFO: 1947 mwl_hal_setnprotmode(hvap, 1948 MS(ic->ic_curhtprotmode, IEEE80211_HTINFO_OPMODE)); 1949 break; 1950 case IEEE80211_BEACON_CAPS: 1951 case IEEE80211_BEACON_WME: 1952 case IEEE80211_BEACON_APPIE: 1953 case IEEE80211_BEACON_CSA: 1954 break; 1955 case IEEE80211_BEACON_TIM: 1956 /* NB: firmware always forms TIM */ 1957 return; 1958 } 1959 /* XXX retain beacon frame and update */ 1960 mwl_beacon_setup(vap); 1961 } 1962 1963 static void 1964 mwl_load_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 1965 { 1966 bus_addr_t *paddr = (bus_addr_t*) arg; 1967 KASSERT(error == 0, ("error %u on bus_dma callback", error)); 1968 *paddr = segs->ds_addr; 1969 } 1970 1971 #ifdef MWL_HOST_PS_SUPPORT 1972 /* 1973 * Handle power save station occupancy changes. 1974 */ 1975 static void 1976 mwl_update_ps(struct ieee80211vap *vap, int nsta) 1977 { 1978 struct mwl_vap *mvp = MWL_VAP(vap); 1979 1980 if (nsta == 0 || mvp->mv_last_ps_sta == 0) 1981 mwl_hal_setpowersave_bss(mvp->mv_hvap, nsta); 1982 mvp->mv_last_ps_sta = nsta; 1983 } 1984 1985 /* 1986 * Handle associated station power save state changes. 1987 */ 1988 static int 1989 mwl_set_tim(struct ieee80211_node *ni, int set) 1990 { 1991 struct ieee80211vap *vap = ni->ni_vap; 1992 struct mwl_vap *mvp = MWL_VAP(vap); 1993 1994 if (mvp->mv_set_tim(ni, set)) { /* NB: state change */ 1995 mwl_hal_setpowersave_sta(mvp->mv_hvap, 1996 IEEE80211_AID(ni->ni_associd), set); 1997 return 1; 1998 } else 1999 return 0; 2000 } 2001 #endif /* MWL_HOST_PS_SUPPORT */ 2002 2003 static int 2004 mwl_desc_setup(struct mwl_softc *sc, const char *name, 2005 struct mwl_descdma *dd, 2006 int nbuf, size_t bufsize, int ndesc, size_t descsize) 2007 { 2008 struct ifnet *ifp = sc->sc_ifp; 2009 uint8_t *ds; 2010 int error; 2011 2012 DPRINTF(sc, MWL_DEBUG_RESET, 2013 "%s: %s DMA: %u bufs (%ju) %u desc/buf (%ju)\n", 2014 __func__, name, nbuf, (uintmax_t) bufsize, 2015 ndesc, (uintmax_t) descsize); 2016 2017 dd->dd_name = name; 2018 dd->dd_desc_len = nbuf * ndesc * descsize; 2019 2020 /* 2021 * Setup DMA descriptor area. 2022 */ 2023 error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), /* parent */ 2024 PAGE_SIZE, 0, /* alignment, bounds */ 2025 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 2026 BUS_SPACE_MAXADDR, /* highaddr */ 2027 NULL, NULL, /* filter, filterarg */ 2028 dd->dd_desc_len, /* maxsize */ 2029 1, /* nsegments */ 2030 dd->dd_desc_len, /* maxsegsize */ 2031 BUS_DMA_ALLOCNOW, /* flags */ 2032 NULL, /* lockfunc */ 2033 NULL, /* lockarg */ 2034 &dd->dd_dmat); 2035 if (error != 0) { 2036 if_printf(ifp, "cannot allocate %s DMA tag\n", dd->dd_name); 2037 return error; 2038 } 2039 2040 /* allocate descriptors */ 2041 error = bus_dmamap_create(dd->dd_dmat, BUS_DMA_NOWAIT, &dd->dd_dmamap); 2042 if (error != 0) { 2043 if_printf(ifp, "unable to create dmamap for %s descriptors, " 2044 "error %u\n", dd->dd_name, error); 2045 goto fail0; 2046 } 2047 2048 error = bus_dmamem_alloc(dd->dd_dmat, (void**) &dd->dd_desc, 2049 BUS_DMA_NOWAIT | BUS_DMA_COHERENT, 2050 &dd->dd_dmamap); 2051 if (error != 0) { 2052 if_printf(ifp, "unable to alloc memory for %u %s descriptors, " 2053 "error %u\n", nbuf * ndesc, dd->dd_name, error); 2054 goto fail1; 2055 } 2056 2057 error = bus_dmamap_load(dd->dd_dmat, dd->dd_dmamap, 2058 dd->dd_desc, dd->dd_desc_len, 2059 mwl_load_cb, &dd->dd_desc_paddr, 2060 BUS_DMA_NOWAIT); 2061 if (error != 0) { 2062 if_printf(ifp, "unable to map %s descriptors, error %u\n", 2063 dd->dd_name, error); 2064 goto fail2; 2065 } 2066 2067 ds = dd->dd_desc; 2068 memset(ds, 0, dd->dd_desc_len); 2069 DPRINTF(sc, MWL_DEBUG_RESET, "%s: %s DMA map: %p (%lu) -> %p (%lu)\n", 2070 __func__, dd->dd_name, ds, (u_long) dd->dd_desc_len, 2071 (caddr_t) dd->dd_desc_paddr, /*XXX*/ (u_long) dd->dd_desc_len); 2072 2073 return 0; 2074 fail2: 2075 bus_dmamem_free(dd->dd_dmat, dd->dd_desc, dd->dd_dmamap); 2076 fail1: 2077 bus_dmamap_destroy(dd->dd_dmat, dd->dd_dmamap); 2078 fail0: 2079 bus_dma_tag_destroy(dd->dd_dmat); 2080 memset(dd, 0, sizeof(*dd)); 2081 return error; 2082 #undef DS2PHYS 2083 } 2084 2085 static void 2086 mwl_desc_cleanup(struct mwl_softc *sc, struct mwl_descdma *dd) 2087 { 2088 bus_dmamap_unload(dd->dd_dmat, dd->dd_dmamap); 2089 bus_dmamem_free(dd->dd_dmat, dd->dd_desc, dd->dd_dmamap); 2090 bus_dmamap_destroy(dd->dd_dmat, dd->dd_dmamap); 2091 bus_dma_tag_destroy(dd->dd_dmat); 2092 2093 memset(dd, 0, sizeof(*dd)); 2094 } 2095 2096 /* 2097 * Construct a tx q's free list. The order of entries on 2098 * the list must reflect the physical layout of tx descriptors 2099 * because the firmware pre-fetches descriptors. 2100 * 2101 * XXX might be better to use indices into the buffer array. 2102 */ 2103 static void 2104 mwl_txq_reset(struct mwl_softc *sc, struct mwl_txq *txq) 2105 { 2106 struct mwl_txbuf *bf; 2107 int i; 2108 2109 bf = txq->dma.dd_bufptr; 2110 STAILQ_INIT(&txq->free); 2111 for (i = 0; i < mwl_txbuf; i++, bf++) 2112 STAILQ_INSERT_TAIL(&txq->free, bf, bf_list); 2113 txq->nfree = i; 2114 } 2115 2116 #define DS2PHYS(_dd, _ds) \ 2117 ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc)) 2118 2119 static int 2120 mwl_txdma_setup(struct mwl_softc *sc, struct mwl_txq *txq) 2121 { 2122 struct ifnet *ifp = sc->sc_ifp; 2123 int error, bsize, i; 2124 struct mwl_txbuf *bf; 2125 struct mwl_txdesc *ds; 2126 2127 error = mwl_desc_setup(sc, "tx", &txq->dma, 2128 mwl_txbuf, sizeof(struct mwl_txbuf), 2129 MWL_TXDESC, sizeof(struct mwl_txdesc)); 2130 if (error != 0) 2131 return error; 2132 2133 /* allocate and setup tx buffers */ 2134 bsize = mwl_txbuf * sizeof(struct mwl_txbuf); 2135 bf = malloc(bsize, M_MWLDEV, M_NOWAIT | M_ZERO); 2136 if (bf == NULL) { 2137 if_printf(ifp, "malloc of %u tx buffers failed\n", 2138 mwl_txbuf); 2139 return ENOMEM; 2140 } 2141 txq->dma.dd_bufptr = bf; 2142 2143 ds = txq->dma.dd_desc; 2144 for (i = 0; i < mwl_txbuf; i++, bf++, ds += MWL_TXDESC) { 2145 bf->bf_desc = ds; 2146 bf->bf_daddr = DS2PHYS(&txq->dma, ds); 2147 error = bus_dmamap_create(sc->sc_dmat, BUS_DMA_NOWAIT, 2148 &bf->bf_dmamap); 2149 if (error != 0) { 2150 if_printf(ifp, "unable to create dmamap for tx " 2151 "buffer %u, error %u\n", i, error); 2152 return error; 2153 } 2154 } 2155 mwl_txq_reset(sc, txq); 2156 return 0; 2157 } 2158 2159 static void 2160 mwl_txdma_cleanup(struct mwl_softc *sc, struct mwl_txq *txq) 2161 { 2162 struct mwl_txbuf *bf; 2163 int i; 2164 2165 bf = txq->dma.dd_bufptr; 2166 for (i = 0; i < mwl_txbuf; i++, bf++) { 2167 KASSERT(bf->bf_m == NULL, ("mbuf on free list")); 2168 KASSERT(bf->bf_node == NULL, ("node on free list")); 2169 if (bf->bf_dmamap != NULL) 2170 bus_dmamap_destroy(sc->sc_dmat, bf->bf_dmamap); 2171 } 2172 STAILQ_INIT(&txq->free); 2173 txq->nfree = 0; 2174 if (txq->dma.dd_bufptr != NULL) { 2175 free(txq->dma.dd_bufptr, M_MWLDEV); 2176 txq->dma.dd_bufptr = NULL; 2177 } 2178 if (txq->dma.dd_desc_len != 0) 2179 mwl_desc_cleanup(sc, &txq->dma); 2180 } 2181 2182 static int 2183 mwl_rxdma_setup(struct mwl_softc *sc) 2184 { 2185 struct ifnet *ifp = sc->sc_ifp; 2186 int error, jumbosize, bsize, i; 2187 struct mwl_rxbuf *bf; 2188 struct mwl_jumbo *rbuf; 2189 struct mwl_rxdesc *ds; 2190 caddr_t data; 2191 2192 error = mwl_desc_setup(sc, "rx", &sc->sc_rxdma, 2193 mwl_rxdesc, sizeof(struct mwl_rxbuf), 2194 1, sizeof(struct mwl_rxdesc)); 2195 if (error != 0) 2196 return error; 2197 2198 /* 2199 * Receive is done to a private pool of jumbo buffers. 2200 * This allows us to attach to mbuf's and avoid re-mapping 2201 * memory on each rx we post. We allocate a large chunk 2202 * of memory and manage it in the driver. The mbuf free 2203 * callback method is used to reclaim frames after sending 2204 * them up the stack. By default we allocate 2x the number of 2205 * rx descriptors configured so we have some slop to hold 2206 * us while frames are processed. 2207 */ 2208 if (mwl_rxbuf < 2*mwl_rxdesc) { 2209 if_printf(ifp, 2210 "too few rx dma buffers (%d); increasing to %d\n", 2211 mwl_rxbuf, 2*mwl_rxdesc); 2212 mwl_rxbuf = 2*mwl_rxdesc; 2213 } 2214 jumbosize = roundup(MWL_AGGR_SIZE, PAGE_SIZE); 2215 sc->sc_rxmemsize = mwl_rxbuf*jumbosize; 2216 2217 error = bus_dma_tag_create(sc->sc_dmat, /* parent */ 2218 PAGE_SIZE, 0, /* alignment, bounds */ 2219 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 2220 BUS_SPACE_MAXADDR, /* highaddr */ 2221 NULL, NULL, /* filter, filterarg */ 2222 sc->sc_rxmemsize, /* maxsize */ 2223 1, /* nsegments */ 2224 sc->sc_rxmemsize, /* maxsegsize */ 2225 BUS_DMA_ALLOCNOW, /* flags */ 2226 NULL, /* lockfunc */ 2227 NULL, /* lockarg */ 2228 &sc->sc_rxdmat); 2229 error = bus_dmamap_create(sc->sc_rxdmat, BUS_DMA_NOWAIT, &sc->sc_rxmap); 2230 if (error != 0) { 2231 if_printf(ifp, "could not create rx DMA map\n"); 2232 return error; 2233 } 2234 2235 error = bus_dmamem_alloc(sc->sc_rxdmat, (void**) &sc->sc_rxmem, 2236 BUS_DMA_NOWAIT | BUS_DMA_COHERENT, 2237 &sc->sc_rxmap); 2238 if (error != 0) { 2239 if_printf(ifp, "could not alloc %ju bytes of rx DMA memory\n", 2240 (uintmax_t) sc->sc_rxmemsize); 2241 return error; 2242 } 2243 2244 error = bus_dmamap_load(sc->sc_rxdmat, sc->sc_rxmap, 2245 sc->sc_rxmem, sc->sc_rxmemsize, 2246 mwl_load_cb, &sc->sc_rxmem_paddr, 2247 BUS_DMA_NOWAIT); 2248 if (error != 0) { 2249 if_printf(ifp, "could not load rx DMA map\n"); 2250 return error; 2251 } 2252 2253 /* 2254 * Allocate rx buffers and set them up. 2255 */ 2256 bsize = mwl_rxdesc * sizeof(struct mwl_rxbuf); 2257 bf = malloc(bsize, M_MWLDEV, M_NOWAIT | M_ZERO); 2258 if (bf == NULL) { 2259 if_printf(ifp, "malloc of %u rx buffers failed\n", bsize); 2260 return error; 2261 } 2262 sc->sc_rxdma.dd_bufptr = bf; 2263 2264 STAILQ_INIT(&sc->sc_rxbuf); 2265 ds = sc->sc_rxdma.dd_desc; 2266 for (i = 0; i < mwl_rxdesc; i++, bf++, ds++) { 2267 bf->bf_desc = ds; 2268 bf->bf_daddr = DS2PHYS(&sc->sc_rxdma, ds); 2269 /* pre-assign dma buffer */ 2270 bf->bf_data = ((uint8_t *)sc->sc_rxmem) + (i*jumbosize); 2271 /* NB: tail is intentional to preserve descriptor order */ 2272 STAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list); 2273 } 2274 2275 /* 2276 * Place remainder of dma memory buffers on the free list. 2277 */ 2278 SLIST_INIT(&sc->sc_rxfree); 2279 for (; i < mwl_rxbuf; i++) { 2280 data = ((uint8_t *)sc->sc_rxmem) + (i*jumbosize); 2281 rbuf = MWL_JUMBO_DATA2BUF(data); 2282 SLIST_INSERT_HEAD(&sc->sc_rxfree, rbuf, next); 2283 sc->sc_nrxfree++; 2284 } 2285 return 0; 2286 } 2287 #undef DS2PHYS 2288 2289 static void 2290 mwl_rxdma_cleanup(struct mwl_softc *sc) 2291 { 2292 if (sc->sc_rxmap != NULL) 2293 bus_dmamap_unload(sc->sc_rxdmat, sc->sc_rxmap); 2294 if (sc->sc_rxmem != NULL) { 2295 bus_dmamem_free(sc->sc_rxdmat, sc->sc_rxmem, sc->sc_rxmap); 2296 sc->sc_rxmem = NULL; 2297 } 2298 if (sc->sc_rxmap != NULL) { 2299 bus_dmamap_destroy(sc->sc_rxdmat, sc->sc_rxmap); 2300 sc->sc_rxmap = NULL; 2301 } 2302 if (sc->sc_rxdma.dd_bufptr != NULL) { 2303 free(sc->sc_rxdma.dd_bufptr, M_MWLDEV); 2304 sc->sc_rxdma.dd_bufptr = NULL; 2305 } 2306 if (sc->sc_rxdma.dd_desc_len != 0) 2307 mwl_desc_cleanup(sc, &sc->sc_rxdma); 2308 } 2309 2310 static int 2311 mwl_dma_setup(struct mwl_softc *sc) 2312 { 2313 int error, i; 2314 2315 error = mwl_rxdma_setup(sc); 2316 if (error != 0) { 2317 mwl_rxdma_cleanup(sc); 2318 return error; 2319 } 2320 2321 for (i = 0; i < MWL_NUM_TX_QUEUES; i++) { 2322 error = mwl_txdma_setup(sc, &sc->sc_txq[i]); 2323 if (error != 0) { 2324 mwl_dma_cleanup(sc); 2325 return error; 2326 } 2327 } 2328 return 0; 2329 } 2330 2331 static void 2332 mwl_dma_cleanup(struct mwl_softc *sc) 2333 { 2334 int i; 2335 2336 for (i = 0; i < MWL_NUM_TX_QUEUES; i++) 2337 mwl_txdma_cleanup(sc, &sc->sc_txq[i]); 2338 mwl_rxdma_cleanup(sc); 2339 } 2340 2341 static struct ieee80211_node * 2342 mwl_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN]) 2343 { 2344 struct ieee80211com *ic = vap->iv_ic; 2345 struct mwl_softc *sc = ic->ic_ifp->if_softc; 2346 const size_t space = sizeof(struct mwl_node); 2347 struct mwl_node *mn; 2348 2349 mn = malloc(space, M_80211_NODE, M_NOWAIT|M_ZERO); 2350 if (mn == NULL) { 2351 /* XXX stat+msg */ 2352 return NULL; 2353 } 2354 DPRINTF(sc, MWL_DEBUG_NODE, "%s: mn %p\n", __func__, mn); 2355 return &mn->mn_node; 2356 } 2357 2358 static void 2359 mwl_node_cleanup(struct ieee80211_node *ni) 2360 { 2361 struct ieee80211com *ic = ni->ni_ic; 2362 struct mwl_softc *sc = ic->ic_ifp->if_softc; 2363 struct mwl_node *mn = MWL_NODE(ni); 2364 2365 DPRINTF(sc, MWL_DEBUG_NODE, "%s: ni %p ic %p staid %d\n", 2366 __func__, ni, ni->ni_ic, mn->mn_staid); 2367 2368 if (mn->mn_staid != 0) { 2369 struct ieee80211vap *vap = ni->ni_vap; 2370 2371 if (mn->mn_hvap != NULL) { 2372 if (vap->iv_opmode == IEEE80211_M_STA) 2373 mwl_hal_delstation(mn->mn_hvap, vap->iv_myaddr); 2374 else 2375 mwl_hal_delstation(mn->mn_hvap, ni->ni_macaddr); 2376 } 2377 /* 2378 * NB: legacy WDS peer sta db entry is installed using 2379 * the associate ap's hvap; use it again to delete it. 2380 * XXX can vap be NULL? 2381 */ 2382 else if (vap->iv_opmode == IEEE80211_M_WDS && 2383 MWL_VAP(vap)->mv_ap_hvap != NULL) 2384 mwl_hal_delstation(MWL_VAP(vap)->mv_ap_hvap, 2385 ni->ni_macaddr); 2386 delstaid(sc, mn->mn_staid); 2387 mn->mn_staid = 0; 2388 } 2389 sc->sc_node_cleanup(ni); 2390 } 2391 2392 /* 2393 * Reclaim rx dma buffers from packets sitting on the ampdu 2394 * reorder queue for a station. We replace buffers with a 2395 * system cluster (if available). 2396 */ 2397 static void 2398 mwl_ampdu_rxdma_reclaim(struct ieee80211_rx_ampdu *rap) 2399 { 2400 #if 0 2401 int i, n, off; 2402 struct mbuf *m; 2403 void *cl; 2404 2405 n = rap->rxa_qframes; 2406 for (i = 0; i < rap->rxa_wnd && n > 0; i++) { 2407 m = rap->rxa_m[i]; 2408 if (m == NULL) 2409 continue; 2410 n--; 2411 /* our dma buffers have a well-known free routine */ 2412 if ((m->m_flags & M_EXT) == 0 || 2413 m->m_ext.ext_free != mwl_ext_free) 2414 continue; 2415 /* 2416 * Try to allocate a cluster and move the data. 2417 */ 2418 off = m->m_data - m->m_ext.ext_buf; 2419 if (off + m->m_pkthdr.len > MCLBYTES) { 2420 /* XXX no AMSDU for now */ 2421 continue; 2422 } 2423 cl = pool_cache_get_paddr(&mclpool_cache, 0, 2424 &m->m_ext.ext_paddr); 2425 if (cl != NULL) { 2426 /* 2427 * Copy the existing data to the cluster, remove 2428 * the rx dma buffer, and attach the cluster in 2429 * its place. Note we preserve the offset to the 2430 * data so frames being bridged can still prepend 2431 * their headers without adding another mbuf. 2432 */ 2433 memcpy((caddr_t) cl + off, m->m_data, m->m_pkthdr.len); 2434 MEXTREMOVE(m); 2435 MEXTADD(m, cl, MCLBYTES, 0, NULL, &mclpool_cache); 2436 /* setup mbuf like _MCLGET does */ 2437 m->m_flags |= M_CLUSTER | M_EXT_RW; 2438 _MOWNERREF(m, M_EXT | M_CLUSTER); 2439 /* NB: m_data is clobbered by MEXTADDR, adjust */ 2440 m->m_data += off; 2441 } 2442 } 2443 #endif 2444 } 2445 2446 /* 2447 * Callback to reclaim resources. We first let the 2448 * net80211 layer do it's thing, then if we are still 2449 * blocked by a lack of rx dma buffers we walk the ampdu 2450 * reorder q's to reclaim buffers by copying to a system 2451 * cluster. 2452 */ 2453 static void 2454 mwl_node_drain(struct ieee80211_node *ni) 2455 { 2456 struct ieee80211com *ic = ni->ni_ic; 2457 struct mwl_softc *sc = ic->ic_ifp->if_softc; 2458 struct mwl_node *mn = MWL_NODE(ni); 2459 2460 DPRINTF(sc, MWL_DEBUG_NODE, "%s: ni %p vap %p staid %d\n", 2461 __func__, ni, ni->ni_vap, mn->mn_staid); 2462 2463 /* NB: call up first to age out ampdu q's */ 2464 sc->sc_node_drain(ni); 2465 2466 /* XXX better to not check low water mark? */ 2467 if (sc->sc_rxblocked && mn->mn_staid != 0 && 2468 (ni->ni_flags & IEEE80211_NODE_HT)) { 2469 uint8_t tid; 2470 /* 2471 * Walk the reorder q and reclaim rx dma buffers by copying 2472 * the packet contents into clusters. 2473 */ 2474 for (tid = 0; tid < WME_NUM_TID; tid++) { 2475 struct ieee80211_rx_ampdu *rap; 2476 2477 rap = &ni->ni_rx_ampdu[tid]; 2478 if ((rap->rxa_flags & IEEE80211_AGGR_XCHGPEND) == 0) 2479 continue; 2480 if (rap->rxa_qframes) 2481 mwl_ampdu_rxdma_reclaim(rap); 2482 } 2483 } 2484 } 2485 2486 static void 2487 mwl_node_getsignal(const struct ieee80211_node *ni, int8_t *rssi, int8_t *noise) 2488 { 2489 *rssi = ni->ni_ic->ic_node_getrssi(ni); 2490 #ifdef MWL_ANT_INFO_SUPPORT 2491 #if 0 2492 /* XXX need to smooth data */ 2493 *noise = -MWL_NODE_CONST(ni)->mn_ai.nf; 2494 #else 2495 *noise = -95; /* XXX */ 2496 #endif 2497 #else 2498 *noise = -95; /* XXX */ 2499 #endif 2500 } 2501 2502 /* 2503 * Convert Hardware per-antenna rssi info to common format: 2504 * Let a1, a2, a3 represent the amplitudes per chain 2505 * Let amax represent max[a1, a2, a3] 2506 * Rssi1_dBm = RSSI_dBm + 20*log10(a1/amax) 2507 * Rssi1_dBm = RSSI_dBm + 20*log10(a1) - 20*log10(amax) 2508 * We store a table that is 4*20*log10(idx) - the extra 4 is to store or 2509 * maintain some extra precision. 2510 * 2511 * Values are stored in .5 db format capped at 127. 2512 */ 2513 static void 2514 mwl_node_getmimoinfo(const struct ieee80211_node *ni, 2515 struct ieee80211_mimo_info *mi) 2516 { 2517 #define CVT(_dst, _src) do { \ 2518 (_dst) = rssi + ((logdbtbl[_src] - logdbtbl[rssi_max]) >> 2); \ 2519 (_dst) = (_dst) > 64 ? 127 : ((_dst) << 1); \ 2520 } while (0) 2521 static const int8_t logdbtbl[32] = { 2522 0, 0, 24, 38, 48, 56, 62, 68, 2523 72, 76, 80, 83, 86, 89, 92, 94, 2524 96, 98, 100, 102, 104, 106, 107, 109, 2525 110, 112, 113, 115, 116, 117, 118, 119 2526 }; 2527 const struct mwl_node *mn = MWL_NODE_CONST(ni); 2528 uint8_t rssi = mn->mn_ai.rsvd1/2; /* XXX */ 2529 uint32_t rssi_max; 2530 2531 rssi_max = mn->mn_ai.rssi_a; 2532 if (mn->mn_ai.rssi_b > rssi_max) 2533 rssi_max = mn->mn_ai.rssi_b; 2534 if (mn->mn_ai.rssi_c > rssi_max) 2535 rssi_max = mn->mn_ai.rssi_c; 2536 2537 CVT(mi->rssi[0], mn->mn_ai.rssi_a); 2538 CVT(mi->rssi[1], mn->mn_ai.rssi_b); 2539 CVT(mi->rssi[2], mn->mn_ai.rssi_c); 2540 2541 mi->noise[0] = mn->mn_ai.nf_a; 2542 mi->noise[1] = mn->mn_ai.nf_b; 2543 mi->noise[2] = mn->mn_ai.nf_c; 2544 #undef CVT 2545 } 2546 2547 static __inline void * 2548 mwl_getrxdma(struct mwl_softc *sc) 2549 { 2550 struct mwl_jumbo *buf; 2551 void *data; 2552 2553 /* 2554 * Allocate from jumbo pool. 2555 */ 2556 MWL_RXFREE_LOCK(sc); 2557 buf = SLIST_FIRST(&sc->sc_rxfree); 2558 if (buf == NULL) { 2559 DPRINTF(sc, MWL_DEBUG_ANY, 2560 "%s: out of rx dma buffers\n", __func__); 2561 sc->sc_stats.mst_rx_nodmabuf++; 2562 data = NULL; 2563 } else { 2564 SLIST_REMOVE_HEAD(&sc->sc_rxfree, next); 2565 sc->sc_nrxfree--; 2566 data = MWL_JUMBO_BUF2DATA(buf); 2567 } 2568 MWL_RXFREE_UNLOCK(sc); 2569 return data; 2570 } 2571 2572 static __inline void 2573 mwl_putrxdma(struct mwl_softc *sc, void *data) 2574 { 2575 struct mwl_jumbo *buf; 2576 2577 /* XXX bounds check data */ 2578 MWL_RXFREE_LOCK(sc); 2579 buf = MWL_JUMBO_DATA2BUF(data); 2580 SLIST_INSERT_HEAD(&sc->sc_rxfree, buf, next); 2581 sc->sc_nrxfree++; 2582 MWL_RXFREE_UNLOCK(sc); 2583 } 2584 2585 static int 2586 mwl_rxbuf_init(struct mwl_softc *sc, struct mwl_rxbuf *bf) 2587 { 2588 struct mwl_rxdesc *ds; 2589 2590 ds = bf->bf_desc; 2591 if (bf->bf_data == NULL) { 2592 bf->bf_data = mwl_getrxdma(sc); 2593 if (bf->bf_data == NULL) { 2594 /* mark descriptor to be skipped */ 2595 ds->RxControl = EAGLE_RXD_CTRL_OS_OWN; 2596 /* NB: don't need PREREAD */ 2597 MWL_RXDESC_SYNC(sc, ds, BUS_DMASYNC_PREWRITE); 2598 sc->sc_stats.mst_rxbuf_failed++; 2599 return ENOMEM; 2600 } 2601 } 2602 /* 2603 * NB: DMA buffer contents is known to be unmodified 2604 * so there's no need to flush the data cache. 2605 */ 2606 2607 /* 2608 * Setup descriptor. 2609 */ 2610 ds->QosCtrl = 0; 2611 ds->RSSI = 0; 2612 ds->Status = EAGLE_RXD_STATUS_IDLE; 2613 ds->Channel = 0; 2614 ds->PktLen = htole16(MWL_AGGR_SIZE); 2615 ds->SQ2 = 0; 2616 ds->pPhysBuffData = htole32(MWL_JUMBO_DMA_ADDR(sc, bf->bf_data)); 2617 /* NB: don't touch pPhysNext, set once */ 2618 ds->RxControl = EAGLE_RXD_CTRL_DRIVER_OWN; 2619 MWL_RXDESC_SYNC(sc, ds, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 2620 2621 return 0; 2622 } 2623 2624 static void 2625 mwl_ext_free(void *data, void *arg) 2626 { 2627 struct mwl_softc *sc = arg; 2628 2629 /* XXX bounds check data */ 2630 mwl_putrxdma(sc, data); 2631 /* 2632 * If we were previously blocked by a lack of rx dma buffers 2633 * check if we now have enough to restart rx interrupt handling. 2634 * NB: we know we are called at splvm which is above splnet. 2635 */ 2636 if (sc->sc_rxblocked && sc->sc_nrxfree > mwl_rxdmalow) { 2637 sc->sc_rxblocked = 0; 2638 mwl_hal_intrset(sc->sc_mh, sc->sc_imask); 2639 } 2640 } 2641 2642 struct mwl_frame_bar { 2643 u_int8_t i_fc[2]; 2644 u_int8_t i_dur[2]; 2645 u_int8_t i_ra[IEEE80211_ADDR_LEN]; 2646 u_int8_t i_ta[IEEE80211_ADDR_LEN]; 2647 /* ctl, seq, FCS */ 2648 } __packed; 2649 2650 /* 2651 * Like ieee80211_anyhdrsize, but handles BAR frames 2652 * specially so the logic below to piece the 802.11 2653 * header together works. 2654 */ 2655 static __inline int 2656 mwl_anyhdrsize(const void *data) 2657 { 2658 const struct ieee80211_frame *wh = data; 2659 2660 if ((wh->i_fc[0]&IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_CTL) { 2661 switch (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) { 2662 case IEEE80211_FC0_SUBTYPE_CTS: 2663 case IEEE80211_FC0_SUBTYPE_ACK: 2664 return sizeof(struct ieee80211_frame_ack); 2665 case IEEE80211_FC0_SUBTYPE_BAR: 2666 return sizeof(struct mwl_frame_bar); 2667 } 2668 return sizeof(struct ieee80211_frame_min); 2669 } else 2670 return ieee80211_hdrsize(data); 2671 } 2672 2673 static void 2674 mwl_handlemicerror(struct ieee80211com *ic, const uint8_t *data) 2675 { 2676 const struct ieee80211_frame *wh; 2677 struct ieee80211_node *ni; 2678 2679 wh = (const struct ieee80211_frame *)(data + sizeof(uint16_t)); 2680 ni = ieee80211_find_rxnode(ic, (const struct ieee80211_frame_min *) wh); 2681 if (ni != NULL) { 2682 ieee80211_notify_michael_failure(ni->ni_vap, wh, 0); 2683 ieee80211_free_node(ni); 2684 } 2685 } 2686 2687 /* 2688 * Convert hardware signal strength to rssi. The value 2689 * provided by the device has the noise floor added in; 2690 * we need to compensate for this but we don't have that 2691 * so we use a fixed value. 2692 * 2693 * The offset of 8 is good for both 2.4 and 5GHz. The LNA 2694 * offset is already set as part of the initial gain. This 2695 * will give at least +/- 3dB for 2.4GHz and +/- 5dB for 5GHz. 2696 */ 2697 static __inline int 2698 cvtrssi(uint8_t ssi) 2699 { 2700 int rssi = (int) ssi + 8; 2701 /* XXX hack guess until we have a real noise floor */ 2702 rssi = 2*(87 - rssi); /* NB: .5 dBm units */ 2703 return (rssi < 0 ? 0 : rssi > 127 ? 127 : rssi); 2704 } 2705 2706 static void 2707 mwl_rx_proc(void *arg, int npending) 2708 { 2709 #define IEEE80211_DIR_DSTODS(wh) \ 2710 ((((const struct ieee80211_frame *)wh)->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) 2711 struct mwl_softc *sc = arg; 2712 struct ifnet *ifp = sc->sc_ifp; 2713 struct ieee80211com *ic = ifp->if_l2com; 2714 struct mwl_rxbuf *bf; 2715 struct mwl_rxdesc *ds; 2716 struct mbuf *m; 2717 struct ieee80211_qosframe *wh; 2718 struct ieee80211_qosframe_addr4 *wh4; 2719 struct ieee80211_node *ni; 2720 struct mwl_node *mn; 2721 int off, len, hdrlen, pktlen, rssi, ntodo; 2722 uint8_t *data, status; 2723 void *newdata; 2724 int16_t nf; 2725 2726 DPRINTF(sc, MWL_DEBUG_RX_PROC, "%s: pending %u rdptr 0x%x wrptr 0x%x\n", 2727 __func__, npending, RD4(sc, sc->sc_hwspecs.rxDescRead), 2728 RD4(sc, sc->sc_hwspecs.rxDescWrite)); 2729 nf = -96; /* XXX */ 2730 bf = sc->sc_rxnext; 2731 for (ntodo = mwl_rxquota; ntodo > 0; ntodo--) { 2732 if (bf == NULL) 2733 bf = STAILQ_FIRST(&sc->sc_rxbuf); 2734 ds = bf->bf_desc; 2735 data = bf->bf_data; 2736 if (data == NULL) { 2737 /* 2738 * If data allocation failed previously there 2739 * will be no buffer; try again to re-populate it. 2740 * Note the firmware will not advance to the next 2741 * descriptor with a dma buffer so we must mimic 2742 * this or we'll get out of sync. 2743 */ 2744 DPRINTF(sc, MWL_DEBUG_ANY, 2745 "%s: rx buf w/o dma memory\n", __func__); 2746 (void) mwl_rxbuf_init(sc, bf); 2747 sc->sc_stats.mst_rx_dmabufmissing++; 2748 break; 2749 } 2750 MWL_RXDESC_SYNC(sc, ds, 2751 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 2752 if (ds->RxControl != EAGLE_RXD_CTRL_DMA_OWN) 2753 break; 2754 #ifdef MWL_DEBUG 2755 if (sc->sc_debug & MWL_DEBUG_RECV_DESC) 2756 mwl_printrxbuf(bf, 0); 2757 #endif 2758 status = ds->Status; 2759 if (status & EAGLE_RXD_STATUS_DECRYPT_ERR_MASK) { 2760 ifp->if_ierrors++; 2761 sc->sc_stats.mst_rx_crypto++; 2762 /* 2763 * NB: Check EAGLE_RXD_STATUS_GENERAL_DECRYPT_ERR 2764 * for backwards compatibility. 2765 */ 2766 if (status != EAGLE_RXD_STATUS_GENERAL_DECRYPT_ERR && 2767 (status & EAGLE_RXD_STATUS_TKIP_MIC_DECRYPT_ERR)) { 2768 /* 2769 * MIC error, notify upper layers. 2770 */ 2771 bus_dmamap_sync(sc->sc_rxdmat, sc->sc_rxmap, 2772 BUS_DMASYNC_POSTREAD); 2773 mwl_handlemicerror(ic, data); 2774 sc->sc_stats.mst_rx_tkipmic++; 2775 } 2776 /* XXX too painful to tap packets */ 2777 goto rx_next; 2778 } 2779 /* 2780 * Sync the data buffer. 2781 */ 2782 len = le16toh(ds->PktLen); 2783 bus_dmamap_sync(sc->sc_rxdmat, sc->sc_rxmap, BUS_DMASYNC_POSTREAD); 2784 /* 2785 * The 802.11 header is provided all or in part at the front; 2786 * use it to calculate the true size of the header that we'll 2787 * construct below. We use this to figure out where to copy 2788 * payload prior to constructing the header. 2789 */ 2790 hdrlen = mwl_anyhdrsize(data + sizeof(uint16_t)); 2791 off = sizeof(uint16_t) + sizeof(struct ieee80211_frame_addr4); 2792 2793 /* calculate rssi early so we can re-use for each aggregate */ 2794 rssi = cvtrssi(ds->RSSI); 2795 2796 pktlen = hdrlen + (len - off); 2797 /* 2798 * NB: we know our frame is at least as large as 2799 * IEEE80211_MIN_LEN because there is a 4-address 2800 * frame at the front. Hence there's no need to 2801 * vet the packet length. If the frame in fact 2802 * is too small it should be discarded at the 2803 * net80211 layer. 2804 */ 2805 2806 /* 2807 * Attach dma buffer to an mbuf. We tried 2808 * doing this based on the packet size (i.e. 2809 * copying small packets) but it turns out to 2810 * be a net loss. The tradeoff might be system 2811 * dependent (cache architecture is important). 2812 */ 2813 MGETHDR(m, M_NOWAIT, MT_DATA); 2814 if (m == NULL) { 2815 DPRINTF(sc, MWL_DEBUG_ANY, 2816 "%s: no rx mbuf\n", __func__); 2817 sc->sc_stats.mst_rx_nombuf++; 2818 goto rx_next; 2819 } 2820 /* 2821 * Acquire the replacement dma buffer before 2822 * processing the frame. If we're out of dma 2823 * buffers we disable rx interrupts and wait 2824 * for the free pool to reach mlw_rxdmalow buffers 2825 * before starting to do work again. If the firmware 2826 * runs out of descriptors then it will toss frames 2827 * which is better than our doing it as that can 2828 * starve our processing. It is also important that 2829 * we always process rx'd frames in case they are 2830 * A-MPDU as otherwise the host's view of the BA 2831 * window may get out of sync with the firmware. 2832 */ 2833 newdata = mwl_getrxdma(sc); 2834 if (newdata == NULL) { 2835 /* NB: stat+msg in mwl_getrxdma */ 2836 m_free(m); 2837 /* disable RX interrupt and mark state */ 2838 mwl_hal_intrset(sc->sc_mh, 2839 sc->sc_imask &~ MACREG_A2HRIC_BIT_RX_RDY); 2840 sc->sc_rxblocked = 1; 2841 ieee80211_drain(ic); 2842 /* XXX check rxblocked and immediately start again? */ 2843 goto rx_stop; 2844 } 2845 bf->bf_data = newdata; 2846 /* 2847 * Attach the dma buffer to the mbuf; 2848 * mwl_rxbuf_init will re-setup the rx 2849 * descriptor using the replacement dma 2850 * buffer we just installed above. 2851 */ 2852 MEXTADD(m, data, MWL_AGGR_SIZE, mwl_ext_free, 2853 data, sc, 0, EXT_NET_DRV); 2854 m->m_data += off - hdrlen; 2855 m->m_pkthdr.len = m->m_len = pktlen; 2856 m->m_pkthdr.rcvif = ifp; 2857 /* NB: dma buffer assumed read-only */ 2858 2859 /* 2860 * Piece 802.11 header together. 2861 */ 2862 wh = mtod(m, struct ieee80211_qosframe *); 2863 /* NB: don't need to do this sometimes but ... */ 2864 /* XXX special case so we can memcpy after m_devget? */ 2865 ovbcopy(data + sizeof(uint16_t), wh, hdrlen); 2866 if (IEEE80211_QOS_HAS_SEQ(wh)) { 2867 if (IEEE80211_DIR_DSTODS(wh)) { 2868 wh4 = mtod(m, 2869 struct ieee80211_qosframe_addr4*); 2870 *(uint16_t *)wh4->i_qos = ds->QosCtrl; 2871 } else { 2872 *(uint16_t *)wh->i_qos = ds->QosCtrl; 2873 } 2874 } 2875 /* 2876 * The f/w strips WEP header but doesn't clear 2877 * the WEP bit; mark the packet with M_WEP so 2878 * net80211 will treat the data as decrypted. 2879 * While here also clear the PWR_MGT bit since 2880 * power save is handled by the firmware and 2881 * passing this up will potentially cause the 2882 * upper layer to put a station in power save 2883 * (except when configured with MWL_HOST_PS_SUPPORT). 2884 */ 2885 if (wh->i_fc[1] & IEEE80211_FC1_WEP) 2886 m->m_flags |= M_WEP; 2887 #ifdef MWL_HOST_PS_SUPPORT 2888 wh->i_fc[1] &= ~IEEE80211_FC1_WEP; 2889 #else 2890 wh->i_fc[1] &= ~(IEEE80211_FC1_WEP | IEEE80211_FC1_PWR_MGT); 2891 #endif 2892 2893 if (ieee80211_radiotap_active(ic)) { 2894 struct mwl_rx_radiotap_header *tap = &sc->sc_rx_th; 2895 2896 tap->wr_flags = 0; 2897 tap->wr_rate = ds->Rate; 2898 tap->wr_antsignal = rssi + nf; 2899 tap->wr_antnoise = nf; 2900 } 2901 if (IFF_DUMPPKTS_RECV(sc, wh)) { 2902 ieee80211_dump_pkt(ic, mtod(m, caddr_t), 2903 len, ds->Rate, rssi); 2904 } 2905 ifp->if_ipackets++; 2906 2907 /* dispatch */ 2908 ni = ieee80211_find_rxnode(ic, 2909 (const struct ieee80211_frame_min *) wh); 2910 if (ni != NULL) { 2911 mn = MWL_NODE(ni); 2912 #ifdef MWL_ANT_INFO_SUPPORT 2913 mn->mn_ai.rssi_a = ds->ai.rssi_a; 2914 mn->mn_ai.rssi_b = ds->ai.rssi_b; 2915 mn->mn_ai.rssi_c = ds->ai.rssi_c; 2916 mn->mn_ai.rsvd1 = rssi; 2917 #endif 2918 /* tag AMPDU aggregates for reorder processing */ 2919 if (ni->ni_flags & IEEE80211_NODE_HT) 2920 m->m_flags |= M_AMPDU; 2921 (void) ieee80211_input(ni, m, rssi, nf); 2922 ieee80211_free_node(ni); 2923 } else 2924 (void) ieee80211_input_all(ic, m, rssi, nf); 2925 rx_next: 2926 /* NB: ignore ENOMEM so we process more descriptors */ 2927 (void) mwl_rxbuf_init(sc, bf); 2928 bf = STAILQ_NEXT(bf, bf_list); 2929 } 2930 rx_stop: 2931 sc->sc_rxnext = bf; 2932 2933 if ((ifp->if_drv_flags & IFF_DRV_OACTIVE) == 0 && 2934 !IFQ_IS_EMPTY(&ifp->if_snd)) { 2935 /* NB: kick fw; the tx thread may have been preempted */ 2936 mwl_hal_txstart(sc->sc_mh, 0); 2937 mwl_start(ifp); 2938 } 2939 #undef IEEE80211_DIR_DSTODS 2940 } 2941 2942 static void 2943 mwl_txq_init(struct mwl_softc *sc, struct mwl_txq *txq, int qnum) 2944 { 2945 struct mwl_txbuf *bf, *bn; 2946 struct mwl_txdesc *ds; 2947 2948 MWL_TXQ_LOCK_INIT(sc, txq); 2949 txq->qnum = qnum; 2950 txq->txpri = 0; /* XXX */ 2951 #if 0 2952 /* NB: q setup by mwl_txdma_setup XXX */ 2953 STAILQ_INIT(&txq->free); 2954 #endif 2955 STAILQ_FOREACH(bf, &txq->free, bf_list) { 2956 bf->bf_txq = txq; 2957 2958 ds = bf->bf_desc; 2959 bn = STAILQ_NEXT(bf, bf_list); 2960 if (bn == NULL) 2961 bn = STAILQ_FIRST(&txq->free); 2962 ds->pPhysNext = htole32(bn->bf_daddr); 2963 } 2964 STAILQ_INIT(&txq->active); 2965 } 2966 2967 /* 2968 * Setup a hardware data transmit queue for the specified 2969 * access control. We record the mapping from ac's 2970 * to h/w queues for use by mwl_tx_start. 2971 */ 2972 static int 2973 mwl_tx_setup(struct mwl_softc *sc, int ac, int mvtype) 2974 { 2975 #define N(a) (sizeof(a)/sizeof(a[0])) 2976 struct mwl_txq *txq; 2977 2978 if (ac >= N(sc->sc_ac2q)) { 2979 device_printf(sc->sc_dev, "AC %u out of range, max %zu!\n", 2980 ac, N(sc->sc_ac2q)); 2981 return 0; 2982 } 2983 if (mvtype >= MWL_NUM_TX_QUEUES) { 2984 device_printf(sc->sc_dev, "mvtype %u out of range, max %u!\n", 2985 mvtype, MWL_NUM_TX_QUEUES); 2986 return 0; 2987 } 2988 txq = &sc->sc_txq[mvtype]; 2989 mwl_txq_init(sc, txq, mvtype); 2990 sc->sc_ac2q[ac] = txq; 2991 return 1; 2992 #undef N 2993 } 2994 2995 /* 2996 * Update WME parameters for a transmit queue. 2997 */ 2998 static int 2999 mwl_txq_update(struct mwl_softc *sc, int ac) 3000 { 3001 #define MWL_EXPONENT_TO_VALUE(v) ((1<<v)-1) 3002 struct ifnet *ifp = sc->sc_ifp; 3003 struct ieee80211com *ic = ifp->if_l2com; 3004 struct mwl_txq *txq = sc->sc_ac2q[ac]; 3005 struct wmeParams *wmep = &ic->ic_wme.wme_chanParams.cap_wmeParams[ac]; 3006 struct mwl_hal *mh = sc->sc_mh; 3007 int aifs, cwmin, cwmax, txoplim; 3008 3009 aifs = wmep->wmep_aifsn; 3010 /* XXX in sta mode need to pass log values for cwmin/max */ 3011 cwmin = MWL_EXPONENT_TO_VALUE(wmep->wmep_logcwmin); 3012 cwmax = MWL_EXPONENT_TO_VALUE(wmep->wmep_logcwmax); 3013 txoplim = wmep->wmep_txopLimit; /* NB: units of 32us */ 3014 3015 if (mwl_hal_setedcaparams(mh, txq->qnum, cwmin, cwmax, aifs, txoplim)) { 3016 device_printf(sc->sc_dev, "unable to update hardware queue " 3017 "parameters for %s traffic!\n", 3018 ieee80211_wme_acnames[ac]); 3019 return 0; 3020 } 3021 return 1; 3022 #undef MWL_EXPONENT_TO_VALUE 3023 } 3024 3025 /* 3026 * Callback from the 802.11 layer to update WME parameters. 3027 */ 3028 static int 3029 mwl_wme_update(struct ieee80211com *ic) 3030 { 3031 struct mwl_softc *sc = ic->ic_ifp->if_softc; 3032 3033 return !mwl_txq_update(sc, WME_AC_BE) || 3034 !mwl_txq_update(sc, WME_AC_BK) || 3035 !mwl_txq_update(sc, WME_AC_VI) || 3036 !mwl_txq_update(sc, WME_AC_VO) ? EIO : 0; 3037 } 3038 3039 /* 3040 * Reclaim resources for a setup queue. 3041 */ 3042 static void 3043 mwl_tx_cleanupq(struct mwl_softc *sc, struct mwl_txq *txq) 3044 { 3045 /* XXX hal work? */ 3046 MWL_TXQ_LOCK_DESTROY(txq); 3047 } 3048 3049 /* 3050 * Reclaim all tx queue resources. 3051 */ 3052 static void 3053 mwl_tx_cleanup(struct mwl_softc *sc) 3054 { 3055 int i; 3056 3057 for (i = 0; i < MWL_NUM_TX_QUEUES; i++) 3058 mwl_tx_cleanupq(sc, &sc->sc_txq[i]); 3059 } 3060 3061 static int 3062 mwl_tx_dmasetup(struct mwl_softc *sc, struct mwl_txbuf *bf, struct mbuf *m0) 3063 { 3064 struct mbuf *m; 3065 int error; 3066 3067 /* 3068 * Load the DMA map so any coalescing is done. This 3069 * also calculates the number of descriptors we need. 3070 */ 3071 error = bus_dmamap_load_mbuf_sg(sc->sc_dmat, bf->bf_dmamap, m0, 3072 bf->bf_segs, &bf->bf_nseg, 3073 BUS_DMA_NOWAIT); 3074 if (error == EFBIG) { 3075 /* XXX packet requires too many descriptors */ 3076 bf->bf_nseg = MWL_TXDESC+1; 3077 } else if (error != 0) { 3078 sc->sc_stats.mst_tx_busdma++; 3079 m_freem(m0); 3080 return error; 3081 } 3082 /* 3083 * Discard null packets and check for packets that 3084 * require too many TX descriptors. We try to convert 3085 * the latter to a cluster. 3086 */ 3087 if (error == EFBIG) { /* too many desc's, linearize */ 3088 sc->sc_stats.mst_tx_linear++; 3089 #if MWL_TXDESC > 1 3090 m = m_collapse(m0, M_NOWAIT, MWL_TXDESC); 3091 #else 3092 m = m_defrag(m0, M_NOWAIT); 3093 #endif 3094 if (m == NULL) { 3095 m_freem(m0); 3096 sc->sc_stats.mst_tx_nombuf++; 3097 return ENOMEM; 3098 } 3099 m0 = m; 3100 error = bus_dmamap_load_mbuf_sg(sc->sc_dmat, bf->bf_dmamap, m0, 3101 bf->bf_segs, &bf->bf_nseg, 3102 BUS_DMA_NOWAIT); 3103 if (error != 0) { 3104 sc->sc_stats.mst_tx_busdma++; 3105 m_freem(m0); 3106 return error; 3107 } 3108 KASSERT(bf->bf_nseg <= MWL_TXDESC, 3109 ("too many segments after defrag; nseg %u", bf->bf_nseg)); 3110 } else if (bf->bf_nseg == 0) { /* null packet, discard */ 3111 sc->sc_stats.mst_tx_nodata++; 3112 m_freem(m0); 3113 return EIO; 3114 } 3115 DPRINTF(sc, MWL_DEBUG_XMIT, "%s: m %p len %u\n", 3116 __func__, m0, m0->m_pkthdr.len); 3117 bus_dmamap_sync(sc->sc_dmat, bf->bf_dmamap, BUS_DMASYNC_PREWRITE); 3118 bf->bf_m = m0; 3119 3120 return 0; 3121 } 3122 3123 static __inline int 3124 mwl_cvtlegacyrate(int rate) 3125 { 3126 switch (rate) { 3127 case 2: return 0; 3128 case 4: return 1; 3129 case 11: return 2; 3130 case 22: return 3; 3131 case 44: return 4; 3132 case 12: return 5; 3133 case 18: return 6; 3134 case 24: return 7; 3135 case 36: return 8; 3136 case 48: return 9; 3137 case 72: return 10; 3138 case 96: return 11; 3139 case 108:return 12; 3140 } 3141 return 0; 3142 } 3143 3144 /* 3145 * Calculate fixed tx rate information per client state; 3146 * this value is suitable for writing to the Format field 3147 * of a tx descriptor. 3148 */ 3149 static uint16_t 3150 mwl_calcformat(uint8_t rate, const struct ieee80211_node *ni) 3151 { 3152 uint16_t fmt; 3153 3154 fmt = SM(3, EAGLE_TXD_ANTENNA) 3155 | (IEEE80211_IS_CHAN_HT40D(ni->ni_chan) ? 3156 EAGLE_TXD_EXTCHAN_LO : EAGLE_TXD_EXTCHAN_HI); 3157 if (rate & IEEE80211_RATE_MCS) { /* HT MCS */ 3158 fmt |= EAGLE_TXD_FORMAT_HT 3159 /* NB: 0x80 implicitly stripped from ucastrate */ 3160 | SM(rate, EAGLE_TXD_RATE); 3161 /* XXX short/long GI may be wrong; re-check */ 3162 if (IEEE80211_IS_CHAN_HT40(ni->ni_chan)) { 3163 fmt |= EAGLE_TXD_CHW_40 3164 | (ni->ni_htcap & IEEE80211_HTCAP_SHORTGI40 ? 3165 EAGLE_TXD_GI_SHORT : EAGLE_TXD_GI_LONG); 3166 } else { 3167 fmt |= EAGLE_TXD_CHW_20 3168 | (ni->ni_htcap & IEEE80211_HTCAP_SHORTGI20 ? 3169 EAGLE_TXD_GI_SHORT : EAGLE_TXD_GI_LONG); 3170 } 3171 } else { /* legacy rate */ 3172 fmt |= EAGLE_TXD_FORMAT_LEGACY 3173 | SM(mwl_cvtlegacyrate(rate), EAGLE_TXD_RATE) 3174 | EAGLE_TXD_CHW_20 3175 /* XXX iv_flags & IEEE80211_F_SHPREAMBLE? */ 3176 | (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE ? 3177 EAGLE_TXD_PREAMBLE_SHORT : EAGLE_TXD_PREAMBLE_LONG); 3178 } 3179 return fmt; 3180 } 3181 3182 static int 3183 mwl_tx_start(struct mwl_softc *sc, struct ieee80211_node *ni, struct mwl_txbuf *bf, 3184 struct mbuf *m0) 3185 { 3186 #define IEEE80211_DIR_DSTODS(wh) \ 3187 ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) 3188 struct ifnet *ifp = sc->sc_ifp; 3189 struct ieee80211com *ic = ifp->if_l2com; 3190 struct ieee80211vap *vap = ni->ni_vap; 3191 int error, iswep, ismcast; 3192 int hdrlen, copyhdrlen, pktlen; 3193 struct mwl_txdesc *ds; 3194 struct mwl_txq *txq; 3195 struct ieee80211_frame *wh; 3196 struct mwltxrec *tr; 3197 struct mwl_node *mn; 3198 uint16_t qos; 3199 #if MWL_TXDESC > 1 3200 int i; 3201 #endif 3202 3203 wh = mtod(m0, struct ieee80211_frame *); 3204 iswep = wh->i_fc[1] & IEEE80211_FC1_WEP; 3205 ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1); 3206 hdrlen = ieee80211_anyhdrsize(wh); 3207 copyhdrlen = hdrlen; 3208 pktlen = m0->m_pkthdr.len; 3209 if (IEEE80211_QOS_HAS_SEQ(wh)) { 3210 if (IEEE80211_DIR_DSTODS(wh)) { 3211 qos = *(uint16_t *) 3212 (((struct ieee80211_qosframe_addr4 *) wh)->i_qos); 3213 copyhdrlen -= sizeof(qos); 3214 } else 3215 qos = *(uint16_t *) 3216 (((struct ieee80211_qosframe *) wh)->i_qos); 3217 } else 3218 qos = 0; 3219 3220 if (iswep) { 3221 const struct ieee80211_cipher *cip; 3222 struct ieee80211_key *k; 3223 3224 /* 3225 * Construct the 802.11 header+trailer for an encrypted 3226 * frame. The only reason this can fail is because of an 3227 * unknown or unsupported cipher/key type. 3228 * 3229 * NB: we do this even though the firmware will ignore 3230 * what we've done for WEP and TKIP as we need the 3231 * ExtIV filled in for CCMP and this also adjusts 3232 * the headers which simplifies our work below. 3233 */ 3234 k = ieee80211_crypto_encap(ni, m0); 3235 if (k == NULL) { 3236 /* 3237 * This can happen when the key is yanked after the 3238 * frame was queued. Just discard the frame; the 3239 * 802.11 layer counts failures and provides 3240 * debugging/diagnostics. 3241 */ 3242 m_freem(m0); 3243 return EIO; 3244 } 3245 /* 3246 * Adjust the packet length for the crypto additions 3247 * done during encap and any other bits that the f/w 3248 * will add later on. 3249 */ 3250 cip = k->wk_cipher; 3251 pktlen += cip->ic_header + cip->ic_miclen + cip->ic_trailer; 3252 3253 /* packet header may have moved, reset our local pointer */ 3254 wh = mtod(m0, struct ieee80211_frame *); 3255 } 3256 3257 if (ieee80211_radiotap_active_vap(vap)) { 3258 sc->sc_tx_th.wt_flags = 0; /* XXX */ 3259 if (iswep) 3260 sc->sc_tx_th.wt_flags |= IEEE80211_RADIOTAP_F_WEP; 3261 #if 0 3262 sc->sc_tx_th.wt_rate = ds->DataRate; 3263 #endif 3264 sc->sc_tx_th.wt_txpower = ni->ni_txpower; 3265 sc->sc_tx_th.wt_antenna = sc->sc_txantenna; 3266 3267 ieee80211_radiotap_tx(vap, m0); 3268 } 3269 /* 3270 * Copy up/down the 802.11 header; the firmware requires 3271 * we present a 2-byte payload length followed by a 3272 * 4-address header (w/o QoS), followed (optionally) by 3273 * any WEP/ExtIV header (but only filled in for CCMP). 3274 * We are assured the mbuf has sufficient headroom to 3275 * prepend in-place by the setup of ic_headroom in 3276 * mwl_attach. 3277 */ 3278 if (hdrlen < sizeof(struct mwltxrec)) { 3279 const int space = sizeof(struct mwltxrec) - hdrlen; 3280 if (M_LEADINGSPACE(m0) < space) { 3281 /* NB: should never happen */ 3282 device_printf(sc->sc_dev, 3283 "not enough headroom, need %d found %zd, " 3284 "m_flags 0x%x m_len %d\n", 3285 space, M_LEADINGSPACE(m0), m0->m_flags, m0->m_len); 3286 ieee80211_dump_pkt(ic, 3287 mtod(m0, const uint8_t *), m0->m_len, 0, -1); 3288 m_freem(m0); 3289 sc->sc_stats.mst_tx_noheadroom++; 3290 return EIO; 3291 } 3292 M_PREPEND(m0, space, M_NOWAIT); 3293 } 3294 tr = mtod(m0, struct mwltxrec *); 3295 if (wh != (struct ieee80211_frame *) &tr->wh) 3296 ovbcopy(wh, &tr->wh, hdrlen); 3297 /* 3298 * Note: the "firmware length" is actually the length 3299 * of the fully formed "802.11 payload". That is, it's 3300 * everything except for the 802.11 header. In particular 3301 * this includes all crypto material including the MIC! 3302 */ 3303 tr->fwlen = htole16(pktlen - hdrlen); 3304 3305 /* 3306 * Load the DMA map so any coalescing is done. This 3307 * also calculates the number of descriptors we need. 3308 */ 3309 error = mwl_tx_dmasetup(sc, bf, m0); 3310 if (error != 0) { 3311 /* NB: stat collected in mwl_tx_dmasetup */ 3312 DPRINTF(sc, MWL_DEBUG_XMIT, 3313 "%s: unable to setup dma\n", __func__); 3314 return error; 3315 } 3316 bf->bf_node = ni; /* NB: held reference */ 3317 m0 = bf->bf_m; /* NB: may have changed */ 3318 tr = mtod(m0, struct mwltxrec *); 3319 wh = (struct ieee80211_frame *)&tr->wh; 3320 3321 /* 3322 * Formulate tx descriptor. 3323 */ 3324 ds = bf->bf_desc; 3325 txq = bf->bf_txq; 3326 3327 ds->QosCtrl = qos; /* NB: already little-endian */ 3328 #if MWL_TXDESC == 1 3329 /* 3330 * NB: multiframes should be zero because the descriptors 3331 * are initialized to zero. This should handle the case 3332 * where the driver is built with MWL_TXDESC=1 but we are 3333 * using firmware with multi-segment support. 3334 */ 3335 ds->PktPtr = htole32(bf->bf_segs[0].ds_addr); 3336 ds->PktLen = htole16(bf->bf_segs[0].ds_len); 3337 #else 3338 ds->multiframes = htole32(bf->bf_nseg); 3339 ds->PktLen = htole16(m0->m_pkthdr.len); 3340 for (i = 0; i < bf->bf_nseg; i++) { 3341 ds->PktPtrArray[i] = htole32(bf->bf_segs[i].ds_addr); 3342 ds->PktLenArray[i] = htole16(bf->bf_segs[i].ds_len); 3343 } 3344 #endif 3345 /* NB: pPhysNext, DataRate, and SapPktInfo setup once, don't touch */ 3346 ds->Format = 0; 3347 ds->pad = 0; 3348 ds->ack_wcb_addr = 0; 3349 3350 mn = MWL_NODE(ni); 3351 /* 3352 * Select transmit rate. 3353 */ 3354 switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) { 3355 case IEEE80211_FC0_TYPE_MGT: 3356 sc->sc_stats.mst_tx_mgmt++; 3357 /* fall thru... */ 3358 case IEEE80211_FC0_TYPE_CTL: 3359 /* NB: assign to BE q to avoid bursting */ 3360 ds->TxPriority = MWL_WME_AC_BE; 3361 break; 3362 case IEEE80211_FC0_TYPE_DATA: 3363 if (!ismcast) { 3364 const struct ieee80211_txparam *tp = ni->ni_txparms; 3365 /* 3366 * EAPOL frames get forced to a fixed rate and w/o 3367 * aggregation; otherwise check for any fixed rate 3368 * for the client (may depend on association state). 3369 */ 3370 if (m0->m_flags & M_EAPOL) { 3371 const struct mwl_vap *mvp = MWL_VAP_CONST(vap); 3372 ds->Format = mvp->mv_eapolformat; 3373 ds->pad = htole16( 3374 EAGLE_TXD_FIXED_RATE | EAGLE_TXD_DONT_AGGR); 3375 } else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) { 3376 /* XXX pre-calculate per node */ 3377 ds->Format = htole16( 3378 mwl_calcformat(tp->ucastrate, ni)); 3379 ds->pad = htole16(EAGLE_TXD_FIXED_RATE); 3380 } 3381 /* NB: EAPOL frames will never have qos set */ 3382 if (qos == 0) 3383 ds->TxPriority = txq->qnum; 3384 #if MWL_MAXBA > 3 3385 else if (mwl_bastream_match(&mn->mn_ba[3], qos)) 3386 ds->TxPriority = mn->mn_ba[3].txq; 3387 #endif 3388 #if MWL_MAXBA > 2 3389 else if (mwl_bastream_match(&mn->mn_ba[2], qos)) 3390 ds->TxPriority = mn->mn_ba[2].txq; 3391 #endif 3392 #if MWL_MAXBA > 1 3393 else if (mwl_bastream_match(&mn->mn_ba[1], qos)) 3394 ds->TxPriority = mn->mn_ba[1].txq; 3395 #endif 3396 #if MWL_MAXBA > 0 3397 else if (mwl_bastream_match(&mn->mn_ba[0], qos)) 3398 ds->TxPriority = mn->mn_ba[0].txq; 3399 #endif 3400 else 3401 ds->TxPriority = txq->qnum; 3402 } else 3403 ds->TxPriority = txq->qnum; 3404 break; 3405 default: 3406 if_printf(ifp, "bogus frame type 0x%x (%s)\n", 3407 wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK, __func__); 3408 sc->sc_stats.mst_tx_badframetype++; 3409 m_freem(m0); 3410 return EIO; 3411 } 3412 3413 if (IFF_DUMPPKTS_XMIT(sc)) 3414 ieee80211_dump_pkt(ic, 3415 mtod(m0, const uint8_t *)+sizeof(uint16_t), 3416 m0->m_len - sizeof(uint16_t), ds->DataRate, -1); 3417 3418 MWL_TXQ_LOCK(txq); 3419 ds->Status = htole32(EAGLE_TXD_STATUS_FW_OWNED); 3420 STAILQ_INSERT_TAIL(&txq->active, bf, bf_list); 3421 MWL_TXDESC_SYNC(txq, ds, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 3422 3423 ifp->if_opackets++; 3424 sc->sc_tx_timer = 5; 3425 MWL_TXQ_UNLOCK(txq); 3426 3427 return 0; 3428 #undef IEEE80211_DIR_DSTODS 3429 } 3430 3431 static __inline int 3432 mwl_cvtlegacyrix(int rix) 3433 { 3434 #define N(x) (sizeof(x)/sizeof(x[0])) 3435 static const int ieeerates[] = 3436 { 2, 4, 11, 22, 44, 12, 18, 24, 36, 48, 72, 96, 108 }; 3437 return (rix < N(ieeerates) ? ieeerates[rix] : 0); 3438 #undef N 3439 } 3440 3441 /* 3442 * Process completed xmit descriptors from the specified queue. 3443 */ 3444 static int 3445 mwl_tx_processq(struct mwl_softc *sc, struct mwl_txq *txq) 3446 { 3447 #define EAGLE_TXD_STATUS_MCAST \ 3448 (EAGLE_TXD_STATUS_MULTICAST_TX | EAGLE_TXD_STATUS_BROADCAST_TX) 3449 struct ifnet *ifp = sc->sc_ifp; 3450 struct ieee80211com *ic = ifp->if_l2com; 3451 struct mwl_txbuf *bf; 3452 struct mwl_txdesc *ds; 3453 struct ieee80211_node *ni; 3454 struct mwl_node *an; 3455 int nreaped; 3456 uint32_t status; 3457 3458 DPRINTF(sc, MWL_DEBUG_TX_PROC, "%s: tx queue %u\n", __func__, txq->qnum); 3459 for (nreaped = 0;; nreaped++) { 3460 MWL_TXQ_LOCK(txq); 3461 bf = STAILQ_FIRST(&txq->active); 3462 if (bf == NULL) { 3463 MWL_TXQ_UNLOCK(txq); 3464 break; 3465 } 3466 ds = bf->bf_desc; 3467 MWL_TXDESC_SYNC(txq, ds, 3468 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 3469 if (ds->Status & htole32(EAGLE_TXD_STATUS_FW_OWNED)) { 3470 MWL_TXQ_UNLOCK(txq); 3471 break; 3472 } 3473 STAILQ_REMOVE_HEAD(&txq->active, bf_list); 3474 MWL_TXQ_UNLOCK(txq); 3475 3476 #ifdef MWL_DEBUG 3477 if (sc->sc_debug & MWL_DEBUG_XMIT_DESC) 3478 mwl_printtxbuf(bf, txq->qnum, nreaped); 3479 #endif 3480 ni = bf->bf_node; 3481 if (ni != NULL) { 3482 an = MWL_NODE(ni); 3483 status = le32toh(ds->Status); 3484 if (status & EAGLE_TXD_STATUS_OK) { 3485 uint16_t Format = le16toh(ds->Format); 3486 uint8_t txant = MS(Format, EAGLE_TXD_ANTENNA); 3487 3488 sc->sc_stats.mst_ant_tx[txant]++; 3489 if (status & EAGLE_TXD_STATUS_OK_RETRY) 3490 sc->sc_stats.mst_tx_retries++; 3491 if (status & EAGLE_TXD_STATUS_OK_MORE_RETRY) 3492 sc->sc_stats.mst_tx_mretries++; 3493 if (txq->qnum >= MWL_WME_AC_VO) 3494 ic->ic_wme.wme_hipri_traffic++; 3495 ni->ni_txrate = MS(Format, EAGLE_TXD_RATE); 3496 if ((Format & EAGLE_TXD_FORMAT_HT) == 0) { 3497 ni->ni_txrate = mwl_cvtlegacyrix( 3498 ni->ni_txrate); 3499 } else 3500 ni->ni_txrate |= IEEE80211_RATE_MCS; 3501 sc->sc_stats.mst_tx_rate = ni->ni_txrate; 3502 } else { 3503 if (status & EAGLE_TXD_STATUS_FAILED_LINK_ERROR) 3504 sc->sc_stats.mst_tx_linkerror++; 3505 if (status & EAGLE_TXD_STATUS_FAILED_XRETRY) 3506 sc->sc_stats.mst_tx_xretries++; 3507 if (status & EAGLE_TXD_STATUS_FAILED_AGING) 3508 sc->sc_stats.mst_tx_aging++; 3509 if (bf->bf_m->m_flags & M_FF) 3510 sc->sc_stats.mst_ff_txerr++; 3511 } 3512 /* 3513 * Do any tx complete callback. Note this must 3514 * be done before releasing the node reference. 3515 * XXX no way to figure out if frame was ACK'd 3516 */ 3517 if (bf->bf_m->m_flags & M_TXCB) { 3518 /* XXX strip fw len in case header inspected */ 3519 m_adj(bf->bf_m, sizeof(uint16_t)); 3520 ieee80211_process_callback(ni, bf->bf_m, 3521 (status & EAGLE_TXD_STATUS_OK) == 0); 3522 } 3523 /* 3524 * Reclaim reference to node. 3525 * 3526 * NB: the node may be reclaimed here if, for example 3527 * this is a DEAUTH message that was sent and the 3528 * node was timed out due to inactivity. 3529 */ 3530 ieee80211_free_node(ni); 3531 } 3532 ds->Status = htole32(EAGLE_TXD_STATUS_IDLE); 3533 3534 bus_dmamap_sync(sc->sc_dmat, bf->bf_dmamap, 3535 BUS_DMASYNC_POSTWRITE); 3536 bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap); 3537 m_freem(bf->bf_m); 3538 3539 mwl_puttxbuf_tail(txq, bf); 3540 } 3541 return nreaped; 3542 #undef EAGLE_TXD_STATUS_MCAST 3543 } 3544 3545 /* 3546 * Deferred processing of transmit interrupt; special-cased 3547 * for four hardware queues, 0-3. 3548 */ 3549 static void 3550 mwl_tx_proc(void *arg, int npending) 3551 { 3552 struct mwl_softc *sc = arg; 3553 struct ifnet *ifp = sc->sc_ifp; 3554 int nreaped; 3555 3556 /* 3557 * Process each active queue. 3558 */ 3559 nreaped = 0; 3560 if (!STAILQ_EMPTY(&sc->sc_txq[0].active)) 3561 nreaped += mwl_tx_processq(sc, &sc->sc_txq[0]); 3562 if (!STAILQ_EMPTY(&sc->sc_txq[1].active)) 3563 nreaped += mwl_tx_processq(sc, &sc->sc_txq[1]); 3564 if (!STAILQ_EMPTY(&sc->sc_txq[2].active)) 3565 nreaped += mwl_tx_processq(sc, &sc->sc_txq[2]); 3566 if (!STAILQ_EMPTY(&sc->sc_txq[3].active)) 3567 nreaped += mwl_tx_processq(sc, &sc->sc_txq[3]); 3568 3569 if (nreaped != 0) { 3570 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 3571 sc->sc_tx_timer = 0; 3572 if (!IFQ_IS_EMPTY(&ifp->if_snd)) { 3573 /* NB: kick fw; the tx thread may have been preempted */ 3574 mwl_hal_txstart(sc->sc_mh, 0); 3575 mwl_start(ifp); 3576 } 3577 } 3578 } 3579 3580 static void 3581 mwl_tx_draintxq(struct mwl_softc *sc, struct mwl_txq *txq) 3582 { 3583 struct ieee80211_node *ni; 3584 struct mwl_txbuf *bf; 3585 u_int ix; 3586 3587 /* 3588 * NB: this assumes output has been stopped and 3589 * we do not need to block mwl_tx_tasklet 3590 */ 3591 for (ix = 0;; ix++) { 3592 MWL_TXQ_LOCK(txq); 3593 bf = STAILQ_FIRST(&txq->active); 3594 if (bf == NULL) { 3595 MWL_TXQ_UNLOCK(txq); 3596 break; 3597 } 3598 STAILQ_REMOVE_HEAD(&txq->active, bf_list); 3599 MWL_TXQ_UNLOCK(txq); 3600 #ifdef MWL_DEBUG 3601 if (sc->sc_debug & MWL_DEBUG_RESET) { 3602 struct ifnet *ifp = sc->sc_ifp; 3603 struct ieee80211com *ic = ifp->if_l2com; 3604 const struct mwltxrec *tr = 3605 mtod(bf->bf_m, const struct mwltxrec *); 3606 mwl_printtxbuf(bf, txq->qnum, ix); 3607 ieee80211_dump_pkt(ic, (const uint8_t *)&tr->wh, 3608 bf->bf_m->m_len - sizeof(tr->fwlen), 0, -1); 3609 } 3610 #endif /* MWL_DEBUG */ 3611 bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap); 3612 ni = bf->bf_node; 3613 if (ni != NULL) { 3614 /* 3615 * Reclaim node reference. 3616 */ 3617 ieee80211_free_node(ni); 3618 } 3619 m_freem(bf->bf_m); 3620 3621 mwl_puttxbuf_tail(txq, bf); 3622 } 3623 } 3624 3625 /* 3626 * Drain the transmit queues and reclaim resources. 3627 */ 3628 static void 3629 mwl_draintxq(struct mwl_softc *sc) 3630 { 3631 struct ifnet *ifp = sc->sc_ifp; 3632 int i; 3633 3634 for (i = 0; i < MWL_NUM_TX_QUEUES; i++) 3635 mwl_tx_draintxq(sc, &sc->sc_txq[i]); 3636 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 3637 sc->sc_tx_timer = 0; 3638 } 3639 3640 #ifdef MWL_DIAGAPI 3641 /* 3642 * Reset the transmit queues to a pristine state after a fw download. 3643 */ 3644 static void 3645 mwl_resettxq(struct mwl_softc *sc) 3646 { 3647 int i; 3648 3649 for (i = 0; i < MWL_NUM_TX_QUEUES; i++) 3650 mwl_txq_reset(sc, &sc->sc_txq[i]); 3651 } 3652 #endif /* MWL_DIAGAPI */ 3653 3654 /* 3655 * Clear the transmit queues of any frames submitted for the 3656 * specified vap. This is done when the vap is deleted so we 3657 * don't potentially reference the vap after it is gone. 3658 * Note we cannot remove the frames; we only reclaim the node 3659 * reference. 3660 */ 3661 static void 3662 mwl_cleartxq(struct mwl_softc *sc, struct ieee80211vap *vap) 3663 { 3664 struct mwl_txq *txq; 3665 struct mwl_txbuf *bf; 3666 int i; 3667 3668 for (i = 0; i < MWL_NUM_TX_QUEUES; i++) { 3669 txq = &sc->sc_txq[i]; 3670 MWL_TXQ_LOCK(txq); 3671 STAILQ_FOREACH(bf, &txq->active, bf_list) { 3672 struct ieee80211_node *ni = bf->bf_node; 3673 if (ni != NULL && ni->ni_vap == vap) { 3674 bf->bf_node = NULL; 3675 ieee80211_free_node(ni); 3676 } 3677 } 3678 MWL_TXQ_UNLOCK(txq); 3679 } 3680 } 3681 3682 static int 3683 mwl_recv_action(struct ieee80211_node *ni, const struct ieee80211_frame *wh, 3684 const uint8_t *frm, const uint8_t *efrm) 3685 { 3686 struct mwl_softc *sc = ni->ni_ic->ic_ifp->if_softc; 3687 const struct ieee80211_action *ia; 3688 3689 ia = (const struct ieee80211_action *) frm; 3690 if (ia->ia_category == IEEE80211_ACTION_CAT_HT && 3691 ia->ia_action == IEEE80211_ACTION_HT_MIMOPWRSAVE) { 3692 const struct ieee80211_action_ht_mimopowersave *mps = 3693 (const struct ieee80211_action_ht_mimopowersave *) ia; 3694 3695 mwl_hal_setmimops(sc->sc_mh, ni->ni_macaddr, 3696 mps->am_control & IEEE80211_A_HT_MIMOPWRSAVE_ENA, 3697 MS(mps->am_control, IEEE80211_A_HT_MIMOPWRSAVE_MODE)); 3698 return 0; 3699 } else 3700 return sc->sc_recv_action(ni, wh, frm, efrm); 3701 } 3702 3703 static int 3704 mwl_addba_request(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap, 3705 int dialogtoken, int baparamset, int batimeout) 3706 { 3707 struct mwl_softc *sc = ni->ni_ic->ic_ifp->if_softc; 3708 struct ieee80211vap *vap = ni->ni_vap; 3709 struct mwl_node *mn = MWL_NODE(ni); 3710 struct mwl_bastate *bas; 3711 3712 bas = tap->txa_private; 3713 if (bas == NULL) { 3714 const MWL_HAL_BASTREAM *sp; 3715 /* 3716 * Check for a free BA stream slot. 3717 */ 3718 #if MWL_MAXBA > 3 3719 if (mn->mn_ba[3].bastream == NULL) 3720 bas = &mn->mn_ba[3]; 3721 else 3722 #endif 3723 #if MWL_MAXBA > 2 3724 if (mn->mn_ba[2].bastream == NULL) 3725 bas = &mn->mn_ba[2]; 3726 else 3727 #endif 3728 #if MWL_MAXBA > 1 3729 if (mn->mn_ba[1].bastream == NULL) 3730 bas = &mn->mn_ba[1]; 3731 else 3732 #endif 3733 #if MWL_MAXBA > 0 3734 if (mn->mn_ba[0].bastream == NULL) 3735 bas = &mn->mn_ba[0]; 3736 else 3737 #endif 3738 { 3739 /* sta already has max BA streams */ 3740 /* XXX assign BA stream to highest priority tid */ 3741 DPRINTF(sc, MWL_DEBUG_AMPDU, 3742 "%s: already has max bastreams\n", __func__); 3743 sc->sc_stats.mst_ampdu_reject++; 3744 return 0; 3745 } 3746 /* NB: no held reference to ni */ 3747 sp = mwl_hal_bastream_alloc(MWL_VAP(vap)->mv_hvap, 3748 (baparamset & IEEE80211_BAPS_POLICY_IMMEDIATE) != 0, 3749 ni->ni_macaddr, tap->txa_tid, ni->ni_htparam, 3750 ni, tap); 3751 if (sp == NULL) { 3752 /* 3753 * No available stream, return 0 so no 3754 * a-mpdu aggregation will be done. 3755 */ 3756 DPRINTF(sc, MWL_DEBUG_AMPDU, 3757 "%s: no bastream available\n", __func__); 3758 sc->sc_stats.mst_ampdu_nostream++; 3759 return 0; 3760 } 3761 DPRINTF(sc, MWL_DEBUG_AMPDU, "%s: alloc bastream %p\n", 3762 __func__, sp); 3763 /* NB: qos is left zero so we won't match in mwl_tx_start */ 3764 bas->bastream = sp; 3765 tap->txa_private = bas; 3766 } 3767 /* fetch current seq# from the firmware; if available */ 3768 if (mwl_hal_bastream_get_seqno(sc->sc_mh, bas->bastream, 3769 vap->iv_opmode == IEEE80211_M_STA ? vap->iv_myaddr : ni->ni_macaddr, 3770 &tap->txa_start) != 0) 3771 tap->txa_start = 0; 3772 return sc->sc_addba_request(ni, tap, dialogtoken, baparamset, batimeout); 3773 } 3774 3775 static int 3776 mwl_addba_response(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap, 3777 int code, int baparamset, int batimeout) 3778 { 3779 struct mwl_softc *sc = ni->ni_ic->ic_ifp->if_softc; 3780 struct mwl_bastate *bas; 3781 3782 bas = tap->txa_private; 3783 if (bas == NULL) { 3784 /* XXX should not happen */ 3785 DPRINTF(sc, MWL_DEBUG_AMPDU, 3786 "%s: no BA stream allocated, TID %d\n", 3787 __func__, tap->txa_tid); 3788 sc->sc_stats.mst_addba_nostream++; 3789 return 0; 3790 } 3791 if (code == IEEE80211_STATUS_SUCCESS) { 3792 struct ieee80211vap *vap = ni->ni_vap; 3793 int bufsiz, error; 3794 3795 /* 3796 * Tell the firmware to setup the BA stream; 3797 * we know resources are available because we 3798 * pre-allocated one before forming the request. 3799 */ 3800 bufsiz = MS(baparamset, IEEE80211_BAPS_BUFSIZ); 3801 if (bufsiz == 0) 3802 bufsiz = IEEE80211_AGGR_BAWMAX; 3803 error = mwl_hal_bastream_create(MWL_VAP(vap)->mv_hvap, 3804 bas->bastream, bufsiz, bufsiz, tap->txa_start); 3805 if (error != 0) { 3806 /* 3807 * Setup failed, return immediately so no a-mpdu 3808 * aggregation will be done. 3809 */ 3810 mwl_hal_bastream_destroy(sc->sc_mh, bas->bastream); 3811 mwl_bastream_free(bas); 3812 tap->txa_private = NULL; 3813 3814 DPRINTF(sc, MWL_DEBUG_AMPDU, 3815 "%s: create failed, error %d, bufsiz %d TID %d " 3816 "htparam 0x%x\n", __func__, error, bufsiz, 3817 tap->txa_tid, ni->ni_htparam); 3818 sc->sc_stats.mst_bacreate_failed++; 3819 return 0; 3820 } 3821 /* NB: cache txq to avoid ptr indirect */ 3822 mwl_bastream_setup(bas, tap->txa_tid, bas->bastream->txq); 3823 DPRINTF(sc, MWL_DEBUG_AMPDU, 3824 "%s: bastream %p assigned to txq %d TID %d bufsiz %d " 3825 "htparam 0x%x\n", __func__, bas->bastream, 3826 bas->txq, tap->txa_tid, bufsiz, ni->ni_htparam); 3827 } else { 3828 /* 3829 * Other side NAK'd us; return the resources. 3830 */ 3831 DPRINTF(sc, MWL_DEBUG_AMPDU, 3832 "%s: request failed with code %d, destroy bastream %p\n", 3833 __func__, code, bas->bastream); 3834 mwl_hal_bastream_destroy(sc->sc_mh, bas->bastream); 3835 mwl_bastream_free(bas); 3836 tap->txa_private = NULL; 3837 } 3838 /* NB: firmware sends BAR so we don't need to */ 3839 return sc->sc_addba_response(ni, tap, code, baparamset, batimeout); 3840 } 3841 3842 static void 3843 mwl_addba_stop(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap) 3844 { 3845 struct mwl_softc *sc = ni->ni_ic->ic_ifp->if_softc; 3846 struct mwl_bastate *bas; 3847 3848 bas = tap->txa_private; 3849 if (bas != NULL) { 3850 DPRINTF(sc, MWL_DEBUG_AMPDU, "%s: destroy bastream %p\n", 3851 __func__, bas->bastream); 3852 mwl_hal_bastream_destroy(sc->sc_mh, bas->bastream); 3853 mwl_bastream_free(bas); 3854 tap->txa_private = NULL; 3855 } 3856 sc->sc_addba_stop(ni, tap); 3857 } 3858 3859 /* 3860 * Setup the rx data structures. This should only be 3861 * done once or we may get out of sync with the firmware. 3862 */ 3863 static int 3864 mwl_startrecv(struct mwl_softc *sc) 3865 { 3866 if (!sc->sc_recvsetup) { 3867 struct mwl_rxbuf *bf, *prev; 3868 struct mwl_rxdesc *ds; 3869 3870 prev = NULL; 3871 STAILQ_FOREACH(bf, &sc->sc_rxbuf, bf_list) { 3872 int error = mwl_rxbuf_init(sc, bf); 3873 if (error != 0) { 3874 DPRINTF(sc, MWL_DEBUG_RECV, 3875 "%s: mwl_rxbuf_init failed %d\n", 3876 __func__, error); 3877 return error; 3878 } 3879 if (prev != NULL) { 3880 ds = prev->bf_desc; 3881 ds->pPhysNext = htole32(bf->bf_daddr); 3882 } 3883 prev = bf; 3884 } 3885 if (prev != NULL) { 3886 ds = prev->bf_desc; 3887 ds->pPhysNext = 3888 htole32(STAILQ_FIRST(&sc->sc_rxbuf)->bf_daddr); 3889 } 3890 sc->sc_recvsetup = 1; 3891 } 3892 mwl_mode_init(sc); /* set filters, etc. */ 3893 return 0; 3894 } 3895 3896 static MWL_HAL_APMODE 3897 mwl_getapmode(const struct ieee80211vap *vap, struct ieee80211_channel *chan) 3898 { 3899 MWL_HAL_APMODE mode; 3900 3901 if (IEEE80211_IS_CHAN_HT(chan)) { 3902 if (vap->iv_flags_ht & IEEE80211_FHT_PUREN) 3903 mode = AP_MODE_N_ONLY; 3904 else if (IEEE80211_IS_CHAN_5GHZ(chan)) 3905 mode = AP_MODE_AandN; 3906 else if (vap->iv_flags & IEEE80211_F_PUREG) 3907 mode = AP_MODE_GandN; 3908 else 3909 mode = AP_MODE_BandGandN; 3910 } else if (IEEE80211_IS_CHAN_ANYG(chan)) { 3911 if (vap->iv_flags & IEEE80211_F_PUREG) 3912 mode = AP_MODE_G_ONLY; 3913 else 3914 mode = AP_MODE_MIXED; 3915 } else if (IEEE80211_IS_CHAN_B(chan)) 3916 mode = AP_MODE_B_ONLY; 3917 else if (IEEE80211_IS_CHAN_A(chan)) 3918 mode = AP_MODE_A_ONLY; 3919 else 3920 mode = AP_MODE_MIXED; /* XXX should not happen? */ 3921 return mode; 3922 } 3923 3924 static int 3925 mwl_setapmode(struct ieee80211vap *vap, struct ieee80211_channel *chan) 3926 { 3927 struct mwl_hal_vap *hvap = MWL_VAP(vap)->mv_hvap; 3928 return mwl_hal_setapmode(hvap, mwl_getapmode(vap, chan)); 3929 } 3930 3931 /* 3932 * Set/change channels. 3933 */ 3934 static int 3935 mwl_chan_set(struct mwl_softc *sc, struct ieee80211_channel *chan) 3936 { 3937 struct mwl_hal *mh = sc->sc_mh; 3938 struct ifnet *ifp = sc->sc_ifp; 3939 struct ieee80211com *ic = ifp->if_l2com; 3940 MWL_HAL_CHANNEL hchan; 3941 int maxtxpow; 3942 3943 DPRINTF(sc, MWL_DEBUG_RESET, "%s: chan %u MHz/flags 0x%x\n", 3944 __func__, chan->ic_freq, chan->ic_flags); 3945 3946 /* 3947 * Convert to a HAL channel description with 3948 * the flags constrained to reflect the current 3949 * operating mode. 3950 */ 3951 mwl_mapchan(&hchan, chan); 3952 mwl_hal_intrset(mh, 0); /* disable interrupts */ 3953 #if 0 3954 mwl_draintxq(sc); /* clear pending tx frames */ 3955 #endif 3956 mwl_hal_setchannel(mh, &hchan); 3957 /* 3958 * Tx power is cap'd by the regulatory setting and 3959 * possibly a user-set limit. We pass the min of 3960 * these to the hal to apply them to the cal data 3961 * for this channel. 3962 * XXX min bound? 3963 */ 3964 maxtxpow = 2*chan->ic_maxregpower; 3965 if (maxtxpow > ic->ic_txpowlimit) 3966 maxtxpow = ic->ic_txpowlimit; 3967 mwl_hal_settxpower(mh, &hchan, maxtxpow / 2); 3968 /* NB: potentially change mcast/mgt rates */ 3969 mwl_setcurchanrates(sc); 3970 3971 /* 3972 * Update internal state. 3973 */ 3974 sc->sc_tx_th.wt_chan_freq = htole16(chan->ic_freq); 3975 sc->sc_rx_th.wr_chan_freq = htole16(chan->ic_freq); 3976 if (IEEE80211_IS_CHAN_A(chan)) { 3977 sc->sc_tx_th.wt_chan_flags = htole16(IEEE80211_CHAN_A); 3978 sc->sc_rx_th.wr_chan_flags = htole16(IEEE80211_CHAN_A); 3979 } else if (IEEE80211_IS_CHAN_ANYG(chan)) { 3980 sc->sc_tx_th.wt_chan_flags = htole16(IEEE80211_CHAN_G); 3981 sc->sc_rx_th.wr_chan_flags = htole16(IEEE80211_CHAN_G); 3982 } else { 3983 sc->sc_tx_th.wt_chan_flags = htole16(IEEE80211_CHAN_B); 3984 sc->sc_rx_th.wr_chan_flags = htole16(IEEE80211_CHAN_B); 3985 } 3986 sc->sc_curchan = hchan; 3987 mwl_hal_intrset(mh, sc->sc_imask); 3988 3989 return 0; 3990 } 3991 3992 static void 3993 mwl_scan_start(struct ieee80211com *ic) 3994 { 3995 struct ifnet *ifp = ic->ic_ifp; 3996 struct mwl_softc *sc = ifp->if_softc; 3997 3998 DPRINTF(sc, MWL_DEBUG_STATE, "%s\n", __func__); 3999 } 4000 4001 static void 4002 mwl_scan_end(struct ieee80211com *ic) 4003 { 4004 struct ifnet *ifp = ic->ic_ifp; 4005 struct mwl_softc *sc = ifp->if_softc; 4006 4007 DPRINTF(sc, MWL_DEBUG_STATE, "%s\n", __func__); 4008 } 4009 4010 static void 4011 mwl_set_channel(struct ieee80211com *ic) 4012 { 4013 struct ifnet *ifp = ic->ic_ifp; 4014 struct mwl_softc *sc = ifp->if_softc; 4015 4016 (void) mwl_chan_set(sc, ic->ic_curchan); 4017 } 4018 4019 /* 4020 * Handle a channel switch request. We inform the firmware 4021 * and mark the global state to suppress various actions. 4022 * NB: we issue only one request to the fw; we may be called 4023 * multiple times if there are multiple vap's. 4024 */ 4025 static void 4026 mwl_startcsa(struct ieee80211vap *vap) 4027 { 4028 struct ieee80211com *ic = vap->iv_ic; 4029 struct mwl_softc *sc = ic->ic_ifp->if_softc; 4030 MWL_HAL_CHANNEL hchan; 4031 4032 if (sc->sc_csapending) 4033 return; 4034 4035 mwl_mapchan(&hchan, ic->ic_csa_newchan); 4036 /* 1 =>'s quiet channel */ 4037 mwl_hal_setchannelswitchie(sc->sc_mh, &hchan, 1, ic->ic_csa_count); 4038 sc->sc_csapending = 1; 4039 } 4040 4041 /* 4042 * Plumb any static WEP key for the station. This is 4043 * necessary as we must propagate the key from the 4044 * global key table of the vap to each sta db entry. 4045 */ 4046 static void 4047 mwl_setanywepkey(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN]) 4048 { 4049 if ((vap->iv_flags & (IEEE80211_F_PRIVACY|IEEE80211_F_WPA)) == 4050 IEEE80211_F_PRIVACY && 4051 vap->iv_def_txkey != IEEE80211_KEYIX_NONE && 4052 vap->iv_nw_keys[vap->iv_def_txkey].wk_keyix != IEEE80211_KEYIX_NONE) 4053 (void) mwl_key_set(vap, &vap->iv_nw_keys[vap->iv_def_txkey], mac); 4054 } 4055 4056 static int 4057 mwl_peerstadb(struct ieee80211_node *ni, int aid, int staid, MWL_HAL_PEERINFO *pi) 4058 { 4059 #define WME(ie) ((const struct ieee80211_wme_info *) ie) 4060 struct ieee80211vap *vap = ni->ni_vap; 4061 struct mwl_hal_vap *hvap; 4062 int error; 4063 4064 if (vap->iv_opmode == IEEE80211_M_WDS) { 4065 /* 4066 * WDS vap's do not have a f/w vap; instead they piggyback 4067 * on an AP vap and we must install the sta db entry and 4068 * crypto state using that AP's handle (the WDS vap has none). 4069 */ 4070 hvap = MWL_VAP(vap)->mv_ap_hvap; 4071 } else 4072 hvap = MWL_VAP(vap)->mv_hvap; 4073 error = mwl_hal_newstation(hvap, ni->ni_macaddr, 4074 aid, staid, pi, 4075 ni->ni_flags & (IEEE80211_NODE_QOS | IEEE80211_NODE_HT), 4076 ni->ni_ies.wme_ie != NULL ? WME(ni->ni_ies.wme_ie)->wme_info : 0); 4077 if (error == 0) { 4078 /* 4079 * Setup security for this station. For sta mode this is 4080 * needed even though do the same thing on transition to 4081 * AUTH state because the call to mwl_hal_newstation 4082 * clobbers the crypto state we setup. 4083 */ 4084 mwl_setanywepkey(vap, ni->ni_macaddr); 4085 } 4086 return error; 4087 #undef WME 4088 } 4089 4090 static void 4091 mwl_setglobalkeys(struct ieee80211vap *vap) 4092 { 4093 struct ieee80211_key *wk; 4094 4095 wk = &vap->iv_nw_keys[0]; 4096 for (; wk < &vap->iv_nw_keys[IEEE80211_WEP_NKID]; wk++) 4097 if (wk->wk_keyix != IEEE80211_KEYIX_NONE) 4098 (void) mwl_key_set(vap, wk, vap->iv_myaddr); 4099 } 4100 4101 /* 4102 * Convert a legacy rate set to a firmware bitmask. 4103 */ 4104 static uint32_t 4105 get_rate_bitmap(const struct ieee80211_rateset *rs) 4106 { 4107 uint32_t rates; 4108 int i; 4109 4110 rates = 0; 4111 for (i = 0; i < rs->rs_nrates; i++) 4112 switch (rs->rs_rates[i] & IEEE80211_RATE_VAL) { 4113 case 2: rates |= 0x001; break; 4114 case 4: rates |= 0x002; break; 4115 case 11: rates |= 0x004; break; 4116 case 22: rates |= 0x008; break; 4117 case 44: rates |= 0x010; break; 4118 case 12: rates |= 0x020; break; 4119 case 18: rates |= 0x040; break; 4120 case 24: rates |= 0x080; break; 4121 case 36: rates |= 0x100; break; 4122 case 48: rates |= 0x200; break; 4123 case 72: rates |= 0x400; break; 4124 case 96: rates |= 0x800; break; 4125 case 108: rates |= 0x1000; break; 4126 } 4127 return rates; 4128 } 4129 4130 /* 4131 * Construct an HT firmware bitmask from an HT rate set. 4132 */ 4133 static uint32_t 4134 get_htrate_bitmap(const struct ieee80211_htrateset *rs) 4135 { 4136 uint32_t rates; 4137 int i; 4138 4139 rates = 0; 4140 for (i = 0; i < rs->rs_nrates; i++) { 4141 if (rs->rs_rates[i] < 16) 4142 rates |= 1<<rs->rs_rates[i]; 4143 } 4144 return rates; 4145 } 4146 4147 /* 4148 * Craft station database entry for station. 4149 * NB: use host byte order here, the hal handles byte swapping. 4150 */ 4151 static MWL_HAL_PEERINFO * 4152 mkpeerinfo(MWL_HAL_PEERINFO *pi, const struct ieee80211_node *ni) 4153 { 4154 const struct ieee80211vap *vap = ni->ni_vap; 4155 4156 memset(pi, 0, sizeof(*pi)); 4157 pi->LegacyRateBitMap = get_rate_bitmap(&ni->ni_rates); 4158 pi->CapInfo = ni->ni_capinfo; 4159 if (ni->ni_flags & IEEE80211_NODE_HT) { 4160 /* HT capabilities, etc */ 4161 pi->HTCapabilitiesInfo = ni->ni_htcap; 4162 /* XXX pi.HTCapabilitiesInfo */ 4163 pi->MacHTParamInfo = ni->ni_htparam; 4164 pi->HTRateBitMap = get_htrate_bitmap(&ni->ni_htrates); 4165 pi->AddHtInfo.ControlChan = ni->ni_htctlchan; 4166 pi->AddHtInfo.AddChan = ni->ni_ht2ndchan; 4167 pi->AddHtInfo.OpMode = ni->ni_htopmode; 4168 pi->AddHtInfo.stbc = ni->ni_htstbc; 4169 4170 /* constrain according to local configuration */ 4171 if ((vap->iv_flags_ht & IEEE80211_FHT_SHORTGI40) == 0) 4172 pi->HTCapabilitiesInfo &= ~IEEE80211_HTCAP_SHORTGI40; 4173 if ((vap->iv_flags_ht & IEEE80211_FHT_SHORTGI20) == 0) 4174 pi->HTCapabilitiesInfo &= ~IEEE80211_HTCAP_SHORTGI20; 4175 if (ni->ni_chw != 40) 4176 pi->HTCapabilitiesInfo &= ~IEEE80211_HTCAP_CHWIDTH40; 4177 } 4178 return pi; 4179 } 4180 4181 /* 4182 * Re-create the local sta db entry for a vap to ensure 4183 * up to date WME state is pushed to the firmware. Because 4184 * this resets crypto state this must be followed by a 4185 * reload of any keys in the global key table. 4186 */ 4187 static int 4188 mwl_localstadb(struct ieee80211vap *vap) 4189 { 4190 #define WME(ie) ((const struct ieee80211_wme_info *) ie) 4191 struct mwl_hal_vap *hvap = MWL_VAP(vap)->mv_hvap; 4192 struct ieee80211_node *bss; 4193 MWL_HAL_PEERINFO pi; 4194 int error; 4195 4196 switch (vap->iv_opmode) { 4197 case IEEE80211_M_STA: 4198 bss = vap->iv_bss; 4199 error = mwl_hal_newstation(hvap, vap->iv_myaddr, 0, 0, 4200 vap->iv_state == IEEE80211_S_RUN ? 4201 mkpeerinfo(&pi, bss) : NULL, 4202 (bss->ni_flags & (IEEE80211_NODE_QOS | IEEE80211_NODE_HT)), 4203 bss->ni_ies.wme_ie != NULL ? 4204 WME(bss->ni_ies.wme_ie)->wme_info : 0); 4205 if (error == 0) 4206 mwl_setglobalkeys(vap); 4207 break; 4208 case IEEE80211_M_HOSTAP: 4209 case IEEE80211_M_MBSS: 4210 error = mwl_hal_newstation(hvap, vap->iv_myaddr, 4211 0, 0, NULL, vap->iv_flags & IEEE80211_F_WME, 0); 4212 if (error == 0) 4213 mwl_setglobalkeys(vap); 4214 break; 4215 default: 4216 error = 0; 4217 break; 4218 } 4219 return error; 4220 #undef WME 4221 } 4222 4223 static int 4224 mwl_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 4225 { 4226 struct mwl_vap *mvp = MWL_VAP(vap); 4227 struct mwl_hal_vap *hvap = mvp->mv_hvap; 4228 struct ieee80211com *ic = vap->iv_ic; 4229 struct ieee80211_node *ni = NULL; 4230 struct ifnet *ifp = ic->ic_ifp; 4231 struct mwl_softc *sc = ifp->if_softc; 4232 struct mwl_hal *mh = sc->sc_mh; 4233 enum ieee80211_state ostate = vap->iv_state; 4234 int error; 4235 4236 DPRINTF(sc, MWL_DEBUG_STATE, "%s: %s: %s -> %s\n", 4237 vap->iv_ifp->if_xname, __func__, 4238 ieee80211_state_name[ostate], ieee80211_state_name[nstate]); 4239 4240 callout_stop(&sc->sc_timer); 4241 /* 4242 * Clear current radar detection state. 4243 */ 4244 if (ostate == IEEE80211_S_CAC) { 4245 /* stop quiet mode radar detection */ 4246 mwl_hal_setradardetection(mh, DR_CHK_CHANNEL_AVAILABLE_STOP); 4247 } else if (sc->sc_radarena) { 4248 /* stop in-service radar detection */ 4249 mwl_hal_setradardetection(mh, DR_DFS_DISABLE); 4250 sc->sc_radarena = 0; 4251 } 4252 /* 4253 * Carry out per-state actions before doing net80211 work. 4254 */ 4255 if (nstate == IEEE80211_S_INIT) { 4256 /* NB: only ap+sta vap's have a fw entity */ 4257 if (hvap != NULL) 4258 mwl_hal_stop(hvap); 4259 } else if (nstate == IEEE80211_S_SCAN) { 4260 mwl_hal_start(hvap); 4261 /* NB: this disables beacon frames */ 4262 mwl_hal_setinframode(hvap); 4263 } else if (nstate == IEEE80211_S_AUTH) { 4264 /* 4265 * Must create a sta db entry in case a WEP key needs to 4266 * be plumbed. This entry will be overwritten if we 4267 * associate; otherwise it will be reclaimed on node free. 4268 */ 4269 ni = vap->iv_bss; 4270 MWL_NODE(ni)->mn_hvap = hvap; 4271 (void) mwl_peerstadb(ni, 0, 0, NULL); 4272 } else if (nstate == IEEE80211_S_CSA) { 4273 /* XXX move to below? */ 4274 if (vap->iv_opmode == IEEE80211_M_HOSTAP || 4275 vap->iv_opmode == IEEE80211_M_MBSS) 4276 mwl_startcsa(vap); 4277 } else if (nstate == IEEE80211_S_CAC) { 4278 /* XXX move to below? */ 4279 /* stop ap xmit and enable quiet mode radar detection */ 4280 mwl_hal_setradardetection(mh, DR_CHK_CHANNEL_AVAILABLE_START); 4281 } 4282 4283 /* 4284 * Invoke the parent method to do net80211 work. 4285 */ 4286 error = mvp->mv_newstate(vap, nstate, arg); 4287 4288 /* 4289 * Carry out work that must be done after net80211 runs; 4290 * this work requires up to date state (e.g. iv_bss). 4291 */ 4292 if (error == 0 && nstate == IEEE80211_S_RUN) { 4293 /* NB: collect bss node again, it may have changed */ 4294 ni = vap->iv_bss; 4295 4296 DPRINTF(sc, MWL_DEBUG_STATE, 4297 "%s: %s(RUN): iv_flags 0x%08x bintvl %d bssid %s " 4298 "capinfo 0x%04x chan %d\n", 4299 vap->iv_ifp->if_xname, __func__, vap->iv_flags, 4300 ni->ni_intval, ether_sprintf(ni->ni_bssid), ni->ni_capinfo, 4301 ieee80211_chan2ieee(ic, ic->ic_curchan)); 4302 4303 /* 4304 * Recreate local sta db entry to update WME/HT state. 4305 */ 4306 mwl_localstadb(vap); 4307 switch (vap->iv_opmode) { 4308 case IEEE80211_M_HOSTAP: 4309 case IEEE80211_M_MBSS: 4310 if (ostate == IEEE80211_S_CAC) { 4311 /* enable in-service radar detection */ 4312 mwl_hal_setradardetection(mh, 4313 DR_IN_SERVICE_MONITOR_START); 4314 sc->sc_radarena = 1; 4315 } 4316 /* 4317 * Allocate and setup the beacon frame 4318 * (and related state). 4319 */ 4320 error = mwl_reset_vap(vap, IEEE80211_S_RUN); 4321 if (error != 0) { 4322 DPRINTF(sc, MWL_DEBUG_STATE, 4323 "%s: beacon setup failed, error %d\n", 4324 __func__, error); 4325 goto bad; 4326 } 4327 /* NB: must be after setting up beacon */ 4328 mwl_hal_start(hvap); 4329 break; 4330 case IEEE80211_M_STA: 4331 DPRINTF(sc, MWL_DEBUG_STATE, "%s: %s: aid 0x%x\n", 4332 vap->iv_ifp->if_xname, __func__, ni->ni_associd); 4333 /* 4334 * Set state now that we're associated. 4335 */ 4336 mwl_hal_setassocid(hvap, ni->ni_bssid, ni->ni_associd); 4337 mwl_setrates(vap); 4338 mwl_hal_setrtsthreshold(hvap, vap->iv_rtsthreshold); 4339 if ((vap->iv_flags & IEEE80211_F_DWDS) && 4340 sc->sc_ndwdsvaps++ == 0) 4341 mwl_hal_setdwds(mh, 1); 4342 break; 4343 case IEEE80211_M_WDS: 4344 DPRINTF(sc, MWL_DEBUG_STATE, "%s: %s: bssid %s\n", 4345 vap->iv_ifp->if_xname, __func__, 4346 ether_sprintf(ni->ni_bssid)); 4347 mwl_seteapolformat(vap); 4348 break; 4349 default: 4350 break; 4351 } 4352 /* 4353 * Set CS mode according to operating channel; 4354 * this mostly an optimization for 5GHz. 4355 * 4356 * NB: must follow mwl_hal_start which resets csmode 4357 */ 4358 if (IEEE80211_IS_CHAN_5GHZ(ic->ic_bsschan)) 4359 mwl_hal_setcsmode(mh, CSMODE_AGGRESSIVE); 4360 else 4361 mwl_hal_setcsmode(mh, CSMODE_AUTO_ENA); 4362 /* 4363 * Start timer to prod firmware. 4364 */ 4365 if (sc->sc_ageinterval != 0) 4366 callout_reset(&sc->sc_timer, sc->sc_ageinterval*hz, 4367 mwl_agestations, sc); 4368 } else if (nstate == IEEE80211_S_SLEEP) { 4369 /* XXX set chip in power save */ 4370 } else if ((vap->iv_flags & IEEE80211_F_DWDS) && 4371 --sc->sc_ndwdsvaps == 0) 4372 mwl_hal_setdwds(mh, 0); 4373 bad: 4374 return error; 4375 } 4376 4377 /* 4378 * Manage station id's; these are separate from AID's 4379 * as AID's may have values out of the range of possible 4380 * station id's acceptable to the firmware. 4381 */ 4382 static int 4383 allocstaid(struct mwl_softc *sc, int aid) 4384 { 4385 int staid; 4386 4387 if (!(0 < aid && aid < MWL_MAXSTAID) || isset(sc->sc_staid, aid)) { 4388 /* NB: don't use 0 */ 4389 for (staid = 1; staid < MWL_MAXSTAID; staid++) 4390 if (isclr(sc->sc_staid, staid)) 4391 break; 4392 } else 4393 staid = aid; 4394 setbit(sc->sc_staid, staid); 4395 return staid; 4396 } 4397 4398 static void 4399 delstaid(struct mwl_softc *sc, int staid) 4400 { 4401 clrbit(sc->sc_staid, staid); 4402 } 4403 4404 /* 4405 * Setup driver-specific state for a newly associated node. 4406 * Note that we're called also on a re-associate, the isnew 4407 * param tells us if this is the first time or not. 4408 */ 4409 static void 4410 mwl_newassoc(struct ieee80211_node *ni, int isnew) 4411 { 4412 struct ieee80211vap *vap = ni->ni_vap; 4413 struct mwl_softc *sc = vap->iv_ic->ic_ifp->if_softc; 4414 struct mwl_node *mn = MWL_NODE(ni); 4415 MWL_HAL_PEERINFO pi; 4416 uint16_t aid; 4417 int error; 4418 4419 aid = IEEE80211_AID(ni->ni_associd); 4420 if (isnew) { 4421 mn->mn_staid = allocstaid(sc, aid); 4422 mn->mn_hvap = MWL_VAP(vap)->mv_hvap; 4423 } else { 4424 mn = MWL_NODE(ni); 4425 /* XXX reset BA stream? */ 4426 } 4427 DPRINTF(sc, MWL_DEBUG_NODE, "%s: mac %s isnew %d aid %d staid %d\n", 4428 __func__, ether_sprintf(ni->ni_macaddr), isnew, aid, mn->mn_staid); 4429 error = mwl_peerstadb(ni, aid, mn->mn_staid, mkpeerinfo(&pi, ni)); 4430 if (error != 0) { 4431 DPRINTF(sc, MWL_DEBUG_NODE, 4432 "%s: error %d creating sta db entry\n", 4433 __func__, error); 4434 /* XXX how to deal with error? */ 4435 } 4436 } 4437 4438 /* 4439 * Periodically poke the firmware to age out station state 4440 * (power save queues, pending tx aggregates). 4441 */ 4442 static void 4443 mwl_agestations(void *arg) 4444 { 4445 struct mwl_softc *sc = arg; 4446 4447 mwl_hal_setkeepalive(sc->sc_mh); 4448 if (sc->sc_ageinterval != 0) /* NB: catch dynamic changes */ 4449 callout_schedule(&sc->sc_timer, sc->sc_ageinterval*hz); 4450 } 4451 4452 static const struct mwl_hal_channel * 4453 findhalchannel(const MWL_HAL_CHANNELINFO *ci, int ieee) 4454 { 4455 int i; 4456 4457 for (i = 0; i < ci->nchannels; i++) { 4458 const struct mwl_hal_channel *hc = &ci->channels[i]; 4459 if (hc->ieee == ieee) 4460 return hc; 4461 } 4462 return NULL; 4463 } 4464 4465 static int 4466 mwl_setregdomain(struct ieee80211com *ic, struct ieee80211_regdomain *rd, 4467 int nchan, struct ieee80211_channel chans[]) 4468 { 4469 struct mwl_softc *sc = ic->ic_ifp->if_softc; 4470 struct mwl_hal *mh = sc->sc_mh; 4471 const MWL_HAL_CHANNELINFO *ci; 4472 int i; 4473 4474 for (i = 0; i < nchan; i++) { 4475 struct ieee80211_channel *c = &chans[i]; 4476 const struct mwl_hal_channel *hc; 4477 4478 if (IEEE80211_IS_CHAN_2GHZ(c)) { 4479 mwl_hal_getchannelinfo(mh, MWL_FREQ_BAND_2DOT4GHZ, 4480 IEEE80211_IS_CHAN_HT40(c) ? 4481 MWL_CH_40_MHz_WIDTH : MWL_CH_20_MHz_WIDTH, &ci); 4482 } else if (IEEE80211_IS_CHAN_5GHZ(c)) { 4483 mwl_hal_getchannelinfo(mh, MWL_FREQ_BAND_5GHZ, 4484 IEEE80211_IS_CHAN_HT40(c) ? 4485 MWL_CH_40_MHz_WIDTH : MWL_CH_20_MHz_WIDTH, &ci); 4486 } else { 4487 if_printf(ic->ic_ifp, 4488 "%s: channel %u freq %u/0x%x not 2.4/5GHz\n", 4489 __func__, c->ic_ieee, c->ic_freq, c->ic_flags); 4490 return EINVAL; 4491 } 4492 /* 4493 * Verify channel has cal data and cap tx power. 4494 */ 4495 hc = findhalchannel(ci, c->ic_ieee); 4496 if (hc != NULL) { 4497 if (c->ic_maxpower > 2*hc->maxTxPow) 4498 c->ic_maxpower = 2*hc->maxTxPow; 4499 goto next; 4500 } 4501 if (IEEE80211_IS_CHAN_HT40(c)) { 4502 /* 4503 * Look for the extension channel since the 4504 * hal table only has the primary channel. 4505 */ 4506 hc = findhalchannel(ci, c->ic_extieee); 4507 if (hc != NULL) { 4508 if (c->ic_maxpower > 2*hc->maxTxPow) 4509 c->ic_maxpower = 2*hc->maxTxPow; 4510 goto next; 4511 } 4512 } 4513 if_printf(ic->ic_ifp, 4514 "%s: no cal data for channel %u ext %u freq %u/0x%x\n", 4515 __func__, c->ic_ieee, c->ic_extieee, 4516 c->ic_freq, c->ic_flags); 4517 return EINVAL; 4518 next: 4519 ; 4520 } 4521 return 0; 4522 } 4523 4524 #define IEEE80211_CHAN_HTG (IEEE80211_CHAN_HT|IEEE80211_CHAN_G) 4525 #define IEEE80211_CHAN_HTA (IEEE80211_CHAN_HT|IEEE80211_CHAN_A) 4526 4527 static void 4528 addchan(struct ieee80211_channel *c, int freq, int flags, int ieee, int txpow) 4529 { 4530 c->ic_freq = freq; 4531 c->ic_flags = flags; 4532 c->ic_ieee = ieee; 4533 c->ic_minpower = 0; 4534 c->ic_maxpower = 2*txpow; 4535 c->ic_maxregpower = txpow; 4536 } 4537 4538 static const struct ieee80211_channel * 4539 findchannel(const struct ieee80211_channel chans[], int nchans, 4540 int freq, int flags) 4541 { 4542 const struct ieee80211_channel *c; 4543 int i; 4544 4545 for (i = 0; i < nchans; i++) { 4546 c = &chans[i]; 4547 if (c->ic_freq == freq && c->ic_flags == flags) 4548 return c; 4549 } 4550 return NULL; 4551 } 4552 4553 static void 4554 addht40channels(struct ieee80211_channel chans[], int maxchans, int *nchans, 4555 const MWL_HAL_CHANNELINFO *ci, int flags) 4556 { 4557 struct ieee80211_channel *c; 4558 const struct ieee80211_channel *extc; 4559 const struct mwl_hal_channel *hc; 4560 int i; 4561 4562 c = &chans[*nchans]; 4563 4564 flags &= ~IEEE80211_CHAN_HT; 4565 for (i = 0; i < ci->nchannels; i++) { 4566 /* 4567 * Each entry defines an HT40 channel pair; find the 4568 * extension channel above and the insert the pair. 4569 */ 4570 hc = &ci->channels[i]; 4571 extc = findchannel(chans, *nchans, hc->freq+20, 4572 flags | IEEE80211_CHAN_HT20); 4573 if (extc != NULL) { 4574 if (*nchans >= maxchans) 4575 break; 4576 addchan(c, hc->freq, flags | IEEE80211_CHAN_HT40U, 4577 hc->ieee, hc->maxTxPow); 4578 c->ic_extieee = extc->ic_ieee; 4579 c++, (*nchans)++; 4580 if (*nchans >= maxchans) 4581 break; 4582 addchan(c, extc->ic_freq, flags | IEEE80211_CHAN_HT40D, 4583 extc->ic_ieee, hc->maxTxPow); 4584 c->ic_extieee = hc->ieee; 4585 c++, (*nchans)++; 4586 } 4587 } 4588 } 4589 4590 static void 4591 addchannels(struct ieee80211_channel chans[], int maxchans, int *nchans, 4592 const MWL_HAL_CHANNELINFO *ci, int flags) 4593 { 4594 struct ieee80211_channel *c; 4595 int i; 4596 4597 c = &chans[*nchans]; 4598 4599 for (i = 0; i < ci->nchannels; i++) { 4600 const struct mwl_hal_channel *hc; 4601 4602 hc = &ci->channels[i]; 4603 if (*nchans >= maxchans) 4604 break; 4605 addchan(c, hc->freq, flags, hc->ieee, hc->maxTxPow); 4606 c++, (*nchans)++; 4607 if (flags == IEEE80211_CHAN_G || flags == IEEE80211_CHAN_HTG) { 4608 /* g channel have a separate b-only entry */ 4609 if (*nchans >= maxchans) 4610 break; 4611 c[0] = c[-1]; 4612 c[-1].ic_flags = IEEE80211_CHAN_B; 4613 c++, (*nchans)++; 4614 } 4615 if (flags == IEEE80211_CHAN_HTG) { 4616 /* HT g channel have a separate g-only entry */ 4617 if (*nchans >= maxchans) 4618 break; 4619 c[-1].ic_flags = IEEE80211_CHAN_G; 4620 c[0] = c[-1]; 4621 c[0].ic_flags &= ~IEEE80211_CHAN_HT; 4622 c[0].ic_flags |= IEEE80211_CHAN_HT20; /* HT20 */ 4623 c++, (*nchans)++; 4624 } 4625 if (flags == IEEE80211_CHAN_HTA) { 4626 /* HT a channel have a separate a-only entry */ 4627 if (*nchans >= maxchans) 4628 break; 4629 c[-1].ic_flags = IEEE80211_CHAN_A; 4630 c[0] = c[-1]; 4631 c[0].ic_flags &= ~IEEE80211_CHAN_HT; 4632 c[0].ic_flags |= IEEE80211_CHAN_HT20; /* HT20 */ 4633 c++, (*nchans)++; 4634 } 4635 } 4636 } 4637 4638 static void 4639 getchannels(struct mwl_softc *sc, int maxchans, int *nchans, 4640 struct ieee80211_channel chans[]) 4641 { 4642 const MWL_HAL_CHANNELINFO *ci; 4643 4644 /* 4645 * Use the channel info from the hal to craft the 4646 * channel list. Note that we pass back an unsorted 4647 * list; the caller is required to sort it for us 4648 * (if desired). 4649 */ 4650 *nchans = 0; 4651 if (mwl_hal_getchannelinfo(sc->sc_mh, 4652 MWL_FREQ_BAND_2DOT4GHZ, MWL_CH_20_MHz_WIDTH, &ci) == 0) 4653 addchannels(chans, maxchans, nchans, ci, IEEE80211_CHAN_HTG); 4654 if (mwl_hal_getchannelinfo(sc->sc_mh, 4655 MWL_FREQ_BAND_5GHZ, MWL_CH_20_MHz_WIDTH, &ci) == 0) 4656 addchannels(chans, maxchans, nchans, ci, IEEE80211_CHAN_HTA); 4657 if (mwl_hal_getchannelinfo(sc->sc_mh, 4658 MWL_FREQ_BAND_2DOT4GHZ, MWL_CH_40_MHz_WIDTH, &ci) == 0) 4659 addht40channels(chans, maxchans, nchans, ci, IEEE80211_CHAN_HTG); 4660 if (mwl_hal_getchannelinfo(sc->sc_mh, 4661 MWL_FREQ_BAND_5GHZ, MWL_CH_40_MHz_WIDTH, &ci) == 0) 4662 addht40channels(chans, maxchans, nchans, ci, IEEE80211_CHAN_HTA); 4663 } 4664 4665 static void 4666 mwl_getradiocaps(struct ieee80211com *ic, 4667 int maxchans, int *nchans, struct ieee80211_channel chans[]) 4668 { 4669 struct mwl_softc *sc = ic->ic_ifp->if_softc; 4670 4671 getchannels(sc, maxchans, nchans, chans); 4672 } 4673 4674 static int 4675 mwl_getchannels(struct mwl_softc *sc) 4676 { 4677 struct ifnet *ifp = sc->sc_ifp; 4678 struct ieee80211com *ic = ifp->if_l2com; 4679 4680 /* 4681 * Use the channel info from the hal to craft the 4682 * channel list for net80211. Note that we pass up 4683 * an unsorted list; net80211 will sort it for us. 4684 */ 4685 memset(ic->ic_channels, 0, sizeof(ic->ic_channels)); 4686 ic->ic_nchans = 0; 4687 getchannels(sc, IEEE80211_CHAN_MAX, &ic->ic_nchans, ic->ic_channels); 4688 4689 ic->ic_regdomain.regdomain = SKU_DEBUG; 4690 ic->ic_regdomain.country = CTRY_DEFAULT; 4691 ic->ic_regdomain.location = 'I'; 4692 ic->ic_regdomain.isocc[0] = ' '; /* XXX? */ 4693 ic->ic_regdomain.isocc[1] = ' '; 4694 return (ic->ic_nchans == 0 ? EIO : 0); 4695 } 4696 #undef IEEE80211_CHAN_HTA 4697 #undef IEEE80211_CHAN_HTG 4698 4699 #ifdef MWL_DEBUG 4700 static void 4701 mwl_printrxbuf(const struct mwl_rxbuf *bf, u_int ix) 4702 { 4703 const struct mwl_rxdesc *ds = bf->bf_desc; 4704 uint32_t status = le32toh(ds->Status); 4705 4706 printf("R[%2u] (DS.V:%p DS.P:%p) NEXT:%08x DATA:%08x RC:%02x%s\n" 4707 " STAT:%02x LEN:%04x RSSI:%02x CHAN:%02x RATE:%02x QOS:%04x HT:%04x\n", 4708 ix, ds, (const struct mwl_desc *)bf->bf_daddr, 4709 le32toh(ds->pPhysNext), le32toh(ds->pPhysBuffData), 4710 ds->RxControl, 4711 ds->RxControl != EAGLE_RXD_CTRL_DRIVER_OWN ? 4712 "" : (status & EAGLE_RXD_STATUS_OK) ? " *" : " !", 4713 ds->Status, le16toh(ds->PktLen), ds->RSSI, ds->Channel, 4714 ds->Rate, le16toh(ds->QosCtrl), le16toh(ds->HtSig2)); 4715 } 4716 4717 static void 4718 mwl_printtxbuf(const struct mwl_txbuf *bf, u_int qnum, u_int ix) 4719 { 4720 const struct mwl_txdesc *ds = bf->bf_desc; 4721 uint32_t status = le32toh(ds->Status); 4722 4723 printf("Q%u[%3u]", qnum, ix); 4724 printf(" (DS.V:%p DS.P:%p)\n", 4725 ds, (const struct mwl_txdesc *)bf->bf_daddr); 4726 printf(" NEXT:%08x DATA:%08x LEN:%04x STAT:%08x%s\n", 4727 le32toh(ds->pPhysNext), 4728 le32toh(ds->PktPtr), le16toh(ds->PktLen), status, 4729 status & EAGLE_TXD_STATUS_USED ? 4730 "" : (status & 3) != 0 ? " *" : " !"); 4731 printf(" RATE:%02x PRI:%x QOS:%04x SAP:%08x FORMAT:%04x\n", 4732 ds->DataRate, ds->TxPriority, le16toh(ds->QosCtrl), 4733 le32toh(ds->SapPktInfo), le16toh(ds->Format)); 4734 #if MWL_TXDESC > 1 4735 printf(" MULTIFRAMES:%u LEN:%04x %04x %04x %04x %04x %04x\n" 4736 , le32toh(ds->multiframes) 4737 , le16toh(ds->PktLenArray[0]), le16toh(ds->PktLenArray[1]) 4738 , le16toh(ds->PktLenArray[2]), le16toh(ds->PktLenArray[3]) 4739 , le16toh(ds->PktLenArray[4]), le16toh(ds->PktLenArray[5]) 4740 ); 4741 printf(" DATA:%08x %08x %08x %08x %08x %08x\n" 4742 , le32toh(ds->PktPtrArray[0]), le32toh(ds->PktPtrArray[1]) 4743 , le32toh(ds->PktPtrArray[2]), le32toh(ds->PktPtrArray[3]) 4744 , le32toh(ds->PktPtrArray[4]), le32toh(ds->PktPtrArray[5]) 4745 ); 4746 #endif 4747 #if 0 4748 { const uint8_t *cp = (const uint8_t *) ds; 4749 int i; 4750 for (i = 0; i < sizeof(struct mwl_txdesc); i++) { 4751 printf("%02x ", cp[i]); 4752 if (((i+1) % 16) == 0) 4753 printf("\n"); 4754 } 4755 printf("\n"); 4756 } 4757 #endif 4758 } 4759 #endif /* MWL_DEBUG */ 4760 4761 #if 0 4762 static void 4763 mwl_txq_dump(struct mwl_txq *txq) 4764 { 4765 struct mwl_txbuf *bf; 4766 int i = 0; 4767 4768 MWL_TXQ_LOCK(txq); 4769 STAILQ_FOREACH(bf, &txq->active, bf_list) { 4770 struct mwl_txdesc *ds = bf->bf_desc; 4771 MWL_TXDESC_SYNC(txq, ds, 4772 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 4773 #ifdef MWL_DEBUG 4774 mwl_printtxbuf(bf, txq->qnum, i); 4775 #endif 4776 i++; 4777 } 4778 MWL_TXQ_UNLOCK(txq); 4779 } 4780 #endif 4781 4782 static void 4783 mwl_watchdog(void *arg) 4784 { 4785 struct mwl_softc *sc; 4786 struct ifnet *ifp; 4787 4788 sc = arg; 4789 callout_reset(&sc->sc_watchdog, hz, mwl_watchdog, sc); 4790 if (sc->sc_tx_timer == 0 || --sc->sc_tx_timer > 0) 4791 return; 4792 4793 ifp = sc->sc_ifp; 4794 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) && !sc->sc_invalid) { 4795 if (mwl_hal_setkeepalive(sc->sc_mh)) 4796 if_printf(ifp, "transmit timeout (firmware hung?)\n"); 4797 else 4798 if_printf(ifp, "transmit timeout\n"); 4799 #if 0 4800 mwl_reset(ifp); 4801 mwl_txq_dump(&sc->sc_txq[0]);/*XXX*/ 4802 #endif 4803 ifp->if_oerrors++; 4804 sc->sc_stats.mst_watchdog++; 4805 } 4806 } 4807 4808 #ifdef MWL_DIAGAPI 4809 /* 4810 * Diagnostic interface to the HAL. This is used by various 4811 * tools to do things like retrieve register contents for 4812 * debugging. The mechanism is intentionally opaque so that 4813 * it can change frequently w/o concern for compatiblity. 4814 */ 4815 static int 4816 mwl_ioctl_diag(struct mwl_softc *sc, struct mwl_diag *md) 4817 { 4818 struct mwl_hal *mh = sc->sc_mh; 4819 u_int id = md->md_id & MWL_DIAG_ID; 4820 void *indata = NULL; 4821 void *outdata = NULL; 4822 u_int32_t insize = md->md_in_size; 4823 u_int32_t outsize = md->md_out_size; 4824 int error = 0; 4825 4826 if (md->md_id & MWL_DIAG_IN) { 4827 /* 4828 * Copy in data. 4829 */ 4830 indata = malloc(insize, M_TEMP, M_NOWAIT); 4831 if (indata == NULL) { 4832 error = ENOMEM; 4833 goto bad; 4834 } 4835 error = copyin(md->md_in_data, indata, insize); 4836 if (error) 4837 goto bad; 4838 } 4839 if (md->md_id & MWL_DIAG_DYN) { 4840 /* 4841 * Allocate a buffer for the results (otherwise the HAL 4842 * returns a pointer to a buffer where we can read the 4843 * results). Note that we depend on the HAL leaving this 4844 * pointer for us to use below in reclaiming the buffer; 4845 * may want to be more defensive. 4846 */ 4847 outdata = malloc(outsize, M_TEMP, M_NOWAIT); 4848 if (outdata == NULL) { 4849 error = ENOMEM; 4850 goto bad; 4851 } 4852 } 4853 if (mwl_hal_getdiagstate(mh, id, indata, insize, &outdata, &outsize)) { 4854 if (outsize < md->md_out_size) 4855 md->md_out_size = outsize; 4856 if (outdata != NULL) 4857 error = copyout(outdata, md->md_out_data, 4858 md->md_out_size); 4859 } else { 4860 error = EINVAL; 4861 } 4862 bad: 4863 if ((md->md_id & MWL_DIAG_IN) && indata != NULL) 4864 free(indata, M_TEMP); 4865 if ((md->md_id & MWL_DIAG_DYN) && outdata != NULL) 4866 free(outdata, M_TEMP); 4867 return error; 4868 } 4869 4870 static int 4871 mwl_ioctl_reset(struct mwl_softc *sc, struct mwl_diag *md) 4872 { 4873 struct mwl_hal *mh = sc->sc_mh; 4874 int error; 4875 4876 MWL_LOCK_ASSERT(sc); 4877 4878 if (md->md_id == 0 && mwl_hal_fwload(mh, NULL) != 0) { 4879 device_printf(sc->sc_dev, "unable to load firmware\n"); 4880 return EIO; 4881 } 4882 if (mwl_hal_gethwspecs(mh, &sc->sc_hwspecs) != 0) { 4883 device_printf(sc->sc_dev, "unable to fetch h/w specs\n"); 4884 return EIO; 4885 } 4886 error = mwl_setupdma(sc); 4887 if (error != 0) { 4888 /* NB: mwl_setupdma prints a msg */ 4889 return error; 4890 } 4891 /* 4892 * Reset tx/rx data structures; after reload we must 4893 * re-start the driver's notion of the next xmit/recv. 4894 */ 4895 mwl_draintxq(sc); /* clear pending frames */ 4896 mwl_resettxq(sc); /* rebuild tx q lists */ 4897 sc->sc_rxnext = NULL; /* force rx to start at the list head */ 4898 return 0; 4899 } 4900 #endif /* MWL_DIAGAPI */ 4901 4902 static int 4903 mwl_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 4904 { 4905 #define IS_RUNNING(ifp) \ 4906 ((ifp->if_flags & IFF_UP) && (ifp->if_drv_flags & IFF_DRV_RUNNING)) 4907 struct mwl_softc *sc = ifp->if_softc; 4908 struct ieee80211com *ic = ifp->if_l2com; 4909 struct ifreq *ifr = (struct ifreq *)data; 4910 int error = 0, startall; 4911 4912 switch (cmd) { 4913 case SIOCSIFFLAGS: 4914 MWL_LOCK(sc); 4915 startall = 0; 4916 if (IS_RUNNING(ifp)) { 4917 /* 4918 * To avoid rescanning another access point, 4919 * do not call mwl_init() here. Instead, 4920 * only reflect promisc mode settings. 4921 */ 4922 mwl_mode_init(sc); 4923 } else if (ifp->if_flags & IFF_UP) { 4924 /* 4925 * Beware of being called during attach/detach 4926 * to reset promiscuous mode. In that case we 4927 * will still be marked UP but not RUNNING. 4928 * However trying to re-init the interface 4929 * is the wrong thing to do as we've already 4930 * torn down much of our state. There's 4931 * probably a better way to deal with this. 4932 */ 4933 if (!sc->sc_invalid) { 4934 mwl_init_locked(sc); /* XXX lose error */ 4935 startall = 1; 4936 } 4937 } else 4938 mwl_stop_locked(ifp, 1); 4939 MWL_UNLOCK(sc); 4940 if (startall) 4941 ieee80211_start_all(ic); 4942 break; 4943 case SIOCGMVSTATS: 4944 mwl_hal_gethwstats(sc->sc_mh, &sc->sc_stats.hw_stats); 4945 /* NB: embed these numbers to get a consistent view */ 4946 sc->sc_stats.mst_tx_packets = ifp->if_opackets; 4947 sc->sc_stats.mst_rx_packets = ifp->if_ipackets; 4948 /* 4949 * NB: Drop the softc lock in case of a page fault; 4950 * we'll accept any potential inconsisentcy in the 4951 * statistics. The alternative is to copy the data 4952 * to a local structure. 4953 */ 4954 return copyout(&sc->sc_stats, 4955 ifr->ifr_data, sizeof (sc->sc_stats)); 4956 #ifdef MWL_DIAGAPI 4957 case SIOCGMVDIAG: 4958 /* XXX check privs */ 4959 return mwl_ioctl_diag(sc, (struct mwl_diag *) ifr); 4960 case SIOCGMVRESET: 4961 /* XXX check privs */ 4962 MWL_LOCK(sc); 4963 error = mwl_ioctl_reset(sc,(struct mwl_diag *) ifr); 4964 MWL_UNLOCK(sc); 4965 break; 4966 #endif /* MWL_DIAGAPI */ 4967 case SIOCGIFMEDIA: 4968 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd); 4969 break; 4970 case SIOCGIFADDR: 4971 error = ether_ioctl(ifp, cmd, data); 4972 break; 4973 default: 4974 error = EINVAL; 4975 break; 4976 } 4977 return error; 4978 #undef IS_RUNNING 4979 } 4980 4981 #ifdef MWL_DEBUG 4982 static int 4983 mwl_sysctl_debug(SYSCTL_HANDLER_ARGS) 4984 { 4985 struct mwl_softc *sc = arg1; 4986 int debug, error; 4987 4988 debug = sc->sc_debug | (mwl_hal_getdebug(sc->sc_mh) << 24); 4989 error = sysctl_handle_int(oidp, &debug, 0, req); 4990 if (error || !req->newptr) 4991 return error; 4992 mwl_hal_setdebug(sc->sc_mh, debug >> 24); 4993 sc->sc_debug = debug & 0x00ffffff; 4994 return 0; 4995 } 4996 #endif /* MWL_DEBUG */ 4997 4998 static void 4999 mwl_sysctlattach(struct mwl_softc *sc) 5000 { 5001 #ifdef MWL_DEBUG 5002 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev); 5003 struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev); 5004 5005 sc->sc_debug = mwl_debug; 5006 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 5007 "debug", CTLTYPE_INT | CTLFLAG_RW, sc, 0, 5008 mwl_sysctl_debug, "I", "control debugging printfs"); 5009 #endif 5010 } 5011 5012 /* 5013 * Announce various information on device/driver attach. 5014 */ 5015 static void 5016 mwl_announce(struct mwl_softc *sc) 5017 { 5018 struct ifnet *ifp = sc->sc_ifp; 5019 5020 if_printf(ifp, "Rev A%d hardware, v%d.%d.%d.%d firmware (regioncode %d)\n", 5021 sc->sc_hwspecs.hwVersion, 5022 (sc->sc_hwspecs.fwReleaseNumber>>24) & 0xff, 5023 (sc->sc_hwspecs.fwReleaseNumber>>16) & 0xff, 5024 (sc->sc_hwspecs.fwReleaseNumber>>8) & 0xff, 5025 (sc->sc_hwspecs.fwReleaseNumber>>0) & 0xff, 5026 sc->sc_hwspecs.regionCode); 5027 sc->sc_fwrelease = sc->sc_hwspecs.fwReleaseNumber; 5028 5029 if (bootverbose) { 5030 int i; 5031 for (i = 0; i <= WME_AC_VO; i++) { 5032 struct mwl_txq *txq = sc->sc_ac2q[i]; 5033 if_printf(ifp, "Use hw queue %u for %s traffic\n", 5034 txq->qnum, ieee80211_wme_acnames[i]); 5035 } 5036 } 5037 if (bootverbose || mwl_rxdesc != MWL_RXDESC) 5038 if_printf(ifp, "using %u rx descriptors\n", mwl_rxdesc); 5039 if (bootverbose || mwl_rxbuf != MWL_RXBUF) 5040 if_printf(ifp, "using %u rx buffers\n", mwl_rxbuf); 5041 if (bootverbose || mwl_txbuf != MWL_TXBUF) 5042 if_printf(ifp, "using %u tx buffers\n", mwl_txbuf); 5043 if (bootverbose && mwl_hal_ismbsscapable(sc->sc_mh)) 5044 if_printf(ifp, "multi-bss support\n"); 5045 #ifdef MWL_TX_NODROP 5046 if (bootverbose) 5047 if_printf(ifp, "no tx drop\n"); 5048 #endif 5049 } 5050