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