Commit 48b05e3c authored by Michal Wajdeczko's avatar Michal Wajdeczko
Browse files

drm/xe/pf: Add support to configure GuC SR-IOV policies 



There are few knobs inside GuC firmware to control VFs scheduling.
Add basic functions to support their reconfigurations.
We will start using them shortly once we prepare debugfs.

Signed-off-by: default avatarMichal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Piotr Piórkowski <piotr.piorkowski@intel.com>
Reviewed-by: default avatarPiotr Piórkowski <piotr.piorkowski@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20240410170338.1199-6-michal.wajdeczko@intel.com
parent 0ddc1e07

drivers/gpu/drm/xe/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -161,6 +161,7 @@ xe-y += \ 


xe-$(CONFIG_PCI_IOV) += \

	xe_gt_sriov_pf_control.o \

	xe_gt_sriov_pf_policy.o \

	xe_lmtt.o \

	xe_lmtt_2l.o \

	xe_lmtt_ml.o \

drivers/gpu/drm/xe/xe_gt_sriov_pf_policy.c

0 → 100644
+417 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: MIT

/*

 * Copyright © 2023-2024 Intel Corporation

 */



#include "abi/guc_actions_sriov_abi.h"



#include "xe_bo.h"

#include "xe_gt.h"

#include "xe_gt_sriov_pf_helpers.h"

#include "xe_gt_sriov_pf_policy.h"

#include "xe_gt_sriov_printk.h"

#include "xe_guc_ct.h"

#include "xe_guc_klv_helpers.h"



/*

 * Return: number of KLVs that were successfully parsed and saved,

 *         negative error code on failure.

 */

static int guc_action_update_vgt_policy(struct xe_guc *guc, u64 addr, u32 size)

{

	u32 request[] = {

		GUC_ACTION_PF2GUC_UPDATE_VGT_POLICY,

		lower_32_bits(addr),

		upper_32_bits(addr),

		size,

	};



	return xe_guc_ct_send_block(&guc->ct, request, ARRAY_SIZE(request));

}



/*

 * Return: number of KLVs that were successfully parsed and saved,

 *         negative error code on failure.

 */

static int pf_send_policy_klvs(struct xe_gt *gt, const u32 *klvs, u32 num_dwords)

{

	const u32 bytes = num_dwords * sizeof(u32);

	struct xe_tile *tile = gt_to_tile(gt);

	struct xe_device *xe = tile_to_xe(tile);

	struct xe_guc *guc = &gt->uc.guc;

	struct xe_bo *bo;

	int ret;



	bo = xe_bo_create_pin_map(xe, tile, NULL,

				  ALIGN(bytes, PAGE_SIZE),

				  ttm_bo_type_kernel,

				  XE_BO_FLAG_VRAM_IF_DGFX(tile) |

				  XE_BO_FLAG_GGTT);

	if (IS_ERR(bo))

		return PTR_ERR(bo);



	xe_map_memcpy_to(xe, &bo->vmap, 0, klvs, bytes);



	ret = guc_action_update_vgt_policy(guc, xe_bo_ggtt_addr(bo), num_dwords);



	xe_bo_unpin_map_no_vm(bo);



	return ret;

}



/*

 * Return: 0 on success, -ENOKEY if some KLVs were not updated, -EPROTO if reply was malformed,

 *         negative error code on failure.

 */

static int pf_push_policy_klvs(struct xe_gt *gt, u32 num_klvs,

			       const u32 *klvs, u32 num_dwords)

{

	int ret;



	xe_gt_assert(gt, num_klvs == xe_guc_klv_count(klvs, num_dwords));



	ret = pf_send_policy_klvs(gt, klvs, num_dwords);



	if (ret != num_klvs) {

		int err = ret < 0 ? ret : ret < num_klvs ? -ENOKEY : -EPROTO;

		struct drm_printer p = xe_gt_info_printer(gt);



		xe_gt_sriov_notice(gt, "Failed to push %u policy KLV%s (%pe)\n",

				   num_klvs, str_plural(num_klvs), ERR_PTR(err));

		xe_guc_klv_print(klvs, num_dwords, &p);

		return err;

	}



	return 0;

}



static int pf_push_policy_u32(struct xe_gt *gt, u16 key, u32 value)

{

	u32 klv[] = {

		PREP_GUC_KLV(key, 1),

		value,

	};



	return pf_push_policy_klvs(gt, 1, klv, ARRAY_SIZE(klv));

}



static int pf_update_policy_bool(struct xe_gt *gt, u16 key, bool *policy, bool value)

{

	int err;



	err = pf_push_policy_u32(gt, key, value);

	if (unlikely(err)) {

		xe_gt_sriov_notice(gt, "Failed to update policy %#x '%s' to '%s' (%pe)\n",

				   key, xe_guc_klv_key_to_string(key),

				   str_enabled_disabled(value), ERR_PTR(err));

		return err;

	}



	xe_gt_sriov_dbg(gt, "policy key %#x '%s' updated to '%s'\n",

			key, xe_guc_klv_key_to_string(key),

			str_enabled_disabled(value));



	*policy = value;

	return 0;

}



static int pf_update_policy_u32(struct xe_gt *gt, u16 key, u32 *policy, u32 value)

{

	int err;



	err = pf_push_policy_u32(gt, key, value);

	if (unlikely(err)) {

		xe_gt_sriov_notice(gt, "Failed to update policy %#x '%s' to '%s' (%pe)\n",

				   key, xe_guc_klv_key_to_string(key),

				   str_enabled_disabled(value), ERR_PTR(err));

		return err;

	}



	xe_gt_sriov_dbg(gt, "policy key %#x '%s' updated to %u\n",

			key, xe_guc_klv_key_to_string(key), value);



	*policy = value;

	return 0;

}



static int pf_provision_sched_if_idle(struct xe_gt *gt, bool enable)

{

	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));

	lockdep_assert_held(xe_gt_sriov_pf_master_mutex(gt));



	return pf_update_policy_bool(gt, GUC_KLV_VGT_POLICY_SCHED_IF_IDLE_KEY,

				     &gt->sriov.pf.policy.guc.sched_if_idle,

				     enable);

}



static int pf_reprovision_sched_if_idle(struct xe_gt *gt)

{

	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));

	lockdep_assert_held(xe_gt_sriov_pf_master_mutex(gt));



	return pf_provision_sched_if_idle(gt, gt->sriov.pf.policy.guc.sched_if_idle);

}



static void pf_sanitize_sched_if_idle(struct xe_gt *gt)

{

	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));

	lockdep_assert_held(xe_gt_sriov_pf_master_mutex(gt));



	gt->sriov.pf.policy.guc.sched_if_idle = false;

}



/**

 * xe_gt_sriov_pf_policy_set_sched_if_idle - Control the 'sched_if_idle' policy.

 * @gt: the &xe_gt where to apply the policy

 * @enable: the value of the 'sched_if_idle' policy

 *

 * This function can only be called on PF.

 *

 * Return: 0 on success or a negative error code on failure.

 */

int xe_gt_sriov_pf_policy_set_sched_if_idle(struct xe_gt *gt, bool enable)

{

	int err;



	mutex_lock(xe_gt_sriov_pf_master_mutex(gt));

	err = pf_provision_sched_if_idle(gt, enable);

	mutex_unlock(xe_gt_sriov_pf_master_mutex(gt));



	return err;

}



/**

 * xe_gt_sriov_pf_policy_get_sched_if_idle - Retrieve value of 'sched_if_idle' policy.

 * @gt: the &xe_gt where to read the policy from

 *

 * This function can only be called on PF.

 *

 * Return: value of 'sched_if_idle' policy.

 */

bool xe_gt_sriov_pf_policy_get_sched_if_idle(struct xe_gt *gt)

{

	bool enable;



	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));



	mutex_lock(xe_gt_sriov_pf_master_mutex(gt));

	enable = gt->sriov.pf.policy.guc.sched_if_idle;

	mutex_unlock(xe_gt_sriov_pf_master_mutex(gt));



	return enable;

}



static int pf_provision_reset_engine(struct xe_gt *gt, bool enable)

{

	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));

	lockdep_assert_held(xe_gt_sriov_pf_master_mutex(gt));



	return pf_update_policy_bool(gt, GUC_KLV_VGT_POLICY_RESET_AFTER_VF_SWITCH_KEY,

				     &gt->sriov.pf.policy.guc.reset_engine, enable);

}



static int pf_reprovision_reset_engine(struct xe_gt *gt)

{

	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));

	lockdep_assert_held(xe_gt_sriov_pf_master_mutex(gt));



	return pf_provision_reset_engine(gt, gt->sriov.pf.policy.guc.reset_engine);

}



static void pf_sanitize_reset_engine(struct xe_gt *gt)

{

	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));

	lockdep_assert_held(xe_gt_sriov_pf_master_mutex(gt));



	gt->sriov.pf.policy.guc.reset_engine = false;

}



/**

 * xe_gt_sriov_pf_policy_set_reset_engine - Control the 'reset_engine' policy.

 * @gt: the &xe_gt where to apply the policy

 * @enable: the value of the 'reset_engine' policy

 *

 * This function can only be called on PF.

 *

 * Return: 0 on success or a negative error code on failure.

 */

int xe_gt_sriov_pf_policy_set_reset_engine(struct xe_gt *gt, bool enable)

{

	int err;



	mutex_lock(xe_gt_sriov_pf_master_mutex(gt));

	err = pf_provision_reset_engine(gt, enable);

	mutex_unlock(xe_gt_sriov_pf_master_mutex(gt));



	return err;

}



/**

 * xe_gt_sriov_pf_policy_get_reset_engine - Retrieve value of 'reset_engine' policy.

 * @gt: the &xe_gt where to read the policy from

 *

 * This function can only be called on PF.

 *

 * Return: value of 'reset_engine' policy.

 */

bool xe_gt_sriov_pf_policy_get_reset_engine(struct xe_gt *gt)

{

	bool enable;



	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));



	mutex_lock(xe_gt_sriov_pf_master_mutex(gt));

	enable = gt->sriov.pf.policy.guc.reset_engine;

	mutex_unlock(xe_gt_sriov_pf_master_mutex(gt));



	return enable;

}



static int pf_provision_sample_period(struct xe_gt *gt, u32 value)

{

	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));

	lockdep_assert_held(xe_gt_sriov_pf_master_mutex(gt));



	return pf_update_policy_u32(gt, GUC_KLV_VGT_POLICY_ADVERSE_SAMPLE_PERIOD_KEY,

				    &gt->sriov.pf.policy.guc.sample_period, value);

}



static int pf_reprovision_sample_period(struct xe_gt *gt)

{

	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));

	lockdep_assert_held(xe_gt_sriov_pf_master_mutex(gt));



	return pf_provision_sample_period(gt, gt->sriov.pf.policy.guc.sample_period);

}



static void pf_sanitize_sample_period(struct xe_gt *gt)

{

	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));

	lockdep_assert_held(xe_gt_sriov_pf_master_mutex(gt));



	gt->sriov.pf.policy.guc.sample_period = 0;

}



/**

 * xe_gt_sriov_pf_policy_set_sample_period - Control the 'sample_period' policy.

 * @gt: the &xe_gt where to apply the policy

 * @value: the value of the 'sample_period' policy

 *

 * This function can only be called on PF.

 *

 * Return: 0 on success or a negative error code on failure.

 */

int xe_gt_sriov_pf_policy_set_sample_period(struct xe_gt *gt, u32 value)

{

	int err;



	mutex_lock(xe_gt_sriov_pf_master_mutex(gt));

	err = pf_provision_sample_period(gt, value);

	mutex_unlock(xe_gt_sriov_pf_master_mutex(gt));



	return err;

}



/**

 * xe_gt_sriov_pf_policy_get_sample_period - Retrieve value of 'sample_period' policy.

 * @gt: the &xe_gt where to read the policy from

 *

 * This function can only be called on PF.

 *

 * Return: value of 'sample_period' policy.

 */

u32 xe_gt_sriov_pf_policy_get_sample_period(struct xe_gt *gt)

{

	u32 value;



	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));



	mutex_lock(xe_gt_sriov_pf_master_mutex(gt));

	value = gt->sriov.pf.policy.guc.sample_period;

	mutex_unlock(xe_gt_sriov_pf_master_mutex(gt));



	return value;

}



static void pf_sanitize_guc_policies(struct xe_gt *gt)

{

	pf_sanitize_sched_if_idle(gt);

	pf_sanitize_reset_engine(gt);

	pf_sanitize_sample_period(gt);

}



/**

 * xe_gt_sriov_pf_policy_sanitize - Reset policy settings.

 * @gt: the &xe_gt

 *

 * This function can only be called on PF.

 *

 * Return: 0 on success or a negative error code on failure.

 */

void xe_gt_sriov_pf_policy_sanitize(struct xe_gt *gt)

{

	mutex_lock(xe_gt_sriov_pf_master_mutex(gt));

	pf_sanitize_guc_policies(gt);

	mutex_unlock(xe_gt_sriov_pf_master_mutex(gt));

}



/**

 * xe_gt_sriov_pf_policy_reprovision - Reprovision (and optionally reset) policy settings.

 * @gt: the &xe_gt

 * @reset: if true will reprovision using default values instead of latest

 *

 * This function can only be called on PF.

 *

 * Return: 0 on success or a negative error code on failure.

 */

int xe_gt_sriov_pf_policy_reprovision(struct xe_gt *gt, bool reset)

{

	int err = 0;



	xe_device_mem_access_get(gt_to_xe(gt));



	mutex_lock(xe_gt_sriov_pf_master_mutex(gt));

	if (reset)

		pf_sanitize_guc_policies(gt);

	err |= pf_reprovision_sched_if_idle(gt);

	err |= pf_reprovision_reset_engine(gt);

	err |= pf_reprovision_sample_period(gt);

	mutex_unlock(xe_gt_sriov_pf_master_mutex(gt));



	xe_device_mem_access_put(gt_to_xe(gt));



	return err ? -ENXIO : 0;

}



static void print_guc_policies(struct drm_printer *p, struct xe_gt_sriov_guc_policies *policy)

{

	drm_printf(p, "%s:\t%s\n",

		   xe_guc_klv_key_to_string(GUC_KLV_VGT_POLICY_SCHED_IF_IDLE_KEY),

		   str_enabled_disabled(policy->sched_if_idle));

	drm_printf(p, "%s:\t%s\n",

		   xe_guc_klv_key_to_string(GUC_KLV_VGT_POLICY_RESET_AFTER_VF_SWITCH_KEY),

		   str_enabled_disabled(policy->reset_engine));

	drm_printf(p, "%s:\t%u %s\n",

		   xe_guc_klv_key_to_string(GUC_KLV_VGT_POLICY_ADVERSE_SAMPLE_PERIOD_KEY),

		   policy->sample_period, policy->sample_period ? "ms" : "(disabled)");

}



/**

 * xe_gt_sriov_pf_policy_print - Dump actual policy values.

 * @gt: the &xe_gt where to read the policy from

 * @p: the &drm_printer

 *

 * This function can only be called on PF.

 *

 * Return: 0 on success or a negative error code on failure.

 */

int xe_gt_sriov_pf_policy_print(struct xe_gt *gt, struct drm_printer *p)

{

	xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));



	mutex_lock(xe_gt_sriov_pf_master_mutex(gt));

	print_guc_policies(p, &gt->sriov.pf.policy.guc);

	mutex_unlock(xe_gt_sriov_pf_master_mutex(gt));



	return 0;

}

drivers/gpu/drm/xe/xe_gt_sriov_pf_policy.h

0 → 100644
+25 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: MIT */

/*

 * Copyright © 2023-2024 Intel Corporation

 */



#ifndef _XE_GT_SRIOV_PF_POLICY_H_

#define _XE_GT_SRIOV_PF_POLICY_H_



#include <linux/types.h>



struct drm_printer;

struct xe_gt;



int xe_gt_sriov_pf_policy_set_sched_if_idle(struct xe_gt *gt, bool enable);

bool xe_gt_sriov_pf_policy_get_sched_if_idle(struct xe_gt *gt);

int xe_gt_sriov_pf_policy_set_reset_engine(struct xe_gt *gt, bool enable);

bool xe_gt_sriov_pf_policy_get_reset_engine(struct xe_gt *gt);

int xe_gt_sriov_pf_policy_set_sample_period(struct xe_gt *gt, u32 value);

u32 xe_gt_sriov_pf_policy_get_sample_period(struct xe_gt *gt);



void xe_gt_sriov_pf_policy_sanitize(struct xe_gt *gt);

int xe_gt_sriov_pf_policy_reprovision(struct xe_gt *gt, bool reset);

int xe_gt_sriov_pf_policy_print(struct xe_gt *gt, struct drm_printer *p);



#endif

drivers/gpu/drm/xe/xe_gt_sriov_pf_policy_types.h

0 → 100644
+31 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: MIT */

/*

 * Copyright © 2023-2024 Intel Corporation

 */



#ifndef _XE_GT_SRIOV_PF_POLICY_TYPES_H_

#define _XE_GT_SRIOV_PF_POLICY_TYPES_H_



#include <linux/types.h>



/**

 * struct xe_gt_sriov_guc_policies - GuC SR-IOV policies.

 * @sched_if_idle: controls strict scheduling policy.

 * @reset_engine: controls engines reset on VF switch policy.

 * @sample_period: adverse events sampling period (in milliseconds).

 */

struct xe_gt_sriov_guc_policies {

	bool sched_if_idle;

	bool reset_engine;

	u32 sample_period;

};



/**

 * struct xe_gt_sriov_pf_policy - PF policy data.

 * @guc: GuC scheduling policies.

 */

struct xe_gt_sriov_pf_policy {

	struct xe_gt_sriov_guc_policies guc;

};



#endif

drivers/gpu/drm/xe/xe_gt_sriov_pf_types.h

0 → 100644
+21 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: MIT */

/*

 * Copyright © 2023-2024 Intel Corporation

 */



#ifndef _XE_GT_SRIOV_PF_TYPES_H_

#define _XE_GT_SRIOV_PF_TYPES_H_



#include <linux/types.h>



#include "xe_gt_sriov_pf_policy_types.h"



/**

 * struct xe_gt_sriov_pf - GT level PF virtualization data.

 * @policy: policy data.

 */

struct xe_gt_sriov_pf {

	struct xe_gt_sriov_pf_policy policy;

};



#endif