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