2 * Copyright (c) 2012 Qualcomm Atheros, Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #include <linux/export.h>
23 static void ath9k_hw_set_powermode_wow_sleep(struct ath_hw
*ah
)
25 struct ath_common
*common
= ath9k_hw_common(ah
);
27 REG_SET_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PWR_SAV
);
29 /* set rx disable bit */
30 REG_WRITE(ah
, AR_CR
, AR_CR_RXD
);
32 if (!ath9k_hw_wait(ah
, AR_CR
, AR_CR_RXE
, 0, AH_WAIT_TIMEOUT
)) {
33 ath_err(common
, "Failed to stop Rx DMA in 10ms AR_CR=0x%08x AR_DIAG_SW=0x%08x\n",
34 REG_READ(ah
, AR_CR
), REG_READ(ah
, AR_DIAG_SW
));
38 if (AR_SREV_9462(ah
) || AR_SREV_9565(ah
)) {
39 if (!REG_READ(ah
, AR_MAC_PCU_GEN_TIMER_TSF_SEL
))
40 REG_CLR_BIT(ah
, AR_DIRECT_CONNECT
, AR_DC_TSF2_ENABLE
);
41 } else if (AR_SREV_9485(ah
)){
42 if (!(REG_READ(ah
, AR_NDP2_TIMER_MODE
) &
43 AR_GEN_TIMERS2_MODE_ENABLE_MASK
))
44 REG_CLR_BIT(ah
, AR_DIRECT_CONNECT
, AR_DC_TSF2_ENABLE
);
47 REG_WRITE(ah
, AR_RTC_FORCE_WAKE
, AR_RTC_FORCE_WAKE_ON_INT
);
50 static void ath9k_wow_create_keep_alive_pattern(struct ath_hw
*ah
)
52 struct ath_common
*common
= ath9k_hw_common(ah
);
53 u8 sta_mac_addr
[ETH_ALEN
], ap_mac_addr
[ETH_ALEN
];
55 u32 data_word
[KAL_NUM_DATA_WORDS
];
57 u32 wow_ka_data_word0
;
59 memcpy(sta_mac_addr
, common
->macaddr
, ETH_ALEN
);
60 memcpy(ap_mac_addr
, common
->curbssid
, ETH_ALEN
);
62 /* set the transmit buffer */
63 ctl
[0] = (KAL_FRAME_LEN
| (MAX_RATE_POWER
<< 16));
66 ctl
[7] = (ah
->txchainmask
) << 2;
67 ctl
[2] = 0xf << 16; /* tx_tries 0 */
69 if (IS_CHAN_2GHZ(ah
->curchan
))
70 ctl
[3] = 0x1b; /* CCK_1M */
72 ctl
[3] = 0xb; /* OFDM_6M */
74 for (i
= 0; i
< KAL_NUM_DESC_WORDS
; i
++)
75 REG_WRITE(ah
, (AR_WOW_KA_DESC_WORD2
+ i
* 4), ctl
[i
]);
77 REG_WRITE(ah
, (AR_WOW_KA_DESC_WORD2
+ i
* 4), ctl
[i
]);
79 data_word
[0] = (KAL_FRAME_TYPE
<< 2) | (KAL_FRAME_SUB_TYPE
<< 4) |
80 (KAL_TO_DS
<< 8) | (KAL_DURATION_ID
<< 16);
81 data_word
[1] = (ap_mac_addr
[3] << 24) | (ap_mac_addr
[2] << 16) |
82 (ap_mac_addr
[1] << 8) | (ap_mac_addr
[0]);
83 data_word
[2] = (sta_mac_addr
[1] << 24) | (sta_mac_addr
[0] << 16) |
84 (ap_mac_addr
[5] << 8) | (ap_mac_addr
[4]);
85 data_word
[3] = (sta_mac_addr
[5] << 24) | (sta_mac_addr
[4] << 16) |
86 (sta_mac_addr
[3] << 8) | (sta_mac_addr
[2]);
87 data_word
[4] = (ap_mac_addr
[3] << 24) | (ap_mac_addr
[2] << 16) |
88 (ap_mac_addr
[1] << 8) | (ap_mac_addr
[0]);
89 data_word
[5] = (ap_mac_addr
[5] << 8) | (ap_mac_addr
[4]);
91 if (AR_SREV_9462_20(ah
)) {
92 /* AR9462 2.0 has an extra descriptor word (time based
93 * discard) compared to other chips */
94 REG_WRITE(ah
, (AR_WOW_KA_DESC_WORD2
+ (12 * 4)), 0);
95 wow_ka_data_word0
= AR_WOW_TXBUF(13);
97 wow_ka_data_word0
= AR_WOW_TXBUF(12);
100 for (i
= 0; i
< KAL_NUM_DATA_WORDS
; i
++)
101 REG_WRITE(ah
, (wow_ka_data_word0
+ i
*4), data_word
[i
]);
105 int ath9k_hw_wow_apply_pattern(struct ath_hw
*ah
, u8
*user_pattern
,
106 u8
*user_mask
, int pattern_count
,
110 u32 pattern_val
, mask_val
;
113 if (pattern_count
>= ah
->wow
.max_patterns
)
116 if (pattern_count
< MAX_NUM_PATTERN_LEGACY
)
117 REG_SET_BIT(ah
, AR_WOW_PATTERN
, BIT(pattern_count
));
119 REG_SET_BIT(ah
, AR_MAC_PCU_WOW4
, BIT(pattern_count
- 8));
121 for (i
= 0; i
< MAX_PATTERN_SIZE
; i
+= 4) {
122 memcpy(&pattern_val
, user_pattern
, 4);
123 REG_WRITE(ah
, (AR_WOW_TB_PATTERN(pattern_count
) + i
),
128 for (i
= 0; i
< MAX_PATTERN_MASK_SIZE
; i
+= 4) {
129 memcpy(&mask_val
, user_mask
, 4);
130 REG_WRITE(ah
, (AR_WOW_TB_MASK(pattern_count
) + i
), mask_val
);
134 if (pattern_count
< MAX_NUM_PATTERN_LEGACY
)
135 ah
->wow
.wow_event_mask
|=
136 BIT(pattern_count
+ AR_WOW_PAT_FOUND_SHIFT
);
138 ah
->wow
.wow_event_mask2
|=
139 BIT((pattern_count
- 8) + AR_WOW_PAT_FOUND_SHIFT
);
141 if (pattern_count
< 4) {
142 set
= (pattern_len
& AR_WOW_LENGTH_MAX
) <<
143 AR_WOW_LEN1_SHIFT(pattern_count
);
144 clr
= AR_WOW_LENGTH1_MASK(pattern_count
);
145 REG_RMW(ah
, AR_WOW_LENGTH1
, set
, clr
);
146 } else if (pattern_count
< 8) {
147 set
= (pattern_len
& AR_WOW_LENGTH_MAX
) <<
148 AR_WOW_LEN2_SHIFT(pattern_count
);
149 clr
= AR_WOW_LENGTH2_MASK(pattern_count
);
150 REG_RMW(ah
, AR_WOW_LENGTH2
, set
, clr
);
151 } else if (pattern_count
< 12) {
152 set
= (pattern_len
& AR_WOW_LENGTH_MAX
) <<
153 AR_WOW_LEN3_SHIFT(pattern_count
);
154 clr
= AR_WOW_LENGTH3_MASK(pattern_count
);
155 REG_RMW(ah
, AR_WOW_LENGTH3
, set
, clr
);
156 } else if (pattern_count
< MAX_NUM_PATTERN
) {
157 set
= (pattern_len
& AR_WOW_LENGTH_MAX
) <<
158 AR_WOW_LEN4_SHIFT(pattern_count
);
159 clr
= AR_WOW_LENGTH4_MASK(pattern_count
);
160 REG_RMW(ah
, AR_WOW_LENGTH4
, set
, clr
);
165 EXPORT_SYMBOL(ath9k_hw_wow_apply_pattern
);
167 u32
ath9k_hw_wow_wakeup(struct ath_hw
*ah
)
173 * read the WoW status register to know
176 rval
= REG_READ(ah
, AR_WOW_PATTERN
);
177 val
= AR_WOW_STATUS(rval
);
180 * mask only the WoW events that we have enabled. Sometimes
181 * we have spurious WoW events from the AR_WOW_PATTERN
182 * register. This mask will clean it up.
185 val
&= ah
->wow
.wow_event_mask
;
188 if (val
& AR_WOW_MAGIC_PAT_FOUND
)
189 wow_status
|= AH_WOW_MAGIC_PATTERN_EN
;
190 if (AR_WOW_PATTERN_FOUND(val
))
191 wow_status
|= AH_WOW_USER_PATTERN_EN
;
192 if (val
& AR_WOW_KEEP_ALIVE_FAIL
)
193 wow_status
|= AH_WOW_LINK_CHANGE
;
194 if (val
& AR_WOW_BEACON_FAIL
)
195 wow_status
|= AH_WOW_BEACON_MISS
;
199 * set and clear WOW_PME_CLEAR registers for the chip to
200 * generate next wow signal.
201 * disable D3 before accessing other registers ?
204 /* do we need to check the bit value 0x01000000 (7-10) ?? */
205 REG_RMW(ah
, AR_PCIE_PM_CTRL
, AR_PMCTRL_WOW_PME_CLR
,
206 AR_PMCTRL_PWR_STATE_D1D3
);
211 REG_WRITE(ah
, AR_WOW_PATTERN
,
212 AR_WOW_CLEAR_EVENTS(REG_READ(ah
, AR_WOW_PATTERN
)));
215 * restore the beacon threshold to init value
217 REG_WRITE(ah
, AR_RSSI_THR
, INIT_RSSI_THR
);
220 * Restore the way the PCI-E reset, Power-On-Reset, external
221 * PCIE_POR_SHORT pins are tied to its original value.
222 * Previously just before WoW sleep, we untie the PCI-E
223 * reset to our Chip's Power On Reset so that any PCI-E
224 * reset from the bus will not reset our chip
226 if (ah
->is_pciexpress
)
227 ath9k_hw_configpcipowersave(ah
, false);
229 ah
->wow
.wow_event_mask
= 0;
233 EXPORT_SYMBOL(ath9k_hw_wow_wakeup
);
235 static void ath9k_hw_wow_set_arwr_reg(struct ath_hw
*ah
)
239 if (!ah
->is_pciexpress
)
243 * We need to untie the internal POR (power-on-reset)
244 * to the external PCI-E reset. We also need to tie
245 * the PCI-E Phy reset to the PCI-E reset.
247 wa_reg
= REG_READ(ah
, AR_WA
);
248 wa_reg
&= ~AR_WA_UNTIE_RESET_EN
;
249 wa_reg
|= AR_WA_RESET_EN
;
250 wa_reg
|= AR_WA_POR_SHORT
;
252 REG_WRITE(ah
, AR_WA
, wa_reg
);
255 void ath9k_hw_wow_enable(struct ath_hw
*ah
, u32 pattern_enable
)
258 u32 keep_alive
, magic_pattern
, host_pm_ctrl
;
260 wow_event_mask
= ah
->wow
.wow_event_mask
;
263 * AR_PMCTRL_HOST_PME_EN - Override PME enable in configuration
264 * space and allow MAC to generate WoW anyway.
266 * AR_PMCTRL_PWR_PM_CTRL_ENA - ???
268 * AR_PMCTRL_AUX_PWR_DET - PCI core SYS_AUX_PWR_DET signal,
269 * needs to be set for WoW in PCI mode.
271 * AR_PMCTRL_WOW_PME_CLR - WoW Clear Signal going to the MAC.
273 * Set the power states appropriately and enable PME.
275 * Set and clear WOW_PME_CLEAR for the chip
276 * to generate next wow signal.
278 REG_SET_BIT(ah
, AR_PCIE_PM_CTRL
, AR_PMCTRL_HOST_PME_EN
|
279 AR_PMCTRL_PWR_PM_CTRL_ENA
|
280 AR_PMCTRL_AUX_PWR_DET
|
281 AR_PMCTRL_WOW_PME_CLR
);
282 REG_CLR_BIT(ah
, AR_PCIE_PM_CTRL
, AR_PMCTRL_WOW_PME_CLR
);
287 * 31:28 in AR_WOW_PATTERN : Indicates the number of bits used in the
288 * contention window. For value N,
289 * the random backoff will be selected between
292 REG_SET_BIT(ah
, AR_WOW_PATTERN
,
293 AR_WOW_BACK_OFF_SHIFT(AR_WOW_PAT_BACKOFF
));
296 * AIFS time, Slot time, Keep Alive count.
298 REG_SET_BIT(ah
, AR_WOW_COUNT
, AR_WOW_AIFS_CNT(AR_WOW_CNT_AIFS_CNT
) |
299 AR_WOW_SLOT_CNT(AR_WOW_CNT_SLOT_CNT
) |
300 AR_WOW_KEEP_ALIVE_CNT(AR_WOW_CNT_KA_CNT
));
304 if (pattern_enable
& AH_WOW_BEACON_MISS
)
305 REG_WRITE(ah
, AR_WOW_BCN_TIMO
, AR_WOW_BEACON_TIMO
);
307 REG_WRITE(ah
, AR_WOW_BCN_TIMO
, AR_WOW_BEACON_TIMO_MAX
);
310 * Keep alive timeout in ms.
313 REG_WRITE(ah
, AR_WOW_KEEP_ALIVE_TIMO
, AR_WOW_KEEP_ALIVE_NEVER
);
315 REG_WRITE(ah
, AR_WOW_KEEP_ALIVE_TIMO
, KAL_TIMEOUT
* 32);
318 * Keep alive delay in us.
320 REG_WRITE(ah
, AR_WOW_KEEP_ALIVE_DELAY
, KAL_DELAY
* 1000);
323 * Create keep alive pattern to respond to beacons.
325 ath9k_wow_create_keep_alive_pattern(ah
);
328 * Configure keep alive register.
330 keep_alive
= REG_READ(ah
, AR_WOW_KEEP_ALIVE
);
332 /* Send keep alive timeouts anyway */
333 keep_alive
&= ~AR_WOW_KEEP_ALIVE_AUTO_DIS
;
335 if (pattern_enable
& AH_WOW_LINK_CHANGE
) {
336 keep_alive
&= ~AR_WOW_KEEP_ALIVE_FAIL_DIS
;
337 wow_event_mask
|= AR_WOW_KEEP_ALIVE_FAIL
;
339 keep_alive
|= AR_WOW_KEEP_ALIVE_FAIL_DIS
;
342 REG_WRITE(ah
, AR_WOW_KEEP_ALIVE
, keep_alive
);
345 * We are relying on a bmiss failure, ensure we have
346 * enough threshold to prevent false positives.
348 REG_RMW_FIELD(ah
, AR_RSSI_THR
, AR_RSSI_THR_BM_THR
,
349 AR_WOW_BMISSTHRESHOLD
);
351 if (pattern_enable
& AH_WOW_BEACON_MISS
) {
352 wow_event_mask
|= AR_WOW_BEACON_FAIL
;
353 REG_SET_BIT(ah
, AR_WOW_BCN_EN
, AR_WOW_BEACON_FAIL_EN
);
355 REG_CLR_BIT(ah
, AR_WOW_BCN_EN
, AR_WOW_BEACON_FAIL_EN
);
359 * Enable the magic packet registers.
361 magic_pattern
= REG_READ(ah
, AR_WOW_PATTERN
);
362 magic_pattern
|= AR_WOW_MAC_INTR_EN
;
364 if (pattern_enable
& AH_WOW_MAGIC_PATTERN_EN
) {
365 magic_pattern
|= AR_WOW_MAGIC_EN
;
366 wow_event_mask
|= AR_WOW_MAGIC_PAT_FOUND
;
368 magic_pattern
&= ~AR_WOW_MAGIC_EN
;
371 REG_WRITE(ah
, AR_WOW_PATTERN
, magic_pattern
);
374 * Enable pattern matching for packets which are less
377 REG_WRITE(ah
, AR_WOW_PATTERN_MATCH_LT_256B
,
378 AR_WOW_PATTERN_SUPPORTED
);
381 * Set the power states appropriately and enable PME.
383 host_pm_ctrl
= REG_READ(ah
, AR_PCIE_PM_CTRL
);
384 host_pm_ctrl
|= AR_PMCTRL_PWR_STATE_D1D3
|
385 AR_PMCTRL_HOST_PME_EN
|
386 AR_PMCTRL_PWR_PM_CTRL_ENA
;
387 host_pm_ctrl
&= ~AR_PCIE_PM_CTRL_ENA
;
389 if (AR_SREV_9462(ah
)) {
391 * This is needed to prevent the chip waking up
392 * the host within 3-4 seconds with certain
395 host_pm_ctrl
&= ~AR_PMCTRL_PWR_STATE_D1D3
;
396 host_pm_ctrl
|= AR_PMCTRL_PWR_STATE_D1D3_REAL
;
399 REG_WRITE(ah
, AR_PCIE_PM_CTRL
, host_pm_ctrl
);
402 * Enable sequence number generation when asleep.
404 REG_CLR_BIT(ah
, AR_STA_ID1
, AR_STA_ID1_PRESERVE_SEQNUM
);
406 /* To bring down WOW power low margin */
407 REG_SET_BIT(ah
, AR_PCIE_PHY_REG3
, BIT(13));
409 ath9k_hw_wow_set_arwr_reg(ah
);
412 REG_CLR_BIT(ah
, AR_PCU_MISC_MODE3
, BIT(5));
414 ath9k_hw_set_powermode_wow_sleep(ah
);
415 ah
->wow
.wow_event_mask
= wow_event_mask
;
417 EXPORT_SYMBOL(ath9k_hw_wow_enable
);