Ticket #1337: madwifi-0.9.3-ath-halops.3.diff

madwifi/ath_hal/ath_hal_api.c

@@ +1 @@
+/*
+ * Wrapper macros/functions for the binary HAL to comply with local coding convention.
+ * 
+ * Provides function-style calling convention using either macros or wrapper functions for function pointers in the HAL.
+ * 
+ * The typical convention is foo(hal,p1,p2,p3,...) turns into hal->foo(p1,p2,p3,...) where foo 
+ * is a function pointer and a member of the struct ath_hal.
+ *
+ * The macros are faster, but the functions have the advantage that they show up unobfuscated in backtraces thus giving you a clue as to where in 
+ * your code you went wrong in your use of the HAL.
+ *
+ */
+#include "opt_ah.h"
+
+#ifdef AH_HALOPS_FUNC
+
+#ifndef AUTOCONF_INCLUDED
+#include <linux/config.h>
+#endif
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/skbuff.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/random.h>
+#include <linux/delay.h>
+#include <linux/cache.h>
+#include <linux/sysctl.h>
+#include <linux/proc_fs.h>
+#include <linux/if_arp.h>
+#include <linux/rtnetlink.h>
+#include <asm/uaccess.h>
+
+#include "ath_hal_api.h"
+
+/*
+ * HAL definitions to comply with local coding convention.
+ */
+HAL_BOOL ath_hal_reset(struct ath_hal* ah, HAL_OPMODE opmode, HAL_CHANNEL* chan,  HAL_BOOL outdoor, HAL_STATUS* pstatus)
+{ 
+    return ((*ah->ah_reset)(ah, (opmode), (chan), (outdoor), (pstatus))); 
+}
+const HAL_RATE_TABLE* ath_hal_getratetable(struct ath_hal* ah, u_int mode) {
+    return ((*ah->ah_getRateTable)(ah, (mode)));
+}
+void ath_hal_getmac(struct ath_hal* ah, u_int8_t* mac) {
+    (*ah->ah_getMacAddress)(ah, (mac));
+}
+HAL_BOOL ath_hal_setmac(struct ath_hal* ah, const u_int8_t* mac) {
+    return ((*ah->ah_setMacAddress)(ah, (mac)));
+}
+void ath_hal_getbssidmask(struct ath_hal * ah, u_int8_t * mask) {
+    (*ah->ah_getBssIdMask)(ah, (mask));
+}
+HAL_BOOL ath_hal_setbssidmask(struct ath_hal * ah, const u_int8_t* mask) {
+    return ((*ah->ah_setBssIdMask)(ah, (mask)));
+}
+HAL_INT ath_hal_intrset(struct ath_hal* ah, HAL_INT mask) {
+    return ((*ah->ah_setInterrupts)(ah, (mask)));
+}
+HAL_INT ath_hal_intrget(struct ath_hal* ah) {
+    return ((*ah->ah_getInterrupts)(ah));
+}
+HAL_BOOL ath_hal_intrpend(struct ath_hal* ah) {
+    return ((*ah->ah_isInterruptPending)(ah));
+}
+HAL_BOOL ath_hal_getisr(struct ath_hal* ah, HAL_INT* pmask) {
+    return ((*ah->ah_getPendingInterrupts)(ah, (pmask)));
+}
+HAL_BOOL ath_hal_updatetxtriglevel(struct ath_hal* ah, HAL_BOOL inc) {
+    return ((*ah->ah_updateTxTrigLevel)(ah, (inc)));
+}
+HAL_BOOL ath_hal_setpower(struct ath_hal* ah, HAL_POWER_MODE mode) {
+        return ((*ah->ah_setPowerMode)(ah, (mode), AH_TRUE));
+}
+u_int32_t ath_hal_keycachesize(struct ath_hal* ah) {
+    return ((*ah->ah_getKeyCacheSize)(ah));
+}
+HAL_BOOL ath_hal_keyreset(struct ath_hal* ah, u_int16_t ix) {
+    return ((*ah->ah_resetKeyCacheEntry)(ah, (ix)));
+}
+HAL_BOOL ath_hal_keyset(struct ath_hal* ah, u_int16_t ix, const HAL_KEYVAL * pk, const u_int8_t * mac) {
+    return ((*ah->ah_setKeyCacheEntry)(ah, (ix), (pk), (mac), AH_FALSE));
+}
+HAL_BOOL ath_hal_keyisvalid(struct ath_hal *ah, u_int16_t ix) {
+    return (((*ah->ah_isKeyCacheEntryValid)(ah, (ix))));
+}
+HAL_BOOL ath_hal_keysetmac(struct ath_hal* ah, u_int16_t ix, const u_int8_t *mac) {
+    return ((*ah->ah_setKeyCacheEntryMac)(ah, (ix), (mac)));
+}
+u_int32_t ath_hal_getrxfilter(struct ath_hal* ah) {
+    return ((*ah->ah_getRxFilter)(ah));
+}
+void ath_hal_setrxfilter(struct ath_hal* ah, u_int32_t filter) {
+    (*ah->ah_setRxFilter)(ah, (filter));
+}
+void ath_hal_setmcastfilter(struct ath_hal* ah, u_int32_t mfilt0, u_int32_t mfilt1) {
+    ((*ah->ah_setMulticastFilter)(ah, (mfilt0), (mfilt1)));
+}
+void ath_hal_putrxbuf(struct ath_hal* ah, u_int32_t bufaddr) {
+    ((*ah->ah_setRxDP)(ah, (bufaddr)));
+}
+u_int32_t ath_hal_gettsf32(struct ath_hal* ah) {
+        return ((*ah->ah_getTsf32)(ah));
+}
+u_int64_t ath_hal_gettsf64(struct ath_hal* ah) {
+    return ((*ah->ah_getTsf64)(ah));
+}
+void ath_hal_resettsf(struct ath_hal* ah) {
+    ((*ah->ah_resetTsf)(ah));
+}
+void ath_hal_rxena(struct ath_hal* ah) {
+    ((*ah->ah_enableReceive)(ah));
+}
+
+u_int32_t ath_hal_numtxpending(struct ath_hal *ah, u_int q) {
+    return ((*ah->ah_numTxPending)(ah, (q)));
+}
+
+HAL_BOOL ath_hal_puttxbuf(struct ath_hal* ah, u_int q, u_int32_t bufaddr) {
+    return ((*ah->ah_setTxDP)(ah, (q), (bufaddr)));
+}
+
+u_int32_t ath_hal_gettxbuf(struct ath_hal* ah, u_int q) {
+    return ((*ah->ah_getTxDP)(ah, (q)));
+}
+
+u_int32_t ath_hal_getrxbuf(struct ath_hal* ah) {
+    return ((*ah->ah_getRxDP)(ah));
+}
+
+HAL_BOOL ath_hal_txstart(struct ath_hal* ah, u_int q) {
+    return ((*ah->ah_startTxDma)(ah, (q)));
+}
+
+HAL_BOOL ath_hal_calibrate(struct ath_hal* ah, HAL_CHANNEL * chan, HAL_BOOL * isIQdone) {
+    return ((*ah->ah_perCalibration)(ah, (chan), (isIQdone)));
+}
+
+void ath_hal_setledstate(struct ath_hal* ah, HAL_LED_STATE state) {
+    return ((*ah->ah_setLedState)(ah, (state)));
+}
+void ath_hal_beaconinit(struct ath_hal * ah, u_int32_t nextb, u_int32_t bperiod) {
+    ((*ah->ah_beaconInit)(ah, (nextb), (bperiod)));
+}
+void ath_hal_beaconreset(struct ath_hal* ah) {
+    ((*ah->ah_resetStationBeaconTimers)(ah));
+}
+void ath_hal_beacontimers(struct ath_hal* ah, const HAL_BEACON_STATE *bs) {
+    ((*ah->ah_setStationBeaconTimers)(ah, (bs)));
+}
+
+void ath_hal_setassocid(struct ath_hal* ah, const u_int8_t *bss, u_int16_t associd) {
+    ((*ah->ah_writeAssocid)(ah, (bss), (associd)));
+}
+
+HAL_BOOL ath_hal_phydisable(struct ath_hal * ah) {
+    return ((*ah->ah_phyDisable)(ah));
+}
+
+void ath_hal_setopmode(struct ath_hal * ah) {
+    ((*ah->ah_setPCUConfig)(ah));
+}
+
+HAL_BOOL ath_hal_stoptxdma(struct ath_hal* ah, u_int q) {
+    return ((*ah->ah_stopTxDma)(ah, q));
+}
+
+void ath_hal_stoppcurecv(struct ath_hal* ah) {
+    ((*ah->ah_stopPcuReceive)(ah));
+}
+
+void ath_hal_startpcurecv(struct ath_hal* ah) {
+    ((*ah->ah_startPcuReceive)(ah));
+}
+
+HAL_BOOL ath_hal_stopdmarecv(struct ath_hal* ah) {
+    return ((*ah->ah_stopDmaReceive)(ah));
+}
+
+HAL_BOOL ath_hal_getdiagstate(struct ath_hal *ah, int id, const void *indata, u_int32_t insize, void** outdata, u_int32_t* outsize) {
+    return ((*ah->ah_getDiagState)(ah, (id), (indata), (insize), (outdata), (outsize)));
+}
+
+HAL_BOOL ath_hal_gettxqueueprops(struct ath_hal * ah, int q, HAL_TXQ_INFO *qi) {
+    return ((*ah->ah_getTxQueueProps)(ah, (q), (qi)));
+}
+
+HAL_BOOL ath_hal_settxqueueprops(struct ath_hal *ah, int q, const HAL_TXQ_INFO *qi) {
+    return ((*ah->ah_setTxQueueProps)(ah, (q), (qi)));
+}
+int     ath_hal_setuptxqueue(struct ath_hal * ah, HAL_TX_QUEUE type, const HAL_TXQ_INFO * qi) {
+    return (*ah->ah_setupTxQueue)(ah, type, qi);
+}
+
+HAL_BOOL ath_hal_resettxqueue(struct ath_hal *ah, u_int q) {
+    return ((*ah->ah_resetTxQueue)(ah, (q)));
+}
+HAL_BOOL ath_hal_releasetxqueue(struct ath_hal *ah, u_int q) {
+    return ((*ah->ah_releaseTxQueue)(ah, (q)));
+}
+HAL_RFGAIN ath_hal_getrfgain(struct ath_hal* ah) {
+    return ((*ah->ah_getRfGain)(ah));
+}
+u_int ath_hal_getdefantenna(struct ath_hal* ah) {
+    return ((*ah->ah_getDefAntenna)(ah));
+}
+void ath_hal_setdefantenna(struct ath_hal* ah, u_int ant) {
+    (*ah->ah_setDefAntenna)(ah, (ant));
+}
+
+void ath_hal_rxmonitor(struct ath_hal* ah, const HAL_NODE_STATS *stats, HAL_CHANNEL *chan) {
+    (*ah->ah_rxMonitor)(ah, stats, chan);
+}
+void ath_hal_mibevent(struct ath_hal * ah, const HAL_NODE_STATS *stats) {
+    ((*ah->ah_procMibEvent)(ah, (stats)));
+}
+HAL_BOOL ath_hal_setslottime(struct ath_hal* ah, u_int us) {
+    return ((*ah->ah_setSlotTime)(ah, (us)));
+}
+u_int ath_hal_getslottime(struct ath_hal* ah) {
+    return ((*ah->ah_getSlotTime)(ah));
+}
+
+HAL_BOOL ath_hal_setacktimeout(struct ath_hal* ah, u_int us) {
+    return ((*ah->ah_setAckTimeout)(ah, (us)));
+}
+
+u_int ath_hal_getacktimeout(struct ath_hal* ah) {
+    return ((*ah->ah_getAckTimeout)(ah));
+}
+
+HAL_BOOL ath_hal_setctstimeout(struct ath_hal* ah, u_int us) {
+    return ((*ah->ah_setCTSTimeout)(ah, (us)));
+}
+
+u_int ath_hal_getctstimeout(struct ath_hal* ah) {
+    return ((*ah->ah_getCTSTimeout)(ah));
+}
+
+HAL_BOOL ath_hal_setdecompmask(struct ath_hal* ah, u_int16_t keyid, int b) {
+    return ((*ah->ah_setDecompMask)(ah, (keyid), (b)));
+}
+
+HAL_STATUS ath_hal_getcapability(struct ath_hal * ah, HAL_CAPABILITY_TYPE type, u_int32_t capability, u_int32_t *result) {
+    return ((*ah->ah_getCapability)(ah, (type), (capability), (result)));
+}
+
+HAL_BOOL ath_hal_setcapability(struct ath_hal * ah, HAL_CAPABILITY_TYPE type, u_int32_t capability, u_int32_t setting, HAL_STATUS *status) {
+    return ((*ah->ah_setCapability)(ah, (type), (capability), (setting), (status)));
+}
+
+HAL_BOOL ath_hal_ciphersupported(struct ath_hal * ah, u_int32_t cipher) {
+    return (ath_hal_getcapability(ah, HAL_CAP_CIPHER, cipher, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_fastframesupported(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_FASTFRAME, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_burstsupported(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_BURST, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_xrsupported(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_XR, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_compressionsupported(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_COMPRESSION, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_turboagsupported(struct ath_hal * ah, int countrycode) {
+    return (ath_hal_getwirelessmodes(ah, countrycode) & (HAL_MODE_108G|HAL_MODE_TURBO));
+}
+
+HAL_BOOL ath_hal_halfrate_chansupported(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_CHAN_HALFRATE, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_quarterrate_chansupported(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_CHAN_QUARTERRATE, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_getregdomain(struct ath_hal * ah, u_int32_t* destination) {
+    return ath_hal_getcapability(ah, HAL_CAP_REG_DMN, 0, destination);
+}
+        
+HAL_BOOL ath_hal_getcountrycode(struct ath_hal * ah, u_int32_t* destination) {
+    (*(destination) = ah->ah_countryCode);
+    return AH_TRUE;
+}
+
+HAL_BOOL ath_hal_hastkipsplit(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TKIP_SPLIT, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_gettkipsplit(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TKIP_SPLIT, 1, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_settkipsplit(struct ath_hal * ah, int v) {
+    return ath_hal_setcapability(ah, HAL_CAP_TKIP_SPLIT, 1, v, NULL);
+}
+
+HAL_BOOL ath_hal_wmetkipmic(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_WME_TKIPMIC, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_hwphycounters(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_PHYCOUNTERS, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_hasdiversity(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_DIVERSITY, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_getdiversity(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_DIVERSITY, 1, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_setdiversity(struct ath_hal * ah, int v) {
+    return ath_hal_setcapability(ah, HAL_CAP_DIVERSITY, 1, v, NULL);
+}
+
+HAL_BOOL ath_hal_getnumtxqueues(struct ath_hal * ah, u_int32_t* destination) {
+    return (ath_hal_getcapability(ah, HAL_CAP_NUM_TXQUEUES, 0, destination) == HAL_OK);
+}
+        
+HAL_BOOL ath_hal_hasveol(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_VEOL, 0, NULL) == HAL_OK);
+}
+        
+HAL_BOOL ath_hal_hastxpowlimit(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TXPOW, 0, NULL) == HAL_OK);
+}
+        
+HAL_BOOL ath_hal_settxpowlimit(struct ath_hal * ah, u_int32_t power) {
+    return ((*ah->ah_setTxPowerLimit)(ah, power));
+}
+
+HAL_BOOL ath_hal_gettxpowlimit(struct ath_hal * ah, u_int32_t* destination) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TXPOW, 1, destination) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_getmaxtxpow(struct ath_hal * ah, u_int32_t* destination) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TXPOW, 2, destination) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_gettpscale(struct ath_hal * ah, u_int32_t* destination) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TXPOW, 3, destination) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_settpscale(struct ath_hal * ah, u_int32_t v) {
+    return ath_hal_setcapability(ah, HAL_CAP_TXPOW, 3, v, NULL);
+}
+
+HAL_BOOL ath_hal_hastpc(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TPC, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_gettpc(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TPC, 1, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_settpc(struct ath_hal * ah, u_int32_t v) {
+    return ath_hal_setcapability(ah, HAL_CAP_TPC, 1, v, NULL);
+}
+
+HAL_BOOL ath_hal_hasbursting(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_BURST, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_hascompression(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_COMPRESSION, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_hasfastframes(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_FASTFRAME, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_hasbssidmask(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_BSSIDMASK, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_hasmcastkeysearch(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_MCAST_KEYSRCH, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_getmcastkeysearch(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_MCAST_KEYSRCH, 1, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_hastkipmic(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TKIP_MIC, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_gettkipmic(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TKIP_MIC, 1, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_settkipmic(struct ath_hal * ah, u_int32_t v) {
+    return ath_hal_setcapability(ah, HAL_CAP_TKIP_MIC, 1, v, NULL);
+}
+
+HAL_BOOL ath_hal_hastsfadjust(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TSF_ADJUST, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_gettsfadjust(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_TSF_ADJUST, 1, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_settsfadjust(struct ath_hal * ah, u_int32_t v) {
+    return ath_hal_setcapability(ah, HAL_CAP_TSF_ADJUST, 1, v, NULL);
+}
+
+HAL_BOOL ath_hal_setrfsilent(struct ath_hal * ah, u_int32_t v) {
+        return ath_hal_setcapability(ah, HAL_CAP_RFSILENT, 1, v, NULL);
+}
+
+HAL_BOOL ath_hal_hasrfsilent(struct ath_hal * ah) {
+    return (ath_hal_getcapability(ah, HAL_CAP_RFSILENT, 0, NULL) == HAL_OK);
+}
+
+HAL_BOOL ath_hal_setuprxdesc(struct ath_hal *ah, struct ath_desc *ds, u_int32_t size, u_int flags) {
+    return ((*ah->ah_setupRxDesc)(ah, (ds), (size), flags));
+}
+
+HAL_BOOL ath_hal_rxprocdesc(struct ath_hal *ah, struct ath_desc *ds, u_int32_t dspa, struct ath_desc *dsnext, u_int64_t tsf, struct ath_rx_status *rs) {
+    return ((*ah->ah_procRxDesc)(ah, (ds), (dspa), (dsnext), (tsf), (rs)));
+}
+
+HAL_BOOL ath_hal_setuptxdesc(struct ath_hal *ah, struct ath_desc *ds, u_int plen, u_int hlen, HAL_PKT_TYPE atype, u_int txpow, u_int txr0, u_int txtr0, u_int keyix, u_int ant, u_int flags, u_int rtsrate, u_int rtsdura, u_int compicvlen, u_int compivlen, u_int comp) {
+    return ((*ah->ah_setupTxDesc)(ah, (ds), (plen), (hlen), (atype), (txpow), (txr0), (txtr0), (keyix), (ant), (flags), (rtsrate), (rtsdura), (compicvlen), (compivlen), (comp)));
+}
+HAL_BOOL ath_hal_setupxtxdesc(struct ath_hal * ah, struct ath_desc* ds, u_int txr1, u_int txtr1, u_int txr2, u_int txtr2, u_int txr3, u_int txtr3) {
+    return ((*ah->ah_setupXTxDesc)(ah, (ds), (txr1), (txtr1), (txr2), (txtr2), (txr3), (txtr3)));
+}
+HAL_BOOL ath_hal_filltxdesc(struct ath_hal * ah, struct ath_desc * ds, u_int l, HAL_BOOL first, HAL_BOOL last, const struct ath_desc * ds0) {
+    return ((*ah->ah_fillTxDesc)(ah, (ds), (l), (first), (last), (ds0)));
+}
+HAL_BOOL ath_hal_txprocdesc(struct ath_hal * ah, struct ath_desc *ds, struct ath_tx_status *ts) {
+    return ((*ah->ah_procTxDesc)(ah, (ds), (ts)));
+}
+void ath_hal_gettxintrtxqs(struct ath_hal *ah, u_int32_t *txqs) {
+    ((*ah->ah_getTxIntrQueue)(ah, (txqs)));
+}
+void ath_hal_txreqintrdesc(struct ath_hal * ah, struct ath_desc *ds) {
+    ((*ah->ah_reqTxIntrDesc)(ah, (ds)));
+}
+HAL_BOOL ath_hal_gpioCfgOutput(struct ath_hal * ah, u_int32_t gpio) {
+    return ((*ah->ah_gpioCfgOutput)(ah, (gpio)));
+}
+HAL_BOOL ath_hal_gpioset(struct ath_hal * ah, u_int32_t gpio, u_int32_t val) {
+    return ((*ah->ah_gpioSet)(ah, (gpio), val));
+}
+void ath_hal_setcoverageclass(struct ath_hal * ah, u_int8_t coverageclass, int now) {
+    ((*ah->ah_setCoverageClass)(ah, (coverageclass), (now)));
+}
+HAL_BOOL ath_hal_radar_wait(struct ath_hal * ah, HAL_CHANNEL *chan) {
+    return ((*ah->ah_radarWait)(ah, (chan)));
+}
+int16_t ath_hal_get_channel_noise(struct ath_hal * ah, HAL_CHANNEL *chan) {
+    return ((*ah->ah_getChanNoise)(ah, (chan)));
+}
+
+HAL_BOOL ath_hal_set_regulatory_domain(struct ath_hal* ah, u_int16_t domain, HAL_STATUS* pstatus) {
+    return ((*ah->ah_setRegulatoryDomain)(ah, domain, pstatus));
+   
+}
+
+HAL_POWER_MODE ath_hal_getpower(struct ath_hal* ah) {
+    return ((*ah->ah_getPowerMode)(ah));
+}
+
+HAL_BOOL ath_hal_set_multicast_filter_index(struct ath_hal* ah, u_int32_t index) {
+    return ((*ah->ah_setMulticastFilterIndex)(ah,index));
+}
+
+HAL_BOOL ath_hal_clear_multicast_filter_index(struct ath_hal* ah, u_int32_t index) {
+    return ((*ah->ah_clrMulticastFilterIndex)(ah,index));
+}
+
+HAL_BOOL ath_hal_gpioGet(struct ath_hal *ah, u_int32_t gpio) {
+    return ((*ah->ah_gpioGet)(ah,gpio));
+}
+HAL_BOOL ath_hal_gpioCfgInput(struct ath_hal *ah, u_int32_t gpio) {
+    return ((*ah->ah_gpioCfgInput)(ah,gpio));
+}
+void ath_hal_gpioSetIntr(struct ath_hal *ah, u_int p1, u_int32_t p2) {
+    ((*ah->ah_gpioSetIntr)(ah,p1,p2));
+}
+
+HAL_BOOL ath_hal_detect_card_present(struct ath_hal* ah) {
+    return ((*ah->ah_detectCardPresent)(ah));
+}
+
+void ath_hal_update_mib_counters(struct ath_hal* ah, HAL_MIB_STATS* stats) {
+    ((*ah->ah_updateMibCounters)(ah, stats));
+}
+HAL_ANT_SETTING ath_hal_get_antenna_switch(struct ath_hal* ah) {
+     return ((*ah->ah_getAntennaSwitch)(ah));
+}
+
+HAL_BOOL ath_hal_set_antenna_switch(struct ath_hal* ah, HAL_ANT_SETTING ant) {
+     return ((*ah->ah_setAntennaSwitch)(ah, ant));
+}
+
+void ath_hal_set_beacon_timers(struct ath_hal* ah, const HAL_BEACON_TIMERS *timers) {
+     ((*ah->ah_setBeaconTimers)(ah, timers));
+}
+EXPORT_SYMBOL(ath_hal_reset);
+EXPORT_SYMBOL(ath_hal_getratetable);
+EXPORT_SYMBOL(ath_hal_getmac);
+EXPORT_SYMBOL(ath_hal_setmac);
+EXPORT_SYMBOL(ath_hal_getbssidmask);
+EXPORT_SYMBOL(ath_hal_setbssidmask);
+EXPORT_SYMBOL(ath_hal_intrset);
+EXPORT_SYMBOL(ath_hal_intrget);
+EXPORT_SYMBOL(ath_hal_intrpend);
+EXPORT_SYMBOL(ath_hal_getisr);
+EXPORT_SYMBOL(ath_hal_updatetxtriglevel);
+EXPORT_SYMBOL(ath_hal_setpower);
+EXPORT_SYMBOL(ath_hal_keycachesize);
+EXPORT_SYMBOL(ath_hal_keyreset);
+EXPORT_SYMBOL(ath_hal_keyset);
+EXPORT_SYMBOL(ath_hal_keyisvalid);
+EXPORT_SYMBOL(ath_hal_keysetmac);
+EXPORT_SYMBOL(ath_hal_getrxfilter);
+EXPORT_SYMBOL(ath_hal_setrxfilter);
+EXPORT_SYMBOL(ath_hal_setmcastfilter);
+EXPORT_SYMBOL(ath_hal_putrxbuf);
+EXPORT_SYMBOL(ath_hal_gettsf32);
+EXPORT_SYMBOL(ath_hal_gettsf64);
+EXPORT_SYMBOL(ath_hal_resettsf);
+EXPORT_SYMBOL(ath_hal_rxena);
+EXPORT_SYMBOL(ath_hal_numtxpending);
+EXPORT_SYMBOL(ath_hal_puttxbuf);
+EXPORT_SYMBOL(ath_hal_gettxbuf);
+EXPORT_SYMBOL(ath_hal_getrxbuf);
+EXPORT_SYMBOL(ath_hal_txstart);
+EXPORT_SYMBOL(ath_hal_calibrate);
+EXPORT_SYMBOL(ath_hal_setledstate);
+EXPORT_SYMBOL(ath_hal_beaconinit);
+EXPORT_SYMBOL(ath_hal_beaconreset);
+EXPORT_SYMBOL(ath_hal_beacontimers);
+EXPORT_SYMBOL(ath_hal_setassocid);
+EXPORT_SYMBOL(ath_hal_phydisable);
+EXPORT_SYMBOL(ath_hal_setopmode);
+EXPORT_SYMBOL(ath_hal_stoptxdma);
+EXPORT_SYMBOL(ath_hal_stoppcurecv);
+EXPORT_SYMBOL(ath_hal_startpcurecv);
+EXPORT_SYMBOL(ath_hal_stopdmarecv);
+EXPORT_SYMBOL(ath_hal_getdiagstate);
+EXPORT_SYMBOL(ath_hal_gettxqueueprops);
+EXPORT_SYMBOL(ath_hal_settxqueueprops);
+EXPORT_SYMBOL(ath_hal_setuptxqueue);
+EXPORT_SYMBOL(ath_hal_resettxqueue);
+EXPORT_SYMBOL(ath_hal_releasetxqueue);
+EXPORT_SYMBOL(ath_hal_getrfgain);
+EXPORT_SYMBOL(ath_hal_getdefantenna);
+EXPORT_SYMBOL(ath_hal_setdefantenna);
+EXPORT_SYMBOL(ath_hal_rxmonitor);
+EXPORT_SYMBOL(ath_hal_mibevent);
+EXPORT_SYMBOL(ath_hal_setslottime);
+EXPORT_SYMBOL(ath_hal_getslottime);
+EXPORT_SYMBOL(ath_hal_setacktimeout);
+EXPORT_SYMBOL(ath_hal_getacktimeout);
+EXPORT_SYMBOL(ath_hal_setctstimeout);
+EXPORT_SYMBOL(ath_hal_getctstimeout);
+EXPORT_SYMBOL(ath_hal_setdecompmask);
+EXPORT_SYMBOL(ath_hal_getcapability);
+EXPORT_SYMBOL(ath_hal_setcapability);
+EXPORT_SYMBOL(ath_hal_ciphersupported);
+EXPORT_SYMBOL(ath_hal_fastframesupported);
+EXPORT_SYMBOL(ath_hal_burstsupported);
+EXPORT_SYMBOL(ath_hal_xrsupported);
+EXPORT_SYMBOL(ath_hal_compressionsupported);
+EXPORT_SYMBOL(ath_hal_turboagsupported);
+EXPORT_SYMBOL(ath_hal_halfrate_chansupported);
+EXPORT_SYMBOL(ath_hal_quarterrate_chansupported);
+EXPORT_SYMBOL(ath_hal_getregdomain);
+EXPORT_SYMBOL(ath_hal_getcountrycode);
+EXPORT_SYMBOL(ath_hal_hastkipsplit);
+EXPORT_SYMBOL(ath_hal_gettkipsplit);
+EXPORT_SYMBOL(ath_hal_settkipsplit);
+EXPORT_SYMBOL(ath_hal_wmetkipmic);
+EXPORT_SYMBOL(ath_hal_hwphycounters);
+EXPORT_SYMBOL(ath_hal_hasdiversity);
+EXPORT_SYMBOL(ath_hal_getdiversity);
+EXPORT_SYMBOL(ath_hal_setdiversity);
+EXPORT_SYMBOL(ath_hal_getnumtxqueues);
+EXPORT_SYMBOL(ath_hal_hasveol);
+EXPORT_SYMBOL(ath_hal_hastxpowlimit);
+EXPORT_SYMBOL(ath_hal_settxpowlimit);
+EXPORT_SYMBOL(ath_hal_gettxpowlimit);
+EXPORT_SYMBOL(ath_hal_getmaxtxpow);
+EXPORT_SYMBOL(ath_hal_gettpscale);
+EXPORT_SYMBOL(ath_hal_settpscale);
+EXPORT_SYMBOL(ath_hal_hastpc);
+EXPORT_SYMBOL(ath_hal_gettpc);
+EXPORT_SYMBOL(ath_hal_settpc);
+EXPORT_SYMBOL(ath_hal_hasbursting);
+EXPORT_SYMBOL(ath_hal_hascompression);
+EXPORT_SYMBOL(ath_hal_hasfastframes);
+EXPORT_SYMBOL(ath_hal_hasbssidmask);
+EXPORT_SYMBOL(ath_hal_hasmcastkeysearch);
+EXPORT_SYMBOL(ath_hal_getmcastkeysearch);
+EXPORT_SYMBOL(ath_hal_hastkipmic);
+EXPORT_SYMBOL(ath_hal_gettkipmic);
+EXPORT_SYMBOL(ath_hal_settkipmic);
+EXPORT_SYMBOL(ath_hal_hastsfadjust);
+EXPORT_SYMBOL(ath_hal_gettsfadjust);
+EXPORT_SYMBOL(ath_hal_settsfadjust);
+EXPORT_SYMBOL(ath_hal_setrfsilent);
+EXPORT_SYMBOL(ath_hal_hasrfsilent);
+EXPORT_SYMBOL(ath_hal_setuprxdesc);
+EXPORT_SYMBOL(ath_hal_rxprocdesc);
+EXPORT_SYMBOL(ath_hal_setuptxdesc);
+EXPORT_SYMBOL(ath_hal_setupxtxdesc);
+EXPORT_SYMBOL(ath_hal_filltxdesc);
+EXPORT_SYMBOL(ath_hal_txprocdesc);
+EXPORT_SYMBOL(ath_hal_gettxintrtxqs);
+EXPORT_SYMBOL(ath_hal_txreqintrdesc);
+EXPORT_SYMBOL(ath_hal_gpioCfgOutput);
+EXPORT_SYMBOL(ath_hal_gpioset);
+EXPORT_SYMBOL(ath_hal_setcoverageclass);
+EXPORT_SYMBOL(ath_hal_radar_wait);
+EXPORT_SYMBOL(ath_hal_get_channel_noise);
+EXPORT_SYMBOL(ath_hal_set_regulatory_domain);
+EXPORT_SYMBOL(ath_hal_getpower);
+EXPORT_SYMBOL(ath_hal_set_multicast_filter_index);
+EXPORT_SYMBOL(ath_hal_clear_multicast_filter_index);
+EXPORT_SYMBOL(ath_hal_gpioGet);
+EXPORT_SYMBOL(ath_hal_gpioCfgInput);
+EXPORT_SYMBOL(ath_hal_gpioSetIntr);
+EXPORT_SYMBOL(ath_hal_detect_card_present);
+EXPORT_SYMBOL(ath_hal_update_mib_counters);
+EXPORT_SYMBOL(ath_hal_get_antenna_switch);
+EXPORT_SYMBOL(ath_hal_set_antenna_switch);
+EXPORT_SYMBOL(ath_hal_set_beacon_timers);
+
+#endif /* #ifndef AH_HALOPS_FUNC */

madwifi/ath_hal/ath_hal_api.h

@@ +1 @@
+/*
+ * Wrapper macros/functions for the binary HAL to comply with local coding convention.
+ * 
+ * Provides function-style calling convention using either macros or wrapper functions for function pointers in the HAL.
+ * 
+ * The typical convention is foo(hal,p1,p2,p3,...) turns into hal->foo(p1,p2,p3,...) where foo 
+ * is a function pointer and a member of the struct ath_hal.
+ *
+ * The macros are faster, but the functions have the advantage that they show up unobfuscated in backtraces thus giving you a clue as to where in 
+ * your code you went wrong in your use of the HAL.
+ *s
+ */
+#ifndef _IF_ATH_HAL_H
+#define _IF_ATH_HAL_H
+
+#include "ah.h"
+
+#ifndef AH_HALOPS_FUNC
+/*
+ * HAL definitions to comply with local coding convention.
+ */
+#define ath_hal_reset(_ah, _opmode, _chan, _outdoor, _pstatus) \
+        ((*(_ah)->ah_reset)((_ah), (_opmode), (_chan), (_outdoor), (_pstatus)))
+#define ath_hal_getratetable(_ah, _mode) \
+        ((*(_ah)->ah_getRateTable)((_ah), (_mode)))
+#define ath_hal_getmac(_ah, _mac) \
+        ((*(_ah)->ah_getMacAddress)((_ah), (_mac)))
+#define ath_hal_setmac(_ah, _mac) \
+        ((*(_ah)->ah_setMacAddress)((_ah), (_mac)))
+#define ath_hal_getbssidmask(_ah, _mask) \
+        ((*(_ah)->ah_getBssIdMask)((_ah), (_mask)))
+#define ath_hal_setbssidmask(_ah, _mask) \
+        ((*(_ah)->ah_setBssIdMask)((_ah), (_mask)))
+#define ath_hal_intrset(_ah, _mask) \
+        ((*(_ah)->ah_setInterrupts)((_ah), (_mask)))
+#define ath_hal_intrget(_ah) \
+        ((*(_ah)->ah_getInterrupts)((_ah)))
+#define ath_hal_intrpend(_ah) \
+        ((*(_ah)->ah_isInterruptPending)((_ah)))
+#define ath_hal_getisr(_ah, _pmask) \
+        ((*(_ah)->ah_getPendingInterrupts)((_ah), (_pmask)))
+#define ath_hal_updatetxtriglevel(_ah, _inc) \
+        ((*(_ah)->ah_updateTxTrigLevel)((_ah), (_inc)))
+#define ath_hal_setpower(_ah, _mode) \
+        ((*(_ah)->ah_setPowerMode)((_ah), (_mode), AH_TRUE))
+#define ath_hal_keycachesize(_ah) \
+        ((*(_ah)->ah_getKeyCacheSize)((_ah)))
+#define ath_hal_keyreset(_ah, _ix) \
+        ((*(_ah)->ah_resetKeyCacheEntry)((_ah), (_ix)))
+#define ath_hal_keyset(_ah, _ix, _pk, _mac) \
+        ((*(_ah)->ah_setKeyCacheEntry)((_ah), (_ix), (_pk), (_mac), AH_FALSE))
+#define ath_hal_keyisvalid(_ah, _ix) \
+        (((*(_ah)->ah_isKeyCacheEntryValid)((_ah), (_ix))))
+#define ath_hal_keysetmac(_ah, _ix, _mac) \
+        ((*(_ah)->ah_setKeyCacheEntryMac)((_ah), (_ix), (_mac)))
+#define ath_hal_getrxfilter(_ah) \
+        ((*(_ah)->ah_getRxFilter)((_ah)))
+#define ath_hal_setrxfilter(_ah, _filter) \
+        ((*(_ah)->ah_setRxFilter)((_ah), (_filter)))
+#define ath_hal_setmcastfilter(_ah, _mfilt0, _mfilt1) \
+        ((*(_ah)->ah_setMulticastFilter)((_ah), (_mfilt0), (_mfilt1)))
+#define ath_hal_waitforbeacon(_ah, _bf) \
+        ((*(_ah)->ah_waitForBeaconDone)((_ah), (_bf)->bf_daddr))
+#define ath_hal_putrxbuf(_ah, _bufaddr) \
+        ((*(_ah)->ah_setRxDP)((_ah), (_bufaddr)))
+#define ath_hal_gettsf32(_ah) \
+        ((*(_ah)->ah_getTsf32)((_ah)))
+#define ath_hal_gettsf64(_ah) \
+        ((*(_ah)->ah_getTsf64)((_ah)))
+#define ath_hal_resettsf(_ah) \
+        ((*(_ah)->ah_resetTsf)((_ah)))
+#define ath_hal_rxena(_ah) \
+        ((*(_ah)->ah_enableReceive)((_ah)))
+#define ath_hal_numtxpending(_ah, _q) \
+        ((*(_ah)->ah_numTxPending)((_ah), (_q)))
+#define ath_hal_puttxbuf(_ah, _q, _bufaddr) \
+        ((*(_ah)->ah_setTxDP)((_ah), (_q), (_bufaddr)))
+#define ath_hal_gettxbuf(_ah, _q) \
+        ((*(_ah)->ah_getTxDP)((_ah), (_q)))
+#define ath_hal_getrxbuf(_ah) \
+        ((*(_ah)->ah_getRxDP)((_ah)))
+#define ath_hal_txstart(_ah, _q) \
+        ((*(_ah)->ah_startTxDma)((_ah), (_q)))
+#define ath_hal_setchannel(_ah, _chan) \
+        ((*(_ah)->ah_setChannel)((_ah), (_chan)))
+#define ath_hal_calibrate(_ah, _chan, _isIQdone) \
+        ((*(_ah)->ah_perCalibration)((_ah), (_chan), (_isIQdone)))
+#define ath_hal_setledstate(_ah, _state) \
+        ((*(_ah)->ah_setLedState)((_ah), (_state)))
+#define ath_hal_beaconinit(_ah, _nextb, _bperiod) \
+        ((*(_ah)->ah_beaconInit)((_ah), (_nextb), (_bperiod)))
+#define ath_hal_beaconreset(_ah) \
+        ((*(_ah)->ah_resetStationBeaconTimers)((_ah)))
+#define ath_hal_beacontimers(_ah, _bs) \
+        ((*(_ah)->ah_setStationBeaconTimers)((_ah), (_bs)))
+#define ath_hal_setassocid(_ah, _bss, _associd) \
+        ((*(_ah)->ah_writeAssocid)((_ah), (_bss), (_associd)))
+#define ath_hal_phydisable(_ah) \
+        ((*(_ah)->ah_phyDisable)((_ah)))
+#define ath_hal_setopmode(_ah) \
+        ((*(_ah)->ah_setPCUConfig)((_ah)))
+#define ath_hal_stoptxdma(_ah, _qnum) \
+        ((*(_ah)->ah_stopTxDma)((_ah), (_qnum)))
+#define ath_hal_stoppcurecv(_ah) \
+        ((*(_ah)->ah_stopPcuReceive)((_ah)))
+#define ath_hal_startpcurecv(_ah) \
+        ((*(_ah)->ah_startPcuReceive)((_ah)))
+#define ath_hal_stopdmarecv(_ah) \
+        ((*(_ah)->ah_stopDmaReceive)((_ah)))
+#define ath_hal_getdiagstate(_ah, _id, _indata, _insize, _outdata, _outsize) \
+        ((*(_ah)->ah_getDiagState)((_ah), (_id), \
+                (_indata), (_insize), (_outdata), (_outsize)))
+#define ath_hal_gettxqueueprops(_ah, _q, _qi) \
+        ((*(_ah)->ah_getTxQueueProps)((_ah), (_q), (_qi)))
+#define ath_hal_settxqueueprops(_ah, _q, _qi) \
+        ((*(_ah)->ah_setTxQueueProps)((_ah), (_q), (_qi)))
+#define ath_hal_setuptxqueue(_ah, _type, _irq) \
+        ((*(_ah)->ah_setupTxQueue)((_ah), (_type), (_irq)))
+#define ath_hal_resettxqueue(_ah, _q) \
+        ((*(_ah)->ah_resetTxQueue)((_ah), (_q)))
+#define ath_hal_releasetxqueue(_ah, _q) \
+        ((*(_ah)->ah_releaseTxQueue)((_ah), (_q)))
+#define ath_hal_getrfgain(_ah) \
+        ((*(_ah)->ah_getRfGain)((_ah)))
+#define ath_hal_getdefantenna(_ah) \
+        ((*(_ah)->ah_getDefAntenna)((_ah)))
+#define ath_hal_setdefantenna(_ah, _ant) \
+        ((*(_ah)->ah_setDefAntenna)((_ah), (_ant)))
+#define ath_hal_rxmonitor(_ah, _arg, _chan) \
+        ((*(_ah)->ah_rxMonitor)((_ah), (_arg), (_chan)))
+#define ath_hal_mibevent(_ah, _stats) \
+        ((*(_ah)->ah_procMibEvent)((_ah), (_stats)))
+#define ath_hal_setslottime(_ah, _us) \
+        ((*(_ah)->ah_setSlotTime)((_ah), (_us)))
+#define ath_hal_getslottime(_ah) \
+        ((*(_ah)->ah_getSlotTime)((_ah)))
+#define ath_hal_setacktimeout(_ah, _us) \
+        ((*(_ah)->ah_setAckTimeout)((_ah), (_us)))
+#define ath_hal_getacktimeout(_ah) \
+        ((*(_ah)->ah_getAckTimeout)((_ah)))
+#define ath_hal_setctstimeout(_ah, _us) \
+        ((*(_ah)->ah_setCTSTimeout)((_ah), (_us)))
+#define ath_hal_getctstimeout(_ah) \
+        ((*(_ah)->ah_getCTSTimeout)((_ah)))
+#define ath_hal_setdecompmask(_ah, _keyid, _b) \
+        ((*(_ah)->ah_setDecompMask)((_ah), (_keyid), (_b)))
+#define ath_hal_enablePhyDiag(_ah) \
+        ((*(_ah)->ah_enablePhyErrDiag)((_ah)))
+#define ath_hal_disablePhyDiag(_ah) \
+        ((*(_ah)->ah_disablePhyErrDiag)((_ah)))
+#define ath_hal_getcapability(_ah, _cap, _param, _result) \
+        ((*(_ah)->ah_getCapability)((_ah), (_cap), (_param), (_result)))
+#define ath_hal_setcapability(_ah, _cap, _param, _v, _status) \
+        ((*(_ah)->ah_setCapability)((_ah), (_cap), (_param), (_v), (_status)))
+#define ath_hal_ciphersupported(_ah, _cipher) \
+        (ath_hal_getcapability(_ah, HAL_CAP_CIPHER, _cipher, NULL) == HAL_OK)
+#define ath_hal_fastframesupported(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_FASTFRAME, 0, NULL) == HAL_OK)
+#define ath_hal_burstsupported(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_BURST, 0, NULL) == HAL_OK)
+#define ath_hal_xrsupported(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_XR, 0, NULL) == HAL_OK)
+#define ath_hal_compressionsupported(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_COMPRESSION, 0, NULL) == HAL_OK)
+#define ath_hal_turboagsupported(_ah, _countrycode) \
+        (ath_hal_getwirelessmodes(_ah, _countrycode) & (HAL_MODE_108G|HAL_MODE_TURBO))
+#define ath_hal_halfrate_chansupported(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_CHAN_HALFRATE, 0, NULL) == HAL_OK)
+#define ath_hal_quarterrate_chansupported(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_CHAN_QUARTERRATE, 0, NULL) == HAL_OK)
+#define ath_hal_getregdomain(_ah, _prd) \
+        ath_hal_getcapability(_ah, HAL_CAP_REG_DMN, 0, (_prd))
+#define ath_hal_getcountrycode(_ah, _pcc) \
+        (*(_pcc) = (_ah)->ah_countryCode)
+#define ath_hal_hastkipsplit(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TKIP_SPLIT, 0, NULL) == HAL_OK)
+#define ath_hal_gettkipsplit(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TKIP_SPLIT, 1, NULL) == HAL_OK)
+#define ath_hal_settkipsplit(_ah, _v) \
+        ath_hal_setcapability(_ah, HAL_CAP_TKIP_SPLIT, 1, _v, NULL)
+#define ath_hal_wmetkipmic(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_WME_TKIPMIC, 0, NULL) == HAL_OK)
+#define ath_hal_hwphycounters(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_PHYCOUNTERS, 0, NULL) == HAL_OK)
+#define ath_hal_hasdiversity(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_DIVERSITY, 0, NULL) == HAL_OK)
+#define ath_hal_getdiversity(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_DIVERSITY, 1, NULL) == HAL_OK)
+#define ath_hal_setdiversity(_ah, _v) \
+        ath_hal_setcapability(_ah, HAL_CAP_DIVERSITY, 1, _v, NULL)
+#define ath_hal_getnumtxqueues(_ah, _pv) \
+        (ath_hal_getcapability(_ah, HAL_CAP_NUM_TXQUEUES, 0, _pv) == HAL_OK)
+#define ath_hal_hasveol(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_VEOL, 0, NULL) == HAL_OK)
+#define ath_hal_hastxpowlimit(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TXPOW, 0, NULL) == HAL_OK)
+#define ath_hal_settxpowlimit(_ah, _pow) \
+        ((*(_ah)->ah_setTxPowerLimit)((_ah), (_pow)))
+#define ath_hal_gettxpowlimit(_ah, _ppow) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TXPOW, 1, _ppow) == HAL_OK)
+#define ath_hal_getmaxtxpow(_ah, _ppow) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TXPOW, 2, _ppow) == HAL_OK)
+#define ath_hal_gettpscale(_ah, _scale) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TXPOW, 3, _scale) == HAL_OK)
+#define ath_hal_settpscale(_ah, _v) \
+        ath_hal_setcapability(_ah, HAL_CAP_TXPOW, 3, _v, NULL)
+#define ath_hal_hastpc(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TPC, 0, NULL) == HAL_OK)
+#define ath_hal_gettpc(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TPC, 1, NULL) == HAL_OK)
+#define ath_hal_settpc(_ah, _v) \
+        ath_hal_setcapability(_ah, HAL_CAP_TPC, 1, _v, NULL)
+#define ath_hal_hasbursting(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_BURST, 0, NULL) == HAL_OK)
+#define ath_hal_hascompression(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_COMPRESSION, 0, NULL) == HAL_OK)
+#define ath_hal_hasfastframes(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_FASTFRAME, 0, NULL) == HAL_OK)
+#define ath_hal_hasbssidmask(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_BSSIDMASK, 0, NULL) == HAL_OK)
+#define ath_hal_hasmcastkeysearch(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_MCAST_KEYSRCH, 0, NULL) == HAL_OK)
+#define ath_hal_getmcastkeysearch(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_MCAST_KEYSRCH, 1, NULL) == HAL_OK)
+#define ath_hal_hastkipmic(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TKIP_MIC, 0, NULL) == HAL_OK)
+#define ath_hal_gettkipmic(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TKIP_MIC, 1, NULL) == HAL_OK)
+#define ath_hal_settkipmic(_ah, _v) \
+        ath_hal_setcapability(_ah, HAL_CAP_TKIP_MIC, 1, _v, NULL)
+#define ath_hal_hastsfadjust(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TSF_ADJUST, 0, NULL) == HAL_OK)
+#define ath_hal_gettsfadjust(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_TSF_ADJUST, 1, NULL) == HAL_OK)
+#define ath_hal_settsfadjust(_ah, _v) \
+        ath_hal_setcapability(_ah, HAL_CAP_TSF_ADJUST, 1, _v, NULL)
+#define ath_hal_setrfsilent(_ah, _v) \
+        ath_hal_setcapability(_ah, HAL_CAP_RFSILENT, 1, _v, NULL)
+#define ath_hal_hasrfsilent(_ah) \
+        (ath_hal_getcapability(_ah, HAL_CAP_RFSILENT, 0, NULL) == HAL_OK)
+
+#define ath_hal_setuprxdesc(_ah, _ds, _size, _intreq) \
+        ((*(_ah)->ah_setupRxDesc)((_ah), (_ds), (_size), (_intreq)))
+#define ath_hal_rxprocdesc(_ah, _ds, _dspa, _dsnext, _tsf, _rs) \
+        ((*(_ah)->ah_procRxDesc)((_ah), (_ds), (_dspa), (_dsnext), (_tsf), (_rs)))
+#define ath_hal_updateCTSForBursting(_ah, _ds, _prevds, _prevdsWithCTS, _gatingds,    \
+                                     _txOpLimit, _ctsDuration)                        \
+        ((*(_ah)->ah_updateCTSForBursting)((_ah), (_ds), (_prevds), (_prevdsWithCTS), \
+                                           (_gatingds), (_txOpLimit), (_ctsDuration)))
+#define ath_hal_setuptxdesc(_ah, _ds, _plen, _hlen, _atype, _txpow, \
+                _txr0, _txtr0, _keyix, _ant, _flags, \
+                _rtsrate, _rtsdura, \
+                _compicvlen, _compivlen, _comp) \
+        ((*(_ah)->ah_setupTxDesc)((_ah), (_ds), (_plen), (_hlen), (_atype), \
+                (_txpow), (_txr0), (_txtr0), (_keyix), (_ant), \
+                (_flags), (_rtsrate), (_rtsdura), \
+                (_compicvlen), (_compivlen), (_comp)))
+#define ath_hal_setupxtxdesc(_ah, _ds, \
+                _txr1, _txtr1, _txr2, _txtr2, _txr3, _txtr3) \
+        ((*(_ah)->ah_setupXTxDesc)((_ah), (_ds), \
+                (_txr1), (_txtr1), (_txr2), (_txtr2), (_txr3), (_txtr3)))
+#define ath_hal_filltxdesc(_ah, _ds, _l, _first, _last, _ds0) \
+        ((*(_ah)->ah_fillTxDesc)((_ah), (_ds), (_l), (_first), (_last), (_ds0)))
+#define ath_hal_txprocdesc(_ah, _ds, _ts) \
+        ((*(_ah)->ah_procTxDesc)((_ah), (_ds), (_ts)))
+#define ath_hal_gettxintrtxqs(_ah, _txqs) \
+        ((*(_ah)->ah_getTxIntrQueue)((_ah), (_txqs)))
+#define ath_hal_txreqintrdesc(_ah, _ds) \
+        ((*(_ah)->ah_reqTxIntrDesc)((_ah), (_ds)))
+
+#define ath_hal_gpioCfgOutput(_ah, _gpio) \
+        ((*(_ah)->ah_gpioCfgOutput)((_ah), (_gpio)))
+#define ath_hal_gpioset(_ah, _gpio, _b) \
+        ((*(_ah)->ah_gpioSet)((_ah), (_gpio), (_b)))
+#define ath_hal_setcoverageclass(_ah, _coverageclass, _now) \
+        ((*(_ah)->ah_setCoverageClass)((_ah), (_coverageclass), (_now)))
+#define ath_hal_radar_wait(_ah, _chan) \
+        ((*(_ah)->ah_radarWait)((_ah), (_chan)))
+#define ath_hal_get_channel_noise(_ah, _chan) \
+        ((*(_ah)->ah_getChanNoise)((_ah), (_chan)))
+
+#else // if AH_HALOPS_FUNC
+
+HAL_BOOL ath_hal_reset(struct ath_hal* ah, HAL_OPMODE opmode, HAL_CHANNEL* chan,  HAL_BOOL outdoor, HAL_STATUS* pstatus);
+const HAL_RATE_TABLE* ath_hal_getratetable(struct ath_hal* ah, u_int mode);
+void ath_hal_getmac(struct ath_hal* ah, u_int8_t* mac);
+HAL_BOOL ath_hal_setmac(struct ath_hal* ah, const u_int8_t* mac);
+void ath_hal_getbssidmask(struct ath_hal * ah, u_int8_t * mask);
+HAL_BOOL ath_hal_setbssidmask(struct ath_hal * ah, const u_int8_t* mask);
+HAL_INT ath_hal_intrset(struct ath_hal* ah, HAL_INT mask);
+HAL_INT ath_hal_intrget(struct ath_hal* ah);
+HAL_BOOL ath_hal_intrpend(struct ath_hal* ah);
+HAL_BOOL ath_hal_getisr(struct ath_hal* ah, HAL_INT* pmask);
+HAL_BOOL ath_hal_updatetxtriglevel(struct ath_hal* ah, HAL_BOOL inc);
+HAL_BOOL ath_hal_setpower(struct ath_hal* ah, HAL_POWER_MODE mode);
+u_int32_t ath_hal_keycachesize(struct ath_hal* ah);
+HAL_BOOL ath_hal_keyreset(struct ath_hal* ah, u_int16_t ix);
+HAL_BOOL ath_hal_keyset(struct ath_hal* ah, u_int16_t ix, const HAL_KEYVAL * pk, const u_int8_t * mac);
+HAL_BOOL ath_hal_keyisvalid(struct ath_hal *ah, u_int16_t ix);
+HAL_BOOL ath_hal_keysetmac(struct ath_hal* ah, u_int16_t ix, const u_int8_t *mac);
+u_int32_t ath_hal_getrxfilter(struct ath_hal* ah);
+void ath_hal_setrxfilter(struct ath_hal* ah, u_int32_t filter);
+void ath_hal_setmcastfilter(struct ath_hal* ah, u_int32_t mfilt0, u_int32_t mfilt1);
+void ath_hal_putrxbuf(struct ath_hal* ah, u_int32_t bufaddr);
+u_int32_t ath_hal_gettsf32(struct ath_hal* ah);
+u_int64_t ath_hal_gettsf64(struct ath_hal* ah);
+void ath_hal_resettsf(struct ath_hal* ah);
+void ath_hal_rxena(struct ath_hal* ah);
+u_int32_t ath_hal_numtxpending(struct ath_hal *hal, u_int q);
+HAL_BOOL ath_hal_puttxbuf(struct ath_hal* ah, u_int q, u_int32_t bufaddr);
+u_int32_t ath_hal_gettxbuf(struct ath_hal* ah, u_int q);
+u_int32_t ath_hal_getrxbuf(struct ath_hal* ah);
+HAL_BOOL ath_hal_txstart(struct ath_hal* ah, u_int q);
+HAL_BOOL ath_hal_calibrate(struct ath_hal* ah, HAL_CHANNEL * chan, HAL_BOOL * isIQdone);
+void ath_hal_setledstate(struct ath_hal* ah, HAL_LED_STATE state);
+void ath_hal_beaconinit(struct ath_hal * ah, u_int32_t nextb, u_int32_t bperiod);
+void ath_hal_beaconreset(struct ath_hal* ah);
+void ath_hal_beacontimers(struct ath_hal* ah, const HAL_BEACON_STATE *bs);
+void ath_hal_setassocid(struct ath_hal* ah, const u_int8_t *bss, u_int16_t associd);
+HAL_BOOL ath_hal_phydisable(struct ath_hal * ah);
+void ath_hal_setopmode(struct ath_hal * ah);
+HAL_BOOL ath_hal_stoptxdma(struct ath_hal* ah, u_int q);
+void ath_hal_stoppcurecv(struct ath_hal* ah);
+void ath_hal_startpcurecv(struct ath_hal* ah);
+HAL_BOOL ath_hal_stopdmarecv(struct ath_hal* ah);
+HAL_BOOL ath_hal_getdiagstate(struct ath_hal *ah, int id, const void *indata, u_int32_t insize, void** outdata, u_int32_t* outsize);
+HAL_BOOL ath_hal_gettxqueueprops(struct ath_hal * ah, int q, HAL_TXQ_INFO *qi);
+HAL_BOOL ath_hal_settxqueueprops(struct ath_hal *ah, int q, const HAL_TXQ_INFO *qi);
+int     ath_hal_setuptxqueue(struct ath_hal * ah, HAL_TX_QUEUE type, const HAL_TXQ_INFO * qi);
+HAL_BOOL ath_hal_resettxqueue(struct ath_hal *ah, u_int q);
+HAL_BOOL ath_hal_releasetxqueue(struct ath_hal *ah, u_int q);
+HAL_RFGAIN ath_hal_getrfgain(struct ath_hal* ah);
+u_int ath_hal_getdefantenna(struct ath_hal* ah);
+void ath_hal_setdefantenna(struct ath_hal* ah, u_int ant);
+void ath_hal_rxmonitor(struct ath_hal* ah, const HAL_NODE_STATS *stats, HAL_CHANNEL *chan);
+void ath_hal_mibevent(struct ath_hal * ah, const HAL_NODE_STATS *stats);
+HAL_BOOL ath_hal_setslottime(struct ath_hal* ah, u_int us);
+u_int ath_hal_getslottime(struct ath_hal* ah);
+HAL_BOOL ath_hal_setacktimeout(struct ath_hal* ah, u_int us);
+u_int ath_hal_getacktimeout(struct ath_hal* ah);
+HAL_BOOL ath_hal_setctstimeout(struct ath_hal* ah, u_int us);
+u_int ath_hal_getctstimeout(struct ath_hal* ah);
+HAL_BOOL ath_hal_setdecompmask(struct ath_hal* ah, u_int16_t keyid, int b);
+HAL_STATUS ath_hal_getcapability(struct ath_hal * ah, HAL_CAPABILITY_TYPE type, u_int32_t capability, u_int32_t *result);
+HAL_BOOL ath_hal_setcapability(struct ath_hal * ah, HAL_CAPABILITY_TYPE type, u_int32_t capability, u_int32_t setting, HAL_STATUS *status);
+HAL_BOOL ath_hal_ciphersupported(struct ath_hal * ah, u_int32_t cipher);
+HAL_BOOL ath_hal_fastframesupported(struct ath_hal * ah);
+HAL_BOOL ath_hal_burstsupported(struct ath_hal * ah);
+HAL_BOOL ath_hal_xrsupported(struct ath_hal * ah);
+HAL_BOOL ath_hal_compressionsupported(struct ath_hal * ah);
+HAL_BOOL ath_hal_turboagsupported(struct ath_hal * ah, int countrycode);
+HAL_BOOL ath_hal_halfrate_chansupported(struct ath_hal * ah);
+HAL_BOOL ath_hal_quarterrate_chansupported(struct ath_hal * ah);
+HAL_BOOL ath_hal_getregdomain(struct ath_hal * ah, u_int32_t* destination);
+HAL_BOOL ath_hal_getcountrycode(struct ath_hal * ah, u_int32_t* destination);
+HAL_BOOL ath_hal_hastkipsplit(struct ath_hal * ah);
+HAL_BOOL ath_hal_gettkipsplit(struct ath_hal * ah);
+HAL_BOOL ath_hal_settkipsplit(struct ath_hal * ah, int v);
+HAL_BOOL ath_hal_wmetkipmic(struct ath_hal * ah);
+HAL_BOOL ath_hal_hwphycounters(struct ath_hal * ah);
+HAL_BOOL ath_hal_hasdiversity(struct ath_hal * ah);
+HAL_BOOL ath_hal_getdiversity(struct ath_hal * ah);
+HAL_BOOL ath_hal_setdiversity(struct ath_hal * ah, int v);
+HAL_BOOL ath_hal_getnumtxqueues(struct ath_hal * ah, u_int32_t* destination);
+HAL_BOOL ath_hal_hasveol(struct ath_hal * ah);
+HAL_BOOL ath_hal_hastxpowlimit(struct ath_hal * ah);
+HAL_BOOL ath_hal_settxpowlimit(struct ath_hal * ah, u_int32_t power);
+HAL_BOOL ath_hal_gettxpowlimit(struct ath_hal * ah, u_int32_t* destination);
+HAL_BOOL ath_hal_getmaxtxpow(struct ath_hal * ah, u_int32_t* destination);
+HAL_BOOL ath_hal_gettpscale(struct ath_hal * ah, u_int32_t* destination);
+HAL_BOOL ath_hal_settpscale(struct ath_hal * ah, u_int32_t v);
+HAL_BOOL ath_hal_hastpc(struct ath_hal * ah);
+HAL_BOOL ath_hal_gettpc(struct ath_hal * ah);
+HAL_BOOL ath_hal_settpc(struct ath_hal * ah, u_int32_t v);
+HAL_BOOL ath_hal_hasbursting(struct ath_hal * ah);
+HAL_BOOL ath_hal_hascompression(struct ath_hal * ah);
+HAL_BOOL ath_hal_hasfastframes(struct ath_hal * ah);
+HAL_BOOL ath_hal_hasbssidmask(struct ath_hal * ah);
+HAL_BOOL ath_hal_hasmcastkeysearch(struct ath_hal * ah);
+HAL_BOOL ath_hal_getmcastkeysearch(struct ath_hal * ah);
+HAL_BOOL ath_hal_hastkipmic(struct ath_hal * ah);
+HAL_BOOL ath_hal_gettkipmic(struct ath_hal * ah);
+HAL_BOOL ath_hal_settkipmic(struct ath_hal * ah, u_int32_t v);
+HAL_BOOL ath_hal_hastsfadjust(struct ath_hal * ah);
+HAL_BOOL ath_hal_gettsfadjust(struct ath_hal * ah);
+HAL_BOOL ath_hal_settsfadjust(struct ath_hal * ah, u_int32_t v);
+HAL_BOOL ath_hal_setrfsilent(struct ath_hal * ah, u_int32_t v);
+HAL_BOOL ath_hal_hasrfsilent(struct ath_hal * ah);
+HAL_BOOL ath_hal_setuprxdesc(struct ath_hal *ah, struct ath_desc *ds, u_int32_t size, u_int flags);
+HAL_BOOL ath_hal_rxprocdesc(struct ath_hal *ah, struct ath_desc *ds, u_int32_t dspa, struct ath_desc *dsnext, u_int64_t tsf, struct ath_rx_status *rs);
+HAL_BOOL ath_hal_setuptxdesc(struct ath_hal *ah, struct ath_desc *ds, u_int plen, u_int hlen, HAL_PKT_TYPE atype, u_int txpow, u_int txr0, u_int txtr0, u_int keyix, u_int ant, u_int flags, u_int rtsrate, u_int rtsdura, u_int compicvlen, u_int compivlen, u_int comp);
+HAL_BOOL ath_hal_setupxtxdesc(struct ath_hal * ah, struct ath_desc* ds, u_int txr1, u_int txtr1, u_int txr2, u_int txtr2, u_int txr3, u_int txtr3);
+HAL_BOOL ath_hal_filltxdesc(struct ath_hal * ah, struct ath_desc * ds, u_int l, HAL_BOOL first, HAL_BOOL last, const struct ath_desc * ds0);
+HAL_BOOL ath_hal_txprocdesc(struct ath_hal * ah, struct ath_desc *ds, struct ath_tx_status *ts);
+void ath_hal_gettxintrtxqs(struct ath_hal *ah, u_int32_t *txqs);
+void ath_hal_txreqintrdesc(struct ath_hal * ah, struct ath_desc *ds);
+HAL_BOOL ath_hal_gpioCfgOutput(struct ath_hal * ah, u_int32_t gpio);
+HAL_BOOL ath_hal_gpioset(struct ath_hal * ah, u_int32_t gpio, u_int32_t val);
+void ath_hal_setcoverageclass(struct ath_hal * ah, u_int8_t coverageclass, int now);
+HAL_BOOL ath_hal_radar_wait(struct ath_hal * ah, HAL_CHANNEL *chan);
+int16_t ath_hal_get_channel_noise(struct ath_hal * ah, HAL_CHANNEL *chan);
+HAL_BOOL ath_hal_set_regulatory_domain(struct ath_hal* ah, u_int16_t domain, HAL_STATUS* pstatus);
+HAL_POWER_MODE ath_hal_getpower(struct ath_hal* ah);
+HAL_BOOL ath_hal_set_multicast_filter_index(struct ath_hal* ah, u_int32_t index);
+HAL_BOOL ath_hal_clear_multicast_filter_index(struct ath_hal* ah, u_int32_t index);
+HAL_BOOL ath_hal_gpioGet(struct ath_hal *ah, u_int32_t gpio);
+HAL_BOOL ath_hal_gpioCfgInput(struct ath_hal *ah, u_int32_t gpio);
+void ath_hal_gpioSetIntr(struct ath_hal *ah, u_int p1, u_int32_t p2);
+HAL_BOOL ath_hal_detect_card_present(struct ath_hal* ah);
+void ath_hal_update_mib_counters(struct ath_hal* ah, HAL_MIB_STATS* stats);
+HAL_ANT_SETTING ath_hal_get_antenna_switch(struct ath_hal* ah);
+HAL_BOOL ath_hal_set_antenna_switch(struct ath_hal* ah, HAL_ANT_SETTING ant);
+void ath_hal_set_beacon_timers(struct ath_hal* ah, const HAL_BEACON_TIMERS *timers);
+
+#endif /* #ifndef AH_HALOPS_FUNC */
+
+#endif /* _IF_ATH_HAL_H */
+

madwifi/ath_hal/Makefile

@@ -49 +49 @@
-include $(TOP)/Makefile.inc
-
-obj-m           += ath_hal.o
-
+ath_hal_api.o 
-
-hostprogs-y     := uudecode
-

madwifi/ath/if_athvar.h

@@ -744 +767 @@
-void ath_sysctl_register(void);
-void ath_sysctl_unregister(void);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-
-#endif /* _DEV_ATH_ATHVAR_H */

madwifi/ath/if_ath.c

@@ -726 +804 @@
-#endif
-
-#ifdef ATH_SUPERG_DYNTURBO
-
+, ath_countrycode
-                                                        IEEE80211_ATHC_AR) : 0);
-#endif
-#ifdef ATH_SUPERG_XR