1 // SPDX-License-Identifier: MIT 2 /* 3 * Copyright © 2021-2022 Intel Corporation 4 */ 5 6 #include <linux/types.h> 7 8 #include <drm/drm_print.h> 9 10 #include "gt/intel_engine_regs.h" 11 #include "gt/intel_gt.h" 12 #include "gt/intel_gt_mcr.h" 13 #include "gt/intel_gt_regs.h" 14 #include "gt/intel_lrc.h" 15 #include "guc_capture_fwif.h" 16 #include "intel_guc_capture.h" 17 #include "intel_guc_fwif.h" 18 #include "i915_drv.h" 19 #include "i915_gpu_error.h" 20 #include "i915_irq.h" 21 #include "i915_memcpy.h" 22 #include "i915_reg.h" 23 24 /* 25 * Define all device tables of GuC error capture register lists 26 * NOTE: For engine-registers, GuC only needs the register offsets 27 * from the engine-mmio-base 28 */ 29 #define COMMON_BASE_GLOBAL \ 30 { FORCEWAKE_MT, 0, 0, "FORCEWAKE" } 31 32 #define COMMON_GEN9BASE_GLOBAL \ 33 { GEN8_FAULT_TLB_DATA0, 0, 0, "GEN8_FAULT_TLB_DATA0" }, \ 34 { GEN8_FAULT_TLB_DATA1, 0, 0, "GEN8_FAULT_TLB_DATA1" }, \ 35 { ERROR_GEN6, 0, 0, "ERROR_GEN6" }, \ 36 { DONE_REG, 0, 0, "DONE_REG" }, \ 37 { HSW_GTT_CACHE_EN, 0, 0, "HSW_GTT_CACHE_EN" } 38 39 #define COMMON_GEN12BASE_GLOBAL \ 40 { GEN12_FAULT_TLB_DATA0, 0, 0, "GEN12_FAULT_TLB_DATA0" }, \ 41 { GEN12_FAULT_TLB_DATA1, 0, 0, "GEN12_FAULT_TLB_DATA1" }, \ 42 { GEN12_AUX_ERR_DBG, 0, 0, "AUX_ERR_DBG" }, \ 43 { GEN12_GAM_DONE, 0, 0, "GAM_DONE" }, \ 44 { GEN12_RING_FAULT_REG, 0, 0, "FAULT_REG" } 45 46 #define COMMON_BASE_ENGINE_INSTANCE \ 47 { RING_PSMI_CTL(0), 0, 0, "RC PSMI" }, \ 48 { RING_ESR(0), 0, 0, "ESR" }, \ 49 { RING_DMA_FADD(0), 0, 0, "RING_DMA_FADD_LDW" }, \ 50 { RING_DMA_FADD_UDW(0), 0, 0, "RING_DMA_FADD_UDW" }, \ 51 { RING_IPEIR(0), 0, 0, "IPEIR" }, \ 52 { RING_IPEHR(0), 0, 0, "IPEHR" }, \ 53 { RING_INSTPS(0), 0, 0, "INSTPS" }, \ 54 { RING_BBADDR(0), 0, 0, "RING_BBADDR_LOW32" }, \ 55 { RING_BBADDR_UDW(0), 0, 0, "RING_BBADDR_UP32" }, \ 56 { RING_BBSTATE(0), 0, 0, "BB_STATE" }, \ 57 { CCID(0), 0, 0, "CCID" }, \ 58 { RING_ACTHD(0), 0, 0, "ACTHD_LDW" }, \ 59 { RING_ACTHD_UDW(0), 0, 0, "ACTHD_UDW" }, \ 60 { RING_INSTPM(0), 0, 0, "INSTPM" }, \ 61 { RING_INSTDONE(0), 0, 0, "INSTDONE" }, \ 62 { RING_NOPID(0), 0, 0, "RING_NOPID" }, \ 63 { RING_START(0), 0, 0, "START" }, \ 64 { RING_HEAD(0), 0, 0, "HEAD" }, \ 65 { RING_TAIL(0), 0, 0, "TAIL" }, \ 66 { RING_CTL(0), 0, 0, "CTL" }, \ 67 { RING_MI_MODE(0), 0, 0, "MODE" }, \ 68 { RING_CONTEXT_CONTROL(0), 0, 0, "RING_CONTEXT_CONTROL" }, \ 69 { RING_HWS_PGA(0), 0, 0, "HWS" }, \ 70 { RING_MODE_GEN7(0), 0, 0, "GFX_MODE" }, \ 71 { GEN8_RING_PDP_LDW(0, 0), 0, 0, "PDP0_LDW" }, \ 72 { GEN8_RING_PDP_UDW(0, 0), 0, 0, "PDP0_UDW" }, \ 73 { GEN8_RING_PDP_LDW(0, 1), 0, 0, "PDP1_LDW" }, \ 74 { GEN8_RING_PDP_UDW(0, 1), 0, 0, "PDP1_UDW" }, \ 75 { GEN8_RING_PDP_LDW(0, 2), 0, 0, "PDP2_LDW" }, \ 76 { GEN8_RING_PDP_UDW(0, 2), 0, 0, "PDP2_UDW" }, \ 77 { GEN8_RING_PDP_LDW(0, 3), 0, 0, "PDP3_LDW" }, \ 78 { GEN8_RING_PDP_UDW(0, 3), 0, 0, "PDP3_UDW" } 79 80 #define COMMON_BASE_HAS_EU \ 81 { EIR, 0, 0, "EIR" } 82 83 #define COMMON_BASE_RENDER \ 84 { GEN7_SC_INSTDONE, 0, 0, "GEN7_SC_INSTDONE" } 85 86 #define COMMON_GEN12BASE_RENDER \ 87 { GEN12_SC_INSTDONE_EXTRA, 0, 0, "GEN12_SC_INSTDONE_EXTRA" }, \ 88 { GEN12_SC_INSTDONE_EXTRA2, 0, 0, "GEN12_SC_INSTDONE_EXTRA2" } 89 90 #define COMMON_GEN12BASE_VEC \ 91 { GEN12_SFC_DONE(0), 0, 0, "SFC_DONE[0]" }, \ 92 { GEN12_SFC_DONE(1), 0, 0, "SFC_DONE[1]" }, \ 93 { GEN12_SFC_DONE(2), 0, 0, "SFC_DONE[2]" }, \ 94 { GEN12_SFC_DONE(3), 0, 0, "SFC_DONE[3]" } 95 96 /* XE_LPD - Global */ 97 static const struct __guc_mmio_reg_descr xe_lpd_global_regs[] = { 98 COMMON_BASE_GLOBAL, 99 COMMON_GEN9BASE_GLOBAL, 100 COMMON_GEN12BASE_GLOBAL, 101 }; 102 103 /* XE_LPD - Render / Compute Per-Class */ 104 static const struct __guc_mmio_reg_descr xe_lpd_rc_class_regs[] = { 105 COMMON_BASE_HAS_EU, 106 COMMON_BASE_RENDER, 107 COMMON_GEN12BASE_RENDER, 108 }; 109 110 /* GEN9/XE_LPD - Render / Compute Per-Engine-Instance */ 111 static const struct __guc_mmio_reg_descr xe_lpd_rc_inst_regs[] = { 112 COMMON_BASE_ENGINE_INSTANCE, 113 }; 114 115 /* GEN9/XE_LPD - Media Decode/Encode Per-Engine-Instance */ 116 static const struct __guc_mmio_reg_descr xe_lpd_vd_inst_regs[] = { 117 COMMON_BASE_ENGINE_INSTANCE, 118 }; 119 120 /* XE_LPD - Video Enhancement Per-Class */ 121 static const struct __guc_mmio_reg_descr xe_lpd_vec_class_regs[] = { 122 COMMON_GEN12BASE_VEC, 123 }; 124 125 /* GEN9/XE_LPD - Video Enhancement Per-Engine-Instance */ 126 static const struct __guc_mmio_reg_descr xe_lpd_vec_inst_regs[] = { 127 COMMON_BASE_ENGINE_INSTANCE, 128 }; 129 130 /* GEN9/XE_LPD - Blitter Per-Engine-Instance */ 131 static const struct __guc_mmio_reg_descr xe_lpd_blt_inst_regs[] = { 132 COMMON_BASE_ENGINE_INSTANCE, 133 }; 134 135 /* GEN9 - Global */ 136 static const struct __guc_mmio_reg_descr default_global_regs[] = { 137 COMMON_BASE_GLOBAL, 138 COMMON_GEN9BASE_GLOBAL, 139 }; 140 141 static const struct __guc_mmio_reg_descr default_rc_class_regs[] = { 142 COMMON_BASE_HAS_EU, 143 COMMON_BASE_RENDER, 144 }; 145 146 /* 147 * Empty lists: 148 * GEN9/XE_LPD - Blitter Per-Class 149 * GEN9/XE_LPD - Media Decode/Encode Per-Class 150 * GEN9 - VEC Class 151 */ 152 static const struct __guc_mmio_reg_descr empty_regs_list[] = { 153 }; 154 155 #define TO_GCAP_DEF_OWNER(x) (GUC_CAPTURE_LIST_INDEX_##x) 156 #define TO_GCAP_DEF_TYPE(x) (GUC_CAPTURE_LIST_TYPE_##x) 157 #define MAKE_REGLIST(regslist, regsowner, regstype, class) \ 158 { \ 159 regslist, \ 160 ARRAY_SIZE(regslist), \ 161 TO_GCAP_DEF_OWNER(regsowner), \ 162 TO_GCAP_DEF_TYPE(regstype), \ 163 class, \ 164 NULL, \ 165 } 166 167 /* List of lists */ 168 static struct __guc_mmio_reg_descr_group default_lists[] = { 169 MAKE_REGLIST(default_global_regs, PF, GLOBAL, 0), 170 MAKE_REGLIST(default_rc_class_regs, PF, ENGINE_CLASS, GUC_RENDER_CLASS), 171 MAKE_REGLIST(xe_lpd_rc_inst_regs, PF, ENGINE_INSTANCE, GUC_RENDER_CLASS), 172 MAKE_REGLIST(empty_regs_list, PF, ENGINE_CLASS, GUC_VIDEO_CLASS), 173 MAKE_REGLIST(xe_lpd_vd_inst_regs, PF, ENGINE_INSTANCE, GUC_VIDEO_CLASS), 174 MAKE_REGLIST(empty_regs_list, PF, ENGINE_CLASS, GUC_VIDEOENHANCE_CLASS), 175 MAKE_REGLIST(xe_lpd_vec_inst_regs, PF, ENGINE_INSTANCE, GUC_VIDEOENHANCE_CLASS), 176 MAKE_REGLIST(empty_regs_list, PF, ENGINE_CLASS, GUC_BLITTER_CLASS), 177 MAKE_REGLIST(xe_lpd_blt_inst_regs, PF, ENGINE_INSTANCE, GUC_BLITTER_CLASS), 178 {} 179 }; 180 181 static const struct __guc_mmio_reg_descr_group xe_lpd_lists[] = { 182 MAKE_REGLIST(xe_lpd_global_regs, PF, GLOBAL, 0), 183 MAKE_REGLIST(xe_lpd_rc_class_regs, PF, ENGINE_CLASS, GUC_RENDER_CLASS), 184 MAKE_REGLIST(xe_lpd_rc_inst_regs, PF, ENGINE_INSTANCE, GUC_RENDER_CLASS), 185 MAKE_REGLIST(empty_regs_list, PF, ENGINE_CLASS, GUC_VIDEO_CLASS), 186 MAKE_REGLIST(xe_lpd_vd_inst_regs, PF, ENGINE_INSTANCE, GUC_VIDEO_CLASS), 187 MAKE_REGLIST(xe_lpd_vec_class_regs, PF, ENGINE_CLASS, GUC_VIDEOENHANCE_CLASS), 188 MAKE_REGLIST(xe_lpd_vec_inst_regs, PF, ENGINE_INSTANCE, GUC_VIDEOENHANCE_CLASS), 189 MAKE_REGLIST(empty_regs_list, PF, ENGINE_CLASS, GUC_BLITTER_CLASS), 190 MAKE_REGLIST(xe_lpd_blt_inst_regs, PF, ENGINE_INSTANCE, GUC_BLITTER_CLASS), 191 {} 192 }; 193 194 static const struct __guc_mmio_reg_descr_group * 195 guc_capture_get_one_list(const struct __guc_mmio_reg_descr_group *reglists, 196 u32 owner, u32 type, u32 id) 197 { 198 int i; 199 200 if (!reglists) 201 return NULL; 202 203 for (i = 0; reglists[i].list; ++i) { 204 if (reglists[i].owner == owner && reglists[i].type == type && 205 (reglists[i].engine == id || reglists[i].type == GUC_CAPTURE_LIST_TYPE_GLOBAL)) 206 return ®lists[i]; 207 } 208 209 return NULL; 210 } 211 212 static struct __guc_mmio_reg_descr_group * 213 guc_capture_get_one_ext_list(struct __guc_mmio_reg_descr_group *reglists, 214 u32 owner, u32 type, u32 id) 215 { 216 int i; 217 218 if (!reglists) 219 return NULL; 220 221 for (i = 0; reglists[i].extlist; ++i) { 222 if (reglists[i].owner == owner && reglists[i].type == type && 223 (reglists[i].engine == id || reglists[i].type == GUC_CAPTURE_LIST_TYPE_GLOBAL)) 224 return ®lists[i]; 225 } 226 227 return NULL; 228 } 229 230 static void guc_capture_free_extlists(struct __guc_mmio_reg_descr_group *reglists) 231 { 232 int i = 0; 233 234 if (!reglists) 235 return; 236 237 while (reglists[i].extlist) 238 kfree(reglists[i++].extlist); 239 } 240 241 struct __ext_steer_reg { 242 const char *name; 243 i915_reg_t reg; 244 }; 245 246 static const struct __ext_steer_reg xe_extregs[] = { 247 {"GEN7_SAMPLER_INSTDONE", GEN7_SAMPLER_INSTDONE}, 248 {"GEN7_ROW_INSTDONE", GEN7_ROW_INSTDONE} 249 }; 250 251 static void __fill_ext_reg(struct __guc_mmio_reg_descr *ext, 252 const struct __ext_steer_reg *extlist, 253 int slice_id, int subslice_id) 254 { 255 ext->reg = extlist->reg; 256 ext->flags = FIELD_PREP(GUC_REGSET_STEERING_GROUP, slice_id); 257 ext->flags |= FIELD_PREP(GUC_REGSET_STEERING_INSTANCE, subslice_id); 258 ext->regname = extlist->name; 259 } 260 261 static int 262 __alloc_ext_regs(struct __guc_mmio_reg_descr_group *newlist, 263 const struct __guc_mmio_reg_descr_group *rootlist, int num_regs) 264 { 265 struct __guc_mmio_reg_descr *list; 266 267 list = kcalloc(num_regs, sizeof(struct __guc_mmio_reg_descr), GFP_KERNEL); 268 if (!list) 269 return -ENOMEM; 270 271 newlist->extlist = list; 272 newlist->num_regs = num_regs; 273 newlist->owner = rootlist->owner; 274 newlist->engine = rootlist->engine; 275 newlist->type = rootlist->type; 276 277 return 0; 278 } 279 280 static void 281 guc_capture_alloc_steered_lists_xe_lpd(struct intel_guc *guc, 282 const struct __guc_mmio_reg_descr_group *lists) 283 { 284 struct intel_gt *gt = guc_to_gt(guc); 285 int slice, subslice, iter, i, num_steer_regs, num_tot_regs = 0; 286 const struct __guc_mmio_reg_descr_group *list; 287 struct __guc_mmio_reg_descr_group *extlists; 288 struct __guc_mmio_reg_descr *extarray; 289 struct sseu_dev_info *sseu; 290 291 /* In XE_LPD we only have steered registers for the render-class */ 292 list = guc_capture_get_one_list(lists, GUC_CAPTURE_LIST_INDEX_PF, 293 GUC_CAPTURE_LIST_TYPE_ENGINE_CLASS, GUC_RENDER_CLASS); 294 /* skip if extlists was previously allocated */ 295 if (!list || guc->capture->extlists) 296 return; 297 298 num_steer_regs = ARRAY_SIZE(xe_extregs); 299 300 sseu = >->info.sseu; 301 for_each_ss_steering(iter, gt, slice, subslice) 302 num_tot_regs += num_steer_regs; 303 304 if (!num_tot_regs) 305 return; 306 307 /* allocate an extra for an end marker */ 308 extlists = kcalloc(2, sizeof(struct __guc_mmio_reg_descr_group), GFP_KERNEL); 309 if (!extlists) 310 return; 311 312 if (__alloc_ext_regs(&extlists[0], list, num_tot_regs)) { 313 kfree(extlists); 314 return; 315 } 316 317 extarray = extlists[0].extlist; 318 for_each_ss_steering(iter, gt, slice, subslice) { 319 for (i = 0; i < num_steer_regs; ++i) { 320 __fill_ext_reg(extarray, &xe_extregs[i], slice, subslice); 321 ++extarray; 322 } 323 } 324 325 guc->capture->extlists = extlists; 326 } 327 328 static const struct __ext_steer_reg xehpg_extregs[] = { 329 {"XEHPG_INSTDONE_GEOM_SVG", XEHPG_INSTDONE_GEOM_SVG} 330 }; 331 332 static bool __has_xehpg_extregs(u32 ipver) 333 { 334 return (ipver >= IP_VER(12, 55)); 335 } 336 337 static void 338 guc_capture_alloc_steered_lists_xe_hpg(struct intel_guc *guc, 339 const struct __guc_mmio_reg_descr_group *lists, 340 u32 ipver) 341 { 342 struct intel_gt *gt = guc_to_gt(guc); 343 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 344 struct sseu_dev_info *sseu; 345 int slice, subslice, i, iter, num_steer_regs, num_tot_regs = 0; 346 const struct __guc_mmio_reg_descr_group *list; 347 struct __guc_mmio_reg_descr_group *extlists; 348 struct __guc_mmio_reg_descr *extarray; 349 350 /* In XE_LP / HPG we only have render-class steering registers during error-capture */ 351 list = guc_capture_get_one_list(lists, GUC_CAPTURE_LIST_INDEX_PF, 352 GUC_CAPTURE_LIST_TYPE_ENGINE_CLASS, GUC_RENDER_CLASS); 353 /* skip if extlists was previously allocated */ 354 if (!list || guc->capture->extlists) 355 return; 356 357 num_steer_regs = ARRAY_SIZE(xe_extregs); 358 if (__has_xehpg_extregs(ipver)) 359 num_steer_regs += ARRAY_SIZE(xehpg_extregs); 360 361 sseu = >->info.sseu; 362 for_each_ss_steering(iter, gt, slice, subslice) 363 num_tot_regs += num_steer_regs; 364 365 if (!num_tot_regs) 366 return; 367 368 /* allocate an extra for an end marker */ 369 extlists = kcalloc(2, sizeof(struct __guc_mmio_reg_descr_group), GFP_KERNEL); 370 if (!extlists) 371 return; 372 373 if (__alloc_ext_regs(&extlists[0], list, num_tot_regs)) { 374 kfree(extlists); 375 return; 376 } 377 378 extarray = extlists[0].extlist; 379 for_each_ss_steering(iter, gt, slice, subslice) { 380 for (i = 0; i < ARRAY_SIZE(xe_extregs); ++i) { 381 __fill_ext_reg(extarray, &xe_extregs[i], slice, subslice); 382 ++extarray; 383 } 384 if (__has_xehpg_extregs(ipver)) { 385 for (i = 0; i < ARRAY_SIZE(xehpg_extregs); ++i) { 386 __fill_ext_reg(extarray, &xehpg_extregs[i], slice, subslice); 387 ++extarray; 388 } 389 } 390 } 391 392 drm_dbg(&i915->drm, "GuC-capture found %d-ext-regs.\n", num_tot_regs); 393 guc->capture->extlists = extlists; 394 } 395 396 static const struct __guc_mmio_reg_descr_group * 397 guc_capture_get_device_reglist(struct intel_guc *guc) 398 { 399 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 400 401 if (GRAPHICS_VER(i915) > 11) { 402 /* 403 * For certain engine classes, there are slice and subslice 404 * level registers requiring steering. We allocate and populate 405 * these at init time based on hw config add it as an extension 406 * list at the end of the pre-populated render list. 407 */ 408 if (IS_DG2(i915)) 409 guc_capture_alloc_steered_lists_xe_hpg(guc, xe_lpd_lists, IP_VER(12, 55)); 410 else if (IS_XEHPSDV(i915)) 411 guc_capture_alloc_steered_lists_xe_hpg(guc, xe_lpd_lists, IP_VER(12, 50)); 412 else 413 guc_capture_alloc_steered_lists_xe_lpd(guc, xe_lpd_lists); 414 415 return xe_lpd_lists; 416 } 417 418 /* if GuC submission is enabled on a non-POR platform, just use a common baseline */ 419 return default_lists; 420 } 421 422 static int 423 guc_capture_list_init(struct intel_guc *guc, u32 owner, u32 type, u32 classid, 424 struct guc_mmio_reg *ptr, u16 num_entries) 425 { 426 u32 i = 0, j = 0; 427 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 428 const struct __guc_mmio_reg_descr_group *reglists = guc->capture->reglists; 429 struct __guc_mmio_reg_descr_group *extlists = guc->capture->extlists; 430 const struct __guc_mmio_reg_descr_group *match; 431 struct __guc_mmio_reg_descr_group *matchext; 432 433 if (!reglists) 434 return -ENODEV; 435 436 match = guc_capture_get_one_list(reglists, owner, type, classid); 437 if (!match) 438 return -ENODATA; 439 440 for (i = 0; i < num_entries && i < match->num_regs; ++i) { 441 ptr[i].offset = match->list[i].reg.reg; 442 ptr[i].value = 0xDEADF00D; 443 ptr[i].flags = match->list[i].flags; 444 ptr[i].mask = match->list[i].mask; 445 } 446 447 matchext = guc_capture_get_one_ext_list(extlists, owner, type, classid); 448 if (matchext) { 449 for (i = match->num_regs, j = 0; i < num_entries && 450 i < (match->num_regs + matchext->num_regs) && 451 j < matchext->num_regs; ++i, ++j) { 452 ptr[i].offset = matchext->extlist[j].reg.reg; 453 ptr[i].value = 0xDEADF00D; 454 ptr[i].flags = matchext->extlist[j].flags; 455 ptr[i].mask = matchext->extlist[j].mask; 456 } 457 } 458 if (i < num_entries) 459 drm_dbg(&i915->drm, "GuC-capture: Init reglist short %d out %d.\n", 460 (int)i, (int)num_entries); 461 462 return 0; 463 } 464 465 static int 466 guc_cap_list_num_regs(struct intel_guc_state_capture *gc, u32 owner, u32 type, u32 classid) 467 { 468 const struct __guc_mmio_reg_descr_group *match; 469 struct __guc_mmio_reg_descr_group *matchext; 470 int num_regs; 471 472 match = guc_capture_get_one_list(gc->reglists, owner, type, classid); 473 if (!match) 474 return 0; 475 476 num_regs = match->num_regs; 477 478 matchext = guc_capture_get_one_ext_list(gc->extlists, owner, type, classid); 479 if (matchext) 480 num_regs += matchext->num_regs; 481 482 return num_regs; 483 } 484 485 int 486 intel_guc_capture_getlistsize(struct intel_guc *guc, u32 owner, u32 type, u32 classid, 487 size_t *size) 488 { 489 struct intel_guc_state_capture *gc = guc->capture; 490 struct __guc_capture_ads_cache *cache = &gc->ads_cache[owner][type][classid]; 491 int num_regs; 492 493 if (!gc->reglists) 494 return -ENODEV; 495 496 if (cache->is_valid) { 497 *size = cache->size; 498 return cache->status; 499 } 500 501 num_regs = guc_cap_list_num_regs(gc, owner, type, classid); 502 if (!num_regs) 503 return -ENODATA; 504 505 *size = PAGE_ALIGN((sizeof(struct guc_debug_capture_list)) + 506 (num_regs * sizeof(struct guc_mmio_reg))); 507 508 return 0; 509 } 510 511 static void guc_capture_create_prealloc_nodes(struct intel_guc *guc); 512 513 int 514 intel_guc_capture_getlist(struct intel_guc *guc, u32 owner, u32 type, u32 classid, 515 void **outptr) 516 { 517 struct intel_guc_state_capture *gc = guc->capture; 518 struct __guc_capture_ads_cache *cache = &gc->ads_cache[owner][type][classid]; 519 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 520 struct guc_debug_capture_list *listnode; 521 int ret, num_regs; 522 u8 *caplist, *tmp; 523 size_t size = 0; 524 525 if (!gc->reglists) 526 return -ENODEV; 527 528 if (cache->is_valid) { 529 *outptr = cache->ptr; 530 return cache->status; 531 } 532 533 /* 534 * ADS population of input registers is a good 535 * time to pre-allocate cachelist output nodes 536 */ 537 guc_capture_create_prealloc_nodes(guc); 538 539 ret = intel_guc_capture_getlistsize(guc, owner, type, classid, &size); 540 if (ret) { 541 cache->is_valid = true; 542 cache->ptr = NULL; 543 cache->size = 0; 544 cache->status = ret; 545 return ret; 546 } 547 548 caplist = kzalloc(size, GFP_KERNEL); 549 if (!caplist) { 550 drm_dbg(&i915->drm, "GuC-capture: failed to alloc cached caplist"); 551 return -ENOMEM; 552 } 553 554 /* populate capture list header */ 555 tmp = caplist; 556 num_regs = guc_cap_list_num_regs(guc->capture, owner, type, classid); 557 listnode = (struct guc_debug_capture_list *)tmp; 558 listnode->header.info = FIELD_PREP(GUC_CAPTURELISTHDR_NUMDESCR, (u32)num_regs); 559 560 /* populate list of register descriptor */ 561 tmp += sizeof(struct guc_debug_capture_list); 562 guc_capture_list_init(guc, owner, type, classid, (struct guc_mmio_reg *)tmp, num_regs); 563 564 /* cache this list */ 565 cache->is_valid = true; 566 cache->ptr = caplist; 567 cache->size = size; 568 cache->status = 0; 569 570 *outptr = caplist; 571 572 return 0; 573 } 574 575 int 576 intel_guc_capture_getnullheader(struct intel_guc *guc, 577 void **outptr, size_t *size) 578 { 579 struct intel_guc_state_capture *gc = guc->capture; 580 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 581 int tmp = sizeof(u32) * 4; 582 void *null_header; 583 584 if (gc->ads_null_cache) { 585 *outptr = gc->ads_null_cache; 586 *size = tmp; 587 return 0; 588 } 589 590 null_header = kzalloc(tmp, GFP_KERNEL); 591 if (!null_header) { 592 drm_dbg(&i915->drm, "GuC-capture: failed to alloc cached nulllist"); 593 return -ENOMEM; 594 } 595 596 gc->ads_null_cache = null_header; 597 *outptr = null_header; 598 *size = tmp; 599 600 return 0; 601 } 602 603 static int 604 guc_capture_output_min_size_est(struct intel_guc *guc) 605 { 606 struct intel_gt *gt = guc_to_gt(guc); 607 struct intel_engine_cs *engine; 608 enum intel_engine_id id; 609 int worst_min_size = 0, num_regs = 0; 610 size_t tmp = 0; 611 612 if (!guc->capture) 613 return -ENODEV; 614 615 /* 616 * If every single engine-instance suffered a failure in quick succession but 617 * were all unrelated, then a burst of multiple error-capture events would dump 618 * registers for every one engine instance, one at a time. In this case, GuC 619 * would even dump the global-registers repeatedly. 620 * 621 * For each engine instance, there would be 1 x guc_state_capture_group_t output 622 * followed by 3 x guc_state_capture_t lists. The latter is how the register 623 * dumps are split across different register types (where the '3' are global vs class 624 * vs instance). 625 */ 626 for_each_engine(engine, gt, id) { 627 worst_min_size += sizeof(struct guc_state_capture_group_header_t) + 628 (3 * sizeof(struct guc_state_capture_header_t)); 629 630 if (!intel_guc_capture_getlistsize(guc, 0, GUC_CAPTURE_LIST_TYPE_GLOBAL, 0, &tmp)) 631 num_regs += tmp; 632 633 if (!intel_guc_capture_getlistsize(guc, 0, GUC_CAPTURE_LIST_TYPE_ENGINE_CLASS, 634 engine->class, &tmp)) { 635 num_regs += tmp; 636 } 637 if (!intel_guc_capture_getlistsize(guc, 0, GUC_CAPTURE_LIST_TYPE_ENGINE_INSTANCE, 638 engine->class, &tmp)) { 639 num_regs += tmp; 640 } 641 } 642 643 worst_min_size += (num_regs * sizeof(struct guc_mmio_reg)); 644 645 return worst_min_size; 646 } 647 648 /* 649 * Add on a 3x multiplier to allow for multiple back-to-back captures occurring 650 * before the i915 can read the data out and process it 651 */ 652 #define GUC_CAPTURE_OVERBUFFER_MULTIPLIER 3 653 654 static void check_guc_capture_size(struct intel_guc *guc) 655 { 656 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 657 int min_size = guc_capture_output_min_size_est(guc); 658 int spare_size = min_size * GUC_CAPTURE_OVERBUFFER_MULTIPLIER; 659 660 if (min_size < 0) 661 drm_warn(&i915->drm, "Failed to calculate GuC error state capture buffer minimum size: %d!\n", 662 min_size); 663 else if (min_size > CAPTURE_BUFFER_SIZE) 664 drm_warn(&i915->drm, "GuC error state capture buffer is too small: %d < %d\n", 665 CAPTURE_BUFFER_SIZE, min_size); 666 else if (spare_size > CAPTURE_BUFFER_SIZE) 667 drm_notice(&i915->drm, "GuC error state capture buffer maybe too small: %d < %d (min = %d)\n", 668 CAPTURE_BUFFER_SIZE, spare_size, min_size); 669 } 670 671 /* 672 * KMD Init time flows: 673 * -------------------- 674 * --> alloc A: GuC input capture regs lists (registered to GuC via ADS). 675 * intel_guc_ads acquires the register lists by calling 676 * intel_guc_capture_list_size and intel_guc_capture_list_get 'n' times, 677 * where n = 1 for global-reg-list + 678 * num_engine_classes for class-reg-list + 679 * num_engine_classes for instance-reg-list 680 * (since all instances of the same engine-class type 681 * have an identical engine-instance register-list). 682 * ADS module also calls separately for PF vs VF. 683 * 684 * --> alloc B: GuC output capture buf (registered via guc_init_params(log_param)) 685 * Size = #define CAPTURE_BUFFER_SIZE (warns if on too-small) 686 * Note2: 'x 3' to hold multiple capture groups 687 * 688 * GUC Runtime notify capture: 689 * -------------------------- 690 * --> G2H STATE_CAPTURE_NOTIFICATION 691 * L--> intel_guc_capture_process 692 * L--> Loop through B (head..tail) and for each engine instance's 693 * err-state-captured register-list we find, we alloc 'C': 694 * --> alloc C: A capture-output-node structure that includes misc capture info along 695 * with 3 register list dumps (global, engine-class and engine-instance) 696 * This node is created from a pre-allocated list of blank nodes in 697 * guc->capture->cachelist and populated with the error-capture 698 * data from GuC and then it's added into guc->capture->outlist linked 699 * list. This list is used for matchup and printout by i915_gpu_coredump 700 * and err_print_gt, (when user invokes the error capture sysfs). 701 * 702 * GUC --> notify context reset: 703 * ----------------------------- 704 * --> G2H CONTEXT RESET 705 * L--> guc_handle_context_reset --> i915_capture_error_state 706 * L--> i915_gpu_coredump(..IS_GUC_CAPTURE) --> gt_record_engines 707 * --> capture_engine(..IS_GUC_CAPTURE) 708 * L--> intel_guc_capture_get_matching_node is where 709 * detach C from internal linked list and add it into 710 * intel_engine_coredump struct (if the context and 711 * engine of the event notification matches a node 712 * in the link list). 713 * 714 * User Sysfs / Debugfs 715 * -------------------- 716 * --> i915_gpu_coredump_copy_to_buffer-> 717 * L--> err_print_to_sgl --> err_print_gt 718 * L--> error_print_guc_captures 719 * L--> intel_guc_capture_print_node prints the 720 * register lists values of the attached node 721 * on the error-engine-dump being reported. 722 * L--> i915_reset_error_state ... -->__i915_gpu_coredump_free 723 * L--> ... cleanup_gt --> 724 * L--> intel_guc_capture_free_node returns the 725 * capture-output-node back to the internal 726 * cachelist for reuse. 727 * 728 */ 729 730 static int guc_capture_buf_cnt(struct __guc_capture_bufstate *buf) 731 { 732 if (buf->wr >= buf->rd) 733 return (buf->wr - buf->rd); 734 return (buf->size - buf->rd) + buf->wr; 735 } 736 737 static int guc_capture_buf_cnt_to_end(struct __guc_capture_bufstate *buf) 738 { 739 if (buf->rd > buf->wr) 740 return (buf->size - buf->rd); 741 return (buf->wr - buf->rd); 742 } 743 744 /* 745 * GuC's error-capture output is a ring buffer populated in a byte-stream fashion: 746 * 747 * The GuC Log buffer region for error-capture is managed like a ring buffer. 748 * The GuC firmware dumps error capture logs into this ring in a byte-stream flow. 749 * Additionally, as per the current and foreseeable future, all packed error- 750 * capture output structures are dword aligned. 751 * 752 * That said, if the GuC firmware is in the midst of writing a structure that is larger 753 * than one dword but the tail end of the err-capture buffer-region has lesser space left, 754 * we would need to extract that structure one dword at a time straddled across the end, 755 * onto the start of the ring. 756 * 757 * Below function, guc_capture_log_remove_dw is a helper for that. All callers of this 758 * function would typically do a straight-up memcpy from the ring contents and will only 759 * call this helper if their structure-extraction is straddling across the end of the 760 * ring. GuC firmware does not add any padding. The reason for the no-padding is to ease 761 * scalability for future expansion of output data types without requiring a redesign 762 * of the flow controls. 763 */ 764 static int 765 guc_capture_log_remove_dw(struct intel_guc *guc, struct __guc_capture_bufstate *buf, 766 u32 *dw) 767 { 768 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 769 int tries = 2; 770 int avail = 0; 771 u32 *src_data; 772 773 if (!guc_capture_buf_cnt(buf)) 774 return 0; 775 776 while (tries--) { 777 avail = guc_capture_buf_cnt_to_end(buf); 778 if (avail >= sizeof(u32)) { 779 src_data = (u32 *)(buf->data + buf->rd); 780 *dw = *src_data; 781 buf->rd += 4; 782 return 4; 783 } 784 if (avail) 785 drm_dbg(&i915->drm, "GuC-Cap-Logs not dword aligned, skipping.\n"); 786 buf->rd = 0; 787 } 788 789 return 0; 790 } 791 792 static bool 793 guc_capture_data_extracted(struct __guc_capture_bufstate *b, 794 int size, void *dest) 795 { 796 if (guc_capture_buf_cnt_to_end(b) >= size) { 797 memcpy(dest, (b->data + b->rd), size); 798 b->rd += size; 799 return true; 800 } 801 return false; 802 } 803 804 static int 805 guc_capture_log_get_group_hdr(struct intel_guc *guc, struct __guc_capture_bufstate *buf, 806 struct guc_state_capture_group_header_t *ghdr) 807 { 808 int read = 0; 809 int fullsize = sizeof(struct guc_state_capture_group_header_t); 810 811 if (fullsize > guc_capture_buf_cnt(buf)) 812 return -1; 813 814 if (guc_capture_data_extracted(buf, fullsize, (void *)ghdr)) 815 return 0; 816 817 read += guc_capture_log_remove_dw(guc, buf, &ghdr->owner); 818 read += guc_capture_log_remove_dw(guc, buf, &ghdr->info); 819 if (read != fullsize) 820 return -1; 821 822 return 0; 823 } 824 825 static int 826 guc_capture_log_get_data_hdr(struct intel_guc *guc, struct __guc_capture_bufstate *buf, 827 struct guc_state_capture_header_t *hdr) 828 { 829 int read = 0; 830 int fullsize = sizeof(struct guc_state_capture_header_t); 831 832 if (fullsize > guc_capture_buf_cnt(buf)) 833 return -1; 834 835 if (guc_capture_data_extracted(buf, fullsize, (void *)hdr)) 836 return 0; 837 838 read += guc_capture_log_remove_dw(guc, buf, &hdr->owner); 839 read += guc_capture_log_remove_dw(guc, buf, &hdr->info); 840 read += guc_capture_log_remove_dw(guc, buf, &hdr->lrca); 841 read += guc_capture_log_remove_dw(guc, buf, &hdr->guc_id); 842 read += guc_capture_log_remove_dw(guc, buf, &hdr->num_mmios); 843 if (read != fullsize) 844 return -1; 845 846 return 0; 847 } 848 849 static int 850 guc_capture_log_get_register(struct intel_guc *guc, struct __guc_capture_bufstate *buf, 851 struct guc_mmio_reg *reg) 852 { 853 int read = 0; 854 int fullsize = sizeof(struct guc_mmio_reg); 855 856 if (fullsize > guc_capture_buf_cnt(buf)) 857 return -1; 858 859 if (guc_capture_data_extracted(buf, fullsize, (void *)reg)) 860 return 0; 861 862 read += guc_capture_log_remove_dw(guc, buf, ®->offset); 863 read += guc_capture_log_remove_dw(guc, buf, ®->value); 864 read += guc_capture_log_remove_dw(guc, buf, ®->flags); 865 read += guc_capture_log_remove_dw(guc, buf, ®->mask); 866 if (read != fullsize) 867 return -1; 868 869 return 0; 870 } 871 872 static void 873 guc_capture_delete_one_node(struct intel_guc *guc, struct __guc_capture_parsed_output *node) 874 { 875 int i; 876 877 for (i = 0; i < GUC_CAPTURE_LIST_TYPE_MAX; ++i) 878 kfree(node->reginfo[i].regs); 879 list_del(&node->link); 880 kfree(node); 881 } 882 883 static void 884 guc_capture_delete_prealloc_nodes(struct intel_guc *guc) 885 { 886 struct __guc_capture_parsed_output *n, *ntmp; 887 888 /* 889 * NOTE: At the end of driver operation, we must assume that we 890 * have prealloc nodes in both the cachelist as well as outlist 891 * if unclaimed error capture events occurred prior to shutdown. 892 */ 893 list_for_each_entry_safe(n, ntmp, &guc->capture->outlist, link) 894 guc_capture_delete_one_node(guc, n); 895 896 list_for_each_entry_safe(n, ntmp, &guc->capture->cachelist, link) 897 guc_capture_delete_one_node(guc, n); 898 } 899 900 static void 901 guc_capture_add_node_to_list(struct __guc_capture_parsed_output *node, 902 struct list_head *list) 903 { 904 list_add_tail(&node->link, list); 905 } 906 907 static void 908 guc_capture_add_node_to_outlist(struct intel_guc_state_capture *gc, 909 struct __guc_capture_parsed_output *node) 910 { 911 guc_capture_add_node_to_list(node, &gc->outlist); 912 } 913 914 static void 915 guc_capture_add_node_to_cachelist(struct intel_guc_state_capture *gc, 916 struct __guc_capture_parsed_output *node) 917 { 918 guc_capture_add_node_to_list(node, &gc->cachelist); 919 } 920 921 static void 922 guc_capture_init_node(struct intel_guc *guc, struct __guc_capture_parsed_output *node) 923 { 924 struct guc_mmio_reg *tmp[GUC_CAPTURE_LIST_TYPE_MAX]; 925 int i; 926 927 for (i = 0; i < GUC_CAPTURE_LIST_TYPE_MAX; ++i) { 928 tmp[i] = node->reginfo[i].regs; 929 memset(tmp[i], 0, sizeof(struct guc_mmio_reg) * 930 guc->capture->max_mmio_per_node); 931 } 932 memset(node, 0, sizeof(*node)); 933 for (i = 0; i < GUC_CAPTURE_LIST_TYPE_MAX; ++i) 934 node->reginfo[i].regs = tmp[i]; 935 936 INIT_LIST_HEAD(&node->link); 937 } 938 939 static struct __guc_capture_parsed_output * 940 guc_capture_get_prealloc_node(struct intel_guc *guc) 941 { 942 struct __guc_capture_parsed_output *found = NULL; 943 944 if (!list_empty(&guc->capture->cachelist)) { 945 struct __guc_capture_parsed_output *n, *ntmp; 946 947 /* get first avail node from the cache list */ 948 list_for_each_entry_safe(n, ntmp, &guc->capture->cachelist, link) { 949 found = n; 950 list_del(&n->link); 951 break; 952 } 953 } else { 954 struct __guc_capture_parsed_output *n, *ntmp; 955 956 /* traverse down and steal back the oldest node already allocated */ 957 list_for_each_entry_safe(n, ntmp, &guc->capture->outlist, link) { 958 found = n; 959 } 960 if (found) 961 list_del(&found->link); 962 } 963 if (found) 964 guc_capture_init_node(guc, found); 965 966 return found; 967 } 968 969 static struct __guc_capture_parsed_output * 970 guc_capture_alloc_one_node(struct intel_guc *guc) 971 { 972 struct __guc_capture_parsed_output *new; 973 int i; 974 975 new = kzalloc(sizeof(*new), GFP_KERNEL); 976 if (!new) 977 return NULL; 978 979 for (i = 0; i < GUC_CAPTURE_LIST_TYPE_MAX; ++i) { 980 new->reginfo[i].regs = kcalloc(guc->capture->max_mmio_per_node, 981 sizeof(struct guc_mmio_reg), GFP_KERNEL); 982 if (!new->reginfo[i].regs) { 983 while (i) 984 kfree(new->reginfo[--i].regs); 985 kfree(new); 986 return NULL; 987 } 988 } 989 guc_capture_init_node(guc, new); 990 991 return new; 992 } 993 994 static struct __guc_capture_parsed_output * 995 guc_capture_clone_node(struct intel_guc *guc, struct __guc_capture_parsed_output *original, 996 u32 keep_reglist_mask) 997 { 998 struct __guc_capture_parsed_output *new; 999 int i; 1000 1001 new = guc_capture_get_prealloc_node(guc); 1002 if (!new) 1003 return NULL; 1004 if (!original) 1005 return new; 1006 1007 new->is_partial = original->is_partial; 1008 1009 /* copy reg-lists that we want to clone */ 1010 for (i = 0; i < GUC_CAPTURE_LIST_TYPE_MAX; ++i) { 1011 if (keep_reglist_mask & BIT(i)) { 1012 GEM_BUG_ON(original->reginfo[i].num_regs > 1013 guc->capture->max_mmio_per_node); 1014 1015 memcpy(new->reginfo[i].regs, original->reginfo[i].regs, 1016 original->reginfo[i].num_regs * sizeof(struct guc_mmio_reg)); 1017 1018 new->reginfo[i].num_regs = original->reginfo[i].num_regs; 1019 new->reginfo[i].vfid = original->reginfo[i].vfid; 1020 1021 if (i == GUC_CAPTURE_LIST_TYPE_ENGINE_CLASS) { 1022 new->eng_class = original->eng_class; 1023 } else if (i == GUC_CAPTURE_LIST_TYPE_ENGINE_INSTANCE) { 1024 new->eng_inst = original->eng_inst; 1025 new->guc_id = original->guc_id; 1026 new->lrca = original->lrca; 1027 } 1028 } 1029 } 1030 1031 return new; 1032 } 1033 1034 static void 1035 __guc_capture_create_prealloc_nodes(struct intel_guc *guc) 1036 { 1037 struct __guc_capture_parsed_output *node = NULL; 1038 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 1039 int i; 1040 1041 for (i = 0; i < PREALLOC_NODES_MAX_COUNT; ++i) { 1042 node = guc_capture_alloc_one_node(guc); 1043 if (!node) { 1044 drm_warn(&i915->drm, "GuC Capture pre-alloc-cache failure\n"); 1045 /* dont free the priors, use what we got and cleanup at shutdown */ 1046 return; 1047 } 1048 guc_capture_add_node_to_cachelist(guc->capture, node); 1049 } 1050 } 1051 1052 static int 1053 guc_get_max_reglist_count(struct intel_guc *guc) 1054 { 1055 int i, j, k, tmp, maxregcount = 0; 1056 1057 for (i = 0; i < GUC_CAPTURE_LIST_INDEX_MAX; ++i) { 1058 for (j = 0; j < GUC_CAPTURE_LIST_TYPE_MAX; ++j) { 1059 for (k = 0; k < GUC_MAX_ENGINE_CLASSES; ++k) { 1060 if (j == GUC_CAPTURE_LIST_TYPE_GLOBAL && k > 0) 1061 continue; 1062 1063 tmp = guc_cap_list_num_regs(guc->capture, i, j, k); 1064 if (tmp > maxregcount) 1065 maxregcount = tmp; 1066 } 1067 } 1068 } 1069 if (!maxregcount) 1070 maxregcount = PREALLOC_NODES_DEFAULT_NUMREGS; 1071 1072 return maxregcount; 1073 } 1074 1075 static void 1076 guc_capture_create_prealloc_nodes(struct intel_guc *guc) 1077 { 1078 /* skip if we've already done the pre-alloc */ 1079 if (guc->capture->max_mmio_per_node) 1080 return; 1081 1082 guc->capture->max_mmio_per_node = guc_get_max_reglist_count(guc); 1083 __guc_capture_create_prealloc_nodes(guc); 1084 } 1085 1086 static int 1087 guc_capture_extract_reglists(struct intel_guc *guc, struct __guc_capture_bufstate *buf) 1088 { 1089 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 1090 struct guc_state_capture_group_header_t ghdr = {0}; 1091 struct guc_state_capture_header_t hdr = {0}; 1092 struct __guc_capture_parsed_output *node = NULL; 1093 struct guc_mmio_reg *regs = NULL; 1094 int i, numlists, numregs, ret = 0; 1095 enum guc_capture_type datatype; 1096 struct guc_mmio_reg tmp; 1097 bool is_partial = false; 1098 1099 i = guc_capture_buf_cnt(buf); 1100 if (!i) 1101 return -ENODATA; 1102 if (i % sizeof(u32)) { 1103 drm_warn(&i915->drm, "GuC Capture new entries unaligned\n"); 1104 ret = -EIO; 1105 goto bailout; 1106 } 1107 1108 /* first get the capture group header */ 1109 if (guc_capture_log_get_group_hdr(guc, buf, &ghdr)) { 1110 ret = -EIO; 1111 goto bailout; 1112 } 1113 /* 1114 * we would typically expect a layout as below where n would be expected to be 1115 * anywhere between 3 to n where n > 3 if we are seeing multiple dependent engine 1116 * instances being reset together. 1117 * ____________________________________________ 1118 * | Capture Group | 1119 * | ________________________________________ | 1120 * | | Capture Group Header: | | 1121 * | | - num_captures = 5 | | 1122 * | |______________________________________| | 1123 * | ________________________________________ | 1124 * | | Capture1: | | 1125 * | | Hdr: GLOBAL, numregs=a | | 1126 * | | ____________________________________ | | 1127 * | | | Reglist | | | 1128 * | | | - reg1, reg2, ... rega | | | 1129 * | | |__________________________________| | | 1130 * | |______________________________________| | 1131 * | ________________________________________ | 1132 * | | Capture2: | | 1133 * | | Hdr: CLASS=RENDER/COMPUTE, numregs=b| | 1134 * | | ____________________________________ | | 1135 * | | | Reglist | | | 1136 * | | | - reg1, reg2, ... regb | | | 1137 * | | |__________________________________| | | 1138 * | |______________________________________| | 1139 * | ________________________________________ | 1140 * | | Capture3: | | 1141 * | | Hdr: INSTANCE=RCS, numregs=c | | 1142 * | | ____________________________________ | | 1143 * | | | Reglist | | | 1144 * | | | - reg1, reg2, ... regc | | | 1145 * | | |__________________________________| | | 1146 * | |______________________________________| | 1147 * | ________________________________________ | 1148 * | | Capture4: | | 1149 * | | Hdr: CLASS=RENDER/COMPUTE, numregs=d| | 1150 * | | ____________________________________ | | 1151 * | | | Reglist | | | 1152 * | | | - reg1, reg2, ... regd | | | 1153 * | | |__________________________________| | | 1154 * | |______________________________________| | 1155 * | ________________________________________ | 1156 * | | Capture5: | | 1157 * | | Hdr: INSTANCE=CCS0, numregs=e | | 1158 * | | ____________________________________ | | 1159 * | | | Reglist | | | 1160 * | | | - reg1, reg2, ... rege | | | 1161 * | | |__________________________________| | | 1162 * | |______________________________________| | 1163 * |__________________________________________| 1164 */ 1165 is_partial = FIELD_GET(CAP_GRP_HDR_CAPTURE_TYPE, ghdr.info); 1166 numlists = FIELD_GET(CAP_GRP_HDR_NUM_CAPTURES, ghdr.info); 1167 1168 while (numlists--) { 1169 if (guc_capture_log_get_data_hdr(guc, buf, &hdr)) { 1170 ret = -EIO; 1171 break; 1172 } 1173 1174 datatype = FIELD_GET(CAP_HDR_CAPTURE_TYPE, hdr.info); 1175 if (datatype > GUC_CAPTURE_LIST_TYPE_ENGINE_INSTANCE) { 1176 /* unknown capture type - skip over to next capture set */ 1177 numregs = FIELD_GET(CAP_HDR_NUM_MMIOS, hdr.num_mmios); 1178 while (numregs--) { 1179 if (guc_capture_log_get_register(guc, buf, &tmp)) { 1180 ret = -EIO; 1181 break; 1182 } 1183 } 1184 continue; 1185 } else if (node) { 1186 /* 1187 * Based on the current capture type and what we have so far, 1188 * decide if we should add the current node into the internal 1189 * linked list for match-up when i915_gpu_coredump calls later 1190 * (and alloc a blank node for the next set of reglists) 1191 * or continue with the same node or clone the current node 1192 * but only retain the global or class registers (such as the 1193 * case of dependent engine resets). 1194 */ 1195 if (datatype == GUC_CAPTURE_LIST_TYPE_GLOBAL) { 1196 guc_capture_add_node_to_outlist(guc->capture, node); 1197 node = NULL; 1198 } else if (datatype == GUC_CAPTURE_LIST_TYPE_ENGINE_CLASS && 1199 node->reginfo[GUC_CAPTURE_LIST_TYPE_ENGINE_CLASS].num_regs) { 1200 /* Add to list, clone node and duplicate global list */ 1201 guc_capture_add_node_to_outlist(guc->capture, node); 1202 node = guc_capture_clone_node(guc, node, 1203 GCAP_PARSED_REGLIST_INDEX_GLOBAL); 1204 } else if (datatype == GUC_CAPTURE_LIST_TYPE_ENGINE_INSTANCE && 1205 node->reginfo[GUC_CAPTURE_LIST_TYPE_ENGINE_INSTANCE].num_regs) { 1206 /* Add to list, clone node and duplicate global + class lists */ 1207 guc_capture_add_node_to_outlist(guc->capture, node); 1208 node = guc_capture_clone_node(guc, node, 1209 (GCAP_PARSED_REGLIST_INDEX_GLOBAL | 1210 GCAP_PARSED_REGLIST_INDEX_ENGCLASS)); 1211 } 1212 } 1213 1214 if (!node) { 1215 node = guc_capture_get_prealloc_node(guc); 1216 if (!node) { 1217 ret = -ENOMEM; 1218 break; 1219 } 1220 if (datatype != GUC_CAPTURE_LIST_TYPE_GLOBAL) 1221 drm_dbg(&i915->drm, "GuC Capture missing global dump: %08x!\n", 1222 datatype); 1223 } 1224 node->is_partial = is_partial; 1225 node->reginfo[datatype].vfid = FIELD_GET(CAP_HDR_CAPTURE_VFID, hdr.owner); 1226 switch (datatype) { 1227 case GUC_CAPTURE_LIST_TYPE_ENGINE_INSTANCE: 1228 node->eng_class = FIELD_GET(CAP_HDR_ENGINE_CLASS, hdr.info); 1229 node->eng_inst = FIELD_GET(CAP_HDR_ENGINE_INSTANCE, hdr.info); 1230 node->lrca = hdr.lrca; 1231 node->guc_id = hdr.guc_id; 1232 break; 1233 case GUC_CAPTURE_LIST_TYPE_ENGINE_CLASS: 1234 node->eng_class = FIELD_GET(CAP_HDR_ENGINE_CLASS, hdr.info); 1235 break; 1236 default: 1237 break; 1238 } 1239 1240 numregs = FIELD_GET(CAP_HDR_NUM_MMIOS, hdr.num_mmios); 1241 if (numregs > guc->capture->max_mmio_per_node) { 1242 drm_dbg(&i915->drm, "GuC Capture list extraction clipped by prealloc!\n"); 1243 numregs = guc->capture->max_mmio_per_node; 1244 } 1245 node->reginfo[datatype].num_regs = numregs; 1246 regs = node->reginfo[datatype].regs; 1247 i = 0; 1248 while (numregs--) { 1249 if (guc_capture_log_get_register(guc, buf, ®s[i++])) { 1250 ret = -EIO; 1251 break; 1252 } 1253 } 1254 } 1255 1256 bailout: 1257 if (node) { 1258 /* If we have data, add to linked list for match-up when i915_gpu_coredump calls */ 1259 for (i = GUC_CAPTURE_LIST_TYPE_GLOBAL; i < GUC_CAPTURE_LIST_TYPE_MAX; ++i) { 1260 if (node->reginfo[i].regs) { 1261 guc_capture_add_node_to_outlist(guc->capture, node); 1262 node = NULL; 1263 break; 1264 } 1265 } 1266 if (node) /* else return it back to cache list */ 1267 guc_capture_add_node_to_cachelist(guc->capture, node); 1268 } 1269 return ret; 1270 } 1271 1272 static int __guc_capture_flushlog_complete(struct intel_guc *guc) 1273 { 1274 u32 action[] = { 1275 INTEL_GUC_ACTION_LOG_BUFFER_FILE_FLUSH_COMPLETE, 1276 GUC_CAPTURE_LOG_BUFFER 1277 }; 1278 1279 return intel_guc_send_nb(guc, action, ARRAY_SIZE(action), 0); 1280 1281 } 1282 1283 static void __guc_capture_process_output(struct intel_guc *guc) 1284 { 1285 unsigned int buffer_size, read_offset, write_offset, full_count; 1286 struct intel_uc *uc = container_of(guc, typeof(*uc), guc); 1287 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 1288 struct guc_log_buffer_state log_buf_state_local; 1289 struct guc_log_buffer_state *log_buf_state; 1290 struct __guc_capture_bufstate buf; 1291 void *src_data = NULL; 1292 bool new_overflow; 1293 int ret; 1294 1295 log_buf_state = guc->log.buf_addr + 1296 (sizeof(struct guc_log_buffer_state) * GUC_CAPTURE_LOG_BUFFER); 1297 src_data = guc->log.buf_addr + intel_guc_get_log_buffer_offset(GUC_CAPTURE_LOG_BUFFER); 1298 1299 /* 1300 * Make a copy of the state structure, inside GuC log buffer 1301 * (which is uncached mapped), on the stack to avoid reading 1302 * from it multiple times. 1303 */ 1304 memcpy(&log_buf_state_local, log_buf_state, sizeof(struct guc_log_buffer_state)); 1305 buffer_size = intel_guc_get_log_buffer_size(GUC_CAPTURE_LOG_BUFFER); 1306 read_offset = log_buf_state_local.read_ptr; 1307 write_offset = log_buf_state_local.sampled_write_ptr; 1308 full_count = log_buf_state_local.buffer_full_cnt; 1309 1310 /* Bookkeeping stuff */ 1311 guc->log.stats[GUC_CAPTURE_LOG_BUFFER].flush += log_buf_state_local.flush_to_file; 1312 new_overflow = intel_guc_check_log_buf_overflow(&guc->log, GUC_CAPTURE_LOG_BUFFER, 1313 full_count); 1314 1315 /* Now copy the actual logs. */ 1316 if (unlikely(new_overflow)) { 1317 /* copy the whole buffer in case of overflow */ 1318 read_offset = 0; 1319 write_offset = buffer_size; 1320 } else if (unlikely((read_offset > buffer_size) || 1321 (write_offset > buffer_size))) { 1322 drm_err(&i915->drm, "invalid GuC log capture buffer state!\n"); 1323 /* copy whole buffer as offsets are unreliable */ 1324 read_offset = 0; 1325 write_offset = buffer_size; 1326 } 1327 1328 buf.size = buffer_size; 1329 buf.rd = read_offset; 1330 buf.wr = write_offset; 1331 buf.data = src_data; 1332 1333 if (!uc->reset_in_progress) { 1334 do { 1335 ret = guc_capture_extract_reglists(guc, &buf); 1336 } while (ret >= 0); 1337 } 1338 1339 /* Update the state of log buffer err-cap state */ 1340 log_buf_state->read_ptr = write_offset; 1341 log_buf_state->flush_to_file = 0; 1342 __guc_capture_flushlog_complete(guc); 1343 } 1344 1345 #if IS_ENABLED(CONFIG_DRM_I915_CAPTURE_ERROR) 1346 1347 static const char * 1348 guc_capture_reg_to_str(const struct intel_guc *guc, u32 owner, u32 type, 1349 u32 class, u32 id, u32 offset, u32 *is_ext) 1350 { 1351 const struct __guc_mmio_reg_descr_group *reglists = guc->capture->reglists; 1352 struct __guc_mmio_reg_descr_group *extlists = guc->capture->extlists; 1353 const struct __guc_mmio_reg_descr_group *match; 1354 struct __guc_mmio_reg_descr_group *matchext; 1355 int j; 1356 1357 *is_ext = 0; 1358 if (!reglists) 1359 return NULL; 1360 1361 match = guc_capture_get_one_list(reglists, owner, type, id); 1362 if (!match) 1363 return NULL; 1364 1365 for (j = 0; j < match->num_regs; ++j) { 1366 if (offset == match->list[j].reg.reg) 1367 return match->list[j].regname; 1368 } 1369 if (extlists) { 1370 matchext = guc_capture_get_one_ext_list(extlists, owner, type, id); 1371 if (!matchext) 1372 return NULL; 1373 for (j = 0; j < matchext->num_regs; ++j) { 1374 if (offset == matchext->extlist[j].reg.reg) { 1375 *is_ext = 1; 1376 return matchext->extlist[j].regname; 1377 } 1378 } 1379 } 1380 1381 return NULL; 1382 } 1383 1384 #ifdef CONFIG_DRM_I915_DEBUG_GUC 1385 #define __out(a, ...) \ 1386 do { \ 1387 drm_warn((&(a)->i915->drm), __VA_ARGS__); \ 1388 i915_error_printf((a), __VA_ARGS__); \ 1389 } while (0) 1390 #else 1391 #define __out(a, ...) \ 1392 i915_error_printf(a, __VA_ARGS__) 1393 #endif 1394 1395 #define GCAP_PRINT_INTEL_ENG_INFO(ebuf, eng) \ 1396 do { \ 1397 __out(ebuf, " i915-Eng-Name: %s command stream\n", \ 1398 (eng)->name); \ 1399 __out(ebuf, " i915-Eng-Inst-Class: 0x%02x\n", (eng)->class); \ 1400 __out(ebuf, " i915-Eng-Inst-Id: 0x%02x\n", (eng)->instance); \ 1401 __out(ebuf, " i915-Eng-LogicalMask: 0x%08x\n", \ 1402 (eng)->logical_mask); \ 1403 } while (0) 1404 1405 #define GCAP_PRINT_GUC_INST_INFO(ebuf, node) \ 1406 do { \ 1407 __out(ebuf, " GuC-Engine-Inst-Id: 0x%08x\n", \ 1408 (node)->eng_inst); \ 1409 __out(ebuf, " GuC-Context-Id: 0x%08x\n", (node)->guc_id); \ 1410 __out(ebuf, " LRCA: 0x%08x\n", (node)->lrca); \ 1411 } while (0) 1412 1413 int intel_guc_capture_print_engine_node(struct drm_i915_error_state_buf *ebuf, 1414 const struct intel_engine_coredump *ee) 1415 { 1416 const char *grptype[GUC_STATE_CAPTURE_GROUP_TYPE_MAX] = { 1417 "full-capture", 1418 "partial-capture" 1419 }; 1420 const char *datatype[GUC_CAPTURE_LIST_TYPE_MAX] = { 1421 "Global", 1422 "Engine-Class", 1423 "Engine-Instance" 1424 }; 1425 struct intel_guc_state_capture *cap; 1426 struct __guc_capture_parsed_output *node; 1427 struct intel_engine_cs *eng; 1428 struct guc_mmio_reg *regs; 1429 struct intel_guc *guc; 1430 const char *str; 1431 int numregs, i, j; 1432 u32 is_ext; 1433 1434 if (!ebuf || !ee) 1435 return -EINVAL; 1436 cap = ee->capture; 1437 if (!cap || !ee->engine) 1438 return -ENODEV; 1439 1440 guc = &ee->engine->gt->uc.guc; 1441 1442 __out(ebuf, "global --- GuC Error Capture on %s command stream:\n", 1443 ee->engine->name); 1444 1445 node = ee->guc_capture_node; 1446 if (!node) { 1447 __out(ebuf, " No matching ee-node\n"); 1448 return 0; 1449 } 1450 1451 __out(ebuf, "Coverage: %s\n", grptype[node->is_partial]); 1452 1453 for (i = GUC_CAPTURE_LIST_TYPE_GLOBAL; i < GUC_CAPTURE_LIST_TYPE_MAX; ++i) { 1454 __out(ebuf, " RegListType: %s\n", 1455 datatype[i % GUC_CAPTURE_LIST_TYPE_MAX]); 1456 __out(ebuf, " Owner-Id: %d\n", node->reginfo[i].vfid); 1457 1458 switch (i) { 1459 case GUC_CAPTURE_LIST_TYPE_GLOBAL: 1460 default: 1461 break; 1462 case GUC_CAPTURE_LIST_TYPE_ENGINE_CLASS: 1463 __out(ebuf, " GuC-Eng-Class: %d\n", node->eng_class); 1464 __out(ebuf, " i915-Eng-Class: %d\n", 1465 guc_class_to_engine_class(node->eng_class)); 1466 break; 1467 case GUC_CAPTURE_LIST_TYPE_ENGINE_INSTANCE: 1468 eng = intel_guc_lookup_engine(guc, node->eng_class, node->eng_inst); 1469 if (eng) 1470 GCAP_PRINT_INTEL_ENG_INFO(ebuf, eng); 1471 else 1472 __out(ebuf, " i915-Eng-Lookup Fail!\n"); 1473 GCAP_PRINT_GUC_INST_INFO(ebuf, node); 1474 break; 1475 } 1476 1477 numregs = node->reginfo[i].num_regs; 1478 __out(ebuf, " NumRegs: %d\n", numregs); 1479 j = 0; 1480 while (numregs--) { 1481 regs = node->reginfo[i].regs; 1482 str = guc_capture_reg_to_str(guc, GUC_CAPTURE_LIST_INDEX_PF, i, 1483 node->eng_class, 0, regs[j].offset, &is_ext); 1484 if (!str) 1485 __out(ebuf, " REG-0x%08x", regs[j].offset); 1486 else 1487 __out(ebuf, " %s", str); 1488 if (is_ext) 1489 __out(ebuf, "[%ld][%ld]", 1490 FIELD_GET(GUC_REGSET_STEERING_GROUP, regs[j].flags), 1491 FIELD_GET(GUC_REGSET_STEERING_INSTANCE, regs[j].flags)); 1492 __out(ebuf, ": 0x%08x\n", regs[j].value); 1493 ++j; 1494 } 1495 } 1496 return 0; 1497 } 1498 1499 #endif //CONFIG_DRM_I915_CAPTURE_ERROR 1500 1501 void intel_guc_capture_free_node(struct intel_engine_coredump *ee) 1502 { 1503 if (!ee || !ee->guc_capture_node) 1504 return; 1505 1506 guc_capture_add_node_to_cachelist(ee->capture, ee->guc_capture_node); 1507 ee->capture = NULL; 1508 ee->guc_capture_node = NULL; 1509 } 1510 1511 void intel_guc_capture_get_matching_node(struct intel_gt *gt, 1512 struct intel_engine_coredump *ee, 1513 struct intel_context *ce) 1514 { 1515 struct __guc_capture_parsed_output *n, *ntmp; 1516 struct drm_i915_private *i915; 1517 struct intel_guc *guc; 1518 1519 if (!gt || !ee || !ce) 1520 return; 1521 1522 i915 = gt->i915; 1523 guc = >->uc.guc; 1524 if (!guc->capture) 1525 return; 1526 1527 GEM_BUG_ON(ee->guc_capture_node); 1528 /* 1529 * Look for a matching GuC reported error capture node from 1530 * the internal output link-list based on lrca, guc-id and engine 1531 * identification. 1532 */ 1533 list_for_each_entry_safe(n, ntmp, &guc->capture->outlist, link) { 1534 if (n->eng_inst == GUC_ID_TO_ENGINE_INSTANCE(ee->engine->guc_id) && 1535 n->eng_class == GUC_ID_TO_ENGINE_CLASS(ee->engine->guc_id) && 1536 n->guc_id && n->guc_id == ce->guc_id.id && 1537 (n->lrca & CTX_GTT_ADDRESS_MASK) && (n->lrca & CTX_GTT_ADDRESS_MASK) == 1538 (ce->lrc.lrca & CTX_GTT_ADDRESS_MASK)) { 1539 list_del(&n->link); 1540 ee->guc_capture_node = n; 1541 ee->capture = guc->capture; 1542 return; 1543 } 1544 } 1545 drm_dbg(&i915->drm, "GuC capture can't match ee to node\n"); 1546 } 1547 1548 void intel_guc_capture_process(struct intel_guc *guc) 1549 { 1550 if (guc->capture) 1551 __guc_capture_process_output(guc); 1552 } 1553 1554 static void 1555 guc_capture_free_ads_cache(struct intel_guc_state_capture *gc) 1556 { 1557 int i, j, k; 1558 struct __guc_capture_ads_cache *cache; 1559 1560 for (i = 0; i < GUC_CAPTURE_LIST_INDEX_MAX; ++i) { 1561 for (j = 0; j < GUC_CAPTURE_LIST_TYPE_MAX; ++j) { 1562 for (k = 0; k < GUC_MAX_ENGINE_CLASSES; ++k) { 1563 cache = &gc->ads_cache[i][j][k]; 1564 if (cache->is_valid) 1565 kfree(cache->ptr); 1566 } 1567 } 1568 } 1569 kfree(gc->ads_null_cache); 1570 } 1571 1572 void intel_guc_capture_destroy(struct intel_guc *guc) 1573 { 1574 if (!guc->capture) 1575 return; 1576 1577 guc_capture_free_ads_cache(guc->capture); 1578 1579 guc_capture_delete_prealloc_nodes(guc); 1580 1581 guc_capture_free_extlists(guc->capture->extlists); 1582 kfree(guc->capture->extlists); 1583 1584 kfree(guc->capture); 1585 guc->capture = NULL; 1586 } 1587 1588 int intel_guc_capture_init(struct intel_guc *guc) 1589 { 1590 guc->capture = kzalloc(sizeof(*guc->capture), GFP_KERNEL); 1591 if (!guc->capture) 1592 return -ENOMEM; 1593 1594 guc->capture->reglists = guc_capture_get_device_reglist(guc); 1595 1596 INIT_LIST_HEAD(&guc->capture->outlist); 1597 INIT_LIST_HEAD(&guc->capture->cachelist); 1598 1599 check_guc_capture_size(guc); 1600 1601 return 0; 1602 } 1603