drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright © 2014-2019 Intel Corporation
   4  */
   5
   6 #include <linux/bsearch.h>
   7
   8 #include "gt/intel_engine_regs.h"
   9 #include "gt/intel_gt.h"
  10 #include "gt/intel_gt_regs.h"
  11 #include "gt/intel_lrc.h"
  12 #include "gt/shmem_utils.h"
  13 #include "intel_guc_ads.h"
  14 #include "intel_guc_fwif.h"
  15 #include "intel_uc.h"
  16 #include "i915_drv.h"
  17
  18 /*
  19  * The Additional Data Struct (ADS) has pointers for different buffers used by
  20  * the GuC. One single gem object contains the ADS struct itself (guc_ads) and
  21  * all the extra buffers indirectly linked via the ADS struct's entries.
  22  *
  23  * Layout of the ADS blob allocated for the GuC:
  24  *
  25  *      +---------------------------------------+ <== base
  26  *      | guc_ads                               |
  27  *      +---------------------------------------+
  28  *      | guc_policies                          |
  29  *      +---------------------------------------+
  30  *      | guc_gt_system_info                    |
  31  *      +---------------------------------------+
  32  *      | guc_engine_usage                      |
  33  *      +---------------------------------------+ <== static
  34  *      | guc_mmio_reg[countA] (engine 0.0)     |
  35  *      | guc_mmio_reg[countB] (engine 0.1)     |
  36  *      | guc_mmio_reg[countC] (engine 1.0)     |
  37  *      |   ...                                 |
  38  *      +---------------------------------------+ <== dynamic
  39  *      | padding                               |
  40  *      +---------------------------------------+ <== 4K aligned
  41  *      | golden contexts                       |
  42  *      +---------------------------------------+
  43  *      | padding                               |
  44  *      +---------------------------------------+ <== 4K aligned
  45  *      | capture lists                         |
  46  *      +---------------------------------------+
  47  *      | padding                               |
  48  *      +---------------------------------------+ <== 4K aligned
  49  *      | private data                          |
  50  *      +---------------------------------------+
  51  *      | padding                               |
  52  *      +---------------------------------------+ <== 4K aligned
  53  */
  54 struct __guc_ads_blob {
  55         struct guc_ads ads;
  56         struct guc_policies policies;
  57         struct guc_gt_system_info system_info;
  58         struct guc_engine_usage engine_usage;
  59         /* From here on, location is dynamic! Refer to above diagram. */
  60         struct guc_mmio_reg regset[0];
  61 } __packed;
  62
  63 #define ads_blob_read(guc_, field_)                                     \
  64         iosys_map_rd_field(&(guc_)->ads_map, 0, struct __guc_ads_blob, field_)
  65
  66 #define ads_blob_write(guc_, field_, val_)                              \
  67         iosys_map_wr_field(&(guc_)->ads_map, 0, struct __guc_ads_blob,  \
  68                            field_, val_)
  69
  70 #define info_map_write(map_, field_, val_) \
  71         iosys_map_wr_field(map_, 0, struct guc_gt_system_info, field_, val_)
  72
  73 #define info_map_read(map_, field_) \
  74         iosys_map_rd_field(map_, 0, struct guc_gt_system_info, field_)
  75
  76 static u32 guc_ads_regset_size(struct intel_guc *guc)
  77 {
  78         GEM_BUG_ON(!guc->ads_regset_size);
  79         return guc->ads_regset_size;
  80 }
  81
  82 static u32 guc_ads_golden_ctxt_size(struct intel_guc *guc)
  83 {
  84         return PAGE_ALIGN(guc->ads_golden_ctxt_size);
  85 }
  86
  87 static u32 guc_ads_capture_size(struct intel_guc *guc)
  88 {
  89         /* FIXME: Allocate a proper capture list */
  90         return PAGE_ALIGN(PAGE_SIZE);
  91 }
  92
  93 static u32 guc_ads_private_data_size(struct intel_guc *guc)
  94 {
  95         return PAGE_ALIGN(guc->fw.private_data_size);
  96 }
  97
  98 static u32 guc_ads_regset_offset(struct intel_guc *guc)
  99 {
 100         return offsetof(struct __guc_ads_blob, regset);
 101 }
 102
 103 static u32 guc_ads_golden_ctxt_offset(struct intel_guc *guc)
 104 {
 105         u32 offset;
 106
 107         offset = guc_ads_regset_offset(guc) +
 108                  guc_ads_regset_size(guc);
 109
 110         return PAGE_ALIGN(offset);
 111 }
 112
 113 static u32 guc_ads_capture_offset(struct intel_guc *guc)
 114 {
 115         u32 offset;
 116
 117         offset = guc_ads_golden_ctxt_offset(guc) +
 118                  guc_ads_golden_ctxt_size(guc);
 119
 120         return PAGE_ALIGN(offset);
 121 }
 122
 123 static u32 guc_ads_private_data_offset(struct intel_guc *guc)
 124 {
 125         u32 offset;
 126
 127         offset = guc_ads_capture_offset(guc) +
 128                  guc_ads_capture_size(guc);
 129
 130         return PAGE_ALIGN(offset);
 131 }
 132
 133 static u32 guc_ads_blob_size(struct intel_guc *guc)
 134 {
 135         return guc_ads_private_data_offset(guc) +
 136                guc_ads_private_data_size(guc);
 137 }
 138
 139 static void guc_policies_init(struct intel_guc *guc)
 140 {
 141         struct intel_gt *gt = guc_to_gt(guc);
 142         struct drm_i915_private *i915 = gt->i915;
 143         u32 global_flags = 0;
 144
 145         ads_blob_write(guc, policies.dpc_promote_time,
 146                        GLOBAL_POLICY_DEFAULT_DPC_PROMOTE_TIME_US);
 147         ads_blob_write(guc, policies.max_num_work_items,
 148                        GLOBAL_POLICY_MAX_NUM_WI);
 149
 150         if (i915->params.reset < 2)
 151                 global_flags |= GLOBAL_POLICY_DISABLE_ENGINE_RESET;
 152
 153         ads_blob_write(guc, policies.global_flags, global_flags);
 154         ads_blob_write(guc, policies.is_valid, 1);
 155 }
 156
 157 void intel_guc_ads_print_policy_info(struct intel_guc *guc,
 158                                      struct drm_printer *dp)
 159 {
 160         if (unlikely(iosys_map_is_null(&guc->ads_map)))
 161                 return;
 162
 163         drm_printf(dp, "Global scheduling policies:\n");
 164         drm_printf(dp, "  DPC promote time   = %u\n",
 165                    ads_blob_read(guc, policies.dpc_promote_time));
 166         drm_printf(dp, "  Max num work items = %u\n",
 167                    ads_blob_read(guc, policies.max_num_work_items));
 168         drm_printf(dp, "  Flags              = %u\n",
 169                    ads_blob_read(guc, policies.global_flags));
 170 }
 171
 172 static int guc_action_policies_update(struct intel_guc *guc, u32 policy_offset)
 173 {
 174         u32 action[] = {
 175                 INTEL_GUC_ACTION_GLOBAL_SCHED_POLICY_CHANGE,
 176                 policy_offset
 177         };
 178
 179         return intel_guc_send_busy_loop(guc, action, ARRAY_SIZE(action), 0, true);
 180 }
 181
 182 int intel_guc_global_policies_update(struct intel_guc *guc)
 183 {
 184         struct intel_gt *gt = guc_to_gt(guc);
 185         u32 scheduler_policies;
 186         intel_wakeref_t wakeref;
 187         int ret;
 188
 189         if (iosys_map_is_null(&guc->ads_map))
 190                 return -EOPNOTSUPP;
 191
 192         scheduler_policies = ads_blob_read(guc, ads.scheduler_policies);
 193         GEM_BUG_ON(!scheduler_policies);
 194
 195         guc_policies_init(guc);
 196
 197         if (!intel_guc_is_ready(guc))
 198                 return 0;
 199
 200         with_intel_runtime_pm(&gt->i915->runtime_pm, wakeref)
 201                 ret = guc_action_policies_update(guc, scheduler_policies);
 202
 203         return ret;
 204 }
 205
 206 static void guc_mapping_table_init(struct intel_gt *gt,
 207                                    struct guc_gt_system_info *system_info)
 208 {
 209         unsigned int i, j;
 210         struct intel_engine_cs *engine;
 211         enum intel_engine_id id;
 212
 213         /* Table must be set to invalid values for entries not used */
 214         for (i = 0; i < GUC_MAX_ENGINE_CLASSES; ++i)
 215                 for (j = 0; j < GUC_MAX_INSTANCES_PER_CLASS; ++j)
 216                         system_info->mapping_table[i][j] =
 217                                 GUC_MAX_INSTANCES_PER_CLASS;
 218
 219         for_each_engine(engine, gt, id) {
 220                 u8 guc_class = engine_class_to_guc_class(engine->class);
 221
 222                 system_info->mapping_table[guc_class][ilog2(engine->logical_mask)] =
 223                         engine->instance;
 224         }
 225 }
 226
 227 /*
 228  * The save/restore register list must be pre-calculated to a temporary
 229  * buffer before it can be copied inside the ADS.
 230  */
 231 struct temp_regset {
 232         /*
 233          * ptr to the section of the storage for the engine currently being
 234          * worked on
 235          */
 236         struct guc_mmio_reg *registers;
 237         /* ptr to the base of the allocated storage for all engines */
 238         struct guc_mmio_reg *storage;
 239         u32 storage_used;
 240         u32 storage_max;
 241 };
 242
 243 static int guc_mmio_reg_cmp(const void *a, const void *b)
 244 {
 245         const struct guc_mmio_reg *ra = a;
 246         const struct guc_mmio_reg *rb = b;
 247
 248         return (int)ra->offset - (int)rb->offset;
 249 }
 250
 251 static struct guc_mmio_reg * __must_check
 252 __mmio_reg_add(struct temp_regset *regset, struct guc_mmio_reg *reg)
 253 {
 254         u32 pos = regset->storage_used;
 255         struct guc_mmio_reg *slot;
 256
 257         if (pos >= regset->storage_max) {
 258                 size_t size = ALIGN((pos + 1) * sizeof(*slot), PAGE_SIZE);
 259                 struct guc_mmio_reg *r = krealloc(regset->storage,
 260                                                   size, GFP_KERNEL);
 261                 if (!r) {
 262                         WARN_ONCE(1, "Incomplete regset list: can't add register (%d)\n",
 263                                   -ENOMEM);
 264                         return ERR_PTR(-ENOMEM);
 265                 }
 266
 267                 regset->registers = r + (regset->registers - regset->storage);
 268                 regset->storage = r;
 269                 regset->storage_max = size / sizeof(*slot);
 270         }
 271
 272         slot = &regset->storage[pos];
 273         regset->storage_used++;
 274         *slot = *reg;
 275
 276         return slot;
 277 }
 278
 279 static long __must_check guc_mmio_reg_add(struct temp_regset *regset,
 280                                           u32 offset, u32 flags)
 281 {
 282         u32 count = regset->storage_used - (regset->registers - regset->storage);
 283         struct guc_mmio_reg reg = {
 284                 .offset = offset,
 285                 .flags = flags,
 286         };
 287         struct guc_mmio_reg *slot;
 288
 289         /*
 290          * The mmio list is built using separate lists within the driver.
 291          * It's possible that at some point we may attempt to add the same
 292          * register more than once. Do not consider this an error; silently
 293          * move on if the register is already in the list.
 294          */
 295         if (bsearch(&reg, regset->registers, count,
 296                     sizeof(reg), guc_mmio_reg_cmp))
 297                 return 0;
 298
 299         slot = __mmio_reg_add(regset, &reg);
 300         if (IS_ERR(slot))
 301                 return PTR_ERR(slot);
 302
 303         while (slot-- > regset->registers) {
 304                 GEM_BUG_ON(slot[0].offset == slot[1].offset);
 305                 if (slot[1].offset > slot[0].offset)
 306                         break;
 307
 308                 swap(slot[1], slot[0]);
 309         }
 310
 311         return 0;
 312 }
 313
 314 #define GUC_MMIO_REG_ADD(regset, reg, masked) \
 315         guc_mmio_reg_add(regset, \
 316                          i915_mmio_reg_offset((reg)), \
 317                          (masked) ? GUC_REGSET_MASKED : 0)
 318
 319 static int guc_mmio_regset_init(struct temp_regset *regset,
 320                                 struct intel_engine_cs *engine)
 321 {
 322         const u32 base = engine->mmio_base;
 323         struct i915_wa_list *wal = &engine->wa_list;
 324         struct i915_wa *wa;
 325         unsigned int i;
 326         int ret = 0;
 327
 328         /*
 329          * Each engine's registers point to a new start relative to
 330          * storage
 331          */
 332         regset->registers = regset->storage + regset->storage_used;
 333
 334         ret |= GUC_MMIO_REG_ADD(regset, RING_MODE_GEN7(base), true);
 335         ret |= GUC_MMIO_REG_ADD(regset, RING_HWS_PGA(base), false);
 336         ret |= GUC_MMIO_REG_ADD(regset, RING_IMR(base), false);
 337
 338         for (i = 0, wa = wal->list; i < wal->count; i++, wa++)
 339                 ret |= GUC_MMIO_REG_ADD(regset, wa->reg, wa->masked_reg);
 340
 341         /* Be extra paranoid and include all whitelist registers. */
 342         for (i = 0; i < RING_MAX_NONPRIV_SLOTS; i++)
 343                 ret |= GUC_MMIO_REG_ADD(regset,
 344                                         RING_FORCE_TO_NONPRIV(base, i),
 345                                         false);
 346
 347         /* add in local MOCS registers */
 348         for (i = 0; i < GEN9_LNCFCMOCS_REG_COUNT; i++)
 349                 ret |= GUC_MMIO_REG_ADD(regset, GEN9_LNCFCMOCS(i), false);
 350
 351         return ret ? -1 : 0;
 352 }
 353
 354 static long guc_mmio_reg_state_create(struct intel_guc *guc)
 355 {
 356         struct intel_gt *gt = guc_to_gt(guc);
 357         struct intel_engine_cs *engine;
 358         enum intel_engine_id id;
 359         struct temp_regset temp_set = {};
 360         long total = 0;
 361         long ret;
 362
 363         for_each_engine(engine, gt, id) {
 364                 u32 used = temp_set.storage_used;
 365
 366                 ret = guc_mmio_regset_init(&temp_set, engine);
 367                 if (ret < 0)
 368                         goto fail_regset_init;
 369
 370                 guc->ads_regset_count[id] = temp_set.storage_used - used;
 371                 total += guc->ads_regset_count[id];
 372         }
 373
 374         guc->ads_regset = temp_set.storage;
 375
 376         drm_dbg(&guc_to_gt(guc)->i915->drm, "Used %zu KB for temporary ADS regset\n",
 377                 (temp_set.storage_max * sizeof(struct guc_mmio_reg)) >> 10);
 378
 379         return total * sizeof(struct guc_mmio_reg);
 380
 381 fail_regset_init:
 382         kfree(temp_set.storage);
 383         return ret;
 384 }
 385
 386 static void guc_mmio_reg_state_init(struct intel_guc *guc,
 387                                     struct __guc_ads_blob *blob)
 388 {
 389         struct intel_gt *gt = guc_to_gt(guc);
 390         struct intel_engine_cs *engine;
 391         struct guc_mmio_reg *ads_registers;
 392         enum intel_engine_id id;
 393         u32 addr_ggtt, offset;
 394
 395         offset = guc_ads_regset_offset(guc);
 396         addr_ggtt = intel_guc_ggtt_offset(guc, guc->ads_vma) + offset;
 397         ads_registers = (struct guc_mmio_reg *)(((u8 *)blob) + offset);
 398
 399         memcpy(ads_registers, guc->ads_regset, guc->ads_regset_size);
 400
 401         for_each_engine(engine, gt, id) {
 402                 u32 count = guc->ads_regset_count[id];
 403                 struct guc_mmio_reg_set *ads_reg_set;
 404                 u8 guc_class;
 405
 406                 /* Class index is checked in class converter */
 407                 GEM_BUG_ON(engine->instance >= GUC_MAX_INSTANCES_PER_CLASS);
 408
 409                 guc_class = engine_class_to_guc_class(engine->class);
 410                 ads_reg_set = &blob->ads.reg_state_list[guc_class][engine->instance];
 411
 412                 if (!count) {
 413                         ads_reg_set->address = 0;
 414                         ads_reg_set->count = 0;
 415                         continue;
 416                 }
 417
 418                 ads_reg_set->address = addr_ggtt;
 419                 ads_reg_set->count = count;
 420
 421                 addr_ggtt += count * sizeof(struct guc_mmio_reg);
 422         }
 423 }
 424
 425 static void fill_engine_enable_masks(struct intel_gt *gt,
 426                                      struct iosys_map *info_map)
 427 {
 428         info_map_write(info_map, engine_enabled_masks[GUC_RENDER_CLASS], 1);
 429         info_map_write(info_map, engine_enabled_masks[GUC_BLITTER_CLASS], 1);
 430         info_map_write(info_map, engine_enabled_masks[GUC_VIDEO_CLASS], VDBOX_MASK(gt));
 431         info_map_write(info_map, engine_enabled_masks[GUC_VIDEOENHANCE_CLASS], VEBOX_MASK(gt));
 432 }
 433
 434 #define LR_HW_CONTEXT_SIZE (80 * sizeof(u32))
 435 #define LRC_SKIP_SIZE (LRC_PPHWSP_SZ * PAGE_SIZE + LR_HW_CONTEXT_SIZE)
 436 static int guc_prep_golden_context(struct intel_guc *guc)
 437 {
 438         struct intel_gt *gt = guc_to_gt(guc);
 439         u32 addr_ggtt, offset;
 440         u32 total_size = 0, alloc_size, real_size;
 441         u8 engine_class, guc_class;
 442         struct guc_gt_system_info local_info;
 443         struct iosys_map info_map;
 444
 445         /*
 446          * Reserve the memory for the golden contexts and point GuC at it but
 447          * leave it empty for now. The context data will be filled in later
 448          * once there is something available to put there.
 449          *
 450          * Note that the HWSP and ring context are not included.
 451          *
 452          * Note also that the storage must be pinned in the GGTT, so that the
 453          * address won't change after GuC has been told where to find it. The
 454          * GuC will also validate that the LRC base + size fall within the
 455          * allowed GGTT range.
 456          */
 457         if (!iosys_map_is_null(&guc->ads_map)) {
 458                 offset = guc_ads_golden_ctxt_offset(guc);
 459                 addr_ggtt = intel_guc_ggtt_offset(guc, guc->ads_vma) + offset;
 460                 info_map = IOSYS_MAP_INIT_OFFSET(&guc->ads_map,
 461                                                  offsetof(struct __guc_ads_blob, system_info));
 462         } else {
 463                 memset(&local_info, 0, sizeof(local_info));
 464                 iosys_map_set_vaddr(&info_map, &local_info);
 465                 fill_engine_enable_masks(gt, &info_map);
 466         }
 467
 468         for (engine_class = 0; engine_class <= MAX_ENGINE_CLASS; ++engine_class) {
 469                 if (engine_class == OTHER_CLASS)
 470                         continue;
 471
 472                 guc_class = engine_class_to_guc_class(engine_class);
 473
 474                 if (!info_map_read(&info_map, engine_enabled_masks[guc_class]))
 475                         continue;
 476
 477                 real_size = intel_engine_context_size(gt, engine_class);
 478                 alloc_size = PAGE_ALIGN(real_size);
 479                 total_size += alloc_size;
 480
 481                 if (iosys_map_is_null(&guc->ads_map))
 482                         continue;
 483
 484                 /*
 485                  * This interface is slightly confusing. We need to pass the
 486                  * base address of the full golden context and the size of just
 487                  * the engine state, which is the section of the context image
 488                  * that starts after the execlists context. This is required to
 489                  * allow the GuC to restore just the engine state when a
 490                  * watchdog reset occurs.
 491                  * We calculate the engine state size by removing the size of
 492                  * what comes before it in the context image (which is identical
 493                  * on all engines).
 494                  */
 495                 ads_blob_write(guc, ads.eng_state_size[guc_class],
 496                                real_size - LRC_SKIP_SIZE);
 497                 ads_blob_write(guc, ads.golden_context_lrca[guc_class],
 498                                addr_ggtt);
 499
 500                 addr_ggtt += alloc_size;
 501         }
 502
 503         /* Make sure current size matches what we calculated previously */
 504         if (guc->ads_golden_ctxt_size)
 505                 GEM_BUG_ON(guc->ads_golden_ctxt_size != total_size);
 506
 507         return total_size;
 508 }
 509
 510 static struct intel_engine_cs *find_engine_state(struct intel_gt *gt, u8 engine_class)
 511 {
 512         struct intel_engine_cs *engine;
 513         enum intel_engine_id id;
 514
 515         for_each_engine(engine, gt, id) {
 516                 if (engine->class != engine_class)
 517                         continue;
 518
 519                 if (!engine->default_state)
 520                         continue;
 521
 522                 return engine;
 523         }
 524
 525         return NULL;
 526 }
 527
 528 static void guc_init_golden_context(struct intel_guc *guc)
 529 {
 530         struct intel_engine_cs *engine;
 531         struct intel_gt *gt = guc_to_gt(guc);
 532         unsigned long offset;
 533         u32 addr_ggtt, total_size = 0, alloc_size, real_size;
 534         u8 engine_class, guc_class;
 535
 536         if (!intel_uc_uses_guc_submission(&gt->uc))
 537                 return;
 538
 539         GEM_BUG_ON(iosys_map_is_null(&guc->ads_map));
 540
 541         /*
 542          * Go back and fill in the golden context data now that it is
 543          * available.
 544          */
 545         offset = guc_ads_golden_ctxt_offset(guc);
 546         addr_ggtt = intel_guc_ggtt_offset(guc, guc->ads_vma) + offset;
 547
 548         for (engine_class = 0; engine_class <= MAX_ENGINE_CLASS; ++engine_class) {
 549                 if (engine_class == OTHER_CLASS)
 550                         continue;
 551
 552                 guc_class = engine_class_to_guc_class(engine_class);
 553                 if (!ads_blob_read(guc, system_info.engine_enabled_masks[guc_class]))
 554                         continue;
 555
 556                 real_size = intel_engine_context_size(gt, engine_class);
 557                 alloc_size = PAGE_ALIGN(real_size);
 558                 total_size += alloc_size;
 559
 560                 engine = find_engine_state(gt, engine_class);
 561                 if (!engine) {
 562                         drm_err(&gt->i915->drm, "No engine state recorded for class %d!\n",
 563                                 engine_class);
 564                         ads_blob_write(guc, ads.eng_state_size[guc_class], 0);
 565                         ads_blob_write(guc, ads.golden_context_lrca[guc_class], 0);
 566                         continue;
 567                 }
 568
 569                 GEM_BUG_ON(ads_blob_read(guc, ads.eng_state_size[guc_class]) !=
 570                            real_size - LRC_SKIP_SIZE);
 571                 GEM_BUG_ON(ads_blob_read(guc, ads.golden_context_lrca[guc_class]) != addr_ggtt);
 572
 573                 addr_ggtt += alloc_size;
 574
 575                 shmem_read_to_iosys_map(engine->default_state, 0, &guc->ads_map,
 576                                         offset, real_size);
 577                 offset += alloc_size;
 578         }
 579
 580         GEM_BUG_ON(guc->ads_golden_ctxt_size != total_size);
 581 }
 582
 583 static void guc_capture_list_init(struct intel_guc *guc, struct __guc_ads_blob *blob)
 584 {
 585         int i, j;
 586         u32 addr_ggtt, offset;
 587
 588         offset = guc_ads_capture_offset(guc);
 589         addr_ggtt = intel_guc_ggtt_offset(guc, guc->ads_vma) + offset;
 590
 591         /* FIXME: Populate a proper capture list */
 592
 593         for (i = 0; i < GUC_CAPTURE_LIST_INDEX_MAX; i++) {
 594                 for (j = 0; j < GUC_MAX_ENGINE_CLASSES; j++) {
 595                         blob->ads.capture_instance[i][j] = addr_ggtt;
 596                         blob->ads.capture_class[i][j] = addr_ggtt;
 597                 }
 598
 599                 blob->ads.capture_global[i] = addr_ggtt;
 600         }
 601 }
 602
 603 static void __guc_ads_init(struct intel_guc *guc)
 604 {
 605         struct intel_gt *gt = guc_to_gt(guc);
 606         struct drm_i915_private *i915 = gt->i915;
 607         struct __guc_ads_blob *blob = guc->ads_blob;
 608         struct iosys_map info_map = IOSYS_MAP_INIT_OFFSET(&guc->ads_map,
 609                         offsetof(struct __guc_ads_blob, system_info));
 610         u32 base;
 611
 612         /* GuC scheduling policies */
 613         guc_policies_init(guc);
 614
 615         /* System info */
 616         fill_engine_enable_masks(gt, &info_map);
 617
 618         blob->system_info.generic_gt_sysinfo[GUC_GENERIC_GT_SYSINFO_SLICE_ENABLED] =
 619                 hweight8(gt->info.sseu.slice_mask);
 620         blob->system_info.generic_gt_sysinfo[GUC_GENERIC_GT_SYSINFO_VDBOX_SFC_SUPPORT_MASK] =
 621                 gt->info.vdbox_sfc_access;
 622
 623         if (GRAPHICS_VER(i915) >= 12 && !IS_DGFX(i915)) {
 624                 u32 distdbreg = intel_uncore_read(gt->uncore,
 625                                                   GEN12_DIST_DBS_POPULATED);
 626                 blob->system_info.generic_gt_sysinfo[GUC_GENERIC_GT_SYSINFO_DOORBELL_COUNT_PER_SQIDI] =
 627                         ((distdbreg >> GEN12_DOORBELLS_PER_SQIDI_SHIFT) &
 628                          GEN12_DOORBELLS_PER_SQIDI) + 1;
 629         }
 630
 631         /* Golden contexts for re-initialising after a watchdog reset */
 632         guc_prep_golden_context(guc);
 633
 634         guc_mapping_table_init(guc_to_gt(guc), &blob->system_info);
 635
 636         base = intel_guc_ggtt_offset(guc, guc->ads_vma);
 637
 638         /* Capture list for hang debug */
 639         guc_capture_list_init(guc, blob);
 640
 641         /* ADS */
 642         blob->ads.scheduler_policies = base + ptr_offset(blob, policies);
 643         blob->ads.gt_system_info = base + ptr_offset(blob, system_info);
 644
 645         /* MMIO save/restore list */
 646         guc_mmio_reg_state_init(guc, blob);
 647
 648         /* Private Data */
 649         blob->ads.private_data = base + guc_ads_private_data_offset(guc);
 650
 651         i915_gem_object_flush_map(guc->ads_vma->obj);
 652 }
 653
 654 /**
 655  * intel_guc_ads_create() - allocates and initializes GuC ADS.
 656  * @guc: intel_guc struct
 657  *
 658  * GuC needs memory block (Additional Data Struct), where it will store
 659  * some data. Allocate and initialize such memory block for GuC use.
 660  */
 661 int intel_guc_ads_create(struct intel_guc *guc)
 662 {
 663         u32 size;
 664         int ret;
 665
 666         GEM_BUG_ON(guc->ads_vma);
 667
 668         /*
 669          * Create reg state size dynamically on system memory to be copied to
 670          * the final ads blob on gt init/reset
 671          */
 672         ret = guc_mmio_reg_state_create(guc);
 673         if (ret < 0)
 674                 return ret;
 675         guc->ads_regset_size = ret;
 676
 677         /* Likewise the golden contexts: */
 678         ret = guc_prep_golden_context(guc);
 679         if (ret < 0)
 680                 return ret;
 681         guc->ads_golden_ctxt_size = ret;
 682
 683         /* Now the total size can be determined: */
 684         size = guc_ads_blob_size(guc);
 685
 686         ret = intel_guc_allocate_and_map_vma(guc, size, &guc->ads_vma,
 687                                              (void **)&guc->ads_blob);
 688         if (ret)
 689                 return ret;
 690
 691         if (i915_gem_object_is_lmem(guc->ads_vma->obj))
 692                 iosys_map_set_vaddr_iomem(&guc->ads_map, (void __iomem *)guc->ads_blob);
 693         else
 694                 iosys_map_set_vaddr(&guc->ads_map, guc->ads_blob);
 695
 696         __guc_ads_init(guc);
 697
 698         return 0;
 699 }
 700
 701 void intel_guc_ads_init_late(struct intel_guc *guc)
 702 {
 703         /*
 704          * The golden context setup requires the saved engine state from
 705          * __engines_record_defaults(). However, that requires engines to be
 706          * operational which means the ADS must already have been configured.
 707          * Fortunately, the golden context state is not needed until a hang
 708          * occurs, so it can be filled in during this late init phase.
 709          */
 710         guc_init_golden_context(guc);
 711 }
 712
 713 void intel_guc_ads_destroy(struct intel_guc *guc)
 714 {
 715         i915_vma_unpin_and_release(&guc->ads_vma, I915_VMA_RELEASE_MAP);
 716         guc->ads_blob = NULL;
 717         iosys_map_clear(&guc->ads_map);
 718         kfree(guc->ads_regset);
 719 }
 720
 721 static void guc_ads_private_data_reset(struct intel_guc *guc)
 722 {
 723         u32 size;
 724
 725         size = guc_ads_private_data_size(guc);
 726         if (!size)
 727                 return;
 728
 729         iosys_map_memset(&guc->ads_map, guc_ads_private_data_offset(guc),
 730                          0, size);
 731 }
 732
 733 /**
 734  * intel_guc_ads_reset() - prepares GuC Additional Data Struct for reuse
 735  * @guc: intel_guc struct
 736  *
 737  * GuC stores some data in ADS, which might be stale after a reset.
 738  * Reinitialize whole ADS in case any part of it was corrupted during
 739  * previous GuC run.
 740  */
 741 void intel_guc_ads_reset(struct intel_guc *guc)
 742 {
 743         if (!guc->ads_vma)
 744                 return;
 745
 746         __guc_ads_init(guc);
 747
 748         guc_ads_private_data_reset(guc);
 749 }
 750
 751 u32 intel_guc_engine_usage_offset(struct intel_guc *guc)
 752 {
 753         return intel_guc_ggtt_offset(guc, guc->ads_vma) +
 754                 offsetof(struct __guc_ads_blob, engine_usage);
 755 }
 756
 757 struct iosys_map intel_guc_engine_usage_record_map(struct intel_engine_cs *engine)
 758 {
 759         struct intel_guc *guc = &engine->gt->uc.guc;
 760         u8 guc_class = engine_class_to_guc_class(engine->class);
 761         size_t offset = offsetof(struct __guc_ads_blob,
 762                                  engine_usage.engines[guc_class][ilog2(engine->logical_mask)]);
 763
 764         return IOSYS_MAP_INIT_OFFSET(&guc->ads_map, offset);
 765 }