1 // SPDX-License-Identifier: MIT 2 /* 3 * Copyright © 2019 Intel Corporation 4 */ 5 6 #include <linux/string_helpers.h> 7 8 #include "i915_drv.h" 9 #include "intel_engine_regs.h" 10 #include "intel_gt_regs.h" 11 #include "intel_sseu.h" 12 13 void intel_sseu_set_info(struct sseu_dev_info *sseu, u8 max_slices, 14 u8 max_subslices, u8 max_eus_per_subslice) 15 { 16 sseu->max_slices = max_slices; 17 sseu->max_subslices = max_subslices; 18 sseu->max_eus_per_subslice = max_eus_per_subslice; 19 } 20 21 unsigned int 22 intel_sseu_subslice_total(const struct sseu_dev_info *sseu) 23 { 24 unsigned int i, total = 0; 25 26 if (sseu->has_xehp_dss) 27 return bitmap_weight(sseu->subslice_mask.xehp, 28 XEHP_BITMAP_BITS(sseu->subslice_mask)); 29 30 for (i = 0; i < ARRAY_SIZE(sseu->subslice_mask.hsw); i++) 31 total += hweight8(sseu->subslice_mask.hsw[i]); 32 33 return total; 34 } 35 36 unsigned int 37 intel_sseu_get_hsw_subslices(const struct sseu_dev_info *sseu, u8 slice) 38 { 39 WARN_ON(sseu->has_xehp_dss); 40 if (WARN_ON(slice >= sseu->max_slices)) 41 return 0; 42 43 return sseu->subslice_mask.hsw[slice]; 44 } 45 46 static u16 sseu_get_eus(const struct sseu_dev_info *sseu, int slice, 47 int subslice) 48 { 49 if (sseu->has_xehp_dss) { 50 WARN_ON(slice > 0); 51 return sseu->eu_mask.xehp[subslice]; 52 } else { 53 return sseu->eu_mask.hsw[slice][subslice]; 54 } 55 } 56 57 static void sseu_set_eus(struct sseu_dev_info *sseu, int slice, int subslice, 58 u16 eu_mask) 59 { 60 GEM_WARN_ON(eu_mask && __fls(eu_mask) >= sseu->max_eus_per_subslice); 61 if (sseu->has_xehp_dss) { 62 GEM_WARN_ON(slice > 0); 63 sseu->eu_mask.xehp[subslice] = eu_mask; 64 } else { 65 sseu->eu_mask.hsw[slice][subslice] = eu_mask; 66 } 67 } 68 69 static u16 compute_eu_total(const struct sseu_dev_info *sseu) 70 { 71 int s, ss, total = 0; 72 73 for (s = 0; s < sseu->max_slices; s++) 74 for (ss = 0; ss < sseu->max_subslices; ss++) 75 if (sseu->has_xehp_dss) 76 total += hweight16(sseu->eu_mask.xehp[ss]); 77 else 78 total += hweight16(sseu->eu_mask.hsw[s][ss]); 79 80 return total; 81 } 82 83 /** 84 * intel_sseu_copy_eumask_to_user - Copy EU mask into a userspace buffer 85 * @to: Pointer to userspace buffer to copy to 86 * @sseu: SSEU structure containing EU mask to copy 87 * 88 * Copies the EU mask to a userspace buffer in the format expected by 89 * the query ioctl's topology queries. 90 * 91 * Returns the result of the copy_to_user() operation. 92 */ 93 int intel_sseu_copy_eumask_to_user(void __user *to, 94 const struct sseu_dev_info *sseu) 95 { 96 u8 eu_mask[GEN_SS_MASK_SIZE * GEN_MAX_EU_STRIDE] = {}; 97 int eu_stride = GEN_SSEU_STRIDE(sseu->max_eus_per_subslice); 98 int len = sseu->max_slices * sseu->max_subslices * eu_stride; 99 int s, ss, i; 100 101 for (s = 0; s < sseu->max_slices; s++) { 102 for (ss = 0; ss < sseu->max_subslices; ss++) { 103 int uapi_offset = 104 s * sseu->max_subslices * eu_stride + 105 ss * eu_stride; 106 u16 mask = sseu_get_eus(sseu, s, ss); 107 108 for (i = 0; i < eu_stride; i++) 109 eu_mask[uapi_offset + i] = 110 (mask >> (BITS_PER_BYTE * i)) & 0xff; 111 } 112 } 113 114 return copy_to_user(to, eu_mask, len); 115 } 116 117 /** 118 * intel_sseu_copy_ssmask_to_user - Copy subslice mask into a userspace buffer 119 * @to: Pointer to userspace buffer to copy to 120 * @sseu: SSEU structure containing subslice mask to copy 121 * 122 * Copies the subslice mask to a userspace buffer in the format expected by 123 * the query ioctl's topology queries. 124 * 125 * Returns the result of the copy_to_user() operation. 126 */ 127 int intel_sseu_copy_ssmask_to_user(void __user *to, 128 const struct sseu_dev_info *sseu) 129 { 130 u8 ss_mask[GEN_SS_MASK_SIZE] = {}; 131 int ss_stride = GEN_SSEU_STRIDE(sseu->max_subslices); 132 int len = sseu->max_slices * ss_stride; 133 int s, ss, i; 134 135 for (s = 0; s < sseu->max_slices; s++) { 136 for (ss = 0; ss < sseu->max_subslices; ss++) { 137 i = s * ss_stride * BITS_PER_BYTE + ss; 138 139 if (!intel_sseu_has_subslice(sseu, s, ss)) 140 continue; 141 142 ss_mask[i / BITS_PER_BYTE] |= BIT(i % BITS_PER_BYTE); 143 } 144 } 145 146 return copy_to_user(to, ss_mask, len); 147 } 148 149 static void gen11_compute_sseu_info(struct sseu_dev_info *sseu, 150 u32 ss_en, u16 eu_en) 151 { 152 u32 valid_ss_mask = GENMASK(sseu->max_subslices - 1, 0); 153 int ss; 154 155 sseu->slice_mask |= BIT(0); 156 sseu->subslice_mask.hsw[0] = ss_en & valid_ss_mask; 157 158 for (ss = 0; ss < sseu->max_subslices; ss++) 159 if (intel_sseu_has_subslice(sseu, 0, ss)) 160 sseu_set_eus(sseu, 0, ss, eu_en); 161 162 sseu->eu_per_subslice = hweight16(eu_en); 163 sseu->eu_total = compute_eu_total(sseu); 164 } 165 166 static void xehp_compute_sseu_info(struct sseu_dev_info *sseu, 167 u16 eu_en) 168 { 169 int ss; 170 171 sseu->slice_mask |= BIT(0); 172 173 bitmap_or(sseu->subslice_mask.xehp, 174 sseu->compute_subslice_mask.xehp, 175 sseu->geometry_subslice_mask.xehp, 176 XEHP_BITMAP_BITS(sseu->subslice_mask)); 177 178 for (ss = 0; ss < sseu->max_subslices; ss++) 179 if (intel_sseu_has_subslice(sseu, 0, ss)) 180 sseu_set_eus(sseu, 0, ss, eu_en); 181 182 sseu->eu_per_subslice = hweight16(eu_en); 183 sseu->eu_total = compute_eu_total(sseu); 184 } 185 186 static void 187 xehp_load_dss_mask(struct intel_uncore *uncore, 188 intel_sseu_ss_mask_t *ssmask, 189 int numregs, 190 ...) 191 { 192 va_list argp; 193 u32 fuse_val[I915_MAX_SS_FUSE_REGS] = {}; 194 int i; 195 196 if (WARN_ON(numregs > I915_MAX_SS_FUSE_REGS)) 197 numregs = I915_MAX_SS_FUSE_REGS; 198 199 va_start(argp, numregs); 200 for (i = 0; i < numregs; i++) 201 fuse_val[i] = intel_uncore_read(uncore, va_arg(argp, i915_reg_t)); 202 va_end(argp); 203 204 bitmap_from_arr32(ssmask->xehp, fuse_val, numregs * 32); 205 } 206 207 static void xehp_sseu_info_init(struct intel_gt *gt) 208 { 209 struct sseu_dev_info *sseu = >->info.sseu; 210 struct intel_uncore *uncore = gt->uncore; 211 u16 eu_en = 0; 212 u8 eu_en_fuse; 213 int num_compute_regs, num_geometry_regs; 214 int eu; 215 216 if (IS_PONTEVECCHIO(gt->i915)) { 217 num_geometry_regs = 0; 218 num_compute_regs = 2; 219 } else { 220 num_geometry_regs = 1; 221 num_compute_regs = 1; 222 } 223 224 /* 225 * The concept of slice has been removed in Xe_HP. To be compatible 226 * with prior generations, assume a single slice across the entire 227 * device. Then calculate out the DSS for each workload type within 228 * that software slice. 229 */ 230 intel_sseu_set_info(sseu, 1, 231 32 * max(num_geometry_regs, num_compute_regs), 232 HAS_ONE_EU_PER_FUSE_BIT(gt->i915) ? 8 : 16); 233 sseu->has_xehp_dss = 1; 234 235 xehp_load_dss_mask(uncore, &sseu->geometry_subslice_mask, 236 num_geometry_regs, 237 GEN12_GT_GEOMETRY_DSS_ENABLE); 238 xehp_load_dss_mask(uncore, &sseu->compute_subslice_mask, 239 num_compute_regs, 240 GEN12_GT_COMPUTE_DSS_ENABLE, 241 XEHPC_GT_COMPUTE_DSS_ENABLE_EXT); 242 243 eu_en_fuse = intel_uncore_read(uncore, XEHP_EU_ENABLE) & XEHP_EU_ENA_MASK; 244 245 if (HAS_ONE_EU_PER_FUSE_BIT(gt->i915)) 246 eu_en = eu_en_fuse; 247 else 248 for (eu = 0; eu < sseu->max_eus_per_subslice / 2; eu++) 249 if (eu_en_fuse & BIT(eu)) 250 eu_en |= BIT(eu * 2) | BIT(eu * 2 + 1); 251 252 xehp_compute_sseu_info(sseu, eu_en); 253 } 254 255 static void gen12_sseu_info_init(struct intel_gt *gt) 256 { 257 struct sseu_dev_info *sseu = >->info.sseu; 258 struct intel_uncore *uncore = gt->uncore; 259 u32 g_dss_en; 260 u16 eu_en = 0; 261 u8 eu_en_fuse; 262 u8 s_en; 263 int eu; 264 265 /* 266 * Gen12 has Dual-Subslices, which behave similarly to 2 gen11 SS. 267 * Instead of splitting these, provide userspace with an array 268 * of DSS to more closely represent the hardware resource. 269 */ 270 intel_sseu_set_info(sseu, 1, 6, 16); 271 272 /* 273 * Although gen12 architecture supported multiple slices, TGL, RKL, 274 * DG1, and ADL only had a single slice. 275 */ 276 s_en = intel_uncore_read(uncore, GEN11_GT_SLICE_ENABLE) & 277 GEN11_GT_S_ENA_MASK; 278 drm_WARN_ON(>->i915->drm, s_en != 0x1); 279 280 g_dss_en = intel_uncore_read(uncore, GEN12_GT_GEOMETRY_DSS_ENABLE); 281 282 /* one bit per pair of EUs */ 283 eu_en_fuse = ~(intel_uncore_read(uncore, GEN11_EU_DISABLE) & 284 GEN11_EU_DIS_MASK); 285 286 for (eu = 0; eu < sseu->max_eus_per_subslice / 2; eu++) 287 if (eu_en_fuse & BIT(eu)) 288 eu_en |= BIT(eu * 2) | BIT(eu * 2 + 1); 289 290 gen11_compute_sseu_info(sseu, g_dss_en, eu_en); 291 292 /* TGL only supports slice-level power gating */ 293 sseu->has_slice_pg = 1; 294 } 295 296 static void gen11_sseu_info_init(struct intel_gt *gt) 297 { 298 struct sseu_dev_info *sseu = >->info.sseu; 299 struct intel_uncore *uncore = gt->uncore; 300 u32 ss_en; 301 u8 eu_en; 302 u8 s_en; 303 304 if (IS_JSL_EHL(gt->i915)) 305 intel_sseu_set_info(sseu, 1, 4, 8); 306 else 307 intel_sseu_set_info(sseu, 1, 8, 8); 308 309 /* 310 * Although gen11 architecture supported multiple slices, ICL and 311 * EHL/JSL only had a single slice in practice. 312 */ 313 s_en = intel_uncore_read(uncore, GEN11_GT_SLICE_ENABLE) & 314 GEN11_GT_S_ENA_MASK; 315 drm_WARN_ON(>->i915->drm, s_en != 0x1); 316 317 ss_en = ~intel_uncore_read(uncore, GEN11_GT_SUBSLICE_DISABLE); 318 319 eu_en = ~(intel_uncore_read(uncore, GEN11_EU_DISABLE) & 320 GEN11_EU_DIS_MASK); 321 322 gen11_compute_sseu_info(sseu, ss_en, eu_en); 323 324 /* ICL has no power gating restrictions. */ 325 sseu->has_slice_pg = 1; 326 sseu->has_subslice_pg = 1; 327 sseu->has_eu_pg = 1; 328 } 329 330 static void cherryview_sseu_info_init(struct intel_gt *gt) 331 { 332 struct sseu_dev_info *sseu = >->info.sseu; 333 u32 fuse; 334 335 fuse = intel_uncore_read(gt->uncore, CHV_FUSE_GT); 336 337 sseu->slice_mask = BIT(0); 338 intel_sseu_set_info(sseu, 1, 2, 8); 339 340 if (!(fuse & CHV_FGT_DISABLE_SS0)) { 341 u8 disabled_mask = 342 ((fuse & CHV_FGT_EU_DIS_SS0_R0_MASK) >> 343 CHV_FGT_EU_DIS_SS0_R0_SHIFT) | 344 (((fuse & CHV_FGT_EU_DIS_SS0_R1_MASK) >> 345 CHV_FGT_EU_DIS_SS0_R1_SHIFT) << 4); 346 347 sseu->subslice_mask.hsw[0] |= BIT(0); 348 sseu_set_eus(sseu, 0, 0, ~disabled_mask & 0xFF); 349 } 350 351 if (!(fuse & CHV_FGT_DISABLE_SS1)) { 352 u8 disabled_mask = 353 ((fuse & CHV_FGT_EU_DIS_SS1_R0_MASK) >> 354 CHV_FGT_EU_DIS_SS1_R0_SHIFT) | 355 (((fuse & CHV_FGT_EU_DIS_SS1_R1_MASK) >> 356 CHV_FGT_EU_DIS_SS1_R1_SHIFT) << 4); 357 358 sseu->subslice_mask.hsw[0] |= BIT(1); 359 sseu_set_eus(sseu, 0, 1, ~disabled_mask & 0xFF); 360 } 361 362 sseu->eu_total = compute_eu_total(sseu); 363 364 /* 365 * CHV expected to always have a uniform distribution of EU 366 * across subslices. 367 */ 368 sseu->eu_per_subslice = intel_sseu_subslice_total(sseu) ? 369 sseu->eu_total / 370 intel_sseu_subslice_total(sseu) : 371 0; 372 /* 373 * CHV supports subslice power gating on devices with more than 374 * one subslice, and supports EU power gating on devices with 375 * more than one EU pair per subslice. 376 */ 377 sseu->has_slice_pg = 0; 378 sseu->has_subslice_pg = intel_sseu_subslice_total(sseu) > 1; 379 sseu->has_eu_pg = (sseu->eu_per_subslice > 2); 380 } 381 382 static void gen9_sseu_info_init(struct intel_gt *gt) 383 { 384 struct drm_i915_private *i915 = gt->i915; 385 struct intel_device_info *info = mkwrite_device_info(i915); 386 struct sseu_dev_info *sseu = >->info.sseu; 387 struct intel_uncore *uncore = gt->uncore; 388 u32 fuse2, eu_disable, subslice_mask; 389 const u8 eu_mask = 0xff; 390 int s, ss; 391 392 fuse2 = intel_uncore_read(uncore, GEN8_FUSE2); 393 sseu->slice_mask = (fuse2 & GEN8_F2_S_ENA_MASK) >> GEN8_F2_S_ENA_SHIFT; 394 395 /* BXT has a single slice and at most 3 subslices. */ 396 intel_sseu_set_info(sseu, IS_GEN9_LP(i915) ? 1 : 3, 397 IS_GEN9_LP(i915) ? 3 : 4, 8); 398 399 /* 400 * The subslice disable field is global, i.e. it applies 401 * to each of the enabled slices. 402 */ 403 subslice_mask = (1 << sseu->max_subslices) - 1; 404 subslice_mask &= ~((fuse2 & GEN9_F2_SS_DIS_MASK) >> 405 GEN9_F2_SS_DIS_SHIFT); 406 407 /* 408 * Iterate through enabled slices and subslices to 409 * count the total enabled EU. 410 */ 411 for (s = 0; s < sseu->max_slices; s++) { 412 if (!(sseu->slice_mask & BIT(s))) 413 /* skip disabled slice */ 414 continue; 415 416 sseu->subslice_mask.hsw[s] = subslice_mask; 417 418 eu_disable = intel_uncore_read(uncore, GEN9_EU_DISABLE(s)); 419 for (ss = 0; ss < sseu->max_subslices; ss++) { 420 int eu_per_ss; 421 u8 eu_disabled_mask; 422 423 if (!intel_sseu_has_subslice(sseu, s, ss)) 424 /* skip disabled subslice */ 425 continue; 426 427 eu_disabled_mask = (eu_disable >> (ss * 8)) & eu_mask; 428 429 sseu_set_eus(sseu, s, ss, ~eu_disabled_mask & eu_mask); 430 431 eu_per_ss = sseu->max_eus_per_subslice - 432 hweight8(eu_disabled_mask); 433 434 /* 435 * Record which subslice(s) has(have) 7 EUs. we 436 * can tune the hash used to spread work among 437 * subslices if they are unbalanced. 438 */ 439 if (eu_per_ss == 7) 440 sseu->subslice_7eu[s] |= BIT(ss); 441 } 442 } 443 444 sseu->eu_total = compute_eu_total(sseu); 445 446 /* 447 * SKL is expected to always have a uniform distribution 448 * of EU across subslices with the exception that any one 449 * EU in any one subslice may be fused off for die 450 * recovery. BXT is expected to be perfectly uniform in EU 451 * distribution. 452 */ 453 sseu->eu_per_subslice = 454 intel_sseu_subslice_total(sseu) ? 455 DIV_ROUND_UP(sseu->eu_total, intel_sseu_subslice_total(sseu)) : 456 0; 457 458 /* 459 * SKL+ supports slice power gating on devices with more than 460 * one slice, and supports EU power gating on devices with 461 * more than one EU pair per subslice. BXT+ supports subslice 462 * power gating on devices with more than one subslice, and 463 * supports EU power gating on devices with more than one EU 464 * pair per subslice. 465 */ 466 sseu->has_slice_pg = 467 !IS_GEN9_LP(i915) && hweight8(sseu->slice_mask) > 1; 468 sseu->has_subslice_pg = 469 IS_GEN9_LP(i915) && intel_sseu_subslice_total(sseu) > 1; 470 sseu->has_eu_pg = sseu->eu_per_subslice > 2; 471 472 if (IS_GEN9_LP(i915)) { 473 #define IS_SS_DISABLED(ss) (!(sseu->subslice_mask.hsw[0] & BIT(ss))) 474 info->has_pooled_eu = hweight8(sseu->subslice_mask.hsw[0]) == 3; 475 476 sseu->min_eu_in_pool = 0; 477 if (info->has_pooled_eu) { 478 if (IS_SS_DISABLED(2) || IS_SS_DISABLED(0)) 479 sseu->min_eu_in_pool = 3; 480 else if (IS_SS_DISABLED(1)) 481 sseu->min_eu_in_pool = 6; 482 else 483 sseu->min_eu_in_pool = 9; 484 } 485 #undef IS_SS_DISABLED 486 } 487 } 488 489 static void bdw_sseu_info_init(struct intel_gt *gt) 490 { 491 struct sseu_dev_info *sseu = >->info.sseu; 492 struct intel_uncore *uncore = gt->uncore; 493 int s, ss; 494 u32 fuse2, subslice_mask, eu_disable[3]; /* s_max */ 495 u32 eu_disable0, eu_disable1, eu_disable2; 496 497 fuse2 = intel_uncore_read(uncore, GEN8_FUSE2); 498 sseu->slice_mask = (fuse2 & GEN8_F2_S_ENA_MASK) >> GEN8_F2_S_ENA_SHIFT; 499 intel_sseu_set_info(sseu, 3, 3, 8); 500 501 /* 502 * The subslice disable field is global, i.e. it applies 503 * to each of the enabled slices. 504 */ 505 subslice_mask = GENMASK(sseu->max_subslices - 1, 0); 506 subslice_mask &= ~((fuse2 & GEN8_F2_SS_DIS_MASK) >> 507 GEN8_F2_SS_DIS_SHIFT); 508 eu_disable0 = intel_uncore_read(uncore, GEN8_EU_DISABLE0); 509 eu_disable1 = intel_uncore_read(uncore, GEN8_EU_DISABLE1); 510 eu_disable2 = intel_uncore_read(uncore, GEN8_EU_DISABLE2); 511 eu_disable[0] = eu_disable0 & GEN8_EU_DIS0_S0_MASK; 512 eu_disable[1] = (eu_disable0 >> GEN8_EU_DIS0_S1_SHIFT) | 513 ((eu_disable1 & GEN8_EU_DIS1_S1_MASK) << 514 (32 - GEN8_EU_DIS0_S1_SHIFT)); 515 eu_disable[2] = (eu_disable1 >> GEN8_EU_DIS1_S2_SHIFT) | 516 ((eu_disable2 & GEN8_EU_DIS2_S2_MASK) << 517 (32 - GEN8_EU_DIS1_S2_SHIFT)); 518 519 /* 520 * Iterate through enabled slices and subslices to 521 * count the total enabled EU. 522 */ 523 for (s = 0; s < sseu->max_slices; s++) { 524 if (!(sseu->slice_mask & BIT(s))) 525 /* skip disabled slice */ 526 continue; 527 528 sseu->subslice_mask.hsw[s] = subslice_mask; 529 530 for (ss = 0; ss < sseu->max_subslices; ss++) { 531 u8 eu_disabled_mask; 532 u32 n_disabled; 533 534 if (!intel_sseu_has_subslice(sseu, s, ss)) 535 /* skip disabled subslice */ 536 continue; 537 538 eu_disabled_mask = 539 eu_disable[s] >> (ss * sseu->max_eus_per_subslice); 540 541 sseu_set_eus(sseu, s, ss, ~eu_disabled_mask & 0xFF); 542 543 n_disabled = hweight8(eu_disabled_mask); 544 545 /* 546 * Record which subslices have 7 EUs. 547 */ 548 if (sseu->max_eus_per_subslice - n_disabled == 7) 549 sseu->subslice_7eu[s] |= 1 << ss; 550 } 551 } 552 553 sseu->eu_total = compute_eu_total(sseu); 554 555 /* 556 * BDW is expected to always have a uniform distribution of EU across 557 * subslices with the exception that any one EU in any one subslice may 558 * be fused off for die recovery. 559 */ 560 sseu->eu_per_subslice = 561 intel_sseu_subslice_total(sseu) ? 562 DIV_ROUND_UP(sseu->eu_total, intel_sseu_subslice_total(sseu)) : 563 0; 564 565 /* 566 * BDW supports slice power gating on devices with more than 567 * one slice. 568 */ 569 sseu->has_slice_pg = hweight8(sseu->slice_mask) > 1; 570 sseu->has_subslice_pg = 0; 571 sseu->has_eu_pg = 0; 572 } 573 574 static void hsw_sseu_info_init(struct intel_gt *gt) 575 { 576 struct drm_i915_private *i915 = gt->i915; 577 struct sseu_dev_info *sseu = >->info.sseu; 578 u32 fuse1; 579 u8 subslice_mask = 0; 580 int s, ss; 581 582 /* 583 * There isn't a register to tell us how many slices/subslices. We 584 * work off the PCI-ids here. 585 */ 586 switch (INTEL_INFO(i915)->gt) { 587 default: 588 MISSING_CASE(INTEL_INFO(i915)->gt); 589 fallthrough; 590 case 1: 591 sseu->slice_mask = BIT(0); 592 subslice_mask = BIT(0); 593 break; 594 case 2: 595 sseu->slice_mask = BIT(0); 596 subslice_mask = BIT(0) | BIT(1); 597 break; 598 case 3: 599 sseu->slice_mask = BIT(0) | BIT(1); 600 subslice_mask = BIT(0) | BIT(1); 601 break; 602 } 603 604 fuse1 = intel_uncore_read(gt->uncore, HSW_PAVP_FUSE1); 605 switch (REG_FIELD_GET(HSW_F1_EU_DIS_MASK, fuse1)) { 606 default: 607 MISSING_CASE(REG_FIELD_GET(HSW_F1_EU_DIS_MASK, fuse1)); 608 fallthrough; 609 case HSW_F1_EU_DIS_10EUS: 610 sseu->eu_per_subslice = 10; 611 break; 612 case HSW_F1_EU_DIS_8EUS: 613 sseu->eu_per_subslice = 8; 614 break; 615 case HSW_F1_EU_DIS_6EUS: 616 sseu->eu_per_subslice = 6; 617 break; 618 } 619 620 intel_sseu_set_info(sseu, hweight8(sseu->slice_mask), 621 hweight8(subslice_mask), 622 sseu->eu_per_subslice); 623 624 for (s = 0; s < sseu->max_slices; s++) { 625 sseu->subslice_mask.hsw[s] = subslice_mask; 626 627 for (ss = 0; ss < sseu->max_subslices; ss++) { 628 sseu_set_eus(sseu, s, ss, 629 (1UL << sseu->eu_per_subslice) - 1); 630 } 631 } 632 633 sseu->eu_total = compute_eu_total(sseu); 634 635 /* No powergating for you. */ 636 sseu->has_slice_pg = 0; 637 sseu->has_subslice_pg = 0; 638 sseu->has_eu_pg = 0; 639 } 640 641 void intel_sseu_info_init(struct intel_gt *gt) 642 { 643 struct drm_i915_private *i915 = gt->i915; 644 645 if (GRAPHICS_VER_FULL(i915) >= IP_VER(12, 50)) 646 xehp_sseu_info_init(gt); 647 else if (GRAPHICS_VER(i915) >= 12) 648 gen12_sseu_info_init(gt); 649 else if (GRAPHICS_VER(i915) >= 11) 650 gen11_sseu_info_init(gt); 651 else if (GRAPHICS_VER(i915) >= 9) 652 gen9_sseu_info_init(gt); 653 else if (IS_BROADWELL(i915)) 654 bdw_sseu_info_init(gt); 655 else if (IS_CHERRYVIEW(i915)) 656 cherryview_sseu_info_init(gt); 657 else if (IS_HASWELL(i915)) 658 hsw_sseu_info_init(gt); 659 } 660 661 u32 intel_sseu_make_rpcs(struct intel_gt *gt, 662 const struct intel_sseu *req_sseu) 663 { 664 struct drm_i915_private *i915 = gt->i915; 665 const struct sseu_dev_info *sseu = >->info.sseu; 666 bool subslice_pg = sseu->has_subslice_pg; 667 u8 slices, subslices; 668 u32 rpcs = 0; 669 670 /* 671 * No explicit RPCS request is needed to ensure full 672 * slice/subslice/EU enablement prior to Gen9. 673 */ 674 if (GRAPHICS_VER(i915) < 9) 675 return 0; 676 677 /* 678 * If i915/perf is active, we want a stable powergating configuration 679 * on the system. Use the configuration pinned by i915/perf. 680 */ 681 if (i915->perf.exclusive_stream) 682 req_sseu = &i915->perf.sseu; 683 684 slices = hweight8(req_sseu->slice_mask); 685 subslices = hweight8(req_sseu->subslice_mask); 686 687 /* 688 * Since the SScount bitfield in GEN8_R_PWR_CLK_STATE is only three bits 689 * wide and Icelake has up to eight subslices, specfial programming is 690 * needed in order to correctly enable all subslices. 691 * 692 * According to documentation software must consider the configuration 693 * as 2x4x8 and hardware will translate this to 1x8x8. 694 * 695 * Furthemore, even though SScount is three bits, maximum documented 696 * value for it is four. From this some rules/restrictions follow: 697 * 698 * 1. 699 * If enabled subslice count is greater than four, two whole slices must 700 * be enabled instead. 701 * 702 * 2. 703 * When more than one slice is enabled, hardware ignores the subslice 704 * count altogether. 705 * 706 * From these restrictions it follows that it is not possible to enable 707 * a count of subslices between the SScount maximum of four restriction, 708 * and the maximum available number on a particular SKU. Either all 709 * subslices are enabled, or a count between one and four on the first 710 * slice. 711 */ 712 if (GRAPHICS_VER(i915) == 11 && 713 slices == 1 && 714 subslices > min_t(u8, 4, hweight8(sseu->subslice_mask.hsw[0]) / 2)) { 715 GEM_BUG_ON(subslices & 1); 716 717 subslice_pg = false; 718 slices *= 2; 719 } 720 721 /* 722 * Starting in Gen9, render power gating can leave 723 * slice/subslice/EU in a partially enabled state. We 724 * must make an explicit request through RPCS for full 725 * enablement. 726 */ 727 if (sseu->has_slice_pg) { 728 u32 mask, val = slices; 729 730 if (GRAPHICS_VER(i915) >= 11) { 731 mask = GEN11_RPCS_S_CNT_MASK; 732 val <<= GEN11_RPCS_S_CNT_SHIFT; 733 } else { 734 mask = GEN8_RPCS_S_CNT_MASK; 735 val <<= GEN8_RPCS_S_CNT_SHIFT; 736 } 737 738 GEM_BUG_ON(val & ~mask); 739 val &= mask; 740 741 rpcs |= GEN8_RPCS_ENABLE | GEN8_RPCS_S_CNT_ENABLE | val; 742 } 743 744 if (subslice_pg) { 745 u32 val = subslices; 746 747 val <<= GEN8_RPCS_SS_CNT_SHIFT; 748 749 GEM_BUG_ON(val & ~GEN8_RPCS_SS_CNT_MASK); 750 val &= GEN8_RPCS_SS_CNT_MASK; 751 752 rpcs |= GEN8_RPCS_ENABLE | GEN8_RPCS_SS_CNT_ENABLE | val; 753 } 754 755 if (sseu->has_eu_pg) { 756 u32 val; 757 758 val = req_sseu->min_eus_per_subslice << GEN8_RPCS_EU_MIN_SHIFT; 759 GEM_BUG_ON(val & ~GEN8_RPCS_EU_MIN_MASK); 760 val &= GEN8_RPCS_EU_MIN_MASK; 761 762 rpcs |= val; 763 764 val = req_sseu->max_eus_per_subslice << GEN8_RPCS_EU_MAX_SHIFT; 765 GEM_BUG_ON(val & ~GEN8_RPCS_EU_MAX_MASK); 766 val &= GEN8_RPCS_EU_MAX_MASK; 767 768 rpcs |= val; 769 770 rpcs |= GEN8_RPCS_ENABLE; 771 } 772 773 return rpcs; 774 } 775 776 void intel_sseu_dump(const struct sseu_dev_info *sseu, struct drm_printer *p) 777 { 778 int s; 779 780 if (sseu->has_xehp_dss) { 781 drm_printf(p, "subslice total: %u\n", 782 intel_sseu_subslice_total(sseu)); 783 drm_printf(p, "geometry dss mask=%*pb\n", 784 XEHP_BITMAP_BITS(sseu->geometry_subslice_mask), 785 sseu->geometry_subslice_mask.xehp); 786 drm_printf(p, "compute dss mask=%*pb\n", 787 XEHP_BITMAP_BITS(sseu->compute_subslice_mask), 788 sseu->compute_subslice_mask.xehp); 789 } else { 790 drm_printf(p, "slice total: %u, mask=%04x\n", 791 hweight8(sseu->slice_mask), sseu->slice_mask); 792 drm_printf(p, "subslice total: %u\n", 793 intel_sseu_subslice_total(sseu)); 794 795 for (s = 0; s < sseu->max_slices; s++) { 796 u8 ss_mask = sseu->subslice_mask.hsw[s]; 797 798 drm_printf(p, "slice%d: %u subslices, mask=%08x\n", 799 s, hweight8(ss_mask), ss_mask); 800 } 801 } 802 803 drm_printf(p, "EU total: %u\n", sseu->eu_total); 804 drm_printf(p, "EU per subslice: %u\n", sseu->eu_per_subslice); 805 drm_printf(p, "has slice power gating: %s\n", 806 str_yes_no(sseu->has_slice_pg)); 807 drm_printf(p, "has subslice power gating: %s\n", 808 str_yes_no(sseu->has_subslice_pg)); 809 drm_printf(p, "has EU power gating: %s\n", 810 str_yes_no(sseu->has_eu_pg)); 811 } 812 813 static void sseu_print_hsw_topology(const struct sseu_dev_info *sseu, 814 struct drm_printer *p) 815 { 816 int s, ss; 817 818 for (s = 0; s < sseu->max_slices; s++) { 819 u8 ss_mask = sseu->subslice_mask.hsw[s]; 820 821 drm_printf(p, "slice%d: %u subslice(s) (0x%08x):\n", 822 s, hweight8(ss_mask), ss_mask); 823 824 for (ss = 0; ss < sseu->max_subslices; ss++) { 825 u16 enabled_eus = sseu_get_eus(sseu, s, ss); 826 827 drm_printf(p, "\tsubslice%d: %u EUs (0x%hx)\n", 828 ss, hweight16(enabled_eus), enabled_eus); 829 } 830 } 831 } 832 833 static void sseu_print_xehp_topology(const struct sseu_dev_info *sseu, 834 struct drm_printer *p) 835 { 836 int dss; 837 838 for (dss = 0; dss < sseu->max_subslices; dss++) { 839 u16 enabled_eus = sseu_get_eus(sseu, 0, dss); 840 841 drm_printf(p, "DSS_%02d: G:%3s C:%3s, %2u EUs (0x%04hx)\n", dss, 842 str_yes_no(test_bit(dss, sseu->geometry_subslice_mask.xehp)), 843 str_yes_no(test_bit(dss, sseu->compute_subslice_mask.xehp)), 844 hweight16(enabled_eus), enabled_eus); 845 } 846 } 847 848 void intel_sseu_print_topology(struct drm_i915_private *i915, 849 const struct sseu_dev_info *sseu, 850 struct drm_printer *p) 851 { 852 if (sseu->max_slices == 0) { 853 drm_printf(p, "Unavailable\n"); 854 } else if (GRAPHICS_VER_FULL(i915) >= IP_VER(12, 50)) { 855 sseu_print_xehp_topology(sseu, p); 856 } else { 857 sseu_print_hsw_topology(sseu, p); 858 } 859 } 860 861 void intel_sseu_print_ss_info(const char *type, 862 const struct sseu_dev_info *sseu, 863 struct seq_file *m) 864 { 865 int s; 866 867 if (sseu->has_xehp_dss) { 868 seq_printf(m, " %s Geometry DSS: %u\n", type, 869 bitmap_weight(sseu->geometry_subslice_mask.xehp, 870 XEHP_BITMAP_BITS(sseu->geometry_subslice_mask))); 871 seq_printf(m, " %s Compute DSS: %u\n", type, 872 bitmap_weight(sseu->compute_subslice_mask.xehp, 873 XEHP_BITMAP_BITS(sseu->compute_subslice_mask))); 874 } else { 875 for (s = 0; s < fls(sseu->slice_mask); s++) 876 seq_printf(m, " %s Slice%i subslices: %u\n", type, 877 s, hweight8(sseu->subslice_mask.hsw[s])); 878 } 879 } 880 881 u16 intel_slicemask_from_xehp_dssmask(intel_sseu_ss_mask_t dss_mask, 882 int dss_per_slice) 883 { 884 intel_sseu_ss_mask_t per_slice_mask = {}; 885 unsigned long slice_mask = 0; 886 int i; 887 888 WARN_ON(DIV_ROUND_UP(XEHP_BITMAP_BITS(dss_mask), dss_per_slice) > 889 8 * sizeof(slice_mask)); 890 891 bitmap_fill(per_slice_mask.xehp, dss_per_slice); 892 for (i = 0; !bitmap_empty(dss_mask.xehp, XEHP_BITMAP_BITS(dss_mask)); i++) { 893 if (bitmap_intersects(dss_mask.xehp, per_slice_mask.xehp, dss_per_slice)) 894 slice_mask |= BIT(i); 895 896 bitmap_shift_right(dss_mask.xehp, dss_mask.xehp, dss_per_slice, 897 XEHP_BITMAP_BITS(dss_mask)); 898 } 899 900 return slice_mask; 901 } 902