xref: /freebsd/sys/dev/ath/ah_osdep.c (revision 2ef29b4c336fc0e19274abd74d16e8ce56af7ddd)
13fe92528SSam Leffler /*-
2b032f27cSSam Leffler  * Copyright (c) 2002-2008 Sam Leffler, Errno Consulting
33fe92528SSam Leffler  * All rights reserved.
43fe92528SSam Leffler  *
53fe92528SSam Leffler  * Redistribution and use in source and binary forms, with or without
63fe92528SSam Leffler  * modification, are permitted provided that the following conditions
73fe92528SSam Leffler  * are met:
83fe92528SSam Leffler  * 1. Redistributions of source code must retain the above copyright
93fe92528SSam Leffler  *    notice, this list of conditions and the following disclaimer,
103fe92528SSam Leffler  *    without modification.
113fe92528SSam Leffler  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
123fe92528SSam Leffler  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
133fe92528SSam Leffler  *    redistribution must be conditioned upon including a substantially
143fe92528SSam Leffler  *    similar Disclaimer requirement for further binary redistribution.
153fe92528SSam Leffler  *
163fe92528SSam Leffler  * NO WARRANTY
173fe92528SSam Leffler  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
183fe92528SSam Leffler  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
193fe92528SSam Leffler  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
203fe92528SSam Leffler  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
213fe92528SSam Leffler  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
223fe92528SSam Leffler  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
233fe92528SSam Leffler  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
243fe92528SSam Leffler  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
253fe92528SSam Leffler  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
263fe92528SSam Leffler  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
273fe92528SSam Leffler  * THE POSSIBILITY OF SUCH DAMAGES.
283fe92528SSam Leffler  *
293fe92528SSam Leffler  * $FreeBSD$
303fe92528SSam Leffler  */
313fe92528SSam Leffler #include "opt_ah.h"
323fe92528SSam Leffler 
333fe92528SSam Leffler #include <sys/param.h>
343fe92528SSam Leffler #include <sys/systm.h>
353fe92528SSam Leffler #include <sys/kernel.h>
363fe92528SSam Leffler #include <sys/module.h>
373fe92528SSam Leffler #include <sys/sysctl.h>
383fe92528SSam Leffler #include <sys/bus.h>
393fe92528SSam Leffler #include <sys/malloc.h>
403fe92528SSam Leffler #include <sys/proc.h>
413fe92528SSam Leffler 
423fe92528SSam Leffler #include <machine/stdarg.h>
433fe92528SSam Leffler 
443fe92528SSam Leffler #include <net/ethernet.h>		/* XXX for ether_sprintf */
453fe92528SSam Leffler 
4633644623SSam Leffler #include <dev/ath/ath_hal/ah.h>
473fe92528SSam Leffler 
483fe92528SSam Leffler /*
493fe92528SSam Leffler  * WiSoC boards overload the bus tag with information about the
503fe92528SSam Leffler  * board layout.  We must extract the bus space tag from that
513fe92528SSam Leffler  * indirect structure.  For everyone else the tag is passed in
523fe92528SSam Leffler  * directly.
533fe92528SSam Leffler  * XXX cache indirect ref privately
543fe92528SSam Leffler  */
553fe92528SSam Leffler #ifdef AH_SUPPORT_AR5312
563fe92528SSam Leffler #define	BUSTAG(ah) \
573fe92528SSam Leffler 	((bus_space_tag_t) ((struct ar531x_config *)((ah)->ah_st))->tag)
583fe92528SSam Leffler #else
5933644623SSam Leffler #define	BUSTAG(ah)	((ah)->ah_st)
603fe92528SSam Leffler #endif
613fe92528SSam Leffler 
623fe92528SSam Leffler extern	void ath_hal_printf(struct ath_hal *, const char*, ...)
633fe92528SSam Leffler 		__printflike(2,3);
643fe92528SSam Leffler extern	void ath_hal_vprintf(struct ath_hal *, const char*, __va_list)
653fe92528SSam Leffler 		__printflike(2, 0);
663fe92528SSam Leffler extern	const char* ath_hal_ether_sprintf(const u_int8_t *mac);
673fe92528SSam Leffler extern	void *ath_hal_malloc(size_t);
683fe92528SSam Leffler extern	void ath_hal_free(void *);
693fe92528SSam Leffler #ifdef AH_ASSERT
703fe92528SSam Leffler extern	void ath_hal_assert_failed(const char* filename,
713fe92528SSam Leffler 		int lineno, const char* msg);
723fe92528SSam Leffler #endif
733fe92528SSam Leffler #ifdef AH_DEBUG
74411373ebSSam Leffler extern	void HALDEBUG(struct ath_hal *ah, u_int mask, const char* fmt, ...);
753fe92528SSam Leffler #endif /* AH_DEBUG */
763fe92528SSam Leffler 
773fe92528SSam Leffler /* NB: put this here instead of the driver to avoid circular references */
783fe92528SSam Leffler SYSCTL_NODE(_hw, OID_AUTO, ath, CTLFLAG_RD, 0, "Atheros driver parameters");
793fe92528SSam Leffler SYSCTL_NODE(_hw_ath, OID_AUTO, hal, CTLFLAG_RD, 0, "Atheros HAL parameters");
803fe92528SSam Leffler 
813fe92528SSam Leffler #ifdef AH_DEBUG
823fe92528SSam Leffler static	int ath_hal_debug = 0;
833fe92528SSam Leffler SYSCTL_INT(_hw_ath_hal, OID_AUTO, debug, CTLFLAG_RW, &ath_hal_debug,
843fe92528SSam Leffler 	    0, "Atheros HAL debugging printfs");
853fe92528SSam Leffler TUNABLE_INT("hw.ath.hal.debug", &ath_hal_debug);
863fe92528SSam Leffler #endif /* AH_DEBUG */
873fe92528SSam Leffler 
883fe92528SSam Leffler /* NB: these are deprecated; they exist for now for compatibility */
893fe92528SSam Leffler int	ath_hal_dma_beacon_response_time = 2;	/* in TU's */
903fe92528SSam Leffler SYSCTL_INT(_hw_ath_hal, OID_AUTO, dma_brt, CTLFLAG_RW,
913fe92528SSam Leffler 	   &ath_hal_dma_beacon_response_time, 0,
923fe92528SSam Leffler 	   "Atheros HAL DMA beacon response time");
933fe92528SSam Leffler int	ath_hal_sw_beacon_response_time = 10;	/* in TU's */
943fe92528SSam Leffler SYSCTL_INT(_hw_ath_hal, OID_AUTO, sw_brt, CTLFLAG_RW,
953fe92528SSam Leffler 	   &ath_hal_sw_beacon_response_time, 0,
963fe92528SSam Leffler 	   "Atheros HAL software beacon response time");
973fe92528SSam Leffler int	ath_hal_additional_swba_backoff = 0;	/* in TU's */
983fe92528SSam Leffler SYSCTL_INT(_hw_ath_hal, OID_AUTO, swba_backoff, CTLFLAG_RW,
993fe92528SSam Leffler 	   &ath_hal_additional_swba_backoff, 0,
1003fe92528SSam Leffler 	   "Atheros HAL additional SWBA backoff time");
1013fe92528SSam Leffler 
1023fe92528SSam Leffler MALLOC_DEFINE(M_ATH_HAL, "ath_hal", "ath hal data");
1033fe92528SSam Leffler 
1043fe92528SSam Leffler void*
1053fe92528SSam Leffler ath_hal_malloc(size_t size)
1063fe92528SSam Leffler {
1073fe92528SSam Leffler 	return malloc(size, M_ATH_HAL, M_NOWAIT | M_ZERO);
1083fe92528SSam Leffler }
1093fe92528SSam Leffler 
1103fe92528SSam Leffler void
1113fe92528SSam Leffler ath_hal_free(void* p)
1123fe92528SSam Leffler {
1132ef29b4cSSam Leffler 	free(p, M_ATH_HAL);
1143fe92528SSam Leffler }
1153fe92528SSam Leffler 
1163fe92528SSam Leffler void
1173fe92528SSam Leffler ath_hal_vprintf(struct ath_hal *ah, const char* fmt, va_list ap)
1183fe92528SSam Leffler {
1193fe92528SSam Leffler 	vprintf(fmt, ap);
1203fe92528SSam Leffler }
1213fe92528SSam Leffler 
1223fe92528SSam Leffler void
1233fe92528SSam Leffler ath_hal_printf(struct ath_hal *ah, const char* fmt, ...)
1243fe92528SSam Leffler {
1253fe92528SSam Leffler 	va_list ap;
1263fe92528SSam Leffler 	va_start(ap, fmt);
1273fe92528SSam Leffler 	ath_hal_vprintf(ah, fmt, ap);
1283fe92528SSam Leffler 	va_end(ap);
1293fe92528SSam Leffler }
1303fe92528SSam Leffler 
1313fe92528SSam Leffler const char*
1323fe92528SSam Leffler ath_hal_ether_sprintf(const u_int8_t *mac)
1333fe92528SSam Leffler {
1343fe92528SSam Leffler 	return ether_sprintf(mac);
1353fe92528SSam Leffler }
1363fe92528SSam Leffler 
1373fe92528SSam Leffler #ifdef AH_DEBUG
138411373ebSSam Leffler void
139411373ebSSam Leffler HALDEBUG(struct ath_hal *ah, u_int mask, const char* fmt, ...)
140411373ebSSam Leffler {
141411373ebSSam Leffler 	if (ath_hal_debug & mask) {
142411373ebSSam Leffler 		__va_list ap;
143411373ebSSam Leffler 		va_start(ap, fmt);
144411373ebSSam Leffler 		ath_hal_vprintf(ah, fmt, ap);
145411373ebSSam Leffler 		va_end(ap);
146411373ebSSam Leffler 	}
147411373ebSSam Leffler }
1483fe92528SSam Leffler #endif /* AH_DEBUG */
1493fe92528SSam Leffler 
1503fe92528SSam Leffler #ifdef AH_DEBUG_ALQ
1513fe92528SSam Leffler /*
1523fe92528SSam Leffler  * ALQ register tracing support.
1533fe92528SSam Leffler  *
1543fe92528SSam Leffler  * Setting hw.ath.hal.alq=1 enables tracing of all register reads and
1553fe92528SSam Leffler  * writes to the file /tmp/ath_hal.log.  The file format is a simple
1563fe92528SSam Leffler  * fixed-size array of records.  When done logging set hw.ath.hal.alq=0
1573fe92528SSam Leffler  * and then decode the file with the arcode program (that is part of the
1583fe92528SSam Leffler  * HAL).  If you start+stop tracing the data will be appended to an
1593fe92528SSam Leffler  * existing file.
1603fe92528SSam Leffler  *
1613fe92528SSam Leffler  * NB: doesn't handle multiple devices properly; only one DEVICE record
1623fe92528SSam Leffler  *     is emitted and the different devices are not identified.
1633fe92528SSam Leffler  */
1643fe92528SSam Leffler #include <sys/alq.h>
1653fe92528SSam Leffler #include <sys/pcpu.h>
16633644623SSam Leffler #include <dev/ath/ath_hal/ah_decode.h>
1673fe92528SSam Leffler 
1683fe92528SSam Leffler static	struct alq *ath_hal_alq;
1693fe92528SSam Leffler static	int ath_hal_alq_emitdev;	/* need to emit DEVICE record */
1703fe92528SSam Leffler static	u_int ath_hal_alq_lost;		/* count of lost records */
1713fe92528SSam Leffler static	const char *ath_hal_logfile = "/tmp/ath_hal.log";
1723fe92528SSam Leffler static	u_int ath_hal_alq_qsize = 64*1024;
1733fe92528SSam Leffler 
1743fe92528SSam Leffler static int
1753fe92528SSam Leffler ath_hal_setlogging(int enable)
1763fe92528SSam Leffler {
1773fe92528SSam Leffler 	int error;
1783fe92528SSam Leffler 
1793fe92528SSam Leffler 	if (enable) {
1803fe92528SSam Leffler 		error = alq_open(&ath_hal_alq, ath_hal_logfile,
1813fe92528SSam Leffler 			curthread->td_ucred, ALQ_DEFAULT_CMODE,
1823fe92528SSam Leffler 			sizeof (struct athregrec), ath_hal_alq_qsize);
1833fe92528SSam Leffler 		ath_hal_alq_lost = 0;
1843fe92528SSam Leffler 		ath_hal_alq_emitdev = 1;
1853fe92528SSam Leffler 		printf("ath_hal: logging to %s enabled\n",
1863fe92528SSam Leffler 			ath_hal_logfile);
1873fe92528SSam Leffler 	} else {
1883fe92528SSam Leffler 		if (ath_hal_alq)
1893fe92528SSam Leffler 			alq_close(ath_hal_alq);
1903fe92528SSam Leffler 		ath_hal_alq = NULL;
1913fe92528SSam Leffler 		printf("ath_hal: logging disabled\n");
1923fe92528SSam Leffler 		error = 0;
1933fe92528SSam Leffler 	}
1943fe92528SSam Leffler 	return (error);
1953fe92528SSam Leffler }
1963fe92528SSam Leffler 
1973fe92528SSam Leffler static int
1983fe92528SSam Leffler sysctl_hw_ath_hal_log(SYSCTL_HANDLER_ARGS)
1993fe92528SSam Leffler {
2003fe92528SSam Leffler 	int error, enable;
2013fe92528SSam Leffler 
2023fe92528SSam Leffler 	enable = (ath_hal_alq != NULL);
2033fe92528SSam Leffler         error = sysctl_handle_int(oidp, &enable, 0, req);
2043fe92528SSam Leffler         if (error || !req->newptr)
2053fe92528SSam Leffler                 return (error);
2063fe92528SSam Leffler 	else
2073fe92528SSam Leffler 		return (ath_hal_setlogging(enable));
2083fe92528SSam Leffler }
2093fe92528SSam Leffler SYSCTL_PROC(_hw_ath_hal, OID_AUTO, alq, CTLTYPE_INT|CTLFLAG_RW,
2103fe92528SSam Leffler 	0, 0, sysctl_hw_ath_hal_log, "I", "Enable HAL register logging");
2113fe92528SSam Leffler SYSCTL_INT(_hw_ath_hal, OID_AUTO, alq_size, CTLFLAG_RW,
2123fe92528SSam Leffler 	&ath_hal_alq_qsize, 0, "In-memory log size (#records)");
2133fe92528SSam Leffler SYSCTL_INT(_hw_ath_hal, OID_AUTO, alq_lost, CTLFLAG_RW,
2143fe92528SSam Leffler 	&ath_hal_alq_lost, 0, "Register operations not logged");
2153fe92528SSam Leffler 
2163fe92528SSam Leffler static struct ale *
2173fe92528SSam Leffler ath_hal_alq_get(struct ath_hal *ah)
2183fe92528SSam Leffler {
2193fe92528SSam Leffler 	struct ale *ale;
2203fe92528SSam Leffler 
2213fe92528SSam Leffler 	if (ath_hal_alq_emitdev) {
2223fe92528SSam Leffler 		ale = alq_get(ath_hal_alq, ALQ_NOWAIT);
2233fe92528SSam Leffler 		if (ale) {
2243fe92528SSam Leffler 			struct athregrec *r =
2253fe92528SSam Leffler 				(struct athregrec *) ale->ae_data;
2263fe92528SSam Leffler 			r->op = OP_DEVICE;
2273fe92528SSam Leffler 			r->reg = 0;
2283fe92528SSam Leffler 			r->val = ah->ah_devid;
2293fe92528SSam Leffler 			alq_post(ath_hal_alq, ale);
2303fe92528SSam Leffler 			ath_hal_alq_emitdev = 0;
2313fe92528SSam Leffler 		} else
2323fe92528SSam Leffler 			ath_hal_alq_lost++;
2333fe92528SSam Leffler 	}
2343fe92528SSam Leffler 	ale = alq_get(ath_hal_alq, ALQ_NOWAIT);
2353fe92528SSam Leffler 	if (!ale)
2363fe92528SSam Leffler 		ath_hal_alq_lost++;
2373fe92528SSam Leffler 	return ale;
2383fe92528SSam Leffler }
2393fe92528SSam Leffler 
2403fe92528SSam Leffler void
2413fe92528SSam Leffler ath_hal_reg_write(struct ath_hal *ah, u_int32_t reg, u_int32_t val)
2423fe92528SSam Leffler {
2433fe92528SSam Leffler 	bus_space_tag_t tag = BUSTAG(ah);
24433644623SSam Leffler 	bus_space_handle_t h = ah->ah_sh;
2453fe92528SSam Leffler 
2463fe92528SSam Leffler 	if (ath_hal_alq) {
2473fe92528SSam Leffler 		struct ale *ale = ath_hal_alq_get(ah);
2483fe92528SSam Leffler 		if (ale) {
2493fe92528SSam Leffler 			struct athregrec *r = (struct athregrec *) ale->ae_data;
2503fe92528SSam Leffler 			r->op = OP_WRITE;
2513fe92528SSam Leffler 			r->reg = reg;
2523fe92528SSam Leffler 			r->val = val;
2533fe92528SSam Leffler 			alq_post(ath_hal_alq, ale);
2543fe92528SSam Leffler 		}
2553fe92528SSam Leffler 	}
2563fe92528SSam Leffler #if _BYTE_ORDER == _BIG_ENDIAN
25769ad6b34SSam Leffler 	if (OS_REG_UNSWAPPED(reg))
2583fe92528SSam Leffler 		bus_space_write_4(tag, h, reg, val);
2593fe92528SSam Leffler 	else
2603fe92528SSam Leffler #endif
2613fe92528SSam Leffler 		bus_space_write_stream_4(tag, h, reg, val);
2623fe92528SSam Leffler }
2633fe92528SSam Leffler 
2643fe92528SSam Leffler u_int32_t
2653fe92528SSam Leffler ath_hal_reg_read(struct ath_hal *ah, u_int32_t reg)
2663fe92528SSam Leffler {
2673fe92528SSam Leffler 	bus_space_tag_t tag = BUSTAG(ah);
26833644623SSam Leffler 	bus_space_handle_t h = ah->ah_sh;
2693fe92528SSam Leffler 	u_int32_t val;
2703fe92528SSam Leffler 
2713fe92528SSam Leffler #if _BYTE_ORDER == _BIG_ENDIAN
27269ad6b34SSam Leffler 	if (OS_REG_UNSWAPPED(reg))
2733fe92528SSam Leffler 		val = bus_space_read_4(tag, h, reg);
2743fe92528SSam Leffler 	else
2753fe92528SSam Leffler #endif
2763fe92528SSam Leffler 		val = bus_space_read_stream_4(tag, h, reg);
2773fe92528SSam Leffler 	if (ath_hal_alq) {
2783fe92528SSam Leffler 		struct ale *ale = ath_hal_alq_get(ah);
2793fe92528SSam Leffler 		if (ale) {
2803fe92528SSam Leffler 			struct athregrec *r = (struct athregrec *) ale->ae_data;
2813fe92528SSam Leffler 			r->op = OP_READ;
2823fe92528SSam Leffler 			r->reg = reg;
2833fe92528SSam Leffler 			r->val = val;
2843fe92528SSam Leffler 			alq_post(ath_hal_alq, ale);
2853fe92528SSam Leffler 		}
2863fe92528SSam Leffler 	}
2873fe92528SSam Leffler 	return val;
2883fe92528SSam Leffler }
2893fe92528SSam Leffler 
2903fe92528SSam Leffler void
2913fe92528SSam Leffler OS_MARK(struct ath_hal *ah, u_int id, u_int32_t v)
2923fe92528SSam Leffler {
2933fe92528SSam Leffler 	if (ath_hal_alq) {
2943fe92528SSam Leffler 		struct ale *ale = ath_hal_alq_get(ah);
2953fe92528SSam Leffler 		if (ale) {
2963fe92528SSam Leffler 			struct athregrec *r = (struct athregrec *) ale->ae_data;
2973fe92528SSam Leffler 			r->op = OP_MARK;
2983fe92528SSam Leffler 			r->reg = id;
2993fe92528SSam Leffler 			r->val = v;
3003fe92528SSam Leffler 			alq_post(ath_hal_alq, ale);
3013fe92528SSam Leffler 		}
3023fe92528SSam Leffler 	}
3033fe92528SSam Leffler }
3043fe92528SSam Leffler #elif defined(AH_DEBUG) || defined(AH_REGOPS_FUNC)
3053fe92528SSam Leffler /*
3063fe92528SSam Leffler  * Memory-mapped device register read/write.  These are here
3073fe92528SSam Leffler  * as routines when debugging support is enabled and/or when
3083fe92528SSam Leffler  * explicitly configured to use function calls.  The latter is
3093fe92528SSam Leffler  * for architectures that might need to do something before
3103fe92528SSam Leffler  * referencing memory (e.g. remap an i/o window).
3113fe92528SSam Leffler  *
3123fe92528SSam Leffler  * NB: see the comments in ah_osdep.h about byte-swapping register
3133fe92528SSam Leffler  *     reads and writes to understand what's going on below.
3143fe92528SSam Leffler  */
3153fe92528SSam Leffler 
3163fe92528SSam Leffler void
3173fe92528SSam Leffler ath_hal_reg_write(struct ath_hal *ah, u_int32_t reg, u_int32_t val)
3183fe92528SSam Leffler {
3193fe92528SSam Leffler 	bus_space_tag_t tag = BUSTAG(ah);
32033644623SSam Leffler 	bus_space_handle_t h = ah->ah_sh;
3213fe92528SSam Leffler 
3223fe92528SSam Leffler #if _BYTE_ORDER == _BIG_ENDIAN
32369ad6b34SSam Leffler 	if (OS_REG_UNSWAPPED(reg))
3243fe92528SSam Leffler 		bus_space_write_4(tag, h, reg, val);
3253fe92528SSam Leffler 	else
3263fe92528SSam Leffler #endif
3273fe92528SSam Leffler 		bus_space_write_stream_4(tag, h, reg, val);
3283fe92528SSam Leffler }
3293fe92528SSam Leffler 
3303fe92528SSam Leffler u_int32_t
3313fe92528SSam Leffler ath_hal_reg_read(struct ath_hal *ah, u_int32_t reg)
3323fe92528SSam Leffler {
3333fe92528SSam Leffler 	bus_space_tag_t tag = BUSTAG(ah);
33433644623SSam Leffler 	bus_space_handle_t h = ah->ah_sh;
3353fe92528SSam Leffler 	u_int32_t val;
3363fe92528SSam Leffler 
3373fe92528SSam Leffler #if _BYTE_ORDER == _BIG_ENDIAN
33869ad6b34SSam Leffler 	if (OS_REG_UNSWAPPED(reg))
3393fe92528SSam Leffler 		val = bus_space_read_4(tag, h, reg);
3403fe92528SSam Leffler 	else
3413fe92528SSam Leffler #endif
3423fe92528SSam Leffler 		val = bus_space_read_stream_4(tag, h, reg);
3433fe92528SSam Leffler 	return val;
3443fe92528SSam Leffler }
3453fe92528SSam Leffler #endif /* AH_DEBUG || AH_REGOPS_FUNC */
3463fe92528SSam Leffler 
3473fe92528SSam Leffler #ifdef AH_ASSERT
3483fe92528SSam Leffler void
3493fe92528SSam Leffler ath_hal_assert_failed(const char* filename, int lineno, const char *msg)
3503fe92528SSam Leffler {
3513fe92528SSam Leffler 	printf("Atheros HAL assertion failure: %s: line %u: %s\n",
3523fe92528SSam Leffler 		filename, lineno, msg);
3533fe92528SSam Leffler 	panic("ath_hal_assert");
3543fe92528SSam Leffler }
3553fe92528SSam Leffler #endif /* AH_ASSERT */
356