2 * Copyright (c) 2010-2011 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.
17 #include <linux/export.h>
19 #include "ar9003_phy.h"
21 static const int firstep_table
[] =
22 /* level: 0 1 2 3 4 5 6 7 8 */
23 { -4, -2, 0, 2, 4, 6, 8, 10, 12 }; /* lvl 0-8, default 2 */
25 static const int cycpwrThr1_table
[] =
26 /* level: 0 1 2 3 4 5 6 7 8 */
27 { -6, -4, -2, 0, 2, 4, 6, 8 }; /* lvl 0-7, default 3 */
30 * register values to turn OFDM weak signal detection OFF
32 static const int m1ThreshLow_off
= 127;
33 static const int m2ThreshLow_off
= 127;
34 static const int m1Thresh_off
= 127;
35 static const int m2Thresh_off
= 127;
36 static const int m2CountThr_off
= 31;
37 static const int m2CountThrLow_off
= 63;
38 static const int m1ThreshLowExt_off
= 127;
39 static const int m2ThreshLowExt_off
= 127;
40 static const int m1ThreshExt_off
= 127;
41 static const int m2ThreshExt_off
= 127;
44 * ar9003_hw_set_channel - set channel on single-chip device
45 * @ah: atheros hardware structure
48 * This is the function to change channel on single-chip devices, that is
49 * for AR9300 family of chipsets.
51 * This function takes the channel value in MHz and sets
52 * hardware channel value. Assumes writes have been enabled to analog bus.
57 * Channel Frequency = (3/4) * freq_ref * (chansel[8:0] + chanfrac[16:0]/2^17)
61 * Channel Frequency = (3/2) * freq_ref * (chansel[8:0] + chanfrac[16:0]/2^10)
62 * (freq_ref = 40MHz/(24>>amodeRefSel))
64 * For 5GHz channels which are 5MHz spaced,
65 * Channel Frequency = (3/2) * freq_ref * (chansel[8:0] + chanfrac[16:0]/2^17)
68 static int ar9003_hw_set_channel(struct ath_hw
*ah
, struct ath9k_channel
*chan
)
70 u16 bMode
, fracMode
= 0, aModeRefSel
= 0;
71 u32 freq
, chan_frac
, div
, channelSel
= 0, reg32
= 0;
72 struct chan_centers centers
;
75 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
76 freq
= centers
.synth_center
;
78 if (freq
< 4800) { /* 2 GHz, fractional mode */
79 if (AR_SREV_9330(ah
)) {
85 channelSel
= (freq
* 4) / div
;
86 chan_frac
= (((freq
* 4) % div
) * 0x20000) / div
;
87 channelSel
= (channelSel
<< 17) | chan_frac
;
88 } else if (AR_SREV_9485(ah
) || AR_SREV_9565(ah
)) {
90 * freq_ref = 40 / (refdiva >> amoderefsel);
91 * where refdiva=1 and amoderefsel=0
92 * ndiv = ((chan_mhz * 4) / 3) / freq_ref;
93 * chansel = int(ndiv), chanfrac = (ndiv - chansel) * 0x20000
95 channelSel
= (freq
* 4) / 120;
96 chan_frac
= (((freq
* 4) % 120) * 0x20000) / 120;
97 channelSel
= (channelSel
<< 17) | chan_frac
;
98 } else if (AR_SREV_9340(ah
)) {
99 if (ah
->is_clk_25mhz
) {
100 channelSel
= (freq
* 2) / 75;
101 chan_frac
= (((freq
* 2) % 75) * 0x20000) / 75;
102 channelSel
= (channelSel
<< 17) | chan_frac
;
104 channelSel
= CHANSEL_2G(freq
) >> 1;
106 } else if (AR_SREV_9550(ah
)) {
107 if (ah
->is_clk_25mhz
)
112 channelSel
= (freq
* 4) / div
;
113 chan_frac
= (((freq
* 4) % div
) * 0x20000) / div
;
114 channelSel
= (channelSel
<< 17) | chan_frac
;
116 channelSel
= CHANSEL_2G(freq
);
121 if ((AR_SREV_9340(ah
) || AR_SREV_9550(ah
)) &&
123 channelSel
= freq
/ 75;
124 chan_frac
= ((freq
% 75) * 0x20000) / 75;
125 channelSel
= (channelSel
<< 17) | chan_frac
;
127 channelSel
= CHANSEL_5G(freq
);
128 /* Doubler is ON, so, divide channelSel by 2. */
135 /* Enable fractional mode for all channels */
138 loadSynthChannel
= 0;
140 reg32
= (bMode
<< 29);
141 REG_WRITE(ah
, AR_PHY_SYNTH_CONTROL
, reg32
);
143 /* Enable Long shift Select for Synthesizer */
144 REG_RMW_FIELD(ah
, AR_PHY_65NM_CH0_SYNTH4
,
145 AR_PHY_SYNTH4_LONG_SHIFT_SELECT
, 1);
147 /* Program Synth. setting */
148 reg32
= (channelSel
<< 2) | (fracMode
<< 30) |
149 (aModeRefSel
<< 28) | (loadSynthChannel
<< 31);
150 REG_WRITE(ah
, AR_PHY_65NM_CH0_SYNTH7
, reg32
);
152 /* Toggle Load Synth channel bit */
153 loadSynthChannel
= 1;
154 reg32
= (channelSel
<< 2) | (fracMode
<< 30) |
155 (aModeRefSel
<< 28) | (loadSynthChannel
<< 31);
156 REG_WRITE(ah
, AR_PHY_65NM_CH0_SYNTH7
, reg32
);
164 * ar9003_hw_spur_mitigate_mrc_cck - convert baseband spur frequency
165 * @ah: atheros hardware structure
168 * For single-chip solutions. Converts to baseband spur frequency given the
169 * input channel frequency and compute register settings below.
171 * Spur mitigation for MRC CCK
173 static void ar9003_hw_spur_mitigate_mrc_cck(struct ath_hw
*ah
,
174 struct ath9k_channel
*chan
)
176 static const u32 spur_freq
[4] = { 2420, 2440, 2464, 2480 };
177 int cur_bb_spur
, negative
= 0, cck_spur_freq
;
179 int range
, max_spur_cnts
, synth_freq
;
180 u8
*spur_fbin_ptr
= ar9003_get_spur_chan_ptr(ah
, IS_CHAN_2GHZ(chan
));
183 * Need to verify range +/- 10 MHz in control channel, otherwise spur
184 * is out-of-band and can be ignored.
187 if (AR_SREV_9485(ah
) || AR_SREV_9340(ah
) || AR_SREV_9330(ah
) ||
189 if (spur_fbin_ptr
[0] == 0) /* No spur */
192 if (IS_CHAN_HT40(chan
)) {
194 if (REG_READ_FIELD(ah
, AR_PHY_GEN_CTRL
,
195 AR_PHY_GC_DYN2040_PRI_CH
) == 0)
196 synth_freq
= chan
->channel
+ 10;
198 synth_freq
= chan
->channel
- 10;
201 synth_freq
= chan
->channel
;
204 range
= AR_SREV_9462(ah
) ? 5 : 10;
206 synth_freq
= chan
->channel
;
209 for (i
= 0; i
< max_spur_cnts
; i
++) {
210 if (AR_SREV_9462(ah
) && (i
== 0 || i
== 3))
214 if (AR_SREV_9485(ah
) || AR_SREV_9340(ah
) || AR_SREV_9330(ah
) ||
216 cur_bb_spur
= ath9k_hw_fbin2freq(spur_fbin_ptr
[i
],
219 cur_bb_spur
= spur_freq
[i
];
221 cur_bb_spur
-= synth_freq
;
222 if (cur_bb_spur
< 0) {
224 cur_bb_spur
= -cur_bb_spur
;
226 if (cur_bb_spur
< range
) {
227 cck_spur_freq
= (int)((cur_bb_spur
<< 19) / 11);
230 cck_spur_freq
= -cck_spur_freq
;
232 cck_spur_freq
= cck_spur_freq
& 0xfffff;
234 REG_RMW_FIELD(ah
, AR_PHY_AGC_CONTROL
,
235 AR_PHY_AGC_CONTROL_YCOK_MAX
, 0x7);
236 REG_RMW_FIELD(ah
, AR_PHY_CCK_SPUR_MIT
,
237 AR_PHY_CCK_SPUR_MIT_SPUR_RSSI_THR
, 0x7f);
238 REG_RMW_FIELD(ah
, AR_PHY_CCK_SPUR_MIT
,
239 AR_PHY_CCK_SPUR_MIT_SPUR_FILTER_TYPE
,
241 REG_RMW_FIELD(ah
, AR_PHY_CCK_SPUR_MIT
,
242 AR_PHY_CCK_SPUR_MIT_USE_CCK_SPUR_MIT
,
244 REG_RMW_FIELD(ah
, AR_PHY_CCK_SPUR_MIT
,
245 AR_PHY_CCK_SPUR_MIT_CCK_SPUR_FREQ
,
252 REG_RMW_FIELD(ah
, AR_PHY_AGC_CONTROL
,
253 AR_PHY_AGC_CONTROL_YCOK_MAX
, 0x5);
254 REG_RMW_FIELD(ah
, AR_PHY_CCK_SPUR_MIT
,
255 AR_PHY_CCK_SPUR_MIT_USE_CCK_SPUR_MIT
, 0x0);
256 REG_RMW_FIELD(ah
, AR_PHY_CCK_SPUR_MIT
,
257 AR_PHY_CCK_SPUR_MIT_CCK_SPUR_FREQ
, 0x0);
260 /* Clean all spur register fields */
261 static void ar9003_hw_spur_ofdm_clear(struct ath_hw
*ah
)
263 REG_RMW_FIELD(ah
, AR_PHY_TIMING4
,
264 AR_PHY_TIMING4_ENABLE_SPUR_FILTER
, 0);
265 REG_RMW_FIELD(ah
, AR_PHY_TIMING11
,
266 AR_PHY_TIMING11_SPUR_FREQ_SD
, 0);
267 REG_RMW_FIELD(ah
, AR_PHY_TIMING11
,
268 AR_PHY_TIMING11_SPUR_DELTA_PHASE
, 0);
269 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_EXT
,
270 AR_PHY_SFCORR_EXT_SPUR_SUBCHANNEL_SD
, 0);
271 REG_RMW_FIELD(ah
, AR_PHY_TIMING11
,
272 AR_PHY_TIMING11_USE_SPUR_FILTER_IN_AGC
, 0);
273 REG_RMW_FIELD(ah
, AR_PHY_TIMING11
,
274 AR_PHY_TIMING11_USE_SPUR_FILTER_IN_SELFCOR
, 0);
275 REG_RMW_FIELD(ah
, AR_PHY_TIMING4
,
276 AR_PHY_TIMING4_ENABLE_SPUR_RSSI
, 0);
277 REG_RMW_FIELD(ah
, AR_PHY_SPUR_REG
,
278 AR_PHY_SPUR_REG_EN_VIT_SPUR_RSSI
, 0);
279 REG_RMW_FIELD(ah
, AR_PHY_SPUR_REG
,
280 AR_PHY_SPUR_REG_ENABLE_NF_RSSI_SPUR_MIT
, 0);
282 REG_RMW_FIELD(ah
, AR_PHY_SPUR_REG
,
283 AR_PHY_SPUR_REG_ENABLE_MASK_PPM
, 0);
284 REG_RMW_FIELD(ah
, AR_PHY_TIMING4
,
285 AR_PHY_TIMING4_ENABLE_PILOT_MASK
, 0);
286 REG_RMW_FIELD(ah
, AR_PHY_TIMING4
,
287 AR_PHY_TIMING4_ENABLE_CHAN_MASK
, 0);
288 REG_RMW_FIELD(ah
, AR_PHY_PILOT_SPUR_MASK
,
289 AR_PHY_PILOT_SPUR_MASK_CF_PILOT_MASK_IDX_A
, 0);
290 REG_RMW_FIELD(ah
, AR_PHY_SPUR_MASK_A
,
291 AR_PHY_SPUR_MASK_A_CF_PUNC_MASK_IDX_A
, 0);
292 REG_RMW_FIELD(ah
, AR_PHY_CHAN_SPUR_MASK
,
293 AR_PHY_CHAN_SPUR_MASK_CF_CHAN_MASK_IDX_A
, 0);
294 REG_RMW_FIELD(ah
, AR_PHY_PILOT_SPUR_MASK
,
295 AR_PHY_PILOT_SPUR_MASK_CF_PILOT_MASK_A
, 0);
296 REG_RMW_FIELD(ah
, AR_PHY_CHAN_SPUR_MASK
,
297 AR_PHY_CHAN_SPUR_MASK_CF_CHAN_MASK_A
, 0);
298 REG_RMW_FIELD(ah
, AR_PHY_SPUR_MASK_A
,
299 AR_PHY_SPUR_MASK_A_CF_PUNC_MASK_A
, 0);
300 REG_RMW_FIELD(ah
, AR_PHY_SPUR_REG
,
301 AR_PHY_SPUR_REG_MASK_RATE_CNTL
, 0);
304 static void ar9003_hw_spur_ofdm(struct ath_hw
*ah
,
307 int spur_delta_phase
,
308 int spur_subchannel_sd
,
314 /* OFDM Spur mitigation */
315 REG_RMW_FIELD(ah
, AR_PHY_TIMING4
,
316 AR_PHY_TIMING4_ENABLE_SPUR_FILTER
, 0x1);
317 REG_RMW_FIELD(ah
, AR_PHY_TIMING11
,
318 AR_PHY_TIMING11_SPUR_FREQ_SD
, spur_freq_sd
);
319 REG_RMW_FIELD(ah
, AR_PHY_TIMING11
,
320 AR_PHY_TIMING11_SPUR_DELTA_PHASE
, spur_delta_phase
);
321 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_EXT
,
322 AR_PHY_SFCORR_EXT_SPUR_SUBCHANNEL_SD
, spur_subchannel_sd
);
323 REG_RMW_FIELD(ah
, AR_PHY_TIMING11
,
324 AR_PHY_TIMING11_USE_SPUR_FILTER_IN_AGC
, 0x1);
326 if (!(AR_SREV_9565(ah
) && range
== 10 && synth_freq
== 2437))
327 REG_RMW_FIELD(ah
, AR_PHY_TIMING11
,
328 AR_PHY_TIMING11_USE_SPUR_FILTER_IN_SELFCOR
, 0x1);
330 REG_RMW_FIELD(ah
, AR_PHY_TIMING4
,
331 AR_PHY_TIMING4_ENABLE_SPUR_RSSI
, 0x1);
332 REG_RMW_FIELD(ah
, AR_PHY_SPUR_REG
,
333 AR_PHY_SPUR_REG_SPUR_RSSI_THRESH
, 34);
334 REG_RMW_FIELD(ah
, AR_PHY_SPUR_REG
,
335 AR_PHY_SPUR_REG_EN_VIT_SPUR_RSSI
, 1);
337 if (!AR_SREV_9340(ah
) &&
338 REG_READ_FIELD(ah
, AR_PHY_MODE
,
339 AR_PHY_MODE_DYNAMIC
) == 0x1)
340 REG_RMW_FIELD(ah
, AR_PHY_SPUR_REG
,
341 AR_PHY_SPUR_REG_ENABLE_NF_RSSI_SPUR_MIT
, 1);
343 mask_index
= (freq_offset
<< 4) / 5;
345 mask_index
= mask_index
- 1;
347 mask_index
= mask_index
& 0x7f;
349 REG_RMW_FIELD(ah
, AR_PHY_SPUR_REG
,
350 AR_PHY_SPUR_REG_ENABLE_MASK_PPM
, 0x1);
351 REG_RMW_FIELD(ah
, AR_PHY_TIMING4
,
352 AR_PHY_TIMING4_ENABLE_PILOT_MASK
, 0x1);
353 REG_RMW_FIELD(ah
, AR_PHY_TIMING4
,
354 AR_PHY_TIMING4_ENABLE_CHAN_MASK
, 0x1);
355 REG_RMW_FIELD(ah
, AR_PHY_PILOT_SPUR_MASK
,
356 AR_PHY_PILOT_SPUR_MASK_CF_PILOT_MASK_IDX_A
, mask_index
);
357 REG_RMW_FIELD(ah
, AR_PHY_SPUR_MASK_A
,
358 AR_PHY_SPUR_MASK_A_CF_PUNC_MASK_IDX_A
, mask_index
);
359 REG_RMW_FIELD(ah
, AR_PHY_CHAN_SPUR_MASK
,
360 AR_PHY_CHAN_SPUR_MASK_CF_CHAN_MASK_IDX_A
, mask_index
);
361 REG_RMW_FIELD(ah
, AR_PHY_PILOT_SPUR_MASK
,
362 AR_PHY_PILOT_SPUR_MASK_CF_PILOT_MASK_A
, 0xc);
363 REG_RMW_FIELD(ah
, AR_PHY_CHAN_SPUR_MASK
,
364 AR_PHY_CHAN_SPUR_MASK_CF_CHAN_MASK_A
, 0xc);
365 REG_RMW_FIELD(ah
, AR_PHY_SPUR_MASK_A
,
366 AR_PHY_SPUR_MASK_A_CF_PUNC_MASK_A
, 0xa0);
367 REG_RMW_FIELD(ah
, AR_PHY_SPUR_REG
,
368 AR_PHY_SPUR_REG_MASK_RATE_CNTL
, 0xff);
371 static void ar9003_hw_spur_ofdm_9565(struct ath_hw
*ah
,
376 mask_index
= (freq_offset
<< 4) / 5;
378 mask_index
= mask_index
- 1;
380 mask_index
= mask_index
& 0x7f;
382 REG_RMW_FIELD(ah
, AR_PHY_PILOT_SPUR_MASK
,
383 AR_PHY_PILOT_SPUR_MASK_CF_PILOT_MASK_IDX_B
,
387 REG_RMW_FIELD(ah
, AR_PHY_SPUR_MASK_B
,
388 AR_PHY_SPUR_MASK_A_CF_PUNC_MASK_IDX_A
,
391 REG_RMW_FIELD(ah
, AR_PHY_CHAN_SPUR_MASK
,
392 AR_PHY_CHAN_SPUR_MASK_CF_CHAN_MASK_IDX_B
,
394 REG_RMW_FIELD(ah
, AR_PHY_PILOT_SPUR_MASK
,
395 AR_PHY_PILOT_SPUR_MASK_CF_PILOT_MASK_B
, 0xe);
396 REG_RMW_FIELD(ah
, AR_PHY_CHAN_SPUR_MASK
,
397 AR_PHY_CHAN_SPUR_MASK_CF_CHAN_MASK_B
, 0xe);
400 REG_RMW_FIELD(ah
, AR_PHY_SPUR_MASK_B
,
401 AR_PHY_SPUR_MASK_A_CF_PUNC_MASK_A
, 0xa0);
404 static void ar9003_hw_spur_ofdm_work(struct ath_hw
*ah
,
405 struct ath9k_channel
*chan
,
410 int spur_freq_sd
= 0;
411 int spur_subchannel_sd
= 0;
412 int spur_delta_phase
= 0;
414 if (IS_CHAN_HT40(chan
)) {
415 if (freq_offset
< 0) {
416 if (REG_READ_FIELD(ah
, AR_PHY_GEN_CTRL
,
417 AR_PHY_GC_DYN2040_PRI_CH
) == 0x0)
418 spur_subchannel_sd
= 1;
420 spur_subchannel_sd
= 0;
422 spur_freq_sd
= ((freq_offset
+ 10) << 9) / 11;
425 if (REG_READ_FIELD(ah
, AR_PHY_GEN_CTRL
,
426 AR_PHY_GC_DYN2040_PRI_CH
) == 0x0)
427 spur_subchannel_sd
= 0;
429 spur_subchannel_sd
= 1;
431 spur_freq_sd
= ((freq_offset
- 10) << 9) / 11;
435 spur_delta_phase
= (freq_offset
<< 17) / 5;
438 spur_subchannel_sd
= 0;
439 spur_freq_sd
= (freq_offset
<< 9) /11;
440 spur_delta_phase
= (freq_offset
<< 18) / 5;
443 spur_freq_sd
= spur_freq_sd
& 0x3ff;
444 spur_delta_phase
= spur_delta_phase
& 0xfffff;
446 ar9003_hw_spur_ofdm(ah
,
454 /* Spur mitigation for OFDM */
455 static void ar9003_hw_spur_mitigate_ofdm(struct ath_hw
*ah
,
456 struct ath9k_channel
*chan
)
464 struct ar9300_eeprom
*eep
= &ah
->eeprom
.ar9300_eep
;
466 if (IS_CHAN_5GHZ(chan
)) {
467 spurChansPtr
= &(eep
->modalHeader5G
.spurChans
[0]);
471 spurChansPtr
= &(eep
->modalHeader2G
.spurChans
[0]);
475 if (spurChansPtr
[0] == 0)
476 return; /* No spur in the mode */
478 if (IS_CHAN_HT40(chan
)) {
480 if (REG_READ_FIELD(ah
, AR_PHY_GEN_CTRL
,
481 AR_PHY_GC_DYN2040_PRI_CH
) == 0x0)
482 synth_freq
= chan
->channel
- 10;
484 synth_freq
= chan
->channel
+ 10;
487 synth_freq
= chan
->channel
;
490 ar9003_hw_spur_ofdm_clear(ah
);
492 for (i
= 0; i
< AR_EEPROM_MODAL_SPURS
&& spurChansPtr
[i
]; i
++) {
493 freq_offset
= ath9k_hw_fbin2freq(spurChansPtr
[i
], mode
);
494 freq_offset
-= synth_freq
;
495 if (abs(freq_offset
) < range
) {
496 ar9003_hw_spur_ofdm_work(ah
, chan
, freq_offset
,
499 if (AR_SREV_9565(ah
) && (i
< 4)) {
500 freq_offset
= ath9k_hw_fbin2freq(spurChansPtr
[i
+ 1],
502 freq_offset
-= synth_freq
;
503 if (abs(freq_offset
) < range
)
504 ar9003_hw_spur_ofdm_9565(ah
, freq_offset
);
512 static void ar9003_hw_spur_mitigate(struct ath_hw
*ah
,
513 struct ath9k_channel
*chan
)
515 if (!AR_SREV_9565(ah
))
516 ar9003_hw_spur_mitigate_mrc_cck(ah
, chan
);
517 ar9003_hw_spur_mitigate_ofdm(ah
, chan
);
520 static u32
ar9003_hw_compute_pll_control(struct ath_hw
*ah
,
521 struct ath9k_channel
*chan
)
525 pll
= SM(0x5, AR_RTC_9300_PLL_REFDIV
);
527 if (chan
&& IS_CHAN_HALF_RATE(chan
))
528 pll
|= SM(0x1, AR_RTC_9300_PLL_CLKSEL
);
529 else if (chan
&& IS_CHAN_QUARTER_RATE(chan
))
530 pll
|= SM(0x2, AR_RTC_9300_PLL_CLKSEL
);
532 pll
|= SM(0x2c, AR_RTC_9300_PLL_DIV
);
537 static void ar9003_hw_set_channel_regs(struct ath_hw
*ah
,
538 struct ath9k_channel
*chan
)
541 u32 enableDacFifo
= 0;
544 (REG_READ(ah
, AR_PHY_GEN_CTRL
) & AR_PHY_GC_ENABLE_DAC_FIFO
);
546 /* Enable 11n HT, 20 MHz */
547 phymode
= AR_PHY_GC_HT_EN
| AR_PHY_GC_SINGLE_HT_LTF1
|
548 AR_PHY_GC_SHORT_GI_40
| enableDacFifo
;
550 /* Configure baseband for dynamic 20/40 operation */
551 if (IS_CHAN_HT40(chan
)) {
552 phymode
|= AR_PHY_GC_DYN2040_EN
;
553 /* Configure control (primary) channel at +-10MHz */
554 if (IS_CHAN_HT40PLUS(chan
))
555 phymode
|= AR_PHY_GC_DYN2040_PRI_CH
;
559 /* make sure we preserve INI settings */
560 phymode
|= REG_READ(ah
, AR_PHY_GEN_CTRL
);
561 /* turn off Green Field detection for STA for now */
562 phymode
&= ~AR_PHY_GC_GF_DETECT_EN
;
564 REG_WRITE(ah
, AR_PHY_GEN_CTRL
, phymode
);
566 /* Configure MAC for 20/40 operation */
567 ath9k_hw_set11nmac2040(ah
, chan
);
569 /* global transmit timeout (25 TUs default)*/
570 REG_WRITE(ah
, AR_GTXTO
, 25 << AR_GTXTO_TIMEOUT_LIMIT_S
);
571 /* carrier sense timeout */
572 REG_WRITE(ah
, AR_CST
, 0xF << AR_CST_TIMEOUT_LIMIT_S
);
575 static void ar9003_hw_init_bb(struct ath_hw
*ah
,
576 struct ath9k_channel
*chan
)
581 * Wait for the frequency synth to settle (synth goes on
582 * via AR_PHY_ACTIVE_EN). Read the phy active delay register.
583 * Value is in 100ns increments.
585 synthDelay
= REG_READ(ah
, AR_PHY_RX_DELAY
) & AR_PHY_RX_DELAY_DELAY
;
587 /* Activate the PHY (includes baseband activate + synthesizer on) */
588 REG_WRITE(ah
, AR_PHY_ACTIVE
, AR_PHY_ACTIVE_EN
);
589 ath9k_hw_synth_delay(ah
, chan
, synthDelay
);
592 void ar9003_hw_set_chain_masks(struct ath_hw
*ah
, u8 rx
, u8 tx
)
594 if (ah
->caps
.tx_chainmask
== 5 || ah
->caps
.rx_chainmask
== 5)
595 REG_SET_BIT(ah
, AR_PHY_ANALOG_SWAP
,
596 AR_PHY_SWAP_ALT_CHAIN
);
598 REG_WRITE(ah
, AR_PHY_RX_CHAINMASK
, rx
);
599 REG_WRITE(ah
, AR_PHY_CAL_CHAINMASK
, rx
);
601 if ((ah
->caps
.hw_caps
& ATH9K_HW_CAP_APM
) && (tx
== 0x7))
604 REG_WRITE(ah
, AR_SELFGEN_MASK
, tx
);
608 * Override INI values with chip specific configuration.
610 static void ar9003_hw_override_ini(struct ath_hw
*ah
)
615 * Set the RX_ABORT and RX_DIS and clear it only after
616 * RXE is set for MAC. This prevents frames with
617 * corrupted descriptor status.
619 REG_SET_BIT(ah
, AR_DIAG_SW
, (AR_DIAG_RX_DIS
| AR_DIAG_RX_ABORT
));
622 * For AR9280 and above, there is a new feature that allows
623 * Multicast search based on both MAC Address and Key ID. By default,
624 * this feature is enabled. But since the driver is not using this
625 * feature, we switch it off; otherwise multicast search based on
626 * MAC addr only will fail.
628 val
= REG_READ(ah
, AR_PCU_MISC_MODE2
) & (~AR_ADHOC_MCAST_KEYID_ENABLE
);
629 val
|= AR_AGG_WEP_ENABLE_FIX
|
631 AR_PCU_MISC_MODE2_CFP_IGNORE
;
632 REG_WRITE(ah
, AR_PCU_MISC_MODE2
, val
);
634 if (AR_SREV_9462(ah
) || AR_SREV_9565(ah
)) {
635 REG_WRITE(ah
, AR_GLB_SWREG_DISCONT_MODE
,
636 AR_GLB_SWREG_DISCONT_EN_BT_WLAN
);
638 if (REG_READ_FIELD(ah
, AR_PHY_TX_IQCAL_CONTROL_0
,
639 AR_PHY_TX_IQCAL_CONTROL_0_ENABLE_TXIQ_CAL
))
640 ah
->enabled_cals
|= TX_IQ_CAL
;
642 ah
->enabled_cals
&= ~TX_IQ_CAL
;
646 if (REG_READ(ah
, AR_PHY_CL_CAL_CTL
) & AR_PHY_CL_CAL_ENABLE
)
647 ah
->enabled_cals
|= TX_CL_CAL
;
649 ah
->enabled_cals
&= ~TX_CL_CAL
;
652 static void ar9003_hw_prog_ini(struct ath_hw
*ah
,
653 struct ar5416IniArray
*iniArr
,
656 unsigned int i
, regWrites
= 0;
658 /* New INI format: Array may be undefined (pre, core, post arrays) */
659 if (!iniArr
->ia_array
)
663 * New INI format: Pre, core, and post arrays for a given subsystem
664 * may be modal (> 2 columns) or non-modal (2 columns). Determine if
665 * the array is non-modal and force the column to 1.
667 if (column
>= iniArr
->ia_columns
)
670 for (i
= 0; i
< iniArr
->ia_rows
; i
++) {
671 u32 reg
= INI_RA(iniArr
, i
, 0);
672 u32 val
= INI_RA(iniArr
, i
, column
);
674 REG_WRITE(ah
, reg
, val
);
680 static int ar9550_hw_get_modes_txgain_index(struct ath_hw
*ah
,
681 struct ath9k_channel
*chan
)
685 if (IS_CHAN_2GHZ(chan
)) {
686 if (IS_CHAN_HT40(chan
))
692 if (chan
->channel
<= 5350)
694 else if ((chan
->channel
> 5350) && (chan
->channel
<= 5600))
699 if (IS_CHAN_HT40(chan
))
705 static void ar9003_doubler_fix(struct ath_hw
*ah
)
707 if (AR_SREV_9300(ah
) || AR_SREV_9580(ah
) || AR_SREV_9550(ah
)) {
708 REG_RMW(ah
, AR_PHY_65NM_CH0_RXTX2
,
709 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK_S
|
710 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHOVR_MASK_S
, 0);
711 REG_RMW(ah
, AR_PHY_65NM_CH1_RXTX2
,
712 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK_S
|
713 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHOVR_MASK_S
, 0);
714 REG_RMW(ah
, AR_PHY_65NM_CH2_RXTX2
,
715 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK_S
|
716 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHOVR_MASK_S
, 0);
720 REG_CLR_BIT(ah
, AR_PHY_65NM_CH0_RXTX2
,
721 AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK
);
722 REG_CLR_BIT(ah
, AR_PHY_65NM_CH1_RXTX2
,
723 AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK
);
724 REG_CLR_BIT(ah
, AR_PHY_65NM_CH2_RXTX2
,
725 AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK
);
729 REG_RMW_FIELD(ah
, AR_PHY_65NM_CH0_RXTX2
,
730 AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK
, 1);
731 REG_RMW_FIELD(ah
, AR_PHY_65NM_CH1_RXTX2
,
732 AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK
, 1);
733 REG_RMW_FIELD(ah
, AR_PHY_65NM_CH2_RXTX2
,
734 AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK
, 1);
738 REG_RMW_FIELD(ah
, AR_PHY_65NM_CH0_SYNTH12
,
739 AR_PHY_65NM_CH0_SYNTH12_VREFMUL3
, 0xf);
741 REG_RMW(ah
, AR_PHY_65NM_CH0_RXTX2
, 0,
742 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK_S
|
743 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHOVR_MASK_S
);
744 REG_RMW(ah
, AR_PHY_65NM_CH1_RXTX2
, 0,
745 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK_S
|
746 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHOVR_MASK_S
);
747 REG_RMW(ah
, AR_PHY_65NM_CH2_RXTX2
, 0,
748 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHON_MASK_S
|
749 1 << AR_PHY_65NM_CH0_RXTX2_SYNTHOVR_MASK_S
);
753 static int ar9003_hw_process_ini(struct ath_hw
*ah
,
754 struct ath9k_channel
*chan
)
756 unsigned int regWrites
= 0, i
;
759 if (IS_CHAN_5GHZ(chan
))
760 modesIndex
= IS_CHAN_HT40(chan
) ? 2 : 1;
762 modesIndex
= IS_CHAN_HT40(chan
) ? 3 : 4;
765 * SOC, MAC, BB, RADIO initvals.
767 for (i
= 0; i
< ATH_INI_NUM_SPLIT
; i
++) {
768 ar9003_hw_prog_ini(ah
, &ah
->iniSOC
[i
], modesIndex
);
769 ar9003_hw_prog_ini(ah
, &ah
->iniMac
[i
], modesIndex
);
770 ar9003_hw_prog_ini(ah
, &ah
->iniBB
[i
], modesIndex
);
771 ar9003_hw_prog_ini(ah
, &ah
->iniRadio
[i
], modesIndex
);
772 if (i
== ATH_INI_POST
&& AR_SREV_9462_20_OR_LATER(ah
))
773 ar9003_hw_prog_ini(ah
,
774 &ah
->ini_radio_post_sys2ant
,
778 ar9003_doubler_fix(ah
);
783 REG_WRITE_ARRAY(&ah
->iniModesRxGain
, 1, regWrites
);
785 if (AR_SREV_9462_20_OR_LATER(ah
)) {
787 * CUS217 mix LNA mode.
789 if (ar9003_hw_get_rx_gain_idx(ah
) == 2) {
790 REG_WRITE_ARRAY(&ah
->ini_modes_rxgain_bb_core
,
792 REG_WRITE_ARRAY(&ah
->ini_modes_rxgain_bb_postamble
,
793 modesIndex
, regWrites
);
799 if ((ar9003_hw_get_rx_gain_idx(ah
) == 2) ||
800 (ar9003_hw_get_rx_gain_idx(ah
) == 3)) {
801 REG_WRITE_ARRAY(&ah
->ini_modes_rxgain_5g_xlna
,
802 modesIndex
, regWrites
);
806 if (AR_SREV_9550(ah
))
807 REG_WRITE_ARRAY(&ah
->ini_modes_rx_gain_bounds
, modesIndex
,
813 if (AR_SREV_9550(ah
)) {
814 int modes_txgain_index
;
816 modes_txgain_index
= ar9550_hw_get_modes_txgain_index(ah
, chan
);
817 if (modes_txgain_index
< 0)
820 REG_WRITE_ARRAY(&ah
->iniModesTxGain
, modes_txgain_index
,
823 REG_WRITE_ARRAY(&ah
->iniModesTxGain
, modesIndex
, regWrites
);
827 * For 5GHz channels requiring Fast Clock, apply
828 * different modal values.
830 if (IS_CHAN_A_FAST_CLOCK(ah
, chan
))
831 REG_WRITE_ARRAY(&ah
->iniModesFastClock
,
832 modesIndex
, regWrites
);
835 * Clock frequency initvals.
837 REG_WRITE_ARRAY(&ah
->iniAdditional
, 1, regWrites
);
842 if (chan
->channel
== 2484)
843 ar9003_hw_prog_ini(ah
, &ah
->iniCckfirJapan2484
, 1);
845 ah
->modes_index
= modesIndex
;
846 ar9003_hw_override_ini(ah
);
847 ar9003_hw_set_channel_regs(ah
, chan
);
848 ar9003_hw_set_chain_masks(ah
, ah
->rxchainmask
, ah
->txchainmask
);
849 ath9k_hw_apply_txpower(ah
, chan
, false);
854 static void ar9003_hw_set_rfmode(struct ath_hw
*ah
,
855 struct ath9k_channel
*chan
)
862 if (IS_CHAN_2GHZ(chan
))
863 rfMode
|= AR_PHY_MODE_DYNAMIC
;
865 rfMode
|= AR_PHY_MODE_OFDM
;
867 if (IS_CHAN_A_FAST_CLOCK(ah
, chan
))
868 rfMode
|= (AR_PHY_MODE_DYNAMIC
| AR_PHY_MODE_DYN_CCK_DISABLE
);
869 if (IS_CHAN_QUARTER_RATE(chan
))
870 rfMode
|= AR_PHY_MODE_QUARTER
;
871 if (IS_CHAN_HALF_RATE(chan
))
872 rfMode
|= AR_PHY_MODE_HALF
;
874 if (rfMode
& (AR_PHY_MODE_QUARTER
| AR_PHY_MODE_HALF
))
875 REG_RMW_FIELD(ah
, AR_PHY_FRAME_CTL
,
876 AR_PHY_FRAME_CTL_CF_OVERLAP_WINDOW
, 3);
878 REG_WRITE(ah
, AR_PHY_MODE
, rfMode
);
881 static void ar9003_hw_mark_phy_inactive(struct ath_hw
*ah
)
883 REG_WRITE(ah
, AR_PHY_ACTIVE
, AR_PHY_ACTIVE_DIS
);
886 static void ar9003_hw_set_delta_slope(struct ath_hw
*ah
,
887 struct ath9k_channel
*chan
)
889 u32 coef_scaled
, ds_coef_exp
, ds_coef_man
;
890 u32 clockMhzScaled
= 0x64000000;
891 struct chan_centers centers
;
894 * half and quarter rate can divide the scaled clock by 2 or 4
895 * scale for selected channel bandwidth
897 if (IS_CHAN_HALF_RATE(chan
))
898 clockMhzScaled
= clockMhzScaled
>> 1;
899 else if (IS_CHAN_QUARTER_RATE(chan
))
900 clockMhzScaled
= clockMhzScaled
>> 2;
903 * ALGO -> coef = 1e8/fcarrier*fclock/40;
904 * scaled coef to provide precision for this floating calculation
906 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
907 coef_scaled
= clockMhzScaled
/ centers
.synth_center
;
909 ath9k_hw_get_delta_slope_vals(ah
, coef_scaled
, &ds_coef_man
,
912 REG_RMW_FIELD(ah
, AR_PHY_TIMING3
,
913 AR_PHY_TIMING3_DSC_MAN
, ds_coef_man
);
914 REG_RMW_FIELD(ah
, AR_PHY_TIMING3
,
915 AR_PHY_TIMING3_DSC_EXP
, ds_coef_exp
);
919 * scaled coeff is 9/10 that of normal coeff
921 coef_scaled
= (9 * coef_scaled
) / 10;
923 ath9k_hw_get_delta_slope_vals(ah
, coef_scaled
, &ds_coef_man
,
927 REG_RMW_FIELD(ah
, AR_PHY_SGI_DELTA
,
928 AR_PHY_SGI_DSC_MAN
, ds_coef_man
);
929 REG_RMW_FIELD(ah
, AR_PHY_SGI_DELTA
,
930 AR_PHY_SGI_DSC_EXP
, ds_coef_exp
);
933 static bool ar9003_hw_rfbus_req(struct ath_hw
*ah
)
935 REG_WRITE(ah
, AR_PHY_RFBUS_REQ
, AR_PHY_RFBUS_REQ_EN
);
936 return ath9k_hw_wait(ah
, AR_PHY_RFBUS_GRANT
, AR_PHY_RFBUS_GRANT_EN
,
937 AR_PHY_RFBUS_GRANT_EN
, AH_WAIT_TIMEOUT
);
941 * Wait for the frequency synth to settle (synth goes on via PHY_ACTIVE_EN).
942 * Read the phy active delay register. Value is in 100ns increments.
944 static void ar9003_hw_rfbus_done(struct ath_hw
*ah
)
946 u32 synthDelay
= REG_READ(ah
, AR_PHY_RX_DELAY
) & AR_PHY_RX_DELAY_DELAY
;
948 ath9k_hw_synth_delay(ah
, ah
->curchan
, synthDelay
);
950 REG_WRITE(ah
, AR_PHY_RFBUS_REQ
, 0);
953 static bool ar9003_hw_ani_control(struct ath_hw
*ah
,
954 enum ath9k_ani_cmd cmd
, int param
)
956 struct ath_common
*common
= ath9k_hw_common(ah
);
957 struct ath9k_channel
*chan
= ah
->curchan
;
958 struct ar5416AniState
*aniState
= &ah
->ani
;
959 int m1ThreshLow
, m2ThreshLow
;
960 int m1Thresh
, m2Thresh
;
961 int m2CountThr
, m2CountThrLow
;
962 int m1ThreshLowExt
, m2ThreshLowExt
;
963 int m1ThreshExt
, m2ThreshExt
;
966 switch (cmd
& ah
->ani_function
) {
967 case ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION
:{
969 * on == 1 means ofdm weak signal detection is ON
970 * on == 1 is the default, for less noise immunity
972 * on == 0 means ofdm weak signal detection is OFF
973 * on == 0 means more noise imm
975 u32 on
= param
? 1 : 0;
977 if (AR_SREV_9462(ah
) || AR_SREV_9565(ah
))
981 aniState
->iniDef
.m1ThreshLow
: m1ThreshLow_off
;
983 aniState
->iniDef
.m2ThreshLow
: m2ThreshLow_off
;
985 aniState
->iniDef
.m1Thresh
: m1Thresh_off
;
987 aniState
->iniDef
.m2Thresh
: m2Thresh_off
;
989 aniState
->iniDef
.m2CountThr
: m2CountThr_off
;
991 aniState
->iniDef
.m2CountThrLow
: m2CountThrLow_off
;
992 m1ThreshLowExt
= on
?
993 aniState
->iniDef
.m1ThreshLowExt
: m1ThreshLowExt_off
;
994 m2ThreshLowExt
= on
?
995 aniState
->iniDef
.m2ThreshLowExt
: m2ThreshLowExt_off
;
997 aniState
->iniDef
.m1ThreshExt
: m1ThreshExt_off
;
999 aniState
->iniDef
.m2ThreshExt
: m2ThreshExt_off
;
1001 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_LOW
,
1002 AR_PHY_SFCORR_LOW_M1_THRESH_LOW
,
1004 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_LOW
,
1005 AR_PHY_SFCORR_LOW_M2_THRESH_LOW
,
1007 REG_RMW_FIELD(ah
, AR_PHY_SFCORR
,
1008 AR_PHY_SFCORR_M1_THRESH
,
1010 REG_RMW_FIELD(ah
, AR_PHY_SFCORR
,
1011 AR_PHY_SFCORR_M2_THRESH
,
1013 REG_RMW_FIELD(ah
, AR_PHY_SFCORR
,
1014 AR_PHY_SFCORR_M2COUNT_THR
,
1016 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_LOW
,
1017 AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW
,
1019 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_EXT
,
1020 AR_PHY_SFCORR_EXT_M1_THRESH_LOW
,
1022 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_EXT
,
1023 AR_PHY_SFCORR_EXT_M2_THRESH_LOW
,
1025 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_EXT
,
1026 AR_PHY_SFCORR_EXT_M1_THRESH
,
1028 REG_RMW_FIELD(ah
, AR_PHY_SFCORR_EXT
,
1029 AR_PHY_SFCORR_EXT_M2_THRESH
,
1033 REG_SET_BIT(ah
, AR_PHY_SFCORR_LOW
,
1034 AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW
);
1036 REG_CLR_BIT(ah
, AR_PHY_SFCORR_LOW
,
1037 AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW
);
1039 if (on
!= aniState
->ofdmWeakSigDetect
) {
1040 ath_dbg(common
, ANI
,
1041 "** ch %d: ofdm weak signal: %s=>%s\n",
1043 aniState
->ofdmWeakSigDetect
?
1047 ah
->stats
.ast_ani_ofdmon
++;
1049 ah
->stats
.ast_ani_ofdmoff
++;
1050 aniState
->ofdmWeakSigDetect
= on
;
1054 case ATH9K_ANI_FIRSTEP_LEVEL
:{
1057 if (level
>= ARRAY_SIZE(firstep_table
)) {
1058 ath_dbg(common
, ANI
,
1059 "ATH9K_ANI_FIRSTEP_LEVEL: level out of range (%u > %zu)\n",
1060 level
, ARRAY_SIZE(firstep_table
));
1065 * make register setting relative to default
1066 * from INI file & cap value
1068 value
= firstep_table
[level
] -
1069 firstep_table
[ATH9K_ANI_FIRSTEP_LVL
] +
1070 aniState
->iniDef
.firstep
;
1071 if (value
< ATH9K_SIG_FIRSTEP_SETTING_MIN
)
1072 value
= ATH9K_SIG_FIRSTEP_SETTING_MIN
;
1073 if (value
> ATH9K_SIG_FIRSTEP_SETTING_MAX
)
1074 value
= ATH9K_SIG_FIRSTEP_SETTING_MAX
;
1075 REG_RMW_FIELD(ah
, AR_PHY_FIND_SIG
,
1076 AR_PHY_FIND_SIG_FIRSTEP
,
1079 * we need to set first step low register too
1080 * make register setting relative to default
1081 * from INI file & cap value
1083 value2
= firstep_table
[level
] -
1084 firstep_table
[ATH9K_ANI_FIRSTEP_LVL
] +
1085 aniState
->iniDef
.firstepLow
;
1086 if (value2
< ATH9K_SIG_FIRSTEP_SETTING_MIN
)
1087 value2
= ATH9K_SIG_FIRSTEP_SETTING_MIN
;
1088 if (value2
> ATH9K_SIG_FIRSTEP_SETTING_MAX
)
1089 value2
= ATH9K_SIG_FIRSTEP_SETTING_MAX
;
1091 REG_RMW_FIELD(ah
, AR_PHY_FIND_SIG_LOW
,
1092 AR_PHY_FIND_SIG_LOW_FIRSTEP_LOW
, value2
);
1094 if (level
!= aniState
->firstepLevel
) {
1095 ath_dbg(common
, ANI
,
1096 "** ch %d: level %d=>%d[def:%d] firstep[level]=%d ini=%d\n",
1098 aniState
->firstepLevel
,
1100 ATH9K_ANI_FIRSTEP_LVL
,
1102 aniState
->iniDef
.firstep
);
1103 ath_dbg(common
, ANI
,
1104 "** ch %d: level %d=>%d[def:%d] firstep_low[level]=%d ini=%d\n",
1106 aniState
->firstepLevel
,
1108 ATH9K_ANI_FIRSTEP_LVL
,
1110 aniState
->iniDef
.firstepLow
);
1111 if (level
> aniState
->firstepLevel
)
1112 ah
->stats
.ast_ani_stepup
++;
1113 else if (level
< aniState
->firstepLevel
)
1114 ah
->stats
.ast_ani_stepdown
++;
1115 aniState
->firstepLevel
= level
;
1119 case ATH9K_ANI_SPUR_IMMUNITY_LEVEL
:{
1122 if (level
>= ARRAY_SIZE(cycpwrThr1_table
)) {
1123 ath_dbg(common
, ANI
,
1124 "ATH9K_ANI_SPUR_IMMUNITY_LEVEL: level out of range (%u > %zu)\n",
1125 level
, ARRAY_SIZE(cycpwrThr1_table
));
1129 * make register setting relative to default
1130 * from INI file & cap value
1132 value
= cycpwrThr1_table
[level
] -
1133 cycpwrThr1_table
[ATH9K_ANI_SPUR_IMMUNE_LVL
] +
1134 aniState
->iniDef
.cycpwrThr1
;
1135 if (value
< ATH9K_SIG_SPUR_IMM_SETTING_MIN
)
1136 value
= ATH9K_SIG_SPUR_IMM_SETTING_MIN
;
1137 if (value
> ATH9K_SIG_SPUR_IMM_SETTING_MAX
)
1138 value
= ATH9K_SIG_SPUR_IMM_SETTING_MAX
;
1139 REG_RMW_FIELD(ah
, AR_PHY_TIMING5
,
1140 AR_PHY_TIMING5_CYCPWR_THR1
,
1144 * set AR_PHY_EXT_CCA for extension channel
1145 * make register setting relative to default
1146 * from INI file & cap value
1148 value2
= cycpwrThr1_table
[level
] -
1149 cycpwrThr1_table
[ATH9K_ANI_SPUR_IMMUNE_LVL
] +
1150 aniState
->iniDef
.cycpwrThr1Ext
;
1151 if (value2
< ATH9K_SIG_SPUR_IMM_SETTING_MIN
)
1152 value2
= ATH9K_SIG_SPUR_IMM_SETTING_MIN
;
1153 if (value2
> ATH9K_SIG_SPUR_IMM_SETTING_MAX
)
1154 value2
= ATH9K_SIG_SPUR_IMM_SETTING_MAX
;
1155 REG_RMW_FIELD(ah
, AR_PHY_EXT_CCA
,
1156 AR_PHY_EXT_CYCPWR_THR1
, value2
);
1158 if (level
!= aniState
->spurImmunityLevel
) {
1159 ath_dbg(common
, ANI
,
1160 "** ch %d: level %d=>%d[def:%d] cycpwrThr1[level]=%d ini=%d\n",
1162 aniState
->spurImmunityLevel
,
1164 ATH9K_ANI_SPUR_IMMUNE_LVL
,
1166 aniState
->iniDef
.cycpwrThr1
);
1167 ath_dbg(common
, ANI
,
1168 "** ch %d: level %d=>%d[def:%d] cycpwrThr1Ext[level]=%d ini=%d\n",
1170 aniState
->spurImmunityLevel
,
1172 ATH9K_ANI_SPUR_IMMUNE_LVL
,
1174 aniState
->iniDef
.cycpwrThr1Ext
);
1175 if (level
> aniState
->spurImmunityLevel
)
1176 ah
->stats
.ast_ani_spurup
++;
1177 else if (level
< aniState
->spurImmunityLevel
)
1178 ah
->stats
.ast_ani_spurdown
++;
1179 aniState
->spurImmunityLevel
= level
;
1183 case ATH9K_ANI_MRC_CCK
:{
1185 * is_on == 1 means MRC CCK ON (default, less noise imm)
1186 * is_on == 0 means MRC CCK is OFF (more noise imm)
1188 bool is_on
= param
? 1 : 0;
1190 if (ah
->caps
.rx_chainmask
== 1)
1193 REG_RMW_FIELD(ah
, AR_PHY_MRC_CCK_CTRL
,
1194 AR_PHY_MRC_CCK_ENABLE
, is_on
);
1195 REG_RMW_FIELD(ah
, AR_PHY_MRC_CCK_CTRL
,
1196 AR_PHY_MRC_CCK_MUX_REG
, is_on
);
1197 if (is_on
!= aniState
->mrcCCK
) {
1198 ath_dbg(common
, ANI
, "** ch %d: MRC CCK: %s=>%s\n",
1200 aniState
->mrcCCK
? "on" : "off",
1201 is_on
? "on" : "off");
1203 ah
->stats
.ast_ani_ccklow
++;
1205 ah
->stats
.ast_ani_cckhigh
++;
1206 aniState
->mrcCCK
= is_on
;
1211 ath_dbg(common
, ANI
, "invalid cmd %u\n", cmd
);
1215 ath_dbg(common
, ANI
,
1216 "ANI parameters: SI=%d, ofdmWS=%s FS=%d MRCcck=%s listenTime=%d ofdmErrs=%d cckErrs=%d\n",
1217 aniState
->spurImmunityLevel
,
1218 aniState
->ofdmWeakSigDetect
? "on" : "off",
1219 aniState
->firstepLevel
,
1220 aniState
->mrcCCK
? "on" : "off",
1221 aniState
->listenTime
,
1222 aniState
->ofdmPhyErrCount
,
1223 aniState
->cckPhyErrCount
);
1227 static void ar9003_hw_do_getnf(struct ath_hw
*ah
,
1228 int16_t nfarray
[NUM_NF_READINGS
])
1230 #define AR_PHY_CH_MINCCA_PWR 0x1FF00000
1231 #define AR_PHY_CH_MINCCA_PWR_S 20
1232 #define AR_PHY_CH_EXT_MINCCA_PWR 0x01FF0000
1233 #define AR_PHY_CH_EXT_MINCCA_PWR_S 16
1238 for (i
= 0; i
< AR9300_MAX_CHAINS
; i
++) {
1239 if (ah
->rxchainmask
& BIT(i
)) {
1240 nf
= MS(REG_READ(ah
, ah
->nf_regs
[i
]),
1241 AR_PHY_CH_MINCCA_PWR
);
1242 nfarray
[i
] = sign_extend32(nf
, 8);
1244 if (IS_CHAN_HT40(ah
->curchan
)) {
1245 u8 ext_idx
= AR9300_MAX_CHAINS
+ i
;
1247 nf
= MS(REG_READ(ah
, ah
->nf_regs
[ext_idx
]),
1248 AR_PHY_CH_EXT_MINCCA_PWR
);
1249 nfarray
[ext_idx
] = sign_extend32(nf
, 8);
1255 static void ar9003_hw_set_nf_limits(struct ath_hw
*ah
)
1257 ah
->nf_2g
.max
= AR_PHY_CCA_MAX_GOOD_VAL_9300_2GHZ
;
1258 ah
->nf_2g
.min
= AR_PHY_CCA_MIN_GOOD_VAL_9300_2GHZ
;
1259 ah
->nf_2g
.nominal
= AR_PHY_CCA_NOM_VAL_9300_2GHZ
;
1260 ah
->nf_5g
.max
= AR_PHY_CCA_MAX_GOOD_VAL_9300_5GHZ
;
1261 ah
->nf_5g
.min
= AR_PHY_CCA_MIN_GOOD_VAL_9300_5GHZ
;
1262 ah
->nf_5g
.nominal
= AR_PHY_CCA_NOM_VAL_9300_5GHZ
;
1264 if (AR_SREV_9330(ah
))
1265 ah
->nf_2g
.nominal
= AR_PHY_CCA_NOM_VAL_9330_2GHZ
;
1267 if (AR_SREV_9462(ah
) || AR_SREV_9565(ah
)) {
1268 ah
->nf_2g
.min
= AR_PHY_CCA_MIN_GOOD_VAL_9462_2GHZ
;
1269 ah
->nf_2g
.nominal
= AR_PHY_CCA_NOM_VAL_9462_2GHZ
;
1270 ah
->nf_5g
.min
= AR_PHY_CCA_MIN_GOOD_VAL_9462_5GHZ
;
1271 ah
->nf_5g
.nominal
= AR_PHY_CCA_NOM_VAL_9462_5GHZ
;
1276 * Initialize the ANI register values with default (ini) values.
1277 * This routine is called during a (full) hardware reset after
1278 * all the registers are initialised from the INI.
1280 static void ar9003_hw_ani_cache_ini_regs(struct ath_hw
*ah
)
1282 struct ar5416AniState
*aniState
;
1283 struct ath_common
*common
= ath9k_hw_common(ah
);
1284 struct ath9k_channel
*chan
= ah
->curchan
;
1285 struct ath9k_ani_default
*iniDef
;
1288 aniState
= &ah
->ani
;
1289 iniDef
= &aniState
->iniDef
;
1291 ath_dbg(common
, ANI
, "ver %d.%d opmode %u chan %d Mhz\n",
1292 ah
->hw_version
.macVersion
,
1293 ah
->hw_version
.macRev
,
1297 val
= REG_READ(ah
, AR_PHY_SFCORR
);
1298 iniDef
->m1Thresh
= MS(val
, AR_PHY_SFCORR_M1_THRESH
);
1299 iniDef
->m2Thresh
= MS(val
, AR_PHY_SFCORR_M2_THRESH
);
1300 iniDef
->m2CountThr
= MS(val
, AR_PHY_SFCORR_M2COUNT_THR
);
1302 val
= REG_READ(ah
, AR_PHY_SFCORR_LOW
);
1303 iniDef
->m1ThreshLow
= MS(val
, AR_PHY_SFCORR_LOW_M1_THRESH_LOW
);
1304 iniDef
->m2ThreshLow
= MS(val
, AR_PHY_SFCORR_LOW_M2_THRESH_LOW
);
1305 iniDef
->m2CountThrLow
= MS(val
, AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW
);
1307 val
= REG_READ(ah
, AR_PHY_SFCORR_EXT
);
1308 iniDef
->m1ThreshExt
= MS(val
, AR_PHY_SFCORR_EXT_M1_THRESH
);
1309 iniDef
->m2ThreshExt
= MS(val
, AR_PHY_SFCORR_EXT_M2_THRESH
);
1310 iniDef
->m1ThreshLowExt
= MS(val
, AR_PHY_SFCORR_EXT_M1_THRESH_LOW
);
1311 iniDef
->m2ThreshLowExt
= MS(val
, AR_PHY_SFCORR_EXT_M2_THRESH_LOW
);
1312 iniDef
->firstep
= REG_READ_FIELD(ah
,
1314 AR_PHY_FIND_SIG_FIRSTEP
);
1315 iniDef
->firstepLow
= REG_READ_FIELD(ah
,
1316 AR_PHY_FIND_SIG_LOW
,
1317 AR_PHY_FIND_SIG_LOW_FIRSTEP_LOW
);
1318 iniDef
->cycpwrThr1
= REG_READ_FIELD(ah
,
1320 AR_PHY_TIMING5_CYCPWR_THR1
);
1321 iniDef
->cycpwrThr1Ext
= REG_READ_FIELD(ah
,
1323 AR_PHY_EXT_CYCPWR_THR1
);
1325 /* these levels just got reset to defaults by the INI */
1326 aniState
->spurImmunityLevel
= ATH9K_ANI_SPUR_IMMUNE_LVL
;
1327 aniState
->firstepLevel
= ATH9K_ANI_FIRSTEP_LVL
;
1328 aniState
->ofdmWeakSigDetect
= true;
1329 aniState
->mrcCCK
= true;
1332 static void ar9003_hw_set_radar_params(struct ath_hw
*ah
,
1333 struct ath_hw_radar_conf
*conf
)
1335 u32 radar_0
= 0, radar_1
= 0;
1338 REG_CLR_BIT(ah
, AR_PHY_RADAR_0
, AR_PHY_RADAR_0_ENA
);
1342 radar_0
|= AR_PHY_RADAR_0_ENA
| AR_PHY_RADAR_0_FFT_ENA
;
1343 radar_0
|= SM(conf
->fir_power
, AR_PHY_RADAR_0_FIRPWR
);
1344 radar_0
|= SM(conf
->radar_rssi
, AR_PHY_RADAR_0_RRSSI
);
1345 radar_0
|= SM(conf
->pulse_height
, AR_PHY_RADAR_0_HEIGHT
);
1346 radar_0
|= SM(conf
->pulse_rssi
, AR_PHY_RADAR_0_PRSSI
);
1347 radar_0
|= SM(conf
->pulse_inband
, AR_PHY_RADAR_0_INBAND
);
1349 radar_1
|= AR_PHY_RADAR_1_MAX_RRSSI
;
1350 radar_1
|= AR_PHY_RADAR_1_BLOCK_CHECK
;
1351 radar_1
|= SM(conf
->pulse_maxlen
, AR_PHY_RADAR_1_MAXLEN
);
1352 radar_1
|= SM(conf
->pulse_inband_step
, AR_PHY_RADAR_1_RELSTEP_THRESH
);
1353 radar_1
|= SM(conf
->radar_inband
, AR_PHY_RADAR_1_RELPWR_THRESH
);
1355 REG_WRITE(ah
, AR_PHY_RADAR_0
, radar_0
);
1356 REG_WRITE(ah
, AR_PHY_RADAR_1
, radar_1
);
1357 if (conf
->ext_channel
)
1358 REG_SET_BIT(ah
, AR_PHY_RADAR_EXT
, AR_PHY_RADAR_EXT_ENA
);
1360 REG_CLR_BIT(ah
, AR_PHY_RADAR_EXT
, AR_PHY_RADAR_EXT_ENA
);
1363 static void ar9003_hw_set_radar_conf(struct ath_hw
*ah
)
1365 struct ath_hw_radar_conf
*conf
= &ah
->radar_conf
;
1367 conf
->fir_power
= -28;
1368 conf
->radar_rssi
= 0;
1369 conf
->pulse_height
= 10;
1370 conf
->pulse_rssi
= 24;
1371 conf
->pulse_inband
= 8;
1372 conf
->pulse_maxlen
= 255;
1373 conf
->pulse_inband_step
= 12;
1374 conf
->radar_inband
= 8;
1377 static void ar9003_hw_antdiv_comb_conf_get(struct ath_hw
*ah
,
1378 struct ath_hw_antcomb_conf
*antconf
)
1382 regval
= REG_READ(ah
, AR_PHY_MC_GAIN_CTRL
);
1383 antconf
->main_lna_conf
= (regval
& AR_PHY_ANT_DIV_MAIN_LNACONF
) >>
1384 AR_PHY_ANT_DIV_MAIN_LNACONF_S
;
1385 antconf
->alt_lna_conf
= (regval
& AR_PHY_ANT_DIV_ALT_LNACONF
) >>
1386 AR_PHY_ANT_DIV_ALT_LNACONF_S
;
1387 antconf
->fast_div_bias
= (regval
& AR_PHY_ANT_FAST_DIV_BIAS
) >>
1388 AR_PHY_ANT_FAST_DIV_BIAS_S
;
1390 if (AR_SREV_9330_11(ah
)) {
1391 antconf
->lna1_lna2_switch_delta
= -1;
1392 antconf
->lna1_lna2_delta
= -9;
1393 antconf
->div_group
= 1;
1394 } else if (AR_SREV_9485(ah
)) {
1395 antconf
->lna1_lna2_switch_delta
= -1;
1396 antconf
->lna1_lna2_delta
= -9;
1397 antconf
->div_group
= 2;
1398 } else if (AR_SREV_9565(ah
)) {
1399 antconf
->lna1_lna2_switch_delta
= 3;
1400 antconf
->lna1_lna2_delta
= -9;
1401 antconf
->div_group
= 3;
1403 antconf
->lna1_lna2_switch_delta
= -1;
1404 antconf
->lna1_lna2_delta
= -3;
1405 antconf
->div_group
= 0;
1409 static void ar9003_hw_antdiv_comb_conf_set(struct ath_hw
*ah
,
1410 struct ath_hw_antcomb_conf
*antconf
)
1414 regval
= REG_READ(ah
, AR_PHY_MC_GAIN_CTRL
);
1415 regval
&= ~(AR_PHY_ANT_DIV_MAIN_LNACONF
|
1416 AR_PHY_ANT_DIV_ALT_LNACONF
|
1417 AR_PHY_ANT_FAST_DIV_BIAS
|
1418 AR_PHY_ANT_DIV_MAIN_GAINTB
|
1419 AR_PHY_ANT_DIV_ALT_GAINTB
);
1420 regval
|= ((antconf
->main_lna_conf
<< AR_PHY_ANT_DIV_MAIN_LNACONF_S
)
1421 & AR_PHY_ANT_DIV_MAIN_LNACONF
);
1422 regval
|= ((antconf
->alt_lna_conf
<< AR_PHY_ANT_DIV_ALT_LNACONF_S
)
1423 & AR_PHY_ANT_DIV_ALT_LNACONF
);
1424 regval
|= ((antconf
->fast_div_bias
<< AR_PHY_ANT_FAST_DIV_BIAS_S
)
1425 & AR_PHY_ANT_FAST_DIV_BIAS
);
1426 regval
|= ((antconf
->main_gaintb
<< AR_PHY_ANT_DIV_MAIN_GAINTB_S
)
1427 & AR_PHY_ANT_DIV_MAIN_GAINTB
);
1428 regval
|= ((antconf
->alt_gaintb
<< AR_PHY_ANT_DIV_ALT_GAINTB_S
)
1429 & AR_PHY_ANT_DIV_ALT_GAINTB
);
1431 REG_WRITE(ah
, AR_PHY_MC_GAIN_CTRL
, regval
);
1434 #ifdef CONFIG_ATH9K_BTCOEX_SUPPORT
1436 static void ar9003_hw_set_bt_ant_diversity(struct ath_hw
*ah
, bool enable
)
1438 struct ath9k_hw_capabilities
*pCap
= &ah
->caps
;
1442 if (!AR_SREV_9485(ah
) && !AR_SREV_9565(ah
))
1445 if (AR_SREV_9485(ah
)) {
1446 regval
= ar9003_hw_ant_ctrl_common_2_get(ah
,
1447 IS_CHAN_2GHZ(ah
->curchan
));
1449 regval
&= ~AR_SWITCH_TABLE_COM2_ALL
;
1450 regval
|= ah
->config
.ant_ctrl_comm2g_switch_enable
;
1452 REG_RMW_FIELD(ah
, AR_PHY_SWITCH_COM_2
,
1453 AR_SWITCH_TABLE_COM2_ALL
, regval
);
1456 ant_div_ctl1
= ah
->eep_ops
->get_eeprom(ah
, EEP_ANT_DIV_CTL1
);
1459 * Set MAIN/ALT LNA conf.
1460 * Set MAIN/ALT gain_tb.
1462 regval
= REG_READ(ah
, AR_PHY_MC_GAIN_CTRL
);
1463 regval
&= (~AR_ANT_DIV_CTRL_ALL
);
1464 regval
|= (ant_div_ctl1
& 0x3f) << AR_ANT_DIV_CTRL_ALL_S
;
1465 REG_WRITE(ah
, AR_PHY_MC_GAIN_CTRL
, regval
);
1467 if (AR_SREV_9485_11_OR_LATER(ah
)) {
1469 * Enable LNA diversity.
1471 regval
= REG_READ(ah
, AR_PHY_MC_GAIN_CTRL
);
1472 regval
&= ~AR_PHY_ANT_DIV_LNADIV
;
1473 regval
|= ((ant_div_ctl1
>> 6) & 0x1) << AR_PHY_ANT_DIV_LNADIV_S
;
1475 regval
|= AR_ANT_DIV_ENABLE
;
1477 REG_WRITE(ah
, AR_PHY_MC_GAIN_CTRL
, regval
);
1480 * Enable fast antenna diversity.
1482 regval
= REG_READ(ah
, AR_PHY_CCK_DETECT
);
1483 regval
&= ~AR_FAST_DIV_ENABLE
;
1484 regval
|= ((ant_div_ctl1
>> 7) & 0x1) << AR_FAST_DIV_ENABLE_S
;
1486 regval
|= AR_FAST_DIV_ENABLE
;
1488 REG_WRITE(ah
, AR_PHY_CCK_DETECT
, regval
);
1490 if (pCap
->hw_caps
& ATH9K_HW_CAP_ANT_DIV_COMB
) {
1491 regval
= REG_READ(ah
, AR_PHY_MC_GAIN_CTRL
);
1492 regval
&= (~(AR_PHY_ANT_DIV_MAIN_LNACONF
|
1493 AR_PHY_ANT_DIV_ALT_LNACONF
|
1494 AR_PHY_ANT_DIV_ALT_GAINTB
|
1495 AR_PHY_ANT_DIV_MAIN_GAINTB
));
1497 * Set MAIN to LNA1 and ALT to LNA2 at the
1500 regval
|= (ATH_ANT_DIV_COMB_LNA1
<<
1501 AR_PHY_ANT_DIV_MAIN_LNACONF_S
);
1502 regval
|= (ATH_ANT_DIV_COMB_LNA2
<<
1503 AR_PHY_ANT_DIV_ALT_LNACONF_S
);
1504 REG_WRITE(ah
, AR_PHY_MC_GAIN_CTRL
, regval
);
1506 } else if (AR_SREV_9565(ah
)) {
1508 REG_SET_BIT(ah
, AR_PHY_MC_GAIN_CTRL
,
1510 REG_SET_BIT(ah
, AR_PHY_MC_GAIN_CTRL
,
1511 (1 << AR_PHY_ANT_SW_RX_PROT_S
));
1512 REG_SET_BIT(ah
, AR_PHY_CCK_DETECT
,
1513 AR_FAST_DIV_ENABLE
);
1514 REG_SET_BIT(ah
, AR_PHY_RESTART
,
1515 AR_PHY_RESTART_ENABLE_DIV_M2FLAG
);
1516 REG_SET_BIT(ah
, AR_BTCOEX_WL_LNADIV
,
1517 AR_BTCOEX_WL_LNADIV_FORCE_ON
);
1519 REG_CLR_BIT(ah
, AR_PHY_MC_GAIN_CTRL
,
1521 REG_CLR_BIT(ah
, AR_PHY_MC_GAIN_CTRL
,
1522 (1 << AR_PHY_ANT_SW_RX_PROT_S
));
1523 REG_CLR_BIT(ah
, AR_PHY_CCK_DETECT
,
1524 AR_FAST_DIV_ENABLE
);
1525 REG_CLR_BIT(ah
, AR_PHY_RESTART
,
1526 AR_PHY_RESTART_ENABLE_DIV_M2FLAG
);
1527 REG_CLR_BIT(ah
, AR_BTCOEX_WL_LNADIV
,
1528 AR_BTCOEX_WL_LNADIV_FORCE_ON
);
1530 regval
= REG_READ(ah
, AR_PHY_MC_GAIN_CTRL
);
1531 regval
&= ~(AR_PHY_ANT_DIV_MAIN_LNACONF
|
1532 AR_PHY_ANT_DIV_ALT_LNACONF
|
1533 AR_PHY_ANT_DIV_MAIN_GAINTB
|
1534 AR_PHY_ANT_DIV_ALT_GAINTB
);
1535 regval
|= (ATH_ANT_DIV_COMB_LNA1
<<
1536 AR_PHY_ANT_DIV_MAIN_LNACONF_S
);
1537 regval
|= (ATH_ANT_DIV_COMB_LNA2
<<
1538 AR_PHY_ANT_DIV_ALT_LNACONF_S
);
1539 REG_WRITE(ah
, AR_PHY_MC_GAIN_CTRL
, regval
);
1546 static int ar9003_hw_fast_chan_change(struct ath_hw
*ah
,
1547 struct ath9k_channel
*chan
,
1550 unsigned int regWrites
= 0;
1553 if (IS_CHAN_5GHZ(chan
))
1554 modesIndex
= IS_CHAN_HT40(chan
) ? 2 : 1;
1556 modesIndex
= IS_CHAN_HT40(chan
) ? 3 : 4;
1558 if (modesIndex
== ah
->modes_index
) {
1559 *ini_reloaded
= false;
1563 ar9003_hw_prog_ini(ah
, &ah
->iniSOC
[ATH_INI_POST
], modesIndex
);
1564 ar9003_hw_prog_ini(ah
, &ah
->iniMac
[ATH_INI_POST
], modesIndex
);
1565 ar9003_hw_prog_ini(ah
, &ah
->iniBB
[ATH_INI_POST
], modesIndex
);
1566 ar9003_hw_prog_ini(ah
, &ah
->iniRadio
[ATH_INI_POST
], modesIndex
);
1568 if (AR_SREV_9462_20_OR_LATER(ah
))
1569 ar9003_hw_prog_ini(ah
, &ah
->ini_radio_post_sys2ant
,
1572 REG_WRITE_ARRAY(&ah
->iniModesTxGain
, modesIndex
, regWrites
);
1574 if (AR_SREV_9462_20_OR_LATER(ah
)) {
1576 * CUS217 mix LNA mode.
1578 if (ar9003_hw_get_rx_gain_idx(ah
) == 2) {
1579 REG_WRITE_ARRAY(&ah
->ini_modes_rxgain_bb_core
,
1581 REG_WRITE_ARRAY(&ah
->ini_modes_rxgain_bb_postamble
,
1582 modesIndex
, regWrites
);
1587 * For 5GHz channels requiring Fast Clock, apply
1588 * different modal values.
1590 if (IS_CHAN_A_FAST_CLOCK(ah
, chan
))
1591 REG_WRITE_ARRAY(&ah
->iniModesFastClock
, modesIndex
, regWrites
);
1593 if (AR_SREV_9565(ah
))
1594 REG_WRITE_ARRAY(&ah
->iniModesFastClock
, 1, regWrites
);
1599 if (chan
->channel
== 2484)
1600 ar9003_hw_prog_ini(ah
, &ah
->iniCckfirJapan2484
, 1);
1602 ah
->modes_index
= modesIndex
;
1603 *ini_reloaded
= true;
1606 ar9003_hw_set_rfmode(ah
, chan
);
1610 static void ar9003_hw_spectral_scan_config(struct ath_hw
*ah
,
1611 struct ath_spec_scan
*param
)
1615 if (!param
->enabled
) {
1616 REG_CLR_BIT(ah
, AR_PHY_SPECTRAL_SCAN
,
1617 AR_PHY_SPECTRAL_SCAN_ENABLE
);
1621 REG_SET_BIT(ah
, AR_PHY_RADAR_0
, AR_PHY_RADAR_0_FFT_ENA
);
1622 REG_SET_BIT(ah
, AR_PHY_SPECTRAL_SCAN
, AR_PHY_SPECTRAL_SCAN_ENABLE
);
1624 /* on AR93xx and newer, count = 0 will make the the chip send
1625 * spectral samples endlessly. Check if this really was intended,
1626 * and fix otherwise.
1628 count
= param
->count
;
1631 else if (param
->count
== 0)
1634 if (param
->short_repeat
)
1635 REG_SET_BIT(ah
, AR_PHY_SPECTRAL_SCAN
,
1636 AR_PHY_SPECTRAL_SCAN_SHORT_REPEAT
);
1638 REG_CLR_BIT(ah
, AR_PHY_SPECTRAL_SCAN
,
1639 AR_PHY_SPECTRAL_SCAN_SHORT_REPEAT
);
1641 REG_RMW_FIELD(ah
, AR_PHY_SPECTRAL_SCAN
,
1642 AR_PHY_SPECTRAL_SCAN_COUNT
, count
);
1643 REG_RMW_FIELD(ah
, AR_PHY_SPECTRAL_SCAN
,
1644 AR_PHY_SPECTRAL_SCAN_PERIOD
, param
->period
);
1645 REG_RMW_FIELD(ah
, AR_PHY_SPECTRAL_SCAN
,
1646 AR_PHY_SPECTRAL_SCAN_FFT_PERIOD
, param
->fft_period
);
1651 static void ar9003_hw_spectral_scan_trigger(struct ath_hw
*ah
)
1653 /* Activate spectral scan */
1654 REG_SET_BIT(ah
, AR_PHY_SPECTRAL_SCAN
,
1655 AR_PHY_SPECTRAL_SCAN_ACTIVE
);
1658 static void ar9003_hw_spectral_scan_wait(struct ath_hw
*ah
)
1660 struct ath_common
*common
= ath9k_hw_common(ah
);
1662 /* Poll for spectral scan complete */
1663 if (!ath9k_hw_wait(ah
, AR_PHY_SPECTRAL_SCAN
,
1664 AR_PHY_SPECTRAL_SCAN_ACTIVE
,
1665 0, AH_WAIT_TIMEOUT
)) {
1666 ath_err(common
, "spectral scan wait failed\n");
1671 static void ar9003_hw_tx99_start(struct ath_hw
*ah
, u32 qnum
)
1673 REG_SET_BIT(ah
, AR_PHY_TEST
, PHY_AGC_CLR
);
1674 REG_SET_BIT(ah
, 0x9864, 0x7f000);
1675 REG_SET_BIT(ah
, 0x9924, 0x7f00fe);
1676 REG_CLR_BIT(ah
, AR_DIAG_SW
, AR_DIAG_RX_DIS
);
1677 REG_WRITE(ah
, AR_CR
, AR_CR_RXD
);
1678 REG_WRITE(ah
, AR_DLCL_IFS(qnum
), 0);
1679 REG_WRITE(ah
, AR_D_GBL_IFS_SIFS
, 20); /* 50 OK */
1680 REG_WRITE(ah
, AR_D_GBL_IFS_EIFS
, 20);
1681 REG_WRITE(ah
, AR_TIME_OUT
, 0x00000400);
1682 REG_WRITE(ah
, AR_DRETRY_LIMIT(qnum
), 0xffffffff);
1683 REG_SET_BIT(ah
, AR_QMISC(qnum
), AR_Q_MISC_DCU_EARLY_TERM_REQ
);
1686 static void ar9003_hw_tx99_stop(struct ath_hw
*ah
)
1688 REG_CLR_BIT(ah
, AR_PHY_TEST
, PHY_AGC_CLR
);
1689 REG_SET_BIT(ah
, AR_DIAG_SW
, AR_DIAG_RX_DIS
);
1692 static void ar9003_hw_tx99_set_txpower(struct ath_hw
*ah
, u8 txpower
)
1694 static s16 p_pwr_array
[ar9300RateSize
] = { 0 };
1697 if (txpower
<= MAX_RATE_POWER
) {
1698 for (i
= 0; i
< ar9300RateSize
; i
++)
1699 p_pwr_array
[i
] = txpower
;
1701 for (i
= 0; i
< ar9300RateSize
; i
++)
1702 p_pwr_array
[i
] = MAX_RATE_POWER
;
1705 REG_WRITE(ah
, 0xa458, 0);
1707 REG_WRITE(ah
, 0xa3c0,
1708 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_6_24
], 24) |
1709 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_6_24
], 16) |
1710 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_6_24
], 8) |
1711 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_6_24
], 0));
1712 REG_WRITE(ah
, 0xa3c4,
1713 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_54
], 24) |
1714 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_48
], 16) |
1715 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_36
], 8) |
1716 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_6_24
], 0));
1717 REG_WRITE(ah
, 0xa3c8,
1718 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_1L_5L
], 24) |
1719 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_1L_5L
], 16) |
1720 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_1L_5L
], 0));
1721 REG_WRITE(ah
, 0xa3cc,
1722 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_11S
], 24) |
1723 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_11L
], 16) |
1724 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_5S
], 8) |
1725 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_LEGACY_1L_5L
], 0));
1726 REG_WRITE(ah
, 0xa3d0,
1727 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_5
], 24) |
1728 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_4
], 16) |
1729 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_1_3_9_11_17_19
], 8)|
1730 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_0_8_16
], 0));
1731 REG_WRITE(ah
, 0xa3d4,
1732 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_13
], 24) |
1733 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_12
], 16) |
1734 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_7
], 8) |
1735 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_6
], 0));
1736 REG_WRITE(ah
, 0xa3e4,
1737 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_21
], 24) |
1738 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_20
], 16) |
1739 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_15
], 8) |
1740 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_14
], 0));
1741 REG_WRITE(ah
, 0xa3e8,
1742 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_23
], 24) |
1743 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_22
], 16) |
1744 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_23
], 8) |
1745 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT20_22
], 0));
1746 REG_WRITE(ah
, 0xa3d8,
1747 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_5
], 24) |
1748 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_4
], 16) |
1749 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_1_3_9_11_17_19
], 8) |
1750 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_0_8_16
], 0));
1751 REG_WRITE(ah
, 0xa3dc,
1752 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_13
], 24) |
1753 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_12
], 16) |
1754 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_7
], 8) |
1755 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_6
], 0));
1756 REG_WRITE(ah
, 0xa3ec,
1757 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_21
], 24) |
1758 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_20
], 16) |
1759 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_15
], 8) |
1760 ATH9K_POW_SM(p_pwr_array
[ALL_TARGET_HT40_14
], 0));
1763 void ar9003_hw_attach_phy_ops(struct ath_hw
*ah
)
1765 struct ath_hw_private_ops
*priv_ops
= ath9k_hw_private_ops(ah
);
1766 struct ath_hw_ops
*ops
= ath9k_hw_ops(ah
);
1767 static const u32 ar9300_cca_regs
[6] = {
1776 priv_ops
->rf_set_freq
= ar9003_hw_set_channel
;
1777 priv_ops
->spur_mitigate_freq
= ar9003_hw_spur_mitigate
;
1778 priv_ops
->compute_pll_control
= ar9003_hw_compute_pll_control
;
1779 priv_ops
->set_channel_regs
= ar9003_hw_set_channel_regs
;
1780 priv_ops
->init_bb
= ar9003_hw_init_bb
;
1781 priv_ops
->process_ini
= ar9003_hw_process_ini
;
1782 priv_ops
->set_rfmode
= ar9003_hw_set_rfmode
;
1783 priv_ops
->mark_phy_inactive
= ar9003_hw_mark_phy_inactive
;
1784 priv_ops
->set_delta_slope
= ar9003_hw_set_delta_slope
;
1785 priv_ops
->rfbus_req
= ar9003_hw_rfbus_req
;
1786 priv_ops
->rfbus_done
= ar9003_hw_rfbus_done
;
1787 priv_ops
->ani_control
= ar9003_hw_ani_control
;
1788 priv_ops
->do_getnf
= ar9003_hw_do_getnf
;
1789 priv_ops
->ani_cache_ini_regs
= ar9003_hw_ani_cache_ini_regs
;
1790 priv_ops
->set_radar_params
= ar9003_hw_set_radar_params
;
1791 priv_ops
->fast_chan_change
= ar9003_hw_fast_chan_change
;
1793 ops
->antdiv_comb_conf_get
= ar9003_hw_antdiv_comb_conf_get
;
1794 ops
->antdiv_comb_conf_set
= ar9003_hw_antdiv_comb_conf_set
;
1795 ops
->spectral_scan_config
= ar9003_hw_spectral_scan_config
;
1796 ops
->spectral_scan_trigger
= ar9003_hw_spectral_scan_trigger
;
1797 ops
->spectral_scan_wait
= ar9003_hw_spectral_scan_wait
;
1799 #ifdef CONFIG_ATH9K_BTCOEX_SUPPORT
1800 ops
->set_bt_ant_diversity
= ar9003_hw_set_bt_ant_diversity
;
1802 ops
->tx99_start
= ar9003_hw_tx99_start
;
1803 ops
->tx99_stop
= ar9003_hw_tx99_stop
;
1804 ops
->tx99_set_txpower
= ar9003_hw_tx99_set_txpower
;
1806 ar9003_hw_set_nf_limits(ah
);
1807 ar9003_hw_set_radar_conf(ah
);
1808 memcpy(ah
->nf_regs
, ar9300_cca_regs
, sizeof(ah
->nf_regs
));
1811 void ar9003_hw_bb_watchdog_config(struct ath_hw
*ah
)
1813 struct ath_common
*common
= ath9k_hw_common(ah
);
1814 u32 idle_tmo_ms
= ah
->bb_watchdog_timeout_ms
;
1815 u32 val
, idle_count
;
1818 /* disable IRQ, disable chip-reset for BB panic */
1819 REG_WRITE(ah
, AR_PHY_WATCHDOG_CTL_2
,
1820 REG_READ(ah
, AR_PHY_WATCHDOG_CTL_2
) &
1821 ~(AR_PHY_WATCHDOG_RST_ENABLE
|
1822 AR_PHY_WATCHDOG_IRQ_ENABLE
));
1824 /* disable watchdog in non-IDLE mode, disable in IDLE mode */
1825 REG_WRITE(ah
, AR_PHY_WATCHDOG_CTL_1
,
1826 REG_READ(ah
, AR_PHY_WATCHDOG_CTL_1
) &
1827 ~(AR_PHY_WATCHDOG_NON_IDLE_ENABLE
|
1828 AR_PHY_WATCHDOG_IDLE_ENABLE
));
1830 ath_dbg(common
, RESET
, "Disabled BB Watchdog\n");
1834 /* enable IRQ, disable chip-reset for BB watchdog */
1835 val
= REG_READ(ah
, AR_PHY_WATCHDOG_CTL_2
) & AR_PHY_WATCHDOG_CNTL2_MASK
;
1836 REG_WRITE(ah
, AR_PHY_WATCHDOG_CTL_2
,
1837 (val
| AR_PHY_WATCHDOG_IRQ_ENABLE
) &
1838 ~AR_PHY_WATCHDOG_RST_ENABLE
);
1840 /* bound limit to 10 secs */
1841 if (idle_tmo_ms
> 10000)
1842 idle_tmo_ms
= 10000;
1845 * The time unit for watchdog event is 2^15 44/88MHz cycles.
1847 * For HT20 we have a time unit of 2^15/44 MHz = .74 ms per tick
1848 * For HT40 we have a time unit of 2^15/88 MHz = .37 ms per tick
1850 * Given we use fast clock now in 5 GHz, these time units should
1851 * be common for both 2 GHz and 5 GHz.
1853 idle_count
= (100 * idle_tmo_ms
) / 74;
1854 if (ah
->curchan
&& IS_CHAN_HT40(ah
->curchan
))
1855 idle_count
= (100 * idle_tmo_ms
) / 37;
1858 * enable watchdog in non-IDLE mode, disable in IDLE mode,
1859 * set idle time-out.
1861 REG_WRITE(ah
, AR_PHY_WATCHDOG_CTL_1
,
1862 AR_PHY_WATCHDOG_NON_IDLE_ENABLE
|
1863 AR_PHY_WATCHDOG_IDLE_MASK
|
1864 (AR_PHY_WATCHDOG_NON_IDLE_MASK
& (idle_count
<< 2)));
1866 ath_dbg(common
, RESET
, "Enabled BB Watchdog timeout (%u ms)\n",
1870 void ar9003_hw_bb_watchdog_read(struct ath_hw
*ah
)
1873 * we want to avoid printing in ISR context so we save the
1874 * watchdog status to be printed later in bottom half context.
1876 ah
->bb_watchdog_last_status
= REG_READ(ah
, AR_PHY_WATCHDOG_STATUS
);
1879 * the watchdog timer should reset on status read but to be sure
1880 * sure we write 0 to the watchdog status bit.
1882 REG_WRITE(ah
, AR_PHY_WATCHDOG_STATUS
,
1883 ah
->bb_watchdog_last_status
& ~AR_PHY_WATCHDOG_STATUS_CLR
);
1886 void ar9003_hw_bb_watchdog_dbg_info(struct ath_hw
*ah
)
1888 struct ath_common
*common
= ath9k_hw_common(ah
);
1891 if (likely(!(common
->debug_mask
& ATH_DBG_RESET
)))
1894 status
= ah
->bb_watchdog_last_status
;
1895 ath_dbg(common
, RESET
,
1896 "\n==== BB update: BB status=0x%08x ====\n", status
);
1897 ath_dbg(common
, RESET
,
1898 "** BB state: wd=%u det=%u rdar=%u rOFDM=%d rCCK=%u tOFDM=%u tCCK=%u agc=%u src=%u **\n",
1899 MS(status
, AR_PHY_WATCHDOG_INFO
),
1900 MS(status
, AR_PHY_WATCHDOG_DET_HANG
),
1901 MS(status
, AR_PHY_WATCHDOG_RADAR_SM
),
1902 MS(status
, AR_PHY_WATCHDOG_RX_OFDM_SM
),
1903 MS(status
, AR_PHY_WATCHDOG_RX_CCK_SM
),
1904 MS(status
, AR_PHY_WATCHDOG_TX_OFDM_SM
),
1905 MS(status
, AR_PHY_WATCHDOG_TX_CCK_SM
),
1906 MS(status
, AR_PHY_WATCHDOG_AGC_SM
),
1907 MS(status
, AR_PHY_WATCHDOG_SRCH_SM
));
1909 ath_dbg(common
, RESET
, "** BB WD cntl: cntl1=0x%08x cntl2=0x%08x **\n",
1910 REG_READ(ah
, AR_PHY_WATCHDOG_CTL_1
),
1911 REG_READ(ah
, AR_PHY_WATCHDOG_CTL_2
));
1912 ath_dbg(common
, RESET
, "** BB mode: BB_gen_controls=0x%08x **\n",
1913 REG_READ(ah
, AR_PHY_GEN_CTRL
));
1915 #define PCT(_field) (common->cc_survey._field * 100 / common->cc_survey.cycles)
1916 if (common
->cc_survey
.cycles
)
1917 ath_dbg(common
, RESET
,
1918 "** BB busy times: rx_clear=%d%%, rx_frame=%d%%, tx_frame=%d%% **\n",
1919 PCT(rx_busy
), PCT(rx_frame
), PCT(tx_frame
));
1921 ath_dbg(common
, RESET
, "==== BB update: done ====\n\n");
1923 EXPORT_SYMBOL(ar9003_hw_bb_watchdog_dbg_info
);
1925 void ar9003_hw_disable_phy_restart(struct ath_hw
*ah
)
1929 /* While receiving unsupported rate frame rx state machine
1930 * gets into a state 0xb and if phy_restart happens in that
1931 * state, BB would go hang. If RXSM is in 0xb state after
1932 * first bb panic, ensure to disable the phy_restart.
1934 if (!((MS(ah
->bb_watchdog_last_status
,
1935 AR_PHY_WATCHDOG_RX_OFDM_SM
) == 0xb) ||
1936 ah
->bb_hang_rx_ofdm
))
1939 ah
->bb_hang_rx_ofdm
= true;
1940 val
= REG_READ(ah
, AR_PHY_RESTART
);
1941 val
&= ~AR_PHY_RESTART_ENA
;
1943 REG_WRITE(ah
, AR_PHY_RESTART
, val
);
1945 EXPORT_SYMBOL(ar9003_hw_disable_phy_restart
);