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
= 1;
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 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 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 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 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 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 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 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 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 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 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 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 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
);
2530 * Process a MIB interrupt. We may potentially be invoked because
2531 * any of the MIB counters overflow/trigger so don't assume we're
2532 * here because a PHY error counter triggered.
2534 void ath9k_hw_procmibevent(struct ath_hal
*ah
,
2535 const struct ath9k_node_stats
*stats
)
2537 struct ath_hal_5416
*ahp
= AH5416(ah
);
2538 u32 phyCnt1
, phyCnt2
;
2540 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
, "Processing Mib Intr\n");
2541 /* Reset these counters regardless */
2542 REG_WRITE(ah
, AR_FILT_OFDM
, 0);
2543 REG_WRITE(ah
, AR_FILT_CCK
, 0);
2544 if (!(REG_READ(ah
, AR_SLP_MIB_CTRL
) & AR_SLP_MIB_PENDING
))
2545 REG_WRITE(ah
, AR_SLP_MIB_CTRL
, AR_SLP_MIB_CLEAR
);
2547 /* Clear the mib counters and save them in the stats */
2548 ath9k_hw_update_mibstats(ah
, &ahp
->ah_mibStats
);
2549 ahp
->ah_stats
.ast_nodestats
= *stats
;
2554 /* NB: these are not reset-on-read */
2555 phyCnt1
= REG_READ(ah
, AR_PHY_ERR_1
);
2556 phyCnt2
= REG_READ(ah
, AR_PHY_ERR_2
);
2557 if (((phyCnt1
& AR_MIBCNT_INTRMASK
) == AR_MIBCNT_INTRMASK
) ||
2558 ((phyCnt2
& AR_MIBCNT_INTRMASK
) == AR_MIBCNT_INTRMASK
)) {
2559 struct ar5416AniState
*aniState
= ahp
->ah_curani
;
2560 u32 ofdmPhyErrCnt
, cckPhyErrCnt
;
2562 /* NB: only use ast_ani_*errs with AH_PRIVATE_DIAG */
2563 ofdmPhyErrCnt
= phyCnt1
- aniState
->ofdmPhyErrBase
;
2564 ahp
->ah_stats
.ast_ani_ofdmerrs
+=
2565 ofdmPhyErrCnt
- aniState
->ofdmPhyErrCount
;
2566 aniState
->ofdmPhyErrCount
= ofdmPhyErrCnt
;
2568 cckPhyErrCnt
= phyCnt2
- aniState
->cckPhyErrBase
;
2569 ahp
->ah_stats
.ast_ani_cckerrs
+=
2570 cckPhyErrCnt
- aniState
->cckPhyErrCount
;
2571 aniState
->cckPhyErrCount
= cckPhyErrCnt
;
2574 * NB: figure out which counter triggered. If both
2575 * trigger we'll only deal with one as the processing
2576 * clobbers the error counter so the trigger threshold
2577 * check will never be true.
2579 if (aniState
->ofdmPhyErrCount
> aniState
->ofdmTrigHigh
)
2580 ath9k_hw_ani_ofdm_err_trigger(ah
);
2581 if (aniState
->cckPhyErrCount
> aniState
->cckTrigHigh
)
2582 ath9k_hw_ani_cck_err_trigger(ah
);
2583 /* NB: always restart to insure the h/w counters are reset */
2584 ath9k_ani_restart(ah
);
2588 static void ath9k_hw_ani_lower_immunity(struct ath_hal
*ah
)
2590 struct ath_hal_5416
*ahp
= AH5416(ah
);
2591 struct ar5416AniState
*aniState
;
2594 aniState
= ahp
->ah_curani
;
2596 if (ah
->ah_opmode
== ATH9K_M_HOSTAP
) {
2597 if (aniState
->firstepLevel
> 0) {
2598 if (ath9k_hw_ani_control(ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2599 aniState
->firstepLevel
- 1)) {
2604 rssi
= BEACON_RSSI(ahp
);
2605 if (rssi
> aniState
->rssiThrHigh
) {
2606 /* XXX: Handle me */
2607 } else if (rssi
> aniState
->rssiThrLow
) {
2608 if (aniState
->ofdmWeakSigDetectOff
) {
2609 if (ath9k_hw_ani_control(ah
,
2610 ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION
,
2616 if (aniState
->firstepLevel
> 0) {
2617 if (ath9k_hw_ani_control
2618 (ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2619 aniState
->firstepLevel
- 1) ==
2625 if (aniState
->firstepLevel
> 0) {
2626 if (ath9k_hw_ani_control
2627 (ah
, ATH9K_ANI_FIRSTEP_LEVEL
,
2628 aniState
->firstepLevel
- 1) ==
2636 if (aniState
->spurImmunityLevel
> 0) {
2637 if (ath9k_hw_ani_control(ah
, ATH9K_ANI_SPUR_IMMUNITY_LEVEL
,
2638 aniState
->spurImmunityLevel
- 1)) {
2643 if (aniState
->noiseImmunityLevel
> 0) {
2644 ath9k_hw_ani_control(ah
, ATH9K_ANI_NOISE_IMMUNITY_LEVEL
,
2645 aniState
->noiseImmunityLevel
- 1);
2650 static int32_t ath9k_hw_ani_get_listen_time(struct ath_hal
*ah
)
2652 struct ath_hal_5416
*ahp
= AH5416(ah
);
2653 struct ar5416AniState
*aniState
;
2654 u32 txFrameCount
, rxFrameCount
, cycleCount
;
2657 txFrameCount
= REG_READ(ah
, AR_TFCNT
);
2658 rxFrameCount
= REG_READ(ah
, AR_RFCNT
);
2659 cycleCount
= REG_READ(ah
, AR_CCCNT
);
2661 aniState
= ahp
->ah_curani
;
2662 if (aniState
->cycleCount
== 0 || aniState
->cycleCount
> cycleCount
) {
2665 ahp
->ah_stats
.ast_ani_lzero
++;
2667 int32_t ccdelta
= cycleCount
- aniState
->cycleCount
;
2668 int32_t rfdelta
= rxFrameCount
- aniState
->rxFrameCount
;
2669 int32_t tfdelta
= txFrameCount
- aniState
->txFrameCount
;
2670 listenTime
= (ccdelta
- rfdelta
- tfdelta
) / 44000;
2672 aniState
->cycleCount
= cycleCount
;
2673 aniState
->txFrameCount
= txFrameCount
;
2674 aniState
->rxFrameCount
= rxFrameCount
;
2679 void ath9k_hw_ani_monitor(struct ath_hal
*ah
,
2680 const struct ath9k_node_stats
*stats
,
2681 struct ath9k_channel
*chan
)
2683 struct ath_hal_5416
*ahp
= AH5416(ah
);
2684 struct ar5416AniState
*aniState
;
2687 aniState
= ahp
->ah_curani
;
2688 ahp
->ah_stats
.ast_nodestats
= *stats
;
2690 listenTime
= ath9k_hw_ani_get_listen_time(ah
);
2691 if (listenTime
< 0) {
2692 ahp
->ah_stats
.ast_ani_lneg
++;
2693 ath9k_ani_restart(ah
);
2697 aniState
->listenTime
+= listenTime
;
2699 if (ahp
->ah_hasHwPhyCounters
) {
2700 u32 phyCnt1
, phyCnt2
;
2701 u32 ofdmPhyErrCnt
, cckPhyErrCnt
;
2703 ath9k_hw_update_mibstats(ah
, &ahp
->ah_mibStats
);
2705 phyCnt1
= REG_READ(ah
, AR_PHY_ERR_1
);
2706 phyCnt2
= REG_READ(ah
, AR_PHY_ERR_2
);
2708 if (phyCnt1
< aniState
->ofdmPhyErrBase
||
2709 phyCnt2
< aniState
->cckPhyErrBase
) {
2710 if (phyCnt1
< aniState
->ofdmPhyErrBase
) {
2711 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2712 "%s: phyCnt1 0x%x, resetting "
2713 "counter value to 0x%x\n",
2715 aniState
->ofdmPhyErrBase
);
2716 REG_WRITE(ah
, AR_PHY_ERR_1
,
2717 aniState
->ofdmPhyErrBase
);
2718 REG_WRITE(ah
, AR_PHY_ERR_MASK_1
,
2719 AR_PHY_ERR_OFDM_TIMING
);
2721 if (phyCnt2
< aniState
->cckPhyErrBase
) {
2722 DPRINTF(ah
->ah_sc
, ATH_DBG_ANI
,
2723 "%s: phyCnt2 0x%x, resetting "
2724 "counter value to 0x%x\n",
2726 aniState
->cckPhyErrBase
);
2727 REG_WRITE(ah
, AR_PHY_ERR_2
,
2728 aniState
->cckPhyErrBase
);
2729 REG_WRITE(ah
, AR_PHY_ERR_MASK_2
,
2730 AR_PHY_ERR_CCK_TIMING
);
2735 ofdmPhyErrCnt
= phyCnt1
- aniState
->ofdmPhyErrBase
;
2736 ahp
->ah_stats
.ast_ani_ofdmerrs
+=
2737 ofdmPhyErrCnt
- aniState
->ofdmPhyErrCount
;
2738 aniState
->ofdmPhyErrCount
= ofdmPhyErrCnt
;
2740 cckPhyErrCnt
= phyCnt2
- aniState
->cckPhyErrBase
;
2741 ahp
->ah_stats
.ast_ani_cckerrs
+=
2742 cckPhyErrCnt
- aniState
->cckPhyErrCount
;
2743 aniState
->cckPhyErrCount
= cckPhyErrCnt
;
2749 if (aniState
->listenTime
> 5 * ahp
->ah_aniPeriod
) {
2750 if (aniState
->ofdmPhyErrCount
<= aniState
->listenTime
*
2751 aniState
->ofdmTrigLow
/ 1000 &&
2752 aniState
->cckPhyErrCount
<= aniState
->listenTime
*
2753 aniState
->cckTrigLow
/ 1000)
2754 ath9k_hw_ani_lower_immunity(ah
);
2755 ath9k_ani_restart(ah
);
2756 } else if (aniState
->listenTime
> ahp
->ah_aniPeriod
) {
2757 if (aniState
->ofdmPhyErrCount
> aniState
->listenTime
*
2758 aniState
->ofdmTrigHigh
/ 1000) {
2759 ath9k_hw_ani_ofdm_err_trigger(ah
);
2760 ath9k_ani_restart(ah
);
2761 } else if (aniState
->cckPhyErrCount
>
2762 aniState
->listenTime
* aniState
->cckTrigHigh
/
2764 ath9k_hw_ani_cck_err_trigger(ah
);
2765 ath9k_ani_restart(ah
);
2770 #ifndef ATH_NF_PER_CHAN
2771 static void ath9k_init_nfcal_hist_buffer(struct ath_hal
*ah
)
2775 for (i
= 0; i
< NUM_NF_READINGS
; i
++) {
2776 ah
->nfCalHist
[i
].currIndex
= 0;
2777 ah
->nfCalHist
[i
].privNF
= AR_PHY_CCA_MAX_GOOD_VALUE
;
2778 ah
->nfCalHist
[i
].invalidNFcount
=
2779 AR_PHY_CCA_FILTERWINDOW_LENGTH
;
2780 for (j
= 0; j
< ATH9K_NF_CAL_HIST_MAX
; j
++) {
2781 ah
->nfCalHist
[i
].nfCalBuffer
[j
] =
2782 AR_PHY_CCA_MAX_GOOD_VALUE
;
2789 static void ath9k_hw_gpio_cfg_output_mux(struct ath_hal
*ah
,
2793 u32 gpio_shift
, tmp
;
2796 addr
= AR_GPIO_OUTPUT_MUX3
;
2798 addr
= AR_GPIO_OUTPUT_MUX2
;
2800 addr
= AR_GPIO_OUTPUT_MUX1
;
2802 gpio_shift
= (gpio
% 6) * 5;
2804 if (AR_SREV_9280_20_OR_LATER(ah
)
2805 || (addr
!= AR_GPIO_OUTPUT_MUX1
)) {
2806 REG_RMW(ah
, addr
, (type
<< gpio_shift
),
2807 (0x1f << gpio_shift
));
2809 tmp
= REG_READ(ah
, addr
);
2810 tmp
= ((tmp
& 0x1F0) << 1) | (tmp
& ~0x1F0);
2811 tmp
&= ~(0x1f << gpio_shift
);
2812 tmp
|= (type
<< gpio_shift
);
2813 REG_WRITE(ah
, addr
, tmp
);
2817 void ath9k_hw_cfg_output(struct ath_hal
*ah
, u32 gpio
,
2822 ath9k_hw_gpio_cfg_output_mux(ah
, gpio
, ah_signal_type
);
2824 gpio_shift
= 2 * gpio
;
2828 (AR_GPIO_OE_OUT_DRV_ALL
<< gpio_shift
),
2829 (AR_GPIO_OE_OUT_DRV
<< gpio_shift
));
2832 void ath9k_hw_set_gpio(struct ath_hal
*ah
, u32 gpio
, u32 val
)
2834 REG_RMW(ah
, AR_GPIO_IN_OUT
, ((val
& 1) << gpio
),
2839 * Configure GPIO Input lines
2841 void ath9k_hw_cfg_gpio_input(struct ath_hal
*ah
, u32 gpio
)
2845 ASSERT(gpio
< ah
->ah_caps
.num_gpio_pins
);
2847 gpio_shift
= gpio
<< 1;
2851 (AR_GPIO_OE_OUT_DRV_NO
<< gpio_shift
),
2852 (AR_GPIO_OE_OUT_DRV
<< gpio_shift
));
2855 #ifdef CONFIG_RFKILL
2856 static void ath9k_enable_rfkill(struct ath_hal
*ah
)
2858 REG_SET_BIT(ah
, AR_GPIO_INPUT_EN_VAL
,
2859 AR_GPIO_INPUT_EN_VAL_RFSILENT_BB
);
2861 REG_CLR_BIT(ah
, AR_GPIO_INPUT_MUX2
,
2862 AR_GPIO_INPUT_MUX2_RFSILENT
);
2864 ath9k_hw_cfg_gpio_input(ah
, ah
->ah_rfkill_gpio
);
2865 REG_SET_BIT(ah
, AR_PHY_TEST
, RFSILENT_BB
);
2869 u32
ath9k_hw_gpio_get(struct ath_hal
*ah
, u32 gpio
)
2871 if (gpio
>= ah
->ah_caps
.num_gpio_pins
)
2874 if (AR_SREV_9280_10_OR_LATER(ah
)) {
2876 (REG_READ(ah
, AR_GPIO_IN_OUT
),
2877 AR928X_GPIO_IN_VAL
) & AR_GPIO_BIT(gpio
)) != 0;
2879 return (MS(REG_READ(ah
, AR_GPIO_IN_OUT
), AR_GPIO_IN_VAL
) &
2880 AR_GPIO_BIT(gpio
)) != 0;
2884 static int ath9k_hw_post_attach(struct ath_hal
*ah
)
2888 if (!ath9k_hw_chip_test(ah
)) {
2889 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
2890 "%s: hardware self-test failed\n", __func__
);
2894 ecode
= ath9k_hw_rf_claim(ah
);
2898 ecode
= ath9k_hw_eeprom_attach(ah
);
2901 ecode
= ath9k_hw_rfattach(ah
);
2905 if (!AR_SREV_9100(ah
)) {
2906 ath9k_hw_ani_setup(ah
);
2907 ath9k_hw_ani_attach(ah
);
2912 static u32
ath9k_hw_ini_fixup(struct ath_hal
*ah
,
2913 struct ar5416_eeprom
*pEepData
,
2916 struct base_eep_header
*pBase
= &(pEepData
->baseEepHeader
);
2918 switch (ah
->ah_devid
) {
2919 case AR9280_DEVID_PCI
:
2920 if (reg
== 0x7894) {
2921 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2922 "ini VAL: %x EEPROM: %x\n", value
,
2923 (pBase
->version
& 0xff));
2925 if ((pBase
->version
& 0xff) > 0x0a) {
2926 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2929 value
&= ~AR_AN_TOP2_PWDCLKIND
;
2930 value
|= AR_AN_TOP2_PWDCLKIND
& (pBase
->
2931 pwdclkind
<< AR_AN_TOP2_PWDCLKIND_S
);
2933 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2934 "PWDCLKIND Earlier Rev\n");
2937 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2938 "final ini VAL: %x\n", value
);
2945 static bool ath9k_hw_fill_cap_info(struct ath_hal
*ah
)
2947 struct ath_hal_5416
*ahp
= AH5416(ah
);
2948 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
2949 u16 capField
= 0, eeval
;
2951 eeval
= ath9k_hw_get_eeprom(ahp
, EEP_REG_0
);
2953 ah
->ah_currentRD
= eeval
;
2955 eeval
= ath9k_hw_get_eeprom(ahp
, EEP_REG_1
);
2956 ah
->ah_currentRDExt
= eeval
;
2958 capField
= ath9k_hw_get_eeprom(ahp
, EEP_OP_CAP
);
2960 if (ah
->ah_opmode
!= ATH9K_M_HOSTAP
&&
2961 ah
->ah_subvendorid
== AR_SUBVENDOR_ID_NEW_A
) {
2962 if (ah
->ah_currentRD
== 0x64 || ah
->ah_currentRD
== 0x65)
2963 ah
->ah_currentRD
+= 5;
2964 else if (ah
->ah_currentRD
== 0x41)
2965 ah
->ah_currentRD
= 0x43;
2966 DPRINTF(ah
->ah_sc
, ATH_DBG_REGULATORY
,
2967 "%s: regdomain mapped to 0x%x\n", __func__
,
2971 eeval
= ath9k_hw_get_eeprom(ahp
, EEP_OP_MODE
);
2972 bitmap_zero(pCap
->wireless_modes
, ATH9K_MODE_MAX
);
2974 if (eeval
& AR5416_OPFLAGS_11A
) {
2975 set_bit(ATH9K_MODE_11A
, pCap
->wireless_modes
);
2976 if (ah
->ah_config
.ht_enable
) {
2977 if (!(eeval
& AR5416_OPFLAGS_N_5G_HT20
))
2978 set_bit(ATH9K_MODE_11NA_HT20
,
2979 pCap
->wireless_modes
);
2980 if (!(eeval
& AR5416_OPFLAGS_N_5G_HT40
)) {
2981 set_bit(ATH9K_MODE_11NA_HT40PLUS
,
2982 pCap
->wireless_modes
);
2983 set_bit(ATH9K_MODE_11NA_HT40MINUS
,
2984 pCap
->wireless_modes
);
2989 if (eeval
& AR5416_OPFLAGS_11G
) {
2990 set_bit(ATH9K_MODE_11B
, pCap
->wireless_modes
);
2991 set_bit(ATH9K_MODE_11G
, pCap
->wireless_modes
);
2992 if (ah
->ah_config
.ht_enable
) {
2993 if (!(eeval
& AR5416_OPFLAGS_N_2G_HT20
))
2994 set_bit(ATH9K_MODE_11NG_HT20
,
2995 pCap
->wireless_modes
);
2996 if (!(eeval
& AR5416_OPFLAGS_N_2G_HT40
)) {
2997 set_bit(ATH9K_MODE_11NG_HT40PLUS
,
2998 pCap
->wireless_modes
);
2999 set_bit(ATH9K_MODE_11NG_HT40MINUS
,
3000 pCap
->wireless_modes
);
3005 pCap
->tx_chainmask
= ath9k_hw_get_eeprom(ahp
, EEP_TX_MASK
);
3006 if ((ah
->ah_isPciExpress
)
3007 || (eeval
& AR5416_OPFLAGS_11A
)) {
3008 pCap
->rx_chainmask
=
3009 ath9k_hw_get_eeprom(ahp
, EEP_RX_MASK
);
3011 pCap
->rx_chainmask
=
3012 (ath9k_hw_gpio_get(ah
, 0)) ? 0x5 : 0x7;
3015 if (!(AR_SREV_9280(ah
) && (ah
->ah_macRev
== 0)))
3016 ahp
->ah_miscMode
|= AR_PCU_MIC_NEW_LOC_ENA
;
3018 pCap
->low_2ghz_chan
= 2312;
3019 pCap
->high_2ghz_chan
= 2732;
3021 pCap
->low_5ghz_chan
= 4920;
3022 pCap
->high_5ghz_chan
= 6100;
3024 pCap
->hw_caps
&= ~ATH9K_HW_CAP_CIPHER_CKIP
;
3025 pCap
->hw_caps
|= ATH9K_HW_CAP_CIPHER_TKIP
;
3026 pCap
->hw_caps
|= ATH9K_HW_CAP_CIPHER_AESCCM
;
3028 pCap
->hw_caps
&= ~ATH9K_HW_CAP_MIC_CKIP
;
3029 pCap
->hw_caps
|= ATH9K_HW_CAP_MIC_TKIP
;
3030 pCap
->hw_caps
|= ATH9K_HW_CAP_MIC_AESCCM
;
3032 pCap
->hw_caps
|= ATH9K_HW_CAP_CHAN_SPREAD
;
3034 if (ah
->ah_config
.ht_enable
)
3035 pCap
->hw_caps
|= ATH9K_HW_CAP_HT
;
3037 pCap
->hw_caps
&= ~ATH9K_HW_CAP_HT
;
3039 pCap
->hw_caps
|= ATH9K_HW_CAP_GTT
;
3040 pCap
->hw_caps
|= ATH9K_HW_CAP_VEOL
;
3041 pCap
->hw_caps
|= ATH9K_HW_CAP_BSSIDMASK
;
3042 pCap
->hw_caps
&= ~ATH9K_HW_CAP_MCAST_KEYSEARCH
;
3044 if (capField
& AR_EEPROM_EEPCAP_MAXQCU
)
3045 pCap
->total_queues
=
3046 MS(capField
, AR_EEPROM_EEPCAP_MAXQCU
);
3048 pCap
->total_queues
= ATH9K_NUM_TX_QUEUES
;
3050 if (capField
& AR_EEPROM_EEPCAP_KC_ENTRIES
)
3051 pCap
->keycache_size
=
3052 1 << MS(capField
, AR_EEPROM_EEPCAP_KC_ENTRIES
);
3054 pCap
->keycache_size
= AR_KEYTABLE_SIZE
;
3056 pCap
->hw_caps
|= ATH9K_HW_CAP_FASTCC
;
3057 pCap
->num_mr_retries
= 4;
3058 pCap
->tx_triglevel_max
= MAX_TX_FIFO_THRESHOLD
;
3060 if (AR_SREV_9280_10_OR_LATER(ah
))
3061 pCap
->num_gpio_pins
= AR928X_NUM_GPIO
;
3063 pCap
->num_gpio_pins
= AR_NUM_GPIO
;
3065 if (AR_SREV_9280_10_OR_LATER(ah
)) {
3066 pCap
->hw_caps
|= ATH9K_HW_CAP_WOW
;
3067 pCap
->hw_caps
|= ATH9K_HW_CAP_WOW_MATCHPATTERN_EXACT
;
3069 pCap
->hw_caps
&= ~ATH9K_HW_CAP_WOW
;
3070 pCap
->hw_caps
&= ~ATH9K_HW_CAP_WOW_MATCHPATTERN_EXACT
;
3073 if (AR_SREV_9160_10_OR_LATER(ah
) || AR_SREV_9100(ah
)) {
3074 pCap
->hw_caps
|= ATH9K_HW_CAP_CST
;
3075 pCap
->rts_aggr_limit
= ATH_AMPDU_LIMIT_MAX
;
3077 pCap
->rts_aggr_limit
= (8 * 1024);
3080 pCap
->hw_caps
|= ATH9K_HW_CAP_ENHANCEDPM
;
3082 #ifdef CONFIG_RFKILL
3083 ah
->ah_rfsilent
= ath9k_hw_get_eeprom(ahp
, EEP_RF_SILENT
);
3084 if (ah
->ah_rfsilent
& EEP_RFSILENT_ENABLED
) {
3085 ah
->ah_rfkill_gpio
=
3086 MS(ah
->ah_rfsilent
, EEP_RFSILENT_GPIO_SEL
);
3087 ah
->ah_rfkill_polarity
=
3088 MS(ah
->ah_rfsilent
, EEP_RFSILENT_POLARITY
);
3090 pCap
->hw_caps
|= ATH9K_HW_CAP_RFSILENT
;
3094 if ((ah
->ah_macVersion
== AR_SREV_VERSION_5416_PCI
) ||
3095 (ah
->ah_macVersion
== AR_SREV_VERSION_5416_PCIE
) ||
3096 (ah
->ah_macVersion
== AR_SREV_VERSION_9160
) ||
3097 (ah
->ah_macVersion
== AR_SREV_VERSION_9100
) ||
3098 (ah
->ah_macVersion
== AR_SREV_VERSION_9280
))
3099 pCap
->hw_caps
&= ~ATH9K_HW_CAP_AUTOSLEEP
;
3101 pCap
->hw_caps
|= ATH9K_HW_CAP_AUTOSLEEP
;
3103 if (AR_SREV_9280(ah
))
3104 pCap
->hw_caps
&= ~ATH9K_HW_CAP_4KB_SPLITTRANS
;
3106 pCap
->hw_caps
|= ATH9K_HW_CAP_4KB_SPLITTRANS
;
3108 if (ah
->ah_currentRDExt
& (1 << REG_EXT_JAPAN_MIDBAND
)) {
3110 AR_EEPROM_EEREGCAP_EN_KK_NEW_11A
|
3111 AR_EEPROM_EEREGCAP_EN_KK_U1_EVEN
|
3112 AR_EEPROM_EEREGCAP_EN_KK_U2
|
3113 AR_EEPROM_EEREGCAP_EN_KK_MIDBAND
;
3116 AR_EEPROM_EEREGCAP_EN_KK_NEW_11A
|
3117 AR_EEPROM_EEREGCAP_EN_KK_U1_EVEN
;
3120 pCap
->reg_cap
|= AR_EEPROM_EEREGCAP_EN_FCC_MIDBAND
;
3122 pCap
->num_antcfg_5ghz
=
3123 ath9k_hw_get_num_ant_config(ahp
, IEEE80211_BAND_5GHZ
);
3124 pCap
->num_antcfg_2ghz
=
3125 ath9k_hw_get_num_ant_config(ahp
, IEEE80211_BAND_2GHZ
);
3130 static void ar5416DisablePciePhy(struct ath_hal
*ah
)
3132 if (!AR_SREV_9100(ah
))
3135 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x9248fc00);
3136 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x24924924);
3137 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x28000029);
3138 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x57160824);
3139 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x25980579);
3140 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x00000000);
3141 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x1aaabe40);
3142 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xbe105554);
3143 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x000e1007);
3145 REG_WRITE(ah
, AR_PCIE_SERDES2
, 0x00000000);
3148 static void ath9k_set_power_sleep(struct ath_hal
*ah
, int setChip
)
3150 REG_SET_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PWR_SAV
);
3152 REG_CLR_BIT(ah
, AR_RTC_FORCE_WAKE
,
3153 AR_RTC_FORCE_WAKE_EN
);
3154 if (!AR_SREV_9100(ah
))
3155 REG_WRITE(ah
, AR_RC
, AR_RC_AHB
| AR_RC_HOSTIF
);
3157 REG_CLR_BIT(ah
, (u16
) (AR_RTC_RESET
),
3162 static void ath9k_set_power_network_sleep(struct ath_hal
*ah
, int setChip
)
3164 REG_SET_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PWR_SAV
);
3166 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
3168 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)) {
3169 REG_WRITE(ah
, AR_RTC_FORCE_WAKE
,
3170 AR_RTC_FORCE_WAKE_ON_INT
);
3172 REG_CLR_BIT(ah
, AR_RTC_FORCE_WAKE
,
3173 AR_RTC_FORCE_WAKE_EN
);
3178 static bool ath9k_hw_set_power_awake(struct ath_hal
*ah
,
3185 if ((REG_READ(ah
, AR_RTC_STATUS
) & AR_RTC_STATUS_M
) ==
3186 AR_RTC_STATUS_SHUTDOWN
) {
3187 if (ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_POWER_ON
)
3192 if (AR_SREV_9100(ah
))
3193 REG_SET_BIT(ah
, AR_RTC_RESET
,
3196 REG_SET_BIT(ah
, AR_RTC_FORCE_WAKE
,
3197 AR_RTC_FORCE_WAKE_EN
);
3200 for (i
= POWER_UP_TIME
/ 50; i
> 0; i
--) {
3201 val
= REG_READ(ah
, AR_RTC_STATUS
) & AR_RTC_STATUS_M
;
3202 if (val
== AR_RTC_STATUS_ON
)
3205 REG_SET_BIT(ah
, AR_RTC_FORCE_WAKE
,
3206 AR_RTC_FORCE_WAKE_EN
);
3209 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
3210 "%s: Failed to wakeup in %uus\n",
3211 __func__
, POWER_UP_TIME
/ 20);
3216 REG_CLR_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PWR_SAV
);
3220 bool ath9k_hw_setpower(struct ath_hal
*ah
,
3221 enum ath9k_power_mode mode
)
3223 struct ath_hal_5416
*ahp
= AH5416(ah
);
3224 static const char *modes
[] = {
3230 int status
= true, setChip
= true;
3232 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
, "%s: %s -> %s (%s)\n", __func__
,
3233 modes
[ahp
->ah_powerMode
], modes
[mode
],
3234 setChip
? "set chip " : "");
3237 case ATH9K_PM_AWAKE
:
3238 status
= ath9k_hw_set_power_awake(ah
, setChip
);
3240 case ATH9K_PM_FULL_SLEEP
:
3241 ath9k_set_power_sleep(ah
, setChip
);
3242 ahp
->ah_chipFullSleep
= true;
3244 case ATH9K_PM_NETWORK_SLEEP
:
3245 ath9k_set_power_network_sleep(ah
, setChip
);
3248 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
3249 "%s: unknown power mode %u\n", __func__
, mode
);
3252 ahp
->ah_powerMode
= mode
;
3256 static struct ath_hal
*ath9k_hw_do_attach(u16 devid
,
3257 struct ath_softc
*sc
,
3261 struct ath_hal_5416
*ahp
;
3264 #ifndef CONFIG_SLOW_ANT_DIV
3269 ahp
= ath9k_hw_newstate(devid
, sc
, mem
, status
);
3275 ath9k_hw_set_defaults(ah
);
3277 if (ah
->ah_config
.intr_mitigation
!= 0)
3278 ahp
->ah_intrMitigation
= true;
3280 if (!ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_POWER_ON
)) {
3281 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: couldn't reset chip\n",
3287 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
)) {
3288 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: couldn't wakeup chip\n",
3294 if (ah
->ah_config
.serialize_regmode
== SER_REG_MODE_AUTO
) {
3295 if (ah
->ah_macVersion
== AR_SREV_VERSION_5416_PCI
) {
3296 ah
->ah_config
.serialize_regmode
=
3299 ah
->ah_config
.serialize_regmode
=
3303 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3304 "%s: serialize_regmode is %d\n",
3305 __func__
, ah
->ah_config
.serialize_regmode
);
3307 if ((ah
->ah_macVersion
!= AR_SREV_VERSION_5416_PCI
) &&
3308 (ah
->ah_macVersion
!= AR_SREV_VERSION_5416_PCIE
) &&
3309 (ah
->ah_macVersion
!= AR_SREV_VERSION_9160
) &&
3310 (!AR_SREV_9100(ah
)) && (!AR_SREV_9280(ah
))) {
3311 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3312 "%s: Mac Chip Rev 0x%02x.%x is not supported by "
3313 "this driver\n", __func__
,
3314 ah
->ah_macVersion
, ah
->ah_macRev
);
3315 ecode
= -EOPNOTSUPP
;
3319 if (AR_SREV_9100(ah
)) {
3320 ahp
->ah_iqCalData
.calData
= &iq_cal_multi_sample
;
3321 ahp
->ah_suppCals
= IQ_MISMATCH_CAL
;
3322 ah
->ah_isPciExpress
= false;
3324 ah
->ah_phyRev
= REG_READ(ah
, AR_PHY_CHIP_ID
);
3326 if (AR_SREV_9160_10_OR_LATER(ah
)) {
3327 if (AR_SREV_9280_10_OR_LATER(ah
)) {
3328 ahp
->ah_iqCalData
.calData
= &iq_cal_single_sample
;
3329 ahp
->ah_adcGainCalData
.calData
=
3330 &adc_gain_cal_single_sample
;
3331 ahp
->ah_adcDcCalData
.calData
=
3332 &adc_dc_cal_single_sample
;
3333 ahp
->ah_adcDcCalInitData
.calData
=
3336 ahp
->ah_iqCalData
.calData
= &iq_cal_multi_sample
;
3337 ahp
->ah_adcGainCalData
.calData
=
3338 &adc_gain_cal_multi_sample
;
3339 ahp
->ah_adcDcCalData
.calData
=
3340 &adc_dc_cal_multi_sample
;
3341 ahp
->ah_adcDcCalInitData
.calData
=
3345 ADC_GAIN_CAL
| ADC_DC_CAL
| IQ_MISMATCH_CAL
;
3348 if (AR_SREV_9160(ah
)) {
3349 ah
->ah_config
.enable_ani
= 1;
3350 ahp
->ah_ani_function
= (ATH9K_ANI_SPUR_IMMUNITY_LEVEL
|
3351 ATH9K_ANI_FIRSTEP_LEVEL
);
3353 ahp
->ah_ani_function
= ATH9K_ANI_ALL
;
3354 if (AR_SREV_9280_10_OR_LATER(ah
)) {
3355 ahp
->ah_ani_function
&=
3356 ~ATH9K_ANI_NOISE_IMMUNITY_LEVEL
;
3360 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3361 "%s: This Mac Chip Rev 0x%02x.%x is \n", __func__
,
3362 ah
->ah_macVersion
, ah
->ah_macRev
);
3364 if (AR_SREV_9280_20_OR_LATER(ah
)) {
3365 INIT_INI_ARRAY(&ahp
->ah_iniModes
, ar9280Modes_9280_2
,
3366 ARRAY_SIZE(ar9280Modes_9280_2
), 6);
3367 INIT_INI_ARRAY(&ahp
->ah_iniCommon
, ar9280Common_9280_2
,
3368 ARRAY_SIZE(ar9280Common_9280_2
), 2);
3370 if (ah
->ah_config
.pcie_clock_req
) {
3371 INIT_INI_ARRAY(&ahp
->ah_iniPcieSerdes
,
3372 ar9280PciePhy_clkreq_off_L1_9280
,
3374 (ar9280PciePhy_clkreq_off_L1_9280
),
3377 INIT_INI_ARRAY(&ahp
->ah_iniPcieSerdes
,
3378 ar9280PciePhy_clkreq_always_on_L1_9280
,
3380 (ar9280PciePhy_clkreq_always_on_L1_9280
),
3383 INIT_INI_ARRAY(&ahp
->ah_iniModesAdditional
,
3384 ar9280Modes_fast_clock_9280_2
,
3385 ARRAY_SIZE(ar9280Modes_fast_clock_9280_2
),
3387 } else if (AR_SREV_9280_10_OR_LATER(ah
)) {
3388 INIT_INI_ARRAY(&ahp
->ah_iniModes
, ar9280Modes_9280
,
3389 ARRAY_SIZE(ar9280Modes_9280
), 6);
3390 INIT_INI_ARRAY(&ahp
->ah_iniCommon
, ar9280Common_9280
,
3391 ARRAY_SIZE(ar9280Common_9280
), 2);
3392 } else if (AR_SREV_9160_10_OR_LATER(ah
)) {
3393 INIT_INI_ARRAY(&ahp
->ah_iniModes
, ar5416Modes_9160
,
3394 ARRAY_SIZE(ar5416Modes_9160
), 6);
3395 INIT_INI_ARRAY(&ahp
->ah_iniCommon
, ar5416Common_9160
,
3396 ARRAY_SIZE(ar5416Common_9160
), 2);
3397 INIT_INI_ARRAY(&ahp
->ah_iniBank0
, ar5416Bank0_9160
,
3398 ARRAY_SIZE(ar5416Bank0_9160
), 2);
3399 INIT_INI_ARRAY(&ahp
->ah_iniBB_RfGain
, ar5416BB_RfGain_9160
,
3400 ARRAY_SIZE(ar5416BB_RfGain_9160
), 3);
3401 INIT_INI_ARRAY(&ahp
->ah_iniBank1
, ar5416Bank1_9160
,
3402 ARRAY_SIZE(ar5416Bank1_9160
), 2);
3403 INIT_INI_ARRAY(&ahp
->ah_iniBank2
, ar5416Bank2_9160
,
3404 ARRAY_SIZE(ar5416Bank2_9160
), 2);
3405 INIT_INI_ARRAY(&ahp
->ah_iniBank3
, ar5416Bank3_9160
,
3406 ARRAY_SIZE(ar5416Bank3_9160
), 3);
3407 INIT_INI_ARRAY(&ahp
->ah_iniBank6
, ar5416Bank6_9160
,
3408 ARRAY_SIZE(ar5416Bank6_9160
), 3);
3409 INIT_INI_ARRAY(&ahp
->ah_iniBank6TPC
, ar5416Bank6TPC_9160
,
3410 ARRAY_SIZE(ar5416Bank6TPC_9160
), 3);
3411 INIT_INI_ARRAY(&ahp
->ah_iniBank7
, ar5416Bank7_9160
,
3412 ARRAY_SIZE(ar5416Bank7_9160
), 2);
3413 if (AR_SREV_9160_11(ah
)) {
3414 INIT_INI_ARRAY(&ahp
->ah_iniAddac
,
3415 ar5416Addac_91601_1
,
3416 ARRAY_SIZE(ar5416Addac_91601_1
), 2);
3418 INIT_INI_ARRAY(&ahp
->ah_iniAddac
, ar5416Addac_9160
,
3419 ARRAY_SIZE(ar5416Addac_9160
), 2);
3421 } else if (AR_SREV_9100_OR_LATER(ah
)) {
3422 INIT_INI_ARRAY(&ahp
->ah_iniModes
, ar5416Modes_9100
,
3423 ARRAY_SIZE(ar5416Modes_9100
), 6);
3424 INIT_INI_ARRAY(&ahp
->ah_iniCommon
, ar5416Common_9100
,
3425 ARRAY_SIZE(ar5416Common_9100
), 2);
3426 INIT_INI_ARRAY(&ahp
->ah_iniBank0
, ar5416Bank0_9100
,
3427 ARRAY_SIZE(ar5416Bank0_9100
), 2);
3428 INIT_INI_ARRAY(&ahp
->ah_iniBB_RfGain
, ar5416BB_RfGain_9100
,
3429 ARRAY_SIZE(ar5416BB_RfGain_9100
), 3);
3430 INIT_INI_ARRAY(&ahp
->ah_iniBank1
, ar5416Bank1_9100
,
3431 ARRAY_SIZE(ar5416Bank1_9100
), 2);
3432 INIT_INI_ARRAY(&ahp
->ah_iniBank2
, ar5416Bank2_9100
,
3433 ARRAY_SIZE(ar5416Bank2_9100
), 2);
3434 INIT_INI_ARRAY(&ahp
->ah_iniBank3
, ar5416Bank3_9100
,
3435 ARRAY_SIZE(ar5416Bank3_9100
), 3);
3436 INIT_INI_ARRAY(&ahp
->ah_iniBank6
, ar5416Bank6_9100
,
3437 ARRAY_SIZE(ar5416Bank6_9100
), 3);
3438 INIT_INI_ARRAY(&ahp
->ah_iniBank6TPC
, ar5416Bank6TPC_9100
,
3439 ARRAY_SIZE(ar5416Bank6TPC_9100
), 3);
3440 INIT_INI_ARRAY(&ahp
->ah_iniBank7
, ar5416Bank7_9100
,
3441 ARRAY_SIZE(ar5416Bank7_9100
), 2);
3442 INIT_INI_ARRAY(&ahp
->ah_iniAddac
, ar5416Addac_9100
,
3443 ARRAY_SIZE(ar5416Addac_9100
), 2);
3445 INIT_INI_ARRAY(&ahp
->ah_iniModes
, ar5416Modes
,
3446 ARRAY_SIZE(ar5416Modes
), 6);
3447 INIT_INI_ARRAY(&ahp
->ah_iniCommon
, ar5416Common
,
3448 ARRAY_SIZE(ar5416Common
), 2);
3449 INIT_INI_ARRAY(&ahp
->ah_iniBank0
, ar5416Bank0
,
3450 ARRAY_SIZE(ar5416Bank0
), 2);
3451 INIT_INI_ARRAY(&ahp
->ah_iniBB_RfGain
, ar5416BB_RfGain
,
3452 ARRAY_SIZE(ar5416BB_RfGain
), 3);
3453 INIT_INI_ARRAY(&ahp
->ah_iniBank1
, ar5416Bank1
,
3454 ARRAY_SIZE(ar5416Bank1
), 2);
3455 INIT_INI_ARRAY(&ahp
->ah_iniBank2
, ar5416Bank2
,
3456 ARRAY_SIZE(ar5416Bank2
), 2);
3457 INIT_INI_ARRAY(&ahp
->ah_iniBank3
, ar5416Bank3
,
3458 ARRAY_SIZE(ar5416Bank3
), 3);
3459 INIT_INI_ARRAY(&ahp
->ah_iniBank6
, ar5416Bank6
,
3460 ARRAY_SIZE(ar5416Bank6
), 3);
3461 INIT_INI_ARRAY(&ahp
->ah_iniBank6TPC
, ar5416Bank6TPC
,
3462 ARRAY_SIZE(ar5416Bank6TPC
), 3);
3463 INIT_INI_ARRAY(&ahp
->ah_iniBank7
, ar5416Bank7
,
3464 ARRAY_SIZE(ar5416Bank7
), 2);
3465 INIT_INI_ARRAY(&ahp
->ah_iniAddac
, ar5416Addac
,
3466 ARRAY_SIZE(ar5416Addac
), 2);
3469 if (ah
->ah_isPciExpress
)
3470 ath9k_hw_configpcipowersave(ah
, 0);
3472 ar5416DisablePciePhy(ah
);
3474 ecode
= ath9k_hw_post_attach(ah
);
3478 #ifndef CONFIG_SLOW_ANT_DIV
3479 if (ah
->ah_devid
== AR9280_DEVID_PCI
) {
3480 for (i
= 0; i
< ahp
->ah_iniModes
.ia_rows
; i
++) {
3481 u32 reg
= INI_RA(&ahp
->ah_iniModes
, i
, 0);
3483 for (j
= 1; j
< ahp
->ah_iniModes
.ia_columns
; j
++) {
3484 u32 val
= INI_RA(&ahp
->ah_iniModes
, i
, j
);
3486 INI_RA(&ahp
->ah_iniModes
, i
, j
) =
3487 ath9k_hw_ini_fixup(ah
, &ahp
->ah_eeprom
,
3494 if (!ath9k_hw_fill_cap_info(ah
)) {
3495 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3496 "%s:failed ath9k_hw_fill_cap_info\n", __func__
);
3501 ecode
= ath9k_hw_init_macaddr(ah
);
3503 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3504 "%s: failed initializing mac address\n",
3509 if (AR_SREV_9285(ah
))
3510 ah
->ah_txTrigLevel
= (AR_FTRIG_256B
>> AR_FTRIG_S
);
3512 ah
->ah_txTrigLevel
= (AR_FTRIG_512B
>> AR_FTRIG_S
);
3514 #ifndef ATH_NF_PER_CHAN
3516 ath9k_init_nfcal_hist_buffer(ah
);
3523 ath9k_hw_detach((struct ath_hal
*) ahp
);
3529 void ath9k_hw_detach(struct ath_hal
*ah
)
3531 if (!AR_SREV_9100(ah
))
3532 ath9k_hw_ani_detach(ah
);
3533 ath9k_hw_rfdetach(ah
);
3535 ath9k_hw_setpower(ah
, ATH9K_PM_FULL_SLEEP
);
3539 bool ath9k_get_channel_edges(struct ath_hal
*ah
,
3540 u16 flags
, u16
*low
,
3543 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
3545 if (flags
& CHANNEL_5GHZ
) {
3546 *low
= pCap
->low_5ghz_chan
;
3547 *high
= pCap
->high_5ghz_chan
;
3550 if ((flags
& CHANNEL_2GHZ
)) {
3551 *low
= pCap
->low_2ghz_chan
;
3552 *high
= pCap
->high_2ghz_chan
;
3559 static inline bool ath9k_hw_fill_vpd_table(u8 pwrMin
,
3568 u8 currPwr
= pwrMin
;
3569 u16 idxL
= 0, idxR
= 0;
3571 for (i
= 0; i
<= (pwrMax
- pwrMin
) / 2; i
++) {
3572 ath9k_hw_get_lower_upper_index(currPwr
, pPwrList
,
3573 numIntercepts
, &(idxL
),
3577 if (idxL
== numIntercepts
- 1)
3578 idxL
= (u16
) (numIntercepts
- 2);
3579 if (pPwrList
[idxL
] == pPwrList
[idxR
])
3582 k
= (u16
) (((currPwr
-
3586 currPwr
) * pVpdList
[idxL
]) /
3589 pRetVpdList
[i
] = (u8
) k
;
3597 ath9k_hw_get_gain_boundaries_pdadcs(struct ath_hal
*ah
,
3598 struct ath9k_channel
*chan
,
3599 struct cal_data_per_freq
*pRawDataSet
,
3603 int16_t *pMinCalPower
,
3604 u16
*pPdGainBoundaries
,
3610 u16 idxL
= 0, idxR
= 0, numPiers
;
3611 static u8 vpdTableL
[AR5416_NUM_PD_GAINS
]
3612 [AR5416_MAX_PWR_RANGE_IN_HALF_DB
];
3613 static u8 vpdTableR
[AR5416_NUM_PD_GAINS
]
3614 [AR5416_MAX_PWR_RANGE_IN_HALF_DB
];
3615 static u8 vpdTableI
[AR5416_NUM_PD_GAINS
]
3616 [AR5416_MAX_PWR_RANGE_IN_HALF_DB
];
3618 u8
*pVpdL
, *pVpdR
, *pPwrL
, *pPwrR
;
3619 u8 minPwrT4
[AR5416_NUM_PD_GAINS
];
3620 u8 maxPwrT4
[AR5416_NUM_PD_GAINS
];
3623 u16 sizeCurrVpdTable
, maxIndex
, tgtIndex
;
3625 int16_t minDelta
= 0;
3626 struct chan_centers centers
;
3628 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
3630 for (numPiers
= 0; numPiers
< availPiers
; numPiers
++) {
3631 if (bChans
[numPiers
] == AR5416_BCHAN_UNUSED
)
3635 match
= ath9k_hw_get_lower_upper_index((u8
)
3640 numPiers
, &idxL
, &idxR
);
3643 for (i
= 0; i
< numXpdGains
; i
++) {
3644 minPwrT4
[i
] = pRawDataSet
[idxL
].pwrPdg
[i
][0];
3645 maxPwrT4
[i
] = pRawDataSet
[idxL
].pwrPdg
[i
][4];
3646 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
3651 AR5416_PD_GAIN_ICEPTS
,
3655 for (i
= 0; i
< numXpdGains
; i
++) {
3656 pVpdL
= pRawDataSet
[idxL
].vpdPdg
[i
];
3657 pPwrL
= pRawDataSet
[idxL
].pwrPdg
[i
];
3658 pVpdR
= pRawDataSet
[idxR
].vpdPdg
[i
];
3659 pPwrR
= pRawDataSet
[idxR
].pwrPdg
[i
];
3661 minPwrT4
[i
] = max(pPwrL
[0], pPwrR
[0]);
3664 min(pPwrL
[AR5416_PD_GAIN_ICEPTS
- 1],
3665 pPwrR
[AR5416_PD_GAIN_ICEPTS
- 1]);
3668 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
3670 AR5416_PD_GAIN_ICEPTS
,
3672 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
3674 AR5416_PD_GAIN_ICEPTS
,
3677 for (j
= 0; j
<= (maxPwrT4
[i
] - minPwrT4
[i
]) / 2; j
++) {
3679 (u8
) (ath9k_hw_interpolate
3686 bChans
[idxR
], vpdTableL
[i
]
3693 *pMinCalPower
= (int16_t) (minPwrT4
[0] / 2);
3696 for (i
= 0; i
< numXpdGains
; i
++) {
3697 if (i
== (numXpdGains
- 1))
3698 pPdGainBoundaries
[i
] =
3699 (u16
) (maxPwrT4
[i
] / 2);
3701 pPdGainBoundaries
[i
] =
3702 (u16
) ((maxPwrT4
[i
] +
3703 minPwrT4
[i
+ 1]) / 4);
3705 pPdGainBoundaries
[i
] =
3706 min((u16
) AR5416_MAX_RATE_POWER
,
3707 pPdGainBoundaries
[i
]);
3709 if ((i
== 0) && !AR_SREV_5416_V20_OR_LATER(ah
)) {
3710 minDelta
= pPdGainBoundaries
[0] - 23;
3711 pPdGainBoundaries
[0] = 23;
3717 if (AR_SREV_9280_10_OR_LATER(ah
))
3718 ss
= (int16_t) (0 - (minPwrT4
[i
] / 2));
3722 ss
= (int16_t) ((pPdGainBoundaries
[i
- 1] -
3723 (minPwrT4
[i
] / 2)) -
3724 tPdGainOverlap
+ 1 + minDelta
);
3726 vpdStep
= (int16_t) (vpdTableI
[i
][1] - vpdTableI
[i
][0]);
3727 vpdStep
= (int16_t) ((vpdStep
< 1) ? 1 : vpdStep
);
3729 while ((ss
< 0) && (k
< (AR5416_NUM_PDADC_VALUES
- 1))) {
3730 tmpVal
= (int16_t) (vpdTableI
[i
][0] + ss
* vpdStep
);
3732 (u8
) ((tmpVal
< 0) ? 0 : tmpVal
);
3737 (u8
) ((maxPwrT4
[i
] - minPwrT4
[i
]) / 2 + 1);
3738 tgtIndex
= (u8
) (pPdGainBoundaries
[i
] + tPdGainOverlap
-
3740 maxIndex
= (tgtIndex
<
3741 sizeCurrVpdTable
) ? tgtIndex
: sizeCurrVpdTable
;
3743 while ((ss
< maxIndex
)
3744 && (k
< (AR5416_NUM_PDADC_VALUES
- 1))) {
3745 pPDADCValues
[k
++] = vpdTableI
[i
][ss
++];
3748 vpdStep
= (int16_t) (vpdTableI
[i
][sizeCurrVpdTable
- 1] -
3749 vpdTableI
[i
][sizeCurrVpdTable
- 2]);
3750 vpdStep
= (int16_t) ((vpdStep
< 1) ? 1 : vpdStep
);
3752 if (tgtIndex
> maxIndex
) {
3753 while ((ss
<= tgtIndex
)
3754 && (k
< (AR5416_NUM_PDADC_VALUES
- 1))) {
3755 tmpVal
= (int16_t) ((vpdTableI
[i
]
3757 1] + (ss
- maxIndex
+
3759 pPDADCValues
[k
++] = (u8
) ((tmpVal
>
3760 255) ? 255 : tmpVal
);
3766 while (i
< AR5416_PD_GAINS_IN_MASK
) {
3767 pPdGainBoundaries
[i
] = pPdGainBoundaries
[i
- 1];
3771 while (k
< AR5416_NUM_PDADC_VALUES
) {
3772 pPDADCValues
[k
] = pPDADCValues
[k
- 1];
3779 ath9k_hw_set_power_cal_table(struct ath_hal
*ah
,
3780 struct ar5416_eeprom
*pEepData
,
3781 struct ath9k_channel
*chan
,
3782 int16_t *pTxPowerIndexOffset
)
3784 struct cal_data_per_freq
*pRawDataset
;
3785 u8
*pCalBChans
= NULL
;
3786 u16 pdGainOverlap_t2
;
3787 static u8 pdadcValues
[AR5416_NUM_PDADC_VALUES
];
3788 u16 gainBoundaries
[AR5416_PD_GAINS_IN_MASK
];
3790 int16_t tMinCalPower
;
3791 u16 numXpdGain
, xpdMask
;
3792 u16 xpdGainValues
[AR5416_NUM_PD_GAINS
] = { 0, 0, 0, 0 };
3793 u32 reg32
, regOffset
, regChainOffset
;
3795 struct ath_hal_5416
*ahp
= AH5416(ah
);
3797 modalIdx
= IS_CHAN_2GHZ(chan
) ? 1 : 0;
3798 xpdMask
= pEepData
->modalHeader
[modalIdx
].xpdGain
;
3800 if ((pEepData
->baseEepHeader
.
3801 version
& AR5416_EEP_VER_MINOR_MASK
) >=
3802 AR5416_EEP_MINOR_VER_2
) {
3804 pEepData
->modalHeader
[modalIdx
].pdGainOverlap
;
3808 (REG_READ(ah
, AR_PHY_TPCRG5
),
3809 AR_PHY_TPCRG5_PD_GAIN_OVERLAP
));
3812 if (IS_CHAN_2GHZ(chan
)) {
3813 pCalBChans
= pEepData
->calFreqPier2G
;
3814 numPiers
= AR5416_NUM_2G_CAL_PIERS
;
3816 pCalBChans
= pEepData
->calFreqPier5G
;
3817 numPiers
= AR5416_NUM_5G_CAL_PIERS
;
3822 for (i
= 1; i
<= AR5416_PD_GAINS_IN_MASK
; i
++) {
3823 if ((xpdMask
>> (AR5416_PD_GAINS_IN_MASK
- i
)) & 1) {
3824 if (numXpdGain
>= AR5416_NUM_PD_GAINS
)
3826 xpdGainValues
[numXpdGain
] =
3827 (u16
) (AR5416_PD_GAINS_IN_MASK
- i
);
3832 REG_RMW_FIELD(ah
, AR_PHY_TPCRG1
, AR_PHY_TPCRG1_NUM_PD_GAIN
,
3833 (numXpdGain
- 1) & 0x3);
3834 REG_RMW_FIELD(ah
, AR_PHY_TPCRG1
, AR_PHY_TPCRG1_PD_GAIN_1
,
3836 REG_RMW_FIELD(ah
, AR_PHY_TPCRG1
, AR_PHY_TPCRG1_PD_GAIN_2
,
3838 REG_RMW_FIELD(ah
, AR_PHY_TPCRG1
, AR_PHY_TPCRG1_PD_GAIN_3
,
3841 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
3842 if (AR_SREV_5416_V20_OR_LATER(ah
) &&
3843 (ahp
->ah_rxchainmask
== 5 || ahp
->ah_txchainmask
== 5)
3845 regChainOffset
= (i
== 1) ? 0x2000 : 0x1000;
3847 regChainOffset
= i
* 0x1000;
3848 if (pEepData
->baseEepHeader
.txMask
& (1 << i
)) {
3849 if (IS_CHAN_2GHZ(chan
))
3850 pRawDataset
= pEepData
->calPierData2G
[i
];
3852 pRawDataset
= pEepData
->calPierData5G
[i
];
3854 ath9k_hw_get_gain_boundaries_pdadcs(ah
, chan
,
3864 if ((i
== 0) || AR_SREV_5416_V20_OR_LATER(ah
)) {
3867 AR_PHY_TPCRG5
+ regChainOffset
,
3868 SM(pdGainOverlap_t2
,
3869 AR_PHY_TPCRG5_PD_GAIN_OVERLAP
)
3870 | SM(gainBoundaries
[0],
3871 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_1
)
3872 | SM(gainBoundaries
[1],
3873 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_2
)
3874 | SM(gainBoundaries
[2],
3875 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_3
)
3876 | SM(gainBoundaries
[3],
3877 AR_PHY_TPCRG5_PD_GAIN_BOUNDARY_4
));
3881 AR_PHY_BASE
+ (672 << 2) + regChainOffset
;
3882 for (j
= 0; j
< 32; j
++) {
3884 ((pdadcValues
[4 * j
+ 0] & 0xFF) << 0)
3885 | ((pdadcValues
[4 * j
+ 1] & 0xFF) <<
3886 8) | ((pdadcValues
[4 * j
+ 2] &
3888 ((pdadcValues
[4 * j
+ 3] & 0xFF) <<
3890 REG_WRITE(ah
, regOffset
, reg32
);
3892 DPRINTF(ah
->ah_sc
, ATH_DBG_PHY_IO
,
3893 "PDADC (%d,%4x): %4.4x %8.8x\n",
3894 i
, regChainOffset
, regOffset
,
3896 DPRINTF(ah
->ah_sc
, ATH_DBG_PHY_IO
,
3897 "PDADC: Chain %d | PDADC %3d Value %3d | "
3898 "PDADC %3d Value %3d | PDADC %3d Value %3d | "
3899 "PDADC %3d Value %3d |\n",
3900 i
, 4 * j
, pdadcValues
[4 * j
],
3901 4 * j
+ 1, pdadcValues
[4 * j
+ 1],
3902 4 * j
+ 2, pdadcValues
[4 * j
+ 2],
3904 pdadcValues
[4 * j
+ 3]);
3910 *pTxPowerIndexOffset
= 0;
3915 void ath9k_hw_configpcipowersave(struct ath_hal
*ah
, int restore
)
3917 struct ath_hal_5416
*ahp
= AH5416(ah
);
3920 if (ah
->ah_isPciExpress
!= true)
3923 if (ah
->ah_config
.pcie_powersave_enable
== 2)
3929 if (AR_SREV_9280_20_OR_LATER(ah
)) {
3930 for (i
= 0; i
< ahp
->ah_iniPcieSerdes
.ia_rows
; i
++) {
3931 REG_WRITE(ah
, INI_RA(&ahp
->ah_iniPcieSerdes
, i
, 0),
3932 INI_RA(&ahp
->ah_iniPcieSerdes
, i
, 1));
3935 } else if (AR_SREV_9280(ah
)
3936 && (ah
->ah_macRev
== AR_SREV_REVISION_9280_10
)) {
3937 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x9248fd00);
3938 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x24924924);
3940 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xa8000019);
3941 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x13160820);
3942 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xe5980560);
3944 if (ah
->ah_config
.pcie_clock_req
)
3945 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x401deffc);
3947 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x401deffd);
3949 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x1aaabe40);
3950 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xbe105554);
3951 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x00043007);
3953 REG_WRITE(ah
, AR_PCIE_SERDES2
, 0x00000000);
3957 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x9248fc00);
3958 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x24924924);
3959 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x28000039);
3960 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x53160824);
3961 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xe5980579);
3962 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x001defff);
3963 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x1aaabe40);
3964 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xbe105554);
3965 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x000e3007);
3966 REG_WRITE(ah
, AR_PCIE_SERDES2
, 0x00000000);
3969 REG_SET_BIT(ah
, AR_PCIE_PM_CTRL
, AR_PCIE_PM_CTRL_ENA
);
3971 if (ah
->ah_config
.pcie_waen
) {
3972 REG_WRITE(ah
, AR_WA
, ah
->ah_config
.pcie_waen
);
3974 if (AR_SREV_9280(ah
))
3975 REG_WRITE(ah
, AR_WA
, 0x0040073f);
3977 REG_WRITE(ah
, AR_WA
, 0x0000073f);
3982 ath9k_hw_get_legacy_target_powers(struct ath_hal
*ah
,
3983 struct ath9k_channel
*chan
,
3984 struct cal_target_power_leg
*powInfo
,
3986 struct cal_target_power_leg
*pNewPower
,
3992 int matchIndex
= -1, lowIndex
= -1;
3994 struct chan_centers centers
;
3996 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
3997 freq
= (isExtTarget
) ? centers
.ext_center
: centers
.ctl_center
;
3999 if (freq
<= ath9k_hw_fbin2freq(powInfo
[0].bChannel
,
4000 IS_CHAN_2GHZ(chan
))) {
4003 for (i
= 0; (i
< numChannels
)
4004 && (powInfo
[i
].bChannel
!= AR5416_BCHAN_UNUSED
); i
++) {
4006 ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
4007 IS_CHAN_2GHZ(chan
))) {
4011 ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
4012 IS_CHAN_2GHZ(chan
)))
4014 ath9k_hw_fbin2freq(powInfo
[i
- 1].
4022 if ((matchIndex
== -1) && (lowIndex
== -1))
4026 if (matchIndex
!= -1) {
4027 *pNewPower
= powInfo
[matchIndex
];
4029 clo
= ath9k_hw_fbin2freq(powInfo
[lowIndex
].bChannel
,
4030 IS_CHAN_2GHZ(chan
));
4031 chi
= ath9k_hw_fbin2freq(powInfo
[lowIndex
+ 1].bChannel
,
4032 IS_CHAN_2GHZ(chan
));
4034 for (i
= 0; i
< numRates
; i
++) {
4035 pNewPower
->tPow2x
[i
] =
4036 (u8
) ath9k_hw_interpolate(freq
, clo
, chi
,
4048 ath9k_hw_get_target_powers(struct ath_hal
*ah
,
4049 struct ath9k_channel
*chan
,
4050 struct cal_target_power_ht
*powInfo
,
4052 struct cal_target_power_ht
*pNewPower
,
4058 int matchIndex
= -1, lowIndex
= -1;
4060 struct chan_centers centers
;
4062 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
4063 freq
= isHt40Target
? centers
.synth_center
: centers
.ctl_center
;
4066 ath9k_hw_fbin2freq(powInfo
[0].bChannel
, IS_CHAN_2GHZ(chan
))) {
4069 for (i
= 0; (i
< numChannels
)
4070 && (powInfo
[i
].bChannel
!= AR5416_BCHAN_UNUSED
); i
++) {
4072 ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
4073 IS_CHAN_2GHZ(chan
))) {
4078 ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
4079 IS_CHAN_2GHZ(chan
)))
4081 ath9k_hw_fbin2freq(powInfo
[i
- 1].
4089 if ((matchIndex
== -1) && (lowIndex
== -1))
4093 if (matchIndex
!= -1) {
4094 *pNewPower
= powInfo
[matchIndex
];
4096 clo
= ath9k_hw_fbin2freq(powInfo
[lowIndex
].bChannel
,
4097 IS_CHAN_2GHZ(chan
));
4098 chi
= ath9k_hw_fbin2freq(powInfo
[lowIndex
+ 1].bChannel
,
4099 IS_CHAN_2GHZ(chan
));
4101 for (i
= 0; i
< numRates
; i
++) {
4102 pNewPower
->tPow2x
[i
] =
4103 (u8
) ath9k_hw_interpolate(freq
, clo
, chi
,
4115 ath9k_hw_get_max_edge_power(u16 freq
,
4116 struct cal_ctl_edges
*pRdEdgesPower
,
4119 u16 twiceMaxEdgePower
= AR5416_MAX_RATE_POWER
;
4122 for (i
= 0; (i
< AR5416_NUM_BAND_EDGES
)
4123 && (pRdEdgesPower
[i
].bChannel
!= AR5416_BCHAN_UNUSED
); i
++) {
4124 if (freq
== ath9k_hw_fbin2freq(pRdEdgesPower
[i
].bChannel
,
4126 twiceMaxEdgePower
= pRdEdgesPower
[i
].tPower
;
4130 ath9k_hw_fbin2freq(pRdEdgesPower
[i
].
4131 bChannel
, is2GHz
))) {
4132 if (ath9k_hw_fbin2freq
4133 (pRdEdgesPower
[i
- 1].bChannel
, is2GHz
) < freq
4134 && pRdEdgesPower
[i
- 1].flag
) {
4136 pRdEdgesPower
[i
- 1].tPower
;
4141 return twiceMaxEdgePower
;
4145 ath9k_hw_set_power_per_rate_table(struct ath_hal
*ah
,
4146 struct ar5416_eeprom
*pEepData
,
4147 struct ath9k_channel
*chan
,
4148 int16_t *ratesArray
,
4150 u8 AntennaReduction
,
4151 u8 twiceMaxRegulatoryPower
,
4154 u8 twiceMaxEdgePower
= AR5416_MAX_RATE_POWER
;
4155 static const u16 tpScaleReductionTable
[5] =
4156 { 0, 3, 6, 9, AR5416_MAX_RATE_POWER
};
4159 int8_t twiceLargestAntenna
;
4160 struct cal_ctl_data
*rep
;
4161 struct cal_target_power_leg targetPowerOfdm
, targetPowerCck
= {
4164 struct cal_target_power_leg targetPowerOfdmExt
= {
4165 0, { 0, 0, 0, 0} }, targetPowerCckExt
= {
4168 struct cal_target_power_ht targetPowerHt20
, targetPowerHt40
= {
4171 u8 scaledPower
= 0, minCtlPower
, maxRegAllowedPower
;
4172 u16 ctlModesFor11a
[] =
4173 { CTL_11A
, CTL_5GHT20
, CTL_11A_EXT
, CTL_5GHT40
};
4174 u16 ctlModesFor11g
[] =
4175 { CTL_11B
, CTL_11G
, CTL_2GHT20
, CTL_11B_EXT
, CTL_11G_EXT
,
4178 u16 numCtlModes
, *pCtlMode
, ctlMode
, freq
;
4179 struct chan_centers centers
;
4181 u8 twiceMinEdgePower
;
4182 struct ath_hal_5416
*ahp
= AH5416(ah
);
4184 tx_chainmask
= ahp
->ah_txchainmask
;
4186 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
4188 twiceLargestAntenna
= max(
4189 pEepData
->modalHeader
4190 [IS_CHAN_2GHZ(chan
)].antennaGainCh
[0],
4191 pEepData
->modalHeader
4192 [IS_CHAN_2GHZ(chan
)].antennaGainCh
[1]);
4194 twiceLargestAntenna
= max((u8
) twiceLargestAntenna
,
4195 pEepData
->modalHeader
4196 [IS_CHAN_2GHZ(chan
)].antennaGainCh
[2]);
4198 twiceLargestAntenna
=
4199 (int8_t) min(AntennaReduction
- twiceLargestAntenna
, 0);
4201 maxRegAllowedPower
= twiceMaxRegulatoryPower
+ twiceLargestAntenna
;
4203 if (ah
->ah_tpScale
!= ATH9K_TP_SCALE_MAX
) {
4204 maxRegAllowedPower
-=
4205 (tpScaleReductionTable
[(ah
->ah_tpScale
)] * 2);
4208 scaledPower
= min(powerLimit
, maxRegAllowedPower
);
4210 switch (ar5416_get_ntxchains(tx_chainmask
)) {
4215 pEepData
->modalHeader
[IS_CHAN_2GHZ(chan
)].
4216 pwrDecreaseFor2Chain
;
4220 pEepData
->modalHeader
[IS_CHAN_2GHZ(chan
)].
4221 pwrDecreaseFor3Chain
;
4225 scaledPower
= max(0, (int32_t) scaledPower
);
4227 if (IS_CHAN_2GHZ(chan
)) {
4229 ARRAY_SIZE(ctlModesFor11g
) -
4230 SUB_NUM_CTL_MODES_AT_2G_40
;
4231 pCtlMode
= ctlModesFor11g
;
4233 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4236 AR5416_NUM_2G_CCK_TARGET_POWERS
,
4239 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4242 AR5416_NUM_2G_20_TARGET_POWERS
,
4243 &targetPowerOfdm
, 4,
4245 ath9k_hw_get_target_powers(ah
, chan
,
4246 pEepData
->calTargetPower2GHT20
,
4247 AR5416_NUM_2G_20_TARGET_POWERS
,
4248 &targetPowerHt20
, 8, false);
4250 if (IS_CHAN_HT40(chan
)) {
4251 numCtlModes
= ARRAY_SIZE(ctlModesFor11g
);
4252 ath9k_hw_get_target_powers(ah
, chan
,
4254 calTargetPower2GHT40
,
4255 AR5416_NUM_2G_40_TARGET_POWERS
,
4256 &targetPowerHt40
, 8,
4258 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4261 AR5416_NUM_2G_CCK_TARGET_POWERS
,
4264 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4267 AR5416_NUM_2G_20_TARGET_POWERS
,
4268 &targetPowerOfdmExt
,
4274 ARRAY_SIZE(ctlModesFor11a
) -
4275 SUB_NUM_CTL_MODES_AT_5G_40
;
4276 pCtlMode
= ctlModesFor11a
;
4278 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4281 AR5416_NUM_5G_20_TARGET_POWERS
,
4282 &targetPowerOfdm
, 4,
4284 ath9k_hw_get_target_powers(ah
, chan
,
4285 pEepData
->calTargetPower5GHT20
,
4286 AR5416_NUM_5G_20_TARGET_POWERS
,
4287 &targetPowerHt20
, 8, false);
4289 if (IS_CHAN_HT40(chan
)) {
4290 numCtlModes
= ARRAY_SIZE(ctlModesFor11a
);
4291 ath9k_hw_get_target_powers(ah
, chan
,
4293 calTargetPower5GHT40
,
4294 AR5416_NUM_5G_40_TARGET_POWERS
,
4295 &targetPowerHt40
, 8,
4297 ath9k_hw_get_legacy_target_powers(ah
, chan
,
4300 AR5416_NUM_5G_20_TARGET_POWERS
,
4301 &targetPowerOfdmExt
,
4306 for (ctlMode
= 0; ctlMode
< numCtlModes
; ctlMode
++) {
4307 bool isHt40CtlMode
=
4308 (pCtlMode
[ctlMode
] == CTL_5GHT40
)
4309 || (pCtlMode
[ctlMode
] == CTL_2GHT40
);
4311 freq
= centers
.synth_center
;
4312 else if (pCtlMode
[ctlMode
] & EXT_ADDITIVE
)
4313 freq
= centers
.ext_center
;
4315 freq
= centers
.ctl_center
;
4317 if (ar5416_get_eep_ver(ahp
) == 14
4318 && ar5416_get_eep_rev(ahp
) <= 2)
4319 twiceMaxEdgePower
= AR5416_MAX_RATE_POWER
;
4321 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
4322 "LOOP-Mode ctlMode %d < %d, isHt40CtlMode %d, "
4323 "EXT_ADDITIVE %d\n",
4324 ctlMode
, numCtlModes
, isHt40CtlMode
,
4325 (pCtlMode
[ctlMode
] & EXT_ADDITIVE
));
4327 for (i
= 0; (i
< AR5416_NUM_CTLS
) && pEepData
->ctlIndex
[i
];
4329 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
4330 " LOOP-Ctlidx %d: cfgCtl 0x%2.2x "
4331 "pCtlMode 0x%2.2x ctlIndex 0x%2.2x "
4333 i
, cfgCtl
, pCtlMode
[ctlMode
],
4334 pEepData
->ctlIndex
[i
], chan
->channel
);
4336 if ((((cfgCtl
& ~CTL_MODE_M
) |
4337 (pCtlMode
[ctlMode
] & CTL_MODE_M
)) ==
4338 pEepData
->ctlIndex
[i
])
4340 (((cfgCtl
& ~CTL_MODE_M
) |
4341 (pCtlMode
[ctlMode
] & CTL_MODE_M
)) ==
4343 ctlIndex
[i
] & CTL_MODE_M
) | SD_NO_CTL
))) {
4344 rep
= &(pEepData
->ctlData
[i
]);
4347 ath9k_hw_get_max_edge_power(freq
,
4350 [ar5416_get_ntxchains
4356 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
4357 " MATCH-EE_IDX %d: ch %d is2 %d "
4358 "2xMinEdge %d chainmask %d chains %d\n",
4359 i
, freq
, IS_CHAN_2GHZ(chan
),
4360 twiceMinEdgePower
, tx_chainmask
,
4361 ar5416_get_ntxchains
4363 if ((cfgCtl
& ~CTL_MODE_M
) == SD_NO_CTL
) {
4365 min(twiceMaxEdgePower
,
4375 minCtlPower
= min(twiceMaxEdgePower
, scaledPower
);
4377 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
4378 " SEL-Min ctlMode %d pCtlMode %d "
4379 "2xMaxEdge %d sP %d minCtlPwr %d\n",
4380 ctlMode
, pCtlMode
[ctlMode
], twiceMaxEdgePower
,
4381 scaledPower
, minCtlPower
);
4383 switch (pCtlMode
[ctlMode
]) {
4385 for (i
= 0; i
< ARRAY_SIZE(targetPowerCck
.tPow2x
);
4387 targetPowerCck
.tPow2x
[i
] =
4388 min(targetPowerCck
.tPow2x
[i
],
4394 for (i
= 0; i
< ARRAY_SIZE(targetPowerOfdm
.tPow2x
);
4396 targetPowerOfdm
.tPow2x
[i
] =
4397 min(targetPowerOfdm
.tPow2x
[i
],
4403 for (i
= 0; i
< ARRAY_SIZE(targetPowerHt20
.tPow2x
);
4405 targetPowerHt20
.tPow2x
[i
] =
4406 min(targetPowerHt20
.tPow2x
[i
],
4411 targetPowerCckExt
.tPow2x
[0] =
4412 min(targetPowerCckExt
.tPow2x
[0], minCtlPower
);
4416 targetPowerOfdmExt
.tPow2x
[0] =
4417 min(targetPowerOfdmExt
.tPow2x
[0], minCtlPower
);
4421 for (i
= 0; i
< ARRAY_SIZE(targetPowerHt40
.tPow2x
);
4423 targetPowerHt40
.tPow2x
[i
] =
4424 min(targetPowerHt40
.tPow2x
[i
],
4433 ratesArray
[rate6mb
] = ratesArray
[rate9mb
] = ratesArray
[rate12mb
] =
4434 ratesArray
[rate18mb
] = ratesArray
[rate24mb
] =
4435 targetPowerOfdm
.tPow2x
[0];
4436 ratesArray
[rate36mb
] = targetPowerOfdm
.tPow2x
[1];
4437 ratesArray
[rate48mb
] = targetPowerOfdm
.tPow2x
[2];
4438 ratesArray
[rate54mb
] = targetPowerOfdm
.tPow2x
[3];
4439 ratesArray
[rateXr
] = targetPowerOfdm
.tPow2x
[0];
4441 for (i
= 0; i
< ARRAY_SIZE(targetPowerHt20
.tPow2x
); i
++)
4442 ratesArray
[rateHt20_0
+ i
] = targetPowerHt20
.tPow2x
[i
];
4444 if (IS_CHAN_2GHZ(chan
)) {
4445 ratesArray
[rate1l
] = targetPowerCck
.tPow2x
[0];
4446 ratesArray
[rate2s
] = ratesArray
[rate2l
] =
4447 targetPowerCck
.tPow2x
[1];
4448 ratesArray
[rate5_5s
] = ratesArray
[rate5_5l
] =
4449 targetPowerCck
.tPow2x
[2];
4451 ratesArray
[rate11s
] = ratesArray
[rate11l
] =
4452 targetPowerCck
.tPow2x
[3];
4455 if (IS_CHAN_HT40(chan
)) {
4456 for (i
= 0; i
< ARRAY_SIZE(targetPowerHt40
.tPow2x
); i
++) {
4457 ratesArray
[rateHt40_0
+ i
] =
4458 targetPowerHt40
.tPow2x
[i
];
4460 ratesArray
[rateDupOfdm
] = targetPowerHt40
.tPow2x
[0];
4461 ratesArray
[rateDupCck
] = targetPowerHt40
.tPow2x
[0];
4462 ratesArray
[rateExtOfdm
] = targetPowerOfdmExt
.tPow2x
[0];
4463 if (IS_CHAN_2GHZ(chan
)) {
4464 ratesArray
[rateExtCck
] =
4465 targetPowerCckExt
.tPow2x
[0];
4472 ath9k_hw_set_txpower(struct ath_hal
*ah
,
4473 struct ar5416_eeprom
*pEepData
,
4474 struct ath9k_channel
*chan
,
4476 u8 twiceAntennaReduction
,
4477 u8 twiceMaxRegulatoryPower
,
4480 struct modal_eep_header
*pModal
=
4481 &(pEepData
->modalHeader
[IS_CHAN_2GHZ(chan
)]);
4482 int16_t ratesArray
[Ar5416RateSize
];
4483 int16_t txPowerIndexOffset
= 0;
4484 u8 ht40PowerIncForPdadc
= 2;
4487 memset(ratesArray
, 0, sizeof(ratesArray
));
4489 if ((pEepData
->baseEepHeader
.
4490 version
& AR5416_EEP_VER_MINOR_MASK
) >=
4491 AR5416_EEP_MINOR_VER_2
) {
4492 ht40PowerIncForPdadc
= pModal
->ht40PowerIncForPdadc
;
4495 if (!ath9k_hw_set_power_per_rate_table(ah
, pEepData
, chan
,
4496 &ratesArray
[0], cfgCtl
,
4497 twiceAntennaReduction
,
4498 twiceMaxRegulatoryPower
,
4500 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
4501 "ath9k_hw_set_txpower: unable to set "
4502 "tx power per rate table\n");
4506 if (!ath9k_hw_set_power_cal_table
4507 (ah
, pEepData
, chan
, &txPowerIndexOffset
)) {
4508 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
4509 "ath9k_hw_set_txpower: unable to set power table\n");
4513 for (i
= 0; i
< ARRAY_SIZE(ratesArray
); i
++) {
4515 (int16_t) (txPowerIndexOffset
+ ratesArray
[i
]);
4516 if (ratesArray
[i
] > AR5416_MAX_RATE_POWER
)
4517 ratesArray
[i
] = AR5416_MAX_RATE_POWER
;
4520 if (AR_SREV_9280_10_OR_LATER(ah
)) {
4521 for (i
= 0; i
< Ar5416RateSize
; i
++)
4522 ratesArray
[i
] -= AR5416_PWR_TABLE_OFFSET
* 2;
4525 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE1
,
4526 ATH9K_POW_SM(ratesArray
[rate18mb
], 24)
4527 | ATH9K_POW_SM(ratesArray
[rate12mb
], 16)
4528 | ATH9K_POW_SM(ratesArray
[rate9mb
], 8)
4529 | ATH9K_POW_SM(ratesArray
[rate6mb
], 0)
4531 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE2
,
4532 ATH9K_POW_SM(ratesArray
[rate54mb
], 24)
4533 | ATH9K_POW_SM(ratesArray
[rate48mb
], 16)
4534 | ATH9K_POW_SM(ratesArray
[rate36mb
], 8)
4535 | ATH9K_POW_SM(ratesArray
[rate24mb
], 0)
4538 if (IS_CHAN_2GHZ(chan
)) {
4539 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE3
,
4540 ATH9K_POW_SM(ratesArray
[rate2s
], 24)
4541 | ATH9K_POW_SM(ratesArray
[rate2l
], 16)
4542 | ATH9K_POW_SM(ratesArray
[rateXr
], 8)
4543 | ATH9K_POW_SM(ratesArray
[rate1l
], 0)
4545 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE4
,
4546 ATH9K_POW_SM(ratesArray
[rate11s
], 24)
4547 | ATH9K_POW_SM(ratesArray
[rate11l
], 16)
4548 | ATH9K_POW_SM(ratesArray
[rate5_5s
], 8)
4549 | ATH9K_POW_SM(ratesArray
[rate5_5l
], 0)
4553 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE5
,
4554 ATH9K_POW_SM(ratesArray
[rateHt20_3
], 24)
4555 | ATH9K_POW_SM(ratesArray
[rateHt20_2
], 16)
4556 | ATH9K_POW_SM(ratesArray
[rateHt20_1
], 8)
4557 | ATH9K_POW_SM(ratesArray
[rateHt20_0
], 0)
4559 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE6
,
4560 ATH9K_POW_SM(ratesArray
[rateHt20_7
], 24)
4561 | ATH9K_POW_SM(ratesArray
[rateHt20_6
], 16)
4562 | ATH9K_POW_SM(ratesArray
[rateHt20_5
], 8)
4563 | ATH9K_POW_SM(ratesArray
[rateHt20_4
], 0)
4566 if (IS_CHAN_HT40(chan
)) {
4567 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE7
,
4568 ATH9K_POW_SM(ratesArray
[rateHt40_3
] +
4569 ht40PowerIncForPdadc
, 24)
4570 | ATH9K_POW_SM(ratesArray
[rateHt40_2
] +
4571 ht40PowerIncForPdadc
, 16)
4572 | ATH9K_POW_SM(ratesArray
[rateHt40_1
] +
4573 ht40PowerIncForPdadc
, 8)
4574 | ATH9K_POW_SM(ratesArray
[rateHt40_0
] +
4575 ht40PowerIncForPdadc
, 0)
4577 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE8
,
4578 ATH9K_POW_SM(ratesArray
[rateHt40_7
] +
4579 ht40PowerIncForPdadc
, 24)
4580 | ATH9K_POW_SM(ratesArray
[rateHt40_6
] +
4581 ht40PowerIncForPdadc
, 16)
4582 | ATH9K_POW_SM(ratesArray
[rateHt40_5
] +
4583 ht40PowerIncForPdadc
, 8)
4584 | ATH9K_POW_SM(ratesArray
[rateHt40_4
] +
4585 ht40PowerIncForPdadc
, 0)
4588 REG_WRITE(ah
, AR_PHY_POWER_TX_RATE9
,
4589 ATH9K_POW_SM(ratesArray
[rateExtOfdm
], 24)
4590 | ATH9K_POW_SM(ratesArray
[rateExtCck
], 16)
4591 | ATH9K_POW_SM(ratesArray
[rateDupOfdm
], 8)
4592 | ATH9K_POW_SM(ratesArray
[rateDupCck
], 0)
4596 REG_WRITE(ah
, AR_PHY_POWER_TX_SUB
,
4597 ATH9K_POW_SM(pModal
->pwrDecreaseFor3Chain
, 6)
4598 | ATH9K_POW_SM(pModal
->pwrDecreaseFor2Chain
, 0)
4602 if (IS_CHAN_HT40(chan
))
4604 else if (IS_CHAN_HT20(chan
))
4607 if (AR_SREV_9280_10_OR_LATER(ah
))
4608 ah
->ah_maxPowerLevel
=
4609 ratesArray
[i
] + AR5416_PWR_TABLE_OFFSET
* 2;
4611 ah
->ah_maxPowerLevel
= ratesArray
[i
];
4616 static inline void ath9k_hw_get_delta_slope_vals(struct ath_hal
*ah
,
4621 u32 coef_exp
, coef_man
;
4623 for (coef_exp
= 31; coef_exp
> 0; coef_exp
--)
4624 if ((coef_scaled
>> coef_exp
) & 0x1)
4627 coef_exp
= 14 - (coef_exp
- COEF_SCALE_S
);
4629 coef_man
= coef_scaled
+ (1 << (COEF_SCALE_S
- coef_exp
- 1));
4631 *coef_mantissa
= coef_man
>> (COEF_SCALE_S
- coef_exp
);
4632 *coef_exponent
= coef_exp
- 16;
4636 ath9k_hw_set_delta_slope(struct ath_hal
*ah
,
4637 struct ath9k_channel
*chan
)
4639 u32 coef_scaled
, ds_coef_exp
, ds_coef_man
;
4640 u32 clockMhzScaled
= 0x64000000;
4641 struct chan_centers centers
;
4643 if (IS_CHAN_HALF_RATE(chan
))
4644 clockMhzScaled
= clockMhzScaled
>> 1;
4645 else if (IS_CHAN_QUARTER_RATE(chan
))
4646 clockMhzScaled
= clockMhzScaled
>> 2;
4648 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
4649 coef_scaled
= clockMhzScaled
/ centers
.synth_center
;
4651 ath9k_hw_get_delta_slope_vals(ah
, coef_scaled
, &ds_coef_man
,
4654 REG_RMW_FIELD(ah
, AR_PHY_TIMING3
,
4655 AR_PHY_TIMING3_DSC_MAN
, ds_coef_man
);
4656 REG_RMW_FIELD(ah
, AR_PHY_TIMING3
,
4657 AR_PHY_TIMING3_DSC_EXP
, ds_coef_exp
);
4659 coef_scaled
= (9 * coef_scaled
) / 10;
4661 ath9k_hw_get_delta_slope_vals(ah
, coef_scaled
, &ds_coef_man
,
4664 REG_RMW_FIELD(ah
, AR_PHY_HALFGI
,
4665 AR_PHY_HALFGI_DSC_MAN
, ds_coef_man
);
4666 REG_RMW_FIELD(ah
, AR_PHY_HALFGI
,
4667 AR_PHY_HALFGI_DSC_EXP
, ds_coef_exp
);
4670 static void ath9k_hw_9280_spur_mitigate(struct ath_hal
*ah
,
4671 struct ath9k_channel
*chan
)
4673 int bb_spur
= AR_NO_SPUR
;
4676 int bb_spur_off
, spur_subchannel_sd
;
4678 int spur_delta_phase
;
4680 int upper
, lower
, cur_vit_mask
;
4683 int pilot_mask_reg
[4] = { AR_PHY_TIMING7
, AR_PHY_TIMING8
,
4684 AR_PHY_PILOT_MASK_01_30
, AR_PHY_PILOT_MASK_31_60
4686 int chan_mask_reg
[4] = { AR_PHY_TIMING9
, AR_PHY_TIMING10
,
4687 AR_PHY_CHANNEL_MASK_01_30
, AR_PHY_CHANNEL_MASK_31_60
4689 int inc
[4] = { 0, 100, 0, 0 };
4690 struct chan_centers centers
;
4697 bool is2GHz
= IS_CHAN_2GHZ(chan
);
4699 memset(&mask_m
, 0, sizeof(int8_t) * 123);
4700 memset(&mask_p
, 0, sizeof(int8_t) * 123);
4702 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
4703 freq
= centers
.synth_center
;
4705 ah
->ah_config
.spurmode
= SPUR_ENABLE_EEPROM
;
4706 for (i
= 0; i
< AR_EEPROM_MODAL_SPURS
; i
++) {
4707 cur_bb_spur
= ath9k_hw_eeprom_get_spur_chan(ah
, i
, is2GHz
);
4710 cur_bb_spur
= (cur_bb_spur
/ 10) + AR_BASE_FREQ_2GHZ
;
4712 cur_bb_spur
= (cur_bb_spur
/ 10) + AR_BASE_FREQ_5GHZ
;
4714 if (AR_NO_SPUR
== cur_bb_spur
)
4716 cur_bb_spur
= cur_bb_spur
- freq
;
4718 if (IS_CHAN_HT40(chan
)) {
4719 if ((cur_bb_spur
> -AR_SPUR_FEEQ_BOUND_HT40
) &&
4720 (cur_bb_spur
< AR_SPUR_FEEQ_BOUND_HT40
)) {
4721 bb_spur
= cur_bb_spur
;
4724 } else if ((cur_bb_spur
> -AR_SPUR_FEEQ_BOUND_HT20
) &&
4725 (cur_bb_spur
< AR_SPUR_FEEQ_BOUND_HT20
)) {
4726 bb_spur
= cur_bb_spur
;
4731 if (AR_NO_SPUR
== bb_spur
) {
4732 REG_CLR_BIT(ah
, AR_PHY_FORCE_CLKEN_CCK
,
4733 AR_PHY_FORCE_CLKEN_CCK_MRC_MUX
);
4736 REG_CLR_BIT(ah
, AR_PHY_FORCE_CLKEN_CCK
,
4737 AR_PHY_FORCE_CLKEN_CCK_MRC_MUX
);
4740 bin
= bb_spur
* 320;
4742 tmp
= REG_READ(ah
, AR_PHY_TIMING_CTRL4(0));
4744 newVal
= tmp
| (AR_PHY_TIMING_CTRL4_ENABLE_SPUR_RSSI
|
4745 AR_PHY_TIMING_CTRL4_ENABLE_SPUR_FILTER
|
4746 AR_PHY_TIMING_CTRL4_ENABLE_CHAN_MASK
|
4747 AR_PHY_TIMING_CTRL4_ENABLE_PILOT_MASK
);
4748 REG_WRITE(ah
, AR_PHY_TIMING_CTRL4(0), newVal
);
4750 newVal
= (AR_PHY_SPUR_REG_MASK_RATE_CNTL
|
4751 AR_PHY_SPUR_REG_ENABLE_MASK_PPM
|
4752 AR_PHY_SPUR_REG_MASK_RATE_SELECT
|
4753 AR_PHY_SPUR_REG_ENABLE_VIT_SPUR_RSSI
|
4754 SM(SPUR_RSSI_THRESH
, AR_PHY_SPUR_REG_SPUR_RSSI_THRESH
));
4755 REG_WRITE(ah
, AR_PHY_SPUR_REG
, newVal
);
4757 if (IS_CHAN_HT40(chan
)) {
4759 spur_subchannel_sd
= 1;
4760 bb_spur_off
= bb_spur
+ 10;
4762 spur_subchannel_sd
= 0;
4763 bb_spur_off
= bb_spur
- 10;
4766 spur_subchannel_sd
= 0;
4767 bb_spur_off
= bb_spur
;
4770 if (IS_CHAN_HT40(chan
))
4772 ((bb_spur
* 262144) /
4773 10) & AR_PHY_TIMING11_SPUR_DELTA_PHASE
;
4776 ((bb_spur
* 524288) /
4777 10) & AR_PHY_TIMING11_SPUR_DELTA_PHASE
;
4779 denominator
= IS_CHAN_2GHZ(chan
) ? 44 : 40;
4780 spur_freq_sd
= ((bb_spur_off
* 2048) / denominator
) & 0x3ff;
4782 newVal
= (AR_PHY_TIMING11_USE_SPUR_IN_AGC
|
4783 SM(spur_freq_sd
, AR_PHY_TIMING11_SPUR_FREQ_SD
) |
4784 SM(spur_delta_phase
, AR_PHY_TIMING11_SPUR_DELTA_PHASE
));
4785 REG_WRITE(ah
, AR_PHY_TIMING11
, newVal
);
4787 newVal
= spur_subchannel_sd
<< AR_PHY_SFCORR_SPUR_SUBCHNL_SD_S
;
4788 REG_WRITE(ah
, AR_PHY_SFCORR_EXT
, newVal
);
4794 for (i
= 0; i
< 4; i
++) {
4798 for (bp
= 0; bp
< 30; bp
++) {
4799 if ((cur_bin
> lower
) && (cur_bin
< upper
)) {
4800 pilot_mask
= pilot_mask
| 0x1 << bp
;
4801 chan_mask
= chan_mask
| 0x1 << bp
;
4806 REG_WRITE(ah
, pilot_mask_reg
[i
], pilot_mask
);
4807 REG_WRITE(ah
, chan_mask_reg
[i
], chan_mask
);
4810 cur_vit_mask
= 6100;
4814 for (i
= 0; i
< 123; i
++) {
4815 if ((cur_vit_mask
> lower
) && (cur_vit_mask
< upper
)) {
4817 /* workaround for gcc bug #37014 */
4818 volatile int tmp
= abs(cur_vit_mask
- bin
);
4824 if (cur_vit_mask
< 0)
4825 mask_m
[abs(cur_vit_mask
/ 100)] = mask_amt
;
4827 mask_p
[cur_vit_mask
/ 100] = mask_amt
;
4829 cur_vit_mask
-= 100;
4832 tmp_mask
= (mask_m
[46] << 30) | (mask_m
[47] << 28)
4833 | (mask_m
[48] << 26) | (mask_m
[49] << 24)
4834 | (mask_m
[50] << 22) | (mask_m
[51] << 20)
4835 | (mask_m
[52] << 18) | (mask_m
[53] << 16)
4836 | (mask_m
[54] << 14) | (mask_m
[55] << 12)
4837 | (mask_m
[56] << 10) | (mask_m
[57] << 8)
4838 | (mask_m
[58] << 6) | (mask_m
[59] << 4)
4839 | (mask_m
[60] << 2) | (mask_m
[61] << 0);
4840 REG_WRITE(ah
, AR_PHY_BIN_MASK_1
, tmp_mask
);
4841 REG_WRITE(ah
, AR_PHY_VIT_MASK2_M_46_61
, tmp_mask
);
4843 tmp_mask
= (mask_m
[31] << 28)
4844 | (mask_m
[32] << 26) | (mask_m
[33] << 24)
4845 | (mask_m
[34] << 22) | (mask_m
[35] << 20)
4846 | (mask_m
[36] << 18) | (mask_m
[37] << 16)
4847 | (mask_m
[48] << 14) | (mask_m
[39] << 12)
4848 | (mask_m
[40] << 10) | (mask_m
[41] << 8)
4849 | (mask_m
[42] << 6) | (mask_m
[43] << 4)
4850 | (mask_m
[44] << 2) | (mask_m
[45] << 0);
4851 REG_WRITE(ah
, AR_PHY_BIN_MASK_2
, tmp_mask
);
4852 REG_WRITE(ah
, AR_PHY_MASK2_M_31_45
, tmp_mask
);
4854 tmp_mask
= (mask_m
[16] << 30) | (mask_m
[16] << 28)
4855 | (mask_m
[18] << 26) | (mask_m
[18] << 24)
4856 | (mask_m
[20] << 22) | (mask_m
[20] << 20)
4857 | (mask_m
[22] << 18) | (mask_m
[22] << 16)
4858 | (mask_m
[24] << 14) | (mask_m
[24] << 12)
4859 | (mask_m
[25] << 10) | (mask_m
[26] << 8)
4860 | (mask_m
[27] << 6) | (mask_m
[28] << 4)
4861 | (mask_m
[29] << 2) | (mask_m
[30] << 0);
4862 REG_WRITE(ah
, AR_PHY_BIN_MASK_3
, tmp_mask
);
4863 REG_WRITE(ah
, AR_PHY_MASK2_M_16_30
, tmp_mask
);
4865 tmp_mask
= (mask_m
[0] << 30) | (mask_m
[1] << 28)
4866 | (mask_m
[2] << 26) | (mask_m
[3] << 24)
4867 | (mask_m
[4] << 22) | (mask_m
[5] << 20)
4868 | (mask_m
[6] << 18) | (mask_m
[7] << 16)
4869 | (mask_m
[8] << 14) | (mask_m
[9] << 12)
4870 | (mask_m
[10] << 10) | (mask_m
[11] << 8)
4871 | (mask_m
[12] << 6) | (mask_m
[13] << 4)
4872 | (mask_m
[14] << 2) | (mask_m
[15] << 0);
4873 REG_WRITE(ah
, AR_PHY_MASK_CTL
, tmp_mask
);
4874 REG_WRITE(ah
, AR_PHY_MASK2_M_00_15
, tmp_mask
);
4876 tmp_mask
= (mask_p
[15] << 28)
4877 | (mask_p
[14] << 26) | (mask_p
[13] << 24)
4878 | (mask_p
[12] << 22) | (mask_p
[11] << 20)
4879 | (mask_p
[10] << 18) | (mask_p
[9] << 16)
4880 | (mask_p
[8] << 14) | (mask_p
[7] << 12)
4881 | (mask_p
[6] << 10) | (mask_p
[5] << 8)
4882 | (mask_p
[4] << 6) | (mask_p
[3] << 4)
4883 | (mask_p
[2] << 2) | (mask_p
[1] << 0);
4884 REG_WRITE(ah
, AR_PHY_BIN_MASK2_1
, tmp_mask
);
4885 REG_WRITE(ah
, AR_PHY_MASK2_P_15_01
, tmp_mask
);
4887 tmp_mask
= (mask_p
[30] << 28)
4888 | (mask_p
[29] << 26) | (mask_p
[28] << 24)
4889 | (mask_p
[27] << 22) | (mask_p
[26] << 20)
4890 | (mask_p
[25] << 18) | (mask_p
[24] << 16)
4891 | (mask_p
[23] << 14) | (mask_p
[22] << 12)
4892 | (mask_p
[21] << 10) | (mask_p
[20] << 8)
4893 | (mask_p
[19] << 6) | (mask_p
[18] << 4)
4894 | (mask_p
[17] << 2) | (mask_p
[16] << 0);
4895 REG_WRITE(ah
, AR_PHY_BIN_MASK2_2
, tmp_mask
);
4896 REG_WRITE(ah
, AR_PHY_MASK2_P_30_16
, tmp_mask
);
4898 tmp_mask
= (mask_p
[45] << 28)
4899 | (mask_p
[44] << 26) | (mask_p
[43] << 24)
4900 | (mask_p
[42] << 22) | (mask_p
[41] << 20)
4901 | (mask_p
[40] << 18) | (mask_p
[39] << 16)
4902 | (mask_p
[38] << 14) | (mask_p
[37] << 12)
4903 | (mask_p
[36] << 10) | (mask_p
[35] << 8)
4904 | (mask_p
[34] << 6) | (mask_p
[33] << 4)
4905 | (mask_p
[32] << 2) | (mask_p
[31] << 0);
4906 REG_WRITE(ah
, AR_PHY_BIN_MASK2_3
, tmp_mask
);
4907 REG_WRITE(ah
, AR_PHY_MASK2_P_45_31
, tmp_mask
);
4909 tmp_mask
= (mask_p
[61] << 30) | (mask_p
[60] << 28)
4910 | (mask_p
[59] << 26) | (mask_p
[58] << 24)
4911 | (mask_p
[57] << 22) | (mask_p
[56] << 20)
4912 | (mask_p
[55] << 18) | (mask_p
[54] << 16)
4913 | (mask_p
[53] << 14) | (mask_p
[52] << 12)
4914 | (mask_p
[51] << 10) | (mask_p
[50] << 8)
4915 | (mask_p
[49] << 6) | (mask_p
[48] << 4)
4916 | (mask_p
[47] << 2) | (mask_p
[46] << 0);
4917 REG_WRITE(ah
, AR_PHY_BIN_MASK2_4
, tmp_mask
);
4918 REG_WRITE(ah
, AR_PHY_MASK2_P_61_45
, tmp_mask
);
4921 static void ath9k_hw_spur_mitigate(struct ath_hal
*ah
,
4922 struct ath9k_channel
*chan
)
4924 int bb_spur
= AR_NO_SPUR
;
4927 int spur_delta_phase
;
4929 int upper
, lower
, cur_vit_mask
;
4932 int pilot_mask_reg
[4] = { AR_PHY_TIMING7
, AR_PHY_TIMING8
,
4933 AR_PHY_PILOT_MASK_01_30
, AR_PHY_PILOT_MASK_31_60
4935 int chan_mask_reg
[4] = { AR_PHY_TIMING9
, AR_PHY_TIMING10
,
4936 AR_PHY_CHANNEL_MASK_01_30
, AR_PHY_CHANNEL_MASK_31_60
4938 int inc
[4] = { 0, 100, 0, 0 };
4945 bool is2GHz
= IS_CHAN_2GHZ(chan
);
4947 memset(&mask_m
, 0, sizeof(int8_t) * 123);
4948 memset(&mask_p
, 0, sizeof(int8_t) * 123);
4950 for (i
= 0; i
< AR_EEPROM_MODAL_SPURS
; i
++) {
4951 cur_bb_spur
= ath9k_hw_eeprom_get_spur_chan(ah
, i
, is2GHz
);
4952 if (AR_NO_SPUR
== cur_bb_spur
)
4954 cur_bb_spur
= cur_bb_spur
- (chan
->channel
* 10);
4955 if ((cur_bb_spur
> -95) && (cur_bb_spur
< 95)) {
4956 bb_spur
= cur_bb_spur
;
4961 if (AR_NO_SPUR
== bb_spur
)
4966 tmp
= REG_READ(ah
, AR_PHY_TIMING_CTRL4(0));
4967 new = tmp
| (AR_PHY_TIMING_CTRL4_ENABLE_SPUR_RSSI
|
4968 AR_PHY_TIMING_CTRL4_ENABLE_SPUR_FILTER
|
4969 AR_PHY_TIMING_CTRL4_ENABLE_CHAN_MASK
|
4970 AR_PHY_TIMING_CTRL4_ENABLE_PILOT_MASK
);
4972 REG_WRITE(ah
, AR_PHY_TIMING_CTRL4(0), new);
4974 new = (AR_PHY_SPUR_REG_MASK_RATE_CNTL
|
4975 AR_PHY_SPUR_REG_ENABLE_MASK_PPM
|
4976 AR_PHY_SPUR_REG_MASK_RATE_SELECT
|
4977 AR_PHY_SPUR_REG_ENABLE_VIT_SPUR_RSSI
|
4978 SM(SPUR_RSSI_THRESH
, AR_PHY_SPUR_REG_SPUR_RSSI_THRESH
));
4979 REG_WRITE(ah
, AR_PHY_SPUR_REG
, new);
4981 spur_delta_phase
= ((bb_spur
* 524288) / 100) &
4982 AR_PHY_TIMING11_SPUR_DELTA_PHASE
;
4984 denominator
= IS_CHAN_2GHZ(chan
) ? 440 : 400;
4985 spur_freq_sd
= ((bb_spur
* 2048) / denominator
) & 0x3ff;
4987 new = (AR_PHY_TIMING11_USE_SPUR_IN_AGC
|
4988 SM(spur_freq_sd
, AR_PHY_TIMING11_SPUR_FREQ_SD
) |
4989 SM(spur_delta_phase
, AR_PHY_TIMING11_SPUR_DELTA_PHASE
));
4990 REG_WRITE(ah
, AR_PHY_TIMING11
, new);
4996 for (i
= 0; i
< 4; i
++) {
5000 for (bp
= 0; bp
< 30; bp
++) {
5001 if ((cur_bin
> lower
) && (cur_bin
< upper
)) {
5002 pilot_mask
= pilot_mask
| 0x1 << bp
;
5003 chan_mask
= chan_mask
| 0x1 << bp
;
5008 REG_WRITE(ah
, pilot_mask_reg
[i
], pilot_mask
);
5009 REG_WRITE(ah
, chan_mask_reg
[i
], chan_mask
);
5012 cur_vit_mask
= 6100;
5016 for (i
= 0; i
< 123; i
++) {
5017 if ((cur_vit_mask
> lower
) && (cur_vit_mask
< upper
)) {
5019 /* workaround for gcc bug #37014 */
5020 volatile int tmp
= abs(cur_vit_mask
- bin
);
5026 if (cur_vit_mask
< 0)
5027 mask_m
[abs(cur_vit_mask
/ 100)] = mask_amt
;
5029 mask_p
[cur_vit_mask
/ 100] = mask_amt
;
5031 cur_vit_mask
-= 100;
5034 tmp_mask
= (mask_m
[46] << 30) | (mask_m
[47] << 28)
5035 | (mask_m
[48] << 26) | (mask_m
[49] << 24)
5036 | (mask_m
[50] << 22) | (mask_m
[51] << 20)
5037 | (mask_m
[52] << 18) | (mask_m
[53] << 16)
5038 | (mask_m
[54] << 14) | (mask_m
[55] << 12)
5039 | (mask_m
[56] << 10) | (mask_m
[57] << 8)
5040 | (mask_m
[58] << 6) | (mask_m
[59] << 4)
5041 | (mask_m
[60] << 2) | (mask_m
[61] << 0);
5042 REG_WRITE(ah
, AR_PHY_BIN_MASK_1
, tmp_mask
);
5043 REG_WRITE(ah
, AR_PHY_VIT_MASK2_M_46_61
, tmp_mask
);
5045 tmp_mask
= (mask_m
[31] << 28)
5046 | (mask_m
[32] << 26) | (mask_m
[33] << 24)
5047 | (mask_m
[34] << 22) | (mask_m
[35] << 20)
5048 | (mask_m
[36] << 18) | (mask_m
[37] << 16)
5049 | (mask_m
[48] << 14) | (mask_m
[39] << 12)
5050 | (mask_m
[40] << 10) | (mask_m
[41] << 8)
5051 | (mask_m
[42] << 6) | (mask_m
[43] << 4)
5052 | (mask_m
[44] << 2) | (mask_m
[45] << 0);
5053 REG_WRITE(ah
, AR_PHY_BIN_MASK_2
, tmp_mask
);
5054 REG_WRITE(ah
, AR_PHY_MASK2_M_31_45
, tmp_mask
);
5056 tmp_mask
= (mask_m
[16] << 30) | (mask_m
[16] << 28)
5057 | (mask_m
[18] << 26) | (mask_m
[18] << 24)
5058 | (mask_m
[20] << 22) | (mask_m
[20] << 20)
5059 | (mask_m
[22] << 18) | (mask_m
[22] << 16)
5060 | (mask_m
[24] << 14) | (mask_m
[24] << 12)
5061 | (mask_m
[25] << 10) | (mask_m
[26] << 8)
5062 | (mask_m
[27] << 6) | (mask_m
[28] << 4)
5063 | (mask_m
[29] << 2) | (mask_m
[30] << 0);
5064 REG_WRITE(ah
, AR_PHY_BIN_MASK_3
, tmp_mask
);
5065 REG_WRITE(ah
, AR_PHY_MASK2_M_16_30
, tmp_mask
);
5067 tmp_mask
= (mask_m
[0] << 30) | (mask_m
[1] << 28)
5068 | (mask_m
[2] << 26) | (mask_m
[3] << 24)
5069 | (mask_m
[4] << 22) | (mask_m
[5] << 20)
5070 | (mask_m
[6] << 18) | (mask_m
[7] << 16)
5071 | (mask_m
[8] << 14) | (mask_m
[9] << 12)
5072 | (mask_m
[10] << 10) | (mask_m
[11] << 8)
5073 | (mask_m
[12] << 6) | (mask_m
[13] << 4)
5074 | (mask_m
[14] << 2) | (mask_m
[15] << 0);
5075 REG_WRITE(ah
, AR_PHY_MASK_CTL
, tmp_mask
);
5076 REG_WRITE(ah
, AR_PHY_MASK2_M_00_15
, tmp_mask
);
5078 tmp_mask
= (mask_p
[15] << 28)
5079 | (mask_p
[14] << 26) | (mask_p
[13] << 24)
5080 | (mask_p
[12] << 22) | (mask_p
[11] << 20)
5081 | (mask_p
[10] << 18) | (mask_p
[9] << 16)
5082 | (mask_p
[8] << 14) | (mask_p
[7] << 12)
5083 | (mask_p
[6] << 10) | (mask_p
[5] << 8)
5084 | (mask_p
[4] << 6) | (mask_p
[3] << 4)
5085 | (mask_p
[2] << 2) | (mask_p
[1] << 0);
5086 REG_WRITE(ah
, AR_PHY_BIN_MASK2_1
, tmp_mask
);
5087 REG_WRITE(ah
, AR_PHY_MASK2_P_15_01
, tmp_mask
);
5089 tmp_mask
= (mask_p
[30] << 28)
5090 | (mask_p
[29] << 26) | (mask_p
[28] << 24)
5091 | (mask_p
[27] << 22) | (mask_p
[26] << 20)
5092 | (mask_p
[25] << 18) | (mask_p
[24] << 16)
5093 | (mask_p
[23] << 14) | (mask_p
[22] << 12)
5094 | (mask_p
[21] << 10) | (mask_p
[20] << 8)
5095 | (mask_p
[19] << 6) | (mask_p
[18] << 4)
5096 | (mask_p
[17] << 2) | (mask_p
[16] << 0);
5097 REG_WRITE(ah
, AR_PHY_BIN_MASK2_2
, tmp_mask
);
5098 REG_WRITE(ah
, AR_PHY_MASK2_P_30_16
, tmp_mask
);
5100 tmp_mask
= (mask_p
[45] << 28)
5101 | (mask_p
[44] << 26) | (mask_p
[43] << 24)
5102 | (mask_p
[42] << 22) | (mask_p
[41] << 20)
5103 | (mask_p
[40] << 18) | (mask_p
[39] << 16)
5104 | (mask_p
[38] << 14) | (mask_p
[37] << 12)
5105 | (mask_p
[36] << 10) | (mask_p
[35] << 8)
5106 | (mask_p
[34] << 6) | (mask_p
[33] << 4)
5107 | (mask_p
[32] << 2) | (mask_p
[31] << 0);
5108 REG_WRITE(ah
, AR_PHY_BIN_MASK2_3
, tmp_mask
);
5109 REG_WRITE(ah
, AR_PHY_MASK2_P_45_31
, tmp_mask
);
5111 tmp_mask
= (mask_p
[61] << 30) | (mask_p
[60] << 28)
5112 | (mask_p
[59] << 26) | (mask_p
[58] << 24)
5113 | (mask_p
[57] << 22) | (mask_p
[56] << 20)
5114 | (mask_p
[55] << 18) | (mask_p
[54] << 16)
5115 | (mask_p
[53] << 14) | (mask_p
[52] << 12)
5116 | (mask_p
[51] << 10) | (mask_p
[50] << 8)
5117 | (mask_p
[49] << 6) | (mask_p
[48] << 4)
5118 | (mask_p
[47] << 2) | (mask_p
[46] << 0);
5119 REG_WRITE(ah
, AR_PHY_BIN_MASK2_4
, tmp_mask
);
5120 REG_WRITE(ah
, AR_PHY_MASK2_P_61_45
, tmp_mask
);
5123 static void ath9k_hw_init_chain_masks(struct ath_hal
*ah
)
5125 struct ath_hal_5416
*ahp
= AH5416(ah
);
5126 int rx_chainmask
, tx_chainmask
;
5128 rx_chainmask
= ahp
->ah_rxchainmask
;
5129 tx_chainmask
= ahp
->ah_txchainmask
;
5131 switch (rx_chainmask
) {
5133 REG_SET_BIT(ah
, AR_PHY_ANALOG_SWAP
,
5134 AR_PHY_SWAP_ALT_CHAIN
);
5136 if (((ah
)->ah_macVersion
<= AR_SREV_VERSION_9160
)) {
5137 REG_WRITE(ah
, AR_PHY_RX_CHAINMASK
, 0x7);
5138 REG_WRITE(ah
, AR_PHY_CAL_CHAINMASK
, 0x7);
5143 if (!AR_SREV_9280(ah
))
5146 REG_WRITE(ah
, AR_PHY_RX_CHAINMASK
, rx_chainmask
);
5147 REG_WRITE(ah
, AR_PHY_CAL_CHAINMASK
, rx_chainmask
);
5153 REG_WRITE(ah
, AR_SELFGEN_MASK
, tx_chainmask
);
5154 if (tx_chainmask
== 0x5) {
5155 REG_SET_BIT(ah
, AR_PHY_ANALOG_SWAP
,
5156 AR_PHY_SWAP_ALT_CHAIN
);
5158 if (AR_SREV_9100(ah
))
5159 REG_WRITE(ah
, AR_PHY_ANALOG_SWAP
,
5160 REG_READ(ah
, AR_PHY_ANALOG_SWAP
) | 0x00000001);
5163 static void ath9k_hw_set_addac(struct ath_hal
*ah
,
5164 struct ath9k_channel
*chan
)
5166 struct modal_eep_header
*pModal
;
5167 struct ath_hal_5416
*ahp
= AH5416(ah
);
5168 struct ar5416_eeprom
*eep
= &ahp
->ah_eeprom
;
5171 if (ah
->ah_macVersion
!= AR_SREV_VERSION_9160
)
5174 if (ar5416_get_eep_rev(ahp
) < AR5416_EEP_MINOR_VER_7
)
5177 pModal
= &(eep
->modalHeader
[IS_CHAN_2GHZ(chan
)]);
5179 if (pModal
->xpaBiasLvl
!= 0xff) {
5180 biaslevel
= pModal
->xpaBiasLvl
;
5183 u16 resetFreqBin
, freqBin
, freqCount
= 0;
5184 struct chan_centers centers
;
5186 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
5189 FREQ2FBIN(centers
.synth_center
, IS_CHAN_2GHZ(chan
));
5190 freqBin
= pModal
->xpaBiasLvlFreq
[0] & 0xff;
5191 biaslevel
= (u8
) (pModal
->xpaBiasLvlFreq
[0] >> 14);
5195 while (freqCount
< 3) {
5196 if (pModal
->xpaBiasLvlFreq
[freqCount
] == 0x0)
5199 freqBin
= pModal
->xpaBiasLvlFreq
[freqCount
] & 0xff;
5200 if (resetFreqBin
>= freqBin
) {
5203 xpaBiasLvlFreq
[freqCount
]
5212 if (IS_CHAN_2GHZ(chan
)) {
5213 INI_RA(&ahp
->ah_iniAddac
, 7, 1) =
5214 (INI_RA(&ahp
->ah_iniAddac
, 7, 1) & (~0x18)) | biaslevel
5217 INI_RA(&ahp
->ah_iniAddac
, 6, 1) =
5218 (INI_RA(&ahp
->ah_iniAddac
, 6, 1) & (~0xc0)) | biaslevel
5223 static u32
ath9k_hw_mac_usec(struct ath_hal
*ah
, u32 clks
)
5225 if (ah
->ah_curchan
!= NULL
)
5227 CLOCK_RATE
[ath9k_hw_chan2wmode(ah
, ah
->ah_curchan
)];
5229 return clks
/ CLOCK_RATE
[ATH9K_MODE_11B
];
5232 static u32
ath9k_hw_mac_to_usec(struct ath_hal
*ah
, u32 clks
)
5234 struct ath9k_channel
*chan
= ah
->ah_curchan
;
5236 if (chan
&& IS_CHAN_HT40(chan
))
5237 return ath9k_hw_mac_usec(ah
, clks
) / 2;
5239 return ath9k_hw_mac_usec(ah
, clks
);
5242 static u32
ath9k_hw_mac_clks(struct ath_hal
*ah
, u32 usecs
)
5244 if (ah
->ah_curchan
!= NULL
)
5245 return usecs
* CLOCK_RATE
[ath9k_hw_chan2wmode(ah
,
5248 return usecs
* CLOCK_RATE
[ATH9K_MODE_11B
];
5251 static u32
ath9k_hw_mac_to_clks(struct ath_hal
*ah
, u32 usecs
)
5253 struct ath9k_channel
*chan
= ah
->ah_curchan
;
5255 if (chan
&& IS_CHAN_HT40(chan
))
5256 return ath9k_hw_mac_clks(ah
, usecs
) * 2;
5258 return ath9k_hw_mac_clks(ah
, usecs
);
5261 static bool ath9k_hw_set_ack_timeout(struct ath_hal
*ah
, u32 us
)
5263 struct ath_hal_5416
*ahp
= AH5416(ah
);
5265 if (us
> ath9k_hw_mac_to_usec(ah
, MS(0xffffffff, AR_TIME_OUT_ACK
))) {
5266 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: bad ack timeout %u\n",
5268 ahp
->ah_acktimeout
= (u32
) -1;
5271 REG_RMW_FIELD(ah
, AR_TIME_OUT
,
5272 AR_TIME_OUT_ACK
, ath9k_hw_mac_to_clks(ah
, us
));
5273 ahp
->ah_acktimeout
= us
;
5278 static bool ath9k_hw_set_cts_timeout(struct ath_hal
*ah
, u32 us
)
5280 struct ath_hal_5416
*ahp
= AH5416(ah
);
5282 if (us
> ath9k_hw_mac_to_usec(ah
, MS(0xffffffff, AR_TIME_OUT_CTS
))) {
5283 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: bad cts timeout %u\n",
5285 ahp
->ah_ctstimeout
= (u32
) -1;
5288 REG_RMW_FIELD(ah
, AR_TIME_OUT
,
5289 AR_TIME_OUT_CTS
, ath9k_hw_mac_to_clks(ah
, us
));
5290 ahp
->ah_ctstimeout
= us
;
5294 static bool ath9k_hw_set_global_txtimeout(struct ath_hal
*ah
,
5297 struct ath_hal_5416
*ahp
= AH5416(ah
);
5300 DPRINTF(ah
->ah_sc
, ATH_DBG_XMIT
,
5301 "%s: bad global tx timeout %u\n", __func__
, tu
);
5302 ahp
->ah_globaltxtimeout
= (u32
) -1;
5305 REG_RMW_FIELD(ah
, AR_GTXTO
, AR_GTXTO_TIMEOUT_LIMIT
, tu
);
5306 ahp
->ah_globaltxtimeout
= tu
;
5311 bool ath9k_hw_setslottime(struct ath_hal
*ah
, u32 us
)
5313 struct ath_hal_5416
*ahp
= AH5416(ah
);
5315 if (us
< ATH9K_SLOT_TIME_9
|| us
> ath9k_hw_mac_to_usec(ah
, 0xffff)) {
5316 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: bad slot time %u\n",
5318 ahp
->ah_slottime
= (u32
) -1;
5321 REG_WRITE(ah
, AR_D_GBL_IFS_SLOT
, ath9k_hw_mac_to_clks(ah
, us
));
5322 ahp
->ah_slottime
= us
;
5327 static void ath9k_hw_init_user_settings(struct ath_hal
*ah
)
5329 struct ath_hal_5416
*ahp
= AH5416(ah
);
5331 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "--AP %s ahp->ah_miscMode 0x%x\n",
5332 __func__
, ahp
->ah_miscMode
);
5333 if (ahp
->ah_miscMode
!= 0)
5334 REG_WRITE(ah
, AR_PCU_MISC
,
5335 REG_READ(ah
, AR_PCU_MISC
) | ahp
->ah_miscMode
);
5336 if (ahp
->ah_slottime
!= (u32
) -1)
5337 ath9k_hw_setslottime(ah
, ahp
->ah_slottime
);
5338 if (ahp
->ah_acktimeout
!= (u32
) -1)
5339 ath9k_hw_set_ack_timeout(ah
, ahp
->ah_acktimeout
);
5340 if (ahp
->ah_ctstimeout
!= (u32
) -1)
5341 ath9k_hw_set_cts_timeout(ah
, ahp
->ah_ctstimeout
);
5342 if (ahp
->ah_globaltxtimeout
!= (u32
) -1)
5343 ath9k_hw_set_global_txtimeout(ah
, ahp
->ah_globaltxtimeout
);
5347 ath9k_hw_process_ini(struct ath_hal
*ah
,
5348 struct ath9k_channel
*chan
,
5349 enum ath9k_ht_macmode macmode
)
5351 int i
, regWrites
= 0;
5352 struct ath_hal_5416
*ahp
= AH5416(ah
);
5353 u32 modesIndex
, freqIndex
;
5356 switch (chan
->chanmode
) {
5358 case CHANNEL_A_HT20
:
5362 case CHANNEL_A_HT40PLUS
:
5363 case CHANNEL_A_HT40MINUS
:
5368 case CHANNEL_G_HT20
:
5373 case CHANNEL_G_HT40PLUS
:
5374 case CHANNEL_G_HT40MINUS
:
5383 REG_WRITE(ah
, AR_PHY(0), 0x00000007);
5385 REG_WRITE(ah
, AR_PHY_ADC_SERIAL_CTL
, AR_PHY_SEL_EXTERNAL_RADIO
);
5387 ath9k_hw_set_addac(ah
, chan
);
5389 if (AR_SREV_5416_V22_OR_LATER(ah
)) {
5390 REG_WRITE_ARRAY(&ahp
->ah_iniAddac
, 1, regWrites
);
5392 struct ar5416IniArray temp
;
5394 sizeof(u32
) * ahp
->ah_iniAddac
.ia_rows
*
5395 ahp
->ah_iniAddac
.ia_columns
;
5397 memcpy(ahp
->ah_addac5416_21
,
5398 ahp
->ah_iniAddac
.ia_array
, addacSize
);
5400 (ahp
->ah_addac5416_21
)[31 *
5401 ahp
->ah_iniAddac
.ia_columns
+ 1] = 0;
5403 temp
.ia_array
= ahp
->ah_addac5416_21
;
5404 temp
.ia_columns
= ahp
->ah_iniAddac
.ia_columns
;
5405 temp
.ia_rows
= ahp
->ah_iniAddac
.ia_rows
;
5406 REG_WRITE_ARRAY(&temp
, 1, regWrites
);
5408 REG_WRITE(ah
, AR_PHY_ADC_SERIAL_CTL
, AR_PHY_SEL_INTERNAL_ADDAC
);
5410 for (i
= 0; i
< ahp
->ah_iniModes
.ia_rows
; i
++) {
5411 u32 reg
= INI_RA(&ahp
->ah_iniModes
, i
, 0);
5412 u32 val
= INI_RA(&ahp
->ah_iniModes
, i
, modesIndex
);
5414 #ifdef CONFIG_SLOW_ANT_DIV
5415 if (ah
->ah_devid
== AR9280_DEVID_PCI
)
5416 val
= ath9k_hw_ini_fixup(ah
, &ahp
->ah_eeprom
, reg
,
5420 REG_WRITE(ah
, reg
, val
);
5422 if (reg
>= 0x7800 && reg
< 0x78a0
5423 && ah
->ah_config
.analog_shiftreg
) {
5427 DO_DELAY(regWrites
);
5430 for (i
= 0; i
< ahp
->ah_iniCommon
.ia_rows
; i
++) {
5431 u32 reg
= INI_RA(&ahp
->ah_iniCommon
, i
, 0);
5432 u32 val
= INI_RA(&ahp
->ah_iniCommon
, i
, 1);
5434 REG_WRITE(ah
, reg
, val
);
5436 if (reg
>= 0x7800 && reg
< 0x78a0
5437 && ah
->ah_config
.analog_shiftreg
) {
5441 DO_DELAY(regWrites
);
5444 ath9k_hw_write_regs(ah
, modesIndex
, freqIndex
, regWrites
);
5446 if (AR_SREV_9280_20(ah
) && IS_CHAN_A_5MHZ_SPACED(chan
)) {
5447 REG_WRITE_ARRAY(&ahp
->ah_iniModesAdditional
, modesIndex
,
5451 ath9k_hw_override_ini(ah
, chan
);
5452 ath9k_hw_set_regs(ah
, chan
, macmode
);
5453 ath9k_hw_init_chain_masks(ah
);
5455 status
= ath9k_hw_set_txpower(ah
, &ahp
->ah_eeprom
, chan
,
5456 ath9k_regd_get_ctl(ah
, chan
),
5457 ath9k_regd_get_antenna_allowed(ah
,
5459 chan
->maxRegTxPower
* 2,
5460 min((u32
) MAX_RATE_POWER
,
5461 (u32
) ah
->ah_powerLimit
));
5463 DPRINTF(ah
->ah_sc
, ATH_DBG_POWER_MGMT
,
5464 "%s: error init'ing transmit power\n", __func__
);
5468 if (!ath9k_hw_set_rf_regs(ah
, chan
, freqIndex
)) {
5469 DPRINTF(ah
->ah_sc
, ATH_DBG_REG_IO
,
5470 "%s: ar5416SetRfRegs failed\n", __func__
);
5477 static void ath9k_hw_setup_calibration(struct ath_hal
*ah
,
5478 struct hal_cal_list
*currCal
)
5480 REG_RMW_FIELD(ah
, AR_PHY_TIMING_CTRL4(0),
5481 AR_PHY_TIMING_CTRL4_IQCAL_LOG_COUNT_MAX
,
5482 currCal
->calData
->calCountMax
);
5484 switch (currCal
->calData
->calType
) {
5485 case IQ_MISMATCH_CAL
:
5486 REG_WRITE(ah
, AR_PHY_CALMODE
, AR_PHY_CALMODE_IQ
);
5487 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5488 "%s: starting IQ Mismatch Calibration\n",
5492 REG_WRITE(ah
, AR_PHY_CALMODE
, AR_PHY_CALMODE_ADC_GAIN
);
5493 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5494 "%s: starting ADC Gain Calibration\n", __func__
);
5497 REG_WRITE(ah
, AR_PHY_CALMODE
, AR_PHY_CALMODE_ADC_DC_PER
);
5498 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5499 "%s: starting ADC DC Calibration\n", __func__
);
5501 case ADC_DC_INIT_CAL
:
5502 REG_WRITE(ah
, AR_PHY_CALMODE
, AR_PHY_CALMODE_ADC_DC_INIT
);
5503 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5504 "%s: starting Init ADC DC Calibration\n",
5509 REG_SET_BIT(ah
, AR_PHY_TIMING_CTRL4(0),
5510 AR_PHY_TIMING_CTRL4_DO_CAL
);
5513 static void ath9k_hw_reset_calibration(struct ath_hal
*ah
,
5514 struct hal_cal_list
*currCal
)
5516 struct ath_hal_5416
*ahp
= AH5416(ah
);
5519 ath9k_hw_setup_calibration(ah
, currCal
);
5521 currCal
->calState
= CAL_RUNNING
;
5523 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
5524 ahp
->ah_Meas0
.sign
[i
] = 0;
5525 ahp
->ah_Meas1
.sign
[i
] = 0;
5526 ahp
->ah_Meas2
.sign
[i
] = 0;
5527 ahp
->ah_Meas3
.sign
[i
] = 0;
5530 ahp
->ah_CalSamples
= 0;
5534 ath9k_hw_per_calibration(struct ath_hal
*ah
,
5535 struct ath9k_channel
*ichan
,
5537 struct hal_cal_list
*currCal
,
5540 struct ath_hal_5416
*ahp
= AH5416(ah
);
5544 if (currCal
->calState
== CAL_RUNNING
) {
5546 AR_PHY_TIMING_CTRL4(0)) &
5547 AR_PHY_TIMING_CTRL4_DO_CAL
)) {
5549 currCal
->calData
->calCollect(ah
);
5551 ahp
->ah_CalSamples
++;
5553 if (ahp
->ah_CalSamples
>=
5554 currCal
->calData
->calNumSamples
) {
5555 int i
, numChains
= 0;
5556 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
5557 if (rxchainmask
& (1 << i
))
5561 currCal
->calData
->calPostProc(ah
,
5565 currCal
->calData
->calType
;
5566 currCal
->calState
= CAL_DONE
;
5569 ath9k_hw_setup_calibration(ah
, currCal
);
5572 } else if (!(ichan
->CalValid
& currCal
->calData
->calType
)) {
5573 ath9k_hw_reset_calibration(ah
, currCal
);
5577 static inline bool ath9k_hw_run_init_cals(struct ath_hal
*ah
,
5580 struct ath_hal_5416
*ahp
= AH5416(ah
);
5581 struct ath9k_channel ichan
;
5583 struct hal_cal_list
*currCal
= ahp
->ah_cal_list_curr
;
5584 const struct hal_percal_data
*calData
= currCal
->calData
;
5587 if (currCal
== NULL
)
5592 for (i
= 0; i
< init_cal_count
; i
++) {
5593 ath9k_hw_reset_calibration(ah
, currCal
);
5595 if (!ath9k_hw_wait(ah
, AR_PHY_TIMING_CTRL4(0),
5596 AR_PHY_TIMING_CTRL4_DO_CAL
, 0)) {
5597 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5598 "%s: Cal %d failed to complete in 100ms.\n",
5599 __func__
, calData
->calType
);
5601 ahp
->ah_cal_list
= ahp
->ah_cal_list_last
=
5602 ahp
->ah_cal_list_curr
= NULL
;
5606 ath9k_hw_per_calibration(ah
, &ichan
, ahp
->ah_rxchainmask
,
5607 currCal
, &isCalDone
);
5609 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5610 "%s: Not able to run Init Cal %d.\n",
5611 __func__
, calData
->calType
);
5613 if (currCal
->calNext
) {
5614 currCal
= currCal
->calNext
;
5615 calData
= currCal
->calData
;
5619 ahp
->ah_cal_list
= ahp
->ah_cal_list_last
= ahp
->ah_cal_list_curr
= NULL
;
5624 ath9k_hw_channel_change(struct ath_hal
*ah
,
5625 struct ath9k_channel
*chan
,
5626 enum ath9k_ht_macmode macmode
)
5628 u32 synthDelay
, qnum
;
5629 struct ath_hal_5416
*ahp
= AH5416(ah
);
5631 for (qnum
= 0; qnum
< AR_NUM_QCU
; qnum
++) {
5632 if (ath9k_hw_numtxpending(ah
, qnum
)) {
5633 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
5634 "%s: Transmit frames pending on queue %d\n",
5640 REG_WRITE(ah
, AR_PHY_RFBUS_REQ
, AR_PHY_RFBUS_REQ_EN
);
5641 if (!ath9k_hw_wait(ah
, AR_PHY_RFBUS_GRANT
, AR_PHY_RFBUS_GRANT_EN
,
5642 AR_PHY_RFBUS_GRANT_EN
)) {
5643 DPRINTF(ah
->ah_sc
, ATH_DBG_PHY_IO
,
5644 "%s: Could not kill baseband RX\n", __func__
);
5648 ath9k_hw_set_regs(ah
, chan
, macmode
);
5650 if (AR_SREV_9280_10_OR_LATER(ah
)) {
5651 if (!(ath9k_hw_ar9280_set_channel(ah
, chan
))) {
5652 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
5653 "%s: failed to set channel\n", __func__
);
5657 if (!(ath9k_hw_set_channel(ah
, chan
))) {
5658 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
5659 "%s: failed to set channel\n", __func__
);
5664 if (ath9k_hw_set_txpower(ah
, &ahp
->ah_eeprom
, chan
,
5665 ath9k_regd_get_ctl(ah
, chan
),
5666 ath9k_regd_get_antenna_allowed(ah
, chan
),
5667 chan
->maxRegTxPower
* 2,
5668 min((u32
) MAX_RATE_POWER
,
5669 (u32
) ah
->ah_powerLimit
)) != 0) {
5670 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
5671 "%s: error init'ing transmit power\n", __func__
);
5675 synthDelay
= REG_READ(ah
, AR_PHY_RX_DELAY
) & AR_PHY_RX_DELAY_DELAY
;
5676 if (IS_CHAN_CCK(chan
))
5677 synthDelay
= (4 * synthDelay
) / 22;
5681 udelay(synthDelay
+ BASE_ACTIVATE_DELAY
);
5683 REG_WRITE(ah
, AR_PHY_RFBUS_REQ
, 0);
5685 if (IS_CHAN_OFDM(chan
) || IS_CHAN_HT(chan
))
5686 ath9k_hw_set_delta_slope(ah
, chan
);
5688 if (AR_SREV_9280_10_OR_LATER(ah
))
5689 ath9k_hw_9280_spur_mitigate(ah
, chan
);
5691 ath9k_hw_spur_mitigate(ah
, chan
);
5693 if (!chan
->oneTimeCalsDone
)
5694 chan
->oneTimeCalsDone
= true;
5699 static bool ath9k_hw_chip_reset(struct ath_hal
*ah
,
5700 struct ath9k_channel
*chan
)
5702 struct ath_hal_5416
*ahp
= AH5416(ah
);
5704 if (!ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_WARM
))
5707 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
))
5710 ahp
->ah_chipFullSleep
= false;
5712 ath9k_hw_init_pll(ah
, chan
);
5714 ath9k_hw_set_rfmode(ah
, chan
);
5719 static inline void ath9k_hw_set_dma(struct ath_hal
*ah
)
5723 regval
= REG_READ(ah
, AR_AHB_MODE
);
5724 REG_WRITE(ah
, AR_AHB_MODE
, regval
| AR_AHB_PREFETCH_RD_EN
);
5726 regval
= REG_READ(ah
, AR_TXCFG
) & ~AR_TXCFG_DMASZ_MASK
;
5727 REG_WRITE(ah
, AR_TXCFG
, regval
| AR_TXCFG_DMASZ_128B
);
5729 REG_RMW_FIELD(ah
, AR_TXCFG
, AR_FTRIG
, ah
->ah_txTrigLevel
);
5731 regval
= REG_READ(ah
, AR_RXCFG
) & ~AR_RXCFG_DMASZ_MASK
;
5732 REG_WRITE(ah
, AR_RXCFG
, regval
| AR_RXCFG_DMASZ_128B
);
5734 REG_WRITE(ah
, AR_RXFIFO_CFG
, 0x200);
5736 if (AR_SREV_9285(ah
)) {
5737 REG_WRITE(ah
, AR_PCU_TXBUF_CTRL
,
5738 AR_9285_PCU_TXBUF_CTRL_USABLE_SIZE
);
5740 REG_WRITE(ah
, AR_PCU_TXBUF_CTRL
,
5741 AR_PCU_TXBUF_CTRL_USABLE_SIZE
);
5745 bool ath9k_hw_stopdmarecv(struct ath_hal
*ah
)
5747 REG_WRITE(ah
, AR_CR
, AR_CR_RXD
);
5748 if (!ath9k_hw_wait(ah
, AR_CR
, AR_CR_RXE
, 0)) {
5749 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
5750 "%s: dma failed to stop in 10ms\n"
5751 "AR_CR=0x%08x\nAR_DIAG_SW=0x%08x\n",
5753 REG_READ(ah
, AR_CR
), REG_READ(ah
, AR_DIAG_SW
));
5760 void ath9k_hw_startpcureceive(struct ath_hal
*ah
)
5762 REG_CLR_BIT(ah
, AR_DIAG_SW
,
5763 (AR_DIAG_RX_DIS
| AR_DIAG_RX_ABORT
));
5765 ath9k_enable_mib_counters(ah
);
5767 ath9k_ani_reset(ah
);
5770 void ath9k_hw_stoppcurecv(struct ath_hal
*ah
)
5772 REG_SET_BIT(ah
, AR_DIAG_SW
, AR_DIAG_RX_DIS
);
5774 ath9k_hw_disable_mib_counters(ah
);
5777 static bool ath9k_hw_iscal_supported(struct ath_hal
*ah
,
5778 struct ath9k_channel
*chan
,
5779 enum hal_cal_types calType
)
5781 struct ath_hal_5416
*ahp
= AH5416(ah
);
5782 bool retval
= false;
5784 switch (calType
& ahp
->ah_suppCals
) {
5785 case IQ_MISMATCH_CAL
:
5786 if (!IS_CHAN_B(chan
))
5791 if (!IS_CHAN_B(chan
)
5792 && !(IS_CHAN_2GHZ(chan
) && IS_CHAN_HT20(chan
)))
5800 static bool ath9k_hw_init_cal(struct ath_hal
*ah
,
5801 struct ath9k_channel
*chan
)
5803 struct ath_hal_5416
*ahp
= AH5416(ah
);
5804 struct ath9k_channel
*ichan
=
5805 ath9k_regd_check_channel(ah
, chan
);
5807 REG_WRITE(ah
, AR_PHY_AGC_CONTROL
,
5808 REG_READ(ah
, AR_PHY_AGC_CONTROL
) |
5809 AR_PHY_AGC_CONTROL_CAL
);
5812 (ah
, AR_PHY_AGC_CONTROL
, AR_PHY_AGC_CONTROL_CAL
, 0)) {
5813 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5814 "%s: offset calibration failed to complete in 1ms; "
5815 "noisy environment?\n", __func__
);
5819 REG_WRITE(ah
, AR_PHY_AGC_CONTROL
,
5820 REG_READ(ah
, AR_PHY_AGC_CONTROL
) |
5821 AR_PHY_AGC_CONTROL_NF
);
5823 ahp
->ah_cal_list
= ahp
->ah_cal_list_last
= ahp
->ah_cal_list_curr
=
5826 if (AR_SREV_9100(ah
) || AR_SREV_9160_10_OR_LATER(ah
)) {
5827 if (ath9k_hw_iscal_supported(ah
, chan
, ADC_GAIN_CAL
)) {
5828 INIT_CAL(&ahp
->ah_adcGainCalData
);
5829 INSERT_CAL(ahp
, &ahp
->ah_adcGainCalData
);
5830 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5831 "%s: enabling ADC Gain Calibration.\n",
5834 if (ath9k_hw_iscal_supported(ah
, chan
, ADC_DC_CAL
)) {
5835 INIT_CAL(&ahp
->ah_adcDcCalData
);
5836 INSERT_CAL(ahp
, &ahp
->ah_adcDcCalData
);
5837 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5838 "%s: enabling ADC DC Calibration.\n",
5841 if (ath9k_hw_iscal_supported(ah
, chan
, IQ_MISMATCH_CAL
)) {
5842 INIT_CAL(&ahp
->ah_iqCalData
);
5843 INSERT_CAL(ahp
, &ahp
->ah_iqCalData
);
5844 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
5845 "%s: enabling IQ Calibration.\n",
5849 ahp
->ah_cal_list_curr
= ahp
->ah_cal_list
;
5851 if (ahp
->ah_cal_list_curr
)
5852 ath9k_hw_reset_calibration(ah
,
5853 ahp
->ah_cal_list_curr
);
5856 ichan
->CalValid
= 0;
5862 bool ath9k_hw_reset(struct ath_hal
*ah
,
5863 struct ath9k_channel
*chan
,
5864 enum ath9k_ht_macmode macmode
,
5865 u8 txchainmask
, u8 rxchainmask
,
5866 enum ath9k_ht_extprotspacing extprotspacing
,
5867 bool bChannelChange
,
5870 #define FAIL(_code) do { ecode = _code; goto bad; } while (0)
5872 struct ath_hal_5416
*ahp
= AH5416(ah
);
5873 struct ath9k_channel
*curchan
= ah
->ah_curchan
;
5877 int i
, rx_chainmask
;
5879 ahp
->ah_extprotspacing
= extprotspacing
;
5880 ahp
->ah_txchainmask
= txchainmask
;
5881 ahp
->ah_rxchainmask
= rxchainmask
;
5883 if (AR_SREV_9280(ah
)) {
5884 ahp
->ah_txchainmask
&= 0x3;
5885 ahp
->ah_rxchainmask
&= 0x3;
5888 if (ath9k_hw_check_chan(ah
, chan
) == NULL
) {
5889 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
5890 "%s: invalid channel %u/0x%x; no mapping\n",
5891 __func__
, chan
->channel
, chan
->channelFlags
);
5895 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
))
5899 ath9k_hw_getnf(ah
, curchan
);
5901 if (bChannelChange
&&
5902 (ahp
->ah_chipFullSleep
!= true) &&
5903 (ah
->ah_curchan
!= NULL
) &&
5904 (chan
->channel
!= ah
->ah_curchan
->channel
) &&
5905 ((chan
->channelFlags
& CHANNEL_ALL
) ==
5906 (ah
->ah_curchan
->channelFlags
& CHANNEL_ALL
)) &&
5907 (!AR_SREV_9280(ah
) || (!IS_CHAN_A_5MHZ_SPACED(chan
) &&
5908 !IS_CHAN_A_5MHZ_SPACED(ah
->
5911 if (ath9k_hw_channel_change(ah
, chan
, macmode
)) {
5912 ath9k_hw_loadnf(ah
, ah
->ah_curchan
);
5913 ath9k_hw_start_nfcal(ah
);
5918 saveDefAntenna
= REG_READ(ah
, AR_DEF_ANTENNA
);
5919 if (saveDefAntenna
== 0)
5922 macStaId1
= REG_READ(ah
, AR_STA_ID1
) & AR_STA_ID1_BASE_RATE_11B
;
5924 saveLedState
= REG_READ(ah
, AR_CFG_LED
) &
5925 (AR_CFG_LED_ASSOC_CTL
| AR_CFG_LED_MODE_SEL
|
5926 AR_CFG_LED_BLINK_THRESH_SEL
| AR_CFG_LED_BLINK_SLOW
);
5928 ath9k_hw_mark_phy_inactive(ah
);
5930 if (!ath9k_hw_chip_reset(ah
, chan
)) {
5931 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s: chip reset failed\n",
5936 if (AR_SREV_9280(ah
)) {
5937 REG_SET_BIT(ah
, AR_GPIO_INPUT_EN_VAL
,
5938 AR_GPIO_JTAG_DISABLE
);
5940 if (test_bit(ATH9K_MODE_11A
, ah
->ah_caps
.wireless_modes
)) {
5941 if (IS_CHAN_5GHZ(chan
))
5942 ath9k_hw_set_gpio(ah
, 9, 0);
5944 ath9k_hw_set_gpio(ah
, 9, 1);
5946 ath9k_hw_cfg_output(ah
, 9, AR_GPIO_OUTPUT_MUX_AS_OUTPUT
);
5949 ecode
= ath9k_hw_process_ini(ah
, chan
, macmode
);
5953 if (IS_CHAN_OFDM(chan
) || IS_CHAN_HT(chan
))
5954 ath9k_hw_set_delta_slope(ah
, chan
);
5956 if (AR_SREV_9280_10_OR_LATER(ah
))
5957 ath9k_hw_9280_spur_mitigate(ah
, chan
);
5959 ath9k_hw_spur_mitigate(ah
, chan
);
5961 if (!ath9k_hw_eeprom_set_board_values(ah
, chan
)) {
5962 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
5963 "%s: error setting board options\n", __func__
);
5967 ath9k_hw_decrease_chain_power(ah
, chan
);
5969 REG_WRITE(ah
, AR_STA_ID0
, get_unaligned_le32(ahp
->ah_macaddr
));
5970 REG_WRITE(ah
, AR_STA_ID1
, get_unaligned_le16(ahp
->ah_macaddr
+ 4)
5972 | AR_STA_ID1_RTS_USE_DEF
5974 ack_6mb
? AR_STA_ID1_ACKCTS_6MB
: 0)
5975 | ahp
->ah_staId1Defaults
);
5976 ath9k_hw_set_operating_mode(ah
, ah
->ah_opmode
);
5978 REG_WRITE(ah
, AR_BSSMSKL
, get_unaligned_le32(ahp
->ah_bssidmask
));
5979 REG_WRITE(ah
, AR_BSSMSKU
, get_unaligned_le16(ahp
->ah_bssidmask
+ 4));
5981 REG_WRITE(ah
, AR_DEF_ANTENNA
, saveDefAntenna
);
5983 REG_WRITE(ah
, AR_BSS_ID0
, get_unaligned_le32(ahp
->ah_bssid
));
5984 REG_WRITE(ah
, AR_BSS_ID1
, get_unaligned_le16(ahp
->ah_bssid
+ 4) |
5985 ((ahp
->ah_assocId
& 0x3fff) << AR_BSS_ID1_AID_S
));
5987 REG_WRITE(ah
, AR_ISR
, ~0);
5989 REG_WRITE(ah
, AR_RSSI_THR
, INIT_RSSI_THR
);
5991 if (AR_SREV_9280_10_OR_LATER(ah
)) {
5992 if (!(ath9k_hw_ar9280_set_channel(ah
, chan
)))
5995 if (!(ath9k_hw_set_channel(ah
, chan
)))
5999 for (i
= 0; i
< AR_NUM_DCU
; i
++)
6000 REG_WRITE(ah
, AR_DQCUMASK(i
), 1 << i
);
6002 ahp
->ah_intrTxqs
= 0;
6003 for (i
= 0; i
< ah
->ah_caps
.total_queues
; i
++)
6004 ath9k_hw_resettxqueue(ah
, i
);
6006 ath9k_hw_init_interrupt_masks(ah
, ah
->ah_opmode
);
6007 ath9k_hw_init_qos(ah
);
6009 #ifdef CONFIG_RFKILL
6010 if (ah
->ah_caps
.hw_caps
& ATH9K_HW_CAP_RFSILENT
)
6011 ath9k_enable_rfkill(ah
);
6013 ath9k_hw_init_user_settings(ah
);
6015 REG_WRITE(ah
, AR_STA_ID1
,
6016 REG_READ(ah
, AR_STA_ID1
) | AR_STA_ID1_PRESERVE_SEQNUM
);
6018 ath9k_hw_set_dma(ah
);
6020 REG_WRITE(ah
, AR_OBS
, 8);
6022 if (ahp
->ah_intrMitigation
) {
6024 REG_RMW_FIELD(ah
, AR_RIMT
, AR_RIMT_LAST
, 500);
6025 REG_RMW_FIELD(ah
, AR_RIMT
, AR_RIMT_FIRST
, 2000);
6028 ath9k_hw_init_bb(ah
, chan
);
6030 if (!ath9k_hw_init_cal(ah
, chan
))
6033 rx_chainmask
= ahp
->ah_rxchainmask
;
6034 if ((rx_chainmask
== 0x5) || (rx_chainmask
== 0x3)) {
6035 REG_WRITE(ah
, AR_PHY_RX_CHAINMASK
, rx_chainmask
);
6036 REG_WRITE(ah
, AR_PHY_CAL_CHAINMASK
, rx_chainmask
);
6039 REG_WRITE(ah
, AR_CFG_LED
, saveLedState
| AR_CFG_SCLK_32KHZ
);
6041 if (AR_SREV_9100(ah
)) {
6043 mask
= REG_READ(ah
, AR_CFG
);
6044 if (mask
& (AR_CFG_SWRB
| AR_CFG_SWTB
| AR_CFG_SWRG
)) {
6045 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
6046 "%s CFG Byte Swap Set 0x%x\n", __func__
,
6050 INIT_CONFIG_STATUS
| AR_CFG_SWRB
| AR_CFG_SWTB
;
6051 REG_WRITE(ah
, AR_CFG
, mask
);
6052 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
6053 "%s Setting CFG 0x%x\n", __func__
,
6054 REG_READ(ah
, AR_CFG
));
6058 REG_WRITE(ah
, AR_CFG
, AR_CFG_SWTD
| AR_CFG_SWRD
);
6070 bool ath9k_hw_phy_disable(struct ath_hal
*ah
)
6072 return ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_WARM
);
6075 bool ath9k_hw_disable(struct ath_hal
*ah
)
6077 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
))
6080 return ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_COLD
);
6084 ath9k_hw_calibrate(struct ath_hal
*ah
, struct ath9k_channel
*chan
,
6085 u8 rxchainmask
, bool longcal
,
6088 struct ath_hal_5416
*ahp
= AH5416(ah
);
6089 struct hal_cal_list
*currCal
= ahp
->ah_cal_list_curr
;
6090 struct ath9k_channel
*ichan
=
6091 ath9k_regd_check_channel(ah
, chan
);
6095 if (ichan
== NULL
) {
6096 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
,
6097 "%s: invalid channel %u/0x%x; no mapping\n",
6098 __func__
, chan
->channel
, chan
->channelFlags
);
6103 (currCal
->calState
== CAL_RUNNING
||
6104 currCal
->calState
== CAL_WAITING
)) {
6105 ath9k_hw_per_calibration(ah
, ichan
, rxchainmask
, currCal
,
6108 ahp
->ah_cal_list_curr
= currCal
= currCal
->calNext
;
6110 if (currCal
->calState
== CAL_WAITING
) {
6112 ath9k_hw_reset_calibration(ah
, currCal
);
6118 ath9k_hw_getnf(ah
, ichan
);
6119 ath9k_hw_loadnf(ah
, ah
->ah_curchan
);
6120 ath9k_hw_start_nfcal(ah
);
6122 if ((ichan
->channelFlags
& CHANNEL_CW_INT
) != 0) {
6124 chan
->channelFlags
|= CHANNEL_CW_INT
;
6125 ichan
->channelFlags
&= ~CHANNEL_CW_INT
;
6132 static void ath9k_hw_iqcal_collect(struct ath_hal
*ah
)
6134 struct ath_hal_5416
*ahp
= AH5416(ah
);
6137 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
6138 ahp
->ah_totalPowerMeasI
[i
] +=
6139 REG_READ(ah
, AR_PHY_CAL_MEAS_0(i
));
6140 ahp
->ah_totalPowerMeasQ
[i
] +=
6141 REG_READ(ah
, AR_PHY_CAL_MEAS_1(i
));
6142 ahp
->ah_totalIqCorrMeas
[i
] +=
6143 (int32_t) REG_READ(ah
, AR_PHY_CAL_MEAS_2(i
));
6144 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6145 "%d: Chn %d pmi=0x%08x;pmq=0x%08x;iqcm=0x%08x;\n",
6146 ahp
->ah_CalSamples
, i
, ahp
->ah_totalPowerMeasI
[i
],
6147 ahp
->ah_totalPowerMeasQ
[i
],
6148 ahp
->ah_totalIqCorrMeas
[i
]);
6152 static void ath9k_hw_adc_gaincal_collect(struct ath_hal
*ah
)
6154 struct ath_hal_5416
*ahp
= AH5416(ah
);
6157 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
6158 ahp
->ah_totalAdcIOddPhase
[i
] +=
6159 REG_READ(ah
, AR_PHY_CAL_MEAS_0(i
));
6160 ahp
->ah_totalAdcIEvenPhase
[i
] +=
6161 REG_READ(ah
, AR_PHY_CAL_MEAS_1(i
));
6162 ahp
->ah_totalAdcQOddPhase
[i
] +=
6163 REG_READ(ah
, AR_PHY_CAL_MEAS_2(i
));
6164 ahp
->ah_totalAdcQEvenPhase
[i
] +=
6165 REG_READ(ah
, AR_PHY_CAL_MEAS_3(i
));
6167 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6168 "%d: Chn %d oddi=0x%08x; eveni=0x%08x; "
6169 "oddq=0x%08x; evenq=0x%08x;\n",
6170 ahp
->ah_CalSamples
, i
,
6171 ahp
->ah_totalAdcIOddPhase
[i
],
6172 ahp
->ah_totalAdcIEvenPhase
[i
],
6173 ahp
->ah_totalAdcQOddPhase
[i
],
6174 ahp
->ah_totalAdcQEvenPhase
[i
]);
6178 static void ath9k_hw_adc_dccal_collect(struct ath_hal
*ah
)
6180 struct ath_hal_5416
*ahp
= AH5416(ah
);
6183 for (i
= 0; i
< AR5416_MAX_CHAINS
; i
++) {
6184 ahp
->ah_totalAdcDcOffsetIOddPhase
[i
] +=
6185 (int32_t) REG_READ(ah
, AR_PHY_CAL_MEAS_0(i
));
6186 ahp
->ah_totalAdcDcOffsetIEvenPhase
[i
] +=
6187 (int32_t) REG_READ(ah
, AR_PHY_CAL_MEAS_1(i
));
6188 ahp
->ah_totalAdcDcOffsetQOddPhase
[i
] +=
6189 (int32_t) REG_READ(ah
, AR_PHY_CAL_MEAS_2(i
));
6190 ahp
->ah_totalAdcDcOffsetQEvenPhase
[i
] +=
6191 (int32_t) REG_READ(ah
, AR_PHY_CAL_MEAS_3(i
));
6193 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6194 "%d: Chn %d oddi=0x%08x; eveni=0x%08x; "
6195 "oddq=0x%08x; evenq=0x%08x;\n",
6196 ahp
->ah_CalSamples
, i
,
6197 ahp
->ah_totalAdcDcOffsetIOddPhase
[i
],
6198 ahp
->ah_totalAdcDcOffsetIEvenPhase
[i
],
6199 ahp
->ah_totalAdcDcOffsetQOddPhase
[i
],
6200 ahp
->ah_totalAdcDcOffsetQEvenPhase
[i
]);
6204 static void ath9k_hw_iqcalibrate(struct ath_hal
*ah
, u8 numChains
)
6206 struct ath_hal_5416
*ahp
= AH5416(ah
);
6207 u32 powerMeasQ
, powerMeasI
, iqCorrMeas
;
6208 u32 qCoffDenom
, iCoffDenom
;
6209 int32_t qCoff
, iCoff
;
6212 for (i
= 0; i
< numChains
; i
++) {
6213 powerMeasI
= ahp
->ah_totalPowerMeasI
[i
];
6214 powerMeasQ
= ahp
->ah_totalPowerMeasQ
[i
];
6215 iqCorrMeas
= ahp
->ah_totalIqCorrMeas
[i
];
6217 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6218 "Starting IQ Cal and Correction for Chain %d\n",
6221 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6222 "Orignal: Chn %diq_corr_meas = 0x%08x\n",
6223 i
, ahp
->ah_totalIqCorrMeas
[i
]);
6228 if (iqCorrMeas
> 0x80000000) {
6229 iqCorrMeas
= (0xffffffff - iqCorrMeas
) + 1;
6233 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6234 "Chn %d pwr_meas_i = 0x%08x\n", i
, powerMeasI
);
6235 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6236 "Chn %d pwr_meas_q = 0x%08x\n", i
, powerMeasQ
);
6237 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
, "iqCorrNeg is 0x%08x\n",
6240 iCoffDenom
= (powerMeasI
/ 2 + powerMeasQ
/ 2) / 128;
6241 qCoffDenom
= powerMeasQ
/ 64;
6243 if (powerMeasQ
!= 0) {
6245 iCoff
= iqCorrMeas
/ iCoffDenom
;
6246 qCoff
= powerMeasI
/ qCoffDenom
- 64;
6247 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6248 "Chn %d iCoff = 0x%08x\n", i
, iCoff
);
6249 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6250 "Chn %d qCoff = 0x%08x\n", i
, qCoff
);
6253 iCoff
= iCoff
& 0x3f;
6254 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6255 "New: Chn %d iCoff = 0x%08x\n", i
, iCoff
);
6256 if (iqCorrNeg
== 0x0)
6257 iCoff
= 0x40 - iCoff
;
6261 else if (qCoff
<= -16)
6264 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6265 "Chn %d : iCoff = 0x%x qCoff = 0x%x\n",
6268 REG_RMW_FIELD(ah
, AR_PHY_TIMING_CTRL4(i
),
6269 AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF
,
6271 REG_RMW_FIELD(ah
, AR_PHY_TIMING_CTRL4(i
),
6272 AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF
,
6274 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6275 "IQ Cal and Correction done for Chain %d\n",
6280 REG_SET_BIT(ah
, AR_PHY_TIMING_CTRL4(0),
6281 AR_PHY_TIMING_CTRL4_IQCORR_ENABLE
);
6285 ath9k_hw_adc_gaincal_calibrate(struct ath_hal
*ah
, u8 numChains
)
6287 struct ath_hal_5416
*ahp
= AH5416(ah
);
6288 u32 iOddMeasOffset
, iEvenMeasOffset
, qOddMeasOffset
,
6290 u32 qGainMismatch
, iGainMismatch
, val
, i
;
6292 for (i
= 0; i
< numChains
; i
++) {
6293 iOddMeasOffset
= ahp
->ah_totalAdcIOddPhase
[i
];
6294 iEvenMeasOffset
= ahp
->ah_totalAdcIEvenPhase
[i
];
6295 qOddMeasOffset
= ahp
->ah_totalAdcQOddPhase
[i
];
6296 qEvenMeasOffset
= ahp
->ah_totalAdcQEvenPhase
[i
];
6298 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6299 "Starting ADC Gain Cal for Chain %d\n", i
);
6301 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6302 "Chn %d pwr_meas_odd_i = 0x%08x\n", i
,
6304 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6305 "Chn %d pwr_meas_even_i = 0x%08x\n", i
,
6307 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6308 "Chn %d pwr_meas_odd_q = 0x%08x\n", i
,
6310 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6311 "Chn %d pwr_meas_even_q = 0x%08x\n", i
,
6314 if (iOddMeasOffset
!= 0 && qEvenMeasOffset
!= 0) {
6316 ((iEvenMeasOffset
* 32) /
6317 iOddMeasOffset
) & 0x3f;
6319 ((qOddMeasOffset
* 32) /
6320 qEvenMeasOffset
) & 0x3f;
6322 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6323 "Chn %d gain_mismatch_i = 0x%08x\n", i
,
6325 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6326 "Chn %d gain_mismatch_q = 0x%08x\n", i
,
6329 val
= REG_READ(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(i
));
6331 val
|= (qGainMismatch
) | (iGainMismatch
<< 6);
6332 REG_WRITE(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(i
), val
);
6334 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6335 "ADC Gain Cal done for Chain %d\n", i
);
6339 REG_WRITE(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(0),
6340 REG_READ(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(0)) |
6341 AR_PHY_NEW_ADC_GAIN_CORR_ENABLE
);
6345 ath9k_hw_adc_dccal_calibrate(struct ath_hal
*ah
, u8 numChains
)
6347 struct ath_hal_5416
*ahp
= AH5416(ah
);
6348 u32 iOddMeasOffset
, iEvenMeasOffset
, val
, i
;
6349 int32_t qOddMeasOffset
, qEvenMeasOffset
, qDcMismatch
, iDcMismatch
;
6350 const struct hal_percal_data
*calData
=
6351 ahp
->ah_cal_list_curr
->calData
;
6353 (1 << (calData
->calCountMax
+ 5)) * calData
->calNumSamples
;
6355 for (i
= 0; i
< numChains
; i
++) {
6356 iOddMeasOffset
= ahp
->ah_totalAdcDcOffsetIOddPhase
[i
];
6357 iEvenMeasOffset
= ahp
->ah_totalAdcDcOffsetIEvenPhase
[i
];
6358 qOddMeasOffset
= ahp
->ah_totalAdcDcOffsetQOddPhase
[i
];
6359 qEvenMeasOffset
= ahp
->ah_totalAdcDcOffsetQEvenPhase
[i
];
6361 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6362 "Starting ADC DC Offset Cal for Chain %d\n", i
);
6364 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6365 "Chn %d pwr_meas_odd_i = %d\n", i
,
6367 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6368 "Chn %d pwr_meas_even_i = %d\n", i
,
6370 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6371 "Chn %d pwr_meas_odd_q = %d\n", i
,
6373 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6374 "Chn %d pwr_meas_even_q = %d\n", i
,
6377 iDcMismatch
= (((iEvenMeasOffset
- iOddMeasOffset
) * 2) /
6378 numSamples
) & 0x1ff;
6379 qDcMismatch
= (((qOddMeasOffset
- qEvenMeasOffset
) * 2) /
6380 numSamples
) & 0x1ff;
6382 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6383 "Chn %d dc_offset_mismatch_i = 0x%08x\n", i
,
6385 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6386 "Chn %d dc_offset_mismatch_q = 0x%08x\n", i
,
6389 val
= REG_READ(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(i
));
6391 val
|= (qDcMismatch
<< 12) | (iDcMismatch
<< 21);
6392 REG_WRITE(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(i
), val
);
6394 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6395 "ADC DC Offset Cal done for Chain %d\n", i
);
6398 REG_WRITE(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(0),
6399 REG_READ(ah
, AR_PHY_NEW_ADC_DC_GAIN_CORR(0)) |
6400 AR_PHY_NEW_ADC_DC_OFFSET_CORR_ENABLE
);
6403 bool ath9k_hw_set_txpowerlimit(struct ath_hal
*ah
, u32 limit
)
6405 struct ath_hal_5416
*ahp
= AH5416(ah
);
6406 struct ath9k_channel
*chan
= ah
->ah_curchan
;
6408 ah
->ah_powerLimit
= min(limit
, (u32
) MAX_RATE_POWER
);
6410 if (ath9k_hw_set_txpower(ah
, &ahp
->ah_eeprom
, chan
,
6411 ath9k_regd_get_ctl(ah
, chan
),
6412 ath9k_regd_get_antenna_allowed(ah
,
6414 chan
->maxRegTxPower
* 2,
6415 min((u32
) MAX_RATE_POWER
,
6416 (u32
) ah
->ah_powerLimit
)) != 0)
6423 ath9k_hw_get_channel_centers(struct ath_hal
*ah
,
6424 struct ath9k_channel
*chan
,
6425 struct chan_centers
*centers
)
6428 struct ath_hal_5416
*ahp
= AH5416(ah
);
6430 if (!IS_CHAN_HT40(chan
)) {
6431 centers
->ctl_center
= centers
->ext_center
=
6432 centers
->synth_center
= chan
->channel
;
6436 if ((chan
->chanmode
== CHANNEL_A_HT40PLUS
) ||
6437 (chan
->chanmode
== CHANNEL_G_HT40PLUS
)) {
6438 centers
->synth_center
=
6439 chan
->channel
+ HT40_CHANNEL_CENTER_SHIFT
;
6442 centers
->synth_center
=
6443 chan
->channel
- HT40_CHANNEL_CENTER_SHIFT
;
6447 centers
->ctl_center
= centers
->synth_center
- (extoff
*
6448 HT40_CHANNEL_CENTER_SHIFT
);
6449 centers
->ext_center
= centers
->synth_center
+ (extoff
*
6453 ATH9K_HT_EXTPROTSPACING_20
)
6455 HT40_CHANNEL_CENTER_SHIFT
6461 ath9k_hw_reset_calvalid(struct ath_hal
*ah
, struct ath9k_channel
*chan
,
6464 struct ath_hal_5416
*ahp
= AH5416(ah
);
6465 struct ath9k_channel
*ichan
=
6466 ath9k_regd_check_channel(ah
, chan
);
6467 struct hal_cal_list
*currCal
= ahp
->ah_cal_list_curr
;
6471 if (!AR_SREV_9100(ah
) && !AR_SREV_9160_10_OR_LATER(ah
))
6474 if (currCal
== NULL
)
6477 if (ichan
== NULL
) {
6478 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6479 "%s: invalid channel %u/0x%x; no mapping\n",
6480 __func__
, chan
->channel
, chan
->channelFlags
);
6485 if (currCal
->calState
!= CAL_DONE
) {
6486 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6487 "%s: Calibration state incorrect, %d\n",
6488 __func__
, currCal
->calState
);
6493 if (!ath9k_hw_iscal_supported(ah
, chan
, currCal
->calData
->calType
))
6496 DPRINTF(ah
->ah_sc
, ATH_DBG_CALIBRATE
,
6497 "%s: Resetting Cal %d state for channel %u/0x%x\n",
6498 __func__
, currCal
->calData
->calType
, chan
->channel
,
6499 chan
->channelFlags
);
6501 ichan
->CalValid
&= ~currCal
->calData
->calType
;
6502 currCal
->calState
= CAL_WAITING
;
6507 void ath9k_hw_getmac(struct ath_hal
*ah
, u8
*mac
)
6509 struct ath_hal_5416
*ahp
= AH5416(ah
);
6511 memcpy(mac
, ahp
->ah_macaddr
, ETH_ALEN
);
6514 bool ath9k_hw_setmac(struct ath_hal
*ah
, const u8
*mac
)
6516 struct ath_hal_5416
*ahp
= AH5416(ah
);
6518 memcpy(ahp
->ah_macaddr
, mac
, ETH_ALEN
);
6522 void ath9k_hw_getbssidmask(struct ath_hal
*ah
, u8
*mask
)
6524 struct ath_hal_5416
*ahp
= AH5416(ah
);
6526 memcpy(mask
, ahp
->ah_bssidmask
, ETH_ALEN
);
6530 ath9k_hw_setbssidmask(struct ath_hal
*ah
, const u8
*mask
)
6532 struct ath_hal_5416
*ahp
= AH5416(ah
);
6534 memcpy(ahp
->ah_bssidmask
, mask
, ETH_ALEN
);
6536 REG_WRITE(ah
, AR_BSSMSKL
, get_unaligned_le32(ahp
->ah_bssidmask
));
6537 REG_WRITE(ah
, AR_BSSMSKU
, get_unaligned_le16(ahp
->ah_bssidmask
+ 4));
6543 ath9k_hw_write_associd(struct ath_hal
*ah
, const u8
*bssid
,
6546 struct ath_hal_5416
*ahp
= AH5416(ah
);
6548 memcpy(ahp
->ah_bssid
, bssid
, ETH_ALEN
);
6549 ahp
->ah_assocId
= assocId
;
6551 REG_WRITE(ah
, AR_BSS_ID0
, get_unaligned_le32(ahp
->ah_bssid
));
6552 REG_WRITE(ah
, AR_BSS_ID1
, get_unaligned_le16(ahp
->ah_bssid
+ 4) |
6553 ((assocId
& 0x3fff) << AR_BSS_ID1_AID_S
));
6556 u64
ath9k_hw_gettsf64(struct ath_hal
*ah
)
6560 tsf
= REG_READ(ah
, AR_TSF_U32
);
6561 tsf
= (tsf
<< 32) | REG_READ(ah
, AR_TSF_L32
);
6565 void ath9k_hw_reset_tsf(struct ath_hal
*ah
)
6570 while (REG_READ(ah
, AR_SLP32_MODE
) & AR_SLP32_TSF_WRITE_STATUS
) {
6573 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
6574 "%s: AR_SLP32_TSF_WRITE_STATUS limit exceeded\n",
6580 REG_WRITE(ah
, AR_RESET_TSF
, AR_RESET_TSF_ONCE
);
6583 u32
ath9k_hw_getdefantenna(struct ath_hal
*ah
)
6585 return REG_READ(ah
, AR_DEF_ANTENNA
) & 0x7;
6588 void ath9k_hw_setantenna(struct ath_hal
*ah
, u32 antenna
)
6590 REG_WRITE(ah
, AR_DEF_ANTENNA
, (antenna
& 0x7));
6594 ath9k_hw_setantennaswitch(struct ath_hal
*ah
,
6595 enum ath9k_ant_setting settings
,
6596 struct ath9k_channel
*chan
,
6601 struct ath_hal_5416
*ahp
= AH5416(ah
);
6602 static u8 tx_chainmask_cfg
, rx_chainmask_cfg
;
6604 if (AR_SREV_9280(ah
)) {
6605 if (!tx_chainmask_cfg
) {
6607 tx_chainmask_cfg
= *tx_chainmask
;
6608 rx_chainmask_cfg
= *rx_chainmask
;
6612 case ATH9K_ANT_FIXED_A
:
6613 *tx_chainmask
= ATH9K_ANTENNA0_CHAINMASK
;
6614 *rx_chainmask
= ATH9K_ANTENNA0_CHAINMASK
;
6615 *antenna_cfgd
= true;
6617 case ATH9K_ANT_FIXED_B
:
6618 if (ah
->ah_caps
.tx_chainmask
>
6619 ATH9K_ANTENNA1_CHAINMASK
) {
6620 *tx_chainmask
= ATH9K_ANTENNA1_CHAINMASK
;
6622 *rx_chainmask
= ATH9K_ANTENNA1_CHAINMASK
;
6623 *antenna_cfgd
= true;
6625 case ATH9K_ANT_VARIABLE
:
6626 *tx_chainmask
= tx_chainmask_cfg
;
6627 *rx_chainmask
= rx_chainmask_cfg
;
6628 *antenna_cfgd
= true;
6634 ahp
->ah_diversityControl
= settings
;
6640 void ath9k_hw_setopmode(struct ath_hal
*ah
)
6642 ath9k_hw_set_operating_mode(ah
, ah
->ah_opmode
);
6646 ath9k_hw_getcapability(struct ath_hal
*ah
, enum ath9k_capability_type type
,
6647 u32 capability
, u32
*result
)
6649 struct ath_hal_5416
*ahp
= AH5416(ah
);
6650 const struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
6653 case ATH9K_CAP_CIPHER
:
6654 switch (capability
) {
6655 case ATH9K_CIPHER_AES_CCM
:
6656 case ATH9K_CIPHER_AES_OCB
:
6657 case ATH9K_CIPHER_TKIP
:
6658 case ATH9K_CIPHER_WEP
:
6659 case ATH9K_CIPHER_MIC
:
6660 case ATH9K_CIPHER_CLR
:
6665 case ATH9K_CAP_TKIP_MIC
:
6666 switch (capability
) {
6670 return (ahp
->ah_staId1Defaults
&
6671 AR_STA_ID1_CRPT_MIC_ENABLE
) ? true :
6674 case ATH9K_CAP_TKIP_SPLIT
:
6675 return (ahp
->ah_miscMode
& AR_PCU_MIC_NEW_LOC_ENA
) ?
6677 case ATH9K_CAP_WME_TKIPMIC
:
6679 case ATH9K_CAP_PHYCOUNTERS
:
6680 return ahp
->ah_hasHwPhyCounters
? 0 : -ENXIO
;
6681 case ATH9K_CAP_DIVERSITY
:
6682 return (REG_READ(ah
, AR_PHY_CCK_DETECT
) &
6683 AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV
) ?
6685 case ATH9K_CAP_PHYDIAG
:
6687 case ATH9K_CAP_MCAST_KEYSRCH
:
6688 switch (capability
) {
6692 if (REG_READ(ah
, AR_STA_ID1
) & AR_STA_ID1_ADHOC
) {
6695 return (ahp
->ah_staId1Defaults
&
6696 AR_STA_ID1_MCAST_KSRCH
) ? true :
6701 case ATH9K_CAP_TSF_ADJUST
:
6702 return (ahp
->ah_miscMode
& AR_PCU_TX_ADD_TSF
) ?
6704 case ATH9K_CAP_RFSILENT
:
6705 if (capability
== 3)
6707 case ATH9K_CAP_ANT_CFG_2GHZ
:
6708 *result
= pCap
->num_antcfg_2ghz
;
6710 case ATH9K_CAP_ANT_CFG_5GHZ
:
6711 *result
= pCap
->num_antcfg_5ghz
;
6713 case ATH9K_CAP_TXPOW
:
6714 switch (capability
) {
6718 *result
= ah
->ah_powerLimit
;
6721 *result
= ah
->ah_maxPowerLevel
;
6724 *result
= ah
->ah_tpScale
;
6734 ath9k_hw_select_antconfig(struct ath_hal
*ah
, u32 cfg
)
6736 struct ath_hal_5416
*ahp
= AH5416(ah
);
6737 struct ath9k_channel
*chan
= ah
->ah_curchan
;
6738 const struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
6740 u32 halNumAntConfig
;
6743 IS_CHAN_2GHZ(chan
) ? pCap
->num_antcfg_2ghz
: pCap
->
6746 if (cfg
< halNumAntConfig
) {
6747 if (!ath9k_hw_get_eeprom_antenna_cfg(ahp
, chan
,
6748 cfg
, &ant_config
)) {
6749 REG_WRITE(ah
, AR_PHY_SWITCH_COM
, ant_config
);
6757 bool ath9k_hw_intrpend(struct ath_hal
*ah
)
6761 if (AR_SREV_9100(ah
))
6764 host_isr
= REG_READ(ah
, AR_INTR_ASYNC_CAUSE
);
6765 if ((host_isr
& AR_INTR_MAC_IRQ
) && (host_isr
!= AR_INTR_SPURIOUS
))
6768 host_isr
= REG_READ(ah
, AR_INTR_SYNC_CAUSE
);
6769 if ((host_isr
& AR_INTR_SYNC_DEFAULT
)
6770 && (host_isr
!= AR_INTR_SPURIOUS
))
6776 bool ath9k_hw_getisr(struct ath_hal
*ah
, enum ath9k_int
*masked
)
6780 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
6782 bool fatal_int
= false;
6784 if (!AR_SREV_9100(ah
)) {
6785 if (REG_READ(ah
, AR_INTR_ASYNC_CAUSE
) & AR_INTR_MAC_IRQ
) {
6786 if ((REG_READ(ah
, AR_RTC_STATUS
) & AR_RTC_STATUS_M
)
6787 == AR_RTC_STATUS_ON
) {
6788 isr
= REG_READ(ah
, AR_ISR
);
6794 AR_INTR_SYNC_CAUSE
) & AR_INTR_SYNC_DEFAULT
;
6798 if (!isr
&& !sync_cause
)
6802 isr
= REG_READ(ah
, AR_ISR
);
6806 struct ath_hal_5416
*ahp
= AH5416(ah
);
6808 if (isr
& AR_ISR_BCNMISC
) {
6810 isr2
= REG_READ(ah
, AR_ISR_S2
);
6811 if (isr2
& AR_ISR_S2_TIM
)
6812 mask2
|= ATH9K_INT_TIM
;
6813 if (isr2
& AR_ISR_S2_DTIM
)
6814 mask2
|= ATH9K_INT_DTIM
;
6815 if (isr2
& AR_ISR_S2_DTIMSYNC
)
6816 mask2
|= ATH9K_INT_DTIMSYNC
;
6817 if (isr2
& (AR_ISR_S2_CABEND
))
6818 mask2
|= ATH9K_INT_CABEND
;
6819 if (isr2
& AR_ISR_S2_GTT
)
6820 mask2
|= ATH9K_INT_GTT
;
6821 if (isr2
& AR_ISR_S2_CST
)
6822 mask2
|= ATH9K_INT_CST
;
6825 isr
= REG_READ(ah
, AR_ISR_RAC
);
6826 if (isr
== 0xffffffff) {
6831 *masked
= isr
& ATH9K_INT_COMMON
;
6833 if (ahp
->ah_intrMitigation
) {
6835 if (isr
& (AR_ISR_RXMINTR
| AR_ISR_RXINTM
))
6836 *masked
|= ATH9K_INT_RX
;
6839 if (isr
& (AR_ISR_RXOK
| AR_ISR_RXERR
))
6840 *masked
|= ATH9K_INT_RX
;
6842 (AR_ISR_TXOK
| AR_ISR_TXDESC
| AR_ISR_TXERR
|
6846 *masked
|= ATH9K_INT_TX
;
6848 s0_s
= REG_READ(ah
, AR_ISR_S0_S
);
6849 ahp
->ah_intrTxqs
|= MS(s0_s
, AR_ISR_S0_QCU_TXOK
);
6850 ahp
->ah_intrTxqs
|= MS(s0_s
, AR_ISR_S0_QCU_TXDESC
);
6852 s1_s
= REG_READ(ah
, AR_ISR_S1_S
);
6853 ahp
->ah_intrTxqs
|= MS(s1_s
, AR_ISR_S1_QCU_TXERR
);
6854 ahp
->ah_intrTxqs
|= MS(s1_s
, AR_ISR_S1_QCU_TXEOL
);
6857 if (isr
& AR_ISR_RXORN
) {
6858 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
6859 "%s: receive FIFO overrun interrupt\n",
6863 if (!AR_SREV_9100(ah
)) {
6864 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)) {
6865 u32 isr5
= REG_READ(ah
, AR_ISR_S5_S
);
6866 if (isr5
& AR_ISR_S5_TIM_TIMER
)
6867 *masked
|= ATH9K_INT_TIM_TIMER
;
6873 if (AR_SREV_9100(ah
))
6878 (AR_INTR_SYNC_HOST1_FATAL
| AR_INTR_SYNC_HOST1_PERR
))
6882 if (sync_cause
& AR_INTR_SYNC_HOST1_FATAL
) {
6883 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
6884 "%s: received PCI FATAL interrupt\n",
6887 if (sync_cause
& AR_INTR_SYNC_HOST1_PERR
) {
6888 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
6889 "%s: received PCI PERR interrupt\n",
6893 if (sync_cause
& AR_INTR_SYNC_RADM_CPL_TIMEOUT
) {
6894 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
6895 "%s: AR_INTR_SYNC_RADM_CPL_TIMEOUT\n",
6897 REG_WRITE(ah
, AR_RC
, AR_RC_HOSTIF
);
6898 REG_WRITE(ah
, AR_RC
, 0);
6899 *masked
|= ATH9K_INT_FATAL
;
6901 if (sync_cause
& AR_INTR_SYNC_LOCAL_TIMEOUT
) {
6902 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
6903 "%s: AR_INTR_SYNC_LOCAL_TIMEOUT\n",
6907 REG_WRITE(ah
, AR_INTR_SYNC_CAUSE_CLR
, sync_cause
);
6908 (void) REG_READ(ah
, AR_INTR_SYNC_CAUSE_CLR
);
6913 enum ath9k_int
ath9k_hw_intrget(struct ath_hal
*ah
)
6915 return AH5416(ah
)->ah_maskReg
;
6918 enum ath9k_int
ath9k_hw_set_interrupts(struct ath_hal
*ah
, enum ath9k_int ints
)
6920 struct ath_hal_5416
*ahp
= AH5416(ah
);
6921 u32 omask
= ahp
->ah_maskReg
;
6923 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
6925 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "%s: 0x%x => 0x%x\n", __func__
,
6928 if (omask
& ATH9K_INT_GLOBAL
) {
6929 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "%s: disable IER\n",
6931 REG_WRITE(ah
, AR_IER
, AR_IER_DISABLE
);
6932 (void) REG_READ(ah
, AR_IER
);
6933 if (!AR_SREV_9100(ah
)) {
6934 REG_WRITE(ah
, AR_INTR_ASYNC_ENABLE
, 0);
6935 (void) REG_READ(ah
, AR_INTR_ASYNC_ENABLE
);
6937 REG_WRITE(ah
, AR_INTR_SYNC_ENABLE
, 0);
6938 (void) REG_READ(ah
, AR_INTR_SYNC_ENABLE
);
6942 mask
= ints
& ATH9K_INT_COMMON
;
6945 if (ints
& ATH9K_INT_TX
) {
6946 if (ahp
->ah_txOkInterruptMask
)
6947 mask
|= AR_IMR_TXOK
;
6948 if (ahp
->ah_txDescInterruptMask
)
6949 mask
|= AR_IMR_TXDESC
;
6950 if (ahp
->ah_txErrInterruptMask
)
6951 mask
|= AR_IMR_TXERR
;
6952 if (ahp
->ah_txEolInterruptMask
)
6953 mask
|= AR_IMR_TXEOL
;
6955 if (ints
& ATH9K_INT_RX
) {
6956 mask
|= AR_IMR_RXERR
;
6957 if (ahp
->ah_intrMitigation
)
6958 mask
|= AR_IMR_RXMINTR
| AR_IMR_RXINTM
;
6960 mask
|= AR_IMR_RXOK
| AR_IMR_RXDESC
;
6961 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
))
6962 mask
|= AR_IMR_GENTMR
;
6965 if (ints
& (ATH9K_INT_BMISC
)) {
6966 mask
|= AR_IMR_BCNMISC
;
6967 if (ints
& ATH9K_INT_TIM
)
6968 mask2
|= AR_IMR_S2_TIM
;
6969 if (ints
& ATH9K_INT_DTIM
)
6970 mask2
|= AR_IMR_S2_DTIM
;
6971 if (ints
& ATH9K_INT_DTIMSYNC
)
6972 mask2
|= AR_IMR_S2_DTIMSYNC
;
6973 if (ints
& ATH9K_INT_CABEND
)
6974 mask2
|= (AR_IMR_S2_CABEND
);
6977 if (ints
& (ATH9K_INT_GTT
| ATH9K_INT_CST
)) {
6978 mask
|= AR_IMR_BCNMISC
;
6979 if (ints
& ATH9K_INT_GTT
)
6980 mask2
|= AR_IMR_S2_GTT
;
6981 if (ints
& ATH9K_INT_CST
)
6982 mask2
|= AR_IMR_S2_CST
;
6985 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "%s: new IMR 0x%x\n", __func__
,
6987 REG_WRITE(ah
, AR_IMR
, mask
);
6988 mask
= REG_READ(ah
, AR_IMR_S2
) & ~(AR_IMR_S2_TIM
|
6990 AR_IMR_S2_DTIMSYNC
|
6994 AR_IMR_S2_GTT
| AR_IMR_S2_CST
);
6995 REG_WRITE(ah
, AR_IMR_S2
, mask
| mask2
);
6996 ahp
->ah_maskReg
= ints
;
6998 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)) {
6999 if (ints
& ATH9K_INT_TIM_TIMER
)
7000 REG_SET_BIT(ah
, AR_IMR_S5
, AR_IMR_S5_TIM_TIMER
);
7002 REG_CLR_BIT(ah
, AR_IMR_S5
, AR_IMR_S5_TIM_TIMER
);
7005 if (ints
& ATH9K_INT_GLOBAL
) {
7006 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "%s: enable IER\n",
7008 REG_WRITE(ah
, AR_IER
, AR_IER_ENABLE
);
7009 if (!AR_SREV_9100(ah
)) {
7010 REG_WRITE(ah
, AR_INTR_ASYNC_ENABLE
,
7012 REG_WRITE(ah
, AR_INTR_ASYNC_MASK
, AR_INTR_MAC_IRQ
);
7015 REG_WRITE(ah
, AR_INTR_SYNC_ENABLE
,
7016 AR_INTR_SYNC_DEFAULT
);
7017 REG_WRITE(ah
, AR_INTR_SYNC_MASK
,
7018 AR_INTR_SYNC_DEFAULT
);
7020 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "AR_IMR 0x%x IER 0x%x\n",
7021 REG_READ(ah
, AR_IMR
), REG_READ(ah
, AR_IER
));
7028 ath9k_hw_beaconinit(struct ath_hal
*ah
,
7029 u32 next_beacon
, u32 beacon_period
)
7031 struct ath_hal_5416
*ahp
= AH5416(ah
);
7034 ahp
->ah_beaconInterval
= beacon_period
;
7036 switch (ah
->ah_opmode
) {
7038 case ATH9K_M_MONITOR
:
7039 REG_WRITE(ah
, AR_NEXT_TBTT_TIMER
, TU_TO_USEC(next_beacon
));
7040 REG_WRITE(ah
, AR_NEXT_DMA_BEACON_ALERT
, 0xffff);
7041 REG_WRITE(ah
, AR_NEXT_SWBA
, 0x7ffff);
7042 flags
|= AR_TBTT_TIMER_EN
;
7045 REG_SET_BIT(ah
, AR_TXCFG
,
7046 AR_TXCFG_ADHOC_BEACON_ATIM_TX_POLICY
);
7047 REG_WRITE(ah
, AR_NEXT_NDP_TIMER
,
7048 TU_TO_USEC(next_beacon
+
7049 (ahp
->ah_atimWindow
? ahp
->
7050 ah_atimWindow
: 1)));
7051 flags
|= AR_NDP_TIMER_EN
;
7052 case ATH9K_M_HOSTAP
:
7053 REG_WRITE(ah
, AR_NEXT_TBTT_TIMER
, TU_TO_USEC(next_beacon
));
7054 REG_WRITE(ah
, AR_NEXT_DMA_BEACON_ALERT
,
7055 TU_TO_USEC(next_beacon
-
7057 dma_beacon_response_time
));
7058 REG_WRITE(ah
, AR_NEXT_SWBA
,
7059 TU_TO_USEC(next_beacon
-
7061 sw_beacon_response_time
));
7063 AR_TBTT_TIMER_EN
| AR_DBA_TIMER_EN
| AR_SWBA_TIMER_EN
;
7067 REG_WRITE(ah
, AR_BEACON_PERIOD
, TU_TO_USEC(beacon_period
));
7068 REG_WRITE(ah
, AR_DMA_BEACON_PERIOD
, TU_TO_USEC(beacon_period
));
7069 REG_WRITE(ah
, AR_SWBA_PERIOD
, TU_TO_USEC(beacon_period
));
7070 REG_WRITE(ah
, AR_NDP_PERIOD
, TU_TO_USEC(beacon_period
));
7072 beacon_period
&= ~ATH9K_BEACON_ENA
;
7073 if (beacon_period
& ATH9K_BEACON_RESET_TSF
) {
7074 beacon_period
&= ~ATH9K_BEACON_RESET_TSF
;
7075 ath9k_hw_reset_tsf(ah
);
7078 REG_SET_BIT(ah
, AR_TIMER_MODE
, flags
);
7082 ath9k_hw_set_sta_beacon_timers(struct ath_hal
*ah
,
7083 const struct ath9k_beacon_state
*bs
)
7085 u32 nextTbtt
, beaconintval
, dtimperiod
, beacontimeout
;
7086 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7088 REG_WRITE(ah
, AR_NEXT_TBTT_TIMER
, TU_TO_USEC(bs
->bs_nexttbtt
));
7090 REG_WRITE(ah
, AR_BEACON_PERIOD
,
7091 TU_TO_USEC(bs
->bs_intval
& ATH9K_BEACON_PERIOD
));
7092 REG_WRITE(ah
, AR_DMA_BEACON_PERIOD
,
7093 TU_TO_USEC(bs
->bs_intval
& ATH9K_BEACON_PERIOD
));
7095 REG_RMW_FIELD(ah
, AR_RSSI_THR
,
7096 AR_RSSI_THR_BM_THR
, bs
->bs_bmissthreshold
);
7098 beaconintval
= bs
->bs_intval
& ATH9K_BEACON_PERIOD
;
7100 if (bs
->bs_sleepduration
> beaconintval
)
7101 beaconintval
= bs
->bs_sleepduration
;
7103 dtimperiod
= bs
->bs_dtimperiod
;
7104 if (bs
->bs_sleepduration
> dtimperiod
)
7105 dtimperiod
= bs
->bs_sleepduration
;
7107 if (beaconintval
== dtimperiod
)
7108 nextTbtt
= bs
->bs_nextdtim
;
7110 nextTbtt
= bs
->bs_nexttbtt
;
7112 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "%s: next DTIM %d\n", __func__
,
7114 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "%s: next beacon %d\n", __func__
,
7116 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "%s: beacon period %d\n", __func__
,
7118 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "%s: DTIM period %d\n", __func__
,
7121 REG_WRITE(ah
, AR_NEXT_DTIM
,
7122 TU_TO_USEC(bs
->bs_nextdtim
- SLEEP_SLOP
));
7123 REG_WRITE(ah
, AR_NEXT_TIM
, TU_TO_USEC(nextTbtt
- SLEEP_SLOP
));
7125 REG_WRITE(ah
, AR_SLEEP1
,
7126 SM((CAB_TIMEOUT_VAL
<< 3), AR_SLEEP1_CAB_TIMEOUT
)
7127 | AR_SLEEP1_ASSUME_DTIM
);
7129 if (pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)
7130 beacontimeout
= (BEACON_TIMEOUT_VAL
<< 3);
7132 beacontimeout
= MIN_BEACON_TIMEOUT_VAL
;
7134 REG_WRITE(ah
, AR_SLEEP2
,
7135 SM(beacontimeout
, AR_SLEEP2_BEACON_TIMEOUT
));
7137 REG_WRITE(ah
, AR_TIM_PERIOD
, TU_TO_USEC(beaconintval
));
7138 REG_WRITE(ah
, AR_DTIM_PERIOD
, TU_TO_USEC(dtimperiod
));
7140 REG_SET_BIT(ah
, AR_TIMER_MODE
,
7141 AR_TBTT_TIMER_EN
| AR_TIM_TIMER_EN
|
7146 bool ath9k_hw_keyisvalid(struct ath_hal
*ah
, u16 entry
)
7148 if (entry
< ah
->ah_caps
.keycache_size
) {
7149 u32 val
= REG_READ(ah
, AR_KEYTABLE_MAC1(entry
));
7150 if (val
& AR_KEYTABLE_VALID
)
7156 bool ath9k_hw_keyreset(struct ath_hal
*ah
, u16 entry
)
7160 if (entry
>= ah
->ah_caps
.keycache_size
) {
7161 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7162 "%s: entry %u out of range\n", __func__
, entry
);
7165 keyType
= REG_READ(ah
, AR_KEYTABLE_TYPE(entry
));
7167 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), 0);
7168 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), 0);
7169 REG_WRITE(ah
, AR_KEYTABLE_KEY2(entry
), 0);
7170 REG_WRITE(ah
, AR_KEYTABLE_KEY3(entry
), 0);
7171 REG_WRITE(ah
, AR_KEYTABLE_KEY4(entry
), 0);
7172 REG_WRITE(ah
, AR_KEYTABLE_TYPE(entry
), AR_KEYTABLE_TYPE_CLR
);
7173 REG_WRITE(ah
, AR_KEYTABLE_MAC0(entry
), 0);
7174 REG_WRITE(ah
, AR_KEYTABLE_MAC1(entry
), 0);
7176 if (keyType
== AR_KEYTABLE_TYPE_TKIP
&& ATH9K_IS_MIC_ENABLED(ah
)) {
7177 u16 micentry
= entry
+ 64;
7179 REG_WRITE(ah
, AR_KEYTABLE_KEY0(micentry
), 0);
7180 REG_WRITE(ah
, AR_KEYTABLE_KEY1(micentry
), 0);
7181 REG_WRITE(ah
, AR_KEYTABLE_KEY2(micentry
), 0);
7182 REG_WRITE(ah
, AR_KEYTABLE_KEY3(micentry
), 0);
7186 if (ah
->ah_curchan
== NULL
)
7193 ath9k_hw_keysetmac(struct ath_hal
*ah
, u16 entry
,
7198 if (entry
>= ah
->ah_caps
.keycache_size
) {
7199 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7200 "%s: entry %u out of range\n", __func__
, entry
);
7205 macHi
= (mac
[5] << 8) | mac
[4];
7206 macLo
= (mac
[3] << 24) | (mac
[2] << 16)
7207 | (mac
[1] << 8) | mac
[0];
7209 macLo
|= (macHi
& 1) << 31;
7214 REG_WRITE(ah
, AR_KEYTABLE_MAC0(entry
), macLo
);
7215 REG_WRITE(ah
, AR_KEYTABLE_MAC1(entry
), macHi
| AR_KEYTABLE_VALID
);
7221 ath9k_hw_set_keycache_entry(struct ath_hal
*ah
, u16 entry
,
7222 const struct ath9k_keyval
*k
,
7223 const u8
*mac
, int xorKey
)
7225 const struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7226 u32 key0
, key1
, key2
, key3
, key4
;
7228 u32 xorMask
= xorKey
?
7229 (ATH9K_KEY_XOR
<< 24 | ATH9K_KEY_XOR
<< 16 | ATH9K_KEY_XOR
<< 8
7230 | ATH9K_KEY_XOR
) : 0;
7231 struct ath_hal_5416
*ahp
= AH5416(ah
);
7233 if (entry
>= pCap
->keycache_size
) {
7234 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7235 "%s: entry %u out of range\n", __func__
, entry
);
7238 switch (k
->kv_type
) {
7239 case ATH9K_CIPHER_AES_OCB
:
7240 keyType
= AR_KEYTABLE_TYPE_AES
;
7242 case ATH9K_CIPHER_AES_CCM
:
7243 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_CIPHER_AESCCM
)) {
7244 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7245 "%s: AES-CCM not supported by "
7246 "mac rev 0x%x\n", __func__
,
7250 keyType
= AR_KEYTABLE_TYPE_CCM
;
7252 case ATH9K_CIPHER_TKIP
:
7253 keyType
= AR_KEYTABLE_TYPE_TKIP
;
7254 if (ATH9K_IS_MIC_ENABLED(ah
)
7255 && entry
+ 64 >= pCap
->keycache_size
) {
7256 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7257 "%s: entry %u inappropriate for TKIP\n",
7262 case ATH9K_CIPHER_WEP
:
7263 if (k
->kv_len
< LEN_WEP40
) {
7264 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7265 "%s: WEP key length %u too small\n",
7266 __func__
, k
->kv_len
);
7269 if (k
->kv_len
<= LEN_WEP40
)
7270 keyType
= AR_KEYTABLE_TYPE_40
;
7271 else if (k
->kv_len
<= LEN_WEP104
)
7272 keyType
= AR_KEYTABLE_TYPE_104
;
7274 keyType
= AR_KEYTABLE_TYPE_128
;
7276 case ATH9K_CIPHER_CLR
:
7277 keyType
= AR_KEYTABLE_TYPE_CLR
;
7280 DPRINTF(ah
->ah_sc
, ATH_DBG_KEYCACHE
,
7281 "%s: cipher %u not supported\n", __func__
,
7286 key0
= get_unaligned_le32(k
->kv_val
+ 0) ^ xorMask
;
7287 key1
= (get_unaligned_le16(k
->kv_val
+ 4) ^ xorMask
) & 0xffff;
7288 key2
= get_unaligned_le32(k
->kv_val
+ 6) ^ xorMask
;
7289 key3
= (get_unaligned_le16(k
->kv_val
+ 10) ^ xorMask
) & 0xffff;
7290 key4
= get_unaligned_le32(k
->kv_val
+ 12) ^ xorMask
;
7291 if (k
->kv_len
<= LEN_WEP104
)
7294 if (keyType
== AR_KEYTABLE_TYPE_TKIP
&& ATH9K_IS_MIC_ENABLED(ah
)) {
7295 u16 micentry
= entry
+ 64;
7297 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), ~key0
);
7298 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), ~key1
);
7299 REG_WRITE(ah
, AR_KEYTABLE_KEY2(entry
), key2
);
7300 REG_WRITE(ah
, AR_KEYTABLE_KEY3(entry
), key3
);
7301 REG_WRITE(ah
, AR_KEYTABLE_KEY4(entry
), key4
);
7302 REG_WRITE(ah
, AR_KEYTABLE_TYPE(entry
), keyType
);
7303 (void) ath9k_hw_keysetmac(ah
, entry
, mac
);
7305 if (ahp
->ah_miscMode
& AR_PCU_MIC_NEW_LOC_ENA
) {
7306 u32 mic0
, mic1
, mic2
, mic3
, mic4
;
7308 mic0
= get_unaligned_le32(k
->kv_mic
+ 0);
7309 mic2
= get_unaligned_le32(k
->kv_mic
+ 4);
7310 mic1
= get_unaligned_le16(k
->kv_txmic
+ 2) & 0xffff;
7311 mic3
= get_unaligned_le16(k
->kv_txmic
+ 0) & 0xffff;
7312 mic4
= get_unaligned_le32(k
->kv_txmic
+ 4);
7313 REG_WRITE(ah
, AR_KEYTABLE_KEY0(micentry
), mic0
);
7314 REG_WRITE(ah
, AR_KEYTABLE_KEY1(micentry
), mic1
);
7315 REG_WRITE(ah
, AR_KEYTABLE_KEY2(micentry
), mic2
);
7316 REG_WRITE(ah
, AR_KEYTABLE_KEY3(micentry
), mic3
);
7317 REG_WRITE(ah
, AR_KEYTABLE_KEY4(micentry
), mic4
);
7318 REG_WRITE(ah
, AR_KEYTABLE_TYPE(micentry
),
7319 AR_KEYTABLE_TYPE_CLR
);
7324 mic0
= get_unaligned_le32(k
->kv_mic
+ 0);
7325 mic2
= get_unaligned_le32(k
->kv_mic
+ 4);
7326 REG_WRITE(ah
, AR_KEYTABLE_KEY0(micentry
), mic0
);
7327 REG_WRITE(ah
, AR_KEYTABLE_KEY1(micentry
), 0);
7328 REG_WRITE(ah
, AR_KEYTABLE_KEY2(micentry
), mic2
);
7329 REG_WRITE(ah
, AR_KEYTABLE_KEY3(micentry
), 0);
7330 REG_WRITE(ah
, AR_KEYTABLE_KEY4(micentry
), 0);
7331 REG_WRITE(ah
, AR_KEYTABLE_TYPE(micentry
),
7332 AR_KEYTABLE_TYPE_CLR
);
7334 REG_WRITE(ah
, AR_KEYTABLE_MAC0(micentry
), 0);
7335 REG_WRITE(ah
, AR_KEYTABLE_MAC1(micentry
), 0);
7336 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), key0
);
7337 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), key1
);
7339 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), key0
);
7340 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), key1
);
7341 REG_WRITE(ah
, AR_KEYTABLE_KEY2(entry
), key2
);
7342 REG_WRITE(ah
, AR_KEYTABLE_KEY3(entry
), key3
);
7343 REG_WRITE(ah
, AR_KEYTABLE_KEY4(entry
), key4
);
7344 REG_WRITE(ah
, AR_KEYTABLE_TYPE(entry
), keyType
);
7346 (void) ath9k_hw_keysetmac(ah
, entry
, mac
);
7349 if (ah
->ah_curchan
== NULL
)
7356 ath9k_hw_updatetxtriglevel(struct ath_hal
*ah
, bool bIncTrigLevel
)
7358 struct ath_hal_5416
*ahp
= AH5416(ah
);
7359 u32 txcfg
, curLevel
, newLevel
;
7360 enum ath9k_int omask
;
7362 if (ah
->ah_txTrigLevel
>= MAX_TX_FIFO_THRESHOLD
)
7365 omask
= ath9k_hw_set_interrupts(ah
,
7366 ahp
->ah_maskReg
& ~ATH9K_INT_GLOBAL
);
7368 txcfg
= REG_READ(ah
, AR_TXCFG
);
7369 curLevel
= MS(txcfg
, AR_FTRIG
);
7370 newLevel
= curLevel
;
7371 if (bIncTrigLevel
) {
7372 if (curLevel
< MAX_TX_FIFO_THRESHOLD
)
7374 } else if (curLevel
> MIN_TX_FIFO_THRESHOLD
)
7376 if (newLevel
!= curLevel
)
7377 REG_WRITE(ah
, AR_TXCFG
,
7378 (txcfg
& ~AR_FTRIG
) | SM(newLevel
, AR_FTRIG
));
7380 ath9k_hw_set_interrupts(ah
, omask
);
7382 ah
->ah_txTrigLevel
= newLevel
;
7384 return newLevel
!= curLevel
;
7387 bool ath9k_hw_set_txq_props(struct ath_hal
*ah
, int q
,
7388 const struct ath9k_tx_queue_info
*qinfo
)
7391 struct ath_hal_5416
*ahp
= AH5416(ah
);
7392 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7393 struct ath9k_tx_queue_info
*qi
;
7395 if (q
>= pCap
->total_queues
) {
7396 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: invalid queue num %u\n",
7401 qi
= &ahp
->ah_txq
[q
];
7402 if (qi
->tqi_type
== ATH9K_TX_QUEUE_INACTIVE
) {
7403 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: inactive queue\n",
7408 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: queue %p\n", __func__
, qi
);
7410 qi
->tqi_ver
= qinfo
->tqi_ver
;
7411 qi
->tqi_subtype
= qinfo
->tqi_subtype
;
7412 qi
->tqi_qflags
= qinfo
->tqi_qflags
;
7413 qi
->tqi_priority
= qinfo
->tqi_priority
;
7414 if (qinfo
->tqi_aifs
!= ATH9K_TXQ_USEDEFAULT
)
7415 qi
->tqi_aifs
= min(qinfo
->tqi_aifs
, 255U);
7417 qi
->tqi_aifs
= INIT_AIFS
;
7418 if (qinfo
->tqi_cwmin
!= ATH9K_TXQ_USEDEFAULT
) {
7419 cw
= min(qinfo
->tqi_cwmin
, 1024U);
7421 while (qi
->tqi_cwmin
< cw
)
7422 qi
->tqi_cwmin
= (qi
->tqi_cwmin
<< 1) | 1;
7424 qi
->tqi_cwmin
= qinfo
->tqi_cwmin
;
7425 if (qinfo
->tqi_cwmax
!= ATH9K_TXQ_USEDEFAULT
) {
7426 cw
= min(qinfo
->tqi_cwmax
, 1024U);
7428 while (qi
->tqi_cwmax
< cw
)
7429 qi
->tqi_cwmax
= (qi
->tqi_cwmax
<< 1) | 1;
7431 qi
->tqi_cwmax
= INIT_CWMAX
;
7433 if (qinfo
->tqi_shretry
!= 0)
7434 qi
->tqi_shretry
= min((u32
) qinfo
->tqi_shretry
, 15U);
7436 qi
->tqi_shretry
= INIT_SH_RETRY
;
7437 if (qinfo
->tqi_lgretry
!= 0)
7438 qi
->tqi_lgretry
= min((u32
) qinfo
->tqi_lgretry
, 15U);
7440 qi
->tqi_lgretry
= INIT_LG_RETRY
;
7441 qi
->tqi_cbrPeriod
= qinfo
->tqi_cbrPeriod
;
7442 qi
->tqi_cbrOverflowLimit
= qinfo
->tqi_cbrOverflowLimit
;
7443 qi
->tqi_burstTime
= qinfo
->tqi_burstTime
;
7444 qi
->tqi_readyTime
= qinfo
->tqi_readyTime
;
7446 switch (qinfo
->tqi_subtype
) {
7447 case ATH9K_WME_UPSD
:
7448 if (qi
->tqi_type
== ATH9K_TX_QUEUE_DATA
)
7449 qi
->tqi_intFlags
= ATH9K_TXQ_USE_LOCKOUT_BKOFF_DIS
;
7457 bool ath9k_hw_get_txq_props(struct ath_hal
*ah
, int q
,
7458 struct ath9k_tx_queue_info
*qinfo
)
7460 struct ath_hal_5416
*ahp
= AH5416(ah
);
7461 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7462 struct ath9k_tx_queue_info
*qi
;
7464 if (q
>= pCap
->total_queues
) {
7465 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: invalid queue num %u\n",
7470 qi
= &ahp
->ah_txq
[q
];
7471 if (qi
->tqi_type
== ATH9K_TX_QUEUE_INACTIVE
) {
7472 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: inactive queue\n",
7477 qinfo
->tqi_qflags
= qi
->tqi_qflags
;
7478 qinfo
->tqi_ver
= qi
->tqi_ver
;
7479 qinfo
->tqi_subtype
= qi
->tqi_subtype
;
7480 qinfo
->tqi_qflags
= qi
->tqi_qflags
;
7481 qinfo
->tqi_priority
= qi
->tqi_priority
;
7482 qinfo
->tqi_aifs
= qi
->tqi_aifs
;
7483 qinfo
->tqi_cwmin
= qi
->tqi_cwmin
;
7484 qinfo
->tqi_cwmax
= qi
->tqi_cwmax
;
7485 qinfo
->tqi_shretry
= qi
->tqi_shretry
;
7486 qinfo
->tqi_lgretry
= qi
->tqi_lgretry
;
7487 qinfo
->tqi_cbrPeriod
= qi
->tqi_cbrPeriod
;
7488 qinfo
->tqi_cbrOverflowLimit
= qi
->tqi_cbrOverflowLimit
;
7489 qinfo
->tqi_burstTime
= qi
->tqi_burstTime
;
7490 qinfo
->tqi_readyTime
= qi
->tqi_readyTime
;
7496 ath9k_hw_setuptxqueue(struct ath_hal
*ah
, enum ath9k_tx_queue type
,
7497 const struct ath9k_tx_queue_info
*qinfo
)
7499 struct ath_hal_5416
*ahp
= AH5416(ah
);
7500 struct ath9k_tx_queue_info
*qi
;
7501 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7505 case ATH9K_TX_QUEUE_BEACON
:
7506 q
= pCap
->total_queues
- 1;
7508 case ATH9K_TX_QUEUE_CAB
:
7509 q
= pCap
->total_queues
- 2;
7511 case ATH9K_TX_QUEUE_PSPOLL
:
7514 case ATH9K_TX_QUEUE_UAPSD
:
7515 q
= pCap
->total_queues
- 3;
7517 case ATH9K_TX_QUEUE_DATA
:
7518 for (q
= 0; q
< pCap
->total_queues
; q
++)
7519 if (ahp
->ah_txq
[q
].tqi_type
==
7520 ATH9K_TX_QUEUE_INACTIVE
)
7522 if (q
== pCap
->total_queues
) {
7523 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
7524 "%s: no available tx queue\n", __func__
);
7529 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: bad tx queue type %u\n",
7534 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: queue %u\n", __func__
, q
);
7536 qi
= &ahp
->ah_txq
[q
];
7537 if (qi
->tqi_type
!= ATH9K_TX_QUEUE_INACTIVE
) {
7538 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
7539 "%s: tx queue %u already active\n", __func__
, q
);
7542 memset(qi
, 0, sizeof(struct ath9k_tx_queue_info
));
7543 qi
->tqi_type
= type
;
7544 if (qinfo
== NULL
) {
7546 TXQ_FLAG_TXOKINT_ENABLE
7547 | TXQ_FLAG_TXERRINT_ENABLE
7548 | TXQ_FLAG_TXDESCINT_ENABLE
| TXQ_FLAG_TXURNINT_ENABLE
;
7549 qi
->tqi_aifs
= INIT_AIFS
;
7550 qi
->tqi_cwmin
= ATH9K_TXQ_USEDEFAULT
;
7551 qi
->tqi_cwmax
= INIT_CWMAX
;
7552 qi
->tqi_shretry
= INIT_SH_RETRY
;
7553 qi
->tqi_lgretry
= INIT_LG_RETRY
;
7554 qi
->tqi_physCompBuf
= 0;
7556 qi
->tqi_physCompBuf
= qinfo
->tqi_physCompBuf
;
7557 (void) ath9k_hw_set_txq_props(ah
, q
, qinfo
);
7564 ath9k_hw_set_txq_interrupts(struct ath_hal
*ah
,
7565 struct ath9k_tx_queue_info
*qi
)
7567 struct ath_hal_5416
*ahp
= AH5416(ah
);
7569 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
7570 "%s: tx ok 0x%x err 0x%x desc 0x%x eol 0x%x urn 0x%x\n",
7571 __func__
, ahp
->ah_txOkInterruptMask
,
7572 ahp
->ah_txErrInterruptMask
, ahp
->ah_txDescInterruptMask
,
7573 ahp
->ah_txEolInterruptMask
, ahp
->ah_txUrnInterruptMask
);
7575 REG_WRITE(ah
, AR_IMR_S0
,
7576 SM(ahp
->ah_txOkInterruptMask
, AR_IMR_S0_QCU_TXOK
)
7577 | SM(ahp
->ah_txDescInterruptMask
, AR_IMR_S0_QCU_TXDESC
));
7578 REG_WRITE(ah
, AR_IMR_S1
,
7579 SM(ahp
->ah_txErrInterruptMask
, AR_IMR_S1_QCU_TXERR
)
7580 | SM(ahp
->ah_txEolInterruptMask
, AR_IMR_S1_QCU_TXEOL
));
7581 REG_RMW_FIELD(ah
, AR_IMR_S2
,
7582 AR_IMR_S2_QCU_TXURN
, ahp
->ah_txUrnInterruptMask
);
7585 bool ath9k_hw_releasetxqueue(struct ath_hal
*ah
, u32 q
)
7587 struct ath_hal_5416
*ahp
= AH5416(ah
);
7588 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7589 struct ath9k_tx_queue_info
*qi
;
7591 if (q
>= pCap
->total_queues
) {
7592 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: invalid queue num %u\n",
7596 qi
= &ahp
->ah_txq
[q
];
7597 if (qi
->tqi_type
== ATH9K_TX_QUEUE_INACTIVE
) {
7598 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: inactive queue %u\n",
7603 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: release queue %u\n",
7606 qi
->tqi_type
= ATH9K_TX_QUEUE_INACTIVE
;
7607 ahp
->ah_txOkInterruptMask
&= ~(1 << q
);
7608 ahp
->ah_txErrInterruptMask
&= ~(1 << q
);
7609 ahp
->ah_txDescInterruptMask
&= ~(1 << q
);
7610 ahp
->ah_txEolInterruptMask
&= ~(1 << q
);
7611 ahp
->ah_txUrnInterruptMask
&= ~(1 << q
);
7612 ath9k_hw_set_txq_interrupts(ah
, qi
);
7617 bool ath9k_hw_resettxqueue(struct ath_hal
*ah
, u32 q
)
7619 struct ath_hal_5416
*ahp
= AH5416(ah
);
7620 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
7621 struct ath9k_channel
*chan
= ah
->ah_curchan
;
7622 struct ath9k_tx_queue_info
*qi
;
7623 u32 cwMin
, chanCwMin
, value
;
7625 if (q
>= pCap
->total_queues
) {
7626 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: invalid queue num %u\n",
7630 qi
= &ahp
->ah_txq
[q
];
7631 if (qi
->tqi_type
== ATH9K_TX_QUEUE_INACTIVE
) {
7632 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: inactive queue %u\n",
7637 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: reset queue %u\n", __func__
, q
);
7639 if (qi
->tqi_cwmin
== ATH9K_TXQ_USEDEFAULT
) {
7640 if (chan
&& IS_CHAN_B(chan
))
7641 chanCwMin
= INIT_CWMIN_11B
;
7643 chanCwMin
= INIT_CWMIN
;
7645 for (cwMin
= 1; cwMin
< chanCwMin
; cwMin
= (cwMin
<< 1) | 1);
7647 cwMin
= qi
->tqi_cwmin
;
7649 REG_WRITE(ah
, AR_DLCL_IFS(q
), SM(cwMin
, AR_D_LCL_IFS_CWMIN
)
7650 | SM(qi
->tqi_cwmax
, AR_D_LCL_IFS_CWMAX
)
7651 | SM(qi
->tqi_aifs
, AR_D_LCL_IFS_AIFS
));
7653 REG_WRITE(ah
, AR_DRETRY_LIMIT(q
),
7654 SM(INIT_SSH_RETRY
, AR_D_RETRY_LIMIT_STA_SH
)
7655 | SM(INIT_SLG_RETRY
, AR_D_RETRY_LIMIT_STA_LG
)
7656 | SM(qi
->tqi_shretry
, AR_D_RETRY_LIMIT_FR_SH
));
7658 REG_WRITE(ah
, AR_QMISC(q
), AR_Q_MISC_DCU_EARLY_TERM_REQ
);
7659 REG_WRITE(ah
, AR_DMISC(q
),
7660 AR_D_MISC_CW_BKOFF_EN
| AR_D_MISC_FRAG_WAIT_EN
| 0x2);
7662 if (qi
->tqi_cbrPeriod
) {
7663 REG_WRITE(ah
, AR_QCBRCFG(q
),
7664 SM(qi
->tqi_cbrPeriod
, AR_Q_CBRCFG_INTERVAL
)
7665 | SM(qi
->tqi_cbrOverflowLimit
,
7666 AR_Q_CBRCFG_OVF_THRESH
));
7667 REG_WRITE(ah
, AR_QMISC(q
),
7669 AR_QMISC(q
)) | AR_Q_MISC_FSP_CBR
| (qi
->
7670 tqi_cbrOverflowLimit
7672 AR_Q_MISC_CBR_EXP_CNTR_LIMIT_EN
7676 if (qi
->tqi_readyTime
&& (qi
->tqi_type
!= ATH9K_TX_QUEUE_CAB
)) {
7677 REG_WRITE(ah
, AR_QRDYTIMECFG(q
),
7678 SM(qi
->tqi_readyTime
, AR_Q_RDYTIMECFG_DURATION
) |
7679 AR_Q_RDYTIMECFG_EN
);
7682 REG_WRITE(ah
, AR_DCHNTIME(q
),
7683 SM(qi
->tqi_burstTime
, AR_D_CHNTIME_DUR
) |
7684 (qi
->tqi_burstTime
? AR_D_CHNTIME_EN
: 0));
7686 if (qi
->tqi_burstTime
7687 && (qi
->tqi_qflags
& TXQ_FLAG_RDYTIME_EXP_POLICY_ENABLE
)) {
7688 REG_WRITE(ah
, AR_QMISC(q
),
7691 AR_Q_MISC_RDYTIME_EXP_POLICY
);
7695 if (qi
->tqi_qflags
& TXQ_FLAG_BACKOFF_DISABLE
) {
7696 REG_WRITE(ah
, AR_DMISC(q
),
7697 REG_READ(ah
, AR_DMISC(q
)) |
7698 AR_D_MISC_POST_FR_BKOFF_DIS
);
7700 if (qi
->tqi_qflags
& TXQ_FLAG_FRAG_BURST_BACKOFF_ENABLE
) {
7701 REG_WRITE(ah
, AR_DMISC(q
),
7702 REG_READ(ah
, AR_DMISC(q
)) |
7703 AR_D_MISC_FRAG_BKOFF_EN
);
7705 switch (qi
->tqi_type
) {
7706 case ATH9K_TX_QUEUE_BEACON
:
7707 REG_WRITE(ah
, AR_QMISC(q
), REG_READ(ah
, AR_QMISC(q
))
7708 | AR_Q_MISC_FSP_DBA_GATED
7709 | AR_Q_MISC_BEACON_USE
7710 | AR_Q_MISC_CBR_INCR_DIS1
);
7712 REG_WRITE(ah
, AR_DMISC(q
), REG_READ(ah
, AR_DMISC(q
))
7713 | (AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL
<<
7714 AR_D_MISC_ARB_LOCKOUT_CNTRL_S
)
7715 | AR_D_MISC_BEACON_USE
7716 | AR_D_MISC_POST_FR_BKOFF_DIS
);
7718 case ATH9K_TX_QUEUE_CAB
:
7719 REG_WRITE(ah
, AR_QMISC(q
), REG_READ(ah
, AR_QMISC(q
))
7720 | AR_Q_MISC_FSP_DBA_GATED
7721 | AR_Q_MISC_CBR_INCR_DIS1
7722 | AR_Q_MISC_CBR_INCR_DIS0
);
7723 value
= (qi
->tqi_readyTime
7724 - (ah
->ah_config
.sw_beacon_response_time
-
7725 ah
->ah_config
.dma_beacon_response_time
)
7727 ah
->ah_config
.additional_swba_backoff
) *
7729 REG_WRITE(ah
, AR_QRDYTIMECFG(q
),
7730 value
| AR_Q_RDYTIMECFG_EN
);
7731 REG_WRITE(ah
, AR_DMISC(q
), REG_READ(ah
, AR_DMISC(q
))
7732 | (AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL
<<
7733 AR_D_MISC_ARB_LOCKOUT_CNTRL_S
));
7735 case ATH9K_TX_QUEUE_PSPOLL
:
7736 REG_WRITE(ah
, AR_QMISC(q
),
7738 AR_QMISC(q
)) | AR_Q_MISC_CBR_INCR_DIS1
);
7740 case ATH9K_TX_QUEUE_UAPSD
:
7741 REG_WRITE(ah
, AR_DMISC(q
), REG_READ(ah
, AR_DMISC(q
))
7742 | AR_D_MISC_POST_FR_BKOFF_DIS
);
7748 if (qi
->tqi_intFlags
& ATH9K_TXQ_USE_LOCKOUT_BKOFF_DIS
) {
7749 REG_WRITE(ah
, AR_DMISC(q
),
7750 REG_READ(ah
, AR_DMISC(q
)) |
7751 SM(AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL
,
7752 AR_D_MISC_ARB_LOCKOUT_CNTRL
) |
7753 AR_D_MISC_POST_FR_BKOFF_DIS
);
7756 if (qi
->tqi_qflags
& TXQ_FLAG_TXOKINT_ENABLE
)
7757 ahp
->ah_txOkInterruptMask
|= 1 << q
;
7759 ahp
->ah_txOkInterruptMask
&= ~(1 << q
);
7760 if (qi
->tqi_qflags
& TXQ_FLAG_TXERRINT_ENABLE
)
7761 ahp
->ah_txErrInterruptMask
|= 1 << q
;
7763 ahp
->ah_txErrInterruptMask
&= ~(1 << q
);
7764 if (qi
->tqi_qflags
& TXQ_FLAG_TXDESCINT_ENABLE
)
7765 ahp
->ah_txDescInterruptMask
|= 1 << q
;
7767 ahp
->ah_txDescInterruptMask
&= ~(1 << q
);
7768 if (qi
->tqi_qflags
& TXQ_FLAG_TXEOLINT_ENABLE
)
7769 ahp
->ah_txEolInterruptMask
|= 1 << q
;
7771 ahp
->ah_txEolInterruptMask
&= ~(1 << q
);
7772 if (qi
->tqi_qflags
& TXQ_FLAG_TXURNINT_ENABLE
)
7773 ahp
->ah_txUrnInterruptMask
|= 1 << q
;
7775 ahp
->ah_txUrnInterruptMask
&= ~(1 << q
);
7776 ath9k_hw_set_txq_interrupts(ah
, qi
);
7781 void ath9k_hw_gettxintrtxqs(struct ath_hal
*ah
, u32
*txqs
)
7783 struct ath_hal_5416
*ahp
= AH5416(ah
);
7784 *txqs
&= ahp
->ah_intrTxqs
;
7785 ahp
->ah_intrTxqs
&= ~(*txqs
);
7789 ath9k_hw_filltxdesc(struct ath_hal
*ah
, struct ath_desc
*ds
,
7790 u32 segLen
, bool firstSeg
,
7791 bool lastSeg
, const struct ath_desc
*ds0
)
7793 struct ar5416_desc
*ads
= AR5416DESC(ds
);
7796 ads
->ds_ctl1
|= segLen
| (lastSeg
? 0 : AR_TxMore
);
7797 } else if (lastSeg
) {
7799 ads
->ds_ctl1
= segLen
;
7800 ads
->ds_ctl2
= AR5416DESC_CONST(ds0
)->ds_ctl2
;
7801 ads
->ds_ctl3
= AR5416DESC_CONST(ds0
)->ds_ctl3
;
7804 ads
->ds_ctl1
= segLen
| AR_TxMore
;
7808 ads
->ds_txstatus0
= ads
->ds_txstatus1
= 0;
7809 ads
->ds_txstatus2
= ads
->ds_txstatus3
= 0;
7810 ads
->ds_txstatus4
= ads
->ds_txstatus5
= 0;
7811 ads
->ds_txstatus6
= ads
->ds_txstatus7
= 0;
7812 ads
->ds_txstatus8
= ads
->ds_txstatus9
= 0;
7816 void ath9k_hw_cleartxdesc(struct ath_hal
*ah
, struct ath_desc
*ds
)
7818 struct ar5416_desc
*ads
= AR5416DESC(ds
);
7820 ads
->ds_txstatus0
= ads
->ds_txstatus1
= 0;
7821 ads
->ds_txstatus2
= ads
->ds_txstatus3
= 0;
7822 ads
->ds_txstatus4
= ads
->ds_txstatus5
= 0;
7823 ads
->ds_txstatus6
= ads
->ds_txstatus7
= 0;
7824 ads
->ds_txstatus8
= ads
->ds_txstatus9
= 0;
7828 ath9k_hw_txprocdesc(struct ath_hal
*ah
, struct ath_desc
*ds
)
7830 struct ar5416_desc
*ads
= AR5416DESC(ds
);
7832 if ((ads
->ds_txstatus9
& AR_TxDone
) == 0)
7833 return -EINPROGRESS
;
7835 ds
->ds_txstat
.ts_seqnum
= MS(ads
->ds_txstatus9
, AR_SeqNum
);
7836 ds
->ds_txstat
.ts_tstamp
= ads
->AR_SendTimestamp
;
7837 ds
->ds_txstat
.ts_status
= 0;
7838 ds
->ds_txstat
.ts_flags
= 0;
7840 if (ads
->ds_txstatus1
& AR_ExcessiveRetries
)
7841 ds
->ds_txstat
.ts_status
|= ATH9K_TXERR_XRETRY
;
7842 if (ads
->ds_txstatus1
& AR_Filtered
)
7843 ds
->ds_txstat
.ts_status
|= ATH9K_TXERR_FILT
;
7844 if (ads
->ds_txstatus1
& AR_FIFOUnderrun
)
7845 ds
->ds_txstat
.ts_status
|= ATH9K_TXERR_FIFO
;
7846 if (ads
->ds_txstatus9
& AR_TxOpExceeded
)
7847 ds
->ds_txstat
.ts_status
|= ATH9K_TXERR_XTXOP
;
7848 if (ads
->ds_txstatus1
& AR_TxTimerExpired
)
7849 ds
->ds_txstat
.ts_status
|= ATH9K_TXERR_TIMER_EXPIRED
;
7851 if (ads
->ds_txstatus1
& AR_DescCfgErr
)
7852 ds
->ds_txstat
.ts_flags
|= ATH9K_TX_DESC_CFG_ERR
;
7853 if (ads
->ds_txstatus1
& AR_TxDataUnderrun
) {
7854 ds
->ds_txstat
.ts_flags
|= ATH9K_TX_DATA_UNDERRUN
;
7855 ath9k_hw_updatetxtriglevel(ah
, true);
7857 if (ads
->ds_txstatus1
& AR_TxDelimUnderrun
) {
7858 ds
->ds_txstat
.ts_flags
|= ATH9K_TX_DELIM_UNDERRUN
;
7859 ath9k_hw_updatetxtriglevel(ah
, true);
7861 if (ads
->ds_txstatus0
& AR_TxBaStatus
) {
7862 ds
->ds_txstat
.ts_flags
|= ATH9K_TX_BA
;
7863 ds
->ds_txstat
.ba_low
= ads
->AR_BaBitmapLow
;
7864 ds
->ds_txstat
.ba_high
= ads
->AR_BaBitmapHigh
;
7867 ds
->ds_txstat
.ts_rateindex
= MS(ads
->ds_txstatus9
, AR_FinalTxIdx
);
7868 switch (ds
->ds_txstat
.ts_rateindex
) {
7870 ds
->ds_txstat
.ts_ratecode
= MS(ads
->ds_ctl3
, AR_XmitRate0
);
7873 ds
->ds_txstat
.ts_ratecode
= MS(ads
->ds_ctl3
, AR_XmitRate1
);
7876 ds
->ds_txstat
.ts_ratecode
= MS(ads
->ds_ctl3
, AR_XmitRate2
);
7879 ds
->ds_txstat
.ts_ratecode
= MS(ads
->ds_ctl3
, AR_XmitRate3
);
7883 ds
->ds_txstat
.ts_rssi
= MS(ads
->ds_txstatus5
, AR_TxRSSICombined
);
7884 ds
->ds_txstat
.ts_rssi_ctl0
= MS(ads
->ds_txstatus0
, AR_TxRSSIAnt00
);
7885 ds
->ds_txstat
.ts_rssi_ctl1
= MS(ads
->ds_txstatus0
, AR_TxRSSIAnt01
);
7886 ds
->ds_txstat
.ts_rssi_ctl2
= MS(ads
->ds_txstatus0
, AR_TxRSSIAnt02
);
7887 ds
->ds_txstat
.ts_rssi_ext0
= MS(ads
->ds_txstatus5
, AR_TxRSSIAnt10
);
7888 ds
->ds_txstat
.ts_rssi_ext1
= MS(ads
->ds_txstatus5
, AR_TxRSSIAnt11
);
7889 ds
->ds_txstat
.ts_rssi_ext2
= MS(ads
->ds_txstatus5
, AR_TxRSSIAnt12
);
7890 ds
->ds_txstat
.evm0
= ads
->AR_TxEVM0
;
7891 ds
->ds_txstat
.evm1
= ads
->AR_TxEVM1
;
7892 ds
->ds_txstat
.evm2
= ads
->AR_TxEVM2
;
7893 ds
->ds_txstat
.ts_shortretry
= MS(ads
->ds_txstatus1
, AR_RTSFailCnt
);
7894 ds
->ds_txstat
.ts_longretry
= MS(ads
->ds_txstatus1
, AR_DataFailCnt
);
7895 ds
->ds_txstat
.ts_virtcol
= MS(ads
->ds_txstatus1
, AR_VirtRetryCnt
);
7896 ds
->ds_txstat
.ts_antenna
= 1;
7902 ath9k_hw_set11n_txdesc(struct ath_hal
*ah
, struct ath_desc
*ds
,
7903 u32 pktLen
, enum ath9k_pkt_type type
, u32 txPower
,
7904 u32 keyIx
, enum ath9k_key_type keyType
, u32 flags
)
7906 struct ar5416_desc
*ads
= AR5416DESC(ds
);
7907 struct ath_hal_5416
*ahp
= AH5416(ah
);
7909 txPower
+= ahp
->ah_txPowerIndexOffset
;
7913 ads
->ds_ctl0
= (pktLen
& AR_FrameLen
)
7914 | (flags
& ATH9K_TXDESC_VMF
? AR_VirtMoreFrag
: 0)
7915 | SM(txPower
, AR_XmitPower
)
7916 | (flags
& ATH9K_TXDESC_VEOL
? AR_VEOL
: 0)
7917 | (flags
& ATH9K_TXDESC_CLRDMASK
? AR_ClrDestMask
: 0)
7918 | (flags
& ATH9K_TXDESC_INTREQ
? AR_TxIntrReq
: 0)
7919 | (keyIx
!= ATH9K_TXKEYIX_INVALID
? AR_DestIdxValid
: 0);
7922 (keyIx
!= ATH9K_TXKEYIX_INVALID
? SM(keyIx
, AR_DestIdx
) : 0)
7923 | SM(type
, AR_FrameType
)
7924 | (flags
& ATH9K_TXDESC_NOACK
? AR_NoAck
: 0)
7925 | (flags
& ATH9K_TXDESC_EXT_ONLY
? AR_ExtOnly
: 0)
7926 | (flags
& ATH9K_TXDESC_EXT_AND_CTL
? AR_ExtAndCtl
: 0);
7928 ads
->ds_ctl6
= SM(keyType
, AR_EncrType
);
7930 if (AR_SREV_9285(ah
)) {
7940 ath9k_hw_set11n_ratescenario(struct ath_hal
*ah
, struct ath_desc
*ds
,
7941 struct ath_desc
*lastds
,
7942 u32 durUpdateEn
, u32 rtsctsRate
,
7944 struct ath9k_11n_rate_series series
[],
7945 u32 nseries
, u32 flags
)
7947 struct ar5416_desc
*ads
= AR5416DESC(ds
);
7948 struct ar5416_desc
*last_ads
= AR5416DESC(lastds
);
7952 (void) rtsctsDuration
;
7954 if (flags
& (ATH9K_TXDESC_RTSENA
| ATH9K_TXDESC_CTSENA
)) {
7955 ds_ctl0
= ads
->ds_ctl0
;
7957 if (flags
& ATH9K_TXDESC_RTSENA
) {
7958 ds_ctl0
&= ~AR_CTSEnable
;
7959 ds_ctl0
|= AR_RTSEnable
;
7961 ds_ctl0
&= ~AR_RTSEnable
;
7962 ds_ctl0
|= AR_CTSEnable
;
7965 ads
->ds_ctl0
= ds_ctl0
;
7968 (ads
->ds_ctl0
& ~(AR_RTSEnable
| AR_CTSEnable
));
7971 ads
->ds_ctl2
= set11nTries(series
, 0)
7972 | set11nTries(series
, 1)
7973 | set11nTries(series
, 2)
7974 | set11nTries(series
, 3)
7975 | (durUpdateEn
? AR_DurUpdateEna
: 0)
7976 | SM(0, AR_BurstDur
);
7978 ads
->ds_ctl3
= set11nRate(series
, 0)
7979 | set11nRate(series
, 1)
7980 | set11nRate(series
, 2)
7981 | set11nRate(series
, 3);
7983 ads
->ds_ctl4
= set11nPktDurRTSCTS(series
, 0)
7984 | set11nPktDurRTSCTS(series
, 1);
7986 ads
->ds_ctl5
= set11nPktDurRTSCTS(series
, 2)
7987 | set11nPktDurRTSCTS(series
, 3);
7989 ads
->ds_ctl7
= set11nRateFlags(series
, 0)
7990 | set11nRateFlags(series
, 1)
7991 | set11nRateFlags(series
, 2)
7992 | set11nRateFlags(series
, 3)
7993 | SM(rtsctsRate
, AR_RTSCTSRate
);
7994 last_ads
->ds_ctl2
= ads
->ds_ctl2
;
7995 last_ads
->ds_ctl3
= ads
->ds_ctl3
;
7999 ath9k_hw_set11n_aggr_first(struct ath_hal
*ah
, struct ath_desc
*ds
,
8002 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8004 ads
->ds_ctl1
|= (AR_IsAggr
| AR_MoreAggr
);
8006 ads
->ds_ctl6
&= ~AR_AggrLen
;
8007 ads
->ds_ctl6
|= SM(aggrLen
, AR_AggrLen
);
8011 ath9k_hw_set11n_aggr_middle(struct ath_hal
*ah
, struct ath_desc
*ds
,
8014 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8017 ads
->ds_ctl1
|= (AR_IsAggr
| AR_MoreAggr
);
8019 ctl6
= ads
->ds_ctl6
;
8020 ctl6
&= ~AR_PadDelim
;
8021 ctl6
|= SM(numDelims
, AR_PadDelim
);
8022 ads
->ds_ctl6
= ctl6
;
8025 void ath9k_hw_set11n_aggr_last(struct ath_hal
*ah
, struct ath_desc
*ds
)
8027 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8029 ads
->ds_ctl1
|= AR_IsAggr
;
8030 ads
->ds_ctl1
&= ~AR_MoreAggr
;
8031 ads
->ds_ctl6
&= ~AR_PadDelim
;
8034 void ath9k_hw_clr11n_aggr(struct ath_hal
*ah
, struct ath_desc
*ds
)
8036 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8038 ads
->ds_ctl1
&= (~AR_IsAggr
& ~AR_MoreAggr
);
8042 ath9k_hw_set11n_burstduration(struct ath_hal
*ah
, struct ath_desc
*ds
,
8045 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8047 ads
->ds_ctl2
&= ~AR_BurstDur
;
8048 ads
->ds_ctl2
|= SM(burstDuration
, AR_BurstDur
);
8052 ath9k_hw_set11n_virtualmorefrag(struct ath_hal
*ah
, struct ath_desc
*ds
,
8055 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8058 ads
->ds_ctl0
|= AR_VirtMoreFrag
;
8060 ads
->ds_ctl0
&= ~AR_VirtMoreFrag
;
8063 void ath9k_hw_putrxbuf(struct ath_hal
*ah
, u32 rxdp
)
8065 REG_WRITE(ah
, AR_RXDP
, rxdp
);
8068 void ath9k_hw_rxena(struct ath_hal
*ah
)
8070 REG_WRITE(ah
, AR_CR
, AR_CR_RXE
);
8073 bool ath9k_hw_setrxabort(struct ath_hal
*ah
, bool set
)
8077 REG_SET_BIT(ah
, AR_DIAG_SW
,
8078 (AR_DIAG_RX_DIS
| AR_DIAG_RX_ABORT
));
8081 (ah
, AR_OBS_BUS_1
, AR_OBS_BUS_1_RX_STATE
, 0)) {
8084 REG_CLR_BIT(ah
, AR_DIAG_SW
,
8088 reg
= REG_READ(ah
, AR_OBS_BUS_1
);
8089 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
8090 "%s: rx failed to go idle in 10 ms RXSM=0x%x\n",
8096 REG_CLR_BIT(ah
, AR_DIAG_SW
,
8097 (AR_DIAG_RX_DIS
| AR_DIAG_RX_ABORT
));
8104 ath9k_hw_setmcastfilter(struct ath_hal
*ah
, u32 filter0
,
8107 REG_WRITE(ah
, AR_MCAST_FIL0
, filter0
);
8108 REG_WRITE(ah
, AR_MCAST_FIL1
, filter1
);
8112 ath9k_hw_setuprxdesc(struct ath_hal
*ah
, struct ath_desc
*ds
,
8113 u32 size
, u32 flags
)
8115 struct ar5416_desc
*ads
= AR5416DESC(ds
);
8116 struct ath9k_hw_capabilities
*pCap
= &ah
->ah_caps
;
8118 ads
->ds_ctl1
= size
& AR_BufLen
;
8119 if (flags
& ATH9K_RXDESC_INTREQ
)
8120 ads
->ds_ctl1
|= AR_RxIntrReq
;
8122 ads
->ds_rxstatus8
&= ~AR_RxDone
;
8123 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
))
8124 memset(&(ads
->u
), 0, sizeof(ads
->u
));
8129 ath9k_hw_rxprocdesc(struct ath_hal
*ah
, struct ath_desc
*ds
,
8130 u32 pa
, struct ath_desc
*nds
, u64 tsf
)
8132 struct ar5416_desc ads
;
8133 struct ar5416_desc
*adsp
= AR5416DESC(ds
);
8135 if ((adsp
->ds_rxstatus8
& AR_RxDone
) == 0)
8136 return -EINPROGRESS
;
8138 ads
.u
.rx
= adsp
->u
.rx
;
8140 ds
->ds_rxstat
.rs_status
= 0;
8141 ds
->ds_rxstat
.rs_flags
= 0;
8143 ds
->ds_rxstat
.rs_datalen
= ads
.ds_rxstatus1
& AR_DataLen
;
8144 ds
->ds_rxstat
.rs_tstamp
= ads
.AR_RcvTimestamp
;
8146 ds
->ds_rxstat
.rs_rssi
= MS(ads
.ds_rxstatus4
, AR_RxRSSICombined
);
8147 ds
->ds_rxstat
.rs_rssi_ctl0
= MS(ads
.ds_rxstatus0
, AR_RxRSSIAnt00
);
8148 ds
->ds_rxstat
.rs_rssi_ctl1
= MS(ads
.ds_rxstatus0
, AR_RxRSSIAnt01
);
8149 ds
->ds_rxstat
.rs_rssi_ctl2
= MS(ads
.ds_rxstatus0
, AR_RxRSSIAnt02
);
8150 ds
->ds_rxstat
.rs_rssi_ext0
= MS(ads
.ds_rxstatus4
, AR_RxRSSIAnt10
);
8151 ds
->ds_rxstat
.rs_rssi_ext1
= MS(ads
.ds_rxstatus4
, AR_RxRSSIAnt11
);
8152 ds
->ds_rxstat
.rs_rssi_ext2
= MS(ads
.ds_rxstatus4
, AR_RxRSSIAnt12
);
8153 if (ads
.ds_rxstatus8
& AR_RxKeyIdxValid
)
8154 ds
->ds_rxstat
.rs_keyix
= MS(ads
.ds_rxstatus8
, AR_KeyIdx
);
8156 ds
->ds_rxstat
.rs_keyix
= ATH9K_RXKEYIX_INVALID
;
8158 ds
->ds_rxstat
.rs_rate
= RXSTATUS_RATE(ah
, (&ads
));
8159 ds
->ds_rxstat
.rs_more
= (ads
.ds_rxstatus1
& AR_RxMore
) ? 1 : 0;
8161 ds
->ds_rxstat
.rs_isaggr
= (ads
.ds_rxstatus8
& AR_RxAggr
) ? 1 : 0;
8162 ds
->ds_rxstat
.rs_moreaggr
=
8163 (ads
.ds_rxstatus8
& AR_RxMoreAggr
) ? 1 : 0;
8164 ds
->ds_rxstat
.rs_antenna
= MS(ads
.ds_rxstatus3
, AR_RxAntenna
);
8165 ds
->ds_rxstat
.rs_flags
=
8166 (ads
.ds_rxstatus3
& AR_GI
) ? ATH9K_RX_GI
: 0;
8167 ds
->ds_rxstat
.rs_flags
|=
8168 (ads
.ds_rxstatus3
& AR_2040
) ? ATH9K_RX_2040
: 0;
8170 if (ads
.ds_rxstatus8
& AR_PreDelimCRCErr
)
8171 ds
->ds_rxstat
.rs_flags
|= ATH9K_RX_DELIM_CRC_PRE
;
8172 if (ads
.ds_rxstatus8
& AR_PostDelimCRCErr
)
8173 ds
->ds_rxstat
.rs_flags
|= ATH9K_RX_DELIM_CRC_POST
;
8174 if (ads
.ds_rxstatus8
& AR_DecryptBusyErr
)
8175 ds
->ds_rxstat
.rs_flags
|= ATH9K_RX_DECRYPT_BUSY
;
8177 if ((ads
.ds_rxstatus8
& AR_RxFrameOK
) == 0) {
8179 if (ads
.ds_rxstatus8
& AR_CRCErr
)
8180 ds
->ds_rxstat
.rs_status
|= ATH9K_RXERR_CRC
;
8181 else if (ads
.ds_rxstatus8
& AR_PHYErr
) {
8184 ds
->ds_rxstat
.rs_status
|= ATH9K_RXERR_PHY
;
8185 phyerr
= MS(ads
.ds_rxstatus8
, AR_PHYErrCode
);
8186 ds
->ds_rxstat
.rs_phyerr
= phyerr
;
8187 } else if (ads
.ds_rxstatus8
& AR_DecryptCRCErr
)
8188 ds
->ds_rxstat
.rs_status
|= ATH9K_RXERR_DECRYPT
;
8189 else if (ads
.ds_rxstatus8
& AR_MichaelErr
)
8190 ds
->ds_rxstat
.rs_status
|= ATH9K_RXERR_MIC
;
8196 static void ath9k_hw_setup_rate_table(struct ath_hal
*ah
,
8197 struct ath9k_rate_table
*rt
)
8201 if (rt
->rateCodeToIndex
[0] != 0)
8203 for (i
= 0; i
< 256; i
++)
8204 rt
->rateCodeToIndex
[i
] = (u8
) -1;
8205 for (i
= 0; i
< rt
->rateCount
; i
++) {
8206 u8 code
= rt
->info
[i
].rateCode
;
8207 u8 cix
= rt
->info
[i
].controlRate
;
8209 rt
->rateCodeToIndex
[code
] = i
;
8210 rt
->rateCodeToIndex
[code
| rt
->info
[i
].shortPreamble
] = i
;
8212 rt
->info
[i
].lpAckDuration
=
8213 ath9k_hw_computetxtime(ah
, rt
,
8214 WLAN_CTRL_FRAME_SIZE
,
8217 rt
->info
[i
].spAckDuration
=
8218 ath9k_hw_computetxtime(ah
, rt
,
8219 WLAN_CTRL_FRAME_SIZE
,
8225 const struct ath9k_rate_table
*ath9k_hw_getratetable(struct ath_hal
*ah
,
8228 struct ath9k_rate_table
*rt
;
8230 case ATH9K_MODE_11A
:
8231 rt
= &ar5416_11a_table
;
8233 case ATH9K_MODE_11B
:
8234 rt
= &ar5416_11b_table
;
8236 case ATH9K_MODE_11G
:
8237 rt
= &ar5416_11g_table
;
8239 case ATH9K_MODE_11NG_HT20
:
8240 case ATH9K_MODE_11NG_HT40PLUS
:
8241 case ATH9K_MODE_11NG_HT40MINUS
:
8242 rt
= &ar5416_11ng_table
;
8244 case ATH9K_MODE_11NA_HT20
:
8245 case ATH9K_MODE_11NA_HT40PLUS
:
8246 case ATH9K_MODE_11NA_HT40MINUS
:
8247 rt
= &ar5416_11na_table
;
8250 DPRINTF(ah
->ah_sc
, ATH_DBG_CHANNEL
, "%s: invalid mode 0x%x\n",
8254 ath9k_hw_setup_rate_table(ah
, rt
);
8258 static const char *ath9k_hw_devname(u16 devid
)
8261 case AR5416_DEVID_PCI
:
8262 case AR5416_DEVID_PCIE
:
8263 return "Atheros 5416";
8264 case AR9160_DEVID_PCI
:
8265 return "Atheros 9160";
8266 case AR9280_DEVID_PCI
:
8267 case AR9280_DEVID_PCIE
:
8268 return "Atheros 9280";
8273 const char *ath9k_hw_probe(u16 vendorid
, u16 devid
)
8275 return vendorid
== ATHEROS_VENDOR_ID
?
8276 ath9k_hw_devname(devid
) : NULL
;
8279 struct ath_hal
*ath9k_hw_attach(u16 devid
,
8280 struct ath_softc
*sc
,
8284 struct ath_hal
*ah
= NULL
;
8287 case AR5416_DEVID_PCI
:
8288 case AR5416_DEVID_PCIE
:
8289 case AR9160_DEVID_PCI
:
8290 case AR9280_DEVID_PCI
:
8291 case AR9280_DEVID_PCIE
:
8292 ah
= ath9k_hw_do_attach(devid
, sc
, mem
, error
);
8295 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
8296 "devid=0x%x not supported.\n", devid
);
8306 ath9k_hw_computetxtime(struct ath_hal
*ah
,
8307 const struct ath9k_rate_table
*rates
,
8308 u32 frameLen
, u16 rateix
,
8311 u32 bitsPerSymbol
, numBits
, numSymbols
, phyTime
, txTime
;
8314 kbps
= rates
->info
[rateix
].rateKbps
;
8318 switch (rates
->info
[rateix
].phy
) {
8321 phyTime
= CCK_PREAMBLE_BITS
+ CCK_PLCP_BITS
;
8322 if (shortPreamble
&& rates
->info
[rateix
].shortPreamble
)
8324 numBits
= frameLen
<< 3;
8325 txTime
= CCK_SIFS_TIME
+ phyTime
8326 + ((numBits
* 1000) / kbps
);
8329 if (ah
->ah_curchan
&& IS_CHAN_QUARTER_RATE(ah
->ah_curchan
)) {
8331 (kbps
* OFDM_SYMBOL_TIME_QUARTER
) / 1000;
8333 numBits
= OFDM_PLCP_BITS
+ (frameLen
<< 3);
8334 numSymbols
= DIV_ROUND_UP(numBits
, bitsPerSymbol
);
8335 txTime
= OFDM_SIFS_TIME_QUARTER
8336 + OFDM_PREAMBLE_TIME_QUARTER
8337 + (numSymbols
* OFDM_SYMBOL_TIME_QUARTER
);
8338 } else if (ah
->ah_curchan
&&
8339 IS_CHAN_HALF_RATE(ah
->ah_curchan
)) {
8341 (kbps
* OFDM_SYMBOL_TIME_HALF
) / 1000;
8343 numBits
= OFDM_PLCP_BITS
+ (frameLen
<< 3);
8344 numSymbols
= DIV_ROUND_UP(numBits
, bitsPerSymbol
);
8345 txTime
= OFDM_SIFS_TIME_HALF
+
8346 OFDM_PREAMBLE_TIME_HALF
8347 + (numSymbols
* OFDM_SYMBOL_TIME_HALF
);
8349 bitsPerSymbol
= (kbps
* OFDM_SYMBOL_TIME
) / 1000;
8351 numBits
= OFDM_PLCP_BITS
+ (frameLen
<< 3);
8352 numSymbols
= DIV_ROUND_UP(numBits
, bitsPerSymbol
);
8353 txTime
= OFDM_SIFS_TIME
+ OFDM_PREAMBLE_TIME
8354 + (numSymbols
* OFDM_SYMBOL_TIME
);
8359 DPRINTF(ah
->ah_sc
, ATH_DBG_PHY_IO
,
8360 "%s: unknown phy %u (rate ix %u)\n", __func__
,
8361 rates
->info
[rateix
].phy
, rateix
);
8368 u32
ath9k_hw_mhz2ieee(struct ath_hal
*ah
, u32 freq
, u32 flags
)
8370 if (flags
& CHANNEL_2GHZ
) {
8374 return (freq
- 2407) / 5;
8376 return 15 + ((freq
- 2512) / 20);
8377 } else if (flags
& CHANNEL_5GHZ
) {
8378 if (ath9k_regd_is_public_safety_sku(ah
) &&
8379 IS_CHAN_IN_PUBLIC_SAFETY_BAND(freq
)) {
8380 return ((freq
* 10) +
8381 (((freq
% 5) == 2) ? 5 : 0) - 49400) / 5;
8382 } else if ((flags
& CHANNEL_A
) && (freq
<= 5000)) {
8383 return (freq
- 4000) / 5;
8385 return (freq
- 5000) / 5;
8391 return (freq
- 2407) / 5;
8393 if (ath9k_regd_is_public_safety_sku(ah
)
8394 && IS_CHAN_IN_PUBLIC_SAFETY_BAND(freq
)) {
8395 return ((freq
* 10) +
8397 2) ? 5 : 0) - 49400) / 5;
8398 } else if (freq
> 4900) {
8399 return (freq
- 4000) / 5;
8401 return 15 + ((freq
- 2512) / 20);
8404 return (freq
- 5000) / 5;
8408 /* We can tune this as we go by monitoring really low values */
8409 #define ATH9K_NF_TOO_LOW -60
8411 /* AR5416 may return very high value (like -31 dBm), in those cases the nf
8412 * is incorrect and we should use the static NF value. Later we can try to
8413 * find out why they are reporting these values */
8414 static bool ath9k_hw_nf_in_range(struct ath_hal
*ah
, s16 nf
)
8416 if (nf
> ATH9K_NF_TOO_LOW
) {
8417 DPRINTF(ah
->ah_sc
, ATH_DBG_NF_CAL
,
8418 "%s: noise floor value detected (%d) is "
8419 "lower than what we think is a "
8420 "reasonable value (%d)\n",
8421 __func__
, nf
, ATH9K_NF_TOO_LOW
);
8428 ath9k_hw_getchan_noise(struct ath_hal
*ah
, struct ath9k_channel
*chan
)
8430 struct ath9k_channel
*ichan
;
8433 ichan
= ath9k_regd_check_channel(ah
, chan
);
8434 if (ichan
== NULL
) {
8435 DPRINTF(ah
->ah_sc
, ATH_DBG_NF_CAL
,
8436 "%s: invalid channel %u/0x%x; no mapping\n",
8437 __func__
, chan
->channel
, chan
->channelFlags
);
8438 return ATH_DEFAULT_NOISE_FLOOR
;
8440 if (ichan
->rawNoiseFloor
== 0) {
8441 enum wireless_mode mode
= ath9k_hw_chan2wmode(ah
, chan
);
8442 nf
= NOISE_FLOOR
[mode
];
8444 nf
= ichan
->rawNoiseFloor
;
8446 if (!ath9k_hw_nf_in_range(ah
, nf
))
8447 nf
= ATH_DEFAULT_NOISE_FLOOR
;
8452 bool ath9k_hw_set_tsfadjust(struct ath_hal
*ah
, u32 setting
)
8454 struct ath_hal_5416
*ahp
= AH5416(ah
);
8457 ahp
->ah_miscMode
|= AR_PCU_TX_ADD_TSF
;
8459 ahp
->ah_miscMode
&= ~AR_PCU_TX_ADD_TSF
;
8463 bool ath9k_hw_phycounters(struct ath_hal
*ah
)
8465 struct ath_hal_5416
*ahp
= AH5416(ah
);
8467 return ahp
->ah_hasHwPhyCounters
? true : false;
8470 u32
ath9k_hw_gettxbuf(struct ath_hal
*ah
, u32 q
)
8472 return REG_READ(ah
, AR_QTXDP(q
));
8475 bool ath9k_hw_puttxbuf(struct ath_hal
*ah
, u32 q
,
8478 REG_WRITE(ah
, AR_QTXDP(q
), txdp
);
8483 bool ath9k_hw_txstart(struct ath_hal
*ah
, u32 q
)
8485 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
, "%s: queue %u\n", __func__
, q
);
8487 REG_WRITE(ah
, AR_Q_TXE
, 1 << q
);
8492 u32
ath9k_hw_numtxpending(struct ath_hal
*ah
, u32 q
)
8496 npend
= REG_READ(ah
, AR_QSTS(q
)) & AR_Q_STS_PEND_FR_CNT
;
8499 if (REG_READ(ah
, AR_Q_TXE
) & (1 << q
))
8505 bool ath9k_hw_stoptxdma(struct ath_hal
*ah
, u32 q
)
8509 REG_WRITE(ah
, AR_Q_TXD
, 1 << q
);
8511 for (wait
= 1000; wait
!= 0; wait
--) {
8512 if (ath9k_hw_numtxpending(ah
, q
) == 0)
8517 if (ath9k_hw_numtxpending(ah
, q
)) {
8520 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
8521 "%s: Num of pending TX Frames %d on Q %d\n",
8522 __func__
, ath9k_hw_numtxpending(ah
, q
), q
);
8524 for (j
= 0; j
< 2; j
++) {
8525 tsfLow
= REG_READ(ah
, AR_TSF_L32
);
8526 REG_WRITE(ah
, AR_QUIET2
,
8527 SM(10, AR_QUIET2_QUIET_DUR
));
8528 REG_WRITE(ah
, AR_QUIET_PERIOD
, 100);
8529 REG_WRITE(ah
, AR_NEXT_QUIET_TIMER
, tsfLow
>> 10);
8530 REG_SET_BIT(ah
, AR_TIMER_MODE
,
8533 if ((REG_READ(ah
, AR_TSF_L32
) >> 10) ==
8537 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
8538 "%s: TSF have moved while trying to set "
8539 "quiet time TSF: 0x%08x\n",
8543 REG_SET_BIT(ah
, AR_DIAG_SW
, AR_DIAG_FORCE_CH_IDLE_HIGH
);
8546 REG_CLR_BIT(ah
, AR_TIMER_MODE
, AR_QUIET_TIMER_EN
);
8550 while (ath9k_hw_numtxpending(ah
, q
)) {
8551 if ((--wait
) == 0) {
8552 DPRINTF(ah
->ah_sc
, ATH_DBG_XMIT
,
8553 "%s: Failed to stop Tx DMA in 100 "
8554 "msec after killing last frame\n",
8561 REG_CLR_BIT(ah
, AR_DIAG_SW
, AR_DIAG_FORCE_CH_IDLE_HIGH
);
8564 REG_WRITE(ah
, AR_Q_TXD
, 0);