sys/dev/mwl/if_mwl.c

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