sys/dev/malo/if_malo.h

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2007 Marvell Semiconductor, Inc.
   5  * Copyright (c) 2007 Sam Leffler, Errno Consulting
   6  * Copyright (c) 2008 Weongyo Jeong <weongyo@freebsd.org>
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer,
  14  *    without modification.
  15  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  16  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  17  *    redistribution must be conditioned upon including a substantially
  18  *    similar Disclaimer requirement for further binary redistribution.
  19  *
  20  * NO WARRANTY
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  24  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  25  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  26  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  29  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  31  * THE POSSIBILITY OF SUCH DAMAGES.
  32  *
  33  * $FreeBSD$
  34  */
  35
  36 /*
  37  * Definitions for the Marvell 88W8335 Wireless LAN controller.
  38  */
  39 #ifndef _DEV_MALO_H
  40 #define _DEV_MALO_H
  41
  42 #include <net80211/ieee80211_radiotap.h>
  43 #include <dev/malo/if_malohal.h>
  44 #include <dev/malo/if_maloioctl.h>
  45
  46 #ifndef MALO_TXBUF
  47 #define MALO_TXBUF              256     /* number of TX descriptors/buffers */
  48 #endif
  49 #ifndef MALO_RXBUF
  50 #define MALO_RXBUF              256     /* number of RX descriptors/buffers */
  51 #endif
  52
  53 #define MALO_TXDESC             1       /* max tx descriptors/segments */
  54
  55 #define MALO_RXSIZE             PAGE_SIZE
  56 #define MALO_RSSI_DUMMY_MARKER  127
  57 #define MALO_RSSI_EP_MULTIPLIER (1<<7)  /* pow2 to optimize out * and / */
  58
  59 #define MALO_REG_INT_CODE                       0x00000C14
  60 /* From host to ARM */
  61 #define MALO_REG_H2A_INTERRUPT_EVENTS           0x00000C18
  62
  63 /* bit definitions for MALO_REG_H2A_INTERRUPT_CAUSE */
  64 #define MALO_H2ARIC_BIT_PPA_READY               0x00000001
  65 #define MALO_H2ARIC_BIT_DOOR_BELL               0x00000002 /* bit 1 */
  66 #define MALO_H2ARIC_BIT_PS                      0x00000004
  67 #define MALO_H2ARIC_BIT_PSPOLL                  0x00000008 /* bit 3 */
  68
  69 /* From ARM to host */
  70 #define MALO_REG_A2H_INTERRUPT_CAUSE            0x00000C30
  71 #define MALO_REG_A2H_INTERRUPT_MASK             0x00000C34
  72 #define MALO_REG_A2H_INTERRUPT_CLEAR_SEL        0x00000C38
  73 #define MALO_REG_A2H_INTERRUPT_STATUS_MASK      0x00000C3C
  74
  75 /* bit definitions for MALO_REG_A2H_INTERRUPT_CAUSE */
  76 #define MALO_A2HRIC_BIT_TX_DONE                 0x00000001      /* bit 0 */
  77 #define MALO_A2HRIC_BIT_RX_RDY                  0x00000002      /* bit 1 */
  78 #define MALO_A2HRIC_BIT_OPC_DONE                0x00000004
  79 #define MALO_A2HRIC_BIT_MAC_EVENT               0x00000008
  80 #define MALO_A2HRIC_BIT_RX_PROBLEM              0x00000010
  81 #define MALO_A2HRIC_BIT_RADIO_OFF               0x00000020      /* bit 5 */
  82 #define MALO_A2HRIC_BIT_RADIO_ON                0x00000040
  83 #define MALO_A2HRIC_BIT_RADAR_DETECT            0x00000080
  84 #define MALO_A2HRIC_BIT_ICV_ERROR               0x00000100
  85 #define MALO_A2HRIC_BIT_MIC_ERROR               0x00000200      /* bit 9 */
  86 #define MALO_A2HRIC_BIT_QUEUE_EMPTY             0x00000400
  87 #define MALO_A2HRIC_BIT_QUEUE_FULL              0x00000800
  88 #define MALO_A2HRIC_BIT_CHAN_SWITCH             0x00001000
  89 #define MALO_A2HRIC_BIT_TX_WATCHDOG             0x00002000
  90 #define MALO_A2HRIC_BIT_BA_WATCHDOG             0x00004000
  91
  92 #define MALO_ISR_SRC_BITS                       \
  93         (MALO_A2HRIC_BIT_RX_RDY |               \
  94          MALO_A2HRIC_BIT_TX_DONE |              \
  95          MALO_A2HRIC_BIT_OPC_DONE |             \
  96          MALO_A2HRIC_BIT_MAC_EVENT |            \
  97          MALO_A2HRIC_BIT_MIC_ERROR |            \
  98          MALO_A2HRIC_BIT_ICV_ERROR |            \
  99          MALO_A2HRIC_BIT_RADAR_DETECT |         \
 100          MALO_A2HRIC_BIT_CHAN_SWITCH |          \
 101          MALO_A2HRIC_BIT_TX_WATCHDOG |          \
 102          MALO_A2HRIC_BIT_QUEUE_EMPTY)
 103 #define MALO_ISR_RESET                          (1<<15)
 104
 105 #define MALO_A2HRIC_BIT_MASK                    MALO_ISR_SRC_BITS
 106
 107 /* map to 0x80000000 on BAR1  */
 108 #define MALO_REG_GEN_PTR                        0x00000C10
 109 #define MALO_REG_INT_CODE                       0x00000C14
 110 #define MALO_REG_SCRATCH                        0x00000C40
 111
 112 /*
 113  * define OpMode for SoftAP/Station mode
 114  *
 115  * the following mode signature has to be written to PCI scratch register#0
 116  * right after successfully downloading the last block of firmware and
 117  * before waiting for firmware ready signature
 118  */
 119 #define MALO_HOSTCMD_STA_MODE                   0x5A
 120 #define MALO_HOSTCMD_STA_FWRDY_SIGNATURE        0xF0F1F2F4
 121
 122 /*
 123  * 16 bit host command code
 124  */
 125 #define MALO_HOSTCMD_NONE                       0x0000
 126 #define MALO_HOSTCMD_CODE_DNLD                  0x0001
 127 #define MALO_HOSTCMD_GET_HW_SPEC                0x0003
 128 #define MALO_HOSTCMD_SET_HW_SPEC                0x0004
 129 #define MALO_HOSTCMD_MAC_MULTICAST_ADR          0x0010
 130 #define MALO_HOSTCMD_SET_WEPKEY                 0x0013
 131 #define MALO_HOSTCMD_802_11_RADIO_CONTROL       0x001c
 132 #define MALO_HOSTCMD_802_11_RF_TX_POWER         0x001e
 133 #define MALO_HOSTCMD_802_11_RF_ANTENNA          0x0020
 134 #define MALO_HOSTCMD_SET_PRE_SCAN               0x0107
 135 #define MALO_HOSTCMD_SET_POST_SCAN              0x0108
 136 #define MALO_HOSTCMD_SET_RF_CHANNEL             0x010a
 137 #define MALO_HOSTCMD_SET_AID                    0x010d
 138 #define MALO_HOSTCMD_SET_RATE                   0x0110
 139 #define MALO_HOSTCMD_SET_SLOT                   0x0114
 140 /* define DFS lab commands  */
 141 #define MALO_HOSTCMD_SET_FIXED_RATE             0x0126
 142 #define MALO_HOSTCMD_SET_REGION_POWER           0x0128
 143 #define MALO_HOSTCMD_GET_CALTABLE               0x1134
 144
 145 /*
 146  * definition of action or option for each command.
 147  */
 148 /* define general purpose action  */
 149 #define MALO_HOSTCMD_ACT_GEN_GET                0x0000
 150 #define MALO_HOSTCMD_ACT_GEN_SET                0x0001
 151 #define MALO_HOSTCMD_ACT_GEN_SET_LIST           0x0002
 152
 153 /* define action or option for HostCmd_FW_USE_FIXED_RATE */
 154 #define MALO_HOSTCMD_ACT_USE_FIXED_RATE         0x0001
 155 #define MALO_HOSTCMD_ACT_NOT_USE_FIXED_RATE     0x0002
 156
 157 /* INT code register event definition  */
 158 #define MALO_INT_CODE_CMD_FINISHED              0x00000005
 159
 160 struct malo_cmd_header {
 161         uint16_t                cmd;
 162         uint16_t                length;
 163         uint16_t                seqnum;
 164         uint16_t                result;
 165 } __packed;
 166
 167 struct malo_cmd_caltable {
 168         struct malo_cmd_header  cmdhdr;
 169         uint8_t                 annex;
 170         uint8_t                 index;
 171         uint8_t                 len;
 172         uint8_t                 reserverd;
 173 #define MALO_CAL_TBL_SIZE       160
 174         uint8_t                 caltbl[MALO_CAL_TBL_SIZE];
 175 } __packed;
 176
 177 struct malo_cmd_get_hwspec {
 178         struct malo_cmd_header  cmdhdr;
 179         u_int8_t                version;        /* version of the HW  */
 180         u_int8_t                hostif;         /* host interface  */
 181         /* Max. number of WCB FW can handle  */
 182         u_int16_t               num_wcb;
 183         /* MaxNbr of MC addresses FW can handle */
 184         u_int16_t               num_mcastaddr;
 185         /* MAC address programmed in HW */
 186         u_int8_t                permaddr[6];
 187         u_int16_t               regioncode;
 188         /* Number of antenna used */
 189         u_int16_t               num_antenna;
 190         /* 4 byte of FW release number */
 191         u_int32_t               fw_releasenum;
 192         u_int32_t               wcbbase0;
 193         u_int32_t               rxpdwr_ptr;
 194         u_int32_t               rxpdrd_ptr;
 195         u_int32_t               ul_fw_awakecookie;
 196         u_int32_t               wcbbase1;
 197         u_int32_t               wcbbase2;
 198         u_int32_t               wcbbase3;
 199 } __packed;
 200
 201 struct malo_cmd_set_hwspec {
 202         struct malo_cmd_header  cmdhdr;
 203         uint8_t                 version;        /* HW revision */
 204         uint8_t                 hostif;         /* Host interface */
 205         /* Max. number of Multicast address FW can handle */
 206         uint16_t                num_mcastaddr;
 207         uint8_t                 permaddr[6];    /* MAC address */
 208         uint16_t                regioncode;     /* Region Code */
 209         /* 4 byte of FW release number */
 210         uint32_t                fwreleasenum;
 211         /* Firmware awake cookie */
 212         uint32_t                ul_fw_awakecookie;
 213         /* Device capabilities (see above) */
 214         uint32_t                devicecaps;
 215         uint32_t                rxpdwrptr;      /* Rx shared memory queue  */
 216         /* # TX queues in WcbBase array */
 217         uint32_t                num_txqueues;
 218         /* TX WCB Rings */
 219         uint32_t                wcbbase[MALO_MAX_TXWCB_QUEUES];
 220         uint32_t                flags;
 221         uint32_t                txwcbnum_per_queue;
 222         uint32_t                total_rxwcb;
 223 } __packed;
 224
 225 /* DS 802.11 */
 226 struct malo_cmd_rf_antenna {
 227         struct malo_cmd_header  cmdhdr;
 228         uint16_t                action;
 229         /* Number of antennas or 0xffff (diversity)  */
 230         uint16_t                mode;
 231 } __packed;
 232
 233 struct malo_cmd_radio_control {
 234         struct malo_cmd_header  cmdhdr;
 235         uint16_t                action;
 236         /*
 237          * bit 0 : 1 = on, 0 = off
 238          * bit 1 : 1 = long, 0 = short
 239          * bit 2 : 1 = auto, 0 = fix
 240          */
 241         uint16_t                control;
 242         uint16_t                radio_on;
 243 } __packed;
 244
 245 struct malo_cmd_fw_set_wmmmode {
 246         struct malo_cmd_header  cmdhdr;
 247         uint16_t                action; /* 0 -> unset, 1 -> set  */
 248 } __packed;
 249
 250 struct malo_cmd_fw_set_rf_channel {
 251         struct malo_cmd_header  cmdhdr;
 252         uint16_t                action;
 253         uint8_t                 cur_channel;    /* channel # */
 254 } __packed;
 255
 256 #define MALO_TX_POWER_LEVEL_TOTAL       8
 257 struct malo_cmd_rf_tx_power {
 258         struct malo_cmd_header  cmdhdr;
 259         uint16_t                action;
 260         uint16_t                support_txpower_level;
 261         uint16_t                current_txpower_level;
 262         uint16_t                reserved;
 263         uint16_t                power_levellist[MALO_TX_POWER_LEVEL_TOTAL];
 264 } __packed;
 265
 266 struct malo_fixrate_flag {
 267         /* lower rate after the retry count.  0 = legacy, 1 = HT  */
 268         uint32_t                type;
 269         /* 0: retry count is not valid, 1: use retry count specified  */
 270         uint32_t                retrycount_valid;
 271 } __packed;
 272
 273 struct malo_fixed_rate_entry {
 274         struct malo_fixrate_flag typeflags;
 275         /* legacy rate(not index) or an MCS code.  */
 276         uint32_t                fixedrate;
 277         uint32_t                retrycount;
 278 } __packed;
 279
 280 struct malo_cmd_fw_use_fixed_rate {
 281         struct malo_cmd_header  cmdhdr;
 282         /*
 283          * MALO_HOSTCMD_ACT_GEN_GET     0x0000
 284          * MALO_HOSTCMD_ACT_GEN_SET     0x0001
 285          * MALO_HOSTCMD_ACT_NOT_USE_FIXED_RATE  0x0002
 286          */
 287         uint32_t                action;
 288         /* use fixed rate specified but firmware can drop to  */
 289         uint32_t                allowratedrop;
 290         uint32_t                entrycount;
 291         struct malo_fixed_rate_entry fixedrate_table[4];
 292         uint8_t                 multicast_rate;
 293         uint8_t                 multirate_txtype;
 294         uint8_t                 management_rate;
 295 } __packed;
 296
 297 #define MALO_RATE_INDEX_MAX_ARRAY               14
 298
 299 struct malo_cmd_fw_set_aid {
 300         struct malo_cmd_header  cmdhdr;
 301         uint16_t                associd;
 302         uint8_t                 macaddr[6];     /* AP's Mac Address(BSSID) */
 303         uint32_t                gprotection;
 304         uint8_t                 aprates[MALO_RATE_INDEX_MAX_ARRAY];
 305 } __packed;
 306
 307 struct malo_cmd_prescan {
 308         struct malo_cmd_header  cmdhdr;
 309 } __packed;
 310
 311 struct malo_cmd_postscan {
 312         struct malo_cmd_header  cmdhdr;
 313         uint32_t                isibss;
 314         uint8_t                 bssid[6];
 315 } __packed;
 316
 317 struct malo_cmd_fw_setslot {
 318         struct malo_cmd_header  cmdhdr;
 319         uint16_t                action;
 320         /* slot = 0 if regular, slot = 1 if short.  */
 321         uint8_t                 slot;
 322 };
 323
 324 struct malo_cmd_set_rate {
 325         struct malo_cmd_header  cmdhdr;
 326         uint8_t                 dataratetype;
 327         uint8_t                 rateindex;
 328         uint8_t                 aprates[14];
 329 } __packed;
 330
 331 struct malo_cmd_wepkey {
 332         struct malo_cmd_header  cmdhdr;
 333         uint16_t                action;
 334         uint8_t                 len;
 335         uint8_t                 flags;
 336         uint16_t                index;
 337         uint8_t                 value[IEEE80211_KEYBUF_SIZE];
 338         uint8_t                 txmickey[IEEE80211_WEP_MICLEN];
 339         uint8_t                 rxmickey[IEEE80211_WEP_MICLEN];
 340         uint64_t                rxseqctr;
 341         uint64_t                txseqctr;
 342 } __packed;
 343
 344 struct malo_cmd_mcast {
 345         struct malo_cmd_header  cmdhdr;
 346         uint16_t                action;
 347         uint16_t                numaddr;
 348 #define MALO_HAL_MCAST_MAX      32
 349         uint8_t                 maclist[6*32];
 350 } __packed;
 351
 352 /*
 353  * DMA state for tx/rx descriptors.
 354  */
 355
 356 /*
 357  * Common "base class" for tx/rx descriptor resources
 358  * allocated using the bus dma api.
 359  */
 360 struct malo_descdma {
 361         const char*             dd_name;
 362         void                    *dd_desc;       /* descriptors */
 363         bus_addr_t              dd_desc_paddr;  /* physical addr of dd_desc */
 364         bus_size_t              dd_desc_len;    /* size of dd_desc */
 365         bus_dma_segment_t       dd_dseg;
 366         int                     dd_dnseg;       /* number of segments */
 367         bus_dma_tag_t           dd_dmat;        /* bus DMA tag */
 368         bus_dmamap_t            dd_dmamap;      /* DMA map for descriptors */
 369         void                    *dd_bufptr;     /* associated buffers */
 370 };
 371
 372 /*
 373  * Hardware tx/rx descriptors.
 374  *
 375  * NB: tx descriptor size must match f/w expected size
 376  * because f/w prefetch's the next descriptor linearly
 377  * and doesn't chase the next pointer.
 378  */
 379 struct malo_txdesc {
 380         uint32_t                status;
 381 #define MALO_TXD_STATUS_IDLE                    0x00000000
 382 #define MALO_TXD_STATUS_USED                    0x00000001
 383 #define MALO_TXD_STATUS_OK                      0x00000001
 384 #define MALO_TXD_STATUS_OK_RETRY                0x00000002
 385 #define MALO_TXD_STATUS_OK_MORE_RETRY           0x00000004
 386 #define MALO_TXD_STATUS_MULTICAST_TX            0x00000008
 387 #define MALO_TXD_STATUS_BROADCAST_TX            0x00000010
 388 #define MALO_TXD_STATUS_FAILED_LINK_ERROR       0x00000020
 389 #define MALO_TXD_STATUS_FAILED_EXCEED_LIMIT     0x00000040
 390 #define MALO_TXD_STATUS_FAILED_XRETRY   MALO_TXD_STATUS_FAILED_EXCEED_LIMIT
 391 #define MALO_TXD_STATUS_FAILED_AGING            0x00000080
 392 #define MALO_TXD_STATUS_FW_OWNED                0x80000000
 393         uint8_t                 datarate;
 394         uint8_t                 txpriority;
 395         uint16_t                qosctrl;
 396         uint32_t                pktptr;
 397         uint16_t                pktlen;
 398         uint8_t                 destaddr[6];
 399         uint32_t                physnext;
 400         uint32_t                sap_pktinfo;
 401         uint16_t                format;
 402 #define MALO_TXD_FORMAT         0x0001  /* frame format/rate */
 403 #define MALO_TXD_FORMAT_LEGACY  0x0000  /* legacy rate frame */
 404 #define MALO_TXD_RATE           0x01f8  /* tx rate (legacy)/ MCS */
 405 #define MALO_TXD_RATE_S         3
 406 /* NB: 3 is reserved */
 407 #define MALO_TXD_ANTENNA        0x1800  /* antenna select */
 408 #define MALO_TXD_ANTENNA_S      11
 409         uint16_t                pad;    /* align to 4-byte boundary */
 410 } __packed;
 411
 412 #define MALO_TXDESC_SYNC(txq, ds, how) do {                             \
 413         bus_dmamap_sync((txq)->dma.dd_dmat, (txq)->dma.dd_dmamap, how); \
 414 } while(0)
 415
 416 struct malo_rxdesc {
 417         uint8_t         rxcontrol;      /* control element */
 418 #define MALO_RXD_CTRL_DRIVER_OWN                0x00
 419 #define MALO_RXD_CTRL_OS_OWN                    0x04
 420 #define MALO_RXD_CTRL_DMA_OWN                   0x80
 421         uint8_t         snr;            /* signal to noise ratio */
 422         uint8_t         status;         /* status field w/ USED bit */
 423 #define MALO_RXD_STATUS_IDLE                    0x00
 424 #define MALO_RXD_STATUS_OK                      0x01
 425 #define MALO_RXD_STATUS_MULTICAST_RX            0x02
 426 #define MALO_RXD_STATUS_BROADCAST_RX            0x04
 427 #define MALO_RXD_STATUS_FRAGMENT_RX             0x08
 428 #define MALO_RXD_STATUS_GENERAL_DECRYPT_ERR     0xff
 429 #define MALO_RXD_STATUS_DECRYPT_ERR_MASK        0x80
 430 #define MALO_RXD_STATUS_TKIP_MIC_DECRYPT_ERR    0x02
 431 #define MALO_RXD_STATUS_WEP_ICV_DECRYPT_ERR     0x04
 432 #define MALO_RXD_STATUS_TKIP_ICV_DECRYPT_ERR    0x08
 433         uint8_t         channel;        /* channel # pkt received on */
 434         uint16_t        pktlen;         /* total length of received data */
 435         uint8_t         nf;             /* noise floor */
 436         uint8_t         rate;           /* received data rate */
 437         uint32_t        physbuffdata;   /* physical address of payload data */
 438         uint32_t        physnext;       /* physical address of next RX desc */
 439         uint16_t        qosctrl;        /* received QosCtrl field variable */
 440         uint16_t        htsig2;         /* like name states */
 441 } __packed;
 442
 443 #define MALO_RXDESC_SYNC(sc, ds, how) do {                              \
 444         bus_dmamap_sync((sc)->malo_rxdma.dd_dmat,                       \
 445             (sc)->malo_rxdma.dd_dmamap, how);                           \
 446 } while (0)
 447
 448 struct malo_rxbuf {
 449         STAILQ_ENTRY(malo_rxbuf) bf_list;
 450         void                    *bf_desc;       /* h/w descriptor */
 451         bus_addr_t              bf_daddr;       /* physical addr of desc */
 452         bus_dmamap_t            bf_dmamap;
 453         bus_addr_t              bf_data;        /* physical addr of rx data */
 454         struct mbuf             *bf_m;          /* jumbo mbuf */
 455 };
 456 typedef STAILQ_HEAD(, malo_rxbuf) malo_rxbufhead;
 457
 458 /*
 459  * Software backed version of tx/rx descriptors.  We keep
 460  * the software state out of the h/w descriptor structure
 461  * so that may be allocated in uncached memory w/o paying
 462  * performance hit.
 463  */
 464 struct malo_txbuf {
 465         STAILQ_ENTRY(malo_txbuf) bf_list;
 466         void                    *bf_desc;       /* h/w descriptor */
 467         bus_addr_t              bf_daddr;       /* physical addr of desc */
 468         bus_dmamap_t            bf_dmamap;      /* DMA map for descriptors */
 469         int                     bf_nseg;
 470         bus_dma_segment_t       bf_segs[MALO_TXDESC];
 471         struct mbuf             *bf_m;
 472         struct ieee80211_node   *bf_node;
 473         struct malo_txq         *bf_txq;        /* backpointer to tx q/ring */
 474 };
 475 typedef STAILQ_HEAD(, malo_txbuf) malo_txbufhead;
 476
 477 /*
 478  * TX/RX ring definitions.  There are 4 tx rings, one
 479  * per AC, and 1 rx ring.  Note carefully that transmit
 480  * descriptors are treated as a contiguous chunk and the
 481  * firmware pre-fetches descriptors.  This means that we
 482  * must preserve order when moving descriptors between
 483  * the active+free lists; otherwise we may stall transmit.
 484  */
 485 struct malo_txq {
 486         struct malo_descdma     dma;            /* bus dma resources */
 487         struct mtx              lock;           /* tx q lock */
 488         char                    name[12];       /* e.g. "malo0_txq4" */
 489         int                     qnum;           /* f/w q number */
 490         int                     txpri;          /* f/w tx priority */
 491         int                     nfree;          /* # buffers on free list */
 492         malo_txbufhead          free;           /* queue of free buffers */
 493         malo_txbufhead          active;         /* queue of active buffers */
 494 };
 495
 496 #define MALO_TXQ_LOCK_INIT(_sc, _tq) do { \
 497         snprintf((_tq)->name, sizeof((_tq)->name), "%s_txq%u", \
 498                 device_get_nameunit((_sc)->malo_dev), (_tq)->qnum); \
 499         mtx_init(&(_tq)->lock, (_tq)->name, NULL, MTX_DEF); \
 500 } while (0)
 501 #define MALO_TXQ_LOCK_DESTROY(_tq)      mtx_destroy(&(_tq)->lock)
 502 #define MALO_TXQ_LOCK(_tq)              mtx_lock(&(_tq)->lock)
 503 #define MALO_TXQ_UNLOCK(_tq)            mtx_unlock(&(_tq)->lock)
 504 #define MALO_TXQ_LOCK_ASSERT(_tq)       mtx_assert(&(_tq)->lock, MA_OWNED)
 505
 506 /*
 507  * Each packet has fixed front matter: a 2-byte length
 508  * of the payload, followed by a 4-address 802.11 header
 509  * (regardless of the actual header and always w/o any
 510  * QoS header).  The payload then follows.
 511  */
 512 struct malo_txrec {
 513         uint16_t fwlen;
 514         struct ieee80211_frame_addr4 wh;
 515 } __packed;
 516
 517 struct malo_vap {
 518         struct ieee80211vap malo_vap;
 519         int                     (*malo_newstate)(struct ieee80211vap *,
 520                                     enum ieee80211_state, int);
 521 };
 522 #define MALO_VAP(vap)   ((struct malo_vap *)(vap))
 523
 524 struct malo_softc {
 525         struct ieee80211com     malo_ic;
 526         struct mbufq            malo_snd;
 527         device_t                malo_dev;
 528         struct mtx              malo_mtx;       /* master lock (recursive) */
 529         struct taskqueue        *malo_tq;       /* private task queue */
 530
 531         bus_dma_tag_t           malo_dmat;      /* bus DMA tag */
 532         bus_space_handle_t      malo_io0h;      /* BAR 0 */
 533         bus_space_tag_t         malo_io0t;
 534         bus_space_handle_t      malo_io1h;      /* BAR 1 */
 535         bus_space_tag_t         malo_io1t;
 536
 537         unsigned int            malo_invalid: 1,/* disable hardware accesses */
 538                                 malo_recvsetup: 1,      /* recv setup */
 539                                 malo_fixedrate: 1,      /* use fixed tx rate */
 540                                 malo_running: 1;
 541
 542         struct malo_hal         *malo_mh;       /* h/w access layer */
 543         struct malo_hal_hwspec  malo_hwspecs;   /* h/w capabilities */
 544         struct malo_hal_txrxdma malo_hwdma;     /* h/w dma setup */
 545         uint32_t                malo_imask;     /* interrupt mask copy */
 546         struct malo_hal_channel malo_curchan;
 547         u_int16_t               malo_rxantenna; /* rx antenna */
 548         u_int16_t               malo_txantenna; /* tx antenna */
 549
 550         struct malo_descdma     malo_rxdma;     /* rx bus dma resources */
 551         malo_rxbufhead          malo_rxbuf;     /* rx buffers */
 552         struct malo_rxbuf       *malo_rxnext;   /* next rx buffer to process */
 553         struct task             malo_rxtask;    /* rx int processing */
 554
 555         struct malo_txq         malo_txq[MALO_NUM_TX_QUEUES];
 556         struct task             malo_txtask;    /* tx int processing */
 557         struct callout  malo_watchdog_timer;
 558         int                     malo_timer;
 559
 560         struct malo_tx_radiotap_header malo_tx_th;
 561         struct malo_rx_radiotap_header malo_rx_th;
 562
 563         struct malo_stats       malo_stats;     /* interface statistics */
 564         int                     malo_debug;
 565 };
 566
 567 #define MALO_LOCK_INIT(_sc) \
 568         mtx_init(&(_sc)->malo_mtx, device_get_nameunit((_sc)->malo_dev), \
 569                  NULL, MTX_DEF | MTX_RECURSE)
 570 #define MALO_LOCK_DESTROY(_sc)          mtx_destroy(&(_sc)->malo_mtx)
 571 #define MALO_LOCK(_sc)                  mtx_lock(&(_sc)->malo_mtx)
 572 #define MALO_UNLOCK(_sc)                mtx_unlock(&(_sc)->malo_mtx)
 573 #define MALO_LOCK_ASSERT(_sc)           mtx_assert(&(_sc)->malo_mtx, MA_OWNED)
 574
 575 #define MALO_RXFREE_INIT(_sc)                                           \
 576         mtx_init(&(_sc)->malo_rxlock, device_get_nameunit((_sc)->malo_dev), \
 577                  NULL, MTX_DEF)
 578 #define MALO_RXFREE_DESTROY(_sc)        mtx_destroy(&(_sc)->malo_rxlock)
 579 #define MALO_RXFREE_LOCK(_sc)           mtx_lock(&(_sc)->malo_rxlock)
 580 #define MALO_RXFREE_UNLOCK(_sc)         mtx_unlock(&(_sc)->malo_rxlock)
 581 #define MALO_RXFREE_ASSERT(_sc)         mtx_assert(&(_sc)->malo_rxlock, \
 582         MA_OWNED)
 583
 584 int     malo_attach(uint16_t, struct malo_softc *);
 585 int     malo_intr(void *);
 586 int     malo_detach(struct malo_softc *);
 587 void    malo_shutdown(struct malo_softc *);
 588 void    malo_suspend(struct malo_softc *);
 589 void    malo_resume(struct malo_softc *);
 590
 591 #endif