2 * Copyright (c) 2008-2009 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>
23 static int btcoex_enable
;
24 module_param(btcoex_enable
, bool, 0);
25 MODULE_PARM_DESC(btcoex_enable
, "Enable Bluetooth coexistence support");
27 #define ATH9K_CLOCK_RATE_CCK 22
28 #define ATH9K_CLOCK_RATE_5GHZ_OFDM 40
29 #define ATH9K_CLOCK_RATE_2GHZ_OFDM 44
31 static bool ath9k_hw_set_reset_reg(struct ath_hw
*ah
, u32 type
);
32 static void ath9k_hw_set_regs(struct ath_hw
*ah
, struct ath9k_channel
*chan
,
33 enum ath9k_ht_macmode macmode
);
34 static u32
ath9k_hw_ini_fixup(struct ath_hw
*ah
,
35 struct ar5416_eeprom_def
*pEepData
,
37 static void ath9k_hw_9280_spur_mitigate(struct ath_hw
*ah
, struct ath9k_channel
*chan
);
38 static void ath9k_hw_spur_mitigate(struct ath_hw
*ah
, struct ath9k_channel
*chan
);
40 /********************/
41 /* Helper Functions */
42 /********************/
44 static u32
ath9k_hw_mac_usec(struct ath_hw
*ah
, u32 clks
)
46 struct ieee80211_conf
*conf
= &ah
->ah_sc
->hw
->conf
;
48 if (!ah
->curchan
) /* should really check for CCK instead */
49 return clks
/ ATH9K_CLOCK_RATE_CCK
;
50 if (conf
->channel
->band
== IEEE80211_BAND_2GHZ
)
51 return clks
/ ATH9K_CLOCK_RATE_2GHZ_OFDM
;
53 return clks
/ ATH9K_CLOCK_RATE_5GHZ_OFDM
;
56 static u32
ath9k_hw_mac_to_usec(struct ath_hw
*ah
, u32 clks
)
58 struct ieee80211_conf
*conf
= &ah
->ah_sc
->hw
->conf
;
60 if (conf_is_ht40(conf
))
61 return ath9k_hw_mac_usec(ah
, clks
) / 2;
63 return ath9k_hw_mac_usec(ah
, clks
);
66 static u32
ath9k_hw_mac_clks(struct ath_hw
*ah
, u32 usecs
)
68 struct ieee80211_conf
*conf
= &ah
->ah_sc
->hw
->conf
;
70 if (!ah
->curchan
) /* should really check for CCK instead */
71 return usecs
*ATH9K_CLOCK_RATE_CCK
;
72 if (conf
->channel
->band
== IEEE80211_BAND_2GHZ
)
73 return usecs
*ATH9K_CLOCK_RATE_2GHZ_OFDM
;
74 return usecs
*ATH9K_CLOCK_RATE_5GHZ_OFDM
;
77 static u32
ath9k_hw_mac_to_clks(struct ath_hw
*ah
, u32 usecs
)
79 struct ieee80211_conf
*conf
= &ah
->ah_sc
->hw
->conf
;
81 if (conf_is_ht40(conf
))
82 return ath9k_hw_mac_clks(ah
, usecs
) * 2;
84 return ath9k_hw_mac_clks(ah
, usecs
);
88 * Read and write, they both share the same lock. We do this to serialize
89 * reads and writes on Atheros 802.11n PCI devices only. This is required
90 * as the FIFO on these devices can only accept sanely 2 requests. After
91 * that the device goes bananas. Serializing the reads/writes prevents this
95 void ath9k_iowrite32(struct ath_hw
*ah
, u32 reg_offset
, u32 val
)
97 if (ah
->config
.serialize_regmode
== SER_REG_MODE_ON
) {
99 spin_lock_irqsave(&ah
->ah_sc
->sc_serial_rw
, flags
);
100 iowrite32(val
, ah
->ah_sc
->mem
+ reg_offset
);
101 spin_unlock_irqrestore(&ah
->ah_sc
->sc_serial_rw
, flags
);
103 iowrite32(val
, ah
->ah_sc
->mem
+ reg_offset
);
106 unsigned int ath9k_ioread32(struct ath_hw
*ah
, u32 reg_offset
)
109 if (ah
->config
.serialize_regmode
== SER_REG_MODE_ON
) {
111 spin_lock_irqsave(&ah
->ah_sc
->sc_serial_rw
, flags
);
112 val
= ioread32(ah
->ah_sc
->mem
+ reg_offset
);
113 spin_unlock_irqrestore(&ah
->ah_sc
->sc_serial_rw
, flags
);
115 val
= ioread32(ah
->ah_sc
->mem
+ reg_offset
);
119 bool ath9k_hw_wait(struct ath_hw
*ah
, u32 reg
, u32 mask
, u32 val
, u32 timeout
)
123 BUG_ON(timeout
< AH_TIME_QUANTUM
);
125 for (i
= 0; i
< (timeout
/ AH_TIME_QUANTUM
); i
++) {
126 if ((REG_READ(ah
, reg
) & mask
) == val
)
129 udelay(AH_TIME_QUANTUM
);
132 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
133 "timeout (%d us) on reg 0x%x: 0x%08x & 0x%08x != 0x%08x\n",
134 timeout
, reg
, REG_READ(ah
, reg
), mask
, val
);
139 u32
ath9k_hw_reverse_bits(u32 val
, u32 n
)
144 for (i
= 0, retval
= 0; i
< n
; i
++) {
145 retval
= (retval
<< 1) | (val
& 1);
151 bool ath9k_get_channel_edges(struct ath_hw
*ah
,
155 struct ath9k_hw_capabilities
*pCap
= &ah
->caps
;
157 if (flags
& CHANNEL_5GHZ
) {
158 *low
= pCap
->low_5ghz_chan
;
159 *high
= pCap
->high_5ghz_chan
;
162 if ((flags
& CHANNEL_2GHZ
)) {
163 *low
= pCap
->low_2ghz_chan
;
164 *high
= pCap
->high_2ghz_chan
;
170 u16
ath9k_hw_computetxtime(struct ath_hw
*ah
,
171 const struct ath_rate_table
*rates
,
172 u32 frameLen
, u16 rateix
,
175 u32 bitsPerSymbol
, numBits
, numSymbols
, phyTime
, txTime
;
178 kbps
= rates
->info
[rateix
].ratekbps
;
183 switch (rates
->info
[rateix
].phy
) {
184 case WLAN_RC_PHY_CCK
:
185 phyTime
= CCK_PREAMBLE_BITS
+ CCK_PLCP_BITS
;
186 if (shortPreamble
&& rates
->info
[rateix
].short_preamble
)
188 numBits
= frameLen
<< 3;
189 txTime
= CCK_SIFS_TIME
+ phyTime
+ ((numBits
* 1000) / kbps
);
191 case WLAN_RC_PHY_OFDM
:
192 if (ah
->curchan
&& IS_CHAN_QUARTER_RATE(ah
->curchan
)) {
193 bitsPerSymbol
= (kbps
* OFDM_SYMBOL_TIME_QUARTER
) / 1000;
194 numBits
= OFDM_PLCP_BITS
+ (frameLen
<< 3);
195 numSymbols
= DIV_ROUND_UP(numBits
, bitsPerSymbol
);
196 txTime
= OFDM_SIFS_TIME_QUARTER
197 + OFDM_PREAMBLE_TIME_QUARTER
198 + (numSymbols
* OFDM_SYMBOL_TIME_QUARTER
);
199 } else if (ah
->curchan
&&
200 IS_CHAN_HALF_RATE(ah
->curchan
)) {
201 bitsPerSymbol
= (kbps
* OFDM_SYMBOL_TIME_HALF
) / 1000;
202 numBits
= OFDM_PLCP_BITS
+ (frameLen
<< 3);
203 numSymbols
= DIV_ROUND_UP(numBits
, bitsPerSymbol
);
204 txTime
= OFDM_SIFS_TIME_HALF
+
205 OFDM_PREAMBLE_TIME_HALF
206 + (numSymbols
* OFDM_SYMBOL_TIME_HALF
);
208 bitsPerSymbol
= (kbps
* OFDM_SYMBOL_TIME
) / 1000;
209 numBits
= OFDM_PLCP_BITS
+ (frameLen
<< 3);
210 numSymbols
= DIV_ROUND_UP(numBits
, bitsPerSymbol
);
211 txTime
= OFDM_SIFS_TIME
+ OFDM_PREAMBLE_TIME
212 + (numSymbols
* OFDM_SYMBOL_TIME
);
216 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
217 "Unknown phy %u (rate ix %u)\n",
218 rates
->info
[rateix
].phy
, rateix
);
226 void ath9k_hw_get_channel_centers(struct ath_hw
*ah
,
227 struct ath9k_channel
*chan
,
228 struct chan_centers
*centers
)
232 if (!IS_CHAN_HT40(chan
)) {
233 centers
->ctl_center
= centers
->ext_center
=
234 centers
->synth_center
= chan
->channel
;
238 if ((chan
->chanmode
== CHANNEL_A_HT40PLUS
) ||
239 (chan
->chanmode
== CHANNEL_G_HT40PLUS
)) {
240 centers
->synth_center
=
241 chan
->channel
+ HT40_CHANNEL_CENTER_SHIFT
;
244 centers
->synth_center
=
245 chan
->channel
- HT40_CHANNEL_CENTER_SHIFT
;
249 centers
->ctl_center
=
250 centers
->synth_center
- (extoff
* HT40_CHANNEL_CENTER_SHIFT
);
251 centers
->ext_center
=
252 centers
->synth_center
+ (extoff
*
253 ((ah
->extprotspacing
== ATH9K_HT_EXTPROTSPACING_20
) ?
254 HT40_CHANNEL_CENTER_SHIFT
: 15));
261 static void ath9k_hw_read_revisions(struct ath_hw
*ah
)
265 val
= REG_READ(ah
, AR_SREV
) & AR_SREV_ID
;
268 val
= REG_READ(ah
, AR_SREV
);
269 ah
->hw_version
.macVersion
=
270 (val
& AR_SREV_VERSION2
) >> AR_SREV_TYPE2_S
;
271 ah
->hw_version
.macRev
= MS(val
, AR_SREV_REVISION2
);
272 ah
->is_pciexpress
= (val
& AR_SREV_TYPE2_HOST_MODE
) ? 0 : 1;
274 if (!AR_SREV_9100(ah
))
275 ah
->hw_version
.macVersion
= MS(val
, AR_SREV_VERSION
);
277 ah
->hw_version
.macRev
= val
& AR_SREV_REVISION
;
279 if (ah
->hw_version
.macVersion
== AR_SREV_VERSION_5416_PCIE
)
280 ah
->is_pciexpress
= true;
284 static int ath9k_hw_get_radiorev(struct ath_hw
*ah
)
289 REG_WRITE(ah
, AR_PHY(0x36), 0x00007058);
291 for (i
= 0; i
< 8; i
++)
292 REG_WRITE(ah
, AR_PHY(0x20), 0x00010000);
293 val
= (REG_READ(ah
, AR_PHY(256)) >> 24) & 0xff;
294 val
= ((val
& 0xf0) >> 4) | ((val
& 0x0f) << 4);
296 return ath9k_hw_reverse_bits(val
, 8);
299 /************************************/
300 /* HW Attach, Detach, Init Routines */
301 /************************************/
303 static void ath9k_hw_disablepcie(struct ath_hw
*ah
)
305 if (AR_SREV_9100(ah
))
308 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x9248fc00);
309 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x24924924);
310 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x28000029);
311 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x57160824);
312 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x25980579);
313 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x00000000);
314 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x1aaabe40);
315 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xbe105554);
316 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x000e1007);
318 REG_WRITE(ah
, AR_PCIE_SERDES2
, 0x00000000);
321 static bool ath9k_hw_chip_test(struct ath_hw
*ah
)
323 u32 regAddr
[2] = { AR_STA_ID0
, AR_PHY_BASE
+ (8 << 2) };
325 u32 patternData
[4] = { 0x55555555,
331 for (i
= 0; i
< 2; i
++) {
332 u32 addr
= regAddr
[i
];
335 regHold
[i
] = REG_READ(ah
, addr
);
336 for (j
= 0; j
< 0x100; j
++) {
337 wrData
= (j
<< 16) | j
;
338 REG_WRITE(ah
, addr
, wrData
);
339 rdData
= REG_READ(ah
, addr
);
340 if (rdData
!= wrData
) {
341 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
342 "address test failed "
343 "addr: 0x%08x - wr:0x%08x != rd:0x%08x\n",
344 addr
, wrData
, rdData
);
348 for (j
= 0; j
< 4; j
++) {
349 wrData
= patternData
[j
];
350 REG_WRITE(ah
, addr
, wrData
);
351 rdData
= REG_READ(ah
, addr
);
352 if (wrData
!= rdData
) {
353 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
354 "address test failed "
355 "addr: 0x%08x - wr:0x%08x != rd:0x%08x\n",
356 addr
, wrData
, rdData
);
360 REG_WRITE(ah
, regAddr
[i
], regHold
[i
]);
367 static const char *ath9k_hw_devname(u16 devid
)
370 case AR5416_DEVID_PCI
:
371 return "Atheros 5416";
372 case AR5416_DEVID_PCIE
:
373 return "Atheros 5418";
374 case AR9160_DEVID_PCI
:
375 return "Atheros 9160";
376 case AR5416_AR9100_DEVID
:
377 return "Atheros 9100";
378 case AR9280_DEVID_PCI
:
379 case AR9280_DEVID_PCIE
:
380 return "Atheros 9280";
381 case AR9285_DEVID_PCIE
:
382 return "Atheros 9285";
388 static void ath9k_hw_set_defaults(struct ath_hw
*ah
)
392 ah
->config
.dma_beacon_response_time
= 2;
393 ah
->config
.sw_beacon_response_time
= 10;
394 ah
->config
.additional_swba_backoff
= 0;
395 ah
->config
.ack_6mb
= 0x0;
396 ah
->config
.cwm_ignore_extcca
= 0;
397 ah
->config
.pcie_powersave_enable
= 0;
398 ah
->config
.pcie_clock_req
= 0;
399 ah
->config
.pcie_waen
= 0;
400 ah
->config
.analog_shiftreg
= 1;
401 ah
->config
.ht_enable
= 1;
402 ah
->config
.ofdm_trig_low
= 200;
403 ah
->config
.ofdm_trig_high
= 500;
404 ah
->config
.cck_trig_high
= 200;
405 ah
->config
.cck_trig_low
= 100;
406 ah
->config
.enable_ani
= 1;
407 ah
->config
.diversity_control
= 0;
408 ah
->config
.antenna_switch_swap
= 0;
410 for (i
= 0; i
< AR_EEPROM_MODAL_SPURS
; i
++) {
411 ah
->config
.spurchans
[i
][0] = AR_NO_SPUR
;
412 ah
->config
.spurchans
[i
][1] = AR_NO_SPUR
;
415 ah
->config
.intr_mitigation
= true;
418 * We need this for PCI devices only (Cardbus, PCI, miniPCI)
419 * _and_ if on non-uniprocessor systems (Multiprocessor/HT).
420 * This means we use it for all AR5416 devices, and the few
421 * minor PCI AR9280 devices out there.
423 * Serialization is required because these devices do not handle
424 * well the case of two concurrent reads/writes due to the latency
425 * involved. During one read/write another read/write can be issued
426 * on another CPU while the previous read/write may still be working
427 * on our hardware, if we hit this case the hardware poops in a loop.
428 * We prevent this by serializing reads and writes.
430 * This issue is not present on PCI-Express devices or pre-AR5416
431 * devices (legacy, 802.11abg).
433 if (num_possible_cpus() > 1)
434 ah
->config
.serialize_regmode
= SER_REG_MODE_AUTO
;
437 static struct ath_hw
*ath9k_hw_newstate(u16 devid
, struct ath_softc
*sc
,
442 ah
= kzalloc(sizeof(struct ath_hw
), GFP_KERNEL
);
444 DPRINTF(sc
, ATH_DBG_FATAL
,
445 "Cannot allocate memory for state block\n");
451 ah
->hw_version
.magic
= AR5416_MAGIC
;
452 ah
->regulatory
.country_code
= CTRY_DEFAULT
;
453 ah
->hw_version
.devid
= devid
;
454 ah
->hw_version
.subvendorid
= 0;
457 if ((devid
== AR5416_AR9100_DEVID
))
458 ah
->hw_version
.macVersion
= AR_SREV_VERSION_9100
;
459 if (!AR_SREV_9100(ah
))
460 ah
->ah_flags
= AH_USE_EEPROM
;
462 ah
->regulatory
.power_limit
= MAX_RATE_POWER
;
463 ah
->regulatory
.tp_scale
= ATH9K_TP_SCALE_MAX
;
465 ah
->diversity_control
= ah
->config
.diversity_control
;
466 ah
->antenna_switch_swap
=
467 ah
->config
.antenna_switch_swap
;
468 ah
->sta_id1_defaults
= AR_STA_ID1_CRPT_MIC_ENABLE
;
469 ah
->beacon_interval
= 100;
470 ah
->enable_32kHz_clock
= DONT_USE_32KHZ
;
471 ah
->slottime
= (u32
) -1;
472 ah
->acktimeout
= (u32
) -1;
473 ah
->ctstimeout
= (u32
) -1;
474 ah
->globaltxtimeout
= (u32
) -1;
476 ah
->gbeacon_rate
= 0;
481 static int ath9k_hw_rfattach(struct ath_hw
*ah
)
483 bool rfStatus
= false;
486 rfStatus
= ath9k_hw_init_rf(ah
, &ecode
);
488 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
489 "RF setup failed, status: %u\n", ecode
);
496 static int ath9k_hw_rf_claim(struct ath_hw
*ah
)
500 REG_WRITE(ah
, AR_PHY(0), 0x00000007);
502 val
= ath9k_hw_get_radiorev(ah
);
503 switch (val
& AR_RADIO_SREV_MAJOR
) {
505 val
= AR_RAD5133_SREV_MAJOR
;
507 case AR_RAD5133_SREV_MAJOR
:
508 case AR_RAD5122_SREV_MAJOR
:
509 case AR_RAD2133_SREV_MAJOR
:
510 case AR_RAD2122_SREV_MAJOR
:
513 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
514 "Radio Chip Rev 0x%02X not supported\n",
515 val
& AR_RADIO_SREV_MAJOR
);
519 ah
->hw_version
.analog5GhzRev
= val
;
524 static int ath9k_hw_init_macaddr(struct ath_hw
*ah
)
531 for (i
= 0; i
< 3; i
++) {
532 eeval
= ah
->eep_ops
->get_eeprom(ah
, AR_EEPROM_MAC(i
));
534 ah
->macaddr
[2 * i
] = eeval
>> 8;
535 ah
->macaddr
[2 * i
+ 1] = eeval
& 0xff;
537 if (sum
== 0 || sum
== 0xffff * 3)
538 return -EADDRNOTAVAIL
;
543 static void ath9k_hw_init_rxgain_ini(struct ath_hw
*ah
)
547 if (ah
->eep_ops
->get_eeprom(ah
, EEP_MINOR_REV
) >= AR5416_EEP_MINOR_VER_17
) {
548 rxgain_type
= ah
->eep_ops
->get_eeprom(ah
, EEP_RXGAIN_TYPE
);
550 if (rxgain_type
== AR5416_EEP_RXGAIN_13DB_BACKOFF
)
551 INIT_INI_ARRAY(&ah
->iniModesRxGain
,
552 ar9280Modes_backoff_13db_rxgain_9280_2
,
553 ARRAY_SIZE(ar9280Modes_backoff_13db_rxgain_9280_2
), 6);
554 else if (rxgain_type
== AR5416_EEP_RXGAIN_23DB_BACKOFF
)
555 INIT_INI_ARRAY(&ah
->iniModesRxGain
,
556 ar9280Modes_backoff_23db_rxgain_9280_2
,
557 ARRAY_SIZE(ar9280Modes_backoff_23db_rxgain_9280_2
), 6);
559 INIT_INI_ARRAY(&ah
->iniModesRxGain
,
560 ar9280Modes_original_rxgain_9280_2
,
561 ARRAY_SIZE(ar9280Modes_original_rxgain_9280_2
), 6);
563 INIT_INI_ARRAY(&ah
->iniModesRxGain
,
564 ar9280Modes_original_rxgain_9280_2
,
565 ARRAY_SIZE(ar9280Modes_original_rxgain_9280_2
), 6);
569 static void ath9k_hw_init_txgain_ini(struct ath_hw
*ah
)
573 if (ah
->eep_ops
->get_eeprom(ah
, EEP_MINOR_REV
) >= AR5416_EEP_MINOR_VER_19
) {
574 txgain_type
= ah
->eep_ops
->get_eeprom(ah
, EEP_TXGAIN_TYPE
);
576 if (txgain_type
== AR5416_EEP_TXGAIN_HIGH_POWER
)
577 INIT_INI_ARRAY(&ah
->iniModesTxGain
,
578 ar9280Modes_high_power_tx_gain_9280_2
,
579 ARRAY_SIZE(ar9280Modes_high_power_tx_gain_9280_2
), 6);
581 INIT_INI_ARRAY(&ah
->iniModesTxGain
,
582 ar9280Modes_original_tx_gain_9280_2
,
583 ARRAY_SIZE(ar9280Modes_original_tx_gain_9280_2
), 6);
585 INIT_INI_ARRAY(&ah
->iniModesTxGain
,
586 ar9280Modes_original_tx_gain_9280_2
,
587 ARRAY_SIZE(ar9280Modes_original_tx_gain_9280_2
), 6);
591 static int ath9k_hw_post_attach(struct ath_hw
*ah
)
595 if (!ath9k_hw_chip_test(ah
))
598 ecode
= ath9k_hw_rf_claim(ah
);
602 ecode
= ath9k_hw_eeprom_attach(ah
);
606 DPRINTF(ah
->ah_sc
, ATH_DBG_CONFIG
, "Eeprom VER: %d, REV: %d\n",
607 ah
->eep_ops
->get_eeprom_ver(ah
), ah
->eep_ops
->get_eeprom_rev(ah
));
609 ecode
= ath9k_hw_rfattach(ah
);
613 if (!AR_SREV_9100(ah
)) {
614 ath9k_hw_ani_setup(ah
);
615 ath9k_hw_ani_attach(ah
);
621 static struct ath_hw
*ath9k_hw_do_attach(u16 devid
, struct ath_softc
*sc
,
628 ah
= ath9k_hw_newstate(devid
, sc
, status
);
632 ath9k_hw_set_defaults(ah
);
634 if (!ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_POWER_ON
)) {
635 DPRINTF(sc
, ATH_DBG_FATAL
, "Couldn't reset chip\n");
640 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
)) {
641 DPRINTF(sc
, ATH_DBG_FATAL
, "Couldn't wakeup chip\n");
646 if (ah
->config
.serialize_regmode
== SER_REG_MODE_AUTO
) {
647 if (ah
->hw_version
.macVersion
== AR_SREV_VERSION_5416_PCI
||
648 (AR_SREV_9280(ah
) && !ah
->is_pciexpress
)) {
649 ah
->config
.serialize_regmode
=
652 ah
->config
.serialize_regmode
=
657 DPRINTF(sc
, ATH_DBG_RESET
, "serialize_regmode is %d\n",
658 ah
->config
.serialize_regmode
);
660 if ((ah
->hw_version
.macVersion
!= AR_SREV_VERSION_5416_PCI
) &&
661 (ah
->hw_version
.macVersion
!= AR_SREV_VERSION_5416_PCIE
) &&
662 (ah
->hw_version
.macVersion
!= AR_SREV_VERSION_9160
) &&
663 (!AR_SREV_9100(ah
)) && (!AR_SREV_9280(ah
)) && (!AR_SREV_9285(ah
))) {
664 DPRINTF(sc
, ATH_DBG_FATAL
,
665 "Mac Chip Rev 0x%02x.%x is not supported by "
666 "this driver\n", ah
->hw_version
.macVersion
,
667 ah
->hw_version
.macRev
);
672 if (AR_SREV_9100(ah
)) {
673 ah
->iq_caldata
.calData
= &iq_cal_multi_sample
;
674 ah
->supp_cals
= IQ_MISMATCH_CAL
;
675 ah
->is_pciexpress
= false;
677 ah
->hw_version
.phyRev
= REG_READ(ah
, AR_PHY_CHIP_ID
);
679 if (AR_SREV_9160_10_OR_LATER(ah
)) {
680 if (AR_SREV_9280_10_OR_LATER(ah
)) {
681 ah
->iq_caldata
.calData
= &iq_cal_single_sample
;
682 ah
->adcgain_caldata
.calData
=
683 &adc_gain_cal_single_sample
;
684 ah
->adcdc_caldata
.calData
=
685 &adc_dc_cal_single_sample
;
686 ah
->adcdc_calinitdata
.calData
=
689 ah
->iq_caldata
.calData
= &iq_cal_multi_sample
;
690 ah
->adcgain_caldata
.calData
=
691 &adc_gain_cal_multi_sample
;
692 ah
->adcdc_caldata
.calData
=
693 &adc_dc_cal_multi_sample
;
694 ah
->adcdc_calinitdata
.calData
=
697 ah
->supp_cals
= ADC_GAIN_CAL
| ADC_DC_CAL
| IQ_MISMATCH_CAL
;
700 ah
->ani_function
= ATH9K_ANI_ALL
;
701 if (AR_SREV_9280_10_OR_LATER(ah
))
702 ah
->ani_function
&= ~ATH9K_ANI_NOISE_IMMUNITY_LEVEL
;
704 if (AR_SREV_9285_12_OR_LATER(ah
)) {
706 INIT_INI_ARRAY(&ah
->iniModes
, ar9285Modes_9285_1_2
,
707 ARRAY_SIZE(ar9285Modes_9285_1_2
), 6);
708 INIT_INI_ARRAY(&ah
->iniCommon
, ar9285Common_9285_1_2
,
709 ARRAY_SIZE(ar9285Common_9285_1_2
), 2);
711 if (ah
->config
.pcie_clock_req
) {
712 INIT_INI_ARRAY(&ah
->iniPcieSerdes
,
713 ar9285PciePhy_clkreq_off_L1_9285_1_2
,
714 ARRAY_SIZE(ar9285PciePhy_clkreq_off_L1_9285_1_2
), 2);
716 INIT_INI_ARRAY(&ah
->iniPcieSerdes
,
717 ar9285PciePhy_clkreq_always_on_L1_9285_1_2
,
718 ARRAY_SIZE(ar9285PciePhy_clkreq_always_on_L1_9285_1_2
),
721 } else if (AR_SREV_9285_10_OR_LATER(ah
)) {
722 INIT_INI_ARRAY(&ah
->iniModes
, ar9285Modes_9285
,
723 ARRAY_SIZE(ar9285Modes_9285
), 6);
724 INIT_INI_ARRAY(&ah
->iniCommon
, ar9285Common_9285
,
725 ARRAY_SIZE(ar9285Common_9285
), 2);
727 if (ah
->config
.pcie_clock_req
) {
728 INIT_INI_ARRAY(&ah
->iniPcieSerdes
,
729 ar9285PciePhy_clkreq_off_L1_9285
,
730 ARRAY_SIZE(ar9285PciePhy_clkreq_off_L1_9285
), 2);
732 INIT_INI_ARRAY(&ah
->iniPcieSerdes
,
733 ar9285PciePhy_clkreq_always_on_L1_9285
,
734 ARRAY_SIZE(ar9285PciePhy_clkreq_always_on_L1_9285
), 2);
736 } else if (AR_SREV_9280_20_OR_LATER(ah
)) {
737 INIT_INI_ARRAY(&ah
->iniModes
, ar9280Modes_9280_2
,
738 ARRAY_SIZE(ar9280Modes_9280_2
), 6);
739 INIT_INI_ARRAY(&ah
->iniCommon
, ar9280Common_9280_2
,
740 ARRAY_SIZE(ar9280Common_9280_2
), 2);
742 if (ah
->config
.pcie_clock_req
) {
743 INIT_INI_ARRAY(&ah
->iniPcieSerdes
,
744 ar9280PciePhy_clkreq_off_L1_9280
,
745 ARRAY_SIZE(ar9280PciePhy_clkreq_off_L1_9280
),2);
747 INIT_INI_ARRAY(&ah
->iniPcieSerdes
,
748 ar9280PciePhy_clkreq_always_on_L1_9280
,
749 ARRAY_SIZE(ar9280PciePhy_clkreq_always_on_L1_9280
), 2);
751 INIT_INI_ARRAY(&ah
->iniModesAdditional
,
752 ar9280Modes_fast_clock_9280_2
,
753 ARRAY_SIZE(ar9280Modes_fast_clock_9280_2
), 3);
754 } else if (AR_SREV_9280_10_OR_LATER(ah
)) {
755 INIT_INI_ARRAY(&ah
->iniModes
, ar9280Modes_9280
,
756 ARRAY_SIZE(ar9280Modes_9280
), 6);
757 INIT_INI_ARRAY(&ah
->iniCommon
, ar9280Common_9280
,
758 ARRAY_SIZE(ar9280Common_9280
), 2);
759 } else if (AR_SREV_9160_10_OR_LATER(ah
)) {
760 INIT_INI_ARRAY(&ah
->iniModes
, ar5416Modes_9160
,
761 ARRAY_SIZE(ar5416Modes_9160
), 6);
762 INIT_INI_ARRAY(&ah
->iniCommon
, ar5416Common_9160
,
763 ARRAY_SIZE(ar5416Common_9160
), 2);
764 INIT_INI_ARRAY(&ah
->iniBank0
, ar5416Bank0_9160
,
765 ARRAY_SIZE(ar5416Bank0_9160
), 2);
766 INIT_INI_ARRAY(&ah
->iniBB_RfGain
, ar5416BB_RfGain_9160
,
767 ARRAY_SIZE(ar5416BB_RfGain_9160
), 3);
768 INIT_INI_ARRAY(&ah
->iniBank1
, ar5416Bank1_9160
,
769 ARRAY_SIZE(ar5416Bank1_9160
), 2);
770 INIT_INI_ARRAY(&ah
->iniBank2
, ar5416Bank2_9160
,
771 ARRAY_SIZE(ar5416Bank2_9160
), 2);
772 INIT_INI_ARRAY(&ah
->iniBank3
, ar5416Bank3_9160
,
773 ARRAY_SIZE(ar5416Bank3_9160
), 3);
774 INIT_INI_ARRAY(&ah
->iniBank6
, ar5416Bank6_9160
,
775 ARRAY_SIZE(ar5416Bank6_9160
), 3);
776 INIT_INI_ARRAY(&ah
->iniBank6TPC
, ar5416Bank6TPC_9160
,
777 ARRAY_SIZE(ar5416Bank6TPC_9160
), 3);
778 INIT_INI_ARRAY(&ah
->iniBank7
, ar5416Bank7_9160
,
779 ARRAY_SIZE(ar5416Bank7_9160
), 2);
780 if (AR_SREV_9160_11(ah
)) {
781 INIT_INI_ARRAY(&ah
->iniAddac
,
783 ARRAY_SIZE(ar5416Addac_91601_1
), 2);
785 INIT_INI_ARRAY(&ah
->iniAddac
, ar5416Addac_9160
,
786 ARRAY_SIZE(ar5416Addac_9160
), 2);
788 } else if (AR_SREV_9100_OR_LATER(ah
)) {
789 INIT_INI_ARRAY(&ah
->iniModes
, ar5416Modes_9100
,
790 ARRAY_SIZE(ar5416Modes_9100
), 6);
791 INIT_INI_ARRAY(&ah
->iniCommon
, ar5416Common_9100
,
792 ARRAY_SIZE(ar5416Common_9100
), 2);
793 INIT_INI_ARRAY(&ah
->iniBank0
, ar5416Bank0_9100
,
794 ARRAY_SIZE(ar5416Bank0_9100
), 2);
795 INIT_INI_ARRAY(&ah
->iniBB_RfGain
, ar5416BB_RfGain_9100
,
796 ARRAY_SIZE(ar5416BB_RfGain_9100
), 3);
797 INIT_INI_ARRAY(&ah
->iniBank1
, ar5416Bank1_9100
,
798 ARRAY_SIZE(ar5416Bank1_9100
), 2);
799 INIT_INI_ARRAY(&ah
->iniBank2
, ar5416Bank2_9100
,
800 ARRAY_SIZE(ar5416Bank2_9100
), 2);
801 INIT_INI_ARRAY(&ah
->iniBank3
, ar5416Bank3_9100
,
802 ARRAY_SIZE(ar5416Bank3_9100
), 3);
803 INIT_INI_ARRAY(&ah
->iniBank6
, ar5416Bank6_9100
,
804 ARRAY_SIZE(ar5416Bank6_9100
), 3);
805 INIT_INI_ARRAY(&ah
->iniBank6TPC
, ar5416Bank6TPC_9100
,
806 ARRAY_SIZE(ar5416Bank6TPC_9100
), 3);
807 INIT_INI_ARRAY(&ah
->iniBank7
, ar5416Bank7_9100
,
808 ARRAY_SIZE(ar5416Bank7_9100
), 2);
809 INIT_INI_ARRAY(&ah
->iniAddac
, ar5416Addac_9100
,
810 ARRAY_SIZE(ar5416Addac_9100
), 2);
812 INIT_INI_ARRAY(&ah
->iniModes
, ar5416Modes
,
813 ARRAY_SIZE(ar5416Modes
), 6);
814 INIT_INI_ARRAY(&ah
->iniCommon
, ar5416Common
,
815 ARRAY_SIZE(ar5416Common
), 2);
816 INIT_INI_ARRAY(&ah
->iniBank0
, ar5416Bank0
,
817 ARRAY_SIZE(ar5416Bank0
), 2);
818 INIT_INI_ARRAY(&ah
->iniBB_RfGain
, ar5416BB_RfGain
,
819 ARRAY_SIZE(ar5416BB_RfGain
), 3);
820 INIT_INI_ARRAY(&ah
->iniBank1
, ar5416Bank1
,
821 ARRAY_SIZE(ar5416Bank1
), 2);
822 INIT_INI_ARRAY(&ah
->iniBank2
, ar5416Bank2
,
823 ARRAY_SIZE(ar5416Bank2
), 2);
824 INIT_INI_ARRAY(&ah
->iniBank3
, ar5416Bank3
,
825 ARRAY_SIZE(ar5416Bank3
), 3);
826 INIT_INI_ARRAY(&ah
->iniBank6
, ar5416Bank6
,
827 ARRAY_SIZE(ar5416Bank6
), 3);
828 INIT_INI_ARRAY(&ah
->iniBank6TPC
, ar5416Bank6TPC
,
829 ARRAY_SIZE(ar5416Bank6TPC
), 3);
830 INIT_INI_ARRAY(&ah
->iniBank7
, ar5416Bank7
,
831 ARRAY_SIZE(ar5416Bank7
), 2);
832 INIT_INI_ARRAY(&ah
->iniAddac
, ar5416Addac
,
833 ARRAY_SIZE(ar5416Addac
), 2);
836 if (ah
->is_pciexpress
)
837 ath9k_hw_configpcipowersave(ah
, 0);
839 ath9k_hw_disablepcie(ah
);
841 ecode
= ath9k_hw_post_attach(ah
);
845 if (AR_SREV_9285_12_OR_LATER(ah
)) {
846 u32 txgain_type
= ah
->eep_ops
->get_eeprom(ah
, EEP_TXGAIN_TYPE
);
849 if (txgain_type
== AR5416_EEP_TXGAIN_HIGH_POWER
) {
850 INIT_INI_ARRAY(&ah
->iniModesTxGain
,
851 ar9285Modes_high_power_tx_gain_9285_1_2
,
852 ARRAY_SIZE(ar9285Modes_high_power_tx_gain_9285_1_2
), 6);
854 INIT_INI_ARRAY(&ah
->iniModesTxGain
,
855 ar9285Modes_original_tx_gain_9285_1_2
,
856 ARRAY_SIZE(ar9285Modes_original_tx_gain_9285_1_2
), 6);
862 if (AR_SREV_9280_20(ah
))
863 ath9k_hw_init_rxgain_ini(ah
);
866 if (AR_SREV_9280_20(ah
))
867 ath9k_hw_init_txgain_ini(ah
);
869 ath9k_hw_fill_cap_info(ah
);
871 if ((ah
->hw_version
.devid
== AR9280_DEVID_PCI
) &&
872 test_bit(ATH9K_MODE_11A
, ah
->caps
.wireless_modes
)) {
875 for (i
= 0; i
< ah
->iniModes
.ia_rows
; i
++) {
876 u32 reg
= INI_RA(&ah
->iniModes
, i
, 0);
878 for (j
= 1; j
< ah
->iniModes
.ia_columns
; j
++) {
879 u32 val
= INI_RA(&ah
->iniModes
, i
, j
);
881 INI_RA(&ah
->iniModes
, i
, j
) =
882 ath9k_hw_ini_fixup(ah
,
889 ecode
= ath9k_hw_init_macaddr(ah
);
891 DPRINTF(sc
, ATH_DBG_FATAL
,
892 "Failed to initialize MAC address\n");
896 if (AR_SREV_9285(ah
))
897 ah
->tx_trig_level
= (AR_FTRIG_256B
>> AR_FTRIG_S
);
899 ah
->tx_trig_level
= (AR_FTRIG_512B
>> AR_FTRIG_S
);
901 ath9k_init_nfcal_hist_buffer(ah
);
913 static void ath9k_hw_init_bb(struct ath_hw
*ah
,
914 struct ath9k_channel
*chan
)
918 synthDelay
= REG_READ(ah
, AR_PHY_RX_DELAY
) & AR_PHY_RX_DELAY_DELAY
;
920 synthDelay
= (4 * synthDelay
) / 22;
924 REG_WRITE(ah
, AR_PHY_ACTIVE
, AR_PHY_ACTIVE_EN
);
926 udelay(synthDelay
+ BASE_ACTIVATE_DELAY
);
929 static void ath9k_hw_init_qos(struct ath_hw
*ah
)
931 REG_WRITE(ah
, AR_MIC_QOS_CONTROL
, 0x100aa);
932 REG_WRITE(ah
, AR_MIC_QOS_SELECT
, 0x3210);
934 REG_WRITE(ah
, AR_QOS_NO_ACK
,
935 SM(2, AR_QOS_NO_ACK_TWO_BIT
) |
936 SM(5, AR_QOS_NO_ACK_BIT_OFF
) |
937 SM(0, AR_QOS_NO_ACK_BYTE_OFF
));
939 REG_WRITE(ah
, AR_TXOP_X
, AR_TXOP_X_VAL
);
940 REG_WRITE(ah
, AR_TXOP_0_3
, 0xFFFFFFFF);
941 REG_WRITE(ah
, AR_TXOP_4_7
, 0xFFFFFFFF);
942 REG_WRITE(ah
, AR_TXOP_8_11
, 0xFFFFFFFF);
943 REG_WRITE(ah
, AR_TXOP_12_15
, 0xFFFFFFFF);
946 static void ath9k_hw_init_pll(struct ath_hw
*ah
,
947 struct ath9k_channel
*chan
)
951 if (AR_SREV_9100(ah
)) {
952 if (chan
&& IS_CHAN_5GHZ(chan
))
957 if (AR_SREV_9280_10_OR_LATER(ah
)) {
958 pll
= SM(0x5, AR_RTC_9160_PLL_REFDIV
);
960 if (chan
&& IS_CHAN_HALF_RATE(chan
))
961 pll
|= SM(0x1, AR_RTC_9160_PLL_CLKSEL
);
962 else if (chan
&& IS_CHAN_QUARTER_RATE(chan
))
963 pll
|= SM(0x2, AR_RTC_9160_PLL_CLKSEL
);
965 if (chan
&& IS_CHAN_5GHZ(chan
)) {
966 pll
|= SM(0x28, AR_RTC_9160_PLL_DIV
);
969 if (AR_SREV_9280_20(ah
)) {
970 if (((chan
->channel
% 20) == 0)
971 || ((chan
->channel
% 10) == 0))
977 pll
|= SM(0x2c, AR_RTC_9160_PLL_DIV
);
980 } else if (AR_SREV_9160_10_OR_LATER(ah
)) {
982 pll
= SM(0x5, AR_RTC_9160_PLL_REFDIV
);
984 if (chan
&& IS_CHAN_HALF_RATE(chan
))
985 pll
|= SM(0x1, AR_RTC_9160_PLL_CLKSEL
);
986 else if (chan
&& IS_CHAN_QUARTER_RATE(chan
))
987 pll
|= SM(0x2, AR_RTC_9160_PLL_CLKSEL
);
989 if (chan
&& IS_CHAN_5GHZ(chan
))
990 pll
|= SM(0x50, AR_RTC_9160_PLL_DIV
);
992 pll
|= SM(0x58, AR_RTC_9160_PLL_DIV
);
994 pll
= AR_RTC_PLL_REFDIV_5
| AR_RTC_PLL_DIV2
;
996 if (chan
&& IS_CHAN_HALF_RATE(chan
))
997 pll
|= SM(0x1, AR_RTC_PLL_CLKSEL
);
998 else if (chan
&& IS_CHAN_QUARTER_RATE(chan
))
999 pll
|= SM(0x2, AR_RTC_PLL_CLKSEL
);
1001 if (chan
&& IS_CHAN_5GHZ(chan
))
1002 pll
|= SM(0xa, AR_RTC_PLL_DIV
);
1004 pll
|= SM(0xb, AR_RTC_PLL_DIV
);
1007 REG_WRITE(ah
, AR_RTC_PLL_CONTROL
, pll
);
1009 udelay(RTC_PLL_SETTLE_DELAY
);
1011 REG_WRITE(ah
, AR_RTC_SLEEP_CLK
, AR_RTC_FORCE_DERIVED_CLK
);
1014 static void ath9k_hw_init_chain_masks(struct ath_hw
*ah
)
1016 int rx_chainmask
, tx_chainmask
;
1018 rx_chainmask
= ah
->rxchainmask
;
1019 tx_chainmask
= ah
->txchainmask
;
1021 switch (rx_chainmask
) {
1023 REG_SET_BIT(ah
, AR_PHY_ANALOG_SWAP
,
1024 AR_PHY_SWAP_ALT_CHAIN
);
1026 if (((ah
)->hw_version
.macVersion
<= AR_SREV_VERSION_9160
)) {
1027 REG_WRITE(ah
, AR_PHY_RX_CHAINMASK
, 0x7);
1028 REG_WRITE(ah
, AR_PHY_CAL_CHAINMASK
, 0x7);
1034 REG_WRITE(ah
, AR_PHY_RX_CHAINMASK
, rx_chainmask
);
1035 REG_WRITE(ah
, AR_PHY_CAL_CHAINMASK
, rx_chainmask
);
1041 REG_WRITE(ah
, AR_SELFGEN_MASK
, tx_chainmask
);
1042 if (tx_chainmask
== 0x5) {
1043 REG_SET_BIT(ah
, AR_PHY_ANALOG_SWAP
,
1044 AR_PHY_SWAP_ALT_CHAIN
);
1046 if (AR_SREV_9100(ah
))
1047 REG_WRITE(ah
, AR_PHY_ANALOG_SWAP
,
1048 REG_READ(ah
, AR_PHY_ANALOG_SWAP
) | 0x00000001);
1051 static void ath9k_hw_init_interrupt_masks(struct ath_hw
*ah
,
1052 enum nl80211_iftype opmode
)
1054 ah
->mask_reg
= AR_IMR_TXERR
|
1060 if (ah
->config
.intr_mitigation
)
1061 ah
->mask_reg
|= AR_IMR_RXINTM
| AR_IMR_RXMINTR
;
1063 ah
->mask_reg
|= AR_IMR_RXOK
;
1065 ah
->mask_reg
|= AR_IMR_TXOK
;
1067 if (opmode
== NL80211_IFTYPE_AP
)
1068 ah
->mask_reg
|= AR_IMR_MIB
;
1070 REG_WRITE(ah
, AR_IMR
, ah
->mask_reg
);
1071 REG_WRITE(ah
, AR_IMR_S2
, REG_READ(ah
, AR_IMR_S2
) | AR_IMR_S2_GTT
);
1073 if (!AR_SREV_9100(ah
)) {
1074 REG_WRITE(ah
, AR_INTR_SYNC_CAUSE
, 0xFFFFFFFF);
1075 REG_WRITE(ah
, AR_INTR_SYNC_ENABLE
, AR_INTR_SYNC_DEFAULT
);
1076 REG_WRITE(ah
, AR_INTR_SYNC_MASK
, 0);
1080 static bool ath9k_hw_set_ack_timeout(struct ath_hw
*ah
, u32 us
)
1082 if (us
> ath9k_hw_mac_to_usec(ah
, MS(0xffffffff, AR_TIME_OUT_ACK
))) {
1083 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "bad ack timeout %u\n", us
);
1084 ah
->acktimeout
= (u32
) -1;
1087 REG_RMW_FIELD(ah
, AR_TIME_OUT
,
1088 AR_TIME_OUT_ACK
, ath9k_hw_mac_to_clks(ah
, us
));
1089 ah
->acktimeout
= us
;
1094 static bool ath9k_hw_set_cts_timeout(struct ath_hw
*ah
, u32 us
)
1096 if (us
> ath9k_hw_mac_to_usec(ah
, MS(0xffffffff, AR_TIME_OUT_CTS
))) {
1097 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "bad cts timeout %u\n", us
);
1098 ah
->ctstimeout
= (u32
) -1;
1101 REG_RMW_FIELD(ah
, AR_TIME_OUT
,
1102 AR_TIME_OUT_CTS
, ath9k_hw_mac_to_clks(ah
, us
));
1103 ah
->ctstimeout
= us
;
1108 static bool ath9k_hw_set_global_txtimeout(struct ath_hw
*ah
, u32 tu
)
1111 DPRINTF(ah
->ah_sc
, ATH_DBG_XMIT
,
1112 "bad global tx timeout %u\n", tu
);
1113 ah
->globaltxtimeout
= (u32
) -1;
1116 REG_RMW_FIELD(ah
, AR_GTXTO
, AR_GTXTO_TIMEOUT_LIMIT
, tu
);
1117 ah
->globaltxtimeout
= tu
;
1122 static void ath9k_hw_init_user_settings(struct ath_hw
*ah
)
1124 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "ah->misc_mode 0x%x\n",
1127 if (ah
->misc_mode
!= 0)
1128 REG_WRITE(ah
, AR_PCU_MISC
,
1129 REG_READ(ah
, AR_PCU_MISC
) | ah
->misc_mode
);
1130 if (ah
->slottime
!= (u32
) -1)
1131 ath9k_hw_setslottime(ah
, ah
->slottime
);
1132 if (ah
->acktimeout
!= (u32
) -1)
1133 ath9k_hw_set_ack_timeout(ah
, ah
->acktimeout
);
1134 if (ah
->ctstimeout
!= (u32
) -1)
1135 ath9k_hw_set_cts_timeout(ah
, ah
->ctstimeout
);
1136 if (ah
->globaltxtimeout
!= (u32
) -1)
1137 ath9k_hw_set_global_txtimeout(ah
, ah
->globaltxtimeout
);
1140 const char *ath9k_hw_probe(u16 vendorid
, u16 devid
)
1142 return vendorid
== ATHEROS_VENDOR_ID
?
1143 ath9k_hw_devname(devid
) : NULL
;
1146 void ath9k_hw_detach(struct ath_hw
*ah
)
1148 if (!AR_SREV_9100(ah
))
1149 ath9k_hw_ani_detach(ah
);
1151 ath9k_hw_rfdetach(ah
);
1152 ath9k_hw_setpower(ah
, ATH9K_PM_FULL_SLEEP
);
1156 struct ath_hw
*ath9k_hw_attach(u16 devid
, struct ath_softc
*sc
, int *error
)
1158 struct ath_hw
*ah
= NULL
;
1161 case AR5416_DEVID_PCI
:
1162 case AR5416_DEVID_PCIE
:
1163 case AR5416_AR9100_DEVID
:
1164 case AR9160_DEVID_PCI
:
1165 case AR9280_DEVID_PCI
:
1166 case AR9280_DEVID_PCIE
:
1167 case AR9285_DEVID_PCIE
:
1168 ah
= ath9k_hw_do_attach(devid
, sc
, error
);
1182 static void ath9k_hw_override_ini(struct ath_hw
*ah
,
1183 struct ath9k_channel
*chan
)
1186 * Set the RX_ABORT and RX_DIS and clear if off only after
1187 * RXE is set for MAC. This prevents frames with corrupted
1188 * descriptor status.
1190 REG_SET_BIT(ah
, AR_DIAG_SW
, (AR_DIAG_RX_DIS
| AR_DIAG_RX_ABORT
));
1193 if (!AR_SREV_5416_20_OR_LATER(ah
) ||
1194 AR_SREV_9280_10_OR_LATER(ah
))
1197 REG_WRITE(ah
, 0x9800 + (651 << 2), 0x11);
1200 static u32
ath9k_hw_def_ini_fixup(struct ath_hw
*ah
,
1201 struct ar5416_eeprom_def
*pEepData
,
1204 struct base_eep_header
*pBase
= &(pEepData
->baseEepHeader
);
1206 switch (ah
->hw_version
.devid
) {
1207 case AR9280_DEVID_PCI
:
1208 if (reg
== 0x7894) {
1209 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
1210 "ini VAL: %x EEPROM: %x\n", value
,
1211 (pBase
->version
& 0xff));
1213 if ((pBase
->version
& 0xff) > 0x0a) {
1214 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
1217 value
&= ~AR_AN_TOP2_PWDCLKIND
;
1218 value
|= AR_AN_TOP2_PWDCLKIND
&
1219 (pBase
->pwdclkind
<< AR_AN_TOP2_PWDCLKIND_S
);
1221 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
1222 "PWDCLKIND Earlier Rev\n");
1225 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
1226 "final ini VAL: %x\n", value
);
1234 static u32
ath9k_hw_ini_fixup(struct ath_hw
*ah
,
1235 struct ar5416_eeprom_def
*pEepData
,
1238 if (ah
->eep_map
== EEP_MAP_4KBITS
)
1241 return ath9k_hw_def_ini_fixup(ah
, pEepData
, reg
, value
);
1244 static void ath9k_olc_init(struct ath_hw
*ah
)
1248 for (i
= 0; i
< AR9280_TX_GAIN_TABLE_SIZE
; i
++)
1249 ah
->originalGain
[i
] =
1250 MS(REG_READ(ah
, AR_PHY_TX_GAIN_TBL1
+ i
* 4),
1255 static u32
ath9k_regd_get_ctl(struct ath_regulatory
*reg
,
1256 struct ath9k_channel
*chan
)
1258 u32 ctl
= ath_regd_get_band_ctl(reg
, chan
->chan
->band
);
1260 if (IS_CHAN_B(chan
))
1262 else if (IS_CHAN_G(chan
))
1270 static int ath9k_hw_process_ini(struct ath_hw
*ah
,
1271 struct ath9k_channel
*chan
,
1272 enum ath9k_ht_macmode macmode
)
1274 int i
, regWrites
= 0;
1275 struct ieee80211_channel
*channel
= chan
->chan
;
1276 u32 modesIndex
, freqIndex
;
1279 switch (chan
->chanmode
) {
1281 case CHANNEL_A_HT20
:
1285 case CHANNEL_A_HT40PLUS
:
1286 case CHANNEL_A_HT40MINUS
:
1291 case CHANNEL_G_HT20
:
1296 case CHANNEL_G_HT40PLUS
:
1297 case CHANNEL_G_HT40MINUS
:
1306 REG_WRITE(ah
, AR_PHY(0), 0x00000007);
1307 REG_WRITE(ah
, AR_PHY_ADC_SERIAL_CTL
, AR_PHY_SEL_EXTERNAL_RADIO
);
1308 ah
->eep_ops
->set_addac(ah
, chan
);
1310 if (AR_SREV_5416_22_OR_LATER(ah
)) {
1311 REG_WRITE_ARRAY(&ah
->iniAddac
, 1, regWrites
);
1313 struct ar5416IniArray temp
;
1315 sizeof(u32
) * ah
->iniAddac
.ia_rows
*
1316 ah
->iniAddac
.ia_columns
;
1318 memcpy(ah
->addac5416_21
,
1319 ah
->iniAddac
.ia_array
, addacSize
);
1321 (ah
->addac5416_21
)[31 * ah
->iniAddac
.ia_columns
+ 1] = 0;
1323 temp
.ia_array
= ah
->addac5416_21
;
1324 temp
.ia_columns
= ah
->iniAddac
.ia_columns
;
1325 temp
.ia_rows
= ah
->iniAddac
.ia_rows
;
1326 REG_WRITE_ARRAY(&temp
, 1, regWrites
);
1329 REG_WRITE(ah
, AR_PHY_ADC_SERIAL_CTL
, AR_PHY_SEL_INTERNAL_ADDAC
);
1331 for (i
= 0; i
< ah
->iniModes
.ia_rows
; i
++) {
1332 u32 reg
= INI_RA(&ah
->iniModes
, i
, 0);
1333 u32 val
= INI_RA(&ah
->iniModes
, i
, modesIndex
);
1335 REG_WRITE(ah
, reg
, val
);
1337 if (reg
>= 0x7800 && reg
< 0x78a0
1338 && ah
->config
.analog_shiftreg
) {
1342 DO_DELAY(regWrites
);
1345 if (AR_SREV_9280(ah
))
1346 REG_WRITE_ARRAY(&ah
->iniModesRxGain
, modesIndex
, regWrites
);
1348 if (AR_SREV_9280(ah
) || (AR_SREV_9285(ah
) &&
1349 AR_SREV_9285_12_OR_LATER(ah
)))
1350 REG_WRITE_ARRAY(&ah
->iniModesTxGain
, modesIndex
, regWrites
);
1352 for (i
= 0; i
< ah
->iniCommon
.ia_rows
; i
++) {
1353 u32 reg
= INI_RA(&ah
->iniCommon
, i
, 0);
1354 u32 val
= INI_RA(&ah
->iniCommon
, i
, 1);
1356 REG_WRITE(ah
, reg
, val
);
1358 if (reg
>= 0x7800 && reg
< 0x78a0
1359 && ah
->config
.analog_shiftreg
) {
1363 DO_DELAY(regWrites
);
1366 ath9k_hw_write_regs(ah
, modesIndex
, freqIndex
, regWrites
);
1368 if (AR_SREV_9280_20(ah
) && IS_CHAN_A_5MHZ_SPACED(chan
)) {
1369 REG_WRITE_ARRAY(&ah
->iniModesAdditional
, modesIndex
,
1373 ath9k_hw_override_ini(ah
, chan
);
1374 ath9k_hw_set_regs(ah
, chan
, macmode
);
1375 ath9k_hw_init_chain_masks(ah
);
1377 if (OLC_FOR_AR9280_20_LATER
)
1380 status
= ah
->eep_ops
->set_txpower(ah
, chan
,
1381 ath9k_regd_get_ctl(&ah
->regulatory
, chan
),
1382 channel
->max_antenna_gain
* 2,
1383 channel
->max_power
* 2,
1384 min((u32
) MAX_RATE_POWER
,
1385 (u32
) ah
->regulatory
.power_limit
));
1387 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
1388 "Error initializing transmit power\n");
1392 if (!ath9k_hw_set_rf_regs(ah
, chan
, freqIndex
)) {
1393 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
1394 "ar5416SetRfRegs failed\n");
1401 /****************************************/
1402 /* Reset and Channel Switching Routines */
1403 /****************************************/
1405 static void ath9k_hw_set_rfmode(struct ath_hw
*ah
, struct ath9k_channel
*chan
)
1412 rfMode
|= (IS_CHAN_B(chan
) || IS_CHAN_G(chan
))
1413 ? AR_PHY_MODE_DYNAMIC
: AR_PHY_MODE_OFDM
;
1415 if (!AR_SREV_9280_10_OR_LATER(ah
))
1416 rfMode
|= (IS_CHAN_5GHZ(chan
)) ?
1417 AR_PHY_MODE_RF5GHZ
: AR_PHY_MODE_RF2GHZ
;
1419 if (AR_SREV_9280_20(ah
) && IS_CHAN_A_5MHZ_SPACED(chan
))
1420 rfMode
|= (AR_PHY_MODE_DYNAMIC
| AR_PHY_MODE_DYN_CCK_DISABLE
);
1422 REG_WRITE(ah
, AR_PHY_MODE
, rfMode
);
1425 static void ath9k_hw_mark_phy_inactive(struct ath_hw
*ah
)
1427 REG_WRITE(ah
, AR_PHY_ACTIVE
, AR_PHY_ACTIVE_DIS
);
1430 static inline void ath9k_hw_set_dma(struct ath_hw
*ah
)
1434 regval
= REG_READ(ah
, AR_AHB_MODE
);
1435 REG_WRITE(ah
, AR_AHB_MODE
, regval
| AR_AHB_PREFETCH_RD_EN
);
1437 regval
= REG_READ(ah
, AR_TXCFG
) & ~AR_TXCFG_DMASZ_MASK
;
1438 REG_WRITE(ah
, AR_TXCFG
, regval
| AR_TXCFG_DMASZ_128B
);
1440 REG_RMW_FIELD(ah
, AR_TXCFG
, AR_FTRIG
, ah
->tx_trig_level
);
1442 regval
= REG_READ(ah
, AR_RXCFG
) & ~AR_RXCFG_DMASZ_MASK
;
1443 REG_WRITE(ah
, AR_RXCFG
, regval
| AR_RXCFG_DMASZ_128B
);
1445 REG_WRITE(ah
, AR_RXFIFO_CFG
, 0x200);
1447 if (AR_SREV_9285(ah
)) {
1448 REG_WRITE(ah
, AR_PCU_TXBUF_CTRL
,
1449 AR_9285_PCU_TXBUF_CTRL_USABLE_SIZE
);
1451 REG_WRITE(ah
, AR_PCU_TXBUF_CTRL
,
1452 AR_PCU_TXBUF_CTRL_USABLE_SIZE
);
1456 static void ath9k_hw_set_operating_mode(struct ath_hw
*ah
, int opmode
)
1460 val
= REG_READ(ah
, AR_STA_ID1
);
1461 val
&= ~(AR_STA_ID1_STA_AP
| AR_STA_ID1_ADHOC
);
1463 case NL80211_IFTYPE_AP
:
1464 REG_WRITE(ah
, AR_STA_ID1
, val
| AR_STA_ID1_STA_AP
1465 | AR_STA_ID1_KSRCH_MODE
);
1466 REG_CLR_BIT(ah
, AR_CFG
, AR_CFG_AP_ADHOC_INDICATION
);
1468 case NL80211_IFTYPE_ADHOC
:
1469 case NL80211_IFTYPE_MESH_POINT
:
1470 REG_WRITE(ah
, AR_STA_ID1
, val
| AR_STA_ID1_ADHOC
1471 | AR_STA_ID1_KSRCH_MODE
);
1472 REG_SET_BIT(ah
, AR_CFG
, AR_CFG_AP_ADHOC_INDICATION
);
1474 case NL80211_IFTYPE_STATION
:
1475 case NL80211_IFTYPE_MONITOR
:
1476 REG_WRITE(ah
, AR_STA_ID1
, val
| AR_STA_ID1_KSRCH_MODE
);
1481 static inline void ath9k_hw_get_delta_slope_vals(struct ath_hw
*ah
,
1486 u32 coef_exp
, coef_man
;
1488 for (coef_exp
= 31; coef_exp
> 0; coef_exp
--)
1489 if ((coef_scaled
>> coef_exp
) & 0x1)
1492 coef_exp
= 14 - (coef_exp
- COEF_SCALE_S
);
1494 coef_man
= coef_scaled
+ (1 << (COEF_SCALE_S
- coef_exp
- 1));
1496 *coef_mantissa
= coef_man
>> (COEF_SCALE_S
- coef_exp
);
1497 *coef_exponent
= coef_exp
- 16;
1500 static void ath9k_hw_set_delta_slope(struct ath_hw
*ah
,
1501 struct ath9k_channel
*chan
)
1503 u32 coef_scaled
, ds_coef_exp
, ds_coef_man
;
1504 u32 clockMhzScaled
= 0x64000000;
1505 struct chan_centers centers
;
1507 if (IS_CHAN_HALF_RATE(chan
))
1508 clockMhzScaled
= clockMhzScaled
>> 1;
1509 else if (IS_CHAN_QUARTER_RATE(chan
))
1510 clockMhzScaled
= clockMhzScaled
>> 2;
1512 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
1513 coef_scaled
= clockMhzScaled
/ centers
.synth_center
;
1515 ath9k_hw_get_delta_slope_vals(ah
, coef_scaled
, &ds_coef_man
,
1518 REG_RMW_FIELD(ah
, AR_PHY_TIMING3
,
1519 AR_PHY_TIMING3_DSC_MAN
, ds_coef_man
);
1520 REG_RMW_FIELD(ah
, AR_PHY_TIMING3
,
1521 AR_PHY_TIMING3_DSC_EXP
, ds_coef_exp
);
1523 coef_scaled
= (9 * coef_scaled
) / 10;
1525 ath9k_hw_get_delta_slope_vals(ah
, coef_scaled
, &ds_coef_man
,
1528 REG_RMW_FIELD(ah
, AR_PHY_HALFGI
,
1529 AR_PHY_HALFGI_DSC_MAN
, ds_coef_man
);
1530 REG_RMW_FIELD(ah
, AR_PHY_HALFGI
,
1531 AR_PHY_HALFGI_DSC_EXP
, ds_coef_exp
);
1534 static bool ath9k_hw_set_reset(struct ath_hw
*ah
, int type
)
1539 if (AR_SREV_9100(ah
)) {
1540 u32 val
= REG_READ(ah
, AR_RTC_DERIVED_CLK
);
1541 val
&= ~AR_RTC_DERIVED_CLK_PERIOD
;
1542 val
|= SM(1, AR_RTC_DERIVED_CLK_PERIOD
);
1543 REG_WRITE(ah
, AR_RTC_DERIVED_CLK
, val
);
1544 (void)REG_READ(ah
, AR_RTC_DERIVED_CLK
);
1547 REG_WRITE(ah
, AR_RTC_FORCE_WAKE
, AR_RTC_FORCE_WAKE_EN
|
1548 AR_RTC_FORCE_WAKE_ON_INT
);
1550 if (AR_SREV_9100(ah
)) {
1551 rst_flags
= AR_RTC_RC_MAC_WARM
| AR_RTC_RC_MAC_COLD
|
1552 AR_RTC_RC_COLD_RESET
| AR_RTC_RC_WARM_RESET
;
1554 tmpReg
= REG_READ(ah
, AR_INTR_SYNC_CAUSE
);
1556 (AR_INTR_SYNC_LOCAL_TIMEOUT
|
1557 AR_INTR_SYNC_RADM_CPL_TIMEOUT
)) {
1558 REG_WRITE(ah
, AR_INTR_SYNC_ENABLE
, 0);
1559 REG_WRITE(ah
, AR_RC
, AR_RC_AHB
| AR_RC_HOSTIF
);
1561 REG_WRITE(ah
, AR_RC
, AR_RC_AHB
);
1564 rst_flags
= AR_RTC_RC_MAC_WARM
;
1565 if (type
== ATH9K_RESET_COLD
)
1566 rst_flags
|= AR_RTC_RC_MAC_COLD
;
1569 REG_WRITE(ah
, AR_RTC_RC
, rst_flags
);
1572 REG_WRITE(ah
, AR_RTC_RC
, 0);
1573 if (!ath9k_hw_wait(ah
, AR_RTC_RC
, AR_RTC_RC_M
, 0, AH_WAIT_TIMEOUT
)) {
1574 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
1575 "RTC stuck in MAC reset\n");
1579 if (!AR_SREV_9100(ah
))
1580 REG_WRITE(ah
, AR_RC
, 0);
1582 ath9k_hw_init_pll(ah
, NULL
);
1584 if (AR_SREV_9100(ah
))
1590 static bool ath9k_hw_set_reset_power_on(struct ath_hw
*ah
)
1592 REG_WRITE(ah
, AR_RTC_FORCE_WAKE
, AR_RTC_FORCE_WAKE_EN
|
1593 AR_RTC_FORCE_WAKE_ON_INT
);
1595 REG_WRITE(ah
, AR_RTC_RESET
, 0);
1597 REG_WRITE(ah
, AR_RTC_RESET
, 1);
1599 if (!ath9k_hw_wait(ah
,
1604 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "RTC not waking up\n");
1608 ath9k_hw_read_revisions(ah
);
1610 return ath9k_hw_set_reset(ah
, ATH9K_RESET_WARM
);
1613 static bool ath9k_hw_set_reset_reg(struct ath_hw
*ah
, u32 type
)
1615 REG_WRITE(ah
, AR_RTC_FORCE_WAKE
,
1616 AR_RTC_FORCE_WAKE_EN
| AR_RTC_FORCE_WAKE_ON_INT
);
1619 case ATH9K_RESET_POWER_ON
:
1620 return ath9k_hw_set_reset_power_on(ah
);
1622 case ATH9K_RESET_WARM
:
1623 case ATH9K_RESET_COLD
:
1624 return ath9k_hw_set_reset(ah
, type
);
1631 static void ath9k_hw_set_regs(struct ath_hw
*ah
, struct ath9k_channel
*chan
,
1632 enum ath9k_ht_macmode macmode
)
1635 u32 enableDacFifo
= 0;
1637 if (AR_SREV_9285_10_OR_LATER(ah
))
1638 enableDacFifo
= (REG_READ(ah
, AR_PHY_TURBO
) &
1639 AR_PHY_FC_ENABLE_DAC_FIFO
);
1641 phymode
= AR_PHY_FC_HT_EN
| AR_PHY_FC_SHORT_GI_40
1642 | AR_PHY_FC_SINGLE_HT_LTF1
| AR_PHY_FC_WALSH
| enableDacFifo
;
1644 if (IS_CHAN_HT40(chan
)) {
1645 phymode
|= AR_PHY_FC_DYN2040_EN
;
1647 if ((chan
->chanmode
== CHANNEL_A_HT40PLUS
) ||
1648 (chan
->chanmode
== CHANNEL_G_HT40PLUS
))
1649 phymode
|= AR_PHY_FC_DYN2040_PRI_CH
;
1651 if (ah
->extprotspacing
== ATH9K_HT_EXTPROTSPACING_25
)
1652 phymode
|= AR_PHY_FC_DYN2040_EXT_CH
;
1654 REG_WRITE(ah
, AR_PHY_TURBO
, phymode
);
1656 ath9k_hw_set11nmac2040(ah
, macmode
);
1658 REG_WRITE(ah
, AR_GTXTO
, 25 << AR_GTXTO_TIMEOUT_LIMIT_S
);
1659 REG_WRITE(ah
, AR_CST
, 0xF << AR_CST_TIMEOUT_LIMIT_S
);
1662 static bool ath9k_hw_chip_reset(struct ath_hw
*ah
,
1663 struct ath9k_channel
*chan
)
1665 if (OLC_FOR_AR9280_20_LATER
) {
1666 if (!ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_POWER_ON
))
1668 } else if (!ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_WARM
))
1671 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
))
1674 ah
->chip_fullsleep
= false;
1675 ath9k_hw_init_pll(ah
, chan
);
1676 ath9k_hw_set_rfmode(ah
, chan
);
1681 static bool ath9k_hw_channel_change(struct ath_hw
*ah
,
1682 struct ath9k_channel
*chan
,
1683 enum ath9k_ht_macmode macmode
)
1685 struct ieee80211_channel
*channel
= chan
->chan
;
1686 u32 synthDelay
, qnum
;
1688 for (qnum
= 0; qnum
< AR_NUM_QCU
; qnum
++) {
1689 if (ath9k_hw_numtxpending(ah
, qnum
)) {
1690 DPRINTF(ah
->ah_sc
, ATH_DBG_QUEUE
,
1691 "Transmit frames pending on queue %d\n", qnum
);
1696 REG_WRITE(ah
, AR_PHY_RFBUS_REQ
, AR_PHY_RFBUS_REQ_EN
);
1697 if (!ath9k_hw_wait(ah
, AR_PHY_RFBUS_GRANT
, AR_PHY_RFBUS_GRANT_EN
,
1698 AR_PHY_RFBUS_GRANT_EN
, AH_WAIT_TIMEOUT
)) {
1699 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
1700 "Could not kill baseband RX\n");
1704 ath9k_hw_set_regs(ah
, chan
, macmode
);
1706 if (AR_SREV_9280_10_OR_LATER(ah
)) {
1707 if (!(ath9k_hw_ar9280_set_channel(ah
, chan
))) {
1708 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
1709 "Failed to set channel\n");
1713 if (!(ath9k_hw_set_channel(ah
, chan
))) {
1714 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
1715 "Failed to set channel\n");
1720 if (ah
->eep_ops
->set_txpower(ah
, chan
,
1721 ath9k_regd_get_ctl(&ah
->regulatory
, chan
),
1722 channel
->max_antenna_gain
* 2,
1723 channel
->max_power
* 2,
1724 min((u32
) MAX_RATE_POWER
,
1725 (u32
) ah
->regulatory
.power_limit
)) != 0) {
1726 DPRINTF(ah
->ah_sc
, ATH_DBG_EEPROM
,
1727 "Error initializing transmit power\n");
1731 synthDelay
= REG_READ(ah
, AR_PHY_RX_DELAY
) & AR_PHY_RX_DELAY_DELAY
;
1732 if (IS_CHAN_B(chan
))
1733 synthDelay
= (4 * synthDelay
) / 22;
1737 udelay(synthDelay
+ BASE_ACTIVATE_DELAY
);
1739 REG_WRITE(ah
, AR_PHY_RFBUS_REQ
, 0);
1741 if (IS_CHAN_OFDM(chan
) || IS_CHAN_HT(chan
))
1742 ath9k_hw_set_delta_slope(ah
, chan
);
1744 if (AR_SREV_9280_10_OR_LATER(ah
))
1745 ath9k_hw_9280_spur_mitigate(ah
, chan
);
1747 ath9k_hw_spur_mitigate(ah
, chan
);
1749 if (!chan
->oneTimeCalsDone
)
1750 chan
->oneTimeCalsDone
= true;
1755 static void ath9k_hw_9280_spur_mitigate(struct ath_hw
*ah
, struct ath9k_channel
*chan
)
1757 int bb_spur
= AR_NO_SPUR
;
1760 int bb_spur_off
, spur_subchannel_sd
;
1762 int spur_delta_phase
;
1764 int upper
, lower
, cur_vit_mask
;
1767 int pilot_mask_reg
[4] = { AR_PHY_TIMING7
, AR_PHY_TIMING8
,
1768 AR_PHY_PILOT_MASK_01_30
, AR_PHY_PILOT_MASK_31_60
1770 int chan_mask_reg
[4] = { AR_PHY_TIMING9
, AR_PHY_TIMING10
,
1771 AR_PHY_CHANNEL_MASK_01_30
, AR_PHY_CHANNEL_MASK_31_60
1773 int inc
[4] = { 0, 100, 0, 0 };
1774 struct chan_centers centers
;
1781 bool is2GHz
= IS_CHAN_2GHZ(chan
);
1783 memset(&mask_m
, 0, sizeof(int8_t) * 123);
1784 memset(&mask_p
, 0, sizeof(int8_t) * 123);
1786 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
1787 freq
= centers
.synth_center
;
1789 ah
->config
.spurmode
= SPUR_ENABLE_EEPROM
;
1790 for (i
= 0; i
< AR_EEPROM_MODAL_SPURS
; i
++) {
1791 cur_bb_spur
= ah
->eep_ops
->get_spur_channel(ah
, i
, is2GHz
);
1794 cur_bb_spur
= (cur_bb_spur
/ 10) + AR_BASE_FREQ_2GHZ
;
1796 cur_bb_spur
= (cur_bb_spur
/ 10) + AR_BASE_FREQ_5GHZ
;
1798 if (AR_NO_SPUR
== cur_bb_spur
)
1800 cur_bb_spur
= cur_bb_spur
- freq
;
1802 if (IS_CHAN_HT40(chan
)) {
1803 if ((cur_bb_spur
> -AR_SPUR_FEEQ_BOUND_HT40
) &&
1804 (cur_bb_spur
< AR_SPUR_FEEQ_BOUND_HT40
)) {
1805 bb_spur
= cur_bb_spur
;
1808 } else if ((cur_bb_spur
> -AR_SPUR_FEEQ_BOUND_HT20
) &&
1809 (cur_bb_spur
< AR_SPUR_FEEQ_BOUND_HT20
)) {
1810 bb_spur
= cur_bb_spur
;
1815 if (AR_NO_SPUR
== bb_spur
) {
1816 REG_CLR_BIT(ah
, AR_PHY_FORCE_CLKEN_CCK
,
1817 AR_PHY_FORCE_CLKEN_CCK_MRC_MUX
);
1820 REG_CLR_BIT(ah
, AR_PHY_FORCE_CLKEN_CCK
,
1821 AR_PHY_FORCE_CLKEN_CCK_MRC_MUX
);
1824 bin
= bb_spur
* 320;
1826 tmp
= REG_READ(ah
, AR_PHY_TIMING_CTRL4(0));
1828 newVal
= tmp
| (AR_PHY_TIMING_CTRL4_ENABLE_SPUR_RSSI
|
1829 AR_PHY_TIMING_CTRL4_ENABLE_SPUR_FILTER
|
1830 AR_PHY_TIMING_CTRL4_ENABLE_CHAN_MASK
|
1831 AR_PHY_TIMING_CTRL4_ENABLE_PILOT_MASK
);
1832 REG_WRITE(ah
, AR_PHY_TIMING_CTRL4(0), newVal
);
1834 newVal
= (AR_PHY_SPUR_REG_MASK_RATE_CNTL
|
1835 AR_PHY_SPUR_REG_ENABLE_MASK_PPM
|
1836 AR_PHY_SPUR_REG_MASK_RATE_SELECT
|
1837 AR_PHY_SPUR_REG_ENABLE_VIT_SPUR_RSSI
|
1838 SM(SPUR_RSSI_THRESH
, AR_PHY_SPUR_REG_SPUR_RSSI_THRESH
));
1839 REG_WRITE(ah
, AR_PHY_SPUR_REG
, newVal
);
1841 if (IS_CHAN_HT40(chan
)) {
1843 spur_subchannel_sd
= 1;
1844 bb_spur_off
= bb_spur
+ 10;
1846 spur_subchannel_sd
= 0;
1847 bb_spur_off
= bb_spur
- 10;
1850 spur_subchannel_sd
= 0;
1851 bb_spur_off
= bb_spur
;
1854 if (IS_CHAN_HT40(chan
))
1856 ((bb_spur
* 262144) /
1857 10) & AR_PHY_TIMING11_SPUR_DELTA_PHASE
;
1860 ((bb_spur
* 524288) /
1861 10) & AR_PHY_TIMING11_SPUR_DELTA_PHASE
;
1863 denominator
= IS_CHAN_2GHZ(chan
) ? 44 : 40;
1864 spur_freq_sd
= ((bb_spur_off
* 2048) / denominator
) & 0x3ff;
1866 newVal
= (AR_PHY_TIMING11_USE_SPUR_IN_AGC
|
1867 SM(spur_freq_sd
, AR_PHY_TIMING11_SPUR_FREQ_SD
) |
1868 SM(spur_delta_phase
, AR_PHY_TIMING11_SPUR_DELTA_PHASE
));
1869 REG_WRITE(ah
, AR_PHY_TIMING11
, newVal
);
1871 newVal
= spur_subchannel_sd
<< AR_PHY_SFCORR_SPUR_SUBCHNL_SD_S
;
1872 REG_WRITE(ah
, AR_PHY_SFCORR_EXT
, newVal
);
1878 for (i
= 0; i
< 4; i
++) {
1882 for (bp
= 0; bp
< 30; bp
++) {
1883 if ((cur_bin
> lower
) && (cur_bin
< upper
)) {
1884 pilot_mask
= pilot_mask
| 0x1 << bp
;
1885 chan_mask
= chan_mask
| 0x1 << bp
;
1890 REG_WRITE(ah
, pilot_mask_reg
[i
], pilot_mask
);
1891 REG_WRITE(ah
, chan_mask_reg
[i
], chan_mask
);
1894 cur_vit_mask
= 6100;
1898 for (i
= 0; i
< 123; i
++) {
1899 if ((cur_vit_mask
> lower
) && (cur_vit_mask
< upper
)) {
1901 /* workaround for gcc bug #37014 */
1902 volatile int tmp_v
= abs(cur_vit_mask
- bin
);
1908 if (cur_vit_mask
< 0)
1909 mask_m
[abs(cur_vit_mask
/ 100)] = mask_amt
;
1911 mask_p
[cur_vit_mask
/ 100] = mask_amt
;
1913 cur_vit_mask
-= 100;
1916 tmp_mask
= (mask_m
[46] << 30) | (mask_m
[47] << 28)
1917 | (mask_m
[48] << 26) | (mask_m
[49] << 24)
1918 | (mask_m
[50] << 22) | (mask_m
[51] << 20)
1919 | (mask_m
[52] << 18) | (mask_m
[53] << 16)
1920 | (mask_m
[54] << 14) | (mask_m
[55] << 12)
1921 | (mask_m
[56] << 10) | (mask_m
[57] << 8)
1922 | (mask_m
[58] << 6) | (mask_m
[59] << 4)
1923 | (mask_m
[60] << 2) | (mask_m
[61] << 0);
1924 REG_WRITE(ah
, AR_PHY_BIN_MASK_1
, tmp_mask
);
1925 REG_WRITE(ah
, AR_PHY_VIT_MASK2_M_46_61
, tmp_mask
);
1927 tmp_mask
= (mask_m
[31] << 28)
1928 | (mask_m
[32] << 26) | (mask_m
[33] << 24)
1929 | (mask_m
[34] << 22) | (mask_m
[35] << 20)
1930 | (mask_m
[36] << 18) | (mask_m
[37] << 16)
1931 | (mask_m
[48] << 14) | (mask_m
[39] << 12)
1932 | (mask_m
[40] << 10) | (mask_m
[41] << 8)
1933 | (mask_m
[42] << 6) | (mask_m
[43] << 4)
1934 | (mask_m
[44] << 2) | (mask_m
[45] << 0);
1935 REG_WRITE(ah
, AR_PHY_BIN_MASK_2
, tmp_mask
);
1936 REG_WRITE(ah
, AR_PHY_MASK2_M_31_45
, tmp_mask
);
1938 tmp_mask
= (mask_m
[16] << 30) | (mask_m
[16] << 28)
1939 | (mask_m
[18] << 26) | (mask_m
[18] << 24)
1940 | (mask_m
[20] << 22) | (mask_m
[20] << 20)
1941 | (mask_m
[22] << 18) | (mask_m
[22] << 16)
1942 | (mask_m
[24] << 14) | (mask_m
[24] << 12)
1943 | (mask_m
[25] << 10) | (mask_m
[26] << 8)
1944 | (mask_m
[27] << 6) | (mask_m
[28] << 4)
1945 | (mask_m
[29] << 2) | (mask_m
[30] << 0);
1946 REG_WRITE(ah
, AR_PHY_BIN_MASK_3
, tmp_mask
);
1947 REG_WRITE(ah
, AR_PHY_MASK2_M_16_30
, tmp_mask
);
1949 tmp_mask
= (mask_m
[0] << 30) | (mask_m
[1] << 28)
1950 | (mask_m
[2] << 26) | (mask_m
[3] << 24)
1951 | (mask_m
[4] << 22) | (mask_m
[5] << 20)
1952 | (mask_m
[6] << 18) | (mask_m
[7] << 16)
1953 | (mask_m
[8] << 14) | (mask_m
[9] << 12)
1954 | (mask_m
[10] << 10) | (mask_m
[11] << 8)
1955 | (mask_m
[12] << 6) | (mask_m
[13] << 4)
1956 | (mask_m
[14] << 2) | (mask_m
[15] << 0);
1957 REG_WRITE(ah
, AR_PHY_MASK_CTL
, tmp_mask
);
1958 REG_WRITE(ah
, AR_PHY_MASK2_M_00_15
, tmp_mask
);
1960 tmp_mask
= (mask_p
[15] << 28)
1961 | (mask_p
[14] << 26) | (mask_p
[13] << 24)
1962 | (mask_p
[12] << 22) | (mask_p
[11] << 20)
1963 | (mask_p
[10] << 18) | (mask_p
[9] << 16)
1964 | (mask_p
[8] << 14) | (mask_p
[7] << 12)
1965 | (mask_p
[6] << 10) | (mask_p
[5] << 8)
1966 | (mask_p
[4] << 6) | (mask_p
[3] << 4)
1967 | (mask_p
[2] << 2) | (mask_p
[1] << 0);
1968 REG_WRITE(ah
, AR_PHY_BIN_MASK2_1
, tmp_mask
);
1969 REG_WRITE(ah
, AR_PHY_MASK2_P_15_01
, tmp_mask
);
1971 tmp_mask
= (mask_p
[30] << 28)
1972 | (mask_p
[29] << 26) | (mask_p
[28] << 24)
1973 | (mask_p
[27] << 22) | (mask_p
[26] << 20)
1974 | (mask_p
[25] << 18) | (mask_p
[24] << 16)
1975 | (mask_p
[23] << 14) | (mask_p
[22] << 12)
1976 | (mask_p
[21] << 10) | (mask_p
[20] << 8)
1977 | (mask_p
[19] << 6) | (mask_p
[18] << 4)
1978 | (mask_p
[17] << 2) | (mask_p
[16] << 0);
1979 REG_WRITE(ah
, AR_PHY_BIN_MASK2_2
, tmp_mask
);
1980 REG_WRITE(ah
, AR_PHY_MASK2_P_30_16
, tmp_mask
);
1982 tmp_mask
= (mask_p
[45] << 28)
1983 | (mask_p
[44] << 26) | (mask_p
[43] << 24)
1984 | (mask_p
[42] << 22) | (mask_p
[41] << 20)
1985 | (mask_p
[40] << 18) | (mask_p
[39] << 16)
1986 | (mask_p
[38] << 14) | (mask_p
[37] << 12)
1987 | (mask_p
[36] << 10) | (mask_p
[35] << 8)
1988 | (mask_p
[34] << 6) | (mask_p
[33] << 4)
1989 | (mask_p
[32] << 2) | (mask_p
[31] << 0);
1990 REG_WRITE(ah
, AR_PHY_BIN_MASK2_3
, tmp_mask
);
1991 REG_WRITE(ah
, AR_PHY_MASK2_P_45_31
, tmp_mask
);
1993 tmp_mask
= (mask_p
[61] << 30) | (mask_p
[60] << 28)
1994 | (mask_p
[59] << 26) | (mask_p
[58] << 24)
1995 | (mask_p
[57] << 22) | (mask_p
[56] << 20)
1996 | (mask_p
[55] << 18) | (mask_p
[54] << 16)
1997 | (mask_p
[53] << 14) | (mask_p
[52] << 12)
1998 | (mask_p
[51] << 10) | (mask_p
[50] << 8)
1999 | (mask_p
[49] << 6) | (mask_p
[48] << 4)
2000 | (mask_p
[47] << 2) | (mask_p
[46] << 0);
2001 REG_WRITE(ah
, AR_PHY_BIN_MASK2_4
, tmp_mask
);
2002 REG_WRITE(ah
, AR_PHY_MASK2_P_61_45
, tmp_mask
);
2005 static void ath9k_hw_spur_mitigate(struct ath_hw
*ah
, struct ath9k_channel
*chan
)
2007 int bb_spur
= AR_NO_SPUR
;
2010 int spur_delta_phase
;
2012 int upper
, lower
, cur_vit_mask
;
2015 int pilot_mask_reg
[4] = { AR_PHY_TIMING7
, AR_PHY_TIMING8
,
2016 AR_PHY_PILOT_MASK_01_30
, AR_PHY_PILOT_MASK_31_60
2018 int chan_mask_reg
[4] = { AR_PHY_TIMING9
, AR_PHY_TIMING10
,
2019 AR_PHY_CHANNEL_MASK_01_30
, AR_PHY_CHANNEL_MASK_31_60
2021 int inc
[4] = { 0, 100, 0, 0 };
2028 bool is2GHz
= IS_CHAN_2GHZ(chan
);
2030 memset(&mask_m
, 0, sizeof(int8_t) * 123);
2031 memset(&mask_p
, 0, sizeof(int8_t) * 123);
2033 for (i
= 0; i
< AR_EEPROM_MODAL_SPURS
; i
++) {
2034 cur_bb_spur
= ah
->eep_ops
->get_spur_channel(ah
, i
, is2GHz
);
2035 if (AR_NO_SPUR
== cur_bb_spur
)
2037 cur_bb_spur
= cur_bb_spur
- (chan
->channel
* 10);
2038 if ((cur_bb_spur
> -95) && (cur_bb_spur
< 95)) {
2039 bb_spur
= cur_bb_spur
;
2044 if (AR_NO_SPUR
== bb_spur
)
2049 tmp
= REG_READ(ah
, AR_PHY_TIMING_CTRL4(0));
2050 new = tmp
| (AR_PHY_TIMING_CTRL4_ENABLE_SPUR_RSSI
|
2051 AR_PHY_TIMING_CTRL4_ENABLE_SPUR_FILTER
|
2052 AR_PHY_TIMING_CTRL4_ENABLE_CHAN_MASK
|
2053 AR_PHY_TIMING_CTRL4_ENABLE_PILOT_MASK
);
2055 REG_WRITE(ah
, AR_PHY_TIMING_CTRL4(0), new);
2057 new = (AR_PHY_SPUR_REG_MASK_RATE_CNTL
|
2058 AR_PHY_SPUR_REG_ENABLE_MASK_PPM
|
2059 AR_PHY_SPUR_REG_MASK_RATE_SELECT
|
2060 AR_PHY_SPUR_REG_ENABLE_VIT_SPUR_RSSI
|
2061 SM(SPUR_RSSI_THRESH
, AR_PHY_SPUR_REG_SPUR_RSSI_THRESH
));
2062 REG_WRITE(ah
, AR_PHY_SPUR_REG
, new);
2064 spur_delta_phase
= ((bb_spur
* 524288) / 100) &
2065 AR_PHY_TIMING11_SPUR_DELTA_PHASE
;
2067 denominator
= IS_CHAN_2GHZ(chan
) ? 440 : 400;
2068 spur_freq_sd
= ((bb_spur
* 2048) / denominator
) & 0x3ff;
2070 new = (AR_PHY_TIMING11_USE_SPUR_IN_AGC
|
2071 SM(spur_freq_sd
, AR_PHY_TIMING11_SPUR_FREQ_SD
) |
2072 SM(spur_delta_phase
, AR_PHY_TIMING11_SPUR_DELTA_PHASE
));
2073 REG_WRITE(ah
, AR_PHY_TIMING11
, new);
2079 for (i
= 0; i
< 4; i
++) {
2083 for (bp
= 0; bp
< 30; bp
++) {
2084 if ((cur_bin
> lower
) && (cur_bin
< upper
)) {
2085 pilot_mask
= pilot_mask
| 0x1 << bp
;
2086 chan_mask
= chan_mask
| 0x1 << bp
;
2091 REG_WRITE(ah
, pilot_mask_reg
[i
], pilot_mask
);
2092 REG_WRITE(ah
, chan_mask_reg
[i
], chan_mask
);
2095 cur_vit_mask
= 6100;
2099 for (i
= 0; i
< 123; i
++) {
2100 if ((cur_vit_mask
> lower
) && (cur_vit_mask
< upper
)) {
2102 /* workaround for gcc bug #37014 */
2103 volatile int tmp_v
= abs(cur_vit_mask
- bin
);
2109 if (cur_vit_mask
< 0)
2110 mask_m
[abs(cur_vit_mask
/ 100)] = mask_amt
;
2112 mask_p
[cur_vit_mask
/ 100] = mask_amt
;
2114 cur_vit_mask
-= 100;
2117 tmp_mask
= (mask_m
[46] << 30) | (mask_m
[47] << 28)
2118 | (mask_m
[48] << 26) | (mask_m
[49] << 24)
2119 | (mask_m
[50] << 22) | (mask_m
[51] << 20)
2120 | (mask_m
[52] << 18) | (mask_m
[53] << 16)
2121 | (mask_m
[54] << 14) | (mask_m
[55] << 12)
2122 | (mask_m
[56] << 10) | (mask_m
[57] << 8)
2123 | (mask_m
[58] << 6) | (mask_m
[59] << 4)
2124 | (mask_m
[60] << 2) | (mask_m
[61] << 0);
2125 REG_WRITE(ah
, AR_PHY_BIN_MASK_1
, tmp_mask
);
2126 REG_WRITE(ah
, AR_PHY_VIT_MASK2_M_46_61
, tmp_mask
);
2128 tmp_mask
= (mask_m
[31] << 28)
2129 | (mask_m
[32] << 26) | (mask_m
[33] << 24)
2130 | (mask_m
[34] << 22) | (mask_m
[35] << 20)
2131 | (mask_m
[36] << 18) | (mask_m
[37] << 16)
2132 | (mask_m
[48] << 14) | (mask_m
[39] << 12)
2133 | (mask_m
[40] << 10) | (mask_m
[41] << 8)
2134 | (mask_m
[42] << 6) | (mask_m
[43] << 4)
2135 | (mask_m
[44] << 2) | (mask_m
[45] << 0);
2136 REG_WRITE(ah
, AR_PHY_BIN_MASK_2
, tmp_mask
);
2137 REG_WRITE(ah
, AR_PHY_MASK2_M_31_45
, tmp_mask
);
2139 tmp_mask
= (mask_m
[16] << 30) | (mask_m
[16] << 28)
2140 | (mask_m
[18] << 26) | (mask_m
[18] << 24)
2141 | (mask_m
[20] << 22) | (mask_m
[20] << 20)
2142 | (mask_m
[22] << 18) | (mask_m
[22] << 16)
2143 | (mask_m
[24] << 14) | (mask_m
[24] << 12)
2144 | (mask_m
[25] << 10) | (mask_m
[26] << 8)
2145 | (mask_m
[27] << 6) | (mask_m
[28] << 4)
2146 | (mask_m
[29] << 2) | (mask_m
[30] << 0);
2147 REG_WRITE(ah
, AR_PHY_BIN_MASK_3
, tmp_mask
);
2148 REG_WRITE(ah
, AR_PHY_MASK2_M_16_30
, tmp_mask
);
2150 tmp_mask
= (mask_m
[0] << 30) | (mask_m
[1] << 28)
2151 | (mask_m
[2] << 26) | (mask_m
[3] << 24)
2152 | (mask_m
[4] << 22) | (mask_m
[5] << 20)
2153 | (mask_m
[6] << 18) | (mask_m
[7] << 16)
2154 | (mask_m
[8] << 14) | (mask_m
[9] << 12)
2155 | (mask_m
[10] << 10) | (mask_m
[11] << 8)
2156 | (mask_m
[12] << 6) | (mask_m
[13] << 4)
2157 | (mask_m
[14] << 2) | (mask_m
[15] << 0);
2158 REG_WRITE(ah
, AR_PHY_MASK_CTL
, tmp_mask
);
2159 REG_WRITE(ah
, AR_PHY_MASK2_M_00_15
, tmp_mask
);
2161 tmp_mask
= (mask_p
[15] << 28)
2162 | (mask_p
[14] << 26) | (mask_p
[13] << 24)
2163 | (mask_p
[12] << 22) | (mask_p
[11] << 20)
2164 | (mask_p
[10] << 18) | (mask_p
[9] << 16)
2165 | (mask_p
[8] << 14) | (mask_p
[7] << 12)
2166 | (mask_p
[6] << 10) | (mask_p
[5] << 8)
2167 | (mask_p
[4] << 6) | (mask_p
[3] << 4)
2168 | (mask_p
[2] << 2) | (mask_p
[1] << 0);
2169 REG_WRITE(ah
, AR_PHY_BIN_MASK2_1
, tmp_mask
);
2170 REG_WRITE(ah
, AR_PHY_MASK2_P_15_01
, tmp_mask
);
2172 tmp_mask
= (mask_p
[30] << 28)
2173 | (mask_p
[29] << 26) | (mask_p
[28] << 24)
2174 | (mask_p
[27] << 22) | (mask_p
[26] << 20)
2175 | (mask_p
[25] << 18) | (mask_p
[24] << 16)
2176 | (mask_p
[23] << 14) | (mask_p
[22] << 12)
2177 | (mask_p
[21] << 10) | (mask_p
[20] << 8)
2178 | (mask_p
[19] << 6) | (mask_p
[18] << 4)
2179 | (mask_p
[17] << 2) | (mask_p
[16] << 0);
2180 REG_WRITE(ah
, AR_PHY_BIN_MASK2_2
, tmp_mask
);
2181 REG_WRITE(ah
, AR_PHY_MASK2_P_30_16
, tmp_mask
);
2183 tmp_mask
= (mask_p
[45] << 28)
2184 | (mask_p
[44] << 26) | (mask_p
[43] << 24)
2185 | (mask_p
[42] << 22) | (mask_p
[41] << 20)
2186 | (mask_p
[40] << 18) | (mask_p
[39] << 16)
2187 | (mask_p
[38] << 14) | (mask_p
[37] << 12)
2188 | (mask_p
[36] << 10) | (mask_p
[35] << 8)
2189 | (mask_p
[34] << 6) | (mask_p
[33] << 4)
2190 | (mask_p
[32] << 2) | (mask_p
[31] << 0);
2191 REG_WRITE(ah
, AR_PHY_BIN_MASK2_3
, tmp_mask
);
2192 REG_WRITE(ah
, AR_PHY_MASK2_P_45_31
, tmp_mask
);
2194 tmp_mask
= (mask_p
[61] << 30) | (mask_p
[60] << 28)
2195 | (mask_p
[59] << 26) | (mask_p
[58] << 24)
2196 | (mask_p
[57] << 22) | (mask_p
[56] << 20)
2197 | (mask_p
[55] << 18) | (mask_p
[54] << 16)
2198 | (mask_p
[53] << 14) | (mask_p
[52] << 12)
2199 | (mask_p
[51] << 10) | (mask_p
[50] << 8)
2200 | (mask_p
[49] << 6) | (mask_p
[48] << 4)
2201 | (mask_p
[47] << 2) | (mask_p
[46] << 0);
2202 REG_WRITE(ah
, AR_PHY_BIN_MASK2_4
, tmp_mask
);
2203 REG_WRITE(ah
, AR_PHY_MASK2_P_61_45
, tmp_mask
);
2206 int ath9k_hw_reset(struct ath_hw
*ah
, struct ath9k_channel
*chan
,
2207 bool bChannelChange
)
2210 struct ath_softc
*sc
= ah
->ah_sc
;
2211 struct ath9k_channel
*curchan
= ah
->curchan
;
2214 int i
, rx_chainmask
, r
;
2216 ah
->extprotspacing
= sc
->ht_extprotspacing
;
2217 ah
->txchainmask
= sc
->tx_chainmask
;
2218 ah
->rxchainmask
= sc
->rx_chainmask
;
2220 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
))
2224 ath9k_hw_getnf(ah
, curchan
);
2226 if (bChannelChange
&&
2227 (ah
->chip_fullsleep
!= true) &&
2228 (ah
->curchan
!= NULL
) &&
2229 (chan
->channel
!= ah
->curchan
->channel
) &&
2230 ((chan
->channelFlags
& CHANNEL_ALL
) ==
2231 (ah
->curchan
->channelFlags
& CHANNEL_ALL
)) &&
2232 (!AR_SREV_9280(ah
) || (!IS_CHAN_A_5MHZ_SPACED(chan
) &&
2233 !IS_CHAN_A_5MHZ_SPACED(ah
->curchan
)))) {
2235 if (ath9k_hw_channel_change(ah
, chan
, sc
->tx_chan_width
)) {
2236 ath9k_hw_loadnf(ah
, ah
->curchan
);
2237 ath9k_hw_start_nfcal(ah
);
2242 saveDefAntenna
= REG_READ(ah
, AR_DEF_ANTENNA
);
2243 if (saveDefAntenna
== 0)
2246 macStaId1
= REG_READ(ah
, AR_STA_ID1
) & AR_STA_ID1_BASE_RATE_11B
;
2248 saveLedState
= REG_READ(ah
, AR_CFG_LED
) &
2249 (AR_CFG_LED_ASSOC_CTL
| AR_CFG_LED_MODE_SEL
|
2250 AR_CFG_LED_BLINK_THRESH_SEL
| AR_CFG_LED_BLINK_SLOW
);
2252 ath9k_hw_mark_phy_inactive(ah
);
2254 if (!ath9k_hw_chip_reset(ah
, chan
)) {
2255 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
, "Chip reset failed\n");
2259 if (AR_SREV_9280_10_OR_LATER(ah
))
2260 REG_SET_BIT(ah
, AR_GPIO_INPUT_EN_VAL
, AR_GPIO_JTAG_DISABLE
);
2262 r
= ath9k_hw_process_ini(ah
, chan
, sc
->tx_chan_width
);
2266 /* Setup MFP options for CCMP */
2267 if (AR_SREV_9280_20_OR_LATER(ah
)) {
2268 /* Mask Retry(b11), PwrMgt(b12), MoreData(b13) to 0 in mgmt
2269 * frames when constructing CCMP AAD. */
2270 REG_RMW_FIELD(ah
, AR_AES_MUTE_MASK1
, AR_AES_MUTE_MASK1_FC_MGMT
,
2272 ah
->sw_mgmt_crypto
= false;
2273 } else if (AR_SREV_9160_10_OR_LATER(ah
)) {
2274 /* Disable hardware crypto for management frames */
2275 REG_CLR_BIT(ah
, AR_PCU_MISC_MODE2
,
2276 AR_PCU_MISC_MODE2_MGMT_CRYPTO_ENABLE
);
2277 REG_SET_BIT(ah
, AR_PCU_MISC_MODE2
,
2278 AR_PCU_MISC_MODE2_NO_CRYPTO_FOR_NON_DATA_PKT
);
2279 ah
->sw_mgmt_crypto
= true;
2281 ah
->sw_mgmt_crypto
= true;
2283 if (IS_CHAN_OFDM(chan
) || IS_CHAN_HT(chan
))
2284 ath9k_hw_set_delta_slope(ah
, chan
);
2286 if (AR_SREV_9280_10_OR_LATER(ah
))
2287 ath9k_hw_9280_spur_mitigate(ah
, chan
);
2289 ath9k_hw_spur_mitigate(ah
, chan
);
2291 ah
->eep_ops
->set_board_values(ah
, chan
);
2293 ath9k_hw_decrease_chain_power(ah
, chan
);
2295 REG_WRITE(ah
, AR_STA_ID0
, get_unaligned_le32(ah
->macaddr
));
2296 REG_WRITE(ah
, AR_STA_ID1
, get_unaligned_le16(ah
->macaddr
+ 4)
2298 | AR_STA_ID1_RTS_USE_DEF
2300 ack_6mb
? AR_STA_ID1_ACKCTS_6MB
: 0)
2301 | ah
->sta_id1_defaults
);
2302 ath9k_hw_set_operating_mode(ah
, ah
->opmode
);
2304 REG_WRITE(ah
, AR_BSSMSKL
, get_unaligned_le32(sc
->bssidmask
));
2305 REG_WRITE(ah
, AR_BSSMSKU
, get_unaligned_le16(sc
->bssidmask
+ 4));
2307 REG_WRITE(ah
, AR_DEF_ANTENNA
, saveDefAntenna
);
2309 REG_WRITE(ah
, AR_BSS_ID0
, get_unaligned_le32(sc
->curbssid
));
2310 REG_WRITE(ah
, AR_BSS_ID1
, get_unaligned_le16(sc
->curbssid
+ 4) |
2311 ((sc
->curaid
& 0x3fff) << AR_BSS_ID1_AID_S
));
2313 REG_WRITE(ah
, AR_ISR
, ~0);
2315 REG_WRITE(ah
, AR_RSSI_THR
, INIT_RSSI_THR
);
2317 if (AR_SREV_9280_10_OR_LATER(ah
)) {
2318 if (!(ath9k_hw_ar9280_set_channel(ah
, chan
)))
2321 if (!(ath9k_hw_set_channel(ah
, chan
)))
2325 for (i
= 0; i
< AR_NUM_DCU
; i
++)
2326 REG_WRITE(ah
, AR_DQCUMASK(i
), 1 << i
);
2329 for (i
= 0; i
< ah
->caps
.total_queues
; i
++)
2330 ath9k_hw_resettxqueue(ah
, i
);
2332 ath9k_hw_init_interrupt_masks(ah
, ah
->opmode
);
2333 ath9k_hw_init_qos(ah
);
2335 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
2336 if (ah
->caps
.hw_caps
& ATH9K_HW_CAP_RFSILENT
)
2337 ath9k_enable_rfkill(ah
);
2339 ath9k_hw_init_user_settings(ah
);
2341 REG_WRITE(ah
, AR_STA_ID1
,
2342 REG_READ(ah
, AR_STA_ID1
) | AR_STA_ID1_PRESERVE_SEQNUM
);
2344 ath9k_hw_set_dma(ah
);
2346 REG_WRITE(ah
, AR_OBS
, 8);
2348 if (ah
->config
.intr_mitigation
) {
2349 REG_RMW_FIELD(ah
, AR_RIMT
, AR_RIMT_LAST
, 500);
2350 REG_RMW_FIELD(ah
, AR_RIMT
, AR_RIMT_FIRST
, 2000);
2353 ath9k_hw_init_bb(ah
, chan
);
2355 if (!ath9k_hw_init_cal(ah
, chan
))
2358 rx_chainmask
= ah
->rxchainmask
;
2359 if ((rx_chainmask
== 0x5) || (rx_chainmask
== 0x3)) {
2360 REG_WRITE(ah
, AR_PHY_RX_CHAINMASK
, rx_chainmask
);
2361 REG_WRITE(ah
, AR_PHY_CAL_CHAINMASK
, rx_chainmask
);
2364 REG_WRITE(ah
, AR_CFG_LED
, saveLedState
| AR_CFG_SCLK_32KHZ
);
2366 if (AR_SREV_9100(ah
)) {
2368 mask
= REG_READ(ah
, AR_CFG
);
2369 if (mask
& (AR_CFG_SWRB
| AR_CFG_SWTB
| AR_CFG_SWRG
)) {
2370 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
2371 "CFG Byte Swap Set 0x%x\n", mask
);
2374 INIT_CONFIG_STATUS
| AR_CFG_SWRB
| AR_CFG_SWTB
;
2375 REG_WRITE(ah
, AR_CFG
, mask
);
2376 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
2377 "Setting CFG 0x%x\n", REG_READ(ah
, AR_CFG
));
2381 REG_WRITE(ah
, AR_CFG
, AR_CFG_SWTD
| AR_CFG_SWRD
);
2388 /************************/
2389 /* Key Cache Management */
2390 /************************/
2392 bool ath9k_hw_keyreset(struct ath_hw
*ah
, u16 entry
)
2396 if (entry
>= ah
->caps
.keycache_size
) {
2397 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
2398 "keychache entry %u out of range\n", entry
);
2402 keyType
= REG_READ(ah
, AR_KEYTABLE_TYPE(entry
));
2404 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), 0);
2405 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), 0);
2406 REG_WRITE(ah
, AR_KEYTABLE_KEY2(entry
), 0);
2407 REG_WRITE(ah
, AR_KEYTABLE_KEY3(entry
), 0);
2408 REG_WRITE(ah
, AR_KEYTABLE_KEY4(entry
), 0);
2409 REG_WRITE(ah
, AR_KEYTABLE_TYPE(entry
), AR_KEYTABLE_TYPE_CLR
);
2410 REG_WRITE(ah
, AR_KEYTABLE_MAC0(entry
), 0);
2411 REG_WRITE(ah
, AR_KEYTABLE_MAC1(entry
), 0);
2413 if (keyType
== AR_KEYTABLE_TYPE_TKIP
&& ATH9K_IS_MIC_ENABLED(ah
)) {
2414 u16 micentry
= entry
+ 64;
2416 REG_WRITE(ah
, AR_KEYTABLE_KEY0(micentry
), 0);
2417 REG_WRITE(ah
, AR_KEYTABLE_KEY1(micentry
), 0);
2418 REG_WRITE(ah
, AR_KEYTABLE_KEY2(micentry
), 0);
2419 REG_WRITE(ah
, AR_KEYTABLE_KEY3(micentry
), 0);
2423 if (ah
->curchan
== NULL
)
2429 bool ath9k_hw_keysetmac(struct ath_hw
*ah
, u16 entry
, const u8
*mac
)
2433 if (entry
>= ah
->caps
.keycache_size
) {
2434 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
2435 "keychache entry %u out of range\n", entry
);
2440 macHi
= (mac
[5] << 8) | mac
[4];
2441 macLo
= (mac
[3] << 24) |
2446 macLo
|= (macHi
& 1) << 31;
2451 REG_WRITE(ah
, AR_KEYTABLE_MAC0(entry
), macLo
);
2452 REG_WRITE(ah
, AR_KEYTABLE_MAC1(entry
), macHi
| AR_KEYTABLE_VALID
);
2457 bool ath9k_hw_set_keycache_entry(struct ath_hw
*ah
, u16 entry
,
2458 const struct ath9k_keyval
*k
,
2461 const struct ath9k_hw_capabilities
*pCap
= &ah
->caps
;
2462 u32 key0
, key1
, key2
, key3
, key4
;
2465 if (entry
>= pCap
->keycache_size
) {
2466 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
2467 "keycache entry %u out of range\n", entry
);
2471 switch (k
->kv_type
) {
2472 case ATH9K_CIPHER_AES_OCB
:
2473 keyType
= AR_KEYTABLE_TYPE_AES
;
2475 case ATH9K_CIPHER_AES_CCM
:
2476 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_CIPHER_AESCCM
)) {
2477 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2478 "AES-CCM not supported by mac rev 0x%x\n",
2479 ah
->hw_version
.macRev
);
2482 keyType
= AR_KEYTABLE_TYPE_CCM
;
2484 case ATH9K_CIPHER_TKIP
:
2485 keyType
= AR_KEYTABLE_TYPE_TKIP
;
2486 if (ATH9K_IS_MIC_ENABLED(ah
)
2487 && entry
+ 64 >= pCap
->keycache_size
) {
2488 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2489 "entry %u inappropriate for TKIP\n", entry
);
2493 case ATH9K_CIPHER_WEP
:
2494 if (k
->kv_len
< LEN_WEP40
) {
2495 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
2496 "WEP key length %u too small\n", k
->kv_len
);
2499 if (k
->kv_len
<= LEN_WEP40
)
2500 keyType
= AR_KEYTABLE_TYPE_40
;
2501 else if (k
->kv_len
<= LEN_WEP104
)
2502 keyType
= AR_KEYTABLE_TYPE_104
;
2504 keyType
= AR_KEYTABLE_TYPE_128
;
2506 case ATH9K_CIPHER_CLR
:
2507 keyType
= AR_KEYTABLE_TYPE_CLR
;
2510 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
2511 "cipher %u not supported\n", k
->kv_type
);
2515 key0
= get_unaligned_le32(k
->kv_val
+ 0);
2516 key1
= get_unaligned_le16(k
->kv_val
+ 4);
2517 key2
= get_unaligned_le32(k
->kv_val
+ 6);
2518 key3
= get_unaligned_le16(k
->kv_val
+ 10);
2519 key4
= get_unaligned_le32(k
->kv_val
+ 12);
2520 if (k
->kv_len
<= LEN_WEP104
)
2524 * Note: Key cache registers access special memory area that requires
2525 * two 32-bit writes to actually update the values in the internal
2526 * memory. Consequently, the exact order and pairs used here must be
2530 if (keyType
== AR_KEYTABLE_TYPE_TKIP
&& ATH9K_IS_MIC_ENABLED(ah
)) {
2531 u16 micentry
= entry
+ 64;
2534 * Write inverted key[47:0] first to avoid Michael MIC errors
2535 * on frames that could be sent or received at the same time.
2536 * The correct key will be written in the end once everything
2539 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), ~key0
);
2540 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), ~key1
);
2542 /* Write key[95:48] */
2543 REG_WRITE(ah
, AR_KEYTABLE_KEY2(entry
), key2
);
2544 REG_WRITE(ah
, AR_KEYTABLE_KEY3(entry
), key3
);
2546 /* Write key[127:96] and key type */
2547 REG_WRITE(ah
, AR_KEYTABLE_KEY4(entry
), key4
);
2548 REG_WRITE(ah
, AR_KEYTABLE_TYPE(entry
), keyType
);
2550 /* Write MAC address for the entry */
2551 (void) ath9k_hw_keysetmac(ah
, entry
, mac
);
2553 if (ah
->misc_mode
& AR_PCU_MIC_NEW_LOC_ENA
) {
2555 * TKIP uses two key cache entries:
2556 * Michael MIC TX/RX keys in the same key cache entry
2557 * (idx = main index + 64):
2558 * key0 [31:0] = RX key [31:0]
2559 * key1 [15:0] = TX key [31:16]
2560 * key1 [31:16] = reserved
2561 * key2 [31:0] = RX key [63:32]
2562 * key3 [15:0] = TX key [15:0]
2563 * key3 [31:16] = reserved
2564 * key4 [31:0] = TX key [63:32]
2566 u32 mic0
, mic1
, mic2
, mic3
, mic4
;
2568 mic0
= get_unaligned_le32(k
->kv_mic
+ 0);
2569 mic2
= get_unaligned_le32(k
->kv_mic
+ 4);
2570 mic1
= get_unaligned_le16(k
->kv_txmic
+ 2) & 0xffff;
2571 mic3
= get_unaligned_le16(k
->kv_txmic
+ 0) & 0xffff;
2572 mic4
= get_unaligned_le32(k
->kv_txmic
+ 4);
2574 /* Write RX[31:0] and TX[31:16] */
2575 REG_WRITE(ah
, AR_KEYTABLE_KEY0(micentry
), mic0
);
2576 REG_WRITE(ah
, AR_KEYTABLE_KEY1(micentry
), mic1
);
2578 /* Write RX[63:32] and TX[15:0] */
2579 REG_WRITE(ah
, AR_KEYTABLE_KEY2(micentry
), mic2
);
2580 REG_WRITE(ah
, AR_KEYTABLE_KEY3(micentry
), mic3
);
2582 /* Write TX[63:32] and keyType(reserved) */
2583 REG_WRITE(ah
, AR_KEYTABLE_KEY4(micentry
), mic4
);
2584 REG_WRITE(ah
, AR_KEYTABLE_TYPE(micentry
),
2585 AR_KEYTABLE_TYPE_CLR
);
2589 * TKIP uses four key cache entries (two for group
2591 * Michael MIC TX/RX keys are in different key cache
2592 * entries (idx = main index + 64 for TX and
2593 * main index + 32 + 96 for RX):
2594 * key0 [31:0] = TX/RX MIC key [31:0]
2595 * key1 [31:0] = reserved
2596 * key2 [31:0] = TX/RX MIC key [63:32]
2597 * key3 [31:0] = reserved
2598 * key4 [31:0] = reserved
2600 * Upper layer code will call this function separately
2601 * for TX and RX keys when these registers offsets are
2606 mic0
= get_unaligned_le32(k
->kv_mic
+ 0);
2607 mic2
= get_unaligned_le32(k
->kv_mic
+ 4);
2609 /* Write MIC key[31:0] */
2610 REG_WRITE(ah
, AR_KEYTABLE_KEY0(micentry
), mic0
);
2611 REG_WRITE(ah
, AR_KEYTABLE_KEY1(micentry
), 0);
2613 /* Write MIC key[63:32] */
2614 REG_WRITE(ah
, AR_KEYTABLE_KEY2(micentry
), mic2
);
2615 REG_WRITE(ah
, AR_KEYTABLE_KEY3(micentry
), 0);
2617 /* Write TX[63:32] and keyType(reserved) */
2618 REG_WRITE(ah
, AR_KEYTABLE_KEY4(micentry
), 0);
2619 REG_WRITE(ah
, AR_KEYTABLE_TYPE(micentry
),
2620 AR_KEYTABLE_TYPE_CLR
);
2623 /* MAC address registers are reserved for the MIC entry */
2624 REG_WRITE(ah
, AR_KEYTABLE_MAC0(micentry
), 0);
2625 REG_WRITE(ah
, AR_KEYTABLE_MAC1(micentry
), 0);
2628 * Write the correct (un-inverted) key[47:0] last to enable
2629 * TKIP now that all other registers are set with correct
2632 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), key0
);
2633 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), key1
);
2635 /* Write key[47:0] */
2636 REG_WRITE(ah
, AR_KEYTABLE_KEY0(entry
), key0
);
2637 REG_WRITE(ah
, AR_KEYTABLE_KEY1(entry
), key1
);
2639 /* Write key[95:48] */
2640 REG_WRITE(ah
, AR_KEYTABLE_KEY2(entry
), key2
);
2641 REG_WRITE(ah
, AR_KEYTABLE_KEY3(entry
), key3
);
2643 /* Write key[127:96] and key type */
2644 REG_WRITE(ah
, AR_KEYTABLE_KEY4(entry
), key4
);
2645 REG_WRITE(ah
, AR_KEYTABLE_TYPE(entry
), keyType
);
2647 /* Write MAC address for the entry */
2648 (void) ath9k_hw_keysetmac(ah
, entry
, mac
);
2654 bool ath9k_hw_keyisvalid(struct ath_hw
*ah
, u16 entry
)
2656 if (entry
< ah
->caps
.keycache_size
) {
2657 u32 val
= REG_READ(ah
, AR_KEYTABLE_MAC1(entry
));
2658 if (val
& AR_KEYTABLE_VALID
)
2664 /******************************/
2665 /* Power Management (Chipset) */
2666 /******************************/
2668 static void ath9k_set_power_sleep(struct ath_hw
*ah
, int setChip
)
2670 REG_SET_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PWR_SAV
);
2672 REG_CLR_BIT(ah
, AR_RTC_FORCE_WAKE
,
2673 AR_RTC_FORCE_WAKE_EN
);
2674 if (!AR_SREV_9100(ah
))
2675 REG_WRITE(ah
, AR_RC
, AR_RC_AHB
| AR_RC_HOSTIF
);
2677 REG_CLR_BIT(ah
, (AR_RTC_RESET
),
2682 static void ath9k_set_power_network_sleep(struct ath_hw
*ah
, int setChip
)
2684 REG_SET_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PWR_SAV
);
2686 struct ath9k_hw_capabilities
*pCap
= &ah
->caps
;
2688 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)) {
2689 REG_WRITE(ah
, AR_RTC_FORCE_WAKE
,
2690 AR_RTC_FORCE_WAKE_ON_INT
);
2692 REG_CLR_BIT(ah
, AR_RTC_FORCE_WAKE
,
2693 AR_RTC_FORCE_WAKE_EN
);
2698 static bool ath9k_hw_set_power_awake(struct ath_hw
*ah
, int setChip
)
2704 if ((REG_READ(ah
, AR_RTC_STATUS
) &
2705 AR_RTC_STATUS_M
) == AR_RTC_STATUS_SHUTDOWN
) {
2706 if (ath9k_hw_set_reset_reg(ah
,
2707 ATH9K_RESET_POWER_ON
) != true) {
2711 if (AR_SREV_9100(ah
))
2712 REG_SET_BIT(ah
, AR_RTC_RESET
,
2715 REG_SET_BIT(ah
, AR_RTC_FORCE_WAKE
,
2716 AR_RTC_FORCE_WAKE_EN
);
2719 for (i
= POWER_UP_TIME
/ 50; i
> 0; i
--) {
2720 val
= REG_READ(ah
, AR_RTC_STATUS
) & AR_RTC_STATUS_M
;
2721 if (val
== AR_RTC_STATUS_ON
)
2724 REG_SET_BIT(ah
, AR_RTC_FORCE_WAKE
,
2725 AR_RTC_FORCE_WAKE_EN
);
2728 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
2729 "Failed to wakeup in %uus\n", POWER_UP_TIME
/ 20);
2734 REG_CLR_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PWR_SAV
);
2739 bool ath9k_hw_setpower(struct ath_hw
*ah
, enum ath9k_power_mode mode
)
2741 int status
= true, setChip
= true;
2742 static const char *modes
[] = {
2749 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "%s -> %s\n",
2750 modes
[ah
->power_mode
], modes
[mode
]);
2753 case ATH9K_PM_AWAKE
:
2754 status
= ath9k_hw_set_power_awake(ah
, setChip
);
2756 case ATH9K_PM_FULL_SLEEP
:
2757 ath9k_set_power_sleep(ah
, setChip
);
2758 ah
->chip_fullsleep
= true;
2760 case ATH9K_PM_NETWORK_SLEEP
:
2761 ath9k_set_power_network_sleep(ah
, setChip
);
2764 DPRINTF(ah
->ah_sc
, ATH_DBG_FATAL
,
2765 "Unknown power mode %u\n", mode
);
2768 ah
->power_mode
= mode
;
2774 * Helper for ASPM support.
2776 * Disable PLL when in L0s as well as receiver clock when in L1.
2777 * This power saving option must be enabled through the SerDes.
2779 * Programming the SerDes must go through the same 288 bit serial shift
2780 * register as the other analog registers. Hence the 9 writes.
2782 void ath9k_hw_configpcipowersave(struct ath_hw
*ah
, int restore
)
2786 if (ah
->is_pciexpress
!= true)
2789 /* Do not touch SerDes registers */
2790 if (ah
->config
.pcie_powersave_enable
== 2)
2793 /* Nothing to do on restore for 11N */
2797 if (AR_SREV_9280_20_OR_LATER(ah
)) {
2799 * AR9280 2.0 or later chips use SerDes values from the
2800 * initvals.h initialized depending on chipset during
2801 * ath9k_hw_do_attach()
2803 for (i
= 0; i
< ah
->iniPcieSerdes
.ia_rows
; i
++) {
2804 REG_WRITE(ah
, INI_RA(&ah
->iniPcieSerdes
, i
, 0),
2805 INI_RA(&ah
->iniPcieSerdes
, i
, 1));
2807 } else if (AR_SREV_9280(ah
) &&
2808 (ah
->hw_version
.macRev
== AR_SREV_REVISION_9280_10
)) {
2809 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x9248fd00);
2810 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x24924924);
2812 /* RX shut off when elecidle is asserted */
2813 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xa8000019);
2814 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x13160820);
2815 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xe5980560);
2817 /* Shut off CLKREQ active in L1 */
2818 if (ah
->config
.pcie_clock_req
)
2819 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x401deffc);
2821 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x401deffd);
2823 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x1aaabe40);
2824 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xbe105554);
2825 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x00043007);
2827 /* Load the new settings */
2828 REG_WRITE(ah
, AR_PCIE_SERDES2
, 0x00000000);
2831 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x9248fc00);
2832 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x24924924);
2834 /* RX shut off when elecidle is asserted */
2835 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x28000039);
2836 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x53160824);
2837 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xe5980579);
2840 * Ignore ah->ah_config.pcie_clock_req setting for
2843 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x001defff);
2845 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x1aaabe40);
2846 REG_WRITE(ah
, AR_PCIE_SERDES
, 0xbe105554);
2847 REG_WRITE(ah
, AR_PCIE_SERDES
, 0x000e3007);
2849 /* Load the new settings */
2850 REG_WRITE(ah
, AR_PCIE_SERDES2
, 0x00000000);
2855 /* set bit 19 to allow forcing of pcie core into L1 state */
2856 REG_SET_BIT(ah
, AR_PCIE_PM_CTRL
, AR_PCIE_PM_CTRL_ENA
);
2858 /* Several PCIe massages to ensure proper behaviour */
2859 if (ah
->config
.pcie_waen
) {
2860 REG_WRITE(ah
, AR_WA
, ah
->config
.pcie_waen
);
2862 if (AR_SREV_9285(ah
))
2863 REG_WRITE(ah
, AR_WA
, AR9285_WA_DEFAULT
);
2865 * On AR9280 chips bit 22 of 0x4004 needs to be set to
2866 * otherwise card may disappear.
2868 else if (AR_SREV_9280(ah
))
2869 REG_WRITE(ah
, AR_WA
, AR9280_WA_DEFAULT
);
2871 REG_WRITE(ah
, AR_WA
, AR_WA_DEFAULT
);
2875 /**********************/
2876 /* Interrupt Handling */
2877 /**********************/
2879 bool ath9k_hw_intrpend(struct ath_hw
*ah
)
2883 if (AR_SREV_9100(ah
))
2886 host_isr
= REG_READ(ah
, AR_INTR_ASYNC_CAUSE
);
2887 if ((host_isr
& AR_INTR_MAC_IRQ
) && (host_isr
!= AR_INTR_SPURIOUS
))
2890 host_isr
= REG_READ(ah
, AR_INTR_SYNC_CAUSE
);
2891 if ((host_isr
& AR_INTR_SYNC_DEFAULT
)
2892 && (host_isr
!= AR_INTR_SPURIOUS
))
2898 bool ath9k_hw_getisr(struct ath_hw
*ah
, enum ath9k_int
*masked
)
2902 struct ath9k_hw_capabilities
*pCap
= &ah
->caps
;
2904 bool fatal_int
= false;
2906 if (!AR_SREV_9100(ah
)) {
2907 if (REG_READ(ah
, AR_INTR_ASYNC_CAUSE
) & AR_INTR_MAC_IRQ
) {
2908 if ((REG_READ(ah
, AR_RTC_STATUS
) & AR_RTC_STATUS_M
)
2909 == AR_RTC_STATUS_ON
) {
2910 isr
= REG_READ(ah
, AR_ISR
);
2914 sync_cause
= REG_READ(ah
, AR_INTR_SYNC_CAUSE
) &
2915 AR_INTR_SYNC_DEFAULT
;
2919 if (!isr
&& !sync_cause
)
2923 isr
= REG_READ(ah
, AR_ISR
);
2927 if (isr
& AR_ISR_BCNMISC
) {
2929 isr2
= REG_READ(ah
, AR_ISR_S2
);
2930 if (isr2
& AR_ISR_S2_TIM
)
2931 mask2
|= ATH9K_INT_TIM
;
2932 if (isr2
& AR_ISR_S2_DTIM
)
2933 mask2
|= ATH9K_INT_DTIM
;
2934 if (isr2
& AR_ISR_S2_DTIMSYNC
)
2935 mask2
|= ATH9K_INT_DTIMSYNC
;
2936 if (isr2
& (AR_ISR_S2_CABEND
))
2937 mask2
|= ATH9K_INT_CABEND
;
2938 if (isr2
& AR_ISR_S2_GTT
)
2939 mask2
|= ATH9K_INT_GTT
;
2940 if (isr2
& AR_ISR_S2_CST
)
2941 mask2
|= ATH9K_INT_CST
;
2942 if (isr2
& AR_ISR_S2_TSFOOR
)
2943 mask2
|= ATH9K_INT_TSFOOR
;
2946 isr
= REG_READ(ah
, AR_ISR_RAC
);
2947 if (isr
== 0xffffffff) {
2952 *masked
= isr
& ATH9K_INT_COMMON
;
2954 if (ah
->config
.intr_mitigation
) {
2955 if (isr
& (AR_ISR_RXMINTR
| AR_ISR_RXINTM
))
2956 *masked
|= ATH9K_INT_RX
;
2959 if (isr
& (AR_ISR_RXOK
| AR_ISR_RXERR
))
2960 *masked
|= ATH9K_INT_RX
;
2962 (AR_ISR_TXOK
| AR_ISR_TXDESC
| AR_ISR_TXERR
|
2966 *masked
|= ATH9K_INT_TX
;
2968 s0_s
= REG_READ(ah
, AR_ISR_S0_S
);
2969 ah
->intr_txqs
|= MS(s0_s
, AR_ISR_S0_QCU_TXOK
);
2970 ah
->intr_txqs
|= MS(s0_s
, AR_ISR_S0_QCU_TXDESC
);
2972 s1_s
= REG_READ(ah
, AR_ISR_S1_S
);
2973 ah
->intr_txqs
|= MS(s1_s
, AR_ISR_S1_QCU_TXERR
);
2974 ah
->intr_txqs
|= MS(s1_s
, AR_ISR_S1_QCU_TXEOL
);
2977 if (isr
& AR_ISR_RXORN
) {
2978 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
2979 "receive FIFO overrun interrupt\n");
2982 if (!AR_SREV_9100(ah
)) {
2983 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)) {
2984 u32 isr5
= REG_READ(ah
, AR_ISR_S5_S
);
2985 if (isr5
& AR_ISR_S5_TIM_TIMER
)
2986 *masked
|= ATH9K_INT_TIM_TIMER
;
2993 if (AR_SREV_9100(ah
))
2999 (AR_INTR_SYNC_HOST1_FATAL
| AR_INTR_SYNC_HOST1_PERR
))
3003 if (sync_cause
& AR_INTR_SYNC_HOST1_FATAL
) {
3004 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
3005 "received PCI FATAL interrupt\n");
3007 if (sync_cause
& AR_INTR_SYNC_HOST1_PERR
) {
3008 DPRINTF(ah
->ah_sc
, ATH_DBG_ANY
,
3009 "received PCI PERR interrupt\n");
3011 *masked
|= ATH9K_INT_FATAL
;
3013 if (sync_cause
& AR_INTR_SYNC_RADM_CPL_TIMEOUT
) {
3014 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
3015 "AR_INTR_SYNC_RADM_CPL_TIMEOUT\n");
3016 REG_WRITE(ah
, AR_RC
, AR_RC_HOSTIF
);
3017 REG_WRITE(ah
, AR_RC
, 0);
3018 *masked
|= ATH9K_INT_FATAL
;
3020 if (sync_cause
& AR_INTR_SYNC_LOCAL_TIMEOUT
) {
3021 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
,
3022 "AR_INTR_SYNC_LOCAL_TIMEOUT\n");
3025 REG_WRITE(ah
, AR_INTR_SYNC_CAUSE_CLR
, sync_cause
);
3026 (void) REG_READ(ah
, AR_INTR_SYNC_CAUSE_CLR
);
3032 enum ath9k_int
ath9k_hw_intrget(struct ath_hw
*ah
)
3034 return ah
->mask_reg
;
3037 enum ath9k_int
ath9k_hw_set_interrupts(struct ath_hw
*ah
, enum ath9k_int ints
)
3039 u32 omask
= ah
->mask_reg
;
3041 struct ath9k_hw_capabilities
*pCap
= &ah
->caps
;
3043 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "0x%x => 0x%x\n", omask
, ints
);
3045 if (omask
& ATH9K_INT_GLOBAL
) {
3046 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "disable IER\n");
3047 REG_WRITE(ah
, AR_IER
, AR_IER_DISABLE
);
3048 (void) REG_READ(ah
, AR_IER
);
3049 if (!AR_SREV_9100(ah
)) {
3050 REG_WRITE(ah
, AR_INTR_ASYNC_ENABLE
, 0);
3051 (void) REG_READ(ah
, AR_INTR_ASYNC_ENABLE
);
3053 REG_WRITE(ah
, AR_INTR_SYNC_ENABLE
, 0);
3054 (void) REG_READ(ah
, AR_INTR_SYNC_ENABLE
);
3058 mask
= ints
& ATH9K_INT_COMMON
;
3061 if (ints
& ATH9K_INT_TX
) {
3062 if (ah
->txok_interrupt_mask
)
3063 mask
|= AR_IMR_TXOK
;
3064 if (ah
->txdesc_interrupt_mask
)
3065 mask
|= AR_IMR_TXDESC
;
3066 if (ah
->txerr_interrupt_mask
)
3067 mask
|= AR_IMR_TXERR
;
3068 if (ah
->txeol_interrupt_mask
)
3069 mask
|= AR_IMR_TXEOL
;
3071 if (ints
& ATH9K_INT_RX
) {
3072 mask
|= AR_IMR_RXERR
;
3073 if (ah
->config
.intr_mitigation
)
3074 mask
|= AR_IMR_RXMINTR
| AR_IMR_RXINTM
;
3076 mask
|= AR_IMR_RXOK
| AR_IMR_RXDESC
;
3077 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
))
3078 mask
|= AR_IMR_GENTMR
;
3081 if (ints
& (ATH9K_INT_BMISC
)) {
3082 mask
|= AR_IMR_BCNMISC
;
3083 if (ints
& ATH9K_INT_TIM
)
3084 mask2
|= AR_IMR_S2_TIM
;
3085 if (ints
& ATH9K_INT_DTIM
)
3086 mask2
|= AR_IMR_S2_DTIM
;
3087 if (ints
& ATH9K_INT_DTIMSYNC
)
3088 mask2
|= AR_IMR_S2_DTIMSYNC
;
3089 if (ints
& ATH9K_INT_CABEND
)
3090 mask2
|= AR_IMR_S2_CABEND
;
3091 if (ints
& ATH9K_INT_TSFOOR
)
3092 mask2
|= AR_IMR_S2_TSFOOR
;
3095 if (ints
& (ATH9K_INT_GTT
| ATH9K_INT_CST
)) {
3096 mask
|= AR_IMR_BCNMISC
;
3097 if (ints
& ATH9K_INT_GTT
)
3098 mask2
|= AR_IMR_S2_GTT
;
3099 if (ints
& ATH9K_INT_CST
)
3100 mask2
|= AR_IMR_S2_CST
;
3103 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "new IMR 0x%x\n", mask
);
3104 REG_WRITE(ah
, AR_IMR
, mask
);
3105 mask
= REG_READ(ah
, AR_IMR_S2
) & ~(AR_IMR_S2_TIM
|
3107 AR_IMR_S2_DTIMSYNC
|
3111 AR_IMR_S2_GTT
| AR_IMR_S2_CST
);
3112 REG_WRITE(ah
, AR_IMR_S2
, mask
| mask2
);
3113 ah
->mask_reg
= ints
;
3115 if (!(pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)) {
3116 if (ints
& ATH9K_INT_TIM_TIMER
)
3117 REG_SET_BIT(ah
, AR_IMR_S5
, AR_IMR_S5_TIM_TIMER
);
3119 REG_CLR_BIT(ah
, AR_IMR_S5
, AR_IMR_S5_TIM_TIMER
);
3122 if (ints
& ATH9K_INT_GLOBAL
) {
3123 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "enable IER\n");
3124 REG_WRITE(ah
, AR_IER
, AR_IER_ENABLE
);
3125 if (!AR_SREV_9100(ah
)) {
3126 REG_WRITE(ah
, AR_INTR_ASYNC_ENABLE
,
3128 REG_WRITE(ah
, AR_INTR_ASYNC_MASK
, AR_INTR_MAC_IRQ
);
3131 REG_WRITE(ah
, AR_INTR_SYNC_ENABLE
,
3132 AR_INTR_SYNC_DEFAULT
);
3133 REG_WRITE(ah
, AR_INTR_SYNC_MASK
,
3134 AR_INTR_SYNC_DEFAULT
);
3136 DPRINTF(ah
->ah_sc
, ATH_DBG_INTERRUPT
, "AR_IMR 0x%x IER 0x%x\n",
3137 REG_READ(ah
, AR_IMR
), REG_READ(ah
, AR_IER
));
3143 /*******************/
3144 /* Beacon Handling */
3145 /*******************/
3147 void ath9k_hw_beaconinit(struct ath_hw
*ah
, u32 next_beacon
, u32 beacon_period
)
3151 ah
->beacon_interval
= beacon_period
;
3153 switch (ah
->opmode
) {
3154 case NL80211_IFTYPE_STATION
:
3155 case NL80211_IFTYPE_MONITOR
:
3156 REG_WRITE(ah
, AR_NEXT_TBTT_TIMER
, TU_TO_USEC(next_beacon
));
3157 REG_WRITE(ah
, AR_NEXT_DMA_BEACON_ALERT
, 0xffff);
3158 REG_WRITE(ah
, AR_NEXT_SWBA
, 0x7ffff);
3159 flags
|= AR_TBTT_TIMER_EN
;
3161 case NL80211_IFTYPE_ADHOC
:
3162 case NL80211_IFTYPE_MESH_POINT
:
3163 REG_SET_BIT(ah
, AR_TXCFG
,
3164 AR_TXCFG_ADHOC_BEACON_ATIM_TX_POLICY
);
3165 REG_WRITE(ah
, AR_NEXT_NDP_TIMER
,
3166 TU_TO_USEC(next_beacon
+
3167 (ah
->atim_window
? ah
->
3169 flags
|= AR_NDP_TIMER_EN
;
3170 case NL80211_IFTYPE_AP
:
3171 REG_WRITE(ah
, AR_NEXT_TBTT_TIMER
, TU_TO_USEC(next_beacon
));
3172 REG_WRITE(ah
, AR_NEXT_DMA_BEACON_ALERT
,
3173 TU_TO_USEC(next_beacon
-
3175 dma_beacon_response_time
));
3176 REG_WRITE(ah
, AR_NEXT_SWBA
,
3177 TU_TO_USEC(next_beacon
-
3179 sw_beacon_response_time
));
3181 AR_TBTT_TIMER_EN
| AR_DBA_TIMER_EN
| AR_SWBA_TIMER_EN
;
3184 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
,
3185 "%s: unsupported opmode: %d\n",
3186 __func__
, ah
->opmode
);
3191 REG_WRITE(ah
, AR_BEACON_PERIOD
, TU_TO_USEC(beacon_period
));
3192 REG_WRITE(ah
, AR_DMA_BEACON_PERIOD
, TU_TO_USEC(beacon_period
));
3193 REG_WRITE(ah
, AR_SWBA_PERIOD
, TU_TO_USEC(beacon_period
));
3194 REG_WRITE(ah
, AR_NDP_PERIOD
, TU_TO_USEC(beacon_period
));
3196 beacon_period
&= ~ATH9K_BEACON_ENA
;
3197 if (beacon_period
& ATH9K_BEACON_RESET_TSF
) {
3198 beacon_period
&= ~ATH9K_BEACON_RESET_TSF
;
3199 ath9k_hw_reset_tsf(ah
);
3202 REG_SET_BIT(ah
, AR_TIMER_MODE
, flags
);
3205 void ath9k_hw_set_sta_beacon_timers(struct ath_hw
*ah
,
3206 const struct ath9k_beacon_state
*bs
)
3208 u32 nextTbtt
, beaconintval
, dtimperiod
, beacontimeout
;
3209 struct ath9k_hw_capabilities
*pCap
= &ah
->caps
;
3211 REG_WRITE(ah
, AR_NEXT_TBTT_TIMER
, TU_TO_USEC(bs
->bs_nexttbtt
));
3213 REG_WRITE(ah
, AR_BEACON_PERIOD
,
3214 TU_TO_USEC(bs
->bs_intval
& ATH9K_BEACON_PERIOD
));
3215 REG_WRITE(ah
, AR_DMA_BEACON_PERIOD
,
3216 TU_TO_USEC(bs
->bs_intval
& ATH9K_BEACON_PERIOD
));
3218 REG_RMW_FIELD(ah
, AR_RSSI_THR
,
3219 AR_RSSI_THR_BM_THR
, bs
->bs_bmissthreshold
);
3221 beaconintval
= bs
->bs_intval
& ATH9K_BEACON_PERIOD
;
3223 if (bs
->bs_sleepduration
> beaconintval
)
3224 beaconintval
= bs
->bs_sleepduration
;
3226 dtimperiod
= bs
->bs_dtimperiod
;
3227 if (bs
->bs_sleepduration
> dtimperiod
)
3228 dtimperiod
= bs
->bs_sleepduration
;
3230 if (beaconintval
== dtimperiod
)
3231 nextTbtt
= bs
->bs_nextdtim
;
3233 nextTbtt
= bs
->bs_nexttbtt
;
3235 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "next DTIM %d\n", bs
->bs_nextdtim
);
3236 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "next beacon %d\n", nextTbtt
);
3237 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "beacon period %d\n", beaconintval
);
3238 DPRINTF(ah
->ah_sc
, ATH_DBG_BEACON
, "DTIM period %d\n", dtimperiod
);
3240 REG_WRITE(ah
, AR_NEXT_DTIM
,
3241 TU_TO_USEC(bs
->bs_nextdtim
- SLEEP_SLOP
));
3242 REG_WRITE(ah
, AR_NEXT_TIM
, TU_TO_USEC(nextTbtt
- SLEEP_SLOP
));
3244 REG_WRITE(ah
, AR_SLEEP1
,
3245 SM((CAB_TIMEOUT_VAL
<< 3), AR_SLEEP1_CAB_TIMEOUT
)
3246 | AR_SLEEP1_ASSUME_DTIM
);
3248 if (pCap
->hw_caps
& ATH9K_HW_CAP_AUTOSLEEP
)
3249 beacontimeout
= (BEACON_TIMEOUT_VAL
<< 3);
3251 beacontimeout
= MIN_BEACON_TIMEOUT_VAL
;
3253 REG_WRITE(ah
, AR_SLEEP2
,
3254 SM(beacontimeout
, AR_SLEEP2_BEACON_TIMEOUT
));
3256 REG_WRITE(ah
, AR_TIM_PERIOD
, TU_TO_USEC(beaconintval
));
3257 REG_WRITE(ah
, AR_DTIM_PERIOD
, TU_TO_USEC(dtimperiod
));
3259 REG_SET_BIT(ah
, AR_TIMER_MODE
,
3260 AR_TBTT_TIMER_EN
| AR_TIM_TIMER_EN
|
3263 /* TSF Out of Range Threshold */
3264 REG_WRITE(ah
, AR_TSFOOR_THRESHOLD
, bs
->bs_tsfoor_threshold
);
3267 /*******************/
3268 /* HW Capabilities */
3269 /*******************/
3271 void ath9k_hw_fill_cap_info(struct ath_hw
*ah
)
3273 struct ath9k_hw_capabilities
*pCap
= &ah
->caps
;
3274 u16 capField
= 0, eeval
;
3276 eeval
= ah
->eep_ops
->get_eeprom(ah
, EEP_REG_0
);
3277 ah
->regulatory
.current_rd
= eeval
;
3279 eeval
= ah
->eep_ops
->get_eeprom(ah
, EEP_REG_1
);
3280 if (AR_SREV_9285_10_OR_LATER(ah
))
3281 eeval
|= AR9285_RDEXT_DEFAULT
;
3282 ah
->regulatory
.current_rd_ext
= eeval
;
3284 capField
= ah
->eep_ops
->get_eeprom(ah
, EEP_OP_CAP
);
3286 if (ah
->opmode
!= NL80211_IFTYPE_AP
&&
3287 ah
->hw_version
.subvendorid
== AR_SUBVENDOR_ID_NEW_A
) {
3288 if (ah
->regulatory
.current_rd
== 0x64 ||
3289 ah
->regulatory
.current_rd
== 0x65)
3290 ah
->regulatory
.current_rd
+= 5;
3291 else if (ah
->regulatory
.current_rd
== 0x41)
3292 ah
->regulatory
.current_rd
= 0x43;
3293 DPRINTF(ah
->ah_sc
, ATH_DBG_REGULATORY
,
3294 "regdomain mapped to 0x%x\n", ah
->regulatory
.current_rd
);
3297 eeval
= ah
->eep_ops
->get_eeprom(ah
, EEP_OP_MODE
);
3298 bitmap_zero(pCap
->wireless_modes
, ATH9K_MODE_MAX
);
3300 if (eeval
& AR5416_OPFLAGS_11A
) {
3301 set_bit(ATH9K_MODE_11A
, pCap
->wireless_modes
);
3302 if (ah
->config
.ht_enable
) {
3303 if (!(eeval
& AR5416_OPFLAGS_N_5G_HT20
))
3304 set_bit(ATH9K_MODE_11NA_HT20
,
3305 pCap
->wireless_modes
);
3306 if (!(eeval
& AR5416_OPFLAGS_N_5G_HT40
)) {
3307 set_bit(ATH9K_MODE_11NA_HT40PLUS
,
3308 pCap
->wireless_modes
);
3309 set_bit(ATH9K_MODE_11NA_HT40MINUS
,
3310 pCap
->wireless_modes
);
3315 if (eeval
& AR5416_OPFLAGS_11G
) {
3316 set_bit(ATH9K_MODE_11B
, pCap
->wireless_modes
);
3317 set_bit(ATH9K_MODE_11G
, pCap
->wireless_modes
);
3318 if (ah
->config
.ht_enable
) {
3319 if (!(eeval
& AR5416_OPFLAGS_N_2G_HT20
))
3320 set_bit(ATH9K_MODE_11NG_HT20
,
3321 pCap
->wireless_modes
);
3322 if (!(eeval
& AR5416_OPFLAGS_N_2G_HT40
)) {
3323 set_bit(ATH9K_MODE_11NG_HT40PLUS
,
3324 pCap
->wireless_modes
);
3325 set_bit(ATH9K_MODE_11NG_HT40MINUS
,
3326 pCap
->wireless_modes
);
3331 pCap
->tx_chainmask
= ah
->eep_ops
->get_eeprom(ah
, EEP_TX_MASK
);
3332 if ((ah
->hw_version
.devid
== AR5416_DEVID_PCI
) &&
3333 !(eeval
& AR5416_OPFLAGS_11A
))
3334 pCap
->rx_chainmask
= ath9k_hw_gpio_get(ah
, 0) ? 0x5 : 0x7;
3336 pCap
->rx_chainmask
= ah
->eep_ops
->get_eeprom(ah
, EEP_RX_MASK
);
3338 if (!(AR_SREV_9280(ah
) && (ah
->hw_version
.macRev
== 0)))
3339 ah
->misc_mode
|= AR_PCU_MIC_NEW_LOC_ENA
;
3341 pCap
->low_2ghz_chan
= 2312;
3342 pCap
->high_2ghz_chan
= 2732;
3344 pCap
->low_5ghz_chan
= 4920;
3345 pCap
->high_5ghz_chan
= 6100;
3347 pCap
->hw_caps
&= ~ATH9K_HW_CAP_CIPHER_CKIP
;
3348 pCap
->hw_caps
|= ATH9K_HW_CAP_CIPHER_TKIP
;
3349 pCap
->hw_caps
|= ATH9K_HW_CAP_CIPHER_AESCCM
;
3351 pCap
->hw_caps
&= ~ATH9K_HW_CAP_MIC_CKIP
;
3352 pCap
->hw_caps
|= ATH9K_HW_CAP_MIC_TKIP
;
3353 pCap
->hw_caps
|= ATH9K_HW_CAP_MIC_AESCCM
;
3355 if (ah
->config
.ht_enable
)
3356 pCap
->hw_caps
|= ATH9K_HW_CAP_HT
;
3358 pCap
->hw_caps
&= ~ATH9K_HW_CAP_HT
;
3360 pCap
->hw_caps
|= ATH9K_HW_CAP_GTT
;
3361 pCap
->hw_caps
|= ATH9K_HW_CAP_VEOL
;
3362 pCap
->hw_caps
|= ATH9K_HW_CAP_BSSIDMASK
;
3363 pCap
->hw_caps
&= ~ATH9K_HW_CAP_MCAST_KEYSEARCH
;
3365 if (capField
& AR_EEPROM_EEPCAP_MAXQCU
)
3366 pCap
->total_queues
=
3367 MS(capField
, AR_EEPROM_EEPCAP_MAXQCU
);
3369 pCap
->total_queues
= ATH9K_NUM_TX_QUEUES
;
3371 if (capField
& AR_EEPROM_EEPCAP_KC_ENTRIES
)
3372 pCap
->keycache_size
=
3373 1 << MS(capField
, AR_EEPROM_EEPCAP_KC_ENTRIES
);
3375 pCap
->keycache_size
= AR_KEYTABLE_SIZE
;
3377 pCap
->hw_caps
|= ATH9K_HW_CAP_FASTCC
;
3378 pCap
->tx_triglevel_max
= MAX_TX_FIFO_THRESHOLD
;
3380 if (AR_SREV_9285_10_OR_LATER(ah
))
3381 pCap
->num_gpio_pins
= AR9285_NUM_GPIO
;
3382 else if (AR_SREV_9280_10_OR_LATER(ah
))
3383 pCap
->num_gpio_pins
= AR928X_NUM_GPIO
;
3385 pCap
->num_gpio_pins
= AR_NUM_GPIO
;
3387 if (AR_SREV_9160_10_OR_LATER(ah
) || AR_SREV_9100(ah
)) {
3388 pCap
->hw_caps
|= ATH9K_HW_CAP_CST
;
3389 pCap
->rts_aggr_limit
= ATH_AMPDU_LIMIT_MAX
;
3391 pCap
->rts_aggr_limit
= (8 * 1024);
3394 pCap
->hw_caps
|= ATH9K_HW_CAP_ENHANCEDPM
;
3396 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
3397 ah
->rfsilent
= ah
->eep_ops
->get_eeprom(ah
, EEP_RF_SILENT
);
3398 if (ah
->rfsilent
& EEP_RFSILENT_ENABLED
) {
3400 MS(ah
->rfsilent
, EEP_RFSILENT_GPIO_SEL
);
3401 ah
->rfkill_polarity
=
3402 MS(ah
->rfsilent
, EEP_RFSILENT_POLARITY
);
3404 pCap
->hw_caps
|= ATH9K_HW_CAP_RFSILENT
;
3408 if ((ah
->hw_version
.macVersion
== AR_SREV_VERSION_5416_PCI
) ||
3409 (ah
->hw_version
.macVersion
== AR_SREV_VERSION_5416_PCIE
) ||
3410 (ah
->hw_version
.macVersion
== AR_SREV_VERSION_9160
) ||
3411 (ah
->hw_version
.macVersion
== AR_SREV_VERSION_9100
) ||
3412 (ah
->hw_version
.macVersion
== AR_SREV_VERSION_9280
) ||
3413 (ah
->hw_version
.macVersion
== AR_SREV_VERSION_9285
))
3414 pCap
->hw_caps
&= ~ATH9K_HW_CAP_AUTOSLEEP
;
3416 pCap
->hw_caps
|= ATH9K_HW_CAP_AUTOSLEEP
;
3418 if (AR_SREV_9280(ah
) || AR_SREV_9285(ah
))
3419 pCap
->hw_caps
&= ~ATH9K_HW_CAP_4KB_SPLITTRANS
;
3421 pCap
->hw_caps
|= ATH9K_HW_CAP_4KB_SPLITTRANS
;
3423 if (ah
->regulatory
.current_rd_ext
& (1 << REG_EXT_JAPAN_MIDBAND
)) {
3425 AR_EEPROM_EEREGCAP_EN_KK_NEW_11A
|
3426 AR_EEPROM_EEREGCAP_EN_KK_U1_EVEN
|
3427 AR_EEPROM_EEREGCAP_EN_KK_U2
|
3428 AR_EEPROM_EEREGCAP_EN_KK_MIDBAND
;
3431 AR_EEPROM_EEREGCAP_EN_KK_NEW_11A
|
3432 AR_EEPROM_EEREGCAP_EN_KK_U1_EVEN
;
3435 pCap
->reg_cap
|= AR_EEPROM_EEREGCAP_EN_FCC_MIDBAND
;
3437 pCap
->num_antcfg_5ghz
=
3438 ah
->eep_ops
->get_num_ant_config(ah
, ATH9K_HAL_FREQ_BAND_5GHZ
);
3439 pCap
->num_antcfg_2ghz
=
3440 ah
->eep_ops
->get_num_ant_config(ah
, ATH9K_HAL_FREQ_BAND_2GHZ
);
3442 if (AR_SREV_9280_10_OR_LATER(ah
) && btcoex_enable
) {
3443 pCap
->hw_caps
|= ATH9K_HW_CAP_BT_COEX
;
3444 ah
->btactive_gpio
= 6;
3445 ah
->wlanactive_gpio
= 5;
3449 bool ath9k_hw_getcapability(struct ath_hw
*ah
, enum ath9k_capability_type type
,
3450 u32 capability
, u32
*result
)
3453 case ATH9K_CAP_CIPHER
:
3454 switch (capability
) {
3455 case ATH9K_CIPHER_AES_CCM
:
3456 case ATH9K_CIPHER_AES_OCB
:
3457 case ATH9K_CIPHER_TKIP
:
3458 case ATH9K_CIPHER_WEP
:
3459 case ATH9K_CIPHER_MIC
:
3460 case ATH9K_CIPHER_CLR
:
3465 case ATH9K_CAP_TKIP_MIC
:
3466 switch (capability
) {
3470 return (ah
->sta_id1_defaults
&
3471 AR_STA_ID1_CRPT_MIC_ENABLE
) ? true :
3474 case ATH9K_CAP_TKIP_SPLIT
:
3475 return (ah
->misc_mode
& AR_PCU_MIC_NEW_LOC_ENA
) ?
3477 case ATH9K_CAP_DIVERSITY
:
3478 return (REG_READ(ah
, AR_PHY_CCK_DETECT
) &
3479 AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV
) ?
3481 case ATH9K_CAP_MCAST_KEYSRCH
:
3482 switch (capability
) {
3486 if (REG_READ(ah
, AR_STA_ID1
) & AR_STA_ID1_ADHOC
) {
3489 return (ah
->sta_id1_defaults
&
3490 AR_STA_ID1_MCAST_KSRCH
) ? true :
3495 case ATH9K_CAP_TXPOW
:
3496 switch (capability
) {
3500 *result
= ah
->regulatory
.power_limit
;
3503 *result
= ah
->regulatory
.max_power_level
;
3506 *result
= ah
->regulatory
.tp_scale
;
3511 return (AR_SREV_9280_20_OR_LATER(ah
) &&
3512 (ah
->eep_ops
->get_eeprom(ah
, EEP_RC_CHAIN_MASK
) == 1))
3519 bool ath9k_hw_setcapability(struct ath_hw
*ah
, enum ath9k_capability_type type
,
3520 u32 capability
, u32 setting
, int *status
)
3525 case ATH9K_CAP_TKIP_MIC
:
3527 ah
->sta_id1_defaults
|=
3528 AR_STA_ID1_CRPT_MIC_ENABLE
;
3530 ah
->sta_id1_defaults
&=
3531 ~AR_STA_ID1_CRPT_MIC_ENABLE
;
3533 case ATH9K_CAP_DIVERSITY
:
3534 v
= REG_READ(ah
, AR_PHY_CCK_DETECT
);
3536 v
|= AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV
;
3538 v
&= ~AR_PHY_CCK_DETECT_BB_ENABLE_ANT_FAST_DIV
;
3539 REG_WRITE(ah
, AR_PHY_CCK_DETECT
, v
);
3541 case ATH9K_CAP_MCAST_KEYSRCH
:
3543 ah
->sta_id1_defaults
|= AR_STA_ID1_MCAST_KSRCH
;
3545 ah
->sta_id1_defaults
&= ~AR_STA_ID1_MCAST_KSRCH
;
3552 /****************************/
3553 /* GPIO / RFKILL / Antennae */
3554 /****************************/
3556 static void ath9k_hw_gpio_cfg_output_mux(struct ath_hw
*ah
,
3560 u32 gpio_shift
, tmp
;
3563 addr
= AR_GPIO_OUTPUT_MUX3
;
3565 addr
= AR_GPIO_OUTPUT_MUX2
;
3567 addr
= AR_GPIO_OUTPUT_MUX1
;
3569 gpio_shift
= (gpio
% 6) * 5;
3571 if (AR_SREV_9280_20_OR_LATER(ah
)
3572 || (addr
!= AR_GPIO_OUTPUT_MUX1
)) {
3573 REG_RMW(ah
, addr
, (type
<< gpio_shift
),
3574 (0x1f << gpio_shift
));
3576 tmp
= REG_READ(ah
, addr
);
3577 tmp
= ((tmp
& 0x1F0) << 1) | (tmp
& ~0x1F0);
3578 tmp
&= ~(0x1f << gpio_shift
);
3579 tmp
|= (type
<< gpio_shift
);
3580 REG_WRITE(ah
, addr
, tmp
);
3584 void ath9k_hw_cfg_gpio_input(struct ath_hw
*ah
, u32 gpio
)
3588 ASSERT(gpio
< ah
->caps
.num_gpio_pins
);
3590 gpio_shift
= gpio
<< 1;
3594 (AR_GPIO_OE_OUT_DRV_NO
<< gpio_shift
),
3595 (AR_GPIO_OE_OUT_DRV
<< gpio_shift
));
3598 u32
ath9k_hw_gpio_get(struct ath_hw
*ah
, u32 gpio
)
3600 #define MS_REG_READ(x, y) \
3601 (MS(REG_READ(ah, AR_GPIO_IN_OUT), x##_GPIO_IN_VAL) & (AR_GPIO_BIT(y)))
3603 if (gpio
>= ah
->caps
.num_gpio_pins
)
3606 if (AR_SREV_9285_10_OR_LATER(ah
))
3607 return MS_REG_READ(AR9285
, gpio
) != 0;
3608 else if (AR_SREV_9280_10_OR_LATER(ah
))
3609 return MS_REG_READ(AR928X
, gpio
) != 0;
3611 return MS_REG_READ(AR
, gpio
) != 0;
3614 void ath9k_hw_cfg_output(struct ath_hw
*ah
, u32 gpio
,
3619 ath9k_hw_gpio_cfg_output_mux(ah
, gpio
, ah_signal_type
);
3621 gpio_shift
= 2 * gpio
;
3625 (AR_GPIO_OE_OUT_DRV_ALL
<< gpio_shift
),
3626 (AR_GPIO_OE_OUT_DRV
<< gpio_shift
));
3629 void ath9k_hw_set_gpio(struct ath_hw
*ah
, u32 gpio
, u32 val
)
3631 REG_RMW(ah
, AR_GPIO_IN_OUT
, ((val
& 1) << gpio
),
3635 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
3636 void ath9k_enable_rfkill(struct ath_hw
*ah
)
3638 REG_SET_BIT(ah
, AR_GPIO_INPUT_EN_VAL
,
3639 AR_GPIO_INPUT_EN_VAL_RFSILENT_BB
);
3641 REG_CLR_BIT(ah
, AR_GPIO_INPUT_MUX2
,
3642 AR_GPIO_INPUT_MUX2_RFSILENT
);
3644 ath9k_hw_cfg_gpio_input(ah
, ah
->rfkill_gpio
);
3645 REG_SET_BIT(ah
, AR_PHY_TEST
, RFSILENT_BB
);
3649 u32
ath9k_hw_getdefantenna(struct ath_hw
*ah
)
3651 return REG_READ(ah
, AR_DEF_ANTENNA
) & 0x7;
3654 void ath9k_hw_setantenna(struct ath_hw
*ah
, u32 antenna
)
3656 REG_WRITE(ah
, AR_DEF_ANTENNA
, (antenna
& 0x7));
3659 bool ath9k_hw_setantennaswitch(struct ath_hw
*ah
,
3660 enum ath9k_ant_setting settings
,
3661 struct ath9k_channel
*chan
,
3666 static u8 tx_chainmask_cfg
, rx_chainmask_cfg
;
3668 if (AR_SREV_9280(ah
)) {
3669 if (!tx_chainmask_cfg
) {
3671 tx_chainmask_cfg
= *tx_chainmask
;
3672 rx_chainmask_cfg
= *rx_chainmask
;
3676 case ATH9K_ANT_FIXED_A
:
3677 *tx_chainmask
= ATH9K_ANTENNA0_CHAINMASK
;
3678 *rx_chainmask
= ATH9K_ANTENNA0_CHAINMASK
;
3679 *antenna_cfgd
= true;
3681 case ATH9K_ANT_FIXED_B
:
3682 if (ah
->caps
.tx_chainmask
>
3683 ATH9K_ANTENNA1_CHAINMASK
) {
3684 *tx_chainmask
= ATH9K_ANTENNA1_CHAINMASK
;
3686 *rx_chainmask
= ATH9K_ANTENNA1_CHAINMASK
;
3687 *antenna_cfgd
= true;
3689 case ATH9K_ANT_VARIABLE
:
3690 *tx_chainmask
= tx_chainmask_cfg
;
3691 *rx_chainmask
= rx_chainmask_cfg
;
3692 *antenna_cfgd
= true;
3698 ah
->diversity_control
= settings
;
3704 /*********************/
3705 /* General Operation */
3706 /*********************/
3708 u32
ath9k_hw_getrxfilter(struct ath_hw
*ah
)
3710 u32 bits
= REG_READ(ah
, AR_RX_FILTER
);
3711 u32 phybits
= REG_READ(ah
, AR_PHY_ERR
);
3713 if (phybits
& AR_PHY_ERR_RADAR
)
3714 bits
|= ATH9K_RX_FILTER_PHYRADAR
;
3715 if (phybits
& (AR_PHY_ERR_OFDM_TIMING
| AR_PHY_ERR_CCK_TIMING
))
3716 bits
|= ATH9K_RX_FILTER_PHYERR
;
3721 void ath9k_hw_setrxfilter(struct ath_hw
*ah
, u32 bits
)
3725 REG_WRITE(ah
, AR_RX_FILTER
, (bits
& 0xffff) | AR_RX_COMPR_BAR
);
3727 if (bits
& ATH9K_RX_FILTER_PHYRADAR
)
3728 phybits
|= AR_PHY_ERR_RADAR
;
3729 if (bits
& ATH9K_RX_FILTER_PHYERR
)
3730 phybits
|= AR_PHY_ERR_OFDM_TIMING
| AR_PHY_ERR_CCK_TIMING
;
3731 REG_WRITE(ah
, AR_PHY_ERR
, phybits
);
3734 REG_WRITE(ah
, AR_RXCFG
,
3735 REG_READ(ah
, AR_RXCFG
) | AR_RXCFG_ZLFDMA
);
3737 REG_WRITE(ah
, AR_RXCFG
,
3738 REG_READ(ah
, AR_RXCFG
) & ~AR_RXCFG_ZLFDMA
);
3741 bool ath9k_hw_phy_disable(struct ath_hw
*ah
)
3743 return ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_WARM
);
3746 bool ath9k_hw_disable(struct ath_hw
*ah
)
3748 if (!ath9k_hw_setpower(ah
, ATH9K_PM_AWAKE
))
3751 return ath9k_hw_set_reset_reg(ah
, ATH9K_RESET_COLD
);
3754 bool ath9k_hw_set_txpowerlimit(struct ath_hw
*ah
, u32 limit
)
3756 struct ath9k_channel
*chan
= ah
->curchan
;
3757 struct ieee80211_channel
*channel
= chan
->chan
;
3759 ah
->regulatory
.power_limit
= min(limit
, (u32
) MAX_RATE_POWER
);
3761 if (ah
->eep_ops
->set_txpower(ah
, chan
,
3762 ath9k_regd_get_ctl(&ah
->regulatory
, chan
),
3763 channel
->max_antenna_gain
* 2,
3764 channel
->max_power
* 2,
3765 min((u32
) MAX_RATE_POWER
,
3766 (u32
) ah
->regulatory
.power_limit
)) != 0)
3772 void ath9k_hw_setmac(struct ath_hw
*ah
, const u8
*mac
)
3774 memcpy(ah
->macaddr
, mac
, ETH_ALEN
);
3777 void ath9k_hw_setopmode(struct ath_hw
*ah
)
3779 ath9k_hw_set_operating_mode(ah
, ah
->opmode
);
3782 void ath9k_hw_setmcastfilter(struct ath_hw
*ah
, u32 filter0
, u32 filter1
)
3784 REG_WRITE(ah
, AR_MCAST_FIL0
, filter0
);
3785 REG_WRITE(ah
, AR_MCAST_FIL1
, filter1
);
3788 void ath9k_hw_setbssidmask(struct ath_softc
*sc
)
3790 REG_WRITE(sc
->sc_ah
, AR_BSSMSKL
, get_unaligned_le32(sc
->bssidmask
));
3791 REG_WRITE(sc
->sc_ah
, AR_BSSMSKU
, get_unaligned_le16(sc
->bssidmask
+ 4));
3794 void ath9k_hw_write_associd(struct ath_softc
*sc
)
3796 REG_WRITE(sc
->sc_ah
, AR_BSS_ID0
, get_unaligned_le32(sc
->curbssid
));
3797 REG_WRITE(sc
->sc_ah
, AR_BSS_ID1
, get_unaligned_le16(sc
->curbssid
+ 4) |
3798 ((sc
->curaid
& 0x3fff) << AR_BSS_ID1_AID_S
));
3801 u64
ath9k_hw_gettsf64(struct ath_hw
*ah
)
3805 tsf
= REG_READ(ah
, AR_TSF_U32
);
3806 tsf
= (tsf
<< 32) | REG_READ(ah
, AR_TSF_L32
);
3811 void ath9k_hw_settsf64(struct ath_hw
*ah
, u64 tsf64
)
3813 REG_WRITE(ah
, AR_TSF_L32
, tsf64
& 0xffffffff);
3814 REG_WRITE(ah
, AR_TSF_U32
, (tsf64
>> 32) & 0xffffffff);
3817 void ath9k_hw_reset_tsf(struct ath_hw
*ah
)
3822 while (REG_READ(ah
, AR_SLP32_MODE
) & AR_SLP32_TSF_WRITE_STATUS
) {
3825 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
,
3826 "AR_SLP32_TSF_WRITE_STATUS limit exceeded\n");
3831 REG_WRITE(ah
, AR_RESET_TSF
, AR_RESET_TSF_ONCE
);
3834 bool ath9k_hw_set_tsfadjust(struct ath_hw
*ah
, u32 setting
)
3837 ah
->misc_mode
|= AR_PCU_TX_ADD_TSF
;
3839 ah
->misc_mode
&= ~AR_PCU_TX_ADD_TSF
;
3844 bool ath9k_hw_setslottime(struct ath_hw
*ah
, u32 us
)
3846 if (us
< ATH9K_SLOT_TIME_9
|| us
> ath9k_hw_mac_to_usec(ah
, 0xffff)) {
3847 DPRINTF(ah
->ah_sc
, ATH_DBG_RESET
, "bad slot time %u\n", us
);
3848 ah
->slottime
= (u32
) -1;
3851 REG_WRITE(ah
, AR_D_GBL_IFS_SLOT
, ath9k_hw_mac_to_clks(ah
, us
));
3857 void ath9k_hw_set11nmac2040(struct ath_hw
*ah
, enum ath9k_ht_macmode mode
)
3861 if (mode
== ATH9K_HT_MACMODE_2040
&&
3862 !ah
->config
.cwm_ignore_extcca
)
3863 macmode
= AR_2040_JOINED_RX_CLEAR
;
3867 REG_WRITE(ah
, AR_2040_MODE
, macmode
);
3870 /***************************/
3871 /* Bluetooth Coexistence */
3872 /***************************/
3874 void ath9k_hw_btcoex_enable(struct ath_hw
*ah
)
3876 /* connect bt_active to baseband */
3877 REG_CLR_BIT(ah
, AR_GPIO_INPUT_EN_VAL
,
3878 (AR_GPIO_INPUT_EN_VAL_BT_PRIORITY_DEF
|
3879 AR_GPIO_INPUT_EN_VAL_BT_FREQUENCY_DEF
));
3881 REG_SET_BIT(ah
, AR_GPIO_INPUT_EN_VAL
,
3882 AR_GPIO_INPUT_EN_VAL_BT_ACTIVE_BB
);
3884 /* Set input mux for bt_active to gpio pin */
3885 REG_RMW_FIELD(ah
, AR_GPIO_INPUT_MUX1
,
3886 AR_GPIO_INPUT_MUX1_BT_ACTIVE
,
3889 /* Configure the desired gpio port for input */
3890 ath9k_hw_cfg_gpio_input(ah
, ah
->btactive_gpio
);
3892 /* Configure the desired GPIO port for TX_FRAME output */
3893 ath9k_hw_cfg_output(ah
, ah
->wlanactive_gpio
,
3894 AR_GPIO_OUTPUT_MUX_AS_TX_FRAME
);