drm/xe/rtp: Allow to track active workarounds

Add the metadata in struct xe_rtp_process_ctx, to be set by
xe_rtp_process_ctx_enable_active_tracking(), so rtp knows how to mark
the active entries while processing the table. This can be used by the
WA infra to record what are the active workarounds.

Reviewed-by: Matt Roper <matthew.d.roper@intel.com>
Link: https://lore.kernel.org/r/20230526164358.86393-6-lucas.demarchi@intel.com
Signed-off-by: Lucas De Marchi <lucas.demarchi@intel.com>
Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>

diff --git a/drivers/gpu/drm/xe/xe_rtp.c b/drivers/gpu/drm/xe/xe_rtp.c
index 0be1f4cfc4d58168da459708252ab8a806c4d74e..29cf92f9b7b38b95af283186e4983709ecd39ff4 100644 (file)
--- a/drivers/gpu/drm/xe/xe_rtp.c
+++ b/drivers/gpu/drm/xe/xe_rtp.c
@@ -112,7 +112,7 @@ static void rtp_add_sr_entry(const struct xe_rtp_action *action,
        xe_reg_sr_add(sr, &sr_entry);
 }
 
-static void rtp_process_one_sr(const struct xe_rtp_entry_sr *entry,
+static bool rtp_process_one_sr(const struct xe_rtp_entry_sr *entry,
                               struct xe_device *xe, struct xe_gt *gt,
                               struct xe_hw_engine *hwe, struct xe_reg_sr *sr)
 {
@@ -121,7 +121,7 @@ static void rtp_process_one_sr(const struct xe_rtp_entry_sr *entry,
        unsigned int i;
 
        if (!rule_matches(xe, gt, hwe, entry))
-               return;
+               return false;
 
        for (action = &entry->actions[0]; i < entry->n_actions; action++, i++) {
                if ((entry->flags & XE_RTP_ENTRY_FLAG_FOREACH_ENGINE) ||
@@ -132,6 +132,8 @@ static void rtp_process_one_sr(const struct xe_rtp_entry_sr *entry,
 
                rtp_add_sr_entry(action, gt, mmio_base, sr);
        }
+
+       return true;
 }
 
 static void rtp_get_context(struct xe_rtp_process_ctx *ctx,
@@ -153,6 +155,38 @@ static void rtp_get_context(struct xe_rtp_process_ctx *ctx,
        };
 }
 
+/**
+ * xe_rtp_process_ctx_enable_active_tracking - Enable tracking of active entries
+ *
+ * Set additional metadata to track what entries are considered "active", i.e.
+ * their rules match the condition. Bits are never cleared: entries with
+ * matching rules set the corresponding bit in the bitmap.
+ *
+ * @ctx: The context for processing the table
+ * @active_entries: bitmap to store the active entries
+ * @n_entries: number of entries to be processed
+ */
+void xe_rtp_process_ctx_enable_active_tracking(struct xe_rtp_process_ctx *ctx,
+                                              unsigned long *active_entries,
+                                              size_t n_entries)
+{
+       ctx->active_entries = active_entries;
+       ctx->n_entries = n_entries;
+}
+
+static void rtp_mark_active(struct xe_device *xe,
+                           struct xe_rtp_process_ctx *ctx,
+                           unsigned int bit)
+{
+       if (!ctx->active_entries)
+               return;
+
+       if (drm_WARN_ON(&xe->drm, bit > ctx->n_entries))
+               return;
+
+       bitmap_set(ctx->active_entries, bit, 1);
+}
+
 /**
  * xe_rtp_process_to_sr - Process all rtp @entries, adding the matching ones to
  *                        the save-restore argument.
@@ -178,15 +212,21 @@ void xe_rtp_process_to_sr(struct xe_rtp_process_ctx *ctx,
        rtp_get_context(ctx, &hwe, &gt, &xe);
 
        for (entry = entries; entry && entry->name; entry++) {
+               bool match = false;
+
                if (entry->flags & XE_RTP_ENTRY_FLAG_FOREACH_ENGINE) {
                        struct xe_hw_engine *each_hwe;
                        enum xe_hw_engine_id id;
 
                        for_each_hw_engine(each_hwe, gt, id)
-                               rtp_process_one_sr(entry, xe, gt, each_hwe, sr);
+                               match |= rtp_process_one_sr(entry, xe, gt,
+                                                           each_hwe, sr);
                } else {
-                       rtp_process_one_sr(entry, xe, gt, hwe, sr);
+                       match = rtp_process_one_sr(entry, xe, gt, hwe, sr);
                }
+
+               if (match)
+                       rtp_mark_active(xe, ctx, entry - entries);
        }
 }
 EXPORT_SYMBOL_IF_KUNIT(xe_rtp_process_to_sr);

diff --git a/drivers/gpu/drm/xe/xe_rtp.h b/drivers/gpu/drm/xe/xe_rtp.h
index 179b497186d28566054eb3759a67062984702270..e69f514ee6c45128effc8ff379f52a8010bdc54b 100644 (file)
--- a/drivers/gpu/drm/xe/xe_rtp.h
+++ b/drivers/gpu/drm/xe/xe_rtp.h
@@ -359,6 +359,10 @@ struct xe_reg_sr;
        struct xe_hw_engine *:  (struct xe_rtp_process_ctx){ { (void *)(arg__) }, XE_RTP_PROCESS_TYPE_ENGINE }, \
        struct xe_gt *:         (struct xe_rtp_process_ctx){ { (void *)(arg__) }, XE_RTP_PROCESS_TYPE_GT })
 
+void xe_rtp_process_ctx_enable_active_tracking(struct xe_rtp_process_ctx *ctx,
+                                              unsigned long *active_entries,
+                                              size_t n_entries);
+
 void xe_rtp_process_to_sr(struct xe_rtp_process_ctx *ctx,
                          const struct xe_rtp_entry_sr *entries,
                          struct xe_reg_sr *sr);

diff --git a/drivers/gpu/drm/xe/xe_rtp_types.h b/drivers/gpu/drm/xe/xe_rtp_types.h
index 66d1cb0aaa081078177841df6801d59eca367a94..03d97b666c64c79bbafae0712b1c4d615496e1dc 100644 (file)
--- a/drivers/gpu/drm/xe/xe_rtp_types.h
+++ b/drivers/gpu/drm/xe/xe_rtp_types.h
@@ -106,6 +106,8 @@ struct xe_rtp_process_ctx {
                struct xe_hw_engine *hwe;
        };
        enum xe_rtp_process_type type;
+       unsigned long *active_entries;
+       size_t n_entries;
 };
 
 #endif