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