linux/drivers/gpu/drm/xe/xe_sriov_pf.c

// SPDX-License-Identifier: MIT
/*
 * Copyright © 2023-2024 Intel Corporation
 */

#include <linux/debugfs.h>
#include <drm/drm_debugfs.h>
#include <drm/drm_managed.h>

#include "xe_assert.h"
#include "xe_configfs.h"
#include "xe_device.h"
#include "xe_gt_sriov_pf.h"
#include "xe_module.h"
#include "xe_sriov.h"
#include "xe_sriov_pf.h"
#include "xe_sriov_pf_helpers.h"
#include "xe_sriov_pf_migration.h"
#include "xe_sriov_pf_service.h"
#include "xe_sriov_pf_sysfs.h"
#include "xe_sriov_printk.h"

static unsigned int wanted_max_vfs(struct xe_device *xe)
{
	if (IS_ENABLED(CONFIG_CONFIGFS_FS))
		return xe_configfs_get_max_vfs(to_pci_dev(xe->drm.dev));
	return xe_modparam.max_vfs;
}

static int pf_reduce_totalvfs(struct xe_device *xe, int limit)
{
	struct device *dev = xe->drm.dev;
	struct pci_dev *pdev = to_pci_dev(dev);
	int err;

	err = pci_sriov_set_totalvfs(pdev, limit);
	if (err)
		xe_sriov_notice(xe, "Failed to set number of VFs to %d (%pe)\n",
				limit, ERR_PTR(err));
	return err;
}

static bool pf_continue_as_native(struct xe_device *xe, const char *why)
{
	xe_sriov_dbg(xe, "%s, continuing as native\n", why);
	pf_reduce_totalvfs(xe, 0);
	return false;
}

/**
 * xe_sriov_pf_readiness - Check if PF functionality can be enabled.
 * @xe: the &xe_device to check
 *
 * This function is called as part of the SR-IOV probe to validate if all
 * PF prerequisites are satisfied and we can continue with enabling PF mode.
 *
 * Return: true if the PF mode can be turned on.
 */
bool xe_sriov_pf_readiness(struct xe_device *xe)
{
	struct device *dev = xe->drm.dev;
	struct pci_dev *pdev = to_pci_dev(dev);
	int totalvfs = pci_sriov_get_totalvfs(pdev);
	int newlimit = min_t(u16, wanted_max_vfs(xe), totalvfs);

	xe_assert(xe, totalvfs <= U16_MAX);

	if (!dev_is_pf(dev))
		return false;

	if (!xe_device_uc_enabled(xe))
		return pf_continue_as_native(xe, "Guc submission disabled");

	if (!newlimit)
		return pf_continue_as_native(xe, "all VFs disabled");

	pf_reduce_totalvfs(xe, newlimit);

	xe->sriov.pf.device_total_vfs = totalvfs;
	xe->sriov.pf.driver_max_vfs = newlimit;

	return true;
}

/**
 * xe_sriov_pf_init_early - Initialize SR-IOV PF specific data.
 * @xe: the &xe_device to initialize
 *
 * Return: 0 on success or a negative error code on failure.
 */
int xe_sriov_pf_init_early(struct xe_device *xe)
{
	int err;

	xe_assert(xe, IS_SRIOV_PF(xe));

	xe->sriov.pf.vfs = drmm_kcalloc(&xe->drm, 1 + xe_sriov_pf_get_totalvfs(xe),
					sizeof(*xe->sriov.pf.vfs), GFP_KERNEL);
	if (!xe->sriov.pf.vfs)
		return -ENOMEM;

	err = drmm_mutex_init(&xe->drm, &xe->sriov.pf.master_lock);
	if (err)
		return err;

	err = xe_sriov_pf_migration_init(xe);
	if (err)
		return err;

	xe_guard_init(&xe->sriov.pf.guard_vfs_enabling, "vfs_enabling");

	xe_sriov_pf_service_init(xe);

	xe_mert_init_early(xe);

	return 0;
}

/**
 * xe_sriov_pf_init_late() - Late initialization of the SR-IOV PF.
 * @xe: the &xe_device to initialize
 *
 * This function can only be called on PF.
 *
 * Return: 0 on success or a negative error code on failure.
 */
int xe_sriov_pf_init_late(struct xe_device *xe)
{
	struct xe_gt *gt;
	unsigned int id;
	int err;

	xe_assert(xe, IS_SRIOV_PF(xe));

	for_each_gt(gt, xe, id) {
		err = xe_gt_sriov_pf_init(gt);
		if (err)
			return err;
	}

	err = xe_sriov_pf_sysfs_init(xe);
	if (err)
		return err;

	return 0;
}

/**
 * xe_sriov_pf_wait_ready() - Wait until PF is ready to operate.
 * @xe: the &xe_device to test
 *
 * This function can only be called on PF.
 *
 * Return: 0 on success or a negative error code on failure.
 */
int xe_sriov_pf_wait_ready(struct xe_device *xe)
{
	struct xe_gt *gt;
	unsigned int id;
	int err;

	if (xe_device_wedged(xe))
		return -ECANCELED;

	for_each_gt(gt, xe, id) {
		err = xe_gt_sriov_pf_wait_ready(gt);
		if (err)
			return err;
	}

	return 0;
}

/**
 * xe_sriov_pf_arm_guard() - Arm the guard for exclusive/lockdown mode.
 * @xe: the PF &xe_device
 * @guard: the &xe_guard to arm
 * @lockdown: arm for lockdown(true) or exclusive(false) mode
 * @who: the address of the new owner, or NULL if it's a caller
 *
 * This function can only be called on PF.
 *
 * It is a simple wrapper for xe_guard_arm() with additional debug
 * messages.
 *
 * Return: 0 on success or a negative error code on failure.
 */
int xe_sriov_pf_arm_guard(struct xe_device *xe, struct xe_guard *guard,
			  bool lockdown, void *who)
{
	void *new_owner = who ?: __builtin_return_address(0);
	int err;

	err = xe_guard_arm(guard, lockdown, new_owner);
	if (err) {
		xe_sriov_dbg(xe, "%s/%s mode denied (%pe) last owner %ps\n",
			     guard->name, xe_guard_mode_str(lockdown),
			     ERR_PTR(err), guard->owner);
		return err;
	}

	xe_sriov_dbg_verbose(xe, "%s/%s by %ps\n",
			     guard->name, xe_guard_mode_str(lockdown),
			     new_owner);
	return 0;
}

/**
 * xe_sriov_pf_disarm_guard() - Disarm the guard.
 * @xe: the PF &xe_device
 * @guard: the &xe_guard to disarm
 * @lockdown: disarm from lockdown(true) or exclusive(false) mode
 * @who: the address of the indirect owner, or NULL if it's a caller
 *
 * This function can only be called on PF.
 *
 * It is a simple wrapper for xe_guard_disarm() with additional debug
 * messages and xe_assert() to easily catch any illegal calls.
 */
void xe_sriov_pf_disarm_guard(struct xe_device *xe, struct xe_guard *guard,
			      bool lockdown, void *who)
{
	bool disarmed;

	xe_sriov_dbg_verbose(xe, "%s/%s by %ps\n",
			     guard->name, xe_guard_mode_str(lockdown),
			     who ?: __builtin_return_address(0));

	disarmed = xe_guard_disarm(guard, lockdown);
	xe_assert_msg(xe, disarmed, "%s/%s not armed? last owner %ps",
		      guard->name, xe_guard_mode_str(lockdown), guard->owner);
}

/**
 * xe_sriov_pf_lockdown() - Lockdown the PF to prevent VFs enabling.
 * @xe: the PF &xe_device
 *
 * This function can only be called on PF.
 *
 * Once the PF is locked down, it will not enable VFs.
 * If VFs are already enabled, the -EBUSY will be returned.
 * To allow the PF enable VFs again call xe_sriov_pf_end_lockdown().
 *
 * Return: 0 on success or a negative error code on failure.
 */
int xe_sriov_pf_lockdown(struct xe_device *xe)
{
	xe_assert(xe, IS_SRIOV_PF(xe));

	return xe_sriov_pf_arm_guard(xe, &xe->sriov.pf.guard_vfs_enabling, true,
				     __builtin_return_address(0));
}

/**
 * xe_sriov_pf_end_lockdown() - Allow the PF to enable VFs again.
 * @xe: the PF &xe_device
 *
 * This function can only be called on PF.
 * See xe_sriov_pf_lockdown() for details.
 */
void xe_sriov_pf_end_lockdown(struct xe_device *xe)
{
	xe_assert(xe, IS_SRIOV_PF(xe));

	xe_sriov_pf_disarm_guard(xe, &xe->sriov.pf.guard_vfs_enabling, true,
				 __builtin_return_address(0));
}

/**
 * xe_sriov_pf_print_vfs_summary - Print SR-IOV PF information.
 * @xe: the &xe_device to print info from
 * @p: the &drm_printer
 *
 * Print SR-IOV PF related information into provided DRM printer.
 */
void xe_sriov_pf_print_vfs_summary(struct xe_device *xe, struct drm_printer *p)
{
	struct pci_dev *pdev = to_pci_dev(xe->drm.dev);

	xe_assert(xe, IS_SRIOV_PF(xe));

	drm_printf(p, "total: %u\n", xe->sriov.pf.device_total_vfs);
	drm_printf(p, "supported: %u\n", xe->sriov.pf.driver_max_vfs);
	drm_printf(p, "enabled: %u\n", pci_num_vf(pdev));
}