1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2020-2023 Intel Corporation
6 #include <linux/highmem.h>
7 #include <linux/moduleparam.h>
9 #include <linux/pm_runtime.h>
10 #include <linux/reboot.h>
12 #include "vpu_boot_api.h"
16 #include "ivpu_fw_log.h"
19 #include "ivpu_jsm_msg.h"
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 VPU hang is detected");
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");
31 #define PM_RESCHEDULE_LIMIT 5
33 static void ivpu_pm_prepare_cold_boot(struct ivpu_device *vdev)
35 struct ivpu_fw_info *fw = vdev->fw;
37 ivpu_cmdq_reset_all_contexts(vdev);
40 fw->entry_point = fw->cold_boot_entry_point;
43 static void ivpu_pm_prepare_warm_boot(struct ivpu_device *vdev)
45 struct ivpu_fw_info *fw = vdev->fw;
46 struct vpu_boot_params *bp = ivpu_bo_vaddr(fw->mem);
48 if (!bp->save_restore_ret_address) {
49 ivpu_pm_prepare_cold_boot(vdev);
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;
57 static int ivpu_suspend(struct ivpu_device *vdev)
61 /* Save PCI state before powering down as it sometimes gets corrupted if NPU hangs */
62 pci_save_state(to_pci_dev(vdev->drm.dev));
64 ret = ivpu_shutdown(vdev);
66 ivpu_err(vdev, "Failed to shutdown VPU: %d\n", ret);
68 pci_set_power_state(to_pci_dev(vdev->drm.dev), PCI_D3hot);
73 static int ivpu_resume(struct ivpu_device *vdev)
78 pci_restore_state(to_pci_dev(vdev->drm.dev));
79 pci_set_power_state(to_pci_dev(vdev->drm.dev), PCI_D0);
81 ret = ivpu_hw_power_up(vdev);
83 ivpu_err(vdev, "Failed to power up HW: %d\n", ret);
87 ret = ivpu_mmu_enable(vdev);
89 ivpu_err(vdev, "Failed to resume MMU: %d\n", ret);
93 ret = ivpu_boot(vdev);
100 ivpu_mmu_disable(vdev);
102 ivpu_hw_power_down(vdev);
103 pci_set_power_state(to_pci_dev(vdev->drm.dev), PCI_D3hot);
105 if (!ivpu_fw_is_cold_boot(vdev)) {
106 ivpu_pm_prepare_cold_boot(vdev);
109 ivpu_err(vdev, "Failed to resume the FW: %d\n", ret);
115 static void ivpu_pm_recovery_work(struct work_struct *work)
117 struct ivpu_pm_info *pm = container_of(work, struct ivpu_pm_info, recovery_work);
118 struct ivpu_device *vdev = pm->vdev;
119 char *evt[2] = {"IVPU_PM_EVENT=IVPU_RECOVER", NULL};
122 ivpu_err(vdev, "Recovering the VPU (reset #%d)\n", atomic_read(&vdev->pm->reset_counter));
124 ret = pm_runtime_resume_and_get(vdev->drm.dev);
126 ivpu_err(vdev, "Failed to resume VPU: %d\n", ret);
128 ivpu_fw_log_dump(vdev);
130 atomic_inc(&vdev->pm->reset_counter);
131 atomic_set(&vdev->pm->reset_pending, 1);
132 down_write(&vdev->pm->reset_lock);
135 ivpu_pm_prepare_cold_boot(vdev);
136 ivpu_jobs_abort_all(vdev);
138 ret = ivpu_resume(vdev);
140 ivpu_err(vdev, "Failed to resume NPU: %d\n", ret);
142 up_write(&vdev->pm->reset_lock);
143 atomic_set(&vdev->pm->reset_pending, 0);
145 kobject_uevent_env(&vdev->drm.dev->kobj, KOBJ_CHANGE, evt);
146 pm_runtime_mark_last_busy(vdev->drm.dev);
147 pm_runtime_put_autosuspend(vdev->drm.dev);
150 void ivpu_pm_trigger_recovery(struct ivpu_device *vdev, const char *reason)
152 ivpu_err(vdev, "Recovery triggered by %s\n", reason);
154 if (ivpu_disable_recovery) {
155 ivpu_err(vdev, "Recovery not available when disable_recovery param is set\n");
159 if (ivpu_is_fpga(vdev)) {
160 ivpu_err(vdev, "Recovery not available on FPGA\n");
164 /* Trigger recovery if it's not in progress */
165 if (atomic_cmpxchg(&vdev->pm->reset_pending, 0, 1) == 0) {
166 ivpu_hw_diagnose_failure(vdev);
167 ivpu_hw_irq_disable(vdev); /* Disable IRQ early to protect from IRQ storm */
168 queue_work(system_long_wq, &vdev->pm->recovery_work);
172 static void ivpu_job_timeout_work(struct work_struct *work)
174 struct ivpu_pm_info *pm = container_of(work, struct ivpu_pm_info, job_timeout_work.work);
175 struct ivpu_device *vdev = pm->vdev;
177 ivpu_pm_trigger_recovery(vdev, "TDR");
180 void ivpu_start_job_timeout_detection(struct ivpu_device *vdev)
182 unsigned long timeout_ms = ivpu_tdr_timeout_ms ? ivpu_tdr_timeout_ms : vdev->timeout.tdr;
184 /* No-op if already queued */
185 queue_delayed_work(system_wq, &vdev->pm->job_timeout_work, msecs_to_jiffies(timeout_ms));
188 void ivpu_stop_job_timeout_detection(struct ivpu_device *vdev)
190 cancel_delayed_work_sync(&vdev->pm->job_timeout_work);
193 int ivpu_pm_suspend_cb(struct device *dev)
195 struct drm_device *drm = dev_get_drvdata(dev);
196 struct ivpu_device *vdev = to_ivpu_device(drm);
197 unsigned long timeout;
199 ivpu_dbg(vdev, PM, "Suspend..\n");
201 timeout = jiffies + msecs_to_jiffies(vdev->timeout.tdr);
202 while (!ivpu_hw_is_idle(vdev)) {
204 if (time_after_eq(jiffies, timeout)) {
205 ivpu_err(vdev, "Failed to enter idle on system suspend\n");
210 ivpu_jsm_pwr_d0i3_enter(vdev);
213 ivpu_pm_prepare_warm_boot(vdev);
215 ivpu_dbg(vdev, PM, "Suspend done.\n");
220 int ivpu_pm_resume_cb(struct device *dev)
222 struct drm_device *drm = dev_get_drvdata(dev);
223 struct ivpu_device *vdev = to_ivpu_device(drm);
226 ivpu_dbg(vdev, PM, "Resume..\n");
228 ret = ivpu_resume(vdev);
230 ivpu_err(vdev, "Failed to resume: %d\n", ret);
232 ivpu_dbg(vdev, PM, "Resume done.\n");
237 int ivpu_pm_runtime_suspend_cb(struct device *dev)
239 struct drm_device *drm = dev_get_drvdata(dev);
240 struct ivpu_device *vdev = to_ivpu_device(drm);
241 bool hw_is_idle = true;
244 drm_WARN_ON(&vdev->drm, !xa_empty(&vdev->submitted_jobs_xa));
245 drm_WARN_ON(&vdev->drm, work_pending(&vdev->pm->recovery_work));
247 ivpu_dbg(vdev, PM, "Runtime suspend..\n");
249 if (!ivpu_hw_is_idle(vdev) && vdev->pm->suspend_reschedule_counter) {
250 ivpu_dbg(vdev, PM, "Failed to enter idle, rescheduling suspend, retries left %d\n",
251 vdev->pm->suspend_reschedule_counter);
252 pm_schedule_suspend(dev, vdev->timeout.reschedule_suspend);
253 vdev->pm->suspend_reschedule_counter--;
257 if (!vdev->pm->suspend_reschedule_counter)
259 else if (ivpu_jsm_pwr_d0i3_enter(vdev))
262 ret = ivpu_suspend(vdev);
264 ivpu_err(vdev, "Failed to set suspend VPU: %d\n", ret);
267 ivpu_err(vdev, "VPU failed to enter idle, force suspended.\n");
268 ivpu_fw_log_dump(vdev);
269 ivpu_pm_prepare_cold_boot(vdev);
271 ivpu_pm_prepare_warm_boot(vdev);
274 vdev->pm->suspend_reschedule_counter = PM_RESCHEDULE_LIMIT;
276 ivpu_dbg(vdev, PM, "Runtime suspend done.\n");
281 int ivpu_pm_runtime_resume_cb(struct device *dev)
283 struct drm_device *drm = dev_get_drvdata(dev);
284 struct ivpu_device *vdev = to_ivpu_device(drm);
287 ivpu_dbg(vdev, PM, "Runtime resume..\n");
289 ret = ivpu_resume(vdev);
291 ivpu_err(vdev, "Failed to set RESUME state: %d\n", ret);
293 ivpu_dbg(vdev, PM, "Runtime resume done.\n");
298 int ivpu_rpm_get(struct ivpu_device *vdev)
302 ret = pm_runtime_resume_and_get(vdev->drm.dev);
303 if (!drm_WARN_ON(&vdev->drm, ret < 0))
304 vdev->pm->suspend_reschedule_counter = PM_RESCHEDULE_LIMIT;
309 int ivpu_rpm_get_if_active(struct ivpu_device *vdev)
313 ret = pm_runtime_get_if_active(vdev->drm.dev, false);
314 drm_WARN_ON(&vdev->drm, ret < 0);
319 void ivpu_rpm_put(struct ivpu_device *vdev)
321 pm_runtime_mark_last_busy(vdev->drm.dev);
322 pm_runtime_put_autosuspend(vdev->drm.dev);
325 void ivpu_pm_reset_prepare_cb(struct pci_dev *pdev)
327 struct ivpu_device *vdev = pci_get_drvdata(pdev);
329 ivpu_dbg(vdev, PM, "Pre-reset..\n");
330 atomic_inc(&vdev->pm->reset_counter);
331 atomic_set(&vdev->pm->reset_pending, 1);
333 pm_runtime_get_sync(vdev->drm.dev);
334 down_write(&vdev->pm->reset_lock);
335 ivpu_prepare_for_reset(vdev);
337 ivpu_pm_prepare_cold_boot(vdev);
338 ivpu_jobs_abort_all(vdev);
339 ivpu_dbg(vdev, PM, "Pre-reset done.\n");
342 void ivpu_pm_reset_done_cb(struct pci_dev *pdev)
344 struct ivpu_device *vdev = pci_get_drvdata(pdev);
347 ivpu_dbg(vdev, PM, "Post-reset..\n");
348 ret = ivpu_resume(vdev);
350 ivpu_err(vdev, "Failed to set RESUME state: %d\n", ret);
351 up_write(&vdev->pm->reset_lock);
352 atomic_set(&vdev->pm->reset_pending, 0);
353 ivpu_dbg(vdev, PM, "Post-reset done.\n");
355 pm_runtime_mark_last_busy(vdev->drm.dev);
356 pm_runtime_put_autosuspend(vdev->drm.dev);
359 void ivpu_pm_init(struct ivpu_device *vdev)
361 struct device *dev = vdev->drm.dev;
362 struct ivpu_pm_info *pm = vdev->pm;
366 pm->suspend_reschedule_counter = PM_RESCHEDULE_LIMIT;
368 init_rwsem(&pm->reset_lock);
369 atomic_set(&pm->reset_pending, 0);
370 atomic_set(&pm->reset_counter, 0);
372 INIT_WORK(&pm->recovery_work, ivpu_pm_recovery_work);
373 INIT_DELAYED_WORK(&pm->job_timeout_work, ivpu_job_timeout_work);
375 if (ivpu_disable_recovery)
378 delay = vdev->timeout.autosuspend;
380 pm_runtime_use_autosuspend(dev);
381 pm_runtime_set_autosuspend_delay(dev, delay);
383 ivpu_dbg(vdev, PM, "Autosuspend delay = %d\n", delay);
386 void ivpu_pm_cancel_recovery(struct ivpu_device *vdev)
388 drm_WARN_ON(&vdev->drm, delayed_work_pending(&vdev->pm->job_timeout_work));
389 cancel_work_sync(&vdev->pm->recovery_work);
392 void ivpu_pm_enable(struct ivpu_device *vdev)
394 struct device *dev = vdev->drm.dev;
396 pm_runtime_set_active(dev);
397 pm_runtime_allow(dev);
398 pm_runtime_mark_last_busy(dev);
399 pm_runtime_put_autosuspend(dev);
402 void ivpu_pm_disable(struct ivpu_device *vdev)
404 pm_runtime_get_noresume(vdev->drm.dev);
405 pm_runtime_forbid(vdev->drm.dev);