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