1 // SPDX-License-Identifier: ISC 2 /* 3 * Copyright (c) 2014,2017 Qualcomm Atheros, Inc. 4 * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved. 5 */ 6 7 #include "wil6210.h" 8 #include <linux/jiffies.h> 9 #include <linux/pm_runtime.h> 10 11 #define WIL6210_AUTOSUSPEND_DELAY_MS (1000) 12 13 static void wil_pm_wake_connected_net_queues(struct wil6210_priv *wil) 14 { 15 int i; 16 17 mutex_lock(&wil->vif_mutex); 18 for (i = 0; i < GET_MAX_VIFS(wil); i++) { 19 struct wil6210_vif *vif = wil->vifs[i]; 20 21 if (vif && test_bit(wil_vif_fwconnected, vif->status)) 22 wil_update_net_queues_bh(wil, vif, NULL, false); 23 } 24 mutex_unlock(&wil->vif_mutex); 25 } 26 27 static void wil_pm_stop_all_net_queues(struct wil6210_priv *wil) 28 { 29 int i; 30 31 mutex_lock(&wil->vif_mutex); 32 for (i = 0; i < GET_MAX_VIFS(wil); i++) { 33 struct wil6210_vif *vif = wil->vifs[i]; 34 35 if (vif) 36 wil_update_net_queues_bh(wil, vif, NULL, true); 37 } 38 mutex_unlock(&wil->vif_mutex); 39 } 40 41 static bool 42 wil_can_suspend_vif(struct wil6210_priv *wil, struct wil6210_vif *vif, 43 bool is_runtime) 44 { 45 struct wireless_dev *wdev = vif_to_wdev(vif); 46 47 switch (wdev->iftype) { 48 case NL80211_IFTYPE_MONITOR: 49 wil_dbg_pm(wil, "Sniffer\n"); 50 return false; 51 52 /* for STA-like interface, don't runtime suspend */ 53 case NL80211_IFTYPE_STATION: 54 case NL80211_IFTYPE_P2P_CLIENT: 55 if (test_bit(wil_vif_fwconnecting, vif->status)) { 56 wil_dbg_pm(wil, "Delay suspend when connecting\n"); 57 return false; 58 } 59 if (is_runtime) { 60 wil_dbg_pm(wil, "STA-like interface\n"); 61 return false; 62 } 63 break; 64 /* AP-like interface - can't suspend */ 65 default: 66 wil_dbg_pm(wil, "AP-like interface\n"); 67 return false; 68 } 69 70 return true; 71 } 72 73 int wil_can_suspend(struct wil6210_priv *wil, bool is_runtime) 74 { 75 int rc = 0, i; 76 bool wmi_only = test_bit(WMI_FW_CAPABILITY_WMI_ONLY, 77 wil->fw_capabilities); 78 bool active_ifaces; 79 80 wil_dbg_pm(wil, "can_suspend: %s\n", is_runtime ? "runtime" : "system"); 81 82 if (wmi_only || debug_fw) { 83 wil_dbg_pm(wil, "Deny any suspend - %s mode\n", 84 wmi_only ? "wmi_only" : "debug_fw"); 85 rc = -EBUSY; 86 goto out; 87 } 88 if (is_runtime && !wil->platform_ops.suspend) { 89 rc = -EBUSY; 90 goto out; 91 } 92 93 mutex_lock(&wil->vif_mutex); 94 active_ifaces = wil_has_active_ifaces(wil, true, false); 95 mutex_unlock(&wil->vif_mutex); 96 97 if (!active_ifaces) { 98 /* can always sleep when down */ 99 wil_dbg_pm(wil, "Interface is down\n"); 100 goto out; 101 } 102 if (test_bit(wil_status_resetting, wil->status)) { 103 wil_dbg_pm(wil, "Delay suspend when resetting\n"); 104 rc = -EBUSY; 105 goto out; 106 } 107 if (wil->recovery_state != fw_recovery_idle) { 108 wil_dbg_pm(wil, "Delay suspend during recovery\n"); 109 rc = -EBUSY; 110 goto out; 111 } 112 113 /* interface is running */ 114 mutex_lock(&wil->vif_mutex); 115 for (i = 0; i < GET_MAX_VIFS(wil); i++) { 116 struct wil6210_vif *vif = wil->vifs[i]; 117 118 if (!vif) 119 continue; 120 if (!wil_can_suspend_vif(wil, vif, is_runtime)) { 121 rc = -EBUSY; 122 mutex_unlock(&wil->vif_mutex); 123 goto out; 124 } 125 } 126 mutex_unlock(&wil->vif_mutex); 127 128 out: 129 wil_dbg_pm(wil, "can_suspend: %s => %s (%d)\n", 130 is_runtime ? "runtime" : "system", rc ? "No" : "Yes", rc); 131 132 if (rc) 133 wil->suspend_stats.rejected_by_host++; 134 135 return rc; 136 } 137 138 static int wil_resume_keep_radio_on(struct wil6210_priv *wil) 139 { 140 int rc = 0; 141 142 /* wil_status_resuming will be cleared when getting 143 * WMI_TRAFFIC_RESUME_EVENTID 144 */ 145 set_bit(wil_status_resuming, wil->status); 146 clear_bit(wil_status_suspended, wil->status); 147 wil_c(wil, RGF_USER_CLKS_CTL_0, BIT_USER_CLKS_RST_PWGD); 148 wil_unmask_irq(wil); 149 150 wil6210_bus_request(wil, wil->bus_request_kbps_pre_suspend); 151 152 /* Send WMI resume request to the device */ 153 rc = wmi_resume(wil); 154 if (rc) { 155 wil_err(wil, "device failed to resume (%d)\n", rc); 156 if (no_fw_recovery) 157 goto out; 158 rc = wil_down(wil); 159 if (rc) { 160 wil_err(wil, "wil_down failed (%d)\n", rc); 161 goto out; 162 } 163 rc = wil_up(wil); 164 if (rc) { 165 wil_err(wil, "wil_up failed (%d)\n", rc); 166 goto out; 167 } 168 } 169 170 /* Wake all queues */ 171 wil_pm_wake_connected_net_queues(wil); 172 173 out: 174 if (rc) 175 set_bit(wil_status_suspended, wil->status); 176 return rc; 177 } 178 179 static int wil_suspend_keep_radio_on(struct wil6210_priv *wil) 180 { 181 int rc = 0; 182 unsigned long data_comp_to; 183 184 wil_dbg_pm(wil, "suspend keep radio on\n"); 185 186 /* Prevent handling of new tx and wmi commands */ 187 rc = down_write_trylock(&wil->mem_lock); 188 if (!rc) { 189 wil_err(wil, 190 "device is busy. down_write_trylock failed, returned (0x%x)\n", 191 rc); 192 wil->suspend_stats.rejected_by_host++; 193 return -EBUSY; 194 } 195 196 set_bit(wil_status_suspending, wil->status); 197 up_write(&wil->mem_lock); 198 199 wil_pm_stop_all_net_queues(wil); 200 201 if (!wil_is_tx_idle(wil)) { 202 wil_dbg_pm(wil, "Pending TX data, reject suspend\n"); 203 wil->suspend_stats.rejected_by_host++; 204 goto reject_suspend; 205 } 206 207 if (!wil->txrx_ops.is_rx_idle(wil)) { 208 wil_dbg_pm(wil, "Pending RX data, reject suspend\n"); 209 wil->suspend_stats.rejected_by_host++; 210 goto reject_suspend; 211 } 212 213 if (!wil_is_wmi_idle(wil)) { 214 wil_dbg_pm(wil, "Pending WMI events, reject suspend\n"); 215 wil->suspend_stats.rejected_by_host++; 216 goto reject_suspend; 217 } 218 219 /* Send WMI suspend request to the device */ 220 rc = wmi_suspend(wil); 221 if (rc) { 222 wil_dbg_pm(wil, "wmi_suspend failed, reject suspend (%d)\n", 223 rc); 224 goto reject_suspend; 225 } 226 227 /* Wait for completion of the pending RX packets */ 228 data_comp_to = jiffies + msecs_to_jiffies(WIL_DATA_COMPLETION_TO_MS); 229 if (test_bit(wil_status_napi_en, wil->status)) { 230 while (!wil->txrx_ops.is_rx_idle(wil)) { 231 if (time_after(jiffies, data_comp_to)) { 232 if (wil->txrx_ops.is_rx_idle(wil)) 233 break; 234 wil_err(wil, 235 "TO waiting for idle RX, suspend failed\n"); 236 wil->suspend_stats.r_on.failed_suspends++; 237 goto resume_after_fail; 238 } 239 wil_dbg_ratelimited(wil, "rx vring is not empty -> NAPI\n"); 240 napi_synchronize(&wil->napi_rx); 241 msleep(20); 242 } 243 } 244 245 /* In case of pending WMI events, reject the suspend 246 * and resume the device. 247 * This can happen if the device sent the WMI events before 248 * approving the suspend. 249 */ 250 if (!wil_is_wmi_idle(wil)) { 251 wil_err(wil, "suspend failed due to pending WMI events\n"); 252 wil->suspend_stats.r_on.failed_suspends++; 253 goto resume_after_fail; 254 } 255 256 wil_mask_irq(wil); 257 258 /* Disable device reset on PERST */ 259 wil_s(wil, RGF_USER_CLKS_CTL_0, BIT_USER_CLKS_RST_PWGD); 260 261 if (wil->platform_ops.suspend) { 262 rc = wil->platform_ops.suspend(wil->platform_handle, true); 263 if (rc) { 264 wil_err(wil, "platform device failed to suspend (%d)\n", 265 rc); 266 wil->suspend_stats.r_on.failed_suspends++; 267 wil_c(wil, RGF_USER_CLKS_CTL_0, BIT_USER_CLKS_RST_PWGD); 268 wil_unmask_irq(wil); 269 goto resume_after_fail; 270 } 271 } 272 273 /* Save the current bus request to return to the same in resume */ 274 wil->bus_request_kbps_pre_suspend = wil->bus_request_kbps; 275 wil6210_bus_request(wil, 0); 276 277 set_bit(wil_status_suspended, wil->status); 278 clear_bit(wil_status_suspending, wil->status); 279 280 return rc; 281 282 resume_after_fail: 283 set_bit(wil_status_resuming, wil->status); 284 clear_bit(wil_status_suspending, wil->status); 285 rc = wmi_resume(wil); 286 /* if resume succeeded, reject the suspend */ 287 if (!rc) { 288 rc = -EBUSY; 289 wil_pm_wake_connected_net_queues(wil); 290 } 291 return rc; 292 293 reject_suspend: 294 clear_bit(wil_status_suspending, wil->status); 295 wil_pm_wake_connected_net_queues(wil); 296 return -EBUSY; 297 } 298 299 static int wil_suspend_radio_off(struct wil6210_priv *wil) 300 { 301 int rc = 0; 302 bool active_ifaces; 303 304 wil_dbg_pm(wil, "suspend radio off\n"); 305 306 rc = down_write_trylock(&wil->mem_lock); 307 if (!rc) { 308 wil_err(wil, 309 "device is busy. down_write_trylock failed, returned (0x%x)\n", 310 rc); 311 wil->suspend_stats.rejected_by_host++; 312 return -EBUSY; 313 } 314 315 set_bit(wil_status_suspending, wil->status); 316 up_write(&wil->mem_lock); 317 318 /* if netif up, hardware is alive, shut it down */ 319 mutex_lock(&wil->vif_mutex); 320 active_ifaces = wil_has_active_ifaces(wil, true, false); 321 mutex_unlock(&wil->vif_mutex); 322 323 if (active_ifaces) { 324 rc = wil_down(wil); 325 if (rc) { 326 wil_err(wil, "wil_down : %d\n", rc); 327 wil->suspend_stats.r_off.failed_suspends++; 328 goto out; 329 } 330 } 331 332 /* Disable PCIe IRQ to prevent sporadic IRQs when PCIe is suspending */ 333 wil_dbg_pm(wil, "Disabling PCIe IRQ before suspending\n"); 334 wil_disable_irq(wil); 335 336 if (wil->platform_ops.suspend) { 337 rc = wil->platform_ops.suspend(wil->platform_handle, false); 338 if (rc) { 339 wil_enable_irq(wil); 340 wil->suspend_stats.r_off.failed_suspends++; 341 goto out; 342 } 343 } 344 345 set_bit(wil_status_suspended, wil->status); 346 347 out: 348 clear_bit(wil_status_suspending, wil->status); 349 wil_dbg_pm(wil, "suspend radio off: %d\n", rc); 350 351 return rc; 352 } 353 354 static int wil_resume_radio_off(struct wil6210_priv *wil) 355 { 356 int rc = 0; 357 bool active_ifaces; 358 359 wil_dbg_pm(wil, "Enabling PCIe IRQ\n"); 360 wil_enable_irq(wil); 361 /* if any netif up, bring hardware up 362 * During open(), IFF_UP set after actual device method 363 * invocation. This prevent recursive call to wil_up() 364 * wil_status_suspended will be cleared in wil_reset 365 */ 366 mutex_lock(&wil->vif_mutex); 367 active_ifaces = wil_has_active_ifaces(wil, true, false); 368 mutex_unlock(&wil->vif_mutex); 369 if (active_ifaces) 370 rc = wil_up(wil); 371 else 372 clear_bit(wil_status_suspended, wil->status); 373 374 return rc; 375 } 376 377 int wil_suspend(struct wil6210_priv *wil, bool is_runtime, bool keep_radio_on) 378 { 379 int rc = 0; 380 381 wil_dbg_pm(wil, "suspend: %s\n", is_runtime ? "runtime" : "system"); 382 383 if (test_bit(wil_status_suspended, wil->status)) { 384 wil_dbg_pm(wil, "trying to suspend while suspended\n"); 385 return 0; 386 } 387 388 if (!keep_radio_on) 389 rc = wil_suspend_radio_off(wil); 390 else 391 rc = wil_suspend_keep_radio_on(wil); 392 393 wil_dbg_pm(wil, "suspend: %s => %d\n", 394 is_runtime ? "runtime" : "system", rc); 395 396 return rc; 397 } 398 399 int wil_resume(struct wil6210_priv *wil, bool is_runtime, bool keep_radio_on) 400 { 401 int rc = 0; 402 403 wil_dbg_pm(wil, "resume: %s\n", is_runtime ? "runtime" : "system"); 404 405 if (wil->platform_ops.resume) { 406 rc = wil->platform_ops.resume(wil->platform_handle, 407 keep_radio_on); 408 if (rc) { 409 wil_err(wil, "platform_ops.resume : %d\n", rc); 410 goto out; 411 } 412 } 413 414 if (keep_radio_on) 415 rc = wil_resume_keep_radio_on(wil); 416 else 417 rc = wil_resume_radio_off(wil); 418 419 out: 420 wil_dbg_pm(wil, "resume: %s => %d\n", is_runtime ? "runtime" : "system", 421 rc); 422 return rc; 423 } 424 425 void wil_pm_runtime_allow(struct wil6210_priv *wil) 426 { 427 struct device *dev = wil_to_dev(wil); 428 429 pm_runtime_put_noidle(dev); 430 pm_runtime_set_autosuspend_delay(dev, WIL6210_AUTOSUSPEND_DELAY_MS); 431 pm_runtime_use_autosuspend(dev); 432 pm_runtime_allow(dev); 433 } 434 435 void wil_pm_runtime_forbid(struct wil6210_priv *wil) 436 { 437 struct device *dev = wil_to_dev(wil); 438 439 pm_runtime_forbid(dev); 440 pm_runtime_get_noresume(dev); 441 } 442 443 int wil_pm_runtime_get(struct wil6210_priv *wil) 444 { 445 int rc; 446 struct device *dev = wil_to_dev(wil); 447 448 rc = pm_runtime_resume_and_get(dev); 449 if (rc < 0) { 450 wil_err(wil, "pm_runtime_resume_and_get() failed, rc = %d\n", rc); 451 return rc; 452 } 453 454 return 0; 455 } 456 457 void wil_pm_runtime_put(struct wil6210_priv *wil) 458 { 459 struct device *dev = wil_to_dev(wil); 460 461 pm_runtime_mark_last_busy(dev); 462 pm_runtime_put_autosuspend(dev); 463 } 464