sys/dev/malo/if_malo.c

   1 /*-
   2  * Copyright (c) 2008 Weongyo Jeong <weongyo@freebsd.org>
   3  * Copyright (c) 2007 Marvell Semiconductor, Inc.
   4  * Copyright (c) 2007 Sam Leffler, Errno Consulting
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer,
  12  *    without modification.
  13  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  14  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  15  *    redistribution must be conditioned upon including a substantially
  16  *    similar Disclaimer requirement for further binary redistribution.
  17  *
  18  * NO WARRANTY
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  22  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  23  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  24  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  27  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  29  * THE POSSIBILITY OF SUCH DAMAGES.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifdef __FreeBSD__
  34 __FBSDID("$FreeBSD$");
  35 #endif
  36
  37 #include "opt_malo.h"
  38
  39 #include <sys/param.h>
  40 #include <sys/endian.h>
  41 #include <sys/kernel.h>
  42 #include <sys/socket.h>
  43 #include <sys/sockio.h>
  44 #include <sys/sysctl.h>
  45 #include <sys/taskqueue.h>
  46
  47 #include <machine/bus.h>
  48 #include <sys/bus.h>
  49
  50 #include <net/if.h>
  51 #include <net/if_var.h>
  52 #include <net/if_dl.h>
  53 #include <net/if_media.h>
  54 #include <net/if_types.h>
  55 #include <net/ethernet.h>
  56
  57 #include <net80211/ieee80211_var.h>
  58 #include <net80211/ieee80211_regdomain.h>
  59
  60 #include <net/bpf.h>
  61
  62 #include <dev/malo/if_malo.h>
  63
  64 SYSCTL_NODE(_hw, OID_AUTO, malo, CTLFLAG_RD, 0,
  65     "Marvell 88w8335 driver parameters");
  66
  67 static  int malo_txcoalesce = 8;        /* # tx pkts to q before poking f/w*/
  68 SYSCTL_INT(_hw_malo, OID_AUTO, txcoalesce, CTLFLAG_RW, &malo_txcoalesce,
  69             0, "tx buffers to send at once");
  70 TUNABLE_INT("hw.malo.txcoalesce", &malo_txcoalesce);
  71 static  int malo_rxbuf = MALO_RXBUF;            /* # rx buffers to allocate */
  72 SYSCTL_INT(_hw_malo, OID_AUTO, rxbuf, CTLFLAG_RW, &malo_rxbuf,
  73             0, "rx buffers allocated");
  74 TUNABLE_INT("hw.malo.rxbuf", &malo_rxbuf);
  75 static  int malo_rxquota = MALO_RXBUF;          /* # max buffers to process */
  76 SYSCTL_INT(_hw_malo, OID_AUTO, rxquota, CTLFLAG_RW, &malo_rxquota,
  77             0, "max rx buffers to process per interrupt");
  78 TUNABLE_INT("hw.malo.rxquota", &malo_rxquota);
  79 static  int malo_txbuf = MALO_TXBUF;            /* # tx buffers to allocate */
  80 SYSCTL_INT(_hw_malo, OID_AUTO, txbuf, CTLFLAG_RW, &malo_txbuf,
  81             0, "tx buffers allocated");
  82 TUNABLE_INT("hw.malo.txbuf", &malo_txbuf);
  83
  84 #ifdef MALO_DEBUG
  85 static  int malo_debug = 0;
  86 SYSCTL_INT(_hw_malo, OID_AUTO, debug, CTLFLAG_RW, &malo_debug,
  87             0, "control debugging printfs");
  88 TUNABLE_INT("hw.malo.debug", &malo_debug);
  89 enum {
  90         MALO_DEBUG_XMIT         = 0x00000001,   /* basic xmit operation */
  91         MALO_DEBUG_XMIT_DESC    = 0x00000002,   /* xmit descriptors */
  92         MALO_DEBUG_RECV         = 0x00000004,   /* basic recv operation */
  93         MALO_DEBUG_RECV_DESC    = 0x00000008,   /* recv descriptors */
  94         MALO_DEBUG_RESET        = 0x00000010,   /* reset processing */
  95         MALO_DEBUG_INTR         = 0x00000040,   /* ISR */
  96         MALO_DEBUG_TX_PROC      = 0x00000080,   /* tx ISR proc */
  97         MALO_DEBUG_RX_PROC      = 0x00000100,   /* rx ISR proc */
  98         MALO_DEBUG_STATE        = 0x00000400,   /* 802.11 state transitions */
  99         MALO_DEBUG_NODE         = 0x00000800,   /* node management */
 100         MALO_DEBUG_RECV_ALL     = 0x00001000,   /* trace all frames (beacons) */
 101         MALO_DEBUG_FW           = 0x00008000,   /* firmware */
 102         MALO_DEBUG_ANY          = 0xffffffff
 103 };
 104 #define IS_BEACON(wh)                                                   \
 105         ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK |                      \
 106                 IEEE80211_FC0_SUBTYPE_MASK)) ==                         \
 107          (IEEE80211_FC0_TYPE_MGT|IEEE80211_FC0_SUBTYPE_BEACON))
 108 #define IFF_DUMPPKTS_RECV(sc, wh)                                       \
 109         (((sc->malo_debug & MALO_DEBUG_RECV) &&                         \
 110           ((sc->malo_debug & MALO_DEBUG_RECV_ALL) || !IS_BEACON(wh))) || \
 111          (sc->malo_ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) ==            \
 112           (IFF_DEBUG|IFF_LINK2))
 113 #define IFF_DUMPPKTS_XMIT(sc)                                           \
 114         ((sc->malo_debug & MALO_DEBUG_XMIT) ||                          \
 115          (sc->malo_ifp->if_flags & (IFF_DEBUG | IFF_LINK2)) ==          \
 116              (IFF_DEBUG | IFF_LINK2))
 117 #define DPRINTF(sc, m, fmt, ...) do {                           \
 118         if (sc->malo_debug & (m))                               \
 119                 printf(fmt, __VA_ARGS__);                       \
 120 } while (0)
 121 #else
 122 #define DPRINTF(sc, m, fmt, ...) do {                           \
 123         (void) sc;                                              \
 124 } while (0)
 125 #endif
 126
 127 static MALLOC_DEFINE(M_MALODEV, "malodev", "malo driver dma buffers");
 128
 129 static struct ieee80211vap *malo_vap_create(struct ieee80211com *,
 130                     const char [IFNAMSIZ], int, enum ieee80211_opmode, int,
 131                     const uint8_t [IEEE80211_ADDR_LEN],
 132                     const uint8_t [IEEE80211_ADDR_LEN]);
 133 static  void    malo_vap_delete(struct ieee80211vap *);
 134 static  int     malo_dma_setup(struct malo_softc *);
 135 static  int     malo_setup_hwdma(struct malo_softc *);
 136 static  void    malo_txq_init(struct malo_softc *, struct malo_txq *, int);
 137 static  void    malo_tx_cleanupq(struct malo_softc *, struct malo_txq *);
 138 static  void    malo_start(struct ifnet *);
 139 static  void    malo_watchdog(void *);
 140 static  int     malo_ioctl(struct ifnet *, u_long, caddr_t);
 141 static  void    malo_updateslot(struct ifnet *);
 142 static  int     malo_newstate(struct ieee80211vap *, enum ieee80211_state, int);
 143 static  void    malo_scan_start(struct ieee80211com *);
 144 static  void    malo_scan_end(struct ieee80211com *);
 145 static  void    malo_set_channel(struct ieee80211com *);
 146 static  int     malo_raw_xmit(struct ieee80211_node *, struct mbuf *,
 147                     const struct ieee80211_bpf_params *);
 148 static  void    malo_sysctlattach(struct malo_softc *);
 149 static  void    malo_announce(struct malo_softc *);
 150 static  void    malo_dma_cleanup(struct malo_softc *);
 151 static  void    malo_stop_locked(struct ifnet *, int);
 152 static  int     malo_chan_set(struct malo_softc *, struct ieee80211_channel *);
 153 static  int     malo_mode_init(struct malo_softc *);
 154 static  void    malo_tx_proc(void *, int);
 155 static  void    malo_rx_proc(void *, int);
 156 static  void    malo_init(void *);
 157
 158 /*
 159  * Read/Write shorthands for accesses to BAR 0.  Note that all BAR 1
 160  * operations are done in the "hal" except getting H/W MAC address at
 161  * malo_attach and there should be no reference to them here.
 162  */
 163 static uint32_t
 164 malo_bar0_read4(struct malo_softc *sc, bus_size_t off)
 165 {
 166         return bus_space_read_4(sc->malo_io0t, sc->malo_io0h, off);
 167 }
 168
 169 static void
 170 malo_bar0_write4(struct malo_softc *sc, bus_size_t off, uint32_t val)
 171 {
 172         DPRINTF(sc, MALO_DEBUG_FW, "%s: off 0x%jx val 0x%x\n",
 173             __func__, (intmax_t)off, val);
 174
 175         bus_space_write_4(sc->malo_io0t, sc->malo_io0h, off, val);
 176 }
 177
 178 int
 179 malo_attach(uint16_t devid, struct malo_softc *sc)
 180 {
 181         int error;
 182         struct ieee80211com *ic;
 183         struct ifnet *ifp;
 184         struct malo_hal *mh;
 185         uint8_t bands;
 186
 187         ifp = sc->malo_ifp = if_alloc(IFT_IEEE80211);
 188         if (ifp == NULL) {
 189                 device_printf(sc->malo_dev, "can not if_alloc()\n");
 190                 return ENOSPC;
 191         }
 192         ic = ifp->if_l2com;
 193
 194         MALO_LOCK_INIT(sc);
 195         callout_init_mtx(&sc->malo_watchdog_timer, &sc->malo_mtx, 0);
 196
 197         /* set these up early for if_printf use */
 198         if_initname(ifp, device_get_name(sc->malo_dev),
 199             device_get_unit(sc->malo_dev));
 200
 201         mh = malo_hal_attach(sc->malo_dev, devid,
 202             sc->malo_io1h, sc->malo_io1t, sc->malo_dmat);
 203         if (mh == NULL) {
 204                 if_printf(ifp, "unable to attach HAL\n");
 205                 error = EIO;
 206                 goto bad;
 207         }
 208         sc->malo_mh = mh;
 209
 210         /*
 211          * Load firmware so we can get setup.  We arbitrarily pick station
 212          * firmware; we'll re-load firmware as needed so setting up
 213          * the wrong mode isn't a big deal.
 214          */
 215         error = malo_hal_fwload(mh, "malo8335-h", "malo8335-m");
 216         if (error != 0) {
 217                 if_printf(ifp, "unable to setup firmware\n");
 218                 goto bad1;
 219         }
 220         /* XXX gethwspecs() extracts correct informations?  not maybe!  */
 221         error = malo_hal_gethwspecs(mh, &sc->malo_hwspecs);
 222         if (error != 0) {
 223                 if_printf(ifp, "unable to fetch h/w specs\n");
 224                 goto bad1;
 225         }
 226
 227         DPRINTF(sc, MALO_DEBUG_FW,
 228             "malo_hal_gethwspecs: hwversion 0x%x hostif 0x%x"
 229             "maxnum_wcb 0x%x maxnum_mcaddr 0x%x maxnum_tx_wcb 0x%x"
 230             "regioncode 0x%x num_antenna 0x%x fw_releasenum 0x%x"
 231             "wcbbase0 0x%x rxdesc_read 0x%x rxdesc_write 0x%x"
 232             "ul_fw_awakecookie 0x%x w[4] = %x %x %x %x",
 233             sc->malo_hwspecs.hwversion,
 234             sc->malo_hwspecs.hostinterface, sc->malo_hwspecs.maxnum_wcb,
 235             sc->malo_hwspecs.maxnum_mcaddr, sc->malo_hwspecs.maxnum_tx_wcb,
 236             sc->malo_hwspecs.regioncode, sc->malo_hwspecs.num_antenna,
 237             sc->malo_hwspecs.fw_releasenum, sc->malo_hwspecs.wcbbase0,
 238             sc->malo_hwspecs.rxdesc_read, sc->malo_hwspecs.rxdesc_write,
 239             sc->malo_hwspecs.ul_fw_awakecookie,
 240             sc->malo_hwspecs.wcbbase[0], sc->malo_hwspecs.wcbbase[1],
 241             sc->malo_hwspecs.wcbbase[2], sc->malo_hwspecs.wcbbase[3]);
 242
 243         /* NB: firmware looks that it does not export regdomain info API.  */
 244         bands = 0;
 245         setbit(&bands, IEEE80211_MODE_11B);
 246         setbit(&bands, IEEE80211_MODE_11G);
 247         ieee80211_init_channels(ic, NULL, &bands);
 248
 249         sc->malo_txantenna = 0x2;       /* h/w default */
 250         sc->malo_rxantenna = 0xffff;    /* h/w default */
 251
 252         /*
 253          * Allocate tx + rx descriptors and populate the lists.
 254          * We immediately push the information to the firmware
 255          * as otherwise it gets upset.
 256          */
 257         error = malo_dma_setup(sc);
 258         if (error != 0) {
 259                 if_printf(ifp, "failed to setup descriptors: %d\n", error);
 260                 goto bad1;
 261         }
 262         error = malo_setup_hwdma(sc);   /* push to firmware */
 263         if (error != 0)                 /* NB: malo_setupdma prints msg */
 264                 goto bad2;
 265
 266         sc->malo_tq = taskqueue_create_fast("malo_taskq", M_NOWAIT,
 267                 taskqueue_thread_enqueue, &sc->malo_tq);
 268         taskqueue_start_threads(&sc->malo_tq, 1, PI_NET,
 269                 "%s taskq", ifp->if_xname);
 270
 271         TASK_INIT(&sc->malo_rxtask, 0, malo_rx_proc, sc);
 272         TASK_INIT(&sc->malo_txtask, 0, malo_tx_proc, sc);
 273
 274         ifp->if_softc = sc;
 275         ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
 276         ifp->if_start = malo_start;
 277         ifp->if_ioctl = malo_ioctl;
 278         ifp->if_init = malo_init;
 279         IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
 280         ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
 281         IFQ_SET_READY(&ifp->if_snd);
 282
 283         ic->ic_ifp = ifp;
 284         /* XXX not right but it's not used anywhere important */
 285         ic->ic_phytype = IEEE80211_T_OFDM;
 286         ic->ic_opmode = IEEE80211_M_STA;
 287         ic->ic_caps =
 288               IEEE80211_C_STA                   /* station mode supported */
 289             | IEEE80211_C_BGSCAN                /* capable of bg scanning */
 290             | IEEE80211_C_MONITOR               /* monitor mode */
 291             | IEEE80211_C_SHPREAMBLE            /* short preamble supported */
 292             | IEEE80211_C_SHSLOT                /* short slot time supported */
 293             | IEEE80211_C_TXPMGT                /* capable of txpow mgt */
 294             | IEEE80211_C_WPA                   /* capable of WPA1+WPA2 */
 295             ;
 296
 297         /*
 298          * Transmit requires space in the packet for a special format transmit
 299          * record and optional padding between this record and the payload.
 300          * Ask the net80211 layer to arrange this when encapsulating
 301          * packets so we can add it efficiently.
 302          */
 303         ic->ic_headroom = sizeof(struct malo_txrec) -
 304                 sizeof(struct ieee80211_frame);
 305
 306         /* call MI attach routine. */
 307         ieee80211_ifattach(ic, sc->malo_hwspecs.macaddr);
 308         /* override default methods */
 309         ic->ic_vap_create = malo_vap_create;
 310         ic->ic_vap_delete = malo_vap_delete;
 311         ic->ic_raw_xmit = malo_raw_xmit;
 312         ic->ic_updateslot = malo_updateslot;
 313
 314         ic->ic_scan_start = malo_scan_start;
 315         ic->ic_scan_end = malo_scan_end;
 316         ic->ic_set_channel = malo_set_channel;
 317
 318         sc->malo_invalid = 0;           /* ready to go, enable int handling */
 319
 320         ieee80211_radiotap_attach(ic,
 321             &sc->malo_tx_th.wt_ihdr, sizeof(sc->malo_tx_th),
 322                 MALO_TX_RADIOTAP_PRESENT,
 323             &sc->malo_rx_th.wr_ihdr, sizeof(sc->malo_rx_th),
 324                 MALO_RX_RADIOTAP_PRESENT);
 325
 326         /*
 327          * Setup dynamic sysctl's.
 328          */
 329         malo_sysctlattach(sc);
 330
 331         if (bootverbose)
 332                 ieee80211_announce(ic);
 333         malo_announce(sc);
 334
 335         return 0;
 336 bad2:
 337         malo_dma_cleanup(sc);
 338 bad1:
 339         malo_hal_detach(mh);
 340 bad:
 341         if_free(ifp);
 342         sc->malo_invalid = 1;
 343
 344         return error;
 345 }
 346
 347 static struct ieee80211vap *
 348 malo_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit,
 349     enum ieee80211_opmode opmode, int flags,
 350     const uint8_t bssid[IEEE80211_ADDR_LEN],
 351     const uint8_t mac[IEEE80211_ADDR_LEN])
 352 {
 353         struct ifnet *ifp = ic->ic_ifp;
 354         struct malo_vap *mvp;
 355         struct ieee80211vap *vap;
 356
 357         if (!TAILQ_EMPTY(&ic->ic_vaps)) {
 358                 if_printf(ifp, "multiple vaps not supported\n");
 359                 return NULL;
 360         }
 361         switch (opmode) {
 362         case IEEE80211_M_STA:
 363                 if (opmode == IEEE80211_M_STA)
 364                         flags |= IEEE80211_CLONE_NOBEACONS;
 365                 /* fall thru... */
 366         case IEEE80211_M_MONITOR:
 367                 break;
 368         default:
 369                 if_printf(ifp, "%s mode not supported\n",
 370                     ieee80211_opmode_name[opmode]);
 371                 return NULL;            /* unsupported */
 372         }
 373         mvp = (struct malo_vap *) malloc(sizeof(struct malo_vap),
 374             M_80211_VAP, M_NOWAIT | M_ZERO);
 375         if (mvp == NULL) {
 376                 if_printf(ifp, "cannot allocate vap state block\n");
 377                 return NULL;
 378         }
 379         vap = &mvp->malo_vap;
 380         ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac);
 381
 382         /* override state transition machine */
 383         mvp->malo_newstate = vap->iv_newstate;
 384         vap->iv_newstate = malo_newstate;
 385
 386         /* complete setup */
 387         ieee80211_vap_attach(vap,
 388             ieee80211_media_change, ieee80211_media_status);
 389         ic->ic_opmode = opmode;
 390         return vap;
 391 }
 392
 393 static void
 394 malo_vap_delete(struct ieee80211vap *vap)
 395 {
 396         struct malo_vap *mvp = MALO_VAP(vap);
 397
 398         ieee80211_vap_detach(vap);
 399         free(mvp, M_80211_VAP);
 400 }
 401
 402 int
 403 malo_intr(void *arg)
 404 {
 405         struct malo_softc *sc = arg;
 406         struct malo_hal *mh = sc->malo_mh;
 407         uint32_t status;
 408
 409         if (sc->malo_invalid) {
 410                 /*
 411                  * The hardware is not ready/present, don't touch anything.
 412                  * Note this can happen early on if the IRQ is shared.
 413                  */
 414                 DPRINTF(sc, MALO_DEBUG_ANY, "%s: invalid; ignored\n", __func__);
 415                 return (FILTER_STRAY);
 416         }
 417
 418         /*
 419          * Figure out the reason(s) for the interrupt.
 420          */
 421         malo_hal_getisr(mh, &status);           /* NB: clears ISR too */
 422         if (status == 0)                        /* must be a shared irq */
 423                 return (FILTER_STRAY);
 424
 425         DPRINTF(sc, MALO_DEBUG_INTR, "%s: status 0x%x imask 0x%x\n",
 426             __func__, status, sc->malo_imask);
 427
 428         if (status & MALO_A2HRIC_BIT_RX_RDY)
 429                 taskqueue_enqueue_fast(sc->malo_tq, &sc->malo_rxtask);
 430         if (status & MALO_A2HRIC_BIT_TX_DONE)
 431                 taskqueue_enqueue_fast(sc->malo_tq, &sc->malo_txtask);
 432         if (status & MALO_A2HRIC_BIT_OPC_DONE)
 433                 malo_hal_cmddone(mh);
 434         if (status & MALO_A2HRIC_BIT_MAC_EVENT)
 435                 ;
 436         if (status & MALO_A2HRIC_BIT_RX_PROBLEM)
 437                 ;
 438         if (status & MALO_A2HRIC_BIT_ICV_ERROR) {
 439                 /* TKIP ICV error */
 440                 sc->malo_stats.mst_rx_badtkipicv++;
 441         }
 442 #ifdef MALO_DEBUG
 443         if (((status | sc->malo_imask) ^ sc->malo_imask) != 0)
 444                 DPRINTF(sc, MALO_DEBUG_INTR,
 445                     "%s: can't handle interrupt status 0x%x\n",
 446                     __func__, status);
 447 #endif
 448         return (FILTER_HANDLED);
 449 }
 450
 451 static void
 452 malo_load_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
 453 {
 454         bus_addr_t *paddr = (bus_addr_t*) arg;
 455
 456         KASSERT(error == 0, ("error %u on bus_dma callback", error));
 457
 458         *paddr = segs->ds_addr;
 459 }
 460
 461 static int
 462 malo_desc_setup(struct malo_softc *sc, const char *name,
 463     struct malo_descdma *dd,
 464     int nbuf, size_t bufsize, int ndesc, size_t descsize)
 465 {
 466         int error;
 467         struct ifnet *ifp = sc->malo_ifp;
 468         uint8_t *ds;
 469
 470         DPRINTF(sc, MALO_DEBUG_RESET,
 471             "%s: %s DMA: %u bufs (%ju) %u desc/buf (%ju)\n",
 472             __func__, name, nbuf, (uintmax_t) bufsize,
 473             ndesc, (uintmax_t) descsize);
 474
 475         dd->dd_name = name;
 476         dd->dd_desc_len = nbuf * ndesc * descsize;
 477
 478         /*
 479          * Setup DMA descriptor area.
 480          */
 481         error = bus_dma_tag_create(bus_get_dma_tag(sc->malo_dev),/* parent */
 482                        PAGE_SIZE, 0,            /* alignment, bounds */
 483                        BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
 484                        BUS_SPACE_MAXADDR,       /* highaddr */
 485                        NULL, NULL,              /* filter, filterarg */
 486                        dd->dd_desc_len,         /* maxsize */
 487                        1,                       /* nsegments */
 488                        dd->dd_desc_len,         /* maxsegsize */
 489                        BUS_DMA_ALLOCNOW,        /* flags */
 490                        NULL,                    /* lockfunc */
 491                        NULL,                    /* lockarg */
 492                        &dd->dd_dmat);
 493         if (error != 0) {
 494                 if_printf(ifp, "cannot allocate %s DMA tag\n", dd->dd_name);
 495                 return error;
 496         }
 497
 498         /* allocate descriptors */
 499         error = bus_dmamap_create(dd->dd_dmat, BUS_DMA_NOWAIT, &dd->dd_dmamap);
 500         if (error != 0) {
 501                 if_printf(ifp, "unable to create dmamap for %s descriptors, "
 502                     "error %u\n", dd->dd_name, error);
 503                 goto fail0;
 504         }
 505
 506         error = bus_dmamem_alloc(dd->dd_dmat, (void**) &dd->dd_desc,
 507             BUS_DMA_NOWAIT | BUS_DMA_COHERENT, &dd->dd_dmamap);
 508         if (error != 0) {
 509                 if_printf(ifp, "unable to alloc memory for %u %s descriptors, "
 510                     "error %u\n", nbuf * ndesc, dd->dd_name, error);
 511                 goto fail1;
 512         }
 513
 514         error = bus_dmamap_load(dd->dd_dmat, dd->dd_dmamap,
 515             dd->dd_desc, dd->dd_desc_len,
 516             malo_load_cb, &dd->dd_desc_paddr, BUS_DMA_NOWAIT);
 517         if (error != 0) {
 518                 if_printf(ifp, "unable to map %s descriptors, error %u\n",
 519                     dd->dd_name, error);
 520                 goto fail2;
 521         }
 522
 523         ds = dd->dd_desc;
 524         memset(ds, 0, dd->dd_desc_len);
 525         DPRINTF(sc, MALO_DEBUG_RESET, "%s: %s DMA map: %p (%lu) -> %p (%lu)\n",
 526             __func__, dd->dd_name, ds, (u_long) dd->dd_desc_len,
 527             (caddr_t) dd->dd_desc_paddr, /*XXX*/ (u_long) dd->dd_desc_len);
 528
 529         return 0;
 530 fail2:
 531         bus_dmamem_free(dd->dd_dmat, dd->dd_desc, dd->dd_dmamap);
 532 fail1:
 533         bus_dmamap_destroy(dd->dd_dmat, dd->dd_dmamap);
 534 fail0:
 535         bus_dma_tag_destroy(dd->dd_dmat);
 536         memset(dd, 0, sizeof(*dd));
 537         return error;
 538 }
 539
 540 #define DS2PHYS(_dd, _ds) \
 541         ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc))
 542
 543 static int
 544 malo_rxdma_setup(struct malo_softc *sc)
 545 {
 546         struct ifnet *ifp = sc->malo_ifp;
 547         int error, bsize, i;
 548         struct malo_rxbuf *bf;
 549         struct malo_rxdesc *ds;
 550
 551         error = malo_desc_setup(sc, "rx", &sc->malo_rxdma,
 552             malo_rxbuf, sizeof(struct malo_rxbuf),
 553             1, sizeof(struct malo_rxdesc));
 554         if (error != 0)
 555                 return error;
 556
 557         /*
 558          * Allocate rx buffers and set them up.
 559          */
 560         bsize = malo_rxbuf * sizeof(struct malo_rxbuf);
 561         bf = malloc(bsize, M_MALODEV, M_NOWAIT | M_ZERO);
 562         if (bf == NULL) {
 563                 if_printf(ifp, "malloc of %u rx buffers failed\n", bsize);
 564                 return error;
 565         }
 566         sc->malo_rxdma.dd_bufptr = bf;
 567
 568         STAILQ_INIT(&sc->malo_rxbuf);
 569         ds = sc->malo_rxdma.dd_desc;
 570         for (i = 0; i < malo_rxbuf; i++, bf++, ds++) {
 571                 bf->bf_desc = ds;
 572                 bf->bf_daddr = DS2PHYS(&sc->malo_rxdma, ds);
 573                 error = bus_dmamap_create(sc->malo_dmat, BUS_DMA_NOWAIT,
 574                     &bf->bf_dmamap);
 575                 if (error != 0) {
 576                         if_printf(ifp, "%s: unable to dmamap for rx buffer, "
 577                             "error %d\n", __func__, error);
 578                         return error;
 579                 }
 580                 /* NB: tail is intentional to preserve descriptor order */
 581                 STAILQ_INSERT_TAIL(&sc->malo_rxbuf, bf, bf_list);
 582         }
 583         return 0;
 584 }
 585
 586 static int
 587 malo_txdma_setup(struct malo_softc *sc, struct malo_txq *txq)
 588 {
 589         struct ifnet *ifp = sc->malo_ifp;
 590         int error, bsize, i;
 591         struct malo_txbuf *bf;
 592         struct malo_txdesc *ds;
 593
 594         error = malo_desc_setup(sc, "tx", &txq->dma,
 595             malo_txbuf, sizeof(struct malo_txbuf),
 596             MALO_TXDESC, sizeof(struct malo_txdesc));
 597         if (error != 0)
 598                 return error;
 599
 600         /* allocate and setup tx buffers */
 601         bsize = malo_txbuf * sizeof(struct malo_txbuf);
 602         bf = malloc(bsize, M_MALODEV, M_NOWAIT | M_ZERO);
 603         if (bf == NULL) {
 604                 if_printf(ifp, "malloc of %u tx buffers failed\n",
 605                     malo_txbuf);
 606                 return ENOMEM;
 607         }
 608         txq->dma.dd_bufptr = bf;
 609
 610         STAILQ_INIT(&txq->free);
 611         txq->nfree = 0;
 612         ds = txq->dma.dd_desc;
 613         for (i = 0; i < malo_txbuf; i++, bf++, ds += MALO_TXDESC) {
 614                 bf->bf_desc = ds;
 615                 bf->bf_daddr = DS2PHYS(&txq->dma, ds);
 616                 error = bus_dmamap_create(sc->malo_dmat, BUS_DMA_NOWAIT,
 617                     &bf->bf_dmamap);
 618                 if (error != 0) {
 619                         if_printf(ifp, "unable to create dmamap for tx "
 620                             "buffer %u, error %u\n", i, error);
 621                         return error;
 622                 }
 623                 STAILQ_INSERT_TAIL(&txq->free, bf, bf_list);
 624                 txq->nfree++;
 625         }
 626
 627         return 0;
 628 }
 629
 630 static void
 631 malo_desc_cleanup(struct malo_softc *sc, struct malo_descdma *dd)
 632 {
 633         bus_dmamap_unload(dd->dd_dmat, dd->dd_dmamap);
 634         bus_dmamem_free(dd->dd_dmat, dd->dd_desc, dd->dd_dmamap);
 635         bus_dmamap_destroy(dd->dd_dmat, dd->dd_dmamap);
 636         bus_dma_tag_destroy(dd->dd_dmat);
 637
 638         memset(dd, 0, sizeof(*dd));
 639 }
 640
 641 static void
 642 malo_rxdma_cleanup(struct malo_softc *sc)
 643 {
 644         struct malo_rxbuf *bf;
 645
 646         STAILQ_FOREACH(bf, &sc->malo_rxbuf, bf_list) {
 647                 if (bf->bf_m != NULL) {
 648                         m_freem(bf->bf_m);
 649                         bf->bf_m = NULL;
 650                 }
 651                 if (bf->bf_dmamap != NULL) {
 652                         bus_dmamap_destroy(sc->malo_dmat, bf->bf_dmamap);
 653                         bf->bf_dmamap = NULL;
 654                 }
 655         }
 656         STAILQ_INIT(&sc->malo_rxbuf);
 657         if (sc->malo_rxdma.dd_bufptr != NULL) {
 658                 free(sc->malo_rxdma.dd_bufptr, M_MALODEV);
 659                 sc->malo_rxdma.dd_bufptr = NULL;
 660         }
 661         if (sc->malo_rxdma.dd_desc_len != 0)
 662                 malo_desc_cleanup(sc, &sc->malo_rxdma);
 663 }
 664
 665 static void
 666 malo_txdma_cleanup(struct malo_softc *sc, struct malo_txq *txq)
 667 {
 668         struct malo_txbuf *bf;
 669         struct ieee80211_node *ni;
 670
 671         STAILQ_FOREACH(bf, &txq->free, bf_list) {
 672                 if (bf->bf_m != NULL) {
 673                         m_freem(bf->bf_m);
 674                         bf->bf_m = NULL;
 675                 }
 676                 ni = bf->bf_node;
 677                 bf->bf_node = NULL;
 678                 if (ni != NULL) {
 679                         /*
 680                          * Reclaim node reference.
 681                          */
 682                         ieee80211_free_node(ni);
 683                 }
 684                 if (bf->bf_dmamap != NULL) {
 685                         bus_dmamap_destroy(sc->malo_dmat, bf->bf_dmamap);
 686                         bf->bf_dmamap = NULL;
 687                 }
 688         }
 689         STAILQ_INIT(&txq->free);
 690         txq->nfree = 0;
 691         if (txq->dma.dd_bufptr != NULL) {
 692                 free(txq->dma.dd_bufptr, M_MALODEV);
 693                 txq->dma.dd_bufptr = NULL;
 694         }
 695         if (txq->dma.dd_desc_len != 0)
 696                 malo_desc_cleanup(sc, &txq->dma);
 697 }
 698
 699 static void
 700 malo_dma_cleanup(struct malo_softc *sc)
 701 {
 702         int i;
 703
 704         for (i = 0; i < MALO_NUM_TX_QUEUES; i++)
 705                 malo_txdma_cleanup(sc, &sc->malo_txq[i]);
 706
 707         malo_rxdma_cleanup(sc);
 708 }
 709
 710 static int
 711 malo_dma_setup(struct malo_softc *sc)
 712 {
 713         int error, i;
 714
 715         /* rxdma initializing.  */
 716         error = malo_rxdma_setup(sc);
 717         if (error != 0)
 718                 return error;
 719
 720         /* NB: we just have 1 tx queue now.  */
 721         for (i = 0; i < MALO_NUM_TX_QUEUES; i++) {
 722                 error = malo_txdma_setup(sc, &sc->malo_txq[i]);
 723                 if (error != 0) {
 724                         malo_dma_cleanup(sc);
 725
 726                         return error;
 727                 }
 728
 729                 malo_txq_init(sc, &sc->malo_txq[i], i);
 730         }
 731
 732         return 0;
 733 }
 734
 735 static void
 736 malo_hal_set_rxtxdma(struct malo_softc *sc)
 737 {
 738         int i;
 739
 740         malo_bar0_write4(sc, sc->malo_hwspecs.rxdesc_read,
 741             sc->malo_hwdma.rxdesc_read);
 742         malo_bar0_write4(sc, sc->malo_hwspecs.rxdesc_write,
 743             sc->malo_hwdma.rxdesc_read);
 744
 745         for (i = 0; i < MALO_NUM_TX_QUEUES; i++) {
 746                 malo_bar0_write4(sc,
 747                     sc->malo_hwspecs.wcbbase[i], sc->malo_hwdma.wcbbase[i]);
 748         }
 749 }
 750
 751 /*
 752  * Inform firmware of our tx/rx dma setup.  The BAR 0 writes below are
 753  * for compatibility with older firmware.  For current firmware we send
 754  * this information with a cmd block via malo_hal_sethwdma.
 755  */
 756 static int
 757 malo_setup_hwdma(struct malo_softc *sc)
 758 {
 759         int i;
 760         struct malo_txq *txq;
 761
 762         sc->malo_hwdma.rxdesc_read = sc->malo_rxdma.dd_desc_paddr;
 763
 764         for (i = 0; i < MALO_NUM_TX_QUEUES; i++) {
 765                 txq = &sc->malo_txq[i];
 766                 sc->malo_hwdma.wcbbase[i] = txq->dma.dd_desc_paddr;
 767         }
 768         sc->malo_hwdma.maxnum_txwcb = malo_txbuf;
 769         sc->malo_hwdma.maxnum_wcb = MALO_NUM_TX_QUEUES;
 770
 771         malo_hal_set_rxtxdma(sc);
 772
 773         return 0;
 774 }
 775
 776 static void
 777 malo_txq_init(struct malo_softc *sc, struct malo_txq *txq, int qnum)
 778 {
 779         struct malo_txbuf *bf, *bn;
 780         struct malo_txdesc *ds;
 781
 782         MALO_TXQ_LOCK_INIT(sc, txq);
 783         txq->qnum = qnum;
 784         txq->txpri = 0; /* XXX */
 785
 786         STAILQ_FOREACH(bf, &txq->free, bf_list) {
 787                 bf->bf_txq = txq;
 788
 789                 ds = bf->bf_desc;
 790                 bn = STAILQ_NEXT(bf, bf_list);
 791                 if (bn == NULL)
 792                         bn = STAILQ_FIRST(&txq->free);
 793                 ds->physnext = htole32(bn->bf_daddr);
 794         }
 795         STAILQ_INIT(&txq->active);
 796 }
 797
 798 /*
 799  * Reclaim resources for a setup queue.
 800  */
 801 static void
 802 malo_tx_cleanupq(struct malo_softc *sc, struct malo_txq *txq)
 803 {
 804         /* XXX hal work? */
 805         MALO_TXQ_LOCK_DESTROY(txq);
 806 }
 807
 808 /*
 809  * Allocate a tx buffer for sending a frame.
 810  */
 811 static struct malo_txbuf *
 812 malo_getbuf(struct malo_softc *sc, struct malo_txq *txq)
 813 {
 814         struct malo_txbuf *bf;
 815
 816         MALO_TXQ_LOCK(txq);
 817         bf = STAILQ_FIRST(&txq->free);
 818         if (bf != NULL) {
 819                 STAILQ_REMOVE_HEAD(&txq->free, bf_list);
 820                 txq->nfree--;
 821         }
 822         MALO_TXQ_UNLOCK(txq);
 823         if (bf == NULL) {
 824                 DPRINTF(sc, MALO_DEBUG_XMIT,
 825                     "%s: out of xmit buffers on q %d\n", __func__, txq->qnum);
 826                 sc->malo_stats.mst_tx_qstop++;
 827         }
 828         return bf;
 829 }
 830
 831 static int
 832 malo_tx_dmasetup(struct malo_softc *sc, struct malo_txbuf *bf, struct mbuf *m0)
 833 {
 834         struct mbuf *m;
 835         int error;
 836
 837         /*
 838          * Load the DMA map so any coalescing is done.  This also calculates
 839          * the number of descriptors we need.
 840          */
 841         error = bus_dmamap_load_mbuf_sg(sc->malo_dmat, bf->bf_dmamap, m0,
 842                                      bf->bf_segs, &bf->bf_nseg,
 843                                      BUS_DMA_NOWAIT);
 844         if (error == EFBIG) {
 845                 /* XXX packet requires too many descriptors */
 846                 bf->bf_nseg = MALO_TXDESC + 1;
 847         } else if (error != 0) {
 848                 sc->malo_stats.mst_tx_busdma++;
 849                 m_freem(m0);
 850                 return error;
 851         }
 852         /*
 853          * Discard null packets and check for packets that require too many
 854          * TX descriptors.  We try to convert the latter to a cluster.
 855          */
 856         if (error == EFBIG) {           /* too many desc's, linearize */
 857                 sc->malo_stats.mst_tx_linear++;
 858                 m = m_defrag(m0, M_NOWAIT);
 859                 if (m == NULL) {
 860                         m_freem(m0);
 861                         sc->malo_stats.mst_tx_nombuf++;
 862                         return ENOMEM;
 863                 }
 864                 m0 = m;
 865                 error = bus_dmamap_load_mbuf_sg(sc->malo_dmat, bf->bf_dmamap, m0,
 866                                              bf->bf_segs, &bf->bf_nseg,
 867                                              BUS_DMA_NOWAIT);
 868                 if (error != 0) {
 869                         sc->malo_stats.mst_tx_busdma++;
 870                         m_freem(m0);
 871                         return error;
 872                 }
 873                 KASSERT(bf->bf_nseg <= MALO_TXDESC,
 874                     ("too many segments after defrag; nseg %u", bf->bf_nseg));
 875         } else if (bf->bf_nseg == 0) {          /* null packet, discard */
 876                 sc->malo_stats.mst_tx_nodata++;
 877                 m_freem(m0);
 878                 return EIO;
 879         }
 880         DPRINTF(sc, MALO_DEBUG_XMIT, "%s: m %p len %u\n",
 881                 __func__, m0, m0->m_pkthdr.len);
 882         bus_dmamap_sync(sc->malo_dmat, bf->bf_dmamap, BUS_DMASYNC_PREWRITE);
 883         bf->bf_m = m0;
 884
 885         return 0;
 886 }
 887
 888 #ifdef MALO_DEBUG
 889 static void
 890 malo_printrxbuf(const struct malo_rxbuf *bf, u_int ix)
 891 {
 892         const struct malo_rxdesc *ds = bf->bf_desc;
 893         uint32_t status = le32toh(ds->status);
 894
 895         printf("R[%2u] (DS.V:%p DS.P:%p) NEXT:%08x DATA:%08x RC:%02x%s\n"
 896             "      STAT:%02x LEN:%04x SNR:%02x NF:%02x CHAN:%02x"
 897             " RATE:%02x QOS:%04x\n",
 898             ix, ds, (const struct malo_desc *)bf->bf_daddr,
 899             le32toh(ds->physnext), le32toh(ds->physbuffdata),
 900             ds->rxcontrol,
 901             ds->rxcontrol != MALO_RXD_CTRL_DRIVER_OWN ?
 902                 "" : (status & MALO_RXD_STATUS_OK) ? " *" : " !",
 903             ds->status, le16toh(ds->pktlen), ds->snr, ds->nf, ds->channel,
 904             ds->rate, le16toh(ds->qosctrl));
 905 }
 906
 907 static void
 908 malo_printtxbuf(const struct malo_txbuf *bf, u_int qnum, u_int ix)
 909 {
 910         const struct malo_txdesc *ds = bf->bf_desc;
 911         uint32_t status = le32toh(ds->status);
 912
 913         printf("Q%u[%3u]", qnum, ix);
 914         printf(" (DS.V:%p DS.P:%p)\n",
 915             ds, (const struct malo_txdesc *)bf->bf_daddr);
 916         printf("    NEXT:%08x DATA:%08x LEN:%04x STAT:%08x%s\n",
 917             le32toh(ds->physnext),
 918             le32toh(ds->pktptr), le16toh(ds->pktlen), status,
 919             status & MALO_TXD_STATUS_USED ?
 920             "" : (status & 3) != 0 ? " *" : " !");
 921         printf("    RATE:%02x PRI:%x QOS:%04x SAP:%08x FORMAT:%04x\n",
 922             ds->datarate, ds->txpriority, le16toh(ds->qosctrl),
 923             le32toh(ds->sap_pktinfo), le16toh(ds->format));
 924 #if 0
 925         {
 926                 const uint8_t *cp = (const uint8_t *) ds;
 927                 int i;
 928                 for (i = 0; i < sizeof(struct malo_txdesc); i++) {
 929                         printf("%02x ", cp[i]);
 930                         if (((i+1) % 16) == 0)
 931                                 printf("\n");
 932                 }
 933                 printf("\n");
 934         }
 935 #endif
 936 }
 937 #endif /* MALO_DEBUG */
 938
 939 static __inline void
 940 malo_updatetxrate(struct ieee80211_node *ni, int rix)
 941 {
 942 #define N(x)    (sizeof(x)/sizeof(x[0]))
 943         static const int ieeerates[] =
 944             { 2, 4, 11, 22, 44, 12, 18, 24, 36, 48, 96, 108 };
 945         if (rix < N(ieeerates))
 946                 ni->ni_txrate = ieeerates[rix];
 947 #undef N
 948 }
 949
 950 static int
 951 malo_fix2rate(int fix_rate)
 952 {
 953 #define N(x)    (sizeof(x)/sizeof(x[0]))
 954         static const int rates[] =
 955             { 2, 4, 11, 22, 12, 18, 24, 36, 48, 96, 108 };
 956         return (fix_rate < N(rates) ? rates[fix_rate] : 0);
 957 #undef N
 958 }
 959
 960 /* idiomatic shorthands: MS = mask+shift, SM = shift+mask */
 961 #define MS(v,x)                 (((v) & x) >> x##_S)
 962 #define SM(v,x)                 (((v) << x##_S) & x)
 963
 964 /*
 965  * Process completed xmit descriptors from the specified queue.
 966  */
 967 static int
 968 malo_tx_processq(struct malo_softc *sc, struct malo_txq *txq)
 969 {
 970         struct malo_txbuf *bf;
 971         struct malo_txdesc *ds;
 972         struct ieee80211_node *ni;
 973         int nreaped;
 974         uint32_t status;
 975
 976         DPRINTF(sc, MALO_DEBUG_TX_PROC, "%s: tx queue %u\n",
 977             __func__, txq->qnum);
 978         for (nreaped = 0;; nreaped++) {
 979                 MALO_TXQ_LOCK(txq);
 980                 bf = STAILQ_FIRST(&txq->active);
 981                 if (bf == NULL) {
 982                         MALO_TXQ_UNLOCK(txq);
 983                         break;
 984                 }
 985                 ds = bf->bf_desc;
 986                 MALO_TXDESC_SYNC(txq, ds,
 987                     BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
 988                 if (ds->status & htole32(MALO_TXD_STATUS_FW_OWNED)) {
 989                         MALO_TXQ_UNLOCK(txq);
 990                         break;
 991                 }
 992                 STAILQ_REMOVE_HEAD(&txq->active, bf_list);
 993                 MALO_TXQ_UNLOCK(txq);
 994
 995 #ifdef MALO_DEBUG
 996                 if (sc->malo_debug & MALO_DEBUG_XMIT_DESC)
 997                         malo_printtxbuf(bf, txq->qnum, nreaped);
 998 #endif
 999                 ni = bf->bf_node;
1000                 if (ni != NULL) {
1001                         status = le32toh(ds->status);
1002                         if (status & MALO_TXD_STATUS_OK) {
1003                                 uint16_t format = le16toh(ds->format);
1004                                 uint8_t txant = MS(format, MALO_TXD_ANTENNA);
1005
1006                                 sc->malo_stats.mst_ant_tx[txant]++;
1007                                 if (status & MALO_TXD_STATUS_OK_RETRY)
1008                                         sc->malo_stats.mst_tx_retries++;
1009                                 if (status & MALO_TXD_STATUS_OK_MORE_RETRY)
1010                                         sc->malo_stats.mst_tx_mretries++;
1011                                 malo_updatetxrate(ni, ds->datarate);
1012                                 sc->malo_stats.mst_tx_rate = ds->datarate;
1013                         } else {
1014                                 if (status & MALO_TXD_STATUS_FAILED_LINK_ERROR)
1015                                         sc->malo_stats.mst_tx_linkerror++;
1016                                 if (status & MALO_TXD_STATUS_FAILED_XRETRY)
1017                                         sc->malo_stats.mst_tx_xretries++;
1018                                 if (status & MALO_TXD_STATUS_FAILED_AGING)
1019                                         sc->malo_stats.mst_tx_aging++;
1020                         }
1021                         /*
1022                          * Do any tx complete callback.  Note this must
1023                          * be done before releasing the node reference.
1024                          * XXX no way to figure out if frame was ACK'd
1025                          */
1026                         if (bf->bf_m->m_flags & M_TXCB) {
1027                                 /* XXX strip fw len in case header inspected */
1028                                 m_adj(bf->bf_m, sizeof(uint16_t));
1029                                 ieee80211_process_callback(ni, bf->bf_m,
1030                                         (status & MALO_TXD_STATUS_OK) == 0);
1031                         }
1032                         /*
1033                          * Reclaim reference to node.
1034                          *
1035                          * NB: the node may be reclaimed here if, for example
1036                          *     this is a DEAUTH message that was sent and the
1037                          *     node was timed out due to inactivity.
1038                          */
1039                         ieee80211_free_node(ni);
1040                 }
1041                 ds->status = htole32(MALO_TXD_STATUS_IDLE);
1042                 ds->pktlen = htole32(0);
1043
1044                 bus_dmamap_sync(sc->malo_dmat, bf->bf_dmamap,
1045                     BUS_DMASYNC_POSTWRITE);
1046                 bus_dmamap_unload(sc->malo_dmat, bf->bf_dmamap);
1047                 m_freem(bf->bf_m);
1048                 bf->bf_m = NULL;
1049                 bf->bf_node = NULL;
1050
1051                 MALO_TXQ_LOCK(txq);
1052                 STAILQ_INSERT_TAIL(&txq->free, bf, bf_list);
1053                 txq->nfree++;
1054                 MALO_TXQ_UNLOCK(txq);
1055         }
1056         return nreaped;
1057 }
1058
1059 /*
1060  * Deferred processing of transmit interrupt.
1061  */
1062 static void
1063 malo_tx_proc(void *arg, int npending)
1064 {
1065         struct malo_softc *sc = arg;
1066         struct ifnet *ifp = sc->malo_ifp;
1067         int i, nreaped;
1068
1069         /*
1070          * Process each active queue.
1071          */
1072         nreaped = 0;
1073         for (i = 0; i < MALO_NUM_TX_QUEUES; i++) {
1074                 if (!STAILQ_EMPTY(&sc->malo_txq[i].active))
1075                         nreaped += malo_tx_processq(sc, &sc->malo_txq[i]);
1076         }
1077
1078         if (nreaped != 0) {
1079                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1080                 sc->malo_timer = 0;
1081                 malo_start(ifp);
1082         }
1083 }
1084
1085 static int
1086 malo_tx_start(struct malo_softc *sc, struct ieee80211_node *ni,
1087     struct malo_txbuf *bf, struct mbuf *m0)
1088 {
1089 #define IEEE80211_DIR_DSTODS(wh) \
1090         ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS)
1091 #define IS_DATA_FRAME(wh)                                               \
1092         ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK)) == IEEE80211_FC0_TYPE_DATA)
1093         int error, ismcast, iswep;
1094         int copyhdrlen, hdrlen, pktlen;
1095         struct ieee80211_frame *wh;
1096         struct ifnet *ifp = sc->malo_ifp;
1097         struct ieee80211com *ic = ifp->if_l2com;
1098         struct ieee80211vap *vap = ni->ni_vap;
1099         struct malo_txdesc *ds;
1100         struct malo_txrec *tr;
1101         struct malo_txq *txq;
1102         uint16_t qos;
1103
1104         wh = mtod(m0, struct ieee80211_frame *);
1105         iswep = wh->i_fc[1] & IEEE80211_FC1_PROTECTED;
1106         ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1);
1107         copyhdrlen = hdrlen = ieee80211_anyhdrsize(wh);
1108         pktlen = m0->m_pkthdr.len;
1109         if (IEEE80211_QOS_HAS_SEQ(wh)) {
1110                 if (IEEE80211_DIR_DSTODS(wh)) {
1111                         qos = *(uint16_t *)
1112                             (((struct ieee80211_qosframe_addr4 *) wh)->i_qos);
1113                         copyhdrlen -= sizeof(qos);
1114                 } else
1115                         qos = *(uint16_t *)
1116                             (((struct ieee80211_qosframe *) wh)->i_qos);
1117         } else
1118                 qos = 0;
1119
1120         if (iswep) {
1121                 struct ieee80211_key *k;
1122
1123                 /*
1124                  * Construct the 802.11 header+trailer for an encrypted
1125                  * frame. The only reason this can fail is because of an
1126                  * unknown or unsupported cipher/key type.
1127                  *
1128                  * NB: we do this even though the firmware will ignore
1129                  *     what we've done for WEP and TKIP as we need the
1130                  *     ExtIV filled in for CCMP and this also adjusts
1131                  *     the headers which simplifies our work below.
1132                  */
1133                 k = ieee80211_crypto_encap(ni, m0);
1134                 if (k == NULL) {
1135                         /*
1136                          * This can happen when the key is yanked after the
1137                          * frame was queued.  Just discard the frame; the
1138                          * 802.11 layer counts failures and provides
1139                          * debugging/diagnostics.
1140                          */
1141                         m_freem(m0);
1142                         return EIO;
1143                 }
1144
1145                 /*
1146                  * Adjust the packet length for the crypto additions
1147                  * done during encap and any other bits that the f/w
1148                  * will add later on.
1149                  */
1150                 pktlen = m0->m_pkthdr.len;
1151
1152                 /* packet header may have moved, reset our local pointer */
1153                 wh = mtod(m0, struct ieee80211_frame *);
1154         }
1155
1156         if (ieee80211_radiotap_active_vap(vap)) {
1157                 sc->malo_tx_th.wt_flags = 0;    /* XXX */
1158                 if (iswep)
1159                         sc->malo_tx_th.wt_flags |= IEEE80211_RADIOTAP_F_WEP;
1160                 sc->malo_tx_th.wt_txpower = ni->ni_txpower;
1161                 sc->malo_tx_th.wt_antenna = sc->malo_txantenna;
1162
1163                 ieee80211_radiotap_tx(vap, m0);
1164         }
1165
1166         /*
1167          * Copy up/down the 802.11 header; the firmware requires
1168          * we present a 2-byte payload length followed by a
1169          * 4-address header (w/o QoS), followed (optionally) by
1170          * any WEP/ExtIV header (but only filled in for CCMP).
1171          * We are assured the mbuf has sufficient headroom to
1172          * prepend in-place by the setup of ic_headroom in
1173          * malo_attach.
1174          */
1175         if (hdrlen < sizeof(struct malo_txrec)) {
1176                 const int space = sizeof(struct malo_txrec) - hdrlen;
1177                 if (M_LEADINGSPACE(m0) < space) {
1178                         /* NB: should never happen */
1179                         device_printf(sc->malo_dev,
1180                             "not enough headroom, need %d found %zd, "
1181                             "m_flags 0x%x m_len %d\n",
1182                             space, M_LEADINGSPACE(m0), m0->m_flags, m0->m_len);
1183                         ieee80211_dump_pkt(ic,
1184                             mtod(m0, const uint8_t *), m0->m_len, 0, -1);
1185                         m_freem(m0);
1186                         /* XXX stat */
1187                         return EIO;
1188                 }
1189                 M_PREPEND(m0, space, M_NOWAIT);
1190         }
1191         tr = mtod(m0, struct malo_txrec *);
1192         if (wh != (struct ieee80211_frame *) &tr->wh)
1193                 ovbcopy(wh, &tr->wh, hdrlen);
1194         /*
1195          * Note: the "firmware length" is actually the length of the fully
1196          * formed "802.11 payload".  That is, it's everything except for
1197          * the 802.11 header.  In particular this includes all crypto
1198          * material including the MIC!
1199          */
1200         tr->fwlen = htole16(pktlen - hdrlen);
1201
1202         /*
1203          * Load the DMA map so any coalescing is done.  This
1204          * also calculates the number of descriptors we need.
1205          */
1206         error = malo_tx_dmasetup(sc, bf, m0);
1207         if (error != 0)
1208                 return error;
1209         bf->bf_node = ni;                       /* NB: held reference */
1210         m0 = bf->bf_m;                          /* NB: may have changed */
1211         tr = mtod(m0, struct malo_txrec *);
1212         wh = (struct ieee80211_frame *)&tr->wh;
1213
1214         /*
1215          * Formulate tx descriptor.
1216          */
1217         ds = bf->bf_desc;
1218         txq = bf->bf_txq;
1219
1220         ds->qosctrl = qos;                      /* NB: already little-endian */
1221         ds->pktptr = htole32(bf->bf_segs[0].ds_addr);
1222         ds->pktlen = htole16(bf->bf_segs[0].ds_len);
1223         /* NB: pPhysNext setup once, don't touch */
1224         ds->datarate = IS_DATA_FRAME(wh) ? 1 : 0;
1225         ds->sap_pktinfo = 0;
1226         ds->format = 0;
1227
1228         /*
1229          * Select transmit rate.
1230          */
1231         switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) {
1232         case IEEE80211_FC0_TYPE_MGT:
1233                 sc->malo_stats.mst_tx_mgmt++;
1234                 /* fall thru... */
1235         case IEEE80211_FC0_TYPE_CTL:
1236                 ds->txpriority = 1;
1237                 break;
1238         case IEEE80211_FC0_TYPE_DATA:
1239                 ds->txpriority = txq->qnum;
1240                 break;
1241         default:
1242                 if_printf(ifp, "bogus frame type 0x%x (%s)\n",
1243                         wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK, __func__);
1244                 /* XXX statistic */
1245                 m_freem(m0);
1246                 return EIO;
1247         }
1248
1249 #ifdef MALO_DEBUG
1250         if (IFF_DUMPPKTS_XMIT(sc))
1251                 ieee80211_dump_pkt(ic,
1252                     mtod(m0, const uint8_t *)+sizeof(uint16_t),
1253                     m0->m_len - sizeof(uint16_t), ds->datarate, -1);
1254 #endif
1255
1256         MALO_TXQ_LOCK(txq);
1257         if (!IS_DATA_FRAME(wh))
1258                 ds->status |= htole32(1);
1259         ds->status |= htole32(MALO_TXD_STATUS_FW_OWNED);
1260         STAILQ_INSERT_TAIL(&txq->active, bf, bf_list);
1261         MALO_TXDESC_SYNC(txq, ds, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1262
1263         ifp->if_opackets++;
1264         sc->malo_timer = 5;
1265         MALO_TXQ_UNLOCK(txq);
1266         return 0;
1267 #undef IEEE80211_DIR_DSTODS
1268 }
1269
1270 static void
1271 malo_start(struct ifnet *ifp)
1272 {
1273         struct malo_softc *sc = ifp->if_softc;
1274         struct ieee80211_node *ni;
1275         struct malo_txq *txq = &sc->malo_txq[0];
1276         struct malo_txbuf *bf = NULL;
1277         struct mbuf *m;
1278         int nqueued = 0;
1279
1280         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || sc->malo_invalid)
1281                 return;
1282
1283         for (;;) {
1284                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
1285                 if (m == NULL)
1286                         break;
1287                 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
1288                 bf = malo_getbuf(sc, txq);
1289                 if (bf == NULL) {
1290                         IFQ_DRV_PREPEND(&ifp->if_snd, m);
1291
1292                         /* XXX blocks other traffic */
1293                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1294                         sc->malo_stats.mst_tx_qstop++;
1295                         break;
1296                 }
1297                 /*
1298                  * Pass the frame to the h/w for transmission.
1299                  */
1300                 if (malo_tx_start(sc, ni, bf, m)) {
1301                         ifp->if_oerrors++;
1302                         if (bf != NULL) {
1303                                 bf->bf_m = NULL;
1304                                 bf->bf_node = NULL;
1305                                 MALO_TXQ_LOCK(txq);
1306                                 STAILQ_INSERT_HEAD(&txq->free, bf, bf_list);
1307                                 MALO_TXQ_UNLOCK(txq);
1308                         }
1309                         ieee80211_free_node(ni);
1310                         continue;
1311                 }
1312                 nqueued++;
1313
1314                 if (nqueued >= malo_txcoalesce) {
1315                         /*
1316                          * Poke the firmware to process queued frames;
1317                          * see below about (lack of) locking.
1318                          */
1319                         nqueued = 0;
1320                         malo_hal_txstart(sc->malo_mh, 0/*XXX*/);
1321                 }
1322         }
1323
1324         if (nqueued) {
1325                 /*
1326                  * NB: We don't need to lock against tx done because
1327                  * this just prods the firmware to check the transmit
1328                  * descriptors.  The firmware will also start fetching
1329                  * descriptors by itself if it notices new ones are
1330                  * present when it goes to deliver a tx done interrupt
1331                  * to the host. So if we race with tx done processing
1332                  * it's ok.  Delivering the kick here rather than in
1333                  * malo_tx_start is an optimization to avoid poking the
1334                  * firmware for each packet.
1335                  *
1336                  * NB: the queue id isn't used so 0 is ok.
1337                  */
1338                 malo_hal_txstart(sc->malo_mh, 0/*XXX*/);
1339         }
1340 }
1341
1342 static void
1343 malo_watchdog(void *arg)
1344 {
1345         struct malo_softc *sc;
1346         struct ifnet *ifp;
1347
1348         sc = arg;
1349         callout_reset(&sc->malo_watchdog_timer, hz, malo_watchdog, sc);
1350         if (sc->malo_timer == 0 || --sc->malo_timer > 0)
1351                 return;
1352
1353         ifp = sc->malo_ifp;
1354         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) && !sc->malo_invalid) {
1355                 if_printf(ifp, "watchdog timeout\n");
1356
1357                 /* XXX no way to reset h/w. now  */
1358
1359                 ifp->if_oerrors++;
1360                 sc->malo_stats.mst_watchdog++;
1361         }
1362 }
1363
1364 static int
1365 malo_hal_reset(struct malo_softc *sc)
1366 {
1367         static int first = 0;
1368         struct ifnet *ifp = sc->malo_ifp;
1369         struct ieee80211com *ic = ifp->if_l2com;
1370         struct malo_hal *mh = sc->malo_mh;
1371
1372         if (first == 0) {
1373                 /*
1374                  * NB: when the device firstly is initialized, sometimes
1375                  * firmware could override rx/tx dma registers so we re-set
1376                  * these values once.
1377                  */
1378                 malo_hal_set_rxtxdma(sc);
1379                 first = 1;
1380         }
1381
1382         malo_hal_setantenna(mh, MHA_ANTENNATYPE_RX, sc->malo_rxantenna);
1383         malo_hal_setantenna(mh, MHA_ANTENNATYPE_TX, sc->malo_txantenna);
1384         malo_hal_setradio(mh, 1, MHP_AUTO_PREAMBLE);
1385         malo_chan_set(sc, ic->ic_curchan);
1386
1387         /* XXX needs other stuffs?  */
1388
1389         return 1;
1390 }
1391
1392 static __inline struct mbuf *
1393 malo_getrxmbuf(struct malo_softc *sc, struct malo_rxbuf *bf)
1394 {
1395         struct mbuf *m;
1396         bus_addr_t paddr;
1397         int error;
1398
1399         /* XXX don't need mbuf, just dma buffer */
1400         m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
1401         if (m == NULL) {
1402                 sc->malo_stats.mst_rx_nombuf++; /* XXX */
1403                 return NULL;
1404         }
1405         error = bus_dmamap_load(sc->malo_dmat, bf->bf_dmamap,
1406             mtod(m, caddr_t), MJUMPAGESIZE,
1407             malo_load_cb, &paddr, BUS_DMA_NOWAIT);
1408         if (error != 0) {
1409                 if_printf(sc->malo_ifp,
1410                     "%s: bus_dmamap_load failed, error %d\n", __func__, error);
1411                 m_freem(m);
1412                 return NULL;
1413         }
1414         bf->bf_data = paddr;
1415         bus_dmamap_sync(sc->malo_dmat, bf->bf_dmamap, BUS_DMASYNC_PREWRITE);
1416
1417         return m;
1418 }
1419
1420 static int
1421 malo_rxbuf_init(struct malo_softc *sc, struct malo_rxbuf *bf)
1422 {
1423         struct malo_rxdesc *ds;
1424
1425         ds = bf->bf_desc;
1426         if (bf->bf_m == NULL) {
1427                 bf->bf_m = malo_getrxmbuf(sc, bf);
1428                 if (bf->bf_m == NULL) {
1429                         /* mark descriptor to be skipped */
1430                         ds->rxcontrol = MALO_RXD_CTRL_OS_OWN;
1431                         /* NB: don't need PREREAD */
1432                         MALO_RXDESC_SYNC(sc, ds, BUS_DMASYNC_PREWRITE);
1433                         return ENOMEM;
1434                 }
1435         }
1436
1437         /*
1438          * Setup descriptor.
1439          */
1440         ds->qosctrl = 0;
1441         ds->snr = 0;
1442         ds->status = MALO_RXD_STATUS_IDLE;
1443         ds->channel = 0;
1444         ds->pktlen = htole16(MALO_RXSIZE);
1445         ds->nf = 0;
1446         ds->physbuffdata = htole32(bf->bf_data);
1447         /* NB: don't touch pPhysNext, set once */
1448         ds->rxcontrol = MALO_RXD_CTRL_DRIVER_OWN;
1449         MALO_RXDESC_SYNC(sc, ds, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1450
1451         return 0;
1452 }
1453
1454 /*
1455  * Setup the rx data structures.  This should only be done once or we may get
1456  * out of sync with the firmware.
1457  */
1458 static int
1459 malo_startrecv(struct malo_softc *sc)
1460 {
1461         struct malo_rxbuf *bf, *prev;
1462         struct malo_rxdesc *ds;
1463
1464         if (sc->malo_recvsetup == 1) {
1465                 malo_mode_init(sc);             /* set filters, etc. */
1466                 return 0;
1467         }
1468
1469         prev = NULL;
1470         STAILQ_FOREACH(bf, &sc->malo_rxbuf, bf_list) {
1471                 int error = malo_rxbuf_init(sc, bf);
1472                 if (error != 0) {
1473                         DPRINTF(sc, MALO_DEBUG_RECV,
1474                             "%s: malo_rxbuf_init failed %d\n",
1475                             __func__, error);
1476                         return error;
1477                 }
1478                 if (prev != NULL) {
1479                         ds = prev->bf_desc;
1480                         ds->physnext = htole32(bf->bf_daddr);
1481                 }
1482                 prev = bf;
1483         }
1484         if (prev != NULL) {
1485                 ds = prev->bf_desc;
1486                 ds->physnext =
1487                     htole32(STAILQ_FIRST(&sc->malo_rxbuf)->bf_daddr);
1488         }
1489
1490         sc->malo_recvsetup = 1;
1491
1492         malo_mode_init(sc);             /* set filters, etc. */
1493
1494         return 0;
1495 }
1496
1497 static void
1498 malo_init_locked(struct malo_softc *sc)
1499 {
1500         struct ifnet *ifp = sc->malo_ifp;
1501         struct malo_hal *mh = sc->malo_mh;
1502         int error;
1503
1504         DPRINTF(sc, MALO_DEBUG_ANY, "%s: if_flags 0x%x\n",
1505             __func__, ifp->if_flags);
1506
1507         MALO_LOCK_ASSERT(sc);
1508
1509         /*
1510          * Stop anything previously setup.  This is safe whether this is
1511          * the first time through or not.
1512          */
1513         malo_stop_locked(ifp, 0);
1514
1515         /*
1516          * Push state to the firmware.
1517          */
1518         if (!malo_hal_reset(sc)) {
1519                 if_printf(ifp, "%s: unable to reset hardware\n", __func__);
1520                 return;
1521         }
1522
1523         /*
1524          * Setup recv (once); transmit is already good to go.
1525          */
1526         error = malo_startrecv(sc);
1527         if (error != 0) {
1528                 if_printf(ifp, "%s: unable to start recv logic, error %d\n",
1529                     __func__, error);
1530                 return;
1531         }
1532
1533         /*
1534          * Enable interrupts.
1535          */
1536         sc->malo_imask = MALO_A2HRIC_BIT_RX_RDY
1537             | MALO_A2HRIC_BIT_TX_DONE
1538             | MALO_A2HRIC_BIT_OPC_DONE
1539             | MALO_A2HRIC_BIT_MAC_EVENT
1540             | MALO_A2HRIC_BIT_RX_PROBLEM
1541             | MALO_A2HRIC_BIT_ICV_ERROR
1542             | MALO_A2HRIC_BIT_RADAR_DETECT
1543             | MALO_A2HRIC_BIT_CHAN_SWITCH;
1544
1545         ifp->if_drv_flags |= IFF_DRV_RUNNING;
1546         malo_hal_intrset(mh, sc->malo_imask);
1547         callout_reset(&sc->malo_watchdog_timer, hz, malo_watchdog, sc);
1548 }
1549
1550 static void
1551 malo_init(void *arg)
1552 {
1553         struct malo_softc *sc = (struct malo_softc *) arg;
1554         struct ifnet *ifp = sc->malo_ifp;
1555         struct ieee80211com *ic = ifp->if_l2com;
1556
1557         DPRINTF(sc, MALO_DEBUG_ANY, "%s: if_flags 0x%x\n",
1558             __func__, ifp->if_flags);
1559
1560         MALO_LOCK(sc);
1561         malo_init_locked(sc);
1562
1563         MALO_UNLOCK(sc);
1564
1565         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1566                 ieee80211_start_all(ic);        /* start all vap's */
1567 }
1568
1569 /*
1570  * Set the multicast filter contents into the hardware.
1571  */
1572 static void
1573 malo_setmcastfilter(struct malo_softc *sc)
1574 {
1575         struct ifnet *ifp = sc->malo_ifp;
1576         struct ieee80211com *ic = ifp->if_l2com;
1577         struct ifmultiaddr *ifma;
1578         uint8_t macs[IEEE80211_ADDR_LEN * MALO_HAL_MCAST_MAX];
1579         uint8_t *mp;
1580         int nmc;
1581
1582         mp = macs;
1583         nmc = 0;
1584
1585         if (ic->ic_opmode == IEEE80211_M_MONITOR ||
1586             (ifp->if_flags & (IFF_ALLMULTI | IFF_PROMISC)))
1587                 goto all;
1588
1589         if_maddr_rlock(ifp);
1590         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1591                 if (ifma->ifma_addr->sa_family != AF_LINK)
1592                         continue;
1593
1594                 if (nmc == MALO_HAL_MCAST_MAX) {
1595                         ifp->if_flags |= IFF_ALLMULTI;
1596                         if_maddr_runlock(ifp);
1597                         goto all;
1598                 }
1599                 IEEE80211_ADDR_COPY(mp,
1600                     LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1601
1602                 mp += IEEE80211_ADDR_LEN, nmc++;
1603         }
1604         if_maddr_runlock(ifp);
1605
1606         malo_hal_setmcast(sc->malo_mh, nmc, macs);
1607
1608 all:
1609         /*
1610          * XXX we don't know how to set the f/w for supporting
1611          * IFF_ALLMULTI | IFF_PROMISC cases
1612          */
1613         return;
1614 }
1615
1616 static int
1617 malo_mode_init(struct malo_softc *sc)
1618 {
1619         struct ifnet *ifp = sc->malo_ifp;
1620         struct ieee80211com *ic = ifp->if_l2com;
1621         struct malo_hal *mh = sc->malo_mh;
1622
1623         /*
1624          * NB: Ignore promisc in hostap mode; it's set by the
1625          * bridge.  This is wrong but we have no way to
1626          * identify internal requests (from the bridge)
1627          * versus external requests such as for tcpdump.
1628          */
1629         malo_hal_setpromisc(mh, (ifp->if_flags & IFF_PROMISC) &&
1630             ic->ic_opmode != IEEE80211_M_HOSTAP);
1631         malo_setmcastfilter(sc);
1632
1633         return ENXIO;
1634 }
1635
1636 static void
1637 malo_tx_draintxq(struct malo_softc *sc, struct malo_txq *txq)
1638 {
1639         struct ieee80211_node *ni;
1640         struct malo_txbuf *bf;
1641         u_int ix;
1642
1643         /*
1644          * NB: this assumes output has been stopped and
1645          *     we do not need to block malo_tx_tasklet
1646          */
1647         for (ix = 0;; ix++) {
1648                 MALO_TXQ_LOCK(txq);
1649                 bf = STAILQ_FIRST(&txq->active);
1650                 if (bf == NULL) {
1651                         MALO_TXQ_UNLOCK(txq);
1652                         break;
1653                 }
1654                 STAILQ_REMOVE_HEAD(&txq->active, bf_list);
1655                 MALO_TXQ_UNLOCK(txq);
1656 #ifdef MALO_DEBUG
1657                 if (sc->malo_debug & MALO_DEBUG_RESET) {
1658                         struct ifnet *ifp = sc->malo_ifp;
1659                         struct ieee80211com *ic = ifp->if_l2com;
1660                         const struct malo_txrec *tr =
1661                             mtod(bf->bf_m, const struct malo_txrec *);
1662                         malo_printtxbuf(bf, txq->qnum, ix);
1663                         ieee80211_dump_pkt(ic, (const uint8_t *)&tr->wh,
1664                             bf->bf_m->m_len - sizeof(tr->fwlen), 0, -1);
1665                 }
1666 #endif /* MALO_DEBUG */
1667                 bus_dmamap_unload(sc->malo_dmat, bf->bf_dmamap);
1668                 ni = bf->bf_node;
1669                 bf->bf_node = NULL;
1670                 if (ni != NULL) {
1671                         /*
1672                          * Reclaim node reference.
1673                          */
1674                         ieee80211_free_node(ni);
1675                 }
1676                 m_freem(bf->bf_m);
1677                 bf->bf_m = NULL;
1678
1679                 MALO_TXQ_LOCK(txq);
1680                 STAILQ_INSERT_TAIL(&txq->free, bf, bf_list);
1681                 txq->nfree++;
1682                 MALO_TXQ_UNLOCK(txq);
1683         }
1684 }
1685
1686 static void
1687 malo_stop_locked(struct ifnet *ifp, int disable)
1688 {
1689         struct malo_softc *sc = ifp->if_softc;
1690         struct malo_hal *mh = sc->malo_mh;
1691         int i;
1692
1693         DPRINTF(sc, MALO_DEBUG_ANY, "%s: invalid %u if_flags 0x%x\n",
1694             __func__, sc->malo_invalid, ifp->if_flags);
1695
1696         MALO_LOCK_ASSERT(sc);
1697
1698         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1699                 return;
1700
1701         /*
1702          * Shutdown the hardware and driver:
1703          *    disable interrupts
1704          *    turn off the radio
1705          *    drain and release tx queues
1706          *
1707          * Note that some of this work is not possible if the hardware
1708          * is gone (invalid).
1709          */
1710         ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1711         callout_stop(&sc->malo_watchdog_timer);
1712         sc->malo_timer = 0;
1713         /* diable interrupt.  */
1714         malo_hal_intrset(mh, 0);
1715         /* turn off the radio.  */
1716         malo_hal_setradio(mh, 0, MHP_AUTO_PREAMBLE);
1717
1718         /* drain and release tx queues.  */
1719         for (i = 0; i < MALO_NUM_TX_QUEUES; i++)
1720                 malo_tx_draintxq(sc, &sc->malo_txq[i]);
1721 }
1722
1723 static int
1724 malo_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1725 {
1726 #define MALO_IS_RUNNING(ifp) \
1727         ((ifp->if_flags & IFF_UP) && (ifp->if_drv_flags & IFF_DRV_RUNNING))
1728         struct malo_softc *sc = ifp->if_softc;
1729         struct ieee80211com *ic = ifp->if_l2com;
1730         struct ifreq *ifr = (struct ifreq *) data;
1731         int error = 0, startall = 0;
1732
1733         MALO_LOCK(sc);
1734         switch (cmd) {
1735         case SIOCSIFFLAGS:
1736                 if (MALO_IS_RUNNING(ifp)) {
1737                         /*
1738                          * To avoid rescanning another access point,
1739                          * do not call malo_init() here.  Instead,
1740                          * only reflect promisc mode settings.
1741                          */
1742                         malo_mode_init(sc);
1743                 } else if (ifp->if_flags & IFF_UP) {
1744                         /*
1745                          * Beware of being called during attach/detach
1746                          * to reset promiscuous mode.  In that case we
1747                          * will still be marked UP but not RUNNING.
1748                          * However trying to re-init the interface
1749                          * is the wrong thing to do as we've already
1750                          * torn down much of our state.  There's
1751                          * probably a better way to deal with this.
1752                          */
1753                         if (!sc->malo_invalid) {
1754                                 malo_init_locked(sc);
1755                                 startall = 1;
1756                         }
1757                 } else
1758                         malo_stop_locked(ifp, 1);
1759                 break;
1760         case SIOCGIFMEDIA:
1761         case SIOCSIFMEDIA:
1762                 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd);
1763                 break;
1764         default:
1765                 error = ether_ioctl(ifp, cmd, data);
1766                 break;
1767         }
1768         MALO_UNLOCK(sc);
1769
1770         if (startall)
1771                 ieee80211_start_all(ic);
1772         return error;
1773 #undef MALO_IS_RUNNING
1774 }
1775
1776 /*
1777  * Callback from the 802.11 layer to update the slot time
1778  * based on the current setting.  We use it to notify the
1779  * firmware of ERP changes and the f/w takes care of things
1780  * like slot time and preamble.
1781  */
1782 static void
1783 malo_updateslot(struct ifnet *ifp)
1784 {
1785         struct malo_softc *sc = ifp->if_softc;
1786         struct ieee80211com *ic = ifp->if_l2com;
1787         struct malo_hal *mh = sc->malo_mh;
1788         int error;
1789
1790         /* NB: can be called early; suppress needless cmds */
1791         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1792                 return;
1793
1794         DPRINTF(sc, MALO_DEBUG_RESET,
1795             "%s: chan %u MHz/flags 0x%x %s slot, (ic_flags 0x%x)\n",
1796             __func__, ic->ic_curchan->ic_freq, ic->ic_curchan->ic_flags,
1797             ic->ic_flags & IEEE80211_F_SHSLOT ? "short" : "long", ic->ic_flags);
1798
1799         if (ic->ic_flags & IEEE80211_F_SHSLOT)
1800                 error = malo_hal_set_slot(mh, 1);
1801         else
1802                 error = malo_hal_set_slot(mh, 0);
1803
1804         if (error != 0)
1805                 device_printf(sc->malo_dev, "setting %s slot failed\n",
1806                         ic->ic_flags & IEEE80211_F_SHSLOT ? "short" : "long");
1807 }
1808
1809 static int
1810 malo_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
1811 {
1812         struct ieee80211com *ic = vap->iv_ic;
1813         struct malo_softc *sc = ic->ic_ifp->if_softc;
1814         struct malo_hal *mh = sc->malo_mh;
1815         int error;
1816
1817         DPRINTF(sc, MALO_DEBUG_STATE, "%s: %s -> %s\n", __func__,
1818             ieee80211_state_name[vap->iv_state],
1819             ieee80211_state_name[nstate]);
1820
1821         /*
1822          * Invoke the net80211 layer first so iv_bss is setup.
1823          */
1824         error = MALO_VAP(vap)->malo_newstate(vap, nstate, arg);
1825         if (error != 0)
1826                 return error;
1827
1828         if (nstate == IEEE80211_S_RUN && vap->iv_state != IEEE80211_S_RUN) {
1829                 struct ieee80211_node *ni = vap->iv_bss;
1830                 enum ieee80211_phymode mode = ieee80211_chan2mode(ni->ni_chan);
1831                 const struct ieee80211_txparam *tp = &vap->iv_txparms[mode];
1832
1833                 DPRINTF(sc, MALO_DEBUG_STATE,
1834                     "%s: %s(RUN): iv_flags 0x%08x bintvl %d bssid %s "
1835                     "capinfo 0x%04x chan %d associd 0x%x mode %d rate %d\n",
1836                     vap->iv_ifp->if_xname, __func__, vap->iv_flags,
1837                     ni->ni_intval, ether_sprintf(ni->ni_bssid), ni->ni_capinfo,
1838                     ieee80211_chan2ieee(ic, ic->ic_curchan),
1839                     ni->ni_associd, mode, tp->ucastrate);
1840
1841                 malo_hal_setradio(mh, 1,
1842                     (ic->ic_flags & IEEE80211_F_SHPREAMBLE) ?
1843                         MHP_SHORT_PREAMBLE : MHP_LONG_PREAMBLE);
1844                 malo_hal_setassocid(sc->malo_mh, ni->ni_bssid, ni->ni_associd);
1845                 malo_hal_set_rate(mh, mode,
1846                    tp->ucastrate == IEEE80211_FIXED_RATE_NONE ?
1847                        0 : malo_fix2rate(tp->ucastrate));
1848         }
1849         return 0;
1850 }
1851
1852 static int
1853 malo_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
1854         const struct ieee80211_bpf_params *params)
1855 {
1856         struct ieee80211com *ic = ni->ni_ic;
1857         struct ifnet *ifp = ic->ic_ifp;
1858         struct malo_softc *sc = ifp->if_softc;
1859         struct malo_txbuf *bf;
1860         struct malo_txq *txq;
1861
1862         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || sc->malo_invalid) {
1863                 ieee80211_free_node(ni);
1864                 m_freem(m);
1865                 return ENETDOWN;
1866         }
1867
1868         /*
1869          * Grab a TX buffer and associated resources.  Note that we depend
1870          * on the classification by the 802.11 layer to get to the right h/w
1871          * queue.  Management frames must ALWAYS go on queue 1 but we
1872          * cannot just force that here because we may receive non-mgt frames.
1873          */
1874         txq = &sc->malo_txq[0];
1875         bf = malo_getbuf(sc, txq);
1876         if (bf == NULL) {
1877                 /* XXX blocks other traffic */
1878                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1879                 ieee80211_free_node(ni);
1880                 m_freem(m);
1881                 return ENOBUFS;
1882         }
1883
1884         /*
1885          * Pass the frame to the h/w for transmission.
1886          */
1887         if (malo_tx_start(sc, ni, bf, m) != 0) {
1888                 ifp->if_oerrors++;
1889                 bf->bf_m = NULL;
1890                 bf->bf_node = NULL;
1891                 MALO_TXQ_LOCK(txq);
1892                 STAILQ_INSERT_HEAD(&txq->free, bf, bf_list);
1893                 txq->nfree++;
1894                 MALO_TXQ_UNLOCK(txq);
1895
1896                 ieee80211_free_node(ni);
1897                 return EIO;             /* XXX */
1898         }
1899
1900         /*
1901          * NB: We don't need to lock against tx done because this just
1902          * prods the firmware to check the transmit descriptors.  The firmware
1903          * will also start fetching descriptors by itself if it notices
1904          * new ones are present when it goes to deliver a tx done interrupt
1905          * to the host. So if we race with tx done processing it's ok.
1906          * Delivering the kick here rather than in malo_tx_start is
1907          * an optimization to avoid poking the firmware for each packet.
1908          *
1909          * NB: the queue id isn't used so 0 is ok.
1910          */
1911         malo_hal_txstart(sc->malo_mh, 0/*XXX*/);
1912
1913         return 0;
1914 }
1915
1916 static void
1917 malo_sysctlattach(struct malo_softc *sc)
1918 {
1919 #ifdef  MALO_DEBUG
1920         struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->malo_dev);
1921         struct sysctl_oid *tree = device_get_sysctl_tree(sc->malo_dev);
1922
1923         sc->malo_debug = malo_debug;
1924         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
1925                 "debug", CTLFLAG_RW, &sc->malo_debug, 0,
1926                 "control debugging printfs");
1927 #endif
1928 }
1929
1930 static void
1931 malo_announce(struct malo_softc *sc)
1932 {
1933         struct ifnet *ifp = sc->malo_ifp;
1934
1935         if_printf(ifp, "versions [hw %d fw %d.%d.%d.%d] (regioncode %d)\n",
1936                 sc->malo_hwspecs.hwversion,
1937                 (sc->malo_hwspecs.fw_releasenum >> 24) & 0xff,
1938                 (sc->malo_hwspecs.fw_releasenum >> 16) & 0xff,
1939                 (sc->malo_hwspecs.fw_releasenum >> 8) & 0xff,
1940                 (sc->malo_hwspecs.fw_releasenum >> 0) & 0xff,
1941                 sc->malo_hwspecs.regioncode);
1942
1943         if (bootverbose || malo_rxbuf != MALO_RXBUF)
1944                 if_printf(ifp, "using %u rx buffers\n", malo_rxbuf);
1945         if (bootverbose || malo_txbuf != MALO_TXBUF)
1946                 if_printf(ifp, "using %u tx buffers\n", malo_txbuf);
1947 }
1948
1949 /*
1950  * Convert net80211 channel to a HAL channel.
1951  */
1952 static void
1953 malo_mapchan(struct malo_hal_channel *hc, const struct ieee80211_channel *chan)
1954 {
1955         hc->channel = chan->ic_ieee;
1956
1957         *(uint32_t *)&hc->flags = 0;
1958         if (IEEE80211_IS_CHAN_2GHZ(chan))
1959                 hc->flags.freqband = MALO_FREQ_BAND_2DOT4GHZ;
1960 }
1961
1962 /*
1963  * Set/change channels.  If the channel is really being changed,
1964  * it's done by reseting the chip.  To accomplish this we must
1965  * first cleanup any pending DMA, then restart stuff after a la
1966  * malo_init.
1967  */
1968 static int
1969 malo_chan_set(struct malo_softc *sc, struct ieee80211_channel *chan)
1970 {
1971         struct malo_hal *mh = sc->malo_mh;
1972         struct malo_hal_channel hchan;
1973
1974         DPRINTF(sc, MALO_DEBUG_RESET, "%s: chan %u MHz/flags 0x%x\n",
1975             __func__, chan->ic_freq, chan->ic_flags);
1976
1977         /*
1978          * Convert to a HAL channel description with the flags constrained
1979          * to reflect the current operating mode.
1980          */
1981         malo_mapchan(&hchan, chan);
1982         malo_hal_intrset(mh, 0);                /* disable interrupts */
1983         malo_hal_setchannel(mh, &hchan);
1984         malo_hal_settxpower(mh, &hchan);
1985
1986         /*
1987          * Update internal state.
1988          */
1989         sc->malo_tx_th.wt_chan_freq = htole16(chan->ic_freq);
1990         sc->malo_rx_th.wr_chan_freq = htole16(chan->ic_freq);
1991         if (IEEE80211_IS_CHAN_ANYG(chan)) {
1992                 sc->malo_tx_th.wt_chan_flags = htole16(IEEE80211_CHAN_G);
1993                 sc->malo_rx_th.wr_chan_flags = htole16(IEEE80211_CHAN_G);
1994         } else {
1995                 sc->malo_tx_th.wt_chan_flags = htole16(IEEE80211_CHAN_B);
1996                 sc->malo_rx_th.wr_chan_flags = htole16(IEEE80211_CHAN_B);
1997         }
1998         sc->malo_curchan = hchan;
1999         malo_hal_intrset(mh, sc->malo_imask);
2000
2001         return 0;
2002 }
2003
2004 static void
2005 malo_scan_start(struct ieee80211com *ic)
2006 {
2007         struct ifnet *ifp = ic->ic_ifp;
2008         struct malo_softc *sc = ifp->if_softc;
2009
2010         DPRINTF(sc, MALO_DEBUG_STATE, "%s\n", __func__);
2011 }
2012
2013 static void
2014 malo_scan_end(struct ieee80211com *ic)
2015 {
2016         struct ifnet *ifp = ic->ic_ifp;
2017         struct malo_softc *sc = ifp->if_softc;
2018
2019         DPRINTF(sc, MALO_DEBUG_STATE, "%s\n", __func__);
2020 }
2021
2022 static void
2023 malo_set_channel(struct ieee80211com *ic)
2024 {
2025         struct ifnet *ifp = ic->ic_ifp;
2026         struct malo_softc *sc = ifp->if_softc;
2027
2028         (void) malo_chan_set(sc, ic->ic_curchan);
2029 }
2030
2031 static void
2032 malo_rx_proc(void *arg, int npending)
2033 {
2034 #define IEEE80211_DIR_DSTODS(wh)                                        \
2035         ((((const struct ieee80211_frame *)wh)->i_fc[1] &               \
2036             IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS)
2037         struct malo_softc *sc = arg;
2038         struct ifnet *ifp = sc->malo_ifp;
2039         struct ieee80211com *ic = ifp->if_l2com;
2040         struct malo_rxbuf *bf;
2041         struct malo_rxdesc *ds;
2042         struct mbuf *m, *mnew;
2043         struct ieee80211_qosframe *wh;
2044         struct ieee80211_qosframe_addr4 *wh4;
2045         struct ieee80211_node *ni;
2046         int off, len, hdrlen, pktlen, rssi, ntodo;
2047         uint8_t *data, status;
2048         uint32_t readptr, writeptr;
2049
2050         DPRINTF(sc, MALO_DEBUG_RX_PROC,
2051             "%s: pending %u rdptr(0x%x) 0x%x wrptr(0x%x) 0x%x\n",
2052             __func__, npending,
2053             sc->malo_hwspecs.rxdesc_read,
2054             malo_bar0_read4(sc, sc->malo_hwspecs.rxdesc_read),
2055             sc->malo_hwspecs.rxdesc_write,
2056             malo_bar0_read4(sc, sc->malo_hwspecs.rxdesc_write));
2057
2058         readptr = malo_bar0_read4(sc, sc->malo_hwspecs.rxdesc_read);
2059         writeptr = malo_bar0_read4(sc, sc->malo_hwspecs.rxdesc_write);
2060         if (readptr == writeptr)
2061                 return;
2062
2063         bf = sc->malo_rxnext;
2064         for (ntodo = malo_rxquota; ntodo > 0 && readptr != writeptr; ntodo--) {
2065                 if (bf == NULL) {
2066                         bf = STAILQ_FIRST(&sc->malo_rxbuf);
2067                         break;
2068                 }
2069                 ds = bf->bf_desc;
2070                 if (bf->bf_m == NULL) {
2071                         /*
2072                          * If data allocation failed previously there
2073                          * will be no buffer; try again to re-populate it.
2074                          * Note the firmware will not advance to the next
2075                          * descriptor with a dma buffer so we must mimic
2076                          * this or we'll get out of sync.
2077                          */
2078                         DPRINTF(sc, MALO_DEBUG_ANY,
2079                             "%s: rx buf w/o dma memory\n", __func__);
2080                         (void)malo_rxbuf_init(sc, bf);
2081                         break;
2082                 }
2083                 MALO_RXDESC_SYNC(sc, ds,
2084                     BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
2085                 if (ds->rxcontrol != MALO_RXD_CTRL_DMA_OWN)
2086                         break;
2087
2088                 readptr = le32toh(ds->physnext);
2089
2090 #ifdef MALO_DEBUG
2091                 if (sc->malo_debug & MALO_DEBUG_RECV_DESC)
2092                         malo_printrxbuf(bf, 0);
2093 #endif
2094                 status = ds->status;
2095                 if (status & MALO_RXD_STATUS_DECRYPT_ERR_MASK) {
2096                         ifp->if_ierrors++;
2097                         goto rx_next;
2098                 }
2099                 /*
2100                  * Sync the data buffer.
2101                  */
2102                 len = le16toh(ds->pktlen);
2103                 bus_dmamap_sync(sc->malo_dmat, bf->bf_dmamap,
2104                     BUS_DMASYNC_POSTREAD);
2105                 /*
2106                  * The 802.11 header is provided all or in part at the front;
2107                  * use it to calculate the true size of the header that we'll
2108                  * construct below.  We use this to figure out where to copy
2109                  * payload prior to constructing the header.
2110                  */
2111                 m = bf->bf_m;
2112                 data = mtod(m, uint8_t *);
2113                 hdrlen = ieee80211_anyhdrsize(data + sizeof(uint16_t));
2114                 off = sizeof(uint16_t) + sizeof(struct ieee80211_frame_addr4);
2115
2116                 /*
2117                  * Calculate RSSI. XXX wrong
2118                  */
2119                 rssi = 2 * ((int) ds->snr - ds->nf);    /* NB: .5 dBm  */
2120                 if (rssi > 100)
2121                         rssi = 100;
2122
2123                 pktlen = hdrlen + (len - off);
2124                 /*
2125                  * NB: we know our frame is at least as large as
2126                  * IEEE80211_MIN_LEN because there is a 4-address frame at
2127                  * the front.  Hence there's no need to vet the packet length.
2128                  * If the frame in fact is too small it should be discarded
2129                  * at the net80211 layer.
2130                  */
2131
2132                 /* XXX don't need mbuf, just dma buffer */
2133                 mnew = malo_getrxmbuf(sc, bf);
2134                 if (mnew == NULL) {
2135                         ifp->if_ierrors++;
2136                         goto rx_next;
2137                 }
2138                 /*
2139                  * Attach the dma buffer to the mbuf; malo_rxbuf_init will
2140                  * re-setup the rx descriptor using the replacement dma
2141                  * buffer we just installed above.
2142                  */
2143                 bf->bf_m = mnew;
2144                 m->m_data += off - hdrlen;
2145                 m->m_pkthdr.len = m->m_len = pktlen;
2146                 m->m_pkthdr.rcvif = ifp;
2147
2148                 /*
2149                  * Piece 802.11 header together.
2150                  */
2151                 wh = mtod(m, struct ieee80211_qosframe *);
2152                 /* NB: don't need to do this sometimes but ... */
2153                 /* XXX special case so we can memcpy after m_devget? */
2154                 ovbcopy(data + sizeof(uint16_t), wh, hdrlen);
2155                 if (IEEE80211_QOS_HAS_SEQ(wh)) {
2156                         if (IEEE80211_DIR_DSTODS(wh)) {
2157                                 wh4 = mtod(m,
2158                                     struct ieee80211_qosframe_addr4*);
2159                                 *(uint16_t *)wh4->i_qos = ds->qosctrl;
2160                         } else {
2161                                 *(uint16_t *)wh->i_qos = ds->qosctrl;
2162                         }
2163                 }
2164                 if (ieee80211_radiotap_active(ic)) {
2165                         sc->malo_rx_th.wr_flags = 0;
2166                         sc->malo_rx_th.wr_rate = ds->rate;
2167                         sc->malo_rx_th.wr_antsignal = rssi;
2168                         sc->malo_rx_th.wr_antnoise = ds->nf;
2169                 }
2170 #ifdef MALO_DEBUG
2171                 if (IFF_DUMPPKTS_RECV(sc, wh)) {
2172                         ieee80211_dump_pkt(ic, mtod(m, caddr_t),
2173                             len, ds->rate, rssi);
2174                 }
2175 #endif
2176                 ifp->if_ipackets++;
2177
2178                 /* dispatch */
2179                 ni = ieee80211_find_rxnode(ic,
2180                     (struct ieee80211_frame_min *)wh);
2181                 if (ni != NULL) {
2182                         (void) ieee80211_input(ni, m, rssi, ds->nf);
2183                         ieee80211_free_node(ni);
2184                 } else
2185                         (void) ieee80211_input_all(ic, m, rssi, ds->nf);
2186 rx_next:
2187                 /* NB: ignore ENOMEM so we process more descriptors */
2188                 (void) malo_rxbuf_init(sc, bf);
2189                 bf = STAILQ_NEXT(bf, bf_list);
2190         }
2191
2192         malo_bar0_write4(sc, sc->malo_hwspecs.rxdesc_read, readptr);
2193         sc->malo_rxnext = bf;
2194
2195         if ((ifp->if_drv_flags & IFF_DRV_OACTIVE) == 0 &&
2196             !IFQ_IS_EMPTY(&ifp->if_snd))
2197                 malo_start(ifp);
2198 #undef IEEE80211_DIR_DSTODS
2199 }
2200
2201 static void
2202 malo_stop(struct ifnet *ifp, int disable)
2203 {
2204         struct malo_softc *sc = ifp->if_softc;
2205
2206         MALO_LOCK(sc);
2207         malo_stop_locked(ifp, disable);
2208         MALO_UNLOCK(sc);
2209 }
2210
2211 /*
2212  * Reclaim all tx queue resources.
2213  */
2214 static void
2215 malo_tx_cleanup(struct malo_softc *sc)
2216 {
2217         int i;
2218
2219         for (i = 0; i < MALO_NUM_TX_QUEUES; i++)
2220                 malo_tx_cleanupq(sc, &sc->malo_txq[i]);
2221 }
2222
2223 int
2224 malo_detach(struct malo_softc *sc)
2225 {
2226         struct ifnet *ifp = sc->malo_ifp;
2227         struct ieee80211com *ic = ifp->if_l2com;
2228
2229         DPRINTF(sc, MALO_DEBUG_ANY, "%s: if_flags %x\n",
2230                 __func__, ifp->if_flags);
2231
2232         malo_stop(ifp, 1);
2233
2234         if (sc->malo_tq != NULL) {
2235                 taskqueue_drain(sc->malo_tq, &sc->malo_rxtask);
2236                 taskqueue_drain(sc->malo_tq, &sc->malo_txtask);
2237                 taskqueue_free(sc->malo_tq);
2238                 sc->malo_tq = NULL;
2239         }
2240
2241         /*
2242          * NB: the order of these is important:
2243          * o call the 802.11 layer before detaching the hal to
2244          *   insure callbacks into the driver to delete global
2245          *   key cache entries can be handled
2246          * o reclaim the tx queue data structures after calling
2247          *   the 802.11 layer as we'll get called back to reclaim
2248          *   node state and potentially want to use them
2249          * o to cleanup the tx queues the hal is called, so detach
2250          *   it last
2251          * Other than that, it's straightforward...
2252          */
2253         ieee80211_ifdetach(ic);
2254         callout_drain(&sc->malo_watchdog_timer);
2255         malo_dma_cleanup(sc);
2256         malo_tx_cleanup(sc);
2257         malo_hal_detach(sc->malo_mh);
2258         if_free(ifp);
2259
2260         MALO_LOCK_DESTROY(sc);
2261
2262         return 0;
2263 }
2264
2265 void
2266 malo_shutdown(struct malo_softc *sc)
2267 {
2268         malo_stop(sc->malo_ifp, 1);
2269 }
2270
2271 void
2272 malo_suspend(struct malo_softc *sc)
2273 {
2274         struct ifnet *ifp = sc->malo_ifp;
2275
2276         DPRINTF(sc, MALO_DEBUG_ANY, "%s: if_flags %x\n",
2277                 __func__, ifp->if_flags);
2278
2279         malo_stop(ifp, 1);
2280 }
2281
2282 void
2283 malo_resume(struct malo_softc *sc)
2284 {
2285         struct ifnet *ifp = sc->malo_ifp;
2286
2287         DPRINTF(sc, MALO_DEBUG_ANY, "%s: if_flags %x\n",
2288                 __func__, ifp->if_flags);
2289
2290         if (ifp->if_flags & IFF_UP)
2291                 malo_init(sc);
2292 }