sys/dev/wpi/if_wpivar.h

   1 /*      $FreeBSD$       */
   2
   3 /*-
   4  * Copyright (c) 2006,2007
   5  *      Damien Bergamini <damien.bergamini@free.fr>
   6  *
   7  * Permission to use, copy, modify, and distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19 #include <net80211/ieee80211_amrr.h>
  20
  21 struct wpi_rx_radiotap_header {
  22         struct ieee80211_radiotap_header wr_ihdr;
  23         uint64_t        wr_tsft;
  24         uint8_t         wr_flags;
  25         uint8_t         wr_rate;
  26         uint16_t        wr_chan_freq;
  27         uint16_t        wr_chan_flags;
  28         int8_t          wr_dbm_antsignal;
  29         int8_t          wr_dbm_antnoise;
  30         uint8_t         wr_antenna;
  31 };
  32
  33 #define WPI_RX_RADIOTAP_PRESENT                                         \
  34         ((1 << IEEE80211_RADIOTAP_TSFT) |                               \
  35          (1 << IEEE80211_RADIOTAP_FLAGS) |                              \
  36          (1 << IEEE80211_RADIOTAP_RATE) |                               \
  37          (1 << IEEE80211_RADIOTAP_CHANNEL) |                            \
  38          (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |                      \
  39          (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |                       \
  40          (1 << IEEE80211_RADIOTAP_ANTENNA))
  41
  42 struct wpi_tx_radiotap_header {
  43         struct ieee80211_radiotap_header wt_ihdr;
  44         uint8_t         wt_flags;
  45         uint8_t         wt_rate;
  46         uint16_t        wt_chan_freq;
  47         uint16_t        wt_chan_flags;
  48         uint8_t         wt_hwqueue;
  49 };
  50
  51 #define WPI_TX_RADIOTAP_PRESENT                                         \
  52         ((1 << IEEE80211_RADIOTAP_FLAGS) |                              \
  53          (1 << IEEE80211_RADIOTAP_RATE) |                               \
  54          (1 << IEEE80211_RADIOTAP_CHANNEL))
  55
  56 struct wpi_dma_info {
  57         bus_dma_tag_t           tag;
  58         bus_dmamap_t            map;
  59         bus_addr_t              paddr;        /* aligned p address */
  60         bus_addr_t              paddr_start;  /* possibly unaligned p start*/
  61         caddr_t                 vaddr;        /* aligned v address */
  62         caddr_t                 vaddr_start;  /* possibly unaligned v start */
  63         bus_size_t              size;
  64 };
  65
  66 struct wpi_tx_data {
  67         bus_dmamap_t            map;
  68         struct mbuf             *m;
  69         struct ieee80211_node   *ni;
  70 };
  71
  72 struct wpi_tx_ring {
  73         struct wpi_dma_info     desc_dma;
  74         struct wpi_dma_info     cmd_dma;
  75         struct wpi_tx_desc      *desc;
  76         struct wpi_tx_cmd       *cmd;
  77         struct wpi_tx_data      *data;
  78         bus_dma_tag_t           data_dmat;
  79         int                     qid;
  80         int                     count;
  81         int                     queued;
  82         int                     cur;
  83 };
  84
  85 #define WPI_RBUF_COUNT ( WPI_RX_RING_COUNT + 16 )
  86
  87 struct wpi_rx_data {
  88         bus_dmamap_t            map;
  89         struct mbuf             *m;
  90 };
  91
  92 struct wpi_rx_ring {
  93         struct wpi_dma_info     desc_dma;
  94         uint32_t                *desc;
  95         struct wpi_rx_data      data[WPI_RX_RING_COUNT];
  96         bus_dma_tag_t           data_dmat;
  97         int                     cur;
  98 };
  99
 100 struct wpi_amrr {
 101         struct  ieee80211_node ni;      /* must be the first */
 102         int     txcnt;
 103         int     retrycnt;
 104         int     success;
 105         int     success_threshold;
 106         int     recovery;
 107 };
 108
 109 struct wpi_node {
 110         struct  ieee80211_node ni;      /* must be the first */
 111         struct  ieee80211_amrr_node     amn;
 112 };
 113 #define WPI_NODE(ni)    ((struct wpi_node *)(ni))
 114
 115 struct wpi_power_sample {
 116         uint8_t index;
 117         int8_t  power;
 118 };
 119
 120 struct wpi_power_group {
 121 #define WPI_SAMPLES_COUNT       5
 122         struct wpi_power_sample samples[WPI_SAMPLES_COUNT];
 123         uint8_t chan;
 124         int8_t  maxpwr;
 125         int16_t temp;
 126 };
 127
 128 struct wpi_vap {
 129         struct ieee80211vap     vap;
 130         struct ieee80211_amrr   amrr;
 131
 132         int                     (*newstate)(struct ieee80211vap *,
 133                                     enum ieee80211_state, int);
 134 };
 135 #define WPI_VAP(vap)    ((struct wpi_vap *)(vap))
 136
 137 struct wpi_softc {
 138         device_t                sc_dev;
 139         struct ifnet            *sc_ifp;
 140         struct mtx              sc_mtx;
 141
 142         /* Flags indicating the current state the driver
 143          * expects the hardware to be in
 144          */
 145         uint32_t                flags;
 146 #define WPI_FLAG_HW_RADIO_OFF   (1 << 0)
 147 #define WPI_FLAG_SCANNING       (1 << 1)
 148 #define WPI_FLAG_BUSY           (1 << 2)
 149 #define WPI_FLAG_AUTH           (1 << 3)
 150
 151         /* shared area */
 152         struct wpi_dma_info     shared_dma;
 153         struct wpi_shared       *shared;
 154
 155         struct wpi_tx_ring      txq[WME_NUM_AC];
 156         struct wpi_tx_ring      cmdq;
 157         struct wpi_rx_ring      rxq;
 158
 159         /* TX Thermal Callibration */
 160         struct callout          calib_to;
 161         int                     calib_cnt;
 162
 163         /* Watch dog timer */
 164         struct callout          watchdog_to;
 165         /* Hardware switch polling timer */
 166         struct callout          hwswitch_to;
 167
 168         struct resource         *irq;
 169         struct resource         *mem;
 170         bus_space_tag_t         sc_st;
 171         bus_space_handle_t      sc_sh;
 172         void                    *sc_ih;
 173         int                     mem_rid;
 174         int                     irq_rid;
 175
 176         struct wpi_config       config;
 177         int                     temp;
 178
 179
 180         int                     sc_tx_timer;
 181         int                     sc_scan_timer;
 182
 183         struct bpf_if           *sc_drvbpf;
 184
 185         struct wpi_rx_radiotap_header sc_rxtap;
 186         int                     sc_rxtap_len;
 187         struct wpi_tx_radiotap_header sc_txtap;
 188         int                     sc_txtap_len;
 189
 190         /* firmware image */
 191         const struct firmware   *fw_fp;
 192
 193         /* firmware DMA transfer */
 194         struct wpi_dma_info     fw_dma;
 195
 196         /* command queue related variables */
 197 #define WPI_SCAN_START          (1<<0)
 198 #define WPI_SCAN_CURCHAN        (1<<1)
 199 #define WPI_SCAN_STOP           (1<<2)
 200 #define WPI_SET_CHAN            (1<<3)
 201 #define WPI_AUTH                (1<<4)
 202 #define WPI_RUN                 (1<<5)
 203 #define WPI_SCAN_NEXT           (1<<6)
 204 #define WPI_RESTART             (1<<7)
 205 #define WPI_RF_RESTART          (1<<8)
 206 #define WPI_CMD_MAXOPS          10
 207         /* command queuing request type */
 208 #define WPI_QUEUE_NORMAL        0
 209 #define WPI_QUEUE_CLEAR         1
 210         int                     sc_cmd[WPI_CMD_MAXOPS];
 211         int                     sc_cmd_arg[WPI_CMD_MAXOPS];
 212         int                     sc_cmd_cur;    /* current queued scan task */
 213         int                     sc_cmd_next;   /* last queued scan task */
 214         struct mtx              sc_cmdlock;
 215
 216         /* Task queues used to control the driver */
 217         struct taskqueue        *sc_tq;         /* Main command task queue */
 218         struct taskqueue        *sc_tq2;        /* firmware reset task queue */
 219
 220         /* Tasks used by the driver */
 221         struct task             sc_radioontask; /* enable rf transmitter task*/
 222         struct task             sc_radioofftask;/* disable rf transmitter task*/
 223         struct task             sc_opstask;     /* operation handling task */
 224         struct task             sc_restarttask; /* reset firmware task */
 225         struct task             sc_bmiss_task;  /* beacon miss */
 226
 227        /* Eeprom info */
 228         uint8_t                 cap;
 229         uint16_t                rev;
 230         uint8_t                 type;
 231         struct wpi_power_group  groups[WPI_POWER_GROUPS_COUNT];
 232         int8_t                  maxpwr[IEEE80211_CHAN_MAX];
 233         char                    domain[4];      /*reglatory domain XXX */
 234 };
 235 #define WPI_LOCK_INIT(_sc) \
 236         mtx_init(&(_sc)->sc_mtx, device_get_nameunit((_sc)->sc_dev), \
 237             MTX_NETWORK_LOCK, MTX_DEF)
 238 #define WPI_LOCK(_sc)           mtx_lock(&(_sc)->sc_mtx)
 239 #define WPI_UNLOCK(_sc)         mtx_unlock(&(_sc)->sc_mtx)
 240 #define WPI_LOCK_ASSERT(sc)     mtx_assert(&(sc)->sc_mtx, MA_OWNED)
 241 #define WPI_LOCK_DESTROY(_sc)   mtx_destroy(&(_sc)->sc_mtx)
 242
 243 #define WPI_CMD_LOCK_INIT(_sc)  \
 244         mtx_init(&(_sc)->sc_cmdlock, device_get_nameunit((_sc)->sc_dev), \
 245             NULL, MTX_DEF)
 246 #define WPI_CMD_LOCK_DESTROY(_sc)        mtx_destroy(&(_sc)->sc_cmdlock)
 247 #define WPI_CMD_LOCK(_sc)                mtx_lock(&(_sc)->sc_cmdlock)
 248 #define WPI_CMD_UNLOCK(_sc)              mtx_unlock(&(_sc)->sc_cmdlock)