1 /* 2 * Copyright 2021 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 */ 23 24 #include "amdgpu_reset.h" 25 #include "aldebaran.h" 26 #include "sienna_cichlid.h" 27 #include "smu_v13_0_10.h" 28 #include "soc_v1_0.h" 29 30 static int amdgpu_reset_xgmi_reset_on_init_suspend(struct amdgpu_device *adev) 31 { 32 int i; 33 34 for (i = adev->num_ip_blocks - 1; i >= 0; i--) { 35 if (!adev->ip_blocks[i].status.valid) 36 continue; 37 if (!adev->ip_blocks[i].status.hw) 38 continue; 39 /* displays are handled in phase1 */ 40 if (adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_DCE) 41 continue; 42 43 /* XXX handle errors */ 44 amdgpu_ip_block_suspend(&adev->ip_blocks[i]); 45 adev->ip_blocks[i].status.hw = false; 46 } 47 48 /* VCN FW shared region is in frambuffer, there are some flags 49 * initialized in that region during sw_init. Make sure the region is 50 * backed up. 51 */ 52 amdgpu_vcn_save_vcpu_bo(adev); 53 54 return 0; 55 } 56 57 static int amdgpu_reset_xgmi_reset_on_init_prep_hwctxt( 58 struct amdgpu_reset_control *reset_ctl, 59 struct amdgpu_reset_context *reset_context) 60 { 61 struct list_head *reset_device_list = reset_context->reset_device_list; 62 struct amdgpu_device *tmp_adev; 63 int r; 64 65 list_for_each_entry(tmp_adev, reset_device_list, reset_list) { 66 amdgpu_unregister_gpu_instance(tmp_adev); 67 r = amdgpu_reset_xgmi_reset_on_init_suspend(tmp_adev); 68 if (r) { 69 dev_err(tmp_adev->dev, 70 "xgmi reset on init: prepare for reset failed"); 71 return r; 72 } 73 } 74 75 return r; 76 } 77 78 static int amdgpu_reset_xgmi_reset_on_init_restore_hwctxt( 79 struct amdgpu_reset_control *reset_ctl, 80 struct amdgpu_reset_context *reset_context) 81 { 82 struct list_head *reset_device_list = reset_context->reset_device_list; 83 struct amdgpu_device *tmp_adev = NULL; 84 int r; 85 86 r = amdgpu_device_reinit_after_reset(reset_context); 87 if (r) 88 return r; 89 list_for_each_entry(tmp_adev, reset_device_list, reset_list) { 90 if (!tmp_adev->kfd.init_complete) { 91 kgd2kfd_init_zone_device(tmp_adev); 92 amdgpu_amdkfd_device_init(tmp_adev); 93 amdgpu_amdkfd_drm_client_create(tmp_adev); 94 amdgpu_ptl_sysfs_init(tmp_adev); 95 } 96 } 97 98 return r; 99 } 100 101 static int amdgpu_reset_xgmi_reset_on_init_perform_reset( 102 struct amdgpu_reset_control *reset_ctl, 103 struct amdgpu_reset_context *reset_context) 104 { 105 struct amdgpu_device *adev = (struct amdgpu_device *)reset_ctl->handle; 106 struct list_head *reset_device_list = reset_context->reset_device_list; 107 struct amdgpu_device *tmp_adev = NULL; 108 int r; 109 110 dev_dbg(adev->dev, "xgmi roi - hw reset\n"); 111 112 list_for_each_entry(tmp_adev, reset_device_list, reset_list) { 113 mutex_lock(&tmp_adev->reset_cntl->reset_lock); 114 tmp_adev->reset_cntl->active_reset = 115 amdgpu_asic_reset_method(adev); 116 } 117 r = 0; 118 /* Mode1 reset needs to be triggered on all devices together */ 119 list_for_each_entry(tmp_adev, reset_device_list, reset_list) { 120 /* For XGMI run all resets in parallel to speed up the process */ 121 if (!queue_work(system_dfl_wq, &tmp_adev->xgmi_reset_work)) 122 r = -EALREADY; 123 if (r) { 124 dev_err(tmp_adev->dev, 125 "xgmi reset on init: reset failed with error, %d", 126 r); 127 break; 128 } 129 } 130 131 /* For XGMI wait for all resets to complete before proceed */ 132 if (!r) { 133 list_for_each_entry(tmp_adev, reset_device_list, reset_list) { 134 flush_work(&tmp_adev->xgmi_reset_work); 135 r = tmp_adev->asic_reset_res; 136 if (r) 137 break; 138 } 139 } 140 141 list_for_each_entry(tmp_adev, reset_device_list, reset_list) { 142 mutex_unlock(&tmp_adev->reset_cntl->reset_lock); 143 tmp_adev->reset_cntl->active_reset = AMD_RESET_METHOD_NONE; 144 } 145 146 return r; 147 } 148 149 int amdgpu_reset_do_xgmi_reset_on_init( 150 struct amdgpu_reset_context *reset_context) 151 { 152 struct list_head *reset_device_list = reset_context->reset_device_list; 153 struct amdgpu_device *adev; 154 int r; 155 156 if (!reset_device_list || list_empty(reset_device_list) || 157 list_is_singular(reset_device_list)) 158 return -EINVAL; 159 160 adev = list_first_entry(reset_device_list, struct amdgpu_device, 161 reset_list); 162 r = amdgpu_reset_prepare_hwcontext(adev, reset_context); 163 if (r) 164 return r; 165 166 r = amdgpu_reset_perform_reset(adev, reset_context); 167 168 return r; 169 } 170 171 struct amdgpu_reset_handler xgmi_reset_on_init_handler = { 172 .reset_method = AMD_RESET_METHOD_ON_INIT, 173 .prepare_env = NULL, 174 .prepare_hwcontext = amdgpu_reset_xgmi_reset_on_init_prep_hwctxt, 175 .perform_reset = amdgpu_reset_xgmi_reset_on_init_perform_reset, 176 .restore_hwcontext = amdgpu_reset_xgmi_reset_on_init_restore_hwctxt, 177 .restore_env = NULL, 178 .do_reset = NULL, 179 }; 180 181 int amdgpu_reset_init(struct amdgpu_device *adev) 182 { 183 int ret = 0; 184 185 switch (amdgpu_ip_version(adev, MP1_HWIP, 0)) { 186 case IP_VERSION(13, 0, 2): 187 case IP_VERSION(13, 0, 6): 188 case IP_VERSION(13, 0, 12): 189 case IP_VERSION(13, 0, 14): 190 ret = aldebaran_reset_init(adev); 191 break; 192 case IP_VERSION(11, 0, 7): 193 ret = sienna_cichlid_reset_init(adev); 194 break; 195 case IP_VERSION(13, 0, 10): 196 ret = smu_v13_0_10_reset_init(adev); 197 break; 198 case IP_VERSION(15, 0, 8): 199 ret = soc_v1_0_reset_init(adev); 200 break; 201 default: 202 break; 203 } 204 205 return ret; 206 } 207 208 int amdgpu_reset_fini(struct amdgpu_device *adev) 209 { 210 int ret = 0; 211 212 switch (amdgpu_ip_version(adev, MP1_HWIP, 0)) { 213 case IP_VERSION(13, 0, 2): 214 case IP_VERSION(13, 0, 6): 215 case IP_VERSION(13, 0, 12): 216 case IP_VERSION(13, 0, 14): 217 ret = aldebaran_reset_fini(adev); 218 break; 219 case IP_VERSION(11, 0, 7): 220 ret = sienna_cichlid_reset_fini(adev); 221 break; 222 case IP_VERSION(13, 0, 10): 223 ret = smu_v13_0_10_reset_fini(adev); 224 break; 225 case IP_VERSION(15, 0, 8): 226 ret = soc_v1_0_reset_fini(adev); 227 break; 228 default: 229 break; 230 } 231 232 return ret; 233 } 234 235 int amdgpu_reset_prepare_hwcontext(struct amdgpu_device *adev, 236 struct amdgpu_reset_context *reset_context) 237 { 238 struct amdgpu_reset_handler *reset_handler = NULL; 239 240 if (adev->reset_cntl && adev->reset_cntl->get_reset_handler) 241 reset_handler = adev->reset_cntl->get_reset_handler( 242 adev->reset_cntl, reset_context); 243 if (!reset_handler) 244 return -EOPNOTSUPP; 245 246 return reset_handler->prepare_hwcontext(adev->reset_cntl, 247 reset_context); 248 } 249 250 int amdgpu_reset_perform_reset(struct amdgpu_device *adev, 251 struct amdgpu_reset_context *reset_context) 252 { 253 int ret; 254 struct amdgpu_reset_handler *reset_handler = NULL; 255 256 if (adev->reset_cntl) 257 reset_handler = adev->reset_cntl->get_reset_handler( 258 adev->reset_cntl, reset_context); 259 if (!reset_handler) 260 return -EOPNOTSUPP; 261 262 ret = reset_handler->perform_reset(adev->reset_cntl, reset_context); 263 if (ret) 264 return ret; 265 266 return reset_handler->restore_hwcontext(adev->reset_cntl, 267 reset_context); 268 } 269 270 271 void amdgpu_reset_destroy_reset_domain(struct kref *ref) 272 { 273 struct amdgpu_reset_domain *reset_domain = container_of(ref, 274 struct amdgpu_reset_domain, 275 refcount); 276 if (reset_domain->wq) 277 destroy_workqueue(reset_domain->wq); 278 279 kvfree(reset_domain); 280 } 281 282 struct amdgpu_reset_domain *amdgpu_reset_create_reset_domain(enum amdgpu_reset_domain_type type, 283 char *wq_name) 284 { 285 struct amdgpu_reset_domain *reset_domain; 286 287 reset_domain = kvzalloc_obj(struct amdgpu_reset_domain); 288 if (!reset_domain) { 289 DRM_ERROR("Failed to allocate amdgpu_reset_domain!"); 290 return NULL; 291 } 292 293 reset_domain->type = type; 294 kref_init(&reset_domain->refcount); 295 296 reset_domain->wq = create_singlethread_workqueue(wq_name); 297 if (!reset_domain->wq) { 298 DRM_ERROR("Failed to allocate wq for amdgpu_reset_domain!"); 299 amdgpu_reset_put_reset_domain(reset_domain); 300 return NULL; 301 302 } 303 304 atomic_set(&reset_domain->in_gpu_reset, 0); 305 atomic_set(&reset_domain->reset_res, 0); 306 init_rwsem(&reset_domain->sem); 307 308 return reset_domain; 309 } 310 311 void amdgpu_device_lock_reset_domain(struct amdgpu_reset_domain *reset_domain) 312 { 313 atomic_set(&reset_domain->in_gpu_reset, 1); 314 down_write(&reset_domain->sem); 315 } 316 317 318 void amdgpu_device_unlock_reset_domain(struct amdgpu_reset_domain *reset_domain) 319 { 320 atomic_set(&reset_domain->in_gpu_reset, 0); 321 up_write(&reset_domain->sem); 322 } 323 324 void amdgpu_reset_get_desc(struct amdgpu_reset_context *rst_ctxt, char *buf, 325 size_t len) 326 { 327 if (!buf || !len) 328 return; 329 330 switch (rst_ctxt->src) { 331 case AMDGPU_RESET_SRC_JOB: 332 if (rst_ctxt->job) { 333 snprintf(buf, len, "job hang on ring:%s", 334 rst_ctxt->job->base.sched->name); 335 } else { 336 strscpy(buf, "job hang", len); 337 } 338 break; 339 case AMDGPU_RESET_SRC_RAS: 340 strscpy(buf, "RAS error", len); 341 break; 342 case AMDGPU_RESET_SRC_MES: 343 strscpy(buf, "MES hang", len); 344 break; 345 case AMDGPU_RESET_SRC_HWS: 346 strscpy(buf, "HWS hang", len); 347 break; 348 case AMDGPU_RESET_SRC_USER: 349 strscpy(buf, "user trigger", len); 350 break; 351 case AMDGPU_RESET_SRC_USERQ: 352 strscpy(buf, "user queue trigger", len); 353 break; 354 default: 355 strscpy(buf, "unknown", len); 356 } 357 } 358 359 bool amdgpu_reset_in_recovery(struct amdgpu_device *adev) 360 { 361 return (adev->init_lvl->level == AMDGPU_INIT_LEVEL_RESET_RECOVERY); 362 } 363