mirror of https://github.com/proski/madwifi
1056 lines
27 KiB
C
1056 lines
27 KiB
C
/*-
|
|
* Copyright (c) 2007 Michael Taylor
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer,
|
|
without modification.
|
|
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
|
|
* similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
|
|
* redistribution must be conditioned upon including a substantially
|
|
* similar Disclaimer requirement for further binary redistribution.
|
|
* 3. Neither the names of the above-listed copyright holders nor the names
|
|
* of any contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* Alternatively, this software may be distributed under the terms of the
|
|
* GNU General Public License ("GPL") version 2 as published by the Free
|
|
* Software Foundation.
|
|
*
|
|
* NO WARRANTY
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
|
|
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
|
|
* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
|
|
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
* THE POSSIBILITY OF SUCH DAMAGES.
|
|
*/
|
|
/* **************************************************************
|
|
* * WARNING: THIS IS A GENERATED FILE. PLEASE DO NOT EDIT *
|
|
* ************************************************************** */
|
|
|
|
#include "if_ath_hal_macros.h"
|
|
|
|
#ifndef _IF_ATH_HAL_H_
|
|
#define _IF_ATH_HAL_H_
|
|
|
|
static inline void ath_hal_getmac(struct ath_hal *ah, u_int8_t *a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_getMacAddress(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_POWER_MODE ath_hal_getPowerMode(struct ath_hal *ah)
|
|
{
|
|
HAL_POWER_MODE ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getPowerMode(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_getdiagstate(struct ath_hal *ah, int request,
|
|
const void *args, u_int32_t argsize, void **result,
|
|
u_int32_t *resultsize)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getDiagState(ah, request, args, argsize, *result, resultsize);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_beaconreset(struct ath_hal *ah)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_resetStationBeaconTimers(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline void ath_hal_setcoverageclass(struct ath_hal *ah, u_int8_t a1,
|
|
int a2)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_setCoverageClass(ah, a1, a2);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline u_int64_t ath_hal_gettsf64(struct ath_hal *ah)
|
|
{
|
|
u_int64_t ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getTsf64(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_rxena(struct ath_hal *ah)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_enableReceive(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_ANT_SETTING ath_hal_getantennaswitch(struct ath_hal *ah)
|
|
{
|
|
HAL_ANT_SETTING ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getAntennaSwitch(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_gpioset(struct ath_hal *ah, u_int32_t gpio,
|
|
u_int32_t val)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_gpioSet(ah, gpio, val);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_gpioCfgOutput(struct ath_hal *ah, u_int32_t gpio)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_gpioCfgOutput(ah, gpio);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_clearmcastfilter(struct ath_hal *ah,
|
|
u_int32_t index)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_clrMulticastFilterIndex(ah, index);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_txreqintrdesc(struct ath_hal *ah,
|
|
struct ath_desc *a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_reqTxIntrDesc(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline void ath_hal_rxmonitor(struct ath_hal *ah,
|
|
const HAL_NODE_STATS *a1, HAL_CHANNEL *a2)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_rxMonitor(ah, a1, a2);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_puttxbuf(struct ath_hal *ah, u_int a1,
|
|
u_int32_t txdp)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setTxDP(ah, a1, txdp);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_keyset(struct ath_hal *ah, u_int16_t a1,
|
|
const HAL_KEYVAL *a2, const u_int8_t *a3, int a4)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setKeyCacheEntry(ah, a1, a2, a3, a4);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_setopmode(struct ath_hal *ah)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_setPCUConfig(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_RFGAIN ath_hal_getrfgain(struct ath_hal *ah)
|
|
{
|
|
HAL_RFGAIN ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getRfGain(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_setmcastfilter(struct ath_hal *ah,
|
|
u_int32_t filter0, u_int32_t filter1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_setMulticastFilter(ah, filter0, filter1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline u_int ath_hal_getacktimeout(struct ath_hal *ah)
|
|
{
|
|
u_int ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getAckTimeout(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_beacontimers(struct ath_hal *ah,
|
|
const HAL_BEACON_STATE *a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_setStationBeaconTimers(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_detectcardpresent(struct ath_hal *ah)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_detectCardPresent(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int ath_hal_getslottime(struct ath_hal *ah)
|
|
{
|
|
u_int ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getSlotTime(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_beaconinit(struct ath_hal *ah, u_int32_t nexttbtt,
|
|
u_int32_t intval)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_beaconInit(ah, nexttbtt, intval);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline void ath_hal_gpiosetintr(struct ath_hal *ah, u_int a1,
|
|
u_int32_t a2)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_gpioSetIntr(ah, a1, a2);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_releasetxqueue(struct ath_hal *ah, u_int q)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_releaseTxQueue(ah, q);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_keysetmac(struct ath_hal *ah, u_int16_t a1,
|
|
const u_int8_t *a2)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setKeyCacheEntryMac(ah, a1, a2);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_STATUS ath_hal_txprocdesc(struct ath_hal *ah,
|
|
struct ath_desc *a1, struct ath_tx_status *a2)
|
|
{
|
|
HAL_STATUS ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_procTxDesc(ah, a1, a2);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_INT ath_hal_intrget(struct ath_hal *ah)
|
|
{
|
|
HAL_INT ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getInterrupts(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setacktimeout(struct ath_hal *ah, u_int a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setAckTimeout(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setbssidmask(struct ath_hal *ah,
|
|
const u_int8_t *a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setBssIdMask(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setackctsrate(struct ath_hal *ah, u_int a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setAckCTSRate(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int32_t ath_hal_getrxfilter(struct ath_hal *ah)
|
|
{
|
|
u_int32_t ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getRxFilter(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline int16_t ath_hal_get_channel_noise(struct ath_hal *ah,
|
|
HAL_CHANNEL *a1)
|
|
{
|
|
int16_t ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getChanNoise(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_keyreset(struct ath_hal *ah, u_int16_t a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_resetKeyCacheEntry(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setantennaswitch(struct ath_hal *ah,
|
|
HAL_ANT_SETTING a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setAntennaSwitch(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_settxqueueprops(struct ath_hal *ah, int q,
|
|
const HAL_TXQ_INFO *qInfo)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setTxQueueProps(ah, q, qInfo);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_putrxbuf(struct ath_hal *ah, u_int32_t rxdp)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_setRxDP(ah, rxdp);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_reset(struct ath_hal *ah, HAL_OPMODE a1,
|
|
HAL_CHANNEL *a2, HAL_BOOL bChannelChange, HAL_STATUS *status)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_reset(ah, a1, a2, bChannelChange, status);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setdecompmask(struct ath_hal *ah, u_int16_t a1,
|
|
int a2)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setDecompMask(ah, a1, a2);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_gettxqueueprops(struct ath_hal *ah, int q,
|
|
HAL_TXQ_INFO *qInfo)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getTxQueueProps(ah, q, qInfo);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_filltxdesc(struct ath_hal *ah,
|
|
struct ath_desc *a1, u_int segLen, HAL_BOOL firstSeg,
|
|
HAL_BOOL lastSeg, const struct ath_desc *a5)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_fillTxDesc(ah, a1, segLen, firstSeg, lastSeg, a5);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int32_t ath_hal_numtxpending(struct ath_hal *ah, u_int q)
|
|
{
|
|
u_int32_t ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_numTxPending(ah, q);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_startpcurecv(struct ath_hal *ah)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_startPcuReceive(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline void ath_hal_setdefantenna(struct ath_hal *ah, u_int a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_setDefAntenna(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setpower(struct ath_hal *ah,
|
|
HAL_POWER_MODE mode, int setChip)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setPowerMode(ah, mode, setChip);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_STATUS ath_hal_rxprocdesc(struct ath_hal *ah,
|
|
struct ath_desc *a1, u_int32_t phyAddr, struct ath_desc *next,
|
|
u_int64_t tsf, struct ath_rx_status *a5)
|
|
{
|
|
HAL_STATUS ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_procRxDesc(ah, a1, phyAddr, next, tsf, a5);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int ath_hal_getackctsrate(struct ath_hal *ah)
|
|
{
|
|
u_int ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getAckCTSRate(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int32_t ath_hal_keycachesize(struct ath_hal *ah)
|
|
{
|
|
u_int32_t ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getKeyCacheSize(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setupxtxdesc(struct ath_hal *ah,
|
|
struct ath_desc *a1, u_int txRate1, u_int txTries1,
|
|
u_int txRate2, u_int txTries2, u_int txRate3, u_int txTries3)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setupXTxDesc(ah, a1, txRate1, txTries1, txRate2, txTries2,
|
|
txRate3, txTries3);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_INT ath_hal_intrset(struct ath_hal *ah, HAL_INT a1)
|
|
{
|
|
HAL_INT ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setInterrupts(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int ath_hal_getctstimeout(struct ath_hal *ah)
|
|
{
|
|
u_int ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getCTSTimeout(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_updatemibcounters(struct ath_hal *ah,
|
|
HAL_MIB_STATS *a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_updateMibCounters(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_calibrate(struct ath_hal *ah, HAL_CHANNEL *a1,
|
|
HAL_BOOL *a2)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_perCalibration(ah, a1, a2);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int32_t ath_hal_getrxbuf(struct ath_hal *ah)
|
|
{
|
|
u_int32_t ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getRxDP(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_settxpowlimit(struct ath_hal *ah, u_int32_t a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setTxPowerLimit(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_getisr(struct ath_hal *ah, HAL_INT *a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getPendingInterrupts(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_updatetxtriglevel(struct ath_hal *ah,
|
|
HAL_BOOL incTrigLevel)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_updateTxTrigLevel(ah, incTrigLevel);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_resettxqueue(struct ath_hal *ah, u_int q)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_resetTxQueue(ah, q);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setmac(struct ath_hal *ah, const u_int8_t *a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setMacAddress(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setctstimeout(struct ath_hal *ah, u_int a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setCTSTimeout(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline const HAL_RATE_TABLE *ath_hal_getratetable(struct ath_hal *ah,
|
|
u_int mode)
|
|
{
|
|
const HAL_RATE_TABLE *ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getRateTable(ah, mode);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int32_t ath_hal_gettsf32(struct ath_hal *ah)
|
|
{
|
|
u_int32_t ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getTsf32(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_mibevent(struct ath_hal *ah,
|
|
const HAL_NODE_STATS *a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_procMibEvent(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline void ath_hal_setbeacontimers(struct ath_hal *ah,
|
|
const HAL_BEACON_TIMERS *a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_setBeaconTimers(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_STATUS ath_hal_getcapability(struct ath_hal *ah,
|
|
HAL_CAPABILITY_TYPE a1, u_int32_t capability,
|
|
u_int32_t *result)
|
|
{
|
|
HAL_STATUS ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getCapability(ah, a1, capability, result);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_radar_wait(struct ath_hal *ah, HAL_CHANNEL *a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_radarWait(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setmcastfilterindex(struct ath_hal *ah,
|
|
u_int32_t index)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setMulticastFilterIndex(ah, index);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_getbssidmask(struct ath_hal *ah, u_int8_t *a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_getBssIdMask(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_intrpend(struct ath_hal *ah)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_isInterruptPending(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_txstart(struct ath_hal *ah, u_int a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_startTxDma(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_gettxintrtxqs(struct ath_hal *ah, u_int32_t *a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_getTxIntrQueue(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setslottime(struct ath_hal *ah, u_int a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setSlotTime(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_setledstate(struct ath_hal *ah, HAL_LED_STATE a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_setLedState(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline void ath_hal_setassocid(struct ath_hal *ah,
|
|
const u_int8_t *bssid, u_int16_t assocId)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_writeAssocid(ah, bssid, assocId);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline void ath_hal_resettsf(struct ath_hal *ah)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_resetTsf(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setuprxdesc(struct ath_hal *ah,
|
|
struct ath_desc *a1, u_int32_t size, u_int flags)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setupRxDesc(ah, a1, size, flags);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_setrxfilter(struct ath_hal *ah, u_int32_t a1)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_setRxFilter(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_keyisvalid(struct ath_hal *ah, u_int16_t a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_isKeyCacheEntryValid(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline void ath_hal_stoppcurecv(struct ath_hal *ah)
|
|
{
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ah->ah_stopPcuReceive(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_stoptxdma(struct ath_hal *ah, u_int a1)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_stopTxDma(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setcapability(struct ath_hal *ah,
|
|
HAL_CAPABILITY_TYPE a1, u_int32_t capability,
|
|
u_int32_t setting, HAL_STATUS *a4)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setCapability(ah, a1, capability, setting, a4);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_stopdmarecv(struct ath_hal *ah)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_stopDmaReceive(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int32_t ath_hal_gettxbuf(struct ath_hal *ah, u_int a1)
|
|
{
|
|
u_int32_t ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getTxDP(ah, a1);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline int ath_hal_setuptxqueue(struct ath_hal *ah, HAL_TX_QUEUE a1,
|
|
const HAL_TXQ_INFO *qInfo)
|
|
{
|
|
int ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setupTxQueue(ah, a1, qInfo);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int ath_hal_getdefantenna(struct ath_hal *ah)
|
|
{
|
|
u_int ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_getDefAntenna(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_phydisable(struct ath_hal *ah)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_phyDisable(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setregulatorydomain(struct ath_hal *ah,
|
|
u_int16_t a1, HAL_STATUS *a2)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setRegulatoryDomain(ah, a1, a2);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_setuptxdesc(struct ath_hal *ah,
|
|
struct ath_desc *a1, u_int pktLen, u_int hdrLen,
|
|
HAL_PKT_TYPE type, u_int txPower, u_int txRate0,
|
|
u_int txTries0, u_int keyIx, u_int antMode, u_int flags,
|
|
u_int rtsctsRate, u_int rtsctsDuration, u_int compicvLen,
|
|
u_int compivLen, u_int comp)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_setupTxDesc(ah, a1, pktLen, hdrLen, type, txPower,
|
|
txRate0, txTries0, keyIx, antMode, flags, rtsctsRate,
|
|
rtsctsDuration, compicvLen, compivLen, comp);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_gpiCfgInput(struct ath_hal *ah, u_int32_t gpio)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_gpioCfgInput(ah, gpio);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline u_int32_t ath_hal_gpioget(struct ath_hal *ah, u_int32_t gpio)
|
|
{
|
|
u_int32_t ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_gpioGet(ah, gpio);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
static inline HAL_BOOL ath_hal_disable(struct ath_hal *ah)
|
|
{
|
|
HAL_BOOL ret;
|
|
ATH_HAL_LOCK_IRQ(ah->ah_sc);
|
|
ath_hal_set_function(__func__);
|
|
ret = ah->ah_disable(ah);
|
|
ath_hal_set_function(NULL);
|
|
ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
|
|
return ret;
|
|
}
|
|
|
|
#include "if_ath_hal_wrappers.h"
|
|
|
|
#endif /* #ifndef _IF_ATH_HAL_H_ */
|
|
/* *** THIS IS A GENERATED FILE -- DO NOT EDIT *** */
|
|
/* *** THIS IS A GENERATED FILE -- DO NOT EDIT *** */
|
|
/* *** THIS IS A GENERATED FILE -- DO NOT EDIT *** */
|