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, MERCHANTABILITY 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 } 1020