FAILED: patch "[PATCH] drm/xe/rtp: Add struct types for RTP tables" failed to apply to 7.1-stable tree
Subsystems (3)
[email protected]
maintainerThe patch below does not apply to the 7.1-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-7.1.y
git checkout FETCH_HEAD
git cherry-pick -x e23fafb8594ea886ee03e005cc32dfda24f417cf
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026072942-jet-festive-8482@gregkh' --subject-prefix 'PATCH 7.1.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From e23fafb8594ea886ee03e005cc32dfda24f417cf Mon Sep 17 00:00:00 2001
From: Gustavo Sousa <[email protected]>
Date: Mon, 1 Jun 2026 13:09:47 -0700
Subject: [PATCH] drm/xe/rtp: Add struct types for RTP tables
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
We currently have a mixture of styles for our RTP tables with respect of how we define the number of entries:
* xe_rtp_process_to_sr() expects to receive the number of entries as
arguments;
* xe_rtp_process() expects the array to have a sentinel at the end of
the array; * in xe_rtp_test.c, even though xe_rtp_process_to_sr() does not require a sentinel value, we need to rely on that technique to be able to count xe_rtp_entry_sr entries because simply using ARRAY_SIZE() is not possible.
The style used by xe_rtp_process_to_sr() makes it hard to share the tables with other compilation units (e.g. kunit tests), since the number of entries is calculated with ARRAY_SIZE(), which is done at compile time.
Since we use the size of the tables to create some bitmasks, using a sentinel style doesn't seem great either.
A way to reconcile things into a single style is to have a struct type that would hold the entries array and the number of entries. Since we have xe_rtp_entry and xe_rtp_entry_sr, we would have one type for each.
The advantage of the proposed approach is that now we have a nice way to share the tables directly to kunit tests with information about their size.
v6:
- Removed sentinels that are not needed
v5:
- Removed added code from conflict resolution issues
v4:
- Removed conflicts with main branch
v3:
- No changes
v2:
- Add compatibility with new xe_rtp_table_sr format for "bad-mcr-reg-forced-to-regular" and "bad-regular-reg-forced-to-mcr"
drivers/gpu/drm/xe/tests/xe_rtp_test.c +40 -63
@@ -54,13 +54,13 @@ struct rtp_to_sr_test_case {unsigned long expected_count_sr_entries;unsigned int expected_sr_errors;unsigned long expected_active; -const struct xe_rtp_entry_sr *entries; +const struct xe_rtp_table_sr table; };struct rtp_test_case {const char *name;unsigned long expected_active; -const struct xe_rtp_entry *entries; +const struct xe_rtp_table table; };static bool fake_xe_gt_mcr_check_reg (struct xe_gt *gt,struct xe_reg reg)
@@ -289,7 +289,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = { .expected_active = BIT(0) | BIT(1), .expected_count_sr_entries = 1,/* Different bits on the same register: create a single entry */ - .entries = (const struct xe_rtp_entry_sr []) { + .table = XE_RTP_TABLE_SR( { XE_RTP_NAME("basic-1"), XE_RTP_RULES(FUNC(match_yes)), XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -298,8 +298,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {XE_RTP_RULES (FUNC (match_yes)),XE_RTP_ACTIONS (SET (REGULAR_REG1 ,REG_BIT (1 ))) }, - {} - }, + ), }, { .name = "no-match-no-add",
@@ -309,7 +308,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = { .expected_active = BIT(0), .expected_count_sr_entries = 1,/* Don't coalesce second entry since rules don't match */ - .entries = (const struct xe_rtp_entry_sr []) { + .table = XE_RTP_TABLE_SR( { XE_RTP_NAME("basic-1"), XE_RTP_RULES(FUNC(match_yes)), XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -318,8 +317,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {XE_RTP_RULES (FUNC (match_no)),XE_RTP_ACTIONS (SET (REGULAR_REG1 ,REG_BIT (1 ))) }, - {} - }, + ), }, { .name = "two-regs-two-entries",
@@ -329,7 +327,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = { .expected_active = BIT(0) | BIT(1), .expected_count_sr_entries = 2,/* Same bits on different registers are not coalesced */ - .entries = (const struct xe_rtp_entry_sr []) { + .table = XE_RTP_TABLE_SR( { XE_RTP_NAME("basic-1"), XE_RTP_RULES(FUNC(match_yes)), XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -338,8 +336,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {XE_RTP_RULES (FUNC (match_yes)),XE_RTP_ACTIONS (SET (REGULAR_REG2 ,REG_BIT (0 ))) }, - {} - }, + ), }, { .name = "clr-one-set-other",
@@ -349,7 +346,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = { .expected_active = BIT(0) | BIT(1), .expected_count_sr_entries = 1,/* Check clr vs set actions on different bits */ - .entries = (const struct xe_rtp_entry_sr []) { + .table = XE_RTP_TABLE_SR( { XE_RTP_NAME("basic-1"), XE_RTP_RULES(FUNC(match_yes)), XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -358,8 +355,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {XE_RTP_RULES (FUNC (match_yes)),XE_RTP_ACTIONS (CLR (REGULAR_REG1 ,REG_BIT (1 ))) }, - {} - }, + ), }, { #define TEMP_MASK REG_GENMASK(10, 8)
@@ -371,14 +367,13 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = { .expected_active = BIT(0), .expected_count_sr_entries = 1,/* Check FIELD_SET works */ - .entries = (const struct xe_rtp_entry_sr[]) { + .table = XE_RTP_TABLE_SR( { XE_RTP_NAME("basic-1"), XE_RTP_RULES(FUNC(match_yes)), XE_RTP_ACTIONS(FIELD_SET(REGULAR_REG1, TEMP_MASK, TEMP_FIELD)) }, - {} - }, + ), #undef TEMP_MASK #undef TEMP_FIELD },
@@ -390,7 +385,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = { .expected_active = BIT(0) | BIT(1), .expected_count_sr_entries = 1, .expected_sr_errors = 1, - .entries = (const struct xe_rtp_entry_sr []) { + .table = XE_RTP_TABLE_SR( { XE_RTP_NAME("basic-1"), XE_RTP_RULES(FUNC(match_yes)), XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -400,8 +395,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {XE_RTP_RULES (FUNC (match_yes)),XE_RTP_ACTIONS (SET (REGULAR_REG1 ,REG_BIT (0 ))) }, - {} - }, + ), }, { .name = "conflict-not-disjoint",
@@ -411,7 +405,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = { .expected_active = BIT(0) | BIT(1), .expected_count_sr_entries = 1, .expected_sr_errors = 1, - .entries = (const struct xe_rtp_entry_sr []) { + .table = XE_RTP_TABLE_SR( { XE_RTP_NAME("basic-1"), XE_RTP_RULES(FUNC(match_yes)), XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -421,8 +415,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {XE_RTP_RULES (FUNC (match_yes)),XE_RTP_ACTIONS (CLR (REGULAR_REG1 ,REG_GENMASK (1 ,0 ))) }, - {} - }, + ), }, { .name = "conflict-reg-type",
@@ -432,7 +425,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = { .expected_active = BIT(0) | BIT(1) | BIT(2), .expected_count_sr_entries = 1, .expected_sr_errors = 2, - .entries = (const struct xe_rtp_entry_sr []) { + .table = XE_RTP_TABLE_SR( { XE_RTP_NAME("basic-1"), XE_RTP_RULES(FUNC(match_yes)), XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -447,8 +440,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {XE_RTP_RULES (FUNC (match_yes)),XE_RTP_ACTIONS (SET (MASKED_REG1 ,REG_BIT (0 ))) }, - {} - }, + ), }, { .name = "bad-mcr-reg-forced-to-regular",
@@ -458,13 +450,12 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = { .expected_active = BIT(0), .expected_count_sr_entries = 1, .expected_sr_errors = 1, - .entries = (const struct xe_rtp_entry_sr []) { + .table = XE_RTP_TABLE_SR( { XE_RTP_NAME("bad-mcr-regular-reg"), XE_RTP_RULES(FUNC(match_yes)), XE_RTP_ACTIONS(SET(BAD_MCR_REG4, REG_BIT(0))) }, - {} - }, + ), }, { .name = "bad-regular-reg-forced-to-mcr",
@@ -474,13 +465,12 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = { .expected_active = BIT(0), .expected_count_sr_entries = 1, .expected_sr_errors = 1, - .entries = (const struct xe_rtp_entry_sr []) { + .table = XE_RTP_TABLE_SR( { XE_RTP_NAME("bad-regular-reg"), XE_RTP_RULES(FUNC(match_yes)), XE_RTP_ACTIONS(SET(BAD_REGULAR_REG5, REG_BIT(0))) }, - {} - }, + ), }, };
@@ -492,16 +482,12 @@ static void xe_rtp_process_to_sr_tests(struct kunit *test)struct xe_reg_sr *reg_sr = >->reg_sr;const struct xe_reg_sr_entry *sre, *sr_entry =NULL ;struct xe_rtp_process_ctx ctx =XE_RTP_PROCESS_CTX_INITIALIZER (gt); -unsigned long idx, count_sr_entries =0 , count_rtp_entries =0 , active =0 ; +unsigned long idx, count_sr_entries =0 , active =0 ;xe_reg_sr_init (reg_sr,"xe_rtp_to_sr_tests" , xe); -while (param->entries[count_rtp_entries].rules) - count_rtp_entries++; - -xe_rtp_process_ctx_enable_active_tracking (&ctx, &active, count_rtp_entries); -xe_rtp_process_to_sr (&ctx, param->entries, count_rtp_entries, - reg_sr, false); +xe_rtp_process_ctx_enable_active_tracking (&ctx, &active, param->table.n_entries); +xe_rtp_process_to_sr (&ctx, ¶m->table, reg_sr, false);xa_for_each (®_sr->xa, idx, sre) {if (idx == param->expected_reg.addr)
@@ -534,56 +520,52 @@ static const struct rtp_test_case rtp_cases[] = { { .name = "active1", .expected_active = BIT(0), - .entries = (const struct xe_rtp_entry[]) { + .table = XE_RTP_TABLE( { XE_RTP_NAME("r1"), XE_RTP_RULES(FUNC(match_yes)), }, - {} - }, + ), }, { .name = "active2", .expected_active = BIT(0) | BIT(1), - .entries = (const struct xe_rtp_entry []) { + .table = XE_RTP_TABLE( { XE_RTP_NAME("r1"), XE_RTP_RULES(FUNC(match_yes)), }, { XE_RTP_NAME("r2"), XE_RTP_RULES(FUNC(match_yes)), }, - {} - }, + ), }, { .name = "active-inactive", .expected_active = BIT(0), - .entries = (const struct xe_rtp_entry []) { + .table = XE_RTP_TABLE( { XE_RTP_NAME("r1"), XE_RTP_RULES(FUNC(match_yes)), }, { XE_RTP_NAME("r2"), XE_RTP_RULES(FUNC(match_no)), }, - {} - }, + ), }, { .name = "inactive-active", .expected_active = BIT(1), - .entries = (const struct xe_rtp_entry []) { + .table = XE_RTP_TABLE( { XE_RTP_NAME("r1"), XE_RTP_RULES(FUNC(match_no)), }, { XE_RTP_NAME("r2"), XE_RTP_RULES(FUNC(match_yes)), }, - {} - }, + ), }, { .name = "inactive-active-inactive", .expected_active = BIT(1), - .entries = (const struct xe_rtp_entry []) { + .table = XE_RTP_TABLE( { XE_RTP_NAME("r1"), XE_RTP_RULES(FUNC(match_no)), },
@@ -593,13 +575,12 @@ static const struct rtp_test_case rtp_cases[] = { { XE_RTP_NAME("r3"), XE_RTP_RULES(FUNC(match_no)), }, - {} - }, + ), }, { .name = "inactive-inactive-inactive", .expected_active = 0, - .entries = (const struct xe_rtp_entry[]) { + .table = XE_RTP_TABLE( { XE_RTP_NAME("r1"), XE_RTP_RULES(FUNC(match_no)), },
@@ -609,8 +590,7 @@ static const struct rtp_test_case rtp_cases[] = { {XE_RTP_NAME ("r3" ), XE_RTP_RULES(FUNC(match_no)), }, - {} - }, + ), }, };
@@ -620,13 +600,10 @@ static void xe_rtp_process_tests(struct kunit *test)struct xe_device *xe = test->priv;struct xe_gt *gt =xe_device_get_root_tile (xe)->primary_gt;struct xe_rtp_process_ctx ctx =XE_RTP_PROCESS_CTX_INITIALIZER (gt); -unsigned long count_rtp_entries =0 , active =0 ; +unsigned long active =0 ; -while (param->entries[count_rtp_entries].rules) - count_rtp_entries++; - -xe_rtp_process_ctx_enable_active_tracking (&ctx, &active, count_rtp_entries); -xe_rtp_process (&ctx, param->entries); +xe_rtp_process_ctx_enable_active_tracking (&ctx, &active, param->table.n_entries); +xe_rtp_process (&ctx, ¶m->table);KUNIT_EXPECT_EQ (test, active, param->expected_active); }
drivers/gpu/drm/xe/xe_hw_engine.c +6 -8
@@ -346,7 +346,7 @@ hw_engine_setup_default_lrc_state(struct xe_hw_engine *hwe)u32 blit_cctl_val =REG_FIELD_PREP (BLIT_CCTL_DST_MOCS_MASK , mocs_write_idx) |REG_FIELD_PREP (BLIT_CCTL_SRC_MOCS_MASK , mocs_read_idx);struct xe_rtp_process_ctx ctx =XE_RTP_PROCESS_CTX_INITIALIZER (hwe); -const struct xe_rtp_entry_sr lrc_setup[] = { + const struct xe_rtp_table_sr lrc_setup = XE_RTP_TABLE_SR(/* * Some blitter commands do not have a field for MOCS, those * commands will use MOCS index pointed by BLIT_CCTL.
@@ -369,10 +369,9 @@ hw_engine_setup_default_lrc_state(struct xe_hw_engine *hwe) PREEMPT_GPGPU_THREAD_GROUP_LEVEL)),XE_RTP_ENTRY_FLAG (FOREACH_ENGINE ) }, - }; + ); - xe_rtp_process_to_sr(&ctx, lrc_setup, ARRAY_SIZE(lrc_setup), - &hwe->reg_lrc, true); +xe_rtp_process_to_sr (&ctx, &lrc_setup, &hwe->reg_lrc, true); }void xe_hw_engine_setup_reg_lrc (struct xe_hw_engine *hwe)
@@ -408,7 +407,7 @@ hw_engine_setup_default_state(struct xe_hw_engine *hwe)u32 ring_cmd_cctl_val =REG_FIELD_PREP (CMD_CCTL_WRITE_OVERRIDE_MASK , mocs_write_idx) |REG_FIELD_PREP (CMD_CCTL_READ_OVERRIDE_MASK , mocs_read_idx);struct xe_rtp_process_ctx ctx =XE_RTP_PROCESS_CTX_INITIALIZER (hwe); -const struct xe_rtp_entry_sr engine_entries[] = { + const struct xe_rtp_table_sr engine_sr = XE_RTP_TABLE_SR( { XE_RTP_NAME("RING_CMD_CCTL_default_MOCS"), XE_RTP_RULES(FUNC(xe_rtp_match_always)), XE_RTP_ACTIONS(FIELD_SET(RING_CMD_CCTL(0),
@@ -465,10 +464,9 @@ hw_engine_setup_default_state(struct xe_hw_engine *hwe)XE_RTP_ACTIONS (SET (GFX_MODE (0 ),GFX_MSIX_INTERRUPT_ENABLE ,XE_RTP_ACTION_FLAG (ENGINE_BASE ))) }, - }; + ); -xe_rtp_process_to_sr (&ctx, engine_entries,ARRAY_SIZE (engine_entries), - &hwe->reg_sr, false); +xe_rtp_process_to_sr (&ctx, &engine_sr, &hwe->reg_sr, false); }static const struct engine_info *find_engine_info (enum xe_engine_class class,int instance)
drivers/gpu/drm/xe/xe_reg_whitelist.c +3 -4
@@ -41,7 +41,7 @@ static bool match_multi_queue_class(const struct xe_device *xe,return xe_gt_supports_multi_queue (gt, hwe->class); } -static const struct xe_rtp_entry_sr register_whitelist[] = { +static const struct xe_rtp_table_sr register_whitelist = XE_RTP_TABLE_SR( { XE_RTP_NAME("WaAllowPMDepthAndInvocationCountAccessFromUMD, 1408556865"), XE_RTP_RULES(GRAPHICS_VERSION_RANGE(1200, 1210), ENGINE_CLASS(RENDER)), XE_RTP_ACTIONS(WHITELIST(PS_INVOCATION_COUNT,
@@ -156,7 +156,7 @@ static const struct xe_rtp_entry_sr register_whitelist[] = {XE_RTP_RULES (FUNC (match_has_mert),ENGINE_CLASS (COPY )),XE_RTP_ACTIONS (WHITELIST_OA_MERT_MMIO_TRG ) }, -}; +);static void whitelist_apply_to_hwe (struct xe_hw_engine *hwe) {
@@ -204,8 +204,7 @@ void xe_reg_whitelist_process_engine(struct xe_hw_engine *hwe) {struct xe_rtp_process_ctx ctx =XE_RTP_PROCESS_CTX_INITIALIZER (hwe); -xe_rtp_process_to_sr (&ctx, register_whitelist,ARRAY_SIZE (register_whitelist), - &hwe->reg_whitelist, false); +xe_rtp_process_to_sr (&ctx, ®ister_whitelist, &hwe->reg_whitelist, false);whitelist_apply_to_hwe (hwe); }
drivers/gpu/drm/xe/xe_rtp.c +16 -15
@@ -326,8 +326,7 @@ static void rtp_mark_active(struct xe_device *xe,* xe_rtp_process_to_sr - Process all rtp @entries, adding the matching ones to * the save-restore argument. * @ctx: The context for processing the table, with one of device, gt or hwe -* @entries: Table with RTP definitions -* @n_entries: Number of entries to process, usually ARRAY_SIZE(entries) +* @table: Table with RTP definitions * @sr: Save-restore struct where matching rules execute the action. This can be * viewed as the "coalesced view" of multiple the tables. The bits for each * register set are expected not to collide with previously added entries
@@ -339,12 +338,10 @@ static void rtp_mark_active(struct xe_device *xe,* used to calculate the right register offset */ void xe_rtp_process_to_sr (struct xe_rtp_process_ctx *ctx, -const struct xe_rtp_entry_sr *entries, -size_t n_entries, +const struct xe_rtp_table_sr *table,struct xe_reg_sr *sr,bool process_in_vf) { -const struct xe_rtp_entry_sr *entry;struct xe_hw_engine *hwe =NULL ;struct xe_gt *gt =NULL ;struct xe_device *xe =NULL ;
@@ -354,9 +351,10 @@ void xe_rtp_process_to_sr(struct xe_rtp_process_ctx *ctx,if (!process_in_vf &&IS_SRIOV_VF (xe))return ; -xe_assert (xe, entries); +xe_assert (xe, table->entries); -for (entry = entries; entry - entries < n_entries; entry++) { +for (size_t i =0 ; i < table->n_entries; i++) { +const struct xe_rtp_entry_sr *entry = &table->entries[i];bool match = false;if (entry->flags &XE_RTP_ENTRY_FLAG_FOREACH_ENGINE ) {
@@ -371,37 +369,40 @@ void xe_rtp_process_to_sr(struct xe_rtp_process_ctx *ctx, }if (match) -rtp_mark_active (xe, ctx, entry - entries); +rtp_mark_active (xe, ctx, i); } }EXPORT_SYMBOL_IF_KUNIT (xe_rtp_process_to_sr);/** -* xe_rtp_process - Process all rtp @entries, without running any action +* xe_rtp_process - Process all entries in rtp @table, without running any action * @ctx: The context for processing the table, with one of device, gt or hwe -* @entries: Table with RTP definitions +* @table: Table with RTP definitions * -* Walk the table pointed by @entries (with an empty sentinel), executing the +* Walk the table pointed by @table, executing the * rules. One difference from xe_rtp_process_to_sr(): there is no action * associated with each entry since this uses struct xe_rtp_entry. Its main use * is for marking active workarounds via * xe_rtp_process_ctx_enable_active_tracking(). */ void xe_rtp_process (struct xe_rtp_process_ctx *ctx, -const struct xe_rtp_entry *entries) +const struct xe_rtp_table *table) { -const struct xe_rtp_entry *entry;struct xe_hw_engine *hwe;struct xe_gt *gt;struct xe_device *xe;rtp_get_context (ctx, &hwe, >, &xe); -for (entry = entries; entry && entry->rules; entry++) { +xe_assert (xe, table->entries); + +for (size_t i =0 ; i < table->n_entries; i++) { +const struct xe_rtp_entry *entry = &table->entries[i]; +if (!rule_matches (xe, gt, hwe, entry->rules, entry->n_rules))continue ; -rtp_mark_active (xe, ctx, entry - entries); +rtp_mark_active (xe, ctx, i); } }EXPORT_SYMBOL_IF_KUNIT (xe_rtp_process);
drivers/gpu/drm/xe/xe_rtp.h +13 -3
@@ -461,6 +461,16 @@ struct xe_reg_sr; XE_RTP_PASTE_FOREACH(ACTION_, COMMA, (__VA_ARGS__)) \ } +#define XE_RTP_TABLE_SR (...) { \ + .entries = (const struct xe_rtp_entry_sr[]){__VA_ARGS__}, \ + .n_entries = ARRAY_SIZE(((const struct xe_rtp_entry_sr[]){__VA_ARGS__})), \ +} + +#define XE_RTP_TABLE (...) { \ + .entries = (const struct xe_rtp_entry[]){__VA_ARGS__}, \ + .n_entries = ARRAY_SIZE(((const struct xe_rtp_entry[]){__VA_ARGS__})), \ +} +#define XE_RTP_PROCESS_CTX_INITIALIZER (arg__) _Generic((arg__), \ 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 }, \
@@ -471,12 +481,12 @@ void xe_rtp_process_ctx_enable_active_tracking(struct xe_rtp_process_ctx *ctx, size_t n_entries);void xe_rtp_process_to_sr (struct xe_rtp_process_ctx *ctx, -const struct xe_rtp_entry_sr *entries, -size_t n_entries,struct xe_reg_sr *sr, +const struct xe_rtp_table_sr *table, +struct xe_reg_sr *sr,bool process_in_vf);void xe_rtp_process (struct xe_rtp_process_ctx *ctx, -const struct xe_rtp_entry *entries); +const struct xe_rtp_table *table);/* Match functions to be used with XE_RTP_MATCH_FUNC */
drivers/gpu/drm/xe/xe_rtp_types.h +10 -0
@@ -112,6 +112,16 @@ struct xe_rtp_entry {u8 n_rules; }; +struct xe_rtp_table_sr { +const struct xe_rtp_entry_sr *entries; +size_t n_entries; +}; + +struct xe_rtp_table { +const struct xe_rtp_entry *entries; +size_t n_entries; +}; +enum xe_rtp_process_type {XE_RTP_PROCESS_TYPE_DEVICE ,XE_RTP_PROCESS_TYPE_GT ,
drivers/gpu/drm/xe/xe_tuning.c +21 -24
107 lines not on this page · raw message
drivers/gpu/drm/xe/xe_wa.c +47 -42
189 lines not on this page · raw message