tools/tools/ath/athstats/athstats.c

   1 /*-
   2  * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    without modification.
  11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  12  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  13  *    redistribution must be conditioned upon including a substantially
  14  *    similar Disclaimer requirement for further binary redistribution.
  15  *
  16  * NO WARRANTY
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  20  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  21  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  22  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  27  * THE POSSIBILITY OF SUCH DAMAGES.
  28  *
  29  * $FreeBSD: src/tools/tools/ath/athstats/athstats.c,v 1.15 2009/02/13 05:45:23 sam Exp $
  30  */
  31
  32 /*
  33  * ath statistics class.
  34  */
  35 #include <sys/types.h>
  36 #include <sys/file.h>
  37 #include <sys/sockio.h>
  38 #include <sys/socket.h>
  39 #include <net/if.h>
  40 #include <net/if_media.h>
  41 #include <net/if_var.h>
  42
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <signal.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <err.h>
  49
  50 #include "ah.h"
  51 #include "ah_desc.h"
  52 #include "ieee80211_ioctl.h"
  53 #include "ieee80211_radiotap.h"
  54 #include "if_athioctl.h"
  55
  56 #include "athstats.h"
  57
  58 #ifdef ATH_SUPPORT_ANI
  59 #define HAL_EP_RND(x,mul) \
  60         ((((x)%(mul)) >= ((mul)/2)) ? ((x) + ((mul) - 1)) / (mul) : (x)/(mul))
  61 #define HAL_RSSI(x)     HAL_EP_RND(x, HAL_RSSI_EP_MULTIPLIER)
  62 #endif
  63
  64 #define NOTPRESENT      { 0, "", "" }
  65
  66 #define AFTER(prev)     ((prev)+1)
  67
  68 static const struct fmt athstats[] = {
  69 #define S_INPUT         0
  70         { 8,    "input",        "input",        "data frames received" },
  71 #define S_OUTPUT        AFTER(S_INPUT)
  72         { 8,    "output",       "output",       "data frames transmit" },
  73 #define S_TX_ALTRATE    AFTER(S_OUTPUT)
  74         { 7,    "altrate",      "altrate",      "tx frames with an alternate rate" },
  75 #define S_TX_SHORTRETRY AFTER(S_TX_ALTRATE)
  76         { 7,    "short",        "short",        "short on-chip tx retries" },
  77 #define S_TX_LONGRETRY  AFTER(S_TX_SHORTRETRY)
  78         { 7,    "long",         "long",         "long on-chip tx retries" },
  79 #define S_TX_XRETRIES   AFTER(S_TX_LONGRETRY)
  80         { 6,    "xretry",       "xretry",       "tx failed 'cuz too many retries" },
  81 #define S_MIB           AFTER(S_TX_XRETRIES)
  82         { 5,    "mib",          "mib",          "mib overflow interrupts" },
  83 #ifndef __linux__
  84 #define S_TX_LINEAR     AFTER(S_MIB)
  85         { 5,    "txlinear",     "txlinear",     "tx linearized to cluster" },
  86 #define S_BSTUCK        AFTER(S_TX_LINEAR)
  87         { 5,    "bstuck",       "bstuck",       "stuck beacon conditions" },
  88 #define S_INTRCOAL      AFTER(S_BSTUCK)
  89         { 5,    "intrcoal",     "intrcoal",     "interrupts coalesced" },
  90 #define S_RATE          AFTER(S_INTRCOAL)
  91 #else
  92 #define S_RATE          AFTER(S_MIB)
  93 #endif
  94         { 5,    "rate",         "rate",         "current transmit rate" },
  95 #define S_WATCHDOG      AFTER(S_RATE)
  96         { 5,    "wdog",         "wdog",         "watchdog timeouts" },
  97 #define S_FATAL         AFTER(S_WATCHDOG)
  98         { 5,    "fatal",        "fatal",        "hardware error interrupts" },
  99 #define S_BMISS         AFTER(S_FATAL)
 100         { 5,    "bmiss",        "bmiss",        "beacon miss interrupts" },
 101 #define S_RXORN         AFTER(S_BMISS)
 102         { 5,    "rxorn",        "rxorn",        "recv overrun interrupts" },
 103 #define S_RXEOL         AFTER(S_RXORN)
 104         { 5,    "rxeol",        "rxeol",        "recv eol interrupts" },
 105 #define S_TXURN         AFTER(S_RXEOL)
 106         { 5,    "txurn",        "txurn",        "txmit underrun interrupts" },
 107 #define S_TX_MGMT       AFTER(S_TXURN)
 108         { 5,    "txmgt",        "txmgt",        "tx management frames" },
 109 #define S_TX_DISCARD    AFTER(S_TX_MGMT)
 110         { 5,    "txdisc",       "txdisc",       "tx frames discarded prior to association" },
 111 #define S_TX_INVALID    AFTER(S_TX_DISCARD)
 112         { 5,    "txinv",        "txinv",        "tx invalid (19)" },
 113 #define S_TX_QSTOP      AFTER(S_TX_INVALID)
 114         { 5,    "qstop",        "qstop",        "tx stopped 'cuz no xmit buffer" },
 115 #define S_TX_ENCAP      AFTER(S_TX_QSTOP)
 116         { 5,    "txencode",     "txencode",     "tx encapsulation failed" },
 117 #define S_TX_NONODE     AFTER(S_TX_ENCAP)
 118         { 5,    "txnonode",     "txnonode",     "tx failed 'cuz no node" },
 119 #define S_TX_NOBUF      AFTER(S_TX_NONODE)
 120         { 5,    "txnobuf",      "txnobuf",      "tx failed 'cuz dma buffer allocation failed" },
 121 #define S_TX_NOFRAG     AFTER(S_TX_NOBUF)
 122         { 5,    "txnofrag",     "txnofrag",     "tx failed 'cuz frag buffer allocation(s) failed" },
 123 #define S_TX_NOMBUF     AFTER(S_TX_NOFRAG)
 124         { 5,    "txnombuf",     "txnombuf",     "tx failed 'cuz mbuf allocation failed" },
 125 #ifndef __linux__
 126 #define S_TX_NOMCL      AFTER(S_TX_NOMBUF)
 127         { 5,    "txnomcl",      "txnomcl",      "tx failed 'cuz cluster allocation failed" },
 128 #define S_TX_FIFOERR    AFTER(S_TX_NOMCL)
 129 #else
 130 #define S_TX_FIFOERR    AFTER(S_TX_NOMBUF)
 131 #endif
 132         { 5,    "efifo",        "efifo",        "tx failed 'cuz FIFO underrun" },
 133 #define S_TX_FILTERED   AFTER(S_TX_FIFOERR)
 134         { 5,    "efilt",        "efilt",        "tx failed 'cuz destination filtered" },
 135 #define S_TX_BADRATE    AFTER(S_TX_FILTERED)
 136         { 5,    "txbadrate",    "txbadrate",    "tx failed 'cuz bogus xmit rate" },
 137 #define S_TX_NOACK      AFTER(S_TX_BADRATE)
 138         { 5,    "noack",        "noack",        "tx frames with no ack marked" },
 139 #define S_TX_RTS        AFTER(S_TX_NOACK)
 140         { 5,    "rts",          "rts",          "tx frames with rts enabled" },
 141 #define S_TX_CTS        AFTER(S_TX_RTS)
 142         { 5,    "cts",          "cts",          "tx frames with cts enabled" },
 143 #define S_TX_SHORTPRE   AFTER(S_TX_CTS)
 144         { 5,    "shpre",        "shpre",        "tx frames with short preamble" },
 145 #define S_TX_PROTECT    AFTER(S_TX_SHORTPRE)
 146         { 5,    "protect",      "protect",      "tx frames with 11g protection" },
 147 #define S_RX_ORN        AFTER(S_TX_PROTECT)
 148         { 5,    "rxorn",        "rxorn",        "rx failed 'cuz of desc overrun" },
 149 #define S_RX_CRC_ERR    AFTER(S_RX_ORN)
 150         { 6,    "crcerr",       "crcerr",       "rx failed 'cuz of bad CRC" },
 151 #define S_RX_FIFO_ERR   AFTER(S_RX_CRC_ERR)
 152         { 5,    "rxfifo",       "rxfifo",       "rx failed 'cuz of FIFO overrun" },
 153 #define S_RX_CRYPTO_ERR AFTER(S_RX_FIFO_ERR)
 154         { 5,    "crypt",        "crypt",        "rx failed 'cuz decryption" },
 155 #define S_RX_MIC_ERR    AFTER(S_RX_CRYPTO_ERR)
 156         { 4,    "mic",          "mic",          "rx failed 'cuz MIC failure" },
 157 #define S_RX_TOOSHORT   AFTER(S_RX_MIC_ERR)
 158         { 5,    "rxshort",      "rxshort",      "rx failed 'cuz frame too short" },
 159 #define S_RX_NOMBUF     AFTER(S_RX_TOOSHORT)
 160         { 5,    "rxnombuf",     "rxnombuf",     "rx setup failed 'cuz no mbuf" },
 161 #define S_RX_MGT        AFTER(S_RX_NOMBUF)
 162         { 5,    "rxmgt",        "rxmgt",        "rx management frames" },
 163 #define S_RX_CTL        AFTER(S_RX_MGT)
 164         { 5,    "rxctl",        "rxctl",        "rx control frames" },
 165 #define S_RX_PHY_ERR    AFTER(S_RX_CTL)
 166         { 7,    "phyerr",       "phyerr",       "rx failed 'cuz of PHY err" },
 167 #define S_RX_PHY_UNDERRUN               AFTER(S_RX_PHY_ERR)
 168         { 4,    "phyund",       "TUnd", "transmit underrun" },
 169 #define S_RX_PHY_TIMING                 AFTER(S_RX_PHY_UNDERRUN)
 170         { 4,    "phytim",       "Tim",  "timing error" },
 171 #define S_RX_PHY_PARITY                 AFTER(S_RX_PHY_TIMING)
 172         { 4,    "phypar",       "IPar", "illegal parity" },
 173 #define S_RX_PHY_RATE                   AFTER(S_RX_PHY_PARITY)
 174         { 4,    "phyrate",      "IRate",        "illegal rate" },
 175 #define S_RX_PHY_LENGTH                 AFTER(S_RX_PHY_RATE)
 176         { 4,    "phylen",       "ILen",         "illegal length" },
 177 #define S_RX_PHY_RADAR                  AFTER(S_RX_PHY_LENGTH)
 178         { 4,    "phyradar",     "Radar",        "radar detect" },
 179 #define S_RX_PHY_SERVICE                AFTER(S_RX_PHY_RADAR)
 180         { 4,    "physervice",   "Service",      "illegal service" },
 181 #define S_RX_PHY_TOR                    AFTER(S_RX_PHY_SERVICE)
 182         { 4,    "phytor",       "TOR",          "transmit override receive" },
 183 #define S_RX_PHY_OFDM_TIMING            AFTER(S_RX_PHY_TOR)
 184         { 6,    "ofdmtim",      "ofdmtim",      "OFDM timing" },
 185 #define S_RX_PHY_OFDM_SIGNAL_PARITY     AFTER(S_RX_PHY_OFDM_TIMING)
 186         { 6,    "ofdmsig",      "ofdmsig",      "OFDM illegal parity" },
 187 #define S_RX_PHY_OFDM_RATE_ILLEGAL      AFTER(S_RX_PHY_OFDM_SIGNAL_PARITY)
 188         { 6,    "ofdmrate",     "ofdmrate",     "OFDM illegal rate" },
 189 #define S_RX_PHY_OFDM_POWER_DROP        AFTER(S_RX_PHY_OFDM_RATE_ILLEGAL)
 190         { 6,    "ofdmpow",      "ofdmpow",      "OFDM power drop" },
 191 #define S_RX_PHY_OFDM_SERVICE           AFTER(S_RX_PHY_OFDM_POWER_DROP)
 192         { 6,    "ofdmservice",  "ofdmservice",  "OFDM illegal service" },
 193 #define S_RX_PHY_OFDM_RESTART           AFTER(S_RX_PHY_OFDM_SERVICE)
 194         { 6,    "ofdmrestart",  "ofdmrestart",  "OFDM restart" },
 195 #define S_RX_PHY_CCK_TIMING             AFTER(S_RX_PHY_OFDM_RESTART)
 196         { 6,    "ccktim",       "ccktim",       "CCK timing" },
 197 #define S_RX_PHY_CCK_HEADER_CRC         AFTER(S_RX_PHY_CCK_TIMING)
 198         { 6,    "cckhead",      "cckhead",      "CCK header crc" },
 199 #define S_RX_PHY_CCK_RATE_ILLEGAL       AFTER(S_RX_PHY_CCK_HEADER_CRC)
 200         { 6,    "cckrate",      "cckrate",      "CCK illegal rate" },
 201 #define S_RX_PHY_CCK_SERVICE            AFTER(S_RX_PHY_CCK_RATE_ILLEGAL)
 202         { 6,    "cckservice",   "cckservice",   "CCK illegal service" },
 203 #define S_RX_PHY_CCK_RESTART            AFTER(S_RX_PHY_CCK_SERVICE)
 204         { 6,    "cckrestar",    "cckrestar",    "CCK restart" },
 205 #define S_BE_NOMBUF     AFTER(S_RX_PHY_CCK_RESTART)
 206         { 4,    "benombuf",     "benombuf",     "beacon setup failed 'cuz no mbuf" },
 207 #define S_BE_XMIT       AFTER(S_BE_NOMBUF)
 208         { 7,    "bexmit",       "bexmit",       "beacons transmitted" },
 209 #define S_PER_CAL       AFTER(S_BE_XMIT)
 210         { 4,    "pcal",         "pcal",         "periodic calibrations" },
 211 #define S_PER_CALFAIL   AFTER(S_PER_CAL)
 212         { 4,    "pcalf",        "pcalf",        "periodic calibration failures" },
 213 #define S_PER_RFGAIN    AFTER(S_PER_CALFAIL)
 214         { 4,    "prfga",        "prfga",        "rfgain value change" },
 215 #if ATH_SUPPORT_TDMA
 216 #define S_TDMA_UPDATE   AFTER(S_PER_RFGAIN)
 217         { 5,    "tdmau",        "tdmau",        "TDMA slot timing updates" },
 218 #define S_TDMA_TIMERS   AFTER(S_TDMA_UPDATE)
 219         { 5,    "tdmab",        "tdmab",        "TDMA slot update set beacon timers" },
 220 #define S_TDMA_TSF      AFTER(S_TDMA_TIMERS)
 221         { 5,    "tdmat",        "tdmat",        "TDMA slot update set TSF" },
 222 #define S_TDMA_TSFADJ   AFTER(S_TDMA_TSF)
 223         { 8,    "tdmadj",       "tdmadj",       "TDMA slot adjust (usecs, smoothed)" },
 224 #define S_TDMA_ACK      AFTER(S_TDMA_TSFADJ)
 225         { 5,    "tdmack",       "tdmack",       "TDMA tx failed 'cuz ACK required" },
 226 #define S_RATE_CALLS    AFTER(S_TDMA_ACK)
 227 #else
 228 #define S_RATE_CALLS    AFTER(S_PER_RFGAIN)
 229 #endif
 230         { 5,    "ratec",        "ratec",        "rate control checks" },
 231 #define S_RATE_RAISE    AFTER(S_RATE_CALLS)
 232         { 5,    "rate+",        "rate+",        "rate control raised xmit rate" },
 233 #define S_RATE_DROP     AFTER(S_RATE_RAISE)
 234         { 5,    "rate-",        "rate-",        "rate control dropped xmit rate" },
 235 #define S_TX_RSSI       AFTER(S_RATE_DROP)
 236         { 4,    "arssi",        "arssi",        "rssi of last ack" },
 237 #define S_RX_RSSI       AFTER(S_TX_RSSI)
 238         { 4,    "rssi",         "rssi",         "avg recv rssi" },
 239 #define S_RX_NOISE      AFTER(S_RX_RSSI)
 240         { 5,    "noise",        "noise",        "rx noise floor" },
 241 #define S_BMISS_PHANTOM AFTER(S_RX_NOISE)
 242         { 5,    "bmissphantom", "bmissphantom", "phantom beacon misses" },
 243 #define S_TX_RAW        AFTER(S_BMISS_PHANTOM)
 244         { 5,    "txraw",        "txraw",        "tx frames through raw api" },
 245 #define S_TX_RAW_FAIL   AFTER(S_TX_RAW)
 246         { 5,    "txrawfail",    "txrawfail",    "raw tx failed 'cuz interface/hw down" },
 247 #define S_RX_TOOBIG     AFTER(S_TX_RAW_FAIL)
 248         { 5,    "rx2big",       "rx2big",       "rx failed 'cuz frame too large"  },
 249 #ifndef __linux__
 250 #define S_CABQ_XMIT     AFTER(S_RX_TOOBIG)
 251         { 5,    "cabxmit",      "cabxmit",      "cabq frames transmitted" },
 252 #define S_CABQ_BUSY     AFTER(S_CABQ_XMIT)
 253         { 5,    "cabqbusy",     "cabqbusy",     "cabq xmit overflowed beacon interval" },
 254 #define S_TX_NODATA     AFTER(S_CABQ_BUSY)
 255         { 5,    "txnodata",     "txnodata",     "tx discarded empty frame" },
 256 #define S_TX_BUSDMA     AFTER(S_TX_NODATA)
 257         { 5,    "txbusdma",     "txbusdma",     "tx failed for dma resrcs" },
 258 #define S_RX_BUSDMA     AFTER(S_TX_BUSDMA)
 259         { 5,    "rxbusdma",     "rxbusdma",     "rx setup failed for dma resrcs" },
 260 #define S_FF_TXOK       AFTER(S_RX_BUSDMA)
 261 #else
 262 #define S_FF_TXOK       AFTER(S_RX_PHY_UNDERRUN)
 263 #endif
 264         { 5,    "fftxok",       "fftxok",       "fast frames xmit successfully" },
 265 #define S_FF_TXERR      AFTER(S_FF_TXOK)
 266         { 5,    "fftxerr",      "fftxerr",      "fast frames not xmit due to error" },
 267 #define S_FF_RX         AFTER(S_FF_TXERR)
 268         { 5,    "ffrx",         "ffrx",         "fast frames received" },
 269 #define S_FF_FLUSH      AFTER(S_FF_RX)
 270         { 5,    "ffflush",      "ffflush",      "fast frames flushed from staging q" },
 271 #define S_TX_QFULL      AFTER(S_FF_FLUSH)
 272         { 5,    "txqfull",      "txqfull",      "tx discarded 'cuz queue is full" },
 273 #define S_ANT_DEFSWITCH AFTER(S_TX_QFULL)
 274         { 5,    "defsw",        "defsw",        "switched default/rx antenna" },
 275 #define S_ANT_TXSWITCH  AFTER(S_ANT_DEFSWITCH)
 276         { 5,    "txsw",         "txsw",         "tx used alternate antenna" },
 277 #ifdef ATH_SUPPORT_ANI
 278 #define S_ANI_NOISE     AFTER(S_ANT_TXSWITCH)
 279         { 2,    "ni",   "NI",           "noise immunity level" },
 280 #define S_ANI_SPUR      AFTER(S_ANI_NOISE)
 281         { 2,    "si",   "SI",           "spur immunity level" },
 282 #define S_ANI_STEP      AFTER(S_ANI_SPUR)
 283         { 2,    "step", "ST",           "first step level" },
 284 #define S_ANI_OFDM      AFTER(S_ANI_STEP)
 285         { 4,    "owsd", "OWSD",         "OFDM weak signal detect" },
 286 #define S_ANI_CCK       AFTER(S_ANI_OFDM)
 287         { 4,    "cwst", "CWST",         "CCK weak signal threshold" },
 288 #define S_ANI_MAXSPUR   AFTER(S_ANI_CCK)
 289         { 3,    "maxsi","MSI",          "max spur immunity level" },
 290 #define S_ANI_LISTEN    AFTER(S_ANI_MAXSPUR)
 291         { 6,    "listen","LISTEN",      "listen time" },
 292 #define S_ANI_NIUP      AFTER(S_ANI_LISTEN)
 293         { 4,    "ni+",  "NI-",          "ANI increased noise immunity" },
 294 #define S_ANI_NIDOWN    AFTER(S_ANI_NIUP)
 295         { 4,    "ni-",  "NI-",          "ANI decrease noise immunity" },
 296 #define S_ANI_SIUP      AFTER(S_ANI_NIDOWN)
 297         { 4,    "si+",  "SI+",          "ANI increased spur immunity" },
 298 #define S_ANI_SIDOWN    AFTER(S_ANI_SIUP)
 299         { 4,    "si-",  "SI-",          "ANI decrease spur immunity" },
 300 #define S_ANI_OFDMON    AFTER(S_ANI_SIDOWN)
 301         { 5,    "ofdm+","OFDM+",        "ANI enabled OFDM weak signal detect" },
 302 #define S_ANI_OFDMOFF   AFTER(S_ANI_OFDMON)
 303         { 5,    "ofdm-","OFDM-",        "ANI disabled OFDM weak signal detect" },
 304 #define S_ANI_CCKHI     AFTER(S_ANI_OFDMOFF)
 305         { 5,    "cck+", "CCK+",         "ANI enabled CCK weak signal threshold" },
 306 #define S_ANI_CCKLO     AFTER(S_ANI_CCKHI)
 307         { 5,    "cck-", "CCK-",         "ANI disabled CCK weak signal threshold" },
 308 #define S_ANI_STEPUP    AFTER(S_ANI_CCKLO)
 309         { 5,    "step+","STEP+",        "ANI increased first step level" },
 310 #define S_ANI_STEPDOWN  AFTER(S_ANI_STEPUP)
 311         { 5,    "step-","STEP-",        "ANI decreased first step level" },
 312 #define S_ANI_OFDMERRS  AFTER(S_ANI_STEPDOWN)
 313         { 8,    "ofdm", "OFDM",         "cumulative OFDM phy error count" },
 314 #define S_ANI_CCKERRS   AFTER(S_ANI_OFDMERRS)
 315         { 8,    "cck",  "CCK",          "cumulative CCK phy error count" },
 316 #define S_ANI_RESET     AFTER(S_ANI_CCKERRS)
 317         { 5,    "reset","RESET",        "ANI parameters zero'd for non-STA operation" },
 318 #define S_ANI_LZERO     AFTER(S_ANI_RESET)
 319         { 5,    "lzero","LZERO",        "ANI forced listen time to zero" },
 320 #define S_ANI_LNEG      AFTER(S_ANI_LZERO)
 321         { 5,    "lneg", "LNEG",         "ANI calculated listen time < 0" },
 322 #define S_MIB_ACKBAD    AFTER(S_ANI_LNEG)
 323         { 5,    "ackbad","ACKBAD",      "missing ACK's" },
 324 #define S_MIB_RTSBAD    AFTER(S_MIB_ACKBAD)
 325         { 5,    "rtsbad","RTSBAD",      "RTS without CTS" },
 326 #define S_MIB_RTSGOOD   AFTER(S_MIB_RTSBAD)
 327         { 5,    "rtsgood","RTSGOOD",    "successful RTS" },
 328 #define S_MIB_FCSBAD    AFTER(S_MIB_RTSGOOD)
 329         { 5,    "fcsbad","FCSBAD",      "bad FCS" },
 330 #define S_MIB_BEACONS   AFTER(S_MIB_FCSBAD)
 331         { 5,    "beacons","beacons",    "beacons received" },
 332 #define S_NODE_AVGBRSSI AFTER(S_MIB_BEACONS)
 333         { 3,    "avgbrssi","BSI",       "average rssi (beacons only)" },
 334 #define S_NODE_AVGRSSI  AFTER(S_NODE_AVGBRSSI)
 335         { 3,    "avgrssi","DSI",        "average rssi (all rx'd frames)" },
 336 #define S_NODE_AVGARSSI AFTER(S_NODE_AVGRSSI)
 337         { 3,    "avgtxrssi","TSI",      "average rssi (ACKs only)" },
 338 #define S_ANT_TX0       AFTER(S_NODE_AVGARSSI)
 339 #else
 340 #define S_ANT_TX0       AFTER(S_ANT_TXSWITCH)
 341 #endif /* ATH_SUPPORT_ANI */
 342         { 8,    "tx0",  "ant0(tx)",     "frames tx on antenna 0" },
 343 #define S_ANT_TX1       AFTER(S_ANT_TX0)
 344         { 8,    "tx1",  "ant1(tx)",     "frames tx on antenna 1"  },
 345 #define S_ANT_TX2       AFTER(S_ANT_TX1)
 346         { 8,    "tx2",  "ant2(tx)",     "frames tx on antenna 2"  },
 347 #define S_ANT_TX3       AFTER(S_ANT_TX2)
 348         { 8,    "tx3",  "ant3(tx)",     "frames tx on antenna 3"  },
 349 #define S_ANT_TX4       AFTER(S_ANT_TX3)
 350         { 8,    "tx4",  "ant4(tx)",     "frames tx on antenna 4"  },
 351 #define S_ANT_TX5       AFTER(S_ANT_TX4)
 352         { 8,    "tx5",  "ant5(tx)",     "frames tx on antenna 5"  },
 353 #define S_ANT_TX6       AFTER(S_ANT_TX5)
 354         { 8,    "tx6",  "ant6(tx)",     "frames tx on antenna 6"  },
 355 #define S_ANT_TX7       AFTER(S_ANT_TX6)
 356         { 8,    "tx7",  "ant7(tx)",     "frames tx on antenna 7"  },
 357 #define S_ANT_RX0       AFTER(S_ANT_TX7)
 358         { 8,    "rx0",  "ant0(rx)",     "frames rx on antenna 0"  },
 359 #define S_ANT_RX1       AFTER(S_ANT_RX0)
 360         { 8,    "rx1",  "ant1(rx)",     "frames rx on antenna 1"   },
 361 #define S_ANT_RX2       AFTER(S_ANT_RX1)
 362         { 8,    "rx2",  "ant2(rx)",     "frames rx on antenna 2"   },
 363 #define S_ANT_RX3       AFTER(S_ANT_RX2)
 364         { 8,    "rx3",  "ant3(rx)",     "frames rx on antenna 3"   },
 365 #define S_ANT_RX4       AFTER(S_ANT_RX3)
 366         { 8,    "rx4",  "ant4(rx)",     "frames rx on antenna 4"   },
 367 #define S_ANT_RX5       AFTER(S_ANT_RX4)
 368         { 8,    "rx5",  "ant5(rx)",     "frames rx on antenna 5"   },
 369 #define S_ANT_RX6       AFTER(S_ANT_RX5)
 370         { 8,    "rx6",  "ant6(rx)",     "frames rx on antenna 6"   },
 371 #define S_ANT_RX7       AFTER(S_ANT_RX6)
 372         { 8,    "rx7",  "ant7(rx)",     "frames rx on antenna 7"   },
 373 #define S_TX_SIGNAL     AFTER(S_ANT_RX7)
 374         { 4,    "asignal",      "asig", "signal of last ack (dBm)" },
 375 #define S_RX_SIGNAL     AFTER(S_TX_SIGNAL)
 376         { 4,    "signal",       "sig",  "avg recv signal (dBm)" },
 377 };
 378 #define S_PHY_MIN       S_RX_PHY_UNDERRUN
 379 #define S_PHY_MAX       S_RX_PHY_CCK_RESTART
 380 #define S_LAST          S_ANT_TX0
 381 #define S_MAX   S_ANT_RX7+1
 382
 383 struct _athstats {
 384         struct ath_stats ath;
 385 #ifdef ATH_SUPPORT_ANI
 386         struct {
 387                 uint32_t ast_ani_niup;          /* increased noise immunity */
 388                 uint32_t ast_ani_nidown;        /* decreased noise immunity */
 389                 uint32_t ast_ani_spurup;        /* increased spur immunity */
 390                 uint32_t ast_ani_spurdown;      /* descreased spur immunity */
 391                 uint32_t ast_ani_ofdmon;        /* OFDM weak signal detect on */
 392                 uint32_t ast_ani_ofdmoff;       /* OFDM weak signal detect off*/
 393                 uint32_t ast_ani_cckhigh;       /* CCK weak signal thr high */
 394                 uint32_t ast_ani_ccklow;        /* CCK weak signal thr low */
 395                 uint32_t ast_ani_stepup;        /* increased first step level */
 396                 uint32_t ast_ani_stepdown;      /* decreased first step level */
 397                 uint32_t ast_ani_ofdmerrs;      /* cumulative ofdm phy err cnt*/
 398                 uint32_t ast_ani_cckerrs;       /* cumulative cck phy err cnt */
 399                 uint32_t ast_ani_reset; /* params zero'd for non-STA */
 400                 uint32_t ast_ani_lzero; /* listen time forced to zero */
 401                 uint32_t ast_ani_lneg;          /* listen time calculated < 0 */
 402                 HAL_MIB_STATS ast_mibstats;     /* MIB counter stats */
 403                 HAL_NODE_STATS ast_nodestats;   /* latest rssi stats */
 404         } ani_stats;
 405         struct {
 406                 uint8_t noiseImmunityLevel;
 407                 uint8_t spurImmunityLevel;
 408                 uint8_t firstepLevel;
 409                 uint8_t ofdmWeakSigDetectOff;
 410                 uint8_t cckWeakSigThreshold;
 411                 uint32_t listenTime;
 412         } ani_state;
 413 #endif
 414 };
 415
 416 struct athstatfoo_p {
 417         struct athstatfoo base;
 418         int s;
 419         int optstats;
 420 #define ATHSTATS_ANI    0x0001
 421         struct ifreq ifr;
 422         struct ath_diag atd;
 423         struct _athstats cur;
 424         struct _athstats total;
 425 };
 426
 427 static void
 428 ath_setifname(struct athstatfoo *wf0, const char *ifname)
 429 {
 430         struct athstatfoo_p *wf = (struct athstatfoo_p *) wf0;
 431
 432         strncpy(wf->ifr.ifr_name, ifname, sizeof (wf->ifr.ifr_name));
 433 #ifdef ATH_SUPPORT_ANI
 434         strncpy(wf->atd.ad_name, ifname, sizeof (wf->atd.ad_name));
 435         wf->optstats |= ATHSTATS_ANI;
 436 #endif
 437 }
 438
 439 static void
 440 ath_zerostats(struct athstatfoo *wf0)
 441 {
 442         struct athstatfoo_p *wf = (struct athstatfoo_p *) wf0;
 443
 444         if (ioctl(wf->s, SIOCZATHSTATS, &wf->ifr) < 0)
 445                 err(-1, wf->ifr.ifr_name);
 446 }
 447
 448 static void
 449 ath_collect(struct athstatfoo_p *wf, struct _athstats *stats)
 450 {
 451         wf->ifr.ifr_data = (caddr_t) &stats->ath;
 452         if (ioctl(wf->s, SIOCGATHSTATS, &wf->ifr) < 0)
 453                 err(1, wf->ifr.ifr_name);
 454 #ifdef ATH_SUPPORT_ANI
 455         if (wf->optstats & ATHSTATS_ANI) {
 456                 wf->atd.ad_id = 5;
 457                 wf->atd.ad_out_data = (caddr_t) &stats->ani_state;
 458                 wf->atd.ad_out_size = sizeof(stats->ani_state);
 459                 if (ioctl(wf->s, SIOCGATHDIAG, &wf->atd) < 0) {
 460                         warn(wf->atd.ad_name);
 461                         wf->optstats &= ~ATHSTATS_ANI;
 462                 }
 463                 wf->atd.ad_id = 8;
 464                 wf->atd.ad_out_data = (caddr_t) &stats->ani_stats;
 465                 wf->atd.ad_out_size = sizeof(stats->ani_stats);
 466                 if (ioctl(wf->s, SIOCGATHDIAG, &wf->atd) < 0)
 467                         warn(wf->atd.ad_name);
 468         }
 469 #endif /* ATH_SUPPORT_ANI */
 470 }
 471
 472 static void
 473 ath_collect_cur(struct statfoo *sf)
 474 {
 475         struct athstatfoo_p *wf = (struct athstatfoo_p *) sf;
 476
 477         ath_collect(wf, &wf->cur);
 478 }
 479
 480 static void
 481 ath_collect_tot(struct statfoo *sf)
 482 {
 483         struct athstatfoo_p *wf = (struct athstatfoo_p *) sf;
 484
 485         ath_collect(wf, &wf->total);
 486 }
 487
 488 static void
 489 ath_update_tot(struct statfoo *sf)
 490 {
 491         struct athstatfoo_p *wf = (struct athstatfoo_p *) sf;
 492
 493         wf->total = wf->cur;
 494 }
 495
 496 static void
 497 snprintrate(char b[], size_t bs, int rate)
 498 {
 499         if (rate & IEEE80211_RATE_MCS)
 500                 snprintf(b, bs, "MCS%u", rate &~ IEEE80211_RATE_MCS);
 501         else if (rate & 1)
 502                 snprintf(b, bs, "%u.5M", rate / 2);
 503         else
 504                 snprintf(b, bs, "%uM", rate / 2);
 505 }
 506
 507 static int
 508 ath_get_curstat(struct statfoo *sf, int s, char b[], size_t bs)
 509 {
 510         struct athstatfoo_p *wf = (struct athstatfoo_p *) sf;
 511 #define STAT(x) \
 512         snprintf(b, bs, "%u", wf->cur.ath.ast_##x - wf->total.ath.ast_##x); return 1
 513 #define PHY(x) \
 514         snprintf(b, bs, "%u", wf->cur.ath.ast_rx_phy[x] - wf->total.ath.ast_rx_phy[x]); return 1
 515 #define ANI(x) \
 516         snprintf(b, bs, "%u", wf->cur.ani_state.x); return 1
 517 #define ANISTAT(x) \
 518         snprintf(b, bs, "%u", wf->cur.ani_stats.ast_ani_##x - wf->total.ani_stats.ast_ani_##x); return 1
 519 #define MIBSTAT(x) \
 520         snprintf(b, bs, "%u", wf->cur.ani_stats.ast_mibstats.x - wf->total.ani_stats.ast_mibstats.x); return 1
 521 #define TXANT(x) \
 522         snprintf(b, bs, "%u", wf->cur.ath.ast_ant_tx[x] - wf->total.ath.ast_ant_tx[x]); return 1
 523 #define RXANT(x) \
 524         snprintf(b, bs, "%u", wf->cur.ath.ast_ant_rx[x] - wf->total.ath.ast_ant_rx[x]); return 1
 525
 526         switch (s) {
 527         case S_INPUT:
 528                 snprintf(b, bs, "%lu",
 529                     (wf->cur.ath.ast_rx_packets - wf->total.ath.ast_rx_packets) -
 530                     (wf->cur.ath.ast_rx_mgt - wf->total.ath.ast_rx_mgt));
 531                 return 1;
 532         case S_OUTPUT:
 533                 snprintf(b, bs, "%lu",
 534                     wf->cur.ath.ast_tx_packets - wf->total.ath.ast_tx_packets);
 535                 return 1;
 536         case S_RATE:
 537                 snprintrate(b, bs, wf->cur.ath.ast_tx_rate);
 538                 return 1;
 539         case S_WATCHDOG:        STAT(watchdog);
 540         case S_FATAL:           STAT(hardware);
 541         case S_BMISS:           STAT(bmiss);
 542         case S_BMISS_PHANTOM:   STAT(bmiss_phantom);
 543 #ifdef S_BSTUCK
 544         case S_BSTUCK:          STAT(bstuck);
 545 #endif
 546         case S_RXORN:           STAT(rxorn);
 547         case S_RXEOL:           STAT(rxeol);
 548         case S_TXURN:           STAT(txurn);
 549         case S_MIB:             STAT(mib);
 550 #ifdef S_INTRCOAL
 551         case S_INTRCOAL:        STAT(intrcoal);
 552 #endif
 553         case S_TX_MGMT:         STAT(tx_mgmt);
 554         case S_TX_DISCARD:      STAT(tx_discard);
 555         case S_TX_QSTOP:        STAT(tx_qstop);
 556         case S_TX_ENCAP:        STAT(tx_encap);
 557         case S_TX_NONODE:       STAT(tx_nonode);
 558         case S_TX_NOBUF:        STAT(tx_nobuf);
 559         case S_TX_NOFRAG:       STAT(tx_nofrag);
 560         case S_TX_NOMBUF:       STAT(tx_nombuf);
 561 #ifdef S_TX_NOMCL
 562         case S_TX_NOMCL:        STAT(tx_nomcl);
 563         case S_TX_LINEAR:       STAT(tx_linear);
 564         case S_TX_NODATA:       STAT(tx_nodata);
 565         case S_TX_BUSDMA:       STAT(tx_busdma);
 566 #endif
 567         case S_TX_XRETRIES:     STAT(tx_xretries);
 568         case S_TX_FIFOERR:      STAT(tx_fifoerr);
 569         case S_TX_FILTERED:     STAT(tx_filtered);
 570         case S_TX_SHORTRETRY:   STAT(tx_shortretry);
 571         case S_TX_LONGRETRY:    STAT(tx_longretry);
 572         case S_TX_BADRATE:      STAT(tx_badrate);
 573         case S_TX_NOACK:        STAT(tx_noack);
 574         case S_TX_RTS:          STAT(tx_rts);
 575         case S_TX_CTS:          STAT(tx_cts);
 576         case S_TX_SHORTPRE:     STAT(tx_shortpre);
 577         case S_TX_ALTRATE:      STAT(tx_altrate);
 578         case S_TX_PROTECT:      STAT(tx_protect);
 579         case S_TX_RAW:          STAT(tx_raw);
 580         case S_TX_RAW_FAIL:     STAT(tx_raw_fail);
 581         case S_RX_NOMBUF:       STAT(rx_nombuf);
 582 #ifdef S_RX_BUSDMA
 583         case S_RX_BUSDMA:       STAT(rx_busdma);
 584 #endif
 585         case S_RX_ORN:          STAT(rx_orn);
 586         case S_RX_CRC_ERR:      STAT(rx_crcerr);
 587         case S_RX_FIFO_ERR:     STAT(rx_fifoerr);
 588         case S_RX_CRYPTO_ERR:   STAT(rx_badcrypt);
 589         case S_RX_MIC_ERR:      STAT(rx_badmic);
 590         case S_RX_PHY_ERR:      STAT(rx_phyerr);
 591         case S_RX_PHY_UNDERRUN: PHY(HAL_PHYERR_UNDERRUN);
 592         case S_RX_PHY_TIMING:   PHY(HAL_PHYERR_TIMING);
 593         case S_RX_PHY_PARITY:   PHY(HAL_PHYERR_PARITY);
 594         case S_RX_PHY_RATE:     PHY(HAL_PHYERR_RATE);
 595         case S_RX_PHY_LENGTH:   PHY(HAL_PHYERR_LENGTH);
 596         case S_RX_PHY_RADAR:    PHY(HAL_PHYERR_RADAR);
 597         case S_RX_PHY_SERVICE:  PHY(HAL_PHYERR_SERVICE);
 598         case S_RX_PHY_TOR:      PHY(HAL_PHYERR_TOR);
 599         case S_RX_PHY_OFDM_TIMING:        PHY(HAL_PHYERR_OFDM_TIMING);
 600         case S_RX_PHY_OFDM_SIGNAL_PARITY: PHY(HAL_PHYERR_OFDM_SIGNAL_PARITY);
 601         case S_RX_PHY_OFDM_RATE_ILLEGAL:  PHY(HAL_PHYERR_OFDM_RATE_ILLEGAL);
 602         case S_RX_PHY_OFDM_POWER_DROP:    PHY(HAL_PHYERR_OFDM_POWER_DROP);
 603         case S_RX_PHY_OFDM_SERVICE:       PHY(HAL_PHYERR_OFDM_SERVICE);
 604         case S_RX_PHY_OFDM_RESTART:       PHY(HAL_PHYERR_OFDM_RESTART);
 605         case S_RX_PHY_CCK_TIMING:         PHY(HAL_PHYERR_CCK_TIMING);
 606         case S_RX_PHY_CCK_HEADER_CRC:     PHY(HAL_PHYERR_CCK_HEADER_CRC);
 607         case S_RX_PHY_CCK_RATE_ILLEGAL:   PHY(HAL_PHYERR_CCK_RATE_ILLEGAL);
 608         case S_RX_PHY_CCK_SERVICE:        PHY(HAL_PHYERR_CCK_SERVICE);
 609         case S_RX_PHY_CCK_RESTART:        PHY(HAL_PHYERR_CCK_RESTART);
 610         case S_RX_TOOSHORT:     STAT(rx_tooshort);
 611         case S_RX_TOOBIG:       STAT(rx_toobig);
 612         case S_RX_MGT:          STAT(rx_mgt);
 613         case S_RX_CTL:          STAT(rx_ctl);
 614         case S_TX_RSSI:
 615                 snprintf(b, bs, "%d", wf->cur.ath.ast_tx_rssi);
 616                 return 1;
 617         case S_RX_RSSI:
 618                 snprintf(b, bs, "%d", wf->cur.ath.ast_rx_rssi);
 619                 return 1;
 620         case S_BE_XMIT:         STAT(be_xmit);
 621         case S_BE_NOMBUF:       STAT(be_nombuf);
 622         case S_PER_CAL:         STAT(per_cal);
 623         case S_PER_CALFAIL:     STAT(per_calfail);
 624         case S_PER_RFGAIN:      STAT(per_rfgain);
 625 #ifdef S_TDMA_UPDATE
 626         case S_TDMA_UPDATE:     STAT(tdma_update);
 627         case S_TDMA_TIMERS:     STAT(tdma_timers);
 628         case S_TDMA_TSF:        STAT(tdma_tsf);
 629         case S_TDMA_TSFADJ:
 630                 snprintf(b, bs, "-%d/+%d",
 631                     wf->cur.ath.ast_tdma_tsfadjm, wf->cur.ath.ast_tdma_tsfadjp);
 632                 return 1;
 633         case S_TDMA_ACK:        STAT(tdma_ack);
 634 #endif
 635         case S_RATE_CALLS:      STAT(rate_calls);
 636         case S_RATE_RAISE:      STAT(rate_raise);
 637         case S_RATE_DROP:       STAT(rate_drop);
 638         case S_ANT_DEFSWITCH:   STAT(ant_defswitch);
 639         case S_ANT_TXSWITCH:    STAT(ant_txswitch);
 640 #ifdef S_ANI_NOISE
 641         case S_ANI_NOISE:       ANI(noiseImmunityLevel);
 642         case S_ANI_SPUR:        ANI(spurImmunityLevel);
 643         case S_ANI_STEP:        ANI(firstepLevel);
 644         case S_ANI_OFDM:        ANI(ofdmWeakSigDetectOff);
 645         case S_ANI_CCK:         ANI(cckWeakSigThreshold);
 646         case S_ANI_LISTEN:      ANI(listenTime);
 647         case S_ANI_NIUP:        ANISTAT(niup);
 648         case S_ANI_NIDOWN:      ANISTAT(nidown);
 649         case S_ANI_SIUP:        ANISTAT(spurup);
 650         case S_ANI_SIDOWN:      ANISTAT(spurdown);
 651         case S_ANI_OFDMON:      ANISTAT(ofdmon);
 652         case S_ANI_OFDMOFF:     ANISTAT(ofdmoff);
 653         case S_ANI_CCKHI:       ANISTAT(cckhigh);
 654         case S_ANI_CCKLO:       ANISTAT(ccklow);
 655         case S_ANI_STEPUP:      ANISTAT(stepup);
 656         case S_ANI_STEPDOWN:    ANISTAT(stepdown);
 657         case S_ANI_OFDMERRS:    ANISTAT(ofdmerrs);
 658         case S_ANI_CCKERRS:     ANISTAT(cckerrs);
 659         case S_ANI_RESET:       ANISTAT(reset);
 660         case S_ANI_LZERO:       ANISTAT(lzero);
 661         case S_ANI_LNEG:        ANISTAT(lneg);
 662         case S_MIB_ACKBAD:      MIBSTAT(ackrcv_bad);
 663         case S_MIB_RTSBAD:      MIBSTAT(rts_bad);
 664         case S_MIB_RTSGOOD:     MIBSTAT(rts_good);
 665         case S_MIB_FCSBAD:      MIBSTAT(fcs_bad);
 666         case S_MIB_BEACONS:     MIBSTAT(beacons);
 667         case S_NODE_AVGBRSSI:
 668                 snprintf(b, bs, "%u",
 669                     HAL_RSSI(wf->cur.ani_stats.ast_nodestats.ns_avgbrssi));
 670                 return 1;
 671         case S_NODE_AVGRSSI:
 672                 snprintf(b, bs, "%u",
 673                     HAL_RSSI(wf->cur.ani_stats.ast_nodestats.ns_avgrssi));
 674                 return 1;
 675         case S_NODE_AVGARSSI:
 676                 snprintf(b, bs, "%u",
 677                     HAL_RSSI(wf->cur.ani_stats.ast_nodestats.ns_avgtxrssi));
 678                 return 1;
 679 #endif
 680         case S_ANT_TX0:         TXANT(0);
 681         case S_ANT_TX1:         TXANT(1);
 682         case S_ANT_TX2:         TXANT(2);
 683         case S_ANT_TX3:         TXANT(3);
 684         case S_ANT_TX4:         TXANT(4);
 685         case S_ANT_TX5:         TXANT(5);
 686         case S_ANT_TX6:         TXANT(6);
 687         case S_ANT_TX7:         TXANT(7);
 688         case S_ANT_RX0:         RXANT(0);
 689         case S_ANT_RX1:         RXANT(1);
 690         case S_ANT_RX2:         RXANT(2);
 691         case S_ANT_RX3:         RXANT(3);
 692         case S_ANT_RX4:         RXANT(4);
 693         case S_ANT_RX5:         RXANT(5);
 694         case S_ANT_RX6:         RXANT(6);
 695         case S_ANT_RX7:         RXANT(7);
 696 #ifdef S_CABQ_XMIT
 697         case S_CABQ_XMIT:       STAT(cabq_xmit);
 698         case S_CABQ_BUSY:       STAT(cabq_busy);
 699 #endif
 700         case S_FF_TXOK:         STAT(ff_txok);
 701         case S_FF_TXERR:        STAT(ff_txerr);
 702         case S_FF_RX:           STAT(ff_rx);
 703         case S_FF_FLUSH:        STAT(ff_flush);
 704         case S_TX_QFULL:        STAT(tx_qfull);
 705         case S_RX_NOISE:
 706                 snprintf(b, bs, "%d", wf->cur.ath.ast_rx_noise);
 707                 return 1;
 708         case S_TX_SIGNAL:
 709                 snprintf(b, bs, "%d",
 710                         wf->cur.ath.ast_tx_rssi + wf->cur.ath.ast_rx_noise);
 711                 return 1;
 712         case S_RX_SIGNAL:
 713                 snprintf(b, bs, "%d",
 714                         wf->cur.ath.ast_rx_rssi + wf->cur.ath.ast_rx_noise);
 715                 return 1;
 716         }
 717         b[0] = '\0';
 718         return 0;
 719 #undef RXANT
 720 #undef TXANT
 721 #undef ANI
 722 #undef ANISTAT
 723 #undef MIBSTAT
 724 #undef PHY
 725 #undef STAT
 726 }
 727
 728 static int
 729 ath_get_totstat(struct statfoo *sf, int s, char b[], size_t bs)
 730 {
 731         struct athstatfoo_p *wf = (struct athstatfoo_p *) sf;
 732 #define STAT(x) \
 733         snprintf(b, bs, "%u", wf->total.ath.ast_##x); return 1
 734 #define PHY(x) \
 735         snprintf(b, bs, "%u", wf->total.ath.ast_rx_phy[x]); return 1
 736 #define ANI(x) \
 737         snprintf(b, bs, "%u", wf->total.ani_state.x); return 1
 738 #define ANISTAT(x) \
 739         snprintf(b, bs, "%u", wf->total.ani_stats.ast_ani_##x); return 1
 740 #define MIBSTAT(x) \
 741         snprintf(b, bs, "%u", wf->total.ani_stats.ast_mibstats.x); return 1
 742 #define TXANT(x) \
 743         snprintf(b, bs, "%u", wf->total.ath.ast_ant_tx[x]); return 1
 744 #define RXANT(x) \
 745         snprintf(b, bs, "%u", wf->total.ath.ast_ant_rx[x]); return 1
 746
 747         switch (s) {
 748         case S_INPUT:
 749                 snprintf(b, bs, "%lu",
 750                     wf->total.ath.ast_rx_packets - wf->total.ath.ast_rx_mgt);
 751                 return 1;
 752         case S_OUTPUT:
 753                 snprintf(b, bs, "%lu", wf->total.ath.ast_tx_packets);
 754                 return 1;
 755         case S_RATE:
 756                 snprintrate(b, bs, wf->total.ath.ast_tx_rate);
 757                 return 1;
 758         case S_WATCHDOG:        STAT(watchdog);
 759         case S_FATAL:           STAT(hardware);
 760         case S_BMISS:           STAT(bmiss);
 761         case S_BMISS_PHANTOM:   STAT(bmiss_phantom);
 762 #ifdef S_BSTUCK
 763         case S_BSTUCK:          STAT(bstuck);
 764 #endif
 765         case S_RXORN:           STAT(rxorn);
 766         case S_RXEOL:           STAT(rxeol);
 767         case S_TXURN:           STAT(txurn);
 768         case S_MIB:             STAT(mib);
 769 #ifdef S_INTRCOAL
 770         case S_INTRCOAL:        STAT(intrcoal);
 771 #endif
 772         case S_TX_MGMT:         STAT(tx_mgmt);
 773         case S_TX_DISCARD:      STAT(tx_discard);
 774         case S_TX_QSTOP:        STAT(tx_qstop);
 775         case S_TX_ENCAP:        STAT(tx_encap);
 776         case S_TX_NONODE:       STAT(tx_nonode);
 777         case S_TX_NOBUF:        STAT(tx_nobuf);
 778         case S_TX_NOFRAG:       STAT(tx_nofrag);
 779         case S_TX_NOMBUF:       STAT(tx_nombuf);
 780 #ifdef S_TX_NOMCL
 781         case S_TX_NOMCL:        STAT(tx_nomcl);
 782         case S_TX_LINEAR:       STAT(tx_linear);
 783         case S_TX_NODATA:       STAT(tx_nodata);
 784         case S_TX_BUSDMA:       STAT(tx_busdma);
 785 #endif
 786         case S_TX_XRETRIES:     STAT(tx_xretries);
 787         case S_TX_FIFOERR:      STAT(tx_fifoerr);
 788         case S_TX_FILTERED:     STAT(tx_filtered);
 789         case S_TX_SHORTRETRY:   STAT(tx_shortretry);
 790         case S_TX_LONGRETRY:    STAT(tx_longretry);
 791         case S_TX_BADRATE:      STAT(tx_badrate);
 792         case S_TX_NOACK:        STAT(tx_noack);
 793         case S_TX_RTS:          STAT(tx_rts);
 794         case S_TX_CTS:          STAT(tx_cts);
 795         case S_TX_SHORTPRE:     STAT(tx_shortpre);
 796         case S_TX_ALTRATE:      STAT(tx_altrate);
 797         case S_TX_PROTECT:      STAT(tx_protect);
 798         case S_TX_RAW:          STAT(tx_raw);
 799         case S_TX_RAW_FAIL:     STAT(tx_raw_fail);
 800         case S_RX_NOMBUF:       STAT(rx_nombuf);
 801 #ifdef S_RX_BUSDMA
 802         case S_RX_BUSDMA:       STAT(rx_busdma);
 803 #endif
 804         case S_RX_ORN:          STAT(rx_orn);
 805         case S_RX_CRC_ERR:      STAT(rx_crcerr);
 806         case S_RX_FIFO_ERR:     STAT(rx_fifoerr);
 807         case S_RX_CRYPTO_ERR:   STAT(rx_badcrypt);
 808         case S_RX_MIC_ERR:      STAT(rx_badmic);
 809         case S_RX_PHY_ERR:      STAT(rx_phyerr);
 810         case S_RX_PHY_UNDERRUN: PHY(HAL_PHYERR_UNDERRUN);
 811         case S_RX_PHY_TIMING:   PHY(HAL_PHYERR_TIMING);
 812         case S_RX_PHY_PARITY:   PHY(HAL_PHYERR_PARITY);
 813         case S_RX_PHY_RATE:     PHY(HAL_PHYERR_RATE);
 814         case S_RX_PHY_LENGTH:   PHY(HAL_PHYERR_LENGTH);
 815         case S_RX_PHY_RADAR:    PHY(HAL_PHYERR_RADAR);
 816         case S_RX_PHY_SERVICE:  PHY(HAL_PHYERR_SERVICE);
 817         case S_RX_PHY_TOR:      PHY(HAL_PHYERR_TOR);
 818         case S_RX_PHY_OFDM_TIMING:        PHY(HAL_PHYERR_OFDM_TIMING);
 819         case S_RX_PHY_OFDM_SIGNAL_PARITY: PHY(HAL_PHYERR_OFDM_SIGNAL_PARITY);
 820         case S_RX_PHY_OFDM_RATE_ILLEGAL:  PHY(HAL_PHYERR_OFDM_RATE_ILLEGAL);
 821         case S_RX_PHY_OFDM_POWER_DROP:    PHY(HAL_PHYERR_OFDM_POWER_DROP);
 822         case S_RX_PHY_OFDM_SERVICE:       PHY(HAL_PHYERR_OFDM_SERVICE);
 823         case S_RX_PHY_OFDM_RESTART:       PHY(HAL_PHYERR_OFDM_RESTART);
 824         case S_RX_PHY_CCK_TIMING:         PHY(HAL_PHYERR_CCK_TIMING);
 825         case S_RX_PHY_CCK_HEADER_CRC:     PHY(HAL_PHYERR_CCK_HEADER_CRC);
 826         case S_RX_PHY_CCK_RATE_ILLEGAL:   PHY(HAL_PHYERR_CCK_RATE_ILLEGAL);
 827         case S_RX_PHY_CCK_SERVICE:        PHY(HAL_PHYERR_CCK_SERVICE);
 828         case S_RX_PHY_CCK_RESTART:        PHY(HAL_PHYERR_CCK_RESTART);
 829         case S_RX_TOOSHORT:     STAT(rx_tooshort);
 830         case S_RX_TOOBIG:       STAT(rx_toobig);
 831         case S_RX_MGT:          STAT(rx_mgt);
 832         case S_RX_CTL:          STAT(rx_ctl);
 833         case S_TX_RSSI:
 834                 snprintf(b, bs, "%d", wf->total.ath.ast_tx_rssi);
 835                 return 1;
 836         case S_RX_RSSI:
 837                 snprintf(b, bs, "%d", wf->total.ath.ast_rx_rssi);
 838                 return 1;
 839         case S_BE_XMIT:         STAT(be_xmit);
 840         case S_BE_NOMBUF:       STAT(be_nombuf);
 841         case S_PER_CAL:         STAT(per_cal);
 842         case S_PER_CALFAIL:     STAT(per_calfail);
 843         case S_PER_RFGAIN:      STAT(per_rfgain);
 844 #ifdef S_TDMA_UPDATE
 845         case S_TDMA_UPDATE:     STAT(tdma_update);
 846         case S_TDMA_TIMERS:     STAT(tdma_timers);
 847         case S_TDMA_TSF:        STAT(tdma_tsf);
 848         case S_TDMA_TSFADJ:
 849                 snprintf(b, bs, "-%d/+%d",
 850                     wf->total.ath.ast_tdma_tsfadjm,
 851                     wf->total.ath.ast_tdma_tsfadjp);
 852                 return 1;
 853         case S_TDMA_ACK:        STAT(tdma_ack);
 854 #endif
 855         case S_RATE_CALLS:      STAT(rate_calls);
 856         case S_RATE_RAISE:      STAT(rate_raise);
 857         case S_RATE_DROP:       STAT(rate_drop);
 858         case S_ANT_DEFSWITCH:   STAT(ant_defswitch);
 859         case S_ANT_TXSWITCH:    STAT(ant_txswitch);
 860 #ifdef S_ANI_NOISE
 861         case S_ANI_NOISE:       ANI(noiseImmunityLevel);
 862         case S_ANI_SPUR:        ANI(spurImmunityLevel);
 863         case S_ANI_STEP:        ANI(firstepLevel);
 864         case S_ANI_OFDM:        ANI(ofdmWeakSigDetectOff);
 865         case S_ANI_CCK:         ANI(cckWeakSigThreshold);
 866         case S_ANI_LISTEN:      ANI(listenTime);
 867         case S_ANI_NIUP:        ANISTAT(niup);
 868         case S_ANI_NIDOWN:      ANISTAT(nidown);
 869         case S_ANI_SIUP:        ANISTAT(spurup);
 870         case S_ANI_SIDOWN:      ANISTAT(spurdown);
 871         case S_ANI_OFDMON:      ANISTAT(ofdmon);
 872         case S_ANI_OFDMOFF:     ANISTAT(ofdmoff);
 873         case S_ANI_CCKHI:       ANISTAT(cckhigh);
 874         case S_ANI_CCKLO:       ANISTAT(ccklow);
 875         case S_ANI_STEPUP:      ANISTAT(stepup);
 876         case S_ANI_STEPDOWN:    ANISTAT(stepdown);
 877         case S_ANI_OFDMERRS:    ANISTAT(ofdmerrs);
 878         case S_ANI_CCKERRS:     ANISTAT(cckerrs);
 879         case S_ANI_RESET:       ANISTAT(reset);
 880         case S_ANI_LZERO:       ANISTAT(lzero);
 881         case S_ANI_LNEG:        ANISTAT(lneg);
 882         case S_MIB_ACKBAD:      MIBSTAT(ackrcv_bad);
 883         case S_MIB_RTSBAD:      MIBSTAT(rts_bad);
 884         case S_MIB_RTSGOOD:     MIBSTAT(rts_good);
 885         case S_MIB_FCSBAD:      MIBSTAT(fcs_bad);
 886         case S_MIB_BEACONS:     MIBSTAT(beacons);
 887         case S_NODE_AVGBRSSI:
 888                 snprintf(b, bs, "%u",
 889                     HAL_RSSI(wf->total.ani_stats.ast_nodestats.ns_avgbrssi));
 890                 return 1;
 891         case S_NODE_AVGRSSI:
 892                 snprintf(b, bs, "%u",
 893                     HAL_RSSI(wf->total.ani_stats.ast_nodestats.ns_avgrssi));
 894                 return 1;
 895         case S_NODE_AVGARSSI:
 896                 snprintf(b, bs, "%u",
 897                     HAL_RSSI(wf->total.ani_stats.ast_nodestats.ns_avgtxrssi));
 898                 return 1;
 899 #endif
 900         case S_ANT_TX0:         TXANT(0);
 901         case S_ANT_TX1:         TXANT(1);
 902         case S_ANT_TX2:         TXANT(2);
 903         case S_ANT_TX3:         TXANT(3);
 904         case S_ANT_TX4:         TXANT(4);
 905         case S_ANT_TX5:         TXANT(5);
 906         case S_ANT_TX6:         TXANT(6);
 907         case S_ANT_TX7:         TXANT(7);
 908         case S_ANT_RX0:         RXANT(0);
 909         case S_ANT_RX1:         RXANT(1);
 910         case S_ANT_RX2:         RXANT(2);
 911         case S_ANT_RX3:         RXANT(3);
 912         case S_ANT_RX4:         RXANT(4);
 913         case S_ANT_RX5:         RXANT(5);
 914         case S_ANT_RX6:         RXANT(6);
 915         case S_ANT_RX7:         RXANT(7);
 916 #ifdef S_CABQ_XMIT
 917         case S_CABQ_XMIT:       STAT(cabq_xmit);
 918         case S_CABQ_BUSY:       STAT(cabq_busy);
 919 #endif
 920         case S_FF_TXOK:         STAT(ff_txok);
 921         case S_FF_TXERR:        STAT(ff_txerr);
 922         case S_FF_RX:           STAT(ff_rx);
 923         case S_FF_FLUSH:        STAT(ff_flush);
 924         case S_TX_QFULL:        STAT(tx_qfull);
 925         case S_RX_NOISE:
 926                 snprintf(b, bs, "%d", wf->total.ath.ast_rx_noise);
 927                 return 1;
 928         case S_TX_SIGNAL:
 929                 snprintf(b, bs, "%d",
 930                         wf->total.ath.ast_tx_rssi + wf->total.ath.ast_rx_noise);
 931                 return 1;
 932         case S_RX_SIGNAL:
 933                 snprintf(b, bs, "%d",
 934                         wf->total.ath.ast_rx_rssi + wf->total.ath.ast_rx_noise);
 935                 return 1;
 936         }
 937         b[0] = '\0';
 938         return 0;
 939 #undef RXANT
 940 #undef TXANT
 941 #undef ANI
 942 #undef ANISTAT
 943 #undef MIBSTAT
 944 #undef PHY
 945 #undef STAT
 946 }
 947
 948 static void
 949 ath_print_verbose(struct statfoo *sf, FILE *fd)
 950 {
 951         struct athstatfoo_p *wf = (struct athstatfoo_p *) sf;
 952 #define isphyerr(i)     (S_PHY_MIN <= i && i <= S_PHY_MAX)
 953         const struct fmt *f;
 954         char s[32];
 955         const char *indent;
 956         int i, width;
 957
 958         width = 0;
 959         for (i = 0; i < S_LAST; i++) {
 960                 f = &sf->stats[i];
 961                 if (!isphyerr(i) && f->width > width)
 962                         width = f->width;
 963         }
 964         for (i = 0; i < S_LAST; i++) {
 965                 if (ath_get_totstat(sf, i, s, sizeof(s)) && strcmp(s, "0")) {
 966                         if (isphyerr(i))
 967                                 indent = "    ";
 968                         else
 969                                 indent = "";
 970                         fprintf(fd, "%s%-*s %s\n", indent, width, s, athstats[i].desc);
 971                 }
 972         }
 973         fprintf(fd, "Antenna profile:\n");
 974         for (i = 0; i < 8; i++)
 975                 if (wf->total.ath.ast_ant_rx[i] || wf->total.ath.ast_ant_tx[i])
 976                         fprintf(fd, "[%u] tx %8u rx %8u\n", i,
 977                                 wf->total.ath.ast_ant_tx[i],
 978                                 wf->total.ath.ast_ant_rx[i]);
 979 #undef isphyerr
 980 }
 981
 982 STATFOO_DEFINE_BOUNCE(athstatfoo)
 983
 984 struct athstatfoo *
 985 athstats_new(const char *ifname, const char *fmtstring)
 986 {
 987 #define N(a)    (sizeof(a) / sizeof(a[0]))
 988         struct athstatfoo_p *wf;
 989
 990         wf = calloc(1, sizeof(struct athstatfoo_p));
 991         if (wf != NULL) {
 992                 statfoo_init(&wf->base.base, "athstats", athstats, N(athstats));
 993                 /* override base methods */
 994                 wf->base.base.collect_cur = ath_collect_cur;
 995                 wf->base.base.collect_tot = ath_collect_tot;
 996                 wf->base.base.get_curstat = ath_get_curstat;
 997                 wf->base.base.get_totstat = ath_get_totstat;
 998                 wf->base.base.update_tot = ath_update_tot;
 999                 wf->base.base.print_verbose = ath_print_verbose;
1000
1001                 /* setup bounce functions for public methods */
1002                 STATFOO_BOUNCE(wf, athstatfoo);
1003
1004                 /* setup our public methods */
1005                 wf->base.setifname = ath_setifname;
1006 #if 0
1007                 wf->base.setstamac = wlan_setstamac;
1008 #endif
1009                 wf->base.zerostats = ath_zerostats;
1010                 wf->s = socket(AF_INET, SOCK_DGRAM, 0);
1011                 if (wf->s < 0)
1012                         err(1, "socket");
1013
1014                 ath_setifname(&wf->base, ifname);
1015                 wf->base.setfmt(&wf->base, fmtstring);
1016         }
1017         return &wf->base;
1018 #undef N
1019 }