1153317Ssam/*- 2186904Ssam * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting 3153317Ssam * All rights reserved. 4153317Ssam * 5153317Ssam * Redistribution and use in source and binary forms, with or without 6153317Ssam * modification, are permitted provided that the following conditions 7153317Ssam * are met: 8153317Ssam * 1. Redistributions of source code must retain the above copyright 9153317Ssam * notice, this list of conditions and the following disclaimer, 10153317Ssam * without modification. 11153317Ssam * 2. Redistributions in binary form must reproduce at minimum a disclaimer 12153317Ssam * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 13153317Ssam * redistribution must be conditioned upon including a substantially 14153317Ssam * similar Disclaimer requirement for further binary redistribution. 15153317Ssam * 16153317Ssam * NO WARRANTY 17153317Ssam * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18153317Ssam * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19153317Ssam * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 20153317Ssam * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 21153317Ssam * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 22153317Ssam * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23153317Ssam * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24153317Ssam * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25153317Ssam * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 26153317Ssam * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 27153317Ssam * THE POSSIBILITY OF SUCH DAMAGES. 28153317Ssam * 29153317Ssam * $FreeBSD$ 30153317Ssam */ 31153317Ssam 32217738Sadrian#include "opt_ah.h" 33217738Sadrian 34153317Ssam/* 35161200Ssam * ath statistics class. 36153317Ssam */ 37153317Ssam#include <sys/types.h> 38153317Ssam#include <sys/file.h> 39153317Ssam#include <sys/sockio.h> 40153317Ssam#include <sys/socket.h> 41153317Ssam#include <net/if.h> 42153317Ssam#include <net/if_media.h> 43153317Ssam#include <net/if_var.h> 44153317Ssam 45153317Ssam#include <stdio.h> 46174570Ssam#include <stdlib.h> 47153317Ssam#include <signal.h> 48161200Ssam#include <string.h> 49161200Ssam#include <unistd.h> 50161200Ssam#include <err.h> 51153317Ssam 52174570Ssam#include "ah.h" 53174570Ssam#include "ah_desc.h" 54226799Sadrian#include "net80211/ieee80211_ioctl.h" 55226799Sadrian#include "net80211/ieee80211_radiotap.h" 56174570Ssam#include "if_athioctl.h" 57153317Ssam 58161200Ssam#include "athstats.h" 59161200Ssam 60184371Ssam#ifdef ATH_SUPPORT_ANI 61184371Ssam#define HAL_EP_RND(x,mul) \ 62184371Ssam ((((x)%(mul)) >= ((mul)/2)) ? ((x) + ((mul) - 1)) / (mul) : (x)/(mul)) 63184371Ssam#define HAL_RSSI(x) HAL_EP_RND(x, HAL_RSSI_EP_MULTIPLIER) 64184371Ssam#endif 65184371Ssam 66161200Ssam#define NOTPRESENT { 0, "", "" } 67161200Ssam 68174570Ssam#define AFTER(prev) ((prev)+1) 69174570Ssam 70161200Ssamstatic const struct fmt athstats[] = { 71161200Ssam#define S_INPUT 0 72188558Ssam { 8, "input", "input", "data frames received" }, 73174570Ssam#define S_OUTPUT AFTER(S_INPUT) 74188558Ssam { 8, "output", "output", "data frames transmit" }, 75174570Ssam#define S_TX_ALTRATE AFTER(S_OUTPUT) 76161200Ssam { 7, "altrate", "altrate", "tx frames with an alternate rate" }, 77174570Ssam#define S_TX_SHORTRETRY AFTER(S_TX_ALTRATE) 78188558Ssam { 7, "short", "short", "short on-chip tx retries" }, 79174570Ssam#define S_TX_LONGRETRY AFTER(S_TX_SHORTRETRY) 80188558Ssam { 7, "long", "long", "long on-chip tx retries" }, 81174570Ssam#define S_TX_XRETRIES AFTER(S_TX_LONGRETRY) 82161200Ssam { 6, "xretry", "xretry", "tx failed 'cuz too many retries" }, 83174570Ssam#define S_MIB AFTER(S_TX_XRETRIES) 84161200Ssam { 5, "mib", "mib", "mib overflow interrupts" }, 85161200Ssam#ifndef __linux__ 86174570Ssam#define S_TX_LINEAR AFTER(S_MIB) 87161200Ssam { 5, "txlinear", "txlinear", "tx linearized to cluster" }, 88174570Ssam#define S_BSTUCK AFTER(S_TX_LINEAR) 89248669Sadrian { 6, "bstuck", "bstuck", "stuck beacon conditions" }, 90174570Ssam#define S_INTRCOAL AFTER(S_BSTUCK) 91161200Ssam { 5, "intrcoal", "intrcoal", "interrupts coalesced" }, 92174570Ssam#define S_RATE AFTER(S_INTRCOAL) 93161200Ssam#else 94174570Ssam#define S_RATE AFTER(S_MIB) 95161200Ssam#endif 96184371Ssam { 5, "rate", "rate", "current transmit rate" }, 97174570Ssam#define S_WATCHDOG AFTER(S_RATE) 98161200Ssam { 5, "wdog", "wdog", "watchdog timeouts" }, 99174570Ssam#define S_FATAL AFTER(S_WATCHDOG) 100161200Ssam { 5, "fatal", "fatal", "hardware error interrupts" }, 101174570Ssam#define S_BMISS AFTER(S_FATAL) 102161200Ssam { 5, "bmiss", "bmiss", "beacon miss interrupts" }, 103174570Ssam#define S_RXORN AFTER(S_BMISS) 104161200Ssam { 5, "rxorn", "rxorn", "recv overrun interrupts" }, 105174570Ssam#define S_RXEOL AFTER(S_RXORN) 106161200Ssam { 5, "rxeol", "rxeol", "recv eol interrupts" }, 107174570Ssam#define S_TXURN AFTER(S_RXEOL) 108161200Ssam { 5, "txurn", "txurn", "txmit underrun interrupts" }, 109174570Ssam#define S_TX_MGMT AFTER(S_TXURN) 110161200Ssam { 5, "txmgt", "txmgt", "tx management frames" }, 111174570Ssam#define S_TX_DISCARD AFTER(S_TX_MGMT) 112161200Ssam { 5, "txdisc", "txdisc", "tx frames discarded prior to association" }, 113174570Ssam#define S_TX_INVALID AFTER(S_TX_DISCARD) 114161200Ssam { 5, "txinv", "txinv", "tx invalid (19)" }, 115174570Ssam#define S_TX_QSTOP AFTER(S_TX_INVALID) 116161200Ssam { 5, "qstop", "qstop", "tx stopped 'cuz no xmit buffer" }, 117174570Ssam#define S_TX_ENCAP AFTER(S_TX_QSTOP) 118161200Ssam { 5, "txencode", "txencode", "tx encapsulation failed" }, 119174570Ssam#define S_TX_NONODE AFTER(S_TX_ENCAP) 120161200Ssam { 5, "txnonode", "txnonode", "tx failed 'cuz no node" }, 121188559Ssam#define S_TX_NOBUF AFTER(S_TX_NONODE) 122188559Ssam { 5, "txnobuf", "txnobuf", "tx failed 'cuz dma buffer allocation failed" }, 123188559Ssam#define S_TX_NOFRAG AFTER(S_TX_NOBUF) 124188559Ssam { 5, "txnofrag", "txnofrag", "tx failed 'cuz frag buffer allocation(s) failed" }, 125188559Ssam#define S_TX_NOMBUF AFTER(S_TX_NOFRAG) 126161200Ssam { 5, "txnombuf", "txnombuf", "tx failed 'cuz mbuf allocation failed" }, 127161200Ssam#ifndef __linux__ 128174570Ssam#define S_TX_NOMCL AFTER(S_TX_NOMBUF) 129161200Ssam { 5, "txnomcl", "txnomcl", "tx failed 'cuz cluster allocation failed" }, 130174570Ssam#define S_TX_FIFOERR AFTER(S_TX_NOMCL) 131161200Ssam#else 132174570Ssam#define S_TX_FIFOERR AFTER(S_TX_NOMBUF) 133161200Ssam#endif 134161200Ssam { 5, "efifo", "efifo", "tx failed 'cuz FIFO underrun" }, 135174570Ssam#define S_TX_FILTERED AFTER(S_TX_FIFOERR) 136161200Ssam { 5, "efilt", "efilt", "tx failed 'cuz destination filtered" }, 137174570Ssam#define S_TX_BADRATE AFTER(S_TX_FILTERED) 138161200Ssam { 5, "txbadrate", "txbadrate", "tx failed 'cuz bogus xmit rate" }, 139174570Ssam#define S_TX_NOACK AFTER(S_TX_BADRATE) 140161200Ssam { 5, "noack", "noack", "tx frames with no ack marked" }, 141174570Ssam#define S_TX_RTS AFTER(S_TX_NOACK) 142161200Ssam { 5, "rts", "rts", "tx frames with rts enabled" }, 143174570Ssam#define S_TX_CTS AFTER(S_TX_RTS) 144161200Ssam { 5, "cts", "cts", "tx frames with cts enabled" }, 145174570Ssam#define S_TX_SHORTPRE AFTER(S_TX_CTS) 146161200Ssam { 5, "shpre", "shpre", "tx frames with short preamble" }, 147174570Ssam#define S_TX_PROTECT AFTER(S_TX_SHORTPRE) 148161200Ssam { 5, "protect", "protect", "tx frames with 11g protection" }, 149174570Ssam#define S_RX_ORN AFTER(S_TX_PROTECT) 150161200Ssam { 5, "rxorn", "rxorn", "rx failed 'cuz of desc overrun" }, 151174570Ssam#define S_RX_CRC_ERR AFTER(S_RX_ORN) 152161200Ssam { 6, "crcerr", "crcerr", "rx failed 'cuz of bad CRC" }, 153174570Ssam#define S_RX_FIFO_ERR AFTER(S_RX_CRC_ERR) 154161200Ssam { 5, "rxfifo", "rxfifo", "rx failed 'cuz of FIFO overrun" }, 155174570Ssam#define S_RX_CRYPTO_ERR AFTER(S_RX_FIFO_ERR) 156161200Ssam { 5, "crypt", "crypt", "rx failed 'cuz decryption" }, 157174570Ssam#define S_RX_MIC_ERR AFTER(S_RX_CRYPTO_ERR) 158161200Ssam { 4, "mic", "mic", "rx failed 'cuz MIC failure" }, 159174570Ssam#define S_RX_TOOSHORT AFTER(S_RX_MIC_ERR) 160161200Ssam { 5, "rxshort", "rxshort", "rx failed 'cuz frame too short" }, 161174570Ssam#define S_RX_NOMBUF AFTER(S_RX_TOOSHORT) 162161200Ssam { 5, "rxnombuf", "rxnombuf", "rx setup failed 'cuz no mbuf" }, 163174570Ssam#define S_RX_MGT AFTER(S_RX_NOMBUF) 164161200Ssam { 5, "rxmgt", "rxmgt", "rx management frames" }, 165174570Ssam#define S_RX_CTL AFTER(S_RX_MGT) 166161200Ssam { 5, "rxctl", "rxctl", "rx control frames" }, 167174570Ssam#define S_RX_PHY_ERR AFTER(S_RX_CTL) 168161200Ssam { 7, "phyerr", "phyerr", "rx failed 'cuz of PHY err" }, 169174570Ssam#define S_RX_PHY_UNDERRUN AFTER(S_RX_PHY_ERR) 170184371Ssam { 4, "phyund", "TUnd", "transmit underrun" }, 171174570Ssam#define S_RX_PHY_TIMING AFTER(S_RX_PHY_UNDERRUN) 172184371Ssam { 4, "phytim", "Tim", "timing error" }, 173174570Ssam#define S_RX_PHY_PARITY AFTER(S_RX_PHY_TIMING) 174184371Ssam { 4, "phypar", "IPar", "illegal parity" }, 175174570Ssam#define S_RX_PHY_RATE AFTER(S_RX_PHY_PARITY) 176184371Ssam { 4, "phyrate", "IRate", "illegal rate" }, 177174570Ssam#define S_RX_PHY_LENGTH AFTER(S_RX_PHY_RATE) 178184371Ssam { 4, "phylen", "ILen", "illegal length" }, 179174570Ssam#define S_RX_PHY_RADAR AFTER(S_RX_PHY_LENGTH) 180184371Ssam { 4, "phyradar", "Radar", "radar detect" }, 181174570Ssam#define S_RX_PHY_SERVICE AFTER(S_RX_PHY_RADAR) 182184371Ssam { 4, "physervice", "Service", "illegal service" }, 183174570Ssam#define S_RX_PHY_TOR AFTER(S_RX_PHY_SERVICE) 184184371Ssam { 4, "phytor", "TOR", "transmit override receive" }, 185174570Ssam#define S_RX_PHY_OFDM_TIMING AFTER(S_RX_PHY_TOR) 186161200Ssam { 6, "ofdmtim", "ofdmtim", "OFDM timing" }, 187174570Ssam#define S_RX_PHY_OFDM_SIGNAL_PARITY AFTER(S_RX_PHY_OFDM_TIMING) 188161200Ssam { 6, "ofdmsig", "ofdmsig", "OFDM illegal parity" }, 189174570Ssam#define S_RX_PHY_OFDM_RATE_ILLEGAL AFTER(S_RX_PHY_OFDM_SIGNAL_PARITY) 190161200Ssam { 6, "ofdmrate", "ofdmrate", "OFDM illegal rate" }, 191174570Ssam#define S_RX_PHY_OFDM_POWER_DROP AFTER(S_RX_PHY_OFDM_RATE_ILLEGAL) 192161200Ssam { 6, "ofdmpow", "ofdmpow", "OFDM power drop" }, 193174570Ssam#define S_RX_PHY_OFDM_SERVICE AFTER(S_RX_PHY_OFDM_POWER_DROP) 194161200Ssam { 6, "ofdmservice", "ofdmservice", "OFDM illegal service" }, 195174570Ssam#define S_RX_PHY_OFDM_RESTART AFTER(S_RX_PHY_OFDM_SERVICE) 196161200Ssam { 6, "ofdmrestart", "ofdmrestart", "OFDM restart" }, 197174570Ssam#define S_RX_PHY_CCK_TIMING AFTER(S_RX_PHY_OFDM_RESTART) 198161200Ssam { 6, "ccktim", "ccktim", "CCK timing" }, 199174570Ssam#define S_RX_PHY_CCK_HEADER_CRC AFTER(S_RX_PHY_CCK_TIMING) 200161200Ssam { 6, "cckhead", "cckhead", "CCK header crc" }, 201174570Ssam#define S_RX_PHY_CCK_RATE_ILLEGAL AFTER(S_RX_PHY_CCK_HEADER_CRC) 202161200Ssam { 6, "cckrate", "cckrate", "CCK illegal rate" }, 203174570Ssam#define S_RX_PHY_CCK_SERVICE AFTER(S_RX_PHY_CCK_RATE_ILLEGAL) 204161200Ssam { 6, "cckservice", "cckservice", "CCK illegal service" }, 205174570Ssam#define S_RX_PHY_CCK_RESTART AFTER(S_RX_PHY_CCK_SERVICE) 206161200Ssam { 6, "cckrestar", "cckrestar", "CCK restart" }, 207174570Ssam#define S_BE_NOMBUF AFTER(S_RX_PHY_CCK_RESTART) 208161200Ssam { 4, "benombuf", "benombuf", "beacon setup failed 'cuz no mbuf" }, 209174570Ssam#define S_BE_XMIT AFTER(S_BE_NOMBUF) 210188558Ssam { 7, "bexmit", "bexmit", "beacons transmitted" }, 211174570Ssam#define S_PER_CAL AFTER(S_BE_XMIT) 212161200Ssam { 4, "pcal", "pcal", "periodic calibrations" }, 213174570Ssam#define S_PER_CALFAIL AFTER(S_PER_CAL) 214161200Ssam { 4, "pcalf", "pcalf", "periodic calibration failures" }, 215174570Ssam#define S_PER_RFGAIN AFTER(S_PER_CALFAIL) 216161200Ssam { 4, "prfga", "prfga", "rfgain value change" }, 217174570Ssam#if ATH_SUPPORT_TDMA 218174570Ssam#define S_TDMA_UPDATE AFTER(S_PER_RFGAIN) 219188558Ssam { 5, "tdmau", "tdmau", "TDMA slot timing updates" }, 220174570Ssam#define S_TDMA_TIMERS AFTER(S_TDMA_UPDATE) 221188558Ssam { 5, "tdmab", "tdmab", "TDMA slot update set beacon timers" }, 222174570Ssam#define S_TDMA_TSF AFTER(S_TDMA_TIMERS) 223188558Ssam { 5, "tdmat", "tdmat", "TDMA slot update set TSF" }, 224186904Ssam#define S_TDMA_TSFADJ AFTER(S_TDMA_TSF) 225188558Ssam { 8, "tdmadj", "tdmadj", "TDMA slot adjust (usecs, smoothed)" }, 226188196Ssam#define S_TDMA_ACK AFTER(S_TDMA_TSFADJ) 227188196Ssam { 5, "tdmack", "tdmack", "TDMA tx failed 'cuz ACK required" }, 228188196Ssam#define S_RATE_CALLS AFTER(S_TDMA_ACK) 229161200Ssam#else 230174570Ssam#define S_RATE_CALLS AFTER(S_PER_RFGAIN) 231161200Ssam#endif 232161200Ssam { 5, "ratec", "ratec", "rate control checks" }, 233174570Ssam#define S_RATE_RAISE AFTER(S_RATE_CALLS) 234161200Ssam { 5, "rate+", "rate+", "rate control raised xmit rate" }, 235174570Ssam#define S_RATE_DROP AFTER(S_RATE_RAISE) 236161200Ssam { 5, "rate-", "rate-", "rate control dropped xmit rate" }, 237174570Ssam#define S_TX_RSSI AFTER(S_RATE_DROP) 238161200Ssam { 4, "arssi", "arssi", "rssi of last ack" }, 239174570Ssam#define S_RX_RSSI AFTER(S_TX_RSSI) 240161200Ssam { 4, "rssi", "rssi", "avg recv rssi" }, 241174570Ssam#define S_RX_NOISE AFTER(S_RX_RSSI) 242161200Ssam { 5, "noise", "noise", "rx noise floor" }, 243174570Ssam#define S_BMISS_PHANTOM AFTER(S_RX_NOISE) 244161200Ssam { 5, "bmissphantom", "bmissphantom", "phantom beacon misses" }, 245174570Ssam#define S_TX_RAW AFTER(S_BMISS_PHANTOM) 246161200Ssam { 5, "txraw", "txraw", "tx frames through raw api" }, 247188196Ssam#define S_TX_RAW_FAIL AFTER(S_TX_RAW) 248188196Ssam { 5, "txrawfail", "txrawfail", "raw tx failed 'cuz interface/hw down" }, 249188196Ssam#define S_RX_TOOBIG AFTER(S_TX_RAW_FAIL) 250161200Ssam { 5, "rx2big", "rx2big", "rx failed 'cuz frame too large" }, 251226799Sadrian#define S_RX_AGG AFTER(S_RX_TOOBIG) 252226799Sadrian { 5, "rxagg", "rxagg", "A-MPDU sub-frames received" }, 253226799Sadrian#define S_RX_HALFGI AFTER(S_RX_AGG) 254226799Sadrian { 5, "rxhalfgi", "rxhgi", "Half-GI frames received" }, 255226799Sadrian#define S_RX_2040 AFTER(S_RX_HALFGI) 256226799Sadrian { 6, "rx2040", "rx2040", "40MHz frames received" }, 257226799Sadrian#define S_RX_PRE_CRC_ERR AFTER(S_RX_2040) 258226799Sadrian { 11, "rxprecrcerr", "rxprecrcerr", "CRC errors for non-last A-MPDU subframes" }, 259226799Sadrian#define S_RX_POST_CRC_ERR AFTER(S_RX_PRE_CRC_ERR) 260226799Sadrian { 12, "rxpostcrcerr", "rxpostcrcerr", "CRC errors for last subframe in an A-MPDU" }, 261226799Sadrian#define S_RX_DECRYPT_BUSY_ERR AFTER(S_RX_POST_CRC_ERR) 262226799Sadrian { 10, "rxdescbusy", "rxdescbusy", "Decryption engine busy" }, 263226799Sadrian#define S_RX_HI_CHAIN AFTER(S_RX_DECRYPT_BUSY_ERR) 264226799Sadrian { 4, "rxhi", "rxhi", "Frames received with RX chain in high power mode" }, 265251398Sadrian#define S_RX_STBC AFTER(S_RX_HI_CHAIN) 266251398Sadrian { 6, "rxstbc", "rxstbc", "Frames received w/ STBC encoding" }, 267251398Sadrian#define S_TX_HTPROTECT AFTER(S_RX_STBC) 268226799Sadrian { 7, "txhtprot", "txhtprot", "Frames transmitted with HT Protection" }, 269226799Sadrian#define S_RX_QEND AFTER(S_TX_HTPROTECT) 270226799Sadrian { 7, "rxquend", "rxquend", "Hit end of RX descriptor queue" }, 271226799Sadrian#define S_TX_TIMEOUT AFTER(S_RX_QEND) 272226799Sadrian { 4, "txtimeout", "TXTX", "TX Timeout" }, 273226799Sadrian#define S_TX_CSTIMEOUT AFTER(S_TX_TIMEOUT) 274226799Sadrian { 4, "csttimeout", "CSTX", "Carrier Sense Timeout" }, 275226799Sadrian#define S_TX_XTXOP_ERR AFTER(S_TX_CSTIMEOUT) 276226799Sadrian { 5, "xtxoperr", "TXOPX", "TXOP exceed" }, 277226799Sadrian#define S_TX_TIMEREXPIRED_ERR AFTER(S_TX_XTXOP_ERR) 278226799Sadrian { 7, "texperr", "texperr", "TX Timer expired" }, 279226799Sadrian#define S_TX_DESCCFG_ERR AFTER(S_TX_TIMEREXPIRED_ERR) 280226799Sadrian { 10, "desccfgerr", "desccfgerr", "TX descriptor error" }, 281226799Sadrian#define S_TX_SWRETRIES AFTER(S_TX_DESCCFG_ERR) 282226799Sadrian { 9, "txswretry", "txswretry", "Number of frames retransmitted in software" }, 283226799Sadrian#define S_TX_SWRETRIES_MAX AFTER(S_TX_SWRETRIES) 284226799Sadrian { 7, "txswmax", "txswmax", "Number of frames exceeding software retry" }, 285226799Sadrian#define S_TX_DATA_UNDERRUN AFTER(S_TX_SWRETRIES_MAX) 286226799Sadrian { 5, "txdataunderrun", "TXDAU", "A-MPDU TX FIFO data underrun" }, 287226799Sadrian#define S_TX_DELIM_UNDERRUN AFTER(S_TX_DATA_UNDERRUN) 288226799Sadrian { 5, "txdelimunderrun", "TXDEU", "A-MPDU TX Delimiter underrun" }, 289227869Sadrian#define S_TX_AGGR_OK AFTER(S_TX_DELIM_UNDERRUN) 290227869Sadrian { 5, "txaggrok", "TXAOK", "A-MPDU sub-frame TX attempt success" }, 291227869Sadrian#define S_TX_AGGR_FAIL AFTER(S_TX_AGGR_OK) 292227870Sadrian { 4, "txaggrfail", "TXAF", "A-MPDU sub-frame TX attempt failures" }, 293227869Sadrian#define S_TX_AGGR_FAILALL AFTER(S_TX_AGGR_FAIL) 294227870Sadrian { 7, "txaggrfailall", "TXAFALL", "A-MPDU TX frame failures" }, 295161200Ssam#ifndef __linux__ 296227869Sadrian#define S_CABQ_XMIT AFTER(S_TX_AGGR_FAILALL) 297248669Sadrian { 7, "cabxmit", "cabxmit", "cabq frames transmitted" }, 298174570Ssam#define S_CABQ_BUSY AFTER(S_CABQ_XMIT) 299248669Sadrian { 8, "cabqbusy", "cabqbusy", "cabq xmit overflowed beacon interval" }, 300174570Ssam#define S_TX_NODATA AFTER(S_CABQ_BUSY) 301248669Sadrian { 8, "txnodata", "txnodata", "tx discarded empty frame" }, 302174570Ssam#define S_TX_BUSDMA AFTER(S_TX_NODATA) 303248669Sadrian { 8, "txbusdma", "txbusdma", "tx failed for dma resrcs" }, 304174570Ssam#define S_RX_BUSDMA AFTER(S_TX_BUSDMA) 305248669Sadrian { 8, "rxbusdma", "rxbusdma", "rx setup failed for dma resrcs" }, 306174570Ssam#define S_FF_TXOK AFTER(S_RX_BUSDMA) 307161200Ssam#else 308227869Sadrian#define S_FF_TXOK AFTER(S_TX_AGGR_FAILALL) 309161200Ssam#endif 310161200Ssam { 5, "fftxok", "fftxok", "fast frames xmit successfully" }, 311174570Ssam#define S_FF_TXERR AFTER(S_FF_TXOK) 312161200Ssam { 5, "fftxerr", "fftxerr", "fast frames not xmit due to error" }, 313174570Ssam#define S_FF_RX AFTER(S_FF_TXERR) 314161200Ssam { 5, "ffrx", "ffrx", "fast frames received" }, 315174570Ssam#define S_FF_FLUSH AFTER(S_FF_RX) 316161200Ssam { 5, "ffflush", "ffflush", "fast frames flushed from staging q" }, 317174570Ssam#define S_TX_QFULL AFTER(S_FF_FLUSH) 318174570Ssam { 5, "txqfull", "txqfull", "tx discarded 'cuz queue is full" }, 319174570Ssam#define S_ANT_DEFSWITCH AFTER(S_TX_QFULL) 320161200Ssam { 5, "defsw", "defsw", "switched default/rx antenna" }, 321174570Ssam#define S_ANT_TXSWITCH AFTER(S_ANT_DEFSWITCH) 322161200Ssam { 5, "txsw", "txsw", "tx used alternate antenna" }, 323184371Ssam#ifdef ATH_SUPPORT_ANI 324184371Ssam#define S_ANI_NOISE AFTER(S_ANT_TXSWITCH) 325184371Ssam { 2, "ni", "NI", "noise immunity level" }, 326184371Ssam#define S_ANI_SPUR AFTER(S_ANI_NOISE) 327184371Ssam { 2, "si", "SI", "spur immunity level" }, 328184371Ssam#define S_ANI_STEP AFTER(S_ANI_SPUR) 329184371Ssam { 2, "step", "ST", "first step level" }, 330184371Ssam#define S_ANI_OFDM AFTER(S_ANI_STEP) 331184371Ssam { 4, "owsd", "OWSD", "OFDM weak signal detect" }, 332184371Ssam#define S_ANI_CCK AFTER(S_ANI_OFDM) 333184371Ssam { 4, "cwst", "CWST", "CCK weak signal threshold" }, 334184371Ssam#define S_ANI_MAXSPUR AFTER(S_ANI_CCK) 335184371Ssam { 3, "maxsi","MSI", "max spur immunity level" }, 336184371Ssam#define S_ANI_LISTEN AFTER(S_ANI_MAXSPUR) 337184371Ssam { 6, "listen","LISTEN", "listen time" }, 338184371Ssam#define S_ANI_NIUP AFTER(S_ANI_LISTEN) 339184371Ssam { 4, "ni+", "NI-", "ANI increased noise immunity" }, 340184371Ssam#define S_ANI_NIDOWN AFTER(S_ANI_NIUP) 341184371Ssam { 4, "ni-", "NI-", "ANI decrease noise immunity" }, 342184371Ssam#define S_ANI_SIUP AFTER(S_ANI_NIDOWN) 343184371Ssam { 4, "si+", "SI+", "ANI increased spur immunity" }, 344184371Ssam#define S_ANI_SIDOWN AFTER(S_ANI_SIUP) 345184371Ssam { 4, "si-", "SI-", "ANI decrease spur immunity" }, 346184371Ssam#define S_ANI_OFDMON AFTER(S_ANI_SIDOWN) 347184371Ssam { 5, "ofdm+","OFDM+", "ANI enabled OFDM weak signal detect" }, 348184371Ssam#define S_ANI_OFDMOFF AFTER(S_ANI_OFDMON) 349184371Ssam { 5, "ofdm-","OFDM-", "ANI disabled OFDM weak signal detect" }, 350184371Ssam#define S_ANI_CCKHI AFTER(S_ANI_OFDMOFF) 351184371Ssam { 5, "cck+", "CCK+", "ANI enabled CCK weak signal threshold" }, 352184371Ssam#define S_ANI_CCKLO AFTER(S_ANI_CCKHI) 353184371Ssam { 5, "cck-", "CCK-", "ANI disabled CCK weak signal threshold" }, 354184371Ssam#define S_ANI_STEPUP AFTER(S_ANI_CCKLO) 355184371Ssam { 5, "step+","STEP+", "ANI increased first step level" }, 356184371Ssam#define S_ANI_STEPDOWN AFTER(S_ANI_STEPUP) 357184371Ssam { 5, "step-","STEP-", "ANI decreased first step level" }, 358184371Ssam#define S_ANI_OFDMERRS AFTER(S_ANI_STEPDOWN) 359188558Ssam { 8, "ofdm", "OFDM", "cumulative OFDM phy error count" }, 360184371Ssam#define S_ANI_CCKERRS AFTER(S_ANI_OFDMERRS) 361188558Ssam { 8, "cck", "CCK", "cumulative CCK phy error count" }, 362184371Ssam#define S_ANI_RESET AFTER(S_ANI_CCKERRS) 363184371Ssam { 5, "reset","RESET", "ANI parameters zero'd for non-STA operation" }, 364184371Ssam#define S_ANI_LZERO AFTER(S_ANI_RESET) 365184371Ssam { 5, "lzero","LZERO", "ANI forced listen time to zero" }, 366184371Ssam#define S_ANI_LNEG AFTER(S_ANI_LZERO) 367184371Ssam { 5, "lneg", "LNEG", "ANI calculated listen time < 0" }, 368184371Ssam#define S_MIB_ACKBAD AFTER(S_ANI_LNEG) 369188558Ssam { 5, "ackbad","ACKBAD", "missing ACK's" }, 370184371Ssam#define S_MIB_RTSBAD AFTER(S_MIB_ACKBAD) 371188558Ssam { 5, "rtsbad","RTSBAD", "RTS without CTS" }, 372184371Ssam#define S_MIB_RTSGOOD AFTER(S_MIB_RTSBAD) 373188558Ssam { 5, "rtsgood","RTSGOOD", "successful RTS" }, 374184371Ssam#define S_MIB_FCSBAD AFTER(S_MIB_RTSGOOD) 375188558Ssam { 5, "fcsbad","FCSBAD", "bad FCS" }, 376184371Ssam#define S_MIB_BEACONS AFTER(S_MIB_FCSBAD) 377188558Ssam { 5, "beacons","beacons", "beacons received" }, 378184371Ssam#define S_NODE_AVGBRSSI AFTER(S_MIB_BEACONS) 379184371Ssam { 3, "avgbrssi","BSI", "average rssi (beacons only)" }, 380184371Ssam#define S_NODE_AVGRSSI AFTER(S_NODE_AVGBRSSI) 381184371Ssam { 3, "avgrssi","DSI", "average rssi (all rx'd frames)" }, 382184371Ssam#define S_NODE_AVGARSSI AFTER(S_NODE_AVGRSSI) 383184371Ssam { 3, "avgtxrssi","TSI", "average rssi (ACKs only)" }, 384184371Ssam#define S_ANT_TX0 AFTER(S_NODE_AVGARSSI) 385184371Ssam#else 386174570Ssam#define S_ANT_TX0 AFTER(S_ANT_TXSWITCH) 387184371Ssam#endif /* ATH_SUPPORT_ANI */ 388188558Ssam { 8, "tx0", "ant0(tx)", "frames tx on antenna 0" }, 389174570Ssam#define S_ANT_TX1 AFTER(S_ANT_TX0) 390188558Ssam { 8, "tx1", "ant1(tx)", "frames tx on antenna 1" }, 391174570Ssam#define S_ANT_TX2 AFTER(S_ANT_TX1) 392188558Ssam { 8, "tx2", "ant2(tx)", "frames tx on antenna 2" }, 393174570Ssam#define S_ANT_TX3 AFTER(S_ANT_TX2) 394188558Ssam { 8, "tx3", "ant3(tx)", "frames tx on antenna 3" }, 395174570Ssam#define S_ANT_TX4 AFTER(S_ANT_TX3) 396188558Ssam { 8, "tx4", "ant4(tx)", "frames tx on antenna 4" }, 397174570Ssam#define S_ANT_TX5 AFTER(S_ANT_TX4) 398188558Ssam { 8, "tx5", "ant5(tx)", "frames tx on antenna 5" }, 399174570Ssam#define S_ANT_TX6 AFTER(S_ANT_TX5) 400188558Ssam { 8, "tx6", "ant6(tx)", "frames tx on antenna 6" }, 401174570Ssam#define S_ANT_TX7 AFTER(S_ANT_TX6) 402188558Ssam { 8, "tx7", "ant7(tx)", "frames tx on antenna 7" }, 403174570Ssam#define S_ANT_RX0 AFTER(S_ANT_TX7) 404188558Ssam { 8, "rx0", "ant0(rx)", "frames rx on antenna 0" }, 405174570Ssam#define S_ANT_RX1 AFTER(S_ANT_RX0) 406188558Ssam { 8, "rx1", "ant1(rx)", "frames rx on antenna 1" }, 407174570Ssam#define S_ANT_RX2 AFTER(S_ANT_RX1) 408188558Ssam { 8, "rx2", "ant2(rx)", "frames rx on antenna 2" }, 409174570Ssam#define S_ANT_RX3 AFTER(S_ANT_RX2) 410188558Ssam { 8, "rx3", "ant3(rx)", "frames rx on antenna 3" }, 411174570Ssam#define S_ANT_RX4 AFTER(S_ANT_RX3) 412188558Ssam { 8, "rx4", "ant4(rx)", "frames rx on antenna 4" }, 413174570Ssam#define S_ANT_RX5 AFTER(S_ANT_RX4) 414188558Ssam { 8, "rx5", "ant5(rx)", "frames rx on antenna 5" }, 415174570Ssam#define S_ANT_RX6 AFTER(S_ANT_RX5) 416188558Ssam { 8, "rx6", "ant6(rx)", "frames rx on antenna 6" }, 417174570Ssam#define S_ANT_RX7 AFTER(S_ANT_RX6) 418188558Ssam { 8, "rx7", "ant7(rx)", "frames rx on antenna 7" }, 419174570Ssam#define S_TX_SIGNAL AFTER(S_ANT_RX7) 420161200Ssam { 4, "asignal", "asig", "signal of last ack (dBm)" }, 421174570Ssam#define S_RX_SIGNAL AFTER(S_TX_SIGNAL) 422161200Ssam { 4, "signal", "sig", "avg recv signal (dBm)" }, 423248668Sadrian#define S_BMISSCOUNT AFTER(S_RX_SIGNAL) 424248668Sadrian { 8, "bmisscount", "bmisscnt", "beacon miss count" }, 425153317Ssam}; 426161200Ssam#define S_PHY_MIN S_RX_PHY_UNDERRUN 427161200Ssam#define S_PHY_MAX S_RX_PHY_CCK_RESTART 428161200Ssam#define S_LAST S_ANT_TX0 429248668Sadrian#define S_MAX S_BMISSCOUNT+1 430153317Ssam 431226799Sadrian/* 432226799Sadrian * XXX fold this into the external HAL definitions! -adrian 433226799Sadrian */ 434174570Ssamstruct _athstats { 435174570Ssam struct ath_stats ath; 436184371Ssam#ifdef ATH_SUPPORT_ANI 437184371Ssam struct { 438184371Ssam uint32_t ast_ani_niup; /* increased noise immunity */ 439184371Ssam uint32_t ast_ani_nidown; /* decreased noise immunity */ 440184371Ssam uint32_t ast_ani_spurup; /* increased spur immunity */ 441184371Ssam uint32_t ast_ani_spurdown; /* descreased spur immunity */ 442184371Ssam uint32_t ast_ani_ofdmon; /* OFDM weak signal detect on */ 443184371Ssam uint32_t ast_ani_ofdmoff; /* OFDM weak signal detect off*/ 444184371Ssam uint32_t ast_ani_cckhigh; /* CCK weak signal thr high */ 445184371Ssam uint32_t ast_ani_ccklow; /* CCK weak signal thr low */ 446184371Ssam uint32_t ast_ani_stepup; /* increased first step level */ 447184371Ssam uint32_t ast_ani_stepdown; /* decreased first step level */ 448184371Ssam uint32_t ast_ani_ofdmerrs; /* cumulative ofdm phy err cnt*/ 449184371Ssam uint32_t ast_ani_cckerrs; /* cumulative cck phy err cnt */ 450184371Ssam uint32_t ast_ani_reset; /* params zero'd for non-STA */ 451184371Ssam uint32_t ast_ani_lzero; /* listen time forced to zero */ 452184371Ssam uint32_t ast_ani_lneg; /* listen time calculated < 0 */ 453184371Ssam HAL_MIB_STATS ast_mibstats; /* MIB counter stats */ 454184371Ssam HAL_NODE_STATS ast_nodestats; /* latest rssi stats */ 455184371Ssam } ani_stats; 456184371Ssam struct { 457184371Ssam uint8_t noiseImmunityLevel; 458184371Ssam uint8_t spurImmunityLevel; 459184371Ssam uint8_t firstepLevel; 460184371Ssam uint8_t ofdmWeakSigDetectOff; 461184453Ssam uint8_t cckWeakSigThreshold; 462184371Ssam uint32_t listenTime; 463184371Ssam } ani_state; 464184371Ssam#endif 465174570Ssam}; 466174570Ssam 467161200Ssamstruct athstatfoo_p { 468161200Ssam struct athstatfoo base; 469161200Ssam int s; 470174570Ssam int optstats; 471184371Ssam#define ATHSTATS_ANI 0x0001 472161200Ssam struct ifreq ifr; 473174570Ssam struct ath_diag atd; 474174570Ssam struct _athstats cur; 475174570Ssam struct _athstats total; 476161200Ssam}; 477161200Ssam 478153317Ssamstatic void 479161200Ssamath_setifname(struct athstatfoo *wf0, const char *ifname) 480153317Ssam{ 481161200Ssam struct athstatfoo_p *wf = (struct athstatfoo_p *) wf0; 482153317Ssam 483161200Ssam strncpy(wf->ifr.ifr_name, ifname, sizeof (wf->ifr.ifr_name)); 484184371Ssam#ifdef ATH_SUPPORT_ANI 485184371Ssam strncpy(wf->atd.ad_name, ifname, sizeof (wf->atd.ad_name)); 486184371Ssam wf->optstats |= ATHSTATS_ANI; 487184371Ssam#endif 488153317Ssam} 489153317Ssam 490188560Ssamstatic void 491188560Ssamath_zerostats(struct athstatfoo *wf0) 492188560Ssam{ 493188560Ssam struct athstatfoo_p *wf = (struct athstatfoo_p *) wf0; 494188560Ssam 495188560Ssam if (ioctl(wf->s, SIOCZATHSTATS, &wf->ifr) < 0) 496244965Sadrian err(-1, "ioctl: %s", wf->ifr.ifr_name); 497188560Ssam} 498188560Ssam 499161200Ssamstatic void 500174570Ssamath_collect(struct athstatfoo_p *wf, struct _athstats *stats) 501153317Ssam{ 502174570Ssam wf->ifr.ifr_data = (caddr_t) &stats->ath; 503161200Ssam if (ioctl(wf->s, SIOCGATHSTATS, &wf->ifr) < 0) 504244965Sadrian err(1, "ioctl: %s", wf->ifr.ifr_name); 505184371Ssam#ifdef ATH_SUPPORT_ANI 506184371Ssam if (wf->optstats & ATHSTATS_ANI) { 507184371Ssam wf->atd.ad_id = 5; 508184371Ssam wf->atd.ad_out_data = (caddr_t) &stats->ani_state; 509184371Ssam wf->atd.ad_out_size = sizeof(stats->ani_state); 510184371Ssam if (ioctl(wf->s, SIOCGATHDIAG, &wf->atd) < 0) { 511244965Sadrian warn("ioctl: %s", wf->atd.ad_name); 512184371Ssam wf->optstats &= ~ATHSTATS_ANI; 513184371Ssam } 514184371Ssam wf->atd.ad_id = 8; 515184371Ssam wf->atd.ad_out_data = (caddr_t) &stats->ani_stats; 516184371Ssam wf->atd.ad_out_size = sizeof(stats->ani_stats); 517184371Ssam if (ioctl(wf->s, SIOCGATHDIAG, &wf->atd) < 0) 518244965Sadrian warn("ioctl: %s", wf->atd.ad_name); 519184371Ssam } 520184371Ssam#endif /* ATH_SUPPORT_ANI */ 521161200Ssam} 522153317Ssam 523161200Ssamstatic void 524161200Ssamath_collect_cur(struct statfoo *sf) 525161200Ssam{ 526161200Ssam struct athstatfoo_p *wf = (struct athstatfoo_p *) sf; 527153317Ssam 528161200Ssam ath_collect(wf, &wf->cur); 529153317Ssam} 530153317Ssam 531161200Ssamstatic void 532161200Ssamath_collect_tot(struct statfoo *sf) 533161200Ssam{ 534161200Ssam struct athstatfoo_p *wf = (struct athstatfoo_p *) sf; 535153317Ssam 536161200Ssam ath_collect(wf, &wf->total); 537161200Ssam} 538161200Ssam 539153317Ssamstatic void 540161200Ssamath_update_tot(struct statfoo *sf) 541153317Ssam{ 542161200Ssam struct athstatfoo_p *wf = (struct athstatfoo_p *) sf; 543161200Ssam 544161200Ssam wf->total = wf->cur; 545153317Ssam} 546153317Ssam 547184371Ssamstatic void 548184371Ssamsnprintrate(char b[], size_t bs, int rate) 549184371Ssam{ 550184371Ssam if (rate & IEEE80211_RATE_MCS) 551184371Ssam snprintf(b, bs, "MCS%u", rate &~ IEEE80211_RATE_MCS); 552184371Ssam else if (rate & 1) 553184371Ssam snprintf(b, bs, "%u.5M", rate / 2); 554184371Ssam else 555184371Ssam snprintf(b, bs, "%uM", rate / 2); 556184371Ssam} 557184371Ssam 558161200Ssamstatic int 559161200Ssamath_get_curstat(struct statfoo *sf, int s, char b[], size_t bs) 560153317Ssam{ 561161200Ssam struct athstatfoo_p *wf = (struct athstatfoo_p *) sf; 562161200Ssam#define STAT(x) \ 563174570Ssam snprintf(b, bs, "%u", wf->cur.ath.ast_##x - wf->total.ath.ast_##x); return 1 564161200Ssam#define PHY(x) \ 565174570Ssam snprintf(b, bs, "%u", wf->cur.ath.ast_rx_phy[x] - wf->total.ath.ast_rx_phy[x]); return 1 566184371Ssam#define ANI(x) \ 567184371Ssam snprintf(b, bs, "%u", wf->cur.ani_state.x); return 1 568184371Ssam#define ANISTAT(x) \ 569184371Ssam snprintf(b, bs, "%u", wf->cur.ani_stats.ast_ani_##x - wf->total.ani_stats.ast_ani_##x); return 1 570184371Ssam#define MIBSTAT(x) \ 571184371Ssam snprintf(b, bs, "%u", wf->cur.ani_stats.ast_mibstats.x - wf->total.ani_stats.ast_mibstats.x); return 1 572161200Ssam#define TXANT(x) \ 573174570Ssam snprintf(b, bs, "%u", wf->cur.ath.ast_ant_tx[x] - wf->total.ath.ast_ant_tx[x]); return 1 574161200Ssam#define RXANT(x) \ 575174570Ssam snprintf(b, bs, "%u", wf->cur.ath.ast_ant_rx[x] - wf->total.ath.ast_ant_rx[x]); return 1 576153317Ssam 577161200Ssam switch (s) { 578161200Ssam case S_INPUT: 579161200Ssam snprintf(b, bs, "%lu", 580244965Sadrian (unsigned long) 581244965Sadrian ((wf->cur.ath.ast_rx_packets - wf->total.ath.ast_rx_packets) - 582244965Sadrian (wf->cur.ath.ast_rx_mgt - wf->total.ath.ast_rx_mgt))); 583161200Ssam return 1; 584161200Ssam case S_OUTPUT: 585161200Ssam snprintf(b, bs, "%lu", 586244965Sadrian (unsigned long) 587244965Sadrian (wf->cur.ath.ast_tx_packets - wf->total.ath.ast_tx_packets)); 588161200Ssam return 1; 589161200Ssam case S_RATE: 590184371Ssam snprintrate(b, bs, wf->cur.ath.ast_tx_rate); 591161200Ssam return 1; 592161200Ssam case S_WATCHDOG: STAT(watchdog); 593161200Ssam case S_FATAL: STAT(hardware); 594161200Ssam case S_BMISS: STAT(bmiss); 595161200Ssam case S_BMISS_PHANTOM: STAT(bmiss_phantom); 596161200Ssam#ifdef S_BSTUCK 597161200Ssam case S_BSTUCK: STAT(bstuck); 598161200Ssam#endif 599161200Ssam case S_RXORN: STAT(rxorn); 600161200Ssam case S_RXEOL: STAT(rxeol); 601161200Ssam case S_TXURN: STAT(txurn); 602161200Ssam case S_MIB: STAT(mib); 603161200Ssam#ifdef S_INTRCOAL 604161200Ssam case S_INTRCOAL: STAT(intrcoal); 605161200Ssam#endif 606161200Ssam case S_TX_MGMT: STAT(tx_mgmt); 607161200Ssam case S_TX_DISCARD: STAT(tx_discard); 608161200Ssam case S_TX_QSTOP: STAT(tx_qstop); 609161200Ssam case S_TX_ENCAP: STAT(tx_encap); 610161200Ssam case S_TX_NONODE: STAT(tx_nonode); 611188559Ssam case S_TX_NOBUF: STAT(tx_nobuf); 612188559Ssam case S_TX_NOFRAG: STAT(tx_nofrag); 613161200Ssam case S_TX_NOMBUF: STAT(tx_nombuf); 614161200Ssam#ifdef S_TX_NOMCL 615161200Ssam case S_TX_NOMCL: STAT(tx_nomcl); 616161200Ssam case S_TX_LINEAR: STAT(tx_linear); 617161200Ssam case S_TX_NODATA: STAT(tx_nodata); 618161200Ssam case S_TX_BUSDMA: STAT(tx_busdma); 619161200Ssam#endif 620161200Ssam case S_TX_XRETRIES: STAT(tx_xretries); 621161200Ssam case S_TX_FIFOERR: STAT(tx_fifoerr); 622161200Ssam case S_TX_FILTERED: STAT(tx_filtered); 623161200Ssam case S_TX_SHORTRETRY: STAT(tx_shortretry); 624161200Ssam case S_TX_LONGRETRY: STAT(tx_longretry); 625161200Ssam case S_TX_BADRATE: STAT(tx_badrate); 626161200Ssam case S_TX_NOACK: STAT(tx_noack); 627161200Ssam case S_TX_RTS: STAT(tx_rts); 628161200Ssam case S_TX_CTS: STAT(tx_cts); 629161200Ssam case S_TX_SHORTPRE: STAT(tx_shortpre); 630161200Ssam case S_TX_ALTRATE: STAT(tx_altrate); 631161200Ssam case S_TX_PROTECT: STAT(tx_protect); 632188196Ssam case S_TX_RAW: STAT(tx_raw); 633188196Ssam case S_TX_RAW_FAIL: STAT(tx_raw_fail); 634161200Ssam case S_RX_NOMBUF: STAT(rx_nombuf); 635161200Ssam#ifdef S_RX_BUSDMA 636161200Ssam case S_RX_BUSDMA: STAT(rx_busdma); 637161200Ssam#endif 638161200Ssam case S_RX_ORN: STAT(rx_orn); 639161200Ssam case S_RX_CRC_ERR: STAT(rx_crcerr); 640161200Ssam case S_RX_FIFO_ERR: STAT(rx_fifoerr); 641161200Ssam case S_RX_CRYPTO_ERR: STAT(rx_badcrypt); 642161200Ssam case S_RX_MIC_ERR: STAT(rx_badmic); 643161200Ssam case S_RX_PHY_ERR: STAT(rx_phyerr); 644161200Ssam case S_RX_PHY_UNDERRUN: PHY(HAL_PHYERR_UNDERRUN); 645161200Ssam case S_RX_PHY_TIMING: PHY(HAL_PHYERR_TIMING); 646161200Ssam case S_RX_PHY_PARITY: PHY(HAL_PHYERR_PARITY); 647161200Ssam case S_RX_PHY_RATE: PHY(HAL_PHYERR_RATE); 648161200Ssam case S_RX_PHY_LENGTH: PHY(HAL_PHYERR_LENGTH); 649161200Ssam case S_RX_PHY_RADAR: PHY(HAL_PHYERR_RADAR); 650161200Ssam case S_RX_PHY_SERVICE: PHY(HAL_PHYERR_SERVICE); 651161200Ssam case S_RX_PHY_TOR: PHY(HAL_PHYERR_TOR); 652161200Ssam case S_RX_PHY_OFDM_TIMING: PHY(HAL_PHYERR_OFDM_TIMING); 653161200Ssam case S_RX_PHY_OFDM_SIGNAL_PARITY: PHY(HAL_PHYERR_OFDM_SIGNAL_PARITY); 654161200Ssam case S_RX_PHY_OFDM_RATE_ILLEGAL: PHY(HAL_PHYERR_OFDM_RATE_ILLEGAL); 655161200Ssam case S_RX_PHY_OFDM_POWER_DROP: PHY(HAL_PHYERR_OFDM_POWER_DROP); 656161200Ssam case S_RX_PHY_OFDM_SERVICE: PHY(HAL_PHYERR_OFDM_SERVICE); 657161200Ssam case S_RX_PHY_OFDM_RESTART: PHY(HAL_PHYERR_OFDM_RESTART); 658161200Ssam case S_RX_PHY_CCK_TIMING: PHY(HAL_PHYERR_CCK_TIMING); 659161200Ssam case S_RX_PHY_CCK_HEADER_CRC: PHY(HAL_PHYERR_CCK_HEADER_CRC); 660161200Ssam case S_RX_PHY_CCK_RATE_ILLEGAL: PHY(HAL_PHYERR_CCK_RATE_ILLEGAL); 661161200Ssam case S_RX_PHY_CCK_SERVICE: PHY(HAL_PHYERR_CCK_SERVICE); 662161200Ssam case S_RX_PHY_CCK_RESTART: PHY(HAL_PHYERR_CCK_RESTART); 663161200Ssam case S_RX_TOOSHORT: STAT(rx_tooshort); 664161200Ssam case S_RX_TOOBIG: STAT(rx_toobig); 665161200Ssam case S_RX_MGT: STAT(rx_mgt); 666161200Ssam case S_RX_CTL: STAT(rx_ctl); 667161200Ssam case S_TX_RSSI: 668174570Ssam snprintf(b, bs, "%d", wf->cur.ath.ast_tx_rssi); 669161200Ssam return 1; 670161200Ssam case S_RX_RSSI: 671174570Ssam snprintf(b, bs, "%d", wf->cur.ath.ast_rx_rssi); 672161200Ssam return 1; 673161200Ssam case S_BE_XMIT: STAT(be_xmit); 674161200Ssam case S_BE_NOMBUF: STAT(be_nombuf); 675161200Ssam case S_PER_CAL: STAT(per_cal); 676161200Ssam case S_PER_CALFAIL: STAT(per_calfail); 677161200Ssam case S_PER_RFGAIN: STAT(per_rfgain); 678161200Ssam#ifdef S_TDMA_UPDATE 679161200Ssam case S_TDMA_UPDATE: STAT(tdma_update); 680161200Ssam case S_TDMA_TIMERS: STAT(tdma_timers); 681161200Ssam case S_TDMA_TSF: STAT(tdma_tsf); 682186904Ssam case S_TDMA_TSFADJ: 683186904Ssam snprintf(b, bs, "-%d/+%d", 684186904Ssam wf->cur.ath.ast_tdma_tsfadjm, wf->cur.ath.ast_tdma_tsfadjp); 685186904Ssam return 1; 686188196Ssam case S_TDMA_ACK: STAT(tdma_ack); 687161200Ssam#endif 688161200Ssam case S_RATE_CALLS: STAT(rate_calls); 689161200Ssam case S_RATE_RAISE: STAT(rate_raise); 690161200Ssam case S_RATE_DROP: STAT(rate_drop); 691161200Ssam case S_ANT_DEFSWITCH: STAT(ant_defswitch); 692161200Ssam case S_ANT_TXSWITCH: STAT(ant_txswitch); 693184371Ssam#ifdef S_ANI_NOISE 694184371Ssam case S_ANI_NOISE: ANI(noiseImmunityLevel); 695184371Ssam case S_ANI_SPUR: ANI(spurImmunityLevel); 696184371Ssam case S_ANI_STEP: ANI(firstepLevel); 697184371Ssam case S_ANI_OFDM: ANI(ofdmWeakSigDetectOff); 698184453Ssam case S_ANI_CCK: ANI(cckWeakSigThreshold); 699184371Ssam case S_ANI_LISTEN: ANI(listenTime); 700184371Ssam case S_ANI_NIUP: ANISTAT(niup); 701184371Ssam case S_ANI_NIDOWN: ANISTAT(nidown); 702184371Ssam case S_ANI_SIUP: ANISTAT(spurup); 703184371Ssam case S_ANI_SIDOWN: ANISTAT(spurdown); 704184371Ssam case S_ANI_OFDMON: ANISTAT(ofdmon); 705184371Ssam case S_ANI_OFDMOFF: ANISTAT(ofdmoff); 706184371Ssam case S_ANI_CCKHI: ANISTAT(cckhigh); 707184371Ssam case S_ANI_CCKLO: ANISTAT(ccklow); 708184371Ssam case S_ANI_STEPUP: ANISTAT(stepup); 709184371Ssam case S_ANI_STEPDOWN: ANISTAT(stepdown); 710184371Ssam case S_ANI_OFDMERRS: ANISTAT(ofdmerrs); 711184371Ssam case S_ANI_CCKERRS: ANISTAT(cckerrs); 712184371Ssam case S_ANI_RESET: ANISTAT(reset); 713184371Ssam case S_ANI_LZERO: ANISTAT(lzero); 714184371Ssam case S_ANI_LNEG: ANISTAT(lneg); 715184371Ssam case S_MIB_ACKBAD: MIBSTAT(ackrcv_bad); 716184371Ssam case S_MIB_RTSBAD: MIBSTAT(rts_bad); 717184371Ssam case S_MIB_RTSGOOD: MIBSTAT(rts_good); 718184371Ssam case S_MIB_FCSBAD: MIBSTAT(fcs_bad); 719184371Ssam case S_MIB_BEACONS: MIBSTAT(beacons); 720184371Ssam case S_NODE_AVGBRSSI: 721184371Ssam snprintf(b, bs, "%u", 722184371Ssam HAL_RSSI(wf->cur.ani_stats.ast_nodestats.ns_avgbrssi)); 723184371Ssam return 1; 724184371Ssam case S_NODE_AVGRSSI: 725184371Ssam snprintf(b, bs, "%u", 726184371Ssam HAL_RSSI(wf->cur.ani_stats.ast_nodestats.ns_avgrssi)); 727184371Ssam return 1; 728184371Ssam case S_NODE_AVGARSSI: 729184371Ssam snprintf(b, bs, "%u", 730184371Ssam HAL_RSSI(wf->cur.ani_stats.ast_nodestats.ns_avgtxrssi)); 731184371Ssam return 1; 732184371Ssam#endif 733161200Ssam case S_ANT_TX0: TXANT(0); 734161200Ssam case S_ANT_TX1: TXANT(1); 735161200Ssam case S_ANT_TX2: TXANT(2); 736161200Ssam case S_ANT_TX3: TXANT(3); 737161200Ssam case S_ANT_TX4: TXANT(4); 738161200Ssam case S_ANT_TX5: TXANT(5); 739161200Ssam case S_ANT_TX6: TXANT(6); 740161200Ssam case S_ANT_TX7: TXANT(7); 741161200Ssam case S_ANT_RX0: RXANT(0); 742161200Ssam case S_ANT_RX1: RXANT(1); 743161200Ssam case S_ANT_RX2: RXANT(2); 744161200Ssam case S_ANT_RX3: RXANT(3); 745161200Ssam case S_ANT_RX4: RXANT(4); 746161200Ssam case S_ANT_RX5: RXANT(5); 747161200Ssam case S_ANT_RX6: RXANT(6); 748161200Ssam case S_ANT_RX7: RXANT(7); 749161200Ssam#ifdef S_CABQ_XMIT 750161200Ssam case S_CABQ_XMIT: STAT(cabq_xmit); 751161200Ssam case S_CABQ_BUSY: STAT(cabq_busy); 752161200Ssam#endif 753161200Ssam case S_FF_TXOK: STAT(ff_txok); 754161200Ssam case S_FF_TXERR: STAT(ff_txerr); 755174570Ssam case S_FF_RX: STAT(ff_rx); 756161200Ssam case S_FF_FLUSH: STAT(ff_flush); 757174570Ssam case S_TX_QFULL: STAT(tx_qfull); 758248668Sadrian case S_BMISSCOUNT: STAT(be_missed); 759161200Ssam case S_RX_NOISE: 760174570Ssam snprintf(b, bs, "%d", wf->cur.ath.ast_rx_noise); 761161200Ssam return 1; 762161200Ssam case S_TX_SIGNAL: 763161200Ssam snprintf(b, bs, "%d", 764174570Ssam wf->cur.ath.ast_tx_rssi + wf->cur.ath.ast_rx_noise); 765161200Ssam return 1; 766161200Ssam case S_RX_SIGNAL: 767161200Ssam snprintf(b, bs, "%d", 768174570Ssam wf->cur.ath.ast_rx_rssi + wf->cur.ath.ast_rx_noise); 769161200Ssam return 1; 770226799Sadrian case S_RX_AGG: STAT(rx_agg); 771226799Sadrian case S_RX_HALFGI: STAT(rx_halfgi); 772226799Sadrian case S_RX_2040: STAT(rx_2040); 773226799Sadrian case S_RX_PRE_CRC_ERR: STAT(rx_pre_crc_err); 774226799Sadrian case S_RX_POST_CRC_ERR: STAT(rx_post_crc_err); 775226799Sadrian case S_RX_DECRYPT_BUSY_ERR: STAT(rx_decrypt_busy_err); 776226799Sadrian case S_RX_HI_CHAIN: STAT(rx_hi_rx_chain); 777251398Sadrian case S_RX_STBC: STAT(rx_stbc); 778226799Sadrian case S_TX_HTPROTECT: STAT(tx_htprotect); 779226799Sadrian case S_RX_QEND: STAT(rx_hitqueueend); 780226799Sadrian case S_TX_TIMEOUT: STAT(tx_timeout); 781226799Sadrian case S_TX_CSTIMEOUT: STAT(tx_cst); 782226799Sadrian case S_TX_XTXOP_ERR: STAT(tx_xtxop); 783226799Sadrian case S_TX_TIMEREXPIRED_ERR: STAT(tx_timerexpired); 784226799Sadrian case S_TX_DESCCFG_ERR: STAT(tx_desccfgerr); 785226799Sadrian case S_TX_SWRETRIES: STAT(tx_swretries); 786226799Sadrian case S_TX_SWRETRIES_MAX: STAT(tx_swretrymax); 787226799Sadrian case S_TX_DATA_UNDERRUN: STAT(tx_data_underrun); 788226799Sadrian case S_TX_DELIM_UNDERRUN: STAT(tx_delim_underrun); 789227869Sadrian case S_TX_AGGR_OK: STAT(tx_aggr_ok); 790227869Sadrian case S_TX_AGGR_FAIL: STAT(tx_aggr_fail); 791227869Sadrian case S_TX_AGGR_FAILALL: STAT(tx_aggr_failall); 792161200Ssam } 793161200Ssam b[0] = '\0'; 794161200Ssam return 0; 795161200Ssam#undef RXANT 796161200Ssam#undef TXANT 797184371Ssam#undef ANI 798184371Ssam#undef ANISTAT 799184371Ssam#undef MIBSTAT 800161200Ssam#undef PHY 801161200Ssam#undef STAT 802161200Ssam} 803153317Ssam 804161200Ssamstatic int 805161200Ssamath_get_totstat(struct statfoo *sf, int s, char b[], size_t bs) 806161200Ssam{ 807161200Ssam struct athstatfoo_p *wf = (struct athstatfoo_p *) sf; 808161200Ssam#define STAT(x) \ 809188558Ssam snprintf(b, bs, "%u", wf->total.ath.ast_##x); return 1 810161200Ssam#define PHY(x) \ 811188558Ssam snprintf(b, bs, "%u", wf->total.ath.ast_rx_phy[x]); return 1 812184371Ssam#define ANI(x) \ 813188558Ssam snprintf(b, bs, "%u", wf->total.ani_state.x); return 1 814184371Ssam#define ANISTAT(x) \ 815188558Ssam snprintf(b, bs, "%u", wf->total.ani_stats.ast_ani_##x); return 1 816184371Ssam#define MIBSTAT(x) \ 817188558Ssam snprintf(b, bs, "%u", wf->total.ani_stats.ast_mibstats.x); return 1 818161200Ssam#define TXANT(x) \ 819188558Ssam snprintf(b, bs, "%u", wf->total.ath.ast_ant_tx[x]); return 1 820161200Ssam#define RXANT(x) \ 821188558Ssam snprintf(b, bs, "%u", wf->total.ath.ast_ant_rx[x]); return 1 822153317Ssam 823161200Ssam switch (s) { 824161200Ssam case S_INPUT: 825188558Ssam snprintf(b, bs, "%lu", 826174570Ssam wf->total.ath.ast_rx_packets - wf->total.ath.ast_rx_mgt); 827161200Ssam return 1; 828161200Ssam case S_OUTPUT: 829188558Ssam snprintf(b, bs, "%lu", wf->total.ath.ast_tx_packets); 830161200Ssam return 1; 831161200Ssam case S_RATE: 832184371Ssam snprintrate(b, bs, wf->total.ath.ast_tx_rate); 833161200Ssam return 1; 834161200Ssam case S_WATCHDOG: STAT(watchdog); 835161200Ssam case S_FATAL: STAT(hardware); 836161200Ssam case S_BMISS: STAT(bmiss); 837161200Ssam case S_BMISS_PHANTOM: STAT(bmiss_phantom); 838161200Ssam#ifdef S_BSTUCK 839161200Ssam case S_BSTUCK: STAT(bstuck); 840161200Ssam#endif 841161200Ssam case S_RXORN: STAT(rxorn); 842161200Ssam case S_RXEOL: STAT(rxeol); 843161200Ssam case S_TXURN: STAT(txurn); 844161200Ssam case S_MIB: STAT(mib); 845161200Ssam#ifdef S_INTRCOAL 846161200Ssam case S_INTRCOAL: STAT(intrcoal); 847161200Ssam#endif 848161200Ssam case S_TX_MGMT: STAT(tx_mgmt); 849161200Ssam case S_TX_DISCARD: STAT(tx_discard); 850161200Ssam case S_TX_QSTOP: STAT(tx_qstop); 851161200Ssam case S_TX_ENCAP: STAT(tx_encap); 852161200Ssam case S_TX_NONODE: STAT(tx_nonode); 853188559Ssam case S_TX_NOBUF: STAT(tx_nobuf); 854188559Ssam case S_TX_NOFRAG: STAT(tx_nofrag); 855161200Ssam case S_TX_NOMBUF: STAT(tx_nombuf); 856161200Ssam#ifdef S_TX_NOMCL 857161200Ssam case S_TX_NOMCL: STAT(tx_nomcl); 858161200Ssam case S_TX_LINEAR: STAT(tx_linear); 859161200Ssam case S_TX_NODATA: STAT(tx_nodata); 860161200Ssam case S_TX_BUSDMA: STAT(tx_busdma); 861161200Ssam#endif 862161200Ssam case S_TX_XRETRIES: STAT(tx_xretries); 863161200Ssam case S_TX_FIFOERR: STAT(tx_fifoerr); 864161200Ssam case S_TX_FILTERED: STAT(tx_filtered); 865161200Ssam case S_TX_SHORTRETRY: STAT(tx_shortretry); 866161200Ssam case S_TX_LONGRETRY: STAT(tx_longretry); 867161200Ssam case S_TX_BADRATE: STAT(tx_badrate); 868161200Ssam case S_TX_NOACK: STAT(tx_noack); 869161200Ssam case S_TX_RTS: STAT(tx_rts); 870161200Ssam case S_TX_CTS: STAT(tx_cts); 871161200Ssam case S_TX_SHORTPRE: STAT(tx_shortpre); 872161200Ssam case S_TX_ALTRATE: STAT(tx_altrate); 873161200Ssam case S_TX_PROTECT: STAT(tx_protect); 874188196Ssam case S_TX_RAW: STAT(tx_raw); 875188196Ssam case S_TX_RAW_FAIL: STAT(tx_raw_fail); 876161200Ssam case S_RX_NOMBUF: STAT(rx_nombuf); 877161200Ssam#ifdef S_RX_BUSDMA 878161200Ssam case S_RX_BUSDMA: STAT(rx_busdma); 879161200Ssam#endif 880161200Ssam case S_RX_ORN: STAT(rx_orn); 881161200Ssam case S_RX_CRC_ERR: STAT(rx_crcerr); 882161200Ssam case S_RX_FIFO_ERR: STAT(rx_fifoerr); 883161200Ssam case S_RX_CRYPTO_ERR: STAT(rx_badcrypt); 884161200Ssam case S_RX_MIC_ERR: STAT(rx_badmic); 885161200Ssam case S_RX_PHY_ERR: STAT(rx_phyerr); 886161200Ssam case S_RX_PHY_UNDERRUN: PHY(HAL_PHYERR_UNDERRUN); 887161200Ssam case S_RX_PHY_TIMING: PHY(HAL_PHYERR_TIMING); 888161200Ssam case S_RX_PHY_PARITY: PHY(HAL_PHYERR_PARITY); 889161200Ssam case S_RX_PHY_RATE: PHY(HAL_PHYERR_RATE); 890161200Ssam case S_RX_PHY_LENGTH: PHY(HAL_PHYERR_LENGTH); 891161200Ssam case S_RX_PHY_RADAR: PHY(HAL_PHYERR_RADAR); 892161200Ssam case S_RX_PHY_SERVICE: PHY(HAL_PHYERR_SERVICE); 893161200Ssam case S_RX_PHY_TOR: PHY(HAL_PHYERR_TOR); 894161200Ssam case S_RX_PHY_OFDM_TIMING: PHY(HAL_PHYERR_OFDM_TIMING); 895161200Ssam case S_RX_PHY_OFDM_SIGNAL_PARITY: PHY(HAL_PHYERR_OFDM_SIGNAL_PARITY); 896161200Ssam case S_RX_PHY_OFDM_RATE_ILLEGAL: PHY(HAL_PHYERR_OFDM_RATE_ILLEGAL); 897161200Ssam case S_RX_PHY_OFDM_POWER_DROP: PHY(HAL_PHYERR_OFDM_POWER_DROP); 898161200Ssam case S_RX_PHY_OFDM_SERVICE: PHY(HAL_PHYERR_OFDM_SERVICE); 899161200Ssam case S_RX_PHY_OFDM_RESTART: PHY(HAL_PHYERR_OFDM_RESTART); 900161200Ssam case S_RX_PHY_CCK_TIMING: PHY(HAL_PHYERR_CCK_TIMING); 901161200Ssam case S_RX_PHY_CCK_HEADER_CRC: PHY(HAL_PHYERR_CCK_HEADER_CRC); 902161200Ssam case S_RX_PHY_CCK_RATE_ILLEGAL: PHY(HAL_PHYERR_CCK_RATE_ILLEGAL); 903161200Ssam case S_RX_PHY_CCK_SERVICE: PHY(HAL_PHYERR_CCK_SERVICE); 904161200Ssam case S_RX_PHY_CCK_RESTART: PHY(HAL_PHYERR_CCK_RESTART); 905161200Ssam case S_RX_TOOSHORT: STAT(rx_tooshort); 906161200Ssam case S_RX_TOOBIG: STAT(rx_toobig); 907161200Ssam case S_RX_MGT: STAT(rx_mgt); 908161200Ssam case S_RX_CTL: STAT(rx_ctl); 909161200Ssam case S_TX_RSSI: 910174570Ssam snprintf(b, bs, "%d", wf->total.ath.ast_tx_rssi); 911161200Ssam return 1; 912161200Ssam case S_RX_RSSI: 913174570Ssam snprintf(b, bs, "%d", wf->total.ath.ast_rx_rssi); 914161200Ssam return 1; 915161200Ssam case S_BE_XMIT: STAT(be_xmit); 916161200Ssam case S_BE_NOMBUF: STAT(be_nombuf); 917161200Ssam case S_PER_CAL: STAT(per_cal); 918161200Ssam case S_PER_CALFAIL: STAT(per_calfail); 919161200Ssam case S_PER_RFGAIN: STAT(per_rfgain); 920161200Ssam#ifdef S_TDMA_UPDATE 921161200Ssam case S_TDMA_UPDATE: STAT(tdma_update); 922161200Ssam case S_TDMA_TIMERS: STAT(tdma_timers); 923161200Ssam case S_TDMA_TSF: STAT(tdma_tsf); 924186904Ssam case S_TDMA_TSFADJ: 925186904Ssam snprintf(b, bs, "-%d/+%d", 926186904Ssam wf->total.ath.ast_tdma_tsfadjm, 927186904Ssam wf->total.ath.ast_tdma_tsfadjp); 928186904Ssam return 1; 929188196Ssam case S_TDMA_ACK: STAT(tdma_ack); 930161200Ssam#endif 931161200Ssam case S_RATE_CALLS: STAT(rate_calls); 932161200Ssam case S_RATE_RAISE: STAT(rate_raise); 933161200Ssam case S_RATE_DROP: STAT(rate_drop); 934161200Ssam case S_ANT_DEFSWITCH: STAT(ant_defswitch); 935161200Ssam case S_ANT_TXSWITCH: STAT(ant_txswitch); 936184371Ssam#ifdef S_ANI_NOISE 937184371Ssam case S_ANI_NOISE: ANI(noiseImmunityLevel); 938184371Ssam case S_ANI_SPUR: ANI(spurImmunityLevel); 939184371Ssam case S_ANI_STEP: ANI(firstepLevel); 940184453Ssam case S_ANI_OFDM: ANI(ofdmWeakSigDetectOff); 941184453Ssam case S_ANI_CCK: ANI(cckWeakSigThreshold); 942184371Ssam case S_ANI_LISTEN: ANI(listenTime); 943184371Ssam case S_ANI_NIUP: ANISTAT(niup); 944184371Ssam case S_ANI_NIDOWN: ANISTAT(nidown); 945184371Ssam case S_ANI_SIUP: ANISTAT(spurup); 946184371Ssam case S_ANI_SIDOWN: ANISTAT(spurdown); 947184371Ssam case S_ANI_OFDMON: ANISTAT(ofdmon); 948184371Ssam case S_ANI_OFDMOFF: ANISTAT(ofdmoff); 949184371Ssam case S_ANI_CCKHI: ANISTAT(cckhigh); 950184371Ssam case S_ANI_CCKLO: ANISTAT(ccklow); 951184371Ssam case S_ANI_STEPUP: ANISTAT(stepup); 952184371Ssam case S_ANI_STEPDOWN: ANISTAT(stepdown); 953184371Ssam case S_ANI_OFDMERRS: ANISTAT(ofdmerrs); 954184371Ssam case S_ANI_CCKERRS: ANISTAT(cckerrs); 955184371Ssam case S_ANI_RESET: ANISTAT(reset); 956184371Ssam case S_ANI_LZERO: ANISTAT(lzero); 957184371Ssam case S_ANI_LNEG: ANISTAT(lneg); 958184371Ssam case S_MIB_ACKBAD: MIBSTAT(ackrcv_bad); 959184371Ssam case S_MIB_RTSBAD: MIBSTAT(rts_bad); 960184371Ssam case S_MIB_RTSGOOD: MIBSTAT(rts_good); 961184371Ssam case S_MIB_FCSBAD: MIBSTAT(fcs_bad); 962184371Ssam case S_MIB_BEACONS: MIBSTAT(beacons); 963184371Ssam case S_NODE_AVGBRSSI: 964184371Ssam snprintf(b, bs, "%u", 965184371Ssam HAL_RSSI(wf->total.ani_stats.ast_nodestats.ns_avgbrssi)); 966184371Ssam return 1; 967184371Ssam case S_NODE_AVGRSSI: 968184371Ssam snprintf(b, bs, "%u", 969184371Ssam HAL_RSSI(wf->total.ani_stats.ast_nodestats.ns_avgrssi)); 970184371Ssam return 1; 971184371Ssam case S_NODE_AVGARSSI: 972184371Ssam snprintf(b, bs, "%u", 973184371Ssam HAL_RSSI(wf->total.ani_stats.ast_nodestats.ns_avgtxrssi)); 974184371Ssam return 1; 975184371Ssam#endif 976161200Ssam case S_ANT_TX0: TXANT(0); 977161200Ssam case S_ANT_TX1: TXANT(1); 978161200Ssam case S_ANT_TX2: TXANT(2); 979161200Ssam case S_ANT_TX3: TXANT(3); 980161200Ssam case S_ANT_TX4: TXANT(4); 981161200Ssam case S_ANT_TX5: TXANT(5); 982161200Ssam case S_ANT_TX6: TXANT(6); 983161200Ssam case S_ANT_TX7: TXANT(7); 984161200Ssam case S_ANT_RX0: RXANT(0); 985161200Ssam case S_ANT_RX1: RXANT(1); 986161200Ssam case S_ANT_RX2: RXANT(2); 987161200Ssam case S_ANT_RX3: RXANT(3); 988161200Ssam case S_ANT_RX4: RXANT(4); 989161200Ssam case S_ANT_RX5: RXANT(5); 990161200Ssam case S_ANT_RX6: RXANT(6); 991161200Ssam case S_ANT_RX7: RXANT(7); 992161200Ssam#ifdef S_CABQ_XMIT 993161200Ssam case S_CABQ_XMIT: STAT(cabq_xmit); 994161200Ssam case S_CABQ_BUSY: STAT(cabq_busy); 995161200Ssam#endif 996161200Ssam case S_FF_TXOK: STAT(ff_txok); 997161200Ssam case S_FF_TXERR: STAT(ff_txerr); 998174570Ssam case S_FF_RX: STAT(ff_rx); 999161200Ssam case S_FF_FLUSH: STAT(ff_flush); 1000174570Ssam case S_TX_QFULL: STAT(tx_qfull); 1001248668Sadrian case S_BMISSCOUNT: STAT(be_missed); 1002161200Ssam case S_RX_NOISE: 1003174570Ssam snprintf(b, bs, "%d", wf->total.ath.ast_rx_noise); 1004161200Ssam return 1; 1005161200Ssam case S_TX_SIGNAL: 1006161200Ssam snprintf(b, bs, "%d", 1007174570Ssam wf->total.ath.ast_tx_rssi + wf->total.ath.ast_rx_noise); 1008161200Ssam return 1; 1009161200Ssam case S_RX_SIGNAL: 1010161200Ssam snprintf(b, bs, "%d", 1011174570Ssam wf->total.ath.ast_rx_rssi + wf->total.ath.ast_rx_noise); 1012161200Ssam return 1; 1013226799Sadrian case S_RX_AGG: STAT(rx_agg); 1014226799Sadrian case S_RX_HALFGI: STAT(rx_halfgi); 1015226799Sadrian case S_RX_2040: STAT(rx_2040); 1016226799Sadrian case S_RX_PRE_CRC_ERR: STAT(rx_pre_crc_err); 1017226799Sadrian case S_RX_POST_CRC_ERR: STAT(rx_post_crc_err); 1018226799Sadrian case S_RX_DECRYPT_BUSY_ERR: STAT(rx_decrypt_busy_err); 1019226799Sadrian case S_RX_HI_CHAIN: STAT(rx_hi_rx_chain); 1020251398Sadrian case S_RX_STBC: STAT(rx_stbc); 1021226799Sadrian case S_TX_HTPROTECT: STAT(tx_htprotect); 1022226799Sadrian case S_RX_QEND: STAT(rx_hitqueueend); 1023226799Sadrian case S_TX_TIMEOUT: STAT(tx_timeout); 1024226799Sadrian case S_TX_CSTIMEOUT: STAT(tx_cst); 1025226799Sadrian case S_TX_XTXOP_ERR: STAT(tx_xtxop); 1026226799Sadrian case S_TX_TIMEREXPIRED_ERR: STAT(tx_timerexpired); 1027226799Sadrian case S_TX_DESCCFG_ERR: STAT(tx_desccfgerr); 1028226799Sadrian case S_TX_SWRETRIES: STAT(tx_swretries); 1029226799Sadrian case S_TX_SWRETRIES_MAX: STAT(tx_swretrymax); 1030226799Sadrian case S_TX_DATA_UNDERRUN: STAT(tx_data_underrun); 1031226799Sadrian case S_TX_DELIM_UNDERRUN: STAT(tx_delim_underrun); 1032227869Sadrian case S_TX_AGGR_OK: STAT(tx_aggr_ok); 1033227869Sadrian case S_TX_AGGR_FAIL: STAT(tx_aggr_fail); 1034227869Sadrian case S_TX_AGGR_FAILALL: STAT(tx_aggr_failall); 1035153317Ssam } 1036161200Ssam b[0] = '\0'; 1037153317Ssam return 0; 1038161200Ssam#undef RXANT 1039161200Ssam#undef TXANT 1040184371Ssam#undef ANI 1041184371Ssam#undef ANISTAT 1042184371Ssam#undef MIBSTAT 1043161200Ssam#undef PHY 1044161200Ssam#undef STAT 1045153317Ssam} 1046161200Ssam 1047161200Ssamstatic void 1048161200Ssamath_print_verbose(struct statfoo *sf, FILE *fd) 1049161200Ssam{ 1050161200Ssam struct athstatfoo_p *wf = (struct athstatfoo_p *) sf; 1051161200Ssam#define isphyerr(i) (S_PHY_MIN <= i && i <= S_PHY_MAX) 1052174570Ssam const struct fmt *f; 1053161200Ssam char s[32]; 1054161200Ssam const char *indent; 1055174570Ssam int i, width; 1056161200Ssam 1057174570Ssam width = 0; 1058161200Ssam for (i = 0; i < S_LAST; i++) { 1059174570Ssam f = &sf->stats[i]; 1060174570Ssam if (!isphyerr(i) && f->width > width) 1061174570Ssam width = f->width; 1062174570Ssam } 1063174570Ssam for (i = 0; i < S_LAST; i++) { 1064161200Ssam if (ath_get_totstat(sf, i, s, sizeof(s)) && strcmp(s, "0")) { 1065161200Ssam if (isphyerr(i)) 1066161200Ssam indent = " "; 1067161200Ssam else 1068161200Ssam indent = ""; 1069174570Ssam fprintf(fd, "%s%-*s %s\n", indent, width, s, athstats[i].desc); 1070161200Ssam } 1071161200Ssam } 1072161200Ssam fprintf(fd, "Antenna profile:\n"); 1073161200Ssam for (i = 0; i < 8; i++) 1074174570Ssam if (wf->total.ath.ast_ant_rx[i] || wf->total.ath.ast_ant_tx[i]) 1075161200Ssam fprintf(fd, "[%u] tx %8u rx %8u\n", i, 1076174570Ssam wf->total.ath.ast_ant_tx[i], 1077174570Ssam wf->total.ath.ast_ant_rx[i]); 1078161200Ssam#undef isphyerr 1079161200Ssam} 1080161200Ssam 1081161200SsamSTATFOO_DEFINE_BOUNCE(athstatfoo) 1082161200Ssam 1083161200Ssamstruct athstatfoo * 1084161200Ssamathstats_new(const char *ifname, const char *fmtstring) 1085161200Ssam{ 1086161200Ssam#define N(a) (sizeof(a) / sizeof(a[0])) 1087161200Ssam struct athstatfoo_p *wf; 1088161200Ssam 1089161200Ssam wf = calloc(1, sizeof(struct athstatfoo_p)); 1090161200Ssam if (wf != NULL) { 1091161200Ssam statfoo_init(&wf->base.base, "athstats", athstats, N(athstats)); 1092161200Ssam /* override base methods */ 1093161200Ssam wf->base.base.collect_cur = ath_collect_cur; 1094161200Ssam wf->base.base.collect_tot = ath_collect_tot; 1095161200Ssam wf->base.base.get_curstat = ath_get_curstat; 1096161200Ssam wf->base.base.get_totstat = ath_get_totstat; 1097161200Ssam wf->base.base.update_tot = ath_update_tot; 1098161200Ssam wf->base.base.print_verbose = ath_print_verbose; 1099161200Ssam 1100161200Ssam /* setup bounce functions for public methods */ 1101161200Ssam STATFOO_BOUNCE(wf, athstatfoo); 1102161200Ssam 1103161200Ssam /* setup our public methods */ 1104161200Ssam wf->base.setifname = ath_setifname; 1105161200Ssam#if 0 1106161200Ssam wf->base.setstamac = wlan_setstamac; 1107161200Ssam#endif 1108188560Ssam wf->base.zerostats = ath_zerostats; 1109161200Ssam wf->s = socket(AF_INET, SOCK_DGRAM, 0); 1110161200Ssam if (wf->s < 0) 1111161200Ssam err(1, "socket"); 1112161200Ssam 1113161200Ssam ath_setifname(&wf->base, ifname); 1114161200Ssam wf->base.setfmt(&wf->base, fmtstring); 1115161200Ssam } 1116161200Ssam return &wf->base; 1117161200Ssam#undef N 1118161200Ssam} 1119