1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2020-2023 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_ipc.h" 17 #include "ivpu_job.h" 18 #include "ivpu_mmu.h" 19 #include "ivpu_pm.h" 20 21 static bool ivpu_disable_recovery; 22 module_param_named_unsafe(disable_recovery, ivpu_disable_recovery, bool, 0644); 23 MODULE_PARM_DESC(disable_recovery, "Disables recovery when VPU hang is detected"); 24 25 #define PM_RESCHEDULE_LIMIT 5 26 27 static void ivpu_pm_prepare_cold_boot(struct ivpu_device *vdev) 28 { 29 struct ivpu_fw_info *fw = vdev->fw; 30 31 ivpu_cmdq_reset_all_contexts(vdev); 32 ivpu_ipc_reset(vdev); 33 ivpu_fw_load(vdev); 34 fw->entry_point = fw->cold_boot_entry_point; 35 } 36 37 static void ivpu_pm_prepare_warm_boot(struct ivpu_device *vdev) 38 { 39 struct ivpu_fw_info *fw = vdev->fw; 40 struct vpu_boot_params *bp = fw->mem->kvaddr; 41 42 if (!bp->save_restore_ret_address) { 43 ivpu_pm_prepare_cold_boot(vdev); 44 return; 45 } 46 47 ivpu_dbg(vdev, FW_BOOT, "Save/restore entry point %llx", bp->save_restore_ret_address); 48 fw->entry_point = bp->save_restore_ret_address; 49 } 50 51 static int ivpu_suspend(struct ivpu_device *vdev) 52 { 53 int ret; 54 55 ret = ivpu_shutdown(vdev); 56 if (ret) { 57 ivpu_err(vdev, "Failed to shutdown VPU: %d\n", ret); 58 return ret; 59 } 60 61 return ret; 62 } 63 64 static int ivpu_resume(struct ivpu_device *vdev) 65 { 66 int ret; 67 68 retry: 69 ret = ivpu_hw_power_up(vdev); 70 if (ret) { 71 ivpu_err(vdev, "Failed to power up HW: %d\n", ret); 72 return ret; 73 } 74 75 ret = ivpu_mmu_enable(vdev); 76 if (ret) { 77 ivpu_err(vdev, "Failed to resume MMU: %d\n", ret); 78 ivpu_hw_power_down(vdev); 79 return ret; 80 } 81 82 ret = ivpu_boot(vdev); 83 if (ret) { 84 ivpu_mmu_disable(vdev); 85 ivpu_hw_power_down(vdev); 86 if (!ivpu_fw_is_cold_boot(vdev)) { 87 ivpu_warn(vdev, "Failed to resume the FW: %d. Retrying cold boot..\n", ret); 88 ivpu_pm_prepare_cold_boot(vdev); 89 goto retry; 90 } else { 91 ivpu_err(vdev, "Failed to resume the FW: %d\n", ret); 92 } 93 } 94 95 return ret; 96 } 97 98 static void ivpu_pm_recovery_work(struct work_struct *work) 99 { 100 struct ivpu_pm_info *pm = container_of(work, struct ivpu_pm_info, recovery_work); 101 struct ivpu_device *vdev = pm->vdev; 102 char *evt[2] = {"IVPU_PM_EVENT=IVPU_RECOVER", NULL}; 103 int ret; 104 105 retry: 106 ret = pci_try_reset_function(to_pci_dev(vdev->drm.dev)); 107 if (ret == -EAGAIN && !drm_dev_is_unplugged(&vdev->drm)) { 108 cond_resched(); 109 goto retry; 110 } 111 112 if (ret && ret != -EAGAIN) 113 ivpu_err(vdev, "Failed to reset VPU: %d\n", ret); 114 115 kobject_uevent_env(&vdev->drm.dev->kobj, KOBJ_CHANGE, evt); 116 } 117 118 void ivpu_pm_schedule_recovery(struct ivpu_device *vdev) 119 { 120 struct ivpu_pm_info *pm = vdev->pm; 121 122 if (ivpu_disable_recovery) { 123 ivpu_err(vdev, "Recovery not available when disable_recovery param is set\n"); 124 return; 125 } 126 127 if (ivpu_is_fpga(vdev)) { 128 ivpu_err(vdev, "Recovery not available on FPGA\n"); 129 return; 130 } 131 132 /* Schedule recovery if it's not in progress */ 133 if (atomic_cmpxchg(&pm->in_reset, 0, 1) == 0) { 134 ivpu_hw_irq_disable(vdev); 135 queue_work(system_long_wq, &pm->recovery_work); 136 } 137 } 138 139 int ivpu_pm_suspend_cb(struct device *dev) 140 { 141 struct drm_device *drm = dev_get_drvdata(dev); 142 struct ivpu_device *vdev = to_ivpu_device(drm); 143 int ret; 144 145 ivpu_dbg(vdev, PM, "Suspend..\n"); 146 147 ret = ivpu_suspend(vdev); 148 if (ret && vdev->pm->suspend_reschedule_counter) { 149 ivpu_dbg(vdev, PM, "Failed to enter idle, rescheduling suspend, retries left %d\n", 150 vdev->pm->suspend_reschedule_counter); 151 pm_schedule_suspend(dev, vdev->timeout.reschedule_suspend); 152 vdev->pm->suspend_reschedule_counter--; 153 return -EBUSY; 154 } else if (!vdev->pm->suspend_reschedule_counter) { 155 ivpu_warn(vdev, "Failed to enter idle, force suspend\n"); 156 ivpu_pm_prepare_cold_boot(vdev); 157 } else { 158 ivpu_pm_prepare_warm_boot(vdev); 159 } 160 161 vdev->pm->suspend_reschedule_counter = PM_RESCHEDULE_LIMIT; 162 163 pci_save_state(to_pci_dev(dev)); 164 pci_set_power_state(to_pci_dev(dev), PCI_D3hot); 165 166 ivpu_dbg(vdev, PM, "Suspend done.\n"); 167 168 return ret; 169 } 170 171 int ivpu_pm_resume_cb(struct device *dev) 172 { 173 struct drm_device *drm = dev_get_drvdata(dev); 174 struct ivpu_device *vdev = to_ivpu_device(drm); 175 int ret; 176 177 ivpu_dbg(vdev, PM, "Resume..\n"); 178 179 pci_set_power_state(to_pci_dev(dev), PCI_D0); 180 pci_restore_state(to_pci_dev(dev)); 181 182 ret = ivpu_resume(vdev); 183 if (ret) 184 ivpu_err(vdev, "Failed to resume: %d\n", ret); 185 186 ivpu_dbg(vdev, PM, "Resume done.\n"); 187 188 return ret; 189 } 190 191 int ivpu_pm_runtime_suspend_cb(struct device *dev) 192 { 193 struct drm_device *drm = dev_get_drvdata(dev); 194 struct ivpu_device *vdev = to_ivpu_device(drm); 195 int ret; 196 197 ivpu_dbg(vdev, PM, "Runtime suspend..\n"); 198 199 if (!ivpu_hw_is_idle(vdev) && vdev->pm->suspend_reschedule_counter) { 200 ivpu_dbg(vdev, PM, "Failed to enter idle, rescheduling suspend, retries left %d\n", 201 vdev->pm->suspend_reschedule_counter); 202 pm_schedule_suspend(dev, vdev->timeout.reschedule_suspend); 203 vdev->pm->suspend_reschedule_counter--; 204 return -EAGAIN; 205 } 206 207 ret = ivpu_suspend(vdev); 208 if (ret) 209 ivpu_err(vdev, "Failed to set suspend VPU: %d\n", ret); 210 211 if (!vdev->pm->suspend_reschedule_counter) { 212 ivpu_warn(vdev, "VPU failed to enter idle, force suspended.\n"); 213 ivpu_pm_prepare_cold_boot(vdev); 214 } else { 215 ivpu_pm_prepare_warm_boot(vdev); 216 } 217 218 vdev->pm->suspend_reschedule_counter = PM_RESCHEDULE_LIMIT; 219 220 ivpu_dbg(vdev, PM, "Runtime suspend done.\n"); 221 222 return 0; 223 } 224 225 int ivpu_pm_runtime_resume_cb(struct device *dev) 226 { 227 struct drm_device *drm = dev_get_drvdata(dev); 228 struct ivpu_device *vdev = to_ivpu_device(drm); 229 int ret; 230 231 ivpu_dbg(vdev, PM, "Runtime resume..\n"); 232 233 ret = ivpu_resume(vdev); 234 if (ret) 235 ivpu_err(vdev, "Failed to set RESUME state: %d\n", ret); 236 237 ivpu_dbg(vdev, PM, "Runtime resume done.\n"); 238 239 return ret; 240 } 241 242 int ivpu_rpm_get(struct ivpu_device *vdev) 243 { 244 int ret; 245 246 ivpu_dbg(vdev, RPM, "rpm_get count %d\n", atomic_read(&vdev->drm.dev->power.usage_count)); 247 248 ret = pm_runtime_resume_and_get(vdev->drm.dev); 249 if (!drm_WARN_ON(&vdev->drm, ret < 0)) 250 vdev->pm->suspend_reschedule_counter = PM_RESCHEDULE_LIMIT; 251 252 return ret; 253 } 254 255 void ivpu_rpm_put(struct ivpu_device *vdev) 256 { 257 ivpu_dbg(vdev, RPM, "rpm_put count %d\n", atomic_read(&vdev->drm.dev->power.usage_count)); 258 259 pm_runtime_mark_last_busy(vdev->drm.dev); 260 pm_runtime_put_autosuspend(vdev->drm.dev); 261 } 262 263 void ivpu_pm_reset_prepare_cb(struct pci_dev *pdev) 264 { 265 struct ivpu_device *vdev = pci_get_drvdata(pdev); 266 267 pm_runtime_get_sync(vdev->drm.dev); 268 269 ivpu_dbg(vdev, PM, "Pre-reset..\n"); 270 atomic_set(&vdev->pm->in_reset, 1); 271 ivpu_shutdown(vdev); 272 ivpu_pm_prepare_cold_boot(vdev); 273 ivpu_jobs_abort_all(vdev); 274 ivpu_dbg(vdev, PM, "Pre-reset done.\n"); 275 } 276 277 void ivpu_pm_reset_done_cb(struct pci_dev *pdev) 278 { 279 struct ivpu_device *vdev = pci_get_drvdata(pdev); 280 int ret; 281 282 ivpu_dbg(vdev, PM, "Post-reset..\n"); 283 ret = ivpu_resume(vdev); 284 if (ret) 285 ivpu_err(vdev, "Failed to set RESUME state: %d\n", ret); 286 atomic_set(&vdev->pm->in_reset, 0); 287 ivpu_dbg(vdev, PM, "Post-reset done.\n"); 288 289 pm_runtime_put_autosuspend(vdev->drm.dev); 290 } 291 292 int ivpu_pm_init(struct ivpu_device *vdev) 293 { 294 struct device *dev = vdev->drm.dev; 295 struct ivpu_pm_info *pm = vdev->pm; 296 297 pm->vdev = vdev; 298 pm->suspend_reschedule_counter = PM_RESCHEDULE_LIMIT; 299 300 atomic_set(&pm->in_reset, 0); 301 INIT_WORK(&pm->recovery_work, ivpu_pm_recovery_work); 302 303 pm_runtime_use_autosuspend(dev); 304 305 if (ivpu_disable_recovery) 306 pm_runtime_set_autosuspend_delay(dev, -1); 307 else if (ivpu_is_silicon(vdev)) 308 pm_runtime_set_autosuspend_delay(dev, 100); 309 else 310 pm_runtime_set_autosuspend_delay(dev, 60000); 311 312 return 0; 313 } 314 315 void ivpu_pm_cancel_recovery(struct ivpu_device *vdev) 316 { 317 cancel_work_sync(&vdev->pm->recovery_work); 318 } 319 320 void ivpu_pm_enable(struct ivpu_device *vdev) 321 { 322 struct device *dev = vdev->drm.dev; 323 324 pm_runtime_set_active(dev); 325 pm_runtime_allow(dev); 326 pm_runtime_mark_last_busy(dev); 327 pm_runtime_put_autosuspend(dev); 328 329 ivpu_dbg(vdev, RPM, "Enable RPM count %d\n", atomic_read(&dev->power.usage_count)); 330 } 331 332 void ivpu_pm_disable(struct ivpu_device *vdev) 333 { 334 struct device *dev = vdev->drm.dev; 335 336 ivpu_dbg(vdev, RPM, "Disable RPM count %d\n", atomic_read(&dev->power.usage_count)); 337 338 pm_runtime_get_noresume(vdev->drm.dev); 339 pm_runtime_forbid(vdev->drm.dev); 340 } 341