sys/dev/iwi/if_iwivar.h

   1 /*      $FreeBSD$       */
   2
   3 /*-
   4  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   5  *
   6  * Copyright (c) 2004, 2005
   7  *      Damien Bergamini <damien.bergamini@free.fr>. 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 unmodified, this list of conditions, and the following
  14  *    disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 struct iwi_rx_radiotap_header {
  33         struct ieee80211_radiotap_header wr_ihdr;
  34         uint8_t         wr_flags;
  35         uint8_t         wr_rate;
  36         uint16_t        wr_chan_freq;
  37         uint16_t        wr_chan_flags;
  38         int8_t          wr_antsignal;
  39         int8_t          wr_antnoise;
  40         uint8_t         wr_antenna;
  41 } __packed __aligned(8);
  42
  43 #define IWI_RX_RADIOTAP_PRESENT                                         \
  44         ((1 << IEEE80211_RADIOTAP_FLAGS) |                              \
  45          (1 << IEEE80211_RADIOTAP_RATE) |                               \
  46          (1 << IEEE80211_RADIOTAP_CHANNEL) |                            \
  47          (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |                      \
  48          (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |                       \
  49          (1 << IEEE80211_RADIOTAP_ANTENNA))
  50
  51 struct iwi_tx_radiotap_header {
  52         struct ieee80211_radiotap_header wt_ihdr;
  53         uint8_t         wt_flags;
  54         uint8_t         wt_pad;
  55         uint16_t        wt_chan_freq;
  56         uint16_t        wt_chan_flags;
  57 } __packed;
  58
  59 #define IWI_TX_RADIOTAP_PRESENT                                         \
  60         ((1 << IEEE80211_RADIOTAP_FLAGS) |                              \
  61          (1 << IEEE80211_RADIOTAP_CHANNEL))
  62
  63 struct iwi_cmd_ring {
  64         bus_dma_tag_t           desc_dmat;
  65         bus_dmamap_t            desc_map;
  66         bus_addr_t              physaddr;
  67         struct iwi_cmd_desc     *desc;
  68         int                     count;
  69         int                     queued;
  70         int                     cur;
  71         int                     next;
  72 };
  73
  74 struct iwi_tx_data {
  75         bus_dmamap_t            map;
  76         struct mbuf             *m;
  77         struct ieee80211_node   *ni;
  78 };
  79
  80 struct iwi_tx_ring {
  81         bus_dma_tag_t           desc_dmat;
  82         bus_dma_tag_t           data_dmat;
  83         bus_dmamap_t            desc_map;
  84         bus_addr_t              physaddr;
  85         bus_addr_t              csr_ridx;
  86         bus_addr_t              csr_widx;
  87         struct iwi_tx_desc      *desc;
  88         struct iwi_tx_data      *data;
  89         int                     count;
  90         int                     queued;
  91         int                     cur;
  92         int                     next;
  93 };
  94
  95 struct iwi_rx_data {
  96         bus_dmamap_t    map;
  97         bus_addr_t      physaddr;
  98         uint32_t        reg;
  99         struct mbuf     *m;
 100 };
 101
 102 struct iwi_rx_ring {
 103         bus_dma_tag_t           data_dmat;
 104         struct iwi_rx_data      *data;
 105         int                     count;
 106         int                     cur;
 107 };
 108
 109 struct iwi_node {
 110         struct ieee80211_node   in_node;
 111         int                     in_station;
 112 #define IWI_MAX_IBSSNODE        32
 113 };
 114
 115 struct iwi_fw {
 116         const struct firmware   *fp;            /* image handle */
 117         const char              *data;          /* firmware image data */
 118         size_t                  size;           /* firmware image size */
 119         const char              *name;          /* associated image name */
 120 };
 121
 122 struct iwi_vap {
 123         struct ieee80211vap     iwi_vap;
 124
 125         int                     (*iwi_newstate)(struct ieee80211vap *,
 126                                     enum ieee80211_state, int);
 127 };
 128 #define IWI_VAP(vap)    ((struct iwi_vap *)(vap))
 129
 130 struct iwi_softc {
 131         struct mtx              sc_mtx;
 132         struct ieee80211com     sc_ic;
 133         struct mbufq            sc_snd;
 134         device_t                sc_dev;
 135
 136         void                    (*sc_node_free)(struct ieee80211_node *);
 137
 138         uint8_t                 sc_mcast[IEEE80211_ADDR_LEN];
 139         struct unrhdr           *sc_unr;
 140
 141         uint32_t                flags;
 142 #define IWI_FLAG_FW_INITED      (1 << 0)
 143 #define IWI_FLAG_BUSY           (1 << 3)        /* busy sending a command */
 144 #define IWI_FLAG_ASSOCIATED     (1 << 4)        /* currently associated  */
 145 #define IWI_FLAG_CHANNEL_SCAN   (1 << 5)
 146         uint32_t                fw_state;
 147 #define IWI_FW_IDLE             0
 148 #define IWI_FW_LOADING          1
 149 #define IWI_FW_ASSOCIATING      2
 150 #define IWI_FW_DISASSOCIATING   3
 151 #define IWI_FW_SCANNING         4
 152         struct iwi_cmd_ring     cmdq;
 153         struct iwi_tx_ring      txq[WME_NUM_AC];
 154         struct iwi_rx_ring      rxq;
 155
 156         struct resource         *irq;
 157         struct resource         *mem;
 158         bus_space_tag_t         sc_st;
 159         bus_space_handle_t      sc_sh;
 160         void                    *sc_ih;
 161
 162         /*
 163          * The card needs external firmware images to work, which is made of a
 164          * bootloader, microcode and firmware proper. In version 3.00 and
 165          * above, all pieces are contained in a single image, preceded by a
 166          * struct iwi_firmware_hdr indicating the size of the 3 pieces.
 167          * Old firmware < 3.0 has separate boot and ucode, so we need to
 168          * load all of them explicitly.
 169          * To avoid issues related to fragmentation, we keep the block of
 170          * dma-ble memory around until detach time, and reallocate it when
 171          * it becomes too small. fw_dma_size is the size currently allocated.
 172          */
 173         int                     fw_dma_size;
 174         uint32_t                fw_flags;       /* allocation status */
 175 #define IWI_FW_HAVE_DMAT        0x01
 176 #define IWI_FW_HAVE_MAP         0x02
 177 #define IWI_FW_HAVE_PHY         0x04
 178         bus_dma_tag_t           fw_dmat;
 179         bus_dmamap_t            fw_map;
 180         bus_addr_t              fw_physaddr;
 181         void                    *fw_virtaddr;
 182         enum ieee80211_opmode   fw_mode;        /* mode of current firmware */
 183         struct iwi_fw           fw_boot;        /* boot firmware */
 184         struct iwi_fw           fw_uc;          /* microcode */
 185         struct iwi_fw           fw_fw;          /* operating mode support */
 186
 187         int                     curchan;        /* current h/w channel # */
 188         int                     antenna;
 189         int                     bluetooth;
 190         struct iwi_associate    assoc;
 191         struct iwi_wme_params   wme[3];
 192         u_int                   sc_scangen;
 193
 194         struct task             sc_radiontask;  /* radio on processing */
 195         struct task             sc_radiofftask; /* radio off processing */
 196         struct task             sc_restarttask; /* restart adapter processing */
 197         struct task             sc_disassoctask;
 198         struct task             sc_monitortask;
 199
 200         unsigned int            sc_running : 1, /* initialized */
 201                                 sc_softled : 1, /* enable LED gpio status */
 202                                 sc_ledstate: 1, /* LED on/off state */
 203                                 sc_blinking: 1; /* LED blink operation active */
 204         u_int                   sc_nictype;     /* NIC type from EEPROM */
 205         u_int                   sc_ledpin;      /* mask for activity LED */
 206         u_int                   sc_ledidle;     /* idle polling interval */
 207         int                     sc_ledevent;    /* time of last LED event */
 208         u_int8_t                sc_rxrate;      /* current rx rate for LED */
 209         u_int8_t                sc_rxrix;
 210         u_int8_t                sc_txrate;      /* current tx rate for LED */
 211         u_int8_t                sc_txrix;
 212         u_int16_t               sc_ledoff;      /* off time for current blink */
 213         struct callout          sc_ledtimer;    /* led off timer */
 214         struct callout          sc_wdtimer;     /* watchdog timer */
 215         struct callout          sc_rftimer;     /* rfkill timer */
 216
 217         int                     sc_tx_timer;
 218         int                     sc_state_timer; /* firmware state timer */
 219         int                     sc_busy_timer;  /* firmware cmd timer */
 220
 221         struct iwi_rx_radiotap_header sc_rxtap;
 222         struct iwi_tx_radiotap_header sc_txtap;
 223
 224         struct iwi_notif_link_quality sc_linkqual;
 225         int                     sc_linkqual_valid;
 226 };
 227
 228 #define IWI_STATE_BEGIN(_sc, _state)    do {                    \
 229         KASSERT(_sc->fw_state == IWI_FW_IDLE,                   \
 230             ("iwi firmware not idle, state %s", iwi_fw_states[_sc->fw_state]));\
 231         _sc->fw_state = _state;                                 \
 232         _sc->sc_state_timer = 5;                                \
 233         DPRINTF(("enter %s state\n", iwi_fw_states[_state]));   \
 234 } while (0)
 235
 236 #define IWI_STATE_END(_sc, _state)      do {                    \
 237         if (_sc->fw_state == _state)                            \
 238                 DPRINTF(("exit %s state\n", iwi_fw_states[_state])); \
 239          else                                                   \
 240                 DPRINTF(("expected %s state, got %s\n", \
 241                     iwi_fw_states[_state], iwi_fw_states[_sc->fw_state])); \
 242         _sc->fw_state = IWI_FW_IDLE;                            \
 243         wakeup(_sc);                                            \
 244         _sc->sc_state_timer = 0;                                \
 245 } while (0)
 246 /*
 247  * NB.: This models the only instance of async locking in iwi_init_locked
 248  *      and must be kept in sync.
 249  */
 250 #define IWI_LOCK_INIT(sc) \
 251         mtx_init(&(sc)->sc_mtx, device_get_nameunit((sc)->sc_dev), \
 252             MTX_NETWORK_LOCK, MTX_DEF)
 253 #define IWI_LOCK_DESTROY(sc)    mtx_destroy(&(sc)->sc_mtx)
 254 #define IWI_LOCK_DECL   int     __waslocked = 0
 255 #define IWI_LOCK_ASSERT(sc)     mtx_assert(&(sc)->sc_mtx, MA_OWNED)
 256 #define IWI_LOCK(sc)    do {                            \
 257         if (!(__waslocked = mtx_owned(&(sc)->sc_mtx)))  \
 258                 mtx_lock(&(sc)->sc_mtx);                \
 259 } while (0)
 260 #define IWI_UNLOCK(sc)  do {                    \
 261         if (!__waslocked)                       \
 262                 mtx_unlock(&(sc)->sc_mtx);      \
 263 } while (0)