forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
295 lines
6.9 KiB
295 lines
6.9 KiB
// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause |
|
/* Copyright(c) 2018-2019 Realtek Corporation |
|
*/ |
|
|
|
#include "main.h" |
|
#include "reg.h" |
|
#include "fw.h" |
|
#include "ps.h" |
|
#include "mac.h" |
|
#include "coex.h" |
|
#include "debug.h" |
|
|
|
static int rtw_ips_pwr_up(struct rtw_dev *rtwdev) |
|
{ |
|
int ret; |
|
|
|
ret = rtw_core_start(rtwdev); |
|
if (ret) |
|
rtw_err(rtwdev, "leave idle state failed\n"); |
|
|
|
rtw_set_channel(rtwdev); |
|
clear_bit(RTW_FLAG_INACTIVE_PS, rtwdev->flags); |
|
|
|
return ret; |
|
} |
|
|
|
int rtw_enter_ips(struct rtw_dev *rtwdev) |
|
{ |
|
set_bit(RTW_FLAG_INACTIVE_PS, rtwdev->flags); |
|
|
|
rtw_coex_ips_notify(rtwdev, COEX_IPS_ENTER); |
|
|
|
rtw_core_stop(rtwdev); |
|
rtw_hci_link_ps(rtwdev, true); |
|
|
|
return 0; |
|
} |
|
|
|
static void rtw_restore_port_cfg_iter(void *data, u8 *mac, |
|
struct ieee80211_vif *vif) |
|
{ |
|
struct rtw_dev *rtwdev = data; |
|
struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv; |
|
u32 config = ~0; |
|
|
|
rtw_vif_port_config(rtwdev, rtwvif, config); |
|
} |
|
|
|
int rtw_leave_ips(struct rtw_dev *rtwdev) |
|
{ |
|
int ret; |
|
|
|
rtw_hci_link_ps(rtwdev, false); |
|
|
|
ret = rtw_ips_pwr_up(rtwdev); |
|
if (ret) { |
|
rtw_err(rtwdev, "failed to leave ips state\n"); |
|
return ret; |
|
} |
|
|
|
rtw_iterate_vifs_atomic(rtwdev, rtw_restore_port_cfg_iter, rtwdev); |
|
|
|
rtw_coex_ips_notify(rtwdev, COEX_IPS_LEAVE); |
|
|
|
return 0; |
|
} |
|
|
|
void rtw_power_mode_change(struct rtw_dev *rtwdev, bool enter) |
|
{ |
|
u8 request, confirm, polling; |
|
int ret; |
|
|
|
request = rtw_read8(rtwdev, rtwdev->hci.rpwm_addr); |
|
confirm = rtw_read8(rtwdev, rtwdev->hci.cpwm_addr); |
|
|
|
/* toggle to request power mode, others remain 0 */ |
|
request ^= request | BIT_RPWM_TOGGLE; |
|
if (enter) { |
|
request |= POWER_MODE_LCLK; |
|
if (rtw_get_lps_deep_mode(rtwdev) == LPS_DEEP_MODE_PG) |
|
request |= POWER_MODE_PG; |
|
} |
|
/* Each request require an ack from firmware */ |
|
request |= POWER_MODE_ACK; |
|
|
|
rtw_write8(rtwdev, rtwdev->hci.rpwm_addr, request); |
|
|
|
/* Check firmware get the power requset and ack via cpwm register */ |
|
ret = read_poll_timeout_atomic(rtw_read8, polling, |
|
(polling ^ confirm) & BIT_RPWM_TOGGLE, |
|
100, 15000, true, rtwdev, |
|
rtwdev->hci.cpwm_addr); |
|
if (ret) { |
|
/* Hit here means that driver failed to get an ack from firmware. |
|
* The reason could be that hardware is locked at Deep sleep, |
|
* so most of the hardware circuits are not working, even |
|
* register read/write; or firmware is locked in some state and |
|
* cannot get the request. It should be treated as fatal error |
|
* and requires an entire analysis about the firmware/hardware. |
|
*/ |
|
WARN(1, "firmware failed to ack driver for %s Deep Power mode\n", |
|
enter ? "entering" : "leaving"); |
|
} |
|
} |
|
EXPORT_SYMBOL(rtw_power_mode_change); |
|
|
|
static void __rtw_leave_lps_deep(struct rtw_dev *rtwdev) |
|
{ |
|
rtw_hci_deep_ps(rtwdev, false); |
|
} |
|
|
|
static int __rtw_fw_leave_lps_check_reg(struct rtw_dev *rtwdev) |
|
{ |
|
int i; |
|
|
|
/* Driver needs to wait for firmware to leave LPS state |
|
* successfully. Firmware will send null packet to inform AP, |
|
* and see if AP sends an ACK back, then firmware will restore |
|
* the REG_TCR register. |
|
* |
|
* If driver does not wait for firmware, null packet with |
|
* PS bit could be sent due to incorrect REG_TCR setting. |
|
* |
|
* In our test, 100ms should be enough for firmware to finish |
|
* the flow. If REG_TCR Register is still incorrect after 100ms, |
|
* just modify it directly, and throw a warn message. |
|
*/ |
|
for (i = 0 ; i < LEAVE_LPS_TRY_CNT; i++) { |
|
if (rtw_read32_mask(rtwdev, REG_TCR, BIT_PWRMGT_HWDATA_EN) == 0) |
|
return 0; |
|
msleep(20); |
|
} |
|
|
|
return -EBUSY; |
|
} |
|
|
|
static int __rtw_fw_leave_lps_check_c2h(struct rtw_dev *rtwdev) |
|
{ |
|
if (wait_for_completion_timeout(&rtwdev->lps_leave_check, |
|
LEAVE_LPS_TIMEOUT)) |
|
return 0; |
|
return -EBUSY; |
|
} |
|
|
|
static void rtw_fw_leave_lps_check(struct rtw_dev *rtwdev) |
|
{ |
|
bool ret = false; |
|
struct rtw_fw_state *fw; |
|
|
|
if (test_bit(RTW_FLAG_WOWLAN, rtwdev->flags)) |
|
fw = &rtwdev->wow_fw; |
|
else |
|
fw = &rtwdev->fw; |
|
|
|
if (rtw_fw_feature_check(fw, FW_FEATURE_LPS_C2H)) |
|
ret = __rtw_fw_leave_lps_check_c2h(rtwdev); |
|
else |
|
ret = __rtw_fw_leave_lps_check_reg(rtwdev); |
|
|
|
if (ret) { |
|
rtw_write32_clr(rtwdev, REG_TCR, BIT_PWRMGT_HWDATA_EN); |
|
rtw_warn(rtwdev, "firmware failed to leave lps state\n"); |
|
} |
|
} |
|
|
|
static void rtw_fw_leave_lps_check_prepare(struct rtw_dev *rtwdev) |
|
{ |
|
struct rtw_fw_state *fw; |
|
|
|
if (test_bit(RTW_FLAG_WOWLAN, rtwdev->flags)) |
|
fw = &rtwdev->wow_fw; |
|
else |
|
fw = &rtwdev->fw; |
|
|
|
if (rtw_fw_feature_check(fw, FW_FEATURE_LPS_C2H)) |
|
reinit_completion(&rtwdev->lps_leave_check); |
|
} |
|
|
|
static void rtw_leave_lps_core(struct rtw_dev *rtwdev) |
|
{ |
|
struct rtw_lps_conf *conf = &rtwdev->lps_conf; |
|
|
|
conf->state = RTW_ALL_ON; |
|
conf->awake_interval = 1; |
|
conf->rlbm = 0; |
|
conf->smart_ps = 0; |
|
|
|
rtw_hci_link_ps(rtwdev, false); |
|
rtw_fw_leave_lps_check_prepare(rtwdev); |
|
rtw_fw_set_pwr_mode(rtwdev); |
|
rtw_fw_leave_lps_check(rtwdev); |
|
|
|
clear_bit(RTW_FLAG_LEISURE_PS, rtwdev->flags); |
|
|
|
rtw_coex_lps_notify(rtwdev, COEX_LPS_DISABLE); |
|
} |
|
|
|
enum rtw_lps_deep_mode rtw_get_lps_deep_mode(struct rtw_dev *rtwdev) |
|
{ |
|
if (test_bit(RTW_FLAG_WOWLAN, rtwdev->flags)) |
|
return rtwdev->lps_conf.wow_deep_mode; |
|
else |
|
return rtwdev->lps_conf.deep_mode; |
|
} |
|
|
|
static void __rtw_enter_lps_deep(struct rtw_dev *rtwdev) |
|
{ |
|
if (rtw_get_lps_deep_mode(rtwdev) == LPS_DEEP_MODE_NONE) |
|
return; |
|
|
|
if (!test_bit(RTW_FLAG_LEISURE_PS, rtwdev->flags)) { |
|
rtw_dbg(rtwdev, RTW_DBG_PS, |
|
"Should enter LPS before entering deep PS\n"); |
|
return; |
|
} |
|
|
|
if (rtw_get_lps_deep_mode(rtwdev) == LPS_DEEP_MODE_PG) |
|
rtw_fw_set_pg_info(rtwdev); |
|
|
|
rtw_hci_deep_ps(rtwdev, true); |
|
} |
|
|
|
static void rtw_enter_lps_core(struct rtw_dev *rtwdev) |
|
{ |
|
struct rtw_lps_conf *conf = &rtwdev->lps_conf; |
|
|
|
conf->state = RTW_RF_OFF; |
|
conf->awake_interval = 1; |
|
conf->rlbm = 1; |
|
conf->smart_ps = 2; |
|
|
|
rtw_coex_lps_notify(rtwdev, COEX_LPS_ENABLE); |
|
|
|
rtw_fw_set_pwr_mode(rtwdev); |
|
rtw_hci_link_ps(rtwdev, true); |
|
|
|
set_bit(RTW_FLAG_LEISURE_PS, rtwdev->flags); |
|
} |
|
|
|
static void __rtw_enter_lps(struct rtw_dev *rtwdev, u8 port_id) |
|
{ |
|
struct rtw_lps_conf *conf = &rtwdev->lps_conf; |
|
|
|
if (test_bit(RTW_FLAG_LEISURE_PS, rtwdev->flags)) |
|
return; |
|
|
|
conf->mode = RTW_MODE_LPS; |
|
conf->port_id = port_id; |
|
|
|
rtw_enter_lps_core(rtwdev); |
|
} |
|
|
|
static void __rtw_leave_lps(struct rtw_dev *rtwdev) |
|
{ |
|
struct rtw_lps_conf *conf = &rtwdev->lps_conf; |
|
|
|
if (test_and_clear_bit(RTW_FLAG_LEISURE_PS_DEEP, rtwdev->flags)) { |
|
rtw_dbg(rtwdev, RTW_DBG_PS, |
|
"Should leave deep PS before leaving LPS\n"); |
|
__rtw_leave_lps_deep(rtwdev); |
|
} |
|
|
|
if (!test_bit(RTW_FLAG_LEISURE_PS, rtwdev->flags)) |
|
return; |
|
|
|
conf->mode = RTW_MODE_ACTIVE; |
|
|
|
rtw_leave_lps_core(rtwdev); |
|
} |
|
|
|
void rtw_enter_lps(struct rtw_dev *rtwdev, u8 port_id) |
|
{ |
|
lockdep_assert_held(&rtwdev->mutex); |
|
|
|
if (rtwdev->coex.stat.wl_force_lps_ctrl) |
|
return; |
|
|
|
__rtw_enter_lps(rtwdev, port_id); |
|
__rtw_enter_lps_deep(rtwdev); |
|
} |
|
|
|
void rtw_leave_lps(struct rtw_dev *rtwdev) |
|
{ |
|
lockdep_assert_held(&rtwdev->mutex); |
|
|
|
__rtw_leave_lps_deep(rtwdev); |
|
__rtw_leave_lps(rtwdev); |
|
} |
|
|
|
void rtw_leave_lps_deep(struct rtw_dev *rtwdev) |
|
{ |
|
lockdep_assert_held(&rtwdev->mutex); |
|
|
|
__rtw_leave_lps_deep(rtwdev); |
|
}
|
|
|