1 /*
2 * Mac80211 power management API for ST-Ericsson CW1200 drivers
3 *
4 * Copyright (c) 2011, ST-Ericsson
5 * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12 #include <linux/module.h>
13 #include <linux/if_ether.h>
14 #include "cw1200.h"
15 #include "pm.h"
16 #include "sta.h"
17 #include "bh.h"
18 #include "hwbus.h"
19
20 #define CW1200_BEACON_SKIPPING_MULTIPLIER 3
21
22 struct cw1200_udp_port_filter {
23 struct wsm_udp_port_filter_hdr hdr;
24 /* Up to 4 filters are allowed. */
25 struct wsm_udp_port_filter filters[WSM_MAX_FILTER_ELEMENTS];
26 } __packed;
27
28 struct cw1200_ether_type_filter {
29 struct wsm_ether_type_filter_hdr hdr;
30 /* Up to 4 filters are allowed. */
31 struct wsm_ether_type_filter filters[WSM_MAX_FILTER_ELEMENTS];
32 } __packed;
33
34 static struct cw1200_udp_port_filter cw1200_udp_port_filter_on = {
35 .hdr.num = 2,
36 .filters = {
37 [0] = {
38 .action = WSM_FILTER_ACTION_FILTER_OUT,
39 .type = WSM_FILTER_PORT_TYPE_DST,
40 .port = __cpu_to_le16(67), /* DHCP Bootps */
41 },
42 [1] = {
43 .action = WSM_FILTER_ACTION_FILTER_OUT,
44 .type = WSM_FILTER_PORT_TYPE_DST,
45 .port = __cpu_to_le16(68), /* DHCP Bootpc */
46 },
47 }
48 };
49
50 static struct wsm_udp_port_filter_hdr cw1200_udp_port_filter_off = {
51 .num = 0,
52 };
53
54 #ifndef ETH_P_WAPI
55 #define ETH_P_WAPI 0x88B4
56 #endif
57
58 static struct cw1200_ether_type_filter cw1200_ether_type_filter_on = {
59 .hdr.num = 4,
60 .filters = {
61 [0] = {
62 .action = WSM_FILTER_ACTION_FILTER_IN,
63 .type = __cpu_to_le16(ETH_P_IP),
64 },
65 [1] = {
66 .action = WSM_FILTER_ACTION_FILTER_IN,
67 .type = __cpu_to_le16(ETH_P_PAE),
68 },
69 [2] = {
70 .action = WSM_FILTER_ACTION_FILTER_IN,
71 .type = __cpu_to_le16(ETH_P_WAPI),
72 },
73 [3] = {
74 .action = WSM_FILTER_ACTION_FILTER_IN,
75 .type = __cpu_to_le16(ETH_P_ARP),
76 },
77 },
78 };
79
80 static struct wsm_ether_type_filter_hdr cw1200_ether_type_filter_off = {
81 .num = 0,
82 };
83
84 /* private */
85 struct cw1200_suspend_state {
86 unsigned long bss_loss_tmo;
87 unsigned long join_tmo;
88 unsigned long direct_probe;
89 unsigned long link_id_gc;
90 bool beacon_skipping;
91 u8 prev_ps_mode;
92 };
93
cw1200_pm_stay_awake_tmo(unsigned long arg)94 static void cw1200_pm_stay_awake_tmo(unsigned long arg)
95 {
96 /* XXX what's the point of this ? */
97 }
98
cw1200_pm_init(struct cw1200_pm_state * pm,struct cw1200_common * priv)99 int cw1200_pm_init(struct cw1200_pm_state *pm,
100 struct cw1200_common *priv)
101 {
102 spin_lock_init(&pm->lock);
103
104 setup_timer(&pm->stay_awake, cw1200_pm_stay_awake_tmo,
105 (unsigned long)pm);
106
107 return 0;
108 }
109
cw1200_pm_deinit(struct cw1200_pm_state * pm)110 void cw1200_pm_deinit(struct cw1200_pm_state *pm)
111 {
112 del_timer_sync(&pm->stay_awake);
113 }
114
cw1200_pm_stay_awake(struct cw1200_pm_state * pm,unsigned long tmo)115 void cw1200_pm_stay_awake(struct cw1200_pm_state *pm,
116 unsigned long tmo)
117 {
118 long cur_tmo;
119 spin_lock_bh(&pm->lock);
120 cur_tmo = pm->stay_awake.expires - jiffies;
121 if (!timer_pending(&pm->stay_awake) || cur_tmo < (long)tmo)
122 mod_timer(&pm->stay_awake, jiffies + tmo);
123 spin_unlock_bh(&pm->lock);
124 }
125
cw1200_suspend_work(struct delayed_work * work)126 static long cw1200_suspend_work(struct delayed_work *work)
127 {
128 int ret = cancel_delayed_work(work);
129 long tmo;
130 if (ret > 0) {
131 /* Timer is pending */
132 tmo = work->timer.expires - jiffies;
133 if (tmo < 0)
134 tmo = 0;
135 } else {
136 tmo = -1;
137 }
138 return tmo;
139 }
140
cw1200_resume_work(struct cw1200_common * priv,struct delayed_work * work,unsigned long tmo)141 static int cw1200_resume_work(struct cw1200_common *priv,
142 struct delayed_work *work,
143 unsigned long tmo)
144 {
145 if ((long)tmo < 0)
146 return 1;
147
148 return queue_delayed_work(priv->workqueue, work, tmo);
149 }
150
cw1200_can_suspend(struct cw1200_common * priv)151 int cw1200_can_suspend(struct cw1200_common *priv)
152 {
153 if (atomic_read(&priv->bh_rx)) {
154 wiphy_dbg(priv->hw->wiphy, "Suspend interrupted.\n");
155 return 0;
156 }
157 return 1;
158 }
159 EXPORT_SYMBOL_GPL(cw1200_can_suspend);
160
cw1200_wow_suspend(struct ieee80211_hw * hw,struct cfg80211_wowlan * wowlan)161 int cw1200_wow_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wowlan)
162 {
163 struct cw1200_common *priv = hw->priv;
164 struct cw1200_pm_state *pm_state = &priv->pm_state;
165 struct cw1200_suspend_state *state;
166 int ret;
167
168 spin_lock_bh(&pm_state->lock);
169 ret = timer_pending(&pm_state->stay_awake);
170 spin_unlock_bh(&pm_state->lock);
171 if (ret)
172 return -EAGAIN;
173
174 /* Do not suspend when datapath is not idle */
175 if (priv->tx_queue_stats.num_queued)
176 return -EBUSY;
177
178 /* Make sure there is no configuration requests in progress. */
179 if (!mutex_trylock(&priv->conf_mutex))
180 return -EBUSY;
181
182 /* Ensure pending operations are done.
183 * Note also that wow_suspend must return in ~2.5sec, before
184 * watchdog is triggered.
185 */
186 if (priv->channel_switch_in_progress)
187 goto revert1;
188
189 /* Do not suspend when join is pending */
190 if (priv->join_pending)
191 goto revert1;
192
193 /* Do not suspend when scanning */
194 if (down_trylock(&priv->scan.lock))
195 goto revert1;
196
197 /* Lock TX. */
198 wsm_lock_tx_async(priv);
199
200 /* Wait to avoid possible race with bh code.
201 * But do not wait too long...
202 */
203 if (wait_event_timeout(priv->bh_evt_wq,
204 !priv->hw_bufs_used, HZ / 10) <= 0)
205 goto revert2;
206
207 /* Set UDP filter */
208 wsm_set_udp_port_filter(priv, &cw1200_udp_port_filter_on.hdr);
209
210 /* Set ethernet frame type filter */
211 wsm_set_ether_type_filter(priv, &cw1200_ether_type_filter_on.hdr);
212
213 /* Allocate state */
214 state = kzalloc(sizeof(struct cw1200_suspend_state), GFP_KERNEL);
215 if (!state)
216 goto revert3;
217
218 /* Change to legacy PS while going to suspend */
219 if (!priv->vif->p2p &&
220 priv->join_status == CW1200_JOIN_STATUS_STA &&
221 priv->powersave_mode.mode != WSM_PSM_PS) {
222 state->prev_ps_mode = priv->powersave_mode.mode;
223 priv->powersave_mode.mode = WSM_PSM_PS;
224 cw1200_set_pm(priv, &priv->powersave_mode);
225 if (wait_event_interruptible_timeout(priv->ps_mode_switch_done,
226 !priv->ps_mode_switch_in_progress, 1*HZ) <= 0) {
227 goto revert4;
228 }
229 }
230
231 /* Store delayed work states. */
232 state->bss_loss_tmo =
233 cw1200_suspend_work(&priv->bss_loss_work);
234 state->join_tmo =
235 cw1200_suspend_work(&priv->join_timeout);
236 state->direct_probe =
237 cw1200_suspend_work(&priv->scan.probe_work);
238 state->link_id_gc =
239 cw1200_suspend_work(&priv->link_id_gc_work);
240
241 cancel_delayed_work_sync(&priv->clear_recent_scan_work);
242 atomic_set(&priv->recent_scan, 0);
243
244 /* Enable beacon skipping */
245 if (priv->join_status == CW1200_JOIN_STATUS_STA &&
246 priv->join_dtim_period &&
247 !priv->has_multicast_subscription) {
248 state->beacon_skipping = true;
249 wsm_set_beacon_wakeup_period(priv,
250 priv->join_dtim_period,
251 CW1200_BEACON_SKIPPING_MULTIPLIER * priv->join_dtim_period);
252 }
253
254 /* Stop serving thread */
255 if (cw1200_bh_suspend(priv))
256 goto revert5;
257
258 ret = timer_pending(&priv->mcast_timeout);
259 if (ret)
260 goto revert6;
261
262 /* Store suspend state */
263 pm_state->suspend_state = state;
264
265 /* Enable IRQ wake */
266 ret = priv->hwbus_ops->power_mgmt(priv->hwbus_priv, true);
267 if (ret) {
268 wiphy_err(priv->hw->wiphy,
269 "PM request failed: %d. WoW is disabled.\n", ret);
270 cw1200_wow_resume(hw);
271 return -EBUSY;
272 }
273
274 /* Force resume if event is coming from the device. */
275 if (atomic_read(&priv->bh_rx)) {
276 cw1200_wow_resume(hw);
277 return -EAGAIN;
278 }
279
280 return 0;
281
282 revert6:
283 WARN_ON(cw1200_bh_resume(priv));
284 revert5:
285 cw1200_resume_work(priv, &priv->bss_loss_work,
286 state->bss_loss_tmo);
287 cw1200_resume_work(priv, &priv->join_timeout,
288 state->join_tmo);
289 cw1200_resume_work(priv, &priv->scan.probe_work,
290 state->direct_probe);
291 cw1200_resume_work(priv, &priv->link_id_gc_work,
292 state->link_id_gc);
293 revert4:
294 kfree(state);
295 revert3:
296 wsm_set_udp_port_filter(priv, &cw1200_udp_port_filter_off);
297 wsm_set_ether_type_filter(priv, &cw1200_ether_type_filter_off);
298 revert2:
299 wsm_unlock_tx(priv);
300 up(&priv->scan.lock);
301 revert1:
302 mutex_unlock(&priv->conf_mutex);
303 return -EBUSY;
304 }
305
cw1200_wow_resume(struct ieee80211_hw * hw)306 int cw1200_wow_resume(struct ieee80211_hw *hw)
307 {
308 struct cw1200_common *priv = hw->priv;
309 struct cw1200_pm_state *pm_state = &priv->pm_state;
310 struct cw1200_suspend_state *state;
311
312 state = pm_state->suspend_state;
313 pm_state->suspend_state = NULL;
314
315 /* Disable IRQ wake */
316 priv->hwbus_ops->power_mgmt(priv->hwbus_priv, false);
317
318 /* Scan.lock must be released before BH is resumed other way
319 * in case when BSS_LOST command arrived the processing of the
320 * command will be delayed.
321 */
322 up(&priv->scan.lock);
323
324 /* Resume BH thread */
325 WARN_ON(cw1200_bh_resume(priv));
326
327 /* Restores previous PS mode */
328 if (!priv->vif->p2p && priv->join_status == CW1200_JOIN_STATUS_STA) {
329 priv->powersave_mode.mode = state->prev_ps_mode;
330 cw1200_set_pm(priv, &priv->powersave_mode);
331 }
332
333 if (state->beacon_skipping) {
334 wsm_set_beacon_wakeup_period(priv, priv->beacon_int *
335 priv->join_dtim_period >
336 MAX_BEACON_SKIP_TIME_MS ? 1 :
337 priv->join_dtim_period, 0);
338 state->beacon_skipping = false;
339 }
340
341 /* Resume delayed work */
342 cw1200_resume_work(priv, &priv->bss_loss_work,
343 state->bss_loss_tmo);
344 cw1200_resume_work(priv, &priv->join_timeout,
345 state->join_tmo);
346 cw1200_resume_work(priv, &priv->scan.probe_work,
347 state->direct_probe);
348 cw1200_resume_work(priv, &priv->link_id_gc_work,
349 state->link_id_gc);
350
351 /* Remove UDP port filter */
352 wsm_set_udp_port_filter(priv, &cw1200_udp_port_filter_off);
353
354 /* Remove ethernet frame type filter */
355 wsm_set_ether_type_filter(priv, &cw1200_ether_type_filter_off);
356
357 /* Unlock datapath */
358 wsm_unlock_tx(priv);
359
360 /* Unlock configuration mutex */
361 mutex_unlock(&priv->conf_mutex);
362
363 /* Free memory */
364 kfree(state);
365
366 return 0;
367 }
368