1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2020-2024 Intel Corporation 4 */ 5 6 #include <linux/highmem.h> 7 #include <linux/moduleparam.h> 8 #include <linux/pci.h> 9 #include <linux/pm_runtime.h> 10 #include <linux/reboot.h> 11 12 #include "vpu_boot_api.h" 13 #include "ivpu_drv.h" 14 #include "ivpu_hw.h" 15 #include "ivpu_fw.h" 16 #include "ivpu_fw_log.h" 17 #include "ivpu_ipc.h" 18 #include "ivpu_job.h" 19 #include "ivpu_jsm_msg.h" 20 #include "ivpu_mmu.h" 21 #include "ivpu_pm.h" 22 23 static bool ivpu_disable_recovery; 24 module_param_named_unsafe(disable_recovery, ivpu_disable_recovery, bool, 0644); 25 MODULE_PARM_DESC(disable_recovery, "Disables recovery when NPU hang is detected"); 26 27 static unsigned long ivpu_tdr_timeout_ms; 28 module_param_named(tdr_timeout_ms, ivpu_tdr_timeout_ms, ulong, 0644); 29 MODULE_PARM_DESC(tdr_timeout_ms, "Timeout for device hang detection, in milliseconds, 0 - default"); 30 31 #define PM_RESCHEDULE_LIMIT 5 32 33 static void ivpu_pm_prepare_cold_boot(struct ivpu_device *vdev) 34 { 35 struct ivpu_fw_info *fw = vdev->fw; 36 37 ivpu_cmdq_reset_all_contexts(vdev); 38 ivpu_ipc_reset(vdev); 39 ivpu_fw_load(vdev); 40 fw->entry_point = fw->cold_boot_entry_point; 41 } 42 43 static void ivpu_pm_prepare_warm_boot(struct ivpu_device *vdev) 44 { 45 struct ivpu_fw_info *fw = vdev->fw; 46 struct vpu_boot_params *bp = ivpu_bo_vaddr(fw->mem); 47 48 if (!bp->save_restore_ret_address) { 49 ivpu_pm_prepare_cold_boot(vdev); 50 return; 51 } 52 53 ivpu_dbg(vdev, FW_BOOT, "Save/restore entry point %llx", bp->save_restore_ret_address); 54 fw->entry_point = bp->save_restore_ret_address; 55 } 56 57 static int ivpu_suspend(struct ivpu_device *vdev) 58 { 59 int ret; 60 61 ivpu_prepare_for_reset(vdev); 62 63 ret = ivpu_shutdown(vdev); 64 if (ret) 65 ivpu_err(vdev, "Failed to shutdown NPU: %d\n", ret); 66 67 return ret; 68 } 69 70 static int ivpu_resume(struct ivpu_device *vdev) 71 { 72 int ret; 73 74 retry: 75 pci_restore_state(to_pci_dev(vdev->drm.dev)); 76 pci_set_power_state(to_pci_dev(vdev->drm.dev), PCI_D0); 77 78 ret = ivpu_hw_power_up(vdev); 79 if (ret) { 80 ivpu_err(vdev, "Failed to power up HW: %d\n", ret); 81 goto err_power_down; 82 } 83 84 ret = ivpu_mmu_enable(vdev); 85 if (ret) { 86 ivpu_err(vdev, "Failed to resume MMU: %d\n", ret); 87 goto err_power_down; 88 } 89 90 ret = ivpu_boot(vdev); 91 if (ret) 92 goto err_mmu_disable; 93 94 return 0; 95 96 err_mmu_disable: 97 ivpu_mmu_disable(vdev); 98 err_power_down: 99 ivpu_hw_power_down(vdev); 100 pci_set_power_state(to_pci_dev(vdev->drm.dev), PCI_D3hot); 101 102 if (!ivpu_fw_is_cold_boot(vdev)) { 103 ivpu_pm_prepare_cold_boot(vdev); 104 goto retry; 105 } else { 106 ivpu_err(vdev, "Failed to resume the FW: %d\n", ret); 107 } 108 109 return ret; 110 } 111 112 static void ivpu_pm_recovery_work(struct work_struct *work) 113 { 114 struct ivpu_pm_info *pm = container_of(work, struct ivpu_pm_info, recovery_work); 115 struct ivpu_device *vdev = pm->vdev; 116 char *evt[2] = {"IVPU_PM_EVENT=IVPU_RECOVER", NULL}; 117 int ret; 118 119 ivpu_err(vdev, "Recovering the NPU (reset #%d)\n", atomic_read(&vdev->pm->reset_counter)); 120 121 ret = pm_runtime_resume_and_get(vdev->drm.dev); 122 if (ret) 123 ivpu_err(vdev, "Failed to resume NPU: %d\n", ret); 124 125 ivpu_fw_log_dump(vdev); 126 127 atomic_inc(&vdev->pm->reset_counter); 128 atomic_set(&vdev->pm->reset_pending, 1); 129 down_write(&vdev->pm->reset_lock); 130 131 ivpu_suspend(vdev); 132 ivpu_pm_prepare_cold_boot(vdev); 133 ivpu_jobs_abort_all(vdev); 134 135 ret = ivpu_resume(vdev); 136 if (ret) 137 ivpu_err(vdev, "Failed to resume NPU: %d\n", ret); 138 139 up_write(&vdev->pm->reset_lock); 140 atomic_set(&vdev->pm->reset_pending, 0); 141 142 kobject_uevent_env(&vdev->drm.dev->kobj, KOBJ_CHANGE, evt); 143 pm_runtime_mark_last_busy(vdev->drm.dev); 144 pm_runtime_put_autosuspend(vdev->drm.dev); 145 } 146 147 void ivpu_pm_trigger_recovery(struct ivpu_device *vdev, const char *reason) 148 { 149 ivpu_err(vdev, "Recovery triggered by %s\n", reason); 150 151 if (ivpu_disable_recovery) { 152 ivpu_err(vdev, "Recovery not available when disable_recovery param is set\n"); 153 return; 154 } 155 156 if (ivpu_is_fpga(vdev)) { 157 ivpu_err(vdev, "Recovery not available on FPGA\n"); 158 return; 159 } 160 161 /* Trigger recovery if it's not in progress */ 162 if (atomic_cmpxchg(&vdev->pm->reset_pending, 0, 1) == 0) { 163 ivpu_hw_diagnose_failure(vdev); 164 ivpu_hw_irq_disable(vdev); /* Disable IRQ early to protect from IRQ storm */ 165 queue_work(system_long_wq, &vdev->pm->recovery_work); 166 } 167 } 168 169 static void ivpu_job_timeout_work(struct work_struct *work) 170 { 171 struct ivpu_pm_info *pm = container_of(work, struct ivpu_pm_info, job_timeout_work.work); 172 struct ivpu_device *vdev = pm->vdev; 173 174 ivpu_pm_trigger_recovery(vdev, "TDR"); 175 } 176 177 void ivpu_start_job_timeout_detection(struct ivpu_device *vdev) 178 { 179 unsigned long timeout_ms = ivpu_tdr_timeout_ms ? ivpu_tdr_timeout_ms : vdev->timeout.tdr; 180 181 /* No-op if already queued */ 182 queue_delayed_work(system_wq, &vdev->pm->job_timeout_work, msecs_to_jiffies(timeout_ms)); 183 } 184 185 void ivpu_stop_job_timeout_detection(struct ivpu_device *vdev) 186 { 187 cancel_delayed_work_sync(&vdev->pm->job_timeout_work); 188 } 189 190 int ivpu_pm_suspend_cb(struct device *dev) 191 { 192 struct drm_device *drm = dev_get_drvdata(dev); 193 struct ivpu_device *vdev = to_ivpu_device(drm); 194 unsigned long timeout; 195 196 ivpu_dbg(vdev, PM, "Suspend..\n"); 197 198 timeout = jiffies + msecs_to_jiffies(vdev->timeout.tdr); 199 while (!ivpu_hw_is_idle(vdev)) { 200 cond_resched(); 201 if (time_after_eq(jiffies, timeout)) { 202 ivpu_err(vdev, "Failed to enter idle on system suspend\n"); 203 return -EBUSY; 204 } 205 } 206 207 ivpu_jsm_pwr_d0i3_enter(vdev); 208 209 ivpu_suspend(vdev); 210 ivpu_pm_prepare_warm_boot(vdev); 211 212 ivpu_dbg(vdev, PM, "Suspend done.\n"); 213 214 return 0; 215 } 216 217 int ivpu_pm_resume_cb(struct device *dev) 218 { 219 struct drm_device *drm = dev_get_drvdata(dev); 220 struct ivpu_device *vdev = to_ivpu_device(drm); 221 int ret; 222 223 ivpu_dbg(vdev, PM, "Resume..\n"); 224 225 ret = ivpu_resume(vdev); 226 if (ret) 227 ivpu_err(vdev, "Failed to resume: %d\n", ret); 228 229 ivpu_dbg(vdev, PM, "Resume done.\n"); 230 231 return ret; 232 } 233 234 int ivpu_pm_runtime_suspend_cb(struct device *dev) 235 { 236 struct drm_device *drm = dev_get_drvdata(dev); 237 struct ivpu_device *vdev = to_ivpu_device(drm); 238 bool hw_is_idle = true; 239 int ret; 240 241 drm_WARN_ON(&vdev->drm, !xa_empty(&vdev->submitted_jobs_xa)); 242 drm_WARN_ON(&vdev->drm, work_pending(&vdev->pm->recovery_work)); 243 244 ivpu_dbg(vdev, PM, "Runtime suspend..\n"); 245 246 if (!ivpu_hw_is_idle(vdev) && vdev->pm->suspend_reschedule_counter) { 247 ivpu_dbg(vdev, PM, "Failed to enter idle, rescheduling suspend, retries left %d\n", 248 vdev->pm->suspend_reschedule_counter); 249 pm_schedule_suspend(dev, vdev->timeout.reschedule_suspend); 250 vdev->pm->suspend_reschedule_counter--; 251 return -EAGAIN; 252 } 253 254 if (!vdev->pm->suspend_reschedule_counter) 255 hw_is_idle = false; 256 else if (ivpu_jsm_pwr_d0i3_enter(vdev)) 257 hw_is_idle = false; 258 259 ret = ivpu_suspend(vdev); 260 if (ret) 261 ivpu_err(vdev, "Failed to suspend NPU: %d\n", ret); 262 263 if (!hw_is_idle) { 264 ivpu_err(vdev, "NPU failed to enter idle, force suspended.\n"); 265 ivpu_fw_log_dump(vdev); 266 ivpu_pm_prepare_cold_boot(vdev); 267 } else { 268 ivpu_pm_prepare_warm_boot(vdev); 269 } 270 271 vdev->pm->suspend_reschedule_counter = PM_RESCHEDULE_LIMIT; 272 273 ivpu_dbg(vdev, PM, "Runtime suspend done.\n"); 274 275 return 0; 276 } 277 278 int ivpu_pm_runtime_resume_cb(struct device *dev) 279 { 280 struct drm_device *drm = dev_get_drvdata(dev); 281 struct ivpu_device *vdev = to_ivpu_device(drm); 282 int ret; 283 284 ivpu_dbg(vdev, PM, "Runtime resume..\n"); 285 286 ret = ivpu_resume(vdev); 287 if (ret) 288 ivpu_err(vdev, "Failed to set RESUME state: %d\n", ret); 289 290 ivpu_dbg(vdev, PM, "Runtime resume done.\n"); 291 292 return ret; 293 } 294 295 int ivpu_rpm_get(struct ivpu_device *vdev) 296 { 297 int ret; 298 299 ret = pm_runtime_resume_and_get(vdev->drm.dev); 300 if (!drm_WARN_ON(&vdev->drm, ret < 0)) 301 vdev->pm->suspend_reschedule_counter = PM_RESCHEDULE_LIMIT; 302 303 return ret; 304 } 305 306 int ivpu_rpm_get_if_active(struct ivpu_device *vdev) 307 { 308 int ret; 309 310 ret = pm_runtime_get_if_in_use(vdev->drm.dev); 311 drm_WARN_ON(&vdev->drm, ret < 0); 312 313 return ret; 314 } 315 316 void ivpu_rpm_put(struct ivpu_device *vdev) 317 { 318 pm_runtime_mark_last_busy(vdev->drm.dev); 319 pm_runtime_put_autosuspend(vdev->drm.dev); 320 } 321 322 void ivpu_pm_reset_prepare_cb(struct pci_dev *pdev) 323 { 324 struct ivpu_device *vdev = pci_get_drvdata(pdev); 325 326 ivpu_dbg(vdev, PM, "Pre-reset..\n"); 327 atomic_inc(&vdev->pm->reset_counter); 328 atomic_set(&vdev->pm->reset_pending, 1); 329 330 pm_runtime_get_sync(vdev->drm.dev); 331 down_write(&vdev->pm->reset_lock); 332 ivpu_prepare_for_reset(vdev); 333 ivpu_hw_reset(vdev); 334 ivpu_pm_prepare_cold_boot(vdev); 335 ivpu_jobs_abort_all(vdev); 336 ivpu_dbg(vdev, PM, "Pre-reset done.\n"); 337 } 338 339 void ivpu_pm_reset_done_cb(struct pci_dev *pdev) 340 { 341 struct ivpu_device *vdev = pci_get_drvdata(pdev); 342 int ret; 343 344 ivpu_dbg(vdev, PM, "Post-reset..\n"); 345 ret = ivpu_resume(vdev); 346 if (ret) 347 ivpu_err(vdev, "Failed to set RESUME state: %d\n", ret); 348 up_write(&vdev->pm->reset_lock); 349 atomic_set(&vdev->pm->reset_pending, 0); 350 ivpu_dbg(vdev, PM, "Post-reset done.\n"); 351 352 pm_runtime_mark_last_busy(vdev->drm.dev); 353 pm_runtime_put_autosuspend(vdev->drm.dev); 354 } 355 356 void ivpu_pm_init(struct ivpu_device *vdev) 357 { 358 struct device *dev = vdev->drm.dev; 359 struct ivpu_pm_info *pm = vdev->pm; 360 int delay; 361 362 pm->vdev = vdev; 363 pm->suspend_reschedule_counter = PM_RESCHEDULE_LIMIT; 364 365 init_rwsem(&pm->reset_lock); 366 atomic_set(&pm->reset_pending, 0); 367 atomic_set(&pm->reset_counter, 0); 368 369 INIT_WORK(&pm->recovery_work, ivpu_pm_recovery_work); 370 INIT_DELAYED_WORK(&pm->job_timeout_work, ivpu_job_timeout_work); 371 372 if (ivpu_disable_recovery) 373 delay = -1; 374 else 375 delay = vdev->timeout.autosuspend; 376 377 pm_runtime_use_autosuspend(dev); 378 pm_runtime_set_autosuspend_delay(dev, delay); 379 380 ivpu_dbg(vdev, PM, "Autosuspend delay = %d\n", delay); 381 } 382 383 void ivpu_pm_cancel_recovery(struct ivpu_device *vdev) 384 { 385 drm_WARN_ON(&vdev->drm, delayed_work_pending(&vdev->pm->job_timeout_work)); 386 cancel_work_sync(&vdev->pm->recovery_work); 387 } 388 389 void ivpu_pm_enable(struct ivpu_device *vdev) 390 { 391 struct device *dev = vdev->drm.dev; 392 393 pm_runtime_set_active(dev); 394 pm_runtime_allow(dev); 395 pm_runtime_mark_last_busy(dev); 396 pm_runtime_put_autosuspend(dev); 397 } 398 399 void ivpu_pm_disable(struct ivpu_device *vdev) 400 { 401 pm_runtime_get_noresume(vdev->drm.dev); 402 pm_runtime_forbid(vdev->drm.dev); 403 } 404