Changeset 12079


Ignore:
Timestamp:
2008-08-03T16:28:21+02:00 (10 years ago)
Author:
kaloz
Message:

update ath9k to latest git version

Location:
trunk/package/ath9k
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/ath9k/Makefile

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

    r12038 r12079  
    5353 
    5454struct ath_tx_status { 
    55         u_int32_t ts_tstamp; 
    56         u_int16_t ts_seqnum; 
    57         u_int8_t ts_status; 
    58         u_int8_t ts_ratecode; 
    59         u_int8_t ts_rateindex; 
     55        u32 ts_tstamp; 
     56        u16 ts_seqnum; 
     57        u8 ts_status; 
     58        u8 ts_ratecode; 
     59        u8 ts_rateindex; 
    6060        int8_t ts_rssi; 
    61         u_int8_t ts_shortretry; 
    62         u_int8_t ts_longretry; 
    63         u_int8_t ts_virtcol; 
    64         u_int8_t ts_antenna; 
    65         u_int8_t ts_flags; 
     61        u8 ts_shortretry; 
     62        u8 ts_longretry; 
     63        u8 ts_virtcol; 
     64        u8 ts_antenna; 
     65        u8 ts_flags; 
    6666        int8_t ts_rssi_ctl0; 
    6767        int8_t ts_rssi_ctl1; 
     
    7070        int8_t ts_rssi_ext1; 
    7171        int8_t ts_rssi_ext2; 
    72         u_int8_t pad[3]; 
    73         u_int32_t ba_low; 
    74         u_int32_t ba_high; 
    75         u_int32_t evm0; 
    76         u_int32_t evm1; 
    77         u_int32_t evm2; 
     72        u8 pad[3]; 
     73        u32 ba_low; 
     74        u32 ba_high; 
     75        u32 evm0; 
     76        u32 evm1; 
     77        u32 evm2; 
    7878}; 
    7979 
    8080struct ath_rx_status { 
    81         u_int32_t rs_tstamp; 
    82         u_int16_t rs_datalen; 
    83         u_int8_t rs_status; 
    84         u_int8_t rs_phyerr; 
     81        u32 rs_tstamp; 
     82        u16 rs_datalen; 
     83        u8 rs_status; 
     84        u8 rs_phyerr; 
    8585        int8_t rs_rssi; 
    86         u_int8_t rs_keyix; 
    87         u_int8_t rs_rate; 
    88         u_int8_t rs_antenna; 
    89         u_int8_t rs_more; 
     86        u8 rs_keyix; 
     87        u8 rs_rate; 
     88        u8 rs_antenna; 
     89        u8 rs_more; 
    9090        int8_t rs_rssi_ctl0; 
    9191        int8_t rs_rssi_ctl1; 
     
    9494        int8_t rs_rssi_ext1; 
    9595        int8_t rs_rssi_ext2; 
    96         u_int8_t rs_isaggr; 
    97         u_int8_t rs_moreaggr; 
    98         u_int8_t rs_num_delims; 
    99         u_int8_t rs_flags; 
    100         u_int32_t evm0; 
    101         u_int32_t evm1; 
    102         u_int32_t evm2; 
     96        u8 rs_isaggr; 
     97        u8 rs_moreaggr; 
     98        u8 rs_num_delims; 
     99        u8 rs_flags; 
     100        u32 evm0; 
     101        u32 evm1; 
     102        u32 evm2; 
    103103}; 
    104104 
     
    117117#define ATH9K_RX_DECRYPT_BUSY     0x40 
    118118 
    119 #define HAL_RXKEYIX_INVALID     ((u_int8_t)-1) 
    120 #define HAL_TXKEYIX_INVALID     ((u_int)-1) 
     119#define ATH9K_RXKEYIX_INVALID   ((u8)-1) 
     120#define ATH9K_TXKEYIX_INVALID   ((u32)-1) 
    121121 
    122122struct ath_desc { 
    123         u_int32_t ds_link; 
    124         u_int32_t ds_data; 
    125         u_int32_t ds_ctl0; 
    126         u_int32_t ds_ctl1; 
    127         u_int32_t ds_hw[20]; 
     123        u32 ds_link; 
     124        u32 ds_data; 
     125        u32 ds_ctl0; 
     126        u32 ds_ctl1; 
     127        u32 ds_hw[20]; 
    128128        union { 
    129129                struct ath_tx_status tx; 
     
    138138#define ds_stat         ds_us.stats 
    139139 
    140 #define HAL_TXDESC_CLRDMASK     0x0001 
    141 #define HAL_TXDESC_NOACK        0x0002 
    142 #define HAL_TXDESC_RTSENA       0x0004 
    143 #define HAL_TXDESC_CTSENA       0x0008 
    144 #define HAL_TXDESC_INTREQ       0x0010 
    145 #define HAL_TXDESC_VEOL         0x0020 
    146 #define HAL_TXDESC_EXT_ONLY     0x0040 
    147 #define HAL_TXDESC_EXT_AND_CTL  0x0080 
    148 #define HAL_TXDESC_VMF          0x0100 
    149 #define HAL_TXDESC_FRAG_IS_ON   0x0200 
    150  
    151 #define HAL_RXDESC_INTREQ       0x0020 
     140#define ATH9K_TXDESC_CLRDMASK           0x0001 
     141#define ATH9K_TXDESC_NOACK              0x0002 
     142#define ATH9K_TXDESC_RTSENA             0x0004 
     143#define ATH9K_TXDESC_CTSENA             0x0008 
     144#define ATH9K_TXDESC_INTREQ             0x0010 
     145#define ATH9K_TXDESC_VEOL               0x0020 
     146#define ATH9K_TXDESC_EXT_ONLY           0x0040 
     147#define ATH9K_TXDESC_EXT_AND_CTL        0x0080 
     148#define ATH9K_TXDESC_VMF                0x0100 
     149#define ATH9K_TXDESC_FRAG_IS_ON         0x0200 
     150 
     151#define ATH9K_RXDESC_INTREQ             0x0020 
    152152 
    153153enum hal_capability_type { 
     
    169169 
    170170struct hal_capabilities { 
    171         u_int halChanSpreadSupport:1, 
     171        u32 halChanSpreadSupport:1, 
    172172                halChapTuningSupport:1, 
    173173                halMicAesCcmSupport:1, 
     
    193193                hal4kbSplitTransSupport:1, 
    194194                halWowMatchPatternExact:1; 
    195         u_int32_t halWirelessModes; 
    196         u_int16_t halTotalQueues; 
    197         u_int16_t halKeyCacheSize; 
    198         u_int16_t halLow5GhzChan, halHigh5GhzChan; 
    199         u_int16_t halLow2GhzChan, halHigh2GhzChan; 
    200         u_int16_t halNumMRRetries; 
    201         u_int16_t halRtsAggrLimit; 
    202         u_int8_t halTxChainMask; 
    203         u_int8_t halRxChainMask; 
    204         u_int16_t halTxTrigLevelMax; 
    205         u_int16_t halRegCap; 
    206         u_int8_t halNumGpioPins; 
    207         u_int8_t halNumAntCfg2GHz; 
    208         u_int8_t halNumAntCfg5GHz; 
     195        u32 halWirelessModes; 
     196        u16 halTotalQueues; 
     197        u16 halKeyCacheSize; 
     198        u16 halLow5GhzChan, halHigh5GhzChan; 
     199        u16 halLow2GhzChan, halHigh2GhzChan; 
     200        u16 halNumMRRetries; 
     201        u16 halRtsAggrLimit; 
     202        u8 halTxChainMask; 
     203        u8 halRxChainMask; 
     204        u16 halTxTrigLevelMax; 
     205        u16 halRegCap; 
     206        u8 halNumGpioPins; 
     207        u8 halNumAntCfg2GHz; 
     208        u8 halNumAntCfg5GHz; 
    209209}; 
    210210 
     
    215215        int ath_hal_6mb_ack; 
    216216        int ath_hal_cwmIgnoreExtCCA; 
    217         u_int8_t ath_hal_pciePowerSaveEnable; 
    218         u_int8_t ath_hal_pcieL1SKPEnable; 
    219         u_int8_t ath_hal_pcieClockReq; 
    220         u_int32_t ath_hal_pcieWaen; 
     217        u8 ath_hal_pciePowerSaveEnable; 
     218        u8 ath_hal_pcieL1SKPEnable; 
     219        u8 ath_hal_pcieClockReq; 
     220        u32 ath_hal_pcieWaen; 
    221221        int ath_hal_pciePowerReset; 
    222         u_int8_t ath_hal_pcieRestore; 
    223         u_int8_t ath_hal_analogShiftReg; 
    224         u_int8_t ath_hal_htEnable; 
    225         u_int32_t ath_hal_ofdmTrigLow; 
    226         u_int32_t ath_hal_ofdmTrigHigh; 
    227         u_int32_t ath_hal_cckTrigHigh; 
    228         u_int32_t ath_hal_cckTrigLow; 
    229         u_int32_t ath_hal_enableANI; 
    230         u_int8_t ath_hal_noiseImmunityLvl; 
    231         u_int32_t ath_hal_ofdmWeakSigDet; 
    232         u_int32_t ath_hal_cckWeakSigThr; 
    233         u_int8_t ath_hal_spurImmunityLvl; 
    234         u_int8_t ath_hal_firStepLvl; 
     222        u8 ath_hal_pcieRestore; 
     223        u8 ath_hal_analogShiftReg; 
     224        u8 ath_hal_htEnable; 
     225        u32 ath_hal_ofdmTrigLow; 
     226        u32 ath_hal_ofdmTrigHigh; 
     227        u32 ath_hal_cckTrigHigh; 
     228        u32 ath_hal_cckTrigLow; 
     229        u32 ath_hal_enableANI; 
     230        u8 ath_hal_noiseImmunityLvl; 
     231        u32 ath_hal_ofdmWeakSigDet; 
     232        u32 ath_hal_cckWeakSigThr; 
     233        u8 ath_hal_spurImmunityLvl; 
     234        u8 ath_hal_firStepLvl; 
    235235        int8_t ath_hal_rssiThrHigh; 
    236236        int8_t ath_hal_rssiThrLow; 
    237         u_int16_t ath_hal_diversityControl; 
    238         u_int16_t ath_hal_antennaSwitchSwap; 
     237        u16 ath_hal_diversityControl; 
     238        u16 ath_hal_antennaSwitchSwap; 
    239239        int ath_hal_serializeRegMode; 
    240240        int ath_hal_intrMitigation; 
     
    251251#define AR_SPUR_FEEQ_BOUND_HT20 10 
    252252        int ath_hal_spurMode; 
    253         u_int16_t ath_hal_spurChans[AR_EEPROM_MODAL_SPURS][2]; 
    254 }; 
    255  
    256 enum hal_tx_queue { 
    257         HAL_TX_QUEUE_INACTIVE = 0, 
    258         HAL_TX_QUEUE_DATA, 
    259         HAL_TX_QUEUE_BEACON, 
    260         HAL_TX_QUEUE_CAB, 
    261         HAL_TX_QUEUE_UAPSD, 
    262         HAL_TX_QUEUE_PSPOLL 
    263 }; 
    264  
    265 #define HAL_NUM_TX_QUEUES 10 
    266  
    267 enum hal_tx_queue_subtype { 
    268         HAL_WME_AC_BK = 0, 
    269         HAL_WME_AC_BE, 
    270         HAL_WME_AC_VI, 
    271         HAL_WME_AC_VO, 
    272         HAL_WME_UPSD 
    273 }; 
    274  
    275 enum hal_tx_queue_flags { 
     253        u16 ath_hal_spurChans[AR_EEPROM_MODAL_SPURS][2]; 
     254}; 
     255 
     256enum ath9k_tx_queue { 
     257        ATH9K_TX_QUEUE_INACTIVE = 0, 
     258        ATH9K_TX_QUEUE_DATA, 
     259        ATH9K_TX_QUEUE_BEACON, 
     260        ATH9K_TX_QUEUE_CAB, 
     261        ATH9K_TX_QUEUE_UAPSD, 
     262        ATH9K_TX_QUEUE_PSPOLL 
     263}; 
     264 
     265#define ATH9K_NUM_TX_QUEUES 10 
     266 
     267enum ath9k_tx_queue_subtype { 
     268        ATH9K_WME_AC_BK = 0, 
     269        ATH9K_WME_AC_BE, 
     270        ATH9K_WME_AC_VI, 
     271        ATH9K_WME_AC_VO, 
     272        ATH9K_WME_UPSD 
     273}; 
     274 
     275enum ath9k_tx_queue_flags { 
    276276        TXQ_FLAG_TXOKINT_ENABLE = 0x0001, 
    277277        TXQ_FLAG_TXERRINT_ENABLE = 0x0001, 
     
    285285}; 
    286286 
    287 struct hal_txq_info { 
    288         u_int32_t tqi_ver; 
    289         enum hal_tx_queue_subtype tqi_subtype; 
    290         enum hal_tx_queue_flags tqi_qflags; 
    291         u_int32_t tqi_priority; 
    292         u_int32_t tqi_aifs; 
    293         u_int32_t tqi_cwmin; 
    294         u_int32_t tqi_cwmax; 
    295         u_int16_t tqi_shretry; 
    296         u_int16_t tqi_lgretry; 
    297         u_int32_t tqi_cbrPeriod; 
    298         u_int32_t tqi_cbrOverflowLimit; 
    299         u_int32_t tqi_burstTime; 
    300         u_int32_t tqi_readyTime; 
    301         u_int32_t tqi_compBuf; 
    302 }; 
    303  
    304 #define HAL_TQI_NONVAL 0xffff 
    305  
    306 #define HAL_TXQ_USEDEFAULT ((u_int32_t) -1) 
    307  
    308 #define HAL_COMP_BUF_MAX_SIZE    9216 
    309 #define HAL_COMP_BUF_ALIGN_SIZE  512 
    310 #define HAL_DECOMP_MASK_SIZE     128 
    311  
    312 #define HAL_READY_TIME_LO_BOUND  50 
    313 #define HAL_READY_TIME_HI_BOUND  96 
    314  
    315 enum hal_pkt_type { 
    316         HAL_PKT_TYPE_NORMAL = 0, 
    317         HAL_PKT_TYPE_ATIM, 
    318         HAL_PKT_TYPE_PSPOLL, 
    319         HAL_PKT_TYPE_BEACON, 
    320         HAL_PKT_TYPE_PROBE_RESP, 
    321         HAL_PKT_TYPE_CHIRP, 
    322         HAL_PKT_TYPE_GRP_POLL, 
    323 }; 
    324  
    325 struct hal_tx_queue_info { 
    326         u_int32_t tqi_ver; 
    327         enum hal_tx_queue tqi_type; 
    328         enum hal_tx_queue_subtype tqi_subtype; 
    329         enum hal_tx_queue_flags tqi_qflags; 
    330         u_int32_t tqi_priority; 
    331         u_int32_t tqi_aifs; 
    332         u_int32_t tqi_cwmin; 
    333         u_int32_t tqi_cwmax; 
    334         u_int16_t tqi_shretry; 
    335         u_int16_t tqi_lgretry; 
    336         u_int32_t tqi_cbrPeriod; 
    337         u_int32_t tqi_cbrOverflowLimit; 
    338         u_int32_t tqi_burstTime; 
    339         u_int32_t tqi_readyTime; 
    340         u_int32_t tqi_physCompBuf; 
    341         u_int32_t tqi_intFlags; 
    342 }; 
    343  
    344 enum hal_rx_filter { 
    345         HAL_RX_FILTER_UCAST = 0x00000001, 
    346         HAL_RX_FILTER_MCAST = 0x00000002, 
    347         HAL_RX_FILTER_BCAST = 0x00000004, 
    348         HAL_RX_FILTER_CONTROL = 0x00000008, 
    349         HAL_RX_FILTER_BEACON = 0x00000010, 
    350         HAL_RX_FILTER_PROM = 0x00000020, 
    351         HAL_RX_FILTER_PROBEREQ = 0x00000080, 
    352         HAL_RX_FILTER_PSPOLL = 0x00004000, 
    353         HAL_RX_FILTER_PHYERR = 0x00000100, 
    354         HAL_RX_FILTER_PHYRADAR = 0x00002000, 
    355 }; 
    356  
    357 enum hal_int { 
    358         HAL_INT_RX = 0x00000001, 
    359         HAL_INT_RXDESC = 0x00000002, 
    360         HAL_INT_RXNOFRM = 0x00000008, 
    361         HAL_INT_RXEOL = 0x00000010, 
    362         HAL_INT_RXORN = 0x00000020, 
    363         HAL_INT_TX = 0x00000040, 
    364         HAL_INT_TXDESC = 0x00000080, 
    365         HAL_INT_TIM_TIMER = 0x00000100, 
    366         HAL_INT_TXURN = 0x00000800, 
    367         HAL_INT_MIB = 0x00001000, 
    368         HAL_INT_RXPHY = 0x00004000, 
    369         HAL_INT_RXKCM = 0x00008000, 
    370         HAL_INT_SWBA = 0x00010000, 
    371         HAL_INT_BMISS = 0x00040000, 
    372         HAL_INT_BNR = 0x00100000, 
    373         HAL_INT_TIM = 0x00200000, 
    374         HAL_INT_DTIM = 0x00400000, 
    375         HAL_INT_DTIMSYNC = 0x00800000, 
    376         HAL_INT_GPIO = 0x01000000, 
    377         HAL_INT_CABEND = 0x02000000, 
    378         HAL_INT_CST = 0x10000000, 
    379         HAL_INT_GTT = 0x20000000, 
    380         HAL_INT_FATAL = 0x40000000, 
    381         HAL_INT_GLOBAL = 0x80000000, 
    382         HAL_INT_BMISC = HAL_INT_TIM 
    383             | HAL_INT_DTIM | HAL_INT_DTIMSYNC | HAL_INT_CABEND, 
    384         HAL_INT_COMMON = HAL_INT_RXNOFRM 
    385             | HAL_INT_RXDESC 
    386             | HAL_INT_RXEOL 
    387             | HAL_INT_RXORN 
    388             | HAL_INT_TXURN 
    389             | HAL_INT_TXDESC 
    390             | HAL_INT_MIB 
    391             | HAL_INT_RXPHY 
    392             | HAL_INT_RXKCM | HAL_INT_SWBA | HAL_INT_BMISS | HAL_INT_GPIO, 
    393         HAL_INT_NOCARD = 0xffffffff 
    394 }; 
    395  
    396 struct hal_rate_table { 
     287struct ath9k_txq_info { 
     288        u32 tqi_ver; 
     289        enum ath9k_tx_queue_subtype tqi_subtype; 
     290        enum ath9k_tx_queue_flags tqi_qflags; 
     291        u32 tqi_priority; 
     292        u32 tqi_aifs; 
     293        u32 tqi_cwmin; 
     294        u32 tqi_cwmax; 
     295        u16 tqi_shretry; 
     296        u16 tqi_lgretry; 
     297        u32 tqi_cbrPeriod; 
     298        u32 tqi_cbrOverflowLimit; 
     299        u32 tqi_burstTime; 
     300        u32 tqi_readyTime; 
     301        u32 tqi_compBuf; 
     302}; 
     303 
     304#define ATH9K_TXQ_USEDEFAULT ((u32) -1) 
     305 
     306#define ATH9K_DECOMP_MASK_SIZE     128 
     307#define ATH9K_READY_TIME_LO_BOUND  50 
     308#define ATH9K_READY_TIME_HI_BOUND  96 
     309 
     310enum ath9k_pkt_type { 
     311        ATH9K_PKT_TYPE_NORMAL = 0, 
     312        ATH9K_PKT_TYPE_ATIM, 
     313        ATH9K_PKT_TYPE_PSPOLL, 
     314        ATH9K_PKT_TYPE_BEACON, 
     315        ATH9K_PKT_TYPE_PROBE_RESP, 
     316        ATH9K_PKT_TYPE_CHIRP, 
     317        ATH9K_PKT_TYPE_GRP_POLL, 
     318}; 
     319 
     320struct ath9k_tx_queue_info { 
     321        u32 tqi_ver; 
     322        enum ath9k_tx_queue tqi_type; 
     323        enum ath9k_tx_queue_subtype tqi_subtype; 
     324        enum ath9k_tx_queue_flags tqi_qflags; 
     325        u32 tqi_priority; 
     326        u32 tqi_aifs; 
     327        u32 tqi_cwmin; 
     328        u32 tqi_cwmax; 
     329        u16 tqi_shretry; 
     330        u16 tqi_lgretry; 
     331        u32 tqi_cbrPeriod; 
     332        u32 tqi_cbrOverflowLimit; 
     333        u32 tqi_burstTime; 
     334        u32 tqi_readyTime; 
     335        u32 tqi_physCompBuf; 
     336        u32 tqi_intFlags; 
     337}; 
     338 
     339enum ath9k_rx_filter { 
     340        ATH9K_RX_FILTER_UCAST = 0x00000001, 
     341        ATH9K_RX_FILTER_MCAST = 0x00000002, 
     342        ATH9K_RX_FILTER_BCAST = 0x00000004, 
     343        ATH9K_RX_FILTER_CONTROL = 0x00000008, 
     344        ATH9K_RX_FILTER_BEACON = 0x00000010, 
     345        ATH9K_RX_FILTER_PROM = 0x00000020, 
     346        ATH9K_RX_FILTER_PROBEREQ = 0x00000080, 
     347        ATH9K_RX_FILTER_PSPOLL = 0x00004000, 
     348        ATH9K_RX_FILTER_PHYERR = 0x00000100, 
     349        ATH9K_RX_FILTER_PHYRADAR = 0x00002000, 
     350}; 
     351 
     352enum ath9k_int { 
     353        ATH9K_INT_RX = 0x00000001, 
     354        ATH9K_INT_RXDESC = 0x00000002, 
     355        ATH9K_INT_RXNOFRM = 0x00000008, 
     356        ATH9K_INT_RXEOL = 0x00000010, 
     357        ATH9K_INT_RXORN = 0x00000020, 
     358        ATH9K_INT_TX = 0x00000040, 
     359        ATH9K_INT_TXDESC = 0x00000080, 
     360        ATH9K_INT_TIM_TIMER = 0x00000100, 
     361        ATH9K_INT_TXURN = 0x00000800, 
     362        ATH9K_INT_MIB = 0x00001000, 
     363        ATH9K_INT_RXPHY = 0x00004000, 
     364        ATH9K_INT_RXKCM = 0x00008000, 
     365        ATH9K_INT_SWBA = 0x00010000, 
     366        ATH9K_INT_BMISS = 0x00040000, 
     367        ATH9K_INT_BNR = 0x00100000, 
     368        ATH9K_INT_TIM = 0x00200000, 
     369        ATH9K_INT_DTIM = 0x00400000, 
     370        ATH9K_INT_DTIMSYNC = 0x00800000, 
     371        ATH9K_INT_GPIO = 0x01000000, 
     372        ATH9K_INT_CABEND = 0x02000000, 
     373        ATH9K_INT_CST = 0x10000000, 
     374        ATH9K_INT_GTT = 0x20000000, 
     375        ATH9K_INT_FATAL = 0x40000000, 
     376        ATH9K_INT_GLOBAL = 0x80000000, 
     377        ATH9K_INT_BMISC = ATH9K_INT_TIM | 
     378                ATH9K_INT_DTIM | 
     379                ATH9K_INT_DTIMSYNC | 
     380                ATH9K_INT_CABEND, 
     381        ATH9K_INT_COMMON = ATH9K_INT_RXNOFRM | 
     382                ATH9K_INT_RXDESC | 
     383                ATH9K_INT_RXEOL | 
     384                ATH9K_INT_RXORN | 
     385                ATH9K_INT_TXURN | 
     386                ATH9K_INT_TXDESC | 
     387                ATH9K_INT_MIB | 
     388                ATH9K_INT_RXPHY | 
     389                ATH9K_INT_RXKCM | 
     390                ATH9K_INT_SWBA | 
     391                ATH9K_INT_BMISS | 
     392                ATH9K_INT_GPIO, 
     393        ATH9K_INT_NOCARD = 0xffffffff 
     394}; 
     395 
     396struct ath9k_rate_table { 
    397397        int rateCount; 
    398         u_int8_t rateCodeToIndex[256]; 
     398        u8 rateCodeToIndex[256]; 
    399399        struct { 
    400                 u_int8_t valid; 
    401                 u_int8_t phy; 
    402                 u_int32_t rateKbps; 
    403                 u_int8_t rateCode; 
    404                 u_int8_t shortPreamble; 
    405                 u_int8_t dot11Rate; 
    406                 u_int8_t controlRate; 
    407                 u_int16_t lpAckDuration; 
    408                 u_int16_t spAckDuration; 
     400                u8 valid; 
     401                u8 phy; 
     402                u32 rateKbps; 
     403                u8 rateCode; 
     404                u8 shortPreamble; 
     405                u8 dot11Rate; 
     406                u8 controlRate; 
     407                u16 lpAckDuration; 
     408                u16 spAckDuration; 
    409409        } info[32]; 
    410410}; 
    411411 
    412 #define HAL_RATESERIES_RTS_CTS  0x0001 
    413 #define HAL_RATESERIES_2040     0x0002 
    414 #define HAL_RATESERIES_HALFGI   0x0004 
    415  
    416 struct hal_11n_rate_series { 
    417         u_int Tries; 
    418         u_int Rate; 
    419         u_int PktDuration; 
    420         u_int ChSel; 
    421         u_int RateFlags; 
    422 }; 
    423  
    424 struct hal_channel { 
    425         u_int16_t channel; 
    426         u_int32_t channelFlags; 
    427         u_int8_t privFlags; 
    428         int8_t maxRegTxPower; 
    429         int8_t maxTxPower; 
    430         int8_t minTxPower; 
     412#define ATH9K_RATESERIES_RTS_CTS  0x0001 
     413#define ATH9K_RATESERIES_2040     0x0002 
     414#define ATH9K_RATESERIES_HALFGI   0x0004 
     415 
     416struct ath9k_11n_rate_series { 
     417        u32 Tries; 
     418        u32 Rate; 
     419        u32 PktDuration; 
     420        u32 ChSel; 
     421        u32 RateFlags; 
    431422}; 
    432423 
     
    453444#define CHANNEL_A           (CHANNEL_5GHZ|CHANNEL_OFDM) 
    454445#define CHANNEL_B           (CHANNEL_2GHZ|CHANNEL_CCK) 
    455 #define CHANNEL_PUREG       (CHANNEL_2GHZ|CHANNEL_OFDM) 
    456446#define CHANNEL_G           (CHANNEL_2GHZ|CHANNEL_OFDM) 
    457447#define CHANNEL_G_HT20      (CHANNEL_2GHZ|CHANNEL_HT20) 
     
    470460         CHANNEL_HT40MINUS) 
    471461 
    472 struct hal_channel_internal { 
    473         u_int16_t channel; 
    474         u_int32_t channelFlags; 
    475         u_int8_t privFlags; 
     462struct ath9k_channel { 
     463        u16 channel; 
     464        u32 channelFlags; 
     465        u8 privFlags; 
    476466        int8_t maxRegTxPower; 
    477467        int8_t maxTxPower; 
    478468        int8_t minTxPower; 
    479         bool bssSendHere; 
    480         u_int8_t gainI; 
    481         bool iqCalValid; 
     469        u32 chanmode; 
    482470        int32_t CalValid; 
    483471        bool oneTimeCalsDone; 
     
    485473        int8_t qCoff; 
    486474        int16_t rawNoiseFloor; 
    487         int16_t noiseFloorAdjust; 
    488475        int8_t antennaMax; 
    489         u_int32_t regDmnFlags; 
    490         u_int32_t conformanceTestLimit; 
    491         u_int64_t ah_tsf_last; 
    492         u_int64_t ah_channel_time; 
    493         u_int16_t mainSpur; 
    494         u_int64_t dfsTsf; 
     476        u32 regDmnFlags; 
     477        u32 conformanceTestLimit[3]; /* 0:11a, 1: 11b, 2:11g */ 
    495478#ifdef ATH_NF_PER_CHAN 
    496         struct hal_nfcal_hist nfCalHist[NUM_NF_READINGS]; 
     479        struct ath9k_nfcal_hist nfCalHist[NUM_NF_READINGS]; 
    497480#endif 
    498481}; 
    499  
    500 #define HAL_SPUR_VAL_MASK       0x3FFF 
    501 #define HAL_SPUR_CHAN_WIDTH     87 
    502 #define HAL_BIN_WIDTH_BASE_100HZ    3125 
    503 #define HAL_MAX_BINS_ALLOWED        28 
    504482 
    505483#define IS_CHAN_A(_c) ((((_c)->channelFlags & CHANNEL_A) == CHANNEL_A) || \ 
     
    512490       (((_c)->channelFlags & CHANNEL_G_HT40PLUS) == CHANNEL_G_HT40PLUS) || \ 
    513491       (((_c)->channelFlags & CHANNEL_G_HT40MINUS) == CHANNEL_G_HT40MINUS)) 
    514 #define IS_CHAN_PUREG(_c) \ 
    515         (((_c)->channelFlags & CHANNEL_PUREG) == CHANNEL_PUREG) 
    516492#define IS_CHAN_CCK(_c) (((_c)->channelFlags & CHANNEL_CCK) != 0) 
    517493#define IS_CHAN_OFDM(_c) (((_c)->channelFlags & CHANNEL_OFDM) != 0) 
     
    521497#define IS_CHAN_HALF_RATE(_c) (((_c)->channelFlags & CHANNEL_HALF) != 0) 
    522498#define IS_CHAN_QUARTER_RATE(_c) (((_c)->channelFlags & CHANNEL_QUARTER) != 0) 
    523 #define IS_CHAN_HT20(_c) (((_c)->channelFlags & CHANNEL_HT20) != 0) 
    524 #define IS_CHAN_HT40(_c) ((((_c)->channelFlags & CHANNEL_HT40PLUS) != 0) \ 
    525                           || (((_c)->channelFlags & CHANNEL_HT40MINUS) != 0)) 
     499 
     500/* These macros check chanmode and not channelFlags */ 
     501#define IS_CHAN_HT20(_c) (((_c)->chanmode == CHANNEL_A_HT20) || \ 
     502                          ((_c)->chanmode == CHANNEL_G_HT20)) 
     503#define IS_CHAN_HT40(_c) (((_c)->chanmode == CHANNEL_A_HT40PLUS) ||     \ 
     504                          ((_c)->chanmode == CHANNEL_A_HT40MINUS) ||    \ 
     505                          ((_c)->chanmode == CHANNEL_G_HT40PLUS) ||     \ 
     506                          ((_c)->chanmode == CHANNEL_G_HT40MINUS)) 
    526507#define IS_CHAN_HT(_c) (IS_CHAN_HT20((_c)) || IS_CHAN_HT40((_c))) 
     508 
    527509#define IS_CHAN_IN_PUBLIC_SAFETY_BAND(_c) ((_c) > 4940 && (_c) < 4990) 
    528 #define IS_CHAN_A_5MHZ_SPACED(_c) \ 
    529         ((((_c)->channelFlags & CHANNEL_5GHZ) != 0) && \ 
    530         (((_c)->channel % 20) != 0) &&  \ 
    531         (((_c)->channel % 10) != 0)) 
    532  
    533 struct hal_keyval { 
    534         u_int8_t kv_type; 
    535         u_int8_t kv_pad; 
    536         u_int16_t kv_len; 
    537         u_int8_t kv_val[16]; 
    538         u_int8_t kv_mic[8]; 
    539         u_int8_t kv_txmic[8]; 
    540 }; 
    541  
    542 enum hal_key_type { 
    543         HAL_KEY_TYPE_CLEAR, 
    544         HAL_KEY_TYPE_WEP, 
    545         HAL_KEY_TYPE_AES, 
    546         HAL_KEY_TYPE_TKIP, 
    547 }; 
    548  
    549 enum hal_cipher { 
    550         HAL_CIPHER_WEP = 0, 
    551         HAL_CIPHER_AES_OCB = 1, 
    552         HAL_CIPHER_AES_CCM = 2, 
    553         HAL_CIPHER_CKIP = 3, 
    554         HAL_CIPHER_TKIP = 4, 
    555         HAL_CIPHER_CLR = 5, 
    556         HAL_CIPHER_MIC = 127 
     510#define IS_CHAN_A_5MHZ_SPACED(_c)                       \ 
     511        ((((_c)->channelFlags & CHANNEL_5GHZ) != 0) &&  \ 
     512         (((_c)->channel % 20) != 0) &&                 \ 
     513         (((_c)->channel % 10) != 0)) 
     514 
     515struct ath9k_keyval { 
     516        u8 kv_type; 
     517        u8 kv_pad; 
     518        u16 kv_len; 
     519        u8 kv_val[16]; 
     520        u8 kv_mic[8]; 
     521        u8 kv_txmic[8]; 
     522}; 
     523 
     524enum ath9k_key_type { 
     525        ATH9K_KEY_TYPE_CLEAR, 
     526        ATH9K_KEY_TYPE_WEP, 
     527        ATH9K_KEY_TYPE_AES, 
     528        ATH9K_KEY_TYPE_TKIP, 
     529}; 
     530 
     531enum ath9k_cipher { 
     532        ATH9K_CIPHER_WEP = 0, 
     533        ATH9K_CIPHER_AES_OCB = 1, 
     534        ATH9K_CIPHER_AES_CCM = 2, 
     535        ATH9K_CIPHER_CKIP = 3, 
     536        ATH9K_CIPHER_TKIP = 4, 
     537        ATH9K_CIPHER_CLR = 5, 
     538        ATH9K_CIPHER_MIC = 127 
    557539}; 
    558540 
     
    597579#define AR_EEPROM_RFSILENT_POLARITY_S   1 
    598580 
    599 enum { 
    600         CTRY_DEBUG = 0x1ff, 
    601         CTRY_DEFAULT = 0 
    602 }; 
     581#define CTRY_DEBUG 0x1ff 
     582#define CTRY_DEFAULT 0 
    603583 
    604584enum reg_ext_bitmap { 
     
    609589}; 
    610590 
    611 struct hal_country_entry { 
    612         u_int16_t countryCode; 
    613         u_int16_t regDmnEnum; 
    614         u_int16_t regDmn5G; 
    615         u_int16_t regDmn2G; 
    616         u_int8_t isMultidomain; 
    617         u_int8_t iso[3]; 
     591struct ath9k_country_entry { 
     592        u16 countryCode; 
     593        u16 regDmnEnum; 
     594        u16 regDmn5G; 
     595        u16 regDmn2G; 
     596        u8 isMultidomain; 
     597        u8 iso[3]; 
    618598}; 
    619599 
     
    633613        REG_WRITE(_a, _r, REG_READ(_a, _r) & ~_f) 
    634614 
    635 #define HAL_COMP_BUF_MAX_SIZE   9216 
    636 #define HAL_COMP_BUF_ALIGN_SIZE 512 
    637  
    638 #define HAL_TXQ_USE_LOCKOUT_BKOFF_DIS   0x00000001 
     615#define ATH9K_COMP_BUF_MAX_SIZE   9216 
     616#define ATH9K_COMP_BUF_ALIGN_SIZE 512 
     617 
     618#define ATH9K_TXQ_USE_LOCKOUT_BKOFF_DIS   0x00000001 
    639619 
    640620#define INIT_AIFS       2 
     
    668648 
    669649#define LE_READ_2(p)                                                    \ 
    670         ((u_int16_t)                                                    \ 
    671          ((((const u_int8_t *)(p))[0]) | \ 
    672                 (((const u_int8_t *)(p))[1] << 8))) 
     650        ((u16)                                                  \ 
     651         ((((const u8 *)(p))[0]) | \ 
     652                (((const u8 *)(p))[1] << 8))) 
    673653 
    674654#define LE_READ_4(p)                                                    \ 
    675         ((u_int32_t)                                                    \ 
    676          ((((const u_int8_t *)(p))[0]) | \ 
    677                 (((const u_int8_t *)(p))[1] << 8) | \ 
    678                 (((const u_int8_t *)(p))[2] << 16) | \ 
    679                         (((const u_int8_t *)(p))[3] << 24))) 
    680  
    681 enum hal_status { 
    682         HAL_OK = 0, 
    683         HAL_ENXIO, 
    684         HAL_ENOMEM, 
    685         HAL_EIO, 
    686         HAL_EEMAGIC, 
    687         HAL_EEVERSION, 
    688         HAL_EELOCKED, 
    689         HAL_EEBADSUM, 
    690         HAL_EEREAD, 
    691         HAL_EEBADMAC, 
    692         HAL_EESIZE, 
    693         HAL_EEWRITE, 
    694         HAL_EINVAL, 
    695         HAL_ENOTSUPP, 
    696         HAL_ESELFTEST, 
    697         HAL_EINPROGRESS 
    698 }; 
    699  
    700 enum hal_power_mode { 
    701         HAL_PM_AWAKE = 0, 
    702         HAL_PM_FULL_SLEEP, 
    703         HAL_PM_NETWORK_SLEEP, 
    704         HAL_PM_UNDEFINED 
    705 }; 
    706  
    707 enum hal_rfgain { 
    708         HAL_RFGAIN_INACTIVE = 0, 
    709         HAL_RFGAIN_READ_REQUESTED, 
    710         HAL_RFGAIN_NEED_CHANGE 
     655        ((u32)                                                  \ 
     656         ((((const u8 *)(p))[0]) | \ 
     657                (((const u8 *)(p))[1] << 8) | \ 
     658                (((const u8 *)(p))[2] << 16) | \ 
     659                        (((const u8 *)(p))[3] << 24))) 
     660 
     661enum ath9k_power_mode { 
     662        ATH9K_PM_AWAKE = 0, 
     663        ATH9K_PM_FULL_SLEEP, 
     664        ATH9K_PM_NETWORK_SLEEP, 
     665        ATH9K_PM_UNDEFINED 
    711666}; 
    712667 
     
    716671#define HAL_ANTENNA_MAX_MODE  3 
    717672 
    718 struct hal_mib_stats { 
    719         u_int32_t ackrcv_bad; 
    720         u_int32_t rts_bad; 
    721         u_int32_t rts_good; 
    722         u_int32_t fcs_bad; 
    723         u_int32_t beacons; 
    724 }; 
    725  
    726 enum hal_ant_setting { 
    727         HAL_ANT_VARIABLE = 0, 
    728         HAL_ANT_FIXED_A, 
    729         HAL_ANT_FIXED_B 
    730 }; 
    731  
    732 enum hal_opmode { 
    733         HAL_M_STA = 1, 
    734         HAL_M_IBSS = 0, 
    735         HAL_M_HOSTAP = 6, 
    736         HAL_M_MONITOR = 8 
    737 }; 
    738  
    739 enum { 
    740         HAL_SLOT_TIME_6 = 6, 
    741         HAL_SLOT_TIME_9 = 9, 
    742         HAL_SLOT_TIME_20 = 20, 
    743 }; 
    744  
    745  
    746 enum hal_ht_macmode { 
    747         HAL_HT_MACMODE_20 = 0, 
    748         HAL_HT_MACMODE_2040 = 1, 
    749 }; 
    750  
    751 enum hal_ht_extprotspacing { 
    752         HAL_HT_EXTPROTSPACING_20 = 0, 
    753         HAL_HT_EXTPROTSPACING_25 = 1, 
    754 }; 
    755  
    756 struct hal_ht_cwm { 
    757         enum hal_ht_macmode ht_macmode; 
    758         enum hal_ht_extprotspacing ht_extprotspacing; 
     673struct ath9k_mib_stats { 
     674        u32 ackrcv_bad; 
     675        u32 rts_bad; 
     676        u32 rts_good; 
     677        u32 fcs_bad; 
     678        u32 beacons; 
     679}; 
     680 
     681enum ath9k_ant_setting { 
     682        ATH9K_ANT_VARIABLE = 0, 
     683        ATH9K_ANT_FIXED_A, 
     684        ATH9K_ANT_FIXED_B 
     685}; 
     686 
     687enum ath9k_opmode { 
     688        ATH9K_M_STA = 1, 
     689        ATH9K_M_IBSS = 0, 
     690        ATH9K_M_HOSTAP = 6, 
     691        ATH9K_M_MONITOR = 8 
     692}; 
     693 
     694#define ATH9K_SLOT_TIME_6 6 
     695#define ATH9K_SLOT_TIME_9 9 
     696#define ATH9K_SLOT_TIME_20 20 
     697 
     698enum ath9k_ht_macmode { 
     699        ATH9K_HT_MACMODE_20 = 0, 
     700        ATH9K_HT_MACMODE_2040 = 1, 
     701}; 
     702 
     703enum ath9k_ht_extprotspacing { 
     704        ATH9K_HT_EXTPROTSPACING_20 = 0, 
     705        ATH9K_HT_EXTPROTSPACING_25 = 1, 
     706}; 
     707 
     708struct ath9k_ht_cwm { 
     709        enum ath9k_ht_macmode ht_macmode; 
     710        enum ath9k_ht_extprotspacing ht_extprotspacing; 
    759711}; 
    760712 
     
    764716}; 
    765717 
    766 enum { 
    767         HAL_TRUE_CHIP = 1 
    768 }; 
    769  
    770 enum hal_bus_type { 
    771         HAL_BUS_TYPE_PCI, 
    772         HAL_BUS_TYPE_AHB 
    773 }; 
    774  
    775 enum hal_ani_cmd { 
    776         HAL_ANI_PRESENT = 0x1, 
    777         HAL_ANI_NOISE_IMMUNITY_LEVEL = 0x2, 
    778         HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION = 0x4, 
    779         HAL_ANI_CCK_WEAK_SIGNAL_THR = 0x8, 
    780         HAL_ANI_FIRSTEP_LEVEL = 0x10, 
    781         HAL_ANI_SPUR_IMMUNITY_LEVEL = 0x20, 
    782         HAL_ANI_MODE = 0x40, 
    783         HAL_ANI_PHYERR_RESET = 0x80, 
    784         HAL_ANI_ALL = 0xff 
     718enum ath9k_ani_cmd { 
     719        ATH9K_ANI_PRESENT = 0x1, 
     720        ATH9K_ANI_NOISE_IMMUNITY_LEVEL = 0x2, 
     721        ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION = 0x4, 
     722        ATH9K_ANI_CCK_WEAK_SIGNAL_THR = 0x8, 
     723        ATH9K_ANI_FIRSTEP_LEVEL = 0x10, 
     724        ATH9K_ANI_SPUR_IMMUNITY_LEVEL = 0x20, 
     725        ATH9K_ANI_MODE = 0x40, 
     726        ATH9K_ANI_PHYERR_RESET = 0x80, 
     727        ATH9K_ANI_ALL = 0xff 
    785728}; 
    786729 
     
    801744}; 
    802745 
    803 enum hal_tp_scale { 
    804         HAL_TP_SCALE_MAX = 0, 
    805         HAL_TP_SCALE_50, 
    806         HAL_TP_SCALE_25, 
    807         HAL_TP_SCALE_12, 
    808         HAL_TP_SCALE_MIN 
     746enum ath9k_tp_scale { 
     747        ATH9K_TP_SCALE_MAX = 0, 
     748        ATH9K_TP_SCALE_50, 
     749        ATH9K_TP_SCALE_25, 
     750        ATH9K_TP_SCALE_12, 
     751        ATH9K_TP_SCALE_MIN 
    809752}; 
    810753 
     
    821764#define AR_PHY_CCA_FILTERWINDOW_LENGTH          5 
    822765 
    823 #define HAL_NF_CAL_HIST_MAX             5 
     766#define ATH9K_NF_CAL_HIST_MAX           5 
    824767#define NUM_NF_READINGS                 6 
    825768 
    826 struct hal_nfcal_hist { 
    827         int16_t nfCalBuffer[HAL_NF_CAL_HIST_MAX]; 
    828         u_int8_t currIndex; 
     769struct ath9k_nfcal_hist { 
     770        int16_t nfCalBuffer[ATH9K_NF_CAL_HIST_MAX]; 
     771        u8 currIndex; 
    829772        int16_t privNF; 
    830         u_int8_t invalidNFcount; 
    831 }; 
    832  
    833 struct hal_beacon_state { 
    834         u_int32_t bs_nexttbtt; 
    835         u_int32_t bs_nextdtim; 
    836         u_int32_t bs_intval; 
    837 #define HAL_BEACON_PERIOD       0x0000ffff 
    838 #define HAL_BEACON_ENA          0x00800000 
    839 #define HAL_BEACON_RESET_TSF    0x01000000 
    840         u_int32_t bs_dtimperiod; 
    841         u_int16_t bs_cfpperiod; 
    842         u_int16_t bs_cfpmaxduration; 
    843         u_int32_t bs_cfpnext; 
    844         u_int16_t bs_timoffset; 
    845         u_int16_t bs_bmissthreshold; 
    846         u_int32_t bs_sleepduration; 
    847 }; 
    848  
    849 struct hal_node_stats { 
    850         u_int32_t ns_avgbrssi; 
    851         u_int32_t ns_avgrssi; 
    852         u_int32_t ns_avgtxrssi; 
    853         u_int32_t ns_avgtxrate; 
    854 }; 
    855  
    856 #define HAL_RSSI_EP_MULTIPLIER  (1<<7) 
    857 #define HAL_RATE_EP_MULTIPLIER  (1<<7) 
    858  
    859 enum hal_gpio_output_mux_type { 
    860         HAL_GPIO_OUTPUT_MUX_AS_OUTPUT, 
    861         HAL_GPIO_OUTPUT_MUX_AS_PCIE_ATTENTION_LED, 
    862         HAL_GPIO_OUTPUT_MUX_AS_PCIE_POWER_LED, 
    863         HAL_GPIO_OUTPUT_MUX_AS_MAC_NETWORK_LED, 
    864         HAL_GPIO_OUTPUT_MUX_AS_MAC_POWER_LED, 
    865         HAL_GPIO_OUTPUT_MUX_NUM_ENTRIES 
     773        u8 invalidNFcount; 
     774}; 
     775 
     776struct ath9k_beacon_state { 
     777        u32 bs_nexttbtt; 
     778        u32 bs_nextdtim; 
     779        u32 bs_intval; 
     780#define ATH9K_BEACON_PERIOD       0x0000ffff 
     781#define ATH9K_BEACON_ENA          0x00800000 
     782#define ATH9K_BEACON_RESET_TSF    0x01000000 
     783        u32 bs_dtimperiod; 
     784        u16 bs_cfpperiod; 
     785        u16 bs_cfpmaxduration; 
     786        u32 bs_cfpnext; 
     787        u16 bs_timoffset; 
     788        u16 bs_bmissthreshold; 
     789        u32 bs_sleepduration; 
     790}; 
     791 
     792struct ath9k_node_stats { 
     793        u32 ns_avgbrssi; 
     794        u32 ns_avgrssi; 
     795        u32 ns_avgtxrssi; 
     796        u32 ns_avgtxrate; 
     797}; 
     798 
     799#define ATH9K_RSSI_EP_MULTIPLIER  (1<<7) 
     800 
     801enum ath9k_gpio_output_mux_type { 
     802        ATH9K_GPIO_OUTPUT_MUX_AS_OUTPUT, 
     803        ATH9K_GPIO_OUTPUT_MUX_AS_PCIE_ATTENTION_LED, 
     804        ATH9K_GPIO_OUTPUT_MUX_AS_PCIE_POWER_LED, 
     805        ATH9K_GPIO_OUTPUT_MUX_AS_MAC_NETWORK_LED, 
     806        ATH9K_GPIO_OUTPUT_MUX_AS_MAC_POWER_LED, 
     807        ATH9K_GPIO_OUTPUT_MUX_NUM_ENTRIES 
    866808}; 
    867809 
    868810enum { 
    869         HAL_RESET_POWER_ON, 
    870         HAL_RESET_WARM, 
    871         HAL_RESET_COLD, 
     811        ATH9K_RESET_POWER_ON, 
     812        ATH9K_RESET_WARM, 
     813        ATH9K_RESET_COLD, 
    872814}; 
    873815 
    874816#define AH_USE_EEPROM   0x1 
    875 #define AH_IS_HB63      0x2 
    876817 
    877818struct ath_hal { 
    878         u_int32_t ah_magic; 
    879         u_int16_t ah_devid; 
    880         u_int16_t ah_subvendorid; 
     819        u32 ah_magic; 
     820        u16 ah_devid; 
     821        u16 ah_subvendorid; 
    881822        struct ath_softc *ah_sc; 
    882823        void __iomem *ah_sh; 
    883         u_int16_t ah_countryCode; 
    884         u_int32_t ah_macVersion; 
    885         u_int16_t ah_macRev; 
    886         u_int16_t ah_phyRev; 
    887         u_int16_t ah_analog5GhzRev; 
    888         u_int16_t ah_analog2GhzRev; 
    889         u_int8_t ah_decompMask[HAL_DECOMP_MASK_SIZE]; 
    890         u_int32_t ah_flags; 
    891         enum hal_opmode ah_opmode; 
     824        u16 ah_countryCode; 
     825        u32 ah_macVersion; 
     826        u16 ah_macRev; 
     827        u16 ah_phyRev; 
     828        u16 ah_analog5GhzRev; 
     829        u16 ah_analog2GhzRev; 
     830        u8 ah_decompMask[ATH9K_DECOMP_MASK_SIZE]; 
     831        u32 ah_flags; 
     832        enum ath9k_opmode ah_opmode; 
    892833        struct hal_ops_config ah_config; 
    893834        struct hal_capabilities ah_caps; 
    894835        int16_t ah_powerLimit; 
    895         u_int16_t ah_maxPowerLevel; 
    896         u_int ah_tpScale; 
    897         u_int16_t ah_currentRD; 
    898         u_int16_t ah_currentRDExt; 
    899         u_int16_t ah_currentRDInUse; 
    900         u_int16_t ah_currentRD5G; 
    901         u_int16_t ah_currentRD2G; 
     836        u16 ah_maxPowerLevel; 
     837        u32 ah_tpScale; 
     838        u16 ah_currentRD; 
     839        u16 ah_currentRDExt; 
     840        u16 ah_currentRDInUse; 
     841        u16 ah_currentRD5G; 
     842        u16 ah_currentRD2G; 
    902843        char ah_iso[4]; 
    903844        enum start_adhoc_option ah_adHocMode; 
    904845        bool ah_commonMode; 
    905         struct hal_channel_internal ah_channels[150]; 
    906         u_int ah_nchan; 
    907         struct hal_channel_internal *ah_curchan; 
    908         u_int16_t ah_rfsilent; 
     846        struct ath9k_channel ah_channels[150]; 
     847        u32 ah_nchan; 
     848        struct ath9k_channel *ah_curchan; 
     849        u16 ah_rfsilent; 
    909850        bool ah_rfkillEnabled; 
    910851        bool ah_isPciExpress; 
    911         u_int16_t ah_txTrigLevel; 
     852        u16 ah_txTrigLevel; 
    912853#ifndef ATH_NF_PER_CHAN 
    913         struct hal_nfcal_hist nfCalHist[NUM_NF_READINGS]; 
     854        struct ath9k_nfcal_hist nfCalHist[NUM_NF_READINGS]; 
    914855#endif 
    915856}; 
     
    947888 
    948889struct chan_centers { 
    949         u_int16_t synth_center; 
    950         u_int16_t ctl_center; 
    951         u_int16_t ext_center; 
    952 }; 
    953  
    954 enum hal_status ath_hal_getcapability(struct ath_hal *ah, 
    955                                       enum hal_capability_type type, 
    956                                       u_int32_t capability, 
    957                                       u_int32_t *result); 
    958 const struct hal_rate_table *ath9k_hw_getratetable(struct ath_hal *ah, 
    959                                                    u_int mode); 
     890        u16 synth_center; 
     891        u16 ctl_center; 
     892        u16 ext_center; 
     893}; 
     894 
     895int ath_hal_getcapability(struct ath_hal *ah, 
     896                          enum hal_capability_type type, 
     897                          u32 capability, 
     898                          u32 *result); 
     899const struct ath9k_rate_table *ath9k_hw_getratetable(struct ath_hal *ah, 
     900                                                     u32 mode); 
    960901void ath9k_hw_detach(struct ath_hal *ah); 
    961 struct ath_hal *ath9k_hw_attach(u_int16_t devid, 
     902struct ath_hal *ath9k_hw_attach(u16 devid, 
    962903                                struct ath_softc *sc, 
    963904                                void __iomem *mem, 
    964                                 enum hal_status *error); 
     905                                int *error); 
    965906bool 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, 
     907                              u32 maxchans, u32 *nchans, 
     908                              u8 *regclassids, 
     909                              u32 maxregids, u32 *nregids, 
     910                              u16 cc, u32 modeSelect, 
    971911                              bool enableOutdoor, 
    972912                              bool enableExtendedChannels); 
    973 u_int ath9k_hw_mhz2ieee(struct ath_hal *ah, u_int freq, u_int flags); 
    974 enum hal_int ath9k_hw_set_interrupts(struct ath_hal *ah, 
    975                                      enum hal_int ints); 
    976 bool 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, 
     913u32 ath9k_hw_mhz2ieee(struct ath_hal *ah, u32 freq, u32 flags); 
     914enum ath9k_int ath9k_hw_set_interrupts(struct ath_hal *ah, 
     915                                     enum ath9k_int ints); 
     916bool ath9k_hw_reset(struct ath_hal *ah, enum ath9k_opmode opmode, 
     917                    struct ath9k_channel *chan, 
     918                    enum ath9k_ht_macmode macmode, 
     919                    u8 txchainmask, u8 rxchainmask, 
     920                    enum ath9k_ht_extprotspacing extprotspacing, 
    981921                    bool bChannelChange, 
    982                     enum hal_status *status); 
     922                    int *status); 
    983923bool ath9k_hw_phy_disable(struct ath_hal *ah); 
    984 void ath9k_hw_reset_calvalid(struct ath_hal *ah, struct hal_channel *chan, 
     924void ath9k_hw_reset_calvalid(struct ath_hal *ah, struct ath9k_channel *chan, 
    985925                             bool *isCalDone); 
    986926void ath9k_hw_ani_monitor(struct ath_hal *ah, 
    987                           const struct hal_node_stats *stats, 
    988                           struct hal_channel *chan); 
     927                          const struct ath9k_node_stats *stats, 
     928                          struct ath9k_channel *chan); 
    989929bool ath9k_hw_calibrate(struct ath_hal *ah, 
    990                         struct hal_channel *chan, 
    991                         u_int8_t rxchainmask, 
     930                        struct ath9k_channel *chan, 
     931                        u8 rxchainmask, 
    992932                        bool longcal, 
    993933                        bool *isCalDone); 
    994934int16_t ath9k_hw_getchan_noise(struct ath_hal *ah, 
    995                                struct hal_channel *chan); 
    996 void ath9k_hw_write_associd(struct ath_hal *ah, const u_int8_t *bssid, 
    997                             u_int16_t assocId); 
    998 void ath9k_hw_setrxfilter(struct ath_hal *ah, u_int32_t bits); 
    999 void ath9k_hw_write_associd(struct ath_hal *ah, const u_int8_t *bssid, 
    1000                             u_int16_t assocId); 
    1001 bool ath9k_hw_stoptxdma(struct ath_hal *ah, u_int q); 
     935                               struct ath9k_channel *chan); 
     936void ath9k_hw_write_associd(struct ath_hal *ah, const u8 *bssid, 
     937                            u16 assocId); 
     938void ath9k_hw_setrxfilter(struct ath_hal *ah, u32 bits); 
     939void ath9k_hw_write_associd(struct ath_hal *ah, const u8 *bssid, 
     940                            u16 assocId); 
     941bool ath9k_hw_stoptxdma(struct ath_hal *ah, u32 q); 
    1002942void ath9k_hw_reset_tsf(struct ath_hal *ah); 
    1003 bool ath9k_hw_keyisvalid(struct ath_hal *ah, u_int16_t entry); 
    1004 bool ath9k_hw_keysetmac(struct ath_hal *ah, u_int16_t entry, 
    1005                         const u_int8_t *mac); 
     943bool ath9k_hw_keyisvalid(struct ath_hal *ah, u16 entry); 
     944bool ath9k_hw_keysetmac(struct ath_hal *ah, u16 entry, 
     945                        const u8 *mac); 
    1006946bool 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, 
     947                                 u16 entry, 
     948                                 const struct ath9k_keyval *k, 
     949                                 const u8 *mac, 
    1010950                                 int xorKey); 
    1011951bool ath9k_hw_set_tsfadjust(struct ath_hal *ah, 
    1012                             u_int32_t setting); 
     952                            u32 setting); 
    1013953void ath9k_hw_configpcipowersave(struct ath_hal *ah, int restore); 
    1014954bool ath9k_hw_intrpend(struct ath_hal *ah); 
    1015 bool ath9k_hw_getisr(struct ath_hal *ah, enum hal_int *masked); 
     955bool ath9k_hw_getisr(struct ath_hal *ah, enum ath9k_int *masked); 
    1016956bool ath9k_hw_updatetxtriglevel(struct ath_hal *ah, 
    1017957                                bool bIncTrigLevel); 
    1018958void ath9k_hw_procmibevent(struct ath_hal *ah, 
    1019                            const struct hal_node_stats *stats); 
     959                           const struct ath9k_node_stats *stats); 
    1020960bool ath9k_hw_setrxabort(struct ath_hal *ah, bool set); 
    1021 void ath9k_hw_set11nmac2040(struct ath_hal *ah, enum hal_ht_macmode mode); 
     961void ath9k_hw_set11nmac2040(struct ath_hal *ah, enum ath9k_ht_macmode mode); 
    1022962bool ath9k_hw_phycounters(struct ath_hal *ah); 
    1023 bool ath9k_hw_keyreset(struct ath_hal *ah, u_int16_t entry); 
     963bool ath9k_hw_keyreset(struct ath_hal *ah, u16 entry); 
    1024964bool ath9k_hw_getcapability(struct ath_hal *ah, 
    1025965                            enum hal_capability_type type, 
    1026                             u_int32_t capability, 
    1027                             u_int32_t *result); 
     966                            u32 capability, 
     967                            u32 *result); 
    1028968bool ath9k_hw_setcapability(struct ath_hal *ah, 
    1029969                            enum hal_capability_type type, 
    1030                             u_int32_t capability, 
    1031                             u_int32_t setting, 
    1032                             enum hal_status *status); 
    1033 u_int ath9k_hw_getdefantenna(struct ath_hal *ah); 
    1034 void ath9k_hw_getmac(struct ath_hal *ah, u_int8_t *mac); 
    1035 void ath9k_hw_getbssidmask(struct ath_hal *ah, u_int8_t *mask); 
     970                            u32 capability, 
     971                            u32 setting, 
     972                            int *status); 
     973u32 ath9k_hw_getdefantenna(struct ath_hal *ah); 
     974void ath9k_hw_getmac(struct ath_hal *ah, u8 *mac); 
     975void ath9k_hw_getbssidmask(struct ath_hal *ah, u8 *mask); 
    1036976bool ath9k_hw_setbssidmask(struct ath_hal *ah, 
    1037                            const u_int8_t *mask); 
     977                           const u8 *mask); 
    1038978bool ath9k_hw_setpower(struct ath_hal *ah, 
    1039                        enum hal_power_mode mode); 
    1040 enum hal_int ath9k_hw_intrget(struct ath_hal *ah); 
    1041 u_int64_t ath9k_hw_gettsf64(struct ath_hal *ah); 
    1042 u_int ath9k_hw_getdefantenna(struct ath_hal *ah); 
    1043 bool ath9k_hw_setslottime(struct ath_hal *ah, u_int us); 
     979                       enum ath9k_power_mode mode); 
     980enum ath9k_int ath9k_hw_intrget(struct ath_hal *ah); 
     981u64 ath9k_hw_gettsf64(struct ath_hal *ah); 
     982u32 ath9k_hw_getdefantenna(struct ath_hal *ah); 
     983bool ath9k_hw_setslottime(struct ath_hal *ah, u32 us); 
    1044984bool 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); 
    1050 void ath9k_hw_setantenna(struct ath_hal *ah, u_int antenna); 
    1051 enum hal_status ath9k_hw_select_antconfig(struct ath_hal *ah, 
    1052                                           u_int32_t cfg); 
    1053 bool ath9k_hw_puttxbuf(struct ath_hal *ah, u_int q, 
    1054                        u_int32_t txdp); 
    1055 bool ath9k_hw_txstart(struct ath_hal *ah, u_int q); 
    1056 u_int16_t ath9k_hw_computetxtime(struct ath_hal *ah, 
    1057                                  const struct hal_rate_table *rates, 
    1058                                  u_int32_t frameLen, u_int16_t rateix, 
     985                               enum ath9k_ant_setting settings, 
     986                               struct ath9k_channel *chan, 
     987                               u8 *tx_chainmask, 
     988                               u8 *rx_chainmask, 
     989                               u8 *antenna_cfgd); 
     990void ath9k_hw_setantenna(struct ath_hal *ah, u32 antenna); 
     991int ath9k_hw_select_antconfig(struct ath_hal *ah, 
     992                              u32 cfg); 
     993bool ath9k_hw_puttxbuf(struct ath_hal *ah, u32 q, 
     994                       u32 txdp); 
     995bool ath9k_hw_txstart(struct ath_hal *ah, u32 q); 
     996u16 ath9k_hw_computetxtime(struct ath_hal *ah, 
     997                                 const struct ath9k_rate_table *rates, 
     998                                 u32 frameLen, u16 rateix, 
    1059999                                 bool shortPreamble); 
    10601000void ath9k_hw_set11n_ratescenario(struct ath_hal *ah, struct ath_desc *ds, 
    10611001                                  struct ath_desc *lastds, 
    1062                                   u_int durUpdateEn, u_int rtsctsRate, 
    1063                                   u_int rtsctsDuration, 
    1064                                   struct hal_11n_rate_series series[], 
    1065                                   u_int nseries, u_int flags); 
     1002                                  u32 durUpdateEn, u32 rtsctsRate, 
     1003                                  u32 rtsctsDuration, 
     1004                                  struct ath9k_11n_rate_series series[], 
     1005                                  u32 nseries, u32 flags); 
    10661006void ath9k_hw_set11n_burstduration(struct ath_hal *ah, 
    10671007                                   struct ath_desc *ds, 
    1068                                    u_int burstDuration); 
     1008                                   u32 burstDuration); 
    10691009void ath9k_hw_cleartxdesc(struct ath_hal *ah, struct ath_desc *ds); 
    1070 u_int32_t ath9k_hw_reverse_bits(u_int32_t val, u_int32_t n); 
    1071 bool ath9k_hw_resettxqueue(struct ath_hal *ah, u_int q); 
    1072 u_int ath9k_regd_get_ctl(struct ath_hal *ah, struct hal_channel *chan); 
    1073 u_int ath9k_regd_get_antenna_allowed(struct ath_hal *ah, 
    1074                                      struct hal_channel *chan); 
    1075 u_int ath9k_hw_mhz2ieee(struct ath_hal *ah, u_int freq, u_int flags); 
     1010u32 ath9k_hw_reverse_bits(u32 val, u32 n); 
     1011bool ath9k_hw_resettxqueue(struct ath_hal *ah, u32 q); 
     1012u32 ath9k_regd_get_ctl(struct ath_hal *ah, struct ath9k_channel *chan); 
     1013u32 ath9k_regd_get_antenna_allowed(struct ath_hal *ah, 
     1014                                     struct ath9k_channel *chan); 
     1015u32 ath9k_hw_mhz2ieee(struct ath_hal *ah, u32 freq, u32 flags); 
    10761016bool ath9k_hw_gettxqueueprops(struct ath_hal *ah, int q, 
    1077                               struct hal_txq_info *qInfo); 
     1017                              struct ath9k_txq_info *qInfo); 
    10781018bool ath9k_hw_settxqueueprops(struct ath_hal *ah, int q, 
    1079                               const struct hal_txq_info *qInfo); 
    1080 struct hal_channel_internal *ath9k_regd_check_channel(struct ath_hal *ah, 
    1081                                               const struct hal_channel *c); 
     1019                              const struct ath9k_txq_info *qInfo); 
     1020struct ath9k_channel *ath9k_regd_check_channel(struct ath_hal *ah, 
     1021                                              const struct ath9k_channel *c); 
    10821022void ath9k_hw_set11n_txdesc(struct ath_hal *ah, struct ath_desc *ds, 
    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); 
     1023                            u32 pktLen, enum ath9k_pkt_type type, 
     1024                            u32 txPower, u32 keyIx, 
     1025                            enum ath9k_key_type keyType, u32 flags); 
    10861026bool ath9k_hw_filltxdesc(struct ath_hal *ah, struct ath_desc *ds, 
    1087                          u_int segLen, bool firstSeg, 
     1027                         u32 segLen, bool firstSeg, 
    10881028                         bool lastSeg, 
    10891029                         const struct ath_desc *ds0); 
    1090 u_int32_t ath9k_hw_GetMibCycleCountsPct(struct ath_hal *ah, 
    1091                                         u_int32_t *rxc_pcnt, 
    1092                                         u_int32_t *rxf_pcnt, 
    1093                                         u_int32_t *txf_pcnt); 
     1030u32 ath9k_hw_GetMibCycleCountsPct(struct ath_hal *ah, 
     1031                                        u32 *rxc_pcnt, 
     1032                                        u32 *rxf_pcnt, 
     1033                                        u32 *txf_pcnt); 
    10941034void ath9k_hw_dmaRegDump(struct ath_hal *ah); 
    10951035void ath9k_hw_beaconinit(struct ath_hal *ah, 
    1096                          u_int32_t next_beacon, u_int32_t beacon_period); 
     1036                         u32 next_beacon, u32 beacon_period); 
    10971037void ath9k_hw_set_sta_beacon_timers(struct ath_hal *ah, 
    1098                                     const struct hal_beacon_state *bs); 
     1038                                    const struct ath9k_beacon_state *bs); 
    10991039bool ath9k_hw_setuprxdesc(struct ath_hal *ah, struct ath_desc *ds, 
    1100                           u_int32_t size, u_int flags); 
    1101 void ath9k_hw_putrxbuf(struct ath_hal *ah, u_int32_t rxdp); 
     1040                          u32 size, u32 flags); 
     1041void ath9k_hw_putrxbuf(struct ath_hal *ah, u32 rxdp); 
    11021042void ath9k_hw_rxena(struct ath_hal *ah); 
    11031043void ath9k_hw_setopmode(struct ath_hal *ah); 
    1104 bool ath9k_hw_setmac(struct ath_hal *ah, const u_int8_t *mac); 
    1105 void ath9k_hw_setmcastfilter(struct ath_hal *ah, u_int32_t filter0, 
    1106                              u_int32_t filter1); 
    1107 u_int32_t ath9k_hw_getrxfilter(struct ath_hal *ah); 
     1044bool ath9k_hw_setmac(struct ath_hal *ah, const u8 *mac); 
     1045void ath9k_hw_setmcastfilter(struct ath_hal *ah, u32 filter0, 
     1046                             u32 filter1); 
     1047u32 ath9k_hw_getrxfilter(struct ath_hal *ah); 
    11081048void ath9k_hw_startpcureceive(struct ath_hal *ah); 
    11091049void ath9k_hw_stoppcurecv(struct ath_hal *ah); 
    11101050bool ath9k_hw_stopdmarecv(struct ath_hal *ah); 
    1111 enum hal_status ath9k_hw_rxprocdesc(struct ath_hal *ah, 
    1112                                     struct ath_desc *ds, u_int32_t pa, 
    1113                                     struct ath_desc *nds, u_int64_t tsf); 
    1114 u_int32_t ath9k_hw_gettxbuf(struct ath_hal *ah, u_int q); 
    1115 enum hal_status ath9k_hw_txprocdesc(struct ath_hal *ah, 
    1116                                     struct ath_desc *ds); 
     1051int ath9k_hw_rxprocdesc(struct ath_hal *ah, 
     1052                        struct ath_desc *ds, u32 pa, 
     1053                        struct ath_desc *nds, u64 tsf); 
     1054u32 ath9k_hw_gettxbuf(struct ath_hal *ah, u32 q); 
     1055int ath9k_hw_txprocdesc(struct ath_hal *ah, 
     1056                        struct ath_desc *ds); 
    11171057void ath9k_hw_set11n_aggr_middle(struct ath_hal *ah, struct ath_desc *ds, 
    1118                                  u_int numDelims); 
     1058                                 u32 numDelims); 
    11191059void ath9k_hw_set11n_aggr_first(struct ath_hal *ah, struct ath_desc *ds, 
    1120                                 u_int aggrLen); 
     1060                                u32 aggrLen); 
    11211061void ath9k_hw_set11n_aggr_last(struct ath_hal *ah, struct ath_desc *ds); 
    1122 bool ath9k_hw_releasetxqueue(struct ath_hal *ah, u_int q); 
    1123 void ath9k_hw_gettxintrtxqs(struct ath_hal *ah, u_int32_t *txqs); 
     1062bool ath9k_hw_releasetxqueue(struct ath_hal *ah, u32 q); 
     1063void ath9k_hw_gettxintrtxqs(struct ath_hal *ah, u32 *txqs); 
    11241064void ath9k_hw_clr11n_aggr(struct ath_hal *ah, struct ath_desc *ds); 
    11251065void ath9k_hw_set11n_virtualmorefrag(struct ath_hal *ah, 
    1126                                      struct ath_desc *ds, u_int vmf); 
    1127 bool ath9k_hw_set_txpowerlimit(struct ath_hal *ah, u_int32_t limit); 
     1066                                     struct ath_desc *ds, u32 vmf); 
     1067bool ath9k_hw_set_txpowerlimit(struct ath_hal *ah, u32 limit); 
    11281068bool ath9k_regd_is_public_safety_sku(struct ath_hal *ah); 
    1129 int ath9k_hw_setuptxqueue(struct ath_hal *ah, enum hal_tx_queue type, 
    1130                           const struct hal_txq_info *qInfo); 
    1131 u_int32_t ath9k_hw_numtxpending(struct ath_hal *ah, u_int q); 
    1132 const char *ath9k_hw_probe(u_int16_t vendorid, u_int16_t devid); 
     1069int ath9k_hw_setuptxqueue(struct ath_hal *ah, enum ath9k_tx_queue type, 
     1070                          const struct ath9k_txq_info *qInfo); 
     1071u32 ath9k_hw_numtxpending(struct ath_hal *ah, u32 q); 
     1072const char *ath9k_hw_probe(u16 vendorid, u16 devid); 
    11331073bool ath9k_hw_disable(struct ath_hal *ah); 
    11341074void ath9k_hw_rfdetach(struct ath_hal *ah); 
    11351075void ath9k_hw_get_channel_centers(struct ath_hal *ah, 
    1136                                   struct hal_channel_internal *chan, 
     1076                                  struct ath9k_channel *chan, 
    11371077                                  struct chan_centers *centers); 
    11381078bool ath9k_get_channel_edges(struct ath_hal *ah, 
    1139                              u_int16_t flags, u_int16_t *low, 
    1140                              u_int16_t *high); 
    1141 bool ath9k_hw_get_chip_power_limits(struct ath_hal *ah, 
    1142                                     struct hal_channel *chans, 
    1143                                     u_int32_t nchans); 
     1079                             u16 flags, u16 *low, 
     1080                             u16 *high); 
    11441081#endif 
  • trunk/package/ath9k/src/drivers/net/wireless/ath9k/beacon.c

    r12038 r12079  
    3030{ 
    3131        struct ath_hal *ah = sc->sc_ah; 
    32         struct hal_txq_info qi; 
     32        struct ath9k_txq_info qi; 
    3333 
    3434        ath9k_hw_gettxqueueprops(ah, sc->sc_bhalq, &qi); 
    35         if (sc->sc_opmode == HAL_M_HOSTAP) { 
     35        if (sc->sc_opmode == ATH9K_M_HOSTAP) { 
    3636                /* Always burst out beacon and CAB traffic. */ 
    3737                qi.tqi_aifs = 1; 
     
    7171        struct ath_desc *ds; 
    7272        int flags, antenna; 
    73         const struct hal_rate_table *rt; 
    74         u_int8_t rix, rate; 
     73        const struct ath9k_rate_table *rt; 
     74        u8 rix, rate; 
    7575        int ctsrate = 0; 
    7676        int ctsduration = 0; 
    77         struct hal_11n_rate_series  series[4]; 
     77        struct ath9k_11n_rate_series  series[4]; 
    7878 
    7979        DPRINTF(sc, ATH_DBG_BEACON, "%s: m %p len %u\n", 
     
    8383        ds = bf->bf_desc; 
    8484 
    85         flags = HAL_TXDESC_NOACK; 
    86  
    87         if (sc->sc_opmode == HAL_M_IBSS && ah->ah_caps.halVEOLSupport) { 
     85        flags = ATH9K_TXDESC_NOACK; 
     86 
     87        if (sc->sc_opmode == ATH9K_M_IBSS && ah->ah_caps.halVEOLSupport) { 
    8888                ds->ds_link = bf->bf_daddr; /* self-linked */ 
    89                 flags |= HAL_TXDESC_VEOL; 
     89                flags |= ATH9K_TXDESC_VEOL; 
    9090                /* Let hardware handle antenna switching. */ 
    9191                antenna = 0; 
     
    115115        ath9k_hw_set11n_txdesc(ah, ds 
    116116                              , skb->len + FCS_LEN /* frame length */ 
    117                               , HAL_PKT_TYPE_BEACON /* Atheros packet type */ 
     117                              , ATH9K_PKT_TYPE_BEACON /* Atheros packet type */ 
    118118                              , avp->av_btxctl.txpower /* txpower XXX */ 
    119                               , HAL_TXKEYIX_INVALID /* no encryption */ 
    120                               , HAL_KEY_TYPE_CLEAR /* no encryption */ 
     119                              , ATH9K_TXKEYIX_INVALID /* no encryption */ 
     120                              , ATH9K_KEY_TYPE_CLEAR /* no encryption */ 
    121121                              , flags /* no ack, veol for beacons */ 
    122122                ); 
     
    130130                ); 
    131131 
    132         memzero(series, sizeof(struct hal_11n_rate_series) * 4); 
     132        memzero(series, sizeof(struct ath9k_11n_rate_series) * 4); 
    133133        series[0].Tries = 1; 
    134134        series[0].Rate = rate; 
    135135        series[0].ChSel = sc->sc_tx_chainmask; 
    136         series[0].RateFlags = (ctsrate) ? HAL_RATESERIES_RTS_CTS : 0; 
     136        series[0].RateFlags = (ctsrate) ? ATH9K_RATESERIES_RTS_CTS : 0; 
    137137        ath9k_hw_set11n_ratescenario(ah, ds, ds, 0, 
    138138                ctsrate, ctsduration, series, 4, 0); 
     
    326326 *  Setup a h/w transmit queue for beacons. 
    327327 * 
    328  *  This function allocates an information structure (struct hal_txq_info) 
     328 *  This function allocates an information structure (struct ath9k_txq_info) 
    329329 *  on the stack, sets some specific parameters (zero out channel width 
    330330 *  min/max, and enable aifs). The info structure does not need to be 
     
    334334int ath_beaconq_setup(struct ath_hal *ah) 
    335335{ 
    336         struct hal_txq_info qi; 
     336        struct ath9k_txq_info qi; 
    337337 
    338338        memzero(&qi, sizeof(qi)); 
     
    341341        qi.tqi_cwmax = 0; 
    342342        /* NB: don't enable any interrupts */ 
    343         return ath9k_hw_setuptxqueue(ah, HAL_TX_QUEUE_BEACON, &qi); 
     343        return ath9k_hw_setuptxqueue(ah, ATH9K_TX_QUEUE_BEACON, &qi); 
    344344} 
    345345 
     
    374374                list_del(&avp->av_bcbuf->list); 
    375375 
    376                 if (sc->sc_opmode == HAL_M_HOSTAP || 
     376                if (sc->sc_opmode == ATH9K_M_HOSTAP || 
    377377                        !sc->sc_ah->ah_caps.halVEOLSupport) { 
    378378                        int slot; 
     
    434434         */ 
    435435        if (avp->av_bslot > 0) { 
    436                 u_int64_t tsfadjust; 
     436                u64 tsfadjust; 
    437437                __le64 val; 
    438438                int intval; 
     
    540540{ 
    541541#define TSF_TO_TU(_h,_l)                                        \ 
    542         ((((u_int32_t)(_h)) << 22) | (((u_int32_t)(_l)) >> 10)) 
     542        ((((u32)(_h)) << 22) | (((u32)(_l)) >> 10)) 
    543543 
    544544        struct ath_softc *sc = (struct ath_softc *)data; 
     
    546546        struct ath_buf *bf = NULL; 
    547547        int slot, if_id; 
    548         u_int32_t bfaddr; 
    549         u_int32_t rx_clear = 0, rx_frame = 0, tx_frame = 0; 
    550         u_int32_t show_cycles = 0; 
    551         u_int32_t bc = 0; /* beacon count */ 
    552         u_int64_t tsf; 
    553         u_int32_t tsftu; 
    554         u_int16_t intval; 
     548        u32 bfaddr; 
     549        u32 rx_clear = 0, rx_frame = 0, tx_frame = 0; 
     550        u32 show_cycles = 0; 
     551        u32 bc = 0; /* beacon count */ 
     552        u64 tsf; 
     553        u32 tsftu; 
     554        u16 intval; 
    555555 
    556556        if (sc->sc_noreset) { 
     
    740740{ 
    741741#define TSF_TO_TU(_h,_l)                                        \ 
    742         ((((u_int32_t)(_h)) << 22) | (((u_int32_t)(_l)) >> 10)) 
     742        ((((u32)(_h)) << 22) | (((u32)(_l)) >> 10)) 
    743743        struct ath_hal *ah = sc->sc_ah; 
    744         u_int32_t nexttbtt, intval; 
     744        u32 nexttbtt, intval; 
    745745        struct ath_beacon_config conf; 
    746         enum hal_opmode av_opmode; 
     746        enum ath9k_opmode av_opmode; 
    747747 
    748748        if (if_id != ATH_IF_ID_ANY) 
     
    769769                             LE_READ_4(conf.u.last_tstamp)); 
    770770        /* XXX conditionalize multi-bss support? */ 
    771         if (sc->sc_opmode == HAL_M_HOSTAP) { 
     771        if (sc->sc_opmode == ATH9K_M_HOSTAP) { 
    772772                /* 
    773773                 * For multi-bss ap support beacons are either staggered 
     
    777777                 */ 
    778778                /* NB: the beacon interval is kept internally in TU's */ 
    779                 intval = conf.beacon_interval & HAL_BEACON_PERIOD; 
     779                intval = conf.beacon_interval & ATH9K_BEACON_PERIOD; 
    780780                intval /= ATH_BCBUF;    /* for staggered beacons */ 
    781781        } else { 
    782                 intval = conf.beacon_interval & HAL_BEACON_PERIOD; 
     782                intval = conf.beacon_interval & ATH9K_BEACON_PERIOD; 
    783783        } 
    784784 
     
    789789        DPRINTF(sc, ATH_DBG_BEACON, "%s: nexttbtt %u intval %u (%u)\n", 
    790790                __func__, nexttbtt, intval, conf.beacon_interval); 
    791         /* Check for HAL_M_HOSTAP and sc_nostabeacons for WDS client */ 
    792         if (sc->sc_opmode == HAL_M_STA) { 
    793                 struct hal_beacon_state bs; 
    794                 u_int64_t tsf; 
    795                 u_int32_t tsftu; 
     791        /* Check for ATH9K_M_HOSTAP and sc_nostabeacons for WDS client */ 
     792        if (sc->sc_opmode == ATH9K_M_STA) { 
     793                struct ath9k_beacon_state bs; 
     794                u64 tsf; 
     795                u32 tsftu; 
    796796                int dtimperiod, dtimcount, sleepduration; 
    797797                int cfpperiod, cfpcount; 
     
    902902                ath9k_hw_set_interrupts(ah, 0); 
    903903                ath9k_hw_set_sta_beacon_timers(ah, &bs); 
    904                 sc->sc_imask |= HAL_INT_BMISS; 
     904                sc->sc_imask |= ATH9K_INT_BMISS; 
    905905                ath9k_hw_set_interrupts(ah, sc->sc_imask); 
    906906        } else { 
    907                 u_int64_t tsf; 
    908                 u_int32_t tsftu; 
     907                u64 tsf; 
     908                u32 tsftu; 
    909909                ath9k_hw_set_interrupts(ah, 0); 
    910910                if (nexttbtt == intval) 
    911                         intval |= HAL_BEACON_RESET_TSF; 
    912                 if (sc->sc_opmode == HAL_M_IBSS) { 
     911                        intval |= ATH9K_BEACON_RESET_TSF; 
     912                if (sc->sc_opmode == ATH9K_M_IBSS) { 
    913913                        /* 
    914914                         * Pull nexttbtt forward to reflect the current 
     
    916916                         */ 
    917917#define FUDGE   2 
    918                         if (!(intval & HAL_BEACON_RESET_TSF)) { 
     918                        if (!(intval & ATH9K_BEACON_RESET_TSF)) { 
    919919                                tsf = ath9k_hw_gettsf64(ah); 
    920                                 tsftu = TSF_TO_TU((u_int32_t)(tsf>>32), 
    921                                         (u_int32_t)tsf) + FUDGE; 
     920                                tsftu = TSF_TO_TU((u32)(tsf>>32), 
     921                                        (u32)tsf) + FUDGE; 
    922922                                do { 
    923923                                        nexttbtt += intval; 
     
    928928                                "%s: IBSS nexttbtt %u intval %u (%u)\n", 
    929929                                __func__, nexttbtt, 
    930                                 intval & ~HAL_BEACON_RESET_TSF, 
     930                                intval & ~ATH9K_BEACON_RESET_TSF, 
    931931                                conf.beacon_interval); 
    932932 
     
    938938                         * deal with things. 
    939939                         */ 
    940                         intval |= HAL_BEACON_ENA; 
     940                        intval |= ATH9K_BEACON_ENA; 
    941941                        if (!ah->ah_caps.halVEOLSupport) 
    942                                 sc->sc_imask |= HAL_INT_SWBA; 
     942                                sc->sc_imask |= ATH9K_INT_SWBA; 
    943943                        ath_beaconq_config(sc); 
    944                 } else if (sc->sc_opmode == HAL_M_HOSTAP) { 
     944                } else if (sc->sc_opmode == ATH9K_M_HOSTAP) { 
    945945                        /* 
    946946                         * In AP mode we enable the beacon timers and 
    947947                         * SWBA interrupts to prepare beacon frames. 
    948948                         */ 
    949                         intval |= HAL_BEACON_ENA; 
    950                         sc->sc_imask |= HAL_INT_SWBA;   /* beacon prepare */ 
     949                        intval |= ATH9K_BEACON_ENA; 
     950                        sc->sc_imask |= ATH9K_INT_SWBA;   /* beacon prepare */ 
    951951                        ath_beaconq_config(sc); 
    952952                } 
     
    958958                 * ibss mode load it once here. 
    959959                 */ 
    960                 if (sc->sc_opmode == HAL_M_IBSS && ah->ah_caps.halVEOLSupport) 
     960                if (sc->sc_opmode == ATH9K_M_IBSS && ah->ah_caps.halVEOLSupport) 
    961961                        ath_beacon_start_adhoc(sc, 0); 
    962962        } 
  • trunk/package/ath9k/src/drivers/net/wireless/ath9k/core.c

    r12038 r12079  
    2222static int ath_outdoor;         /* enable outdoor use */ 
    2323 
    24 static const u_int8_t ath_bcast_mac[ETH_ALEN] = 
     24static const u8 ath_bcast_mac[ETH_ALEN] = 
    2525    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 
    2626 
    27 static u_int32_t ath_chainmask_sel_up_rssi_thres = 
     27static u32 ath_chainmask_sel_up_rssi_thres = 
    2828        ATH_CHAINMASK_SEL_UP_RSSI_THRES; 
    29 static u_int32_t ath_chainmask_sel_down_rssi_thres = 
     29static u32 ath_chainmask_sel_down_rssi_thres = 
    3030        ATH_CHAINMASK_SEL_DOWN_RSSI_THRES; 
    31 static u_int32_t ath_chainmask_sel_period = 
     31static u32 ath_chainmask_sel_period = 
    3232        ATH_CHAINMASK_SEL_TIMEOUT; 
    3333 
     
    3636static void bus_read_cachesize(struct ath_softc *sc, int *csz) 
    3737{ 
    38         u_int8_t u8tmp; 
    39  
    40         pci_read_config_byte(sc->pdev, PCI_CACHE_LINE_SIZE, (u_int8_t *)&u8tmp); 
     38        u8 u8tmp; 
     39 
     40        pci_read_config_byte(sc->pdev, PCI_CACHE_LINE_SIZE, (u8 *)&u8tmp); 
    4141        *csz = (int)u8tmp; 
    4242 
     
    6161static void ath_setcurmode(struct ath_softc *sc, enum wireless_mode mode) 
    6262{ 
    63         const struct hal_rate_table *rt; 
     63        const struct ath9k_rate_table *rt; 
    6464        int i; 
    6565 
     
    6969 
    7070        for (i = 0; i < rt->rateCount; i++) 
    71                 sc->sc_rixmap[rt->info[i].rateCode] = (u_int8_t) i; 
     71                sc->sc_rixmap[rt->info[i].rateCode] = (u8) i; 
    7272 
    7373        memzero(sc->sc_hwmap, sizeof(sc->sc_hwmap)); 
    7474        for (i = 0; i < 256; i++) { 
    75                 u_int8_t ix = rt->rateCodeToIndex[i]; 
     75                u8 ix = rt->rateCodeToIndex[i]; 
    7676 
    7777                if (ix == 0xff) 
     
    111111{ 
    112112        struct ath_hal *ah = sc->sc_ah; 
    113         const struct hal_rate_table *rt; 
     113        const struct ath9k_rate_table *rt; 
    114114 
    115115        switch (mode) { 
     
    169169/* 
    170170 *  Set up channel list 
    171  * 
    172  *  Determines the proper set of channelflags based on the selected mode, 
    173  *  allocates a channel array, and passes it to the HAL for initialization. 
    174  *  If successful, the list is passed to the upper layer, then de-allocated. 
    175 */ 
    176  
    177 static int ath_getchannels(struct ath_softc *sc, 
    178                            u_int cc, 
    179                            bool outDoor, 
    180                            bool xchanMode) 
     171 */ 
     172static int ath_setup_channels(struct ath_softc *sc) 
    181173{ 
    182174        struct ath_hal *ah = sc->sc_ah; 
    183         struct hal_channel *chans; 
    184         int nchan; 
    185         u_int8_t regclassids[ATH_REGCLASSIDS_MAX]; 
    186         u_int nregclass = 0; 
    187  
    188         chans = kmalloc(ATH_CHAN_MAX * sizeof(struct hal_channel), GFP_KERNEL); 
    189         if (chans == NULL) { 
    190                 DPRINTF(sc, ATH_DBG_FATAL, 
    191                         "%s: unable to allocate channel table\n", __func__); 
    192                 return -ENOMEM; 
    193         } 
    194  
     175        int nchan, i, a = 0, b = 0; 
     176        u8 regclassids[ATH_REGCLASSIDS_MAX]; 
     177        u32 nregclass = 0; 
     178        struct ieee80211_supported_band *band_2ghz; 
     179        struct ieee80211_supported_band *band_5ghz; 
     180        struct ieee80211_channel *chan_2ghz; 
     181        struct ieee80211_channel *chan_5ghz; 
     182        struct ath9k_channel *c; 
     183 
     184        /* Fill in ah->ah_channels */ 
    195185        if (!ath9k_regd_init_channels(ah, 
    196                                       chans, 
    197186                                      ATH_CHAN_MAX, 
    198                                       (u_int *)&nchan, 
     187                                      (u32 *)&nchan, 
    199188                                      regclassids, 
    200189                                      ATH_REGCLASSIDS_MAX, 
    201190                                      &nregclass, 
    202                                       cc, 
     191                                      CTRY_DEFAULT, 
    203192                                      ATH9K_MODE_SEL_ALL, 
    204                                       outDoor, 
    205                                       xchanMode)) { 
    206                 u_int32_t rd = ah->ah_currentRD; 
     193                                      false, 
     194                                      1)) { 
     195                u32 rd = ah->ah_currentRD; 
    207196 
    208197                DPRINTF(sc, ATH_DBG_FATAL, 
    209                         "%s: unable to collect channel list from hal; " 
     198                        "%s: unable to collect channel list; " 
    210199                        "regdomain likely %u country code %u\n", 
    211                         __func__, rd, cc); 
    212                 kfree(chans); 
     200                        __func__, rd, CTRY_DEFAULT); 
    213201                return -EINVAL; 
    214202        } 
    215203 
    216         ath_setup_channel_list(sc, 
    217                                CLIST_UPDATE, 
    218                                chans, 
    219                                nchan, 
    220                                regclassids, 
    221                                nregclass, 
    222                                CTRY_DEFAULT); 
    223  
    224         kfree(chans); 
     204        band_2ghz = &sc->sbands[IEEE80211_BAND_2GHZ]; 
     205        band_5ghz = &sc->sbands[IEEE80211_BAND_5GHZ]; 
     206        chan_2ghz = sc->channels[IEEE80211_BAND_2GHZ]; 
     207        chan_5ghz = sc->channels[IEEE80211_BAND_5GHZ]; 
     208 
     209        for (i = 0; i < nchan; i++) { 
     210                c = &ah->ah_channels[i]; 
     211                if (IS_CHAN_2GHZ(c)) { 
     212                        chan_2ghz[a].band = IEEE80211_BAND_2GHZ; 
     213                        chan_2ghz[a].center_freq = c->channel; 
     214                        chan_2ghz[a].max_power = c->maxTxPower; 
     215 
     216                        if (c->privFlags & CHANNEL_DISALLOW_ADHOC) 
     217                                chan_2ghz[a].flags |= 
     218                                        IEEE80211_CHAN_NO_IBSS; 
     219                        if (c->channelFlags & CHANNEL_PASSIVE) 
     220                                chan_2ghz[a].flags |= 
     221                                        IEEE80211_CHAN_PASSIVE_SCAN; 
     222 
     223                        band_2ghz->n_channels = ++a; 
     224 
     225                        DPRINTF(sc, ATH_DBG_CONFIG, 
     226                                "%s: 2MHz channel: %d, " 
     227                                "channelFlags: 0x%x\n", 
     228                                __func__, 
     229                                c->channel, 
     230                                c->channelFlags); 
     231                } else if (IS_CHAN_5GHZ(c)) { 
     232                        chan_5ghz[b].band = IEEE80211_BAND_5GHZ; 
     233                        chan_5ghz[b].center_freq = c->channel; 
     234                        chan_5ghz[b].max_power = c->maxTxPower; 
     235 
     236                        if (c->privFlags & CHANNEL_DISALLOW_ADHOC) 
     237                                chan_5ghz[b].flags |= 
     238                                        IEEE80211_CHAN_NO_IBSS; 
     239                        if (c->channelFlags & CHANNEL_PASSIVE) 
     240                                chan_5ghz[b].flags |= 
     241                                        IEEE80211_CHAN_PASSIVE_SCAN; 
     242 
     243                        band_5ghz->n_channels = ++b; 
     244 
     245                        DPRINTF(sc, ATH_DBG_CONFIG, 
     246                                "%s: 5MHz channel: %d, " 
     247                                "channelFlags: 0x%x\n", 
     248                                __func__, 
     249                                c->channel, 
     250                                c->channelFlags); 
     251                } 
     252        } 
     253 
    225254        return 0; 
    226255} 
     
    234263*/ 
    235264 
    236 static enum wireless_mode ath_chan2mode(struct hal_channel *chan) 
    237 { 
    238         if ((chan->channelFlags & CHANNEL_A) == CHANNEL_A) 
     265static enum wireless_mode ath_chan2mode(struct ath9k_channel *chan) 
     266{ 
     267        if (chan->chanmode == CHANNEL_A) 
    239268                return WIRELESS_MODE_11a; 
    240         else if ((chan->channelFlags & CHANNEL_G) == CHANNEL_G) 
     269        else if (chan->chanmode == CHANNEL_G) 
    241270                return WIRELESS_MODE_11g; 
    242         else if ((chan->channelFlags & CHANNEL_B) == CHANNEL_B) 
     271        else if (chan->chanmode == CHANNEL_B) 
    243272                return WIRELESS_MODE_11b; 
    244         else if ((chan->channelFlags & CHANNEL_A_HT20) == CHANNEL_A_HT20) 
     273        else if (chan->chanmode == CHANNEL_A_HT20) 
    245274                return WIRELESS_MODE_11NA_HT20; 
    246         else if ((chan->channelFlags & CHANNEL_G_HT20) == CHANNEL_G_HT20) 
     275        else if (chan->chanmode == CHANNEL_G_HT20) 
    247276                return WIRELESS_MODE_11NG_HT20; 
    248         else if ((chan->channelFlags & CHANNEL_A_HT40PLUS) == 
    249                  CHANNEL_A_HT40PLUS) 
     277        else if (chan->chanmode == CHANNEL_A_HT40PLUS) 
    250278                return WIRELESS_MODE_11NA_HT40PLUS; 
    251         else if ((chan->channelFlags & CHANNEL_A_HT40MINUS) == 
    252                  CHANNEL_A_HT40MINUS) 
     279        else if (chan->chanmode == CHANNEL_A_HT40MINUS) 
    253280                return WIRELESS_MODE_11NA_HT40MINUS; 
    254         else if ((chan->channelFlags & CHANNEL_G_HT40PLUS) == 
    255                  CHANNEL_G_HT40PLUS) 
     281        else if (chan->chanmode == CHANNEL_G_HT40PLUS) 
    256282                return WIRELESS_MODE_11NG_HT40PLUS; 
    257         else if ((chan->channelFlags & CHANNEL_G_HT40MINUS) == 
    258                  CHANNEL_G_HT40MINUS) 
     283        else if (chan->chanmode == CHANNEL_G_HT40MINUS) 
    259284                return WIRELESS_MODE_11NG_HT40MINUS; 
    260285 
     
    270295*/ 
    271296 
    272 static void ath_chan_change(struct ath_softc *sc, struct hal_channel *chan) 
     297static void ath_chan_change(struct ath_softc *sc, struct ath9k_channel *chan) 
    273298{ 
    274299        enum wireless_mode mode; 
     
    333358{ 
    334359        struct ath_hal *ah = sc->sc_ah; 
    335         u_int32_t rfilt; 
    336         u_int32_t now = (u_int32_t) jiffies_to_msecs(get_timestamp()); 
     360        u32 rfilt; 
     361        u32 now = (u32) jiffies_to_msecs(get_timestamp()); 
    337362 
    338363        sc->sc_scanning = 1; 
     
    358383{ 
    359384        struct ath_hal *ah = sc->sc_ah; 
    360         u_int32_t rfilt; 
    361         u_int32_t now = (u_int32_t) jiffies_to_msecs(get_timestamp()); 
     385        u32 rfilt; 
     386        u32 now = (u32) jiffies_to_msecs(get_timestamp()); 
    362387 
    363388        sc->sc_scanning = 0; 
     
    379404 * DMA, then restart stuff after a la ath_init. 
    380405*/ 
    381 int ath_set_channel(struct ath_softc *sc, struct hal_channel *hchan) 
     406int ath_set_channel(struct ath_softc *sc, struct ath9k_channel *hchan) 
    382407{ 
    383408        struct ath_hal *ah = sc->sc_ah; 
    384409        bool fastcc = true, stopped; 
    385         enum hal_ht_macmode ht_macmode; 
     410        enum ath9k_ht_macmode ht_macmode; 
    386411 
    387412        if (sc->sc_invalid)     /* if the device is invalid or removed */ 
     
    402427            hchan->channelFlags != sc->sc_curchan.channelFlags || 
    403428            sc->sc_update_chainmask || sc->sc_full_reset) { 
    404                 enum hal_status status; 
     429                int status; 
    405430                /* 
    406431                 * This is only performed if the channel settings have 
     
    581606        struct ath_hal *ah = sc->sc_ah; 
    582607        struct ath_vap *avp; 
    583         u_int32_t rfilt = 0; 
     608        u32 rfilt = 0; 
    584609        DECLARE_MAC_BUF(mac); 
    585610 
     
    596621 
    597622        /* update ratectrl about the new state */ 
    598         ath_rate_newstate(sc, avp, 0); 
     623        ath_rate_newstate(sc, avp); 
    599624 
    600625        rfilt = ath_calcrxfilter(sc); 
    601626        ath9k_hw_setrxfilter(ah, rfilt); 
    602627 
    603         if (sc->sc_opmode == HAL_M_STA || sc->sc_opmode == HAL_M_IBSS) { 
     628        if (sc->sc_opmode == ATH9K_M_STA || sc->sc_opmode == ATH9K_M_IBSS) { 
    604629                memcpy(sc->sc_curbssid, ath_bcast_mac, ETH_ALEN); 
    605630                ath9k_hw_write_associd(ah, sc->sc_curbssid, sc->sc_curaid); 
     
    617642         */ 
    618643        ath9k_hw_set_interrupts(ah, 
    619                 sc->sc_imask & ~(HAL_INT_SWBA | HAL_INT_BMISS)); 
    620         sc->sc_imask &= ~(HAL_INT_SWBA | HAL_INT_BMISS); 
     644                sc->sc_imask & ~(ATH9K_INT_SWBA | ATH9K_INT_BMISS)); 
     645        sc->sc_imask &= ~(ATH9K_INT_SWBA | ATH9K_INT_BMISS); 
    621646        /* need to reconfigure the beacons when it moves to RUN */ 
    622647        sc->sc_beacons = 0; 
     
    628653                   int if_id, 
    629654                   struct ieee80211_vif *if_data, 
    630                    enum hal_opmode opmode) 
     655                   enum ath9k_opmode opmode) 
    631656{ 
    632657        struct ath_vap *avp; 
     
    639664 
    640665        switch (opmode) { 
    641         case HAL_M_STA: 
    642         case HAL_M_IBSS: 
    643         case HAL_M_MONITOR: 
    644                 break; 
    645         case HAL_M_HOSTAP: 
     666        case ATH9K_M_STA: 
     667        case ATH9K_M_IBSS: 
     668        case ATH9K_M_MONITOR: 
     669                break; 
     670        case ATH9K_M_HOSTAP: 
    646671                /* XXX not right, beacon buffer is allocated on RUN trans */ 
    647672                if (list_empty(&sc->sc_bbuf)) 
     
    738763/********/ 
    739764 
    740 int ath_open(struct ath_softc *sc, struct hal_channel *initial_chan) 
     765int ath_open(struct ath_softc *sc, struct ath9k_channel *initial_chan) 
    741766{ 
    742767        struct ath_hal *ah = sc->sc_ah; 
    743         enum hal_status status; 
     768        int status; 
    744769        int error = 0; 
    745         enum hal_ht_macmode ht_macmode = ath_cwm_macmode(sc); 
     770        enum ath9k_ht_macmode ht_macmode = ath_cwm_macmode(sc); 
    746771 
    747772        DPRINTF(sc, ATH_DBG_CONFIG, "%s: mode %d\n", __func__, sc->sc_opmode); 
     
    802827        } 
    803828        /* Setup our intr mask. */ 
    804         sc->sc_imask = HAL_INT_RX | HAL_INT_TX 
    805                 | HAL_INT_RXEOL | HAL_INT_RXORN 
    806                 | HAL_INT_FATAL | HAL_INT_GLOBAL; 
     829        sc->sc_imask = ATH9K_INT_RX | ATH9K_INT_TX 
     830                | ATH9K_INT_RXEOL | ATH9K_INT_RXORN 
     831                | ATH9K_INT_FATAL | ATH9K_INT_GLOBAL; 
    807832 
    808833        if (ah->ah_caps.halGTTSupport) 
    809                 sc->sc_imask |= HAL_INT_GTT; 
     834                sc->sc_imask |= ATH9K_INT_GTT; 
    810835 
    811836        if (ah->ah_caps.halHTSupport) 
    812                 sc->sc_imask |= HAL_INT_CST; 
     837                sc->sc_imask |= ATH9K_INT_CST; 
    813838 
    814839        /* 
     
    817842         */ 
    818843        if (ath9k_hw_phycounters(ah) && 
    819             ((sc->sc_opmode == HAL_M_STA) || (sc->sc_opmode == HAL_M_IBSS))) 
    820                 sc->sc_imask |= HAL_INT_MIB; 
     844            ((sc->sc_opmode == ATH9K_M_STA) || (sc->sc_opmode == ATH9K_M_IBSS))) 
     845                sc->sc_imask |= ATH9K_INT_MIB; 
    821846        /* 
    822847         * Some hardware processes the TIM IE and fires an 
     
    825850         * enable the TIM interrupt when operating as station. 
    826851         */ 
    827         if (ah->ah_caps.halEnhancedPmSupport && sc->sc_opmode == HAL_M_STA && 
     852        if (ah->ah_caps.halEnhancedPmSupport && sc->sc_opmode == ATH9K_M_STA && 
    828853                !sc->sc_config.swBeaconProcess) 
    829                 sc->sc_imask |= HAL_INT_TIM; 
     854                sc->sc_imask |= ATH9K_INT_TIM; 
    830855        /* 
    831856         *  Don't enable interrupts here as we've not yet built our 
     
    850875 */ 
    851876 
    852 static int ath_reset_start(struct ath_softc *sc, u_int32_t flag) 
     877static int ath_reset_start(struct ath_softc *sc, u32 flag) 
    853878{ 
    854879        struct ath_hal *ah = sc->sc_ah; 
     
    862887} 
    863888 
    864 static int ath_reset_end(struct ath_softc *sc, u_int32_t flag) 
     889static int ath_reset_end(struct ath_softc *sc, u32 flag) 
    865890{ 
    866891        struct ath_hal *ah = sc->sc_ah; 
     
    886911        if (flag & RESET_RETRY_TXQ) { 
    887912                int i; 
    888                 for (i = 0; i < HAL_NUM_TX_QUEUES; i++) { 
     913                for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) { 
    889914                        if (ATH_TXQ_SETUP(sc, i)) { 
    890915                                spin_lock_bh(&sc->sc_txq[i].axq_lock); 
     
    900925{ 
    901926        struct ath_hal *ah = sc->sc_ah; 
    902         enum hal_status status; 
     927        int status; 
    903928        int error = 0; 
    904         enum hal_ht_macmode ht_macmode = ath_cwm_macmode(sc); 
     929        enum ath9k_ht_macmode ht_macmode = ath_cwm_macmode(sc); 
    905930 
    906931        /* NB: indicate channel change so we do a full reset */ 
     
    950975        struct ath_softc *sc = dev; 
    951976        struct ath_hal *ah = sc->sc_ah; 
    952         enum hal_int status; 
     977        enum ath9k_int status; 
    953978        bool sched = false; 
    954979 
     
    9861011                sc->sc_intrstatus = status; 
    9871012 
    988                 if (status & HAL_INT_FATAL) { 
     1013                if (status & ATH9K_INT_FATAL) { 
    9891014                        /* need a chip reset */ 
    9901015                        sched = true; 
    991                 } else if (status & HAL_INT_RXORN) { 
     1016                } else if (status & ATH9K_INT_RXORN) { 
    9921017                        /* need a chip reset */ 
    9931018                        sched = true; 
    9941019                } else { 
    995                         if (status & HAL_INT_SWBA) { 
     1020                        if (status & ATH9K_INT_SWBA) { 
    9961021                                /* schedule a tasklet for beacon handling */ 
    9971022                                tasklet_schedule(&sc->bcon_tasklet); 
    9981023                        } 
    999                         if (status & HAL_INT_RXEOL) { 
     1024                        if (status & ATH9K_INT_RXEOL) { 
    10001025                                /* 
    10011026                                 * NB: the hardware should re-read the link when 
     
    10061031                        } 
    10071032 
    1008                         if (status & HAL_INT_TXURN) 
     1033                        if (status & ATH9K_INT_TXURN) 
    10091034                                /* bump tx trigger level */ 
    10101035                                ath9k_hw_updatetxtriglevel(ah, true); 
    10111036                        /* XXX: optimize this */ 
    1012                         if (status & HAL_INT_RX) 
     1037                        if (status & ATH9K_INT_RX) 
    10131038                                sched = true; 
    1014                         if (status & HAL_INT_TX) 
     1039                        if (status & ATH9K_INT_TX) 
    10151040                                sched = true; 
    1016                         if (status & HAL_INT_BMISS) 
     1041                        if (status & ATH9K_INT_BMISS) 
    10171042                                sched = true; 
    10181043                        /* carrier sense timeout */ 
    1019                         if (status & HAL_INT_CST) 
     1044                        if (status & ATH9K_INT_CST) 
    10201045                                sched = true; 
    1021                         if (status & HAL_INT_MIB) { 
     1046                        if (status & ATH9K_INT_MIB) { 
    10221047                                /* 
    10231048                                 * Disable interrupts until we service the MIB 
     
    10341059                                ath9k_hw_set_interrupts(ah, sc->sc_imask); 
    10351060                        } 
    1036                         if (status & HAL_INT_TIM_TIMER) { 
     1061                        if (status & ATH9K_INT_TIM_TIMER) { 
    10371062                                if (!ah->ah_caps.halAutoSleepSupport) { 
    10381063                                        /* Clear RxAbort bit so that we can 
     
    10471072        if (sched) { 
    10481073                /* turn off every interrupt except SWBA */ 
    1049                 ath9k_hw_set_interrupts(ah, (sc->sc_imask & HAL_INT_SWBA)); 
     1074                ath9k_hw_set_interrupts(ah, (sc->sc_imask & ATH9K_INT_SWBA)); 
    10501075                tasklet_schedule(&sc->intr_tq); 
    10511076        } 
     
    10591084{ 
    10601085        struct ath_softc *sc = (struct ath_softc *)data; 
    1061         u_int32_t status = sc->sc_intrstatus; 
    1062  
    1063         if (status & HAL_INT_FATAL) { 
     1086        u32 status = sc->sc_intrstatus; 
     1087 
     1088        if (status & ATH9K_INT_FATAL) { 
    10641089                /* need a chip reset */ 
    10651090                ath_internal_reset(sc); 
     
    10671092        } else { 
    10681093 
    1069                 if (status & (HAL_INT_RX | HAL_INT_RXEOL | HAL_INT_RXORN)) { 
     1094                if (status & 
     1095                    (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN)) { 
    10701096                        /* XXX: fill me in */ 
    10711097                        /* 
    1072                         if (status & HAL_INT_RXORN) { 
     1098                        if (status & ATH9K_INT_RXORN) { 
    10731099                        } 
    1074                         if (status & HAL_INT_RXEOL) { 
     1100                        if (status & ATH9K_INT_RXEOL) { 
    10751101                        } 
    10761102                        */ 
     
    10801106                } 
    10811107                /* XXX: optimize this */ 
    1082                 if (status & HAL_INT_TX) 
     1108                if (status & ATH9K_INT_TX) 
    10831109                        ath_tx_tasklet(sc); 
    10841110                /* XXX: fill me in */ 
    10851111                /* 
    1086                 if (status & HAL_INT_BMISS) { 
    1087                 } 
    1088                 if (status & (HAL_INT_TIM | HAL_INT_DTIMSYNC)) { 
    1089                         if (status & HAL_INT_TIM) { 
     1112                if (status & ATH9K_INT_BMISS) { 
     1113                } 
     1114                if (status & (ATH9K_INT_TIM | ATH9K_INT_DTIMSYNC)) { 
     1115                        if (status & ATH9K_INT_TIM) { 
    10901116                        } 
    1091                         if (status & HAL_INT_DTIMSYNC) { 
     1117                        if (status & ATH9K_INT_DTIMSYNC) { 
    10921118                        } 
    10931119                } 
     
    10991125} 
    11001126 
    1101 int ath_init(u_int16_t devid, struct ath_softc *sc) 
     1127int ath_init(u16 devid, struct ath_softc *sc) 
    11021128{ 
    11031129        struct ath_hal *ah = NULL; 
    1104         enum hal_status status; 
     1130        int status; 
    11051131        int error = 0, i; 
    11061132        int csz = 0; 
    1107         u_int32_t rd; 
     1133        u32 rd; 
    11081134 
    11091135        /* XXX: hardware will not be ready until ath_open() being called */ 
     
    11551181         */ 
    11561182        for (i = 0; i < sc->sc_keymax; i++) 
    1157                 ath9k_hw_keyreset(ah, (u_int16_t) i); 
     1183                ath9k_hw_keyreset(ah, (u16) i); 
    11581184        /* 
    11591185         * Mark key cache slots associated with global keys 
     
    11761202        rd = ah->ah_currentRD; 
    11771203 
    1178         error = ath_getchannels(sc, 
    1179                                 CTRY_DEFAULT, 
    1180                                 ath_outdoor, 
    1181                                 1); 
     1204        error = ath_setup_channels(sc); 
    11821205        if (error) 
    11831206                goto bad; 
    11841207 
    11851208        /* default to STA mode */ 
    1186         sc->sc_opmode = HAL_M_MONITOR; 
     1209        sc->sc_opmode = ATH9K_M_MONITOR; 
    11871210 
    11881211        /* Setup rate tables for all potential media types. */ 
     
    12081231                goto bad2; 
    12091232        } 
    1210         sc->sc_cabq = ath_txq_setup(sc, HAL_TX_QUEUE_CAB, 0); 
     1233        sc->sc_cabq = ath_txq_setup(sc, ATH9K_TX_QUEUE_CAB, 0); 
    12111234        if (sc->sc_cabq == NULL) { 
    12121235                DPRINTF(sc, ATH_DBG_FATAL, 
     
    12241247        /* Setup data queues */ 
    12251248        /* NB: ensure BK queue is the lowest priority h/w queue */ 
    1226         if (!ath_tx_setup(sc, HAL_WME_AC_BK)) { 
     1249        if (!ath_tx_setup(sc, ATH9K_WME_AC_BK)) { 
    12271250                DPRINTF(sc, ATH_DBG_FATAL, 
    12281251                        "%s: unable to setup xmit queue for BK traffic\n", 
     
    12321255        } 
    12331256 
    1234         if (!ath_tx_setup(sc, HAL_WME_AC_BE)) { 
     1257        if (!ath_tx_setup(sc, ATH9K_WME_AC_BE)) { 
    12351258                DPRINTF(sc, ATH_DBG_FATAL, 
    12361259                        "%s: unable to setup xmit queue for BE traffic\n", 
     
    12391262                goto bad2; 
    12401263        } 
    1241         if (!ath_tx_setup(sc, HAL_WME_AC_VI)) { 
     1264        if (!ath_tx_setup(sc, ATH9K_WME_AC_VI)) { 
    12421265                DPRINTF(sc, ATH_DBG_FATAL, 
    12431266                        "%s: unable to setup xmit queue for VI traffic\n", 
     
    12461269                goto bad2; 
    12471270        } 
    1248         if (!ath_tx_setup(sc, HAL_WME_AC_VO)) { 
     1271        if (!ath_tx_setup(sc, ATH9K_WME_AC_VO)) { 
    12491272                DPRINTF(sc, ATH_DBG_FATAL, 
    12501273                        "%s: unable to setup xmit queue for VO traffic\n", 
     
    12601283        } 
    12611284 
    1262         if (ath9k_hw_getcapability(ah, HAL_CAP_CIPHER, HAL_CIPHER_TKIP, NULL)) { 
     1285        if (ath9k_hw_getcapability(ah, HAL_CAP_CIPHER, 
     1286                                   ATH9K_CIPHER_TKIP, NULL)) { 
    12631287                /* 
    12641288                 * Whether we should enable h/w TKIP MIC. 
     
    12761300         * to 27 otherwise 59. 
    12771301         */ 
    1278         if (ath9k_hw_getcapability(ah, HAL_CAP_CIPHER, HAL_CIPHER_TKIP, NULL) 
    1279             && ath9k_hw_getcapability(ah, HAL_CAP_CIPHER, HAL_CIPHER_MIC, NULL) 
    1280             && ath9k_hw_getcapability(ah, HAL_CAP_TKIP_SPLIT, 0, NULL)) 
     1302        if (ath9k_hw_getcapability(ah, HAL_CAP_CIPHER, 
     1303                                   ATH9K_CIPHER_TKIP, NULL) 
     1304            && ath9k_hw_getcapability(ah, HAL_CAP_CIPHER, 
     1305                                      ATH9K_CIPHER_MIC, NULL) 
     1306            && ath9k_hw_getcapability(ah, HAL_CAP_TKIP_SPLIT, 
     1307                                      0, NULL)) 
    12811308                sc->sc_splitmic = 1; 
    12821309 
    12831310        /* turn on mcast key search if possible */ 
    1284         if (ath9k_hw_getcapability(ah, HAL_CAP_MCAST_KEYSRCH, 0, NULL) 
    1285                                         == HAL_OK) 
     1311        if (!ath9k_hw_getcapability(ah, HAL_CAP_MCAST_KEYSRCH, 0, NULL)) 
    12861312                (void)ath9k_hw_setcapability(ah, HAL_CAP_MCAST_KEYSRCH, 1, 
    12871313                                             1, NULL); 
     
    13151341                ath9k_hw_setbssidmask(ah, sc->sc_bssidmask); 
    13161342        } 
    1317         sc->sc_slottime = HAL_SLOT_TIME_9;      /* default to short slot time */ 
     1343        sc->sc_slottime = ATH9K_SLOT_TIME_9;    /* default to short slot time */ 
    13181344 
    13191345        /* initialize beacon slots */ 
     
    13321358bad2: 
    13331359        /* cleanup tx queues */ 
    1334         for (i = 0; i < HAL_NUM_TX_QUEUES; i++) 
     1360        for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) 
    13351361                if (ATH_TXQ_SETUP(sc, i)) 
    13361362                        ath_tx_cleanupq(sc, &sc->sc_txq[i]); 
     
    13501376        ath_stop(sc); 
    13511377        if (!sc->sc_invalid) 
    1352                 ath9k_hw_setpower(sc->sc_ah, HAL_PM_AWAKE); 
     1378                ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_AWAKE); 
    13531379        ath_rate_detach(sc->sc_rc); 
    13541380        /* cleanup tx queues */ 
    1355         for (i = 0; i < HAL_NUM_TX_QUEUES; i++) 
     1381        for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) 
    13561382                if (ATH_TXQ_SETUP(sc, i)) 
    13571383                        ath_tx_cleanupq(sc, &sc->sc_txq[i]); 
     
    14891515/**************/ 
    14901516 
    1491 void ath_key_reset(struct ath_softc *sc, u_int16_t keyix, int freeslot) 
     1517void ath_key_reset(struct ath_softc *sc, u16 keyix, int freeslot) 
    14921518{ 
    14931519        ath9k_hw_keyreset(sc->sc_ah, keyix); 
     
    14971523 
    14981524int ath_keyset(struct ath_softc *sc, 
    1499                u_int16_t keyix, 
    1500                struct hal_keyval *hk, 
    1501                const u_int8_t mac[ETH_ALEN]) 
     1525               u16 keyix, 
     1526               struct ath9k_keyval *hk, 
     1527               const u8 mac[ETH_ALEN]) 
    15021528{ 
    15031529        bool status; 
     
    15231549{ 
    15241550        struct ath_hal *ah = sc->sc_ah; 
    1525         u_int32_t txpow; 
     1551        u32 txpow; 
    15261552 
    15271553        if (sc->sc_curtxpow != sc->sc_config.txpowlimit) { 
     
    15351561/* Return the current country and domain information */ 
    15361562void ath_get_currentCountry(struct ath_softc *sc, 
    1537         struct hal_country_entry *ctry) 
     1563        struct ath9k_country_entry *ctry) 
    15381564{ 
    15391565        ath9k_regd_get_current_country(sc->sc_ah, ctry); 
     
    15731599 
    15741600void ath_slow_ant_div_start(struct ath_antdiv *antdiv, 
    1575                             u_int8_t num_antcfg, 
    1576                             const u_int8_t *bssid) 
     1601                            u8 num_antcfg, 
     1602                            const u8 *bssid) 
    15771603{ 
    15781604        antdiv->antdiv_num_antcfg = 
     
    15951621 
    15961622static int32_t ath_find_max_val(int32_t *val, 
    1597         u_int8_t num_val, u_int8_t *max_index) 
    1598 { 
    1599         u_int32_t MaxVal = *val++; 
    1600         u_int32_t cur_index = 0; 
     1623        u8 num_val, u8 *max_index) 
     1624{ 
     1625        u32 MaxVal = *val++; 
     1626        u32 cur_index = 0; 
    16011627 
    16021628        *max_index = 0; 
     
    16191645        struct ath_softc *sc = antdiv->antdiv_sc; 
    16201646        struct ath_hal *ah = sc->sc_ah; 
    1621         u_int64_t curtsf = 0; 
    1622         u_int8_t bestcfg, curcfg = antdiv->antdiv_curcfg; 
     1647        u64 curtsf = 0; 
     1648        u8 bestcfg, curcfg = antdiv->antdiv_curcfg; 
    16231649        __le16 fc = hdr->frame_control; 
    16241650 
     
    16431669                                curcfg = 0; 
    16441670 
    1645                         if (HAL_OK == ath9k_hw_select_antconfig(ah, curcfg)) { 
     1671                        if (!ath9k_hw_select_antconfig(ah, curcfg)) { 
    16461672                                antdiv->antdiv_bestcfg = antdiv->antdiv_curcfg; 
    16471673                                antdiv->antdiv_curcfg = curcfg; 
     
    16641690                        ath_find_max_val(antdiv->antdiv_lastbrssi, 
    16651691                                   antdiv->antdiv_num_antcfg, &bestcfg); 
    1666                         if (HAL_OK == ath9k_hw_select_antconfig(ah, bestcfg)) { 
     1692                        if (!ath9k_hw_select_antconfig(ah, bestcfg)) { 
    16671693                                antdiv->antdiv_bestcfg = bestcfg; 
    16681694                                antdiv->antdiv_curcfg = bestcfg; 
     
    16711697                        } 
    16721698                } else { 
    1673                         if (HAL_OK == ath9k_hw_select_antconfig(ah, curcfg)) { 
     1699                        if (!ath9k_hw_select_antconfig(ah, curcfg)) { 
    16741700                                antdiv->antdiv_curcfg = curcfg; 
    16751701                                antdiv->antdiv_laststatetsf = curtsf; 
     
    17311757         */ 
    17321758        if (!(sc->sc_ah->ah_caps.hal4kbSplitTransSupport)) { 
    1733                 u_int32_t ndesc_skipped = 
     1759                u32 ndesc_skipped = 
    17341760                        ATH_DESC_4KB_BOUND_NUM_SKIPPED(dd->dd_desc_len); 
    1735                 u_int32_t dma_len; 
     1761                u32 dma_len; 
    17361762 
    17371763                while (ndesc_skipped) { 
     
    17531779        ds = dd->dd_desc; 
    17541780        DPRINTF(sc, ATH_DBG_CONFIG, "%s: %s DMA map: %p (%u) -> %llx (%u)\n", 
    1755                 __func__, dd->dd_name, ds, (u_int32_t) dd->dd_desc_len, 
    1756                 ito64(dd->dd_desc_paddr), /*XXX*/(u_int32_t) dd->dd_desc_len); 
     1781                __func__, dd->dd_name, ds, (u32) dd->dd_desc_len, 
     1782                ito64(dd->dd_desc_paddr), /*XXX*/(u32) dd->dd_desc_len); 
    17571783 
    17581784        /* allocate buffers */ 
     
    18391865        switch (queue) { 
    18401866        case 0: 
    1841                 qnum = sc->sc_haltype2q[HAL_WME_AC_VO]; 
     1867                qnum = sc->sc_haltype2q[ATH9K_WME_AC_VO]; 
    18421868                break; 
    18431869        case 1: 
    1844                 qnum = sc->sc_haltype2q[HAL_WME_AC_VI]; 
     1870                qnum = sc->sc_haltype2q[ATH9K_WME_AC_VI]; 
    18451871                break; 
    18461872        case 2: 
    1847                 qnum = sc->sc_haltype2q[HAL_WME_AC_BE]; 
     1873                qnum = sc->sc_haltype2q[ATH9K_WME_AC_BE]; 
    18481874                break; 
    18491875        case 3: 
    1850                 qnum = sc->sc_haltype2q[HAL_WME_AC_BK]; 
     1876                qnum = sc->sc_haltype2q[ATH9K_WME_AC_BK]; 
    18511877                break; 
    18521878        default: 
    1853                 qnum = sc->sc_haltype2q[HAL_WME_AC_BE]; 
     1879                qnum = sc->sc_haltype2q[ATH9K_WME_AC_BE]; 
    18541880                break; 
    18551881        } 
     
    18581884} 
    18591885 
    1860 int ath_get_mac80211_qnum(u_int queue, struct ath_softc *sc) 
     1886int ath_get_mac80211_qnum(u32 queue, struct ath_softc *sc) 
    18611887{ 
    18621888        int qnum; 
    18631889 
    18641890        switch (queue) { 
    1865         case HAL_WME_AC_VO: 
     1891        case ATH9K_WME_AC_VO: 
    18661892                qnum = 0; 
    18671893                break; 
    1868         case HAL_WME_AC_VI: 
     1894        case ATH9K_WME_AC_VI: 
    18691895                qnum = 1; 
    18701896                break; 
    1871         case HAL_WME_AC_BE: 
     1897        case ATH9K_WME_AC_BE: 
    18721898                qnum = 2; 
    18731899                break; 
    1874         case HAL_WME_AC_BK: 
     1900        case ATH9K_WME_AC_BK: 
    18751901                qnum = 3; 
    18761902                break; 
     
    18911917*/ 
    18921918 
    1893 u_int64_t ath_extend_tsf(struct ath_softc *sc, u_int32_t rstamp) 
    1894 { 
    1895         u_int64_t tsf; 
     1919u64 ath_extend_tsf(struct ath_softc *sc, u32 rstamp) 
     1920{ 
     1921        u64 tsf; 
    18961922 
    18971923        tsf = ath9k_hw_gettsf64(sc->sc_ah); 
     
    19081934*/ 
    19091935 
    1910 void ath_setdefantenna(void *context, u_int antenna) 
     1936void ath_setdefantenna(void *context, u32 antenna) 
    19111937{ 
    19121938        struct ath_softc *sc = (struct ath_softc *)context; 
  • trunk/package/ath9k/src/drivers/net/wireless/ath9k/core.h

    r12038 r12079  
    214214 * for Atheros Device */ 
    215215struct ath_config { 
    216         u_int32_t   ath_aggr_prot; 
    217         u_int16_t   txpowlimit; 
    218         u_int16_t   txpowlimit_override; 
    219         u_int8_t    cabqReadytime; /* Cabq Readytime % */ 
    220         u_int8_t    swBeaconProcess; /* Process received beacons 
     216        u32   ath_aggr_prot; 
     217        u16   txpowlimit; 
     218        u16   txpowlimit_override; 
     219        u8    cabqReadytime; /* Cabq Readytime % */ 
     220        u8    swBeaconProcess; /* Process received beacons 
    221221                                        in SW (vs HW) */ 
    222222}; 
     
    270270struct ath_buf_state { 
    271271        int bfs_nframes;        /* # frames in aggregate */ 
    272         u_int16_t bfs_al;       /* length of aggregate */ 
    273         u_int16_t bfs_frmlen;   /* length of frame */ 
     272        u16 bfs_al;     /* length of aggregate */ 
     273        u16 bfs_frmlen; /* length of frame */ 
    274274        int bfs_seqno;          /* sequence number */ 
    275275        int bfs_tidno;          /* tid of this frame */ 
     
    290290        int bfs_rifsburst_elem; /* RIFS burst/bar */ 
    291291        int bfs_nrifsubframes;  /* # of elements in burst */ 
    292         enum hal_key_type bfs_keytype;  /* key type use to encrypt this frame */ 
     292        /* key type use to encrypt this frame */ 
     293        enum ath9k_key_type bfs_keytype; 
    293294}; 
    294295 
     
    333334        dma_addr_t bf_daddr;            /* physical addr of desc */ 
    334335        dma_addr_t bf_buf_addr;         /* physical addr of data buffer */ 
    335         u_int32_t bf_status; 
    336         u_int16_t bf_flags;             /* tx descriptor flags */ 
     336        u32 bf_status; 
     337        u16 bf_flags;           /* tx descriptor flags */ 
    337338        struct ath_buf_state bf_state;  /* buffer state */ 
    338339        dma_addr_t bf_dmacontext; 
     
    361362        struct ath_desc *dd_desc;       /* descriptors  */ 
    362363        dma_addr_t dd_desc_paddr;       /* physical addr of dd_desc  */ 
    363         u_int32_t dd_desc_len;          /* size of dd_desc  */ 
     364        u32 dd_desc_len;                /* size of dd_desc  */ 
    364365        struct ath_buf *dd_bufptr;      /* associated buffers */ 
    365366        dma_addr_t dd_dmacontext; 
     
    403404/* per frame rx status block */ 
    404405struct ath_recv_status { 
    405         u_int64_t tsf;          /* mac tsf */ 
     406        u64 tsf;                /* mac tsf */ 
    406407        int8_t rssi;            /* RSSI (noise floor ajusted) */ 
    407408        int8_t rssictl[ATH_MAX_ANTENNA];        /* RSSI (noise floor ajusted) */ 
    408409        int8_t rssiextn[ATH_MAX_ANTENNA];       /* RSSI (noise floor ajusted) */ 
    409410        int8_t abs_rssi;        /* absolute RSSI */ 
    410         u_int8_t rateieee;      /* data rate received (IEEE rate code) */ 
    411         u_int8_t ratecode;      /* phy rate code */ 
     411        u8 rateieee;    /* data rate received (IEEE rate code) */ 
     412        u8 ratecode;    /* phy rate code */ 
    412413        int rateKbps;           /* data rate received (Kbps) */ 
    413414        int antenna;            /* rx antenna */ 
     
    443444        int                 seq_reset;  /* need to reset start sequence */ 
    444445        int                 addba_exchangecomplete; 
    445         u_int16_t           seq_next;   /* next expected sequence */ 
    446         u_int16_t           baw_size;   /* block-ack window size */ 
     446        u16           seq_next;   /* next expected sequence */ 
     447        u16           baw_size;   /* block-ack window size */ 
    447448}; 
    448449 
     
    455456bool ath_stoprecv(struct ath_softc *sc); 
    456457void ath_flushrecv(struct ath_softc *sc); 
    457 u_int32_t ath_calcrxfilter(struct ath_softc *sc); 
     458u32 ath_calcrxfilter(struct ath_softc *sc); 
    458459void ath_rx_node_init(struct ath_softc *sc, struct ath_node *an); 
    459460void ath_rx_node_free(struct ath_softc *sc, struct ath_node *an); 
     
    472473                    struct sk_buff *skb, 
    473474                    struct ath_recv_status *status, 
    474                     u_int16_t keyix); 
     475                    u16 keyix); 
    475476int ath_rx_subframe(struct ath_node *an, struct sk_buff *skb, 
    476477                    struct ath_recv_status *status); 
     
    521522 */ 
    522523struct ath_txq { 
    523         u_int                   axq_qnum;       /* hardware q number */ 
    524         u_int32_t               *axq_link;      /* link ptr in last TX desc */ 
     524        u32                     axq_qnum;       /* hardware q number */ 
     525        u32             *axq_link;      /* link ptr in last TX desc */ 
    525526        struct list_head        axq_q;          /* transmit queue */ 
    526527        spinlock_t              axq_lock;       /* lock on q and link */ 
    527528        unsigned long           axq_lockflags;  /* intr state when must cli */ 
    528         u_int                   axq_depth;      /* queue depth */ 
    529         u_int8_t                axq_aggr_depth; /* aggregates queued */ 
    530         u_int32_t               axq_totalqueued;/* total ever queued */ 
    531         u_int                   axq_intrcnt;    /* count to determine 
     529        u32                     axq_depth;      /* queue depth */ 
     530        u8                axq_aggr_depth; /* aggregates queued */ 
     531        u32             axq_totalqueued;/* total ever queued */ 
     532        u32                     axq_intrcnt;    /* count to determine 
    532533                                                if descriptor should generate 
    533534                                                int on this txq. */ 
     
    551552        struct ath_atx_ac       *ac;        /* parent access category */ 
    552553        struct ath_buf          *tx_buf[ATH_TID_MAX_BUFS];/* active tx frames */ 
    553         u_int16_t               seq_start;  /* starting seq of BA window */ 
    554         u_int16_t               seq_next;   /* next seq to be used */ 
    555         u_int16_t               baw_size;   /* BA window size */ 
     554        u16               seq_start;  /* starting seq of BA window */ 
     555        u16               seq_next;   /* next seq to be used */ 
     556        u16               baw_size;   /* BA window size */ 
    556557        int                     tidno;      /* TID number */ 
    557558        int                     baw_head;   /* first un-acked tx buffer */ 
     
    561562        int                     cleanup_inprogress; /* aggr of this TID is 
    562563                                                being teared down */ 
    563         u_int32_t               addba_exchangecomplete:1; /* ADDBA state */ 
     564        u32               addba_exchangecomplete:1; /* ADDBA state */ 
    564565        int32_t                 addba_exchangeinprogress; 
    565566        int                     addba_exchangeattempts; 
     
    586587        int if_id;              /* only valid for cab traffic */ 
    587588        int qnum;               /* h/w queue number */ 
    588         u_int ht:1;             /* if it can be transmitted using HT */ 
    589         u_int ps:1;             /* if one or more stations are in PS mode */ 
    590         u_int use_minrate:1;    /* if this frame should transmitted using 
     589        u32 ht:1;             /* if it can be transmitted using HT */ 
     590        u32 ps:1;             /* if one or more stations are in PS mode */ 
     591        u32 use_minrate:1;      /* if this frame should transmitted using 
    591592                                minimum rate */ 
    592         enum hal_pkt_type atype;        /* Atheros packet type */ 
    593         enum hal_key_type keytype;      /* key type */ 
    594         u_int flags;            /* HAL flags */ 
    595         u_int16_t seqno;        /* sequence number */ 
    596         u_int16_t tidno;        /* tid number */ 
    597         u_int16_t txpower;      /* transmit power */ 
    598         u_int16_t frmlen;       /* frame length */ 
    599         u_int32_t keyix;        /* key index */ 
     593        enum ath9k_pkt_type atype;      /* Atheros packet type */ 
     594        enum ath9k_key_type keytype;    /* key type */ 
     595        u32 flags;              /* HAL flags */ 
     596        u16 seqno;      /* sequence number */ 
     597        u16 tidno;      /* tid number */ 
     598        u16 txpower;    /* transmit power */ 
     599        u16 frmlen;       /* frame length */ 
     600        u32 keyix;        /* key index */ 
    600601        int min_rate;           /* minimum rate */ 
    601602        int mcast_rate;         /* multicast rate */ 
    602         u_int16_t nextfraglen;  /* next fragment length */ 
     603        u16 nextfraglen;        /* next fragment length */ 
    603604        /* below is set only by ath_dev */ 
    604605        struct ath_softc *dev;  /* device handle */ 
     
    628629/* if extn chain rssis are valid */ 
    629630#define ATH_TX_RSSI_EXTN_VALID  0x02 
    630         u_int32_t airtime;      /* time on air per final tx rate */ 
     631        u32 airtime;    /* time on air per final tx rate */ 
    631632}; 
    632633 
     
    645646int ath_tx_cleanup(struct ath_softc *sc); 
    646647int ath_tx_get_qnum(struct ath_softc *sc, int qtype, int haltype); 
    647 int ath_txq_update(struct ath_softc *sc, int qnum, struct hal_txq_info *q); 
     648int ath_txq_update(struct ath_softc *sc, int qnum, struct ath9k_txq_info *q); 
    648649int ath_tx_start(struct ath_softc *sc, struct sk_buff *skb); 
    649650void ath_tx_tasklet(struct ath_softc *sc); 
    650 u_int32_t ath_txq_depth(struct ath_softc *sc, int qnum); 
    651 u_int32_t ath_txq_aggr_depth(struct ath_softc *sc, int qnum); 
    652 void ath_notify_txq_status(struct ath_softc *sc, u_int16_t queue_depth); 
     651u32 ath_txq_depth(struct ath_softc *sc, int qnum); 
     652u32 ath_txq_aggr_depth(struct ath_softc *sc, int qnum); 
     653void ath_notify_txq_status(struct ath_softc *sc, u16 queue_depth); 
    653654void ath_tx_complete(struct ath_softc *sc, struct sk_buff *skb, 
    654655                     struct ath_xmit_status *tx_status, struct ath_node *an); 
     
    734735        struct ath_chainmask_sel an_chainmask_sel; 
    735736        struct ath_node_aggr    an_aggr; /* A-MPDU aggregation state */ 
    736         u_int8_t                an_smmode; /* SM Power save mode */ 
    737         u_int8_t                an_flags; 
     737        u8              an_smmode; /* SM Power save mode */ 
     738        u8              an_flags; 
    738739        u8                      an_addr[ETH_ALEN]; 
    739740}; 
     
    744745        struct ath_node *an, u8 tidno); 
    745746void ath_tx_aggr_teardown(struct ath_softc *sc, 
    746         struct ath_node *an, u_int8_t tidno); 
     747        struct ath_node *an, u8 tidno); 
    747748void ath_rx_aggr_teardown(struct ath_softc *sc, 
    748         struct ath_node *an, u_int8_t tidno); 
     749        struct ath_node *an, u8 tidno); 
    749750int ath_rx_aggr_start(struct ath_softc *sc, 
    750751                      const u8 *addr, 
     
    764765        struct ath_node *node, int isnew, int isuapsd); 
    765766struct ath_node *ath_node_attach(struct ath_softc *sc, 
    766         u_int8_t addr[ETH_ALEN], int if_id); 
     767        u8 addr[ETH_ALEN], int if_id); 
    767768void ath_node_detach(struct ath_softc *sc, struct ath_node *an, bool bh_flag); 
    768 struct ath_node *ath_node_get(struct ath_softc *sc, u_int8_t addr[ETH_ALEN]); 
     769struct ath_node *ath_node_get(struct ath_softc *sc, u8 addr[ETH_ALEN]); 
    769770void ath_node_put(struct ath_softc *sc, struct ath_node *an, bool bh_flag); 
    770 struct ath_node *ath_node_find(struct ath_softc *sc, u_int8_t *addr); 
     771struct ath_node *ath_node_find(struct ath_softc *sc, u8 *addr); 
    771772 
    772773/*******************/ 
     
    790791/* beacon configuration */ 
    791792struct ath_beacon_config { 
    792         u_int16_t beacon_interval; 
    793         u_int16_t listen_interval; 
    794         u_int16_t dtim_period; 
    795         u_int16_t bmiss_timeout; 
    796         u_int8_t dtim_count; 
    797         u_int8_t tim_offset; 
     793        u16 beacon_interval; 
     794        u16 listen_interval; 
     795        u16 dtim_period; 
     796        u16 bmiss_timeout; 
     797        u8 dtim_count; 
     798        u8 tim_offset; 
    798799        union { 
    799                 u_int64_t last_tsf; 
    800                 u_int8_t last_tstamp[8]; 
     800                u64 last_tsf; 
     801                u8 last_tstamp[8]; 
    801802        } u; /* last received beacon/probe response timestamp of this BSS. */ 
    802803}; 
     
    805806 * quick acess of beacon content by low-level driver */ 
    806807struct ath_beacon_offset { 
    807         u_int8_t *bo_tim;       /* start of atim/dtim */ 
     808        u8 *bo_tim;     /* start of atim/dtim */ 
    808809}; 
    809810 
     
    852853/* VAP configuration (from protocol layer) */ 
    853854struct ath_vap_config { 
    854         u_int32_t av_fixed_rateset; 
    855         u_int32_t av_fixed_retryset; 
     855        u32 av_fixed_rateset; 
     856        u32 av_fixed_retryset; 
    856857}; 
    857858 
     
    860861        struct ieee80211_vif            *av_if_data; /* interface(vap) 
    861862                                instance from 802.11 protocal layer */ 
    862         enum hal_opmode                 av_opmode;  /* VAP operational mode */ 
     863        enum ath9k_opmode                 av_opmode;  /* VAP operational mode */ 
    863864        struct ath_buf                  *av_bcbuf;  /* beacon buffer */ 
    864865        struct ath_beacon_offset        av_boff;    /* dynamic update state */ 
     
    870871        struct ath_vap_config           av_config;  /* vap configuration 
    871872                                        parameters from 802.11 protocol layer*/ 
     873        struct ath_rate_node            *rc_node; 
    872874}; 
    873875 
     
    875877                   int if_id, 
    876878                   struct ieee80211_vif *if_data, 
    877                    enum hal_opmode opmode); 
     879                   enum ath9k_opmode opmode); 
    878880int ath_vap_detach(struct ath_softc *sc, int if_id); 
    879881int ath_vap_config(struct ath_softc *sc, 
     
    896898struct ath_antdiv { 
    897899        struct ath_softc *antdiv_sc; 
    898         u_int8_t antdiv_start; 
     900        u8 antdiv_start; 
    899901        enum ATH_ANT_DIV_STATE antdiv_state; 
    900         u_int8_t antdiv_num_antcfg; 
    901         u_int8_t antdiv_curcfg; 
    902         u_int8_t antdiv_bestcfg; 
     902        u8 antdiv_num_antcfg; 
     903        u8 antdiv_curcfg; 
     904        u8 antdiv_bestcfg; 
    903905        int32_t antdivf_rssitrig; 
    904906        int32_t antdiv_lastbrssi[ATH_ANT_DIV_MAX_CFG]; 
    905         u_int64_t antdiv_lastbtsf[ATH_ANT_DIV_MAX_CFG]; 
    906         u_int64_t antdiv_laststatetsf; 
    907         u_int8_t antdiv_bssid[ETH_ALEN]; 
     907        u64 antdiv_lastbtsf[ATH_ANT_DIV_MAX_CFG]; 
     908        u64 antdiv_laststatetsf; 
     909        u8 antdiv_bssid[ETH_ALEN]; 
    908910}; 
    909911 
     
    911913        struct ath_softc *sc, int32_t rssitrig); 
    912914void ath_slow_ant_div_start(struct ath_antdiv *antdiv, 
    913                             u_int8_t num_antcfg, 
    914                             const u_int8_t *bssid); 
     915                            u8 num_antcfg, 
     916                            const u8 *bssid); 
    915917void ath_slow_ant_div_stop(struct ath_antdiv *antdiv); 
    916918void ath_slow_ant_div(struct ath_antdiv *antdiv, 
    917919                      struct ieee80211_hdr *wh, 
    918920                      struct ath_rx_status *rx_stats); 
    919 void ath_setdefantenna(void *sc, u_int antenna); 
     921void ath_setdefantenna(void *sc, u32 antenna); 
    920922 
    921923/********************/ 
     
    948950 */ 
    949951#define ATH_KEYMAX              128        /* max key cache size we handle */ 
    950 #define ATH_KEYBYTES            (ATH_KEYMAX/NBBY) /* storage space in bytes */ 
    951952 
    952953#define RESET_RETRY_TXQ         0x00000001 
     
    985986}; 
    986987 
    987 enum ieee80211_clist_cmd { 
    988         CLIST_UPDATE, 
    989         CLIST_DFS_UPDATE, 
    990         CLIST_NEW_COUNTRY 
    991 }; 
    992  
    993988enum RATE_TYPE { 
    994989        NORMAL_RATE = 0, 
     
    998993 
    999994struct ath_ht_info { 
    1000         enum hal_ht_macmode tx_chan_width; 
    1001         u_int16_t maxampdu; 
    1002         u_int8_t mpdudensity; 
    1003         u_int8_t ext_chan_offset; 
     995        enum ath9k_ht_macmode tx_chan_width; 
     996        u16 maxampdu; 
     997        u8 mpdudensity; 
     998        u8 ext_chan_offset; 
    1004999}; 
    10051000 
     
    10151010        struct ath_hal          *sc_ah;     /* HAL Instance */ 
    10161011        struct ath_rate_softc    *sc_rc;     /* tx rate control support */ 
    1017         u_int32_t               sc_intrstatus; /* HAL_STATUS */ 
    1018         enum hal_opmode         sc_opmode;  /* current operating mode */ 
     1012        u32               sc_intrstatus; /* HAL_STATUS */ 
     1013        enum ath9k_opmode         sc_opmode;  /* current operating mode */ 
    10191014 
    10201015        /* Properties, Config */ 
    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 */ 
     1016        u8                sc_invalid;   /* being detached */ 
     1017        u8                sc_beacons;   /* beacons running */ 
     1018        u8                sc_scanning;  /* scanning active */ 
     1019        u8                sc_txaggr;    /* enable 11n tx aggregation */ 
     1020        u8                sc_rxaggr;    /* enable 11n rx aggregation */ 
     1021        u8                sc_update_chainmask;  /* change chain mask */ 
     1022        u8                sc_full_reset;                /* force full reset */ 
    10281023        enum wireless_mode      sc_curmode;     /* current phy mode */ 
    1029         u_int16_t               sc_curtxpow;    /* current tx power limit */ 
    1030         u_int16_t               sc_curaid;      /* current association id */ 
    1031         u_int8_t                sc_curbssid[ETH_ALEN]; 
    1032         u_int8_t                sc_myaddr[ETH_ALEN]; 
     1024        u16               sc_curtxpow;    /* current tx power limit */ 
     1025        u16               sc_curaid;      /* current association id */ 
     1026        u8                sc_curbssid[ETH_ALEN]; 
     1027        u8                sc_myaddr[ETH_ALEN]; 
    10331028        enum PROT_MODE          sc_protmode;    /* protection mode */ 
    1034         u_int8_t                sc_mcastantenna;/* Multicast antenna number */ 
    1035         u_int8_t                sc_txantenna;   /* data tx antenna 
     1029        u8                sc_mcastantenna;/* Multicast antenna number */ 
     1030        u8                sc_txantenna;   /* data tx antenna 
    10361031                                                (fixed or auto) */ 
    1037         u_int8_t                sc_nbcnvaps;    /* # of vaps sending beacons */ 
    1038         u_int16_t               sc_nvaps;       /* # of active virtual ap's */ 
     1032        u8                sc_nbcnvaps;    /* # of vaps sending beacons */ 
     1033        u16               sc_nvaps;       /* # of active virtual ap's */ 
    10391034        struct ath_vap          *sc_vaps[ATH_BCBUF]; /* interface id 
    10401035                                                to avp map */ 
    1041         enum hal_int            sc_imask;       /* interrupt mask copy */ 
    1042         u_int8_t                sc_bssidmask[ETH_ALEN]; 
    1043         u_int8_t                sc_defant;      /* current default antenna */ 
    1044         u_int8_t                sc_rxotherant;  /* rx's on non-default antenna*/ 
    1045         u_int16_t               sc_cachelsz;    /* cache line size */ 
     1036        enum ath9k_int            sc_imask;       /* interrupt mask copy */ 
     1037        u8                sc_bssidmask[ETH_ALEN]; 
     1038        u8                sc_defant;      /* current default antenna */ 
     1039        u8                sc_rxotherant;  /* rx's on non-default antenna*/ 
     1040        u16               sc_cachelsz;    /* cache line size */ 
    10461041        int                     sc_slotupdate;  /* slot to next advance fsm */ 
    10471042        int                     sc_slottime;    /* slot time */ 
    1048         u_int8_t                sc_noreset; 
     1043        u8                sc_noreset; 
    10491044        int                     sc_bslot[ATH_BCBUF];/* beacon xmit slots */ 
    1050         struct hal_node_stats   sc_halstats;    /* station-mode rssi stats */ 
     1045        struct ath9k_node_stats   sc_halstats;    /* station-mode rssi stats */ 
    10511046        struct list_head        node_list; 
    10521047        struct ath_ht_info      sc_ht_info; 
    10531048        int16_t                 sc_noise_floor; /* signal noise floor in dBm */ 
    1054         enum hal_ht_extprotspacing   sc_ht_extprotspacing; 
    1055         u_int8_t                sc_tx_chainmask; 
    1056         u_int8_t                sc_rx_chainmask; 
    1057         u_int8_t                sc_rxchaindetect_ref; 
    1058         u_int8_t                sc_rxchaindetect_thresh5GHz; 
    1059         u_int8_t                sc_rxchaindetect_thresh2GHz; 
    1060         u_int8_t                sc_rxchaindetect_delta5GHz; 
    1061         u_int8_t                sc_rxchaindetect_delta2GHz; 
    1062         u_int32_t               sc_rtsaggrlimit; /* Chipset specific 
     1049        enum ath9k_ht_extprotspacing   sc_ht_extprotspacing; 
     1050        u8                sc_tx_chainmask; 
     1051        u8                sc_rx_chainmask; 
     1052        u8                sc_rxchaindetect_ref; 
     1053        u8                sc_rxchaindetect_thresh5GHz; 
     1054        u8                sc_rxchaindetect_thresh2GHz; 
     1055        u8                sc_rxchaindetect_delta5GHz; 
     1056        u8                sc_rxchaindetect_delta2GHz; 
     1057        u32               sc_rtsaggrlimit; /* Chipset specific 
    10631058                                                aggr limit */ 
    10641059        u32                     sc_flags; 
     
    10741069 
    10751070        /* Crypto */ 
    1076         u_int                   sc_keymax;      /* size of key cache */ 
    1077         DECLARE_BITMAP          (sc_keymap, ATH_KEYBYTES);/* key use bit map */ 
    1078         u_int8_t                sc_splitmic;    /* split TKIP MIC keys */ 
     1071        u32                   sc_keymax;      /* size of key cache */ 
     1072        DECLARE_BITMAP          (sc_keymap, ATH_KEYMAX);/* key use bit map */ 
     1073        u8              sc_splitmic;    /* split TKIP MIC keys */ 
    10791074        int                     sc_keytype;     /* type of the key being used */ 
    10801075 
     
    10831078        struct ath_descdma      sc_rxdma;       /* RX descriptors */ 
    10841079        int                     sc_rxbufsize;   /* rx size based on mtu */ 
    1085         u_int32_t               *sc_rxlink;     /* link ptr in last RX desc */ 
    1086         u_int32_t               sc_rxflush;     /* rx flush in progress */ 
    1087         u_int64_t               sc_lastrx;      /* tsf of last rx'd frame */ 
     1080        u32               *sc_rxlink;     /* link ptr in last RX desc */ 
     1081        u32               sc_rxflush;     /* rx flush in progress */ 
     1082        u64               sc_lastrx;      /* tsf of last rx'd frame */ 
    10881083 
    10891084        /* TX */ 
    10901085        struct list_head        sc_txbuf;       /* transmit buffer */ 
    1091         struct ath_txq          sc_txq[HAL_NUM_TX_QUEUES]; 
     1086        struct ath_txq          sc_txq[ATH9K_NUM_TX_QUEUES]; 
    10921087        struct ath_descdma      sc_txdma;       /* TX descriptors */ 
    1093         u_int                   sc_txqsetup;    /* h/w queues setup */ 
    1094         u_int                   sc_txintrperiod;/* tx interrupt batching */ 
    1095         int                     sc_haltype2q[HAL_WME_AC_VO+1]; /* HAL WME 
     1088        u32                   sc_txqsetup;    /* h/w queues setup */ 
     1089        u32                   sc_txintrperiod;/* tx interrupt batching */ 
     1090        int                     sc_haltype2q[ATH9K_WME_AC_VO+1]; /* HAL WME 
    10961091                                                        AC -> h/w qnum */ 
    1097         u_int32_t               sc_ant_tx[8];   /* recent tx frames/antenna */ 
     1092        u32               sc_ant_tx[8];   /* recent tx frames/antenna */ 
    10981093 
    10991094        /* Beacon */ 
    1100         struct hal_txq_info     sc_beacon_qi;   /* adhoc only: beacon 
     1095        struct ath9k_txq_info     sc_beacon_qi;   /* adhoc only: beacon 
    11011096                                                queue parameters */ 
    11021097        struct ath_descdma      sc_bdma;        /* beacon descriptors */ 
    11031098        struct ath_txq          *sc_cabq;       /* tx q for cab frames */ 
    11041099        struct list_head        sc_bbuf;        /* beacon buffers */ 
    1105         u_int                   sc_bhalq;       /* HAL q for outgoing beacons */ 
    1106         u_int                   sc_bmisscount;  /* missed beacon transmits */ 
    1107         u_int32_t               ast_be_xmit; /* beacons transmitted */ 
     1100        u32                   sc_bhalq;       /* HAL q for outgoing beacons */ 
     1101        u32                   sc_bmisscount;  /* missed beacon transmits */ 
     1102        u32               ast_be_xmit; /* beacons transmitted */ 
    11081103 
    11091104        /* Rate */ 
    11101105        struct ieee80211_rate          rates[IEEE80211_NUM_BANDS][ATH_RATE_MAX]; 
    1111         const struct hal_rate_table    *sc_rates[WIRELESS_MODE_MAX]; 
    1112         const struct hal_rate_table    *sc_currates;  /* current rate table */ 
    1113         u_int8_t                       sc_rixmap[256]; /* IEEE to h/w 
     1106        const struct ath9k_rate_table    *sc_rates[WIRELESS_MODE_MAX]; 
     1107        const struct ath9k_rate_table    *sc_currates; /* current rate table */ 
     1108        u8                       sc_rixmap[256]; /* IEEE to h/w 
    11141109                                                rate table ix */ 
    1115         u_int8_t                       sc_minrateix;   /* min h/w rate index */ 
    1116         u_int8_t                       sc_protrix; /* protection rate index */ 
     1110        u8                       sc_minrateix;   /* min h/w rate index */ 
     1111        u8                       sc_protrix; /* protection rate index */ 
    11171112        struct { 
    1118                 u_int32_t rateKbps;      /* transfer rate in kbs */ 
    1119                 u_int8_t ieeerate;       /* IEEE rate */ 
     1113                u32 rateKbps;      /* transfer rate in kbs */ 
     1114                u8 ieeerate;       /* IEEE rate */ 
    11201115        } sc_hwmap[256];         /* h/w rate ix mappings */ 
    11211116 
     
    11231118        struct ieee80211_channel channels[IEEE80211_NUM_BANDS][ATH_CHAN_MAX]; 
    11241119        struct ieee80211_supported_band sbands[IEEE80211_NUM_BANDS]; 
    1125         struct hal_channel              sc_curchan; /* current h/w channel */ 
     1120        struct ath9k_channel            sc_curchan; /* current h/w channel */ 
    11261121 
    11271122        /* Locks */ 
     
    11331128}; 
    11341129 
    1135 int ath_init(u_int16_t devid, struct ath_softc *sc); 
     1130int ath_init(u16 devid, struct ath_softc *sc); 
    11361131void ath_deinit(struct ath_softc *sc); 
    1137 int ath_open(struct ath_softc *sc, struct hal_channel *initial_chan); 
     1132int ath_open(struct ath_softc *sc, struct ath9k_channel *initial_chan); 
    11381133int ath_suspend(struct ath_softc *sc); 
    11391134irqreturn_t ath_isr(int irq, void *dev); 
     
    11411136void ath_scan_start(struct ath_softc *sc); 
    11421137void ath_scan_end(struct ath_softc *sc); 
    1143 int ath_set_channel(struct ath_softc *sc, struct hal_channel *hchan); 
    1144 void ath_setup_channel_list(struct ath_softc *sc, 
    1145                             enum ieee80211_clist_cmd cmd, 
    1146                             const struct hal_channel *chans, 
    1147                             int nchan, 
    1148                             const u_int8_t *regclassids, 
    1149                             u_int nregclass, 
    1150                             int countrycode); 
     1138int ath_set_channel(struct ath_softc *sc, struct ath9k_channel *hchan); 
    11511139void ath_setup_rate(struct ath_softc *sc, 
    11521140                    enum wireless_mode wMode, 
    11531141                    enum RATE_TYPE type, 
    1154                     const struct hal_rate_table *rt); 
     1142                    const struct ath9k_rate_table *rt); 
    11551143 
    11561144/*********************/ 
     
    11581146/*********************/ 
    11591147 
    1160 void ath_key_reset(struct ath_softc *sc, u_int16_t keyix, int freeslot); 
     1148void ath_key_reset(struct ath_softc *sc, u16 keyix, int freeslot); 
    11611149int ath_keyset(struct ath_softc *sc, 
    1162                u_int16_t keyix, 
    1163                struct hal_keyval *hk, 
    1164                const u_int8_t mac[ETH_ALEN]); 
     1150               u16 keyix, 
     1151               struct ath9k_keyval *hk, 
     1152               const u8 mac[ETH_ALEN]); 
    11651153int ath_get_hal_qnum(u16 queue, struct ath_softc *sc); 
    1166 int ath_get_mac80211_qnum(u_int queue, struct ath_softc *sc); 
     1154int ath_get_mac80211_qnum(u32 queue, struct ath_softc *sc); 
    11671155void ath_setslottime(struct ath_softc *sc); 
    11681156void ath_update_txpow(struct ath_softc *sc); 
    11691157int ath_cabq_update(struct ath_softc *); 
    11701158void ath_get_currentCountry(struct ath_softc *sc, 
    1171         struct hal_country_entry *ctry); 
    1172 u_int64_t ath_extend_tsf(struct ath_softc *sc, u_int32_t rstamp); 
     1159        struct ath9k_country_entry *ctry); 
     1160u64 ath_extend_tsf(struct ath_softc *sc, u32 rstamp); 
    11731161void ath_internal_reset(struct ath_softc *sc); 
    1174 u_int32_t ath_chan2flags(struct ieee80211_channel *chan, struct ath_softc *sc); 
     1162u32 ath_chan2flags(struct ieee80211_channel *chan, struct ath_softc *sc); 
    11751163dma_addr_t ath_skb_map_single(struct ath_softc *sc, 
    11761164                              struct sk_buff *skb, 
     
    11811169                          int direction, 
    11821170                          dma_addr_t *pa); 
    1183 void ath_mcast_merge(struct ath_softc *sc, u_int32_t mfilt[2]); 
    1184 enum hal_ht_macmode ath_cwm_macmode(struct ath_softc *sc); 
     1171void ath_mcast_merge(struct ath_softc *sc, u32 mfilt[2]); 
     1172enum ath9k_ht_macmode ath_cwm_macmode(struct ath_softc *sc); 
    11851173 
    11861174#endif /* CORE_H */ 
  • trunk/package/ath9k/src/drivers/net/wireless/ath9k/hw.c

    r12038 r12079  
    2424 
    2525static void ath9k_hw_iqcal_collect(struct ath_hal *ah); 
    26 static void ath9k_hw_iqcalibrate(struct ath_hal *ah, u_int8_t numChains); 
     26static void ath9k_hw_iqcalibrate(struct ath_hal *ah, u8 numChains); 
    2727static void ath9k_hw_adc_gaincal_collect(struct ath_hal *ah); 
    2828static void ath9k_hw_adc_gaincal_calibrate(struct ath_hal *ah, 
    29                                            u_int8_t numChains); 
     29                                           u8 numChains); 
    3030static void ath9k_hw_adc_dccal_collect(struct ath_hal *ah); 
    3131static void ath9k_hw_adc_dccal_calibrate(struct ath_hal *ah, 
    32                                          u_int8_t numChains); 
    33  
    34 static const u_int8_t CLOCK_RATE[] = { 40, 80, 22, 44, 88, 40 }; 
     32                                         u8 numChains); 
     33 
     34static const u8 CLOCK_RATE[] = { 40, 80, 22, 44, 88, 40 }; 
    3535static const int16_t NOISE_FLOOR[] = { -96, -93, -98, -96, -93, -96 }; 
    3636 
     
    108108}; 
    109109 
    110 static struct hal_rate_table ar5416_11a_table = { 
     110static struct ath9k_rate_table ar5416_11a_table = { 
    111111        8, 
    112112        {0}, 
     
    123123}; 
    124124 
    125 static struct hal_rate_table ar5416_11b_table = { 
     125static struct ath9k_rate_table ar5416_11b_table = { 
    126126        4, 
    127127        {0}, 
     
    134134}; 
    135135 
    136 static struct hal_rate_table ar5416_11g_table = { 
     136static struct ath9k_rate_table ar5416_11g_table = { 
    137137        12, 
    138138        {0}, 
     
    154154}; 
    155155 
    156 static struct hal_rate_table ar5416_11ng_table = { 
     156static struct ath9k_rate_table ar5416_11ng_table = { 
    157157        28, 
    158158        {0}, 
     
    190190}; 
    191191 
    192 static struct hal_rate_table ar5416_11na_table = { 
     192static struct ath9k_rate_table ar5416_11na_table = { 
    193193        24, 
    194194        {0}, 
     
    222222 
    223223static enum wireless_mode ath9k_hw_chan2wmode(struct ath_hal *ah, 
    224                                        const struct hal_channel *chan) 
     224                                       const struct ath9k_channel *chan) 
    225225{ 
    226226        if (IS_CHAN_CCK(chan)) 
     
    232232 
    233233static bool ath9k_hw_wait(struct ath_hal *ah, 
    234                           u_int reg, 
    235                           u_int32_t mask, 
    236                           u_int32_t val) 
     234                          u32 reg, 
     235                          u32 mask, 
     236                          u32 val) 
    237237{ 
    238238        int i; 
     
    250250} 
    251251 
    252 static bool ath9k_hw_eeprom_read(struct ath_hal *ah, u_int off, 
    253                                  u_int16_t *data) 
     252static bool ath9k_hw_eeprom_read(struct ath_hal *ah, u32 off, 
     253                                 u16 *data) 
    254254{ 
    255255        (void) REG_READ(ah, AR5416_EEPROM_OFFSET + (off << AR5416_EEPROM_S)); 
     
    268268} 
    269269 
    270 static enum hal_status ath9k_hw_flash_map(struct ath_hal *ah) 
     270static int ath9k_hw_flash_map(struct ath_hal *ah) 
    271271{ 
    272272        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    277277                DPRINTF(ah->ah_sc, ATH_DBG_EEPROM, 
    278278                         "%s: cannot remap eeprom region \n", __func__); 
    279                 return HAL_EIO; 
    280         } 
    281  
    282         return HAL_OK; 
    283 } 
    284  
    285 static bool ath9k_hw_flash_read(struct ath_hal *ah, u_int off, 
    286                                 u_int16_t *data) 
     279                return -EIO; 
     280        } 
     281 
     282        return 0; 
     283} 
     284 
     285static bool ath9k_hw_flash_read(struct ath_hal *ah, u32 off, 
     286                                u16 *data) 
    287287{ 
    288288        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    294294static void ath9k_hw_read_revisions(struct ath_hal *ah) 
    295295{ 
    296         u_int32_t val; 
     296        u32 val; 
    297297 
    298298        val = REG_READ(ah, AR_SREV) & AR_SREV_ID; 
     
    319319} 
    320320 
    321 u_int32_t ath9k_hw_reverse_bits(u_int32_t val, u_int32_t n) 
    322 { 
    323         u_int32_t retval; 
     321u32 ath9k_hw_reverse_bits(u32 val, u32 n) 
     322{ 
     323        u32 retval; 
    324324        int i; 
    325325 
     
    372372 
    373373static inline void ath9k_hw_override_ini(struct ath_hal *ah, 
    374                                          struct hal_channel *chan) 
     374                                         struct ath9k_channel *chan) 
    375375{ 
    376376        if (!AR_SREV_5416_V20_OR_LATER(ah) 
     
    382382 
    383383static inline void ath9k_hw_init_bb(struct ath_hal *ah, 
    384                                     struct hal_channel *chan) 
    385 { 
    386         u_int32_t synthDelay; 
     384                                    struct ath9k_channel *chan) 
     385{ 
     386        u32 synthDelay; 
    387387 
    388388        synthDelay = REG_READ(ah, AR_PHY_RX_DELAY) & AR_PHY_RX_DELAY_DELAY; 
     
    398398 
    399399static inline void ath9k_hw_init_interrupt_masks(struct ath_hal *ah, 
    400                                                  enum hal_opmode opmode) 
     400                                                 enum ath9k_opmode opmode) 
    401401{ 
    402402        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    415415        ahp->ah_maskReg |= AR_IMR_TXOK; 
    416416 
    417         if (opmode == HAL_M_HOSTAP) 
     417        if (opmode == ATH9K_M_HOSTAP) 
    418418                ahp->ah_maskReg |= AR_IMR_MIB; 
    419419 
     
    446446 
    447447static void ath9k_hw_analog_shift_rmw(struct ath_hal *ah, 
    448                                       u_int reg, 
    449                                       u_int32_t mask, 
    450                                       u_int32_t shift, 
    451                                       u_int32_t val) 
    452 { 
    453         u_int32_t regVal; 
     448                                      u32 reg, 
     449                                      u32 mask, 
     450                                      u32 shift, 
     451                                      u32 val) 
     452{ 
     453        u32 regVal; 
    454454 
    455455        regVal = REG_READ(ah, reg) & ~mask; 
     
    464464} 
    465465 
    466 static u_int8_t ath9k_hw_get_num_ant_config(struct ath_hal_5416 *ahp, 
     466static u8 ath9k_hw_get_num_ant_config(struct ath_hal_5416 *ahp, 
    467467                                            enum hal_freq_band freq_band) 
    468468{ 
     
    471471                &(eep->modalHeader[HAL_FREQ_BAND_2GHZ == freq_band]); 
    472472        struct base_eep_header *pBase = &eep->baseEepHeader; 
    473         u_int8_t num_ant_config; 
     473        u8 num_ant_config; 
    474474 
    475475        num_ant_config = 1; 
     
    482482} 
    483483 
    484 static enum hal_status 
     484static int 
    485485ath9k_hw_get_eeprom_antenna_cfg(struct ath_hal_5416 *ahp, 
    486                                 struct hal_channel_internal *chan, 
    487                                 u_int8_t index, 
    488                                 u_int16_t *config) 
     486                                struct ath9k_channel *chan, 
     487                                u8 index, 
     488                                u16 *config) 
    489489{ 
    490490        struct ar5416_eeprom *eep = &ahp->ah_eeprom; 
     
    496496        case 0: 
    497497                *config = pModal->antCtrlCommon & 0xFFFF; 
    498                 return HAL_OK; 
     498                return 0; 
    499499        case 1: 
    500500                if (pBase->version >= 0x0E0D) { 
     
    502502                                *config = 
    503503                                ((pModal->antCtrlCommon & 0xFFFF0000) >> 16); 
    504                                 return HAL_OK; 
     504                                return 0; 
    505505                        } 
    506506                } 
     
    510510        } 
    511511 
    512         return HAL_EINVAL; 
     512        return -EINVAL; 
    513513} 
    514514 
    515515static inline bool ath9k_hw_nvram_read(struct ath_hal *ah, 
    516                                        u_int off, 
    517                                        u_int16_t *data) 
     516                                       u32 off, 
     517                                       u16 *data) 
    518518{ 
    519519        if (ath9k_hw_use_flash(ah)) 
     
    527527        struct ath_hal_5416 *ahp = AH5416(ah); 
    528528        struct ar5416_eeprom *eep = &ahp->ah_eeprom; 
    529         u_int16_t *eep_data; 
     529        u16 *eep_data; 
    530530        int addr, ar5416_eep_start_loc = 0; 
    531531 
     
    538538                ar5416_eep_start_loc = 256; 
    539539 
    540         eep_data = (u_int16_t *) eep; 
     540        eep_data = (u16 *) eep; 
    541541        for (addr = 0; 
    542              addr < sizeof(struct ar5416_eeprom) / sizeof(u_int16_t); 
     542             addr < sizeof(struct ar5416_eeprom) / sizeof(u16); 
    543543             addr++) { 
    544544                if (!ath9k_hw_nvram_read(ah, addr + ar5416_eep_start_loc, 
     
    557557static bool 
    558558ath9k_hw_eeprom_set_board_values(struct ath_hal *ah, 
    559                                  struct hal_channel_internal *chan) 
     559                                 struct ath9k_channel *chan) 
    560560{ 
    561561        struct modal_eep_header *pModal; 
     
    563563        struct ath_hal_5416 *ahp = AH5416(ah); 
    564564        struct ar5416_eeprom *eep = &ahp->ah_eeprom; 
    565         u_int8_t txRxAttenLocal; 
    566         u_int16_t ant_config; 
     565        u8 txRxAttenLocal; 
     566        u16 ant_config; 
    567567 
    568568        pModal = &(eep->modalHeader[IS_CHAN_2GHZ(chan)]); 
     
    790790} 
    791791 
    792 static inline enum hal_status ath9k_hw_check_eeprom(struct ath_hal *ah) 
    793 { 
    794         u_int32_t sum = 0, el; 
    795         u_int16_t *eepdata; 
     792static inline int ath9k_hw_check_eeprom(struct ath_hal *ah) 
     793{ 
     794        u32 sum = 0, el; 
     795        u16 *eepdata; 
    796796        int i; 
    797797        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    801801 
    802802        if (!ath9k_hw_use_flash(ah)) { 
    803                 u_int16_t magic, magic2; 
     803                u16 magic, magic2; 
    804804                int addr; 
    805805 
     
    818818                        if (magic2 == AR5416_EEPROM_MAGIC) { 
    819819                                need_swap = true; 
    820                                 eepdata = (u_int16_t *) (&ahp->ah_eeprom); 
     820                                eepdata = (u16 *) (&ahp->ah_eeprom); 
    821821 
    822822                                for (addr = 0; 
    823823                                     addr < 
    824824                                             sizeof(struct ar5416_eeprom) / 
    825                                              sizeof(u_int16_t); addr++) { 
    826                                         u_int16_t temp; 
     825                                             sizeof(u16); addr++) { 
     826                                        u16 temp; 
    827827 
    828828                                        temp = swab16(*eepdata); 
     
    841841                                         "Invalid EEPROM Magic. " 
    842842                                        "endianness missmatch.\n"); 
    843                                 return HAL_EEBADSUM; 
     843                                return -EINVAL; 
    844844                        } 
    845845                } 
     
    854854 
    855855        if (el > sizeof(struct ar5416_eeprom)) 
    856                 el = sizeof(struct ar5416_eeprom) / sizeof(u_int16_t); 
     856                el = sizeof(struct ar5416_eeprom) / sizeof(u16); 
    857857        else 
    858                 el = el / sizeof(u_int16_t); 
    859  
    860         eepdata = (u_int16_t *) (&ahp->ah_eeprom); 
     858                el = el / sizeof(u16); 
     859 
     860        eepdata = (u16 *) (&ahp->ah_eeprom); 
    861861 
    862862        for (i = 0; i < el; i++) 
     
    864864 
    865865        if (need_swap) { 
    866                 u_int32_t integer, j; 
    867                 u_int16_t word; 
     866                u32 integer, j; 
     867                u16 word; 
    868868 
    869869                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)); 
    919                 return HAL_EEBADSUM; 
    920         } 
    921  
    922         return HAL_OK; 
     919                return -EINVAL; 
     920        } 
     921 
     922        return 0; 
    923923} 
    924924 
    925925static bool ath9k_hw_chip_test(struct ath_hal *ah) 
    926926{ 
    927         u_int32_t regAddr[2] = { AR_STA_ID0, AR_PHY_BASE + (8 << 2) }; 
    928         u_int32_t regHold[2]; 
    929         u_int32_t patternData[4] = { 0x55555555, 
     927        u32 regAddr[2] = { AR_STA_ID0, AR_PHY_BASE + (8 << 2) }; 
     928        u32 regHold[2]; 
     929        u32 patternData[4] = { 0x55555555, 
    930930                                     0xaaaaaaaa, 
    931931                                     0x66666666, 
     
    934934 
    935935        for (i = 0; i < 2; i++) { 
    936                 u_int32_t addr = regAddr[i]; 
    937                 u_int32_t wrData, rdData; 
     936                u32 addr = regAddr[i]; 
     937                u32 wrData, rdData; 
    938938 
    939939                regHold[i] = REG_READ(ah, addr); 
     
    968968} 
    969969 
    970 u_int32_t ath9k_hw_getrxfilter(struct ath_hal *ah) 
    971 { 
    972         u_int32_t bits = REG_READ(ah, AR_RX_FILTER); 
    973         u_int32_t phybits = REG_READ(ah, AR_PHY_ERR); 
     970u32 ath9k_hw_getrxfilter(struct ath_hal *ah) 
     971{ 
     972        u32 bits = REG_READ(ah, AR_RX_FILTER); 
     973        u32 phybits = REG_READ(ah, AR_PHY_ERR); 
    974974 
    975975        if (phybits & AR_PHY_ERR_RADAR) 
    976                 bits |= HAL_RX_FILTER_PHYRADAR; 
     976                bits |= ATH9K_RX_FILTER_PHYRADAR; 
    977977        if (phybits & (AR_PHY_ERR_OFDM_TIMING | AR_PHY_ERR_CCK_TIMING)) 
    978                 bits |= HAL_RX_FILTER_PHYERR; 
     978                bits |= ATH9K_RX_FILTER_PHYERR; 
    979979        return bits; 
    980980} 
    981981 
    982 void ath9k_hw_setrxfilter(struct ath_hal *ah, u_int32_t bits) 
    983 { 
    984         u_int32_t phybits; 
     982void ath9k_hw_setrxfilter(struct ath_hal *ah, u32 bits) 
     983{ 
     984        u32 phybits; 
    985985 
    986986        REG_WRITE(ah, AR_RX_FILTER, (bits & 0xffff) | AR_RX_COMPR_BAR); 
    987987        phybits = 0; 
    988         if (bits & HAL_RX_FILTER_PHYRADAR) 
     988        if (bits & ATH9K_RX_FILTER_PHYRADAR) 
    989989                phybits |= AR_PHY_ERR_RADAR; 
    990         if (bits & HAL_RX_FILTER_PHYERR) 
     990        if (bits & ATH9K_RX_FILTER_PHYERR) 
    991991                phybits |= AR_PHY_ERR_OFDM_TIMING | AR_PHY_ERR_CCK_TIMING; 
    992992        REG_WRITE(ah, AR_PHY_ERR, phybits); 
     
    10021002bool ath9k_hw_setcapability(struct ath_hal *ah, 
    10031003                            enum hal_capability_type type, 
    1004                             u_int32_t capability, 
    1005                             u_int32_t setting, 
    1006                             enum hal_status *status) 
     1004                            u32 capability, 
     1005                            u32 setting, 
     1006                            int *status) 
    10071007{ 
    10081008        struct ath_hal_5416 *ahp = AH5416(ah); 
    1009         u_int32_t v; 
     1009        u32 v; 
    10101010 
    10111011        switch (type) { 
     
    10451045void ath9k_hw_dmaRegDump(struct ath_hal *ah) 
    10461046{ 
    1047         u_int32_t val[ATH9K_NUM_DMA_DEBUG_REGS]; 
     1047        u32 val[ATH9K_NUM_DMA_DEBUG_REGS]; 
    10481048        int qcuOffset = 0, dcuOffset = 0; 
    1049         u_int32_t *qcuBase = &val[0], *dcuBase = &val[4]; 
     1049        u32 *qcuBase = &val[0], *dcuBase = &val[4]; 
    10501050        int i; 
    10511051 
     
    10601060                        DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, "\n"); 
    10611061 
    1062                 val[i] = REG_READ(ah, AR_DMADBG_0 + (i * sizeof(u_int32_t))); 
     1062                val[i] = REG_READ(ah, AR_DMADBG_0 + (i * sizeof(u32))); 
    10631063                DPRINTF(ah->ah_sc, ATH_DBG_REG_IO, "%d: %08x ", i, val[i]); 
    10641064        } 
     
    11151115} 
    11161116 
    1117 u_int32_t ath9k_hw_GetMibCycleCountsPct(struct ath_hal *ah, 
    1118                                         u_int32_t *rxc_pcnt, 
    1119                                         u_int32_t *rxf_pcnt, 
    1120                                         u_int32_t *txf_pcnt) 
    1121 { 
    1122         static u_int32_t cycles, rx_clear, rx_frame, tx_frame; 
    1123         u_int32_t good = 1; 
    1124  
    1125         u_int32_t rc = REG_READ(ah, AR_RCCNT); 
    1126         u_int32_t rf = REG_READ(ah, AR_RFCNT); 
    1127         u_int32_t tf = REG_READ(ah, AR_TFCNT); 
    1128         u_int32_t cc = REG_READ(ah, AR_CCCNT); 
     1117u32 ath9k_hw_GetMibCycleCountsPct(struct ath_hal *ah, 
     1118                                        u32 *rxc_pcnt, 
     1119                                        u32 *rxf_pcnt, 
     1120                                        u32 *txf_pcnt) 
     1121{ 
     1122        static u32 cycles, rx_clear, rx_frame, tx_frame; 
     1123        u32 good = 1; 
     1124 
     1125        u32 rc = REG_READ(ah, AR_RCCNT); 
     1126        u32 rf = REG_READ(ah, AR_RFCNT); 
     1127        u32 tf = REG_READ(ah, AR_TFCNT); 
     1128        u32 cc = REG_READ(ah, AR_CCCNT); 
    11291129 
    11301130        if (cycles == 0 || cycles > cc) { 
     
    11341134                good = 0; 
    11351135        } else { 
    1136                 u_int32_t cc_d = cc - cycles; 
    1137                 u_int32_t rc_d = rc - rx_clear; 
    1138                 u_int32_t rf_d = rf - rx_frame; 
    1139                 u_int32_t tf_d = tf - tx_frame; 
     1136                u32 cc_d = cc - cycles; 
     1137                u32 rc_d = rc - rx_clear; 
     1138                u32 rf_d = rf - rx_frame; 
     1139                u32 tf_d = tf - tx_frame; 
    11401140 
    11411141                if (cc_d != 0) { 
     
    11561156} 
    11571157 
    1158 void ath9k_hw_set11nmac2040(struct ath_hal *ah, enum hal_ht_macmode mode) 
    1159 { 
    1160         u_int32_t macmode; 
    1161  
    1162         if (mode == HAL_HT_MACMODE_2040 && 
     1158void ath9k_hw_set11nmac2040(struct ath_hal *ah, enum ath9k_ht_macmode mode) 
     1159{ 
     1160        u32 macmode; 
     1161 
     1162        if (mode == ATH9K_HT_MACMODE_2040 && 
    11631163            !ah->ah_config.ath_hal_cwmIgnoreExtCCA) 
    11641164                macmode = AR_2040_JOINED_RX_CLEAR; 
     
    11751175 
    11761176 
    1177 static struct ath_hal_5416 *ath9k_hw_newstate(u_int16_t devid, 
     1177static struct ath_hal_5416 *ath9k_hw_newstate(u16 devid, 
    11781178                                              struct ath_softc *sc, 
    11791179                                              void __iomem *mem, 
    1180                                               enum hal_status *status) 
    1181 { 
    1182         static const u_int8_t defbssidmask[ETH_ALEN] = 
     1180                                              int *status) 
     1181{ 
     1182        static const u8 defbssidmask[ETH_ALEN] = 
    11831183                { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 
    11841184        struct ath_hal_5416 *ahp; 
     
    11901190                         "%s: cannot allocate memory for state block\n", 
    11911191                         __func__); 
    1192                 *status = HAL_ENOMEM; 
     1192                *status = -ENOMEM; 
    11931193                return NULL; 
    11941194        } 
     
    12111211 
    12121212        ah->ah_powerLimit = MAX_RATE_POWER; 
    1213         ah->ah_tpScale = HAL_TP_SCALE_MAX; 
     1213        ah->ah_tpScale = ATH9K_TP_SCALE_MAX; 
    12141214 
    12151215        ahp->ah_atimWindow = 0; 
     
    12211221        ahp->ah_beaconInterval = 100; 
    12221222        ahp->ah_enable32kHzClock = DONT_USE_32KHZ; 
    1223         ahp->ah_slottime = (u_int) -1; 
    1224         ahp->ah_acktimeout = (u_int) -1; 
    1225         ahp->ah_ctstimeout = (u_int) -1; 
    1226         ahp->ah_globaltxtimeout = (u_int) -1; 
     1223        ahp->ah_slottime = (u32) -1; 
     1224        ahp->ah_acktimeout = (u32) -1; 
     1225        ahp->ah_ctstimeout = (u32) -1; 
     1226        ahp->ah_globaltxtimeout = (u32) -1; 
    12271227        memcpy(&ahp->ah_bssidmask, defbssidmask, ETH_ALEN); 
    12281228 
     
    12321232} 
    12331233 
    1234 static enum hal_status ath9k_hw_eeprom_attach(struct ath_hal *ah) 
    1235 { 
    1236         enum hal_status status; 
     1234static int ath9k_hw_eeprom_attach(struct ath_hal *ah) 
     1235{ 
     1236        int status; 
    12371237 
    12381238        if (ath9k_hw_use_flash(ah)) 
     
    12401240 
    12411241        if (!ath9k_hw_fill_eeprom(ah)) 
    1242                 return HAL_EIO; 
     1242                return -EIO; 
    12431243 
    12441244        status = ath9k_hw_check_eeprom(ah); 
     
    12471247} 
    12481248 
    1249 u_int32_t ath9k_hw_get_eeprom(struct ath_hal_5416 *ahp, 
     1249u32 ath9k_hw_get_eeprom(struct ath_hal_5416 *ahp, 
    12501250                              enum eeprom_param param) 
    12511251{ 
     
    12961296static inline int ath9k_hw_get_radiorev(struct ath_hal *ah) 
    12971297{ 
    1298         u_int32_t val; 
     1298        u32 val; 
    12991299        int i; 
    13001300 
     
    13071307} 
    13081308 
    1309 static inline enum hal_status ath9k_hw_init_macaddr(struct ath_hal *ah) 
    1310 { 
    1311         u_int32_t sum; 
     1309static inline int ath9k_hw_init_macaddr(struct ath_hal *ah) 
     1310{ 
     1311        u32 sum; 
    13121312        int i; 
    1313         u_int16_t eeval; 
     1313        u16 eeval; 
    13141314        struct ath_hal_5416 *ahp = AH5416(ah); 
    13151315        DECLARE_MAC_BUF(mac); 
     
    13261326                         "%s: mac address read failed: %s\n", __func__, 
    13271327                         print_mac(mac, ahp->ah_macaddr)); 
    1328                 return HAL_EEBADMAC; 
    1329         } 
    1330  
    1331         return HAL_OK; 
    1332 } 
    1333  
    1334 static inline int16_t ath9k_hw_interpolate(u_int16_t target, 
    1335                                            u_int16_t srcLeft, 
    1336                                            u_int16_t srcRight, 
     1328                return -EADDRNOTAVAIL; 
     1329        } 
     1330 
     1331        return 0; 
     1332} 
     1333 
     1334static inline int16_t ath9k_hw_interpolate(u16 target, 
     1335                                           u16 srcLeft, 
     1336                                           u16 srcRight, 
    13371337                                           int16_t targetLeft, 
    13381338                                           int16_t targetRight) 
     
    13501350} 
    13511351 
    1352 static inline u_int16_t ath9k_hw_fbin2freq(u_int8_t fbin, 
     1352static inline u16 ath9k_hw_fbin2freq(u8 fbin, 
    13531353                                           bool is2GHz) 
    13541354{ 
     
    13571357                return fbin; 
    13581358 
    1359         return (u_int16_t) ((is2GHz) ? (2300 + fbin) : (4800 + 5 * fbin)); 
    1360 } 
    1361  
    1362 static u_int16_t ath9k_hw_eeprom_get_spur_chan(struct ath_hal *ah, 
    1363                                                u_int16_t i, 
     1359        return (u16) ((is2GHz) ? (2300 + fbin) : (4800 + 5 * fbin)); 
     1360} 
     1361 
     1362static u16 ath9k_hw_eeprom_get_spur_chan(struct ath_hal *ah, 
     1363                                               u16 i, 
    13641364                                               bool is2GHz) 
    13651365{ 
     
    13671367        struct ar5416_eeprom *eep = 
    13681368                (struct ar5416_eeprom *) &ahp->ah_eeprom; 
    1369         u_int16_t spur_val = AR_NO_SPUR; 
     1369        u16 spur_val = AR_NO_SPUR; 
    13701370 
    13711371        DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
     
    13891389} 
    13901390 
    1391 static inline enum hal_status ath9k_hw_rfattach(struct ath_hal *ah) 
     1391static inline int ath9k_hw_rfattach(struct ath_hal *ah) 
    13921392{ 
    13931393        bool rfStatus = false; 
    1394         enum hal_status ecode = HAL_OK; 
     1394        int ecode = 0; 
    13951395 
    13961396        rfStatus = ath9k_hw_init_rf(ah, &ecode); 
     
    14021402        } 
    14031403 
    1404         return HAL_OK; 
    1405 } 
    1406  
    1407 static enum hal_status ath9k_hw_rf_claim(struct ath_hal *ah) 
    1408 { 
    1409         u_int32_t val; 
     1404        return 0; 
     1405} 
     1406 
     1407static int ath9k_hw_rf_claim(struct ath_hal *ah) 
     1408{ 
     1409        u32 val; 
    14101410 
    14111411        REG_WRITE(ah, AR_PHY(0), 0x00000007); 
     
    14261426                        "supported by this driver\n", 
    14271427                         __func__, ah->ah_analog5GhzRev); 
    1428                 return HAL_ENOTSUPP; 
     1428                return -EOPNOTSUPP; 
    14291429        } 
    14301430 
    14311431        ah->ah_analog5GhzRev = val; 
    14321432 
    1433         return HAL_OK; 
     1433        return 0; 
    14341434} 
    14351435 
    14361436static inline void ath9k_hw_init_pll(struct ath_hal *ah, 
    1437                                      struct hal_channel *chan) 
    1438 { 
    1439         u_int32_t pll; 
     1437                                     struct ath9k_channel *chan) 
     1438{ 
     1439        u32 pll; 
    14401440 
    14411441        if (AR_SREV_9100(ah)) { 
     
    14951495                } 
    14961496        } 
    1497         REG_WRITE(ah, (u_int16_t) (AR_RTC_PLL_CONTROL), pll); 
     1497        REG_WRITE(ah, (u16) (AR_RTC_PLL_CONTROL), pll); 
    14981498 
    14991499        udelay(RTC_PLL_SETTLE_DELAY); 
     
    15021502} 
    15031503 
    1504 static void ath9k_hw_set_regs(struct ath_hal *ah, struct hal_channel *chan, 
    1505                               enum hal_ht_macmode macmode) 
    1506 { 
    1507         u_int32_t phymode; 
     1504static void ath9k_hw_set_regs(struct ath_hal *ah, struct ath9k_channel *chan, 
     1505                              enum ath9k_ht_macmode macmode) 
     1506{ 
     1507        u32 phymode; 
    15081508        struct ath_hal_5416 *ahp = AH5416(ah); 
    15091509 
     
    15141514                phymode |= AR_PHY_FC_DYN2040_EN; 
    15151515 
    1516                 if (chan->channelFlags & CHANNEL_HT40PLUS) 
     1516                if ((chan->chanmode == CHANNEL_A_HT40PLUS) || 
     1517                    (chan->chanmode == CHANNEL_G_HT40PLUS)) 
    15171518                        phymode |= AR_PHY_FC_DYN2040_PRI_CH; 
    15181519 
    1519                 if (ahp->ah_extprotspacing == HAL_HT_EXTPROTSPACING_25) 
     1520                if (ahp->ah_extprotspacing == ATH9K_HT_EXTPROTSPACING_25) 
    15201521                        phymode |= AR_PHY_FC_DYN2040_EXT_CH; 
    15211522        } 
     
    15301531static void ath9k_hw_set_operating_mode(struct ath_hal *ah, int opmode) 
    15311532{ 
    1532         u_int32_t val; 
     1533        u32 val; 
    15331534 
    15341535        val = REG_READ(ah, AR_STA_ID1); 
    15351536        val &= ~(AR_STA_ID1_STA_AP | AR_STA_ID1_ADHOC); 
    15361537        switch (opmode) { 
    1537         case HAL_M_HOSTAP: 
     1538        case ATH9K_M_HOSTAP: 
    15381539                REG_WRITE(ah, AR_STA_ID1, val | AR_STA_ID1_STA_AP 
    15391540                          | AR_STA_ID1_KSRCH_MODE); 
    15401541                REG_CLR_BIT(ah, AR_CFG, AR_CFG_AP_ADHOC_INDICATION); 
    15411542                break; 
    1542         case HAL_M_IBSS: 
     1543        case ATH9K_M_IBSS: 
    15431544                REG_WRITE(ah, AR_STA_ID1, val | AR_STA_ID1_ADHOC 
    15441545                          | AR_STA_ID1_KSRCH_MODE); 
    15451546                REG_SET_BIT(ah, AR_CFG, AR_CFG_AP_ADHOC_INDICATION); 
    15461547                break; 
    1547         case HAL_M_STA: 
    1548         case HAL_M_MONITOR: 
     1548        case ATH9K_M_STA: 
     1549        case ATH9K_M_MONITOR: 
    15491550                REG_WRITE(ah, AR_STA_ID1, val | AR_STA_ID1_KSRCH_MODE); 
    15501551                break; 
     
    15531554 
    15541555static inline void 
    1555 ath9k_hw_set_rfmode(struct ath_hal *ah, struct hal_channel *chan) 
    1556 { 
    1557         u_int32_t rfMode = 0; 
     1556ath9k_hw_set_rfmode(struct ath_hal *ah, struct ath9k_channel *chan) 
     1557{ 
     1558        u32 rfMode = 0; 
    15581559 
    15591560        if (chan == NULL) 
     
    15751576static bool ath9k_hw_set_reset(struct ath_hal *ah, int type) 
    15761577{ 
    1577         u_int32_t rst_flags; 
    1578         u_int32_t tmpReg; 
     1578        u32 rst_flags; 
     1579        u32 tmpReg; 
    15791580 
    15801581        REG_WRITE(ah, AR_RTC_FORCE_WAKE, AR_RTC_FORCE_WAKE_EN | 
     
    15961597 
    15971598                rst_flags = AR_RTC_RC_MAC_WARM; 
    1598                 if (type == HAL_RESET_COLD) 
     1599                if (type == ATH9K_RESET_COLD) 
    15991600                        rst_flags |= AR_RTC_RC_MAC_COLD; 
    16001601        } 
    16011602 
    1602         REG_WRITE(ah, (u_int16_t) (AR_RTC_RC), rst_flags); 
     1603        REG_WRITE(ah, (u16) (AR_RTC_RC), rst_flags); 
    16031604        udelay(50); 
    16041605 
    1605         REG_WRITE(ah, (u_int16_t) (AR_RTC_RC), 0); 
    1606         if (!ath9k_hw_wait(ah, (u_int16_t) (AR_RTC_RC), AR_RTC_RC_M, 0)) { 
     1606        REG_WRITE(ah, (u16) (AR_RTC_RC), 0); 
     1607        if (!ath9k_hw_wait(ah, (u16) (AR_RTC_RC), AR_RTC_RC_M, 0)) { 
    16071608                DPRINTF(ah->ah_sc, ATH_DBG_RESET, 
    16081609                        "%s: RTC stuck in MAC reset\n", 
     
    16271628                  AR_RTC_FORCE_WAKE_ON_INT); 
    16281629 
    1629         REG_WRITE(ah, (u_int16_t) (AR_RTC_RESET), 0); 
    1630         REG_WRITE(ah, (u_int16_t) (AR_RTC_RESET), 1); 
     1630        REG_WRITE(ah, (u16) (AR_RTC_RESET), 0); 
     1631        REG_WRITE(ah, (u16) (AR_RTC_RESET), 1); 
    16311632 
    16321633        if (!ath9k_hw_wait(ah, 
     
    16411642        ath9k_hw_read_revisions(ah); 
    16421643 
    1643         return ath9k_hw_set_reset(ah, HAL_RESET_WARM); 
     1644        return ath9k_hw_set_reset(ah, ATH9K_RESET_WARM); 
    16441645} 
    16451646 
    16461647static bool ath9k_hw_set_reset_reg(struct ath_hal *ah, 
    1647                                    u_int32_t type) 
     1648                                   u32 type) 
    16481649{ 
    16491650        REG_WRITE(ah, AR_RTC_FORCE_WAKE, 
     
    16511652 
    16521653        switch (type) { 
    1653         case HAL_RESET_POWER_ON: 
     1654        case ATH9K_RESET_POWER_ON: 
    16541655                return ath9k_hw_set_reset_power_on(ah); 
    16551656                break; 
    1656         case HAL_RESET_WARM: 
    1657         case HAL_RESET_COLD: 
     1657        case ATH9K_RESET_WARM: 
     1658        case ATH9K_RESET_COLD: 
    16581659                return ath9k_hw_set_reset(ah, type); 
    16591660                break; 
     
    16631664} 
    16641665 
    1665 static inline struct hal_channel_internal *ath9k_hw_check_chan( 
    1666                         struct ath_hal *ah, struct hal_channel *chan) 
    1667 { 
    1668         if ((IS(chan, CHANNEL_2GHZ) ^ IS(chan, CHANNEL_5GHZ)) == 0) { 
     1666static inline 
     1667struct ath9k_channel *ath9k_hw_check_chan(struct ath_hal *ah, 
     1668                                          struct ath9k_channel *chan) 
     1669{ 
     1670        if (!(IS_CHAN_2GHZ(chan) ^ IS_CHAN_5GHZ(chan))) { 
    16691671                DPRINTF(ah->ah_sc, ATH_DBG_CHANNEL, 
    16701672                         "%s: invalid channel %u/0x%x; not marked as " 
     
    16741676        } 
    16751677 
    1676         if ((IS(chan, CHANNEL_OFDM) 
    1677              ^ IS(chan, CHANNEL_CCK) 
    1678              ^ IS(chan, CHANNEL_HT20) 
    1679              ^ IS(chan, CHANNEL_HT40PLUS) 
    1680              ^ IS(chan, CHANNEL_HT40MINUS)) == 0) { 
     1678        if (!IS_CHAN_OFDM(chan) && 
     1679              !IS_CHAN_CCK(chan) && 
     1680              !IS_CHAN_HT20(chan) && 
     1681              !IS_CHAN_HT40(chan)) { 
    16811682                DPRINTF(ah->ah_sc, ATH_DBG_CHANNEL, 
    1682                          "%s: invalid channel %u/0x%x; not marked as " 
    1683                          "OFDM or CCK or HT20 or HT40PLUS or HT40MINUS\n", 
    1684                          __func__, chan->channel, chan->channelFlags); 
     1683                        "%s: invalid channel %u/0x%x; not marked as " 
     1684                        "OFDM or CCK or HT20 or HT40PLUS or HT40MINUS\n", 
     1685                        __func__, chan->channel, chan->channelFlags); 
    16851686                return NULL; 
    16861687        } 
     
    16901691 
    16911692static inline bool 
    1692 ath9k_hw_get_lower_upper_index(u_int8_t target, 
    1693                                u_int8_t *pList, 
    1694                                u_int16_t listSize, 
    1695                                u_int16_t *indexL, 
    1696                                u_int16_t *indexR) 
    1697 { 
    1698         u_int16_t i; 
     1693ath9k_hw_get_lower_upper_index(u8 target, 
     1694                               u8 *pList, 
     1695                               u16 listSize, 
     1696                               u16 *indexL, 
     1697                               u16 *indexR) 
     1698{ 
     1699        u16 i; 
    16991700 
    17001701        if (target <= pList[0]) { 
     
    17031704        } 
    17041705        if (target >= pList[listSize - 1]) { 
    1705                 *indexL = *indexR = (u_int16_t) (listSize - 1); 
     1706                *indexL = *indexR = (u16) (listSize - 1); 
    17061707                return true; 
    17071708        } 
     
    17141715                if (target < pList[i + 1]) { 
    17151716                        *indexL = i; 
    1716                         *indexR = (u_int16_t) (i + 1); 
     1717                        *indexR = (u16) (i + 1); 
    17171718                        return false; 
    17181719                } 
     
    17241725{ 
    17251726        int16_t nfval; 
    1726         int16_t sort[HAL_NF_CAL_HIST_MAX]; 
     1727        int16_t sort[ATH9K_NF_CAL_HIST_MAX]; 
    17271728        int i, j; 
    17281729 
    1729         for (i = 0; i < HAL_NF_CAL_HIST_MAX; i++) 
     1730        for (i = 0; i < ATH9K_NF_CAL_HIST_MAX; i++) 
    17301731                sort[i] = nfCalBuffer[i]; 
    17311732 
    1732         for (i = 0; i < HAL_NF_CAL_HIST_MAX - 1; i++) { 
    1733                 for (j = 1; j < HAL_NF_CAL_HIST_MAX - i; j++) { 
     1733        for (i = 0; i < ATH9K_NF_CAL_HIST_MAX - 1; i++) { 
     1734                for (j = 1; j < ATH9K_NF_CAL_HIST_MAX - i; j++) { 
    17341735                        if (sort[j] > sort[j - 1]) { 
    17351736                                nfval = sort[j]; 
     
    17391740                } 
    17401741        } 
    1741         nfval = sort[(HAL_NF_CAL_HIST_MAX - 1) >> 1]; 
     1742        nfval = sort[(ATH9K_NF_CAL_HIST_MAX - 1) >> 1]; 
    17421743 
    17431744        return nfval; 
    17441745} 
    17451746 
    1746 static void ath9k_hw_update_nfcal_hist_buffer(struct hal_nfcal_hist *h, 
     1747static void ath9k_hw_update_nfcal_hist_buffer(struct ath9k_nfcal_hist *h, 
    17471748                                              int16_t *nfarray) 
    17481749{ 
     
    17521753                h[i].nfCalBuffer[h[i].currIndex] = nfarray[i]; 
    17531754 
    1754                 if (++h[i].currIndex >= HAL_NF_CAL_HIST_MAX) 
     1755                if (++h[i].currIndex >= ATH9K_NF_CAL_HIST_MAX) 
    17551756                        h[i].currIndex = 0; 
    17561757 
     
    17581759                        if (nfarray[i] < AR_PHY_CCA_MIN_BAD_VALUE 
    17591760                            || nfarray[i] > AR_PHY_CCA_MAX_HIGH_VALUE) { 
    1760                                 h[i].invalidNFcount = HAL_NF_CAL_HIST_MAX; 
     1761                                h[i].invalidNFcount = ATH9K_NF_CAL_HIST_MAX; 
    17611762                        } else { 
    17621763                                h[i].invalidNFcount--; 
     
    18491850static bool 
    18501851getNoiseFloorThresh(struct ath_hal *ah, 
    1851                     const struct hal_channel_internal *chan, 
     1852                    const struct ath9k_channel *chan, 
    18521853                    int16_t *nft) 
    18531854{ 
    18541855        struct ath_hal_5416 *ahp = AH5416(ah); 
    18551856 
    1856         switch (chan->channelFlags & CHANNEL_ALL) { 
     1857        switch (chan->chanmode) { 
    18571858        case CHANNEL_A: 
    18581859        case CHANNEL_A_HT20: 
     
    18871888 
    18881889static void 
    1889 ath9k_hw_loadnf(struct ath_hal *ah, struct hal_channel_internal *chan) 
    1890 { 
    1891         struct hal_nfcal_hist *h; 
     1890ath9k_hw_loadnf(struct ath_hal *ah, struct ath9k_channel *chan) 
     1891{ 
     1892        struct ath9k_nfcal_hist *h; 
    18921893        int i, j; 
    18931894        int32_t val; 
    1894         const u_int32_t ar5416_cca_regs[6] = { 
     1895        const u32 ar5416_cca_regs[6] = { 
    18951896                AR_PHY_CCA, 
    18961897                AR_PHY_CH1_CCA, 
     
    19001901                AR_PHY_CH2_EXT_CCA 
    19011902        }; 
    1902         u_int8_t chainmask; 
     1903        u8 chainmask; 
    19031904 
    19041905        if (AR_SREV_9280(ah)) 
     
    19171918                        val = REG_READ(ah, ar5416_cca_regs[i]); 
    19181919                        val &= 0xFFFFFE00; 
    1919                         val |= (((u_int32_t) (h[i].privNF) << 1) & 0x1ff); 
     1920                        val |= (((u32) (h[i].privNF) << 1) & 0x1ff); 
    19201921                        REG_WRITE(ah, ar5416_cca_regs[i], val); 
    19211922                } 
     
    19391940                        val = REG_READ(ah, ar5416_cca_regs[i]); 
    19401941                        val &= 0xFFFFFE00; 
    1941                         val |= (((u_int32_t) (-50) << 1) & 0x1ff); 
     1942                        val |= (((u32) (-50) << 1) & 0x1ff); 
    19421943                        REG_WRITE(ah, ar5416_cca_regs[i], val); 
    19431944                } 
     
    19461947 
    19471948static int16_t ath9k_hw_getnf(struct ath_hal *ah, 
    1948                               struct hal_channel_internal *chan) 
     1949                              struct ath9k_channel *chan) 
    19491950{ 
    19501951        int16_t nf, nfThresh; 
    19511952        int16_t nfarray[NUM_NF_READINGS] = { 0 }; 
    1952         struct hal_nfcal_hist *h; 
    1953         u_int8_t chainmask; 
     1953        struct ath9k_nfcal_hist *h; 
     1954        u8 chainmask; 
    19541955 
    19551956        if (AR_SREV_9280(ah)) 
     
    19921993 
    19931994static void ath9k_hw_update_mibstats(struct ath_hal *ah, 
    1994                               struct hal_mib_stats *stats) 
     1995                              struct ath9k_mib_stats *stats) 
    19951996{ 
    19961997        stats->ackrcv_bad += REG_READ(ah, AR_ACK_FAIL); 
     
    20332034 
    20342035static int ath9k_hw_get_ani_channel_idx(struct ath_hal *ah, 
    2035                                         struct hal_channel_internal *chan) 
     2036                                        struct ath9k_channel *chan) 
    20362037{ 
    20372038        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    20622063        memset(ahp->ah_ani, 0, sizeof(ahp->ah_ani)); 
    20632064        for (i = 0; i < ARRAY_SIZE(ahp->ah_ani); i++) { 
    2064                 ahp->ah_ani[i].ofdmTrigHigh = HAL_ANI_OFDM_TRIG_HIGH; 
    2065                 ahp->ah_ani[i].ofdmTrigLow = HAL_ANI_OFDM_TRIG_LOW; 
    2066                 ahp->ah_ani[i].cckTrigHigh = HAL_ANI_CCK_TRIG_HIGH; 
    2067                 ahp->ah_ani[i].cckTrigLow = HAL_ANI_CCK_TRIG_LOW; 
    2068                 ahp->ah_ani[i].rssiThrHigh = HAL_ANI_RSSI_THR_HIGH; 
    2069                 ahp->ah_ani[i].rssiThrLow = HAL_ANI_RSSI_THR_LOW; 
     2065                ahp->ah_ani[i].ofdmTrigHigh = ATH9K_ANI_OFDM_TRIG_HIGH; 
     2066                ahp->ah_ani[i].ofdmTrigLow = ATH9K_ANI_OFDM_TRIG_LOW; 
     2067                ahp->ah_ani[i].cckTrigHigh = ATH9K_ANI_CCK_TRIG_HIGH; 
     2068                ahp->ah_ani[i].cckTrigLow = ATH9K_ANI_CCK_TRIG_LOW; 
     2069                ahp->ah_ani[i].rssiThrHigh = ATH9K_ANI_RSSI_THR_HIGH; 
     2070                ahp->ah_ani[i].rssiThrLow = ATH9K_ANI_RSSI_THR_LOW; 
    20702071                ahp->ah_ani[i].ofdmWeakSigDetectOff = 
    2071                         !HAL_ANI_USE_OFDM_WEAK_SIG; 
     2072                        !ATH9K_ANI_USE_OFDM_WEAK_SIG; 
    20722073                ahp->ah_ani[i].cckWeakSigThreshold = 
    2073                         HAL_ANI_CCK_WEAK_SIG_THR; 
    2074                 ahp->ah_ani[i].spurImmunityLevel = HAL_ANI_SPUR_IMMUNE_LVL; 
    2075                 ahp->ah_ani[i].firstepLevel = HAL_ANI_FIRSTEP_LVL; 
     2074                        ATH9K_ANI_CCK_WEAK_SIG_THR; 
     2075                ahp->ah_ani[i].spurImmunityLevel = ATH9K_ANI_SPUR_IMMUNE_LVL; 
     2076                ahp->ah_ani[i].firstepLevel = ATH9K_ANI_FIRSTEP_LVL; 
    20762077                if (ahp->ah_hasHwPhyCounters) { 
    20772078                        ahp->ah_ani[i].ofdmPhyErrBase = 
    2078                                 AR_PHY_COUNTMAX - HAL_ANI_OFDM_TRIG_HIGH; 
     2079                                AR_PHY_COUNTMAX - ATH9K_ANI_OFDM_TRIG_HIGH; 
    20792080                        ahp->ah_ani[i].cckPhyErrBase = 
    2080                                 AR_PHY_COUNTMAX - HAL_ANI_CCK_TRIG_HIGH; 
     2081                                AR_PHY_COUNTMAX - ATH9K_ANI_CCK_TRIG_HIGH; 
    20812082                } 
    20822083        } 
     
    20922093                ath9k_enable_mib_counters(ah); 
    20932094        } 
    2094         ahp->ah_aniPeriod = HAL_ANI_PERIOD; 
     2095        ahp->ah_aniPeriod = ATH9K_ANI_PERIOD; 
    20952096        if (ah->ah_config.ath_hal_enableANI) 
    20962097                ahp->ah_procPhyErr |= HAL_PROCESS_ANI; 
     
    21292130 
    21302131static bool ath9k_hw_ani_control(struct ath_hal *ah, 
    2131                                  enum hal_ani_cmd cmd, int param) 
     2132                                 enum ath9k_ani_cmd cmd, int param) 
    21322133{ 
    21332134        struct ath_hal_5416 *ahp = AH5416(ah); 
     
    21352136 
    21362137        switch (cmd & ahp->ah_ani_function) { 
    2137         case HAL_ANI_NOISE_IMMUNITY_LEVEL:{ 
    2138                 u_int level = param; 
     2138        case ATH9K_ANI_NOISE_IMMUNITY_LEVEL:{ 
     2139                u32 level = param; 
    21392140 
    21402141                if (level >= ARRAY_SIZE(ahp->ah_totalSizeDesired)) { 
     
    21672168                break; 
    21682169        } 
    2169         case HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION:{ 
     2170        case ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION:{ 
    21702171                const int m1ThreshLow[] = { 127, 50 }; 
    21712172                const int m2ThreshLow[] = { 127, 40 }; 
     
    21742175                const int m2CountThr[] = { 31, 16 }; 
    21752176                const int m2CountThrLow[] = { 63, 48 }; 
    2176                 u_int on = param ? 1 : 0; 
     2177                u32 on = param ? 1 : 0; 
    21772178 
    21782179                REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 
     
    22242225                break; 
    22252226        } 
    2226         case HAL_ANI_CCK_WEAK_SIGNAL_THR:{ 
     2227        case ATH9K_ANI_CCK_WEAK_SIGNAL_THR:{ 
    22272228                const int weakSigThrCck[] = { 8, 6 }; 
    2228                 u_int high = param ? 1 : 0; 
     2229                u32 high = param ? 1 : 0; 
    22292230 
    22302231                REG_RMW_FIELD(ah, AR_PHY_CCK_DETECT, 
     
    22402241                break; 
    22412242        } 
    2242         case HAL_ANI_FIRSTEP_LEVEL:{ 
     2243        case ATH9K_ANI_FIRSTEP_LEVEL:{ 
    22432244                const int firstep[] = { 0, 4, 8 }; 
    2244                 u_int level = param; 
     2245                u32 level = param; 
    22452246 
    22462247                if (level >= ARRAY_SIZE(firstep)) { 
     
    22612262                break; 
    22622263        } 
    2263         case HAL_ANI_SPUR_IMMUNITY_LEVEL:{ 
     2264        case ATH9K_ANI_SPUR_IMMUNITY_LEVEL:{ 
    22642265                const int cycpwrThr1[] = 
    22652266                        { 2, 4, 6, 8, 10, 12, 14, 16 }; 
    2266                 u_int level = param; 
     2267                u32 level = param; 
    22672268 
    22682269                if (level >= ARRAY_SIZE(cycpwrThr1)) { 
     
    22842285                break; 
    22852286        } 
    2286         case HAL_ANI_PRESENT: 
     2287        case ATH9K_ANI_PRESENT: 
    22872288                break; 
    22882289        default: 
     
    23562357{ 
    23572358        struct ath_hal_5416 *ahp = AH5416(ah); 
    2358         struct hal_channel_internal *chan = ah->ah_curchan; 
     2359        struct ath9k_channel *chan = ah->ah_curchan; 
    23592360        struct ar5416AniState *aniState; 
    23602361        enum wireless_mode mode; 
     
    23672368 
    23682369        if (aniState->noiseImmunityLevel < HAL_NOISE_IMMUNE_MAX) { 
    2369                 if (ath9k_hw_ani_control(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 
     2370                if (ath9k_hw_ani_control(ah, ATH9K_ANI_NOISE_IMMUNITY_LEVEL, 
    23702371                                         aniState->noiseImmunityLevel + 1)) { 
    23712372                        return; 
     
    23742375 
    23752376        if (aniState->spurImmunityLevel < HAL_SPUR_IMMUNE_MAX) { 
    2376                 if (ath9k_hw_ani_control(ah, HAL_ANI_SPUR_IMMUNITY_LEVEL, 
     2377                if (ath9k_hw_ani_control(ah, ATH9K_ANI_SPUR_IMMUNITY_LEVEL, 
    23772378                                         aniState->spurImmunityLevel + 1)) { 
    23782379                        return; 
     
    23802381        } 
    23812382 
    2382         if (ah->ah_opmode == HAL_M_HOSTAP) { 
     2383        if (ah->ah_opmode == ATH9K_M_HOSTAP) { 
    23832384                if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) { 
    2384                         ath9k_hw_ani_control(ah, HAL_ANI_FIRSTEP_LEVEL, 
     2385                        ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, 
    23852386                                             aniState->firstepLevel + 1); 
    23862387                } 
     
    23912392                if (!aniState->ofdmWeakSigDetectOff) { 
    23922393                        if (ath9k_hw_ani_control(ah, 
    2393                                          HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
     2394                                         ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
    23942395                                         false)) { 
    23952396                                ath9k_hw_ani_control(ah, 
    2396                                         HAL_ANI_SPUR_IMMUNITY_LEVEL, 
     2397                                        ATH9K_ANI_SPUR_IMMUNITY_LEVEL, 
    23972398                                        0); 
    23982399                                return; 
     
    24002401                } 
    24012402                if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) { 
    2402                         ath9k_hw_ani_control(ah, HAL_ANI_FIRSTEP_LEVEL, 
     2403                        ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, 
    24032404                                             aniState->firstepLevel + 1); 
    24042405                        return; 
     
    24072408                if (aniState->ofdmWeakSigDetectOff) 
    24082409                        ath9k_hw_ani_control(ah, 
    2409                                              HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
    2410                                              true); 
     2410                                     ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
     2411                                     true); 
    24112412                if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) 
    2412                         ath9k_hw_ani_control(ah, HAL_ANI_FIRSTEP_LEVEL, 
     2413                        ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, 
    24132414                                             aniState->firstepLevel + 1); 
    24142415                return; 
    24152416        } else { 
    2416                 mode = ath9k_hw_chan2wmode(ah, (struct hal_channel *) chan); 
     2417                mode = ath9k_hw_chan2wmode(ah, chan); 
    24172418                if (mode == WIRELESS_MODE_11g || mode == WIRELESS_MODE_11b) { 
    24182419                        if (!aniState->ofdmWeakSigDetectOff) 
    24192420                                ath9k_hw_ani_control(ah, 
    2420                                              HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
    2421                                              false); 
     2421                                     ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
     2422                                     false); 
    24222423                        if (aniState->firstepLevel > 0) 
    24232424                                ath9k_hw_ani_control(ah, 
    2424                                                      HAL_ANI_FIRSTEP_LEVEL, 
     2425                                                     ATH9K_ANI_FIRSTEP_LEVEL, 
    24252426                                                     0); 
    24262427                        return; 
     
    24322433{ 
    24332434        struct ath_hal_5416 *ahp = AH5416(ah); 
    2434         struct hal_channel_internal *chan = ah->ah_curchan; 
     2435        struct ath9k_channel *chan = ah->ah_curchan; 
    24352436        struct ar5416AniState *aniState; 
    24362437        enum wireless_mode mode; 
     
    24422443        aniState = ahp->ah_curani; 
    24432444        if (aniState->noiseImmunityLevel < HAL_NOISE_IMMUNE_MAX) { 
    2444                 if (ath9k_hw_ani_control(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 
     2445                if (ath9k_hw_ani_control(ah, ATH9K_ANI_NOISE_IMMUNITY_LEVEL, 
    24452446                                         aniState->noiseImmunityLevel + 1)) { 
    24462447                        return; 
    24472448                } 
    24482449        } 
    2449         if (ah->ah_opmode == HAL_M_HOSTAP) { 
     2450        if (ah->ah_opmode == ATH9K_M_HOSTAP) { 
    24502451                if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) { 
    2451                         ath9k_hw_ani_control(ah, HAL_ANI_FIRSTEP_LEVEL, 
     2452                        ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, 
    24522453                                             aniState->firstepLevel + 1); 
    24532454                } 
     
    24572458        if (rssi > aniState->rssiThrLow) { 
    24582459                if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) 
    2459                         ath9k_hw_ani_control(ah, HAL_ANI_FIRSTEP_LEVEL, 
     2460                        ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, 
    24602461                                             aniState->firstepLevel + 1); 
    24612462        } else { 
    2462                 mode = ath9k_hw_chan2wmode(ah, (struct hal_channel *) chan); 
     2463                mode = ath9k_hw_chan2wmode(ah, chan); 
    24632464                if (mode == WIRELESS_MODE_11g || mode == WIRELESS_MODE_11b) { 
    24642465                        if (aniState->firstepLevel > 0) 
    24652466                                ath9k_hw_ani_control(ah, 
    2466                                                      HAL_ANI_FIRSTEP_LEVEL, 
     2467                                                     ATH9K_ANI_FIRSTEP_LEVEL, 
    24672468                                                     0); 
    24682469                } 
     
    24742475        struct ath_hal_5416 *ahp = AH5416(ah); 
    24752476        struct ar5416AniState *aniState; 
    2476         struct hal_channel_internal *chan = ah->ah_curchan; 
     2477        struct ath9k_channel *chan = ah->ah_curchan; 
    24772478        int index; 
    24782479 
     
    24842485        ahp->ah_curani = aniState; 
    24852486 
    2486         if (DO_ANI(ah) && ah->ah_opmode != HAL_M_STA 
    2487             && ah->ah_opmode != HAL_M_IBSS) { 
     2487        if (DO_ANI(ah) && ah->ah_opmode != ATH9K_M_STA 
     2488            && ah->ah_opmode != ATH9K_M_IBSS) { 
    24882489                DPRINTF(ah->ah_sc, ATH_DBG_ANI, 
    24892490                         "%s: Reset ANI state opmode %u\n", __func__, 
    24902491                         ah->ah_opmode); 
    24912492                ahp->ah_stats.ast_ani_reset++; 
    2492                 ath9k_hw_ani_control(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 0); 
    2493                 ath9k_hw_ani_control(ah, HAL_ANI_SPUR_IMMUNITY_LEVEL, 0); 
    2494                 ath9k_hw_ani_control(ah, HAL_ANI_FIRSTEP_LEVEL, 0); 
     2493                ath9k_hw_ani_control(ah, ATH9K_ANI_NOISE_IMMUNITY_LEVEL, 0); 
     2494                ath9k_hw_ani_control(ah, ATH9K_ANI_SPUR_IMMUNITY_LEVEL, 0); 
     2495                ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, 0); 
    24952496                ath9k_hw_ani_control(ah, 
    2496                                      HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
    2497                                      !HAL_ANI_USE_OFDM_WEAK_SIG); 
    2498                 ath9k_hw_ani_control(ah, HAL_ANI_CCK_WEAK_SIGNAL_THR, 
    2499                                      HAL_ANI_CCK_WEAK_SIG_THR); 
     2497                                     ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
     2498                                     !ATH9K_ANI_USE_OFDM_WEAK_SIG); 
     2499                ath9k_hw_ani_control(ah, ATH9K_ANI_CCK_WEAK_SIGNAL_THR, 
     2500                                     ATH9K_ANI_CCK_WEAK_SIG_THR); 
    25002501                ath9k_hw_setrxfilter(ah, 
    25012502                                     ath9k_hw_getrxfilter(ah) | 
    2502                                      HAL_RX_FILTER_PHYERR); 
    2503                 if (ah->ah_opmode == HAL_M_HOSTAP) { 
     2503                                     ATH9K_RX_FILTER_PHYERR); 
     2504                if (ah->ah_opmode == ATH9K_M_HOSTAP) { 
    25042505                        ahp->ah_curani->ofdmTrigHigh = 
    25052506                                ah->ah_config.ath_hal_ofdmTrigHigh; 
     
    25162517 
    25172518        if (aniState->noiseImmunityLevel != 0) 
    2518                 ath9k_hw_ani_control(ah, HAL_ANI_NOISE_IMMUNITY_LEVEL, 
     2519                ath9k_hw_ani_control(ah, ATH9K_ANI_NOISE_IMMUNITY_LEVEL, 
    25192520                                     aniState->noiseImmunityLevel); 
    25202521        if (aniState->spurImmunityLevel != 0) 
    2521                 ath9k_hw_ani_control(ah, HAL_ANI_SPUR_IMMUNITY_LEVEL, 
     2522                ath9k_hw_ani_control(ah, ATH9K_ANI_SPUR_IMMUNITY_LEVEL, 
    25222523                                     aniState->spurImmunityLevel); 
    25232524        if (aniState->ofdmWeakSigDetectOff) 
    25242525                ath9k_hw_ani_control(ah, 
    2525                                      HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
     2526                                     ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, 
    25262527                                     !aniState->ofdmWeakSigDetectOff); 
    25272528        if (aniState->cckWeakSigThreshold) 
    2528                 ath9k_hw_ani_control(ah, HAL_ANI_CCK_WEAK_SIGNAL_THR, 
     2529                ath9k_hw_ani_control(ah, ATH9K_ANI_CCK_WEAK_SIGNAL_THR, 
    25292530                                     aniState->cckWeakSigThreshold); 
    25302531        if (aniState->firstepLevel != 0) 
    2531                 ath9k_hw_ani_control(ah, HAL_ANI_FIRSTEP_LEVEL, 
     2532                ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, 
    25322533                                     aniState->firstepLevel); 
    25332534        if