Changeset 12038


Ignore:
Timestamp:
2008-07-31T11:51:31+02:00 (10 years ago)
Author:
kaloz
Message:

sync ath9k with latest git code

Location:
trunk/package/ath9k
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/ath9k/Makefile

    r11903 r12038  
    99 
    1010PKG_NAME:=ath9k 
    11 PKG_VERSION:=20080722 
     11PKG_VERSION:=20080731 
    1212PKG_RELEASE:=1 
    1313 
  • trunk/package/ath9k/src/drivers/net/wireless/ath9k/ath9k.h

    r11902 r12038  
    3333#define AR_SUBVENDOR_ID_NEW_A   0x7065 
    3434 
    35 #define HAL_TXERR_XRETRY        0x01 
    36 #define HAL_TXERR_FILT          0x02 
    37 #define HAL_TXERR_FIFO          0x04 
    38 #define HAL_TXERR_XTXOP         0x08 
    39 #define HAL_TXERR_TIMER_EXPIRED 0x10 
    40  
    41 #define HAL_TX_BA               0x01 
    42 #define HAL_TX_PWRMGMT          0x02 
    43 #define HAL_TX_DESC_CFG_ERR     0x04 
    44 #define HAL_TX_DATA_UNDERRUN    0x08 
    45 #define HAL_TX_DELIM_UNDERRUN   0x10 
    46 #define HAL_TX_SW_ABORTED       0x40 
    47 #define HAL_TX_SW_FILTERED      0x80 
     35#define ATH9K_TXERR_XRETRY         0x01 
     36#define ATH9K_TXERR_FILT           0x02 
     37#define ATH9K_TXERR_FIFO           0x04 
     38#define ATH9K_TXERR_XTXOP          0x08 
     39#define ATH9K_TXERR_TIMER_EXPIRED 0x10 
     40 
     41#define ATH9K_TX_BA                0x01 
     42#define ATH9K_TX_PWRMGMT           0x02 
     43#define ATH9K_TX_DESC_CFG_ERR      0x04 
     44#define ATH9K_TX_DATA_UNDERRUN     0x08 
     45#define ATH9K_TX_DELIM_UNDERRUN    0x10 
     46#define ATH9K_TX_SW_ABORTED        0x40 
     47#define ATH9K_TX_SW_FILTERED       0x80 
    4848 
    4949#define NBBY    8 
     
    103103}; 
    104104 
    105 #define HAL_RXERR_CRC           0x01 
    106 #define HAL_RXERR_PHY           0x02 
    107 #define HAL_RXERR_FIFO          0x04 
    108 #define HAL_RXERR_DECRYPT       0x08 
    109 #define HAL_RXERR_MIC           0x10 
    110  
    111 #define HAL_RX_MORE             0x01 
    112 #define HAL_RX_MORE_AGGR        0x02 
    113 #define HAL_RX_GI               0x04 
    114 #define HAL_RX_2040             0x08 
    115 #define HAL_RX_DELIM_CRC_PRE    0x10 
    116 #define HAL_RX_DELIM_CRC_POST   0x20 
    117 #define HAL_RX_DECRYPT_BUSY     0x40 
    118  
    119 enum hal_bool { 
    120         AH_FALSE = 0, 
    121         AH_TRUE = 1, 
    122 }; 
     105#define ATH9K_RXERR_CRC           0x01 
     106#define ATH9K_RXERR_PHY           0x02 
     107#define ATH9K_RXERR_FIFO          0x04 
     108#define ATH9K_RXERR_DECRYPT       0x08 
     109#define ATH9K_RXERR_MIC           0x10 
     110 
     111#define ATH9K_RX_MORE             0x01 
     112#define ATH9K_RX_MORE_AGGR        0x02 
     113#define ATH9K_RX_GI               0x04 
     114#define ATH9K_RX_2040             0x08 
     115#define ATH9K_RX_DELIM_CRC_PRE    0x10 
     116#define ATH9K_RX_DELIM_CRC_POST   0x20 
     117#define ATH9K_RX_DECRYPT_BUSY     0x40 
    123118 
    124119#define HAL_RXKEYIX_INVALID     ((u_int8_t)-1) 
     
    244239        int ath_hal_serializeRegMode; 
    245240        int ath_hal_intrMitigation; 
    246         int ath_hal_debug; 
    247241#define SPUR_DISABLE            0 
    248242#define SPUR_ENABLE_IOCTL       1 
     
    483477        int8_t maxTxPower; 
    484478        int8_t minTxPower; 
    485         enum hal_bool bssSendHere; 
     479        bool bssSendHere; 
    486480        u_int8_t gainI; 
    487         enum hal_bool iqCalValid; 
     481        bool iqCalValid; 
    488482        int32_t CalValid; 
    489         enum hal_bool oneTimeCalsDone; 
     483        bool oneTimeCalsDone; 
    490484        int8_t iCoff; 
    491485        int8_t qCoff; 
     
    624618}; 
    625619 
    626 #define HAL_DBG_RESET           0x00000001 
    627 #define HAL_DBG_PHY_IO          0x00000002 
    628 #define HAL_DBG_REG_IO          0x00000004 
    629 #define HAL_DBG_RF_PARAM        0x00000008 
    630 #define HAL_DBG_QUEUE           0x00000010 
    631 #define HAL_DBG_EEPROM_DUMP     0x00000020 
    632 #define HAL_DBG_EEPROM          0x00000040 
    633 #define HAL_DBG_NF_CAL          0x00000080 
    634 #define HAL_DBG_CALIBRATE       0x00000100 
    635 #define HAL_DBG_CHANNEL         0x00000200 
    636 #define HAL_DBG_INTERRUPT       0x00000400 
    637 #define HAL_DBG_DFS             0x00000800 
    638 #define HAL_DBG_DMA             0x00001000 
    639 #define HAL_DBG_REGULATORY      0x00002000 
    640 #define HAL_DBG_TX              0x00004000 
    641 #define HAL_DBG_TXDESC          0x00008000 
    642 #define HAL_DBG_RX              0x00010000 
    643 #define HAL_DBG_RXDESC          0x00020000 
    644 #define HAL_DBG_ANI             0x00040000 
    645 #define HAL_DBG_BEACON          0x00080000 
    646 #define HAL_DBG_KEYCACHE        0x00100000 
    647 #define HAL_DBG_POWER_MGMT      0x00200000 
    648 #define HAL_DBG_MALLOC          0x00400000 
    649 #define HAL_DBG_POWER_OVERRIDE  0x01000000 
    650 #define HAL_DBG_SPUR_MITIGATE   0x02000000 
    651 #define HAL_DBG_UNMASKABLE      0xFFFFFFFF 
    652  
    653620#define REG_WRITE(_ah, _reg, _val) iowrite32(_val, _ah->ah_sh + _reg) 
    654621#define REG_READ(_ah, _reg) ioread32(_ah->ah_sh + _reg) 
     
    656623#define SM(_v, _f)  (((_v) << _f##_S) & _f) 
    657624#define MS(_v, _f)  (((_v) & _f) >> _f##_S) 
    658 #define OS_REG_RMW(_a, _r, _set, _clr)    \ 
     625#define REG_RMW(_a, _r, _set, _clr)    \ 
    659626        REG_WRITE(_a, _r, (REG_READ(_a, _r) & ~(_clr)) | (_set)) 
    660 #define OS_REG_RMW_FIELD(_a, _r, _f, _v) \ 
     627#define REG_RMW_FIELD(_a, _r, _f, _v) \ 
    661628        REG_WRITE(_a, _r, \ 
    662629        (REG_READ(_a, _r) & ~_f) | (((_v) << _f##_S) & _f)) 
    663 #define OS_REG_SET_BIT(_a, _r, _f) \ 
     630#define REG_SET_BIT(_a, _r, _f) \ 
    664631        REG_WRITE(_a, _r, REG_READ(_a, _r) | _f) 
    665 #define OS_REG_CLR_BIT(_a, _r, _f) \ 
     632#define REG_CLR_BIT(_a, _r, _f) \ 
    666633        REG_WRITE(_a, _r, REG_READ(_a, _r) & ~_f) 
    667 #define OS_REG_ath9k_regd_is_bit_set(_a, _r, _f) \ 
    668         ((REG_READ(_a, _r) & _f) != 0) 
    669634 
    670635#define HAL_COMP_BUF_MAX_SIZE   9216 
     
    914879        u_int16_t ah_devid; 
    915880        u_int16_t ah_subvendorid; 
    916         void *ah_sc; 
     881        struct ath_softc *ah_sc; 
    917882        void __iomem *ah_sh; 
    918883        u_int16_t ah_countryCode; 
     
    937902        char ah_iso[4]; 
    938903        enum start_adhoc_option ah_adHocMode; 
    939         enum hal_bool ah_commonMode; 
     904        bool ah_commonMode; 
    940905        struct hal_channel_internal ah_channels[150]; 
    941906        u_int ah_nchan; 
    942907        struct hal_channel_internal *ah_curchan; 
    943908        u_int16_t ah_rfsilent; 
    944         enum hal_bool ah_rfkillEnabled; 
    945         enum hal_bool ah_isPciExpress; 
     909        bool ah_rfkillEnabled; 
     910        bool ah_isPciExpress; 
    946911        u_int16_t ah_txTrigLevel; 
    947912#ifndef ATH_NF_PER_CHAN 
     
    949914#endif 
    950915}; 
    951  
    952 #define HDPRINTF(_ah, _m, _fmt, ...) do {                               \ 
    953                 if (((_ah) == NULL && _m == HAL_DBG_UNMASKABLE) ||      \ 
    954                     (((struct ath_hal *)(_ah))->ah_config.ath_hal_debug & _m)) \ 
    955                         printk(KERN_DEBUG _fmt , ##__VA_ARGS__);        \ 
    956         } while (0) 
    957916 
    958917enum wireless_mode { 
     
    1000959                                                   u_int mode); 
    1001960void ath9k_hw_detach(struct ath_hal *ah); 
    1002 struct ath_hal *ath9k_hw_attach(u_int16_t devid, void *sc, void __iomem *mem, 
     961struct ath_hal *ath9k_hw_attach(u_int16_t devid, 
     962                                struct ath_softc *sc, 
     963                                void __iomem *mem, 
    1003964                                enum hal_status *error); 
    1004 enum hal_bool ath9k_regd_init_channels(struct ath_hal *ah, 
    1005                                        struct hal_channel *chans, 
    1006                                        u_int maxchans, u_int *nchans, 
    1007                                        u_int8_t *regclassids, 
    1008                                        u_int maxregids, u_int *nregids, 
    1009                                        u_int16_t cc, u_int32_t modeSelect, 
    1010                                        enum hal_bool enableOutdoor, 
    1011                                        enum hal_bool 
    1012                                        enableExtendedChannels); 
     965bool ath9k_regd_init_channels(struct ath_hal *ah, 
     966                              struct hal_channel *chans, 
     967                              u_int maxchans, u_int *nchans, 
     968                              u_int8_t *regclassids, 
     969                              u_int maxregids, u_int *nregids, 
     970                              u_int16_t cc, u_int32_t modeSelect, 
     971                              bool enableOutdoor, 
     972                              bool enableExtendedChannels); 
    1013973u_int ath9k_hw_mhz2ieee(struct ath_hal *ah, u_int freq, u_int flags); 
    1014974enum hal_int ath9k_hw_set_interrupts(struct ath_hal *ah, 
    1015975                                     enum hal_int ints); 
    1016 enum hal_bool ath9k_hw_reset(struct ath_hal *ah, enum hal_opmode opmode, 
    1017                              struct hal_channel *chan, 
    1018                              enum hal_ht_macmode macmode, 
    1019                              u_int8_t txchainmask, u_int8_t rxchainmask, 
    1020                              enum hal_ht_extprotspacing extprotspacing, 
    1021                              enum hal_bool bChannelChange, 
    1022                              enum hal_status *status); 
    1023 enum hal_bool ath9k_hw_phy_disable(struct ath_hal *ah); 
     976bool ath9k_hw_reset(struct ath_hal *ah, enum hal_opmode opmode, 
     977                    struct hal_channel *chan, 
     978                    enum hal_ht_macmode macmode, 
     979                    u_int8_t txchainmask, u_int8_t rxchainmask, 
     980                    enum hal_ht_extprotspacing extprotspacing, 
     981                    bool bChannelChange, 
     982                    enum hal_status *status); 
     983bool ath9k_hw_phy_disable(struct ath_hal *ah); 
    1024984void ath9k_hw_reset_calvalid(struct ath_hal *ah, struct hal_channel *chan, 
    1025                              enum hal_bool *isCalDone); 
     985                             bool *isCalDone); 
    1026986void ath9k_hw_ani_monitor(struct ath_hal *ah, 
    1027987                          const struct hal_node_stats *stats, 
    1028988                          struct hal_channel *chan); 
    1029 enum hal_bool ath9k_hw_calibrate(struct ath_hal *ah, 
    1030                                  struct hal_channel *chan, 
    1031                                  u_int8_t rxchainmask, 
    1032                                  enum hal_bool longcal, 
    1033                                  enum hal_bool *isCalDone); 
     989bool ath9k_hw_calibrate(struct ath_hal *ah, 
     990                        struct hal_channel *chan, 
     991                        u_int8_t rxchainmask, 
     992                        bool longcal, 
     993                        bool *isCalDone); 
    1034994int16_t ath9k_hw_getchan_noise(struct ath_hal *ah, 
    1035995                               struct hal_channel *chan); 
     
    1039999void ath9k_hw_write_associd(struct ath_hal *ah, const u_int8_t *bssid, 
    10401000                            u_int16_t assocId); 
    1041 enum hal_bool ath9k_hw_stoptxdma(struct ath_hal *ah, u_int q); 
     1001bool ath9k_hw_stoptxdma(struct ath_hal *ah, u_int q); 
    10421002void ath9k_hw_reset_tsf(struct ath_hal *ah); 
    1043 enum hal_bool ath9k_hw_keyisvalid(struct ath_hal *ah, u_int16_t entry); 
    1044 enum hal_bool ath9k_hw_keysetmac(struct ath_hal *ah, u_int16_t entry, 
    1045                                  const u_int8_t *mac); 
    1046 enum hal_bool ath9k_hw_set_keycache_entry(struct ath_hal *ah, 
    1047                                           u_int16_t entry, 
    1048                                           const struct hal_keyval *k, 
    1049                                           const u_int8_t *mac, 
    1050                                           int xorKey); 
    1051 enum hal_bool ath9k_hw_set_tsfadjust(struct ath_hal *ah, 
    1052                                      u_int32_t setting); 
     1003bool ath9k_hw_keyisvalid(struct ath_hal *ah, u_int16_t entry); 
     1004bool ath9k_hw_keysetmac(struct ath_hal *ah, u_int16_t entry, 
     1005                        const u_int8_t *mac); 
     1006bool ath9k_hw_set_keycache_entry(struct ath_hal *ah, 
     1007                                u_int16_t entry, 
     1008                                const struct hal_keyval *k, 
     1009                                const u_int8_t *mac, 
     1010                                int xorKey); 
     1011bool ath9k_hw_set_tsfadjust(struct ath_hal *ah, 
     1012                            u_int32_t setting); 
    10531013void ath9k_hw_configpcipowersave(struct ath_hal *ah, int restore); 
    1054 enum hal_bool ath9k_hw_intrpend(struct ath_hal *ah); 
    1055 enum hal_bool ath9k_hw_getisr(struct ath_hal *ah, enum hal_int *masked); 
    1056 enum hal_bool ath9k_hw_updatetxtriglevel(struct ath_hal *ah, 
    1057                                          enum hal_bool bIncTrigLevel); 
     1014bool ath9k_hw_intrpend(struct ath_hal *ah); 
     1015bool ath9k_hw_getisr(struct ath_hal *ah, enum hal_int *masked); 
     1016bool ath9k_hw_updatetxtriglevel(struct ath_hal *ah, 
     1017                                bool bIncTrigLevel); 
    10581018void ath9k_hw_procmibevent(struct ath_hal *ah, 
    10591019                           const struct hal_node_stats *stats); 
    1060 enum hal_bool ath9k_hw_setrxabort(struct ath_hal *ah, enum hal_bool set); 
     1020bool ath9k_hw_setrxabort(struct ath_hal *ah, bool set); 
    10611021void ath9k_hw_set11nmac2040(struct ath_hal *ah, enum hal_ht_macmode mode); 
    1062 enum hal_bool ath9k_hw_setupxtxdesc(struct ath_hal *ah, 
    1063                                     struct ath_desc *ds, 
    1064                                     u_int txRate1, u_int txTries1, 
    1065                                     u_int txRate2, u_int txTries2, 
    1066                                     u_int txRate3, u_int txTries3); 
    1067 enum hal_bool ath9k_hw_phycounters(struct ath_hal *ah); 
    1068 enum hal_bool ath9k_hw_keyreset(struct ath_hal *ah, u_int16_t entry); 
    1069 enum hal_bool ath9k_hw_getcapability(struct ath_hal *ah, 
    1070                                      enum hal_capability_type type, 
    1071                                      u_int32_t capability, 
    1072                                      u_int32_t *result); 
    1073 enum hal_bool ath9k_hw_setcapability(struct ath_hal *ah, 
    1074                                      enum hal_capability_type type, 
    1075                                      u_int32_t capability, 
    1076                                      u_int32_t setting, 
    1077                                      enum hal_status *status); 
     1022bool ath9k_hw_phycounters(struct ath_hal *ah); 
     1023bool ath9k_hw_keyreset(struct ath_hal *ah, u_int16_t entry); 
     1024bool ath9k_hw_getcapability(struct ath_hal *ah, 
     1025                            enum hal_capability_type type, 
     1026                            u_int32_t capability, 
     1027                            u_int32_t *result); 
     1028bool ath9k_hw_setcapability(struct ath_hal *ah, 
     1029                            enum hal_capability_type type, 
     1030                            u_int32_t capability, 
     1031                            u_int32_t setting, 
     1032                            enum hal_status *status); 
    10781033u_int ath9k_hw_getdefantenna(struct ath_hal *ah); 
    10791034void ath9k_hw_getmac(struct ath_hal *ah, u_int8_t *mac); 
    10801035void ath9k_hw_getbssidmask(struct ath_hal *ah, u_int8_t *mask); 
    1081 enum hal_bool ath9k_hw_setbssidmask(struct ath_hal *ah, 
    1082                                     const u_int8_t *mask); 
    1083 enum hal_bool ath9k_hw_setpower(struct ath_hal *ah, 
    1084                                 enum hal_power_mode mode); 
     1036bool ath9k_hw_setbssidmask(struct ath_hal *ah, 
     1037                           const u_int8_t *mask); 
     1038bool ath9k_hw_setpower(struct ath_hal *ah, 
     1039                       enum hal_power_mode mode); 
    10851040enum hal_int ath9k_hw_intrget(struct ath_hal *ah); 
    10861041u_int64_t ath9k_hw_gettsf64(struct ath_hal *ah); 
    10871042u_int ath9k_hw_getdefantenna(struct ath_hal *ah); 
    1088 enum hal_bool ath9k_hw_setslottime(struct ath_hal *ah, u_int us); 
    1089 enum hal_bool ath9k_hw_setantennaswitch(struct ath_hal *ah, 
    1090                                         enum hal_ant_setting settings, 
    1091                                         struct hal_channel *chan, 
    1092                                         u_int8_t *tx_chainmask, 
    1093                                         u_int8_t *rx_chainmask, 
    1094                                         u_int8_t *antenna_cfgd); 
     1043bool ath9k_hw_setslottime(struct ath_hal *ah, u_int us); 
     1044bool ath9k_hw_setantennaswitch(struct ath_hal *ah, 
     1045                               enum hal_ant_setting settings, 
     1046                               struct hal_channel *chan, 
     1047                               u_int8_t *tx_chainmask, 
     1048                               u_int8_t *rx_chainmask, 
     1049                               u_int8_t *antenna_cfgd); 
    10951050void ath9k_hw_setantenna(struct ath_hal *ah, u_int antenna); 
    10961051enum hal_status ath9k_hw_select_antconfig(struct ath_hal *ah, 
    10971052                                          u_int32_t cfg); 
    1098 enum hal_bool ath9k_hw_puttxbuf(struct ath_hal *ah, u_int q, 
    1099                                 u_int32_t txdp); 
    1100 enum hal_bool ath9k_hw_txstart(struct ath_hal *ah, u_int q); 
     1053bool ath9k_hw_puttxbuf(struct ath_hal *ah, u_int q, 
     1054                       u_int32_t txdp); 
     1055bool ath9k_hw_txstart(struct ath_hal *ah, u_int q); 
    11011056u_int16_t ath9k_hw_computetxtime(struct ath_hal *ah, 
    11021057                                 const struct hal_rate_table *rates, 
    11031058                                 u_int32_t frameLen, u_int16_t rateix, 
    1104                                  enum hal_bool shortPreamble); 
     1059                                 bool shortPreamble); 
    11051060void ath9k_hw_set11n_ratescenario(struct ath_hal *ah, struct ath_desc *ds, 
    11061061                                  struct ath_desc *lastds, 
     
    11141069void ath9k_hw_cleartxdesc(struct ath_hal *ah, struct ath_desc *ds); 
    11151070u_int32_t ath9k_hw_reverse_bits(u_int32_t val, u_int32_t n); 
    1116 enum hal_bool ath9k_hw_resettxqueue(struct ath_hal *ah, u_int q); 
     1071bool ath9k_hw_resettxqueue(struct ath_hal *ah, u_int q); 
    11171072u_int ath9k_regd_get_ctl(struct ath_hal *ah, struct hal_channel *chan); 
    11181073u_int ath9k_regd_get_antenna_allowed(struct ath_hal *ah, 
    1119         struct hal_channel *chan); 
     1074                                     struct hal_channel *chan); 
    11201075u_int ath9k_hw_mhz2ieee(struct ath_hal *ah, u_int freq, u_int flags); 
    1121 enum hal_bool ath9k_hw_gettxqueueprops(struct ath_hal *ah, int q, 
    1122         struct hal_txq_info *qInfo); 
    1123 enum hal_bool ath9k_hw_settxqueueprops(struct ath_hal *ah, int q, 
    1124                                        const struct hal_txq_info *qInfo); 
     1076bool ath9k_hw_gettxqueueprops(struct ath_hal *ah, int q, 
     1077                              struct hal_txq_info *qInfo); 
     1078bool ath9k_hw_settxqueueprops(struct ath_hal *ah, int q, 
     1079                              const struct hal_txq_info *qInfo); 
    11251080struct hal_channel_internal *ath9k_regd_check_channel(struct ath_hal *ah, 
    1126         const struct hal_channel *c); 
     1081                                              const struct hal_channel *c); 
    11271082void ath9k_hw_set11n_txdesc(struct ath_hal *ah, struct ath_desc *ds, 
    1128         u_int pktLen, enum hal_pkt_type type, 
    1129         u_int txPower, u_int keyIx, 
    1130         enum hal_key_type keyType, u_int flags); 
    1131 enum hal_bool ath9k_hw_filltxdesc(struct ath_hal *ah, struct ath_desc *ds, 
    1132         u_int segLen, enum hal_bool firstSeg, 
    1133         enum hal_bool lastSeg, 
    1134         const struct ath_desc *ds0); 
     1083                            u_int pktLen, enum hal_pkt_type type, 
     1084                            u_int txPower, u_int keyIx, 
     1085                            enum hal_key_type keyType, u_int flags); 
     1086bool ath9k_hw_filltxdesc(struct ath_hal *ah, struct ath_desc *ds, 
     1087                         u_int segLen, bool firstSeg, 
     1088                         bool lastSeg, 
     1089                         const struct ath_desc *ds0); 
    11351090u_int32_t ath9k_hw_GetMibCycleCountsPct(struct ath_hal *ah, 
    11361091                                        u_int32_t *rxc_pcnt, 
     
    11421097void ath9k_hw_set_sta_beacon_timers(struct ath_hal *ah, 
    11431098                                    const struct hal_beacon_state *bs); 
    1144 enum hal_bool ath9k_hw_setuprxdesc(struct ath_hal *ah, struct ath_desc *ds, 
    1145                                    u_int32_t size, u_int flags); 
     1099bool ath9k_hw_setuprxdesc(struct ath_hal *ah, struct ath_desc *ds, 
     1100                          u_int32_t size, u_int flags); 
    11461101void ath9k_hw_putrxbuf(struct ath_hal *ah, u_int32_t rxdp); 
    11471102void ath9k_hw_rxena(struct ath_hal *ah); 
    11481103void ath9k_hw_setopmode(struct ath_hal *ah); 
    1149 enum hal_bool ath9k_hw_setmac(struct ath_hal *ah, const u_int8_t *mac); 
     1104bool ath9k_hw_setmac(struct ath_hal *ah, const u_int8_t *mac); 
    11501105void ath9k_hw_setmcastfilter(struct ath_hal *ah, u_int32_t filter0, 
    11511106                             u_int32_t filter1); 
     
    11531108void ath9k_hw_startpcureceive(struct ath_hal *ah); 
    11541109void ath9k_hw_stoppcurecv(struct ath_hal *ah); 
    1155 enum hal_bool ath9k_hw_stopdmarecv(struct ath_hal *ah); 
     1110bool ath9k_hw_stopdmarecv(struct ath_hal *ah); 
    11561111enum hal_status ath9k_hw_rxprocdesc(struct ath_hal *ah, 
    11571112                                    struct ath_desc *ds, u_int32_t pa, 
     
    11651120                                u_int aggrLen); 
    11661121void ath9k_hw_set11n_aggr_last(struct ath_hal *ah, struct ath_desc *ds); 
    1167 enum hal_bool ath9k_hw_releasetxqueue(struct ath_hal *ah, u_int q); 
     1122bool ath9k_hw_releasetxqueue(struct ath_hal *ah, u_int q); 
    11681123void ath9k_hw_gettxintrtxqs(struct ath_hal *ah, u_int32_t *txqs); 
    11691124void ath9k_hw_clr11n_aggr(struct ath_hal *ah, struct ath_desc *ds); 
    11701125void ath9k_hw_set11n_virtualmorefrag(struct ath_hal *ah, 
    11711126                                     struct ath_desc *ds, u_int vmf); 
    1172 enum hal_bool ath9k_hw_set_txpowerlimit(struct ath_hal *ah, u_int32_t limit); 
    1173 enum hal_bool ath9k_regd_is_public_safety_sku(struct ath_hal *ah); 
     1127bool ath9k_hw_set_txpowerlimit(struct ath_hal *ah, u_int32_t limit); 
     1128bool ath9k_regd_is_public_safety_sku(struct ath_hal *ah); 
    11741129int ath9k_hw_setuptxqueue(struct ath_hal *ah, enum hal_tx_queue type, 
    11751130                          const struct hal_txq_info *qInfo); 
    11761131u_int32_t ath9k_hw_numtxpending(struct ath_hal *ah, u_int q); 
    11771132const char *ath9k_hw_probe(u_int16_t vendorid, u_int16_t devid); 
    1178 enum hal_bool ath9k_hw_disable(struct ath_hal *ah); 
     1133bool ath9k_hw_disable(struct ath_hal *ah); 
    11791134void ath9k_hw_rfdetach(struct ath_hal *ah); 
    11801135void ath9k_hw_get_channel_centers(struct ath_hal *ah, 
    11811136                                  struct hal_channel_internal *chan, 
    11821137                                  struct chan_centers *centers); 
    1183 enum hal_bool ath9k_get_channel_edges(struct ath_hal *ah, 
    1184                                       u_int16_t flags, u_int16_t *low, 
    1185                                       u_int16_t *high); 
    1186 enum hal_bool ath9k_hw_get_chip_power_limits(struct ath_hal *ah, 
    1187                                              struct hal_channel *chans, 
    1188                                              u_int32_t nchans); 
     1138bool ath9k_get_channel_edges(struct ath_hal *ah, 
     1139                             u_int16_t flags, u_int16_t *low, 
     1140                             u_int16_t *high); 
     1141bool ath9k_hw_get_chip_power_limits(struct ath_hal *ah, 
     1142                                    struct hal_channel *chans, 
     1143                                    u_int32_t nchans); 
    11891144#endif 
  • trunk/package/ath9k/src/drivers/net/wireless/ath9k/beacon.c

    r11902 r12038  
    4646 
    4747        if (!ath9k_hw_settxqueueprops(ah, sc->sc_bhalq, &qi)) { 
    48                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     48                DPRINTF(sc, ATH_DBG_FATAL, 
    4949                        "%s: unable to update h/w beacon queue parameters\n", 
    5050                        __func__); 
     
    7777        struct hal_11n_rate_series  series[4]; 
    7878 
    79         DPRINTF(sc, ATH_DEBUG_BEACON, "%s: m %p len %u\n", 
     79        DPRINTF(sc, ATH_DBG_BEACON, "%s: m %p len %u\n", 
    8080                __func__, skb, skb->len); 
    8181 
     
    8585        flags = HAL_TXDESC_NOACK; 
    8686 
    87         if (sc->sc_opmode == HAL_M_IBSS && sc->sc_hasveol) { 
     87        if (sc->sc_opmode == HAL_M_IBSS && ah->ah_caps.halVEOLSupport) { 
    8888                ds->ds_link = bf->bf_daddr; /* self-linked */ 
    8989                flags |= HAL_TXDESC_VEOL; 
     
    9898                 * XXX assumes two antenna 
    9999                 */ 
    100                 if (sc->sc_stagbeacons) 
    101                         antenna = ((sc->ast_be_xmit / 
    102                                         sc->sc_nbcnvaps) & 1 ? 2 : 1); 
    103                 else 
    104                         antenna = (sc->ast_be_xmit & 1 ? 2 : 1); 
     100                antenna = ((sc->ast_be_xmit / sc->sc_nbcnvaps) & 1 ? 2 : 1); 
    105101        } 
    106102 
     
    129125        ath9k_hw_filltxdesc(ah, ds 
    130126                           , roundup(skb->len, 4) /* buffer length */ 
    131                            , AH_TRUE /* first segment */ 
    132                            , AH_TRUE /* last segment */ 
     127                           , true /* first segment */ 
     128                           , true /* last segment */ 
    133129                           , ds /* first descriptor */ 
    134130                ); 
     
    220216 
    221217        if (avp->av_bcbuf == NULL) { 
    222                 DPRINTF(sc, ATH_DEBUG_BEACON, "%s: avp=%p av_bcbuf=%p\n", 
     218                DPRINTF(sc, ATH_DBG_BEACON, "%s: avp=%p av_bcbuf=%p\n", 
    223219                        __func__, avp, avp->av_bcbuf); 
    224220                return NULL; 
     
    273269                 * acquires txq lock inside. 
    274270                 */ 
    275                 if (sc->sc_nvaps > 1 && sc->sc_stagbeacons) { 
    276                         ath_tx_draintxq(sc, cabq, AH_FALSE); 
    277                         DPRINTF(sc, ATH_DEBUG_BEACON, 
     271                if (sc->sc_nvaps > 1) { 
     272                        ath_tx_draintxq(sc, cabq, false); 
     273                        DPRINTF(sc, ATH_DBG_BEACON, 
    278274                                "%s: flush previous cabq traffic\n", __func__); 
    279275                } 
     
    310306 
    311307        if (avp->av_bcbuf == NULL) { 
    312                 DPRINTF(sc, ATH_DEBUG_BEACON, "%s: avp=%p av_bcbuf=%p\n", 
     308                DPRINTF(sc, ATH_DBG_BEACON, "%s: avp=%p av_bcbuf=%p\n", 
    313309                        __func__, avp, avp != NULL ? avp->av_bcbuf : NULL); 
    314310                return; 
     
    323319        ath9k_hw_puttxbuf(ah, sc->sc_bhalq, bf->bf_daddr); 
    324320        ath9k_hw_txstart(ah, sc->sc_bhalq); 
    325         DPRINTF(sc, ATH_DEBUG_BEACON, "%s: TXDP%u = %llx (%p)\n", __func__, 
     321        DPRINTF(sc, ATH_DBG_BEACON, "%s: TXDP%u = %llx (%p)\n", __func__, 
    326322                sc->sc_bhalq, ito64(bf->bf_daddr), bf->bf_desc); 
    327323} 
     
    378374                list_del(&avp->av_bcbuf->list); 
    379375 
    380                 if (sc->sc_opmode == HAL_M_HOSTAP || !sc->sc_hasveol) { 
     376                if (sc->sc_opmode == HAL_M_HOSTAP || 
     377                        !sc->sc_ah->ah_caps.halVEOLSupport) { 
    381378                        int slot; 
    382379                        /* 
     
    400397                                        /* NB: keep looking for a double slot */ 
    401398                                } 
    402                         KASSERT(sc->sc_bslot[avp->av_bslot] == ATH_IF_ID_ANY, 
    403                                 ("beacon slot %u not empty?", avp->av_bslot)); 
     399                        BUG_ON(sc->sc_bslot[avp->av_bslot] != ATH_IF_ID_ANY); 
    404400                        sc->sc_bslot[avp->av_bslot] = if_id; 
    405401                        sc->sc_nbcnvaps++; 
     
    410406        bf = avp->av_bcbuf; 
    411407        if (bf->bf_mpdu != NULL) { 
    412                 struct ath_xmit_status tx_status; 
    413  
    414                 skb = (struct sk_buff *) bf->bf_mpdu; 
     408                skb = (struct sk_buff *)bf->bf_mpdu; 
    415409                ath_skb_unmap_single(sc, skb, PCI_DMA_TODEVICE, 
    416410                                     get_dma_mem_context(bf, bf_dmacontext)); 
    417                 tx_status.flags = 0; 
    418                 tx_status.retries = 0; 
    419                 ath_tx_complete(sc, skb, &tx_status, NULL); 
     411                dev_kfree_skb_any(skb); 
    420412                bf->bf_mpdu = NULL; 
    421413        } 
     
    425417         * we assume the wbuf routines will return us something 
    426418         * with this alignment (perhaps should assert). 
    427          */ 
    428         skb = ath_get_beacon(sc, if_id, &avp->av_boff, &avp->av_btxctl); 
     419         * FIXME: Fill avp->av_boff.bo_tim,avp->av_btxctl.txpower and 
     420         * avp->av_btxctl.shortPreamble 
     421         */ 
     422        skb = ieee80211_beacon_get(sc->hw, avp->av_if_data); 
    429423        if (skb == NULL) { 
    430                 DPRINTF(sc, ATH_DEBUG_BEACON, "%s: cannot get skb\n", 
     424                DPRINTF(sc, ATH_DBG_BEACON, "%s: cannot get skb\n", 
    431425                        __func__); 
    432426                return -ENOMEM; 
     
    439433         * following the header. 
    440434         */ 
    441         if (sc->sc_stagbeacons && avp->av_bslot > 0) { 
     435        if (avp->av_bslot > 0) { 
    442436                u_int64_t tsfadjust; 
     437                __le64 val; 
    443438                int intval; 
    444439 
     
    459454                 */ 
    460455                tsfadjust = (intval * (ATH_BCBUF - avp->av_bslot)) / ATH_BCBUF; 
    461                 tsfadjust = cpu_to_le64(tsfadjust<<10);     /* TU->TSF */ 
    462  
    463                 DPRINTF(sc, ATH_DEBUG_BEACON, 
     456                val = cpu_to_le64(tsfadjust << 10);     /* TU->TSF */ 
     457 
     458                DPRINTF(sc, ATH_DBG_BEACON, 
    464459                        "%s: %s beacons, bslot %d intval %u tsfadjust %llu\n", 
    465                         __func__, sc->sc_stagbeacons ? "stagger" : "burst", 
     460                        __func__, "stagger", 
    466461                        avp->av_bslot, intval, (unsigned long long)tsfadjust); 
    467462 
    468463                wh = (struct ieee80211_hdr *)skb->data; 
    469                 memcpy(&wh[1], &tsfadjust, sizeof(tsfadjust)); 
     464                memcpy(&wh[1], &val, sizeof(val)); 
    470465        } 
    471466 
     
    496491                bf = avp->av_bcbuf; 
    497492                if (bf->bf_mpdu != NULL) { 
    498                         struct sk_buff *skb = (struct sk_buff *) bf->bf_mpdu; 
    499                         struct ath_xmit_status tx_status; 
    500  
     493                        struct sk_buff *skb = (struct sk_buff *)bf->bf_mpdu; 
    501494                        ath_skb_unmap_single(sc, skb, PCI_DMA_TODEVICE, 
    502495                                get_dma_mem_context(bf, bf_dmacontext)); 
    503                         tx_status.flags = 0; 
    504                         tx_status.retries = 0; 
    505                         ath_tx_complete(sc, skb, &tx_status, NULL); 
     496                        dev_kfree_skb_any(skb); 
    506497                        bf->bf_mpdu = NULL; 
    507498                } 
     
    528519                if (bf->bf_mpdu != NULL) { 
    529520                        struct sk_buff *skb = (struct sk_buff *) bf->bf_mpdu; 
    530                         struct ath_xmit_status tx_status; 
    531  
    532521                        ath_skb_unmap_single(sc, skb, PCI_DMA_TODEVICE, 
    533522                                get_dma_mem_context(bf, bf_dmacontext)); 
    534                         tx_status.flags = 0; 
    535                         tx_status.retries = 0; 
    536                         ath_tx_complete(sc, skb, &tx_status, NULL); 
     523                        dev_kfree_skb_any(skb); 
    537524                        bf->bf_mpdu = NULL; 
    538525                } 
     
    563550        u_int32_t show_cycles = 0; 
    564551        u_int32_t bc = 0; /* beacon count */ 
     552        u_int64_t tsf; 
     553        u_int32_t tsftu; 
     554        u_int16_t intval; 
    565555 
    566556        if (sc->sc_noreset) { 
     
    587577                if (sc->sc_bmisscount < BSTUCK_THRESH) { 
    588578                        if (sc->sc_noreset) { 
    589                                 DPRINTF(sc, ATH_DEBUG_BEACON, 
     579                                DPRINTF(sc, ATH_DBG_BEACON, 
    590580                                        "%s: missed %u consecutive beacons\n", 
    591581                                        __func__, sc->sc_bmisscount); 
     
    597587                                         */ 
    598588                                        DPRINTF(sc, 
    599                                                 ATH_DEBUG_BEACON, 
     589                                                ATH_DBG_BEACON, 
    600590                                                "%s: busy times: rx_clear=%d, " 
    601591                                                "rx_frame=%d, tx_frame=%d\n", 
     
    604594                                } else { 
    605595                                        DPRINTF(sc, 
    606                                                 ATH_DEBUG_BEACON, 
     596                                                ATH_DBG_BEACON, 
    607597                                                "%s: unable to obtain " 
    608598                                                "busy times\n", __func__); 
    609599                                } 
    610600                        } else { 
    611                                 DPRINTF(sc, ATH_DEBUG_BEACON, 
     601                                DPRINTF(sc, ATH_DBG_BEACON, 
    612602                                        "%s: missed %u consecutive beacons\n", 
    613603                                        __func__, sc->sc_bmisscount); 
     
    617607                                if (sc->sc_bmisscount == BSTUCK_THRESH) { 
    618608                                        DPRINTF(sc, 
    619                                                 ATH_DEBUG_BEACON, 
     609                                                ATH_DBG_BEACON, 
    620610                                                "%s: beacon is officially " 
    621611                                                "stuck\n", __func__); 
     
    623613                                } 
    624614                        } else { 
    625                                 DPRINTF(sc, ATH_DEBUG_BEACON, 
     615                                DPRINTF(sc, ATH_DBG_BEACON, 
    626616                                        "%s: beacon is officially stuck\n", 
    627617                                        __func__); 
     
    635625                if (sc->sc_noreset) { 
    636626                        DPRINTF(sc, 
    637                                 ATH_DEBUG_BEACON, 
     627                                ATH_DBG_BEACON, 
    638628                                "%s: resume beacon xmit after %u misses\n", 
    639629                                __func__, sc->sc_bmisscount); 
    640630                } else { 
    641                         DPRINTF(sc, ATH_DEBUG_BEACON, 
     631                        DPRINTF(sc, ATH_DBG_BEACON, 
    642632                                "%s: resume beacon xmit after %u misses\n", 
    643633                                __func__, sc->sc_bmisscount); 
     
    647637 
    648638        /* 
    649          * Generate beacon frames.  If we are sending frames 
    650          * staggered then calculate the slot for this frame based 
     639         * Generate beacon frames. we are sending frames 
     640         * staggered so calculate the slot for this frame based 
    651641         * on the tsf to safeguard against missing an swba. 
    652          * Otherwise we are bursting all frames together and need 
    653          * to generate a frame for each vap that is up and running. 
    654          */ 
    655         if (sc->sc_stagbeacons) { 
    656                 /* staggered beacons */ 
    657                 u_int64_t tsf; 
    658                 u_int32_t tsftu; 
    659                 u_int16_t intval; 
    660  
    661                 /* FIXME: Use default value for now - Sujith */ 
    662                 intval = ATH_DEFAULT_BINTVAL; 
    663  
    664                 tsf = ath9k_hw_gettsf64(ah); 
    665                 tsftu = TSF_TO_TU(tsf>>32, tsf); 
    666                 slot = ((tsftu % intval) * ATH_BCBUF) / intval; 
    667                 if_id = sc->sc_bslot[(slot + 1) % ATH_BCBUF]; 
    668                 DPRINTF(sc, ATH_DEBUG_BEACON, 
     642         */ 
     643 
     644        /* FIXME: Use default value for now - Sujith */ 
     645        intval = ATH_DEFAULT_BINTVAL; 
     646 
     647        tsf = ath9k_hw_gettsf64(ah); 
     648        tsftu = TSF_TO_TU(tsf>>32, tsf); 
     649        slot = ((tsftu % intval) * ATH_BCBUF) / intval; 
     650        if_id = sc->sc_bslot[(slot + 1) % ATH_BCBUF]; 
     651        DPRINTF(sc, ATH_DBG_BEACON, 
    669652                        "%s: slot %d [tsf %llu tsftu %u intval %u] if_id %d\n", 
    670653                        __func__, slot, (unsigned long long) tsf, tsftu, 
    671654                        intval, if_id); 
    672                 bfaddr = 0; 
    673                 if (if_id != ATH_IF_ID_ANY) { 
    674                         bf = ath_beacon_generate(sc, if_id); 
    675                         if (bf != NULL) { 
    676                                 bfaddr = bf->bf_daddr; 
    677                                 bc = 1; 
    678                         } 
    679                 } 
    680         } else { 
    681                 /* XXX: Clean this up, move work to a helper */ 
    682                 /* burst'd beacons */ 
    683                 u_int32_t *bflink; 
    684                 bflink = &bfaddr; 
    685                 /* XXX rotate/randomize order? */ 
    686                 for (slot = 0; slot < ATH_BCBUF; slot++) { 
    687                         if_id = sc->sc_bslot[slot]; 
    688                         if (if_id != ATH_IF_ID_ANY) { 
    689                                 bf = ath_beacon_generate(sc, if_id); 
    690                                 if (bf != NULL) { 
    691                                         *bflink = bf->bf_daddr; 
    692                                         bflink = &bf->bf_desc->ds_link; 
    693                                         bc++; 
    694                                 } 
    695                         } 
    696                 } 
    697                 *bflink = 0;    /* link of last frame */ 
     655        bfaddr = 0; 
     656        if (if_id != ATH_IF_ID_ANY) { 
     657                bf = ath_beacon_generate(sc, if_id); 
     658                if (bf != NULL) { 
     659                        bfaddr = bf->bf_daddr; 
     660                        bc = 1; 
     661                } 
    698662        } 
    699663        /* 
     
    720684                ath_setslottime(sc);        /* commit change to hardware */ 
    721685 
    722         if ((!sc->sc_stagbeacons || slot == 0) && (!sc->sc_diversity)) { 
    723                 int otherant; 
    724                 /* 
    725                  * Check recent per-antenna transmit statistics and flip 
    726                  * the default rx antenna if noticeably more frames went out 
    727                  * on the non-default antenna.  Only do this if rx diversity 
    728                  * is off. 
    729                  * XXX assumes 2 anntenae 
    730                  */ 
    731                 otherant = sc->sc_defant & 1 ? 2 : 1; 
    732                 if (sc->sc_ant_tx[otherant] > sc->sc_ant_tx[sc->sc_defant] + 
    733                         ATH_ANTENNA_DIFF) { 
    734                         DPRINTF(sc, ATH_DEBUG_BEACON, 
    735                                 "%s: flip defant to %u, %u > %u\n", 
    736                                 __func__, otherant, sc->sc_ant_tx[otherant], 
    737                                 sc->sc_ant_tx[sc->sc_defant]); 
    738                         ath_setdefantenna(sc, otherant); 
    739                 } 
    740                 sc->sc_ant_tx[1] = sc->sc_ant_tx[2] = 0; 
    741         } 
    742  
    743686        if (bfaddr != 0) { 
    744687                /* 
     
    748691                 */ 
    749692                if (!ath9k_hw_stoptxdma(ah, sc->sc_bhalq)) { 
    750                         DPRINTF(sc, ATH_DEBUG_FATAL, 
     693                        DPRINTF(sc, ATH_DBG_FATAL, 
    751694                                "%s: beacon queue %u did not stop?\n", 
    752695                                __func__, sc->sc_bhalq); 
     
    772715void ath_bstuck_process(struct ath_softc *sc) 
    773716{ 
    774         DPRINTF(sc, ATH_DEBUG_BEACON, 
     717        DPRINTF(sc, ATH_DBG_BEACON, 
    775718                "%s: stuck beacon; resetting (bmiss count %u)\n", 
    776719                __func__, sc->sc_bmisscount); 
     
    835778                /* NB: the beacon interval is kept internally in TU's */ 
    836779                intval = conf.beacon_interval & HAL_BEACON_PERIOD; 
    837                 if (sc->sc_stagbeacons) 
    838                         intval /= ATH_BCBUF;    /* for staggered beacons */ 
    839                 if ((sc->sc_nostabeacons) && 
    840                     (av_opmode == HAL_M_HOSTAP)) 
    841                         nexttbtt = 0; 
     780                intval /= ATH_BCBUF;    /* for staggered beacons */ 
    842781        } else { 
    843782                intval = conf.beacon_interval & HAL_BEACON_PERIOD; 
     
    848787        else if (intval)        /* NB: can be 0 for monitor mode */ 
    849788                nexttbtt = roundup(nexttbtt, intval); 
    850         DPRINTF(sc, ATH_DEBUG_BEACON, "%s: nexttbtt %u intval %u (%u)\n", 
     789        DPRINTF(sc, ATH_DBG_BEACON, "%s: nexttbtt %u intval %u (%u)\n", 
    851790                __func__, nexttbtt, intval, conf.beacon_interval); 
    852791        /* Check for HAL_M_HOSTAP and sc_nostabeacons for WDS client */ 
    853         if ((sc->sc_opmode == HAL_M_STA) || 
    854              ((sc->sc_opmode == HAL_M_HOSTAP) && 
    855               (av_opmode == HAL_M_STA) && 
    856               (sc->sc_nostabeacons))) { 
     792        if (sc->sc_opmode == HAL_M_STA) { 
    857793                struct hal_beacon_state bs; 
    858794                u_int64_t tsf; 
     
    937873                        bs.bs_sleepduration = bs.bs_dtimperiod; 
    938874 
    939                 DPRINTF(sc, ATH_DEBUG_BEACON, 
     875                DPRINTF(sc, ATH_DBG_BEACON, 
    940876                        "%s: tsf %llu " 
    941877                        "tsf:tu %u " 
     
    964900                        ); 
    965901 
    966                 if (!(sc->sc_nostabeacons)) { 
    967                         ath9k_hw_set_interrupts(ah, 0); 
    968                         ath9k_hw_set_sta_beacon_timers(ah, &bs); 
    969                         sc->sc_imask |= HAL_INT_BMISS; 
    970                         ath9k_hw_set_interrupts(ah, sc->sc_imask); 
    971                 } 
     902                ath9k_hw_set_interrupts(ah, 0); 
     903                ath9k_hw_set_sta_beacon_timers(ah, &bs); 
     904                sc->sc_imask |= HAL_INT_BMISS; 
     905                ath9k_hw_set_interrupts(ah, sc->sc_imask); 
    972906        } else { 
    973907                u_int64_t tsf; 
     
    991925                        } 
    992926#undef FUDGE 
    993                         DPRINTF(sc, ATH_DEBUG_BEACON, 
     927                        DPRINTF(sc, ATH_DBG_BEACON, 
    994928                                "%s: IBSS nexttbtt %u intval %u (%u)\n", 
    995929                                __func__, nexttbtt, 
     
    1005939                         */ 
    1006940                        intval |= HAL_BEACON_ENA; 
    1007                         if (!sc->sc_hasveol) 
     941                        if (!ah->ah_caps.halVEOLSupport) 
    1008942                                sc->sc_imask |= HAL_INT_SWBA; 
    1009943                        ath_beaconq_config(sc); 
     
    1024958                 * ibss mode load it once here. 
    1025959                 */ 
    1026                 if (sc->sc_opmode == HAL_M_IBSS && sc->sc_hasveol) 
     960                if (sc->sc_opmode == HAL_M_IBSS && ah->ah_caps.halVEOLSupport) 
    1027961                        ath_beacon_start_adhoc(sc, 0); 
    1028962        } 
  • trunk/package/ath9k/src/drivers/net/wireless/ath9k/core.c

    r11902 r12038  
    2020#include "regd.h" 
    2121 
    22 static int ath_outdoor = AH_FALSE;              /* enable outdoor use */ 
     22static int ath_outdoor;         /* enable outdoor use */ 
    2323 
    2424static const u_int8_t ath_bcast_mac[ETH_ALEN] = 
     
    6666        memset(sc->sc_rixmap, 0xff, sizeof(sc->sc_rixmap)); 
    6767        rt = sc->sc_rates[mode]; 
    68         KASSERT(rt != NULL, ("no h/w rate set for phy mode %u", mode)); 
     68        BUG_ON(!rt); 
    6969 
    7070        for (i = 0; i < rt->rateCount; i++) 
     
    153153                break; 
    154154        default: 
    155                 DPRINTF(sc, ATH_DEBUG_FATAL, "%s: invalid mode %u\n", 
     155                DPRINTF(sc, ATH_DBG_FATAL, "%s: invalid mode %u\n", 
    156156                        __func__, mode); 
    157157                return 0; 
     
    177177static int ath_getchannels(struct ath_softc *sc, 
    178178                           u_int cc, 
    179                            enum hal_bool outDoor, 
    180                            enum hal_bool xchanMode) 
     179                           bool outDoor, 
     180                           bool xchanMode) 
    181181{ 
    182182        struct ath_hal *ah = sc->sc_ah; 
     
    188188        chans = kmalloc(ATH_CHAN_MAX * sizeof(struct hal_channel), GFP_KERNEL); 
    189189        if (chans == NULL) { 
    190                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     190                DPRINTF(sc, ATH_DBG_FATAL, 
    191191                        "%s: unable to allocate channel table\n", __func__); 
    192192                return -ENOMEM; 
     
    206206                u_int32_t rd = ah->ah_currentRD; 
    207207 
    208                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     208                DPRINTF(sc, ATH_DBG_FATAL, 
    209209                        "%s: unable to collect channel list from hal; " 
    210210                        "regdomain likely %u country code %u\n", 
     
    291291        struct ath_hal *ah = sc->sc_ah; 
    292292 
    293         DPRINTF(sc, ATH_DEBUG_CONFIG, "%s: invalid %u\n", 
     293        DPRINTF(sc, ATH_DBG_CONFIG, "%s: invalid %u\n", 
    294294                __func__, sc->sc_invalid); 
    295295 
     
    312312        if (!sc->sc_invalid) 
    313313                ath9k_hw_set_interrupts(ah, 0); 
    314         ath_draintxq(sc, AH_FALSE); 
     314        ath_draintxq(sc, false); 
    315315        if (!sc->sc_invalid) { 
    316316                ath_stoprecv(sc); 
     
    343343        /* Restore previous power management state. */ 
    344344 
    345         DPRINTF(sc, ATH_DEBUG_CONFIG, "%d.%03d | %s: RX filter 0x%x aid 0\n", 
     345        DPRINTF(sc, ATH_DBG_CONFIG, "%d.%03d | %s: RX filter 0x%x aid 0\n", 
    346346                now / 1000, now % 1000, __func__, rfilt); 
    347347} 
     
    362362 
    363363        sc->sc_scanning = 0; 
     364        /* Request for a full reset due to rx packet filter changes */ 
     365        sc->sc_full_reset = 1; 
    364366        rfilt = ath_calcrxfilter(sc); 
    365367        ath9k_hw_setrxfilter(ah, rfilt); 
    366368        ath9k_hw_write_associd(ah, sc->sc_curbssid, sc->sc_curaid); 
    367369 
    368         DPRINTF(sc, ATH_DEBUG_CONFIG, "%d.%03d | %s: RX filter 0x%x aid 0x%x\n", 
     370        DPRINTF(sc, ATH_DBG_CONFIG, "%d.%03d | %s: RX filter 0x%x aid 0x%x\n", 
    369371                now / 1000, now % 1000, __func__, rfilt, sc->sc_curaid); 
    370372} 
     
    380382{ 
    381383        struct ath_hal *ah = sc->sc_ah; 
    382         enum hal_bool fastcc = AH_TRUE, stopped; 
     384        bool fastcc = true, stopped; 
    383385        enum hal_ht_macmode ht_macmode; 
    384386 
     
    386388                return -EIO; 
    387389 
    388         DPRINTF(sc, ATH_DEBUG_CONFIG, 
     390        DPRINTF(sc, ATH_DBG_CONFIG, 
    389391                "%s: %u (%u MHz) -> %u (%u MHz), cflags:%x\n", 
    390392                __func__, 
     
    411413                 */ 
    412414                ath9k_hw_set_interrupts(ah, 0); /* disable interrupts */ 
    413                 ath_draintxq(sc, AH_FALSE);     /* clear pending tx frames */ 
     415                ath_draintxq(sc, false);        /* clear pending tx frames */ 
    414416                stopped = ath_stoprecv(sc);     /* turn off frame recv */ 
    415417 
     
    419421 
    420422                if (!stopped || sc->sc_full_reset) 
    421                         fastcc = AH_FALSE; 
     423                        fastcc = false; 
    422424 
    423425                spin_lock_bh(&sc->sc_resetlock); 
     
    427429                                        sc->sc_ht_extprotspacing, 
    428430                                        fastcc, &status)) { 
    429                         DPRINTF(sc, ATH_DEBUG_FATAL, 
     431                        DPRINTF(sc, ATH_DBG_FATAL, 
    430432                                "%s: unable to reset channel %u (%uMhz) " 
    431433                                "flags 0x%x hal status %u\n", __func__, 
     
    444446                /* Re-enable rx framework */ 
    445447                if (ath_startrecv(sc) != 0) { 
    446                         DPRINTF(sc, ATH_DEBUG_FATAL, 
     448                        DPRINTF(sc, ATH_DBG_FATAL, 
    447449                                "%s: unable to restart recv logic\n", __func__); 
    448450                        return -EIO; 
     
    508510         * enabled/disabled setting 
    509511         */ 
    510         if ((sc->sc_no_tx_3_chains == AH_FALSE) || 
    511             (sc->sc_config.chainmask_sel == AH_FALSE)) 
     512        if (sc->sc_ah->ah_caps.halTxChainMask != ATH_CHAINMASK_SEL_3X3) { 
    512513                cm->cur_tx_mask = sc->sc_tx_chainmask; 
    513514                return cm->cur_tx_mask; 
     515        } 
    514516 
    515517        if (cm->tx_avgrssi == ATH_RSSI_DUMMY_MARKER) 
     
    542544} 
    543545 
     546/* 
     547 * Update tx/rx chainmask. For legacy association, 
     548 * hard code chainmask to 1x1, for 11n association, use 
     549 * the chainmask configuration. 
     550 */ 
     551 
     552void ath_update_chainmask(struct ath_softc *sc, int is_ht) 
     553{ 
     554        sc->sc_update_chainmask = 1; 
     555        if (is_ht) { 
     556                sc->sc_tx_chainmask = sc->sc_ah->ah_caps.halTxChainMask; 
     557                sc->sc_rx_chainmask = sc->sc_ah->ah_caps.halRxChainMask; 
     558        } else { 
     559                sc->sc_tx_chainmask = 1; 
     560                sc->sc_rx_chainmask = 1; 
     561        } 
     562 
     563        DPRINTF(sc, ATH_DBG_CONFIG, "%s: tx chmask: %d, rx chmask: %d\n", 
     564                __func__, sc->sc_tx_chainmask, sc->sc_rx_chainmask); 
     565} 
     566 
    544567/******************/ 
    545568/* VAP management */ 
    546569/******************/ 
    547  
    548 /* 
    549  *  Down VAP instance 
    550  * 
    551  *  This routine will stop the indicated VAP and put it in a "down" state. 
    552  *  The down state is basically an initialization state that can be brought 
    553  *  back up by calling the opposite up routine. 
    554  *  This routine will bring the interface out of power save mode, set the 
    555  *  LED states, update the rate control processing, stop DMA transfers, and 
    556  *  set the VAP into the down state. 
    557 */ 
    558  
    559 int ath_vap_down(struct ath_softc *sc, int if_id, u_int flags) 
    560 { 
    561         struct ath_hal *ah = sc->sc_ah; 
    562         struct ath_vap *avp; 
    563  
    564         avp = sc->sc_vaps[if_id]; 
    565         if (avp == NULL) { 
    566                 DPRINTF(sc, ATH_DEBUG_FATAL, "%s: invalid interface id %u\n", 
    567                         __func__, if_id); 
    568                 return -EINVAL; 
    569         } 
    570  
    571 #ifdef CONFIG_SLOW_ANT_DIV 
    572         if (sc->sc_slowAntDiv) 
    573                 ath_slow_ant_div_stop(&sc->sc_antdiv); 
    574 #endif 
    575  
    576         /* update ratectrl about the new state */ 
    577         ath_rate_newstate(sc, avp, 0); 
    578  
    579         /* Reclaim beacon resources */ 
    580         if (sc->sc_opmode == HAL_M_HOSTAP || sc->sc_opmode == HAL_M_IBSS) { 
    581                 ath9k_hw_stoptxdma(ah, sc->sc_bhalq); 
    582                 ath_beacon_return(sc, avp); 
    583         } 
    584  
    585         if (flags & ATH_IF_HW_OFF) { 
    586                 sc->sc_imask &= ~(HAL_INT_SWBA | HAL_INT_BMISS); 
    587                 ath9k_hw_set_interrupts(ah, sc->sc_imask & ~HAL_INT_GLOBAL); 
    588                 sc->sc_beacons = 0; 
    589         } 
    590  
    591         return 0; 
    592 } 
    593570 
    594571/* 
     
    609586        avp = sc->sc_vaps[if_id]; 
    610587        if (avp == NULL) { 
    611                 DPRINTF(sc, ATH_DEBUG_FATAL, "%s: invalid interface id %u\n", 
     588                DPRINTF(sc, ATH_DBG_FATAL, "%s: invalid interface id %u\n", 
    612589                        __func__, if_id); 
    613590                return -EINVAL; 
     
    615592 
    616593#ifdef CONFIG_SLOW_ANT_DIV 
    617         if (sc->sc_slowAntDiv) 
    618                 ath_slow_ant_div_stop(&sc->sc_antdiv); 
     594        ath_slow_ant_div_stop(&sc->sc_antdiv); 
    619595#endif 
    620596 
     
    631607                sc->sc_curaid = 0; 
    632608 
    633         DPRINTF(sc, ATH_DEBUG_CONFIG, 
     609        DPRINTF(sc, ATH_DBG_CONFIG, 
    634610                "%s: RX filter 0x%x bssid %s aid 0x%x\n", 
    635611                __func__, rfilt, print_mac(mac, 
     
    649625} 
    650626 
    651 int ath_vap_join(struct ath_softc *sc, int if_id, 
    652                  const u_int8_t bssid[ETH_ALEN], u_int flags) 
    653 { 
    654         struct ath_hal *ah = sc->sc_ah; 
    655         struct ath_vap *avp; 
    656         u_int32_t rfilt = 0; 
    657         DECLARE_MAC_BUF(mac); 
    658  
    659         avp = sc->sc_vaps[if_id]; 
    660         if (avp == NULL) { 
    661                 DPRINTF(sc, ATH_DEBUG_FATAL, "%s: invalid interface id %u\n", 
    662                         __func__, if_id); 
    663                 return -EINVAL; 
    664         } 
    665  
    666         /* update ratectrl about the new state */ 
    667         ath_rate_newstate(sc, avp, 0); 
    668  
    669         rfilt = ath_calcrxfilter(sc); 
    670         ath9k_hw_setrxfilter(ah, rfilt); 
    671  
    672         memcpy(sc->sc_curbssid, bssid, ETH_ALEN); 
    673         sc->sc_curaid = 0; 
    674         ath9k_hw_write_associd(ah, sc->sc_curbssid, sc->sc_curaid); 
    675  
    676         DPRINTF(sc, ATH_DEBUG_CONFIG, 
    677                 "%s: RX filter 0x%x bssid %s aid 0x%x\n", 
    678                 __func__, rfilt, 
    679                 print_mac(mac, sc->sc_curbssid), sc->sc_curaid); 
    680  
    681         /* 
    682          * Update tx/rx chainmask. For legacy association, 
    683          * hard code chainmask to 1x1, for 11n association, use 
    684          * the chainmask configuration. 
    685          */ 
    686         sc->sc_update_chainmask = 1; 
    687         if (flags & ATH_IF_HT) { 
    688                 sc->sc_tx_chainmask = ah->ah_caps.halTxChainMask; 
    689                 sc->sc_rx_chainmask = ah->ah_caps.halRxChainMask; 
    690         } else { 
    691                 sc->sc_tx_chainmask = 1; 
    692                 sc->sc_rx_chainmask = 1; 
    693         } 
    694  
    695         /* Enable rx chain mask detection if configured to do so */ 
    696  
    697         sc->sc_rx_chainmask_detect = 0; 
    698  
    699         /* Set aggregation protection mode parameters */ 
    700  
    701         sc->sc_config.ath_aggr_prot = 0; 
    702  
    703         /* 
    704          * Reset our TSF so that its value is lower than the beacon that we are 
    705          * trying to catch. Only then hw will update its TSF register with the 
    706          * new beacon. Reset the TSF before setting the BSSID to avoid allowing 
    707          * in any frames that would update our TSF only to have us clear it 
    708          * immediately thereafter. 
    709          */ 
    710         ath9k_hw_reset_tsf(ah); 
    711  
    712         /* 
    713          * XXXX 
    714          * Disable BMISS interrupt when we're not associated 
    715          */ 
    716         ath9k_hw_set_interrupts(ah, 
    717                 sc->sc_imask & ~(HAL_INT_SWBA | HAL_INT_BMISS)); 
    718         sc->sc_imask &= ~(HAL_INT_SWBA | HAL_INT_BMISS); 
    719         /* need to reconfigure the beacons when it moves to RUN */ 
    720         sc->sc_beacons = 0; 
    721  
    722         return 0; 
    723 } 
    724  
    725 int ath_vap_up(struct ath_softc *sc, 
    726                int if_id, 
    727                const u_int8_t bssid[ETH_ALEN], 
    728                u_int8_t aid, u_int flags) 
    729 { 
    730         struct ath_hal *ah = sc->sc_ah; 
    731         struct ath_vap *avp; 
    732         u_int32_t rfilt = 0; 
    733         int i, error = 0; 
    734         DECLARE_MAC_BUF(mac); 
    735  
    736         ASSERT(if_id != ATH_IF_ID_ANY); 
    737         avp = sc->sc_vaps[if_id]; 
    738         if (avp == NULL) { 
    739                 DPRINTF(sc, ATH_DEBUG_FATAL, "%s: invalid interface id %u\n", 
    740                         __func__, if_id); 
    741                 return -EINVAL; 
    742         } 
    743  
    744         /* update ratectrl about the new state */ 
    745         ath_rate_newstate(sc, avp, 1); 
    746  
    747         rfilt = ath_calcrxfilter(sc); 
    748         ath9k_hw_setrxfilter(ah, rfilt); 
    749  
    750         if (avp->av_opmode == HAL_M_STA || avp->av_opmode == HAL_M_IBSS) { 
    751                 memcpy(sc->sc_curbssid, bssid, ETH_ALEN); 
    752                 sc->sc_curaid = aid; 
    753                 ath9k_hw_write_associd(ah, sc->sc_curbssid, sc->sc_curaid); 
    754         } 
    755  
    756         DPRINTF(sc, ATH_DEBUG_CONFIG, 
    757                 "%s: RX filter 0x%x bssid %s aid 0x%x\n", 
    758                 __func__, rfilt, 
    759                 print_mac(mac, sc->sc_curbssid), sc->sc_curaid); 
    760  
    761         if ((avp->av_opmode != IEEE80211_IF_TYPE_STA) && 
    762                 (flags & ATH_IF_PRIVACY)) { 
    763                 for (i = 0; i < IEEE80211_WEP_NKID; i++) 
    764                         if (ath9k_hw_keyisvalid(ah, (u_int16_t) i)) 
    765                                 ath9k_hw_keysetmac(ah, (u_int16_t) i, bssid); 
    766         } 
    767  
    768         switch (avp->av_opmode) { 
    769         case HAL_M_HOSTAP: 
    770         case HAL_M_IBSS: 
    771                 /* 
    772                  * Allocate and setup the beacon frame. 
    773                  * 
    774                  * Stop any previous beacon DMA.  This may be 
    775                  * necessary, for example, when an ibss merge 
    776                  * causes reconfiguration; there will be a state 
    777                  * transition from RUN->RUN that means we may 
    778                  * be called with beacon transmission active. 
    779                  */ 
    780                 ath9k_hw_stoptxdma(ah, sc->sc_bhalq); 
    781  
    782                 error = ath_beacon_alloc(sc, if_id); 
    783                 if (error != 0) 
    784                         goto bad; 
    785  
    786                 if (flags & ATH_IF_BEACON_ENABLE) 
    787                         sc->sc_beacons = 0; 
    788  
    789                 break; 
    790         case HAL_M_STA: 
    791                 /* 
    792                  * start rx chain mask detection if it is enabled. 
    793                  * Use the default chainmask as starting point. 
    794                  */ 
    795                 if (sc->sc_rx_chainmask_detect) { 
    796                         if (flags & ATH_IF_HT) 
    797                                 sc->sc_rx_chainmask = 
    798                                         ah->ah_caps.halRxChainMask; 
    799                         else 
    800                                 sc->sc_rx_chainmask = 1; 
    801  
    802                         sc->sc_rx_chainmask_start = 1; 
    803                 } 
    804                 break; 
    805         default: 
    806                 break; 
    807         } 
    808         /* Moved beacon_config after dfs_wait check 
    809          * so that ath_beacon_config won't be called duing dfswait 
    810          * period - this will fix the beacon stuck afer DFS 
    811          * CAC period issue 
    812          * Configure the beacon and sleep timers. */ 
    813  
    814         if (!sc->sc_beacons && !(flags & ATH_IF_BEACON_SYNC)) { 
    815                 ath_beacon_config(sc, if_id); 
    816                 sc->sc_beacons = 1; 
    817         } 
    818  
    819         /* Reset rssi stats; maybe not the best place... */ 
    820         if (flags & ATH_IF_HW_ON) { 
    821                 sc->sc_halstats.ns_avgbrssi = ATH_RSSI_DUMMY_MARKER; 
    822                 sc->sc_halstats.ns_avgrssi = ATH_RSSI_DUMMY_MARKER; 
    823                 sc->sc_halstats.ns_avgtxrssi = ATH_RSSI_DUMMY_MARKER; 
    824                 sc->sc_halstats.ns_avgtxrate = ATH_RATE_DUMMY_MARKER; 
    825         } 
    826 bad: 
    827         return error; 
    828 } 
    829  
    830627int ath_vap_attach(struct ath_softc *sc, 
    831628                   int if_id, 
    832629                   struct ieee80211_vif *if_data, 
    833                    enum hal_opmode opmode, 
    834                    enum hal_opmode iv_opmode, 
    835                    int nostabeacons) 
     630                   enum hal_opmode opmode) 
    836631{ 
    837632        struct ath_vap *avp; 
    838633 
    839634        if (if_id >= ATH_BCBUF || sc->sc_vaps[if_id] != NULL) { 
    840                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     635                DPRINTF(sc, ATH_DBG_FATAL, 
    841636                        "%s: Invalid interface id = %u\n", __func__, if_id); 
    842637                return -EINVAL; 
     
    845640        switch (opmode) { 
    846641        case HAL_M_STA: 
    847                 sc->sc_nostabeacons = nostabeacons; 
    848                 break; 
    849642        case HAL_M_IBSS: 
    850643        case HAL_M_MONITOR: 
    851644                break; 
    852645        case HAL_M_HOSTAP: 
    853                 /* copy nostabeacons - for WDS client */ 
    854                 sc->sc_nostabeacons = nostabeacons; 
    855646                /* XXX not right, beacon buffer is allocated on RUN trans */ 
    856647                if (list_empty(&sc->sc_bbuf)) 
     
    869660        avp->av_if_data = if_data; 
    870661        /* Set the VAP opmode */ 
    871         avp->av_opmode = iv_opmode; 
     662        avp->av_opmode = opmode; 
    872663        avp->av_bslot = -1; 
    873664        INIT_LIST_HEAD(&avp->av_mcastq.axq_q); 
    874665        INIT_LIST_HEAD(&avp->av_mcastq.axq_acq); 
    875666        spin_lock_init(&avp->av_mcastq.axq_lock); 
    876         if (opmode == HAL_M_HOSTAP || opmode == HAL_M_IBSS) { 
    877                 if (sc->sc_hastsfadd) { 
    878                         /* 
    879                          * Multiple vaps are to transmit beacons and we 
    880                          * have h/w support for TSF adjusting; enable use 
    881                          * of staggered beacons. 
    882                          */ 
    883                         /* XXX check for beacon interval too small */ 
    884                         sc->sc_stagbeacons = 1; 
    885                 } 
    886         } 
    887         if (sc->sc_hastsfadd) 
    888                 ath9k_hw_set_tsfadjust(sc->sc_ah, sc->sc_stagbeacons); 
     667 
     668        ath9k_hw_set_tsfadjust(sc->sc_ah, 1); 
    889669 
    890670        sc->sc_vaps[if_id] = avp; 
     
    907687        avp = sc->sc_vaps[if_id]; 
    908688        if (avp == NULL) { 
    909                 DPRINTF(sc, ATH_DEBUG_FATAL, "%s: invalid interface id %u\n", 
     689                DPRINTF(sc, ATH_DBG_FATAL, "%s: invalid interface id %u\n", 
    910690                        __func__, if_id); 
    911691                return -EINVAL; 
     
    920700         */ 
    921701        ath9k_hw_set_interrupts(ah, 0); /* disable interrupts */ 
    922         ath_draintxq(sc, AH_FALSE);     /* stop xmit side */ 
     702        ath_draintxq(sc, false);        /* stop xmit side */ 
    923703        ath_stoprecv(sc);       /* stop recv side */ 
    924704        ath_flushrecv(sc);      /* flush recv queue */ 
    925705 
    926706        /* Reclaim any pending mcast bufs on the vap. */ 
    927         ath_tx_draintxq(sc, &avp->av_mcastq, AH_FALSE); 
    928  
    929         if (sc->sc_opmode == HAL_M_HOSTAP && sc->sc_nostabeacons) 
    930                 sc->sc_nostabeacons = 0; 
     707        ath_tx_draintxq(sc, &avp->av_mcastq, false); 
    931708 
    932709        kfree(avp); 
     
    934711        sc->sc_nvaps--; 
    935712 
    936         /* restart H/W in case there are other VAPs */ 
    937         if (sc->sc_nvaps) { 
    938                 /* Restart rx+tx machines if device is still running. */ 
    939                 if (ath_startrecv(sc) != 0)     /* restart recv */ 
    940                         DPRINTF(sc, ATH_DEBUG_FATAL, 
    941                                 "%s: unable to start recv logic\n", __func__); 
    942                 if (sc->sc_beacons) 
    943                         /* restart beacons */ 
    944                         ath_beacon_config(sc, ATH_IF_ID_ANY); 
    945  
    946                 ath9k_hw_set_interrupts(ah, sc->sc_imask); 
    947         } 
    948713        return 0; 
    949714} 
     
    955720 
    956721        if (if_id >= ATH_BCBUF) { 
    957                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     722                DPRINTF(sc, ATH_DBG_FATAL, 
    958723                        "%s: Invalid interface id = %u\n", __func__, if_id); 
    959724                return -EINVAL; 
     
    980745        enum hal_ht_macmode ht_macmode = ath_cwm_macmode(sc); 
    981746 
    982         DPRINTF(sc, ATH_DEBUG_CONFIG, "%s: mode %d\n", __func__, sc->sc_opmode); 
     747        DPRINTF(sc, ATH_DBG_CONFIG, "%s: mode %d\n", __func__, sc->sc_opmode); 
    983748 
    984749        /* 
     
    1007772        if (!ath9k_hw_reset(ah, sc->sc_opmode, &sc->sc_curchan, ht_macmode, 
    1008773                           sc->sc_tx_chainmask, sc->sc_rx_chainmask, 
    1009                            sc->sc_ht_extprotspacing, AH_FALSE, &status)) { 
    1010                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     774                           sc->sc_ht_extprotspacing, false, &status)) { 
     775                DPRINTF(sc, ATH_DBG_FATAL, 
    1011776                        "%s: unable to reset hardware; hal status %u " 
    1012777                        "(freq %u flags 0x%x)\n", __func__, status, 
     
    1031796         */ 
    1032797        if (ath_startrecv(sc) != 0) { 
    1033                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     798                DPRINTF(sc, ATH_DBG_FATAL, 
    1034799                        "%s: unable to start recv logic\n", __func__); 
    1035800                error = -EIO; 
     
    1044809                sc->sc_imask |= HAL_INT_GTT; 
    1045810 
    1046         if (sc->sc_hashtsupport) 
     811        if (ah->ah_caps.halHTSupport) 
    1047812                sc->sc_imask |= HAL_INT_CST; 
    1048813 
     
    1051816         * Note we only do this (at the moment) for station mode. 
    1052817         */ 
    1053         if (sc->sc_needmib && 
     818        if (ath9k_hw_phycounters(ah) && 
    1054819            ((sc->sc_opmode == HAL_M_STA) || (sc->sc_opmode == HAL_M_IBSS))) 
    1055820                sc->sc_imask |= HAL_INT_MIB; 
     
    1102867 
    1103868        if (ath_startrecv(sc) != 0)     /* restart recv */ 
    1104                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     869                DPRINTF(sc, ATH_DBG_FATAL, 
    1105870                        "%s: unable to start recv logic\n", __func__); 
    1106871 
     
    1144909                           ht_macmode, 
    1145910                           sc->sc_tx_chainmask, sc->sc_rx_chainmask, 
    1146                            sc->sc_ht_extprotspacing, AH_FALSE, &status)) { 
    1147                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     911                           sc->sc_ht_extprotspacing, false, &status)) { 
     912                DPRINTF(sc, ATH_DBG_FATAL, 
    1148913                        "%s: unable to reset hardware; hal status %u\n", 
    1149914                        __func__, status); 
     
    1181946 * It's the caller's responsibility to ensure the chip is awake. */ 
    1182947 
    1183 int ath_intr(struct ath_softc *sc) 
    1184 { 
     948irqreturn_t ath_isr(int irq, void *dev) 
     949{ 
     950        struct ath_softc *sc = dev; 
    1185951        struct ath_hal *ah = sc->sc_ah; 
    1186952        enum hal_int status; 
    1187         int sched = ATH_ISR_NOSCHED; 
     953        bool sched = false; 
    1188954 
    1189955        do { 
     
    1194960                         * on if the IRQ is shared. 
    1195961                         */ 
    1196                         return ATH_ISR_NOTMINE; 
     962                        return IRQ_NONE; 
    1197963                } 
    1198964                if (!ath9k_hw_intrpend(ah)) {   /* shared irq, not for us */ 
    1199                         return ATH_ISR_NOTMINE; 
     965                        return IRQ_NONE; 
    1200966                } 
    1201967 
     
    1216982 
    1217983                if (!status) 
    1218                         return ATH_ISR_NOTMINE; 
     984                        return IRQ_NONE; 
    1219985 
    1220986                sc->sc_intrstatus = status; 
     
    1222988                if (status & HAL_INT_FATAL) { 
    1223989                        /* need a chip reset */ 
    1224                         sched = ATH_ISR_SCHED; 
     990                        sched = true; 
    1225991                } else if (status & HAL_INT_RXORN) { 
    1226992                        /* need a chip reset */ 
    1227                         sched = ATH_ISR_SCHED; 
     993                        sched = true; 
    1228994                } else { 
    1229995                        if (status & HAL_INT_SWBA) { 
     
    12371003                                 *     at least on older hardware revs. 
    12381004                                 */ 
    1239                                 sched = ATH_ISR_SCHED; 
     1005                                sched = true; 
    12401006                        } 
    12411007 
    12421008                        if (status & HAL_INT_TXURN) 
    12431009                                /* bump tx trigger level */ 
    1244                                 ath9k_hw_updatetxtriglevel(ah, AH_TRUE); 
     1010                                ath9k_hw_updatetxtriglevel(ah, true); 
    12451011                        /* XXX: optimize this */ 
    12461012                        if (status & HAL_INT_RX) 
    1247                                 sched = ATH_ISR_SCHED; 
     1013                                sched = true; 
    12481014                        if (status & HAL_INT_TX) 
    1249                                 sched = ATH_ISR_SCHED; 
     1015                                sched = true; 
    12501016                        if (status & HAL_INT_BMISS) 
    1251                                 sched = ATH_ISR_SCHED; 
     1017                                sched = true; 
    12521018                        /* carrier sense timeout */ 
    12531019                        if (status & HAL_INT_CST) 
    1254                                 sched = ATH_ISR_SCHED; 
     1020                                sched = true; 
    12551021                        if (status & HAL_INT_MIB) { 
    12561022                                /* 
     
    12691035                        } 
    12701036                        if (status & HAL_INT_TIM_TIMER) { 
    1271                                 if (!sc->sc_hasautosleep) { 
     1037                                if (!ah->ah_caps.halAutoSleepSupport) { 
    12721038                                        /* Clear RxAbort bit so that we can 
    12731039                                         * receive frames */ 
    12741040                                        ath9k_hw_setrxabort(ah, 0); 
    1275                                         /* Set flag indicating we're waiting 
    1276                                          * for a beacon */ 
    1277                                         sc->sc_waitbeacon = 1; 
    1278  
    1279                                         sched = ATH_ISR_SCHED; 
     1041                                        sched = true; 
    12801042                                } 
    12811043                        } 
     
    12831045        } while (0); 
    12841046 
    1285         if (sched == ATH_ISR_SCHED) 
     1047        if (sched) { 
    12861048                /* turn off every interrupt except SWBA */ 
    12871049                ath9k_hw_set_interrupts(ah, (sc->sc_imask & HAL_INT_SWBA)); 
    1288  
    1289         return sched; 
    1290  
     1050                tasklet_schedule(&sc->intr_tq); 
     1051        } 
     1052 
     1053        return IRQ_HANDLED; 
    12911054} 
    12921055 
     
    13361099} 
    13371100 
    1338 void ath_set_macmode(struct ath_softc *sc, enum hal_ht_macmode macmode) 
    1339 { 
    1340         ath9k_hw_set11nmac2040(sc->sc_ah, macmode); 
    1341 } 
    1342  
    13431101int ath_init(u_int16_t devid, struct ath_softc *sc) 
    13441102{ 
     
    13531111 
    13541112        sc->sc_debug = DBG_DEFAULT; 
    1355         DPRINTF(sc, ATH_DEBUG_CONFIG, "%s: devid 0x%x\n", __func__, devid); 
     1113        DPRINTF(sc, ATH_DBG_CONFIG, "%s: devid 0x%x\n", __func__, devid); 
    13561114 
    13571115        /* Initialize tasklet */ 
     
    13721130        ah = ath9k_hw_attach(devid, sc, sc->mem, &status); 
    13731131        if (ah == NULL) { 
    1374                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     1132                DPRINTF(sc, ATH_DBG_FATAL, 
    13751133                        "%s: unable to attach hardware; HAL status %u\n", 
    13761134                        __func__, status); 
     
    13831141        sc->sc_rtsaggrlimit = ah->ah_caps.halRtsAggrLimit; 
    13841142 
    1385         /* 
    1386          * Check if the MAC has multi-rate retry support. 
    1387          * We do this by trying to setup a fake extended 
    1388          * descriptor.  MAC's that don't have support will 
    1389          * return false w/o doing anything.  MAC's that do 
    1390          * support it will return true w/o doing anything. 
    1391          * 
    1392          *  XXX This is lame.  Just query a hal property, Luke! 
    1393          */ 
    1394         sc->sc_mrretry = ath9k_hw_setupxtxdesc(ah, NULL, 0, 0, 0, 0, 0, 0); 
    1395  
    1396         /* 
    1397          * Check if the device has hardware counters for PHY 
    1398          * errors.  If so we need to enable the MIB interrupt 
    1399          * so we can act on stat triggers. 
    1400          */ 
    1401         if (ath9k_hw_phycounters(ah)) 
    1402                 sc->sc_needmib = 1; 
    1403  
    14041143        /* Get the hardware key cache size. */ 
    14051144        sc->sc_keymax = ah->ah_caps.halKeyCacheSize; 
    14061145        if (sc->sc_keymax > ATH_KEYMAX) { 
    1407                 DPRINTF(sc, ATH_DEBUG_KEYCACHE, 
     1146                DPRINTF(sc, ATH_DBG_KEYCACHE, 
    14081147                        "%s: Warning, using only %u entries in %u key cache\n", 
    14091148                        __func__, ATH_KEYMAX, sc->sc_keymax); 
     
    14641203        sc->sc_bhalq = ath_beaconq_setup(ah); 
    14651204        if (sc->sc_bhalq == -1) { 
    1466                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     1205                DPRINTF(sc, ATH_DBG_FATAL, 
    14671206                        "%s: unable to setup a beacon xmit queue\n", __func__); 
    14681207                error = -EIO; 
     
    14711210        sc->sc_cabq = ath_txq_setup(sc, HAL_TX_QUEUE_CAB, 0); 
    14721211        if (sc->sc_cabq == NULL) { 
    1473                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     1212                DPRINTF(sc, ATH_DBG_FATAL, 
    14741213                        "%s: unable to setup CAB xmit queue\n", __func__); 
    14751214                error = -EIO; 
     
    14861225        /* NB: ensure BK queue is the lowest priority h/w queue */ 
    14871226        if (!ath_tx_setup(sc, HAL_WME_AC_BK)) { 
    1488                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     1227                DPRINTF(sc, ATH_DBG_FATAL, 
    14891228                        "%s: unable to setup xmit queue for BK traffic\n", 
    14901229                        __func__); 
     
    14941233 
    14951234        if (!ath_tx_setup(sc, HAL_WME_AC_BE)) { 
    1496                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     1235                DPRINTF(sc, ATH_DBG_FATAL, 
    14971236                        "%s: unable to setup xmit queue for BE traffic\n", 
    14981237                        __func__); 
     
    15011240        } 
    15021241        if (!ath_tx_setup(sc, HAL_WME_AC_VI)) { 
    1503                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     1242                DPRINTF(sc, ATH_DBG_FATAL, 
    15041243                        "%s: unable to setup xmit queue for VI traffic\n", 
    15051244                        __func__); 
     
    15081247        } 
    15091248        if (!ath_tx_setup(sc, HAL_WME_AC_VO)) { 
    1510                 DPRINTF(sc, ATH_DEBUG_FATAL, 
     1249                DPRINTF(sc, ATH_DBG_FATAL, 
    15111250                        "%s: unable to setup xmit queue for VO traffic\n", 
    15121251                        __func__); 
     
    15141253                goto bad2; 
    15151254        } 
    1516  
    1517         if (ah->ah_caps.halHTSupport) 
    1518                 sc->sc_hashtsupport = 1; 
    15191255 
    15201256        sc->sc_rc = ath_rate_attach(ah); 
     
    15331269                ath9k_hw_setcapability(sc->sc_ah, HAL_CAP_TKIP_MIC, 0, 1, NULL); 
    15341270        } 
    1535         sc->sc_hasclrkey = ath9k_hw_getcapability(ah, HAL_CAP_CIPHER, 
    1536                                                   HAL_CIPHER_CLR, NULL); 
    15371271 
    15381272        /* 
     
    15571291 
    15581292        /* 11n Capabilities */ 
    1559         if (sc->sc_hashtsupport) { 
     1293        if (ah->ah_caps.halHTSupport) { 
    15601294                sc->sc_txaggr = 1; 
    15611295                sc->sc_rxaggr = 1; 
    15621296        } 
    1563  
    1564         /* Check for misc other capabilities. */ 
    1565         sc->sc_hasbmask = ah->ah_caps.halBssIdMaskSupport ? 1 : 0; 
    1566         sc->sc_hastsfadd = 
    1567                 ath9k_hw_getcapability(ah, HAL_CAP_TSF_ADJUST, 0, NULL); 
    1568  
    1569         /* 
    1570          * If we cannot transmit on three chains, prevent chain mask 
    1571          * selection logic from switching between 2x2 and 3x3 chain 
    1572          * masks based on RSSI. 
    1573          */ 
    1574         sc->sc_no_tx_3_chains = 
    1575             (ah->ah_caps.halTxChainMask == ATH_CHAINMASK_SEL_3X3) ? 
    1576                 AH_TRUE : AH_FALSE; 
    1577         sc->sc_config.chainmask_sel = sc->sc_no_tx_3_chains; 
    15781297 
    15791298        sc->sc_tx_chainmask = ah->ah_caps.halTxChainMask; 
     
    15871306        sc->sc_rxchaindetect_delta2GHz = 30; 
    15881307 
    1589         /* 
    1590          * Query the hal about antenna support 
    1591          * Enable rx fast diversity if hal has support 
    1592          */ 
    1593         if (ath9k_hw_getcapability(ah, HAL_CAP_DIVERSITY, 0, NULL)) { 
    1594                 sc->sc_hasdiversity = 1; 
    1595                 ath9k_hw_setcapability(ah, HAL_CAP_DIVERSITY, 
    1596                         1, AH_TRUE, NULL); 
    1597                 sc->sc_diversity = 1; 
    1598         } else { 
    1599                 sc->sc_hasdiversity = 0; 
    1600                 sc->sc_diversity = 0; 
    1601                 ath9k_hw_setcapability(ah, HAL_CAP_DIVERSITY, 
    1602                         1, AH_FALSE, NULL); 
    1603         } 
     1308        ath9k_hw_setcapability(ah, HAL_CAP_DIVERSITY, 1, true, NULL); 
    16041309        sc->sc_defant = ath9k_hw_getdefantenna(ah); 
    16051310 
    1606         /* 
    1607          * Not all chips have the VEOL support we want to 
    1608          * use with IBSS beacons; check here for it. 
    1609          */ 
    1610         sc->sc_hasveol = ah->ah_caps.halVEOLSupport; 
    1611  
    16121311        ath9k_hw_getmac(ah, sc->sc_myaddr); 
    1613         if (sc->sc_hasbmask) { 
     1312        if (ah->ah_caps.halBssIdMaskSupport) { 
    16141313                ath9k_hw_getbssidmask(ah, sc->sc_bssidmask); 
    16151314                ATH_SET_VAP_BSSID_MASK(sc->sc_bssidmask); 
    16161315                ath9k_hw_setbssidmask(ah, sc->sc_bssidmask); 
    16171316        } 
    1618         sc->sc_hasautosleep = ah->ah_caps.halAutoSleepSupport; 
    1619         sc->sc_waitbeacon = 0; 
    16201317        sc->sc_slottime = HAL_SLOT_TIME_9;      /* default to short slot time */ 
    16211318 
     
    16281325 
    16291326#ifdef CONFIG_SLOW_ANT_DIV 
    1630         sc->sc_slowAntDiv = 1; 
    16311327        /* range is 40 - 255, we use something in the middle */ 
    16321328        ath_slow_ant_div_init(&sc->sc_antdiv, sc, 0x127); 
    1633 #else 
    1634         sc->sc_slowAntDiv = 0; 
    16351329#endif 
    16361330 
     
    16521346        int i; 
    16531347 
    1654         DPRINTF(sc, ATH_DEBUG_CONFIG, "%s\n", __func__); 
     1348        DPRINTF(sc, ATH_DBG_CONFIG, "%s\n", __func__); 
    16551349 
    16561350        ath_stop(sc); 
     
    16961390        list_add(&an->list, &sc->node_list); 
    16971391 
    1698         DPRINTF(sc, ATH_DEBUG_NODE, "%s: an %p for: %s\n", 
    1699                 __func__, an, print_mac(mac, addr)); 
    1700  
    17011392        return an; 
    17021393} 
     
    17211412 
    17221413        spin_unlock_irqrestore(&sc->node_lock, flags); 
    1723  
    1724         DPRINTF(sc, ATH_DEBUG_NODE, "%s: an %p for: %s\n", 
    1725                 __func__, an, print_mac(mac, an->an_addr)); 
    17261414 
    17271415        kfree(an); 
     
    18001488/* Encryption */ 
    18011489/**************/ 
     1490 
    18021491void ath_key_reset(struct ath_softc *sc, u_int16_t keyix, int freeslot) 
    18031492{ 
     
    18121501               const u_int8_t mac[ETH_ALEN]) 
    18131502{ 
    1814         enum hal_bool status; 
     1503        bool status; 
    18151504 
    18161505        status = ath9k_hw_set_keycache_entry(sc->sc_ah, 
    1817                 keyix, hk, mac, AH_FALSE); 
    1818  
    1819         return status != AH_FALSE; 
     1506                keyix, hk, mac, false); 
     1507 
     1508        return status != false; 
    18201509} 
    18211510 
     
    20211710        int i, bsize, error; 
    20221711 
    2023         DPRINTF(sc, ATH_DEBUG_CONFIG, "%s: %s DMA: %u buffers %u desc/buf\n", 
     1712        DPRINTF(sc, ATH_DBG_CONFIG, "%s: %s DMA: %u buffers %u desc/buf\n", 
    20241713                __func__, name, nbuf, ndesc); 
    20251714 
    20261715        /* ath_desc must be a multiple of DWORDs */ 
    20271716        if ((sizeof(struct ath_desc) % 4) != 0) { 
    2028                 DPRINTF(sc, ATH_DEBUG_FATAL, "%s: ath_desc not DWORD aligned\n", 
     1717                DPRINTF(sc, ATH_DBG_FATAL, "%s: ath_desc not DWORD aligned\n", 
    20291718                        __func__); 
    20301719                ASSERT((sizeof(struct ath_desc) % 4) == 0); 
     
    20631752        } 
    20641753        ds = dd->dd_desc; 
    2065         DPRINTF(sc, ATH_DEBUG_CONFIG, "%s: %s DMA map: %p (%u) -> %llx (%u)\n", 
     1754        DPRINTF(sc, ATH_DBG_CONFIG, "%s: %s DMA map: %p (%u) -> %llx (%u)\n", 
    20661755                __func__, dd->dd_name, ds, (u_int32_t) dd->dd_desc_len, 
    20671756                ito64(dd->dd_desc_paddr), /*XXX*/(u_int32_t) dd->dd_desc_len); 
     
    21441833} 
    21451834 
    2146 void ath_setrxfilter(struct ath_softc *sc) 
    2147 { 
    2148         u_int32_t rxfilt; 
    2149  
    2150         rxfilt = ath_calcrxfilter(sc); 
    2151         ath9k_hw_setrxfilter(sc->sc_ah, rxfilt); 
    2152 } 
    2153  
    21541835int ath_get_hal_qnum(u16 queue, struct ath_softc *sc) 
    21551836{ 
  • trunk/package/ath9k/src/drivers/net/wireless/ath9k/core.h

    r11902 r12038  
    157157        } while (0) 
    158158 
    159 #define KASSERT(exp, msg) do {                  \ 
    160                 if (unlikely(!(exp))) {         \ 
    161                         printk msg;             \ 
    162                         BUG();                  \ 
    163                 }                               \ 
    164         } while (0) 
    165  
    166159/* XXX: remove */ 
    167160#define memzero(_buf, _len) memset(_buf, 0, _len) 
     
    185178 
    186179enum ATH_DEBUG { 
    187         ATH_DEBUG_XMIT          = 0x00000001,   /* basic xmit operation */ 
    188         ATH_DEBUG_RECV          = 0x00000002,   /* basic recv operation */ 
    189         ATH_DEBUG_BEACON        = 0x00000004,   /* beacon handling */ 
    190         ATH_DEBUG_TX_PROC       = 0x00000008,   /* tx ISR proc */ 
    191         ATH_DEBUG_RX_PROC       = 0x00000010,   /* rx ISR proc */ 
    192         ATH_DEBUG_BEACON_PROC   = 0x00000020,   /* beacon ISR proc */ 
    193         ATH_DEBUG_RATE          = 0x00000040,   /* rate control */ 
    194         ATH_DEBUG_CONFIG        = 0x00000080,   /* configuration */ 
    195         ATH_DEBUG_KEYCACHE      = 0x00000100,   /* key cache management */ 
    196         ATH_DEBUG_NODE          = 0x00000200,   /* node management */ 
    197         ATH_DEBUG_AGGR          = 0x00000400,   /* Aggregation */ 
    198         ATH_DEBUG_CWM           = 0x00000800,   /* Channel Width Management */ 
    199         ATH_DEBUG_FATAL         = 0x00001000,   /* fatal errors */ 
    200         ATH_DEBUG_ANY           = 0xffffffff 
    201 }; 
    202  
    203 #define DBG_DEFAULT (ATH_DEBUG_FATAL) 
     180        ATH_DBG_RESET           = 0x00000001, 
     181        ATH_DBG_PHY_IO          = 0x00000002, 
     182        ATH_DBG_REG_IO          = 0x00000004, 
     183        ATH_DBG_QUEUE           = 0x00000008, 
     184        ATH_DBG_EEPROM          = 0x00000010, 
     185        ATH_DBG_NF_CAL          = 0x00000020, 
     186        ATH_DBG_CALIBRATE       = 0x00000040, 
     187        ATH_DBG_CHANNEL         = 0x00000080, 
     188        ATH_DBG_INTERRUPT       = 0x00000100, 
     189        ATH_DBG_REGULATORY      = 0x00000200, 
     190        ATH_DBG_ANI             = 0x00000400, 
     191        ATH_DBG_POWER_MGMT      = 0x00000800, 
     192        ATH_DBG_XMIT            = 0x00001000, 
     193        ATH_DBG_BEACON          = 0x00002000, 
     194        ATH_DBG_RATE            = 0x00004000, 
     195        ATH_DBG_CONFIG          = 0x00008000, 
     196        ATH_DBG_KEYCACHE        = 0x00010000, 
     197        ATH_DBG_AGGR            = 0x00020000, 
     198        ATH_DBG_FATAL           = 0x00040000, 
     199        ATH_DBG_ANY             = 0xffffffff 
     200}; 
     201 
     202#define DBG_DEFAULT (ATH_DBG_FATAL) 
    204203 
    205204#define DPRINTF(sc, _m, _fmt, ...) do {                 \ 
     
    215214 * for Atheros Device */ 
    216215struct ath_config { 
    217         u_int8_t    chainmask_sel; /* enable automatic tx chainmask selection */ 
    218216        u_int32_t   ath_aggr_prot; 
    219217        u_int16_t   txpowlimit; 
     
    250248 
    251249int ath_chainmask_sel_logic(struct ath_softc *sc, struct ath_node *an); 
     250void ath_update_chainmask(struct ath_softc *sc, int is_ht); 
    252251 
    253252/*************************/ 
     
    453452}; 
    454453 
    455 void ath_setrxfilter(struct ath_softc *sc); 
    456454int ath_startrecv(struct ath_softc *sc); 
    457 enum hal_bool ath_stoprecv(struct ath_softc *sc); 
     455bool ath_stoprecv(struct ath_softc *sc); 
    458456void ath_flushrecv(struct ath_softc *sc); 
    459457u_int32_t ath_calcrxfilter(struct ath_softc *sc); 
     
    636634void ath_tx_cleanupq(struct ath_softc *sc, struct ath_txq *txq); 
    637635int ath_tx_setup(struct ath_softc *sc, int haltype); 
    638 void ath_draintxq(struct ath_softc *sc, enum hal_bool retry_tx); 
     636void ath_draintxq(struct ath_softc *sc, bool retry_tx); 
    639637void ath_tx_draintxq(struct ath_softc *sc, 
    640         struct ath_txq *txq, enum hal_bool retry_tx); 
     638        struct ath_txq *txq, bool retry_tx); 
    641639void ath_tx_node_init(struct ath_softc *sc, struct ath_node *an); 
    642640void ath_tx_node_cleanup(struct ath_softc *sc, 
     
    696694#define ATH_DS_BA_SEQ(_ds)               ((_ds)->ds_us.tx.ts_seqnum) 
    697695#define ATH_DS_BA_BITMAP(_ds)            (&(_ds)->ds_us.tx.ba_low) 
    698 #define ATH_DS_TX_BA(_ds)                ((_ds)->ds_us.tx.ts_flags & HAL_TX_BA) 
     696#define ATH_DS_TX_BA(_ds)       ((_ds)->ds_us.tx.ts_flags & ATH9K_TX_BA) 
    699697#define ATH_AN_2_TID(_an, _tidno)        (&(_an)->an_aggr.tx.tid[(_tidno)]) 
    700698 
     
    823821                          int if_id, 
    824822                          struct ath_beacon_config *conf); 
    825 struct sk_buff *ath_get_beacon(struct ath_softc *sc, 
    826                                int if_id, 
    827                                struct ath_beacon_offset *bo, 
    828                                struct ath_tx_control *txctl); 
    829823int ath_update_beacon(struct ath_softc *sc, 
    830824                      int if_id, 
     
    881875                   int if_id, 
    882876                   struct ieee80211_vif *if_data, 
    883                    enum hal_opmode opmode, 
    884                    enum hal_opmode iv_opmode, 
    885                    int nostabeacons); 
     877                   enum hal_opmode opmode); 
    886878int ath_vap_detach(struct ath_softc *sc, int if_id); 
    887879int ath_vap_config(struct ath_softc *sc, 
    888880        int if_id, struct ath_vap_config *if_config); 
    889 int ath_vap_down(struct ath_softc *sc, int if_id, u_int flags); 
    890881int ath_vap_listen(struct ath_softc *sc, int if_id); 
    891 int ath_vap_join(struct ath_softc *sc, 
    892                  int if_id, 
    893                  const u_int8_t bssid[ETH_ALEN], 
    894                  u_int flags); 
    895 int ath_vap_up(struct ath_softc *sc, 
    896                int if_id, 
    897                const u_int8_t bssid[ETH_ALEN], 
    898                u_int8_t aid, 
    899                u_int flags); 
    900882 
    901883/*********************/ 
     
    973955#define ATH_TXPOWER_MAX         100     /* .5 dBm units */ 
    974956 
    975 #define ATH_ISR_NOSCHED         0x0000  /* Do not schedule bottom half */ 
    976 /* Schedule the bottom half for execution */ 
    977 #define ATH_ISR_SCHED           0x0001 
    978 /* This was not my interrupt, for shared IRQ's */ 
    979 #define ATH_ISR_NOTMINE         0x0002 
    980  
    981957#define RSSI_LPF_THRESHOLD         -20 
    982958#define ATH_RSSI_EP_MULTIPLIER     (1<<7)  /* pow2 to optimize out * and / */ 
     
    10431019 
    10441020        /* Properties, Config */ 
    1045         unsigned int 
    1046                 sc_invalid             : 1, /* being detached */ 
    1047                 sc_mrretry             : 1, /* multi-rate retry support */ 
    1048                 sc_needmib             : 1, /* enable MIB stats intr */ 
    1049                 sc_hasdiversity        : 1, /* rx diversity available */ 
    1050                 sc_diversity           : 1, /* enable rx diversity */ 
    1051                 sc_hasveol             : 1, /* tx VEOL support */ 
    1052                 sc_beacons             : 1, /* beacons running */ 
    1053                 sc_hasbmask            : 1, /* bssid mask support */ 
    1054                 sc_hastsfadd           : 1, /* tsf adjust support */ 
    1055                 sc_scanning            : 1, /* scanning active */ 
    1056                 sc_nostabeacons        : 1, /* no beacons for station */ 
    1057                 sc_hasclrkey           : 1, /* CLR key supported */ 
    1058                 sc_stagbeacons         : 1, /* use staggered beacons */ 
    1059                 sc_txaggr              : 1, /* enable 11n tx aggregation */ 
    1060                 sc_rxaggr              : 1, /* enable 11n rx aggregation */ 
    1061                 sc_hasautosleep        : 1, /* automatic sleep after TIM */ 
    1062                 sc_waitbeacon          : 1, /* waiting for first beacon 
    1063                                                 after waking up */ 
    1064                 sc_no_tx_3_chains      : 1, /* user, hardware, regulatory 
    1065                                         or country may disallow transmit on 
    1066                                         three chains. */ 
    1067                 sc_update_chainmask    : 1, /* change chain mask */ 
    1068                 sc_rx_chainmask_detect : 1, /* enable rx chain mask detection */ 
    1069                 sc_rx_chainmask_start  : 1, /* start rx chain mask detection */ 
    1070                 sc_hashtsupport        : 1, /* supports 11n */ 
    1071                 sc_full_reset          : 1, /* force full reset */ 
    1072                 sc_slowAntDiv          : 1; /* enable slow antenna diversity */ 
     1021        u_int8_t                sc_invalid;     /* being detached */ 
     1022        u_int8_t                sc_beacons;     /* beacons running */ 
     1023        u_int8_t                sc_scanning;    /* scanning active */ 
     1024        u_int8_t                sc_txaggr;      /* enable 11n tx aggregation */ 
     1025        u_int8_t                sc_rxaggr;      /* enable 11n rx aggregation */ 
     1026        u_int8_t                sc_update_chainmask;    /* change chain mask */ 
     1027        u_int8_t                sc_full_reset;          /* force full reset */ 
    10731028        enum wireless_mode      sc_curmode;     /* current phy mode */ 
    10741029        u_int16_t               sc_curtxpow;    /* current tx power limit */ 
     
    11201075        /* Crypto */ 
    11211076        u_int                   sc_keymax;      /* size of key cache */ 
    1122         u_int8_t                sc_keymap[ATH_KEYBYTES];/* key use bit map */ 
     1077        DECLARE_BITMAP          (sc_keymap, ATH_KEYBYTES);/* key use bit map */ 
    11231078        u_int8_t                sc_splitmic;    /* split TKIP MIC keys */ 
    11241079        int                     sc_keytype;     /* type of the key being used */ 
     
    11821137int ath_open(struct ath_softc *sc, struct hal_channel *initial_chan); 
    11831138int ath_suspend(struct ath_softc *sc); 
    1184 int ath_intr(struct ath_softc *sc); 
     1139irqreturn_t ath_isr(int irq, void *dev); 
    11851140int ath_reset(struct ath_softc *sc); 
    11861141void ath_scan_start(struct ath_softc *sc); 
     
    12031158/*********************/ 
    12041159 
    1205 void ath_set_macmode(struct ath_softc *sc, enum hal_ht_macmode macmode); 
    12061160void ath_key_reset(struct ath_softc *sc, u_int16_t keyix, int freeslot); 
    12071161int ath_keyset(struct ath_softc *sc, 
  • trunk/package/ath9k/src/drivers/net/wireless/ath9k/hw.c

    r11902 r12038  
    1717#include <linux/io.h> 
    1818 
    19 #include "ath9k.h" 
     19#include "core.h" 
    2020#include "hw.h" 
    2121#include "reg.h" 
     
    112112        {0}, 
    113113        { 
    114                 {AH_TRUE, PHY_OFDM, 6000, 0x0b, 0x00, (0x80 | 12), 0}, 
    115                 {AH_TRUE, PHY_OFDM, 9000, 0x0f, 0x00, 18, 0}, 
    116                 {AH_TRUE, PHY_OFDM, 12000, 0x0a, 0x00, (0x80 | 24), 2}, 
    117                 {AH_TRUE, PHY_OFDM, 18000, 0x0e, 0x00, 36, 2}, 
    118                 {AH_TRUE, PHY_OFDM, 24000, 0x09, 0x00, (0x80 | 48), 4}, 
    119                 {AH_TRUE, PHY_OFDM, 36000, 0x0d, 0x00, 72, 4}, 
    120                 {AH_TRUE, PHY_OFDM, 48000, 0x08, 0x00, 96, 4}, 
    121                 {AH_TRUE, PHY_OFDM, 54000, 0x0c, 0x00, 108, 4} 
     114                {true, PHY_OFDM, 6000, 0x0b, 0x00, (0x80 | 12), 0}, 
     115                {true, PHY_OFDM, 9000, 0x0f, 0x00, 18, 0}, 
     116                {true, PHY_OFDM, 12000, 0x0a, 0x00, (0x80 | 24), 2}, 
     117                {true, PHY_OFDM, 18000, 0x0e, 0x00, 36, 2}, 
     118                {true, PHY_OFDM, 24000, 0x09, 0x00, (0x80 | 48), 4}, 
     119                {true, PHY_OFDM, 36000, 0x0d, 0x00, 72, 4}, 
     120                {true, PHY_OFDM, 48000, 0x08, 0x00, 96, 4}, 
     121                {true, PHY_OFDM, 54000, 0x0c, 0x00, 108, 4} 
    122122        }, 
    123123}; 
     
    127127        {0}, 
    128128        { 
    129                 {AH_TRUE, PHY_CCK, 1000, 0x1b, 0x00, (0x80 | 2), 0}, 
    130                 {AH_TRUE, PHY_CCK, 2000, 0x1a, 0x04, (0x80 | 4), 1}, 
    131                 {AH_TRUE, PHY_CCK, 5500, 0x19, 0x04, (0x80 | 11), 1}, 
    132                 {AH_TRUE, PHY_CCK, 11000, 0x18, 0x04, (0x80 | 22), 1} 
     129                {true, PHY_CCK, 1000, 0x1b, 0x00, (0x80 | 2), 0}, 
     130                {true, PHY_CCK, 2000, 0x1a, 0x04, (0x80 | 4), 1}, 
     131                {true, PHY_CCK, 5500, 0x19, 0x04, (0x80 | 11), 1}, 
     132                {true, PHY_CCK, 11000, 0x18, 0x04, (0x80 | 22), 1} 
    133133        }, 
    134134}; 
     
    138138        {0}, 
    139139        { 
    140                 {AH_TRUE, PHY_CCK, 1000, 0x1b, 0x00, (0x80 | 2), 0}, 
    141                 {AH_TRUE, PHY_CCK, 2000, 0x1a, 0x04, (0x80 | 4), 1}, 
    142                 {AH_TRUE, PHY_CCK, 5500, 0x19, 0x04, (0x80 | 11), 2}, 
    143                 {AH_TRUE, PHY_CCK, 11000, 0x18, 0x04, (0x80 | 22), 3}, 
    144  
    145                 {AH_FALSE, PHY_OFDM, 6000, 0x0b, 0x00, 12, 4}, 
    146                 {AH_FALSE, PHY_OFDM, 9000, 0x0f, 0x00, 18, 4}, 
    147                 {AH_TRUE, PHY_OFDM, 12000, 0x0a, 0x00, 24, 6}, 
    148                 {AH_TRUE, PHY_OFDM, 18000, 0x0e, 0x00, 36, 6}, 
    149                 {AH_TRUE, PHY_OFDM, 24000, 0x09, 0x00, 48, 8}, 
    150                 {AH_TRUE, PHY_OFDM, 36000, 0x0d, 0x00, 72, 8}, 
    151                 {AH_TRUE, PHY_OFDM, 48000, 0x08, 0x00, 96, 8}, 
    152                 {AH_TRUE, PHY_OFDM, 54000, 0x0c, 0x00, 108, 8} 
     140                {true, PHY_CCK, 1000, 0x1b, 0x00, (0x80 | 2), 0}, 
     141                {true, PHY_CCK, 2000, 0x1a, 0x04, (0x80 | 4), 1}, 
     142                {true, PHY_CCK, 5500, 0x19, 0x04, (0x80 | 11), 2}, 
     143                {true, PHY_CCK, 11000, 0x18, 0x04, (0x80 | 22), 3}, 
     144 
     145                {false, PHY_OFDM, 6000, 0x0b, 0x00, 12, 4}, 
     146                {false, PHY_OFDM, 9000, 0x0f, 0x00, 18, 4}, 
     147                {true, PHY_OFDM, 12000, 0x0a, 0x00, 24, 6}, 
     148                {true, PHY_OFDM, 18000, 0x0e, 0x00, 36, 6}, 
     149                {true, PHY_OFDM, 24000, 0x09, 0x00, 48, 8}, 
     150                {true, PHY_OFDM, 36000, 0x0d, 0x00, 72, 8}, 
     151                {true, PHY_OFDM, 48000, 0x08, 0x00, 96, 8}, 
     152                {true, PHY_OFDM, 54000, 0x0c, 0x00, 108, 8} 
    153153        }, 
    154154}; 
     
    158158        {0}, 
    159159        { 
    160                 {AH_TRUE, PHY_CCK, 1000, 0x1b, 0x00, (0x80 | 2), 0}, 
    161                 {AH_TRUE, PHY_CCK, 2000, 0x1a, 0x04, (0x80 | 4), 1}, 
    162                 {AH_TRUE, PHY_CCK, 5500, 0x19, 0x04, (0x80 | 11), 2}, 
    163                 {AH_TRUE, PHY_CCK, 11000, 0x18, 0x04, (0x80 | 22), 3}, 
    164  
    165                 {AH_FALSE, PHY_OFDM, 6000, 0x0b, 0x00, 12, 4}, 
    166                 {AH_FALSE, PHY_OFDM, 9000, 0x0f, 0x00, 18, 4}, 
    167                 {AH_TRUE, PHY_OFDM, 12000, 0x0a, 0x00, 24, 6}, 
    168                 {AH_TRUE, PHY_OFDM, 18000, 0x0e, 0x00, 36, 6}, 
    169                 {AH_TRUE, PHY_OFDM, 24000, 0x09, 0x00, 48, 8}, 
    170                 {AH_TRUE, PHY_OFDM, 36000, 0x0d, 0x00, 72, 8}, 
    171                 {AH_TRUE, PHY_OFDM, 48000, 0x08, 0x00, 96, 8}, 
    172                 {AH_TRUE, PHY_OFDM, 54000, 0x0c, 0x00, 108, 8}, 
    173                 {AH_TRUE, PHY_HT, 6500, 0x80, 0x00, 0, 4}, 
    174                 {AH_TRUE, PHY_HT, 13000, 0x81, 0x00, 1, 6}, 
    175                 {AH_TRUE, PHY_HT, 19500, 0x82, 0x00, 2, 6}, 
    176                 {AH_TRUE, PHY_HT, 26000, 0x83, 0x00, 3, 8}, 
    177                 {AH_TRUE, PHY_HT, 39000, 0x84, 0x00, 4, 8}, 
    178                 {AH_TRUE, PHY_HT, 52000, 0x85, 0x00, 5, 8}, 
    179                 {AH_TRUE, PHY_HT, 58500, 0x86, 0x00, 6, 8}, 
    180                 {AH_TRUE, PHY_HT, 65000, 0x87, 0x00, 7, 8}, 
    181                 {AH_TRUE, PHY_HT, 13000, 0x88, 0x00, 8, 4}, 
    182                 {AH_TRUE, PHY_HT, 26000, 0x89, 0x00, 9, 6}, 
    183                 {AH_TRUE, PHY_HT, 39000, 0x8a, 0x00, 10, 6}, 
    184                 {AH_TRUE, PHY_HT, 52000, 0x8b, 0x00, 11, 8}, 
    185                 {AH_TRUE, PHY_HT, 78000, 0x8c, 0x00, 12, 8}, 
    186                 {AH_TRUE, PHY_HT, 104000, 0x8d, 0x00, 13, 8}, 
    187                 {AH_TRUE, PHY_HT, 117000, 0x8e, 0x00, 14, 8}, 
    188                 {AH_TRUE, PHY_HT, 130000, 0x8f, 0x00, 15, 8}, 
     160                {true, PHY_CCK, 1000, 0x1b, 0x00, (0x80 | 2), 0}, 
     161                {true, PHY_CCK, 2000, 0x1a, 0x04, (0x80 | 4), 1}, 
     162                {true, PHY_CCK, 5500, 0x19, 0x04, (0x80 | 11), 2}, 
     163                {true, PHY_CCK, 11000, 0x18, 0x04, (0x80 | 22), 3}, 
     164 
     165                {false, PHY_OFDM, 6000, 0x0b, 0x00, 12, 4}, 
     166                {false, PHY_OFDM, 9000, 0x0f, 0x00, 18, 4}, 
     167                {true, PHY_OFDM, 12000, 0x0a, 0x00, 24, 6}, 
     168                {true, PHY_OFDM, 18000, 0x0e, 0x00, 36, 6}, 
     169                {true, PHY_OFDM, 24000, 0x09, 0x00, 48, 8}, 
     170                {true, PHY_OFDM, 36000, 0x0d, 0x00, 72, 8}, 
     171                {true, PHY_OFDM, 48000, 0x08, 0x00, 96, 8}, 
     172                {true, PHY_OFDM, 54000, 0x0c, 0x00, 108, 8}, 
     173                {true, PHY_HT, 6500, 0x80, 0x00, 0, 4}, 
     174                {true, PHY_HT, 13000, 0x81, 0x00, 1, 6}, 
     175                {true, PHY_HT, 19500, 0x82, 0x00, 2, 6}, 
     176                {true, PHY_HT, 26000, 0x83, 0x00, 3, 8}, 
     177                {true, PHY_HT, 39000, 0x84, 0x00, 4, 8}, 
     178                {true, PHY_HT, 52000, 0x85, 0x00, 5, 8}, 
     179                {true, PHY_HT, 58500, 0x86, 0x00, 6, 8}, 
     180                {true, PHY_HT, 65000, 0x87, 0x00, 7, 8}, 
     181                {true, PHY_HT, 13000, 0x88, 0x00, 8, 4}, 
     182                {true, PHY_HT, 26000, 0x89, 0x00, 9, 6}, 
     183                {true, PHY_HT, 39000, 0x8a, 0x00, 10, 6}, 
     184                {true, PHY_HT, 52000, 0x8b, 0x00, 11, 8}, 
     185                {true, PHY_HT, 78000, 0x8c, 0x00, 12, 8}, 
     186                {true, PHY_HT, 104000, 0x8d, 0x00, 13, 8}, 
     187                {true, PHY_HT, 117000, 0x8e, 0x00, 14, 8}, 
     188                {true, PHY_HT, 130000, 0x8f, 0x00, 15, 8}, 
    189189        }, 
    190190}; 
     
    194194        {0}, 
    195195        { 
    196                 {AH_TRUE, PHY_OFDM, 6000, 0x0b, 0x00, (0x80 | 12), 0}, 
    197                 {AH_TRUE, PHY_OFDM, 9000, 0x0f, 0x00, 18, 0}, 
    198                 {AH_TRUE, PHY_OFDM, 12000, 0x0a, 0x00, (0x80 | 24), 2}, 
    199                 {AH_TRUE, PHY_OFDM, 18000, 0x0e, 0x00, 36, 2}, 
    200                 {AH_TRUE, PHY_OFDM, 24000, 0x09, 0x00, (0x80 | 48), 4}, 
    201                 {AH_TRUE, PHY_OFDM, 36000, 0x0d, 0x00, 72, 4}, 
    202                 {AH_TRUE, PHY_OFDM, 48000, 0x08, 0x00, 96, 4}, 
    203                 {AH_TRUE, PHY_OFDM, 54000, 0x0c, 0x00, 108, 4}, 
    204                 {AH_TRUE, PHY_HT, 6500, 0x80, 0x00, 0, 0}, 
    205                 {AH_TRUE, PHY_HT, 13000, 0x81, 0x00, 1, 2}, 
    206                 {AH_TRUE, PHY_HT, 19500, 0x82, 0x00, 2, 2}, 
    207                 {AH_TRUE, PHY_HT, 26000, 0x83, 0x00, 3, 4}, 
    208                 {AH_TRUE, PHY_HT, 39000, 0x84, 0x00, 4, 4}, 
    209                 {AH_TRUE, PHY_HT, 52000, 0x85, 0x00, 5, 4}, 
    210                 {AH_TRUE, PHY_HT, 58500, 0x86, 0x00, 6, 4}, 
    211                 {AH_TRUE, PHY_HT, 65000, 0x87, 0x00, 7, 4}, 
    212                 {AH_TRUE, PHY_HT, 13000, 0x88, 0x00, 8, 0}, 
    213                 {AH_TRUE, PHY_HT, 26000, 0x89, 0x00, 9, 2}, 
    214                 {AH_TRUE, PHY_HT, 39000, 0x8a, 0x00, 10, 2}, 
    215                 {AH_TRUE, PHY_HT, 52000, 0x8b, 0x00, 11, 4}, 
    216                 {AH_TRUE, PHY_HT, 78000, 0x8c, 0x00, 12, 4}, 
    217                 {AH_TRUE, PHY_HT, 104000, 0x8d, 0x00, 13, 4}, 
    218                 {AH_TRUE, PHY_HT, 117000, 0x8e, 0x00, 14, 4}, 
    219                 {AH_TRUE, PHY_HT, 130000, 0x8f, 0x00, 15, 4}, 
     196                {true, PHY_OFDM, 6000, 0x0b, 0x00, (0x80 | 12), 0}, 
     197                {true, PHY_OFDM, 9000, 0x0f, 0x00, 18, 0}, 
     198                {true, PHY_OFDM, 12000, 0x0a, 0x00, (0x80 | 24), 2}, 
     199                {true, PHY_OFDM, 18000, 0x0e, 0x00, 36, 2}, 
     200                {true, PHY_OFDM, 24000, 0x09, 0x00, (0x80 | 48), 4}, 
     201                {true, PHY_OFDM, 36000, 0x0d, 0x00, 72, 4}, 
     202                {true, PHY_OFDM, 48000, 0x08, 0x00, 96, 4}, 
     203                {true, PHY_OFDM, 54000, 0x0c, 0x00, 108, 4}, 
     204                {true, PHY_HT, 6500, 0x80, 0x00, 0, 0}, 
     205                {true, PHY_HT, 13000, 0x81, 0x00, 1, 2}, 
     206                {true, PHY_HT, 19500, 0x82, 0x00, 2, 2}, 
     207                {true, PHY_HT, 26000, 0x83, 0x00, 3, 4}, 
     208                {true, PHY_HT, 39000, 0x84, 0x00, 4, 4}, 
     209                {true, PHY_HT, 52000, 0x85, 0x00, 5, 4}, 
     210                {true, PHY_HT, 58500, 0x86, 0x00, 6, 4}, 
     211                {true, PHY_HT, 65000, 0x87, 0x00, 7, 4}, 
     212                {true, PHY_HT, 13000, 0x88, 0x00, 8, 0}, 
     213                {true, PHY_HT, 26000, 0x89, 0x00, 9, 2}, 
     214                {true, PHY_HT, 39000, 0x8a, 0x00, 10, 2}, 
     215                {true, PHY_HT, 52000, 0x8b, 0x00, 11, 4}, 
     216                {true, PHY_HT, 78000, 0x8c, 0x00, 12, 4}, 
     217                {true, PHY_HT, 104000, 0x8d, 0x00, 13, 4}, 
     218                {true, PHY_HT, 117000, 0x8e, 0x00, 14, 4}, 
     219                {true, PHY_HT, 130000, 0x8f, 0x00, 15, 4}, 
    220220        }, 
    221221}; 
     
    231231} 
    232232 
    233 static enum hal_bool ath9k_hw_wait(struct ath_hal *ah, 
    234                             u_int reg, 
    235                             u_int32_t mask, 
    236                             u_int32_t val) 
     233static bool ath9k_hw_wait(struct ath_hal *ah, 
     234                          u_int reg, 
     235                          u_int32_t mask, 
     236                          u_int32_t val) 
    237237{ 
    238238        int i; 
     
    240240        for (i = 0; i < (AH_TIMEOUT / AH_TIME_QUANTUM); i++) { 
    241241                if ((REG_READ(ah, reg) & mask) == val) 
    242                         return AH_TRUE; 
     242                        return true; 
    243243 
    244244                udelay(AH_TIME_QUANTUM); 
    245245        } 
    246         HDPRINTF(ah, HAL_DBG_PHY_IO, 
     246        DPRINTF(ah->ah_sc, ATH_DBG_PHY_IO, 
    247247                 "%s: timeout on reg 0x%x: 0x%08x & 0x%08x != 0x%08x\n", 
    248248                 __func__, reg, REG_READ(ah, reg), mask, val); 
    249         return AH_FALSE; 
    250 } 
    251  
    252 static enum hal_bool ath9k_hw_eeprom_read(struct ath_hal *ah, u_int off, 
    253                                    u_int16_t *data) 
     249        return false; 
     250} 
     251 
     252static bool ath9k_hw_eeprom_read(struct ath_hal *ah, u_int off, 
     253                                 u_int16_t *data) 
    254254{ 
    255255        (void) REG_READ(ah, AR5416_EEPROM_OFFSET + (off << AR5416_EEPROM_S)); 
     
    259259                           AR_EEPROM_STATUS_DATA_BUSY | 
    260260                           AR_EEPROM_STATUS_DATA_PROT_ACCESS, 0)) { 
    261                 return AH_FALSE; 
     261                return false; 
    262262        } 
    263263 
     
    265265                   AR_EEPROM_STATUS_DATA_VAL); 
    266266 
    267         return AH_TRUE; 
     267        return true; 
    268268} 
    269269 
     
    275275 
    276276        if (!ahp->ah_cal_mem) { 
    277                 HDPRINTF(ah, HAL_DBG_EEPROM, 
     277                DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, 
    278278                         "%s: cannot remap eeprom region \n", __func__); 
    279279                return HAL_EIO; 
     
    283283} 
    284284 
    285 static enum hal_bool ath9k_hw_flash_read(struct ath_hal *ah, u_int off, 
    286                                   u_int16_t *data) 
     285static bool ath9k_hw_flash_read(struct ath_hal *ah, u_int off, 
     286                                u_int16_t *data) 
    287287{ 
    288288        struct ath_hal_5416 *ahp = AH5416(ah); 
    289289 
    290290        *data = ioread16(ahp->ah_cal_mem + off); 
    291         return AH_TRUE; 
     291        return true; 
    292292} 
    293293 
     
    315315 
    316316                if (ah->ah_macVersion == AR_SREV_VERSION_5416_PCIE) 
    317                         ah->ah_isPciExpress = AH_TRUE; 
     317                        ah->ah_isPciExpress = true; 
    318318        } 
    319319} 
     
    369369 
    370370        ah->ah_config.ath_hal_intrMitigation = 0; 
    371         ah->ah_config.ath_hal_debug = 0; 
    372371} 
    373372 
     
    514513} 
    515514 
    516 static inline enum hal_bool ath9k_hw_nvram_read(struct ath_hal *ah, 
    517                                                 u_int off, 
    518                                                 u_int16_t *data) 
     515static inline bool ath9k_hw_nvram_read(struct ath_hal *ah, 
     516                                       u_int off, 
     517                                       u_int16_t *data) 
    519518{ 
    520519        if (ath9k_hw_use_flash(ah)) 
     
    524523} 
    525524 
    526 static inline enum hal_bool ath9k_hw_fill_eeprom(struct ath_hal *ah) 
     525static inline bool ath9k_hw_fill_eeprom(struct ath_hal *ah) 
    527526{ 
    528527        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    532531 
    533532        if (!ath9k_hw_use_flash(ah)) { 
    534                 HDPRINTF(ah, HAL_DBG_EEPROM, 
     533                DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, 
    535534                         "%s: Reading from EEPROM, not flash\n", __func__); 
    536535                ar5416_eep_start_loc = 256; 
     
    545544                if (!ath9k_hw_nvram_read(ah, addr + ar5416_eep_start_loc, 
    546545                                         eep_data)) { 
    547                         HDPRINTF(ah, HAL_DBG_EEPROM, 
     546                        DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, 
    548547                                 "%s: Unable to read eeprom region \n", 
    549548                                 __func__); 
    550                         return AH_FALSE; 
     549                        return false; 
    551550                } 
    552551                eep_data++; 
    553552        } 
    554         return AH_TRUE; 
     553        return true; 
    555554} 
    556555 
    557556/* XXX: Clean me up, make me more legible */ 
    558 static enum hal_bool 
     557static bool 
    559558ath9k_hw_eeprom_set_board_values(struct ath_hal *ah, 
    560559                                 struct hal_channel_internal *chan) 
     
    603602                if ((i == 0) || AR_SREV_5416_V20_OR_LATER(ah)) { 
    604603                        if ((eep->baseEepHeader.version & 
    605                         AR5416_EEP_VER_MINOR_MASK) >= AR5416_EEP_MINOR_VER_3) { 
     604                             AR5416_EEP_VER_MINOR_MASK) >= 
     605                            AR5416_EEP_MINOR_VER_3) { 
    606606                                txRxAttenLocal = pModal->txRxAttenCh[i]; 
    607607                                if (AR_SREV_9280_10_OR_LATER(ah)) { 
    608                                         OS_REG_RMW_FIELD(ah, 
    609                                                  AR_PHY_GAIN_2GHZ + 
    610                                                  regChainOffset, 
    611                                          AR_PHY_GAIN_2GHZ_XATTEN1_MARGIN, 
    612                                                  pModal-> 
    613                                                  bswMargin[i]); 
    614                                         OS_REG_RMW_FIELD(ah, 
    615                                                  AR_PHY_GAIN_2GHZ + 
    616                                                  regChainOffset, 
    617                                                  AR_PHY_GAIN_2GHZ_XATTEN1_DB, 
    618                                                  pModal-> 
    619                                                  bswAtten[i]); 
    620                                         OS_REG_RMW_FIELD(ah, 
    621                                                  AR_PHY_GAIN_2GHZ + 
    622                                                  regChainOffset, 
    623                                          AR_PHY_GAIN_2GHZ_XATTEN2_MARGIN, 
    624                                                  pModal-> 
    625                                                  xatten2Margin[i]); 
    626                                         OS_REG_RMW_FIELD(ah, 
    627                                                  AR_PHY_GAIN_2GHZ + 
    628                                                  regChainOffset, 
    629                                                  AR_PHY_GAIN_2GHZ_XATTEN2_DB, 
    630                                                  pModal-> 
    631                                                  xatten2Db[i]); 
     608                                        REG_RMW_FIELD(ah, 
     609                                                AR_PHY_GAIN_2GHZ + 
     610                                                regChainOffset, 
     611                                                AR_PHY_GAIN_2GHZ_XATTEN1_MARGIN, 
     612                                                pModal-> 
     613                                                bswMargin[i]); 
     614                                        REG_RMW_FIELD(ah, 
     615                                                AR_PHY_GAIN_2GHZ + 
     616                                                regChainOffset, 
     617                                                AR_PHY_GAIN_2GHZ_XATTEN1_DB, 
     618                                                pModal-> 
     619                                                bswAtten[i]); 
     620                                        REG_RMW_FIELD(ah, 
     621                                                AR_PHY_GAIN_2GHZ + 
     622                                                regChainOffset, 
     623                                                AR_PHY_GAIN_2GHZ_XATTEN2_MARGIN, 
     624                                                pModal-> 
     625                                                xatten2Margin[i]); 
     626                                        REG_RMW_FIELD(ah, 
     627                                                AR_PHY_GAIN_2GHZ + 
     628                                                regChainOffset, 
     629                                                AR_PHY_GAIN_2GHZ_XATTEN2_DB, 
     630                                                pModal-> 
     631                                                xatten2Db[i]); 
    632632                                } else { 
    633633                                        REG_WRITE(ah, 
     
    639639                                                   ~AR_PHY_GAIN_2GHZ_BSW_MARGIN) 
    640640                                                  | SM(pModal-> 
    641                                                bswMargin[i], 
    642                                                AR_PHY_GAIN_2GHZ_BSW_MARGIN)); 
     641                                                  bswMargin[i], 
     642                                                  AR_PHY_GAIN_2GHZ_BSW_MARGIN)); 
    643643                                        REG_WRITE(ah, 
    644644                                                  AR_PHY_GAIN_2GHZ + 
     
    649649                                                   ~AR_PHY_GAIN_2GHZ_BSW_ATTEN) 
    650650                                                  | SM(pModal->bswAtten[i], 
    651                                                AR_PHY_GAIN_2GHZ_BSW_ATTEN)); 
     651                                                  AR_PHY_GAIN_2GHZ_BSW_ATTEN)); 
    652652                                } 
    653653                        } 
    654654                        if (AR_SREV_9280_10_OR_LATER(ah)) { 
    655                                 OS_REG_RMW_FIELD(ah, 
    656                                                 AR_PHY_RXGAIN + 
    657                                                 regChainOffset, 
    658                                                 AR9280_PHY_RXGAIN_TXRX_ATTEN, 
    659                                                 txRxAttenLocal); 
    660                                 OS_REG_RMW_FIELD(ah, 
    661                                                 AR_PHY_RXGAIN + 
    662                                                 regChainOffset, 
    663                                                 AR9280_PHY_RXGAIN_TXRX_MARGIN, 
    664                                                 pModal->rxTxMarginCh[i]); 
     655                                REG_RMW_FIELD(ah, 
     656                                              AR_PHY_RXGAIN + 
     657                                              regChainOffset, 
     658                                              AR9280_PHY_RXGAIN_TXRX_ATTEN, 
     659                                              txRxAttenLocal); 
     660                                REG_RMW_FIELD(ah, 
     661                                              AR_PHY_RXGAIN + 
     662                                              regChainOffset, 
     663                                              AR9280_PHY_RXGAIN_TXRX_MARGIN, 
     664                                              pModal->rxTxMarginCh[i]); 
    665665                        } else { 
    666666                                REG_WRITE(ah, 
     
    729729                                          AR_AN_TOP2_LOCALBIAS_S, 
    730730                                          pModal->local_bias); 
    731                 HDPRINTF(NULL, HAL_DBG_UNMASKABLE, "ForceXPAon: %d\n", 
    732                          pModal->force_xpaon); 
    733                 OS_REG_RMW_FIELD(ah, AR_PHY_XPA_CFG, AR_PHY_FORCE_XPA_CFG, 
    734                                 pModal->force_xpaon); 
    735         } 
    736  
    737         OS_REG_RMW_FIELD(ah, AR_PHY_SETTLING, AR_PHY_SETTLING_SWITCH, 
    738                         pModal->switchSettling); 
    739         OS_REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, AR_PHY_DESIRED_SZ_ADC, 
    740                         pModal->adcDesiredSize); 
     731                DPRINTF(ah->ah_sc, ATH_DBG_ANY, "ForceXPAon: %d\n", 
     732                        pModal->force_xpaon); 
     733                REG_RMW_FIELD(ah, AR_PHY_XPA_CFG, AR_PHY_FORCE_XPA_CFG, 
     734                              pModal->force_xpaon); 
     735        } 
     736 
     737        REG_RMW_FIELD(ah, AR_PHY_SETTLING, AR_PHY_SETTLING_SWITCH, 
     738                      pModal->switchSettling); 
     739        REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, AR_PHY_DESIRED_SZ_ADC, 
     740                      pModal->adcDesiredSize); 
    741741 
    742742        if (!AR_SREV_9280_10_OR_LATER(ah)) 
    743                 OS_REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, 
    744                                 AR_PHY_DESIRED_SZ_PGA, 
    745                                 pModal->pgaDesiredSize); 
     743                REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, 
     744                              AR_PHY_DESIRED_SZ_PGA, 
     745                              pModal->pgaDesiredSize); 
    746746 
    747747        REG_WRITE(ah, AR_PHY_RF_CTL4, 
     
    754754                       AR_PHY_RF_CTL4_FRAME_XPAB_ON)); 
    755755 
    756         OS_REG_RMW_FIELD(ah, AR_PHY_RF_CTL3, AR_PHY_TX_END_TO_A2_RX_ON, 
    757                         pModal->txEndToRxOn); 
     756        REG_RMW_FIELD(ah, AR_PHY_RF_CTL3, AR_PHY_TX_END_TO_A2_RX_ON, 
     757                      pModal->txEndToRxOn); 
    758758        if (AR_SREV_9280_10_OR_LATER(ah)) { 
    759                 OS_REG_RMW_FIELD(ah, AR_PHY_CCA, AR9280_PHY_CCA_THRESH62, 
    760                                 pModal->thresh62); 
    761                 OS_REG_RMW_FIELD(ah, AR_PHY_EXT_CCA0, 
    762                                 AR_PHY_EXT_CCA0_THRESH62, 
    763                                 pModal->thresh62); 
     759                REG_RMW_FIELD(ah, AR_PHY_CCA, AR9280_PHY_CCA_THRESH62, 
     760                              pModal->thresh62); 
     761                REG_RMW_FIELD(ah, AR_PHY_EXT_CCA0, 
     762                              AR_PHY_EXT_CCA0_THRESH62, 
     763                              pModal->thresh62); 
    764764        } else { 
    765                 OS_REG_RMW_FIELD(ah, AR_PHY_CCA, AR_PHY_CCA_THRESH62, 
    766                                 pModal->thresh62); 
    767                 OS_REG_RMW_FIELD(ah, AR_PHY_EXT_CCA, 
    768                                 AR_PHY_EXT_CCA_THRESH62, 
    769                                 pModal->thresh62); 
     765                REG_RMW_FIELD(ah, AR_PHY_CCA, AR_PHY_CCA_THRESH62, 
     766                              pModal->thresh62); 
     767                REG_RMW_FIELD(ah, AR_PHY_EXT_CCA, 
     768                              AR_PHY_EXT_CCA_THRESH62, 
     769                              pModal->thresh62); 
    770770        } 
    771771 
    772772        if ((eep->baseEepHeader.version & AR5416_EEP_VER_MINOR_MASK) >= 
    773773            AR5416_EEP_MINOR_VER_2) { 
    774                 OS_REG_RMW_FIELD(ah, AR_PHY_RF_CTL2, 
    775                                 AR_PHY_TX_END_DATA_START, 
    776                                 pModal->txFrameToDataStart); 
    777                 OS_REG_RMW_FIELD(ah, AR_PHY_RF_CTL2, AR_PHY_TX_END_PA_ON, 
    778                                 pModal->txFrameToPaOn); 
     774                REG_RMW_FIELD(ah, AR_PHY_RF_CTL2, 
     775                              AR_PHY_TX_END_DATA_START, 
     776                              pModal->txFrameToDataStart); 
     777                REG_RMW_FIELD(ah, AR_PHY_RF_CTL2, AR_PHY_TX_END_PA_ON, 
     778                              pModal->txFrameToPaOn); 
    779779        } 
    780780 
     
    782782            AR5416_EEP_MINOR_VER_3) { 
    783783                if (IS_CHAN_HT40(chan)) 
    784                         OS_REG_RMW_FIELD(ah, AR_PHY_SETTLING, 
    785                                         AR_PHY_SETTLING_SWITCH, 
    786                                         pModal->swSettleHt40); 
    787         } 
    788  
    789         return AH_TRUE; 
     784                        REG_RMW_FIELD(ah, AR_PHY_SETTLING, 
     785                                      AR_PHY_SETTLING_SWITCH, 
     786                                      pModal->swSettleHt40); 
     787        } 
     788 
     789        return true; 
    790790} 
    791791 
     
    796796        int i; 
    797797        struct ath_hal_5416 *ahp = AH5416(ah); 
    798         enum hal_bool need_swap = AH_FALSE; 
     798        bool need_swap = false; 
    799799        struct ar5416_eeprom *eep = 
    800800                (struct ar5416_eeprom *) &ahp->ah_eeprom; 
     
    806806                if (!ath9k_hw_nvram_read(ah, AR5416_EEPROM_MAGIC_OFFSET, 
    807807                                        &magic)) { 
    808                         HDPRINTF(ah, HAL_DBG_EEPROM, 
     808                        DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, 
    809809                                 "%s: Reading Magic # failed\n", __func__); 
    810                         return AH_FALSE; 
    811                 } 
    812                 HDPRINTF(ah, HAL_DBG_EEPROM, "%s: Read Magic = 0x%04X\n", 
     810                        return false; 
     811                } 
     812                DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, "%s: Read Magic = 0x%04X\n", 
    813813                         __func__, magic); 
    814814 
     
    817817 
    818818                        if (magic2 == AR5416_EEPROM_MAGIC) { 
    819                                 need_swap = AH_TRUE; 
     819                                need_swap = true; 
    820820                                eepdata = (u_int16_t *) (&ahp->ah_eeprom); 
    821821 
     
    830830                                        eepdata++; 
    831831 
    832                                         HDPRINTF(ah, HAL_DBG_EEPROM_DUMP, 
     832                                        DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, 
    833833                                                 "0x%04X  ", *eepdata); 
    834834                                        if (((addr + 1) % 6) == 0) 
    835                                                 HDPRINTF(ah, 
    836                                                          HAL_DBG_EEPROM_DUMP, 
     835                                                DPRINTF(ah->ah_sc, 
     836                                                         ATH_DBG_EEPROM, 
    837837                                                         "\n"); 
    838838                                } 
    839839                        } else { 
    840                                 HDPRINTF(ah, HAL_DBG_EEPROM, 
     840                                DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, 
    841841                                         "Invalid EEPROM Magic. " 
    842842                                        "endianness missmatch.\n"); 
     
    845845                } 
    846846        } 
    847         HDPRINTF(ah, HAL_DBG_EEPROM, "need_swap = %s.\n", 
     847        DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, "need_swap = %s.\n", 
    848848                 need_swap ? "True" : "False"); 
    849849 
     
    853853                el = ahp->ah_eeprom.baseEepHeader.length; 
    854854 
    855         if (el < sizeof(struct ar5416_eeprom)) 
     855        if (el > sizeof(struct ar5416_eeprom)) 
    856856                el = sizeof(struct ar5416_eeprom) / sizeof(u_int16_t); 
    857857        else 
     
    867867                u_int16_t word; 
    868868 
    869                 HDPRINTF(ah, HAL_DBG_EEPROM, 
     869                DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, 
    870870                         "EEPROM Endianness is not native.. Changing \n"); 
    871871 
     
    914914        if (sum != 0xffff || ar5416_get_eep_ver(ahp) != AR5416_EEP_VER || 
    915915            ar5416_get_eep_rev(ahp) < AR5416_EEP_NO_BACK_VER) { 
    916                 HDPRINTF(ah, HAL_DBG_EEPROM, 
     916                DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, 
    917917                         "Bad EEPROM checksum 0x%x or revision 0x%04x\n", 
    918918                         sum, ar5416_get_eep_ver(ahp)); 
     
    923923} 
    924924 
    925 static enum hal_bool ath9k_hw_chip_test(struct ath_hal *ah) 
     925static bool ath9k_hw_chip_test(struct ath_hal *ah) 
    926926{ 
    927927        u_int32_t regAddr[2] = { AR_STA_ID0, AR_PHY_BASE + (8 << 2) }; 
     
    943943                        rdData = REG_READ(ah, addr); 
    944944                        if (rdData != wrData) { 
    945                                 HDPRINTF(ah, HAL_DBG_REG_IO, 
     945                                DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    946946                                 "%s: address test failed " 
    947947                                "addr: 0x%08x - wr:0x%08x != rd:0x%08x\n", 
    948948                                 __func__, addr, wrData, rdData); 
    949                                 return AH_FALSE; 
     949                                return false; 
    950950                        } 
    951951                } 
     
    955955                        rdData = REG_READ(ah, addr); 
    956956                        if (wrData != rdData) { 
    957                                 HDPRINTF(ah, HAL_DBG_REG_IO, 
     957                                DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    958958                                 "%s: address test failed " 
    959959                                "addr: 0x%08x - wr:0x%08x != rd:0x%08x\n", 
    960960                                 __func__, addr, wrData, rdData); 
    961                                 return AH_FALSE; 
     961                                return false; 
    962962                        } 
    963963                } 
     
    965965        } 
    966966        udelay(100); 
    967         return AH_TRUE; 
     967        return true; 
    968968} 
    969969 
     
    10001000} 
    10011001 
    1002 enum hal_bool ath9k_hw_setcapability(struct ath_hal *ah, 
    1003                                      enum hal_capability_type type, 
    1004                                      u_int32_t capability, 
    1005                                      u_int32_t setting, 
    1006                                      enum hal_status *status) 
     1002bool ath9k_hw_setcapability(struct ath_hal *ah, 
     1003                            enum hal_capability_type type, 
     1004                            u_int32_t capability, 
     1005                            u_int32_t setting, 
     1006                            enum hal_status *status) 
    10071007{ 
    10081008        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    10171017                        ahp->ah_staId1Defaults &= 
    10181018                                ~AR_STA_ID1_CRPT_MIC_ENABLE; 
    1019                 return AH_TRUE; 
     1019                return true; 
    10201020        case HAL_CAP_DIVERSITY: 
    10211021                v = REG_READ(ah, AR_PHY_CCK_DETECT); 
     
    10251025                        v &= ~AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV; 
    10261026                REG_WRITE(ah, AR_PHY_CCK_DETECT, v); 
    1027                 return AH_TRUE; 
     1027                return true; 
    10281028        case HAL_CAP_MCAST_KEYSRCH: 
    10291029                if (setting) 
     
    10311031                else 
    10321032                        ahp->ah_staId1Defaults &= ~AR_STA_ID1_MCAST_KSRCH; 
    1033                 return AH_TRUE; 
     1033                return true; 
    10341034        case HAL_CAP_TSF_ADJUST: 
    10351035                if (setting) 
     
    10371037                else 
    10381038                        ahp->ah_miscMode &= ~AR_PCU_TX_ADD_TSF; 
    1039                 return AH_TRUE; 
     1039                return true; 
    10401040        default: 
    1041                 return AH_FALSE; 
     1041                return false; 
    10421042        } 
    10431043} 
     
    10551055                    AR_MACMISC_MISC_OBS_BUS_MSB_S))); 
    10561056 
    1057         HDPRINTF(ah, HAL_DBG_REG_IO, "Raw DMA Debug values:\n"); 
     1057        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, "Raw DMA Debug values:\n"); 
    10581058        for (i = 0; i < ATH9K_NUM_DMA_DEBUG_REGS; i++) { 
    10591059                if (i % 4 == 0) 
    1060                         HDPRINTF(ah, HAL_DBG_REG_IO, "\n"); 
     1060                        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, "\n"); 
    10611061 
    10621062                val[i] = REG_READ(ah, AR_DMADBG_0 + (i * sizeof(u_int32_t))); 
    1063                 HDPRINTF(ah, HAL_DBG_REG_IO, "%d: %08x ", i, val[i]); 
    1064         } 
    1065  
    1066         HDPRINTF(ah, HAL_DBG_REG_IO, "\n\n"); 
    1067         HDPRINTF(ah, HAL_DBG_REG_IO, 
     1063                DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, "%d: %08x ", i, val[i]); 
     1064        } 
     1065 
     1066        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, "\n\n"); 
     1067        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    10681068                 "Num QCU: chain_st fsp_ok fsp_st DCU: chain_st\n"); 
    10691069 
     
    10801080                } 
    10811081 
    1082                 HDPRINTF(ah, HAL_DBG_REG_IO, 
     1082                DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    10831083                         "%2d          %2x      %1x     %2x           %2x\n", 
    10841084                         i, (*qcuBase & (0x7 << qcuOffset)) >> qcuOffset, 
     
    10891089        } 
    10901090 
    1091         HDPRINTF(ah, HAL_DBG_REG_IO, "\n"); 
    1092         HDPRINTF(ah, HAL_DBG_REG_IO, 
     1091        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, "\n"); 
     1092        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    10931093                 "qcu_stitch state:   %2x    qcu_fetch state:        %2x\n", 
    10941094                 (val[3] & 0x003c0000) >> 18, (val[3] & 0x03c00000) >> 22); 
    1095         HDPRINTF(ah, HAL_DBG_REG_IO, 
     1095        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    10961096                 "qcu_complete state: %2x    dcu_complete state:     %2x\n", 
    10971097                 (val[3] & 0x1c000000) >> 26, (val[6] & 0x3)); 
    1098         HDPRINTF(ah, HAL_DBG_REG_IO, 
     1098        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    10991099                 "dcu_arb state:      %2x    dcu_fp state:           %2x\n", 
    11001100                 (val[5] & 0x06000000) >> 25, (val[5] & 0x38000000) >> 27); 
    1101         HDPRINTF(ah, HAL_DBG_REG_IO, 
     1101        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    11021102                 "chan_idle_dur:     %3d    chan_idle_dur_valid:     %1d\n", 
    11031103                 (val[6] & 0x000003fc) >> 2, (val[6] & 0x00000400) >> 10); 
    1104         HDPRINTF(ah, HAL_DBG_REG_IO, 
     1104        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    11051105                 "txfifo_valid_0:      %1d    txfifo_valid_1:          %1d\n", 
    11061106                 (val[6] & 0x00000800) >> 11, (val[6] & 0x00001000) >> 12); 
    1107         HDPRINTF(ah, HAL_DBG_REG_IO, 
     1107        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    11081108                 "txfifo_dcu_num_0:   %2d    txfifo_dcu_num_1:       %2d\n", 
    11091109                 (val[6] & 0x0001e000) >> 13, (val[6] & 0x001e0000) >> 17); 
    11101110 
    1111         HDPRINTF(ah, HAL_DBG_REG_IO, "pcu observe 0x%x \n", 
    1112                  REG_READ(ah, AR_OBS_BUS_1)); 
    1113         HDPRINTF(ah, HAL_DBG_REG_IO, "AR_CR 0x%x \n", REG_READ(ah, AR_CR)); 
     1111        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, "pcu observe 0x%x \n", 
     1112                REG_READ(ah, AR_OBS_BUS_1)); 
     1113        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
     1114                "AR_CR 0x%x \n", REG_READ(ah, AR_CR)); 
    11141115} 
    11151116 
     
    11281129 
    11291130        if (cycles == 0 || cycles > cc) { 
    1130                 HDPRINTF(ah, HAL_DBG_CHANNEL, 
     1131                DPRINTF(ah->ah_sc, ATH_DBG_CHANNEL, 
    11311132                         "%s: cycle counter wrap. ExtBusy = 0\n", 
    11321133                         __func__); 
     
    11741175 
    11751176 
    1176 static struct ath_hal_5416 *ath9k_hw_newstate(u_int16_t devid, void *sc, 
     1177static struct ath_hal_5416 *ath9k_hw_newstate(u_int16_t devid, 
     1178                                              struct ath_softc *sc, 
    11771179                                              void __iomem *mem, 
    11781180                                              enum hal_status *status) 
     
    11851187        ahp = kzalloc(sizeof(struct ath_hal_5416), GFP_KERNEL); 
    11861188        if (ahp == NULL) { 
    1187                 HDPRINTF(NULL, HAL_DBG_UNMASKABLE, 
     1189                DPRINTF(sc, ATH_DBG_FATAL, 
    11881190                         "%s: cannot allocate memory for state block\n", 
    11891191                         __func__); 
     
    13211323        } 
    13221324        if (sum == 0 || sum == 0xffff * 3) { 
    1323                 HDPRINTF(ah, HAL_DBG_EEPROM, 
     1325                DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, 
    13241326                         "%s: mac address read failed: %s\n", __func__, 
    13251327                         print_mac(mac, ahp->ah_macaddr)); 
     
    13491351 
    13501352static inline u_int16_t ath9k_hw_fbin2freq(u_int8_t fbin, 
    1351                                            enum hal_bool is2GHz) 
     1353                                           bool is2GHz) 
    13521354{ 
    13531355 
     
    13601362static u_int16_t ath9k_hw_eeprom_get_spur_chan(struct ath_hal *ah, 
    13611363                                               u_int16_t i, 
    1362                                                enum hal_bool is2GHz) 
     1364                                               bool is2GHz) 
    13631365{ 
    13641366        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    13671369        u_int16_t spur_val = AR_NO_SPUR; 
    13681370 
    1369         HDPRINTF(ah, HAL_DBG_ANI, 
     1371        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    13701372                 "Getting spur idx %d is2Ghz. %d val %x\n", 
    13711373                 i, is2GHz, ah->ah_config.ath_hal_spurChans[i][is2GHz]); 
     
    13761378        case SPUR_ENABLE_IOCTL: 
    13771379                spur_val = ah->ah_config.ath_hal_spurChans[i][is2GHz]; 
    1378                 HDPRINTF(ah, HAL_DBG_ANI, 
     1380                DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    13791381                         "Getting spur val from new loc. %d\n", spur_val); 
    13801382                break; 
     
    13891391static inline enum hal_status ath9k_hw_rfattach(struct ath_hal *ah) 
    13901392{ 
    1391         enum hal_bool rfStatus = AH_FALSE; 
     1393        bool rfStatus = false; 
    13921394        enum hal_status ecode = HAL_OK; 
    13931395 
    13941396        rfStatus = ath9k_hw_init_rf(ah, &ecode); 
    13951397        if (!rfStatus) { 
    1396                 HDPRINTF(ah, HAL_DBG_RESET, 
     1398                DPRINTF(ah->ah_sc, ATH_DBG_RESET, 
    13971399                         "%s: RF setup failed, status %u\n", __func__, 
    13981400                         ecode); 
     
    14201422                break; 
    14211423        default: 
    1422                 HDPRINTF(ah, HAL_DBG_CHANNEL, 
     1424                DPRINTF(ah->ah_sc, ATH_DBG_CHANNEL, 
    14231425                         "%s: 5G Radio Chip Rev 0x%02X is not " 
    14241426                        "supported by this driver\n", 
     
    15361538                REG_WRITE(ah, AR_STA_ID1, val | AR_STA_ID1_STA_AP 
    15371539                          | AR_STA_ID1_KSRCH_MODE); 
    1538                 OS_REG_CLR_BIT(ah, AR_CFG, AR_CFG_AP_ADHOC_INDICATION); 
     1540                REG_CLR_BIT(ah, AR_CFG, AR_CFG_AP_ADHOC_INDICATION); 
    15391541                break; 
    15401542        case HAL_M_IBSS: 
    15411543                REG_WRITE(ah, AR_STA_ID1, val | AR_STA_ID1_ADHOC 
    15421544                          | AR_STA_ID1_KSRCH_MODE); 
    1543                 OS_REG_SET_BIT(ah, AR_CFG, AR_CFG_AP_ADHOC_INDICATION); 
     1545                REG_SET_BIT(ah, AR_CFG, AR_CFG_AP_ADHOC_INDICATION); 
    15441546                break; 
    15451547        case HAL_M_STA: 
     
    15711573} 
    15721574 
    1573 static enum hal_bool ath9k_hw_set_reset(struct ath_hal *ah, int type) 
     1575static bool ath9k_hw_set_reset(struct ath_hal *ah, int type) 
    15741576{ 
    15751577        u_int32_t rst_flags; 
     
    16031605        REG_WRITE(ah, (u_int16_t) (AR_RTC_RC), 0); 
    16041606        if (!ath9k_hw_wait(ah, (u_int16_t) (AR_RTC_RC), AR_RTC_RC_M, 0)) { 
    1605                 HDPRINTF(ah, HAL_DBG_RESET, "%s: RTC stuck in MAC reset\n", 
    1606                          __func__); 
    1607                 return AH_FALSE; 
     1607                DPRINTF(ah->ah_sc, ATH_DBG_RESET, 
     1608                        "%s: RTC stuck in MAC reset\n", 
     1609                        __func__); 
     1610                return false; 
    16081611        } 
    16091612 
     
    16161619                udelay(50); 
    16171620 
    1618         return AH_TRUE; 
    1619 } 
    1620  
    1621 static inline enum hal_bool ath9k_hw_set_reset_power_on(struct ath_hal *ah) 
     1621        return true; 
     1622} 
     1623 
     1624static inline bool ath9k_hw_set_reset_power_on(struct ath_hal *ah) 
    16221625{ 
    16231626        REG_WRITE(ah, AR_RTC_FORCE_WAKE, AR_RTC_FORCE_WAKE_EN | 
     
    16311634                           AR_RTC_STATUS_M, 
    16321635                           AR_RTC_STATUS_ON)) { 
    1633                 HDPRINTF(ah, HAL_DBG_RESET, "%s: RTC not waking up\n", 
     1636                DPRINTF(ah->ah_sc, ATH_DBG_RESET, "%s: RTC not waking up\n", 
    16341637                         __func__); 
    1635                 return AH_FALSE; 
     1638                return false; 
    16361639        } 
    16371640 
     
    16411644} 
    16421645 
    1643 static enum hal_bool ath9k_hw_set_reset_reg(struct ath_hal *ah, 
    1644                                             u_int32_t type) 
     1646static bool ath9k_hw_set_reset_reg(struct ath_hal *ah, 
     1647                                   u_int32_t type) 
    16451648{ 
    16461649        REG_WRITE(ah, AR_RTC_FORCE_WAKE, 
     
    16561659                break; 
    16571660        default: 
    1658                 return AH_FALSE; 
     1661                return false; 
    16591662        } 
    16601663} 
     
    16641667{ 
    16651668        if ((IS(chan, CHANNEL_2GHZ) ^ IS(chan, CHANNEL_5GHZ)) == 0) { 
    1666                 HDPRINTF(ah, HAL_DBG_CHANNEL, 
     1669                DPRINTF(ah->ah_sc, ATH_DBG_CHANNEL, 
    16671670                         "%s: invalid channel %u/0x%x; not marked as " 
    16681671                         "2GHz or 5GHz\n", __func__, chan->channel, 
     
    16761679             ^ IS(chan, CHANNEL_HT40PLUS) 
    16771680             ^ IS(chan, CHANNEL_HT40MINUS)) == 0) { 
    1678                 HDPRINTF(ah, HAL_DBG_CHANNEL, 
     1681                DPRINTF(ah->ah_sc, ATH_DBG_CHANNEL, 
    16791682                         "%s: invalid channel %u/0x%x; not marked as " 
    16801683                         "OFDM or CCK or HT20 or HT40PLUS or HT40MINUS\n", 
     
    16861689} 
    16871690 
    1688 static inline enum hal_bool 
     1691static inline bool 
    16891692ath9k_hw_get_lower_upper_index(u_int8_t target, 
    16901693                               u_int8_t *pList, 
     
    16971700        if (target <= pList[0]) { 
    16981701                *indexL = *indexR = 0; 
    1699                 return AH_TRUE; 
     1702                return true; 
    17001703        } 
    17011704        if (target >= pList[listSize - 1]) { 
    17021705                *indexL = *indexR = (u_int16_t) (listSize - 1); 
    1703                 return AH_TRUE; 
     1706                return true; 
    17041707        } 
    17051708 
     
    17071710                if (pList[i] == target) { 
    17081711                        *indexL = *indexR = i; 
    1709                         return AH_TRUE; 
     1712                        return true; 
    17101713                } 
    17111714                if (target < pList[i + 1]) { 
    17121715                        *indexL = i; 
    17131716                        *indexR = (u_int16_t) (i + 1); 
    1714                         return AH_FALSE; 
    1715                 } 
    1716         } 
    1717         return AH_FALSE; 
     1717                        return false; 
     1718                } 
     1719        } 
     1720        return false; 
    17181721} 
    17191722 
     
    17801783        if (nf & 0x100) 
    17811784                nf = 0 - ((nf ^ 0x1ff) + 1); 
    1782         HDPRINTF(ah, HAL_DBG_CALIBRATE, 
     1785        DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE, 
    17831786                 "NF calibrated [ctl] [chain 0] is %d\n", nf); 
    17841787        nfarray[0] = nf; 
     
    17931796        if (nf & 0x100) 
    17941797                nf = 0 - ((nf ^ 0x1ff) + 1); 
    1795         HDPRINTF(ah, HAL_DBG_NF_CAL, 
     1798        DPRINTF(ah->ah_sc, ATH_DBG_NF_CAL, 
    17961799                 "NF calibrated [ctl] [chain 1] is %d\n", nf); 
    17971800        nfarray[1] = nf; 
     
    18021805                if (nf & 0x100) 
    18031806                        nf = 0 - ((nf ^ 0x1ff) + 1); 
    1804                 HDPRINTF(ah, HAL_DBG_NF_CAL, 
     1807                DPRINTF(ah->ah_sc, ATH_DBG_NF_CAL, 
    18051808                         "NF calibrated [ctl] [chain 2] is %d\n", nf); 
    18061809                nfarray[2] = nf; 
     
    18161819        if (nf & 0x100) 
    18171820                nf = 0 - ((nf ^ 0x1ff) + 1); 
    1818         HDPRINTF(ah, HAL_DBG_NF_CAL, 
     1821        DPRINTF(ah->ah_sc, ATH_DBG_NF_CAL, 
    18191822                 "NF calibrated [ext] [chain 0] is %d\n", nf); 
    18201823        nfarray[3] = nf; 
     
    18291832        if (nf & 0x100) 
    18301833                nf = 0 - ((nf ^ 0x1ff) + 1); 
    1831         HDPRINTF(ah, HAL_DBG_CALIBRATE, 
     1834        DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE, 
    18321835                 "NF calibrated [ext] [chain 1] is %d\n", nf); 
    18331836        nfarray[4] = nf; 
     
    18381841                if (nf & 0x100) 
    18391842                        nf = 0 - ((nf ^ 0x1ff) + 1); 
    1840                 HDPRINTF(ah, HAL_DBG_NF_CAL, 
     1843                DPRINTF(ah->ah_sc, ATH_DBG_NF_CAL, 
    18411844                         "NF calibrated [ext] [chain 2] is %d\n", nf); 
    18421845                nfarray[5] = nf; 
     
    18441847} 
    18451848 
    1846 static enum hal_bool 
     1849static bool 
    18471850getNoiseFloorThresh(struct ath_hal *ah, 
    18481851                    const struct hal_channel_internal *chan, 
     
    18661869                break; 
    18671870        default: 
    1868                 HDPRINTF(ah, HAL_DBG_CHANNEL, 
     1871                DPRINTF(ah->ah_sc, ATH_DBG_CHANNEL, 
    18691872                         "%s: invalid channel flags 0x%x\n", __func__, 
    18701873                         chan->channelFlags); 
    1871                 return AH_FALSE; 
    1872         } 
    1873         return AH_TRUE; 
     1874                return false; 
     1875        } 
     1876        return true; 
    18741877} 
    18751878 
    18761879static void ath9k_hw_start_nfcal(struct ath_hal *ah) 
    18771880{ 
    1878         OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, 
    1879                        AR_PHY_AGC_CONTROL_ENABLE_NF); 
    1880         OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, 
    1881                        AR_PHY_AGC_CONTROL_NO_UPDATE_NF); 
    1882         OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF); 
     1881        REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, 
     1882                    AR_PHY_AGC_CONTROL_ENABLE_NF); 
     1883        REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, 
     1884                    AR_PHY_AGC_CONTROL_NO_UPDATE_NF); 
     1885        REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF); 
    18831886} 
    18841887 
     
    19191922        } 
    19201923 
    1921         OS_REG_CLR_BIT(ah, AR_PHY_AGC_CONTROL, 
    1922                        AR_PHY_AGC_CONTROL_ENABLE_NF); 
    1923         OS_REG_CLR_BIT(ah, AR_PHY_AGC_CONTROL, 
    1924                        AR_PHY_AGC_CONTROL_NO_UPDATE_NF); 
    1925         OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF); 
     1924        REG_CLR_BIT(ah, AR_PHY_AGC_CONTROL, 
     1925                    AR_PHY_AGC_CONTROL_ENABLE_NF); 
     1926        REG_CLR_BIT(ah, AR_PHY_AGC_CONTROL, 
     1927                    AR_PHY_AGC_CONTROL_NO_UPDATE_NF); 
     1928        REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF); 
    19261929 
    19271930        for (j = 0; j < 1000; j++) { 
     
    19571960        chan->channelFlags &= (~CHANNEL_CW_INT); 
    19581961        if (REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF) { 
    1959                 HDPRINTF(ah, HAL_DBG_CALIBRATE, 
     1962                DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE, 
    19601963                         "%s: NF did not complete in calibration window\n", 
    19611964                         __func__); 
     
    19681971                if (getNoiseFloorThresh(ah, chan, &nfThresh) 
    19691972                    && nf > nfThresh) { 
    1970                         HDPRINTF(ah, HAL_DBG_CALIBRATE, 
     1973                        DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE, 
    19711974                                 "%s: noise floor failed detected; " 
    19721975                                 "detected %d, threshold %d\n", __func__, 
     
    20022005        struct ath_hal_5416 *ahp = AH5416(ah); 
    20032006 
    2004         HDPRINTF(ah, HAL_DBG_ANI, "Enable mib counters\n"); 
     2007        DPRINTF(ah->ah_sc, ATH_DBG_ANI, "Enable mib counters\n"); 
    20052008 
    20062009        ath9k_hw_update_mibstats(ah, &ahp->ah_mibStats); 
     
    20192022        struct ath_hal_5416 *ahp = AH5416(ah); 
    20202023 
    2021         HDPRINTF(ah, HAL_DBG_ANI, "Disabling MIB counters\n"); 
     2024        DPRINTF(ah->ah_sc, ATH_DBG_ANI, "Disabling MIB counters\n"); 
    20222025 
    20232026        REG_WRITE(ah, AR_MIBC, AR_MIBC_FMC | AR_MIBC_CMC); 
     
    20452048        } 
    20462049 
    2047         HDPRINTF(ah, HAL_DBG_ANI, 
     2050        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    20482051                 "No more channel states left. Using channel 0\n"); 
    20492052        return 0; 
     
    20792082        } 
    20802083        if (ahp->ah_hasHwPhyCounters) { 
    2081                 HDPRINTF(ah, HAL_DBG_ANI, "Setting OfdmErrBase = 0x%08x\n", 
    2082                          ahp->ah_ani[0].ofdmPhyErrBase); 
    2083                 HDPRINTF(ah, HAL_DBG_ANI, "Setting cckErrBase = 0x%08x\n", 
    2084                          ahp->ah_ani[0].cckPhyErrBase); 
     2084                DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
     2085                        "Setting OfdmErrBase = 0x%08x\n", 
     2086                        ahp->ah_ani[0].ofdmPhyErrBase); 
     2087                DPRINTF(ah->ah_sc, ATH_DBG_ANI, "Setting cckErrBase = 0x%08x\n", 
     2088                        ahp->ah_ani[0].cckPhyErrBase); 
    20852089 
    20862090                REG_WRITE(ah, AR_PHY_ERR_1, ahp->ah_ani[0].ofdmPhyErrBase); 
     
    21152119        struct ath_hal_5416 *ahp = AH5416(ah); 
    21162120 
    2117         HDPRINTF(ah, HAL_DBG_ANI, "Detaching Ani\n"); 
     2121        DPRINTF(ah->ah_sc, ATH_DBG_ANI, "Detaching Ani\n"); 
    21182122        if (ahp->ah_hasHwPhyCounters) { 
    21192123                ath9k_hw_disable_mib_counters(ah); 
     
    21242128 
    21252129 
    2126 static enum hal_bool ath9k_hw_ani_control(struct ath_hal *ah, 
    2127                                           enum hal_ani_cmd cmd, int param) 
     2130static bool ath9k_hw_ani_control(struct ath_hal *ah, 
     2131                                enum hal_ani_cmd cmd, int param) 
    21282132{ 
    21292133        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    21352139 
    21362140                if (level >= ARRAY_SIZE(ahp->ah_totalSizeDesired)) { 
    2137                         HDPRINTF(ah, HAL_DBG_ANI, 
     2141                        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    21382142                                 "%s: level out of range (%u > %u)\n", 
    21392143                                 __func__, level, 
    21402144                                 (unsigned) ARRAY_SIZE(ahp-> 
    21412145                                                       ah_totalSizeDesired)); 
    2142                         return AH_FALSE; 
    2143                 } 
    2144  
    2145                 OS_REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, 
    2146                                 AR_PHY_DESIRED_SZ_TOT_DES, 
    2147                                 ahp->ah_totalSizeDesired[level]); 
    2148                 OS_REG_RMW_FIELD(ah, AR_PHY_AGC_CTL1, 
    2149                                 AR_PHY_AGC_CTL1_COARSE_LOW, 
    2150                                 ahp->ah_coarseLow[level]); 
    2151                 OS_REG_RMW_FIELD(ah, AR_PHY_AGC_CTL1, 
    2152                                 AR_PHY_AGC_CTL1_COARSE_HIGH, 
    2153                                 ahp->ah_coarseHigh[level]); 
    2154                 OS_REG_RMW_FIELD(ah, AR_PHY_FIND_SIG, 
    2155                                 AR_PHY_FIND_SIG_FIRPWR, 
    2156                                 ahp->ah_firpwr[level]); 
     2146                        return false; 
     2147                } 
     2148 
     2149                REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, 
     2150                              AR_PHY_DESIRED_SZ_TOT_DES, 
     2151                              ahp->ah_totalSizeDesired[level]); 
     2152                REG_RMW_FIELD(ah, AR_PHY_AGC_CTL1, 
     2153                              AR_PHY_AGC_CTL1_COARSE_LOW, 
     2154                              ahp->ah_coarseLow[level]); 
     2155                REG_RMW_FIELD(ah, AR_PHY_AGC_CTL1, 
     2156                              AR_PHY_AGC_CTL1_COARSE_HIGH, 
     2157                              ahp->ah_coarseHigh[level]); 
     2158                REG_RMW_FIELD(ah, AR_PHY_FIND_SIG, 
     2159                              AR_PHY_FIND_SIG_FIRPWR, 
     2160                              ahp->ah_firpwr[level]); 
    21572161 
    21582162                if (level > aniState->noiseImmunityLevel) 
     
    21722176                u_int on = param ? 1 : 0; 
    21732177 
    2174                 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 
    2175                                 AR_PHY_SFCORR_LOW_M1_THRESH_LOW, 
    2176                                 m1ThreshLow[on]); 
    2177                 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 
    2178                                 AR_PHY_SFCORR_LOW_M2_THRESH_LOW, 
    2179                                 m2ThreshLow[on]); 
    2180                 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR, 
    2181                                 AR_PHY_SFCORR_M1_THRESH, 
    2182                                 m1Thresh[on]); 
    2183                 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR, 
    2184                                 AR_PHY_SFCORR_M2_THRESH, 
    2185                                 m2Thresh[on]); 
    2186                 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR, 
    2187                                 AR_PHY_SFCORR_M2COUNT_THR, 
    2188                                 m2CountThr[on]); 
    2189                 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 
    2190                                 AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW, 
    2191                                 m2CountThrLow[on]); 
    2192  
    2193                 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 
    2194                                 AR_PHY_SFCORR_EXT_M1_THRESH_LOW, 
    2195                                 m1ThreshLow[on]); 
    2196                 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 
    2197                                 AR_PHY_SFCORR_EXT_M2_THRESH_LOW, 
    2198                                 m2ThreshLow[on]); 
    2199                 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 
    2200                                 AR_PHY_SFCORR_EXT_M1_THRESH, 
    2201                                 m1Thresh[on]); 
    2202                 OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 
    2203                                 AR_PHY_SFCORR_EXT_M2_THRESH, 
    2204                                 m2Thresh[on]); 
     2178                REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 
     2179                              AR_PHY_SFCORR_LOW_M1_THRESH_LOW, 
     2180                              m1ThreshLow[on]); 
     2181                REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 
     2182                              AR_PHY_SFCORR_LOW_M2_THRESH_LOW, 
     2183                              m2ThreshLow[on]); 
     2184                REG_RMW_FIELD(ah, AR_PHY_SFCORR, 
     2185                              AR_PHY_SFCORR_M1_THRESH, 
     2186                              m1Thresh[on]); 
     2187                REG_RMW_FIELD(ah, AR_PHY_SFCORR, 
     2188                              AR_PHY_SFCORR_M2_THRESH, 
     2189                              m2Thresh[on]); 
     2190                REG_RMW_FIELD(ah, AR_PHY_SFCORR, 
     2191                              AR_PHY_SFCORR_M2COUNT_THR, 
     2192                              m2CountThr[on]); 
     2193                REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 
     2194                              AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW, 
     2195                              m2CountThrLow[on]); 
     2196 
     2197                REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 
     2198                              AR_PHY_SFCORR_EXT_M1_THRESH_LOW, 
     2199                              m1ThreshLow[on]); 
     2200                REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 
     2201                              AR_PHY_SFCORR_EXT_M2_THRESH_LOW, 
     2202                              m2ThreshLow[on]); 
     2203                REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 
     2204                              AR_PHY_SFCORR_EXT_M1_THRESH, 
     2205                              m1Thresh[on]); 
     2206                REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 
     2207                              AR_PHY_SFCORR_EXT_M2_THRESH, 
     2208                              m2Thresh[on]); 
    22052209 
    22062210                if (on) 
    2207                         OS_REG_SET_BIT(ah, AR_PHY_SFCORR_LOW, 
    2208                                        AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); 
     2211                        REG_SET_BIT(ah, AR_PHY_SFCORR_LOW, 
     2212                                    AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); 
    22092213                else 
    2210                         OS_REG_CLR_BIT(ah, AR_PHY_SFCORR_LOW, 
    2211                                        AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); 
     2214                        REG_CLR_BIT(ah, AR_PHY_SFCORR_LOW, 
     2215                                    AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); 
    22122216 
    22132217                if (!on != aniState->ofdmWeakSigDetectOff) { 
     
    22242228                u_int high = param ? 1 : 0; 
    22252229 
    2226                 OS_REG_RMW_FIELD(ah, AR_PHY_CCK_DETECT, 
    2227                                 AR_PHY_CCK_DETECT_WEAK_SIG_THR_CCK, 
    2228                                 weakSigThrCck[high]); 
     2230                REG_RMW_FIELD(ah, AR_PHY_CCK_DETECT, 
     2231                              AR_PHY_CCK_DETECT_WEAK_SIG_THR_CCK, 
     2232                              weakSigThrCck[high]); 
    22292233                if (high != aniState->cckWeakSigThreshold) { 
    22302234                        if (high) 
     
    22412245 
    22422246                if (level >= ARRAY_SIZE(firstep)) { 
    2243                         HDPRINTF(ah, HAL_DBG_ANI, 
     2247                        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    22442248                                 "%s: level out of range (%u > %u)\n", 
    22452249                                 __func__, level, 
    2246                                  (unsigned) ARRAY_SIZE(firstep)); 
    2247                         return AH_FALSE; 
    2248                 } 
    2249                 OS_REG_RMW_FIELD(ah, AR_PHY_FIND_SIG, 
    2250                                 AR_PHY_FIND_SIG_FIRSTEP, 
    2251                                 firstep[level]); 
     2250                                (unsigned) ARRAY_SIZE(firstep)); 
     2251                        return false; 
     2252                } 
     2253                REG_RMW_FIELD(ah, AR_PHY_FIND_SIG, 
     2254                              AR_PHY_FIND_SIG_FIRSTEP, 
     2255                              firstep[level]); 
    22522256                if (level > aniState->firstepLevel) 
    22532257                        ahp->ah_stats.ast_ani_stepup++; 
     
    22632267 
    22642268                if (level >= ARRAY_SIZE(cycpwrThr1)) { 
    2265                         HDPRINTF(ah, HAL_DBG_ANI, 
     2269                        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    22662270                                 "%s: level out of range (%u > %u)\n", 
    22672271                                 __func__, level, 
    22682272                                 (unsigned) 
    2269                                  ARRAY_SIZE(cycpwrThr1)); 
    2270                         return AH_FALSE; 
    2271                 } 
    2272                 OS_REG_RMW_FIELD(ah, AR_PHY_TIMING5, 
    2273                                 AR_PHY_TIMING5_CYCPWR_THR1, 
    2274                                 cycpwrThr1[level]); 
     2273                                ARRAY_SIZE(cycpwrThr1)); 
     2274                        return false; 
     2275                } 
     2276                REG_RMW_FIELD(ah, AR_PHY_TIMING5, 
     2277                              AR_PHY_TIMING5_CYCPWR_THR1, 
     2278                              cycpwrThr1[level]); 
    22752279                if (level > aniState->spurImmunityLevel) 
    22762280                        ahp->ah_stats.ast_ani_spurup++; 
     
    22832287                break; 
    22842288        default: 
    2285                 HDPRINTF(ah, HAL_DBG_ANI, "%s: invalid cmd %u\n", __func__, 
    2286                         cmd); 
    2287                 return AH_FALSE; 
    2288         } 
    2289  
    2290         HDPRINTF(ah, HAL_DBG_ANI, "%s: ANI parameters:\n", __func__); 
    2291         HDPRINTF(ah, HAL_DBG_ANI, 
     2289                DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
     2290                        "%s: invalid cmd %u\n", __func__, cmd); 
     2291                return false; 
     2292        } 
     2293 
     2294        DPRINTF(ah->ah_sc, ATH_DBG_ANI, "%s: ANI parameters:\n", __func__); 
     2295        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    22922296                "noiseImmunityLevel=%d, spurImmunityLevel=%d, " 
    22932297                "ofdmWeakSigDetectOff=%d\n", 
    22942298                 aniState->noiseImmunityLevel, aniState->spurImmunityLevel, 
    22952299                 !aniState->ofdmWeakSigDetectOff); 
    2296         HDPRINTF(ah, HAL_DBG_ANI, 
     2300        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    22972301                "cckWeakSigThreshold=%d, " 
    22982302                "firstepLevel=%d, listenTime=%d\n", 
    22992303                 aniState->cckWeakSigThreshold, aniState->firstepLevel, 
    23002304                 aniState->listenTime); 
    2301         HDPRINTF(ah, HAL_DBG_ANI, 
     2305        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    23022306                 "cycleCount=%d, ofdmPhyErrCount=%d, cckPhyErrCount=%d\n\n", 
    23032307                 aniState->cycleCount, aniState->ofdmPhyErrCount, 
    23042308                 aniState->cckPhyErrCount); 
    2305         return AH_TRUE; 
     2309        return true; 
    23062310} 
    23072311 
     
    23202324                if (aniState->ofdmTrigHigh > AR_PHY_COUNTMAX) { 
    23212325                        aniState->ofdmPhyErrBase = 0; 
    2322                         HDPRINTF(ah, HAL_DBG_ANI, 
     2326                        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    23232327                                 "OFDM Trigger is too high for hw counters\n"); 
    23242328                } else { 
     
    23282332                if (aniState->cckTrigHigh > AR_PHY_COUNTMAX) { 
    23292333                        aniState->cckPhyErrBase = 0; 
    2330                         HDPRINTF(ah, HAL_DBG_ANI, 
     2334                        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    23312335                                 "CCK Trigger is too high for hw counters\n"); 
    23322336                } else { 
     
    23342338                                AR_PHY_COUNTMAX - aniState->cckTrigHigh; 
    23352339                } 
    2336                 HDPRINTF(ah, HAL_DBG_ANI, 
     2340                DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    23372341                         "%s: Writing ofdmbase=%u   cckbase=%u\n", 
    23382342                         __func__, aniState->ofdmPhyErrBase, 
     
    23642368        if (aniState->noiseImmunityLevel < HAL_NOISE_IMMUNE_MAX) { 
    23652369                if (ath9k_hw_ani_control(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 
    2366                                          aniState->noiseImmunityLevel + 
    2367                                          1) == AH_TRUE) { 
     2370                                         aniState->noiseImmunityLevel + 1)) { 
    23682371                        return; 
    23692372                } 
     
    23722375        if (aniState->spurImmunityLevel < HAL_SPUR_IMMUNE_MAX) { 
    23732376                if (ath9k_hw_ani_control(ah, HAL_ANI_SPUR_IMMUNITY_LEVEL, 
    2374                                          aniState->spurImmunityLevel + 
    2375                                          1) == AH_TRUE) { 
     2377                                         aniState->spurImmunityLevel + 1)) { 
    23762378                        return; 
    23772379                } 
     
    23902392                        if (ath9k_hw_ani_control(ah, 
    23912393                                         HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
    2392                                          AH_FALSE) == AH_TRUE) { 
     2394                                         false)) { 
    23932395                                ath9k_hw_ani_control(ah, 
    23942396                                        HAL_ANI_SPUR_IMMUNITY_LEVEL, 
     
    24062408                        ath9k_hw_ani_control(ah, 
    24072409                                             HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
    2408                                              AH_TRUE); 
     2410                                             true); 
    24092411                if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) 
    24102412                        ath9k_hw_ani_control(ah, HAL_ANI_FIRSTEP_LEVEL, 
     
    24172419                                ath9k_hw_ani_control(ah, 
    24182420                                             HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
    2419                                              AH_FALSE); 
     2421                                             false); 
    24202422                        if (aniState->firstepLevel > 0) 
    24212423                                ath9k_hw_ani_control(ah, 
     
    24412443        if (aniState->noiseImmunityLevel < HAL_NOISE_IMMUNE_MAX) { 
    24422444                if (ath9k_hw_ani_control(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 
    2443                                          aniState->noiseImmunityLevel + 
    2444                                          1) == AH_TRUE) { 
     2445                                         aniState->noiseImmunityLevel + 1)) { 
    24452446                        return; 
    24462447                } 
     
    24852486        if (DO_ANI(ah) && ah->ah_opmode != HAL_M_STA 
    24862487            && ah->ah_opmode != HAL_M_IBSS) { 
    2487                 HDPRINTF(ah, HAL_DBG_ANI, 
     2488                DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    24882489                         "%s: Reset ANI state opmode %u\n", __func__, 
    24892490                         ah->ah_opmode); 
     
    25522553        u_int32_t phyCnt1, phyCnt2; 
    25532554 
    2554         HDPRINTF(ah, HAL_DBG_ANI, "Processing Mib Intr\n"); 
     2555        DPRINTF(ah->ah_sc, ATH_DBG_ANI, "Processing Mib Intr\n"); 
    25552556 
    25562557        REG_WRITE(ah, AR_FILT_OFDM, 0); 
     
    26022603                if (aniState->firstepLevel > 0) { 
    26032604                        if (ath9k_hw_ani_control(ah, HAL_ANI_FIRSTEP_LEVEL, 
    2604                                                  aniState->firstepLevel - 
    2605                                                  1) == AH_TRUE) { 
     2605                                                 aniState->firstepLevel - 1)) { 
    26062606                                return; 
    26072607                        } 
     
    26152615                                if (ath9k_hw_ani_control(ah, 
    26162616                                         HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
    2617                                          AH_TRUE) == 
    2618                                     AH_TRUE) { 
     2617                                         true) == 
     2618                                    true) { 
    26192619                                        return; 
    26202620                                } 
     
    26242624                                    (ah, HAL_ANI_FIRSTEP_LEVEL, 
    26252625                                     aniState->firstepLevel - 1) == 
    2626                                     AH_TRUE) { 
     2626                                    true) { 
    26272627                                        return; 
    26282628                                } 
     
    26332633                                    (ah, HAL_ANI_FIRSTEP_LEVEL, 
    26342634                                     aniState->firstepLevel - 1) == 
    2635                                     AH_TRUE) { 
     2635                                    true) { 
    26362636                                        return; 
    26372637                                } 
     
    26422642        if (aniState->spurImmunityLevel > 0) { 
    26432643                if (ath9k_hw_ani_control(ah, HAL_ANI_SPUR_IMMUNITY_LEVEL, 
    2644                                          aniState->spurImmunityLevel - 
    2645                                          1) == AH_TRUE) { 
     2644                                         aniState->spurImmunityLevel - 1)) { 
    26462645                        return; 
    26472646                } 
     
    27162715                    phyCnt2 < aniState->cckPhyErrBase) { 
    27172716                        if (phyCnt1 < aniState->ofdmPhyErrBase) { 
    2718                                 HDPRINTF(ah, HAL_DBG_ANI, 
     2717                                DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    27192718                                         "%s: phyCnt1 0x%x, resetting " 
    27202719                                         "counter value to 0x%x\n", 
     
    27272726                        } 
    27282727                        if (phyCnt2 < aniState->cckPhyErrBase) { 
    2729                                 HDPRINTF(ah, HAL_DBG_ANI, 
     2728                                DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    27302729                                         "%s: phyCnt2 0x%x, resetting " 
    27312730                                         "counter value to 0x%x\n", 
     
    28112810        if (AR_SREV_9280_20_OR_LATER(ah) 
    28122811            || (addr != AR_GPIO_OUTPUT_MUX1)) { 
    2813                 OS_REG_RMW(ah, addr, (type << gpio_shift), 
    2814                            (0x1f << gpio_shift)); 
     2812                REG_RMW(ah, addr, (type << gpio_shift), 
     2813                        (0x1f << gpio_shift)); 
    28152814        } else { 
    28162815                tmp = REG_READ(ah, addr); 
     
    28222821} 
    28232822 
    2824 static enum hal_bool ath9k_hw_cfg_output(struct ath_hal *ah, u_int32_t gpio, 
    2825                                   enum hal_gpio_output_mux_type 
    2826                                   halSignalType) 
     2823static bool ath9k_hw_cfg_output(struct ath_hal *ah, u_int32_t gpio, 
     2824                                enum hal_gpio_output_mux_type 
     2825                                halSignalType) 
    28272826{ 
    28282827        u_int32_t ah_signal_type; 
     
    28462845                ah_signal_type = MuxSignalConversionTable[halSignalType]; 
    28472846        else 
    2848                 return AH_FALSE; 
     2847                return false; 
    28492848 
    28502849        ath9k_hw_gpio_cfg_output_mux(ah, gpio, ah_signal_type); 
     
    28522851        gpio_shift = 2 * gpio; 
    28532852 
    2854         OS_REG_RMW(ah, 
    2855                    AR_GPIO_OE_OUT, 
    2856                    (AR_GPIO_OE_OUT_DRV_ALL << gpio_shift), 
    2857                    (AR_GPIO_OE_OUT_DRV << gpio_shift)); 
    2858  
    2859         return AH_TRUE; 
    2860 } 
    2861  
    2862 static enum hal_bool ath9k_hw_set_gpio(struct ath_hal *ah, u_int32_t gpio, 
    2863                                 u_int32_t val) 
    2864 { 
    2865         OS_REG_RMW(ah, AR_GPIO_IN_OUT, ((val & 1) << gpio), 
    2866                    AR_GPIO_BIT(gpio)); 
    2867         return AH_TRUE; 
     2853        REG_RMW(ah, 
     2854                AR_GPIO_OE_OUT, 
     2855                (AR_GPIO_OE_OUT_DRV_ALL << gpio_shift), 
     2856                (AR_GPIO_OE_OUT_DRV << gpio_shift)); 
     2857 
     2858        return true; 
     2859} 
     2860 
     2861static bool ath9k_hw_set_gpio(struct ath_hal *ah, u_int32_t gpio, 
     2862                              u_int32_t val) 
     2863{ 
     2864        REG_RMW(ah, AR_GPIO_IN_OUT, ((val & 1) << gpio), 
     2865                AR_GPIO_BIT(gpio)); 
     2866        return true; 
    28682867} 
    28692868 
     
    28882887 
    28892888        if (!ath9k_hw_chip_test(ah)) { 
    2890                 HDPRINTF(ah, HAL_DBG_REG_IO, 
     2889                DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, 
    28912890                         "%s: hardware self-test failed\n", __func__); 
    28922891                return HAL_ESELFTEST; 
     
    29202919        case AR9280_DEVID_PCI: 
    29212920                if (reg == 0x7894) { 
    2922                         HDPRINTF(NULL, HAL_DBG_UNMASKABLE, 
     2921                        DPRINTF(ah->ah_sc, ATH_DBG_ANY, 
    29232922                                 "ini VAL: %x  EEPROM: %x\n", value, 
    29242923                                 (pBase->version & 0xff)); 
    29252924 
    29262925                        if ((pBase->version & 0xff) > 0x0a) { 
    2927                                 HDPRINTF(NULL, HAL_DBG_UNMASKABLE, 
     2926                                DPRINTF(ah->ah_sc, ATH_DBG_ANY, 
    29282927                                         "PWDCLKIND: %d\n", 
    29292928                                         pBase->pwdclkind); 
     
    29322931                                         pwdclkind << AR_AN_TOP2_PWDCLKIND_S); 
    29332932                        } else { 
    2934                                 HDPRINTF(NULL, HAL_DBG_UNMASKABLE, 
     2933                                DPRINTF(ah->ah_sc, ATH_DBG_ANY, 
    29352934                                         "PWDCLKIND Earlier Rev\n"); 
    29362935                        } 
    29372936 
    2938                         HDPRINTF(NULL, HAL_DBG_UNMASKABLE, 
     2937                        DPRINTF(ah->ah_sc, ATH_DBG_ANY, 
    29392938                                 "final ini VAL: %x\n", value); 
    29402939                } 
     
    29442943} 
    29452944 
    2946 static enum hal_bool ath9k_hw_fill_cap_info(struct ath_hal *ah) 
     2945static bool ath9k_hw_fill_cap_info(struct ath_hal *ah) 
    29472946{ 
    29482947        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    29652964                else if (ah->ah_currentRD == 0x41) 
    29662965                        ah->ah_currentRD = 0x43; 
    2967                 HDPRINTF(ah, HAL_DBG_REGULATORY, 
     2966                DPRINTF(ah->ah_sc, ATH_DBG_REGULATORY, 
    29682967                         "%s: regdomain mapped to 0x%x\n", __func__, 
    29692968                         ah->ah_currentRD); 
     
    30123011        pCap->halHigh5GhzChan = 6100; 
    30133012 
    3014         pCap->halCipherCkipSupport = AH_FALSE; 
    3015         pCap->halCipherTkipSupport = AH_TRUE; 
    3016         pCap->halCipherAesCcmSupport = AH_TRUE; 
    3017  
    3018         pCap->halMicCkipSupport = AH_FALSE; 
    3019         pCap->halMicTkipSupport = AH_TRUE; 
    3020         pCap->halMicAesCcmSupport = AH_TRUE; 
    3021  
    3022         pCap->halChanSpreadSupport = AH_TRUE; 
     3013        pCap->halCipherCkipSupport = false; 
     3014        pCap->halCipherTkipSupport = true; 
     3015        pCap->halCipherAesCcmSupport = true; 
     3016 
     3017        pCap->halMicCkipSupport = false; 
     3018        pCap->halMicTkipSupport = true; 
     3019        pCap->halMicAesCcmSupport = true; 
     3020 
     3021        pCap->halChanSpreadSupport = true; 
    30233022 
    30243023        pCap->halHTSupport = 
    3025                 ah->ah_config.ath_hal_htEnable ? AH_TRUE : AH_FALSE; 
    3026         pCap->halGTTSupport = AH_TRUE; 
    3027         pCap->halVEOLSupport = AH_TRUE; 
    3028         pCap->halBssIdMaskSupport = AH_TRUE; 
    3029         pCap->halMcastKeySrchSupport = AH_FALSE; 
     3024                ah->ah_config.ath_hal_htEnable ? true : false; 
     3025        pCap->halGTTSupport = true; 
     3026        pCap->halVEOLSupport = true; 
     3027        pCap->halBssIdMaskSupport = true; 
     3028        pCap->halMcastKeySrchSupport = false; 
    30303029 
    30313030        if (capField & AR_EEPROM_EEPCAP_MAXQCU) 
     
    30413040                pCap->halKeyCacheSize = AR_KEYTABLE_SIZE; 
    30423041 
    3043         pCap->halFastCCSupport = AH_TRUE; 
     3042        pCap->halFastCCSupport = true; 
    30443043        pCap->halNumMRRetries = 4; 
    30453044        pCap->halTxTrigLevelMax = MAX_TX_FIFO_THRESHOLD; 
     
    30513050 
    30523051        if (AR_SREV_9280_10_OR_LATER(ah)) { 
    3053                 pCap->halWowSupport = AH_TRUE; 
    3054                 pCap->halWowMatchPatternExact = AH_TRUE; 
     3052                pCap->halWowSupport = true; 
     3053                pCap->halWowMatchPatternExact = true; 
    30553054        } else { 
    3056                 pCap->halWowSupport = AH_FALSE; 
    3057                 pCap->halWowMatchPatternExact = AH_FALSE; 
     3055                pCap->halWowSupport = false; 
     3056                pCap->halWowMatchPatternExact = false; 
    30583057        } 
    30593058 
    30603059        if (AR_SREV_9160_10_OR_LATER(ah) || AR_SREV_9100(ah)) { 
    3061                 pCap->halCSTSupport = AH_TRUE; 
     3060                pCap->halCSTSupport = true; 
    30623061                pCap->halRtsAggrLimit = ATH_AMPDU_LIMIT_MAX; 
    30633062        } else { 
     
    30653064        } 
    30663065 
    3067         pCap->halEnhancedPmSupport = AH_TRUE; 
     3066        pCap->halEnhancedPmSupport = true; 
    30683067 
    30693068        ah->ah_rfsilent = ath9k_hw_get_eeprom(ahp, EEP_RF_SILENT); 
     
    30743073                        MS(ah->ah_rfsilent, EEP_RFSILENT_POLARITY); 
    30753074 
    3076                 ath9k_hw_setcapability(ah, HAL_CAP_RFSILENT, 1, AH_TRUE, 
     3075                ath9k_hw_setcapability(ah, HAL_CAP_RFSILENT, 1, true, 
    30773076                                       NULL); 
    3078                 pCap->halRfSilentSupport = AH_TRUE; 
     3077                pCap->halRfSilentSupport = true; 
    30793078        } 
    30803079 
     
    30843083            (ah->ah_macVersion == AR_SREV_VERSION_9100) || 
    30853084            (ah->ah_macVersion == AR_SREV_VERSION_9280)) 
    3086                 pCap->halAutoSleepSupport = AH_FALSE; 
     3085                pCap->halAutoSleepSupport = false; 
    30873086        else 
    3088                 pCap->halAutoSleepSupport = AH_TRUE; 
     3087                pCap->halAutoSleepSupport = true; 
    30893088 
    30903089        if (AR_SREV_9280(ah)) 
    3091                 pCap->hal4kbSplitTransSupport = AH_FALSE; 
     3090                pCap->hal4kbSplitTransSupport = false; 
    30923091        else 
    3093                 pCap->hal4kbSplitTransSupport = AH_TRUE; 
     3092                pCap->hal4kbSplitTransSupport = true; 
    30943093 
    30953094        if (ah->ah_currentRDExt & (1 << REG_EXT_JAPAN_MIDBAND)) { 
     
    31123111                ath9k_hw_get_num_ant_config(ahp, HAL_FREQ_BAND_2GHZ); 
    31133112 
    3114         return AH_TRUE; 
     3113        return true; 
    31153114} 
    31163115 
     
    31353134static void ath9k_set_power_sleep(struct ath_hal *ah, int setChip) 
    31363135{ 
    3137         OS_REG_SET_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV); 
     3136        REG_SET_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV); 
    31383137        if (setChip) { 
    3139                 OS_REG_CLR_BIT(ah, AR_RTC_FORCE_WAKE, 
    3140                                AR_RTC_FORCE_WAKE_EN); 
     3138                REG_CLR_BIT(ah, AR_RTC_FORCE_WAKE, 
     3139                            AR_RTC_FORCE_WAKE_EN); 
    31413140                if (!AR_SREV_9100(ah)) 
    31423141                        REG_WRITE(ah, AR_RC, AR_RC_AHB | AR_RC_HOSTIF); 
    31433142 
    3144                 OS_REG_CLR_BIT(ah, (u_int16_t) (AR_RTC_RESET), 
    3145                                AR_RTC_RESET_EN); 
     3143                REG_CLR_BIT(ah, (u_int16_t) (AR_RTC_RESET), 
     3144                            AR_RTC_RESET_EN); 
    31463145        } 
    31473146} 
     
    31493148static void ath9k_set_power_network_sleep(struct ath_hal *ah, int setChip) 
    31503149{ 
    3151         OS_REG_SET_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV); 
     3150        REG_SET_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV); 
    31523151        if (setChip) { 
    31533152                struct hal_capabilities *pCap = &ah->ah_caps; 
     
    31573156                                  AR_RTC_FORCE_WAKE_ON_INT); 
    31583157                } else { 
    3159                         OS_REG_CLR_BIT(ah, AR_RTC_FORCE_WAKE, 
    3160                                        AR_RTC_FORCE_WAKE_EN); 
    3161                 } 
    3162         } 
    3163 } 
    3164  
    3165 static enum hal_bool ath9k_hw_set_power_awake(struct ath_hal *ah, 
    3166                                               int setChip) 
     3158                        REG_CLR_BIT(ah, AR_RTC_FORCE_WAKE, 
     3159                                    AR_RTC_FORCE_WAKE_EN); 
     3160                } 
     3161        } 
     3162} 
     3163 
     3164static bool ath9k_hw_set_power_awake(struct ath_hal *ah, 
     3165                                     int setChip) 
    31673166{ 
    31683167        u_int32_t val; 
     
    31733172                    AR_RTC_STATUS_SHUTDOWN) { 
    31743173                        if (ath9k_hw_set_reset_reg(ah, HAL_RESET_POWER_ON) 
    3175                             != AH_TRUE) { 
    3176                                 return AH_FALSE; 
     3174                            != true) { 
     3175                                return false; 
    31773176                        } 
    31783177                } 
    31793178                if (AR_SREV_9100(ah)) 
    3180                         OS_REG_SET_BIT(ah, AR_RTC_RESET, 
     3179                        REG_SET_BIT(ah, AR_RTC_RESET, 
    31813180                                       AR_RTC_RESET_EN); 
    31823181 
    3183                 OS_REG_SET_BIT(ah, AR_RTC_FORCE_WAKE, 
    3184                                AR_RTC_FORCE_WAKE_EN); 
     3182                REG_SET_BIT(ah, AR_RTC_FORCE_WAKE, 
     3183                            AR_RTC_FORCE_WAKE_EN); 
    31853184                udelay(50); 
    31863185 
     
    31903189                                break; 
    31913190                        udelay(50); 
    3192                         OS_REG_SET_BIT(ah, AR_RTC_FORCE_WAKE, 
     3191                        REG_SET_BIT(ah, AR_RTC_FORCE_WAKE, 
    31933192                                       AR_RTC_FORCE_WAKE_EN); 
    31943193                } 
    31953194                if (i == 0) { 
    3196                         HDPRINTF(ah, HAL_DBG_POWER_MGMT, 
     3195                        DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT, 
    31973196                                 "%s: Failed to wakeup in %uus\n", 
    31983197                                 __func__, POWER_UP_TIME / 20); 
    3199                         return AH_FALSE; 
    3200                 } 
    3201         } 
    3202  
    3203         OS_REG_CLR_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV); 
    3204         return AH_TRUE; 
    3205 } 
    3206  
    3207 enum hal_bool ath9k_hw_setpower(struct ath_hal *ah, 
    3208                                 enum hal_power_mode mode) 
     3198                        return false; 
     3199                } 
     3200        } 
     3201 
     3202        REG_CLR_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV); 
     3203        return true; 
     3204} 
     3205 
     3206bool ath9k_hw_setpower(struct ath_hal *ah, 
     3207                       enum hal_power_mode mode) 
    32093208{ 
    32103209        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    32153214                "UNDEFINED" 
    32163215        }; 
    3217         int status = AH_TRUE, setChip = AH_TRUE; 
    3218  
    3219         HDPRINTF(ah, HAL_DBG_POWER_MGMT, "%s: %s -> %s (%s)\n", __func__, 
     3216        int status = true, setChip = true; 
     3217 
     3218        DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT, "%s: %s -> %s (%s)\n", __func__, 
    32203219                 modes[ahp->ah_powerMode], modes[mode], 
    32213220                 setChip ? "set chip " : ""); 
     
    32273226        case HAL_PM_FULL_SLEEP: 
    32283227                ath9k_set_power_sleep(ah, setChip); 
    3229                 ahp->ah_chipFullSleep = AH_TRUE; 
     3228                ahp->ah_chipFullSleep = true; 
    32303229                break; 
    32313230        case HAL_PM_NETWORK_SLEEP: 
     
    32333232                break; 
    32343233        default: 
    3235                 HDPRINTF(ah, HAL_DBG_POWER_MGMT, 
     3234                DPRINTF(ah->ah_sc, ATH_DBG_POWER_MGMT, 
    32363235                         "%s: unknown power mode %u\n", __func__, mode); 
    3237                 return AH_FALSE; 
     3236                return false; 
    32383237        } 
    32393238        ahp->ah_powerMode = mode; 
     
    32413240} 
    32423241 
    3243 static struct ath_hal *ath9k_hw_do_attach(u_int16_t devid, void *sc, 
     3242static struct ath_hal *ath9k_hw_do_attach(u_int16_t devid, 
     3243                                          struct ath_softc *sc, 
    32443244                                          void __iomem *mem, 
    32453245                                          enum hal_status *status) 
     
    32623262 
    32633263        if (ah->ah_config.ath_hal_intrMitigation != 0) 
    3264                 ahp->ah_intrMitigation = AH_TRUE; 
     3264                ahp->ah_intrMitigation = true; 
    32653265 
    32663266        if (!ath9k_hw_set_reset_reg(ah, HAL_RESET_POWER_ON)) { 
    3267                 HDPRINTF(ah, HAL_DBG_RESET, "%s: couldn't reset chip\n", 
     3267                DPRINTF(ah->ah_sc, ATH_DBG_RESET, "%s: couldn't reset chip\n", 
    32683268                         __func__); 
    32693269                ecode = HAL_EIO; 
     
    32723272 
    32733273        if (!ath9k_hw_setpower(ah, HAL_PM_AWAKE)) { 
    3274                 HDPRINTF(ah, HAL_DBG_RESET, "%s: couldn't wakeup chip\n", 
     3274                DPRINTF(ah->ah_sc, ATH_DBG_RESET, "%s: couldn't wakeup chip\n", 
    32753275                         __func__); 
    32763276                ecode = HAL_EIO; 
     
    32873287                } 
    32883288        } 
    3289         HDPRINTF(ah, HAL_DBG_RESET, "%s: ath_hal_serializeRegMode is %d\n", 
    3290                  __func__, ah->ah_config.ath_hal_serializeRegMode); 
     3289        DPRINTF(ah->ah_sc, ATH_DBG_RESET, 
     3290                "%s: ath_hal_serializeRegMode is %d\n", 
     3291                __func__, ah->ah_config.ath_hal_serializeRegMode); 
    32913292 
    32923293        if ((ah->ah_macVersion != AR_SREV_VERSION_5416_PCI) && 
     
    32943295            (ah->ah_macVersion != AR_SREV_VERSION_9160) && 
    32953296            (!AR_SREV_9100(ah)) && (!AR_SREV_9280(ah))) { 
    3296                 HDPRINTF(ah, HAL_DBG_RESET, 
     3297                DPRINTF(ah->ah_sc, ATH_DBG_RESET, 
    32973298                         "%s: Mac Chip Rev 0x%02x.%x is not supported by " 
    32983299                         "this driver\n", __func__, 
     
    33053306                ahp->ah_iqCalData.calData = &iq_cal_multi_sample; 
    33063307                ahp->ah_suppCals = IQ_MISMATCH_CAL; 
    3307                 ah->ah_isPciExpress = AH_FALSE; 
     3308                ah->ah_isPciExpress = false; 
    33083309        } 
    33093310        ah->ah_phyRev = REG_READ(ah, AR_PHY_CHIP_ID); 
     
    33433344        } 
    33443345 
    3345         HDPRINTF(ah, HAL_DBG_RESET, 
     3346        DPRINTF(ah->ah_sc, ATH_DBG_RESET, 
    33463347                 "%s: This Mac Chip Rev 0x%02x.%x is \n", __func__, 
    33473348                 ah->ah_macVersion, ah->ah_macRev); 
     
    34783479 
    34793480        if (!ath9k_hw_fill_cap_info(ah)) { 
    3480                 HDPRINTF(ah, HAL_DBG_RESET, 
     3481                DPRINTF(ah->ah_sc, ATH_DBG_RESET, 
    34813482                         "%s:failed ath9k_hw_fill_cap_info\n", __func__); 
    34823483                ecode = HAL_EEREAD; 
     
    34863487        ecode = ath9k_hw_init_macaddr(ah); 
    34873488        if (ecode != HAL_OK) { 
    3488                 HDPRINTF(ah, HAL_DBG_RESET, 
     3489                DPRINTF(ah->ah_sc, ATH_DBG_RESET, 
    34893490                         "%s: failed initializing mac address\n", 
    34903491                         __func__); 
     
    35223523} 
    35233524 
    3524 enum hal_bool ath9k_get_channel_edges(struct ath_hal *ah, 
    3525                                       u_int16_t flags, u_int16_t *low, 
    3526                                       u_int16_t *high) 
     3525bool ath9k_get_channel_edges(struct ath_hal *ah, 
     3526                             u_int16_t flags, u_int16_t *low, 
     3527                             u_int16_t *high) 
    35273528{ 
    35283529        struct hal_capabilities *pCap = &ah->ah_caps; 
     
    35313532                *low = pCap->halLow5GhzChan; 
    35323533                *high = pCap->halHigh5GhzChan; 
    3533                 return AH_TRUE; 
     3534                return true; 
    35343535        } 
    35353536        if ((flags & CHANNEL_2GHZ)) { 
     
    35373538                *high = pCap->halHigh2GhzChan; 
    35383539 
    3539                 return AH_TRUE; 
    3540         } 
    3541         return AH_FALSE; 
    3542 } 
    3543  
    3544 static inline enum hal_bool ath9k_hw_fill_vpd_table(u_int8_t pwrMin, 
    3545                                                     u_int8_t pwrMax, 
    3546                                                     u_int8_t *pPwrList, 
    3547                                                     u_int8_t *pVpdList, 
    3548                                                     u_int16_t 
    3549                                                     numIntercepts, 
    3550                                                     u_int8_t *pRetVpdList) 
     3540                return true; 
     3541        } 
     3542        return false; 
     3543} 
     3544 
     3545static inline bool ath9k_hw_fill_vpd_table(u_int8_t pwrMin, 
     3546                                           u_int8_t pwrMax, 
     3547                                           u_int8_t *pPwrList, 
     3548                                           u_int8_t *pVpdList, 
     3549                                           u_int16_t 
     3550                                           numIntercepts, 
     3551                                           u_int8_t *pRetVpdList) 
    35513552{ 
    35523553        u_int16_t i, k; 
     
    35763577        } 
    35773578 
    3578         return AH_TRUE; 
     3579        return true; 
    35793580} 
    35803581 
     
    36073608        int16_t tmpVal; 
    36083609        u_int16_t sizeCurrVpdTable, maxIndex, tgtIndex; 
    3609         enum hal_bool match; 
     3610        bool match; 
    36103611        int16_t minDelta = 0; 
    36113612        struct chan_centers centers; 
     
    37613762} 
    37623763 
    3763 static inline enum hal_bool 
     3764static inline bool 
    37643765ath9k_hw_set_power_cal_table(struct ath_hal *ah, 
    37653766                             struct ar5416_eeprom *pEepData, 
     
    38153816        } 
    38163817 
    3817         OS_REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_NUM_PD_GAIN, 
    3818                         (numXpdGain - 1) & 0x3); 
    3819         OS_REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_1, 
    3820                         xpdGainValues[0]); 
    3821         OS_REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_2, 
    3822                         xpdGainValues[1]); 
    3823         OS_REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_3, 
    3824                         xpdGainValues[2]); 
     3818        REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_NUM_PD_GAIN, 
     3819                      (numXpdGain - 1) & 0x3); 
     3820        REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_1, 
     3821                      xpdGainValues[0]); 
     3822        REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_2, 
     3823                      xpdGainValues[1]); 
     3824        REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_3, 
     3825                      xpdGainValues[2]); 
    38253826 
    38263827        for (i = 0; i < AR5416_MAX_CHAINS; i++) { 
     
    38753876                                REG_WRITE(ah, regOffset, reg32); 
    38763877 
    3877                                 HDPRINTF(ah, HAL_DBG_PHY_IO, 
     3878                                DPRINTF(ah->ah_sc, ATH_DBG_PHY_IO, 
    38783879                                         "PDADC (%d,%4x): %4.4x %8.8x\n", 
    38793880                                         i, regChainOffset, regOffset, 
    38803881                                         reg32); 
    3881                                 HDPRINTF(ah, HAL_DBG_PHY_IO, 
     3882                                DPRINTF(ah->ah_sc, ATH_DBG_PHY_IO, 
    38823883                                "PDADC: Chain %d | PDADC %3d Value %3d | " 
    38833884                                "PDADC %3d Value %3d | PDADC %3d Value %3d | " 
     
    38953896        *pTxPowerIndexOffset = 0; 
    38963897 
    3897         return AH_TRUE; 
     3898        return true; 
    38983899} 
    38993900 
     
    39033904        u_int8_t i; 
    39043905 
    3905         if (ah->ah_isPciExpress != AH_TRUE) 
     3906        if (ah->ah_isPciExpress != true) 
    39063907                return; 
    39073908 
     
    39523953        } 
    39533954 
    3954         OS_REG_SET_BIT(ah, AR_PCIE_PM_CTRL, AR_PCIE_PM_CTRL_ENA); 
     3955        REG_SET_BIT(ah, AR_PCIE_PM_CTRL, AR_PCIE_PM_CTRL_ENA); 
    39553956 
    39563957        if (ah->ah_config.ath_hal_pcieWaen) { 
     
    39713972                                  struct cal_target_power_leg *pNewPower, 
    39723973                                  u_int16_t numRates, 
    3973                                   enum hal_bool isExtTarget) 
     3974                                  bool isExtTarget) 
    39743975{ 
    39753976        u_int16_t clo, chi; 
     
    40374038                           struct cal_target_power_ht *pNewPower, 
    40384039                           u_int16_t numRates, 
    4039                            enum hal_bool isHt40Target) 
     4040                           bool isHt40Target) 
    40404041{ 
    40414042        u_int16_t clo, chi; 
     
    41004101ath9k_hw_get_max_edge_power(u_int16_t freq, 
    41014102                            struct cal_ctl_edges *pRdEdgesPower, 
    4102                             enum hal_bool is2GHz) 
     4103                            bool is2GHz) 
    41034104{ 
    41044105        u_int16_t twiceMaxEdgePower = AR5416_MAX_RATE_POWER; 
     
    41274128} 
    41284129 
    4129 static inline enum hal_bool 
     4130static inline bool 
    41304131ath9k_hw_set_power_per_rate_table(struct ath_hal *ah, 
    41314132                                  struct ar5416_eeprom *pEepData, 
     
    42214222                        AR5416_NUM_2G_CCK_TARGET_POWERS, 
    42224223                        &targetPowerCck, 4, 
    4223                         AH_FALSE); 
     4224                        false); 
    42244225                ath9k_hw_get_legacy_target_powers(ah, chan, 
    42254226                        pEepData-> 
     
    42274228                        AR5416_NUM_2G_20_TARGET_POWERS, 
    42284229                        &targetPowerOfdm, 4, 
    4229                         AH_FALSE); 
     4230                        false); 
    42304231                ath9k_hw_get_target_powers(ah, chan, 
    42314232                        pEepData->calTargetPower2GHT20, 
    42324233                        AR5416_NUM_2G_20_TARGET_POWERS, 
    4233                         &targetPowerHt20, 8, AH_FALSE); 
     4234                        &targetPowerHt20, 8, false); 
    42344235 
    42354236                if (IS_CHAN_HT40(chan)) { 
     
    42404241                                AR5416_NUM_2G_40_TARGET_POWERS, 
    42414242                                &targetPowerHt40, 8, 
    4242                                 AH_TRUE); 
     4243                                true); 
    42434244                        ath9k_hw_get_legacy_target_powers(ah, chan, 
    42444245                                pEepData-> 
     
    42464247                                AR5416_NUM_2G_CCK_TARGET_POWERS, 
    42474248                                &targetPowerCckExt, 
    4248                                 4, AH_TRUE); 
     4249                                4, true); 
    42494250                        ath9k_hw_get_legacy_target_powers(ah, chan, 
    42504251                                pEepData->