1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 *
4 * Based on the r8180 driver, which is:
5 * Copyright 2004-2005 Andrea Merello <andrea.merello@gmail.com>, et al.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of version 2 of the GNU General Public License as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * The full GNU General Public License is included in this distribution in the
16 * file called LICENSE.
17 *
18 * Contact Information:
19 * wlanfae <wlanfae@realtek.com>
20 *****************************************************************************/
21 #include "rtl_ps.h"
22 #include "rtl_core.h"
23 #include "r8192E_phy.h"
24 #include "r8192E_phyreg.h"
25 #include "r8190P_rtl8256.h" /* RTL8225 Radio frontend */
26 #include "r8192E_cmdpkt.h"
27 #include <linux/jiffies.h>
28
_rtl92e_hw_sleep(struct net_device * dev)29 static void _rtl92e_hw_sleep(struct net_device *dev)
30 {
31 struct r8192_priv *priv = rtllib_priv(dev);
32 unsigned long flags = 0;
33
34 spin_lock_irqsave(&priv->rf_ps_lock, flags);
35 if (priv->RFChangeInProgress) {
36 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
37 RT_TRACE(COMP_DBG,
38 "_rtl92e_hw_sleep(): RF Change in progress!\n");
39 return;
40 }
41 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
42 RT_TRACE(COMP_DBG, "%s()============>come to sleep down\n", __func__);
43
44 rtl92e_set_rf_state(dev, eRfSleep, RF_CHANGE_BY_PS);
45 }
46
rtl92e_hw_sleep_wq(void * data)47 void rtl92e_hw_sleep_wq(void *data)
48 {
49 struct rtllib_device *ieee = container_of_dwork_rsl(data,
50 struct rtllib_device, hw_sleep_wq);
51 struct net_device *dev = ieee->dev;
52
53 _rtl92e_hw_sleep(dev);
54 }
55
rtl92e_hw_wakeup(struct net_device * dev)56 void rtl92e_hw_wakeup(struct net_device *dev)
57 {
58 struct r8192_priv *priv = rtllib_priv(dev);
59 unsigned long flags = 0;
60
61 spin_lock_irqsave(&priv->rf_ps_lock, flags);
62 if (priv->RFChangeInProgress) {
63 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
64 RT_TRACE(COMP_DBG,
65 "rtl92e_hw_wakeup(): RF Change in progress!\n");
66 queue_delayed_work_rsl(priv->rtllib->wq,
67 &priv->rtllib->hw_wakeup_wq,
68 msecs_to_jiffies(10));
69 return;
70 }
71 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
72 RT_TRACE(COMP_PS, "%s()============>come to wake up\n", __func__);
73 rtl92e_set_rf_state(dev, eRfOn, RF_CHANGE_BY_PS);
74 }
75
rtl92e_hw_wakeup_wq(void * data)76 void rtl92e_hw_wakeup_wq(void *data)
77 {
78 struct rtllib_device *ieee = container_of_dwork_rsl(data,
79 struct rtllib_device, hw_wakeup_wq);
80 struct net_device *dev = ieee->dev;
81
82 rtl92e_hw_wakeup(dev);
83 }
84
85 #define MIN_SLEEP_TIME 50
86 #define MAX_SLEEP_TIME 10000
rtl92e_enter_sleep(struct net_device * dev,u64 time)87 void rtl92e_enter_sleep(struct net_device *dev, u64 time)
88 {
89 struct r8192_priv *priv = rtllib_priv(dev);
90
91 u32 tmp;
92 unsigned long flags;
93 unsigned long timeout;
94
95 spin_lock_irqsave(&priv->ps_lock, flags);
96
97 time -= msecs_to_jiffies(8 + 16 + 7);
98
99 timeout = jiffies + msecs_to_jiffies(MIN_SLEEP_TIME);
100 if (time_before((unsigned long)time, timeout)) {
101 spin_unlock_irqrestore(&priv->ps_lock, flags);
102 netdev_info(dev, "too short to sleep::%lld < %ld\n",
103 time - jiffies, msecs_to_jiffies(MIN_SLEEP_TIME));
104 return;
105 }
106 timeout = jiffies + msecs_to_jiffies(MAX_SLEEP_TIME);
107 if (time_after((unsigned long)time, timeout)) {
108 netdev_info(dev, "========>too long to sleep:%lld > %ld\n",
109 time - jiffies, msecs_to_jiffies(MAX_SLEEP_TIME));
110 spin_unlock_irqrestore(&priv->ps_lock, flags);
111 return;
112 }
113 tmp = time - jiffies;
114 queue_delayed_work_rsl(priv->rtllib->wq,
115 &priv->rtllib->hw_wakeup_wq, tmp);
116 queue_delayed_work_rsl(priv->rtllib->wq,
117 (void *)&priv->rtllib->hw_sleep_wq, 0);
118 spin_unlock_irqrestore(&priv->ps_lock, flags);
119 }
120
_rtl92e_ps_update_rf_state(struct net_device * dev)121 static void _rtl92e_ps_update_rf_state(struct net_device *dev)
122 {
123 struct r8192_priv *priv = rtllib_priv(dev);
124 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
125 &(priv->rtllib->PowerSaveControl);
126
127 RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state() --------->\n");
128 pPSC->bSwRfProcessing = true;
129
130 RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state(): Set RF to %s.\n",
131 pPSC->eInactivePowerState == eRfOff ? "OFF" : "ON");
132 rtl92e_set_rf_state(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
133
134 pPSC->bSwRfProcessing = false;
135 RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state() <---------\n");
136 }
137
rtl92e_ips_enter(struct net_device * dev)138 void rtl92e_ips_enter(struct net_device *dev)
139 {
140 struct r8192_priv *priv = rtllib_priv(dev);
141 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
142 &(priv->rtllib->PowerSaveControl);
143 enum rt_rf_power_state rtState;
144
145 if (pPSC->bInactivePs) {
146 rtState = priv->rtllib->eRFPowerState;
147 if (rtState == eRfOn && !pPSC->bSwRfProcessing &&
148 (priv->rtllib->state != RTLLIB_LINKED) &&
149 (priv->rtllib->iw_mode != IW_MODE_MASTER)) {
150 RT_TRACE(COMP_PS, "rtl92e_ips_enter(): Turn off RF.\n");
151 pPSC->eInactivePowerState = eRfOff;
152 priv->isRFOff = true;
153 priv->bInPowerSaveMode = true;
154 _rtl92e_ps_update_rf_state(dev);
155 }
156 }
157 }
158
rtl92e_ips_leave(struct net_device * dev)159 void rtl92e_ips_leave(struct net_device *dev)
160 {
161 struct r8192_priv *priv = rtllib_priv(dev);
162 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
163 &(priv->rtllib->PowerSaveControl);
164 enum rt_rf_power_state rtState;
165
166 if (pPSC->bInactivePs) {
167 rtState = priv->rtllib->eRFPowerState;
168 if (rtState != eRfOn && !pPSC->bSwRfProcessing &&
169 priv->rtllib->RfOffReason <= RF_CHANGE_BY_IPS) {
170 RT_TRACE(COMP_PS, "rtl92e_ips_leave(): Turn on RF.\n");
171 pPSC->eInactivePowerState = eRfOn;
172 priv->bInPowerSaveMode = false;
173 _rtl92e_ps_update_rf_state(dev);
174 }
175 }
176 }
177
rtl92e_ips_leave_wq(void * data)178 void rtl92e_ips_leave_wq(void *data)
179 {
180 struct rtllib_device *ieee = container_of_work_rsl(data,
181 struct rtllib_device, ips_leave_wq);
182 struct net_device *dev = ieee->dev;
183 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
184
185 down(&priv->rtllib->ips_sem);
186 rtl92e_ips_leave(dev);
187 up(&priv->rtllib->ips_sem);
188 }
189
rtl92e_rtllib_ips_leave_wq(struct net_device * dev)190 void rtl92e_rtllib_ips_leave_wq(struct net_device *dev)
191 {
192 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
193 enum rt_rf_power_state rtState;
194
195 rtState = priv->rtllib->eRFPowerState;
196
197 if (priv->rtllib->PowerSaveControl.bInactivePs) {
198 if (rtState == eRfOff) {
199 if (priv->rtllib->RfOffReason > RF_CHANGE_BY_IPS) {
200 netdev_warn(dev, "%s(): RF is OFF.\n",
201 __func__);
202 return;
203 }
204 netdev_info(dev, "=========>%s(): rtl92e_ips_leave\n",
205 __func__);
206 queue_work_rsl(priv->rtllib->wq,
207 &priv->rtllib->ips_leave_wq);
208 }
209 }
210 }
211
rtl92e_rtllib_ips_leave(struct net_device * dev)212 void rtl92e_rtllib_ips_leave(struct net_device *dev)
213 {
214 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
215
216 down(&priv->rtllib->ips_sem);
217 rtl92e_ips_leave(dev);
218 up(&priv->rtllib->ips_sem);
219 }
220
_rtl92e_ps_set_mode(struct net_device * dev,u8 rtPsMode)221 static bool _rtl92e_ps_set_mode(struct net_device *dev, u8 rtPsMode)
222 {
223 struct r8192_priv *priv = rtllib_priv(dev);
224
225 if (priv->rtllib->iw_mode == IW_MODE_ADHOC)
226 return false;
227
228 RT_TRACE(COMP_LPS, "%s(): set ieee->ps = %x\n", __func__, rtPsMode);
229 if (!priv->ps_force)
230 priv->rtllib->ps = rtPsMode;
231 if (priv->rtllib->sta_sleep != LPS_IS_WAKE &&
232 rtPsMode == RTLLIB_PS_DISABLED) {
233 unsigned long flags;
234
235 rtl92e_hw_wakeup(dev);
236 priv->rtllib->sta_sleep = LPS_IS_WAKE;
237
238 spin_lock_irqsave(&(priv->rtllib->mgmt_tx_lock), flags);
239 RT_TRACE(COMP_DBG,
240 "LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
241 rtllib_sta_ps_send_null_frame(priv->rtllib, 0);
242 spin_unlock_irqrestore(&(priv->rtllib->mgmt_tx_lock), flags);
243 }
244
245 return true;
246 }
247
rtl92e_leisure_ps_enter(struct net_device * dev)248 void rtl92e_leisure_ps_enter(struct net_device *dev)
249 {
250 struct r8192_priv *priv = rtllib_priv(dev);
251 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
252 &(priv->rtllib->PowerSaveControl);
253
254 RT_TRACE(COMP_PS, "rtl92e_leisure_ps_enter()...\n");
255 RT_TRACE(COMP_PS,
256 "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
257 pPSC->bLeisurePs, priv->rtllib->ps, pPSC->LpsIdleCount,
258 RT_CHECK_FOR_HANG_PERIOD);
259
260 if (!((priv->rtllib->iw_mode == IW_MODE_INFRA) &&
261 (priv->rtllib->state == RTLLIB_LINKED))
262 || (priv->rtllib->iw_mode == IW_MODE_ADHOC) ||
263 (priv->rtllib->iw_mode == IW_MODE_MASTER))
264 return;
265
266 if (pPSC->bLeisurePs) {
267 if (pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) {
268
269 if (priv->rtllib->ps == RTLLIB_PS_DISABLED) {
270
271 RT_TRACE(COMP_LPS,
272 "rtl92e_leisure_ps_enter(): Enter 802.11 power save mode...\n");
273
274 if (!pPSC->bFwCtrlLPS) {
275 if (priv->rtllib->SetFwCmdHandler)
276 priv->rtllib->SetFwCmdHandler(
277 dev, FW_CMD_LPS_ENTER);
278 }
279 _rtl92e_ps_set_mode(dev, RTLLIB_PS_MBCAST |
280 RTLLIB_PS_UNICAST);
281 }
282 } else
283 pPSC->LpsIdleCount++;
284 }
285 }
286
rtl92e_leisure_ps_leave(struct net_device * dev)287 void rtl92e_leisure_ps_leave(struct net_device *dev)
288 {
289 struct r8192_priv *priv = rtllib_priv(dev);
290 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
291 &(priv->rtllib->PowerSaveControl);
292
293
294 RT_TRACE(COMP_PS, "rtl92e_leisure_ps_leave()...\n");
295 RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d\n",
296 pPSC->bLeisurePs, priv->rtllib->ps);
297
298 if (pPSC->bLeisurePs) {
299 if (priv->rtllib->ps != RTLLIB_PS_DISABLED) {
300 RT_TRACE(COMP_LPS,
301 "rtl92e_leisure_ps_leave(): Busy Traffic , Leave 802.11 power save..\n");
302 _rtl92e_ps_set_mode(dev, RTLLIB_PS_DISABLED);
303
304 if (!pPSC->bFwCtrlLPS) {
305 if (priv->rtllib->SetFwCmdHandler)
306 priv->rtllib->SetFwCmdHandler(dev,
307 FW_CMD_LPS_LEAVE);
308 }
309 }
310 }
311 }
312