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 22struct 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 28struct 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 34static 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 50static 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 58static 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 80static struct wsm_ether_type_filter_hdr cw1200_ether_type_filter_off = { 81 .num = 0, 82}; 83 84/* private */ 85struct 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 94static void cw1200_pm_stay_awake_tmo(unsigned long arg) 95{ 96 /* XXX what's the point of this ? */ 97} 98 99int cw1200_pm_init(struct cw1200_pm_state *pm, 100 struct cw1200_common *priv) 101{ 102 spin_lock_init(&pm->lock); 103 104 init_timer(&pm->stay_awake); 105 pm->stay_awake.data = (unsigned long)pm; 106 pm->stay_awake.function = cw1200_pm_stay_awake_tmo; 107 108 return 0; 109} 110 111void cw1200_pm_deinit(struct cw1200_pm_state *pm) 112{ 113 del_timer_sync(&pm->stay_awake); 114} 115 116void cw1200_pm_stay_awake(struct cw1200_pm_state *pm, 117 unsigned long tmo) 118{ 119 long cur_tmo; 120 spin_lock_bh(&pm->lock); 121 cur_tmo = pm->stay_awake.expires - jiffies; 122 if (!timer_pending(&pm->stay_awake) || cur_tmo < (long)tmo) 123 mod_timer(&pm->stay_awake, jiffies + tmo); 124 spin_unlock_bh(&pm->lock); 125} 126 127static long cw1200_suspend_work(struct delayed_work *work) 128{ 129 int ret = cancel_delayed_work(work); 130 long tmo; 131 if (ret > 0) { 132 /* Timer is pending */ 133 tmo = work->timer.expires - jiffies; 134 if (tmo < 0) 135 tmo = 0; 136 } else { 137 tmo = -1; 138 } 139 return tmo; 140} 141 142static int cw1200_resume_work(struct cw1200_common *priv, 143 struct delayed_work *work, 144 unsigned long tmo) 145{ 146 if ((long)tmo < 0) 147 return 1; 148 149 return queue_delayed_work(priv->workqueue, work, tmo); 150} 151 152int cw1200_can_suspend(struct cw1200_common *priv) 153{ 154 if (atomic_read(&priv->bh_rx)) { 155 wiphy_dbg(priv->hw->wiphy, "Suspend interrupted.\n"); 156 return 0; 157 } 158 return 1; 159} 160EXPORT_SYMBOL_GPL(cw1200_can_suspend); 161 162int cw1200_wow_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wowlan) 163{ 164 struct cw1200_common *priv = hw->priv; 165 struct cw1200_pm_state *pm_state = &priv->pm_state; 166 struct cw1200_suspend_state *state; 167 int ret; 168 169 spin_lock_bh(&pm_state->lock); 170 ret = timer_pending(&pm_state->stay_awake); 171 spin_unlock_bh(&pm_state->lock); 172 if (ret) 173 return -EAGAIN; 174 175 /* Do not suspend when datapath is not idle */ 176 if (priv->tx_queue_stats.num_queued) 177 return -EBUSY; 178 179 /* Make sure there is no configuration requests in progress. */ 180 if (!mutex_trylock(&priv->conf_mutex)) 181 return -EBUSY; 182 183 /* Ensure pending operations are done. 184 * Note also that wow_suspend must return in ~2.5sec, before 185 * watchdog is triggered. 186 */ 187 if (priv->channel_switch_in_progress) 188 goto revert1; 189 190 /* Do not suspend when join is pending */ 191 if (priv->join_pending) 192 goto revert1; 193 194 /* Do not suspend when scanning */ 195 if (down_trylock(&priv->scan.lock)) 196 goto revert1; 197 198 /* Lock TX. */ 199 wsm_lock_tx_async(priv); 200 201 /* Wait to avoid possible race with bh code. 202 * But do not wait too long... 203 */ 204 if (wait_event_timeout(priv->bh_evt_wq, 205 !priv->hw_bufs_used, HZ / 10) <= 0) 206 goto revert2; 207 208 /* Set UDP filter */ 209 wsm_set_udp_port_filter(priv, &cw1200_udp_port_filter_on.hdr); 210 211 /* Set ethernet frame type filter */ 212 wsm_set_ether_type_filter(priv, &cw1200_ether_type_filter_on.hdr); 213 214 /* Allocate state */ 215 state = kzalloc(sizeof(struct cw1200_suspend_state), GFP_KERNEL); 216 if (!state) 217 goto revert3; 218 219 /* Change to legacy PS while going to suspend */ 220 if (!priv->vif->p2p && 221 priv->join_status == CW1200_JOIN_STATUS_STA && 222 priv->powersave_mode.mode != WSM_PSM_PS) { 223 state->prev_ps_mode = priv->powersave_mode.mode; 224 priv->powersave_mode.mode = WSM_PSM_PS; 225 cw1200_set_pm(priv, &priv->powersave_mode); 226 if (wait_event_interruptible_timeout(priv->ps_mode_switch_done, 227 !priv->ps_mode_switch_in_progress, 1*HZ) <= 0) { 228 goto revert4; 229 } 230 } 231 232 /* Store delayed work states. */ 233 state->bss_loss_tmo = 234 cw1200_suspend_work(&priv->bss_loss_work); 235 state->join_tmo = 236 cw1200_suspend_work(&priv->join_timeout); 237 state->direct_probe = 238 cw1200_suspend_work(&priv->scan.probe_work); 239 state->link_id_gc = 240 cw1200_suspend_work(&priv->link_id_gc_work); 241 242 cancel_delayed_work_sync(&priv->clear_recent_scan_work); 243 atomic_set(&priv->recent_scan, 0); 244 245 /* Enable beacon skipping */ 246 if (priv->join_status == CW1200_JOIN_STATUS_STA && 247 priv->join_dtim_period && 248 !priv->has_multicast_subscription) { 249 state->beacon_skipping = true; 250 wsm_set_beacon_wakeup_period(priv, 251 priv->join_dtim_period, 252 CW1200_BEACON_SKIPPING_MULTIPLIER * priv->join_dtim_period); 253 } 254 255 /* Stop serving thread */ 256 if (cw1200_bh_suspend(priv)) 257 goto revert5; 258 259 ret = timer_pending(&priv->mcast_timeout); 260 if (ret) 261 goto revert6; 262 263 /* Store suspend state */ 264 pm_state->suspend_state = state; 265 266 /* Enable IRQ wake */ 267 ret = priv->hwbus_ops->power_mgmt(priv->hwbus_priv, true); 268 if (ret) { 269 wiphy_err(priv->hw->wiphy, 270 "PM request failed: %d. WoW is disabled.\n", ret); 271 cw1200_wow_resume(hw); 272 return -EBUSY; 273 } 274 275 /* Force resume if event is coming from the device. */ 276 if (atomic_read(&priv->bh_rx)) { 277 cw1200_wow_resume(hw); 278 return -EAGAIN; 279 } 280 281 return 0; 282 283revert6: 284 WARN_ON(cw1200_bh_resume(priv)); 285revert5: 286 cw1200_resume_work(priv, &priv->bss_loss_work, 287 state->bss_loss_tmo); 288 cw1200_resume_work(priv, &priv->join_timeout, 289 state->join_tmo); 290 cw1200_resume_work(priv, &priv->scan.probe_work, 291 state->direct_probe); 292 cw1200_resume_work(priv, &priv->link_id_gc_work, 293 state->link_id_gc); 294revert4: 295 kfree(state); 296revert3: 297 wsm_set_udp_port_filter(priv, &cw1200_udp_port_filter_off); 298 wsm_set_ether_type_filter(priv, &cw1200_ether_type_filter_off); 299revert2: 300 wsm_unlock_tx(priv); 301 up(&priv->scan.lock); 302revert1: 303 mutex_unlock(&priv->conf_mutex); 304 return -EBUSY; 305} 306 307int cw1200_wow_resume(struct ieee80211_hw *hw) 308{ 309 struct cw1200_common *priv = hw->priv; 310 struct cw1200_pm_state *pm_state = &priv->pm_state; 311 struct cw1200_suspend_state *state; 312 313 state = pm_state->suspend_state; 314 pm_state->suspend_state = NULL; 315 316 /* Disable IRQ wake */ 317 priv->hwbus_ops->power_mgmt(priv->hwbus_priv, false); 318 319 /* Scan.lock must be released before BH is resumed other way 320 * in case when BSS_LOST command arrived the processing of the 321 * command will be delayed. 322 */ 323 up(&priv->scan.lock); 324 325 /* Resume BH thread */ 326 WARN_ON(cw1200_bh_resume(priv)); 327 328 /* Restores previous PS mode */ 329 if (!priv->vif->p2p && priv->join_status == CW1200_JOIN_STATUS_STA) { 330 priv->powersave_mode.mode = state->prev_ps_mode; 331 cw1200_set_pm(priv, &priv->powersave_mode); 332 } 333 334 if (state->beacon_skipping) { 335 wsm_set_beacon_wakeup_period(priv, priv->beacon_int * 336 priv->join_dtim_period > 337 MAX_BEACON_SKIP_TIME_MS ? 1 : 338 priv->join_dtim_period, 0); 339 state->beacon_skipping = false; 340 } 341 342 /* Resume delayed work */ 343 cw1200_resume_work(priv, &priv->bss_loss_work, 344 state->bss_loss_tmo); 345 cw1200_resume_work(priv, &priv->join_timeout, 346 state->join_tmo); 347 cw1200_resume_work(priv, &priv->scan.probe_work, 348 state->direct_probe); 349 cw1200_resume_work(priv, &priv->link_id_gc_work, 350 state->link_id_gc); 351 352 /* Remove UDP port filter */ 353 wsm_set_udp_port_filter(priv, &cw1200_udp_port_filter_off); 354 355 /* Remove ethernet frame type filter */ 356 wsm_set_ether_type_filter(priv, &cw1200_ether_type_filter_off); 357 358 /* Unlock datapath */ 359 wsm_unlock_tx(priv); 360 361 /* Unlock configuration mutex */ 362 mutex_unlock(&priv->conf_mutex); 363 364 /* Free memory */ 365 kfree(state); 366 367 return 0; 368} 369