2 * Copyright (c) 2008 Atheros Communications Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 #include <asm/unaligned.h>
26 static void ath9k_hw_iqcal_collect(struct ath_hal
*ah
);
27 static void ath9k_hw_iqcalibrate(struct ath_hal
*ah
, u8 numChains
);
28 static void ath9k_hw_adc_gaincal_collect(struct ath_hal
*ah
);
29 static void ath9k_hw_adc_gaincal_calibrate(struct ath_hal
*ah
,
31 static void ath9k_hw_adc_dccal_collect(struct ath_hal
*ah
);
32 static void ath9k_hw_adc_dccal_calibrate(struct ath_hal
*ah
,
35 static const u8 CLOCK_RATE
[] = { 40, 80, 22, 44, 88, 40 };
36 static const int16_t NOISE_FLOOR
[] = { -96, -93, -98, -96, -93, -96 };
38 static const struct hal_percal_data iq_cal_multi_sample
= {
42 ath9k_hw_iqcal_collect
,
45 static const struct hal_percal_data iq_cal_single_sample
= {
49 ath9k_hw_iqcal_collect
,
52 static const struct hal_percal_data adc_gain_cal_multi_sample
= {
56 ath9k_hw_adc_gaincal_collect
,
57 ath9k_hw_adc_gaincal_calibrate
59 static const struct hal_percal_data adc_gain_cal_single_sample
= {
63 ath9k_hw_adc_gaincal_collect
,
64 ath9k_hw_adc_gaincal_calibrate
66 static const struct hal_percal_data adc_dc_cal_multi_sample
= {
70 ath9k_hw_adc_dccal_collect
,
71 ath9k_hw_adc_dccal_calibrate
73 static const struct hal_percal_data adc_dc_cal_single_sample
= {
77 ath9k_hw_adc_dccal_collect
,
78 ath9k_hw_adc_dccal_calibrate
80 static const struct hal_percal_data adc_init_dc_cal
= {
84 ath9k_hw_adc_dccal_collect
,
85 ath9k_hw_adc_dccal_calibrate
88 static struct ath9k_rate_table ar5416_11a_table
= {
92 {true, PHY_OFDM
, 6000, 0x0b, 0x00, (0x80 | 12), 0},
93 {true, PHY_OFDM
, 9000, 0x0f, 0x00, 18, 0},
94 {true, PHY_OFDM
, 12000, 0x0a, 0x00, (0x80 | 24), 2},
95 {true, PHY_OFDM
, 18000, 0x0e, 0x00, 36, 2},
96 {true, PHY_OFDM
, 24000, 0x09, 0x00, (0x80 | 48), 4},
97 {true, PHY_OFDM
, 36000, 0x0d, 0x00, 72, 4},
98 {true, PHY_OFDM
, 48000, 0x08, 0x00, 96, 4},
99 {true, PHY_OFDM
, 54000, 0x0c, 0x00, 108, 4}
103 static struct ath9k_rate_table ar5416_11b_table
= {
107 {true, PHY_CCK
, 1000, 0x1b, 0x00, (0x80 | 2), 0},
108 {true, PHY_CCK
, 2000, 0x1a, 0x04, (0x80 | 4), 1},
109 {true, PHY_CCK
, 5500, 0x19, 0x04, (0x80 | 11), 1},
110 {true, PHY_CCK
, 11000, 0x18, 0x04, (0x80 | 22), 1}
114 static struct ath9k_rate_table ar5416_11g_table
= {
118 {true, PHY_CCK
, 1000, 0x1b, 0x00, (0x80 | 2), 0},
119 {true, PHY_CCK
, 2000, 0x1a, 0x04, (0x80 | 4), 1},
120 {true, PHY_CCK
, 5500, 0x19, 0x04, (0x80 | 11), 2},
121 {true, PHY_CCK
, 11000, 0x18, 0x04, (0x80 | 22), 3},
123 {false, PHY_OFDM
, 6000, 0x0b, 0x00, 12, 4},
124 {false, PHY_OFDM
, 9000, 0x0f, 0x00, 18, 4},
125 {true, PHY_OFDM
, 12000, 0x0a, 0x00, 24, 6},
126 {true, PHY_OFDM
, 18000, 0x0e, 0x00, 36, 6},
127 {true, PHY_OFDM
, 24000, 0x09, 0x00, 48, 8},
128 {true, PHY_OFDM
, 36000, 0x0d, 0x00, 72, 8},
129 {true, PHY_OFDM
, 48000, 0x08, 0x00, 96, 8},
130 {true, PHY_OFDM
, 54000, 0x0c, 0x00, 108, 8}
134 static struct ath9k_rate_table ar5416_11ng_table
= {
138 {true, PHY_CCK
, 1000, 0x1b, 0x00, (0x80 | 2), 0},
139 {true, PHY_CCK
, 2000, 0x1a, 0x04, (0x80 | 4), 1},
140 {true, PHY_CCK
, 5500, 0x19, 0x04, (0x80 | 11), 2},
141 {true, PHY_CCK
, 11000, 0x18, 0x04, (0x80 | 22), 3},
143 {false, PHY_OFDM
, 6000, 0x0b, 0x00, 12, 4},
144 {false, PHY_OFDM
, 9000, 0x0f, 0x00, 18, 4},
145 {true, PHY_OFDM
, 12000, 0x0a, 0x00, 24, 6},
146 {true, PHY_OFDM
, 18000, 0x0e, 0x00, 36, 6},
147 {true, PHY_OFDM
, 24000, 0x09, 0x00, 48, 8},
148 {true, PHY_OFDM
, 36000, 0x0d, 0x00, 72, 8},
149 {true, PHY_OFDM
, 48000, 0x08, 0x00, 96, 8},
150 {true, PHY_OFDM
, 54000, 0x0c, 0x00, 108, 8},
151 {true, PHY_HT
, 6500, 0x80, 0x00, 0, 4},
152 {true, PHY_HT
, 13000, 0x81, 0x00, 1, 6},
153 {true, PHY_HT
, 19500, 0x82, 0x00, 2, 6},
154 {true, PHY_HT
, 26000, 0x83, 0x00, 3, 8},
155 {true, PHY_HT
, 39000, 0x84, 0x00, 4, 8},
156 {true, PHY_HT
, 52000, 0x85, 0x00, 5, 8},
157 {true, PHY_HT
, 58500, 0x86, 0x00, 6, 8},
158 {true, PHY_HT
, 65000, 0x87, 0x00, 7, 8},
159 {true, PHY_HT
, 13000, 0x88, 0x00, 8, 4},
160 {true, PHY_HT
, 26000, 0x89, 0x00, 9, 6},
161 {true, PHY_HT
, 39000, 0x8a, 0x00, 10, 6},
162 {true, PHY_HT
, 52000, 0x8b, 0x00, 11, 8},
163 {true, PHY_HT
, 78000, 0x8c, 0x00, 12, 8},
164 {true, PHY_HT
, 104000, 0x8d, 0x00, 13, 8},
165 {true, PHY_HT
, 117000, 0x8e, 0x00, 14, 8},
166 {true, PHY_HT
, 130000, 0x8f, 0x00, 15, 8},
170 static struct ath9k_rate_table ar5416_11na_table
= {
174 {true, PHY_OFDM
, 6000, 0x0b, 0x00, (0x80 | 12), 0},
175 {true, PHY_OFDM
, 9000, 0x0f, 0x00, 18, 0},
176 {true, PHY_OFDM
, 12000, 0x0a, 0x00, (0x80 | 24), 2},
177 {true, PHY_OFDM
, 18000, 0x0e, 0x00, 36, 2},
178 {true, PHY_OFDM
, 24000, 0x09, 0x00, (0x80 | 48), 4},
179 {true, PHY_OFDM
, 36000, 0x0d, 0x00, 72, 4},
180 {true, PHY_OFDM
, 48000, 0x08, 0x00, 96, 4},
181 {true, PHY_OFDM
, 54000, 0x0c, 0x00, 108, 4},
182 {true, PHY_HT
, 6500, 0x80, 0x00, 0, 0},
183 {true, PHY_HT
, 13000, 0x81, 0x00, 1, 2},
184 {true, PHY_HT
, 19500, 0x82, 0x00, 2, 2},
185 {true, PHY_HT
, 26000, 0x83, 0x00, 3, 4},
186 {true, PHY_HT
, 39000, 0x84, 0x00, 4, 4},
187 {true, PHY_HT
, 52000, 0x85, 0x00, 5, 4},
188 {true, PHY_HT
, 58500, 0x86, 0x00, 6, 4},
189 {true, PHY_HT
, 65000, 0x87, 0x00, 7, 4},
190 {true, PHY_HT
, 13000, 0x88, 0x00, 8, 0},
191 {true, PHY_HT
, 26000, 0x89, 0x00, 9, 2},
192 {true, PHY_HT
, 39000, 0x8a, 0x00, 10, 2},
193 {true, PHY_HT
, 52000, 0x8b, 0x00, 11, 4},
194 {true, PHY_HT
, 78000, 0x8c, 0x00, 12, 4},
195 {true, PHY_HT
, 104000, 0x8d, 0x00, 13, 4},
196 {true, PHY_HT
, 117000, 0x8e, 0x00, 14, 4},
197 {true, PHY_HT
, 130000, 0x8f, 0x00, 15, 4},
201 static enum wireless_mode
ath9k_hw_chan2wmode(struct ath_hal
*ah
,
202 const struct ath9k_channel
*chan
)
204 if (IS_CHAN_CCK(chan
))
205 return ATH9K_MODE_11A
;
207 return ATH9K_MODE_11G
;
208 return ATH9K_MODE_11A
;
211 static bool ath9k_hw_wait(struct ath_hal
*ah
,
218 for (i
= 0; i
< (AH_TIMEOUT
/ AH_TIME_QUANTUM
); i
++) {
219 if ((REG_READ(ah
, reg
) & mask
) == val
)
222 udelay(AH_TIME_QUANTUM
);
224 DPRINTF(ah
->ah_sc
, ATH_DBG_PHY_IO
,
225 "%s: timeout on reg 0x%x: 0x%08x & 0x%08x != 0x%08x\n",
226 __func__
, reg
, REG_READ(ah
, reg
), mask
, val
);
230 static bool ath9k_hw_eeprom_read(struct ath_hal
*ah
, u32 off
,
233 (void) REG_READ(ah
, AR5416_EEPROM_OFFSET
+ (off
<< AR5416_EEPROM_S
));
235 if (!ath9k_hw_wait(ah
,
236 AR_EEPROM_STATUS_DATA
,
237 AR_EEPROM_STATUS_DATA_BUSY
|
238 AR_EEPROM_STATUS_DATA_PROT_ACCESS
, 0)) {
242 *data
= MS(REG_READ(ah
, AR_EEPROM_STATUS_DATA
),
243 AR_EEPROM_STATUS_DATA_VAL
);
248 static int ath9k_hw_flash_map(struct ath_hal
*ah
)
250 struct ath_hal_5416
*ahp
= AH5416(ah
);
252 ahp
->ah_cal_mem
= ioremap(AR5416_EEPROM_START_ADDR
, AR5416_EEPROM_MAX
);
254 if (!ahp
->ah_cal_mem
) {
255 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
256 "%s: cannot remap eeprom region \n", __func__
);
263 static bool ath9k_hw_flash_read(struct ath_hal
*ah
, u32 off
,
266 struct ath_hal_5416
*ahp
= AH5416(ah
);
268 *data
= ioread16(ahp
->ah_cal_mem
+ off
);
272 static void ath9k_hw_read_revisions(struct ath_hal
*ah
)
276 val
= REG_READ(ah
, AR_SREV
) & AR_SREV_ID
;
279 val
= REG_READ(ah
, AR_SREV
);
282 (val
& AR_SREV_VERSION2
) >> AR_SREV_TYPE2_S
;
284 ah
->ah_macRev
= MS(val
, AR_SREV_REVISION2
);
285 ah
->ah_isPciExpress
=
286 (val
& AR_SREV_TYPE2_HOST_MODE
) ? 0 : 1;
289 if (!AR_SREV_9100(ah
))
290 ah
->ah_macVersion
= MS(val
, AR_SREV_VERSION
);
292 ah
->ah_macRev
= val
& AR_SREV_REVISION
;
294 if (ah
->ah_macVersion
== AR_SREV_VERSION_5416_PCIE
)
295 ah
->ah_isPciExpress
= true;
299 u32
ath9k_hw_reverse_bits(u32 val
, u32 n
)
304 for (i
= 0, retval
= 0; i
< n
; i
++) {
305 retval
= (retval
<< 1) | (val
& 1);
311 static void ath9k_hw_set_defaults(struct ath_hal
*ah
)
315 ah
->ah_config
.dma_beacon_response_time
= 2;
316 ah
->ah_config
.sw_beacon_response_time
= 10;
317 ah
->ah_config
.additional_swba_backoff
= 0;
318 ah
->ah_config
.ack_6mb
= 0x0;
319 ah
->ah_config
.cwm_ignore_extcca
= 0;
320 ah
->ah_config
.pcie_powersave_enable
= 0;
321 ah
->ah_config
.pcie_l1skp_enable
= 0;
322 ah
->ah_config
.pcie_clock_req
= 0;
323 ah
->ah_config
.pcie_power_reset
= 0x100;
324 ah
->ah_config
.pcie_restore
= 0;
325 ah
->ah_config
.pcie_waen
= 0;
326 ah
->ah_config
.analog_shiftreg
= 1;
327 ah
->ah_config
.ht_enable
= 1;
328 ah
->ah_config
.ofdm_trig_low
= 200;
329 ah
->ah_config
.ofdm_trig_high
= 500;
330 ah
->ah_config
.cck_trig_high
= 200;
331 ah
->ah_config
.cck_trig_low
= 100;
332 ah
->ah_config
.enable_ani
= 0;
333 ah
->ah_config
.noise_immunity_level
= 4;
334 ah
->ah_config
.ofdm_weaksignal_det
= 1;
335 ah
->ah_config
.cck_weaksignal_thr
= 0;
336 ah
->ah_config
.spur_immunity_level
= 2;
337 ah
->ah_config
.firstep_level
= 0;
338 ah
->ah_config
.rssi_thr_high
= 40;
339 ah
->ah_config
.rssi_thr_low
= 7;
340 ah
->ah_config
.diversity_control
= 0;
341 ah
->ah_config
.antenna_switch_swap
= 0;
343 for (i
= 0; i
< AR_EEPROM_MODAL_SPURS
; i
++) {
344 ah
->ah_config
.spurchans
[i
][0] = AR_NO_SPUR
;
345 ah
->ah_config
.spurchans
[i
][1] = AR_NO_SPUR
;
348 ah
->ah_config
.intr_mitigation
= 0;
351 static inline void ath9k_hw_override_ini(struct ath_hal
*ah
,
352 struct ath9k_channel
*chan
)
354 if (!AR_SREV_5416_V20_OR_LATER(ah
)
355 || AR_SREV_9280_10_OR_LATER(ah
))
358 REG_WRITE(ah
, 0x9800 + (651 << 2), 0x11);
361 static inline void ath9k_hw_init_bb(struct ath_hal
*ah
,
362 struct ath9k_channel
*chan
)
366 synthDelay
= REG_READ(ah
, AR_PHY_RX_DELAY
) & AR_PHY_RX_DELAY_DELAY
;
367 if (IS_CHAN_CCK(chan
))
368 synthDelay
= (4 * synthDelay
) / 22;
372 REG_WRITE(ah
, AR_PHY_ACTIVE
, AR_PHY_ACTIVE_EN
);
374 udelay(synthDelay
+ BASE_ACTIVATE_DELAY
);
377 static inline void ath9k_hw_init_interrupt_masks(struct ath_hal
*ah
,
378 enum ath9k_opmode opmode
)
380 struct ath_hal_5416
*ahp
= AH5416(ah
);
382 ahp
->ah_maskReg
= AR_IMR_TXERR
|
388 if (ahp
->ah_intrMitigation
)
389 ahp
->ah_maskReg
|= AR_IMR_RXINTM
| AR_IMR_RXMINTR
;
391 ahp
->ah_maskReg
|= AR_IMR_RXOK
;
393 ahp
->ah_maskReg
|= AR_IMR_TXOK
;
395 if (opmode
== ATH9K_M_HOSTAP
)
396 ahp
->ah_maskReg
|= AR_IMR_MIB
;
398 REG_WRITE(ah
, AR_IMR
, ahp
->ah_maskReg
);
399 REG_WRITE(ah
, AR_IMR_S2
, REG_READ(ah
, AR_IMR_S2
) | AR_IMR_S2_GTT
);
401 if (!AR_SREV_9100(ah
)) {
402 REG_WRITE(ah
, AR_INTR_SYNC_CAUSE
, 0xFFFFFFFF);
403 REG_WRITE(ah
, AR_INTR_SYNC_ENABLE
, AR_INTR_SYNC_DEFAULT
);
404 REG_WRITE(ah
, AR_INTR_SYNC_MASK
, 0);
408 static inline void ath9k_hw_init_qos(struct ath_hal
*ah
)
410 REG_WRITE(ah
, AR_MIC_QOS_CONTROL
, 0x100aa);
411 REG_WRITE(ah
, AR_MIC_QOS_SELECT
, 0x3210);
413 REG_WRITE(ah
, AR_QOS_NO_ACK
,
414 SM(2, AR_QOS_NO_ACK_TWO_BIT
) |
415 SM(5, AR_QOS_NO_ACK_BIT_OFF
) |
416 SM(0, AR_QOS_NO_ACK_BYTE_OFF
));
418 REG_WRITE(ah
, AR_TXOP_X
, AR_TXOP_X_VAL
);
419 REG_WRITE(ah
, AR_TXOP_0_3
, 0xFFFFFFFF);
420 REG_WRITE(ah
, AR_TXOP_4_7
, 0xFFFFFFFF);
421 REG_WRITE(ah
, AR_TXOP_8_11
, 0xFFFFFFFF);
422 REG_WRITE(ah
, AR_TXOP_12_15
, 0xFFFFFFFF);
425 static void ath9k_hw_analog_shift_rmw(struct ath_hal
*ah
,
433 regVal
= REG_READ(ah
, reg
) & ~mask
;
434 regVal
|= (val
<< shift
) & mask
;
436 REG_WRITE(ah
, reg
, regVal
);
438 if (ah
->ah_config
.analog_shiftreg
)
444 static u8
ath9k_hw_get_num_ant_config(struct ath_hal_5416
*ahp
,
445 enum ieee80211_band freq_band
)
447 struct ar5416_eeprom
*eep
= &ahp
->ah_eeprom
;
448 struct modal_eep_header
*pModal
=
449 &(eep
->modalHeader
[IEEE80211_BAND_5GHZ
== freq_band
]);
450 struct base_eep_header
*pBase
= &eep
->baseEepHeader
;
455 if (pBase
->version
>= 0x0E0D)
459 return num_ant_config
;
463 ath9k_hw_get_eeprom_antenna_cfg(struct ath_hal_5416
*ahp
,
464 struct ath9k_channel
*chan
,
468 struct ar5416_eeprom
*eep
= &ahp
->ah_eeprom
;
469 struct modal_eep_header
*pModal
=
470 &(eep
->modalHeader
[IS_CHAN_2GHZ(chan
)]);
471 struct base_eep_header
*pBase
= &eep
->baseEepHeader
;
475 *config
= pModal
->antCtrlCommon
& 0xFFFF;
478 if (pBase
->version
>= 0x0E0D) {
479 if (pModal
->useAnt1
) {
481 ((pModal
->antCtrlCommon
& 0xFFFF0000) >> 16);
493 static inline bool ath9k_hw_nvram_read(struct ath_hal
*ah
,
497 if (ath9k_hw_use_flash(ah
))
498 return ath9k_hw_flash_read(ah
, off
, data
);
500 return ath9k_hw_eeprom_read(ah
, off
, data
);
503 static inline bool ath9k_hw_fill_eeprom(struct ath_hal
*ah
)
505 struct ath_hal_5416
*ahp
= AH5416(ah
);
506 struct ar5416_eeprom
*eep
= &ahp
->ah_eeprom
;
508 int addr
, ar5416_eep_start_loc
= 0;
510 if (!ath9k_hw_use_flash(ah
)) {
511 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
512 "%s: Reading from EEPROM, not flash\n", __func__
);
513 ar5416_eep_start_loc
= 256;
515 if (AR_SREV_9100(ah
))
516 ar5416_eep_start_loc
= 256;
518 eep_data
= (u16
*) eep
;
520 addr
< sizeof(struct ar5416_eeprom
) / sizeof(u16
);
522 if (!ath9k_hw_nvram_read(ah
, addr
+ ar5416_eep_start_loc
,
524 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
525 "%s: Unable to read eeprom region \n",
534 /* XXX: Clean me up, make me more legible */
536 ath9k_hw_eeprom_set_board_values(struct ath_hal
*ah
,
537 struct ath9k_channel
*chan
)
539 struct modal_eep_header
*pModal
;
540 int i
, regChainOffset
;
541 struct ath_hal_5416
*ahp
= AH5416(ah
);
542 struct ar5416_eeprom
*eep
= &ahp
->ah_eeprom
;
546 pModal
= &(eep
->modalHeader
[IS_CHAN_2GHZ(chan
)]);
548 txRxAttenLocal
= IS_CHAN_2GHZ(chan
) ? 23 : 44;
550 ath9k_hw_get_eeprom_antenna_cfg(ahp
, chan
, 1, &ant_config
);
551 REG_WRITE(ah
, AR_PHY_SWITCH_COM
, ant_config
);
553 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
554 if (AR_SREV_9280(ah
)) {
559 if (AR_SREV_5416_V20_OR_LATER(ah
) &&
560 (ahp
->ah_rxchainmask
== 5 || ahp
->ah_txchainmask
== 5)
562 regChainOffset
= (i
== 1) ? 0x2000 : 0x1000;
564 regChainOffset
= i
* 0x1000;
566 REG_WRITE(ah
, AR_PHY_SWITCH_CHAIN_0
+ regChainOffset
,
567 pModal
->antCtrlChain
[i
]);
569 REG_WRITE(ah
, AR_PHY_TIMING_CTRL4(0) + regChainOffset
,
571 AR_PHY_TIMING_CTRL4(0) +
573 ~(AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF
|
574 AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF
)) |
575 SM(pModal
->iqCalICh
[i
],
576 AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF
) |
577 SM(pModal
->iqCalQCh
[i
],
578 AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF
));
580 if ((i
== 0) || AR_SREV_5416_V20_OR_LATER(ah
)) {
581 if ((eep
->baseEepHeader
.version
&
582 AR5416_EEP_VER_MINOR_MASK
) >=
583 AR5416_EEP_MINOR_VER_3
) {
584 txRxAttenLocal
= pModal
->txRxAttenCh
[i
];
585 if (AR_SREV_9280_10_OR_LATER(ah
)) {
589 AR_PHY_GAIN_2GHZ_XATTEN1_MARGIN
,
595 AR_PHY_GAIN_2GHZ_XATTEN1_DB
,
601 AR_PHY_GAIN_2GHZ_XATTEN2_MARGIN
,
607 AR_PHY_GAIN_2GHZ_XATTEN2_DB
,
617 ~AR_PHY_GAIN_2GHZ_BSW_MARGIN
)
620 AR_PHY_GAIN_2GHZ_BSW_MARGIN
));
627 ~AR_PHY_GAIN_2GHZ_BSW_ATTEN
)
628 | SM(pModal
->bswAtten
[i
],
629 AR_PHY_GAIN_2GHZ_BSW_ATTEN
));
632 if (AR_SREV_9280_10_OR_LATER(ah
)) {
636 AR9280_PHY_RXGAIN_TXRX_ATTEN
,
641 AR9280_PHY_RXGAIN_TXRX_MARGIN
,
642 pModal
->rxTxMarginCh
[i
]);
645 AR_PHY_RXGAIN
+ regChainOffset
,
649 ~AR_PHY_RXGAIN_TXRX_ATTEN
) |
651 AR_PHY_RXGAIN_TXRX_ATTEN
));
658 ~AR_PHY_GAIN_2GHZ_RXTX_MARGIN
) |
659 SM(pModal
->rxTxMarginCh
[i
],
660 AR_PHY_GAIN_2GHZ_RXTX_MARGIN
));
665 if (AR_SREV_9280_10_OR_LATER(ah
)) {
666 if (IS_CHAN_2GHZ(chan
)) {
667 ath9k_hw_analog_shift_rmw(ah
, AR_AN_RF2G1_CH0
,
669 AR_AN_RF2G1_CH0_OB_S
,
671 ath9k_hw_analog_shift_rmw(ah
, AR_AN_RF2G1_CH0
,
673 AR_AN_RF2G1_CH0_DB_S
,
675 ath9k_hw_analog_shift_rmw(ah
, AR_AN_RF2G1_CH1
,
677 AR_AN_RF2G1_CH1_OB_S
,
679 ath9k_hw_analog_shift_rmw(ah
, AR_AN_RF2G1_CH1
,
681 AR_AN_RF2G1_CH1_DB_S
,
684 ath9k_hw_analog_shift_rmw(ah
, AR_AN_RF5G1_CH0
,
686 AR_AN_RF5G1_CH0_OB5_S
,
688 ath9k_hw_analog_shift_rmw(ah
, AR_AN_RF5G1_CH0
,
690 AR_AN_RF5G1_CH0_DB5_S
,
692 ath9k_hw_analog_shift_rmw(ah
, AR_AN_RF5G1_CH1
,
694 AR_AN_RF5G1_CH1_OB5_S
,
696 ath9k_hw_analog_shift_rmw(ah
, AR_AN_RF5G1_CH1
,
698 AR_AN_RF5G1_CH1_DB5_S
,
701 ath9k_hw_analog_shift_rmw(ah
, AR_AN_TOP2
,
702 AR_AN_TOP2_XPABIAS_LVL
,
703 AR_AN_TOP2_XPABIAS_LVL_S
,
705 ath9k_hw_analog_shift_rmw(ah
, AR_AN_TOP2
,
706 AR_AN_TOP2_LOCALBIAS
,
707 AR_AN_TOP2_LOCALBIAS_S
,
709 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
, "ForceXPAon: %d\n",
710 pModal
->force_xpaon
);
711 REG_RMW_FIELD(ah
, AR_PHY_XPA_CFG
, AR_PHY_FORCE_XPA_CFG
,
712 pModal
->force_xpaon
);
715 REG_RMW_FIELD(ah
, AR_PHY_SETTLING
, AR_PHY_SETTLING_SWITCH
,
716 pModal
->switchSettling
);
717 REG_RMW_FIELD(ah
, AR_PHY_DESIRED_SZ
, AR_PHY_DESIRED_SZ_ADC
,
718 pModal
->adcDesiredSize
);
720 if (!AR_SREV_9280_10_OR_LATER(ah
))
721 REG_RMW_FIELD(ah
, AR_PHY_DESIRED_SZ
,
722 AR_PHY_DESIRED_SZ_PGA
,
723 pModal
->pgaDesiredSize
);
725 REG_WRITE(ah
, AR_PHY_RF_CTL4
,
726 SM(pModal
->txEndToXpaOff
, AR_PHY_RF_CTL4_TX_END_XPAA_OFF
)
727 | SM(pModal
->txEndToXpaOff
,
728 AR_PHY_RF_CTL4_TX_END_XPAB_OFF
)
729 | SM(pModal
->txFrameToXpaOn
,
730 AR_PHY_RF_CTL4_FRAME_XPAA_ON
)
731 | SM(pModal
->txFrameToXpaOn
,
732 AR_PHY_RF_CTL4_FRAME_XPAB_ON
));
734 REG_RMW_FIELD(ah
, AR_PHY_RF_CTL3
, AR_PHY_TX_END_TO_A2_RX_ON
,
735 pModal
->txEndToRxOn
);
736 if (AR_SREV_9280_10_OR_LATER(ah
)) {
737 REG_RMW_FIELD(ah
, AR_PHY_CCA
, AR9280_PHY_CCA_THRESH62
,
739 REG_RMW_FIELD(ah
, AR_PHY_EXT_CCA0
,
740 AR_PHY_EXT_CCA0_THRESH62
,
743 REG_RMW_FIELD(ah
, AR_PHY_CCA
, AR_PHY_CCA_THRESH62
,
745 REG_RMW_FIELD(ah
, AR_PHY_EXT_CCA
,
746 AR_PHY_EXT_CCA_THRESH62
,
750 if ((eep
->baseEepHeader
.version
& AR5416_EEP_VER_MINOR_MASK
) >=
751 AR5416_EEP_MINOR_VER_2
) {
752 REG_RMW_FIELD(ah
, AR_PHY_RF_CTL2
,
753 AR_PHY_TX_END_DATA_START
,
754 pModal
->txFrameToDataStart
);
755 REG_RMW_FIELD(ah
, AR_PHY_RF_CTL2
, AR_PHY_TX_END_PA_ON
,
756 pModal
->txFrameToPaOn
);
759 if ((eep
->baseEepHeader
.version
& AR5416_EEP_VER_MINOR_MASK
) >=
760 AR5416_EEP_MINOR_VER_3
) {
761 if (IS_CHAN_HT40(chan
))
762 REG_RMW_FIELD(ah
, AR_PHY_SETTLING
,
763 AR_PHY_SETTLING_SWITCH
,
764 pModal
->swSettleHt40
);
770 static inline int ath9k_hw_check_eeprom(struct ath_hal
*ah
)
775 struct ath_hal_5416
*ahp
= AH5416(ah
);
776 bool need_swap
= false;
777 struct ar5416_eeprom
*eep
=
778 (struct ar5416_eeprom
*) &ahp
->ah_eeprom
;
780 if (!ath9k_hw_use_flash(ah
)) {
784 if (!ath9k_hw_nvram_read(ah
, AR5416_EEPROM_MAGIC_OFFSET
,
786 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
787 "%s: Reading Magic # failed\n", __func__
);
790 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
, "%s: Read Magic = 0x%04X\n",
793 if (magic
!= AR5416_EEPROM_MAGIC
) {
794 magic2
= swab16(magic
);
796 if (magic2
== AR5416_EEPROM_MAGIC
) {
798 eepdata
= (u16
*) (&ahp
->ah_eeprom
);
802 sizeof(struct ar5416_eeprom
) /
803 sizeof(u16
); addr
++) {
806 temp
= swab16(*eepdata
);
810 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
811 "0x%04X ", *eepdata
);
812 if (((addr
+ 1) % 6) == 0)
818 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
819 "Invalid EEPROM Magic. "
820 "endianness missmatch.\n");
825 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
, "need_swap = %s.\n",
826 need_swap
? "True" : "False");
829 el
= swab16(ahp
->ah_eeprom
.baseEepHeader
.length
);
831 el
= ahp
->ah_eeprom
.baseEepHeader
.length
;
833 if (el
> sizeof(struct ar5416_eeprom
))
834 el
= sizeof(struct ar5416_eeprom
) / sizeof(u16
);
836 el
= el
/ sizeof(u16
);
838 eepdata
= (u16
*) (&ahp
->ah_eeprom
);
840 for (i
= 0; i
< el
; i
++)
847 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
848 "EEPROM Endianness is not native.. Changing \n");
850 word
= swab16(eep
->baseEepHeader
.length
);
851 eep
->baseEepHeader
.length
= word
;
853 word
= swab16(eep
->baseEepHeader
.checksum
);
854 eep
->baseEepHeader
.checksum
= word
;
856 word
= swab16(eep
->baseEepHeader
.version
);
857 eep
->baseEepHeader
.version
= word
;
859 word
= swab16(eep
->baseEepHeader
.regDmn
[0]);
860 eep
->baseEepHeader
.regDmn
[0] = word
;
862 word
= swab16(eep
->baseEepHeader
.regDmn
[1]);
863 eep
->baseEepHeader
.regDmn
[1] = word
;
865 word
= swab16(eep
->baseEepHeader
.rfSilent
);
866 eep
->baseEepHeader
.rfSilent
= word
;
868 word
= swab16(eep
->baseEepHeader
.blueToothOptions
);
869 eep
->baseEepHeader
.blueToothOptions
= word
;
871 word
= swab16(eep
->baseEepHeader
.deviceCap
);
872 eep
->baseEepHeader
.deviceCap
= word
;
874 for (j
= 0; j
< ARRAY_SIZE(eep
->modalHeader
); j
++) {
875 struct modal_eep_header
*pModal
=
876 &eep
->modalHeader
[j
];
877 integer
= swab32(pModal
->antCtrlCommon
);
878 pModal
->antCtrlCommon
= integer
;
880 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
881 integer
= swab32(pModal
->antCtrlChain
[i
]);
882 pModal
->antCtrlChain
[i
] = integer
;
885 for (i
= 0; i
< AR5416_EEPROM_MODAL_SPURS
; i
++) {
886 word
= swab16(pModal
->spurChans
[i
].spurChan
);
887 pModal
->spurChans
[i
].spurChan
= word
;
892 if (sum
!= 0xffff || ar5416_get_eep_ver(ahp
) != AR5416_EEP_VER
||
893 ar5416_get_eep_rev(ahp
) < AR5416_EEP_NO_BACK_VER
) {
894 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
895 "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
896 sum
, ar5416_get_eep_ver(ahp
));
903 static bool ath9k_hw_chip_test(struct ath_hal
*ah
)
905 u32 regAddr
[2] = { AR_STA_ID0
, AR_PHY_BASE
+ (8 << 2) };
907 u32 patternData
[4] = { 0x55555555,
913 for (i
= 0; i
< 2; i
++) {
914 u32 addr
= regAddr
[i
];
917 regHold
[i
] = REG_READ(ah
, addr
);
918 for (j
= 0; j
< 0x100; j
++) {
919 wrData
= (j
<< 16) | j
;
920 REG_WRITE(ah
, addr
, wrData
);
921 rdData
= REG_READ(ah
, addr
);
922 if (rdData
!= wrData
) {
923 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
924 "%s: address test failed "
925 "addr: 0x%08x - wr:0x%08x != rd:0x%08x\n",
926 __func__
, addr
, wrData
, rdData
);
930 for (j
= 0; j
< 4; j
++) {
931 wrData
= patternData
[j
];
932 REG_WRITE(ah
, addr
, wrData
);
933 rdData
= REG_READ(ah
, addr
);
934 if (wrData
!= rdData
) {
935 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
936 "%s: address test failed "
937 "addr: 0x%08x - wr:0x%08x != rd:0x%08x\n",
938 __func__
, addr
, wrData
, rdData
);
942 REG_WRITE(ah
, regAddr
[i
], regHold
[i
]);
948 u32
ath9k_hw_getrxfilter(struct ath_hal
*ah
)
950 u32 bits
= REG_READ(ah
, AR_RX_FILTER
);
951 u32 phybits
= REG_READ(ah
, AR_PHY_ERR
);
953 if (phybits
& AR_PHY_ERR_RADAR
)
954 bits
|= ATH9K_RX_FILTER_PHYRADAR
;
955 if (phybits
& (AR_PHY_ERR_OFDM_TIMING
| AR_PHY_ERR_CCK_TIMING
))
956 bits
|= ATH9K_RX_FILTER_PHYERR
;
960 void ath9k_hw_setrxfilter(struct ath_hal
*ah
, u32 bits
)
964 REG_WRITE(ah
, AR_RX_FILTER
, (bits
& 0xffff) | AR_RX_COMPR_BAR
);
966 if (bits
& ATH9K_RX_FILTER_PHYRADAR
)
967 phybits
|= AR_PHY_ERR_RADAR
;
968 if (bits
& ATH9K_RX_FILTER_PHYERR
)
969 phybits
|= AR_PHY_ERR_OFDM_TIMING
| AR_PHY_ERR_CCK_TIMING
;
970 REG_WRITE(ah
, AR_PHY_ERR
, phybits
);
973 REG_WRITE(ah
, AR_RXCFG
,
974 REG_READ(ah
, AR_RXCFG
) | AR_RXCFG_ZLFDMA
);
976 REG_WRITE(ah
, AR_RXCFG
,
977 REG_READ(ah
, AR_RXCFG
) & ~AR_RXCFG_ZLFDMA
);
980 bool ath9k_hw_setcapability(struct ath_hal
*ah
,
981 enum ath9k_capability_type type
,
986 struct ath_hal_5416
*ahp
= AH5416(ah
);
990 case ATH9K_CAP_TKIP_MIC
:
992 ahp
->ah_staId1Defaults
|=
993 AR_STA_ID1_CRPT_MIC_ENABLE
;
995 ahp
->ah_staId1Defaults
&=
996 ~AR_STA_ID1_CRPT_MIC_ENABLE
;
998 case ATH9K_CAP_DIVERSITY
:
999 v
= REG_READ(ah
, AR_PHY_CCK_DETECT
);
1001 v
|= AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV
;
1003 v
&= ~AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV
;
1004 REG_WRITE(ah
, AR_PHY_CCK_DETECT
, v
);
1006 case ATH9K_CAP_MCAST_KEYSRCH
:
1008 ahp
->ah_staId1Defaults
|= AR_STA_ID1_MCAST_KSRCH
;
1010 ahp
->ah_staId1Defaults
&= ~AR_STA_ID1_MCAST_KSRCH
;
1012 case ATH9K_CAP_TSF_ADJUST
:
1014 ahp
->ah_miscMode
|= AR_PCU_TX_ADD_TSF
;
1016 ahp
->ah_miscMode
&= ~AR_PCU_TX_ADD_TSF
;
1023 void ath9k_hw_dmaRegDump(struct ath_hal
*ah
)
1025 u32 val
[ATH9K_NUM_DMA_DEBUG_REGS
];
1026 int qcuOffset
= 0, dcuOffset
= 0;
1027 u32
*qcuBase
= &val
[0], *dcuBase
= &val
[4];
1030 REG_WRITE(ah
, AR_MACMISC
,
1031 ((AR_MACMISC_DMA_OBS_LINE_8
<< AR_MACMISC_DMA_OBS_S
) |
1032 (AR_MACMISC_MISC_OBS_BUS_1
<<
1033 AR_MACMISC_MISC_OBS_BUS_MSB_S
)));
1035 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
, "Raw DMA Debug values:\n");
1036 for (i
= 0; i
< ATH9K_NUM_DMA_DEBUG_REGS
; i
++) {
1038 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
, "\n");
1040 val
[i
] = REG_READ(ah
, AR_DMADBG_0
+ (i
* sizeof(u32
)));
1041 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
, "%d: %08x ", i
, val
[i
]);
1044 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
, "\n\n");
1045 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
1046 "Num QCU: chain_st fsp_ok fsp_st DCU: chain_st\n");
1048 for (i
= 0; i
< ATH9K_NUM_QUEUES
;
1049 i
++, qcuOffset
+= 4, dcuOffset
+= 5) {
1060 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
1061 "%2d %2x %1x %2x %2x\n",
1062 i
, (*qcuBase
& (0x7 << qcuOffset
)) >> qcuOffset
,
1063 (*qcuBase
& (0x8 << qcuOffset
)) >> (qcuOffset
+
1065 val
[2] & (0x7 << (i
* 3)) >> (i
* 3),
1066 (*dcuBase
& (0x1f << dcuOffset
)) >> dcuOffset
);
1069 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
, "\n");
1070 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
1071 "qcu_stitch state: %2x qcu_fetch state: %2x\n",
1072 (val
[3] & 0x003c0000) >> 18, (val
[3] & 0x03c00000) >> 22);
1073 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
1074 "qcu_complete state: %2x dcu_complete state: %2x\n",
1075 (val
[3] & 0x1c000000) >> 26, (val
[6] & 0x3));
1076 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
1077 "dcu_arb state: %2x dcu_fp state: %2x\n",
1078 (val
[5] & 0x06000000) >> 25, (val
[5] & 0x38000000) >> 27);
1079 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
1080 "chan_idle_dur: %3d chan_idle_dur_valid: %1d\n",
1081 (val
[6] & 0x000003fc) >> 2, (val
[6] & 0x00000400) >> 10);
1082 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
1083 "txfifo_valid_0: %1d txfifo_valid_1: %1d\n",
1084 (val
[6] & 0x00000800) >> 11, (val
[6] & 0x00001000) >> 12);
1085 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
1086 "txfifo_dcu_num_0: %2d txfifo_dcu_num_1: %2d\n",
1087 (val
[6] & 0x0001e000) >> 13, (val
[6] & 0x001e0000) >> 17);
1089 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
, "pcu observe 0x%x \n",
1090 REG_READ(ah
, AR_OBS_BUS_1
));
1091 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
1092 "AR_CR 0x%x \n", REG_READ(ah
, AR_CR
));
1095 u32
ath9k_hw_GetMibCycleCountsPct(struct ath_hal
*ah
,
1100 static u32 cycles
, rx_clear
, rx_frame
, tx_frame
;
1103 u32 rc
= REG_READ(ah
, AR_RCCNT
);
1104 u32 rf
= REG_READ(ah
, AR_RFCNT
);
1105 u32 tf
= REG_READ(ah
, AR_TFCNT
);
1106 u32 cc
= REG_READ(ah
, AR_CCCNT
);
1108 if (cycles
== 0 || cycles
> cc
) {
1109 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
1110 "%s: cycle counter wrap. ExtBusy = 0\n",
1114 u32 cc_d
= cc
- cycles
;
1115 u32 rc_d
= rc
- rx_clear
;
1116 u32 rf_d
= rf
- rx_frame
;
1117 u32 tf_d
= tf
- tx_frame
;
1120 *rxc_pcnt
= rc_d
* 100 / cc_d
;
1121 *rxf_pcnt
= rf_d
* 100 / cc_d
;
1122 *txf_pcnt
= tf_d
* 100 / cc_d
;
1136 void ath9k_hw_set11nmac2040(struct ath_hal
*ah
, enum ath9k_ht_macmode mode
)
1140 if (mode
== ATH9K_HT_MACMODE_2040
&&
1141 !ah
->ah_config
.cwm_ignore_extcca
)
1142 macmode
= AR_2040_JOINED_RX_CLEAR
;
1146 REG_WRITE(ah
, AR_2040_MODE
, macmode
);
1149 static void ath9k_hw_mark_phy_inactive(struct ath_hal
*ah
)
1151 REG_WRITE(ah
, AR_PHY_ACTIVE
, AR_PHY_ACTIVE_DIS
);
1155 static struct ath_hal_5416
*ath9k_hw_newstate(u16 devid
,
1156 struct ath_softc
*sc
,
1160 static const u8 defbssidmask
[ETH_ALEN
] =
1161 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1162 struct ath_hal_5416
*ahp
;
1165 ahp
= kzalloc(sizeof(struct ath_hal_5416
), GFP_KERNEL
);
1167 DPRINTF(sc
, ATH_DBG_FATAL
,
1168 "%s: cannot allocate memory for state block\n",
1179 ah
->ah_magic
= AR5416_MAGIC
;
1180 ah
->ah_countryCode
= CTRY_DEFAULT
;
1182 ah
->ah_devid
= devid
;
1183 ah
->ah_subvendorid
= 0;
1186 if ((devid
== AR5416_AR9100_DEVID
))
1187 ah
->ah_macVersion
= AR_SREV_VERSION_9100
;
1188 if (!AR_SREV_9100(ah
))
1189 ah
->ah_flags
= AH_USE_EEPROM
;
1191 ah
->ah_powerLimit
= MAX_RATE_POWER
;
1192 ah
->ah_tpScale
= ATH9K_TP_SCALE_MAX
;
1194 ahp
->ah_atimWindow
= 0;
1195 ahp
->ah_diversityControl
= ah
->ah_config
.diversity_control
;
1196 ahp
->ah_antennaSwitchSwap
=
1197 ah
->ah_config
.antenna_switch_swap
;
1199 ahp
->ah_staId1Defaults
= AR_STA_ID1_CRPT_MIC_ENABLE
;
1200 ahp
->ah_beaconInterval
= 100;
1201 ahp
->ah_enable32kHzClock
= DONT_USE_32KHZ
;
1202 ahp
->ah_slottime
= (u32
) -1;
1203 ahp
->ah_acktimeout
= (u32
) -1;
1204 ahp
->ah_ctstimeout
= (u32
) -1;
1205 ahp
->ah_globaltxtimeout
= (u32
) -1;
1206 memcpy(&ahp
->ah_bssidmask
, defbssidmask
, ETH_ALEN
);
1208 ahp
->ah_gBeaconRate
= 0;
1213 static int ath9k_hw_eeprom_attach(struct ath_hal
*ah
)
1217 if (ath9k_hw_use_flash(ah
))
1218 ath9k_hw_flash_map(ah
);
1220 if (!ath9k_hw_fill_eeprom(ah
))
1223 status
= ath9k_hw_check_eeprom(ah
);
1228 u32
ath9k_hw_get_eeprom(struct ath_hal_5416
*ahp
,
1229 enum eeprom_param param
)
1231 struct ar5416_eeprom
*eep
= &ahp
->ah_eeprom
;
1232 struct modal_eep_header
*pModal
= eep
->modalHeader
;
1233 struct base_eep_header
*pBase
= &eep
->baseEepHeader
;
1236 case EEP_NFTHRESH_5
:
1237 return -pModal
[0].noiseFloorThreshCh
[0];
1238 case EEP_NFTHRESH_2
:
1239 return -pModal
[1].noiseFloorThreshCh
[0];
1240 case AR_EEPROM_MAC(0):
1241 return pBase
->macAddr
[0] << 8 | pBase
->macAddr
[1];
1242 case AR_EEPROM_MAC(1):
1243 return pBase
->macAddr
[2] << 8 | pBase
->macAddr
[3];
1244 case AR_EEPROM_MAC(2):
1245 return pBase
->macAddr
[4] << 8 | pBase
->macAddr
[5];
1247 return pBase
->regDmn
[0];
1249 return pBase
->regDmn
[1];
1251 return pBase
->deviceCap
;
1253 return pBase
->opCapFlags
;
1255 return pBase
->rfSilent
;
1257 return pModal
[0].ob
;
1259 return pModal
[0].db
;
1261 return pModal
[1].ob
;
1263 return pModal
[1].db
;
1265 return pBase
->version
& AR5416_EEP_VER_MINOR_MASK
;
1267 return pBase
->txMask
;
1269 return pBase
->rxMask
;
1275 static inline int ath9k_hw_get_radiorev(struct ath_hal
*ah
)
1280 REG_WRITE(ah
, AR_PHY(0x36), 0x00007058);
1281 for (i
= 0; i
< 8; i
++)
1282 REG_WRITE(ah
, AR_PHY(0x20), 0x00010000);
1283 val
= (REG_READ(ah
, AR_PHY(256)) >> 24) & 0xff;
1284 val
= ((val
& 0xf0) >> 4) | ((val
& 0x0f) << 4);
1285 return ath9k_hw_reverse_bits(val
, 8);
1288 static inline int ath9k_hw_init_macaddr(struct ath_hal
*ah
)
1293 struct ath_hal_5416
*ahp
= AH5416(ah
);
1294 DECLARE_MAC_BUF(mac
);
1297 for (i
= 0; i
< 3; i
++) {
1298 eeval
= ath9k_hw_get_eeprom(ahp
, AR_EEPROM_MAC(i
));
1300 ahp
->ah_macaddr
[2 * i
] = eeval
>> 8;
1301 ahp
->ah_macaddr
[2 * i
+ 1] = eeval
& 0xff;
1303 if (sum
== 0 || sum
== 0xffff * 3) {
1304 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
1305 "%s: mac address read failed: %s\n", __func__
,
1306 print_mac(mac
, ahp
->ah_macaddr
));
1307 return -EADDRNOTAVAIL
;
1313 static inline int16_t ath9k_hw_interpolate(u16 target
,
1317 int16_t targetRight
)
1321 if (srcRight
== srcLeft
) {
1324 rv
= (int16_t) (((target
- srcLeft
) * targetRight
+
1325 (srcRight
- target
) * targetLeft
) /
1326 (srcRight
- srcLeft
));
1331 static inline u16
ath9k_hw_fbin2freq(u8 fbin
,
1335 if (fbin
== AR5416_BCHAN_UNUSED
)
1338 return (u16
) ((is2GHz
) ? (2300 + fbin
) : (4800 + 5 * fbin
));
1341 static u16
ath9k_hw_eeprom_get_spur_chan(struct ath_hal
*ah
,
1345 struct ath_hal_5416
*ahp
= AH5416(ah
);
1346 struct ar5416_eeprom
*eep
=
1347 (struct ar5416_eeprom
*) &ahp
->ah_eeprom
;
1348 u16 spur_val
= AR_NO_SPUR
;
1350 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
1351 "Getting spur idx %d is2Ghz. %d val %x\n",
1352 i
, is2GHz
, ah
->ah_config
.spurchans
[i
][is2GHz
]);
1354 switch (ah
->ah_config
.spurmode
) {
1357 case SPUR_ENABLE_IOCTL
:
1358 spur_val
= ah
->ah_config
.spurchans
[i
][is2GHz
];
1359 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
1360 "Getting spur val from new loc. %d\n", spur_val
);
1362 case SPUR_ENABLE_EEPROM
:
1363 spur_val
= eep
->modalHeader
[is2GHz
].spurChans
[i
].spurChan
;
1370 static inline int ath9k_hw_rfattach(struct ath_hal
*ah
)
1372 bool rfStatus
= false;
1375 rfStatus
= ath9k_hw_init_rf(ah
, &ecode
);
1377 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
1378 "%s: RF setup failed, status %u\n", __func__
,
1386 static int ath9k_hw_rf_claim(struct ath_hal
*ah
)
1390 REG_WRITE(ah
, AR_PHY(0), 0x00000007);
1392 val
= ath9k_hw_get_radiorev(ah
);
1393 switch (val
& AR_RADIO_SREV_MAJOR
) {
1395 val
= AR_RAD5133_SREV_MAJOR
;
1397 case AR_RAD5133_SREV_MAJOR
:
1398 case AR_RAD5122_SREV_MAJOR
:
1399 case AR_RAD2133_SREV_MAJOR
:
1400 case AR_RAD2122_SREV_MAJOR
:
1403 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
1404 "%s: 5G Radio Chip Rev 0x%02X is not "
1405 "supported by this driver\n",
1406 __func__
, ah
->ah_analog5GhzRev
);
1410 ah
->ah_analog5GhzRev
= val
;
1415 static inline void ath9k_hw_init_pll(struct ath_hal
*ah
,
1416 struct ath9k_channel
*chan
)
1420 if (AR_SREV_9100(ah
)) {
1421 if (chan
&& IS_CHAN_5GHZ(chan
))
1426 if (AR_SREV_9280_10_OR_LATER(ah
)) {
1427 pll
= SM(0x5, AR_RTC_9160_PLL_REFDIV
);
1429 if (chan
&& IS_CHAN_HALF_RATE(chan
))
1430 pll
|= SM(0x1, AR_RTC_9160_PLL_CLKSEL
);
1431 else if (chan
&& IS_CHAN_QUARTER_RATE(chan
))
1432 pll
|= SM(0x2, AR_RTC_9160_PLL_CLKSEL
);
1434 if (chan
&& IS_CHAN_5GHZ(chan
)) {
1435 pll
|= SM(0x28, AR_RTC_9160_PLL_DIV
);
1438 if (AR_SREV_9280_20(ah
)) {
1439 if (((chan
->channel
% 20) == 0)
1440 || ((chan
->channel
% 10) == 0))
1446 pll
|= SM(0x2c, AR_RTC_9160_PLL_DIV
);
1449 } else if (AR_SREV_9160_10_OR_LATER(ah
)) {
1451 pll
= SM(0x5, AR_RTC_9160_PLL_REFDIV
);
1453 if (chan
&& IS_CHAN_HALF_RATE(chan
))
1454 pll
|= SM(0x1, AR_RTC_9160_PLL_CLKSEL
);
1455 else if (chan
&& IS_CHAN_QUARTER_RATE(chan
))
1456 pll
|= SM(0x2, AR_RTC_9160_PLL_CLKSEL
);
1458 if (chan
&& IS_CHAN_5GHZ(chan
))
1459 pll
|= SM(0x50, AR_RTC_9160_PLL_DIV
);
1461 pll
|= SM(0x58, AR_RTC_9160_PLL_DIV
);
1463 pll
= AR_RTC_PLL_REFDIV_5
| AR_RTC_PLL_DIV2
;
1465 if (chan
&& IS_CHAN_HALF_RATE(chan
))
1466 pll
|= SM(0x1, AR_RTC_PLL_CLKSEL
);
1467 else if (chan
&& IS_CHAN_QUARTER_RATE(chan
))
1468 pll
|= SM(0x2, AR_RTC_PLL_CLKSEL
);
1470 if (chan
&& IS_CHAN_5GHZ(chan
))
1471 pll
|= SM(0xa, AR_RTC_PLL_DIV
);
1473 pll
|= SM(0xb, AR_RTC_PLL_DIV
);
1476 REG_WRITE(ah
, (u16
) (AR_RTC_PLL_CONTROL
), pll
);
1478 udelay(RTC_PLL_SETTLE_DELAY
);
1480 REG_WRITE(ah
, AR_RTC_SLEEP_CLK
, AR_RTC_FORCE_DERIVED_CLK
);
1483 static void ath9k_hw_set_regs(struct ath_hal
*ah
, struct ath9k_channel
*chan
,
1484 enum ath9k_ht_macmode macmode
)
1487 struct ath_hal_5416
*ahp
= AH5416(ah
);
1489 phymode
= AR_PHY_FC_HT_EN
| AR_PHY_FC_SHORT_GI_40
1490 | AR_PHY_FC_SINGLE_HT_LTF1
| AR_PHY_FC_WALSH
;
1492 if (IS_CHAN_HT40(chan
)) {
1493 phymode
|= AR_PHY_FC_DYN2040_EN
;
1495 if ((chan
->chanmode
== CHANNEL_A_HT40PLUS
) ||
1496 (chan
->chanmode
== CHANNEL_G_HT40PLUS
))
1497 phymode
|= AR_PHY_FC_DYN2040_PRI_CH
;
1499 if (ahp
->ah_extprotspacing
== ATH9K_HT_EXTPROTSPACING_25
)
1500 phymode
|= AR_PHY_FC_DYN2040_EXT_CH
;
1502 REG_WRITE(ah
, AR_PHY_TURBO
, phymode
);
1504 ath9k_hw_set11nmac2040(ah
, macmode
);
1506 REG_WRITE(ah
, AR_GTXTO
, 25 << AR_GTXTO_TIMEOUT_LIMIT_S
);
1507 REG_WRITE(ah
, AR_CST
, 0xF << AR_CST_TIMEOUT_LIMIT_S
);
1510 static void ath9k_hw_set_operating_mode(struct ath_hal
*ah
, int opmode
)
1514 val
= REG_READ(ah
, AR_STA_ID1
);
1515 val
&= ~(AR_STA_ID1_STA_AP
| AR_STA_ID1_ADHOC
);
1517 case ATH9K_M_HOSTAP
:
1518 REG_WRITE(ah
, AR_STA_ID1
, val
| AR_STA_ID1_STA_AP
1519 | AR_STA_ID1_KSRCH_MODE
);
1520 REG_CLR_BIT(ah
, AR_CFG
, AR_CFG_AP_ADHOC_INDICATION
);
1523 REG_WRITE(ah
, AR_STA_ID1
, val
| AR_STA_ID1_ADHOC
1524 | AR_STA_ID1_KSRCH_MODE
);
1525 REG_SET_BIT(ah
, AR_CFG
, AR_CFG_AP_ADHOC_INDICATION
);
1528 case ATH9K_M_MONITOR
:
1529 REG_WRITE(ah
, AR_STA_ID1
, val
| AR_STA_ID1_KSRCH_MODE
);
1535 ath9k_hw_set_rfmode(struct ath_hal
*ah
, struct ath9k_channel
*chan
)
1542 rfMode
|= (IS_CHAN_B(chan
) || IS_CHAN_G(chan
))
1543 ? AR_PHY_MODE_DYNAMIC
: AR_PHY_MODE_OFDM
;
1545 if (!AR_SREV_9280_10_OR_LATER(ah
))
1546 rfMode
|= (IS_CHAN_5GHZ(chan
)) ? AR_PHY_MODE_RF5GHZ
:
1549 if (AR_SREV_9280_20(ah
) && IS_CHAN_A_5MHZ_SPACED(chan
))
1550 rfMode
|= (AR_PHY_MODE_DYNAMIC
| AR_PHY_MODE_DYN_CCK_DISABLE
);
1552 REG_WRITE(ah
, AR_PHY_MODE
, rfMode
);
1555 static bool ath9k_hw_set_reset(struct ath_hal
*ah
, int type
)
1560 REG_WRITE(ah
, AR_RTC_FORCE_WAKE
, AR_RTC_FORCE_WAKE_EN
|
1561 AR_RTC_FORCE_WAKE_ON_INT
);
1563 if (AR_SREV_9100(ah
)) {
1564 rst_flags
= AR_RTC_RC_MAC_WARM
| AR_RTC_RC_MAC_COLD
|
1565 AR_RTC_RC_COLD_RESET
| AR_RTC_RC_WARM_RESET
;
1567 tmpReg
= REG_READ(ah
, AR_INTR_SYNC_CAUSE
);
1569 (AR_INTR_SYNC_LOCAL_TIMEOUT
|
1570 AR_INTR_SYNC_RADM_CPL_TIMEOUT
)) {
1571 REG_WRITE(ah
, AR_INTR_SYNC_ENABLE
, 0);
1572 REG_WRITE(ah
, AR_RC
, AR_RC_AHB
| AR_RC_HOSTIF
);
1574 REG_WRITE(ah
, AR_RC
, AR_RC_AHB
);
1577 rst_flags
= AR_RTC_RC_MAC_WARM
;
1578 if (type
== ATH9K_RESET_COLD
)
1579 rst_flags
|= AR_RTC_RC_MAC_COLD
;
1582 REG_WRITE(ah
, (u16
) (AR_RTC_RC
), rst_flags
);
1585 REG_WRITE(ah
, (u16
) (AR_RTC_RC
), 0);
1586 if (!ath9k_hw_wait(ah
, (u16
) (AR_RTC_RC
), AR_RTC_RC_M
, 0)) {
1587 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
1588 "%s: RTC stuck in MAC reset\n",
1593 if (!AR_SREV_9100(ah
))
1594 REG_WRITE(ah
, AR_RC
, 0);
1596 ath9k_hw_init_pll(ah
, NULL
);
1598 if (AR_SREV_9100(ah
))
1604 static inline bool ath9k_hw_set_reset_power_on(struct ath_hal
*ah
)
1606 REG_WRITE(ah
, AR_RTC_FORCE_WAKE
, AR_RTC_FORCE_WAKE_EN
|
1607 AR_RTC_FORCE_WAKE_ON_INT
);
1609 REG_WRITE(ah
, (u16
) (AR_RTC_RESET
), 0);
1610 REG_WRITE(ah
, (u16
) (AR_RTC_RESET
), 1);
1612 if (!ath9k_hw_wait(ah
,
1615 AR_RTC_STATUS_ON
)) {
1616 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: RTC not waking up\n",
1621 ath9k_hw_read_revisions(ah
);
1623 return ath9k_hw_set_reset(ah
, ATH9K_RESET_WARM
);
1626 static bool ath9k_hw_set_reset_reg(struct ath_hal
*ah
,
1629 REG_WRITE(ah
, AR_RTC_FORCE_WAKE
,
1630 AR_RTC_FORCE_WAKE_EN
| AR_RTC_FORCE_WAKE_ON_INT
);
1633 case ATH9K_RESET_POWER_ON
:
1634 return ath9k_hw_set_reset_power_on(ah
);
1636 case ATH9K_RESET_WARM
:
1637 case ATH9K_RESET_COLD
:
1638 return ath9k_hw_set_reset(ah
, type
);
1646 struct ath9k_channel
*ath9k_hw_check_chan(struct ath_hal
*ah
,
1647 struct ath9k_channel
*chan
)
1649 if (!(IS_CHAN_2GHZ(chan
) ^ IS_CHAN_5GHZ(chan
))) {
1650 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
1651 "%s: invalid channel %u/0x%x; not marked as "
1652 "2GHz or 5GHz\n", __func__
, chan
->channel
,
1653 chan
->channelFlags
);
1657 if (!IS_CHAN_OFDM(chan
) &&
1658 !IS_CHAN_CCK(chan
) &&
1659 !IS_CHAN_HT20(chan
) &&
1660 !IS_CHAN_HT40(chan
)) {
1661 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
1662 "%s: invalid channel %u/0x%x; not marked as "
1663 "OFDM or CCK or HT20 or HT40PLUS or HT40MINUS\n",
1664 __func__
, chan
->channel
, chan
->channelFlags
);
1668 return ath9k_regd_check_channel(ah
, chan
);
1672 ath9k_hw_get_lower_upper_index(u8 target
,
1680 if (target
<= pList
[0]) {
1681 *indexL
= *indexR
= 0;
1684 if (target
>= pList
[listSize
- 1]) {
1685 *indexL
= *indexR
= (u16
) (listSize
- 1);
1689 for (i
= 0; i
< listSize
- 1; i
++) {
1690 if (pList
[i
] == target
) {
1691 *indexL
= *indexR
= i
;
1694 if (target
< pList
[i
+ 1]) {
1696 *indexR
= (u16
) (i
+ 1);
1703 static int16_t ath9k_hw_get_nf_hist_mid(int16_t *nfCalBuffer
)
1706 int16_t sort
[ATH9K_NF_CAL_HIST_MAX
];
1709 for (i
= 0; i
< ATH9K_NF_CAL_HIST_MAX
; i
++)
1710 sort
[i
] = nfCalBuffer
[i
];
1712 for (i
= 0; i
< ATH9K_NF_CAL_HIST_MAX
- 1; i
++) {
1713 for (j
= 1; j
< ATH9K_NF_CAL_HIST_MAX
- i
; j
++) {
1714 if (sort
[j
] > sort
[j
- 1]) {
1716 sort
[j
] = sort
[j
- 1];
1717 sort
[j
- 1] = nfval
;
1721 nfval
= sort
[(ATH9K_NF_CAL_HIST_MAX
- 1) >> 1];
1726 static void ath9k_hw_update_nfcal_hist_buffer(struct ath9k_nfcal_hist
*h
,
1731 for (i
= 0; i
< NUM_NF_READINGS
; i
++) {
1732 h
[i
].nfCalBuffer
[h
[i
].currIndex
] = nfarray
[i
];
1734 if (++h
[i
].currIndex
>= ATH9K_NF_CAL_HIST_MAX
)
1737 if (h
[i
].invalidNFcount
> 0) {
1738 if (nfarray
[i
] < AR_PHY_CCA_MIN_BAD_VALUE
1739 || nfarray
[i
] > AR_PHY_CCA_MAX_HIGH_VALUE
) {
1740 h
[i
].invalidNFcount
= ATH9K_NF_CAL_HIST_MAX
;
1742 h
[i
].invalidNFcount
--;
1743 h
[i
].privNF
= nfarray
[i
];
1747 ath9k_hw_get_nf_hist_mid(h
[i
].nfCalBuffer
);
1753 static void ar5416GetNoiseFloor(struct ath_hal
*ah
,
1754 int16_t nfarray
[NUM_NF_READINGS
])
1758 if (AR_SREV_9280_10_OR_LATER(ah
))
1759 nf
= MS(REG_READ(ah
, AR_PHY_CCA
), AR9280_PHY_MINCCA_PWR
);
1761 nf
= MS(REG_READ(ah
, AR_PHY_CCA
), AR_PHY_MINCCA_PWR
);
1764 nf
= 0 - ((nf
^ 0x1ff) + 1);
1765 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
1766 "NF calibrated [ctl] [chain 0] is %d\n", nf
);
1769 if (AR_SREV_9280_10_OR_LATER(ah
))
1770 nf
= MS(REG_READ(ah
, AR_PHY_CH1_CCA
),
1771 AR9280_PHY_CH1_MINCCA_PWR
);
1773 nf
= MS(REG_READ(ah
, AR_PHY_CH1_CCA
),
1774 AR_PHY_CH1_MINCCA_PWR
);
1777 nf
= 0 - ((nf
^ 0x1ff) + 1);
1778 DPRINTF(ah
->ah_sc
, ATH_DBG_NF_CAL
,
1779 "NF calibrated [ctl] [chain 1] is %d\n", nf
);
1782 if (!AR_SREV_9280(ah
)) {
1783 nf
= MS(REG_READ(ah
, AR_PHY_CH2_CCA
),
1784 AR_PHY_CH2_MINCCA_PWR
);
1786 nf
= 0 - ((nf
^ 0x1ff) + 1);
1787 DPRINTF(ah
->ah_sc
, ATH_DBG_NF_CAL
,
1788 "NF calibrated [ctl] [chain 2] is %d\n", nf
);
1792 if (AR_SREV_9280_10_OR_LATER(ah
))
1793 nf
= MS(REG_READ(ah
, AR_PHY_EXT_CCA
),
1794 AR9280_PHY_EXT_MINCCA_PWR
);
1796 nf
= MS(REG_READ(ah
, AR_PHY_EXT_CCA
),
1797 AR_PHY_EXT_MINCCA_PWR
);
1800 nf
= 0 - ((nf
^ 0x1ff) + 1);
1801 DPRINTF(ah
->ah_sc
, ATH_DBG_NF_CAL
,
1802 "NF calibrated [ext] [chain 0] is %d\n", nf
);
1805 if (AR_SREV_9280_10_OR_LATER(ah
))
1806 nf
= MS(REG_READ(ah
, AR_PHY_CH1_EXT_CCA
),
1807 AR9280_PHY_CH1_EXT_MINCCA_PWR
);
1809 nf
= MS(REG_READ(ah
, AR_PHY_CH1_EXT_CCA
),
1810 AR_PHY_CH1_EXT_MINCCA_PWR
);
1813 nf
= 0 - ((nf
^ 0x1ff) + 1);
1814 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
1815 "NF calibrated [ext] [chain 1] is %d\n", nf
);
1818 if (!AR_SREV_9280(ah
)) {
1819 nf
= MS(REG_READ(ah
, AR_PHY_CH2_EXT_CCA
),
1820 AR_PHY_CH2_EXT_MINCCA_PWR
);
1822 nf
= 0 - ((nf
^ 0x1ff) + 1);
1823 DPRINTF(ah
->ah_sc
, ATH_DBG_NF_CAL
,
1824 "NF calibrated [ext] [chain 2] is %d\n", nf
);
1830 getNoiseFloorThresh(struct ath_hal
*ah
,
1831 const struct ath9k_channel
*chan
,
1834 struct ath_hal_5416
*ahp
= AH5416(ah
);
1836 switch (chan
->chanmode
) {
1838 case CHANNEL_A_HT20
:
1839 case CHANNEL_A_HT40PLUS
:
1840 case CHANNEL_A_HT40MINUS
:
1841 *nft
= (int16_t) ath9k_hw_get_eeprom(ahp
, EEP_NFTHRESH_5
);
1845 case CHANNEL_G_HT20
:
1846 case CHANNEL_G_HT40PLUS
:
1847 case CHANNEL_G_HT40MINUS
:
1848 *nft
= (int16_t) ath9k_hw_get_eeprom(ahp
, EEP_NFTHRESH_2
);
1851 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
1852 "%s: invalid channel flags 0x%x\n", __func__
,
1853 chan
->channelFlags
);
1859 static void ath9k_hw_start_nfcal(struct ath_hal
*ah
)
1861 REG_SET_BIT(ah
, AR_PHY_AGC_CONTROL
,
1862 AR_PHY_AGC_CONTROL_ENABLE_NF
);
1863 REG_SET_BIT(ah
, AR_PHY_AGC_CONTROL
,
1864 AR_PHY_AGC_CONTROL_NO_UPDATE_NF
);
1865 REG_SET_BIT(ah
, AR_PHY_AGC_CONTROL
, AR_PHY_AGC_CONTROL_NF
);
1869 ath9k_hw_loadnf(struct ath_hal
*ah
, struct ath9k_channel
*chan
)
1871 struct ath9k_nfcal_hist
*h
;
1874 const u32 ar5416_cca_regs
[6] = {
1884 if (AR_SREV_9280(ah
))
1889 #ifdef ATH_NF_PER_CHAN
1890 h
= chan
->nfCalHist
;
1895 for (i
= 0; i
< NUM_NF_READINGS
; i
++) {
1896 if (chainmask
& (1 << i
)) {
1897 val
= REG_READ(ah
, ar5416_cca_regs
[i
]);
1899 val
|= (((u32
) (h
[i
].privNF
) << 1) & 0x1ff);
1900 REG_WRITE(ah
, ar5416_cca_regs
[i
], val
);
1904 REG_CLR_BIT(ah
, AR_PHY_AGC_CONTROL
,
1905 AR_PHY_AGC_CONTROL_ENABLE_NF
);
1906 REG_CLR_BIT(ah
, AR_PHY_AGC_CONTROL
,
1907 AR_PHY_AGC_CONTROL_NO_UPDATE_NF
);
1908 REG_SET_BIT(ah
, AR_PHY_AGC_CONTROL
, AR_PHY_AGC_CONTROL_NF
);
1910 for (j
= 0; j
< 1000; j
++) {
1911 if ((REG_READ(ah
, AR_PHY_AGC_CONTROL
) &
1912 AR_PHY_AGC_CONTROL_NF
) == 0)
1917 for (i
= 0; i
< NUM_NF_READINGS
; i
++) {
1918 if (chainmask
& (1 << i
)) {
1919 val
= REG_READ(ah
, ar5416_cca_regs
[i
]);
1921 val
|= (((u32
) (-50) << 1) & 0x1ff);
1922 REG_WRITE(ah
, ar5416_cca_regs
[i
], val
);
1927 static int16_t ath9k_hw_getnf(struct ath_hal
*ah
,
1928 struct ath9k_channel
*chan
)
1930 int16_t nf
, nfThresh
;
1931 int16_t nfarray
[NUM_NF_READINGS
] = { 0 };
1932 struct ath9k_nfcal_hist
*h
;
1935 if (AR_SREV_9280(ah
))
1940 chan
->channelFlags
&= (~CHANNEL_CW_INT
);
1941 if (REG_READ(ah
, AR_PHY_AGC_CONTROL
) & AR_PHY_AGC_CONTROL_NF
) {
1942 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
1943 "%s: NF did not complete in calibration window\n",
1946 chan
->rawNoiseFloor
= nf
;
1947 return chan
->rawNoiseFloor
;
1949 ar5416GetNoiseFloor(ah
, nfarray
);
1951 if (getNoiseFloorThresh(ah
, chan
, &nfThresh
)
1953 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
1954 "%s: noise floor failed detected; "
1955 "detected %d, threshold %d\n", __func__
,
1957 chan
->channelFlags
|= CHANNEL_CW_INT
;
1961 #ifdef ATH_NF_PER_CHAN
1962 h
= chan
->nfCalHist
;
1967 ath9k_hw_update_nfcal_hist_buffer(h
, nfarray
);
1968 chan
->rawNoiseFloor
= h
[0].privNF
;
1970 return chan
->rawNoiseFloor
;
1973 static void ath9k_hw_update_mibstats(struct ath_hal
*ah
,
1974 struct ath9k_mib_stats
*stats
)
1976 stats
->ackrcv_bad
+= REG_READ(ah
, AR_ACK_FAIL
);
1977 stats
->rts_bad
+= REG_READ(ah
, AR_RTS_FAIL
);
1978 stats
->fcs_bad
+= REG_READ(ah
, AR_FCS_FAIL
);
1979 stats
->rts_good
+= REG_READ(ah
, AR_RTS_OK
);
1980 stats
->beacons
+= REG_READ(ah
, AR_BEACON_CNT
);
1983 static void ath9k_enable_mib_counters(struct ath_hal
*ah
)
1985 struct ath_hal_5416
*ahp
= AH5416(ah
);
1987 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
, "Enable mib counters\n");
1989 ath9k_hw_update_mibstats(ah
, &ahp
->ah_mibStats
);
1991 REG_WRITE(ah
, AR_FILT_OFDM
, 0);
1992 REG_WRITE(ah
, AR_FILT_CCK
, 0);
1993 REG_WRITE(ah
, AR_MIBC
,
1994 ~(AR_MIBC_COW
| AR_MIBC_FMC
| AR_MIBC_CMC
| AR_MIBC_MCS
)
1996 REG_WRITE(ah
, AR_PHY_ERR_MASK_1
, AR_PHY_ERR_OFDM_TIMING
);
1997 REG_WRITE(ah
, AR_PHY_ERR_MASK_2
, AR_PHY_ERR_CCK_TIMING
);
2000 static void ath9k_hw_disable_mib_counters(struct ath_hal
*ah
)
2002 struct ath_hal_5416
*ahp
= AH5416(ah
);
2004 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
, "Disabling MIB counters\n");
2006 REG_WRITE(ah
, AR_MIBC
, AR_MIBC_FMC
| AR_MIBC_CMC
);
2008 ath9k_hw_update_mibstats(ah
, &ahp
->ah_mibStats
);
2010 REG_WRITE(ah
, AR_FILT_OFDM
, 0);
2011 REG_WRITE(ah
, AR_FILT_CCK
, 0);
2014 static int ath9k_hw_get_ani_channel_idx(struct ath_hal
*ah
,
2015 struct ath9k_channel
*chan
)
2017 struct ath_hal_5416
*ahp
= AH5416(ah
);
2020 for (i
= 0; i
< ARRAY_SIZE(ahp
->ah_ani
); i
++) {
2021 if (ahp
->ah_ani
[i
].c
.channel
== chan
->channel
)
2023 if (ahp
->ah_ani
[i
].c
.channel
== 0) {
2024 ahp
->ah_ani
[i
].c
.channel
= chan
->channel
;
2025 ahp
->ah_ani
[i
].c
.channelFlags
= chan
->channelFlags
;
2030 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2031 "No more channel states left. Using channel 0\n");
2035 static void ath9k_hw_ani_attach(struct ath_hal
*ah
)
2037 struct ath_hal_5416
*ahp
= AH5416(ah
);
2040 ahp
->ah_hasHwPhyCounters
= 1;
2042 memset(ahp
->ah_ani
, 0, sizeof(ahp
->ah_ani
));
2043 for (i
= 0; i
< ARRAY_SIZE(ahp
->ah_ani
); i
++) {
2044 ahp
->ah_ani
[i
].ofdmTrigHigh
= ATH9K_ANI_OFDM_TRIG_HIGH
;
2045 ahp
->ah_ani
[i
].ofdmTrigLow
= ATH9K_ANI_OFDM_TRIG_LOW
;
2046 ahp
->ah_ani
[i
].cckTrigHigh
= ATH9K_ANI_CCK_TRIG_HIGH
;
2047 ahp
->ah_ani
[i
].cckTrigLow
= ATH9K_ANI_CCK_TRIG_LOW
;
2048 ahp
->ah_ani
[i
].rssiThrHigh
= ATH9K_ANI_RSSI_THR_HIGH
;
2049 ahp
->ah_ani
[i
].rssiThrLow
= ATH9K_ANI_RSSI_THR_LOW
;
2050 ahp
->ah_ani
[i
].ofdmWeakSigDetectOff
=
2051 !ATH9K_ANI_USE_OFDM_WEAK_SIG
;
2052 ahp
->ah_ani
[i
].cckWeakSigThreshold
=
2053 ATH9K_ANI_CCK_WEAK_SIG_THR
;
2054 ahp
->ah_ani
[i
].spurImmunityLevel
= ATH9K_ANI_SPUR_IMMUNE_LVL
;
2055 ahp
->ah_ani
[i
].firstepLevel
= ATH9K_ANI_FIRSTEP_LVL
;
2056 if (ahp
->ah_hasHwPhyCounters
) {
2057 ahp
->ah_ani
[i
].ofdmPhyErrBase
=
2058 AR_PHY_COUNTMAX
- ATH9K_ANI_OFDM_TRIG_HIGH
;
2059 ahp
->ah_ani
[i
].cckPhyErrBase
=
2060 AR_PHY_COUNTMAX
- ATH9K_ANI_CCK_TRIG_HIGH
;
2063 if (ahp
->ah_hasHwPhyCounters
) {
2064 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2065 "Setting OfdmErrBase = 0x%08x\n",
2066 ahp
->ah_ani
[0].ofdmPhyErrBase
);
2067 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
, "Setting cckErrBase = 0x%08x\n",
2068 ahp
->ah_ani
[0].cckPhyErrBase
);
2070 REG_WRITE(ah
, AR_PHY_ERR_1
, ahp
->ah_ani
[0].ofdmPhyErrBase
);
2071 REG_WRITE(ah
, AR_PHY_ERR_2
, ahp
->ah_ani
[0].cckPhyErrBase
);
2072 ath9k_enable_mib_counters(ah
);
2074 ahp
->ah_aniPeriod
= ATH9K_ANI_PERIOD
;
2075 if (ah
->ah_config
.enable_ani
)
2076 ahp
->ah_procPhyErr
|= HAL_PROCESS_ANI
;
2079 static inline void ath9k_hw_ani_setup(struct ath_hal
*ah
)
2081 struct ath_hal_5416
*ahp
= AH5416(ah
);
2084 const int totalSizeDesired
[] = { -55, -55, -55, -55, -62 };
2085 const int coarseHigh
[] = { -14, -14, -14, -14, -12 };
2086 const int coarseLow
[] = { -64, -64, -64, -64, -70 };
2087 const int firpwr
[] = { -78, -78, -78, -78, -80 };
2089 for (i
= 0; i
< 5; i
++) {
2090 ahp
->ah_totalSizeDesired
[i
] = totalSizeDesired
[i
];
2091 ahp
->ah_coarseHigh
[i
] = coarseHigh
[i
];
2092 ahp
->ah_coarseLow
[i
] = coarseLow
[i
];
2093 ahp
->ah_firpwr
[i
] = firpwr
[i
];
2097 static void ath9k_hw_ani_detach(struct ath_hal
*ah
)
2099 struct ath_hal_5416
*ahp
= AH5416(ah
);
2101 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
, "Detaching Ani\n");
2102 if (ahp
->ah_hasHwPhyCounters
) {
2103 ath9k_hw_disable_mib_counters(ah
);
2104 REG_WRITE(ah
, AR_PHY_ERR_1
, 0);
2105 REG_WRITE(ah
, AR_PHY_ERR_2
, 0);
2110 static bool ath9k_hw_ani_control(struct ath_hal
*ah
,
2111 enum ath9k_ani_cmd cmd
, int param
)
2113 struct ath_hal_5416
*ahp
= AH5416(ah
);
2114 struct ar5416AniState
*aniState
= ahp
->ah_curani
;
2116 switch (cmd
& ahp
->ah_ani_function
) {
2117 case ATH9K_ANI_NOISE_IMMUNITY_LEVEL
:{
2120 if (level
>= ARRAY_SIZE(ahp
->ah_totalSizeDesired
)) {
2121 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2122 "%s: level out of range (%u > %u)\n",
2124 (unsigned) ARRAY_SIZE(ahp
->
2125 ah_totalSizeDesired
));
2129 REG_RMW_FIELD(ah
, AR_PHY_DESIRED_SZ
,
2130 AR_PHY_DESIRED_SZ_TOT_DES
,
2131 ahp
->ah_totalSizeDesired
[level
]);
2132 REG_RMW_FIELD(ah
, AR_PHY_AGC_CTL1
,
2133 AR_PHY_AGC_CTL1_COARSE_LOW
,
2134 ahp
->ah_coarseLow
[level
]);
2135 REG_RMW_FIELD(ah
, AR_PHY_AGC_CTL1
,
2136 AR_PHY_AGC_CTL1_COARSE_HIGH
,
2137 ahp
->ah_coarseHigh
[level
]);
2138 REG_RMW_FIELD(ah
, AR_PHY_FIND_SIG
,
2139 AR_PHY_FIND_SIG_FIRPWR
,
2140 ahp
->ah_firpwr
[level
]);
2142 if (level
> aniState
->noiseImmunityLevel
)
2143 ahp
->ah_stats
.ast_ani_niup
++;
2144 else if (level
< aniState
->noiseImmunityLevel
)
2145 ahp
->ah_stats
.ast_ani_nidown
++;
2146 aniState
->noiseImmunityLevel
= level
;
2149 case ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION
:{
2150 const int m1ThreshLow
[] = { 127, 50 };
2151 const int m2ThreshLow
[] = { 127, 40 };
2152 const int m1Thresh
[] = { 127, 0x4d };
2153 const int m2Thresh
[] = { 127, 0x40 };
2154 const int m2CountThr
[] = { 31, 16 };
2155 const int m2CountThrLow
[] = { 63, 48 };
2156 u32 on
= param
? 1 : 0;
2158 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_LOW
,
2159 AR_PHY_SFCORR_LOW_M1_THRESH_LOW
,
2161 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_LOW
,
2162 AR_PHY_SFCORR_LOW_M2_THRESH_LOW
,
2164 REG_RMW_FIELD(ah
, AR_PHY_SFCORR
,
2165 AR_PHY_SFCORR_M1_THRESH
,
2167 REG_RMW_FIELD(ah
, AR_PHY_SFCORR
,
2168 AR_PHY_SFCORR_M2_THRESH
,
2170 REG_RMW_FIELD(ah
, AR_PHY_SFCORR
,
2171 AR_PHY_SFCORR_M2COUNT_THR
,
2173 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_LOW
,
2174 AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW
,
2177 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_EXT
,
2178 AR_PHY_SFCORR_EXT_M1_THRESH_LOW
,
2180 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_EXT
,
2181 AR_PHY_SFCORR_EXT_M2_THRESH_LOW
,
2183 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_EXT
,
2184 AR_PHY_SFCORR_EXT_M1_THRESH
,
2186 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_EXT
,
2187 AR_PHY_SFCORR_EXT_M2_THRESH
,
2191 REG_SET_BIT(ah
, AR_PHY_SFCORR_LOW
,
2192 AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW
);
2194 REG_CLR_BIT(ah
, AR_PHY_SFCORR_LOW
,
2195 AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW
);
2197 if (!on
!= aniState
->ofdmWeakSigDetectOff
) {
2199 ahp
->ah_stats
.ast_ani_ofdmon
++;
2201 ahp
->ah_stats
.ast_ani_ofdmoff
++;
2202 aniState
->ofdmWeakSigDetectOff
= !on
;
2206 case ATH9K_ANI_CCK_WEAK_SIGNAL_THR
:{
2207 const int weakSigThrCck
[] = { 8, 6 };
2208 u32 high
= param
? 1 : 0;
2210 REG_RMW_FIELD(ah
, AR_PHY_CCK_DETECT
,
2211 AR_PHY_CCK_DETECT_WEAK_SIG_THR_CCK
,
2212 weakSigThrCck
[high
]);
2213 if (high
!= aniState
->cckWeakSigThreshold
) {
2215 ahp
->ah_stats
.ast_ani_cckhigh
++;
2217 ahp
->ah_stats
.ast_ani_ccklow
++;
2218 aniState
->cckWeakSigThreshold
= high
;
2222 case ATH9K_ANI_FIRSTEP_LEVEL
:{
2223 const int firstep
[] = { 0, 4, 8 };
2226 if (level
>= ARRAY_SIZE(firstep
)) {
2227 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2228 "%s: level out of range (%u > %u)\n",
2230 (unsigned) ARRAY_SIZE(firstep
));
2233 REG_RMW_FIELD(ah
, AR_PHY_FIND_SIG
,
2234 AR_PHY_FIND_SIG_FIRSTEP
,
2236 if (level
> aniState
->firstepLevel
)
2237 ahp
->ah_stats
.ast_ani_stepup
++;
2238 else if (level
< aniState
->firstepLevel
)
2239 ahp
->ah_stats
.ast_ani_stepdown
++;
2240 aniState
->firstepLevel
= level
;
2243 case ATH9K_ANI_SPUR_IMMUNITY_LEVEL
:{
2244 const int cycpwrThr1
[] =
2245 { 2, 4, 6, 8, 10, 12, 14, 16 };
2248 if (level
>= ARRAY_SIZE(cycpwrThr1
)) {
2249 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2250 "%s: level out of range (%u > %u)\n",
2253 ARRAY_SIZE(cycpwrThr1
));
2256 REG_RMW_FIELD(ah
, AR_PHY_TIMING5
,
2257 AR_PHY_TIMING5_CYCPWR_THR1
,
2259 if (level
> aniState
->spurImmunityLevel
)
2260 ahp
->ah_stats
.ast_ani_spurup
++;
2261 else if (level
< aniState
->spurImmunityLevel
)
2262 ahp
->ah_stats
.ast_ani_spurdown
++;
2263 aniState
->spurImmunityLevel
= level
;
2266 case ATH9K_ANI_PRESENT
:
2269 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2270 "%s: invalid cmd %u\n", __func__
, cmd
);
2274 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
, "%s: ANI parameters:\n", __func__
);
2275 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2276 "noiseImmunityLevel=%d, spurImmunityLevel=%d, "
2277 "ofdmWeakSigDetectOff=%d\n",
2278 aniState
->noiseImmunityLevel
, aniState
->spurImmunityLevel
,
2279 !aniState
->ofdmWeakSigDetectOff
);
2280 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2281 "cckWeakSigThreshold=%d, "
2282 "firstepLevel=%d, listenTime=%d\n",
2283 aniState
->cckWeakSigThreshold
, aniState
->firstepLevel
,
2284 aniState
->listenTime
);
2285 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2286 "cycleCount=%d, ofdmPhyErrCount=%d, cckPhyErrCount=%d\n\n",
2287 aniState
->cycleCount
, aniState
->ofdmPhyErrCount
,
2288 aniState
->cckPhyErrCount
);
2292 static void ath9k_ani_restart(struct ath_hal
*ah
)
2294 struct ath_hal_5416
*ahp
= AH5416(ah
);
2295 struct ar5416AniState
*aniState
;
2300 aniState
= ahp
->ah_curani
;
2302 aniState
->listenTime
= 0;
2303 if (ahp
->ah_hasHwPhyCounters
) {
2304 if (aniState
->ofdmTrigHigh
> AR_PHY_COUNTMAX
) {
2305 aniState
->ofdmPhyErrBase
= 0;
2306 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2307 "OFDM Trigger is too high for hw counters\n");
2309 aniState
->ofdmPhyErrBase
=
2310 AR_PHY_COUNTMAX
- aniState
->ofdmTrigHigh
;
2312 if (aniState
->cckTrigHigh
> AR_PHY_COUNTMAX
) {
2313 aniState
->cckPhyErrBase
= 0;
2314 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2315 "CCK Trigger is too high for hw counters\n");
2317 aniState
->cckPhyErrBase
=
2318 AR_PHY_COUNTMAX
- aniState
->cckTrigHigh
;
2320 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2321 "%s: Writing ofdmbase=%u cckbase=%u\n",
2322 __func__
, aniState
->ofdmPhyErrBase
,
2323 aniState
->cckPhyErrBase
);
2324 REG_WRITE(ah
, AR_PHY_ERR_1
, aniState
->ofdmPhyErrBase
);
2325 REG_WRITE(ah
, AR_PHY_ERR_2
, aniState
->cckPhyErrBase
);
2326 REG_WRITE(ah
, AR_PHY_ERR_MASK_1
, AR_PHY_ERR_OFDM_TIMING
);
2327 REG_WRITE(ah
, AR_PHY_ERR_MASK_2
, AR_PHY_ERR_CCK_TIMING
);
2329 ath9k_hw_update_mibstats(ah
, &ahp
->ah_mibStats
);
2331 aniState
->ofdmPhyErrCount
= 0;
2332 aniState
->cckPhyErrCount
= 0;
2335 static void ath9k_hw_ani_ofdm_err_trigger(struct ath_hal
*ah
)
2337 struct ath_hal_5416
*ahp
= AH5416(ah
);
2338 struct ath9k_channel
*chan
= ah
->ah_curchan
;
2339 struct ar5416AniState
*aniState
;
2340 enum wireless_mode mode
;
2346 aniState
= ahp
->ah_curani
;
2348 if (aniState
->noiseImmunityLevel
< HAL_NOISE_IMMUNE_MAX
) {
2349 if (ath9k_hw_ani_control(ah
, ATH9K_ANI_NOISE_IMMUNITY_LEVEL
,
2350 aniState
->noiseImmunityLevel
+ 1)) {
2355 if (aniState
->spurImmunityLevel
< HAL_SPUR_IMMUNE_MAX
) {
2356 if (ath9k_hw_ani_control(ah
, ATH9K_ANI_SPUR_IMMUNITY_LEVEL
,
2357 aniState
->spurImmunityLevel
+ 1)) {
2362 if (ah
->ah_opmode
== ATH9K_M_HOSTAP
) {
2363 if (aniState
->firstepLevel
< HAL_FIRST_STEP_MAX
) {
2364 ath9k_hw_ani_control(ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2365 aniState
->firstepLevel
+ 1);
2369 rssi
= BEACON_RSSI(ahp
);
2370 if (rssi
> aniState
->rssiThrHigh
) {
2371 if (!aniState
->ofdmWeakSigDetectOff
) {
2372 if (ath9k_hw_ani_control(ah
,
2373 ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION
,
2375 ath9k_hw_ani_control(ah
,
2376 ATH9K_ANI_SPUR_IMMUNITY_LEVEL
,
2381 if (aniState
->firstepLevel
< HAL_FIRST_STEP_MAX
) {
2382 ath9k_hw_ani_control(ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2383 aniState
->firstepLevel
+ 1);
2386 } else if (rssi
> aniState
->rssiThrLow
) {
2387 if (aniState
->ofdmWeakSigDetectOff
)
2388 ath9k_hw_ani_control(ah
,
2389 ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION
,
2391 if (aniState
->firstepLevel
< HAL_FIRST_STEP_MAX
)
2392 ath9k_hw_ani_control(ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2393 aniState
->firstepLevel
+ 1);
2396 mode
= ath9k_hw_chan2wmode(ah
, chan
);
2397 if (mode
== ATH9K_MODE_11G
|| mode
== ATH9K_MODE_11B
) {
2398 if (!aniState
->ofdmWeakSigDetectOff
)
2399 ath9k_hw_ani_control(ah
,
2400 ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION
,
2402 if (aniState
->firstepLevel
> 0)
2403 ath9k_hw_ani_control(ah
,
2404 ATH9K_ANI_FIRSTEP_LEVEL
,
2411 static void ath9k_hw_ani_cck_err_trigger(struct ath_hal
*ah
)
2413 struct ath_hal_5416
*ahp
= AH5416(ah
);
2414 struct ath9k_channel
*chan
= ah
->ah_curchan
;
2415 struct ar5416AniState
*aniState
;
2416 enum wireless_mode mode
;
2422 aniState
= ahp
->ah_curani
;
2423 if (aniState
->noiseImmunityLevel
< HAL_NOISE_IMMUNE_MAX
) {
2424 if (ath9k_hw_ani_control(ah
, ATH9K_ANI_NOISE_IMMUNITY_LEVEL
,
2425 aniState
->noiseImmunityLevel
+ 1)) {
2429 if (ah
->ah_opmode
== ATH9K_M_HOSTAP
) {
2430 if (aniState
->firstepLevel
< HAL_FIRST_STEP_MAX
) {
2431 ath9k_hw_ani_control(ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2432 aniState
->firstepLevel
+ 1);
2436 rssi
= BEACON_RSSI(ahp
);
2437 if (rssi
> aniState
->rssiThrLow
) {
2438 if (aniState
->firstepLevel
< HAL_FIRST_STEP_MAX
)
2439 ath9k_hw_ani_control(ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2440 aniState
->firstepLevel
+ 1);
2442 mode
= ath9k_hw_chan2wmode(ah
, chan
);
2443 if (mode
== ATH9K_MODE_11G
|| mode
== ATH9K_MODE_11B
) {
2444 if (aniState
->firstepLevel
> 0)
2445 ath9k_hw_ani_control(ah
,
2446 ATH9K_ANI_FIRSTEP_LEVEL
,
2452 static void ath9k_ani_reset(struct ath_hal
*ah
)
2454 struct ath_hal_5416
*ahp
= AH5416(ah
);
2455 struct ar5416AniState
*aniState
;
2456 struct ath9k_channel
*chan
= ah
->ah_curchan
;
2462 index
= ath9k_hw_get_ani_channel_idx(ah
, chan
);
2463 aniState
= &ahp
->ah_ani
[index
];
2464 ahp
->ah_curani
= aniState
;
2466 if (DO_ANI(ah
) && ah
->ah_opmode
!= ATH9K_M_STA
2467 && ah
->ah_opmode
!= ATH9K_M_IBSS
) {
2468 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2469 "%s: Reset ANI state opmode %u\n", __func__
,
2471 ahp
->ah_stats
.ast_ani_reset
++;
2472 ath9k_hw_ani_control(ah
, ATH9K_ANI_NOISE_IMMUNITY_LEVEL
, 0);
2473 ath9k_hw_ani_control(ah
, ATH9K_ANI_SPUR_IMMUNITY_LEVEL
, 0);
2474 ath9k_hw_ani_control(ah
, ATH9K_ANI_FIRSTEP_LEVEL
, 0);
2475 ath9k_hw_ani_control(ah
,
2476 ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION
,
2477 !ATH9K_ANI_USE_OFDM_WEAK_SIG
);
2478 ath9k_hw_ani_control(ah
, ATH9K_ANI_CCK_WEAK_SIGNAL_THR
,
2479 ATH9K_ANI_CCK_WEAK_SIG_THR
);
2480 ath9k_hw_setrxfilter(ah
,
2481 ath9k_hw_getrxfilter(ah
) |
2482 ATH9K_RX_FILTER_PHYERR
);
2483 if (ah
->ah_opmode
== ATH9K_M_HOSTAP
) {
2484 ahp
->ah_curani
->ofdmTrigHigh
=
2485 ah
->ah_config
.ofdm_trig_high
;
2486 ahp
->ah_curani
->ofdmTrigLow
=
2487 ah
->ah_config
.ofdm_trig_low
;
2488 ahp
->ah_curani
->cckTrigHigh
=
2489 ah
->ah_config
.cck_trig_high
;
2490 ahp
->ah_curani
->cckTrigLow
=
2491 ah
->ah_config
.cck_trig_low
;
2493 ath9k_ani_restart(ah
);
2497 if (aniState
->noiseImmunityLevel
!= 0)
2498 ath9k_hw_ani_control(ah
, ATH9K_ANI_NOISE_IMMUNITY_LEVEL
,
2499 aniState
->noiseImmunityLevel
);
2500 if (aniState
->spurImmunityLevel
!= 0)
2501 ath9k_hw_ani_control(ah
, ATH9K_ANI_SPUR_IMMUNITY_LEVEL
,
2502 aniState
->spurImmunityLevel
);
2503 if (aniState
->ofdmWeakSigDetectOff
)
2504 ath9k_hw_ani_control(ah
,
2505 ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION
,
2506 !aniState
->ofdmWeakSigDetectOff
);
2507 if (aniState
->cckWeakSigThreshold
)
2508 ath9k_hw_ani_control(ah
, ATH9K_ANI_CCK_WEAK_SIGNAL_THR
,
2509 aniState
->cckWeakSigThreshold
);
2510 if (aniState
->firstepLevel
!= 0)
2511 ath9k_hw_ani_control(ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2512 aniState
->firstepLevel
);
2513 if (ahp
->ah_hasHwPhyCounters
) {
2514 ath9k_hw_setrxfilter(ah
,
2515 ath9k_hw_getrxfilter(ah
) &
2516 ~ATH9K_RX_FILTER_PHYERR
);
2517 ath9k_ani_restart(ah
);
2518 REG_WRITE(ah
, AR_PHY_ERR_MASK_1
, AR_PHY_ERR_OFDM_TIMING
);
2519 REG_WRITE(ah
, AR_PHY_ERR_MASK_2
, AR_PHY_ERR_CCK_TIMING
);
2522 ath9k_ani_restart(ah
);
2523 ath9k_hw_setrxfilter(ah
,
2524 ath9k_hw_getrxfilter(ah
) |
2525 ATH9K_RX_FILTER_PHYERR
);
2529 void ath9k_hw_procmibevent(struct ath_hal
*ah
,
2530 const struct ath9k_node_stats
*stats
)
2532 struct ath_hal_5416
*ahp
= AH5416(ah
);
2533 u32 phyCnt1
, phyCnt2
;
2535 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
, "Processing Mib Intr\n");
2537 REG_WRITE(ah
, AR_FILT_OFDM
, 0);
2538 REG_WRITE(ah
, AR_FILT_CCK
, 0);
2539 if (!(REG_READ(ah
, AR_SLP_MIB_CTRL
) & AR_SLP_MIB_PENDING
))
2540 REG_WRITE(ah
, AR_SLP_MIB_CTRL
, AR_SLP_MIB_CLEAR
);
2542 ath9k_hw_update_mibstats(ah
, &ahp
->ah_mibStats
);
2543 ahp
->ah_stats
.ast_nodestats
= *stats
;
2548 phyCnt1
= REG_READ(ah
, AR_PHY_ERR_1
);
2549 phyCnt2
= REG_READ(ah
, AR_PHY_ERR_2
);
2550 if (((phyCnt1
& AR_MIBCNT_INTRMASK
) == AR_MIBCNT_INTRMASK
) ||
2551 ((phyCnt2
& AR_MIBCNT_INTRMASK
) == AR_MIBCNT_INTRMASK
)) {
2552 struct ar5416AniState
*aniState
= ahp
->ah_curani
;
2553 u32 ofdmPhyErrCnt
, cckPhyErrCnt
;
2555 ofdmPhyErrCnt
= phyCnt1
- aniState
->ofdmPhyErrBase
;
2556 ahp
->ah_stats
.ast_ani_ofdmerrs
+=
2557 ofdmPhyErrCnt
- aniState
->ofdmPhyErrCount
;
2558 aniState
->ofdmPhyErrCount
= ofdmPhyErrCnt
;
2560 cckPhyErrCnt
= phyCnt2
- aniState
->cckPhyErrBase
;
2561 ahp
->ah_stats
.ast_ani_cckerrs
+=
2562 cckPhyErrCnt
- aniState
->cckPhyErrCount
;
2563 aniState
->cckPhyErrCount
= cckPhyErrCnt
;
2565 if (aniState
->ofdmPhyErrCount
> aniState
->ofdmTrigHigh
)
2566 ath9k_hw_ani_ofdm_err_trigger(ah
);
2567 if (aniState
->cckPhyErrCount
> aniState
->cckTrigHigh
)
2568 ath9k_hw_ani_cck_err_trigger(ah
);
2570 ath9k_ani_restart(ah
);
2574 static void ath9k_hw_ani_lower_immunity(struct ath_hal
*ah
)
2576 struct ath_hal_5416
*ahp
= AH5416(ah
);
2577 struct ar5416AniState
*aniState
;
2580 aniState
= ahp
->ah_curani
;
2582 if (ah
->ah_opmode
== ATH9K_M_HOSTAP
) {
2583 if (aniState
->firstepLevel
> 0) {
2584 if (ath9k_hw_ani_control(ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2585 aniState
->firstepLevel
- 1)) {
2590 rssi
= BEACON_RSSI(ahp
);
2591 if (rssi
> aniState
->rssiThrHigh
) {
2592 /* XXX: Handle me */
2593 } else if (rssi
> aniState
->rssiThrLow
) {
2594 if (aniState
->ofdmWeakSigDetectOff
) {
2595 if (ath9k_hw_ani_control(ah
,
2596 ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION
,
2602 if (aniState
->firstepLevel
> 0) {
2603 if (ath9k_hw_ani_control
2604 (ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2605 aniState
->firstepLevel
- 1) ==
2611 if (aniState
->firstepLevel
> 0) {
2612 if (ath9k_hw_ani_control
2613 (ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2614 aniState
->firstepLevel
- 1) ==
2622 if (aniState
->spurImmunityLevel
> 0) {
2623 if (ath9k_hw_ani_control(ah
, ATH9K_ANI_SPUR_IMMUNITY_LEVEL
,
2624 aniState
->spurImmunityLevel
- 1)) {
2629 if (aniState
->noiseImmunityLevel
> 0) {
2630 ath9k_hw_ani_control(ah
, ATH9K_ANI_NOISE_IMMUNITY_LEVEL
,
2631 aniState
->noiseImmunityLevel
- 1);
2636 static int32_t ath9k_hw_ani_get_listen_time(struct ath_hal
*ah
)
2638 struct ath_hal_5416
*ahp
= AH5416(ah
);
2639 struct ar5416AniState
*aniState
;
2640 u32 txFrameCount
, rxFrameCount
, cycleCount
;
2643 txFrameCount
= REG_READ(ah
, AR_TFCNT
);
2644 rxFrameCount
= REG_READ(ah
, AR_RFCNT
);
2645 cycleCount
= REG_READ(ah
, AR_CCCNT
);
2647 aniState
= ahp
->ah_curani
;
2648 if (aniState
->cycleCount
== 0 || aniState
->cycleCount
> cycleCount
) {
2651 ahp
->ah_stats
.ast_ani_lzero
++;
2653 int32_t ccdelta
= cycleCount
- aniState
->cycleCount
;
2654 int32_t rfdelta
= rxFrameCount
- aniState
->rxFrameCount
;
2655 int32_t tfdelta
= txFrameCount
- aniState
->txFrameCount
;
2656 listenTime
= (ccdelta
- rfdelta
- tfdelta
) / 44000;
2658 aniState
->cycleCount
= cycleCount
;
2659 aniState
->txFrameCount
= txFrameCount
;
2660 aniState
->rxFrameCount
= rxFrameCount
;
2665 void ath9k_hw_ani_monitor(struct ath_hal
*ah
,
2666 const struct ath9k_node_stats
*stats
,
2667 struct ath9k_channel
*chan
)
2669 struct ath_hal_5416
*ahp
= AH5416(ah
);
2670 struct ar5416AniState
*aniState
;
2673 aniState
= ahp
->ah_curani
;
2674 ahp
->ah_stats
.ast_nodestats
= *stats
;
2676 listenTime
= ath9k_hw_ani_get_listen_time(ah
);
2677 if (listenTime
< 0) {
2678 ahp
->ah_stats
.ast_ani_lneg
++;
2679 ath9k_ani_restart(ah
);
2683 aniState
->listenTime
+= listenTime
;
2685 if (ahp
->ah_hasHwPhyCounters
) {
2686 u32 phyCnt1
, phyCnt2
;
2687 u32 ofdmPhyErrCnt
, cckPhyErrCnt
;
2689 ath9k_hw_update_mibstats(ah
, &ahp
->ah_mibStats
);
2691 phyCnt1
= REG_READ(ah
, AR_PHY_ERR_1
);
2692 phyCnt2
= REG_READ(ah
, AR_PHY_ERR_2
);
2694 if (phyCnt1
< aniState
->ofdmPhyErrBase
||
2695 phyCnt2
< aniState
->cckPhyErrBase
) {
2696 if (phyCnt1
< aniState
->ofdmPhyErrBase
) {
2697 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2698 "%s: phyCnt1 0x%x, resetting "
2699 "counter value to 0x%x\n",
2701 aniState
->ofdmPhyErrBase
);
2702 REG_WRITE(ah
, AR_PHY_ERR_1
,
2703 aniState
->ofdmPhyErrBase
);
2704 REG_WRITE(ah
, AR_PHY_ERR_MASK_1
,
2705 AR_PHY_ERR_OFDM_TIMING
);
2707 if (phyCnt2
< aniState
->cckPhyErrBase
) {
2708 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2709 "%s: phyCnt2 0x%x, resetting "
2710 "counter value to 0x%x\n",
2712 aniState
->cckPhyErrBase
);
2713 REG_WRITE(ah
, AR_PHY_ERR_2
,
2714 aniState
->cckPhyErrBase
);
2715 REG_WRITE(ah
, AR_PHY_ERR_MASK_2
,
2716 AR_PHY_ERR_CCK_TIMING
);
2721 ofdmPhyErrCnt
= phyCnt1
- aniState
->ofdmPhyErrBase
;
2722 ahp
->ah_stats
.ast_ani_ofdmerrs
+=
2723 ofdmPhyErrCnt
- aniState
->ofdmPhyErrCount
;
2724 aniState
->ofdmPhyErrCount
= ofdmPhyErrCnt
;
2726 cckPhyErrCnt
= phyCnt2
- aniState
->cckPhyErrBase
;
2727 ahp
->ah_stats
.ast_ani_cckerrs
+=
2728 cckPhyErrCnt
- aniState
->cckPhyErrCount
;
2729 aniState
->cckPhyErrCount
= cckPhyErrCnt
;
2735 if (aniState
->listenTime
> 5 * ahp
->ah_aniPeriod
) {
2736 if (aniState
->ofdmPhyErrCount
<= aniState
->listenTime
*
2737 aniState
->ofdmTrigLow
/ 1000 &&
2738 aniState
->cckPhyErrCount
<= aniState
->listenTime
*
2739 aniState
->cckTrigLow
/ 1000)
2740 ath9k_hw_ani_lower_immunity(ah
);
2741 ath9k_ani_restart(ah
);
2742 } else if (aniState
->listenTime
> ahp
->ah_aniPeriod
) {
2743 if (aniState
->ofdmPhyErrCount
> aniState
->listenTime
*
2744 aniState
->ofdmTrigHigh
/ 1000) {
2745 ath9k_hw_ani_ofdm_err_trigger(ah
);
2746 ath9k_ani_restart(ah
);
2747 } else if (aniState
->cckPhyErrCount
>
2748 aniState
->listenTime
* aniState
->cckTrigHigh
/
2750 ath9k_hw_ani_cck_err_trigger(ah
);
2751 ath9k_ani_restart(ah
);
2756 #ifndef ATH_NF_PER_CHAN
2757 static void ath9k_init_nfcal_hist_buffer(struct ath_hal
*ah
)
2761 for (i
= 0; i
< NUM_NF_READINGS
; i
++) {
2762 ah
->nfCalHist
[i
].currIndex
= 0;
2763 ah
->nfCalHist
[i
].privNF
= AR_PHY_CCA_MAX_GOOD_VALUE
;
2764 ah
->nfCalHist
[i
].invalidNFcount
=
2765 AR_PHY_CCA_FILTERWINDOW_LENGTH
;
2766 for (j
= 0; j
< ATH9K_NF_CAL_HIST_MAX
; j
++) {
2767 ah
->nfCalHist
[i
].nfCalBuffer
[j
] =
2768 AR_PHY_CCA_MAX_GOOD_VALUE
;
2775 static void ath9k_hw_gpio_cfg_output_mux(struct ath_hal
*ah
,
2779 u32 gpio_shift
, tmp
;
2782 addr
= AR_GPIO_OUTPUT_MUX3
;
2784 addr
= AR_GPIO_OUTPUT_MUX2
;
2786 addr
= AR_GPIO_OUTPUT_MUX1
;
2788 gpio_shift
= (gpio
% 6) * 5;
2790 if (AR_SREV_9280_20_OR_LATER(ah
)
2791 || (addr
!= AR_GPIO_OUTPUT_MUX1
)) {
2792 REG_RMW(ah
, addr
, (type
<< gpio_shift
),
2793 (0x1f << gpio_shift
));
2795 tmp
= REG_READ(ah
, addr
);
2796 tmp
= ((tmp
& 0x1F0) << 1) | (tmp
& ~0x1F0);
2797 tmp
&= ~(0x1f << gpio_shift
);
2798 tmp
|= (type
<< gpio_shift
);
2799 REG_WRITE(ah
, addr
, tmp
);
2803 static bool ath9k_hw_cfg_output(struct ath_hal
*ah
, u32 gpio
,
2804 enum ath9k_gpio_output_mux_type
2810 static u32 MuxSignalConversionTable
[] = {
2812 AR_GPIO_OUTPUT_MUX_AS_OUTPUT
,
2814 AR_GPIO_OUTPUT_MUX_AS_PCIE_ATTENTION_LED
,
2816 AR_GPIO_OUTPUT_MUX_AS_PCIE_POWER_LED
,
2818 AR_GPIO_OUTPUT_MUX_AS_MAC_NETWORK_LED
,
2820 AR_GPIO_OUTPUT_MUX_AS_MAC_POWER_LED
,
2823 if ((halSignalType
>= 0)
2824 && (halSignalType
< ARRAY_SIZE(MuxSignalConversionTable
)))
2825 ah_signal_type
= MuxSignalConversionTable
[halSignalType
];
2829 ath9k_hw_gpio_cfg_output_mux(ah
, gpio
, ah_signal_type
);
2831 gpio_shift
= 2 * gpio
;
2835 (AR_GPIO_OE_OUT_DRV_ALL
<< gpio_shift
),
2836 (AR_GPIO_OE_OUT_DRV
<< gpio_shift
));
2841 static bool ath9k_hw_set_gpio(struct ath_hal
*ah
, u32 gpio
,
2844 REG_RMW(ah
, AR_GPIO_IN_OUT
, ((val
& 1) << gpio
),
2849 static u32
ath9k_hw_gpio_get(struct ath_hal
*ah
, u32 gpio
)
2851 if (gpio
>= ah
->ah_caps
.num_gpio_pins
)
2854 if (AR_SREV_9280_10_OR_LATER(ah
)) {
2856 (REG_READ(ah
, AR_GPIO_IN_OUT
),
2857 AR928X_GPIO_IN_VAL
) & AR_GPIO_BIT(gpio
)) != 0;
2859 return (MS(REG_READ(ah
, AR_GPIO_IN_OUT
), AR_GPIO_IN_VAL
) &
2860 AR_GPIO_BIT(gpio
)) != 0;
2864 static inline int ath9k_hw_post_attach(struct ath_hal
*ah
)
2868 if (!ath9k_hw_chip_test(ah
)) {
2869 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
2870 "%s: hardware self-test failed\n", __func__
);
2874 ecode
= ath9k_hw_rf_claim(ah
);
2878 ecode
= ath9k_hw_eeprom_attach(ah
);
2881 ecode
= ath9k_hw_rfattach(ah
);
2885 if (!AR_SREV_9100(ah
)) {
2886 ath9k_hw_ani_setup(ah
);
2887 ath9k_hw_ani_attach(ah
);
2892 static u32
ath9k_hw_ini_fixup(struct ath_hal
*ah
,
2893 struct ar5416_eeprom
*pEepData
,
2896 struct base_eep_header
*pBase
= &(pEepData
->baseEepHeader
);
2898 switch (ah
->ah_devid
) {
2899 case AR9280_DEVID_PCI
:
2900 if (reg
== 0x7894) {
2901 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2902 "ini VAL: %x EEPROM: %x\n", value
,
2903 (pBase
->version
& 0xff));
2905 if ((pBase
->version
& 0xff) > 0x0a) {
2906 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2909 value
&= ~AR_AN_TOP2_PWDCLKIND
;
2910 value
|= AR_AN_TOP2_PWDCLKIND
& (pBase
->
2911 pwdclkind
<< AR_AN_TOP2_PWDCLKIND_S
);
2913 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2914 "PWDCLKIND Earlier Rev\n");
2917 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2918 "final ini VAL: %x\n", value
);
2925 static bool ath9k_hw_fill_cap_info(struct ath_hal
*ah
)
2927 struct ath_hal_5416
*ahp
= AH5416(ah
);
2928 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
2929 u16 capField
= 0, eeval
;
2931 eeval
= ath9k_hw_get_eeprom(ahp
, EEP_REG_0
);
2933 ah
->ah_currentRD
= eeval
;
2935 eeval
= ath9k_hw_get_eeprom(ahp
, EEP_REG_1
);
2936 ah
->ah_currentRDExt
= eeval
;
2938 capField
= ath9k_hw_get_eeprom(ahp
, EEP_OP_CAP
);
2940 if (ah
->ah_opmode
!= ATH9K_M_HOSTAP
&&
2941 ah
->ah_subvendorid
== AR_SUBVENDOR_ID_NEW_A
) {
2942 if (ah
->ah_currentRD
== 0x64 || ah
->ah_currentRD
== 0x65)
2943 ah
->ah_currentRD
+= 5;
2944 else if (ah
->ah_currentRD
== 0x41)
2945 ah
->ah_currentRD
= 0x43;
2946 DPRINTF(ah
->ah_sc
, ATH_DBG_REGULATORY
,
2947 "%s: regdomain mapped to 0x%x\n", __func__
,
2951 eeval
= ath9k_hw_get_eeprom(ahp
, EEP_OP_MODE
);
2952 bitmap_zero(pCap
->wireless_modes
, ATH9K_MODE_MAX
);
2954 if (eeval
& AR5416_OPFLAGS_11A
) {
2955 set_bit(ATH9K_MODE_11A
, pCap
->wireless_modes
);
2956 if (ah
->ah_config
.ht_enable
) {
2957 if (!(eeval
& AR5416_OPFLAGS_N_5G_HT20
))
2958 set_bit(ATH9K_MODE_11NA_HT20
,
2959 pCap
->wireless_modes
);
2960 if (!(eeval
& AR5416_OPFLAGS_N_5G_HT40
)) {
2961 set_bit(ATH9K_MODE_11NA_HT40PLUS
,
2962 pCap
->wireless_modes
);
2963 set_bit(ATH9K_MODE_11NA_HT40MINUS
,
2964 pCap
->wireless_modes
);
2969 if (eeval
& AR5416_OPFLAGS_11G
) {
2970 set_bit(ATH9K_MODE_11B
, pCap
->wireless_modes
);
2971 set_bit(ATH9K_MODE_11G
, pCap
->wireless_modes
);
2972 if (ah
->ah_config
.ht_enable
) {
2973 if (!(eeval
& AR5416_OPFLAGS_N_2G_HT20
))
2974 set_bit(ATH9K_MODE_11NG_HT20
,
2975 pCap
->wireless_modes
);
2976 if (!(eeval
& AR5416_OPFLAGS_N_2G_HT40
)) {
2977 set_bit(ATH9K_MODE_11NG_HT40PLUS
,
2978 pCap
->wireless_modes
);
2979 set_bit(ATH9K_MODE_11NG_HT40MINUS
,
2980 pCap
->wireless_modes
);
2985 pCap
->tx_chainmask
= ath9k_hw_get_eeprom(ahp
, EEP_TX_MASK
);
2986 if ((ah
->ah_isPciExpress
)
2987 || (eeval
& AR5416_OPFLAGS_11A
)) {
2988 pCap
->rx_chainmask
=
2989 ath9k_hw_get_eeprom(ahp
, EEP_RX_MASK
);
2991 pCap
->rx_chainmask
=
2992 (ath9k_hw_gpio_get(ah
, 0)) ? 0x5 : 0x7;
2995 if (!(AR_SREV_9280(ah
) && (ah
->ah_macRev
== 0)))
2996 ahp
->ah_miscMode
|= AR_PCU_MIC_NEW_LOC_ENA
;
2998 pCap
->low_2ghz_chan
= 2312;
2999 pCap
->high_2ghz_chan
= 2732;
3001 pCap
->low_5ghz_chan
= 4920;
3002 pCap
->high_5ghz_chan
= 6100;
3004 pCap
->hw_caps
&= ~ATH9K_HW_CAP_CIPHER_CKIP
;
3005 pCap
->hw_caps
|= ATH9K_HW_CAP_CIPHER_TKIP
;
3006 pCap
->hw_caps
|= ATH9K_HW_CAP_CIPHER_AESCCM
;
3008 pCap
->hw_caps
&= ~ATH9K_HW_CAP_MIC_CKIP
;
3009 pCap
->hw_caps
|= ATH9K_HW_CAP_MIC_TKIP
;
3010 pCap
->hw_caps
|= ATH9K_HW_CAP_MIC_AESCCM
;
3012 pCap
->hw_caps
|= ATH9K_HW_CAP_CHAN_SPREAD
;
3014 if (ah
->ah_config
.ht_enable
)
3015 pCap
->hw_caps
|= ATH9K_HW_CAP_HT
;
3017 pCap
->hw_caps
&= ~ATH9K_HW_CAP_HT
;
3019 pCap
->hw_caps
|= ATH9K_HW_CAP_GTT
;
3020 pCap
->hw_caps
|= ATH9K_HW_CAP_VEOL
;
3021 pCap
->hw_caps
|= ATH9K_HW_CAP_BSSIDMASK
;
3022 pCap
->hw_caps
&= ~ATH9K_HW_CAP_MCAST_KEYSEARCH
;
3024 if (capField
& AR_EEPROM_EEPCAP_MAXQCU
)
3025 pCap
->total_queues
=
3026 MS(capField
, AR_EEPROM_EEPCAP_MAXQCU
);
3028 pCap
->total_queues
= ATH9K_NUM_TX_QUEUES
;
3030 if (capField
& AR_EEPROM_EEPCAP_KC_ENTRIES
)
3031 pCap
->keycache_size
=
3032 1 << MS(capField
, AR_EEPROM_EEPCAP_KC_ENTRIES
);
3034 pCap
->keycache_size
= AR_KEYTABLE_SIZE
;
3036 pCap
->hw_caps
|= ATH9K_HW_CAP_FASTCC
;
3037 pCap
->num_mr_retries
= 4;
3038 pCap
->tx_triglevel_max
= MAX_TX_FIFO_THRESHOLD
;
3040 if (AR_SREV_9280_10_OR_LATER(ah
))
3041 pCap
->num_gpio_pins
= AR928X_NUM_GPIO
;
3043 pCap
->num_gpio_pins
= AR_NUM_GPIO
;
3045 if (AR_SREV_9280_10_OR_LATER(ah
)) {
3046 pCap
->hw_caps
|= ATH9K_HW_CAP_WOW
;
3047 pCap
->hw_caps
|= ATH9K_HW_CAP_WOW_MATCHPATTERN_EXACT
;
3049 pCap
->hw_caps
&= ~ATH9K_HW_CAP_WOW
;
3050 pCap
->hw_caps
&= ~ATH9K_HW_CAP_WOW_MATCHPATTERN_EXACT
;
3053 if (AR_SREV_9160_10_OR_LATER(ah
) || AR_SREV_9100(ah
)) {
3054 pCap
->hw_caps
|= ATH9K_HW_CAP_CST
;
3055 pCap
->rts_aggr_limit
= ATH_AMPDU_LIMIT_MAX
;
3057 pCap
->rts_aggr_limit
= (8 * 1024);
3060 pCap
->hw_caps
|= ATH9K_HW_CAP_ENHANCEDPM
;
3062 ah
->ah_rfsilent
= ath9k_hw_get_eeprom(ahp
, EEP_RF_SILENT
);
3063 if (ah
->ah_rfsilent
& EEP_RFSILENT_ENABLED
) {
3064 ahp
->ah_gpioSelect
=
3065 MS(ah
->ah_rfsilent
, EEP_RFSILENT_GPIO_SEL
);
3067 MS(ah
->ah_rfsilent
, EEP_RFSILENT_POLARITY
);
3069 ath9k_hw_setcapability(ah
, ATH9K_CAP_RFSILENT
, 1, true,
3071 pCap
->hw_caps
|= ATH9K_HW_CAP_RFSILENT
;
3074 if ((ah
->ah_macVersion
== AR_SREV_VERSION_5416_PCI
) ||
3075 (ah
->ah_macVersion
== AR_SREV_VERSION_5416_PCIE
) ||
3076 (ah
->ah_macVersion
== AR_SREV_VERSION_9160
) ||
3077 (ah
->ah_macVersion
== AR_SREV_VERSION_9100
) ||
3078 (ah
->ah_macVersion
== AR_SREV_VERSION_9280
))
3079 pCap
->hw_caps
&= ~ATH9K_HW_CAP_AUTOSLEEP
;
3081 pCap
->hw_caps
|= ATH9K_HW_CAP_AUTOSLEEP
;
3083 if (AR_SREV_9280(ah
))
3084 pCap
->hw_caps
&= ~ATH9K_HW_CAP_4KB_SPLITTRANS
;
3086 pCap
->hw_caps
|= ATH9K_HW_CAP_4KB_SPLITTRANS
;
3088 if (ah
->ah_currentRDExt
& (1 << REG_EXT_JAPAN_MIDBAND
)) {
3090 AR_EEPROM_EEREGCAP_EN_KK_NEW_11A
|
3091 AR_EEPROM_EEREGCAP_EN_KK_U1_EVEN
|
3092 AR_EEPROM_EEREGCAP_EN_KK_U2
|
3093 AR_EEPROM_EEREGCAP_EN_KK_MIDBAND
;
3096 AR_EEPROM_EEREGCAP_EN_KK_NEW_11A
|
3097 AR_EEPROM_EEREGCAP_EN_KK_U1_EVEN
;
3100 pCap
->reg_cap
|= AR_EEPROM_EEREGCAP_EN_FCC_MIDBAND
;
3102 pCap
->num_antcfg_5ghz
=
3103 ath9k_hw_get_num_ant_config(ahp
, IEEE80211_BAND_5GHZ
);
3104 pCap
->num_antcfg_2ghz
=
3105 ath9k_hw_get_num_ant_config(ahp
, IEEE80211_BAND_2GHZ
);
3110 static void ar5416DisablePciePhy(struct ath_hal
*ah
)
3112 if (!AR_SREV_9100(ah
))
3115 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x9248fc00);
3116 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x24924924);
3117 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x28000029);
3118 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x57160824);
3119 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x25980579);
3120 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x00000000);
3121 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x1aaabe40);
3122 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xbe105554);
3123 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x000e1007);
3125 REG_WRITE(ah
, AR_PCIE_SERDES2
, 0x00000000);
3128 static void ath9k_set_power_sleep(struct ath_hal
*ah
, int setChip
)
3130 REG_SET_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PWR_SAV
);
3132 REG_CLR_BIT(ah
, AR_RTC_FORCE_WAKE
,
3133 AR_RTC_FORCE_WAKE_EN
);
3134 if (!AR_SREV_9100(ah
))
3135 REG_WRITE(ah
, AR_RC
, AR_RC_AHB
| AR_RC_HOSTIF
);
3137 REG_CLR_BIT(ah
, (u16
) (AR_RTC_RESET
),
3142 static void ath9k_set_power_network_sleep(struct ath_hal
*ah
, int setChip
)
3144 REG_SET_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PWR_SAV
);
3146 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
3148 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)) {
3149 REG_WRITE(ah
, AR_RTC_FORCE_WAKE
,
3150 AR_RTC_FORCE_WAKE_ON_INT
);
3152 REG_CLR_BIT(ah
, AR_RTC_FORCE_WAKE
,
3153 AR_RTC_FORCE_WAKE_EN
);
3158 static bool ath9k_hw_set_power_awake(struct ath_hal
*ah
,
3165 if ((REG_READ(ah
, AR_RTC_STATUS
) & AR_RTC_STATUS_M
) ==
3166 AR_RTC_STATUS_SHUTDOWN
) {
3167 if (ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_POWER_ON
)
3172 if (AR_SREV_9100(ah
))
3173 REG_SET_BIT(ah
, AR_RTC_RESET
,
3176 REG_SET_BIT(ah
, AR_RTC_FORCE_WAKE
,
3177 AR_RTC_FORCE_WAKE_EN
);
3180 for (i
= POWER_UP_TIME
/ 50; i
> 0; i
--) {
3181 val
= REG_READ(ah
, AR_RTC_STATUS
) & AR_RTC_STATUS_M
;
3182 if (val
== AR_RTC_STATUS_ON
)
3185 REG_SET_BIT(ah
, AR_RTC_FORCE_WAKE
,
3186 AR_RTC_FORCE_WAKE_EN
);
3189 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
3190 "%s: Failed to wakeup in %uus\n",
3191 __func__
, POWER_UP_TIME
/ 20);
3196 REG_CLR_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PWR_SAV
);
3200 bool ath9k_hw_setpower(struct ath_hal
*ah
,
3201 enum ath9k_power_mode mode
)
3203 struct ath_hal_5416
*ahp
= AH5416(ah
);
3204 static const char *modes
[] = {
3210 int status
= true, setChip
= true;
3212 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
, "%s: %s -> %s (%s)\n", __func__
,
3213 modes
[ahp
->ah_powerMode
], modes
[mode
],
3214 setChip
? "set chip " : "");
3217 case ATH9K_PM_AWAKE
:
3218 status
= ath9k_hw_set_power_awake(ah
, setChip
);
3220 case ATH9K_PM_FULL_SLEEP
:
3221 ath9k_set_power_sleep(ah
, setChip
);
3222 ahp
->ah_chipFullSleep
= true;
3224 case ATH9K_PM_NETWORK_SLEEP
:
3225 ath9k_set_power_network_sleep(ah
, setChip
);
3228 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
3229 "%s: unknown power mode %u\n", __func__
, mode
);
3232 ahp
->ah_powerMode
= mode
;
3236 static struct ath_hal
*ath9k_hw_do_attach(u16 devid
,
3237 struct ath_softc
*sc
,
3241 struct ath_hal_5416
*ahp
;
3244 #ifndef CONFIG_SLOW_ANT_DIV
3249 ahp
= ath9k_hw_newstate(devid
, sc
, mem
, status
);
3255 ath9k_hw_set_defaults(ah
);
3257 if (ah
->ah_config
.intr_mitigation
!= 0)
3258 ahp
->ah_intrMitigation
= true;
3260 if (!ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_POWER_ON
)) {
3261 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: couldn't reset chip\n",
3267 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
)) {
3268 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: couldn't wakeup chip\n",
3274 if (ah
->ah_config
.serialize_regmode
== SER_REG_MODE_AUTO
) {
3275 if (ah
->ah_macVersion
== AR_SREV_VERSION_5416_PCI
) {
3276 ah
->ah_config
.serialize_regmode
=
3279 ah
->ah_config
.serialize_regmode
=
3283 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3284 "%s: serialize_regmode is %d\n",
3285 __func__
, ah
->ah_config
.serialize_regmode
);
3287 if ((ah
->ah_macVersion
!= AR_SREV_VERSION_5416_PCI
) &&
3288 (ah
->ah_macVersion
!= AR_SREV_VERSION_5416_PCIE
) &&
3289 (ah
->ah_macVersion
!= AR_SREV_VERSION_9160
) &&
3290 (!AR_SREV_9100(ah
)) && (!AR_SREV_9280(ah
))) {
3291 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3292 "%s: Mac Chip Rev 0x%02x.%x is not supported by "
3293 "this driver\n", __func__
,
3294 ah
->ah_macVersion
, ah
->ah_macRev
);
3295 ecode
= -EOPNOTSUPP
;
3299 if (AR_SREV_9100(ah
)) {
3300 ahp
->ah_iqCalData
.calData
= &iq_cal_multi_sample
;
3301 ahp
->ah_suppCals
= IQ_MISMATCH_CAL
;
3302 ah
->ah_isPciExpress
= false;
3304 ah
->ah_phyRev
= REG_READ(ah
, AR_PHY_CHIP_ID
);
3306 if (AR_SREV_9160_10_OR_LATER(ah
)) {
3307 if (AR_SREV_9280_10_OR_LATER(ah
)) {
3308 ahp
->ah_iqCalData
.calData
= &iq_cal_single_sample
;
3309 ahp
->ah_adcGainCalData
.calData
=
3310 &adc_gain_cal_single_sample
;
3311 ahp
->ah_adcDcCalData
.calData
=
3312 &adc_dc_cal_single_sample
;
3313 ahp
->ah_adcDcCalInitData
.calData
=
3316 ahp
->ah_iqCalData
.calData
= &iq_cal_multi_sample
;
3317 ahp
->ah_adcGainCalData
.calData
=
3318 &adc_gain_cal_multi_sample
;
3319 ahp
->ah_adcDcCalData
.calData
=
3320 &adc_dc_cal_multi_sample
;
3321 ahp
->ah_adcDcCalInitData
.calData
=
3325 ADC_GAIN_CAL
| ADC_DC_CAL
| IQ_MISMATCH_CAL
;
3328 if (AR_SREV_9160(ah
)) {
3329 ah
->ah_config
.enable_ani
= 1;
3330 ahp
->ah_ani_function
= (ATH9K_ANI_SPUR_IMMUNITY_LEVEL
|
3331 ATH9K_ANI_FIRSTEP_LEVEL
);
3333 ahp
->ah_ani_function
= ATH9K_ANI_ALL
;
3334 if (AR_SREV_9280_10_OR_LATER(ah
)) {
3335 ahp
->ah_ani_function
&=
3336 ~ATH9K_ANI_NOISE_IMMUNITY_LEVEL
;
3340 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3341 "%s: This Mac Chip Rev 0x%02x.%x is \n", __func__
,
3342 ah
->ah_macVersion
, ah
->ah_macRev
);
3344 if (AR_SREV_9280_20_OR_LATER(ah
)) {
3345 INIT_INI_ARRAY(&ahp
->ah_iniModes
, ar9280Modes_9280_2
,
3346 ARRAY_SIZE(ar9280Modes_9280_2
), 6);
3347 INIT_INI_ARRAY(&ahp
->ah_iniCommon
, ar9280Common_9280_2
,
3348 ARRAY_SIZE(ar9280Common_9280_2
), 2);
3350 if (ah
->ah_config
.pcie_clock_req
) {
3351 INIT_INI_ARRAY(&ahp
->ah_iniPcieSerdes
,
3352 ar9280PciePhy_clkreq_off_L1_9280
,
3354 (ar9280PciePhy_clkreq_off_L1_9280
),
3357 INIT_INI_ARRAY(&ahp
->ah_iniPcieSerdes
,
3358 ar9280PciePhy_clkreq_always_on_L1_9280
,
3360 (ar9280PciePhy_clkreq_always_on_L1_9280
),
3363 INIT_INI_ARRAY(&ahp
->ah_iniModesAdditional
,
3364 ar9280Modes_fast_clock_9280_2
,
3365 ARRAY_SIZE(ar9280Modes_fast_clock_9280_2
),
3367 } else if (AR_SREV_9280_10_OR_LATER(ah
)) {
3368 INIT_INI_ARRAY(&ahp
->ah_iniModes
, ar9280Modes_9280
,
3369 ARRAY_SIZE(ar9280Modes_9280
), 6);
3370 INIT_INI_ARRAY(&ahp
->ah_iniCommon
, ar9280Common_9280
,
3371 ARRAY_SIZE(ar9280Common_9280
), 2);
3372 } else if (AR_SREV_9160_10_OR_LATER(ah
)) {
3373 INIT_INI_ARRAY(&ahp
->ah_iniModes
, ar5416Modes_9160
,
3374 ARRAY_SIZE(ar5416Modes_9160
), 6);
3375 INIT_INI_ARRAY(&ahp
->ah_iniCommon
, ar5416Common_9160
,
3376 ARRAY_SIZE(ar5416Common_9160
), 2);
3377 INIT_INI_ARRAY(&ahp
->ah_iniBank0
, ar5416Bank0_9160
,
3378 ARRAY_SIZE(ar5416Bank0_9160
), 2);
3379 INIT_INI_ARRAY(&ahp
->ah_iniBB_RfGain
, ar5416BB_RfGain_9160
,
3380 ARRAY_SIZE(ar5416BB_RfGain_9160
), 3);
3381 INIT_INI_ARRAY(&ahp
->ah_iniBank1
, ar5416Bank1_9160
,
3382 ARRAY_SIZE(ar5416Bank1_9160
), 2);
3383 INIT_INI_ARRAY(&ahp
->ah_iniBank2
, ar5416Bank2_9160
,
3384 ARRAY_SIZE(ar5416Bank2_9160
), 2);
3385 INIT_INI_ARRAY(&ahp
->ah_iniBank3
, ar5416Bank3_9160
,
3386 ARRAY_SIZE(ar5416Bank3_9160
), 3);
3387 INIT_INI_ARRAY(&ahp
->ah_iniBank6
, ar5416Bank6_9160
,
3388 ARRAY_SIZE(ar5416Bank6_9160
), 3);
3389 INIT_INI_ARRAY(&ahp
->ah_iniBank6TPC
, ar5416Bank6TPC_9160
,
3390 ARRAY_SIZE(ar5416Bank6TPC_9160
), 3);
3391 INIT_INI_ARRAY(&ahp
->ah_iniBank7
, ar5416Bank7_9160
,
3392 ARRAY_SIZE(ar5416Bank7_9160
), 2);
3393 if (AR_SREV_9160_11(ah
)) {
3394 INIT_INI_ARRAY(&ahp
->ah_iniAddac
,
3395 ar5416Addac_91601_1
,
3396 ARRAY_SIZE(ar5416Addac_91601_1
), 2);
3398 INIT_INI_ARRAY(&ahp
->ah_iniAddac
, ar5416Addac_9160
,
3399 ARRAY_SIZE(ar5416Addac_9160
), 2);
3401 } else if (AR_SREV_9100_OR_LATER(ah
)) {
3402 INIT_INI_ARRAY(&ahp
->ah_iniModes
, ar5416Modes_9100
,
3403 ARRAY_SIZE(ar5416Modes_9100
), 6);
3404 INIT_INI_ARRAY(&ahp
->ah_iniCommon
, ar5416Common_9100
,
3405 ARRAY_SIZE(ar5416Common_9100
), 2);
3406 INIT_INI_ARRAY(&ahp
->ah_iniBank0
, ar5416Bank0_9100
,
3407 ARRAY_SIZE(ar5416Bank0_9100
), 2);
3408 INIT_INI_ARRAY(&ahp
->ah_iniBB_RfGain
, ar5416BB_RfGain_9100
,
3409 ARRAY_SIZE(ar5416BB_RfGain_9100
), 3);
3410 INIT_INI_ARRAY(&ahp
->ah_iniBank1
, ar5416Bank1_9100
,
3411 ARRAY_SIZE(ar5416Bank1_9100
), 2);
3412 INIT_INI_ARRAY(&ahp
->ah_iniBank2
, ar5416Bank2_9100
,
3413 ARRAY_SIZE(ar5416Bank2_9100
), 2);
3414 INIT_INI_ARRAY(&ahp
->ah_iniBank3
, ar5416Bank3_9100
,
3415 ARRAY_SIZE(ar5416Bank3_9100
), 3);
3416 INIT_INI_ARRAY(&ahp
->ah_iniBank6
, ar5416Bank6_9100
,
3417 ARRAY_SIZE(ar5416Bank6_9100
), 3);
3418 INIT_INI_ARRAY(&ahp
->ah_iniBank6TPC
, ar5416Bank6TPC_9100
,
3419 ARRAY_SIZE(ar5416Bank6TPC_9100
), 3);
3420 INIT_INI_ARRAY(&ahp
->ah_iniBank7
, ar5416Bank7_9100
,
3421 ARRAY_SIZE(ar5416Bank7_9100
), 2);
3422 INIT_INI_ARRAY(&ahp
->ah_iniAddac
, ar5416Addac_9100
,
3423 ARRAY_SIZE(ar5416Addac_9100
), 2);
3425 INIT_INI_ARRAY(&ahp
->ah_iniModes
, ar5416Modes
,
3426 ARRAY_SIZE(ar5416Modes
), 6);
3427 INIT_INI_ARRAY(&ahp
->ah_iniCommon
, ar5416Common
,
3428 ARRAY_SIZE(ar5416Common
), 2);
3429 INIT_INI_ARRAY(&ahp
->ah_iniBank0
, ar5416Bank0
,
3430 ARRAY_SIZE(ar5416Bank0
), 2);
3431 INIT_INI_ARRAY(&ahp
->ah_iniBB_RfGain
, ar5416BB_RfGain
,
3432 ARRAY_SIZE(ar5416BB_RfGain
), 3);
3433 INIT_INI_ARRAY(&ahp
->ah_iniBank1
, ar5416Bank1
,
3434 ARRAY_SIZE(ar5416Bank1
), 2);
3435 INIT_INI_ARRAY(&ahp
->ah_iniBank2
, ar5416Bank2
,
3436 ARRAY_SIZE(ar5416Bank2
), 2);
3437 INIT_INI_ARRAY(&ahp
->ah_iniBank3
, ar5416Bank3
,
3438 ARRAY_SIZE(ar5416Bank3
), 3);
3439 INIT_INI_ARRAY(&ahp
->ah_iniBank6
, ar5416Bank6
,
3440 ARRAY_SIZE(ar5416Bank6
), 3);
3441 INIT_INI_ARRAY(&ahp
->ah_iniBank6TPC
, ar5416Bank6TPC
,
3442 ARRAY_SIZE(ar5416Bank6TPC
), 3);
3443 INIT_INI_ARRAY(&ahp
->ah_iniBank7
, ar5416Bank7
,
3444 ARRAY_SIZE(ar5416Bank7
), 2);
3445 INIT_INI_ARRAY(&ahp
->ah_iniAddac
, ar5416Addac
,
3446 ARRAY_SIZE(ar5416Addac
), 2);
3449 if (ah
->ah_isPciExpress
)
3450 ath9k_hw_configpcipowersave(ah
, 0);
3452 ar5416DisablePciePhy(ah
);
3454 ecode
= ath9k_hw_post_attach(ah
);
3458 #ifndef CONFIG_SLOW_ANT_DIV
3459 if (ah
->ah_devid
== AR9280_DEVID_PCI
) {
3460 for (i
= 0; i
< ahp
->ah_iniModes
.ia_rows
; i
++) {
3461 u32 reg
= INI_RA(&ahp
->ah_iniModes
, i
, 0);
3463 for (j
= 1; j
< ahp
->ah_iniModes
.ia_columns
; j
++) {
3464 u32 val
= INI_RA(&ahp
->ah_iniModes
, i
, j
);
3466 INI_RA(&ahp
->ah_iniModes
, i
, j
) =
3467 ath9k_hw_ini_fixup(ah
, &ahp
->ah_eeprom
,
3474 if (!ath9k_hw_fill_cap_info(ah
)) {
3475 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3476 "%s:failed ath9k_hw_fill_cap_info\n", __func__
);
3481 ecode
= ath9k_hw_init_macaddr(ah
);
3483 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3484 "%s: failed initializing mac address\n",
3489 if (AR_SREV_9285(ah
))
3490 ah
->ah_txTrigLevel
= (AR_FTRIG_256B
>> AR_FTRIG_S
);
3492 ah
->ah_txTrigLevel
= (AR_FTRIG_512B
>> AR_FTRIG_S
);
3494 #ifndef ATH_NF_PER_CHAN
3496 ath9k_init_nfcal_hist_buffer(ah
);
3503 ath9k_hw_detach((struct ath_hal
*) ahp
);
3509 void ath9k_hw_detach(struct ath_hal
*ah
)
3511 if (!AR_SREV_9100(ah
))
3512 ath9k_hw_ani_detach(ah
);
3513 ath9k_hw_rfdetach(ah
);
3515 ath9k_hw_setpower(ah
, ATH9K_PM_FULL_SLEEP
);
3519 bool ath9k_get_channel_edges(struct ath_hal
*ah
,
3520 u16 flags
, u16
*low
,
3523 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
3525 if (flags
& CHANNEL_5GHZ
) {
3526 *low
= pCap
->low_5ghz_chan
;
3527 *high
= pCap
->high_5ghz_chan
;
3530 if ((flags
& CHANNEL_2GHZ
)) {
3531 *low
= pCap
->low_2ghz_chan
;
3532 *high
= pCap
->high_2ghz_chan
;
3539 static inline bool ath9k_hw_fill_vpd_table(u8 pwrMin
,
3548 u8 currPwr
= pwrMin
;
3549 u16 idxL
= 0, idxR
= 0;
3551 for (i
= 0; i
<= (pwrMax
- pwrMin
) / 2; i
++) {
3552 ath9k_hw_get_lower_upper_index(currPwr
, pPwrList
,
3553 numIntercepts
, &(idxL
),
3557 if (idxL
== numIntercepts
- 1)
3558 idxL
= (u16
) (numIntercepts
- 2);
3559 if (pPwrList
[idxL
] == pPwrList
[idxR
])
3562 k
= (u16
) (((currPwr
-
3566 currPwr
) * pVpdList
[idxL
]) /
3569 pRetVpdList
[i
] = (u8
) k
;
3577 ath9k_hw_get_gain_boundaries_pdadcs(struct ath_hal
*ah
,
3578 struct ath9k_channel
*chan
,
3579 struct cal_data_per_freq
*pRawDataSet
,
3583 int16_t *pMinCalPower
,
3584 u16
*pPdGainBoundaries
,
3590 u16 idxL
= 0, idxR
= 0, numPiers
;
3591 static u8 vpdTableL
[AR5416_NUM_PD_GAINS
]
3592 [AR5416_MAX_PWR_RANGE_IN_HALF_DB
];
3593 static u8 vpdTableR
[AR5416_NUM_PD_GAINS
]
3594 [AR5416_MAX_PWR_RANGE_IN_HALF_DB
];
3595 static u8 vpdTableI
[AR5416_NUM_PD_GAINS
]
3596 [AR5416_MAX_PWR_RANGE_IN_HALF_DB
];
3598 u8
*pVpdL
, *pVpdR
, *pPwrL
, *pPwrR
;
3599 u8 minPwrT4
[AR5416_NUM_PD_GAINS
];
3600 u8 maxPwrT4
[AR5416_NUM_PD_GAINS
];
3603 u16 sizeCurrVpdTable
, maxIndex
, tgtIndex
;
3605 int16_t minDelta
= 0;
3606 struct chan_centers centers
;
3608 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
3610 for (numPiers
= 0; numPiers
< availPiers
; numPiers
++) {
3611 if (bChans
[numPiers
] == AR5416_BCHAN_UNUSED
)
3615 match
= ath9k_hw_get_lower_upper_index((u8
)
3620 numPiers
, &idxL
, &idxR
);
3623 for (i
= 0; i
< numXpdGains
; i
++) {
3624 minPwrT4
[i
] = pRawDataSet
[idxL
].pwrPdg
[i
][0];
3625 maxPwrT4
[i
] = pRawDataSet
[idxL
].pwrPdg
[i
][4];
3626 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
3631 AR5416_PD_GAIN_ICEPTS
,
3635 for (i
= 0; i
< numXpdGains
; i
++) {
3636 pVpdL
= pRawDataSet
[idxL
].vpdPdg
[i
];
3637 pPwrL
= pRawDataSet
[idxL
].pwrPdg
[i
];
3638 pVpdR
= pRawDataSet
[idxR
].vpdPdg
[i
];
3639 pPwrR
= pRawDataSet
[idxR
].pwrPdg
[i
];
3641 minPwrT4
[i
] = max(pPwrL
[0], pPwrR
[0]);
3644 min(pPwrL
[AR5416_PD_GAIN_ICEPTS
- 1],
3645 pPwrR
[AR5416_PD_GAIN_ICEPTS
- 1]);
3648 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
3650 AR5416_PD_GAIN_ICEPTS
,
3652 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
3654 AR5416_PD_GAIN_ICEPTS
,
3657 for (j
= 0; j
<= (maxPwrT4
[i
] - minPwrT4
[i
]) / 2; j
++) {
3659 (u8
) (ath9k_hw_interpolate
3666 bChans
[idxR
], vpdTableL
[i
]
3673 *pMinCalPower
= (int16_t) (minPwrT4
[0] / 2);
3676 for (i
= 0; i
< numXpdGains
; i
++) {
3677 if (i
== (numXpdGains
- 1))
3678 pPdGainBoundaries
[i
] =
3679 (u16
) (maxPwrT4
[i
] / 2);
3681 pPdGainBoundaries
[i
] =
3682 (u16
) ((maxPwrT4
[i
] +
3683 minPwrT4
[i
+ 1]) / 4);
3685 pPdGainBoundaries
[i
] =
3686 min((u16
) AR5416_MAX_RATE_POWER
,
3687 pPdGainBoundaries
[i
]);
3689 if ((i
== 0) && !AR_SREV_5416_V20_OR_LATER(ah
)) {
3690 minDelta
= pPdGainBoundaries
[0] - 23;
3691 pPdGainBoundaries
[0] = 23;
3697 if (AR_SREV_9280_10_OR_LATER(ah
))
3698 ss
= (int16_t) (0 - (minPwrT4
[i
] / 2));
3702 ss
= (int16_t) ((pPdGainBoundaries
[i
- 1] -
3703 (minPwrT4
[i
] / 2)) -
3704 tPdGainOverlap
+ 1 + minDelta
);
3706 vpdStep
= (int16_t) (vpdTableI
[i
][1] - vpdTableI
[i
][0]);
3707 vpdStep
= (int16_t) ((vpdStep
< 1) ? 1 : vpdStep
);
3709 while ((ss
< 0) && (k
< (AR5416_NUM_PDADC_VALUES
- 1))) {
3710 tmpVal
= (int16_t) (vpdTableI
[i
][0] + ss
* vpdStep
);
3712 (u8
) ((tmpVal
< 0) ? 0 : tmpVal
);
3717 (u8
) ((maxPwrT4
[i
] - minPwrT4
[i
]) / 2 + 1);
3718 tgtIndex
= (u8
) (pPdGainBoundaries
[i
] + tPdGainOverlap
-
3720 maxIndex
= (tgtIndex
<
3721 sizeCurrVpdTable
) ? tgtIndex
: sizeCurrVpdTable
;
3723 while ((ss
< maxIndex
)
3724 && (k
< (AR5416_NUM_PDADC_VALUES
- 1))) {
3725 pPDADCValues
[k
++] = vpdTableI
[i
][ss
++];
3728 vpdStep
= (int16_t) (vpdTableI
[i
][sizeCurrVpdTable
- 1] -
3729 vpdTableI
[i
][sizeCurrVpdTable
- 2]);
3730 vpdStep
= (int16_t) ((vpdStep
< 1) ? 1 : vpdStep
);
3732 if (tgtIndex
> maxIndex
) {
3733 while ((ss
<= tgtIndex
)
3734 && (k
< (AR5416_NUM_PDADC_VALUES
- 1))) {
3735 tmpVal
= (int16_t) ((vpdTableI
[i
]
3737 1] + (ss
- maxIndex
+
3739 pPDADCValues
[k
++] = (u8
) ((tmpVal
>
3740 255) ? 255 : tmpVal
);
3746 while (i
< AR5416_PD_GAINS_IN_MASK
) {
3747 pPdGainBoundaries
[i
] = pPdGainBoundaries
[i
- 1];
3751 while (k
< AR5416_NUM_PDADC_VALUES
) {
3752 pPDADCValues
[k
] = pPDADCValues
[k
- 1];
3759 ath9k_hw_set_power_cal_table(struct ath_hal
*ah
,
3760 struct ar5416_eeprom
*pEepData
,
3761 struct ath9k_channel
*chan
,
3762 int16_t *pTxPowerIndexOffset
)
3764 struct cal_data_per_freq
*pRawDataset
;
3765 u8
*pCalBChans
= NULL
;
3766 u16 pdGainOverlap_t2
;
3767 static u8 pdadcValues
[AR5416_NUM_PDADC_VALUES
];
3768 u16 gainBoundaries
[AR5416_PD_GAINS_IN_MASK
];
3770 int16_t tMinCalPower
;
3771 u16 numXpdGain
, xpdMask
;
3772 u16 xpdGainValues
[AR5416_NUM_PD_GAINS
] = { 0, 0, 0, 0 };
3773 u32 reg32
, regOffset
, regChainOffset
;
3775 struct ath_hal_5416
*ahp
= AH5416(ah
);
3777 modalIdx
= IS_CHAN_2GHZ(chan
) ? 1 : 0;
3778 xpdMask
= pEepData
->modalHeader
[modalIdx
].xpdGain
;
3780 if ((pEepData
->baseEepHeader
.
3781 version
& AR5416_EEP_VER_MINOR_MASK
) >=
3782 AR5416_EEP_MINOR_VER_2
) {
3784 pEepData
->modalHeader
[modalIdx
].pdGainOverlap
;
3788 (REG_READ(ah
, AR_PHY_TPCRG5
),
3789 AR_PHY_TPCRG5_PD_GAIN_OVERLAP
));
3792 if (IS_CHAN_2GHZ(chan
)) {
3793 pCalBChans
= pEepData
->calFreqPier2G
;
3794 numPiers
= AR5416_NUM_2G_CAL_PIERS
;
3796 pCalBChans
= pEepData
->calFreqPier5G
;
3797 numPiers
= AR5416_NUM_5G_CAL_PIERS
;
3802 for (i
= 1; i
<= AR5416_PD_GAINS_IN_MASK
; i
++) {
3803 if ((xpdMask
>> (AR5416_PD_GAINS_IN_MASK
- i
)) & 1) {
3804 if (numXpdGain
>= AR5416_NUM_PD_GAINS
)
3806 xpdGainValues
[numXpdGain
] =
3807 (u16
) (AR5416_PD_GAINS_IN_MASK
- i
);
3812 REG_RMW_FIELD(ah
, AR_PHY_TPCRG1
, AR_PHY_TPCRG1_NUM_PD_GAIN
,
3813 (numXpdGain
- 1) & 0x3);
3814 REG_RMW_FIELD(ah
, AR_PHY_TPCRG1
, AR_PHY_TPCRG1_PD_GAIN_1
,
3816 REG_RMW_FIELD(ah
, AR_PHY_TPCRG1
, AR_PHY_TPCRG1_PD_GAIN_2
,
3818 REG_RMW_FIELD(ah
, AR_PHY_TPCRG1
, AR_PHY_TPCRG1_PD_GAIN_3
,
3821 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
3822 if (AR_SREV_5416_V20_OR_LATER(ah
) &&
3823 (ahp
->ah_rxchainmask
== 5 || ahp
->ah_txchainmask
== 5)
3825 regChainOffset
= (i
== 1) ? 0x2000 : 0x1000;
3827 regChainOffset
= i
* 0x1000;
3828 if (pEepData
->baseEepHeader
.txMask
& (1 << i
)) {
3829 if (IS_CHAN_2GHZ(chan
))
3830 pRawDataset
= pEepData
->calPierData2G
[i
];
3832 pRawDataset
= pEepData
->calPierData5G
[i
];
3834 ath9k_hw_get_gain_boundaries_pdadcs(ah
, chan
,
3844 if ((i
== 0) || AR_SREV_5416_V20_OR_LATER(ah
)) {
3847 AR_PHY_TPCRG5
+ regChainOffset
,
3848 SM(pdGainOverlap_t2
,
3849 AR_PHY_TPCRG5_PD_GAIN_OVERLAP
)
3850 | SM(gainBoundaries
[0],
3851 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_1
)
3852 | SM(gainBoundaries
[1],
3853 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_2
)
3854 | SM(gainBoundaries
[2],
3855 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_3
)
3856 | SM(gainBoundaries
[3],
3857 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_4
));
3861 AR_PHY_BASE
+ (672 << 2) + regChainOffset
;
3862 for (j
= 0; j
< 32; j
++) {
3864 ((pdadcValues
[4 * j
+ 0] & 0xFF) << 0)
3865 | ((pdadcValues
[4 * j
+ 1] & 0xFF) <<
3866 8) | ((pdadcValues
[4 * j
+ 2] &
3868 ((pdadcValues
[4 * j
+ 3] & 0xFF) <<
3870 REG_WRITE(ah
, regOffset
, reg32
);
3872 DPRINTF(ah
->ah_sc
, ATH_DBG_PHY_IO
,
3873 "PDADC (%d,%4x): %4.4x %8.8x\n",
3874 i
, regChainOffset
, regOffset
,
3876 DPRINTF(ah
->ah_sc
, ATH_DBG_PHY_IO
,
3877 "PDADC: Chain %d | PDADC %3d Value %3d | "
3878 "PDADC %3d Value %3d | PDADC %3d Value %3d | "
3879 "PDADC %3d Value %3d |\n",
3880 i
, 4 * j
, pdadcValues
[4 * j
],
3881 4 * j
+ 1, pdadcValues
[4 * j
+ 1],
3882 4 * j
+ 2, pdadcValues
[4 * j
+ 2],
3884 pdadcValues
[4 * j
+ 3]);
3890 *pTxPowerIndexOffset
= 0;
3895 void ath9k_hw_configpcipowersave(struct ath_hal
*ah
, int restore
)
3897 struct ath_hal_5416
*ahp
= AH5416(ah
);
3900 if (ah
->ah_isPciExpress
!= true)
3903 if (ah
->ah_config
.pcie_powersave_enable
== 2)
3909 if (AR_SREV_9280_20_OR_LATER(ah
)) {
3910 for (i
= 0; i
< ahp
->ah_iniPcieSerdes
.ia_rows
; i
++) {
3911 REG_WRITE(ah
, INI_RA(&ahp
->ah_iniPcieSerdes
, i
, 0),
3912 INI_RA(&ahp
->ah_iniPcieSerdes
, i
, 1));
3915 } else if (AR_SREV_9280(ah
)
3916 && (ah
->ah_macRev
== AR_SREV_REVISION_9280_10
)) {
3917 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x9248fd00);
3918 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x24924924);
3920 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xa8000019);
3921 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x13160820);
3922 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xe5980560);
3924 if (ah
->ah_config
.pcie_clock_req
)
3925 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x401deffc);
3927 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x401deffd);
3929 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x1aaabe40);
3930 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xbe105554);
3931 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x00043007);
3933 REG_WRITE(ah
, AR_PCIE_SERDES2
, 0x00000000);
3937 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x9248fc00);
3938 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x24924924);
3939 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x28000039);
3940 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x53160824);
3941 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xe5980579);
3942 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x001defff);
3943 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x1aaabe40);
3944 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xbe105554);
3945 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x000e3007);
3946 REG_WRITE(ah
, AR_PCIE_SERDES2
, 0x00000000);
3949 REG_SET_BIT(ah
, AR_PCIE_PM_CTRL
, AR_PCIE_PM_CTRL_ENA
);
3951 if (ah
->ah_config
.pcie_waen
) {
3952 REG_WRITE(ah
, AR_WA
, ah
->ah_config
.pcie_waen
);
3954 if (AR_SREV_9280(ah
))
3955 REG_WRITE(ah
, AR_WA
, 0x0040073f);
3957 REG_WRITE(ah
, AR_WA
, 0x0000073f);
3962 ath9k_hw_get_legacy_target_powers(struct ath_hal
*ah
,
3963 struct ath9k_channel
*chan
,
3964 struct cal_target_power_leg
*powInfo
,
3966 struct cal_target_power_leg
*pNewPower
,
3972 int matchIndex
= -1, lowIndex
= -1;
3974 struct chan_centers centers
;
3976 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
3977 freq
= (isExtTarget
) ? centers
.ext_center
: centers
.ctl_center
;
3979 if (freq
<= ath9k_hw_fbin2freq(powInfo
[0].bChannel
,
3980 IS_CHAN_2GHZ(chan
))) {
3983 for (i
= 0; (i
< numChannels
)
3984 && (powInfo
[i
].bChannel
!= AR5416_BCHAN_UNUSED
); i
++) {
3986 ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
3987 IS_CHAN_2GHZ(chan
))) {
3991 ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
3992 IS_CHAN_2GHZ(chan
)))
3994 ath9k_hw_fbin2freq(powInfo
[i
- 1].
4002 if ((matchIndex
== -1) && (lowIndex
== -1))
4006 if (matchIndex
!= -1) {
4007 *pNewPower
= powInfo
[matchIndex
];
4009 clo
= ath9k_hw_fbin2freq(powInfo
[lowIndex
].bChannel
,
4010 IS_CHAN_2GHZ(chan
));
4011 chi
= ath9k_hw_fbin2freq(powInfo
[lowIndex
+ 1].bChannel
,
4012 IS_CHAN_2GHZ(chan
));
4014 for (i
= 0; i
< numRates
; i
++) {
4015 pNewPower
->tPow2x
[i
] =
4016 (u8
) ath9k_hw_interpolate(freq
, clo
, chi
,
4028 ath9k_hw_get_target_powers(struct ath_hal
*ah
,
4029 struct ath9k_channel
*chan
,
4030 struct cal_target_power_ht
*powInfo
,
4032 struct cal_target_power_ht
*pNewPower
,
4038 int matchIndex
= -1, lowIndex
= -1;
4040 struct chan_centers centers
;
4042 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
4043 freq
= isHt40Target
? centers
.synth_center
: centers
.ctl_center
;
4046 ath9k_hw_fbin2freq(powInfo
[0].bChannel
, IS_CHAN_2GHZ(chan
))) {
4049 for (i
= 0; (i
< numChannels
)
4050 && (powInfo
[i
].bChannel
!= AR5416_BCHAN_UNUSED
); i
++) {
4052 ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
4053 IS_CHAN_2GHZ(chan
))) {
4058 ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
4059 IS_CHAN_2GHZ(chan
)))
4061 ath9k_hw_fbin2freq(powInfo
[i
- 1].
4069 if ((matchIndex
== -1) && (lowIndex
== -1))
4073 if (matchIndex
!= -1) {
4074 *pNewPower
= powInfo
[matchIndex
];
4076 clo
= ath9k_hw_fbin2freq(powInfo
[lowIndex
].bChannel
,
4077 IS_CHAN_2GHZ(chan
));
4078 chi
= ath9k_hw_fbin2freq(powInfo
[lowIndex
+ 1].bChannel
,
4079 IS_CHAN_2GHZ(chan
));
4081 for (i
= 0; i
< numRates
; i
++) {
4082 pNewPower
->tPow2x
[i
] =
4083 (u8
) ath9k_hw_interpolate(freq
, clo
, chi
,
4095 ath9k_hw_get_max_edge_power(u16 freq
,
4096 struct cal_ctl_edges
*pRdEdgesPower
,
4099 u16 twiceMaxEdgePower
= AR5416_MAX_RATE_POWER
;
4102 for (i
= 0; (i
< AR5416_NUM_BAND_EDGES
)
4103 && (pRdEdgesPower
[i
].bChannel
!= AR5416_BCHAN_UNUSED
); i
++) {
4104 if (freq
== ath9k_hw_fbin2freq(pRdEdgesPower
[i
].bChannel
,
4106 twiceMaxEdgePower
= pRdEdgesPower
[i
].tPower
;
4110 ath9k_hw_fbin2freq(pRdEdgesPower
[i
].
4111 bChannel
, is2GHz
))) {
4112 if (ath9k_hw_fbin2freq
4113 (pRdEdgesPower
[i
- 1].bChannel
, is2GHz
) < freq
4114 && pRdEdgesPower
[i
- 1].flag
) {
4116 pRdEdgesPower
[i
- 1].tPower
;
4121 return twiceMaxEdgePower
;
4125 ath9k_hw_set_power_per_rate_table(struct ath_hal
*ah
,
4126 struct ar5416_eeprom
*pEepData
,
4127 struct ath9k_channel
*chan
,
4128 int16_t *ratesArray
,
4130 u8 AntennaReduction
,
4131 u8 twiceMaxRegulatoryPower
,
4134 u8 twiceMaxEdgePower
= AR5416_MAX_RATE_POWER
;
4135 static const u16 tpScaleReductionTable
[5] =
4136 { 0, 3, 6, 9, AR5416_MAX_RATE_POWER
};
4139 int8_t twiceLargestAntenna
;
4140 struct cal_ctl_data
*rep
;
4141 struct cal_target_power_leg targetPowerOfdm
, targetPowerCck
= {
4144 struct cal_target_power_leg targetPowerOfdmExt
= {
4145 0, { 0, 0, 0, 0} }, targetPowerCckExt
= {
4148 struct cal_target_power_ht targetPowerHt20
, targetPowerHt40
= {
4151 u8 scaledPower
= 0, minCtlPower
, maxRegAllowedPower
;
4152 u16 ctlModesFor11a
[] =
4153 { CTL_11A
, CTL_5GHT20
, CTL_11A_EXT
, CTL_5GHT40
};
4154 u16 ctlModesFor11g
[] =
4155 { CTL_11B
, CTL_11G
, CTL_2GHT20
, CTL_11B_EXT
, CTL_11G_EXT
,
4158 u16 numCtlModes
, *pCtlMode
, ctlMode
, freq
;
4159 struct chan_centers centers
;
4161 u8 twiceMinEdgePower
;
4162 struct ath_hal_5416
*ahp
= AH5416(ah
);
4164 tx_chainmask
= ahp
->ah_txchainmask
;
4166 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
4168 twiceLargestAntenna
= max(
4169 pEepData
->modalHeader
4170 [IS_CHAN_2GHZ(chan
)].antennaGainCh
[0],
4171 pEepData
->modalHeader
4172 [IS_CHAN_2GHZ(chan
)].antennaGainCh
[1]);
4174 twiceLargestAntenna
= max((u8
) twiceLargestAntenna
,
4175 pEepData
->modalHeader
4176 [IS_CHAN_2GHZ(chan
)].antennaGainCh
[2]);
4178 twiceLargestAntenna
=
4179 (int8_t) min(AntennaReduction
- twiceLargestAntenna
, 0);
4181 maxRegAllowedPower
= twiceMaxRegulatoryPower
+ twiceLargestAntenna
;
4183 if (ah
->ah_tpScale
!= ATH9K_TP_SCALE_MAX
) {
4184 maxRegAllowedPower
-=
4185 (tpScaleReductionTable
[(ah
->ah_tpScale
)] * 2);
4188 scaledPower
= min(powerLimit
, maxRegAllowedPower
);
4190 switch (ar5416_get_ntxchains(tx_chainmask
)) {
4195 pEepData
->modalHeader
[IS_CHAN_2GHZ(chan
)].
4196 pwrDecreaseFor2Chain
;
4200 pEepData
->modalHeader
[IS_CHAN_2GHZ(chan
)].
4201 pwrDecreaseFor3Chain
;
4205 scaledPower
= max(0, (int32_t) scaledPower
);
4207 if (IS_CHAN_2GHZ(chan
)) {
4209 ARRAY_SIZE(ctlModesFor11g
) -
4210 SUB_NUM_CTL_MODES_AT_2G_40
;
4211 pCtlMode
= ctlModesFor11g
;
4213 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4216 AR5416_NUM_2G_CCK_TARGET_POWERS
,
4219 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4222 AR5416_NUM_2G_20_TARGET_POWERS
,
4223 &targetPowerOfdm
, 4,
4225 ath9k_hw_get_target_powers(ah
, chan
,
4226 pEepData
->calTargetPower2GHT20
,
4227 AR5416_NUM_2G_20_TARGET_POWERS
,
4228 &targetPowerHt20
, 8, false);
4230 if (IS_CHAN_HT40(chan
)) {
4231 numCtlModes
= ARRAY_SIZE(ctlModesFor11g
);
4232 ath9k_hw_get_target_powers(ah
, chan
,
4234 calTargetPower2GHT40
,
4235 AR5416_NUM_2G_40_TARGET_POWERS
,
4236 &targetPowerHt40
, 8,
4238 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4241 AR5416_NUM_2G_CCK_TARGET_POWERS
,
4244 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4247 AR5416_NUM_2G_20_TARGET_POWERS
,
4248 &targetPowerOfdmExt
,
4254 ARRAY_SIZE(ctlModesFor11a
) -
4255 SUB_NUM_CTL_MODES_AT_5G_40
;
4256 pCtlMode
= ctlModesFor11a
;
4258 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4261 AR5416_NUM_5G_20_TARGET_POWERS
,
4262 &targetPowerOfdm
, 4,
4264 ath9k_hw_get_target_powers(ah
, chan
,
4265 pEepData
->calTargetPower5GHT20
,
4266 AR5416_NUM_5G_20_TARGET_POWERS
,
4267 &targetPowerHt20
, 8, false);
4269 if (IS_CHAN_HT40(chan
)) {
4270 numCtlModes
= ARRAY_SIZE(ctlModesFor11a
);
4271 ath9k_hw_get_target_powers(ah
, chan
,
4273 calTargetPower5GHT40
,
4274 AR5416_NUM_5G_40_TARGET_POWERS
,
4275 &targetPowerHt40
, 8,
4277 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4280 AR5416_NUM_5G_20_TARGET_POWERS
,
4281 &targetPowerOfdmExt
,
4286 for (ctlMode
= 0; ctlMode
< numCtlModes
; ctlMode
++) {
4287 bool isHt40CtlMode
=
4288 (pCtlMode
[ctlMode
] == CTL_5GHT40
)
4289 || (pCtlMode
[ctlMode
] == CTL_2GHT40
);
4291 freq
= centers
.synth_center
;
4292 else if (pCtlMode
[ctlMode
] & EXT_ADDITIVE
)
4293 freq
= centers
.ext_center
;
4295 freq
= centers
.ctl_center
;
4297 if (ar5416_get_eep_ver(ahp
) == 14
4298 && ar5416_get_eep_rev(ahp
) <= 2)
4299 twiceMaxEdgePower
= AR5416_MAX_RATE_POWER
;
4301 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
4302 "LOOP-Mode ctlMode %d < %d, isHt40CtlMode %d, "
4303 "EXT_ADDITIVE %d\n",
4304 ctlMode
, numCtlModes
, isHt40CtlMode
,
4305 (pCtlMode
[ctlMode
] & EXT_ADDITIVE
));
4307 for (i
= 0; (i
< AR5416_NUM_CTLS
) && pEepData
->ctlIndex
[i
];
4309 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
4310 " LOOP-Ctlidx %d: cfgCtl 0x%2.2x "
4311 "pCtlMode 0x%2.2x ctlIndex 0x%2.2x "
4313 i
, cfgCtl
, pCtlMode
[ctlMode
],
4314 pEepData
->ctlIndex
[i
], chan
->channel
);
4316 if ((((cfgCtl
& ~CTL_MODE_M
) |
4317 (pCtlMode
[ctlMode
] & CTL_MODE_M
)) ==
4318 pEepData
->ctlIndex
[i
])
4320 (((cfgCtl
& ~CTL_MODE_M
) |
4321 (pCtlMode
[ctlMode
] & CTL_MODE_M
)) ==
4323 ctlIndex
[i
] & CTL_MODE_M
) | SD_NO_CTL
))) {
4324 rep
= &(pEepData
->ctlData
[i
]);
4327 ath9k_hw_get_max_edge_power(freq
,
4330 [ar5416_get_ntxchains
4336 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
4337 " MATCH-EE_IDX %d: ch %d is2 %d "
4338 "2xMinEdge %d chainmask %d chains %d\n",
4339 i
, freq
, IS_CHAN_2GHZ(chan
),
4340 twiceMinEdgePower
, tx_chainmask
,
4341 ar5416_get_ntxchains
4343 if ((cfgCtl
& ~CTL_MODE_M
) == SD_NO_CTL
) {
4345 min(twiceMaxEdgePower
,
4355 minCtlPower
= min(twiceMaxEdgePower
, scaledPower
);
4357 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
4358 " SEL-Min ctlMode %d pCtlMode %d "
4359 "2xMaxEdge %d sP %d minCtlPwr %d\n",
4360 ctlMode
, pCtlMode
[ctlMode
], twiceMaxEdgePower
,
4361 scaledPower
, minCtlPower
);
4363 switch (pCtlMode
[ctlMode
]) {
4365 for (i
= 0; i
< ARRAY_SIZE(targetPowerCck
.tPow2x
);
4367 targetPowerCck
.tPow2x
[i
] =
4368 min(targetPowerCck
.tPow2x
[i
],
4374 for (i
= 0; i
< ARRAY_SIZE(targetPowerOfdm
.tPow2x
);
4376 targetPowerOfdm
.tPow2x
[i
] =
4377 min(targetPowerOfdm
.tPow2x
[i
],
4383 for (i
= 0; i
< ARRAY_SIZE(targetPowerHt20
.tPow2x
);
4385 targetPowerHt20
.tPow2x
[i
] =
4386 min(targetPowerHt20
.tPow2x
[i
],
4391 targetPowerCckExt
.tPow2x
[0] =
4392 min(targetPowerCckExt
.tPow2x
[0], minCtlPower
);
4396 targetPowerOfdmExt
.tPow2x
[0] =
4397 min(targetPowerOfdmExt
.tPow2x
[0], minCtlPower
);
4401 for (i
= 0; i
< ARRAY_SIZE(targetPowerHt40
.tPow2x
);
4403 targetPowerHt40
.tPow2x
[i
] =
4404 min(targetPowerHt40
.tPow2x
[i
],
4413 ratesArray
[rate6mb
] = ratesArray
[rate9mb
] = ratesArray
[rate12mb
] =
4414 ratesArray
[rate18mb
] = ratesArray
[rate24mb
] =
4415 targetPowerOfdm
.tPow2x
[0];
4416 ratesArray
[rate36mb
] = targetPowerOfdm
.tPow2x
[1];
4417 ratesArray
[rate48mb
] = targetPowerOfdm
.tPow2x
[2];
4418 ratesArray
[rate54mb
] = targetPowerOfdm
.tPow2x
[3];
4419 ratesArray
[rateXr
] = targetPowerOfdm
.tPow2x
[0];
4421 for (i
= 0; i
< ARRAY_SIZE(targetPowerHt20
.tPow2x
); i
++)
4422 ratesArray
[rateHt20_0
+ i
] = targetPowerHt20
.tPow2x
[i
];
4424 if (IS_CHAN_2GHZ(chan
)) {
4425 ratesArray
[rate1l
] = targetPowerCck
.tPow2x
[0];
4426 ratesArray
[rate2s
] = ratesArray
[rate2l
] =
4427 targetPowerCck
.tPow2x
[1];
4428 ratesArray
[rate5_5s
] = ratesArray
[rate5_5l
] =
4429 targetPowerCck
.tPow2x
[2];
4431 ratesArray
[rate11s
] = ratesArray
[rate11l
] =
4432 targetPowerCck
.tPow2x
[3];
4435 if (IS_CHAN_HT40(chan
)) {
4436 for (i
= 0; i
< ARRAY_SIZE(targetPowerHt40
.tPow2x
); i
++) {
4437 ratesArray
[rateHt40_0
+ i
] =
4438 targetPowerHt40
.tPow2x
[i
];
4440 ratesArray
[rateDupOfdm
] = targetPowerHt40
.tPow2x
[0];
4441 ratesArray
[rateDupCck
] = targetPowerHt40
.tPow2x
[0];
4442 ratesArray
[rateExtOfdm
] = targetPowerOfdmExt
.tPow2x
[0];
4443 if (IS_CHAN_2GHZ(chan
)) {
4444 ratesArray
[rateExtCck
] =
4445 targetPowerCckExt
.tPow2x
[0];
4452 ath9k_hw_set_txpower(struct ath_hal
*ah
,
4453 struct ar5416_eeprom
*pEepData
,
4454 struct ath9k_channel
*chan
,
4456 u8 twiceAntennaReduction
,
4457 u8 twiceMaxRegulatoryPower
,
4460 struct modal_eep_header
*pModal
=
4461 &(pEepData
->modalHeader
[IS_CHAN_2GHZ(chan
)]);
4462 int16_t ratesArray
[Ar5416RateSize
];
4463 int16_t txPowerIndexOffset
= 0;
4464 u8 ht40PowerIncForPdadc
= 2;
4467 memset(ratesArray
, 0, sizeof(ratesArray
));
4469 if ((pEepData
->baseEepHeader
.
4470 version
& AR5416_EEP_VER_MINOR_MASK
) >=
4471 AR5416_EEP_MINOR_VER_2
) {
4472 ht40PowerIncForPdadc
= pModal
->ht40PowerIncForPdadc
;
4475 if (!ath9k_hw_set_power_per_rate_table(ah
, pEepData
, chan
,
4476 &ratesArray
[0], cfgCtl
,
4477 twiceAntennaReduction
,
4478 twiceMaxRegulatoryPower
,
4480 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
4481 "ath9k_hw_set_txpower: unable to set "
4482 "tx power per rate table\n");
4486 if (!ath9k_hw_set_power_cal_table
4487 (ah
, pEepData
, chan
, &txPowerIndexOffset
)) {
4488 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
4489 "ath9k_hw_set_txpower: unable to set power table\n");
4493 for (i
= 0; i
< ARRAY_SIZE(ratesArray
); i
++) {
4495 (int16_t) (txPowerIndexOffset
+ ratesArray
[i
]);
4496 if (ratesArray
[i
] > AR5416_MAX_RATE_POWER
)
4497 ratesArray
[i
] = AR5416_MAX_RATE_POWER
;
4500 if (AR_SREV_9280_10_OR_LATER(ah
)) {
4501 for (i
= 0; i
< Ar5416RateSize
; i
++)
4502 ratesArray
[i
] -= AR5416_PWR_TABLE_OFFSET
* 2;
4505 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE1
,
4506 ATH9K_POW_SM(ratesArray
[rate18mb
], 24)
4507 | ATH9K_POW_SM(ratesArray
[rate12mb
], 16)
4508 | ATH9K_POW_SM(ratesArray
[rate9mb
], 8)
4509 | ATH9K_POW_SM(ratesArray
[rate6mb
], 0)
4511 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE2
,
4512 ATH9K_POW_SM(ratesArray
[rate54mb
], 24)
4513 | ATH9K_POW_SM(ratesArray
[rate48mb
], 16)
4514 | ATH9K_POW_SM(ratesArray
[rate36mb
], 8)
4515 | ATH9K_POW_SM(ratesArray
[rate24mb
], 0)
4518 if (IS_CHAN_2GHZ(chan
)) {
4519 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE3
,
4520 ATH9K_POW_SM(ratesArray
[rate2s
], 24)
4521 | ATH9K_POW_SM(ratesArray
[rate2l
], 16)
4522 | ATH9K_POW_SM(ratesArray
[rateXr
], 8)
4523 | ATH9K_POW_SM(ratesArray
[rate1l
], 0)
4525 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE4
,
4526 ATH9K_POW_SM(ratesArray
[rate11s
], 24)
4527 | ATH9K_POW_SM(ratesArray
[rate11l
], 16)
4528 | ATH9K_POW_SM(ratesArray
[rate5_5s
], 8)
4529 | ATH9K_POW_SM(ratesArray
[rate5_5l
], 0)
4533 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE5
,
4534 ATH9K_POW_SM(ratesArray
[rateHt20_3
], 24)
4535 | ATH9K_POW_SM(ratesArray
[rateHt20_2
], 16)
4536 | ATH9K_POW_SM(ratesArray
[rateHt20_1
], 8)
4537 | ATH9K_POW_SM(ratesArray
[rateHt20_0
], 0)
4539 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE6
,
4540 ATH9K_POW_SM(ratesArray
[rateHt20_7
], 24)
4541 | ATH9K_POW_SM(ratesArray
[rateHt20_6
], 16)
4542 | ATH9K_POW_SM(ratesArray
[rateHt20_5
], 8)
4543 | ATH9K_POW_SM(ratesArray
[rateHt20_4
], 0)
4546 if (IS_CHAN_HT40(chan
)) {
4547 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE7
,
4548 ATH9K_POW_SM(ratesArray
[rateHt40_3
] +
4549 ht40PowerIncForPdadc
, 24)
4550 | ATH9K_POW_SM(ratesArray
[rateHt40_2
] +
4551 ht40PowerIncForPdadc
, 16)
4552 | ATH9K_POW_SM(ratesArray
[rateHt40_1
] +
4553 ht40PowerIncForPdadc
, 8)
4554 | ATH9K_POW_SM(ratesArray
[rateHt40_0
] +
4555 ht40PowerIncForPdadc
, 0)
4557 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE8
,
4558 ATH9K_POW_SM(ratesArray
[rateHt40_7
] +
4559 ht40PowerIncForPdadc
, 24)
4560 | ATH9K_POW_SM(ratesArray
[rateHt40_6
] +
4561 ht40PowerIncForPdadc
, 16)
4562 | ATH9K_POW_SM(ratesArray
[rateHt40_5
] +
4563 ht40PowerIncForPdadc
, 8)
4564 | ATH9K_POW_SM(ratesArray
[rateHt40_4
] +
4565 ht40PowerIncForPdadc
, 0)
4568 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE9
,
4569 ATH9K_POW_SM(ratesArray
[rateExtOfdm
], 24)
4570 | ATH9K_POW_SM(ratesArray
[rateExtCck
], 16)
4571 | ATH9K_POW_SM(ratesArray
[rateDupOfdm
], 8)
4572 | ATH9K_POW_SM(ratesArray
[rateDupCck
], 0)
4576 REG_WRITE(ah
, AR_PHY_POWER_TX_SUB
,
4577 ATH9K_POW_SM(pModal
->pwrDecreaseFor3Chain
, 6)
4578 | ATH9K_POW_SM(pModal
->pwrDecreaseFor2Chain
, 0)
4582 if (IS_CHAN_HT40(chan
))
4584 else if (IS_CHAN_HT20(chan
))
4587 if (AR_SREV_9280_10_OR_LATER(ah
))
4588 ah
->ah_maxPowerLevel
=
4589 ratesArray
[i
] + AR5416_PWR_TABLE_OFFSET
* 2;
4591 ah
->ah_maxPowerLevel
= ratesArray
[i
];
4596 static inline void ath9k_hw_get_delta_slope_vals(struct ath_hal
*ah
,
4601 u32 coef_exp
, coef_man
;
4603 for (coef_exp
= 31; coef_exp
> 0; coef_exp
--)
4604 if ((coef_scaled
>> coef_exp
) & 0x1)
4607 coef_exp
= 14 - (coef_exp
- COEF_SCALE_S
);
4609 coef_man
= coef_scaled
+ (1 << (COEF_SCALE_S
- coef_exp
- 1));
4611 *coef_mantissa
= coef_man
>> (COEF_SCALE_S
- coef_exp
);
4612 *coef_exponent
= coef_exp
- 16;
4616 ath9k_hw_set_delta_slope(struct ath_hal
*ah
,
4617 struct ath9k_channel
*chan
)
4619 u32 coef_scaled
, ds_coef_exp
, ds_coef_man
;
4620 u32 clockMhzScaled
= 0x64000000;
4621 struct chan_centers centers
;
4623 if (IS_CHAN_HALF_RATE(chan
))
4624 clockMhzScaled
= clockMhzScaled
>> 1;
4625 else if (IS_CHAN_QUARTER_RATE(chan
))
4626 clockMhzScaled
= clockMhzScaled
>> 2;
4628 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
4629 coef_scaled
= clockMhzScaled
/ centers
.synth_center
;
4631 ath9k_hw_get_delta_slope_vals(ah
, coef_scaled
, &ds_coef_man
,
4634 REG_RMW_FIELD(ah
, AR_PHY_TIMING3
,
4635 AR_PHY_TIMING3_DSC_MAN
, ds_coef_man
);
4636 REG_RMW_FIELD(ah
, AR_PHY_TIMING3
,
4637 AR_PHY_TIMING3_DSC_EXP
, ds_coef_exp
);
4639 coef_scaled
= (9 * coef_scaled
) / 10;
4641 ath9k_hw_get_delta_slope_vals(ah
, coef_scaled
, &ds_coef_man
,
4644 REG_RMW_FIELD(ah
, AR_PHY_HALFGI
,
4645 AR_PHY_HALFGI_DSC_MAN
, ds_coef_man
);
4646 REG_RMW_FIELD(ah
, AR_PHY_HALFGI
,
4647 AR_PHY_HALFGI_DSC_EXP
, ds_coef_exp
);
4650 static void ath9k_hw_9280_spur_mitigate(struct ath_hal
*ah
,
4651 struct ath9k_channel
*chan
)
4653 int bb_spur
= AR_NO_SPUR
;
4656 int bb_spur_off
, spur_subchannel_sd
;
4658 int spur_delta_phase
;
4660 int upper
, lower
, cur_vit_mask
;
4663 int pilot_mask_reg
[4] = { AR_PHY_TIMING7
, AR_PHY_TIMING8
,
4664 AR_PHY_PILOT_MASK_01_30
, AR_PHY_PILOT_MASK_31_60
4666 int chan_mask_reg
[4] = { AR_PHY_TIMING9
, AR_PHY_TIMING10
,
4667 AR_PHY_CHANNEL_MASK_01_30
, AR_PHY_CHANNEL_MASK_31_60
4669 int inc
[4] = { 0, 100, 0, 0 };
4670 struct chan_centers centers
;
4677 bool is2GHz
= IS_CHAN_2GHZ(chan
);
4679 memset(&mask_m
, 0, sizeof(int8_t) * 123);
4680 memset(&mask_p
, 0, sizeof(int8_t) * 123);
4682 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
4683 freq
= centers
.synth_center
;
4685 ah
->ah_config
.spurmode
= SPUR_ENABLE_EEPROM
;
4686 for (i
= 0; i
< AR_EEPROM_MODAL_SPURS
; i
++) {
4687 cur_bb_spur
= ath9k_hw_eeprom_get_spur_chan(ah
, i
, is2GHz
);
4690 cur_bb_spur
= (cur_bb_spur
/ 10) + AR_BASE_FREQ_2GHZ
;
4692 cur_bb_spur
= (cur_bb_spur
/ 10) + AR_BASE_FREQ_5GHZ
;
4694 if (AR_NO_SPUR
== cur_bb_spur
)
4696 cur_bb_spur
= cur_bb_spur
- freq
;
4698 if (IS_CHAN_HT40(chan
)) {
4699 if ((cur_bb_spur
> -AR_SPUR_FEEQ_BOUND_HT40
) &&
4700 (cur_bb_spur
< AR_SPUR_FEEQ_BOUND_HT40
)) {
4701 bb_spur
= cur_bb_spur
;
4704 } else if ((cur_bb_spur
> -AR_SPUR_FEEQ_BOUND_HT20
) &&
4705 (cur_bb_spur
< AR_SPUR_FEEQ_BOUND_HT20
)) {
4706 bb_spur
= cur_bb_spur
;
4711 if (AR_NO_SPUR
== bb_spur
) {
4712 REG_CLR_BIT(ah
, AR_PHY_FORCE_CLKEN_CCK
,
4713 AR_PHY_FORCE_CLKEN_CCK_MRC_MUX
);
4716 REG_CLR_BIT(ah
, AR_PHY_FORCE_CLKEN_CCK
,
4717 AR_PHY_FORCE_CLKEN_CCK_MRC_MUX
);
4720 bin
= bb_spur
* 320;
4722 tmp
= REG_READ(ah
, AR_PHY_TIMING_CTRL4(0));
4724 newVal
= tmp
| (AR_PHY_TIMING_CTRL4_ENABLE_SPUR_RSSI
|
4725 AR_PHY_TIMING_CTRL4_ENABLE_SPUR_FILTER
|
4726 AR_PHY_TIMING_CTRL4_ENABLE_CHAN_MASK
|
4727 AR_PHY_TIMING_CTRL4_ENABLE_PILOT_MASK
);
4728 REG_WRITE(ah
, AR_PHY_TIMING_CTRL4(0), newVal
);
4730 newVal
= (AR_PHY_SPUR_REG_MASK_RATE_CNTL
|
4731 AR_PHY_SPUR_REG_ENABLE_MASK_PPM
|
4732 AR_PHY_SPUR_REG_MASK_RATE_SELECT
|
4733 AR_PHY_SPUR_REG_ENABLE_VIT_SPUR_RSSI
|
4734 SM(SPUR_RSSI_THRESH
, AR_PHY_SPUR_REG_SPUR_RSSI_THRESH
));
4735 REG_WRITE(ah
, AR_PHY_SPUR_REG
, newVal
);
4737 if (IS_CHAN_HT40(chan
)) {
4739 spur_subchannel_sd
= 1;
4740 bb_spur_off
= bb_spur
+ 10;
4742 spur_subchannel_sd
= 0;
4743 bb_spur_off
= bb_spur
- 10;
4746 spur_subchannel_sd
= 0;
4747 bb_spur_off
= bb_spur
;
4750 if (IS_CHAN_HT40(chan
))
4752 ((bb_spur
* 262144) /
4753 10) & AR_PHY_TIMING11_SPUR_DELTA_PHASE
;
4756 ((bb_spur
* 524288) /
4757 10) & AR_PHY_TIMING11_SPUR_DELTA_PHASE
;
4759 denominator
= IS_CHAN_2GHZ(chan
) ? 44 : 40;
4760 spur_freq_sd
= ((bb_spur_off
* 2048) / denominator
) & 0x3ff;
4762 newVal
= (AR_PHY_TIMING11_USE_SPUR_IN_AGC
|
4763 SM(spur_freq_sd
, AR_PHY_TIMING11_SPUR_FREQ_SD
) |
4764 SM(spur_delta_phase
, AR_PHY_TIMING11_SPUR_DELTA_PHASE
));
4765 REG_WRITE(ah
, AR_PHY_TIMING11
, newVal
);
4767 newVal
= spur_subchannel_sd
<< AR_PHY_SFCORR_SPUR_SUBCHNL_SD_S
;
4768 REG_WRITE(ah
, AR_PHY_SFCORR_EXT
, newVal
);
4774 for (i
= 0; i
< 4; i
++) {
4778 for (bp
= 0; bp
< 30; bp
++) {
4779 if ((cur_bin
> lower
) && (cur_bin
< upper
)) {
4780 pilot_mask
= pilot_mask
| 0x1 << bp
;
4781 chan_mask
= chan_mask
| 0x1 << bp
;
4786 REG_WRITE(ah
, pilot_mask_reg
[i
], pilot_mask
);
4787 REG_WRITE(ah
, chan_mask_reg
[i
], chan_mask
);
4790 cur_vit_mask
= 6100;
4794 for (i
= 0; i
< 123; i
++) {
4795 if ((cur_vit_mask
> lower
) && (cur_vit_mask
< upper
)) {
4797 /* workaround for gcc bug #37014 */
4798 volatile int tmp
= abs(cur_vit_mask
- bin
);
4804 if (cur_vit_mask
< 0)
4805 mask_m
[abs(cur_vit_mask
/ 100)] = mask_amt
;
4807 mask_p
[cur_vit_mask
/ 100] = mask_amt
;
4809 cur_vit_mask
-= 100;
4812 tmp_mask
= (mask_m
[46] << 30) | (mask_m
[47] << 28)
4813 | (mask_m
[48] << 26) | (mask_m
[49] << 24)
4814 | (mask_m
[50] << 22) | (mask_m
[51] << 20)
4815 | (mask_m
[52] << 18) | (mask_m
[53] << 16)
4816 | (mask_m
[54] << 14) | (mask_m
[55] << 12)
4817 | (mask_m
[56] << 10) | (mask_m
[57] << 8)
4818 | (mask_m
[58] << 6) | (mask_m
[59] << 4)
4819 | (mask_m
[60] << 2) | (mask_m
[61] << 0);
4820 REG_WRITE(ah
, AR_PHY_BIN_MASK_1
, tmp_mask
);
4821 REG_WRITE(ah
, AR_PHY_VIT_MASK2_M_46_61
, tmp_mask
);
4823 tmp_mask
= (mask_m
[31] << 28)
4824 | (mask_m
[32] << 26) | (mask_m
[33] << 24)
4825 | (mask_m
[34] << 22) | (mask_m
[35] << 20)
4826 | (mask_m
[36] << 18) | (mask_m
[37] << 16)
4827 | (mask_m
[48] << 14) | (mask_m
[39] << 12)
4828 | (mask_m
[40] << 10) | (mask_m
[41] << 8)
4829 | (mask_m
[42] << 6) | (mask_m
[43] << 4)
4830 | (mask_m
[44] << 2) | (mask_m
[45] << 0);
4831 REG_WRITE(ah
, AR_PHY_BIN_MASK_2
, tmp_mask
);
4832 REG_WRITE(ah
, AR_PHY_MASK2_M_31_45
, tmp_mask
);
4834 tmp_mask
= (mask_m
[16] << 30) | (mask_m
[16] << 28)
4835 | (mask_m
[18] << 26) | (mask_m
[18] << 24)
4836 | (mask_m
[20] << 22) | (mask_m
[20] << 20)
4837 | (mask_m
[22] << 18) | (mask_m
[22] << 16)
4838 | (mask_m
[24] << 14) | (mask_m
[24] << 12)
4839 | (mask_m
[25] << 10) | (mask_m
[26] << 8)
4840 | (mask_m
[27] << 6) | (mask_m
[28] << 4)
4841 | (mask_m
[29] << 2) | (mask_m
[30] << 0);
4842 REG_WRITE(ah
, AR_PHY_BIN_MASK_3
, tmp_mask
);
4843 REG_WRITE(ah
, AR_PHY_MASK2_M_16_30
, tmp_mask
);
4845 tmp_mask
= (mask_m
[0] << 30) | (mask_m
[1] << 28)
4846 | (mask_m
[2] << 26) | (mask_m
[3] << 24)
4847 | (mask_m
[4] << 22) | (mask_m
[5] << 20)
4848 | (mask_m
[6] << 18) | (mask_m
[7] << 16)
4849 | (mask_m
[8] << 14) | (mask_m
[9] << 12)
4850 | (mask_m
[10] << 10) | (mask_m
[11] << 8)
4851 | (mask_m
[12] << 6) | (mask_m
[13] << 4)
4852 | (mask_m
[14] << 2) | (mask_m
[15] << 0);
4853 REG_WRITE(ah
, AR_PHY_MASK_CTL
, tmp_mask
);
4854 REG_WRITE(ah
, AR_PHY_MASK2_M_00_15
, tmp_mask
);
4856 tmp_mask
= (mask_p
[15] << 28)
4857 | (mask_p
[14] << 26) | (mask_p
[13] << 24)
4858 | (mask_p
[12] << 22) | (mask_p
[11] << 20)
4859 | (mask_p
[10] << 18) | (mask_p
[9] << 16)
4860 | (mask_p
[8] << 14) | (mask_p
[7] << 12)
4861 | (mask_p
[6] << 10) | (mask_p
[5] << 8)
4862 | (mask_p
[4] << 6) | (mask_p
[3] << 4)
4863 | (mask_p
[2] << 2) | (mask_p
[1] << 0);
4864 REG_WRITE(ah
, AR_PHY_BIN_MASK2_1
, tmp_mask
);
4865 REG_WRITE(ah
, AR_PHY_MASK2_P_15_01
, tmp_mask
);
4867 tmp_mask
= (mask_p
[30] << 28)
4868 | (mask_p
[29] << 26) | (mask_p
[28] << 24)
4869 | (mask_p
[27] << 22) | (mask_p
[26] << 20)
4870 | (mask_p
[25] << 18) | (mask_p
[24] << 16)
4871 | (mask_p
[23] << 14) | (mask_p
[22] << 12)
4872 | (mask_p
[21] << 10) | (mask_p
[20] << 8)
4873 | (mask_p
[19] << 6) | (mask_p
[18] << 4)
4874 | (mask_p
[17] << 2) | (mask_p
[16] << 0);
4875 REG_WRITE(ah
, AR_PHY_BIN_MASK2_2
, tmp_mask
);
4876 REG_WRITE(ah
, AR_PHY_MASK2_P_30_16
, tmp_mask
);
4878 tmp_mask
= (mask_p
[45] << 28)
4879 | (mask_p
[44] << 26) | (mask_p
[43] << 24)
4880 | (mask_p
[42] << 22) | (mask_p
[41] << 20)
4881 | (mask_p
[40] << 18) | (mask_p
[39] << 16)
4882 | (mask_p
[38] << 14) | (mask_p
[37] << 12)
4883 | (mask_p
[36] << 10) | (mask_p
[35] << 8)
4884 | (mask_p
[34] << 6) | (mask_p
[33] << 4)
4885 | (mask_p
[32] << 2) | (mask_p
[31] << 0);
4886 REG_WRITE(ah
, AR_PHY_BIN_MASK2_3
, tmp_mask
);
4887 REG_WRITE(ah
, AR_PHY_MASK2_P_45_31
, tmp_mask
);
4889 tmp_mask
= (mask_p
[61] << 30) | (mask_p
[60] << 28)
4890 | (mask_p
[59] << 26) | (mask_p
[58] << 24)
4891 | (mask_p
[57] << 22) | (mask_p
[56] << 20)
4892 | (mask_p
[55] << 18) | (mask_p
[54] << 16)
4893 | (mask_p
[53] << 14) | (mask_p
[52] << 12)
4894 | (mask_p
[51] << 10) | (mask_p
[50] << 8)
4895 | (mask_p
[49] << 6) | (mask_p
[48] << 4)
4896 | (mask_p
[47] << 2) | (mask_p
[46] << 0);
4897 REG_WRITE(ah
, AR_PHY_BIN_MASK2_4
, tmp_mask
);
4898 REG_WRITE(ah
, AR_PHY_MASK2_P_61_45
, tmp_mask
);
4901 static void ath9k_hw_spur_mitigate(struct ath_hal
*ah
,
4902 struct ath9k_channel
*chan
)
4904 int bb_spur
= AR_NO_SPUR
;
4907 int spur_delta_phase
;
4909 int upper
, lower
, cur_vit_mask
;
4912 int pilot_mask_reg
[4] = { AR_PHY_TIMING7
, AR_PHY_TIMING8
,
4913 AR_PHY_PILOT_MASK_01_30
, AR_PHY_PILOT_MASK_31_60
4915 int chan_mask_reg
[4] = { AR_PHY_TIMING9
, AR_PHY_TIMING10
,
4916 AR_PHY_CHANNEL_MASK_01_30
, AR_PHY_CHANNEL_MASK_31_60
4918 int inc
[4] = { 0, 100, 0, 0 };
4925 bool is2GHz
= IS_CHAN_2GHZ(chan
);
4927 memset(&mask_m
, 0, sizeof(int8_t) * 123);
4928 memset(&mask_p
, 0, sizeof(int8_t) * 123);
4930 for (i
= 0; i
< AR_EEPROM_MODAL_SPURS
; i
++) {
4931 cur_bb_spur
= ath9k_hw_eeprom_get_spur_chan(ah
, i
, is2GHz
);
4932 if (AR_NO_SPUR
== cur_bb_spur
)
4934 cur_bb_spur
= cur_bb_spur
- (chan
->channel
* 10);
4935 if ((cur_bb_spur
> -95) && (cur_bb_spur
< 95)) {
4936 bb_spur
= cur_bb_spur
;
4941 if (AR_NO_SPUR
== bb_spur
)
4946 tmp
= REG_READ(ah
, AR_PHY_TIMING_CTRL4(0));
4947 new = tmp
| (AR_PHY_TIMING_CTRL4_ENABLE_SPUR_RSSI
|
4948 AR_PHY_TIMING_CTRL4_ENABLE_SPUR_FILTER
|
4949 AR_PHY_TIMING_CTRL4_ENABLE_CHAN_MASK
|
4950 AR_PHY_TIMING_CTRL4_ENABLE_PILOT_MASK
);
4952 REG_WRITE(ah
, AR_PHY_TIMING_CTRL4(0), new);
4954 new = (AR_PHY_SPUR_REG_MASK_RATE_CNTL
|
4955 AR_PHY_SPUR_REG_ENABLE_MASK_PPM
|
4956 AR_PHY_SPUR_REG_MASK_RATE_SELECT
|
4957 AR_PHY_SPUR_REG_ENABLE_VIT_SPUR_RSSI
|
4958 SM(SPUR_RSSI_THRESH
, AR_PHY_SPUR_REG_SPUR_RSSI_THRESH
));
4959 REG_WRITE(ah
, AR_PHY_SPUR_REG
, new);
4961 spur_delta_phase
= ((bb_spur
* 524288) / 100) &
4962 AR_PHY_TIMING11_SPUR_DELTA_PHASE
;
4964 denominator
= IS_CHAN_2GHZ(chan
) ? 440 : 400;
4965 spur_freq_sd
= ((bb_spur
* 2048) / denominator
) & 0x3ff;
4967 new = (AR_PHY_TIMING11_USE_SPUR_IN_AGC
|
4968 SM(spur_freq_sd
, AR_PHY_TIMING11_SPUR_FREQ_SD
) |
4969 SM(spur_delta_phase
, AR_PHY_TIMING11_SPUR_DELTA_PHASE
));
4970 REG_WRITE(ah
, AR_PHY_TIMING11
, new);
4976 for (i
= 0; i
< 4; i
++) {
4980 for (bp
= 0; bp
< 30; bp
++) {
4981 if ((cur_bin
> lower
) && (cur_bin
< upper
)) {
4982 pilot_mask
= pilot_mask
| 0x1 << bp
;
4983 chan_mask
= chan_mask
| 0x1 << bp
;
4988 REG_WRITE(ah
, pilot_mask_reg
[i
], pilot_mask
);
4989 REG_WRITE(ah
, chan_mask_reg
[i
], chan_mask
);
4992 cur_vit_mask
= 6100;
4996 for (i
= 0; i
< 123; i
++) {
4997 if ((cur_vit_mask
> lower
) && (cur_vit_mask
< upper
)) {
4999 /* workaround for gcc bug #37014 */
5000 volatile int tmp
= abs(cur_vit_mask
- bin
);
5006 if (cur_vit_mask
< 0)
5007 mask_m
[abs(cur_vit_mask
/ 100)] = mask_amt
;
5009 mask_p
[cur_vit_mask
/ 100] = mask_amt
;
5011 cur_vit_mask
-= 100;
5014 tmp_mask
= (mask_m
[46] << 30) | (mask_m
[47] << 28)
5015 | (mask_m
[48] << 26) | (mask_m
[49] << 24)
5016 | (mask_m
[50] << 22) | (mask_m
[51] << 20)
5017 | (mask_m
[52] << 18) | (mask_m
[53] << 16)
5018 | (mask_m
[54] << 14) | (mask_m
[55] << 12)
5019 | (mask_m
[56] << 10) | (mask_m
[57] << 8)
5020 | (mask_m
[58] << 6) | (mask_m
[59] << 4)
5021 | (mask_m
[60] << 2) | (mask_m
[61] << 0);
5022 REG_WRITE(ah
, AR_PHY_BIN_MASK_1
, tmp_mask
);
5023 REG_WRITE(ah
, AR_PHY_VIT_MASK2_M_46_61
, tmp_mask
);
5025 tmp_mask
= (mask_m
[31] << 28)
5026 | (mask_m
[32] << 26) | (mask_m
[33] << 24)
5027 | (mask_m
[34] << 22) | (mask_m
[35] << 20)
5028 | (mask_m
[36] << 18) | (mask_m
[37] << 16)
5029 | (mask_m
[48] << 14) | (mask_m
[39] << 12)
5030 | (mask_m
[40] << 10) | (mask_m
[41] << 8)
5031 | (mask_m
[42] << 6) | (mask_m
[43] << 4)
5032 | (mask_m
[44] << 2) | (mask_m
[45] << 0);
5033 REG_WRITE(ah
, AR_PHY_BIN_MASK_2
, tmp_mask
);
5034 REG_WRITE(ah
, AR_PHY_MASK2_M_31_45
, tmp_mask
);
5036 tmp_mask
= (mask_m
[16] << 30) | (mask_m
[16] << 28)
5037 | (mask_m
[18] << 26) | (mask_m
[18] << 24)
5038 | (mask_m
[20] << 22) | (mask_m
[20] << 20)
5039 | (mask_m
[22] << 18) | (mask_m
[22] << 16)
5040 | (mask_m
[24] << 14) | (mask_m
[24] << 12)
5041 | (mask_m
[25] << 10) | (mask_m
[26] << 8)
5042 | (mask_m
[27] << 6) | (mask_m
[28] << 4)
5043 | (mask_m
[29] << 2) | (mask_m
[30] << 0);
5044 REG_WRITE(ah
, AR_PHY_BIN_MASK_3
, tmp_mask
);
5045 REG_WRITE(ah
, AR_PHY_MASK2_M_16_30
, tmp_mask
);
5047 tmp_mask
= (mask_m
[0] << 30) | (mask_m
[1] << 28)
5048 | (mask_m
[2] << 26) | (mask_m
[3] << 24)
5049 | (mask_m
[4] << 22) | (mask_m
[5] << 20)
5050 | (mask_m
[6] << 18) | (mask_m
[7] << 16)
5051 | (mask_m
[8] << 14) | (mask_m
[9] << 12)
5052 | (mask_m
[10] << 10) | (mask_m
[11] << 8)
5053 | (mask_m
[12] << 6) | (mask_m
[13] << 4)
5054 | (mask_m
[14] << 2) | (mask_m
[15] << 0);
5055 REG_WRITE(ah
, AR_PHY_MASK_CTL
, tmp_mask
);
5056 REG_WRITE(ah
, AR_PHY_MASK2_M_00_15
, tmp_mask
);
5058 tmp_mask
= (mask_p
[15] << 28)
5059 | (mask_p
[14] << 26) | (mask_p
[13] << 24)
5060 | (mask_p
[12] << 22) | (mask_p
[11] << 20)
5061 | (mask_p
[10] << 18) | (mask_p
[9] << 16)
5062 | (mask_p
[8] << 14) | (mask_p
[7] << 12)
5063 | (mask_p
[6] << 10) | (mask_p
[5] << 8)
5064 | (mask_p
[4] << 6) | (mask_p
[3] << 4)
5065 | (mask_p
[2] << 2) | (mask_p
[1] << 0);
5066 REG_WRITE(ah
, AR_PHY_BIN_MASK2_1
, tmp_mask
);
5067 REG_WRITE(ah
, AR_PHY_MASK2_P_15_01
, tmp_mask
);
5069 tmp_mask
= (mask_p
[30] << 28)
5070 | (mask_p
[29] << 26) | (mask_p
[28] << 24)
5071 | (mask_p
[27] << 22) | (mask_p
[26] << 20)
5072 | (mask_p
[25] << 18) | (mask_p
[24] << 16)
5073 | (mask_p
[23] << 14) | (mask_p
[22] << 12)
5074 | (mask_p
[21] << 10) | (mask_p
[20] << 8)
5075 | (mask_p
[19] << 6) | (mask_p
[18] << 4)
5076 | (mask_p
[17] << 2) | (mask_p
[16] << 0);
5077 REG_WRITE(ah
, AR_PHY_BIN_MASK2_2
, tmp_mask
);
5078 REG_WRITE(ah
, AR_PHY_MASK2_P_30_16
, tmp_mask
);
5080 tmp_mask
= (mask_p
[45] << 28)
5081 | (mask_p
[44] << 26) | (mask_p
[43] << 24)
5082 | (mask_p
[42] << 22) | (mask_p
[41] << 20)
5083 | (mask_p
[40] << 18) | (mask_p
[39] << 16)
5084 | (mask_p
[38] << 14) | (mask_p
[37] << 12)
5085 | (mask_p
[36] << 10) | (mask_p
[35] << 8)
5086 | (mask_p
[34] << 6) | (mask_p
[33] << 4)
5087 | (mask_p
[32] << 2) | (mask_p
[31] << 0);
5088 REG_WRITE(ah
, AR_PHY_BIN_MASK2_3
, tmp_mask
);
5089 REG_WRITE(ah
, AR_PHY_MASK2_P_45_31
, tmp_mask
);
5091 tmp_mask
= (mask_p
[61] << 30) | (mask_p
[60] << 28)
5092 | (mask_p
[59] << 26) | (mask_p
[58] << 24)
5093 | (mask_p
[57] << 22) | (mask_p
[56] << 20)
5094 | (mask_p
[55] << 18) | (mask_p
[54] << 16)
5095 | (mask_p
[53] << 14) | (mask_p
[52] << 12)
5096 | (mask_p
[51] << 10) | (mask_p
[50] << 8)
5097 | (mask_p
[49] << 6) | (mask_p
[48] << 4)
5098 | (mask_p
[47] << 2) | (mask_p
[46] << 0);
5099 REG_WRITE(ah
, AR_PHY_BIN_MASK2_4
, tmp_mask
);
5100 REG_WRITE(ah
, AR_PHY_MASK2_P_61_45
, tmp_mask
);
5103 static inline void ath9k_hw_init_chain_masks(struct ath_hal
*ah
)
5105 struct ath_hal_5416
*ahp
= AH5416(ah
);
5106 int rx_chainmask
, tx_chainmask
;
5108 rx_chainmask
= ahp
->ah_rxchainmask
;
5109 tx_chainmask
= ahp
->ah_txchainmask
;
5111 switch (rx_chainmask
) {
5113 REG_SET_BIT(ah
, AR_PHY_ANALOG_SWAP
,
5114 AR_PHY_SWAP_ALT_CHAIN
);
5116 if (((ah
)->ah_macVersion
<= AR_SREV_VERSION_9160
)) {
5117 REG_WRITE(ah
, AR_PHY_RX_CHAINMASK
, 0x7);
5118 REG_WRITE(ah
, AR_PHY_CAL_CHAINMASK
, 0x7);
5123 if (!AR_SREV_9280(ah
))
5126 REG_WRITE(ah
, AR_PHY_RX_CHAINMASK
, rx_chainmask
);
5127 REG_WRITE(ah
, AR_PHY_CAL_CHAINMASK
, rx_chainmask
);
5133 REG_WRITE(ah
, AR_SELFGEN_MASK
, tx_chainmask
);
5134 if (tx_chainmask
== 0x5) {
5135 REG_SET_BIT(ah
, AR_PHY_ANALOG_SWAP
,
5136 AR_PHY_SWAP_ALT_CHAIN
);
5138 if (AR_SREV_9100(ah
))
5139 REG_WRITE(ah
, AR_PHY_ANALOG_SWAP
,
5140 REG_READ(ah
, AR_PHY_ANALOG_SWAP
) | 0x00000001);
5143 static void ath9k_hw_set_addac(struct ath_hal
*ah
,
5144 struct ath9k_channel
*chan
)
5146 struct modal_eep_header
*pModal
;
5147 struct ath_hal_5416
*ahp
= AH5416(ah
);
5148 struct ar5416_eeprom
*eep
= &ahp
->ah_eeprom
;
5151 if (ah
->ah_macVersion
!= AR_SREV_VERSION_9160
)
5154 if (ar5416_get_eep_rev(ahp
) < AR5416_EEP_MINOR_VER_7
)
5157 pModal
= &(eep
->modalHeader
[IS_CHAN_2GHZ(chan
)]);
5159 if (pModal
->xpaBiasLvl
!= 0xff) {
5160 biaslevel
= pModal
->xpaBiasLvl
;
5163 u16 resetFreqBin
, freqBin
, freqCount
= 0;
5164 struct chan_centers centers
;
5166 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
5169 FREQ2FBIN(centers
.synth_center
, IS_CHAN_2GHZ(chan
));
5170 freqBin
= pModal
->xpaBiasLvlFreq
[0] & 0xff;
5171 biaslevel
= (u8
) (pModal
->xpaBiasLvlFreq
[0] >> 14);
5175 while (freqCount
< 3) {
5176 if (pModal
->xpaBiasLvlFreq
[freqCount
] == 0x0)
5179 freqBin
= pModal
->xpaBiasLvlFreq
[freqCount
] & 0xff;
5180 if (resetFreqBin
>= freqBin
) {
5183 xpaBiasLvlFreq
[freqCount
]
5192 if (IS_CHAN_2GHZ(chan
)) {
5193 INI_RA(&ahp
->ah_iniAddac
, 7, 1) =
5194 (INI_RA(&ahp
->ah_iniAddac
, 7, 1) & (~0x18)) | biaslevel
5197 INI_RA(&ahp
->ah_iniAddac
, 6, 1) =
5198 (INI_RA(&ahp
->ah_iniAddac
, 6, 1) & (~0xc0)) | biaslevel
5203 static u32
ath9k_hw_mac_usec(struct ath_hal
*ah
, u32 clks
)
5205 if (ah
->ah_curchan
!= NULL
)
5207 CLOCK_RATE
[ath9k_hw_chan2wmode(ah
, ah
->ah_curchan
)];
5209 return clks
/ CLOCK_RATE
[ATH9K_MODE_11B
];
5212 static u32
ath9k_hw_mac_to_usec(struct ath_hal
*ah
, u32 clks
)
5214 struct ath9k_channel
*chan
= ah
->ah_curchan
;
5216 if (chan
&& IS_CHAN_HT40(chan
))
5217 return ath9k_hw_mac_usec(ah
, clks
) / 2;
5219 return ath9k_hw_mac_usec(ah
, clks
);
5222 static u32
ath9k_hw_mac_clks(struct ath_hal
*ah
, u32 usecs
)
5224 if (ah
->ah_curchan
!= NULL
)
5225 return usecs
* CLOCK_RATE
[ath9k_hw_chan2wmode(ah
,
5228 return usecs
* CLOCK_RATE
[ATH9K_MODE_11B
];
5231 static u32
ath9k_hw_mac_to_clks(struct ath_hal
*ah
, u32 usecs
)
5233 struct ath9k_channel
*chan
= ah
->ah_curchan
;
5235 if (chan
&& IS_CHAN_HT40(chan
))
5236 return ath9k_hw_mac_clks(ah
, usecs
) * 2;
5238 return ath9k_hw_mac_clks(ah
, usecs
);
5241 static bool ath9k_hw_set_ack_timeout(struct ath_hal
*ah
, u32 us
)
5243 struct ath_hal_5416
*ahp
= AH5416(ah
);
5245 if (us
> ath9k_hw_mac_to_usec(ah
, MS(0xffffffff, AR_TIME_OUT_ACK
))) {
5246 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: bad ack timeout %u\n",
5248 ahp
->ah_acktimeout
= (u32
) -1;
5251 REG_RMW_FIELD(ah
, AR_TIME_OUT
,
5252 AR_TIME_OUT_ACK
, ath9k_hw_mac_to_clks(ah
, us
));
5253 ahp
->ah_acktimeout
= us
;
5258 static bool ath9k_hw_set_cts_timeout(struct ath_hal
*ah
, u32 us
)
5260 struct ath_hal_5416
*ahp
= AH5416(ah
);
5262 if (us
> ath9k_hw_mac_to_usec(ah
, MS(0xffffffff, AR_TIME_OUT_CTS
))) {
5263 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: bad cts timeout %u\n",
5265 ahp
->ah_ctstimeout
= (u32
) -1;
5268 REG_RMW_FIELD(ah
, AR_TIME_OUT
,
5269 AR_TIME_OUT_CTS
, ath9k_hw_mac_to_clks(ah
, us
));
5270 ahp
->ah_ctstimeout
= us
;
5274 static bool ath9k_hw_set_global_txtimeout(struct ath_hal
*ah
,
5277 struct ath_hal_5416
*ahp
= AH5416(ah
);
5280 DPRINTF(ah
->ah_sc
, ATH_DBG_XMIT
,
5281 "%s: bad global tx timeout %u\n", __func__
, tu
);
5282 ahp
->ah_globaltxtimeout
= (u32
) -1;
5285 REG_RMW_FIELD(ah
, AR_GTXTO
, AR_GTXTO_TIMEOUT_LIMIT
, tu
);
5286 ahp
->ah_globaltxtimeout
= tu
;
5291 bool ath9k_hw_setslottime(struct ath_hal
*ah
, u32 us
)
5293 struct ath_hal_5416
*ahp
= AH5416(ah
);
5295 if (us
< ATH9K_SLOT_TIME_9
|| us
> ath9k_hw_mac_to_usec(ah
, 0xffff)) {
5296 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: bad slot time %u\n",
5298 ahp
->ah_slottime
= (u32
) -1;
5301 REG_WRITE(ah
, AR_D_GBL_IFS_SLOT
, ath9k_hw_mac_to_clks(ah
, us
));
5302 ahp
->ah_slottime
= us
;
5307 static inline void ath9k_hw_init_user_settings(struct ath_hal
*ah
)
5309 struct ath_hal_5416
*ahp
= AH5416(ah
);
5311 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "--AP %s ahp->ah_miscMode 0x%x\n",
5312 __func__
, ahp
->ah_miscMode
);
5313 if (ahp
->ah_miscMode
!= 0)
5314 REG_WRITE(ah
, AR_PCU_MISC
,
5315 REG_READ(ah
, AR_PCU_MISC
) | ahp
->ah_miscMode
);
5316 if (ahp
->ah_slottime
!= (u32
) -1)
5317 ath9k_hw_setslottime(ah
, ahp
->ah_slottime
);
5318 if (ahp
->ah_acktimeout
!= (u32
) -1)
5319 ath9k_hw_set_ack_timeout(ah
, ahp
->ah_acktimeout
);
5320 if (ahp
->ah_ctstimeout
!= (u32
) -1)
5321 ath9k_hw_set_cts_timeout(ah
, ahp
->ah_ctstimeout
);
5322 if (ahp
->ah_globaltxtimeout
!= (u32
) -1)
5323 ath9k_hw_set_global_txtimeout(ah
, ahp
->ah_globaltxtimeout
);
5327 ath9k_hw_process_ini(struct ath_hal
*ah
,
5328 struct ath9k_channel
*chan
,
5329 enum ath9k_ht_macmode macmode
)
5331 int i
, regWrites
= 0;
5332 struct ath_hal_5416
*ahp
= AH5416(ah
);
5333 u32 modesIndex
, freqIndex
;
5336 switch (chan
->chanmode
) {
5338 case CHANNEL_A_HT20
:
5342 case CHANNEL_A_HT40PLUS
:
5343 case CHANNEL_A_HT40MINUS
:
5348 case CHANNEL_G_HT20
:
5353 case CHANNEL_G_HT40PLUS
:
5354 case CHANNEL_G_HT40MINUS
:
5363 REG_WRITE(ah
, AR_PHY(0), 0x00000007);
5365 REG_WRITE(ah
, AR_PHY_ADC_SERIAL_CTL
, AR_PHY_SEL_EXTERNAL_RADIO
);
5367 ath9k_hw_set_addac(ah
, chan
);
5369 if (AR_SREV_5416_V22_OR_LATER(ah
)) {
5370 REG_WRITE_ARRAY(&ahp
->ah_iniAddac
, 1, regWrites
);
5372 struct ar5416IniArray temp
;
5374 sizeof(u32
) * ahp
->ah_iniAddac
.ia_rows
*
5375 ahp
->ah_iniAddac
.ia_columns
;
5377 memcpy(ahp
->ah_addac5416_21
,
5378 ahp
->ah_iniAddac
.ia_array
, addacSize
);
5380 (ahp
->ah_addac5416_21
)[31 *
5381 ahp
->ah_iniAddac
.ia_columns
+ 1] = 0;
5383 temp
.ia_array
= ahp
->ah_addac5416_21
;
5384 temp
.ia_columns
= ahp
->ah_iniAddac
.ia_columns
;
5385 temp
.ia_rows
= ahp
->ah_iniAddac
.ia_rows
;
5386 REG_WRITE_ARRAY(&temp
, 1, regWrites
);
5388 REG_WRITE(ah
, AR_PHY_ADC_SERIAL_CTL
, AR_PHY_SEL_INTERNAL_ADDAC
);
5390 for (i
= 0; i
< ahp
->ah_iniModes
.ia_rows
; i
++) {
5391 u32 reg
= INI_RA(&ahp
->ah_iniModes
, i
, 0);
5392 u32 val
= INI_RA(&ahp
->ah_iniModes
, i
, modesIndex
);
5394 #ifdef CONFIG_SLOW_ANT_DIV
5395 if (ah
->ah_devid
== AR9280_DEVID_PCI
)
5396 val
= ath9k_hw_ini_fixup(ah
, &ahp
->ah_eeprom
, reg
,
5400 REG_WRITE(ah
, reg
, val
);
5402 if (reg
>= 0x7800 && reg
< 0x78a0
5403 && ah
->ah_config
.analog_shiftreg
) {
5407 DO_DELAY(regWrites
);
5410 for (i
= 0; i
< ahp
->ah_iniCommon
.ia_rows
; i
++) {
5411 u32 reg
= INI_RA(&ahp
->ah_iniCommon
, i
, 0);
5412 u32 val
= INI_RA(&ahp
->ah_iniCommon
, i
, 1);
5414 REG_WRITE(ah
, reg
, val
);
5416 if (reg
>= 0x7800 && reg
< 0x78a0
5417 && ah
->ah_config
.analog_shiftreg
) {
5421 DO_DELAY(regWrites
);
5424 ath9k_hw_write_regs(ah
, modesIndex
, freqIndex
, regWrites
);
5426 if (AR_SREV_9280_20(ah
) && IS_CHAN_A_5MHZ_SPACED(chan
)) {
5427 REG_WRITE_ARRAY(&ahp
->ah_iniModesAdditional
, modesIndex
,
5431 ath9k_hw_override_ini(ah
, chan
);
5432 ath9k_hw_set_regs(ah
, chan
, macmode
);
5433 ath9k_hw_init_chain_masks(ah
);
5435 status
= ath9k_hw_set_txpower(ah
, &ahp
->ah_eeprom
, chan
,
5436 ath9k_regd_get_ctl(ah
, chan
),
5437 ath9k_regd_get_antenna_allowed(ah
,
5439 chan
->maxRegTxPower
* 2,
5440 min((u32
) MAX_RATE_POWER
,
5441 (u32
) ah
->ah_powerLimit
));
5443 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
5444 "%s: error init'ing transmit power\n", __func__
);
5448 if (!ath9k_hw_set_rf_regs(ah
, chan
, freqIndex
)) {
5449 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
5450 "%s: ar5416SetRfRegs failed\n", __func__
);
5457 static inline void ath9k_hw_setup_calibration(struct ath_hal
*ah
,
5458 struct hal_cal_list
*currCal
)
5460 REG_RMW_FIELD(ah
, AR_PHY_TIMING_CTRL4(0),
5461 AR_PHY_TIMING_CTRL4_IQCAL_LOG_COUNT_MAX
,
5462 currCal
->calData
->calCountMax
);
5464 switch (currCal
->calData
->calType
) {
5465 case IQ_MISMATCH_CAL
:
5466 REG_WRITE(ah
, AR_PHY_CALMODE
, AR_PHY_CALMODE_IQ
);
5467 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5468 "%s: starting IQ Mismatch Calibration\n",
5472 REG_WRITE(ah
, AR_PHY_CALMODE
, AR_PHY_CALMODE_ADC_GAIN
);
5473 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5474 "%s: starting ADC Gain Calibration\n", __func__
);
5477 REG_WRITE(ah
, AR_PHY_CALMODE
, AR_PHY_CALMODE_ADC_DC_PER
);
5478 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5479 "%s: starting ADC DC Calibration\n", __func__
);
5481 case ADC_DC_INIT_CAL
:
5482 REG_WRITE(ah
, AR_PHY_CALMODE
, AR_PHY_CALMODE_ADC_DC_INIT
);
5483 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5484 "%s: starting Init ADC DC Calibration\n",
5489 REG_SET_BIT(ah
, AR_PHY_TIMING_CTRL4(0),
5490 AR_PHY_TIMING_CTRL4_DO_CAL
);
5493 static inline void ath9k_hw_reset_calibration(struct ath_hal
*ah
,
5494 struct hal_cal_list
*currCal
)
5496 struct ath_hal_5416
*ahp
= AH5416(ah
);
5499 ath9k_hw_setup_calibration(ah
, currCal
);
5501 currCal
->calState
= CAL_RUNNING
;
5503 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
5504 ahp
->ah_Meas0
.sign
[i
] = 0;
5505 ahp
->ah_Meas1
.sign
[i
] = 0;
5506 ahp
->ah_Meas2
.sign
[i
] = 0;
5507 ahp
->ah_Meas3
.sign
[i
] = 0;
5510 ahp
->ah_CalSamples
= 0;
5514 ath9k_hw_per_calibration(struct ath_hal
*ah
,
5515 struct ath9k_channel
*ichan
,
5517 struct hal_cal_list
*currCal
,
5520 struct ath_hal_5416
*ahp
= AH5416(ah
);
5524 if (currCal
->calState
== CAL_RUNNING
) {
5526 AR_PHY_TIMING_CTRL4(0)) &
5527 AR_PHY_TIMING_CTRL4_DO_CAL
)) {
5529 currCal
->calData
->calCollect(ah
);
5531 ahp
->ah_CalSamples
++;
5533 if (ahp
->ah_CalSamples
>=
5534 currCal
->calData
->calNumSamples
) {
5535 int i
, numChains
= 0;
5536 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
5537 if (rxchainmask
& (1 << i
))
5541 currCal
->calData
->calPostProc(ah
,
5545 currCal
->calData
->calType
;
5546 currCal
->calState
= CAL_DONE
;
5549 ath9k_hw_setup_calibration(ah
, currCal
);
5552 } else if (!(ichan
->CalValid
& currCal
->calData
->calType
)) {
5553 ath9k_hw_reset_calibration(ah
, currCal
);
5557 static inline bool ath9k_hw_run_init_cals(struct ath_hal
*ah
,
5560 struct ath_hal_5416
*ahp
= AH5416(ah
);
5561 struct ath9k_channel ichan
;
5563 struct hal_cal_list
*currCal
= ahp
->ah_cal_list_curr
;
5564 const struct hal_percal_data
*calData
= currCal
->calData
;
5567 if (currCal
== NULL
)
5572 for (i
= 0; i
< init_cal_count
; i
++) {
5573 ath9k_hw_reset_calibration(ah
, currCal
);
5575 if (!ath9k_hw_wait(ah
, AR_PHY_TIMING_CTRL4(0),
5576 AR_PHY_TIMING_CTRL4_DO_CAL
, 0)) {
5577 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5578 "%s: Cal %d failed to complete in 100ms.\n",
5579 __func__
, calData
->calType
);
5581 ahp
->ah_cal_list
= ahp
->ah_cal_list_last
=
5582 ahp
->ah_cal_list_curr
= NULL
;
5586 ath9k_hw_per_calibration(ah
, &ichan
, ahp
->ah_rxchainmask
,
5587 currCal
, &isCalDone
);
5589 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5590 "%s: Not able to run Init Cal %d.\n",
5591 __func__
, calData
->calType
);
5593 if (currCal
->calNext
) {
5594 currCal
= currCal
->calNext
;
5595 calData
= currCal
->calData
;
5599 ahp
->ah_cal_list
= ahp
->ah_cal_list_last
= ahp
->ah_cal_list_curr
= NULL
;
5604 ath9k_hw_channel_change(struct ath_hal
*ah
,
5605 struct ath9k_channel
*chan
,
5606 enum ath9k_ht_macmode macmode
)
5608 u32 synthDelay
, qnum
;
5609 struct ath_hal_5416
*ahp
= AH5416(ah
);
5611 for (qnum
= 0; qnum
< AR_NUM_QCU
; qnum
++) {
5612 if (ath9k_hw_numtxpending(ah
, qnum
)) {
5613 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
5614 "%s: Transmit frames pending on queue %d\n",
5620 REG_WRITE(ah
, AR_PHY_RFBUS_REQ
, AR_PHY_RFBUS_REQ_EN
);
5621 if (!ath9k_hw_wait(ah
, AR_PHY_RFBUS_GRANT
, AR_PHY_RFBUS_GRANT_EN
,
5622 AR_PHY_RFBUS_GRANT_EN
)) {
5623 DPRINTF(ah
->ah_sc
, ATH_DBG_PHY_IO
,
5624 "%s: Could not kill baseband RX\n", __func__
);
5628 ath9k_hw_set_regs(ah
, chan
, macmode
);
5630 if (AR_SREV_9280_10_OR_LATER(ah
)) {
5631 if (!(ath9k_hw_ar9280_set_channel(ah
, chan
))) {
5632 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
5633 "%s: failed to set channel\n", __func__
);
5637 if (!(ath9k_hw_set_channel(ah
, chan
))) {
5638 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
5639 "%s: failed to set channel\n", __func__
);
5644 if (ath9k_hw_set_txpower(ah
, &ahp
->ah_eeprom
, chan
,
5645 ath9k_regd_get_ctl(ah
, chan
),
5646 ath9k_regd_get_antenna_allowed(ah
, chan
),
5647 chan
->maxRegTxPower
* 2,
5648 min((u32
) MAX_RATE_POWER
,
5649 (u32
) ah
->ah_powerLimit
)) != 0) {
5650 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
5651 "%s: error init'ing transmit power\n", __func__
);
5655 synthDelay
= REG_READ(ah
, AR_PHY_RX_DELAY
) & AR_PHY_RX_DELAY_DELAY
;
5656 if (IS_CHAN_CCK(chan
))
5657 synthDelay
= (4 * synthDelay
) / 22;
5661 udelay(synthDelay
+ BASE_ACTIVATE_DELAY
);
5663 REG_WRITE(ah
, AR_PHY_RFBUS_REQ
, 0);
5665 if (IS_CHAN_OFDM(chan
) || IS_CHAN_HT(chan
))
5666 ath9k_hw_set_delta_slope(ah
, chan
);
5668 if (AR_SREV_9280_10_OR_LATER(ah
))
5669 ath9k_hw_9280_spur_mitigate(ah
, chan
);
5671 ath9k_hw_spur_mitigate(ah
, chan
);
5673 if (!chan
->oneTimeCalsDone
)
5674 chan
->oneTimeCalsDone
= true;
5679 static bool ath9k_hw_chip_reset(struct ath_hal
*ah
,
5680 struct ath9k_channel
*chan
)
5682 struct ath_hal_5416
*ahp
= AH5416(ah
);
5684 if (!ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_WARM
))
5687 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
))
5690 ahp
->ah_chipFullSleep
= false;
5692 ath9k_hw_init_pll(ah
, chan
);
5694 ath9k_hw_set_rfmode(ah
, chan
);
5699 static inline void ath9k_hw_set_dma(struct ath_hal
*ah
)
5703 regval
= REG_READ(ah
, AR_AHB_MODE
);
5704 REG_WRITE(ah
, AR_AHB_MODE
, regval
| AR_AHB_PREFETCH_RD_EN
);
5706 regval
= REG_READ(ah
, AR_TXCFG
) & ~AR_TXCFG_DMASZ_MASK
;
5707 REG_WRITE(ah
, AR_TXCFG
, regval
| AR_TXCFG_DMASZ_128B
);
5709 REG_RMW_FIELD(ah
, AR_TXCFG
, AR_FTRIG
, ah
->ah_txTrigLevel
);
5711 regval
= REG_READ(ah
, AR_RXCFG
) & ~AR_RXCFG_DMASZ_MASK
;
5712 REG_WRITE(ah
, AR_RXCFG
, regval
| AR_RXCFG_DMASZ_128B
);
5714 REG_WRITE(ah
, AR_RXFIFO_CFG
, 0x200);
5716 if (AR_SREV_9285(ah
)) {
5717 REG_WRITE(ah
, AR_PCU_TXBUF_CTRL
,
5718 AR_9285_PCU_TXBUF_CTRL_USABLE_SIZE
);
5720 REG_WRITE(ah
, AR_PCU_TXBUF_CTRL
,
5721 AR_PCU_TXBUF_CTRL_USABLE_SIZE
);
5725 bool ath9k_hw_stopdmarecv(struct ath_hal
*ah
)
5727 REG_WRITE(ah
, AR_CR
, AR_CR_RXD
);
5728 if (!ath9k_hw_wait(ah
, AR_CR
, AR_CR_RXE
, 0)) {
5729 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
5730 "%s: dma failed to stop in 10ms\n"
5731 "AR_CR=0x%08x\nAR_DIAG_SW=0x%08x\n",
5733 REG_READ(ah
, AR_CR
), REG_READ(ah
, AR_DIAG_SW
));
5740 void ath9k_hw_startpcureceive(struct ath_hal
*ah
)
5742 REG_CLR_BIT(ah
, AR_DIAG_SW
,
5743 (AR_DIAG_RX_DIS
| AR_DIAG_RX_ABORT
));
5745 ath9k_enable_mib_counters(ah
);
5747 ath9k_ani_reset(ah
);
5750 void ath9k_hw_stoppcurecv(struct ath_hal
*ah
)
5752 REG_SET_BIT(ah
, AR_DIAG_SW
, AR_DIAG_RX_DIS
);
5754 ath9k_hw_disable_mib_counters(ah
);
5757 static bool ath9k_hw_iscal_supported(struct ath_hal
*ah
,
5758 struct ath9k_channel
*chan
,
5759 enum hal_cal_types calType
)
5761 struct ath_hal_5416
*ahp
= AH5416(ah
);
5762 bool retval
= false;
5764 switch (calType
& ahp
->ah_suppCals
) {
5765 case IQ_MISMATCH_CAL
:
5766 if (!IS_CHAN_B(chan
))
5771 if (!IS_CHAN_B(chan
)
5772 && !(IS_CHAN_2GHZ(chan
) && IS_CHAN_HT20(chan
)))
5780 static inline bool ath9k_hw_init_cal(struct ath_hal
*ah
,
5781 struct ath9k_channel
*chan
)
5783 struct ath_hal_5416
*ahp
= AH5416(ah
);
5784 struct ath9k_channel
*ichan
=
5785 ath9k_regd_check_channel(ah
, chan
);
5787 REG_WRITE(ah
, AR_PHY_AGC_CONTROL
,
5788 REG_READ(ah
, AR_PHY_AGC_CONTROL
) |
5789 AR_PHY_AGC_CONTROL_CAL
);
5792 (ah
, AR_PHY_AGC_CONTROL
, AR_PHY_AGC_CONTROL_CAL
, 0)) {
5793 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5794 "%s: offset calibration failed to complete in 1ms; "
5795 "noisy environment?\n", __func__
);
5799 REG_WRITE(ah
, AR_PHY_AGC_CONTROL
,
5800 REG_READ(ah
, AR_PHY_AGC_CONTROL
) |
5801 AR_PHY_AGC_CONTROL_NF
);
5803 ahp
->ah_cal_list
= ahp
->ah_cal_list_last
= ahp
->ah_cal_list_curr
=
5806 if (AR_SREV_9100(ah
) || AR_SREV_9160_10_OR_LATER(ah
)) {
5807 if (ath9k_hw_iscal_supported(ah
, chan
, ADC_GAIN_CAL
)) {
5808 INIT_CAL(&ahp
->ah_adcGainCalData
);
5809 INSERT_CAL(ahp
, &ahp
->ah_adcGainCalData
);
5810 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5811 "%s: enabling ADC Gain Calibration.\n",
5814 if (ath9k_hw_iscal_supported(ah
, chan
, ADC_DC_CAL
)) {
5815 INIT_CAL(&ahp
->ah_adcDcCalData
);
5816 INSERT_CAL(ahp
, &ahp
->ah_adcDcCalData
);
5817 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5818 "%s: enabling ADC DC Calibration.\n",
5821 if (ath9k_hw_iscal_supported(ah
, chan
, IQ_MISMATCH_CAL
)) {
5822 INIT_CAL(&ahp
->ah_iqCalData
);
5823 INSERT_CAL(ahp
, &ahp
->ah_iqCalData
);
5824 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5825 "%s: enabling IQ Calibration.\n",
5829 ahp
->ah_cal_list_curr
= ahp
->ah_cal_list
;
5831 if (ahp
->ah_cal_list_curr
)
5832 ath9k_hw_reset_calibration(ah
,
5833 ahp
->ah_cal_list_curr
);
5836 ichan
->CalValid
= 0;
5842 bool ath9k_hw_reset(struct ath_hal
*ah
,
5843 struct ath9k_channel
*chan
,
5844 enum ath9k_ht_macmode macmode
,
5845 u8 txchainmask
, u8 rxchainmask
,
5846 enum ath9k_ht_extprotspacing extprotspacing
,
5847 bool bChannelChange
,
5850 #define FAIL(_code) do { ecode = _code; goto bad; } while (0)
5852 struct ath_hal_5416
*ahp
= AH5416(ah
);
5853 struct ath9k_channel
*curchan
= ah
->ah_curchan
;
5857 int i
, rx_chainmask
;
5859 ahp
->ah_extprotspacing
= extprotspacing
;
5860 ahp
->ah_txchainmask
= txchainmask
;
5861 ahp
->ah_rxchainmask
= rxchainmask
;
5863 if (AR_SREV_9280(ah
)) {
5864 ahp
->ah_txchainmask
&= 0x3;
5865 ahp
->ah_rxchainmask
&= 0x3;
5868 if (ath9k_hw_check_chan(ah
, chan
) == NULL
) {
5869 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
5870 "%s: invalid channel %u/0x%x; no mapping\n",
5871 __func__
, chan
->channel
, chan
->channelFlags
);
5875 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
))
5879 ath9k_hw_getnf(ah
, curchan
);
5881 if (bChannelChange
&&
5882 (ahp
->ah_chipFullSleep
!= true) &&
5883 (ah
->ah_curchan
!= NULL
) &&
5884 (chan
->channel
!= ah
->ah_curchan
->channel
) &&
5885 ((chan
->channelFlags
& CHANNEL_ALL
) ==
5886 (ah
->ah_curchan
->channelFlags
& CHANNEL_ALL
)) &&
5887 (!AR_SREV_9280(ah
) || (!IS_CHAN_A_5MHZ_SPACED(chan
) &&
5888 !IS_CHAN_A_5MHZ_SPACED(ah
->
5891 if (ath9k_hw_channel_change(ah
, chan
, macmode
)) {
5892 ath9k_hw_loadnf(ah
, ah
->ah_curchan
);
5893 ath9k_hw_start_nfcal(ah
);
5898 saveDefAntenna
= REG_READ(ah
, AR_DEF_ANTENNA
);
5899 if (saveDefAntenna
== 0)
5902 macStaId1
= REG_READ(ah
, AR_STA_ID1
) & AR_STA_ID1_BASE_RATE_11B
;
5904 saveLedState
= REG_READ(ah
, AR_CFG_LED
) &
5905 (AR_CFG_LED_ASSOC_CTL
| AR_CFG_LED_MODE_SEL
|
5906 AR_CFG_LED_BLINK_THRESH_SEL
| AR_CFG_LED_BLINK_SLOW
);
5908 ath9k_hw_mark_phy_inactive(ah
);
5910 if (!ath9k_hw_chip_reset(ah
, chan
)) {
5911 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: chip reset failed\n",
5916 if (AR_SREV_9280(ah
)) {
5917 REG_SET_BIT(ah
, AR_GPIO_INPUT_EN_VAL
,
5918 AR_GPIO_JTAG_DISABLE
);
5920 if (test_bit(ATH9K_MODE_11A
, ah
->ah_caps
.wireless_modes
)) {
5921 if (IS_CHAN_5GHZ(chan
))
5922 ath9k_hw_set_gpio(ah
, 9, 0);
5924 ath9k_hw_set_gpio(ah
, 9, 1);
5926 ath9k_hw_cfg_output(ah
, 9, ATH9K_GPIO_OUTPUT_MUX_AS_OUTPUT
);
5929 ecode
= ath9k_hw_process_ini(ah
, chan
, macmode
);
5933 if (IS_CHAN_OFDM(chan
) || IS_CHAN_HT(chan
))
5934 ath9k_hw_set_delta_slope(ah
, chan
);
5936 if (AR_SREV_9280_10_OR_LATER(ah
))
5937 ath9k_hw_9280_spur_mitigate(ah
, chan
);
5939 ath9k_hw_spur_mitigate(ah
, chan
);
5941 if (!ath9k_hw_eeprom_set_board_values(ah
, chan
)) {
5942 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
5943 "%s: error setting board options\n", __func__
);
5947 ath9k_hw_decrease_chain_power(ah
, chan
);
5949 REG_WRITE(ah
, AR_STA_ID0
, get_unaligned_le32(ahp
->ah_macaddr
));
5950 REG_WRITE(ah
, AR_STA_ID1
, get_unaligned_le16(ahp
->ah_macaddr
+ 4)
5952 | AR_STA_ID1_RTS_USE_DEF
5954 ack_6mb
? AR_STA_ID1_ACKCTS_6MB
: 0)
5955 | ahp
->ah_staId1Defaults
);
5956 ath9k_hw_set_operating_mode(ah
, ah
->ah_opmode
);
5958 REG_WRITE(ah
, AR_BSSMSKL
, get_unaligned_le32(ahp
->ah_bssidmask
));
5959 REG_WRITE(ah
, AR_BSSMSKU
, get_unaligned_le16(ahp
->ah_bssidmask
+ 4));
5961 REG_WRITE(ah
, AR_DEF_ANTENNA
, saveDefAntenna
);
5963 REG_WRITE(ah
, AR_BSS_ID0
, get_unaligned_le32(ahp
->ah_bssid
));
5964 REG_WRITE(ah
, AR_BSS_ID1
, get_unaligned_le16(ahp
->ah_bssid
+ 4) |
5965 ((ahp
->ah_assocId
& 0x3fff) << AR_BSS_ID1_AID_S
));
5967 REG_WRITE(ah
, AR_ISR
, ~0);
5969 REG_WRITE(ah
, AR_RSSI_THR
, INIT_RSSI_THR
);
5971 if (AR_SREV_9280_10_OR_LATER(ah
)) {
5972 if (!(ath9k_hw_ar9280_set_channel(ah
, chan
)))
5975 if (!(ath9k_hw_set_channel(ah
, chan
)))
5979 for (i
= 0; i
< AR_NUM_DCU
; i
++)
5980 REG_WRITE(ah
, AR_DQCUMASK(i
), 1 << i
);
5982 ahp
->ah_intrTxqs
= 0;
5983 for (i
= 0; i
< ah
->ah_caps
.total_queues
; i
++)
5984 ath9k_hw_resettxqueue(ah
, i
);
5986 ath9k_hw_init_interrupt_masks(ah
, ah
->ah_opmode
);
5987 ath9k_hw_init_qos(ah
);
5989 ath9k_hw_init_user_settings(ah
);
5991 REG_WRITE(ah
, AR_STA_ID1
,
5992 REG_READ(ah
, AR_STA_ID1
) | AR_STA_ID1_PRESERVE_SEQNUM
);
5994 ath9k_hw_set_dma(ah
);
5996 REG_WRITE(ah
, AR_OBS
, 8);
5998 if (ahp
->ah_intrMitigation
) {
6000 REG_RMW_FIELD(ah
, AR_RIMT
, AR_RIMT_LAST
, 500);
6001 REG_RMW_FIELD(ah
, AR_RIMT
, AR_RIMT_FIRST
, 2000);
6004 ath9k_hw_init_bb(ah
, chan
);
6006 if (!ath9k_hw_init_cal(ah
, chan
))
6009 rx_chainmask
= ahp
->ah_rxchainmask
;
6010 if ((rx_chainmask
== 0x5) || (rx_chainmask
== 0x3)) {
6011 REG_WRITE(ah
, AR_PHY_RX_CHAINMASK
, rx_chainmask
);
6012 REG_WRITE(ah
, AR_PHY_CAL_CHAINMASK
, rx_chainmask
);
6015 REG_WRITE(ah
, AR_CFG_LED
, saveLedState
| AR_CFG_SCLK_32KHZ
);
6017 if (AR_SREV_9100(ah
)) {
6019 mask
= REG_READ(ah
, AR_CFG
);
6020 if (mask
& (AR_CFG_SWRB
| AR_CFG_SWTB
| AR_CFG_SWRG
)) {
6021 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
6022 "%s CFG Byte Swap Set 0x%x\n", __func__
,
6026 INIT_CONFIG_STATUS
| AR_CFG_SWRB
| AR_CFG_SWTB
;
6027 REG_WRITE(ah
, AR_CFG
, mask
);
6028 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
6029 "%s Setting CFG 0x%x\n", __func__
,
6030 REG_READ(ah
, AR_CFG
));
6034 REG_WRITE(ah
, AR_CFG
, AR_CFG_SWTD
| AR_CFG_SWRD
);
6046 bool ath9k_hw_phy_disable(struct ath_hal
*ah
)
6048 return ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_WARM
);
6051 bool ath9k_hw_disable(struct ath_hal
*ah
)
6053 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
))
6056 return ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_COLD
);
6060 ath9k_hw_calibrate(struct ath_hal
*ah
, struct ath9k_channel
*chan
,
6061 u8 rxchainmask
, bool longcal
,
6064 struct ath_hal_5416
*ahp
= AH5416(ah
);
6065 struct hal_cal_list
*currCal
= ahp
->ah_cal_list_curr
;
6066 struct ath9k_channel
*ichan
=
6067 ath9k_regd_check_channel(ah
, chan
);
6071 if (ichan
== NULL
) {
6072 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
6073 "%s: invalid channel %u/0x%x; no mapping\n",
6074 __func__
, chan
->channel
, chan
->channelFlags
);
6079 (currCal
->calState
== CAL_RUNNING
||
6080 currCal
->calState
== CAL_WAITING
)) {
6081 ath9k_hw_per_calibration(ah
, ichan
, rxchainmask
, currCal
,
6084 ahp
->ah_cal_list_curr
= currCal
= currCal
->calNext
;
6086 if (currCal
->calState
== CAL_WAITING
) {
6088 ath9k_hw_reset_calibration(ah
, currCal
);
6094 ath9k_hw_getnf(ah
, ichan
);
6095 ath9k_hw_loadnf(ah
, ah
->ah_curchan
);
6096 ath9k_hw_start_nfcal(ah
);
6098 if ((ichan
->channelFlags
& CHANNEL_CW_INT
) != 0) {
6100 chan
->channelFlags
|= CHANNEL_CW_INT
;
6101 ichan
->channelFlags
&= ~CHANNEL_CW_INT
;
6108 static void ath9k_hw_iqcal_collect(struct ath_hal
*ah
)
6110 struct ath_hal_5416
*ahp
= AH5416(ah
);
6113 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
6114 ahp
->ah_totalPowerMeasI
[i
] +=
6115 REG_READ(ah
, AR_PHY_CAL_MEAS_0(i
));
6116 ahp
->ah_totalPowerMeasQ
[i
] +=
6117 REG_READ(ah
, AR_PHY_CAL_MEAS_1(i
));
6118 ahp
->ah_totalIqCorrMeas
[i
] +=
6119 (int32_t) REG_READ(ah
, AR_PHY_CAL_MEAS_2(i
));
6120 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6121 "%d: Chn %d pmi=0x%08x;pmq=0x%08x;iqcm=0x%08x;\n",
6122 ahp
->ah_CalSamples
, i
, ahp
->ah_totalPowerMeasI
[i
],
6123 ahp
->ah_totalPowerMeasQ
[i
],
6124 ahp
->ah_totalIqCorrMeas
[i
]);
6128 static void ath9k_hw_adc_gaincal_collect(struct ath_hal
*ah
)
6130 struct ath_hal_5416
*ahp
= AH5416(ah
);
6133 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
6134 ahp
->ah_totalAdcIOddPhase
[i
] +=
6135 REG_READ(ah
, AR_PHY_CAL_MEAS_0(i
));
6136 ahp
->ah_totalAdcIEvenPhase
[i
] +=
6137 REG_READ(ah
, AR_PHY_CAL_MEAS_1(i
));
6138 ahp
->ah_totalAdcQOddPhase
[i
] +=
6139 REG_READ(ah
, AR_PHY_CAL_MEAS_2(i
));
6140 ahp
->ah_totalAdcQEvenPhase
[i
] +=
6141 REG_READ(ah
, AR_PHY_CAL_MEAS_3(i
));
6143 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6144 "%d: Chn %d oddi=0x%08x; eveni=0x%08x; "
6145 "oddq=0x%08x; evenq=0x%08x;\n",
6146 ahp
->ah_CalSamples
, i
,
6147 ahp
->ah_totalAdcIOddPhase
[i
],
6148 ahp
->ah_totalAdcIEvenPhase
[i
],
6149 ahp
->ah_totalAdcQOddPhase
[i
],
6150 ahp
->ah_totalAdcQEvenPhase
[i
]);
6154 static void ath9k_hw_adc_dccal_collect(struct ath_hal
*ah
)
6156 struct ath_hal_5416
*ahp
= AH5416(ah
);
6159 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
6160 ahp
->ah_totalAdcDcOffsetIOddPhase
[i
] +=
6161 (int32_t) REG_READ(ah
, AR_PHY_CAL_MEAS_0(i
));
6162 ahp
->ah_totalAdcDcOffsetIEvenPhase
[i
] +=
6163 (int32_t) REG_READ(ah
, AR_PHY_CAL_MEAS_1(i
));
6164 ahp
->ah_totalAdcDcOffsetQOddPhase
[i
] +=
6165 (int32_t) REG_READ(ah
, AR_PHY_CAL_MEAS_2(i
));
6166 ahp
->ah_totalAdcDcOffsetQEvenPhase
[i
] +=
6167 (int32_t) REG_READ(ah
, AR_PHY_CAL_MEAS_3(i
));
6169 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6170 "%d: Chn %d oddi=0x%08x; eveni=0x%08x; "
6171 "oddq=0x%08x; evenq=0x%08x;\n",
6172 ahp
->ah_CalSamples
, i
,
6173 ahp
->ah_totalAdcDcOffsetIOddPhase
[i
],
6174 ahp
->ah_totalAdcDcOffsetIEvenPhase
[i
],
6175 ahp
->ah_totalAdcDcOffsetQOddPhase
[i
],
6176 ahp
->ah_totalAdcDcOffsetQEvenPhase
[i
]);
6180 static void ath9k_hw_iqcalibrate(struct ath_hal
*ah
, u8 numChains
)
6182 struct ath_hal_5416
*ahp
= AH5416(ah
);
6183 u32 powerMeasQ
, powerMeasI
, iqCorrMeas
;
6184 u32 qCoffDenom
, iCoffDenom
;
6185 int32_t qCoff
, iCoff
;
6188 for (i
= 0; i
< numChains
; i
++) {
6189 powerMeasI
= ahp
->ah_totalPowerMeasI
[i
];
6190 powerMeasQ
= ahp
->ah_totalPowerMeasQ
[i
];
6191 iqCorrMeas
= ahp
->ah_totalIqCorrMeas
[i
];
6193 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6194 "Starting IQ Cal and Correction for Chain %d\n",
6197 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6198 "Orignal: Chn %diq_corr_meas = 0x%08x\n",
6199 i
, ahp
->ah_totalIqCorrMeas
[i
]);
6204 if (iqCorrMeas
> 0x80000000) {
6205 iqCorrMeas
= (0xffffffff - iqCorrMeas
) + 1;
6209 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6210 "Chn %d pwr_meas_i = 0x%08x\n", i
, powerMeasI
);
6211 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6212 "Chn %d pwr_meas_q = 0x%08x\n", i
, powerMeasQ
);
6213 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
, "iqCorrNeg is 0x%08x\n",
6216 iCoffDenom
= (powerMeasI
/ 2 + powerMeasQ
/ 2) / 128;
6217 qCoffDenom
= powerMeasQ
/ 64;
6219 if (powerMeasQ
!= 0) {
6221 iCoff
= iqCorrMeas
/ iCoffDenom
;
6222 qCoff
= powerMeasI
/ qCoffDenom
- 64;
6223 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6224 "Chn %d iCoff = 0x%08x\n", i
, iCoff
);
6225 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6226 "Chn %d qCoff = 0x%08x\n", i
, qCoff
);
6229 iCoff
= iCoff
& 0x3f;
6230 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6231 "New: Chn %d iCoff = 0x%08x\n", i
, iCoff
);
6232 if (iqCorrNeg
== 0x0)
6233 iCoff
= 0x40 - iCoff
;
6237 else if (qCoff
<= -16)
6240 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6241 "Chn %d : iCoff = 0x%x qCoff = 0x%x\n",
6244 REG_RMW_FIELD(ah
, AR_PHY_TIMING_CTRL4(i
),
6245 AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF
,
6247 REG_RMW_FIELD(ah
, AR_PHY_TIMING_CTRL4(i
),
6248 AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF
,
6250 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6251 "IQ Cal and Correction done for Chain %d\n",
6256 REG_SET_BIT(ah
, AR_PHY_TIMING_CTRL4(0),
6257 AR_PHY_TIMING_CTRL4_IQCORR_ENABLE
);
6261 ath9k_hw_adc_gaincal_calibrate(struct ath_hal
*ah
, u8 numChains
)
6263 struct ath_hal_5416
*ahp
= AH5416(ah
);
6264 u32 iOddMeasOffset
, iEvenMeasOffset
, qOddMeasOffset
,
6266 u32 qGainMismatch
, iGainMismatch
, val
, i
;
6268 for (i
= 0; i
< numChains
; i
++) {
6269 iOddMeasOffset
= ahp
->ah_totalAdcIOddPhase
[i
];
6270 iEvenMeasOffset
= ahp
->ah_totalAdcIEvenPhase
[i
];
6271 qOddMeasOffset
= ahp
->ah_totalAdcQOddPhase
[i
];
6272 qEvenMeasOffset
= ahp
->ah_totalAdcQEvenPhase
[i
];
6274 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6275 "Starting ADC Gain Cal for Chain %d\n", i
);
6277 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6278 "Chn %d pwr_meas_odd_i = 0x%08x\n", i
,
6280 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6281 "Chn %d pwr_meas_even_i = 0x%08x\n", i
,
6283 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6284 "Chn %d pwr_meas_odd_q = 0x%08x\n", i
,
6286 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6287 "Chn %d pwr_meas_even_q = 0x%08x\n", i
,
6290 if (iOddMeasOffset
!= 0 && qEvenMeasOffset
!= 0) {
6292 ((iEvenMeasOffset
* 32) /
6293 iOddMeasOffset
) & 0x3f;
6295 ((qOddMeasOffset
* 32) /
6296 qEvenMeasOffset
) & 0x3f;
6298 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6299 "Chn %d gain_mismatch_i = 0x%08x\n", i
,
6301 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6302 "Chn %d gain_mismatch_q = 0x%08x\n", i
,
6305 val
= REG_READ(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(i
));
6307 val
|= (qGainMismatch
) | (iGainMismatch
<< 6);
6308 REG_WRITE(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(i
), val
);
6310 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6311 "ADC Gain Cal done for Chain %d\n", i
);
6315 REG_WRITE(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(0),
6316 REG_READ(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(0)) |
6317 AR_PHY_NEW_ADC_GAIN_CORR_ENABLE
);
6321 ath9k_hw_adc_dccal_calibrate(struct ath_hal
*ah
, u8 numChains
)
6323 struct ath_hal_5416
*ahp
= AH5416(ah
);
6324 u32 iOddMeasOffset
, iEvenMeasOffset
, val
, i
;
6325 int32_t qOddMeasOffset
, qEvenMeasOffset
, qDcMismatch
, iDcMismatch
;
6326 const struct hal_percal_data
*calData
=
6327 ahp
->ah_cal_list_curr
->calData
;
6329 (1 << (calData
->calCountMax
+ 5)) * calData
->calNumSamples
;
6331 for (i
= 0; i
< numChains
; i
++) {
6332 iOddMeasOffset
= ahp
->ah_totalAdcDcOffsetIOddPhase
[i
];
6333 iEvenMeasOffset
= ahp
->ah_totalAdcDcOffsetIEvenPhase
[i
];
6334 qOddMeasOffset
= ahp
->ah_totalAdcDcOffsetQOddPhase
[i
];
6335 qEvenMeasOffset
= ahp
->ah_totalAdcDcOffsetQEvenPhase
[i
];
6337 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6338 "Starting ADC DC Offset Cal for Chain %d\n", i
);
6340 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6341 "Chn %d pwr_meas_odd_i = %d\n", i
,
6343 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6344 "Chn %d pwr_meas_even_i = %d\n", i
,
6346 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6347 "Chn %d pwr_meas_odd_q = %d\n", i
,
6349 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6350 "Chn %d pwr_meas_even_q = %d\n", i
,
6353 iDcMismatch
= (((iEvenMeasOffset
- iOddMeasOffset
) * 2) /
6354 numSamples
) & 0x1ff;
6355 qDcMismatch
= (((qOddMeasOffset
- qEvenMeasOffset
) * 2) /
6356 numSamples
) & 0x1ff;
6358 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6359 "Chn %d dc_offset_mismatch_i = 0x%08x\n", i
,
6361 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6362 "Chn %d dc_offset_mismatch_q = 0x%08x\n", i
,
6365 val
= REG_READ(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(i
));
6367 val
|= (qDcMismatch
<< 12) | (iDcMismatch
<< 21);
6368 REG_WRITE(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(i
), val
);
6370 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6371 "ADC DC Offset Cal done for Chain %d\n", i
);
6374 REG_WRITE(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(0),
6375 REG_READ(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(0)) |
6376 AR_PHY_NEW_ADC_DC_OFFSET_CORR_ENABLE
);
6379 bool ath9k_hw_set_txpowerlimit(struct ath_hal
*ah
, u32 limit
)
6381 struct ath_hal_5416
*ahp
= AH5416(ah
);
6382 struct ath9k_channel
*chan
= ah
->ah_curchan
;
6384 ah
->ah_powerLimit
= min(limit
, (u32
) MAX_RATE_POWER
);
6386 if (ath9k_hw_set_txpower(ah
, &ahp
->ah_eeprom
, chan
,
6387 ath9k_regd_get_ctl(ah
, chan
),
6388 ath9k_regd_get_antenna_allowed(ah
,
6390 chan
->maxRegTxPower
* 2,
6391 min((u32
) MAX_RATE_POWER
,
6392 (u32
) ah
->ah_powerLimit
)) != 0)
6399 ath9k_hw_get_channel_centers(struct ath_hal
*ah
,
6400 struct ath9k_channel
*chan
,
6401 struct chan_centers
*centers
)
6404 struct ath_hal_5416
*ahp
= AH5416(ah
);
6406 if (!IS_CHAN_HT40(chan
)) {
6407 centers
->ctl_center
= centers
->ext_center
=
6408 centers
->synth_center
= chan
->channel
;
6412 if ((chan
->chanmode
== CHANNEL_A_HT40PLUS
) ||
6413 (chan
->chanmode
== CHANNEL_G_HT40PLUS
)) {
6414 centers
->synth_center
=
6415 chan
->channel
+ HT40_CHANNEL_CENTER_SHIFT
;
6418 centers
->synth_center
=
6419 chan
->channel
- HT40_CHANNEL_CENTER_SHIFT
;
6423 centers
->ctl_center
= centers
->synth_center
- (extoff
*
6424 HT40_CHANNEL_CENTER_SHIFT
);
6425 centers
->ext_center
= centers
->synth_center
+ (extoff
*
6429 ATH9K_HT_EXTPROTSPACING_20
)
6431 HT40_CHANNEL_CENTER_SHIFT
6437 ath9k_hw_reset_calvalid(struct ath_hal
*ah
, struct ath9k_channel
*chan
,
6440 struct ath_hal_5416
*ahp
= AH5416(ah
);
6441 struct ath9k_channel
*ichan
=
6442 ath9k_regd_check_channel(ah
, chan
);
6443 struct hal_cal_list
*currCal
= ahp
->ah_cal_list_curr
;
6447 if (!AR_SREV_9100(ah
) && !AR_SREV_9160_10_OR_LATER(ah
))
6450 if (currCal
== NULL
)
6453 if (ichan
== NULL
) {
6454 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6455 "%s: invalid channel %u/0x%x; no mapping\n",
6456 __func__
, chan
->channel
, chan
->channelFlags
);
6461 if (currCal
->calState
!= CAL_DONE
) {
6462 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6463 "%s: Calibration state incorrect, %d\n",
6464 __func__
, currCal
->calState
);
6469 if (!ath9k_hw_iscal_supported(ah
, chan
, currCal
->calData
->calType
))
6472 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6473 "%s: Resetting Cal %d state for channel %u/0x%x\n",
6474 __func__
, currCal
->calData
->calType
, chan
->channel
,
6475 chan
->channelFlags
);
6477 ichan
->CalValid
&= ~currCal
->calData
->calType
;
6478 currCal
->calState
= CAL_WAITING
;
6483 void ath9k_hw_getmac(struct ath_hal
*ah
, u8
*mac
)
6485 struct ath_hal_5416
*ahp
= AH5416(ah
);
6487 memcpy(mac
, ahp
->ah_macaddr
, ETH_ALEN
);
6490 bool ath9k_hw_setmac(struct ath_hal
*ah
, const u8
*mac
)
6492 struct ath_hal_5416
*ahp
= AH5416(ah
);
6494 memcpy(ahp
->ah_macaddr
, mac
, ETH_ALEN
);
6498 void ath9k_hw_getbssidmask(struct ath_hal
*ah
, u8
*mask
)
6500 struct ath_hal_5416
*ahp
= AH5416(ah
);
6502 memcpy(mask
, ahp
->ah_bssidmask
, ETH_ALEN
);
6506 ath9k_hw_setbssidmask(struct ath_hal
*ah
, const u8
*mask
)
6508 struct ath_hal_5416
*ahp
= AH5416(ah
);
6510 memcpy(ahp
->ah_bssidmask
, mask
, ETH_ALEN
);
6512 REG_WRITE(ah
, AR_BSSMSKL
, get_unaligned_le32(ahp
->ah_bssidmask
));
6513 REG_WRITE(ah
, AR_BSSMSKU
, get_unaligned_le16(ahp
->ah_bssidmask
+ 4));
6518 #ifdef CONFIG_ATH9K_RFKILL
6519 static void ath9k_enable_rfkill(struct ath_hal
*ah
)
6521 struct ath_hal_5416
*ahp
= AH5416(ah
);
6523 REG_SET_BIT(ah
, AR_GPIO_INPUT_EN_VAL
,
6524 AR_GPIO_INPUT_EN_VAL_RFSILENT_BB
);
6526 REG_CLR_BIT(ah
, AR_GPIO_INPUT_MUX2
,
6527 AR_GPIO_INPUT_MUX2_RFSILENT
);
6529 ath9k_hw_cfg_gpio_input(ah
, ahp
->ah_gpioSelect
);
6530 REG_SET_BIT(ah
, AR_PHY_TEST
, RFSILENT_BB
);
6532 if (ahp
->ah_gpioBit
== ath9k_hw_gpio_get(ah
, ahp
->ah_gpioSelect
)) {
6534 ath9k_hw_set_gpio_intr(ah
, ahp
->ah_gpioSelect
,
6537 ath9k_hw_set_gpio_intr(ah
, ahp
->ah_gpioSelect
,
6544 ath9k_hw_write_associd(struct ath_hal
*ah
, const u8
*bssid
,
6547 struct ath_hal_5416
*ahp
= AH5416(ah
);
6549 memcpy(ahp
->ah_bssid
, bssid
, ETH_ALEN
);
6550 ahp
->ah_assocId
= assocId
;
6552 REG_WRITE(ah
, AR_BSS_ID0
, get_unaligned_le32(ahp
->ah_bssid
));
6553 REG_WRITE(ah
, AR_BSS_ID1
, get_unaligned_le16(ahp
->ah_bssid
+ 4) |
6554 ((assocId
& 0x3fff) << AR_BSS_ID1_AID_S
));
6557 u64
ath9k_hw_gettsf64(struct ath_hal
*ah
)
6561 tsf
= REG_READ(ah
, AR_TSF_U32
);
6562 tsf
= (tsf
<< 32) | REG_READ(ah
, AR_TSF_L32
);
6566 void ath9k_hw_reset_tsf(struct ath_hal
*ah
)
6571 while (REG_READ(ah
, AR_SLP32_MODE
) & AR_SLP32_TSF_WRITE_STATUS
) {
6574 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
6575 "%s: AR_SLP32_TSF_WRITE_STATUS limit exceeded\n",
6581 REG_WRITE(ah
, AR_RESET_TSF
, AR_RESET_TSF_ONCE
);
6584 u32
ath9k_hw_getdefantenna(struct ath_hal
*ah
)
6586 return REG_READ(ah
, AR_DEF_ANTENNA
) & 0x7;
6589 void ath9k_hw_setantenna(struct ath_hal
*ah
, u32 antenna
)
6591 REG_WRITE(ah
, AR_DEF_ANTENNA
, (antenna
& 0x7));
6595 ath9k_hw_setantennaswitch(struct ath_hal
*ah
,
6596 enum ath9k_ant_setting settings
,
6597 struct ath9k_channel
*chan
,
6602 struct ath_hal_5416
*ahp
= AH5416(ah
);
6603 static u8 tx_chainmask_cfg
, rx_chainmask_cfg
;
6605 if (AR_SREV_9280(ah
)) {
6606 if (!tx_chainmask_cfg
) {
6608 tx_chainmask_cfg
= *tx_chainmask
;
6609 rx_chainmask_cfg
= *rx_chainmask
;
6613 case ATH9K_ANT_FIXED_A
:
6614 *tx_chainmask
= ATH9K_ANTENNA0_CHAINMASK
;
6615 *rx_chainmask
= ATH9K_ANTENNA0_CHAINMASK
;
6616 *antenna_cfgd
= true;
6618 case ATH9K_ANT_FIXED_B
:
6619 if (ah
->ah_caps
.tx_chainmask
>
6620 ATH9K_ANTENNA1_CHAINMASK
) {
6621 *tx_chainmask
= ATH9K_ANTENNA1_CHAINMASK
;
6623 *rx_chainmask
= ATH9K_ANTENNA1_CHAINMASK
;
6624 *antenna_cfgd
= true;
6626 case ATH9K_ANT_VARIABLE
:
6627 *tx_chainmask
= tx_chainmask_cfg
;
6628 *rx_chainmask
= rx_chainmask_cfg
;
6629 *antenna_cfgd
= true;
6635 ahp
->ah_diversityControl
= settings
;
6641 void ath9k_hw_setopmode(struct ath_hal
*ah
)
6643 ath9k_hw_set_operating_mode(ah
, ah
->ah_opmode
);
6647 ath9k_hw_getcapability(struct ath_hal
*ah
, enum ath9k_capability_type type
,
6648 u32 capability
, u32
*result
)
6650 struct ath_hal_5416
*ahp
= AH5416(ah
);
6651 const struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
6654 case ATH9K_CAP_CIPHER
:
6655 switch (capability
) {
6656 case ATH9K_CIPHER_AES_CCM
:
6657 case ATH9K_CIPHER_AES_OCB
:
6658 case ATH9K_CIPHER_TKIP
:
6659 case ATH9K_CIPHER_WEP
:
6660 case ATH9K_CIPHER_MIC
:
6661 case ATH9K_CIPHER_CLR
:
6666 case ATH9K_CAP_TKIP_MIC
:
6667 switch (capability
) {
6671 return (ahp
->ah_staId1Defaults
&
6672 AR_STA_ID1_CRPT_MIC_ENABLE
) ? true :
6675 case ATH9K_CAP_TKIP_SPLIT
:
6676 return (ahp
->ah_miscMode
& AR_PCU_MIC_NEW_LOC_ENA
) ?
6678 case ATH9K_CAP_WME_TKIPMIC
:
6680 case ATH9K_CAP_PHYCOUNTERS
:
6681 return ahp
->ah_hasHwPhyCounters
? 0 : -ENXIO
;
6682 case ATH9K_CAP_DIVERSITY
:
6683 return (REG_READ(ah
, AR_PHY_CCK_DETECT
) &
6684 AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV
) ?
6686 case ATH9K_CAP_PHYDIAG
:
6688 case ATH9K_CAP_MCAST_KEYSRCH
:
6689 switch (capability
) {
6693 if (REG_READ(ah
, AR_STA_ID1
) & AR_STA_ID1_ADHOC
) {
6696 return (ahp
->ah_staId1Defaults
&
6697 AR_STA_ID1_MCAST_KSRCH
) ? true :
6702 case ATH9K_CAP_TSF_ADJUST
:
6703 return (ahp
->ah_miscMode
& AR_PCU_TX_ADD_TSF
) ?
6705 case ATH9K_CAP_RFSILENT
:
6706 if (capability
== 3)
6708 case ATH9K_CAP_ANT_CFG_2GHZ
:
6709 *result
= pCap
->num_antcfg_2ghz
;
6711 case ATH9K_CAP_ANT_CFG_5GHZ
:
6712 *result
= pCap
->num_antcfg_5ghz
;
6714 case ATH9K_CAP_TXPOW
:
6715 switch (capability
) {
6719 *result
= ah
->ah_powerLimit
;
6722 *result
= ah
->ah_maxPowerLevel
;
6725 *result
= ah
->ah_tpScale
;
6735 ath9k_hw_select_antconfig(struct ath_hal
*ah
, u32 cfg
)
6737 struct ath_hal_5416
*ahp
= AH5416(ah
);
6738 struct ath9k_channel
*chan
= ah
->ah_curchan
;
6739 const struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
6741 u32 halNumAntConfig
;
6744 IS_CHAN_2GHZ(chan
) ? pCap
->num_antcfg_2ghz
: pCap
->
6747 if (cfg
< halNumAntConfig
) {
6748 if (!ath9k_hw_get_eeprom_antenna_cfg(ahp
, chan
,
6749 cfg
, &ant_config
)) {
6750 REG_WRITE(ah
, AR_PHY_SWITCH_COM
, ant_config
);
6758 bool ath9k_hw_intrpend(struct ath_hal
*ah
)
6762 if (AR_SREV_9100(ah
))
6765 host_isr
= REG_READ(ah
, AR_INTR_ASYNC_CAUSE
);
6766 if ((host_isr
& AR_INTR_MAC_IRQ
) && (host_isr
!= AR_INTR_SPURIOUS
))
6769 host_isr
= REG_READ(ah
, AR_INTR_SYNC_CAUSE
);
6770 if ((host_isr
& AR_INTR_SYNC_DEFAULT
)
6771 && (host_isr
!= AR_INTR_SPURIOUS
))
6777 bool ath9k_hw_getisr(struct ath_hal
*ah
, enum ath9k_int
*masked
)
6781 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
6783 bool fatal_int
= false;
6785 if (!AR_SREV_9100(ah
)) {
6786 if (REG_READ(ah
, AR_INTR_ASYNC_CAUSE
) & AR_INTR_MAC_IRQ
) {
6787 if ((REG_READ(ah
, AR_RTC_STATUS
) & AR_RTC_STATUS_M
)
6788 == AR_RTC_STATUS_ON
) {
6789 isr
= REG_READ(ah
, AR_ISR
);
6795 AR_INTR_SYNC_CAUSE
) & AR_INTR_SYNC_DEFAULT
;
6799 if (!isr
&& !sync_cause
)
6803 isr
= REG_READ(ah
, AR_ISR
);
6807 struct ath_hal_5416
*ahp
= AH5416(ah
);
6809 if (isr
& AR_ISR_BCNMISC
) {
6811 isr2
= REG_READ(ah
, AR_ISR_S2
);
6812 if (isr2
& AR_ISR_S2_TIM
)
6813 mask2
|= ATH9K_INT_TIM
;
6814 if (isr2
& AR_ISR_S2_DTIM
)
6815 mask2
|= ATH9K_INT_DTIM
;
6816 if (isr2
& AR_ISR_S2_DTIMSYNC
)
6817 mask2
|= ATH9K_INT_DTIMSYNC
;
6818 if (isr2
& (AR_ISR_S2_CABEND
))
6819 mask2
|= ATH9K_INT_CABEND
;
6820 if (isr2
& AR_ISR_S2_GTT
)
6821 mask2
|= ATH9K_INT_GTT
;
6822 if (isr2
& AR_ISR_S2_CST
)
6823 mask2
|= ATH9K_INT_CST
;
6826 isr
= REG_READ(ah
, AR_ISR_RAC
);
6827 if (isr
== 0xffffffff) {
6832 *masked
= isr
& ATH9K_INT_COMMON
;
6834 if (ahp
->ah_intrMitigation
) {
6836 if (isr
& (AR_ISR_RXMINTR
| AR_ISR_RXINTM
))
6837 *masked
|= ATH9K_INT_RX
;
6840 if (isr
& (AR_ISR_RXOK
| AR_ISR_RXERR
))
6841 *masked
|= ATH9K_INT_RX
;
6843 (AR_ISR_TXOK
| AR_ISR_TXDESC
| AR_ISR_TXERR
|
6847 *masked
|= ATH9K_INT_TX
;
6849 s0_s
= REG_READ(ah
, AR_ISR_S0_S
);
6850 ahp
->ah_intrTxqs
|= MS(s0_s
, AR_ISR_S0_QCU_TXOK
);
6851 ahp
->ah_intrTxqs
|= MS(s0_s
, AR_ISR_S0_QCU_TXDESC
);
6853 s1_s
= REG_READ(ah
, AR_ISR_S1_S
);
6854 ahp
->ah_intrTxqs
|= MS(s1_s
, AR_ISR_S1_QCU_TXERR
);
6855 ahp
->ah_intrTxqs
|= MS(s1_s
, AR_ISR_S1_QCU_TXEOL
);
6858 if (isr
& AR_ISR_RXORN
) {
6859 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
6860 "%s: receive FIFO overrun interrupt\n",
6864 if (!AR_SREV_9100(ah
)) {
6865 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)) {
6866 u32 isr5
= REG_READ(ah
, AR_ISR_S5_S
);
6867 if (isr5
& AR_ISR_S5_TIM_TIMER
)
6868 *masked
|= ATH9K_INT_TIM_TIMER
;
6874 if (AR_SREV_9100(ah
))
6879 (AR_INTR_SYNC_HOST1_FATAL
| AR_INTR_SYNC_HOST1_PERR
))
6883 if (sync_cause
& AR_INTR_SYNC_HOST1_FATAL
) {
6884 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
6885 "%s: received PCI FATAL interrupt\n",
6888 if (sync_cause
& AR_INTR_SYNC_HOST1_PERR
) {
6889 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
6890 "%s: received PCI PERR interrupt\n",
6894 if (sync_cause
& AR_INTR_SYNC_RADM_CPL_TIMEOUT
) {
6895 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
6896 "%s: AR_INTR_SYNC_RADM_CPL_TIMEOUT\n",
6898 REG_WRITE(ah
, AR_RC
, AR_RC_HOSTIF
);
6899 REG_WRITE(ah
, AR_RC
, 0);
6900 *masked
|= ATH9K_INT_FATAL
;
6902 if (sync_cause
& AR_INTR_SYNC_LOCAL_TIMEOUT
) {
6903 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
6904 "%s: AR_INTR_SYNC_LOCAL_TIMEOUT\n",
6908 REG_WRITE(ah
, AR_INTR_SYNC_CAUSE_CLR
, sync_cause
);
6909 (void) REG_READ(ah
, AR_INTR_SYNC_CAUSE_CLR
);
6914 enum ath9k_int
ath9k_hw_intrget(struct ath_hal
*ah
)
6916 return AH5416(ah
)->ah_maskReg
;
6919 enum ath9k_int
ath9k_hw_set_interrupts(struct ath_hal
*ah
, enum ath9k_int ints
)
6921 struct ath_hal_5416
*ahp
= AH5416(ah
);
6922 u32 omask
= ahp
->ah_maskReg
;
6924 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
6926 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "%s: 0x%x => 0x%x\n", __func__
,
6929 if (omask
& ATH9K_INT_GLOBAL
) {
6930 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "%s: disable IER\n",
6932 REG_WRITE(ah
, AR_IER
, AR_IER_DISABLE
);
6933 (void) REG_READ(ah
, AR_IER
);
6934 if (!AR_SREV_9100(ah
)) {
6935 REG_WRITE(ah
, AR_INTR_ASYNC_ENABLE
, 0);
6936 (void) REG_READ(ah
, AR_INTR_ASYNC_ENABLE
);
6938 REG_WRITE(ah
, AR_INTR_SYNC_ENABLE
, 0);
6939 (void) REG_READ(ah
, AR_INTR_SYNC_ENABLE
);
6943 mask
= ints
& ATH9K_INT_COMMON
;
6946 if (ints
& ATH9K_INT_TX
) {
6947 if (ahp
->ah_txOkInterruptMask
)
6948 mask
|= AR_IMR_TXOK
;
6949 if (ahp
->ah_txDescInterruptMask
)
6950 mask
|= AR_IMR_TXDESC
;
6951 if (ahp
->ah_txErrInterruptMask
)
6952 mask
|= AR_IMR_TXERR
;
6953 if (ahp
->ah_txEolInterruptMask
)
6954 mask
|= AR_IMR_TXEOL
;
6956 if (ints
& ATH9K_INT_RX
) {
6957 mask
|= AR_IMR_RXERR
;
6958 if (ahp
->ah_intrMitigation
)
6959 mask
|= AR_IMR_RXMINTR
| AR_IMR_RXINTM
;
6961 mask
|= AR_IMR_RXOK
| AR_IMR_RXDESC
;
6962 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
))
6963 mask
|= AR_IMR_GENTMR
;
6966 if (ints
& (ATH9K_INT_BMISC
)) {
6967 mask
|= AR_IMR_BCNMISC
;
6968 if (ints
& ATH9K_INT_TIM
)
6969 mask2
|= AR_IMR_S2_TIM
;
6970 if (ints
& ATH9K_INT_DTIM
)
6971 mask2
|= AR_IMR_S2_DTIM
;
6972 if (ints
& ATH9K_INT_DTIMSYNC
)
6973 mask2
|= AR_IMR_S2_DTIMSYNC
;
6974 if (ints
& ATH9K_INT_CABEND
)
6975 mask2
|= (AR_IMR_S2_CABEND
);
6978 if (ints
& (ATH9K_INT_GTT
| ATH9K_INT_CST
)) {
6979 mask
|= AR_IMR_BCNMISC
;
6980 if (ints
& ATH9K_INT_GTT
)
6981 mask2
|= AR_IMR_S2_GTT
;
6982 if (ints
& ATH9K_INT_CST
)
6983 mask2
|= AR_IMR_S2_CST
;
6986 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "%s: new IMR 0x%x\n", __func__
,
6988 REG_WRITE(ah
, AR_IMR
, mask
);
6989 mask
= REG_READ(ah
, AR_IMR_S2
) & ~(AR_IMR_S2_TIM
|
6991 AR_IMR_S2_DTIMSYNC
|
6995 AR_IMR_S2_GTT
| AR_IMR_S2_CST
);
6996 REG_WRITE(ah
, AR_IMR_S2
, mask
| mask2
);
6997 ahp
->ah_maskReg
= ints
;
6999 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)) {
7000 if (ints
& ATH9K_INT_TIM_TIMER
)
7001 REG_SET_BIT(ah
, AR_IMR_S5
, AR_IMR_S5_TIM_TIMER
);
7003 REG_CLR_BIT(ah
, AR_IMR_S5
, AR_IMR_S5_TIM_TIMER
);
7006 if (ints
& ATH9K_INT_GLOBAL
) {
7007 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "%s: enable IER\n",
7009 REG_WRITE(ah
, AR_IER
, AR_IER_ENABLE
);
7010 if (!AR_SREV_9100(ah
)) {
7011 REG_WRITE(ah
, AR_INTR_ASYNC_ENABLE
,
7013 REG_WRITE(ah
, AR_INTR_ASYNC_MASK
, AR_INTR_MAC_IRQ
);
7016 REG_WRITE(ah
, AR_INTR_SYNC_ENABLE
,
7017 AR_INTR_SYNC_DEFAULT
);
7018 REG_WRITE(ah
, AR_INTR_SYNC_MASK
,
7019 AR_INTR_SYNC_DEFAULT
);
7021 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "AR_IMR 0x%x IER 0x%x\n",
7022 REG_READ(ah
, AR_IMR
), REG_READ(ah
, AR_IER
));
7029 ath9k_hw_beaconinit(struct ath_hal
*ah
,
7030 u32 next_beacon
, u32 beacon_period
)
7032 struct ath_hal_5416
*ahp
= AH5416(ah
);
7035 ahp
->ah_beaconInterval
= beacon_period
;
7037 switch (ah
->ah_opmode
) {
7039 case ATH9K_M_MONITOR
:
7040 REG_WRITE(ah
, AR_NEXT_TBTT_TIMER
, TU_TO_USEC(next_beacon
));
7041 REG_WRITE(ah
, AR_NEXT_DMA_BEACON_ALERT
, 0xffff);
7042 REG_WRITE(ah
, AR_NEXT_SWBA
, 0x7ffff);
7043 flags
|= AR_TBTT_TIMER_EN
;
7046 REG_SET_BIT(ah
, AR_TXCFG
,
7047 AR_TXCFG_ADHOC_BEACON_ATIM_TX_POLICY
);
7048 REG_WRITE(ah
, AR_NEXT_NDP_TIMER
,
7049 TU_TO_USEC(next_beacon
+
7050 (ahp
->ah_atimWindow
? ahp
->
7051 ah_atimWindow
: 1)));
7052 flags
|= AR_NDP_TIMER_EN
;
7053 case ATH9K_M_HOSTAP
:
7054 REG_WRITE(ah
, AR_NEXT_TBTT_TIMER
, TU_TO_USEC(next_beacon
));
7055 REG_WRITE(ah
, AR_NEXT_DMA_BEACON_ALERT
,
7056 TU_TO_USEC(next_beacon
-
7058 dma_beacon_response_time
));
7059 REG_WRITE(ah
, AR_NEXT_SWBA
,
7060 TU_TO_USEC(next_beacon
-
7062 sw_beacon_response_time
));
7064 AR_TBTT_TIMER_EN
| AR_DBA_TIMER_EN
| AR_SWBA_TIMER_EN
;
7068 REG_WRITE(ah
, AR_BEACON_PERIOD
, TU_TO_USEC(beacon_period
));
7069 REG_WRITE(ah
, AR_DMA_BEACON_PERIOD
, TU_TO_USEC(beacon_period
));
7070 REG_WRITE(ah
, AR_SWBA_PERIOD
, TU_TO_USEC(beacon_period
));
7071 REG_WRITE(ah
, AR_NDP_PERIOD
, TU_TO_USEC(beacon_period
));
7073 beacon_period
&= ~ATH9K_BEACON_ENA
;
7074 if (beacon_period
& ATH9K_BEACON_RESET_TSF
) {
7075 beacon_period
&= ~ATH9K_BEACON_RESET_TSF
;
7076 ath9k_hw_reset_tsf(ah
);
7079 REG_SET_BIT(ah
, AR_TIMER_MODE
, flags
);
7083 ath9k_hw_set_sta_beacon_timers(struct ath_hal
*ah
,
7084 const struct ath9k_beacon_state
*bs
)
7086 u32 nextTbtt
, beaconintval
, dtimperiod
, beacontimeout
;
7087 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7089 REG_WRITE(ah
, AR_NEXT_TBTT_TIMER
, TU_TO_USEC(bs
->bs_nexttbtt
));
7091 REG_WRITE(ah
, AR_BEACON_PERIOD
,
7092 TU_TO_USEC(bs
->bs_intval
& ATH9K_BEACON_PERIOD
));
7093 REG_WRITE(ah
, AR_DMA_BEACON_PERIOD
,
7094 TU_TO_USEC(bs
->bs_intval
& ATH9K_BEACON_PERIOD
));
7096 REG_RMW_FIELD(ah
, AR_RSSI_THR
,
7097 AR_RSSI_THR_BM_THR
, bs
->bs_bmissthreshold
);
7099 beaconintval
= bs
->bs_intval
& ATH9K_BEACON_PERIOD
;
7101 if (bs
->bs_sleepduration
> beaconintval
)
7102 beaconintval
= bs
->bs_sleepduration
;
7104 dtimperiod
= bs
->bs_dtimperiod
;
7105 if (bs
->bs_sleepduration
> dtimperiod
)
7106 dtimperiod
= bs
->bs_sleepduration
;
7108 if (beaconintval
== dtimperiod
)
7109 nextTbtt
= bs
->bs_nextdtim
;
7111 nextTbtt
= bs
->bs_nexttbtt
;
7113 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "%s: next DTIM %d\n", __func__
,
7115 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "%s: next beacon %d\n", __func__
,
7117 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "%s: beacon period %d\n", __func__
,
7119 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "%s: DTIM period %d\n", __func__
,
7122 REG_WRITE(ah
, AR_NEXT_DTIM
,
7123 TU_TO_USEC(bs
->bs_nextdtim
- SLEEP_SLOP
));
7124 REG_WRITE(ah
, AR_NEXT_TIM
, TU_TO_USEC(nextTbtt
- SLEEP_SLOP
));
7126 REG_WRITE(ah
, AR_SLEEP1
,
7127 SM((CAB_TIMEOUT_VAL
<< 3), AR_SLEEP1_CAB_TIMEOUT
)
7128 | AR_SLEEP1_ASSUME_DTIM
);
7130 if (pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)
7131 beacontimeout
= (BEACON_TIMEOUT_VAL
<< 3);
7133 beacontimeout
= MIN_BEACON_TIMEOUT_VAL
;
7135 REG_WRITE(ah
, AR_SLEEP2
,
7136 SM(beacontimeout
, AR_SLEEP2_BEACON_TIMEOUT
));
7138 REG_WRITE(ah
, AR_TIM_PERIOD
, TU_TO_USEC(beaconintval
));
7139 REG_WRITE(ah
, AR_DTIM_PERIOD
, TU_TO_USEC(dtimperiod
));
7141 REG_SET_BIT(ah
, AR_TIMER_MODE
,
7142 AR_TBTT_TIMER_EN
| AR_TIM_TIMER_EN
|
7147 bool ath9k_hw_keyisvalid(struct ath_hal
*ah
, u16 entry
)
7149 if (entry
< ah
->ah_caps
.keycache_size
) {
7150 u32 val
= REG_READ(ah
, AR_KEYTABLE_MAC1(entry
));
7151 if (val
& AR_KEYTABLE_VALID
)
7157 bool ath9k_hw_keyreset(struct ath_hal
*ah
, u16 entry
)
7161 if (entry
>= ah
->ah_caps
.keycache_size
) {
7162 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7163 "%s: entry %u out of range\n", __func__
, entry
);
7166 keyType
= REG_READ(ah
, AR_KEYTABLE_TYPE(entry
));
7168 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), 0);
7169 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), 0);
7170 REG_WRITE(ah
, AR_KEYTABLE_KEY2(entry
), 0);
7171 REG_WRITE(ah
, AR_KEYTABLE_KEY3(entry
), 0);
7172 REG_WRITE(ah
, AR_KEYTABLE_KEY4(entry
), 0);
7173 REG_WRITE(ah
, AR_KEYTABLE_TYPE(entry
), AR_KEYTABLE_TYPE_CLR
);
7174 REG_WRITE(ah
, AR_KEYTABLE_MAC0(entry
), 0);
7175 REG_WRITE(ah
, AR_KEYTABLE_MAC1(entry
), 0);
7177 if (keyType
== AR_KEYTABLE_TYPE_TKIP
&& ATH9K_IS_MIC_ENABLED(ah
)) {
7178 u16 micentry
= entry
+ 64;
7180 REG_WRITE(ah
, AR_KEYTABLE_KEY0(micentry
), 0);
7181 REG_WRITE(ah
, AR_KEYTABLE_KEY1(micentry
), 0);
7182 REG_WRITE(ah
, AR_KEYTABLE_KEY2(micentry
), 0);
7183 REG_WRITE(ah
, AR_KEYTABLE_KEY3(micentry
), 0);
7187 if (ah
->ah_curchan
== NULL
)
7194 ath9k_hw_keysetmac(struct ath_hal
*ah
, u16 entry
,
7199 if (entry
>= ah
->ah_caps
.keycache_size
) {
7200 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7201 "%s: entry %u out of range\n", __func__
, entry
);
7206 macHi
= (mac
[5] << 8) | mac
[4];
7207 macLo
= (mac
[3] << 24) | (mac
[2] << 16)
7208 | (mac
[1] << 8) | mac
[0];
7210 macLo
|= (macHi
& 1) << 31;
7215 REG_WRITE(ah
, AR_KEYTABLE_MAC0(entry
), macLo
);
7216 REG_WRITE(ah
, AR_KEYTABLE_MAC1(entry
), macHi
| AR_KEYTABLE_VALID
);
7222 ath9k_hw_set_keycache_entry(struct ath_hal
*ah
, u16 entry
,
7223 const struct ath9k_keyval
*k
,
7224 const u8
*mac
, int xorKey
)
7226 const struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7227 u32 key0
, key1
, key2
, key3
, key4
;
7229 u32 xorMask
= xorKey
?
7230 (ATH9K_KEY_XOR
<< 24 | ATH9K_KEY_XOR
<< 16 | ATH9K_KEY_XOR
<< 8
7231 | ATH9K_KEY_XOR
) : 0;
7232 struct ath_hal_5416
*ahp
= AH5416(ah
);
7234 if (entry
>= pCap
->keycache_size
) {
7235 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7236 "%s: entry %u out of range\n", __func__
, entry
);
7239 switch (k
->kv_type
) {
7240 case ATH9K_CIPHER_AES_OCB
:
7241 keyType
= AR_KEYTABLE_TYPE_AES
;
7243 case ATH9K_CIPHER_AES_CCM
:
7244 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_CIPHER_AESCCM
)) {
7245 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7246 "%s: AES-CCM not supported by "
7247 "mac rev 0x%x\n", __func__
,
7251 keyType
= AR_KEYTABLE_TYPE_CCM
;
7253 case ATH9K_CIPHER_TKIP
:
7254 keyType
= AR_KEYTABLE_TYPE_TKIP
;
7255 if (ATH9K_IS_MIC_ENABLED(ah
)
7256 && entry
+ 64 >= pCap
->keycache_size
) {
7257 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7258 "%s: entry %u inappropriate for TKIP\n",
7263 case ATH9K_CIPHER_WEP
:
7264 if (k
->kv_len
< 40 / NBBY
) {
7265 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7266 "%s: WEP key length %u too small\n",
7267 __func__
, k
->kv_len
);
7270 if (k
->kv_len
<= 40 / NBBY
)
7271 keyType
= AR_KEYTABLE_TYPE_40
;
7272 else if (k
->kv_len
<= 104 / NBBY
)
7273 keyType
= AR_KEYTABLE_TYPE_104
;
7275 keyType
= AR_KEYTABLE_TYPE_128
;
7277 case ATH9K_CIPHER_CLR
:
7278 keyType
= AR_KEYTABLE_TYPE_CLR
;
7281 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7282 "%s: cipher %u not supported\n", __func__
,
7287 key0
= get_unaligned_le32(k
->kv_val
+ 0) ^ xorMask
;
7288 key1
= (get_unaligned_le16(k
->kv_val
+ 4) ^ xorMask
) & 0xffff;
7289 key2
= get_unaligned_le32(k
->kv_val
+ 6) ^ xorMask
;
7290 key3
= (get_unaligned_le16(k
->kv_val
+ 10) ^ xorMask
) & 0xffff;
7291 key4
= get_unaligned_le32(k
->kv_val
+ 12) ^ xorMask
;
7292 if (k
->kv_len
<= 104 / NBBY
)
7295 if (keyType
== AR_KEYTABLE_TYPE_TKIP
&& ATH9K_IS_MIC_ENABLED(ah
)) {
7296 u16 micentry
= entry
+ 64;
7298 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), ~key0
);
7299 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), ~key1
);
7300 REG_WRITE(ah
, AR_KEYTABLE_KEY2(entry
), key2
);
7301 REG_WRITE(ah
, AR_KEYTABLE_KEY3(entry
), key3
);
7302 REG_WRITE(ah
, AR_KEYTABLE_KEY4(entry
), key4
);
7303 REG_WRITE(ah
, AR_KEYTABLE_TYPE(entry
), keyType
);
7304 (void) ath9k_hw_keysetmac(ah
, entry
, mac
);
7306 if (ahp
->ah_miscMode
& AR_PCU_MIC_NEW_LOC_ENA
) {
7307 u32 mic0
, mic1
, mic2
, mic3
, mic4
;
7309 mic0
= get_unaligned_le32(k
->kv_mic
+ 0);
7310 mic2
= get_unaligned_le32(k
->kv_mic
+ 4);
7311 mic1
= get_unaligned_le16(k
->kv_txmic
+ 2) & 0xffff;
7312 mic3
= get_unaligned_le16(k
->kv_txmic
+ 0) & 0xffff;
7313 mic4
= get_unaligned_le32(k
->kv_txmic
+ 4);
7314 REG_WRITE(ah
, AR_KEYTABLE_KEY0(micentry
), mic0
);
7315 REG_WRITE(ah
, AR_KEYTABLE_KEY1(micentry
), mic1
);
7316 REG_WRITE(ah
, AR_KEYTABLE_KEY2(micentry
), mic2
);
7317 REG_WRITE(ah
, AR_KEYTABLE_KEY3(micentry
), mic3
);
7318 REG_WRITE(ah
, AR_KEYTABLE_KEY4(micentry
), mic4
);
7319 REG_WRITE(ah
, AR_KEYTABLE_TYPE(micentry
),
7320 AR_KEYTABLE_TYPE_CLR
);
7325 mic0
= get_unaligned_le32(k
->kv_mic
+ 0);
7326 mic2
= get_unaligned_le32(k
->kv_mic
+ 4);
7327 REG_WRITE(ah
, AR_KEYTABLE_KEY0(micentry
), mic0
);
7328 REG_WRITE(ah
, AR_KEYTABLE_KEY1(micentry
), 0);
7329 REG_WRITE(ah
, AR_KEYTABLE_KEY2(micentry
), mic2
);
7330 REG_WRITE(ah
, AR_KEYTABLE_KEY3(micentry
), 0);
7331 REG_WRITE(ah
, AR_KEYTABLE_KEY4(micentry
), 0);
7332 REG_WRITE(ah
, AR_KEYTABLE_TYPE(micentry
),
7333 AR_KEYTABLE_TYPE_CLR
);
7335 REG_WRITE(ah
, AR_KEYTABLE_MAC0(micentry
), 0);
7336 REG_WRITE(ah
, AR_KEYTABLE_MAC1(micentry
), 0);
7337 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), key0
);
7338 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), key1
);
7340 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), key0
);
7341 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), key1
);
7342 REG_WRITE(ah
, AR_KEYTABLE_KEY2(entry
), key2
);
7343 REG_WRITE(ah
, AR_KEYTABLE_KEY3(entry
), key3
);
7344 REG_WRITE(ah
, AR_KEYTABLE_KEY4(entry
), key4
);
7345 REG_WRITE(ah
, AR_KEYTABLE_TYPE(entry
), keyType
);
7347 (void) ath9k_hw_keysetmac(ah
, entry
, mac
);
7350 if (ah
->ah_curchan
== NULL
)
7357 ath9k_hw_updatetxtriglevel(struct ath_hal
*ah
, bool bIncTrigLevel
)
7359 struct ath_hal_5416
*ahp
= AH5416(ah
);
7360 u32 txcfg
, curLevel
, newLevel
;
7361 enum ath9k_int omask
;
7363 if (ah
->ah_txTrigLevel
>= MAX_TX_FIFO_THRESHOLD
)
7366 omask
= ath9k_hw_set_interrupts(ah
,
7367 ahp
->ah_maskReg
& ~ATH9K_INT_GLOBAL
);
7369 txcfg
= REG_READ(ah
, AR_TXCFG
);
7370 curLevel
= MS(txcfg
, AR_FTRIG
);
7371 newLevel
= curLevel
;
7372 if (bIncTrigLevel
) {
7373 if (curLevel
< MAX_TX_FIFO_THRESHOLD
)
7375 } else if (curLevel
> MIN_TX_FIFO_THRESHOLD
)
7377 if (newLevel
!= curLevel
)
7378 REG_WRITE(ah
, AR_TXCFG
,
7379 (txcfg
& ~AR_FTRIG
) | SM(newLevel
, AR_FTRIG
));
7381 ath9k_hw_set_interrupts(ah
, omask
);
7383 ah
->ah_txTrigLevel
= newLevel
;
7385 return newLevel
!= curLevel
;
7388 bool ath9k_hw_set_txq_props(struct ath_hal
*ah
, int q
,
7389 const struct ath9k_tx_queue_info
*qinfo
)
7392 struct ath_hal_5416
*ahp
= AH5416(ah
);
7393 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7394 struct ath9k_tx_queue_info
*qi
;
7396 if (q
>= pCap
->total_queues
) {
7397 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: invalid queue num %u\n",
7402 qi
= &ahp
->ah_txq
[q
];
7403 if (qi
->tqi_type
== ATH9K_TX_QUEUE_INACTIVE
) {
7404 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: inactive queue\n",
7409 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: queue %p\n", __func__
, qi
);
7411 qi
->tqi_ver
= qinfo
->tqi_ver
;
7412 qi
->tqi_subtype
= qinfo
->tqi_subtype
;
7413 qi
->tqi_qflags
= qinfo
->tqi_qflags
;
7414 qi
->tqi_priority
= qinfo
->tqi_priority
;
7415 if (qinfo
->tqi_aifs
!= ATH9K_TXQ_USEDEFAULT
)
7416 qi
->tqi_aifs
= min(qinfo
->tqi_aifs
, 255U);
7418 qi
->tqi_aifs
= INIT_AIFS
;
7419 if (qinfo
->tqi_cwmin
!= ATH9K_TXQ_USEDEFAULT
) {
7420 cw
= min(qinfo
->tqi_cwmin
, 1024U);
7422 while (qi
->tqi_cwmin
< cw
)
7423 qi
->tqi_cwmin
= (qi
->tqi_cwmin
<< 1) | 1;
7425 qi
->tqi_cwmin
= qinfo
->tqi_cwmin
;
7426 if (qinfo
->tqi_cwmax
!= ATH9K_TXQ_USEDEFAULT
) {
7427 cw
= min(qinfo
->tqi_cwmax
, 1024U);
7429 while (qi
->tqi_cwmax
< cw
)
7430 qi
->tqi_cwmax
= (qi
->tqi_cwmax
<< 1) | 1;
7432 qi
->tqi_cwmax
= INIT_CWMAX
;
7434 if (qinfo
->tqi_shretry
!= 0)
7435 qi
->tqi_shretry
= min((u32
) qinfo
->tqi_shretry
, 15U);
7437 qi
->tqi_shretry
= INIT_SH_RETRY
;
7438 if (qinfo
->tqi_lgretry
!= 0)
7439 qi
->tqi_lgretry
= min((u32
) qinfo
->tqi_lgretry
, 15U);
7441 qi
->tqi_lgretry
= INIT_LG_RETRY
;
7442 qi
->tqi_cbrPeriod
= qinfo
->tqi_cbrPeriod
;
7443 qi
->tqi_cbrOverflowLimit
= qinfo
->tqi_cbrOverflowLimit
;
7444 qi
->tqi_burstTime
= qinfo
->tqi_burstTime
;
7445 qi
->tqi_readyTime
= qinfo
->tqi_readyTime
;
7447 switch (qinfo
->tqi_subtype
) {
7448 case ATH9K_WME_UPSD
:
7449 if (qi
->tqi_type
== ATH9K_TX_QUEUE_DATA
)
7450 qi
->tqi_intFlags
= ATH9K_TXQ_USE_LOCKOUT_BKOFF_DIS
;
7458 bool ath9k_hw_get_txq_props(struct ath_hal
*ah
, int q
,
7459 struct ath9k_tx_queue_info
*qinfo
)
7461 struct ath_hal_5416
*ahp
= AH5416(ah
);
7462 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7463 struct ath9k_tx_queue_info
*qi
;
7465 if (q
>= pCap
->total_queues
) {
7466 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: invalid queue num %u\n",
7471 qi
= &ahp
->ah_txq
[q
];
7472 if (qi
->tqi_type
== ATH9K_TX_QUEUE_INACTIVE
) {
7473 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: inactive queue\n",
7478 qinfo
->tqi_qflags
= qi
->tqi_qflags
;
7479 qinfo
->tqi_ver
= qi
->tqi_ver
;
7480 qinfo
->tqi_subtype
= qi
->tqi_subtype
;
7481 qinfo
->tqi_qflags
= qi
->tqi_qflags
;
7482 qinfo
->tqi_priority
= qi
->tqi_priority
;
7483 qinfo
->tqi_aifs
= qi
->tqi_aifs
;
7484 qinfo
->tqi_cwmin
= qi
->tqi_cwmin
;
7485 qinfo
->tqi_cwmax
= qi
->tqi_cwmax
;
7486 qinfo
->tqi_shretry
= qi
->tqi_shretry
;
7487 qinfo
->tqi_lgretry
= qi
->tqi_lgretry
;
7488 qinfo
->tqi_cbrPeriod
= qi
->tqi_cbrPeriod
;
7489 qinfo
->tqi_cbrOverflowLimit
= qi
->tqi_cbrOverflowLimit
;
7490 qinfo
->tqi_burstTime
= qi
->tqi_burstTime
;
7491 qinfo
->tqi_readyTime
= qi
->tqi_readyTime
;
7497 ath9k_hw_setuptxqueue(struct ath_hal
*ah
, enum ath9k_tx_queue type
,
7498 const struct ath9k_tx_queue_info
*qinfo
)
7500 struct ath_hal_5416
*ahp
= AH5416(ah
);
7501 struct ath9k_tx_queue_info
*qi
;
7502 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7506 case ATH9K_TX_QUEUE_BEACON
:
7507 q
= pCap
->total_queues
- 1;
7509 case ATH9K_TX_QUEUE_CAB
:
7510 q
= pCap
->total_queues
- 2;
7512 case ATH9K_TX_QUEUE_PSPOLL
:
7515 case ATH9K_TX_QUEUE_UAPSD
:
7516 q
= pCap
->total_queues
- 3;
7518 case ATH9K_TX_QUEUE_DATA
:
7519 for (q
= 0; q
< pCap
->total_queues
; q
++)
7520 if (ahp
->ah_txq
[q
].tqi_type
==
7521 ATH9K_TX_QUEUE_INACTIVE
)
7523 if (q
== pCap
->total_queues
) {
7524 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
7525 "%s: no available tx queue\n", __func__
);
7530 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: bad tx queue type %u\n",
7535 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: queue %u\n", __func__
, q
);
7537 qi
= &ahp
->ah_txq
[q
];
7538 if (qi
->tqi_type
!= ATH9K_TX_QUEUE_INACTIVE
) {
7539 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
7540 "%s: tx queue %u already active\n", __func__
, q
);
7543 memset(qi
, 0, sizeof(struct ath9k_tx_queue_info
));
7544 qi
->tqi_type
= type
;
7545 if (qinfo
== NULL
) {
7547 TXQ_FLAG_TXOKINT_ENABLE
7548 | TXQ_FLAG_TXERRINT_ENABLE
7549 | TXQ_FLAG_TXDESCINT_ENABLE
| TXQ_FLAG_TXURNINT_ENABLE
;
7550 qi
->tqi_aifs
= INIT_AIFS
;
7551 qi
->tqi_cwmin
= ATH9K_TXQ_USEDEFAULT
;
7552 qi
->tqi_cwmax
= INIT_CWMAX
;
7553 qi
->tqi_shretry
= INIT_SH_RETRY
;
7554 qi
->tqi_lgretry
= INIT_LG_RETRY
;
7555 qi
->tqi_physCompBuf
= 0;
7557 qi
->tqi_physCompBuf
= qinfo
->tqi_physCompBuf
;
7558 (void) ath9k_hw_set_txq_props(ah
, q
, qinfo
);
7565 ath9k_hw_set_txq_interrupts(struct ath_hal
*ah
,
7566 struct ath9k_tx_queue_info
*qi
)
7568 struct ath_hal_5416
*ahp
= AH5416(ah
);
7570 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
7571 "%s: tx ok 0x%x err 0x%x desc 0x%x eol 0x%x urn 0x%x\n",
7572 __func__
, ahp
->ah_txOkInterruptMask
,
7573 ahp
->ah_txErrInterruptMask
, ahp
->ah_txDescInterruptMask
,
7574 ahp
->ah_txEolInterruptMask
, ahp
->ah_txUrnInterruptMask
);
7576 REG_WRITE(ah
, AR_IMR_S0
,
7577 SM(ahp
->ah_txOkInterruptMask
, AR_IMR_S0_QCU_TXOK
)
7578 | SM(ahp
->ah_txDescInterruptMask
, AR_IMR_S0_QCU_TXDESC
));
7579 REG_WRITE(ah
, AR_IMR_S1
,
7580 SM(ahp
->ah_txErrInterruptMask
, AR_IMR_S1_QCU_TXERR
)
7581 | SM(ahp
->ah_txEolInterruptMask
, AR_IMR_S1_QCU_TXEOL
));
7582 REG_RMW_FIELD(ah
, AR_IMR_S2
,
7583 AR_IMR_S2_QCU_TXURN
, ahp
->ah_txUrnInterruptMask
);
7586 bool ath9k_hw_releasetxqueue(struct ath_hal
*ah
, u32 q
)
7588 struct ath_hal_5416
*ahp
= AH5416(ah
);
7589 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7590 struct ath9k_tx_queue_info
*qi
;
7592 if (q
>= pCap
->total_queues
) {
7593 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: invalid queue num %u\n",
7597 qi
= &ahp
->ah_txq
[q
];
7598 if (qi
->tqi_type
== ATH9K_TX_QUEUE_INACTIVE
) {
7599 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: inactive queue %u\n",
7604 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: release queue %u\n",
7607 qi
->tqi_type
= ATH9K_TX_QUEUE_INACTIVE
;
7608 ahp
->ah_txOkInterruptMask
&= ~(1 << q
);
7609 ahp
->ah_txErrInterruptMask
&= ~(1 << q
);
7610 ahp
->ah_txDescInterruptMask
&= ~(1 << q
);
7611 ahp
->ah_txEolInterruptMask
&= ~(1 << q
);
7612 ahp
->ah_txUrnInterruptMask
&= ~(1 << q
);
7613 ath9k_hw_set_txq_interrupts(ah
, qi
);
7618 bool ath9k_hw_resettxqueue(struct ath_hal
*ah
, u32 q
)
7620 struct ath_hal_5416
*ahp
= AH5416(ah
);
7621 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7622 struct ath9k_channel
*chan
= ah
->ah_curchan
;
7623 struct ath9k_tx_queue_info
*qi
;
7624 u32 cwMin
, chanCwMin
, value
;
7626 if (q
>= pCap
->total_queues
) {
7627 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: invalid queue num %u\n",
7631 qi
= &ahp
->ah_txq
[q
];
7632 if (qi
->tqi_type
== ATH9K_TX_QUEUE_INACTIVE
) {
7633 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: inactive queue %u\n",
7638 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: reset queue %u\n", __func__
, q
);
7640 if (qi
->tqi_cwmin
== ATH9K_TXQ_USEDEFAULT
) {
7641 if (chan
&& IS_CHAN_B(chan
))
7642 chanCwMin
= INIT_CWMIN_11B
;
7644 chanCwMin
= INIT_CWMIN
;
7646 for (cwMin
= 1; cwMin
< chanCwMin
; cwMin
= (cwMin
<< 1) | 1);
7648 cwMin
= qi
->tqi_cwmin
;
7650 REG_WRITE(ah
, AR_DLCL_IFS(q
), SM(cwMin
, AR_D_LCL_IFS_CWMIN
)
7651 | SM(qi
->tqi_cwmax
, AR_D_LCL_IFS_CWMAX
)
7652 | SM(qi
->tqi_aifs
, AR_D_LCL_IFS_AIFS
));
7654 REG_WRITE(ah
, AR_DRETRY_LIMIT(q
),
7655 SM(INIT_SSH_RETRY
, AR_D_RETRY_LIMIT_STA_SH
)
7656 | SM(INIT_SLG_RETRY
, AR_D_RETRY_LIMIT_STA_LG
)
7657 | SM(qi
->tqi_shretry
, AR_D_RETRY_LIMIT_FR_SH
)
7660 REG_WRITE(ah
, AR_QMISC(q
), AR_Q_MISC_DCU_EARLY_TERM_REQ
);
7661 REG_WRITE(ah
, AR_DMISC(q
),
7662 AR_D_MISC_CW_BKOFF_EN
| AR_D_MISC_FRAG_WAIT_EN
| 0x2);
7664 if (qi
->tqi_cbrPeriod
) {
7665 REG_WRITE(ah
, AR_QCBRCFG(q
),
7666 SM(qi
->tqi_cbrPeriod
, AR_Q_CBRCFG_INTERVAL
)
7667 | SM(qi
->tqi_cbrOverflowLimit
,
7668 AR_Q_CBRCFG_OVF_THRESH
));
7669 REG_WRITE(ah
, AR_QMISC(q
),
7671 AR_QMISC(q
)) | AR_Q_MISC_FSP_CBR
| (qi
->
7672 tqi_cbrOverflowLimit
7674 AR_Q_MISC_CBR_EXP_CNTR_LIMIT_EN
7678 if (qi
->tqi_readyTime
&& (qi
->tqi_type
!= ATH9K_TX_QUEUE_CAB
)) {
7679 REG_WRITE(ah
, AR_QRDYTIMECFG(q
),
7680 SM(qi
->tqi_readyTime
, AR_Q_RDYTIMECFG_DURATION
) |
7681 AR_Q_RDYTIMECFG_EN
);
7684 REG_WRITE(ah
, AR_DCHNTIME(q
),
7685 SM(qi
->tqi_burstTime
, AR_D_CHNTIME_DUR
) |
7686 (qi
->tqi_burstTime
? AR_D_CHNTIME_EN
: 0));
7688 if (qi
->tqi_burstTime
7689 && (qi
->tqi_qflags
& TXQ_FLAG_RDYTIME_EXP_POLICY_ENABLE
)) {
7690 REG_WRITE(ah
, AR_QMISC(q
),
7693 AR_Q_MISC_RDYTIME_EXP_POLICY
);
7697 if (qi
->tqi_qflags
& TXQ_FLAG_BACKOFF_DISABLE
) {
7698 REG_WRITE(ah
, AR_DMISC(q
),
7699 REG_READ(ah
, AR_DMISC(q
)) |
7700 AR_D_MISC_POST_FR_BKOFF_DIS
);
7702 if (qi
->tqi_qflags
& TXQ_FLAG_FRAG_BURST_BACKOFF_ENABLE
) {
7703 REG_WRITE(ah
, AR_DMISC(q
),
7704 REG_READ(ah
, AR_DMISC(q
)) |
7705 AR_D_MISC_FRAG_BKOFF_EN
);
7707 switch (qi
->tqi_type
) {
7708 case ATH9K_TX_QUEUE_BEACON
:
7709 REG_WRITE(ah
, AR_QMISC(q
), REG_READ(ah
, AR_QMISC(q
))
7710 | AR_Q_MISC_FSP_DBA_GATED
7711 | AR_Q_MISC_BEACON_USE
7712 | AR_Q_MISC_CBR_INCR_DIS1
);
7714 REG_WRITE(ah
, AR_DMISC(q
), REG_READ(ah
, AR_DMISC(q
))
7715 | (AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL
<<
7716 AR_D_MISC_ARB_LOCKOUT_CNTRL_S
)
7717 | AR_D_MISC_BEACON_USE
7718 | AR_D_MISC_POST_FR_BKOFF_DIS
);
7720 case ATH9K_TX_QUEUE_CAB
:
7721 REG_WRITE(ah
, AR_QMISC(q
), REG_READ(ah
, AR_QMISC(q
))
7722 | AR_Q_MISC_FSP_DBA_GATED
7723 | AR_Q_MISC_CBR_INCR_DIS1
7724 | AR_Q_MISC_CBR_INCR_DIS0
);
7725 value
= (qi
->tqi_readyTime
7726 - (ah
->ah_config
.sw_beacon_response_time
-
7727 ah
->ah_config
.dma_beacon_response_time
)
7729 ah
->ah_config
.additional_swba_backoff
) *
7731 REG_WRITE(ah
, AR_QRDYTIMECFG(q
),
7732 value
| AR_Q_RDYTIMECFG_EN
);
7733 REG_WRITE(ah
, AR_DMISC(q
), REG_READ(ah
, AR_DMISC(q
))
7734 | (AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL
<<
7735 AR_D_MISC_ARB_LOCKOUT_CNTRL_S
));
7737 case ATH9K_TX_QUEUE_PSPOLL
:
7738 REG_WRITE(ah
, AR_QMISC(q
),
7740 AR_QMISC(q
)) | AR_Q_MISC_CBR_INCR_DIS1
);
7742 case ATH9K_TX_QUEUE_UAPSD
:
7743 REG_WRITE(ah
, AR_DMISC(q
), REG_READ(ah
, AR_DMISC(q
))
7744 | AR_D_MISC_POST_FR_BKOFF_DIS
);
7750 if (qi
->tqi_intFlags
& ATH9K_TXQ_USE_LOCKOUT_BKOFF_DIS
) {
7751 REG_WRITE(ah
, AR_DMISC(q
),
7752 REG_READ(ah
, AR_DMISC(q
)) |
7753 SM(AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL
,
7754 AR_D_MISC_ARB_LOCKOUT_CNTRL
) |
7755 AR_D_MISC_POST_FR_BKOFF_DIS
);
7758 if (qi
->tqi_qflags
& TXQ_FLAG_TXOKINT_ENABLE
)
7759 ahp
->ah_txOkInterruptMask
|= 1 << q
;
7761 ahp
->ah_txOkInterruptMask
&= ~(1 << q
);
7762 if (qi
->tqi_qflags
& TXQ_FLAG_TXERRINT_ENABLE
)
7763 ahp
->ah_txErrInterruptMask
|= 1 << q
;
7765 ahp
->ah_txErrInterruptMask
&= ~(1 << q
);
7766 if (qi
->tqi_qflags
& TXQ_FLAG_TXDESCINT_ENABLE
)
7767 ahp
->ah_txDescInterruptMask
|= 1 << q
;
7769 ahp
->ah_txDescInterruptMask
&= ~(1 << q
);
7770 if (qi
->tqi_qflags
& TXQ_FLAG_TXEOLINT_ENABLE
)
7771 ahp
->ah_txEolInterruptMask
|= 1 << q
;
7773 ahp
->ah_txEolInterruptMask
&= ~(1 << q
);
7774 if (qi
->tqi_qflags
& TXQ_FLAG_TXURNINT_ENABLE
)
7775 ahp
->ah_txUrnInterruptMask
|= 1 << q
;
7777 ahp
->ah_txUrnInterruptMask
&= ~(1 << q
);
7778 ath9k_hw_set_txq_interrupts(ah
, qi
);
7783 void ath9k_hw_gettxintrtxqs(struct ath_hal
*ah
, u32
*txqs
)
7785 struct ath_hal_5416
*ahp
= AH5416(ah
);
7786 *txqs
&= ahp
->ah_intrTxqs
;
7787 ahp
->ah_intrTxqs
&= ~(*txqs
);
7791 ath9k_hw_filltxdesc(struct ath_hal
*ah
, struct ath_desc
*ds
,
7792 u32 segLen
, bool firstSeg
,
7793 bool lastSeg
, const struct ath_desc
*ds0
)
7795 struct ar5416_desc
*ads
= AR5416DESC(ds
);
7798 ads
->ds_ctl1
|= segLen
| (lastSeg
? 0 : AR_TxMore
);
7799 } else if (lastSeg
) {
7801 ads
->ds_ctl1
= segLen
;
7802 ads
->ds_ctl2
= AR5416DESC_CONST(ds0
)->ds_ctl2
;
7803 ads
->ds_ctl3
= AR5416DESC_CONST(ds0
)->ds_ctl3
;
7806 ads
->ds_ctl1
= segLen
| AR_TxMore
;
7810 ads
->ds_txstatus0
= ads
->ds_txstatus1
= 0;
7811 ads
->ds_txstatus2
= ads
->ds_txstatus3
= 0;
7812 ads
->ds_txstatus4
= ads
->ds_txstatus5
= 0;
7813 ads
->ds_txstatus6
= ads
->ds_txstatus7
= 0;
7814 ads
->ds_txstatus8
= ads
->ds_txstatus9
= 0;
7818 void ath9k_hw_cleartxdesc(struct ath_hal
*ah
, struct ath_desc
*ds
)
7820 struct ar5416_desc
*ads
= AR5416DESC(ds
);
7822 ads
->ds_txstatus0
= ads
->ds_txstatus1
= 0;
7823 ads
->ds_txstatus2
= ads
->ds_txstatus3
= 0;
7824 ads
->ds_txstatus4
= ads
->ds_txstatus5
= 0;
7825 ads
->ds_txstatus6
= ads
->ds_txstatus7
= 0;
7826 ads
->ds_txstatus8
= ads
->ds_txstatus9
= 0;
7830 ath9k_hw_txprocdesc(struct ath_hal
*ah
, struct ath_desc
*ds
)
7832 struct ar5416_desc
*ads
= AR5416DESC(ds
);
7834 if ((ads
->ds_txstatus9
& AR_TxDone
) == 0)
7835 return -EINPROGRESS
;
7837 ds
->ds_txstat
.ts_seqnum
= MS(ads
->ds_txstatus9
, AR_SeqNum
);
7838 ds
->ds_txstat
.ts_tstamp
= ads
->AR_SendTimestamp
;
7839 ds
->ds_txstat
.ts_status
= 0;
7840 ds
->ds_txstat
.ts_flags
= 0;
7842 if (ads
->ds_txstatus1
& AR_ExcessiveRetries
)
7843 ds
->ds_txstat
.ts_status
|= ATH9K_TXERR_XRETRY
;
7844 if (ads
->ds_txstatus1
& AR_Filtered
)
7845 ds
->ds_txstat
.ts_status
|= ATH9K_TXERR_FILT
;
7846 if (ads
->ds_txstatus1
& AR_FIFOUnderrun
)
7847 ds
->ds_txstat
.ts_status
|= ATH9K_TXERR_FIFO
;
7848 if (ads
->ds_txstatus9
& AR_TxOpExceeded
)
7849 ds
->ds_txstat
.ts_status
|= ATH9K_TXERR_XTXOP
;
7850 if (ads
->ds_txstatus1
& AR_TxTimerExpired
)
7851 ds
->ds_txstat
.ts_status
|= ATH9K_TXERR_TIMER_EXPIRED
;
7853 if (ads
->ds_txstatus1
& AR_DescCfgErr
)
7854 ds
->ds_txstat
.ts_flags
|= ATH9K_TX_DESC_CFG_ERR
;
7855 if (ads
->ds_txstatus1
& AR_TxDataUnderrun
) {
7856 ds
->ds_txstat
.ts_flags
|= ATH9K_TX_DATA_UNDERRUN
;
7857 ath9k_hw_updatetxtriglevel(ah
, true);
7859 if (ads
->ds_txstatus1
& AR_TxDelimUnderrun
) {
7860 ds
->ds_txstat
.ts_flags
|= ATH9K_TX_DELIM_UNDERRUN
;
7861 ath9k_hw_updatetxtriglevel(ah
, true);
7863 if (ads
->ds_txstatus0
& AR_TxBaStatus
) {
7864 ds
->ds_txstat
.ts_flags
|= ATH9K_TX_BA
;
7865 ds
->ds_txstat
.ba_low
= ads
->AR_BaBitmapLow
;
7866 ds
->ds_txstat
.ba_high
= ads
->AR_BaBitmapHigh
;
7869 ds
->ds_txstat
.ts_rateindex
= MS(ads
->ds_txstatus9
, AR_FinalTxIdx
);
7870 switch (ds
->ds_txstat
.ts_rateindex
) {
7872 ds
->ds_txstat
.ts_ratecode
= MS(ads
->ds_ctl3
, AR_XmitRate0
);
7875 ds
->ds_txstat
.ts_ratecode
= MS(ads
->ds_ctl3
, AR_XmitRate1
);
7878 ds
->ds_txstat
.ts_ratecode
= MS(ads
->ds_ctl3
, AR_XmitRate2
);
7881 ds
->ds_txstat
.ts_ratecode
= MS(ads
->ds_ctl3
, AR_XmitRate3
);
7885 ds
->ds_txstat
.ts_rssi
= MS(ads
->ds_txstatus5
, AR_TxRSSICombined
);
7886 ds
->ds_txstat
.ts_rssi_ctl0
= MS(ads
->ds_txstatus0
, AR_TxRSSIAnt00
);
7887 ds
->ds_txstat
.ts_rssi_ctl1
= MS(ads
->ds_txstatus0
, AR_TxRSSIAnt01
);
7888 ds
->ds_txstat
.ts_rssi_ctl2
= MS(ads
->ds_txstatus0
, AR_TxRSSIAnt02
);
7889 ds
->ds_txstat
.ts_rssi_ext0
= MS(ads
->ds_txstatus5
, AR_TxRSSIAnt10
);
7890 ds
->ds_txstat
.ts_rssi_ext1
= MS(ads
->ds_txstatus5
, AR_TxRSSIAnt11
);
7891 ds
->ds_txstat
.ts_rssi_ext2
= MS(ads
->ds_txstatus5
, AR_TxRSSIAnt12
);
7892 ds
->ds_txstat
.evm0
= ads
->AR_TxEVM0
;
7893 ds
->ds_txstat
.evm1
= ads
->AR_TxEVM1
;
7894 ds
->ds_txstat
.evm2
= ads
->AR_TxEVM2
;
7895 ds
->ds_txstat
.ts_shortretry
= MS(ads
->ds_txstatus1
, AR_RTSFailCnt
);
7896 ds
->ds_txstat
.ts_longretry
= MS(ads
->ds_txstatus1
, AR_DataFailCnt
);
7897 ds
->ds_txstat
.ts_virtcol
= MS(ads
->ds_txstatus1
, AR_VirtRetryCnt
);
7898 ds
->ds_txstat
.ts_antenna
= 1;
7904 ath9k_hw_set11n_txdesc(struct ath_hal
*ah
, struct ath_desc
*ds
,
7905 u32 pktLen
, enum ath9k_pkt_type type
, u32 txPower
,
7906 u32 keyIx
, enum ath9k_key_type keyType
, u32 flags
)
7908 struct ar5416_desc
*ads
= AR5416DESC(ds
);
7909 struct ath_hal_5416
*ahp
= AH5416(ah
);
7911 txPower
+= ahp
->ah_txPowerIndexOffset
;
7915 ads
->ds_ctl0
= (pktLen
& AR_FrameLen
)
7916 | (flags
& ATH9K_TXDESC_VMF
? AR_VirtMoreFrag
: 0)
7917 | SM(txPower
, AR_XmitPower
)
7918 | (flags
& ATH9K_TXDESC_VEOL
? AR_VEOL
: 0)
7919 | (flags
& ATH9K_TXDESC_CLRDMASK
? AR_ClrDestMask
: 0)
7920 | (flags
& ATH9K_TXDESC_INTREQ
? AR_TxIntrReq
: 0)
7921 | (keyIx
!= ATH9K_TXKEYIX_INVALID
? AR_DestIdxValid
: 0);
7924 (keyIx
!= ATH9K_TXKEYIX_INVALID
? SM(keyIx
, AR_DestIdx
) : 0)
7925 | SM(type
, AR_FrameType
)
7926 | (flags
& ATH9K_TXDESC_NOACK
? AR_NoAck
: 0)
7927 | (flags
& ATH9K_TXDESC_EXT_ONLY
? AR_ExtOnly
: 0)
7928 | (flags
& ATH9K_TXDESC_EXT_AND_CTL
? AR_ExtAndCtl
: 0);
7930 ads
->ds_ctl6
= SM(keyType
, AR_EncrType
);
7932 if (AR_SREV_9285(ah
)) {
7942 ath9k_hw_set11n_ratescenario(struct ath_hal
*ah
, struct ath_desc
*ds
,
7943 struct ath_desc
*lastds
,
7944 u32 durUpdateEn
, u32 rtsctsRate
,
7946 struct ath9k_11n_rate_series series
[],
7947 u32 nseries
, u32 flags
)
7949 struct ar5416_desc
*ads
= AR5416DESC(ds
);
7950 struct ar5416_desc
*last_ads
= AR5416DESC(lastds
);
7954 (void) rtsctsDuration
;
7956 if (flags
& (ATH9K_TXDESC_RTSENA
| ATH9K_TXDESC_CTSENA
)) {
7957 ds_ctl0
= ads
->ds_ctl0
;
7959 if (flags
& ATH9K_TXDESC_RTSENA
) {
7960 ds_ctl0
&= ~AR_CTSEnable
;
7961 ds_ctl0
|= AR_RTSEnable
;
7963 ds_ctl0
&= ~AR_RTSEnable
;
7964 ds_ctl0
|= AR_CTSEnable
;
7967 ads
->ds_ctl0
= ds_ctl0
;
7970 (ads
->ds_ctl0
& ~(AR_RTSEnable
| AR_CTSEnable
));
7973 ads
->ds_ctl2
= set11nTries(series
, 0)
7974 | set11nTries(series
, 1)
7975 | set11nTries(series
, 2)
7976 | set11nTries(series
, 3)
7977 | (durUpdateEn
? AR_DurUpdateEna
: 0)
7978 | SM(0, AR_BurstDur
);
7980 ads
->ds_ctl3
= set11nRate(series
, 0)
7981 | set11nRate(series
, 1)
7982 | set11nRate(series
, 2)
7983 | set11nRate(series
, 3);
7985 ads
->ds_ctl4
= set11nPktDurRTSCTS(series
, 0)
7986 | set11nPktDurRTSCTS(series
, 1);
7988 ads
->ds_ctl5
= set11nPktDurRTSCTS(series
, 2)
7989 | set11nPktDurRTSCTS(series
, 3);
7991 ads
->ds_ctl7
= set11nRateFlags(series
, 0)
7992 | set11nRateFlags(series
, 1)
7993 | set11nRateFlags(series
, 2)
7994 | set11nRateFlags(series
, 3)
7995 | SM(rtsctsRate
, AR_RTSCTSRate
);
7996 last_ads
->ds_ctl2
= ads
->ds_ctl2
;
7997 last_ads
->ds_ctl3
= ads
->ds_ctl3
;
8001 ath9k_hw_set11n_aggr_first(struct ath_hal
*ah
, struct ath_desc
*ds
,
8004 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8006 ads
->ds_ctl1
|= (AR_IsAggr
| AR_MoreAggr
);
8008 ads
->ds_ctl6
&= ~AR_AggrLen
;
8009 ads
->ds_ctl6
|= SM(aggrLen
, AR_AggrLen
);
8013 ath9k_hw_set11n_aggr_middle(struct ath_hal
*ah
, struct ath_desc
*ds
,
8016 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8019 ads
->ds_ctl1
|= (AR_IsAggr
| AR_MoreAggr
);
8021 ctl6
= ads
->ds_ctl6
;
8022 ctl6
&= ~AR_PadDelim
;
8023 ctl6
|= SM(numDelims
, AR_PadDelim
);
8024 ads
->ds_ctl6
= ctl6
;
8027 void ath9k_hw_set11n_aggr_last(struct ath_hal
*ah
, struct ath_desc
*ds
)
8029 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8031 ads
->ds_ctl1
|= AR_IsAggr
;
8032 ads
->ds_ctl1
&= ~AR_MoreAggr
;
8033 ads
->ds_ctl6
&= ~AR_PadDelim
;
8036 void ath9k_hw_clr11n_aggr(struct ath_hal
*ah
, struct ath_desc
*ds
)
8038 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8040 ads
->ds_ctl1
&= (~AR_IsAggr
& ~AR_MoreAggr
);
8044 ath9k_hw_set11n_burstduration(struct ath_hal
*ah
, struct ath_desc
*ds
,
8047 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8049 ads
->ds_ctl2
&= ~AR_BurstDur
;
8050 ads
->ds_ctl2
|= SM(burstDuration
, AR_BurstDur
);
8054 ath9k_hw_set11n_virtualmorefrag(struct ath_hal
*ah
, struct ath_desc
*ds
,
8057 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8060 ads
->ds_ctl0
|= AR_VirtMoreFrag
;
8062 ads
->ds_ctl0
&= ~AR_VirtMoreFrag
;
8065 void ath9k_hw_putrxbuf(struct ath_hal
*ah
, u32 rxdp
)
8067 REG_WRITE(ah
, AR_RXDP
, rxdp
);
8070 void ath9k_hw_rxena(struct ath_hal
*ah
)
8072 REG_WRITE(ah
, AR_CR
, AR_CR_RXE
);
8075 bool ath9k_hw_setrxabort(struct ath_hal
*ah
, bool set
)
8079 REG_SET_BIT(ah
, AR_DIAG_SW
,
8080 (AR_DIAG_RX_DIS
| AR_DIAG_RX_ABORT
));
8083 (ah
, AR_OBS_BUS_1
, AR_OBS_BUS_1_RX_STATE
, 0)) {
8086 REG_CLR_BIT(ah
, AR_DIAG_SW
,
8090 reg
= REG_READ(ah
, AR_OBS_BUS_1
);
8091 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
8092 "%s: rx failed to go idle in 10 ms RXSM=0x%x\n",
8098 REG_CLR_BIT(ah
, AR_DIAG_SW
,
8099 (AR_DIAG_RX_DIS
| AR_DIAG_RX_ABORT
));
8106 ath9k_hw_setmcastfilter(struct ath_hal
*ah
, u32 filter0
,
8109 REG_WRITE(ah
, AR_MCAST_FIL0
, filter0
);
8110 REG_WRITE(ah
, AR_MCAST_FIL1
, filter1
);
8114 ath9k_hw_setuprxdesc(struct ath_hal
*ah
, struct ath_desc
*ds
,
8115 u32 size
, u32 flags
)
8117 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8118 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
8120 ads
->ds_ctl1
= size
& AR_BufLen
;
8121 if (flags
& ATH9K_RXDESC_INTREQ
)
8122 ads
->ds_ctl1
|= AR_RxIntrReq
;
8124 ads
->ds_rxstatus8
&= ~AR_RxDone
;
8125 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
))
8126 memset(&(ads
->u
), 0, sizeof(ads
->u
));
8131 ath9k_hw_rxprocdesc(struct ath_hal
*ah
, struct ath_desc
*ds
,
8132 u32 pa
, struct ath_desc
*nds
, u64 tsf
)
8134 struct ar5416_desc ads
;
8135 struct ar5416_desc
*adsp
= AR5416DESC(ds
);
8137 if ((adsp
->ds_rxstatus8
& AR_RxDone
) == 0)
8138 return -EINPROGRESS
;
8140 ads
.u
.rx
= adsp
->u
.rx
;
8142 ds
->ds_rxstat
.rs_status
= 0;
8143 ds
->ds_rxstat
.rs_flags
= 0;
8145 ds
->ds_rxstat
.rs_datalen
= ads
.ds_rxstatus1
& AR_DataLen
;
8146 ds
->ds_rxstat
.rs_tstamp
= ads
.AR_RcvTimestamp
;
8148 ds
->ds_rxstat
.rs_rssi
= MS(ads
.ds_rxstatus4
, AR_RxRSSICombined
);
8149 ds
->ds_rxstat
.rs_rssi_ctl0
= MS(ads
.ds_rxstatus0
, AR_RxRSSIAnt00
);
8150 ds
->ds_rxstat
.rs_rssi_ctl1
= MS(ads
.ds_rxstatus0
, AR_RxRSSIAnt01
);
8151 ds
->ds_rxstat
.rs_rssi_ctl2
= MS(ads
.ds_rxstatus0
, AR_RxRSSIAnt02
);
8152 ds
->ds_rxstat
.rs_rssi_ext0
= MS(ads
.ds_rxstatus4
, AR_RxRSSIAnt10
);
8153 ds
->ds_rxstat
.rs_rssi_ext1
= MS(ads
.ds_rxstatus4
, AR_RxRSSIAnt11
);
8154 ds
->ds_rxstat
.rs_rssi_ext2
= MS(ads
.ds_rxstatus4
, AR_RxRSSIAnt12
);
8155 if (ads
.ds_rxstatus8
& AR_RxKeyIdxValid
)
8156 ds
->ds_rxstat
.rs_keyix
= MS(ads
.ds_rxstatus8
, AR_KeyIdx
);
8158 ds
->ds_rxstat
.rs_keyix
= ATH9K_RXKEYIX_INVALID
;
8160 ds
->ds_rxstat
.rs_rate
= RXSTATUS_RATE(ah
, (&ads
));
8161 ds
->ds_rxstat
.rs_more
= (ads
.ds_rxstatus1
& AR_RxMore
) ? 1 : 0;
8163 ds
->ds_rxstat
.rs_isaggr
= (ads
.ds_rxstatus8
& AR_RxAggr
) ? 1 : 0;
8164 ds
->ds_rxstat
.rs_moreaggr
=
8165 (ads
.ds_rxstatus8
& AR_RxMoreAggr
) ? 1 : 0;
8166 ds
->ds_rxstat
.rs_antenna
= MS(ads
.ds_rxstatus3
, AR_RxAntenna
);
8167 ds
->ds_rxstat
.rs_flags
=
8168 (ads
.ds_rxstatus3
& AR_GI
) ? ATH9K_RX_GI
: 0;
8169 ds
->ds_rxstat
.rs_flags
|=
8170 (ads
.ds_rxstatus3
& AR_2040
) ? ATH9K_RX_2040
: 0;
8172 if (ads
.ds_rxstatus8
& AR_PreDelimCRCErr
)
8173 ds
->ds_rxstat
.rs_flags
|= ATH9K_RX_DELIM_CRC_PRE
;
8174 if (ads
.ds_rxstatus8
& AR_PostDelimCRCErr
)
8175 ds
->ds_rxstat
.rs_flags
|= ATH9K_RX_DELIM_CRC_POST
;
8176 if (ads
.ds_rxstatus8
& AR_DecryptBusyErr
)
8177 ds
->ds_rxstat
.rs_flags
|= ATH9K_RX_DECRYPT_BUSY
;
8179 if ((ads
.ds_rxstatus8
& AR_RxFrameOK
) == 0) {
8181 if (ads
.ds_rxstatus8
& AR_CRCErr
)
8182 ds
->ds_rxstat
.rs_status
|= ATH9K_RXERR_CRC
;
8183 else if (ads
.ds_rxstatus8
& AR_PHYErr
) {
8186 ds
->ds_rxstat
.rs_status
|= ATH9K_RXERR_PHY
;
8187 phyerr
= MS(ads
.ds_rxstatus8
, AR_PHYErrCode
);
8188 ds
->ds_rxstat
.rs_phyerr
= phyerr
;
8189 } else if (ads
.ds_rxstatus8
& AR_DecryptCRCErr
)
8190 ds
->ds_rxstat
.rs_status
|= ATH9K_RXERR_DECRYPT
;
8191 else if (ads
.ds_rxstatus8
& AR_MichaelErr
)
8192 ds
->ds_rxstat
.rs_status
|= ATH9K_RXERR_MIC
;
8198 static void ath9k_hw_setup_rate_table(struct ath_hal
*ah
,
8199 struct ath9k_rate_table
*rt
)
8203 if (rt
->rateCodeToIndex
[0] != 0)
8205 for (i
= 0; i
< 256; i
++)
8206 rt
->rateCodeToIndex
[i
] = (u8
) -1;
8207 for (i
= 0; i
< rt
->rateCount
; i
++) {
8208 u8 code
= rt
->info
[i
].rateCode
;
8209 u8 cix
= rt
->info
[i
].controlRate
;
8211 rt
->rateCodeToIndex
[code
] = i
;
8212 rt
->rateCodeToIndex
[code
| rt
->info
[i
].shortPreamble
] = i
;
8214 rt
->info
[i
].lpAckDuration
=
8215 ath9k_hw_computetxtime(ah
, rt
,
8216 WLAN_CTRL_FRAME_SIZE
,
8219 rt
->info
[i
].spAckDuration
=
8220 ath9k_hw_computetxtime(ah
, rt
,
8221 WLAN_CTRL_FRAME_SIZE
,
8227 const struct ath9k_rate_table
*ath9k_hw_getratetable(struct ath_hal
*ah
,
8230 struct ath9k_rate_table
*rt
;
8232 case ATH9K_MODE_11A
:
8233 rt
= &ar5416_11a_table
;
8235 case ATH9K_MODE_11B
:
8236 rt
= &ar5416_11b_table
;
8238 case ATH9K_MODE_11G
:
8239 rt
= &ar5416_11g_table
;
8241 case ATH9K_MODE_11NG_HT20
:
8242 case ATH9K_MODE_11NG_HT40PLUS
:
8243 case ATH9K_MODE_11NG_HT40MINUS
:
8244 rt
= &ar5416_11ng_table
;
8246 case ATH9K_MODE_11NA_HT20
:
8247 case ATH9K_MODE_11NA_HT40PLUS
:
8248 case ATH9K_MODE_11NA_HT40MINUS
:
8249 rt
= &ar5416_11na_table
;
8252 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
, "%s: invalid mode 0x%x\n",
8256 ath9k_hw_setup_rate_table(ah
, rt
);
8260 static const char *ath9k_hw_devname(u16 devid
)
8263 case AR5416_DEVID_PCI
:
8264 case AR5416_DEVID_PCIE
:
8265 return "Atheros 5416";
8266 case AR9160_DEVID_PCI
:
8267 return "Atheros 9160";
8268 case AR9280_DEVID_PCI
:
8269 case AR9280_DEVID_PCIE
:
8270 return "Atheros 9280";
8275 const char *ath9k_hw_probe(u16 vendorid
, u16 devid
)
8277 return vendorid
== ATHEROS_VENDOR_ID
?
8278 ath9k_hw_devname(devid
) : NULL
;
8281 struct ath_hal
*ath9k_hw_attach(u16 devid
,
8282 struct ath_softc
*sc
,
8286 struct ath_hal
*ah
= NULL
;
8289 case AR5416_DEVID_PCI
:
8290 case AR5416_DEVID_PCIE
:
8291 case AR9160_DEVID_PCI
:
8292 case AR9280_DEVID_PCI
:
8293 case AR9280_DEVID_PCIE
:
8294 ah
= ath9k_hw_do_attach(devid
, sc
, mem
, error
);
8297 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
8298 "devid=0x%x not supported.\n", devid
);
8304 ah
->ah_devid
= ah
->ah_devid
;
8305 ah
->ah_subvendorid
= ah
->ah_subvendorid
;
8306 ah
->ah_macVersion
= ah
->ah_macVersion
;
8307 ah
->ah_macRev
= ah
->ah_macRev
;
8308 ah
->ah_phyRev
= ah
->ah_phyRev
;
8309 ah
->ah_analog5GhzRev
= ah
->ah_analog5GhzRev
;
8310 ah
->ah_analog2GhzRev
= ah
->ah_analog2GhzRev
;
8316 ath9k_hw_computetxtime(struct ath_hal
*ah
,
8317 const struct ath9k_rate_table
*rates
,
8318 u32 frameLen
, u16 rateix
,
8321 u32 bitsPerSymbol
, numBits
, numSymbols
, phyTime
, txTime
;
8324 kbps
= rates
->info
[rateix
].rateKbps
;
8328 switch (rates
->info
[rateix
].phy
) {
8331 phyTime
= CCK_PREAMBLE_BITS
+ CCK_PLCP_BITS
;
8332 if (shortPreamble
&& rates
->info
[rateix
].shortPreamble
)
8334 numBits
= frameLen
<< 3;
8335 txTime
= CCK_SIFS_TIME
+ phyTime
8336 + ((numBits
* 1000) / kbps
);
8339 if (ah
->ah_curchan
&& IS_CHAN_QUARTER_RATE(ah
->ah_curchan
)) {
8341 (kbps
* OFDM_SYMBOL_TIME_QUARTER
) / 1000;
8343 numBits
= OFDM_PLCP_BITS
+ (frameLen
<< 3);
8344 numSymbols
= DIV_ROUND_UP(numBits
, bitsPerSymbol
);
8345 txTime
= OFDM_SIFS_TIME_QUARTER
8346 + OFDM_PREAMBLE_TIME_QUARTER
8347 + (numSymbols
* OFDM_SYMBOL_TIME_QUARTER
);
8348 } else if (ah
->ah_curchan
&&
8349 IS_CHAN_HALF_RATE(ah
->ah_curchan
)) {
8351 (kbps
* OFDM_SYMBOL_TIME_HALF
) / 1000;
8353 numBits
= OFDM_PLCP_BITS
+ (frameLen
<< 3);
8354 numSymbols
= DIV_ROUND_UP(numBits
, bitsPerSymbol
);
8355 txTime
= OFDM_SIFS_TIME_HALF
+
8356 OFDM_PREAMBLE_TIME_HALF
8357 + (numSymbols
* OFDM_SYMBOL_TIME_HALF
);
8359 bitsPerSymbol
= (kbps
* OFDM_SYMBOL_TIME
) / 1000;
8361 numBits
= OFDM_PLCP_BITS
+ (frameLen
<< 3);
8362 numSymbols
= DIV_ROUND_UP(numBits
, bitsPerSymbol
);
8363 txTime
= OFDM_SIFS_TIME
+ OFDM_PREAMBLE_TIME
8364 + (numSymbols
* OFDM_SYMBOL_TIME
);
8369 DPRINTF(ah
->ah_sc
, ATH_DBG_PHY_IO
,
8370 "%s: unknown phy %u (rate ix %u)\n", __func__
,
8371 rates
->info
[rateix
].phy
, rateix
);
8378 u32
ath9k_hw_mhz2ieee(struct ath_hal
*ah
, u32 freq
, u32 flags
)
8380 if (flags
& CHANNEL_2GHZ
) {
8384 return (freq
- 2407) / 5;
8386 return 15 + ((freq
- 2512) / 20);
8387 } else if (flags
& CHANNEL_5GHZ
) {
8388 if (ath9k_regd_is_public_safety_sku(ah
) &&
8389 IS_CHAN_IN_PUBLIC_SAFETY_BAND(freq
)) {
8390 return ((freq
* 10) +
8391 (((freq
% 5) == 2) ? 5 : 0) - 49400) / 5;
8392 } else if ((flags
& CHANNEL_A
) && (freq
<= 5000)) {
8393 return (freq
- 4000) / 5;
8395 return (freq
- 5000) / 5;
8401 return (freq
- 2407) / 5;
8403 if (ath9k_regd_is_public_safety_sku(ah
)
8404 && IS_CHAN_IN_PUBLIC_SAFETY_BAND(freq
)) {
8405 return ((freq
* 10) +
8407 2) ? 5 : 0) - 49400) / 5;
8408 } else if (freq
> 4900) {
8409 return (freq
- 4000) / 5;
8411 return 15 + ((freq
- 2512) / 20);
8414 return (freq
- 5000) / 5;
8419 ath9k_hw_getchan_noise(struct ath_hal
*ah
, struct ath9k_channel
*chan
)
8421 struct ath9k_channel
*ichan
;
8423 ichan
= ath9k_regd_check_channel(ah
, chan
);
8424 if (ichan
== NULL
) {
8425 DPRINTF(ah
->ah_sc
, ATH_DBG_NF_CAL
,
8426 "%s: invalid channel %u/0x%x; no mapping\n",
8427 __func__
, chan
->channel
, chan
->channelFlags
);
8430 if (ichan
->rawNoiseFloor
== 0) {
8431 enum wireless_mode mode
= ath9k_hw_chan2wmode(ah
, chan
);
8432 return NOISE_FLOOR
[mode
];
8434 return ichan
->rawNoiseFloor
;
8437 bool ath9k_hw_set_tsfadjust(struct ath_hal
*ah
, u32 setting
)
8439 struct ath_hal_5416
*ahp
= AH5416(ah
);
8442 ahp
->ah_miscMode
|= AR_PCU_TX_ADD_TSF
;
8444 ahp
->ah_miscMode
&= ~AR_PCU_TX_ADD_TSF
;
8448 bool ath9k_hw_phycounters(struct ath_hal
*ah
)
8450 struct ath_hal_5416
*ahp
= AH5416(ah
);
8452 return ahp
->ah_hasHwPhyCounters
? true : false;
8455 u32
ath9k_hw_gettxbuf(struct ath_hal
*ah
, u32 q
)
8457 return REG_READ(ah
, AR_QTXDP(q
));
8460 bool ath9k_hw_puttxbuf(struct ath_hal
*ah
, u32 q
,
8463 REG_WRITE(ah
, AR_QTXDP(q
), txdp
);
8468 bool ath9k_hw_txstart(struct ath_hal
*ah
, u32 q
)
8470 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: queue %u\n", __func__
, q
);
8472 REG_WRITE(ah
, AR_Q_TXE
, 1 << q
);
8477 u32
ath9k_hw_numtxpending(struct ath_hal
*ah
, u32 q
)
8481 npend
= REG_READ(ah
, AR_QSTS(q
)) & AR_Q_STS_PEND_FR_CNT
;
8484 if (REG_READ(ah
, AR_Q_TXE
) & (1 << q
))
8490 bool ath9k_hw_stoptxdma(struct ath_hal
*ah
, u32 q
)
8494 REG_WRITE(ah
, AR_Q_TXD
, 1 << q
);
8496 for (wait
= 1000; wait
!= 0; wait
--) {
8497 if (ath9k_hw_numtxpending(ah
, q
) == 0)
8502 if (ath9k_hw_numtxpending(ah
, q
)) {
8505 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
8506 "%s: Num of pending TX Frames %d on Q %d\n",
8507 __func__
, ath9k_hw_numtxpending(ah
, q
), q
);
8509 for (j
= 0; j
< 2; j
++) {
8510 tsfLow
= REG_READ(ah
, AR_TSF_L32
);
8511 REG_WRITE(ah
, AR_QUIET2
,
8512 SM(10, AR_QUIET2_QUIET_DUR
));
8513 REG_WRITE(ah
, AR_QUIET_PERIOD
, 100);
8514 REG_WRITE(ah
, AR_NEXT_QUIET_TIMER
, tsfLow
>> 10);
8515 REG_SET_BIT(ah
, AR_TIMER_MODE
,
8518 if ((REG_READ(ah
, AR_TSF_L32
) >> 10) ==
8522 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
8523 "%s: TSF have moved while trying to set "
8524 "quiet time TSF: 0x%08x\n",
8528 REG_SET_BIT(ah
, AR_DIAG_SW
, AR_DIAG_FORCE_CH_IDLE_HIGH
);
8531 REG_CLR_BIT(ah
, AR_TIMER_MODE
, AR_QUIET_TIMER_EN
);
8535 while (ath9k_hw_numtxpending(ah
, q
)) {
8536 if ((--wait
) == 0) {
8537 DPRINTF(ah
->ah_sc
, ATH_DBG_XMIT
,
8538 "%s: Failed to stop Tx DMA in 100 "
8539 "msec after killing last frame\n",
8546 REG_CLR_BIT(ah
, AR_DIAG_SW
, AR_DIAG_FORCE_CH_IDLE_HIGH
);
8549 REG_WRITE(ah
, AR_Q_TXD
, 0);