drivers/net/wireless/madwifi/ath/if_ath_hal.h

   1 /*-
   2  * Copyright (c) 2007 Michael Taylor
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10         without modification.
  11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  12  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  13  *    redistribution must be conditioned upon including a substantially
  14  *    similar Disclaimer requirement for further binary redistribution.
  15  * 3. Neither the names of the above-listed copyright holders nor the names
  16  *    of any contributors may be used to endorse or promote products derived
  17  *    from this software without specific prior written permission.
  18  *
  19  * Alternatively, this software may be distributed under the terms of the
  20  * GNU General Public License ("GPL") version 2 as published by the Free
  21  * Software Foundation.
  22  *
  23  * NO WARRANTY
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  27  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  28  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  29  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  32  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  34  * THE POSSIBILITY OF SUCH DAMAGES.
  35  */
  36 /* **************************************************************
  37  * *   WARNING: THIS IS A GENERATED FILE.  PLEASE DO NOT EDIT   *
  38  * ************************************************************** */
  39
  40 #include "if_ath_hal_macros.h"
  41 #ifdef CONFIG_KALLSYMS
  42 #include "linux/kallsyms.h"
  43 #endif                          /* CONFIG_KALLSYMS */
  44
  45 #ifndef _IF_ATH_HAL_H_
  46 #define _IF_ATH_HAL_H_
  47
  48 static inline void ath_hal_getmac(struct ath_hal *ah, u_int8_t *a1)
  49 {
  50         ATH_HAL_LOCK_IRQ(ah->ah_sc);
  51         ath_hal_set_function(__func__);
  52         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
  53         ah->ah_getMacAddress(ah, a1);
  54         ath_hal_set_function(NULL);
  55         ath_hal_set_device(NULL);
  56         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
  57 }
  58
  59 static inline HAL_POWER_MODE ath_hal_getPowerMode(struct ath_hal *ah)
  60 {
  61         HAL_POWER_MODE ret;
  62         ATH_HAL_LOCK_IRQ(ah->ah_sc);
  63         ath_hal_set_function(__func__);
  64         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
  65         ret = ah->ah_getPowerMode(ah);
  66         ath_hal_set_function(NULL);
  67         ath_hal_set_device(NULL);
  68         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
  69         return ret;
  70 }
  71
  72 static inline HAL_BOOL ath_hal_getdiagstate(struct ath_hal *ah, int request,
  73                                             const void *args, u_int32_t argsize,
  74                                             void **result,
  75                                             u_int32_t *resultsize)
  76 {
  77         HAL_BOOL ret;
  78         ATH_HAL_LOCK_IRQ(ah->ah_sc);
  79         ath_hal_set_function(__func__);
  80         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
  81         ret =
  82             ah->ah_getDiagState(ah, request, args, argsize, *result,
  83                                 resultsize);
  84         ath_hal_set_function(NULL);
  85         ath_hal_set_device(NULL);
  86         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
  87         return ret;
  88 }
  89
  90 static inline void ath_hal_beaconreset(struct ath_hal *ah)
  91 {
  92         ATH_HAL_LOCK_IRQ(ah->ah_sc);
  93         ath_hal_set_function(__func__);
  94         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
  95         ah->ah_resetStationBeaconTimers(ah);
  96         ath_hal_set_function(NULL);
  97         ath_hal_set_device(NULL);
  98         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
  99 }
 100
 101 static inline void ath_hal_setcoverageclass(struct ath_hal *ah, u_int8_t a1,
 102                                             int a2)
 103 {
 104         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 105         ath_hal_set_function(__func__);
 106         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 107         ah->ah_setCoverageClass(ah, a1, a2);
 108         ath_hal_set_function(NULL);
 109         ath_hal_set_device(NULL);
 110         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 111 }
 112
 113 static inline u_int64_t ath_hal_gettsf64(struct ath_hal *ah)
 114 {
 115         u_int64_t ret;
 116         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 117         ath_hal_set_function(__func__);
 118         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 119         ret = ah->ah_getTsf64(ah);
 120         ath_hal_set_function(NULL);
 121         ath_hal_set_device(NULL);
 122         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 123         return ret;
 124 }
 125
 126 static inline void ath_hal_rxena(struct ath_hal *ah)
 127 {
 128         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 129         ath_hal_set_function(__func__);
 130         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 131         ah->ah_enableReceive(ah);
 132         ath_hal_set_function(NULL);
 133         ath_hal_set_device(NULL);
 134         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 135 }
 136
 137 static inline HAL_ANT_SETTING ath_hal_getantennaswitch(struct ath_hal *ah)
 138 {
 139         HAL_ANT_SETTING ret;
 140         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 141         ath_hal_set_function(__func__);
 142         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 143         ret = ah->ah_getAntennaSwitch(ah);
 144         ath_hal_set_function(NULL);
 145         ath_hal_set_device(NULL);
 146         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 147         return ret;
 148 }
 149
 150 static inline HAL_BOOL ath_hal_gpioset(struct ath_hal *ah, u_int32_t gpio,
 151                                        u_int32_t val)
 152 {
 153         HAL_BOOL ret;
 154         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 155         ath_hal_set_function(__func__);
 156         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 157         ret = ah->ah_gpioSet(ah, gpio, val);
 158         ath_hal_set_function(NULL);
 159         ath_hal_set_device(NULL);
 160         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 161         return ret;
 162 }
 163
 164 static inline HAL_BOOL ath_hal_gpioCfgOutput(struct ath_hal *ah, u_int32_t gpio)
 165 {
 166         HAL_BOOL ret;
 167         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 168         ath_hal_set_function(__func__);
 169         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 170         ret = ah->ah_gpioCfgOutput(ah, gpio);
 171         ath_hal_set_function(NULL);
 172         ath_hal_set_device(NULL);
 173         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 174         return ret;
 175 }
 176
 177 static inline HAL_BOOL ath_hal_clearmcastfilter(struct ath_hal *ah,
 178                                                 u_int32_t index)
 179 {
 180         HAL_BOOL ret;
 181         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 182         ath_hal_set_function(__func__);
 183         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 184         ret = ah->ah_clrMulticastFilterIndex(ah, index);
 185         ath_hal_set_function(NULL);
 186         ath_hal_set_device(NULL);
 187         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 188         return ret;
 189 }
 190
 191 static inline void ath_hal_txreqintrdesc(struct ath_hal *ah,
 192                                          struct ath_desc *a1)
 193 {
 194         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 195         ath_hal_set_function(__func__);
 196         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 197         ah->ah_reqTxIntrDesc(ah, a1);
 198         ath_hal_set_function(NULL);
 199         ath_hal_set_device(NULL);
 200         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 201 }
 202
 203 static inline void ath_hal_rxmonitor(struct ath_hal *ah,
 204                                      const HAL_NODE_STATS *a1, HAL_CHANNEL *a2)
 205 {
 206         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 207         ath_hal_set_function(__func__);
 208         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 209         ah->ah_rxMonitor(ah, a1, a2);
 210         ath_hal_set_function(NULL);
 211         ath_hal_set_device(NULL);
 212         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 213 }
 214
 215 static inline HAL_BOOL ath_hal_puttxbuf(struct ath_hal *ah, u_int a1,
 216                                         u_int32_t txdp)
 217 {
 218         HAL_BOOL ret;
 219         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 220         ath_hal_set_function(__func__);
 221         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 222         ret = ah->ah_setTxDP(ah, a1, txdp);
 223         ath_hal_set_function(NULL);
 224         ath_hal_set_device(NULL);
 225         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 226         return ret;
 227 }
 228
 229 static inline HAL_BOOL ath_hal_keyset(struct ath_hal *ah, u_int16_t a1,
 230                                       const HAL_KEYVAL *a2, const u_int8_t *a3,
 231                                       int a4)
 232 {
 233         HAL_BOOL ret;
 234         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 235         ath_hal_set_function(__func__);
 236         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 237         ret = ah->ah_setKeyCacheEntry(ah, a1, a2, a3, a4);
 238         ath_hal_set_function(NULL);
 239         ath_hal_set_device(NULL);
 240         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 241         return ret;
 242 }
 243
 244 static inline void ath_hal_setopmode(struct ath_hal *ah)
 245 {
 246         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 247         ath_hal_set_function(__func__);
 248         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 249         ah->ah_setPCUConfig(ah);
 250         ath_hal_set_function(NULL);
 251         ath_hal_set_device(NULL);
 252         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 253 }
 254
 255 static inline HAL_RFGAIN ath_hal_getrfgain(struct ath_hal *ah)
 256 {
 257         HAL_RFGAIN ret;
 258         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 259         ath_hal_set_function(__func__);
 260         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 261         ret = ah->ah_getRfGain(ah);
 262         ath_hal_set_function(NULL);
 263         ath_hal_set_device(NULL);
 264         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 265         return ret;
 266 }
 267
 268 static inline void ath_hal_setmcastfilter(struct ath_hal *ah, u_int32_t filter0,
 269                                           u_int32_t filter1)
 270 {
 271         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 272         ath_hal_set_function(__func__);
 273         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 274         ah->ah_setMulticastFilter(ah, filter0, filter1);
 275         ath_hal_set_function(NULL);
 276         ath_hal_set_device(NULL);
 277         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 278 }
 279
 280 static inline u_int ath_hal_getacktimeout(struct ath_hal *ah)
 281 {
 282         u_int ret;
 283         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 284         ath_hal_set_function(__func__);
 285         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 286         ret = ah->ah_getAckTimeout(ah);
 287         ath_hal_set_function(NULL);
 288         ath_hal_set_device(NULL);
 289         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 290         return ret;
 291 }
 292
 293 static inline void ath_hal_beacontimers(struct ath_hal *ah,
 294                                         const HAL_BEACON_STATE *a1)
 295 {
 296         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 297         ath_hal_set_function(__func__);
 298         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 299         ah->ah_setStationBeaconTimers(ah, a1);
 300         ath_hal_set_function(NULL);
 301         ath_hal_set_device(NULL);
 302         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 303 }
 304
 305 static inline HAL_BOOL ath_hal_detectcardpresent(struct ath_hal *ah)
 306 {
 307         HAL_BOOL ret;
 308         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 309         ath_hal_set_function(__func__);
 310         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 311         ret = ah->ah_detectCardPresent(ah);
 312         ath_hal_set_function(NULL);
 313         ath_hal_set_device(NULL);
 314         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 315         return ret;
 316 }
 317
 318 static inline u_int ath_hal_getslottime(struct ath_hal *ah)
 319 {
 320         u_int ret;
 321         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 322         ath_hal_set_function(__func__);
 323         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 324         ret = ah->ah_getSlotTime(ah);
 325         ath_hal_set_function(NULL);
 326         ath_hal_set_device(NULL);
 327         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 328         return ret;
 329 }
 330
 331 static inline void ath_hal_beaconinit(struct ath_hal *ah, u_int32_t nexttbtt,
 332                                       u_int32_t intval)
 333 {
 334         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 335         ath_hal_set_function(__func__);
 336         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 337         ah->ah_beaconInit(ah, nexttbtt, intval);
 338         ath_hal_set_function(NULL);
 339         ath_hal_set_device(NULL);
 340         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 341 }
 342
 343 static inline void ath_hal_gpiosetintr(struct ath_hal *ah, u_int a1,
 344                                        u_int32_t a2)
 345 {
 346         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 347         ath_hal_set_function(__func__);
 348         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 349         ah->ah_gpioSetIntr(ah, a1, a2);
 350         ath_hal_set_function(NULL);
 351         ath_hal_set_device(NULL);
 352         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 353 }
 354
 355 static inline HAL_BOOL ath_hal_releasetxqueue(struct ath_hal *ah, u_int q)
 356 {
 357         HAL_BOOL ret;
 358         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 359         ath_hal_set_function(__func__);
 360         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 361         ret = ah->ah_releaseTxQueue(ah, q);
 362         ath_hal_set_function(NULL);
 363         ath_hal_set_device(NULL);
 364         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 365         return ret;
 366 }
 367
 368 static inline HAL_BOOL ath_hal_keysetmac(struct ath_hal *ah, u_int16_t a1,
 369                                          const u_int8_t *a2)
 370 {
 371         HAL_BOOL ret;
 372         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 373         ath_hal_set_function(__func__);
 374         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 375         ret = ah->ah_setKeyCacheEntryMac(ah, a1, a2);
 376         ath_hal_set_function(NULL);
 377         ath_hal_set_device(NULL);
 378         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 379         return ret;
 380 }
 381
 382 static inline HAL_STATUS ath_hal_txprocdesc(struct ath_hal *ah,
 383                                             struct ath_desc *a1,
 384                                             struct ath_tx_status *a2)
 385 {
 386         HAL_STATUS ret;
 387         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 388         ath_hal_set_function(__func__);
 389         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 390         ret = ah->ah_procTxDesc(ah, a1, a2);
 391         ath_hal_set_function(NULL);
 392         ath_hal_set_device(NULL);
 393         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 394         return ret;
 395 }
 396
 397 static inline HAL_INT ath_hal_intrget(struct ath_hal *ah)
 398 {
 399         HAL_INT ret;
 400         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 401         ath_hal_set_function(__func__);
 402         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 403         ret = ah->ah_getInterrupts(ah);
 404         ath_hal_set_function(NULL);
 405         ath_hal_set_device(NULL);
 406         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 407         return ret;
 408 }
 409
 410 static inline HAL_BOOL ath_hal_setacktimeout(struct ath_hal *ah, u_int a1)
 411 {
 412         HAL_BOOL ret;
 413         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 414         ath_hal_set_function(__func__);
 415         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 416         ret = ah->ah_setAckTimeout(ah, a1);
 417         ath_hal_set_function(NULL);
 418         ath_hal_set_device(NULL);
 419         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 420         return ret;
 421 }
 422
 423 static inline HAL_BOOL ath_hal_setbssidmask(struct ath_hal *ah,
 424                                             const u_int8_t *a1)
 425 {
 426         HAL_BOOL ret;
 427         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 428         ath_hal_set_function(__func__);
 429         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 430         ret = ah->ah_setBssIdMask(ah, a1);
 431         ath_hal_set_function(NULL);
 432         ath_hal_set_device(NULL);
 433         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 434         return ret;
 435 }
 436
 437 static inline HAL_BOOL ath_hal_setackctsrate(struct ath_hal *ah, u_int a1)
 438 {
 439         HAL_BOOL ret;
 440         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 441         ath_hal_set_function(__func__);
 442         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 443         ret = ah->ah_setAckCTSRate(ah, a1);
 444         ath_hal_set_function(NULL);
 445         ath_hal_set_device(NULL);
 446         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 447         return ret;
 448 }
 449
 450 static inline u_int32_t ath_hal_getrxfilter(struct ath_hal *ah)
 451 {
 452         u_int32_t ret;
 453         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 454         ath_hal_set_function(__func__);
 455         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 456         ret = ah->ah_getRxFilter(ah);
 457         ath_hal_set_function(NULL);
 458         ath_hal_set_device(NULL);
 459         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 460         return ret;
 461 }
 462
 463 static inline int16_t ath_hal_get_channel_noise(struct ath_hal *ah,
 464                                                 HAL_CHANNEL *a1)
 465 {
 466         int16_t ret;
 467         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 468         ath_hal_set_function(__func__);
 469         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 470         ret = ah->ah_getChanNoise(ah, a1);
 471         ath_hal_set_function(NULL);
 472         ath_hal_set_device(NULL);
 473         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 474         return ret;
 475 }
 476
 477 static inline HAL_BOOL ath_hal_keyreset(struct ath_hal *ah, u_int16_t a1)
 478 {
 479         HAL_BOOL ret;
 480         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 481         ath_hal_set_function(__func__);
 482         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 483         ret = ah->ah_resetKeyCacheEntry(ah, a1);
 484         ath_hal_set_function(NULL);
 485         ath_hal_set_device(NULL);
 486         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 487         return ret;
 488 }
 489
 490 static inline HAL_BOOL ath_hal_setantennaswitch(struct ath_hal *ah,
 491                                                 HAL_ANT_SETTING a1)
 492 {
 493         HAL_BOOL ret;
 494         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 495         ath_hal_set_function(__func__);
 496         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 497         ret = ah->ah_setAntennaSwitch(ah, a1);
 498         ath_hal_set_function(NULL);
 499         ath_hal_set_device(NULL);
 500         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 501         return ret;
 502 }
 503
 504 static inline HAL_BOOL ath_hal_settxqueueprops(struct ath_hal *ah, int q,
 505                                                const HAL_TXQ_INFO *qInfo)
 506 {
 507         HAL_BOOL ret;
 508         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 509         ath_hal_set_function(__func__);
 510         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 511         ret = ah->ah_setTxQueueProps(ah, q, qInfo);
 512         ath_hal_set_function(NULL);
 513         ath_hal_set_device(NULL);
 514         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 515         return ret;
 516 }
 517
 518 static inline void ath_hal_putrxbuf(struct ath_hal *ah, u_int32_t rxdp)
 519 {
 520         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 521         ath_hal_set_function(__func__);
 522         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 523         ah->ah_setRxDP(ah, rxdp);
 524         ath_hal_set_function(NULL);
 525         ath_hal_set_device(NULL);
 526         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 527 }
 528
 529 static inline HAL_BOOL ath_hal_reset(struct ath_hal *ah, HAL_OPMODE a1,
 530                                      HAL_CHANNEL *a2, HAL_BOOL bChannelChange,
 531                                      HAL_STATUS *status)
 532 {
 533         HAL_BOOL ret;
 534         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 535         ath_hal_set_function(__func__);
 536         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 537         ret = ah->ah_reset(ah, a1, a2, bChannelChange, status);
 538         ath_hal_set_function(NULL);
 539         ath_hal_set_device(NULL);
 540         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 541         return ret;
 542 }
 543
 544 static inline HAL_BOOL ath_hal_setdecompmask(struct ath_hal *ah, u_int16_t a1,
 545                                              int a2)
 546 {
 547         HAL_BOOL ret;
 548         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 549         ath_hal_set_function(__func__);
 550         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 551         ret = ah->ah_setDecompMask(ah, a1, a2);
 552         ath_hal_set_function(NULL);
 553         ath_hal_set_device(NULL);
 554         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 555         return ret;
 556 }
 557
 558 static inline HAL_BOOL ath_hal_gettxqueueprops(struct ath_hal *ah, int q,
 559                                                HAL_TXQ_INFO *qInfo)
 560 {
 561         HAL_BOOL ret;
 562         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 563         ath_hal_set_function(__func__);
 564         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 565         ret = ah->ah_getTxQueueProps(ah, q, qInfo);
 566         ath_hal_set_function(NULL);
 567         ath_hal_set_device(NULL);
 568         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 569         return ret;
 570 }
 571
 572 static inline HAL_BOOL ath_hal_filltxdesc(struct ath_hal *ah,
 573                                           struct ath_desc *a1, u_int segLen,
 574                                           HAL_BOOL firstSeg, HAL_BOOL lastSeg,
 575                                           const struct ath_desc *a5)
 576 {
 577         HAL_BOOL ret;
 578         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 579         ath_hal_set_function(__func__);
 580         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 581         ret = ah->ah_fillTxDesc(ah, a1, segLen, firstSeg, lastSeg, a5);
 582         ath_hal_set_function(NULL);
 583         ath_hal_set_device(NULL);
 584         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 585         return ret;
 586 }
 587
 588 static inline u_int32_t ath_hal_numtxpending(struct ath_hal *ah, u_int q)
 589 {
 590         u_int32_t ret;
 591         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 592         ath_hal_set_function(__func__);
 593         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 594         ret = ah->ah_numTxPending(ah, q);
 595         ath_hal_set_function(NULL);
 596         ath_hal_set_device(NULL);
 597         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 598         return ret;
 599 }
 600
 601 static inline void ath_hal_startpcurecv(struct ath_hal *ah)
 602 {
 603         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 604         ath_hal_set_function(__func__);
 605         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 606         ah->ah_startPcuReceive(ah);
 607         ath_hal_set_function(NULL);
 608         ath_hal_set_device(NULL);
 609         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 610 }
 611
 612 static inline void ath_hal_setdefantenna(struct ath_hal *ah, u_int a1)
 613 {
 614         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 615         ath_hal_set_function(__func__);
 616         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 617         ah->ah_setDefAntenna(ah, a1);
 618         ath_hal_set_function(NULL);
 619         ath_hal_set_device(NULL);
 620         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 621 }
 622
 623 static inline HAL_BOOL ath_hal_setpower(struct ath_hal *ah, HAL_POWER_MODE mode,
 624                                         int setChip)
 625 {
 626         HAL_BOOL ret;
 627         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 628         ath_hal_set_function(__func__);
 629         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 630         ret = ah->ah_setPowerMode(ah, mode, setChip);
 631         ath_hal_set_function(NULL);
 632         ath_hal_set_device(NULL);
 633         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 634         return ret;
 635 }
 636
 637 static inline HAL_STATUS ath_hal_rxprocdesc(struct ath_hal *ah,
 638                                             struct ath_desc *a1,
 639                                             u_int32_t phyAddr,
 640                                             struct ath_desc *next,
 641                                             u_int64_t tsf,
 642                                             struct ath_rx_status *a5)
 643 {
 644         HAL_STATUS ret;
 645         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 646         ath_hal_set_function(__func__);
 647         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 648         ret = ah->ah_procRxDesc(ah, a1, phyAddr, next, tsf, a5);
 649         ath_hal_set_function(NULL);
 650         ath_hal_set_device(NULL);
 651         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 652         return ret;
 653 }
 654
 655 static inline u_int ath_hal_getackctsrate(struct ath_hal *ah)
 656 {
 657         u_int ret;
 658         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 659         ath_hal_set_function(__func__);
 660         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 661         ret = ah->ah_getAckCTSRate(ah);
 662         ath_hal_set_function(NULL);
 663         ath_hal_set_device(NULL);
 664         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 665         return ret;
 666 }
 667
 668 static inline u_int32_t ath_hal_keycachesize(struct ath_hal *ah)
 669 {
 670         u_int32_t ret;
 671         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 672         ath_hal_set_function(__func__);
 673         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 674         ret = ah->ah_getKeyCacheSize(ah);
 675         ath_hal_set_function(NULL);
 676         ath_hal_set_device(NULL);
 677         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 678         return ret;
 679 }
 680
 681 static inline HAL_BOOL ath_hal_setupxtxdesc(struct ath_hal *ah,
 682                                             struct ath_desc *a1, u_int txRate1,
 683                                             u_int txTries1, u_int txRate2,
 684                                             u_int txTries2, u_int txRate3,
 685                                             u_int txTries3)
 686 {
 687         HAL_BOOL ret;
 688         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 689         ath_hal_set_function(__func__);
 690         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 691         ret =
 692             ah->ah_setupXTxDesc(ah, a1, txRate1, txTries1, txRate2, txTries2,
 693                                 txRate3, txTries3);
 694         ath_hal_set_function(NULL);
 695         ath_hal_set_device(NULL);
 696         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 697         return ret;
 698 }
 699
 700 static inline HAL_INT ath_hal_intrset(struct ath_hal *ah, HAL_INT a1)
 701 {
 702         HAL_INT ret;
 703         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 704         ath_hal_set_function(__func__);
 705         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 706         ret = ah->ah_setInterrupts(ah, a1);
 707         ath_hal_set_function(NULL);
 708         ath_hal_set_device(NULL);
 709         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 710         return ret;
 711 }
 712
 713 static inline u_int ath_hal_getctstimeout(struct ath_hal *ah)
 714 {
 715         u_int ret;
 716         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 717         ath_hal_set_function(__func__);
 718         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 719         ret = ah->ah_getCTSTimeout(ah);
 720         ath_hal_set_function(NULL);
 721         ath_hal_set_device(NULL);
 722         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 723         return ret;
 724 }
 725
 726 static inline void ath_hal_updatemibcounters(struct ath_hal *ah,
 727                                              HAL_MIB_STATS *a1)
 728 {
 729         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 730         ath_hal_set_function(__func__);
 731         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 732         ah->ah_updateMibCounters(ah, a1);
 733         ath_hal_set_function(NULL);
 734         ath_hal_set_device(NULL);
 735         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 736 }
 737
 738 static inline HAL_BOOL ath_hal_calibrate(struct ath_hal *ah, HAL_CHANNEL *a1,
 739                                          HAL_BOOL *a2)
 740 {
 741         HAL_BOOL ret;
 742         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 743         ath_hal_set_function(__func__);
 744         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 745         ret = ah->ah_perCalibration(ah, a1, a2);
 746         ath_hal_set_function(NULL);
 747         ath_hal_set_device(NULL);
 748         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 749         return ret;
 750 }
 751
 752 static inline u_int32_t ath_hal_getrxbuf(struct ath_hal *ah)
 753 {
 754         u_int32_t ret;
 755         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 756         ath_hal_set_function(__func__);
 757         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 758         ret = ah->ah_getRxDP(ah);
 759         ath_hal_set_function(NULL);
 760         ath_hal_set_device(NULL);
 761         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 762         return ret;
 763 }
 764
 765 static inline HAL_BOOL ath_hal_settxpowlimit(struct ath_hal *ah, u_int32_t a1)
 766 {
 767         HAL_BOOL ret;
 768         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 769         ath_hal_set_function(__func__);
 770         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 771         ret = ah->ah_setTxPowerLimit(ah, a1);
 772         ath_hal_set_function(NULL);
 773         ath_hal_set_device(NULL);
 774         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 775         return ret;
 776 }
 777
 778 static inline HAL_BOOL ath_hal_getisr(struct ath_hal *ah, HAL_INT *a1)
 779 {
 780         HAL_BOOL ret;
 781         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 782         ath_hal_set_function(__func__);
 783         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 784         ret = ah->ah_getPendingInterrupts(ah, a1);
 785         ath_hal_set_function(NULL);
 786         ath_hal_set_device(NULL);
 787         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 788         return ret;
 789 }
 790
 791 static inline HAL_BOOL ath_hal_updatetxtriglevel(struct ath_hal *ah,
 792                                                  HAL_BOOL incTrigLevel)
 793 {
 794         HAL_BOOL ret;
 795         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 796         ath_hal_set_function(__func__);
 797         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 798         ret = ah->ah_updateTxTrigLevel(ah, incTrigLevel);
 799         ath_hal_set_function(NULL);
 800         ath_hal_set_device(NULL);
 801         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 802         return ret;
 803 }
 804
 805 static inline HAL_BOOL ath_hal_resettxqueue(struct ath_hal *ah, u_int q)
 806 {
 807         HAL_BOOL ret;
 808         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 809         ath_hal_set_function(__func__);
 810         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 811         ret = ah->ah_resetTxQueue(ah, q);
 812         ath_hal_set_function(NULL);
 813         ath_hal_set_device(NULL);
 814         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 815         return ret;
 816 }
 817
 818 static inline HAL_BOOL ath_hal_setmac(struct ath_hal *ah, const u_int8_t *a1)
 819 {
 820         HAL_BOOL ret;
 821         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 822         ath_hal_set_function(__func__);
 823         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 824         ret = ah->ah_setMacAddress(ah, a1);
 825         ath_hal_set_function(NULL);
 826         ath_hal_set_device(NULL);
 827         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 828         return ret;
 829 }
 830
 831 static inline HAL_BOOL ath_hal_setctstimeout(struct ath_hal *ah, u_int a1)
 832 {
 833         HAL_BOOL ret;
 834         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 835         ath_hal_set_function(__func__);
 836         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 837         ret = ah->ah_setCTSTimeout(ah, a1);
 838         ath_hal_set_function(NULL);
 839         ath_hal_set_device(NULL);
 840         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 841         return ret;
 842 }
 843
 844 static inline const HAL_RATE_TABLE *ath_hal_getratetable(struct ath_hal *ah,
 845                                                          u_int mode)
 846 {
 847         const HAL_RATE_TABLE *ret;
 848         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 849         ath_hal_set_function(__func__);
 850         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 851         ret = ah->ah_getRateTable(ah, mode);
 852         ath_hal_set_function(NULL);
 853         ath_hal_set_device(NULL);
 854         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 855         return ret;
 856 }
 857
 858 static inline u_int32_t ath_hal_gettsf32(struct ath_hal *ah)
 859 {
 860         u_int32_t ret;
 861         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 862         ath_hal_set_function(__func__);
 863         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 864         ret = ah->ah_getTsf32(ah);
 865         ath_hal_set_function(NULL);
 866         ath_hal_set_device(NULL);
 867         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 868         return ret;
 869 }
 870
 871 static inline void ath_hal_mibevent(struct ath_hal *ah,
 872                                     const HAL_NODE_STATS *a1)
 873 {
 874         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 875         ath_hal_set_function(__func__);
 876         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 877         ah->ah_procMibEvent(ah, a1);
 878         ath_hal_set_function(NULL);
 879         ath_hal_set_device(NULL);
 880         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 881 }
 882
 883 static inline void ath_hal_setbeacontimers(struct ath_hal *ah,
 884                                            const HAL_BEACON_TIMERS *a1)
 885 {
 886         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 887         ath_hal_set_function(__func__);
 888         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 889         ah->ah_setBeaconTimers(ah, a1);
 890         ath_hal_set_function(NULL);
 891         ath_hal_set_device(NULL);
 892         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 893 }
 894
 895 static inline HAL_STATUS ath_hal_getcapability(struct ath_hal *ah,
 896                                                HAL_CAPABILITY_TYPE a1,
 897                                                u_int32_t capability,
 898                                                u_int32_t *result)
 899 {
 900         HAL_STATUS ret;
 901         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 902         ath_hal_set_function(__func__);
 903         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 904         ret = ah->ah_getCapability(ah, a1, capability, result);
 905         ath_hal_set_function(NULL);
 906         ath_hal_set_device(NULL);
 907         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 908         return ret;
 909 }
 910
 911 static inline HAL_BOOL ath_hal_radar_wait(struct ath_hal *ah, HAL_CHANNEL *a1)
 912 {
 913         HAL_BOOL ret;
 914         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 915         ath_hal_set_function(__func__);
 916         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 917         ret = ah->ah_radarWait(ah, a1);
 918         ath_hal_set_function(NULL);
 919         ath_hal_set_device(NULL);
 920         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 921         return ret;
 922 }
 923
 924 static inline HAL_BOOL ath_hal_setmcastfilterindex(struct ath_hal *ah,
 925                                                    u_int32_t index)
 926 {
 927         HAL_BOOL ret;
 928         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 929         ath_hal_set_function(__func__);
 930         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 931         ret = ah->ah_setMulticastFilterIndex(ah, index);
 932         ath_hal_set_function(NULL);
 933         ath_hal_set_device(NULL);
 934         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 935         return ret;
 936 }
 937
 938 static inline void ath_hal_getbssidmask(struct ath_hal *ah, u_int8_t *a1)
 939 {
 940         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 941         ath_hal_set_function(__func__);
 942         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 943         ah->ah_getBssIdMask(ah, a1);
 944         ath_hal_set_function(NULL);
 945         ath_hal_set_device(NULL);
 946         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 947 }
 948
 949 static inline HAL_BOOL ath_hal_intrpend(struct ath_hal *ah)
 950 {
 951         HAL_BOOL ret;
 952         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 953         ath_hal_set_function(__func__);
 954         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 955         ret = ah->ah_isInterruptPending(ah);
 956         ath_hal_set_function(NULL);
 957         ath_hal_set_device(NULL);
 958         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 959         return ret;
 960 }
 961
 962 static inline HAL_BOOL ath_hal_txstart(struct ath_hal *ah, u_int a1)
 963 {
 964         HAL_BOOL ret;
 965         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 966         ath_hal_set_function(__func__);
 967         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 968         ret = ah->ah_startTxDma(ah, a1);
 969         ath_hal_set_function(NULL);
 970         ath_hal_set_device(NULL);
 971         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 972         return ret;
 973 }
 974
 975 static inline void ath_hal_gettxintrtxqs(struct ath_hal *ah, u_int32_t *a1)
 976 {
 977         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 978         ath_hal_set_function(__func__);
 979         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 980         ah->ah_getTxIntrQueue(ah, a1);
 981         ath_hal_set_function(NULL);
 982         ath_hal_set_device(NULL);
 983         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 984 }
 985
 986 static inline HAL_BOOL ath_hal_setslottime(struct ath_hal *ah, u_int a1)
 987 {
 988         HAL_BOOL ret;
 989         ATH_HAL_LOCK_IRQ(ah->ah_sc);
 990         ath_hal_set_function(__func__);
 991         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
 992         ret = ah->ah_setSlotTime(ah, a1);
 993         ath_hal_set_function(NULL);
 994         ath_hal_set_device(NULL);
 995         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
 996         return ret;
 997 }
 998
 999 static inline void ath_hal_setledstate(struct ath_hal *ah, HAL_LED_STATE a1)
1000 {
1001         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1002         ath_hal_set_function(__func__);
1003         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1004         ah->ah_setLedState(ah, a1);
1005         ath_hal_set_function(NULL);
1006         ath_hal_set_device(NULL);
1007         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1008 }
1009
1010 static inline void ath_hal_setassocid(struct ath_hal *ah, const u_int8_t *bssid,
1011                                       u_int16_t assocId)
1012 {
1013         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1014         ath_hal_set_function(__func__);
1015         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1016         ah->ah_writeAssocid(ah, bssid, assocId);
1017         ath_hal_set_function(NULL);
1018         ath_hal_set_device(NULL);
1019         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1020 }
1021
1022 static inline void ath_hal_resettsf(struct ath_hal *ah)
1023 {
1024         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1025         ath_hal_set_function(__func__);
1026         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1027         ah->ah_resetTsf(ah);
1028         ath_hal_set_function(NULL);
1029         ath_hal_set_device(NULL);
1030         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1031 }
1032
1033 static inline HAL_BOOL ath_hal_setuprxdesc(struct ath_hal *ah,
1034                                            struct ath_desc *a1, u_int32_t size,
1035                                            u_int flags)
1036 {
1037         HAL_BOOL ret;
1038         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1039         ath_hal_set_function(__func__);
1040         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1041         ret = ah->ah_setupRxDesc(ah, a1, size, flags);
1042         ath_hal_set_function(NULL);
1043         ath_hal_set_device(NULL);
1044         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1045         return ret;
1046 }
1047
1048 static inline void ath_hal_setrxfilter(struct ath_hal *ah, u_int32_t a1)
1049 {
1050         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1051         ath_hal_set_function(__func__);
1052         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1053         ah->ah_setRxFilter(ah, a1);
1054         ath_hal_set_function(NULL);
1055         ath_hal_set_device(NULL);
1056         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1057 }
1058
1059 static inline HAL_BOOL ath_hal_keyisvalid(struct ath_hal *ah, u_int16_t a1)
1060 {
1061         HAL_BOOL ret;
1062         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1063         ath_hal_set_function(__func__);
1064         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1065         ret = ah->ah_isKeyCacheEntryValid(ah, a1);
1066         ath_hal_set_function(NULL);
1067         ath_hal_set_device(NULL);
1068         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1069         return ret;
1070 }
1071
1072 static inline void ath_hal_stoppcurecv(struct ath_hal *ah)
1073 {
1074         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1075         ath_hal_set_function(__func__);
1076         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1077         ah->ah_stopPcuReceive(ah);
1078         ath_hal_set_function(NULL);
1079         ath_hal_set_device(NULL);
1080         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1081 }
1082
1083 static inline HAL_BOOL ath_hal_stoptxdma(struct ath_hal *ah, u_int a1)
1084 {
1085         HAL_BOOL ret;
1086         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1087         ath_hal_set_function(__func__);
1088         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1089         ret = ah->ah_stopTxDma(ah, a1);
1090         ath_hal_set_function(NULL);
1091         ath_hal_set_device(NULL);
1092         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1093         return ret;
1094 }
1095
1096 static inline HAL_BOOL ath_hal_setcapability(struct ath_hal *ah,
1097                                              HAL_CAPABILITY_TYPE a1,
1098                                              u_int32_t capability,
1099                                              u_int32_t setting, HAL_STATUS *a4)
1100 {
1101         HAL_BOOL ret;
1102         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1103         ath_hal_set_function(__func__);
1104         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1105         ret = ah->ah_setCapability(ah, a1, capability, setting, a4);
1106         ath_hal_set_function(NULL);
1107         ath_hal_set_device(NULL);
1108         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1109         return ret;
1110 }
1111
1112 static inline HAL_BOOL ath_hal_stopdmarecv(struct ath_hal *ah)
1113 {
1114         HAL_BOOL ret;
1115         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1116         ath_hal_set_function(__func__);
1117         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1118         ret = ah->ah_stopDmaReceive(ah);
1119         ath_hal_set_function(NULL);
1120         ath_hal_set_device(NULL);
1121         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1122         return ret;
1123 }
1124
1125 static inline u_int32_t ath_hal_gettxbuf(struct ath_hal *ah, u_int a1)
1126 {
1127         u_int32_t ret;
1128         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1129         ath_hal_set_function(__func__);
1130         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1131         ret = ah->ah_getTxDP(ah, a1);
1132         ath_hal_set_function(NULL);
1133         ath_hal_set_device(NULL);
1134         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1135         return ret;
1136 }
1137
1138 static inline int ath_hal_setuptxqueue(struct ath_hal *ah, HAL_TX_QUEUE a1,
1139                                        const HAL_TXQ_INFO *qInfo)
1140 {
1141         int ret;
1142         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1143         ath_hal_set_function(__func__);
1144         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1145         ret = ah->ah_setupTxQueue(ah, a1, qInfo);
1146         ath_hal_set_function(NULL);
1147         ath_hal_set_device(NULL);
1148         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1149         return ret;
1150 }
1151
1152 static inline u_int ath_hal_getdefantenna(struct ath_hal *ah)
1153 {
1154         u_int ret;
1155         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1156         ath_hal_set_function(__func__);
1157         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1158         ret = ah->ah_getDefAntenna(ah);
1159         ath_hal_set_function(NULL);
1160         ath_hal_set_device(NULL);
1161         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1162         return ret;
1163 }
1164
1165 static inline HAL_BOOL ath_hal_phydisable(struct ath_hal *ah)
1166 {
1167         HAL_BOOL ret;
1168         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1169         ath_hal_set_function(__func__);
1170         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1171         ret = ah->ah_phyDisable(ah);
1172         ath_hal_set_function(NULL);
1173         ath_hal_set_device(NULL);
1174         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1175         return ret;
1176 }
1177
1178 static inline HAL_BOOL ath_hal_setregulatorydomain(struct ath_hal *ah,
1179                                                    u_int16_t a1, HAL_STATUS *a2)
1180 {
1181         HAL_BOOL ret;
1182         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1183         ath_hal_set_function(__func__);
1184         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1185         ret = ah->ah_setRegulatoryDomain(ah, a1, a2);
1186         ath_hal_set_function(NULL);
1187         ath_hal_set_device(NULL);
1188         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1189         return ret;
1190 }
1191
1192 static inline HAL_BOOL ath_hal_setuptxdesc(struct ath_hal *ah,
1193                                            struct ath_desc *a1, u_int pktLen,
1194                                            u_int hdrLen, HAL_PKT_TYPE type,
1195                                            u_int txPower, u_int txRate0,
1196                                            u_int txTries0, u_int keyIx,
1197                                            u_int antMode, u_int flags,
1198                                            u_int rtsctsRate,
1199                                            u_int rtsctsDuration,
1200                                            u_int compicvLen, u_int compivLen,
1201                                            u_int comp)
1202 {
1203         HAL_BOOL ret;
1204         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1205         ath_hal_set_function(__func__);
1206         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1207         ret =
1208             ah->ah_setupTxDesc(ah, a1, pktLen, hdrLen, type, txPower, txRate0,
1209                                txTries0, keyIx, antMode, flags, rtsctsRate,
1210                                rtsctsDuration, compicvLen, compivLen, comp);
1211         ath_hal_set_function(NULL);
1212         ath_hal_set_device(NULL);
1213         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1214         return ret;
1215 }
1216
1217 static inline HAL_BOOL ath_hal_gpiCfgInput(struct ath_hal *ah, u_int32_t gpio)
1218 {
1219         HAL_BOOL ret;
1220         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1221         ath_hal_set_function(__func__);
1222         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1223         ret = ah->ah_gpioCfgInput(ah, gpio);
1224         ath_hal_set_function(NULL);
1225         ath_hal_set_device(NULL);
1226         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1227         return ret;
1228 }
1229
1230 static inline u_int32_t ath_hal_gpioget(struct ath_hal *ah, u_int32_t gpio)
1231 {
1232         u_int32_t ret;
1233         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1234         ath_hal_set_function(__func__);
1235         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1236         ret = ah->ah_gpioGet(ah, gpio);
1237         ath_hal_set_function(NULL);
1238         ath_hal_set_device(NULL);
1239         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1240         return ret;
1241 }
1242
1243 static inline HAL_BOOL ath_hal_disable(struct ath_hal *ah)
1244 {
1245         HAL_BOOL ret;
1246         ATH_HAL_LOCK_IRQ(ah->ah_sc);
1247         ath_hal_set_function(__func__);
1248         ath_hal_set_device(SC_DEV_NAME(ah->ah_sc));
1249         ret = ah->ah_disable(ah);
1250         ath_hal_set_function(NULL);
1251         ath_hal_set_device(NULL);
1252         ATH_HAL_UNLOCK_IRQ(ah->ah_sc);
1253         return ret;
1254 }
1255
1256 /* Example script to create a HAL function unmangling SED script:
1257
1258    dmesg -c &>/dev/null && iwpriv ath0 dump_hal_map && dmesg | \
1259            sed -n -r -e "/zz[0-9a-f]{8}/ { s~^([^+]*)[^=]*=(.*)~s/\1\/\2 (\1)/g~; p; } " \
1260            >hal_unmangle.sed
1261
1262  * Example usage:
1263
1264            tail -f /var/log/messages | sed -f hal_unmangle.sed
1265  */
1266 static inline void ath_hal_dump_map(struct ath_hal *ah)
1267 {
1268 #ifdef CONFIG_KALLSYMS
1269
1270         /* void ah_getMacAddress(struct ath_hal *ah, u_int8_t *a1) */
1271         __print_symbol("%s=ah_getMacAddress\n",
1272                        (unsigned long)ah->ah_getMacAddress);
1273         /* HAL_POWER_MODE ah_getPowerMode(struct ath_hal *ah) */
1274         __print_symbol("%s=ah_getPowerMode\n",
1275                        (unsigned long)ah->ah_getPowerMode);
1276         /* HAL_BOOL ah_getDiagState(struct ath_hal *ah, int request, const void *args, u_int32_t argsize, void **result, u_int32_t *resultsize) */
1277         __print_symbol("%s=ah_getDiagState\n",
1278                        (unsigned long)ah->ah_getDiagState);
1279         /* void ah_resetStationBeaconTimers(struct ath_hal *ah) */
1280         __print_symbol("%s=ah_resetStationBeaconTimers\n",
1281                        (unsigned long)ah->ah_resetStationBeaconTimers);
1282         /* void ah_setCoverageClass(struct ath_hal *ah, u_int8_t a1, int a2) */
1283         __print_symbol("%s=ah_setCoverageClass\n",
1284                        (unsigned long)ah->ah_setCoverageClass);
1285         /* u_int64_t ah_getTsf64(struct ath_hal *ah) */
1286         __print_symbol("%s=ah_getTsf64\n", (unsigned long)ah->ah_getTsf64);
1287         /* void ah_enableReceive(struct ath_hal *ah) */
1288         __print_symbol("%s=ah_enableReceive\n",
1289                        (unsigned long)ah->ah_enableReceive);
1290         /* HAL_ANT_SETTING ah_getAntennaSwitch(struct ath_hal *ah) */
1291         __print_symbol("%s=ah_getAntennaSwitch\n",
1292                        (unsigned long)ah->ah_getAntennaSwitch);
1293         /* HAL_BOOL ah_gpioSet(struct ath_hal *ah, u_int32_t gpio, u_int32_t val) */
1294         __print_symbol("%s=ah_gpioSet\n", (unsigned long)ah->ah_gpioSet);
1295         /* HAL_BOOL ah_gpioCfgOutput(struct ath_hal *ah, u_int32_t gpio) */
1296         __print_symbol("%s=ah_gpioCfgOutput\n",
1297                        (unsigned long)ah->ah_gpioCfgOutput);
1298         /* HAL_BOOL ah_clrMulticastFilterIndex(struct ath_hal *ah, u_int32_t index) */
1299         __print_symbol("%s=ah_clrMulticastFilterIndex\n",
1300                        (unsigned long)ah->ah_clrMulticastFilterIndex);
1301         /* void ah_reqTxIntrDesc(struct ath_hal *ah, struct ath_desc *a1) */
1302         __print_symbol("%s=ah_reqTxIntrDesc\n",
1303                        (unsigned long)ah->ah_reqTxIntrDesc);
1304         /* void ah_rxMonitor(struct ath_hal *ah, const HAL_NODE_STATS *a1, HAL_CHANNEL *a2) */
1305         __print_symbol("%s=ah_rxMonitor\n", (unsigned long)ah->ah_rxMonitor);
1306         /* HAL_BOOL ah_setTxDP(struct ath_hal *ah, u_int a1, u_int32_t txdp) */
1307         __print_symbol("%s=ah_setTxDP\n", (unsigned long)ah->ah_setTxDP);
1308         /* HAL_BOOL ah_setKeyCacheEntry(struct ath_hal *ah, u_int16_t a1, const HAL_KEYVAL *a2, const u_int8_t *a3, int a4) */
1309         __print_symbol("%s=ah_setKeyCacheEntry\n",
1310                        (unsigned long)ah->ah_setKeyCacheEntry);
1311         /* void ah_setPCUConfig(struct ath_hal *ah) */
1312         __print_symbol("%s=ah_setPCUConfig\n",
1313                        (unsigned long)ah->ah_setPCUConfig);
1314         /* HAL_RFGAIN ah_getRfGain(struct ath_hal *ah) */
1315         __print_symbol("%s=ah_getRfGain\n", (unsigned long)ah->ah_getRfGain);
1316         /* void ah_setMulticastFilter(struct ath_hal *ah, u_int32_t filter0, u_int32_t filter1) */
1317         __print_symbol("%s=ah_setMulticastFilter\n",
1318                        (unsigned long)ah->ah_setMulticastFilter);
1319         /* u_int ah_getAckTimeout(struct ath_hal *ah) */
1320         __print_symbol("%s=ah_getAckTimeout\n",
1321                        (unsigned long)ah->ah_getAckTimeout);
1322         /* void ah_setStationBeaconTimers(struct ath_hal *ah, const HAL_BEACON_STATE *a1) */
1323         __print_symbol("%s=ah_setStationBeaconTimers\n",
1324                        (unsigned long)ah->ah_setStationBeaconTimers);
1325         /* HAL_BOOL ah_detectCardPresent(struct ath_hal *ah) */
1326         __print_symbol("%s=ah_detectCardPresent\n",
1327                        (unsigned long)ah->ah_detectCardPresent);
1328         /* u_int ah_getSlotTime(struct ath_hal *ah) */
1329         __print_symbol("%s=ah_getSlotTime\n",
1330                        (unsigned long)ah->ah_getSlotTime);
1331         /* void ah_beaconInit(struct ath_hal *ah, u_int32_t nexttbtt, u_int32_t intval) */
1332         __print_symbol("%s=ah_beaconInit\n", (unsigned long)ah->ah_beaconInit);
1333         /* void ah_gpioSetIntr(struct ath_hal *ah, u_int a1, u_int32_t a2) */
1334         __print_symbol("%s=ah_gpioSetIntr\n",
1335                        (unsigned long)ah->ah_gpioSetIntr);
1336         /* HAL_BOOL ah_releaseTxQueue(struct ath_hal *ah, u_int q) */
1337         __print_symbol("%s=ah_releaseTxQueue\n",
1338                        (unsigned long)ah->ah_releaseTxQueue);
1339         /* HAL_BOOL ah_setKeyCacheEntryMac(struct ath_hal *ah, u_int16_t a1, const u_int8_t *a2) */
1340         __print_symbol("%s=ah_setKeyCacheEntryMac\n",
1341                        (unsigned long)ah->ah_setKeyCacheEntryMac);
1342         /* HAL_STATUS ah_procTxDesc(struct ath_hal *ah, struct ath_desc *a1, struct ath_tx_status *a2) */
1343         __print_symbol("%s=ah_procTxDesc\n", (unsigned long)ah->ah_procTxDesc);
1344         /* HAL_INT ah_getInterrupts(struct ath_hal *ah) */
1345         __print_symbol("%s=ah_getInterrupts\n",
1346                        (unsigned long)ah->ah_getInterrupts);
1347         /* HAL_BOOL ah_setAckTimeout(struct ath_hal *ah, u_int a1) */
1348         __print_symbol("%s=ah_setAckTimeout\n",
1349                        (unsigned long)ah->ah_setAckTimeout);
1350         /* HAL_BOOL ah_setBssIdMask(struct ath_hal *ah, const u_int8_t *a1) */
1351         __print_symbol("%s=ah_setBssIdMask\n",
1352                        (unsigned long)ah->ah_setBssIdMask);
1353         /* HAL_BOOL ah_setAckCTSRate(struct ath_hal *ah, u_int a1) */
1354         __print_symbol("%s=ah_setAckCTSRate\n",
1355                        (unsigned long)ah->ah_setAckCTSRate);
1356         /* u_int32_t ah_getRxFilter(struct ath_hal *ah) */
1357         __print_symbol("%s=ah_getRxFilter\n",
1358                        (unsigned long)ah->ah_getRxFilter);
1359         /* int16_t ah_getChanNoise(struct ath_hal *ah, HAL_CHANNEL *a1) */
1360         __print_symbol("%s=ah_getChanNoise\n",
1361                        (unsigned long)ah->ah_getChanNoise);
1362         /* HAL_BOOL ah_resetKeyCacheEntry(struct ath_hal *ah, u_int16_t a1) */
1363         __print_symbol("%s=ah_resetKeyCacheEntry\n",
1364                        (unsigned long)ah->ah_resetKeyCacheEntry);
1365         /* HAL_BOOL ah_setAntennaSwitch(struct ath_hal *ah, HAL_ANT_SETTING a1) */
1366         __print_symbol("%s=ah_setAntennaSwitch\n",
1367                        (unsigned long)ah->ah_setAntennaSwitch);
1368         /* HAL_BOOL ah_setTxQueueProps(struct ath_hal *ah, int q, const HAL_TXQ_INFO *qInfo) */
1369         __print_symbol("%s=ah_setTxQueueProps\n",
1370                        (unsigned long)ah->ah_setTxQueueProps);
1371         /* void ah_setRxDP(struct ath_hal *ah, u_int32_t rxdp) */
1372         __print_symbol("%s=ah_setRxDP\n", (unsigned long)ah->ah_setRxDP);
1373         /* HAL_BOOL ah_reset(struct ath_hal *ah, HAL_OPMODE a1, HAL_CHANNEL *a2, HAL_BOOL bChannelChange, HAL_STATUS *status) */
1374         __print_symbol("%s=ah_reset\n", (unsigned long)ah->ah_reset);
1375         /* HAL_BOOL ah_setDecompMask(struct ath_hal *ah, u_int16_t a1, int a2) */
1376         __print_symbol("%s=ah_setDecompMask\n",
1377                        (unsigned long)ah->ah_setDecompMask);
1378         /* HAL_BOOL ah_getTxQueueProps(struct ath_hal *ah, int q, HAL_TXQ_INFO *qInfo) */
1379         __print_symbol("%s=ah_getTxQueueProps\n",
1380                        (unsigned long)ah->ah_getTxQueueProps);
1381         /* HAL_BOOL ah_fillTxDesc(struct ath_hal *ah, struct ath_desc *a1, u_int segLen, HAL_BOOL firstSeg, HAL_BOOL lastSeg, const struct ath_desc *a5) */
1382         __print_symbol("%s=ah_fillTxDesc\n", (unsigned long)ah->ah_fillTxDesc);
1383         /* u_int32_t ah_numTxPending(struct ath_hal *ah, u_int q) */
1384         __print_symbol("%s=ah_numTxPending\n",
1385                        (unsigned long)ah->ah_numTxPending);
1386         /* void ah_startPcuReceive(struct ath_hal *ah) */
1387         __print_symbol("%s=ah_startPcuReceive\n",
1388                        (unsigned long)ah->ah_startPcuReceive);
1389         /* void ah_setDefAntenna(struct ath_hal *ah, u_int a1) */
1390         __print_symbol("%s=ah_setDefAntenna\n",
1391                        (unsigned long)ah->ah_setDefAntenna);
1392         /* HAL_BOOL ah_setPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) */
1393         __print_symbol("%s=ah_setPowerMode\n",
1394                        (unsigned long)ah->ah_setPowerMode);
1395         /* HAL_STATUS ah_procRxDesc(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) */
1396         __print_symbol("%s=ah_procRxDesc\n", (unsigned long)ah->ah_procRxDesc);
1397         /* u_int ah_getAckCTSRate(struct ath_hal *ah) */
1398         __print_symbol("%s=ah_getAckCTSRate\n",
1399                        (unsigned long)ah->ah_getAckCTSRate);
1400         /* u_int32_t ah_getKeyCacheSize(struct ath_hal *ah) */
1401         __print_symbol("%s=ah_getKeyCacheSize\n",
1402                        (unsigned long)ah->ah_getKeyCacheSize);
1403         /* HAL_BOOL ah_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) */
1404         __print_symbol("%s=ah_setupXTxDesc\n",
1405                        (unsigned long)ah->ah_setupXTxDesc);
1406         /* HAL_INT ah_setInterrupts(struct ath_hal *ah, HAL_INT a1) */
1407         __print_symbol("%s=ah_setInterrupts\n",
1408                        (unsigned long)ah->ah_setInterrupts);
1409         /* u_int ah_getCTSTimeout(struct ath_hal *ah) */
1410         __print_symbol("%s=ah_getCTSTimeout\n",
1411                        (unsigned long)ah->ah_getCTSTimeout);
1412         /* void ah_updateMibCounters(struct ath_hal *ah, HAL_MIB_STATS *a1) */
1413         __print_symbol("%s=ah_updateMibCounters\n",
1414                        (unsigned long)ah->ah_updateMibCounters);
1415         /* HAL_BOOL ah_perCalibration(struct ath_hal *ah, HAL_CHANNEL *a1, HAL_BOOL *a2) */
1416         __print_symbol("%s=ah_perCalibration\n",
1417                        (unsigned long)ah->ah_perCalibration);
1418         /* u_int32_t ah_getRxDP(struct ath_hal *ah) */
1419         __print_symbol("%s=ah_getRxDP\n", (unsigned long)ah->ah_getRxDP);
1420         /* HAL_BOOL ah_setTxPowerLimit(struct ath_hal *ah, u_int32_t a1) */
1421         __print_symbol("%s=ah_setTxPowerLimit\n",
1422                        (unsigned long)ah->ah_setTxPowerLimit);
1423         /* HAL_BOOL ah_getPendingInterrupts(struct ath_hal *ah, HAL_INT *a1) */
1424         __print_symbol("%s=ah_getPendingInterrupts\n",
1425                        (unsigned long)ah->ah_getPendingInterrupts);
1426         /* HAL_BOOL ah_updateTxTrigLevel(struct ath_hal *ah, HAL_BOOL incTrigLevel) */
1427         __print_symbol("%s=ah_updateTxTrigLevel\n",
1428                        (unsigned long)ah->ah_updateTxTrigLevel);
1429         /* HAL_BOOL ah_resetTxQueue(struct ath_hal *ah, u_int q) */
1430         __print_symbol("%s=ah_resetTxQueue\n",
1431                        (unsigned long)ah->ah_resetTxQueue);
1432         /* HAL_BOOL ah_setMacAddress(struct ath_hal *ah, const u_int8_t *a1) */
1433         __print_symbol("%s=ah_setMacAddress\n",
1434                        (unsigned long)ah->ah_setMacAddress);
1435         /* HAL_BOOL ah_setCTSTimeout(struct ath_hal *ah, u_int a1) */
1436         __print_symbol("%s=ah_setCTSTimeout\n",
1437                        (unsigned long)ah->ah_setCTSTimeout);
1438         /* const HAL_RATE_TABLE *ah_getRateTable(struct ath_hal *ah, u_int mode) */
1439         __print_symbol("%s=ah_getRateTable\n",
1440                        (unsigned long)ah->ah_getRateTable);
1441         /* u_int32_t ah_getTsf32(struct ath_hal *ah) */
1442         __print_symbol("%s=ah_getTsf32\n", (unsigned long)ah->ah_getTsf32);
1443         /* void ah_procMibEvent(struct ath_hal *ah, const HAL_NODE_STATS *a1) */
1444         __print_symbol("%s=ah_procMibEvent\n",
1445                        (unsigned long)ah->ah_procMibEvent);
1446         /* void ah_setBeaconTimers(struct ath_hal *ah, const HAL_BEACON_TIMERS *a1) */
1447         __print_symbol("%s=ah_setBeaconTimers\n",
1448                        (unsigned long)ah->ah_setBeaconTimers);
1449         /* HAL_STATUS ah_getCapability(struct ath_hal *ah, HAL_CAPABILITY_TYPE a1, u_int32_t capability, u_int32_t *result) */
1450         __print_symbol("%s=ah_getCapability\n",
1451                        (unsigned long)ah->ah_getCapability);
1452         /* HAL_BOOL ah_radarWait(struct ath_hal *ah, HAL_CHANNEL *a1) */
1453         __print_symbol("%s=ah_radarWait\n", (unsigned long)ah->ah_radarWait);
1454         /* HAL_BOOL ah_setMulticastFilterIndex(struct ath_hal *ah, u_int32_t index) */
1455         __print_symbol("%s=ah_setMulticastFilterIndex\n",
1456                        (unsigned long)ah->ah_setMulticastFilterIndex);
1457         /* void ah_getBssIdMask(struct ath_hal *ah, u_int8_t *a1) */
1458         __print_symbol("%s=ah_getBssIdMask\n",
1459                        (unsigned long)ah->ah_getBssIdMask);
1460         /* HAL_BOOL ah_isInterruptPending(struct ath_hal *ah) */
1461         __print_symbol("%s=ah_isInterruptPending\n",
1462                        (unsigned long)ah->ah_isInterruptPending);
1463         /* HAL_BOOL ah_startTxDma(struct ath_hal *ah, u_int a1) */
1464         __print_symbol("%s=ah_startTxDma\n", (unsigned long)ah->ah_startTxDma);
1465         /* void ah_getTxIntrQueue(struct ath_hal *ah, u_int32_t *a1) */
1466         __print_symbol("%s=ah_getTxIntrQueue\n",
1467                        (unsigned long)ah->ah_getTxIntrQueue);
1468         /* HAL_BOOL ah_setSlotTime(struct ath_hal *ah, u_int a1) */
1469         __print_symbol("%s=ah_setSlotTime\n",
1470                        (unsigned long)ah->ah_setSlotTime);
1471         /* void ah_setLedState(struct ath_hal *ah, HAL_LED_STATE a1) */
1472         __print_symbol("%s=ah_setLedState\n",
1473                        (unsigned long)ah->ah_setLedState);
1474         /* void ah_writeAssocid(struct ath_hal *ah, const u_int8_t *bssid, u_int16_t assocId) */
1475         __print_symbol("%s=ah_writeAssocid\n",
1476                        (unsigned long)ah->ah_writeAssocid);
1477         /* void ah_resetTsf(struct ath_hal *ah) */
1478         __print_symbol("%s=ah_resetTsf\n", (unsigned long)ah->ah_resetTsf);
1479         /* HAL_BOOL ah_setupRxDesc(struct ath_hal *ah, struct ath_desc *a1, u_int32_t size, u_int flags) */
1480         __print_symbol("%s=ah_setupRxDesc\n",
1481                        (unsigned long)ah->ah_setupRxDesc);
1482         /* void ah_setRxFilter(struct ath_hal *ah, u_int32_t a1) */
1483         __print_symbol("%s=ah_setRxFilter\n",
1484                        (unsigned long)ah->ah_setRxFilter);
1485         /* HAL_BOOL ah_isKeyCacheEntryValid(struct ath_hal *ah, u_int16_t a1) */
1486         __print_symbol("%s=ah_isKeyCacheEntryValid\n",
1487                        (unsigned long)ah->ah_isKeyCacheEntryValid);
1488         /* void ah_stopPcuReceive(struct ath_hal *ah) */
1489         __print_symbol("%s=ah_stopPcuReceive\n",
1490                        (unsigned long)ah->ah_stopPcuReceive);
1491         /* HAL_BOOL ah_stopTxDma(struct ath_hal *ah, u_int a1) */
1492         __print_symbol("%s=ah_stopTxDma\n", (unsigned long)ah->ah_stopTxDma);
1493         /* HAL_BOOL ah_setCapability(struct ath_hal *ah, HAL_CAPABILITY_TYPE a1, u_int32_t capability, u_int32_t setting, HAL_STATUS *a4) */
1494         __print_symbol("%s=ah_setCapability\n",
1495                        (unsigned long)ah->ah_setCapability);
1496         /* HAL_BOOL ah_stopDmaReceive(struct ath_hal *ah) */
1497         __print_symbol("%s=ah_stopDmaReceive\n",
1498                        (unsigned long)ah->ah_stopDmaReceive);
1499         /* u_int32_t ah_getTxDP(struct ath_hal *ah, u_int a1) */
1500         __print_symbol("%s=ah_getTxDP\n", (unsigned long)ah->ah_getTxDP);
1501         /* int ah_setupTxQueue(struct ath_hal *ah, HAL_TX_QUEUE a1, const HAL_TXQ_INFO *qInfo) */
1502         __print_symbol("%s=ah_setupTxQueue\n",
1503                        (unsigned long)ah->ah_setupTxQueue);
1504         /* u_int ah_getDefAntenna(struct ath_hal *ah) */
1505         __print_symbol("%s=ah_getDefAntenna\n",
1506                        (unsigned long)ah->ah_getDefAntenna);
1507         /* HAL_BOOL ah_phyDisable(struct ath_hal *ah) */
1508         __print_symbol("%s=ah_phyDisable\n", (unsigned long)ah->ah_phyDisable);
1509         /* HAL_BOOL ah_setRegulatoryDomain(struct ath_hal *ah, u_int16_t a1, HAL_STATUS *a2) */
1510         __print_symbol("%s=ah_setRegulatoryDomain\n",
1511                        (unsigned long)ah->ah_setRegulatoryDomain);
1512         /* HAL_BOOL ah_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) */
1513         __print_symbol("%s=ah_setupTxDesc\n",
1514                        (unsigned long)ah->ah_setupTxDesc);
1515         /* HAL_BOOL ah_gpioCfgInput(struct ath_hal *ah, u_int32_t gpio) */
1516         __print_symbol("%s=ah_gpioCfgInput\n",
1517                        (unsigned long)ah->ah_gpioCfgInput);
1518         /* u_int32_t ah_gpioGet(struct ath_hal *ah, u_int32_t gpio) */
1519         __print_symbol("%s=ah_gpioGet\n", (unsigned long)ah->ah_gpioGet);
1520         /* HAL_BOOL ah_disable(struct ath_hal *ah) */
1521         __print_symbol("%s=ah_disable\n", (unsigned long)ah->ah_disable);
1522 #else                           /* #ifdef CONFIG_KALLSYMS */
1523
1524         printk
1525             ("To use this feature you must enable CONFIG_KALLSYMS in your kernel.");
1526
1527 #endif                          /* #ifndef CONFIG_KALLSYMS */
1528
1529 }
1530
1531 #include "if_ath_hal_wrappers.h"
1532 #include "if_ath_hal_extensions.h"
1533
1534 #endif                          /* #ifndef _IF_ATH_HAL_H_ */
1535  /* *** THIS IS A GENERATED FILE -- DO NOT EDIT *** */
1536  /* *** THIS IS A GENERATED FILE -- DO NOT EDIT *** */
1537  /* *** THIS IS A GENERATED FILE -- DO NOT EDIT *** */