Commit 5d902ee5 authored by Perry Yuan's avatar Perry Yuan Committed by Borislav Petkov (AMD)
Browse files

platform/x86: hfi: Introduce AMD Hardware Feedback Interface Driver 



The AMD Heterogeneous core design and Hardware Feedback Interface (HFI)
provide behavioral classification and a dynamically updated ranking table
for the scheduler to use when choosing cores for tasks.

There are two CPU core types defined: Classic and Dense. Classic cores are
the standard performance cores, while Dense cores are optimized for area and
efficiency.

Heterogeneous compute refers to CPU implementations that are comprised
of more than one architectural class, each with two capabilities. This
means each CPU reports two separate capabilities: "perf" and "eff".

Each capability lists all core ranking numbers between 0 and 255, where
a higher number represents a higher capability.

Heterogeneous systems can also extend to more than two architectural
classes.

The purpose of the scheduling feedback mechanism is to provide information
to the operating system scheduler in real time, allowing the scheduler to
direct threads to the optimal core during task scheduling.

All core ranking data are provided by the PMFW via a shared memory ranking
table, which the driver reads and uses to update core capabilities to the
scheduler. When the hardware updates the table, it generates a platform
interrupt to notify the OS to read the new ranking table.

Signed-off-by: default avatarPerry Yuan <perry.yuan@amd.com>
Co-developed-by: default avatarMario Limonciello <mario.limonciello@amd.com>
Signed-off-by: default avatarMario Limonciello <mario.limonciello@amd.com>
Signed-off-by: default avatarBorislav Petkov (AMD) <bp@alien8.de>
Reviewed-by: default avatarGautham R. Shenoy <gautham.shenoy@amd.com>
Reviewed-by: default avatarShyam Sundar S K <Shyam-sundar.S-k@amd.com>
Acked-by: default avatarIlpo Järvinen <ilpo.jarvinen@linux.intel.com>
Link: https://bugzilla.kernel.org/show_bug.cgi?id=206537
Link: https://lore.kernel.org/20250609200518.3616080-5-superm1@kernel.org
parent a3c4f339

drivers/platform/x86/amd/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
source "drivers/platform/x86/amd/hsmp/Kconfig"

source "drivers/platform/x86/amd/pmf/Kconfig"

source "drivers/platform/x86/amd/pmc/Kconfig"

source "drivers/platform/x86/amd/hfi/Kconfig"



config AMD_3D_VCACHE

	tristate "AMD 3D V-Cache Performance Optimizer Driver"

drivers/platform/x86/amd/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -11,3 +11,4 @@ obj-$(CONFIG_AMD_HSMP) += hsmp/ 
obj-$(CONFIG_AMD_PMF)		+= pmf/

obj-$(CONFIG_AMD_WBRF)		+= wbrf.o

obj-$(CONFIG_AMD_ISP_PLATFORM)	+= amd_isp4.o

obj-$(CONFIG_AMD_HFI)		+= hfi/

drivers/platform/x86/amd/hfi/Kconfig

0 → 100644
+17 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only

#

# AMD Hardware Feedback Interface Driver

#



config AMD_HFI

	bool "AMD Hetero Core Hardware Feedback Driver"

	depends on ACPI

	depends on CPU_SUP_AMD

	help

	  Select this option to enable the AMD Heterogeneous Core Hardware

	  Feedback Interface. If selected, hardware provides runtime thread

	  classification guidance to the operating system on the performance and

	  energy efficiency capabilities of each heterogeneous CPU core. These

	  capabilities may vary due to the inherent differences in the core types

	  and can also change as a result of variations in the operating

	  conditions of the system such as power and thermal limits.

drivers/platform/x86/amd/hfi/Makefile

0 → 100644
+7 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

#

# AMD Hardware Feedback Interface Driver

#



obj-$(CONFIG_AMD_HFI) += amd_hfi.o

amd_hfi-objs := hfi.o

drivers/platform/x86/amd/hfi/hfi.c

0 → 100644
+158 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * AMD Hardware Feedback Interface Driver

 *

 * Copyright (C) 2025 Advanced Micro Devices, Inc. All Rights Reserved.

 *

 * Authors: Perry Yuan <Perry.Yuan@amd.com>

 *          Mario Limonciello <mario.limonciello@amd.com>

 */



#define pr_fmt(fmt)  "amd-hfi: " fmt



#include <linux/acpi.h>

#include <linux/cpu.h>

#include <linux/cpumask.h>

#include <linux/gfp.h>

#include <linux/init.h>

#include <linux/io.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/mutex.h>

#include <linux/platform_device.h>

#include <linux/smp.h>



#define AMD_HFI_DRIVER		"amd_hfi"



#define AMD_HETERO_CPUID_27	0x80000027



static struct platform_device *device;



struct amd_hfi_data {

	const char	*name;

	struct device	*dev;

};



struct amd_hfi_classes {

	u32	perf;

	u32	eff;

};



/**

 * struct amd_hfi_cpuinfo - HFI workload class info per CPU

 * @cpu:		CPU index

 * @class_index:	workload class ID index

 * @nr_class:		max number of workload class supported

 * @amd_hfi_classes:	current CPU workload class ranking data

 *

 * Parameters of a logical processor linked with hardware feedback class.

 */

struct amd_hfi_cpuinfo {

	int		cpu;

	s16		class_index;

	u8		nr_class;

	struct amd_hfi_classes	*amd_hfi_classes;

};



static DEFINE_PER_CPU(struct amd_hfi_cpuinfo, amd_hfi_cpuinfo) = {.class_index = -1};



static int amd_hfi_alloc_class_data(struct platform_device *pdev)

{

	struct amd_hfi_cpuinfo *hfi_cpuinfo;

	struct device *dev = &pdev->dev;

	u32 nr_class_id;

	int idx;



	nr_class_id = cpuid_eax(AMD_HETERO_CPUID_27);

	if (nr_class_id > 255) {

		dev_err(dev, "number of supported classes too large: %d\n",

			nr_class_id);

		return -EINVAL;

	}



	for_each_possible_cpu(idx) {

		struct amd_hfi_classes *classes;



		classes = devm_kcalloc(dev,

				       nr_class_id,

				       sizeof(struct amd_hfi_classes),

				       GFP_KERNEL);

		if (!classes)

			return -ENOMEM;

		hfi_cpuinfo = per_cpu_ptr(&amd_hfi_cpuinfo, idx);

		hfi_cpuinfo->amd_hfi_classes = classes;

		hfi_cpuinfo->nr_class = nr_class_id;

	}



	return 0;

}



static const struct acpi_device_id amd_hfi_platform_match[] = {

	{"AMDI0104", 0},

	{ }

};

MODULE_DEVICE_TABLE(acpi, amd_hfi_platform_match);



static int amd_hfi_probe(struct platform_device *pdev)

{

	struct amd_hfi_data *amd_hfi_data;

	int ret;



	if (!acpi_match_device(amd_hfi_platform_match, &pdev->dev))

		return -ENODEV;



	amd_hfi_data = devm_kzalloc(&pdev->dev, sizeof(*amd_hfi_data), GFP_KERNEL);

	if (!amd_hfi_data)

		return -ENOMEM;



	amd_hfi_data->dev = &pdev->dev;

	platform_set_drvdata(pdev, amd_hfi_data);



	ret = amd_hfi_alloc_class_data(pdev);

	if (ret)

		return ret;



	return 0;

}



static struct platform_driver amd_hfi_driver = {

	.driver = {

		.name = AMD_HFI_DRIVER,

		.owner = THIS_MODULE,

		.acpi_match_table = ACPI_PTR(amd_hfi_platform_match),

	},

	.probe = amd_hfi_probe,

};



static int __init amd_hfi_init(void)

{

	int ret;



	if (acpi_disabled ||

	    !cpu_feature_enabled(X86_FEATURE_AMD_HTR_CORES) ||

	    !cpu_feature_enabled(X86_FEATURE_AMD_WORKLOAD_CLASS))

		return -ENODEV;



	device = platform_device_register_simple(AMD_HFI_DRIVER, -1, NULL, 0);

	if (IS_ERR(device)) {

		pr_err("unable to register HFI platform device\n");

		return PTR_ERR(device);

	}



	ret = platform_driver_register(&amd_hfi_driver);

	if (ret)

		pr_err("failed to register HFI driver\n");



	return ret;

}



static __exit void amd_hfi_exit(void)

{

	platform_driver_unregister(&amd_hfi_driver);

	platform_device_unregister(device);

}

module_init(amd_hfi_init);

module_exit(amd_hfi_exit);



MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("AMD Hardware Feedback Interface Driver");