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
_rtl92e_hw_sleep(struct net_device * dev)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
rtl92e_hw_sleep_wq(void * data)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
rtl92e_hw_wakeup(struct net_device * dev)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
rtl92e_hw_wakeup_wq(void * data)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
rtl92e_enter_sleep(struct net_device * dev,u64 time)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
_rtl92e_ps_update_rf_state(struct net_device * dev)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 *pPSC = (struct rt_pwr_save_ctrl *)
104 &(priv->rtllib->PowerSaveControl);
105
106 pPSC->bSwRfProcessing = true;
107 rtl92e_set_rf_state(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
108
109 pPSC->bSwRfProcessing = false;
110 }
111
rtl92e_ips_enter(struct net_device * dev)112 void rtl92e_ips_enter(struct net_device *dev)
113 {
114 struct r8192_priv *priv = rtllib_priv(dev);
115 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
116 &(priv->rtllib->PowerSaveControl);
117 enum rt_rf_power_state rt_state;
118
119 if (pPSC->bInactivePs) {
120 rt_state = priv->rtllib->rf_power_state;
121 if (rt_state == rf_on && !pPSC->bSwRfProcessing &&
122 (priv->rtllib->state != RTLLIB_LINKED) &&
123 (priv->rtllib->iw_mode != IW_MODE_MASTER)) {
124 pPSC->eInactivePowerState = rf_off;
125 priv->isRFOff = true;
126 priv->bInPowerSaveMode = true;
127 _rtl92e_ps_update_rf_state(dev);
128 }
129 }
130 }
131
rtl92e_ips_leave(struct net_device * dev)132 void rtl92e_ips_leave(struct net_device *dev)
133 {
134 struct r8192_priv *priv = rtllib_priv(dev);
135 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
136 &(priv->rtllib->PowerSaveControl);
137 enum rt_rf_power_state rt_state;
138
139 if (pPSC->bInactivePs) {
140 rt_state = priv->rtllib->rf_power_state;
141 if (rt_state != rf_on && !pPSC->bSwRfProcessing &&
142 priv->rtllib->rf_off_reason <= RF_CHANGE_BY_IPS) {
143 pPSC->eInactivePowerState = rf_on;
144 priv->bInPowerSaveMode = false;
145 _rtl92e_ps_update_rf_state(dev);
146 }
147 }
148 }
149
rtl92e_ips_leave_wq(void * data)150 void rtl92e_ips_leave_wq(void *data)
151 {
152 struct rtllib_device *ieee = container_of_work_rsl(data,
153 struct rtllib_device, ips_leave_wq);
154 struct net_device *dev = ieee->dev;
155 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
156
157 mutex_lock(&priv->rtllib->ips_mutex);
158 rtl92e_ips_leave(dev);
159 mutex_unlock(&priv->rtllib->ips_mutex);
160 }
161
rtl92e_rtllib_ips_leave_wq(struct net_device * dev)162 void rtl92e_rtllib_ips_leave_wq(struct net_device *dev)
163 {
164 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
165 enum rt_rf_power_state rt_state;
166
167 rt_state = priv->rtllib->rf_power_state;
168
169 if (priv->rtllib->PowerSaveControl.bInactivePs) {
170 if (rt_state == rf_off) {
171 if (priv->rtllib->rf_off_reason > RF_CHANGE_BY_IPS) {
172 netdev_warn(dev, "%s(): RF is OFF.\n",
173 __func__);
174 return;
175 }
176 netdev_info(dev, "=========>%s(): rtl92e_ips_leave\n",
177 __func__);
178 schedule_work(&priv->rtllib->ips_leave_wq);
179 }
180 }
181 }
182
rtl92e_rtllib_ips_leave(struct net_device * dev)183 void rtl92e_rtllib_ips_leave(struct net_device *dev)
184 {
185 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
186
187 mutex_lock(&priv->rtllib->ips_mutex);
188 rtl92e_ips_leave(dev);
189 mutex_unlock(&priv->rtllib->ips_mutex);
190 }
191
_rtl92e_ps_set_mode(struct net_device * dev,u8 rtPsMode)192 static bool _rtl92e_ps_set_mode(struct net_device *dev, u8 rtPsMode)
193 {
194 struct r8192_priv *priv = rtllib_priv(dev);
195
196 if (priv->rtllib->iw_mode == IW_MODE_ADHOC)
197 return false;
198
199 if (!priv->ps_force)
200 priv->rtllib->ps = rtPsMode;
201 if (priv->rtllib->sta_sleep != LPS_IS_WAKE &&
202 rtPsMode == RTLLIB_PS_DISABLED) {
203 unsigned long flags;
204
205 rtl92e_hw_wakeup(dev);
206 priv->rtllib->sta_sleep = LPS_IS_WAKE;
207
208 spin_lock_irqsave(&(priv->rtllib->mgmt_tx_lock), flags);
209 rtllib_sta_ps_send_null_frame(priv->rtllib, 0);
210 spin_unlock_irqrestore(&(priv->rtllib->mgmt_tx_lock), flags);
211 }
212
213 return true;
214 }
215
rtl92e_leisure_ps_enter(struct net_device * dev)216 void rtl92e_leisure_ps_enter(struct net_device *dev)
217 {
218 struct r8192_priv *priv = rtllib_priv(dev);
219 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
220 &(priv->rtllib->PowerSaveControl);
221
222 if (!((priv->rtllib->iw_mode == IW_MODE_INFRA) &&
223 (priv->rtllib->state == RTLLIB_LINKED))
224 || (priv->rtllib->iw_mode == IW_MODE_ADHOC) ||
225 (priv->rtllib->iw_mode == IW_MODE_MASTER))
226 return;
227
228 if (pPSC->bLeisurePs) {
229 if (pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) {
230
231 if (priv->rtllib->ps == RTLLIB_PS_DISABLED) {
232 if (!pPSC->bFwCtrlLPS) {
233 if (priv->rtllib->SetFwCmdHandler)
234 priv->rtllib->SetFwCmdHandler(
235 dev, FW_CMD_LPS_ENTER);
236 }
237 _rtl92e_ps_set_mode(dev, RTLLIB_PS_MBCAST |
238 RTLLIB_PS_UNICAST);
239 }
240 } else
241 pPSC->LpsIdleCount++;
242 }
243 }
244
rtl92e_leisure_ps_leave(struct net_device * dev)245 void rtl92e_leisure_ps_leave(struct net_device *dev)
246 {
247 struct r8192_priv *priv = rtllib_priv(dev);
248 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
249 &(priv->rtllib->PowerSaveControl);
250
251 if (pPSC->bLeisurePs) {
252 if (priv->rtllib->ps != RTLLIB_PS_DISABLED) {
253 _rtl92e_ps_set_mode(dev, RTLLIB_PS_DISABLED);
254
255 if (!pPSC->bFwCtrlLPS) {
256 if (priv->rtllib->SetFwCmdHandler)
257 priv->rtllib->SetFwCmdHandler(dev,
258 FW_CMD_LPS_LEAVE);
259 }
260 }
261 }
262 }
263
