1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved. 4 * 5 * Based on the r8180 driver, which is: 6 * Copyright 2004-2005 Andrea Merello <andrea.merello@gmail.com>, et al. 7 * 8 * Contact Information: wlanfae <wlanfae@realtek.com> 9 */ 10 #include "rtl_ps.h" 11 #include "rtl_core.h" 12 #include "r8192E_phy.h" 13 #include "r8192E_phyreg.h" 14 #include "r8190P_rtl8256.h" /* RTL8225 Radio frontend */ 15 #include "r8192E_cmdpkt.h" 16 #include <linux/jiffies.h> 17 18 static void _rtl92e_hw_sleep(struct net_device *dev) 19 { 20 struct r8192_priv *priv = rtllib_priv(dev); 21 unsigned long flags = 0; 22 23 spin_lock_irqsave(&priv->rf_ps_lock, flags); 24 if (priv->rf_change_in_progress) { 25 spin_unlock_irqrestore(&priv->rf_ps_lock, flags); 26 return; 27 } 28 spin_unlock_irqrestore(&priv->rf_ps_lock, flags); 29 rtl92e_set_rf_state(dev, rf_sleep, RF_CHANGE_BY_PS); 30 } 31 32 void rtl92e_hw_sleep_wq(void *data) 33 { 34 struct rtllib_device *ieee = container_of_dwork_rsl(data, 35 struct rtllib_device, hw_sleep_wq); 36 struct net_device *dev = ieee->dev; 37 38 _rtl92e_hw_sleep(dev); 39 } 40 41 void rtl92e_hw_wakeup(struct net_device *dev) 42 { 43 struct r8192_priv *priv = rtllib_priv(dev); 44 unsigned long flags = 0; 45 46 spin_lock_irqsave(&priv->rf_ps_lock, flags); 47 if (priv->rf_change_in_progress) { 48 spin_unlock_irqrestore(&priv->rf_ps_lock, flags); 49 schedule_delayed_work(&priv->rtllib->hw_wakeup_wq, 50 msecs_to_jiffies(10)); 51 return; 52 } 53 spin_unlock_irqrestore(&priv->rf_ps_lock, flags); 54 rtl92e_set_rf_state(dev, rf_on, RF_CHANGE_BY_PS); 55 } 56 57 void rtl92e_hw_wakeup_wq(void *data) 58 { 59 struct rtllib_device *ieee = container_of_dwork_rsl(data, 60 struct rtllib_device, hw_wakeup_wq); 61 struct net_device *dev = ieee->dev; 62 63 rtl92e_hw_wakeup(dev); 64 } 65 66 #define MIN_SLEEP_TIME 50 67 #define MAX_SLEEP_TIME 10000 68 void rtl92e_enter_sleep(struct net_device *dev, u64 time) 69 { 70 struct r8192_priv *priv = rtllib_priv(dev); 71 72 u32 tmp; 73 unsigned long flags; 74 unsigned long timeout; 75 76 spin_lock_irqsave(&priv->ps_lock, flags); 77 78 time -= msecs_to_jiffies(8 + 16 + 7); 79 80 timeout = jiffies + msecs_to_jiffies(MIN_SLEEP_TIME); 81 if (time_before((unsigned long)time, timeout)) { 82 spin_unlock_irqrestore(&priv->ps_lock, flags); 83 netdev_info(dev, "too short to sleep::%lld < %ld\n", 84 time - jiffies, msecs_to_jiffies(MIN_SLEEP_TIME)); 85 return; 86 } 87 timeout = jiffies + msecs_to_jiffies(MAX_SLEEP_TIME); 88 if (time_after((unsigned long)time, timeout)) { 89 netdev_info(dev, "========>too long to sleep:%lld > %ld\n", 90 time - jiffies, msecs_to_jiffies(MAX_SLEEP_TIME)); 91 spin_unlock_irqrestore(&priv->ps_lock, flags); 92 return; 93 } 94 tmp = time - jiffies; 95 schedule_delayed_work(&priv->rtllib->hw_wakeup_wq, tmp); 96 schedule_delayed_work(&priv->rtllib->hw_sleep_wq, 0); 97 spin_unlock_irqrestore(&priv->ps_lock, flags); 98 } 99 100 static void _rtl92e_ps_update_rf_state(struct net_device *dev) 101 { 102 struct r8192_priv *priv = rtllib_priv(dev); 103 struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *) 104 &priv->rtllib->pwr_save_ctrl; 105 106 psc->bSwRfProcessing = true; 107 rtl92e_set_rf_state(dev, psc->eInactivePowerState, RF_CHANGE_BY_IPS); 108 109 psc->bSwRfProcessing = false; 110 } 111 112 void rtl92e_ips_enter(struct net_device *dev) 113 { 114 struct r8192_priv *priv = rtllib_priv(dev); 115 struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *) 116 &priv->rtllib->pwr_save_ctrl; 117 enum rt_rf_power_state rt_state; 118 119 rt_state = priv->rtllib->rf_power_state; 120 if (rt_state == rf_on && !psc->bSwRfProcessing && 121 (priv->rtllib->state != RTLLIB_LINKED) && 122 (priv->rtllib->iw_mode != IW_MODE_MASTER)) { 123 psc->eInactivePowerState = rf_off; 124 _rtl92e_ps_update_rf_state(dev); 125 } 126 } 127 128 void rtl92e_ips_leave(struct net_device *dev) 129 { 130 struct r8192_priv *priv = rtllib_priv(dev); 131 struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *) 132 &priv->rtllib->pwr_save_ctrl; 133 enum rt_rf_power_state rt_state; 134 135 rt_state = priv->rtllib->rf_power_state; 136 if (rt_state != rf_on && !psc->bSwRfProcessing && 137 priv->rtllib->rf_off_reason <= RF_CHANGE_BY_IPS) { 138 psc->eInactivePowerState = rf_on; 139 _rtl92e_ps_update_rf_state(dev); 140 } 141 } 142 143 void rtl92e_ips_leave_wq(void *data) 144 { 145 struct rtllib_device *ieee = container_of_work_rsl(data, 146 struct rtllib_device, ips_leave_wq); 147 struct net_device *dev = ieee->dev; 148 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); 149 150 mutex_lock(&priv->rtllib->ips_mutex); 151 rtl92e_ips_leave(dev); 152 mutex_unlock(&priv->rtllib->ips_mutex); 153 } 154 155 void rtl92e_rtllib_ips_leave_wq(struct net_device *dev) 156 { 157 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); 158 enum rt_rf_power_state rt_state; 159 160 rt_state = priv->rtllib->rf_power_state; 161 if (rt_state == rf_off) { 162 if (priv->rtllib->rf_off_reason > RF_CHANGE_BY_IPS) { 163 netdev_warn(dev, "%s(): RF is OFF.\n", 164 __func__); 165 return; 166 } 167 netdev_info(dev, "=========>%s(): rtl92e_ips_leave\n", 168 __func__); 169 schedule_work(&priv->rtllib->ips_leave_wq); 170 } 171 } 172 173 void rtl92e_rtllib_ips_leave(struct net_device *dev) 174 { 175 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); 176 177 mutex_lock(&priv->rtllib->ips_mutex); 178 rtl92e_ips_leave(dev); 179 mutex_unlock(&priv->rtllib->ips_mutex); 180 } 181 182 static bool _rtl92e_ps_set_mode(struct net_device *dev, u8 rtPsMode) 183 { 184 struct r8192_priv *priv = rtllib_priv(dev); 185 186 if (priv->rtllib->iw_mode == IW_MODE_ADHOC) 187 return false; 188 189 if (!priv->ps_force) 190 priv->rtllib->ps = rtPsMode; 191 if (priv->rtllib->sta_sleep != LPS_IS_WAKE && 192 rtPsMode == RTLLIB_PS_DISABLED) { 193 unsigned long flags; 194 195 rtl92e_hw_wakeup(dev); 196 priv->rtllib->sta_sleep = LPS_IS_WAKE; 197 198 spin_lock_irqsave(&(priv->rtllib->mgmt_tx_lock), flags); 199 rtllib_sta_ps_send_null_frame(priv->rtllib, 0); 200 spin_unlock_irqrestore(&(priv->rtllib->mgmt_tx_lock), flags); 201 } 202 203 return true; 204 } 205 206 void rtl92e_leisure_ps_enter(struct net_device *dev) 207 { 208 struct r8192_priv *priv = rtllib_priv(dev); 209 struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *) 210 &priv->rtllib->pwr_save_ctrl; 211 212 if (!((priv->rtllib->iw_mode == IW_MODE_INFRA) && 213 (priv->rtllib->state == RTLLIB_LINKED)) 214 || (priv->rtllib->iw_mode == IW_MODE_ADHOC) || 215 (priv->rtllib->iw_mode == IW_MODE_MASTER)) 216 return; 217 218 if (psc->bLeisurePs) { 219 if (psc->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) { 220 221 if (priv->rtllib->ps == RTLLIB_PS_DISABLED) { 222 if (priv->rtllib->SetFwCmdHandler) 223 priv->rtllib->SetFwCmdHandler(dev, FW_CMD_LPS_ENTER); 224 _rtl92e_ps_set_mode(dev, RTLLIB_PS_MBCAST | 225 RTLLIB_PS_UNICAST); 226 } 227 } else 228 psc->LpsIdleCount++; 229 } 230 } 231 232 void rtl92e_leisure_ps_leave(struct net_device *dev) 233 { 234 struct r8192_priv *priv = rtllib_priv(dev); 235 struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *) 236 &priv->rtllib->pwr_save_ctrl; 237 238 if (psc->bLeisurePs) { 239 if (priv->rtllib->ps != RTLLIB_PS_DISABLED) { 240 _rtl92e_ps_set_mode(dev, RTLLIB_PS_DISABLED); 241 if (priv->rtllib->SetFwCmdHandler) 242 priv->rtllib->SetFwCmdHandler(dev, FW_CMD_LPS_LEAVE); 243 } 244 } 245 } 246