Unverified Commit 2c02ef08 authored by openeuler-ci-bot's avatar openeuler-ci-bot Committed by Gitee
Browse files

!4032 intel: add TPMI base driver support for GNR 

Merge Pull Request from: @jiayingbao 
 
The TPMI (Topology Aware Register and PM Capsule Interface) provides a
flexible, extendable and PCIe enumerable MMIO interface for PM features.
The TPMI interface uses a PCI VSEC structure to expose the location of
MMIO region.
this change include:
Move PMT from MFD bus to auxiliary bus 
add intel_vsec for PMT/TPMI
backport bugfix for PMT
add TPMI base driver support on BHS platforms. RAPL, ISST, UFS are dependent on this driver.

Test:
tpmi debugfs function memdump and write pass.
telemetry function read/write test pass.
config:
+CONFIG_INTEL_TPMI=m
+CONFIG_AUXILIARY_BUS=y
-CONFIG_MFD_INTEL_PMT=m
+CONFIG_INTEL_VSEC=m
 
 
Link:https://gitee.com/openeuler/kernel/pulls/4032

 

Reviewed-by: default avatarXu Kuohai <xukuohai@huawei.com>
Reviewed-by: default avatarJason Zeng <jason.zeng@intel.com>
Reviewed-by: default avatarAichun Shi <aichun.shi@intel.com>
Reviewed-by: default avatarWeilong Chen <chenweilong@huawei.com>
Signed-off-by: default avatarJialin Zhang <zhangjialin11@huawei.com>
parents 9db5c334 3c8648c4

MAINTAINERS

+8 −4
Original line number Diff line number Diff line
@@ -9091,10 +9091,9 @@ F: drivers/mfd/intel_soc_pmic* 
F:	include/linux/mfd/intel_msic.h

F:	include/linux/mfd/intel_soc_pmic*









INTEL PMT DRIVER









M:	"David E. Box" <david.e.box@linux.intel.com>









S:	Maintained









F:	drivers/mfd/intel_pmt.c









INTEL PMT DRIVERS









M:	David E. Box <david.e.box@linux.intel.com>









S:	Supported









F:	drivers/platform/x86/intel_pmt_*

















INTEL PRO/WIRELESS 2100, 2200BG, 2915ABG NETWORK CONNECTION SUPPORT








@@ -9159,6 +9158,11 @@ L:	platform-driver-x86@vger.kernel.org







S:	Maintained









F:	drivers/platform/x86/intel-uncore-frequency.c

















INTEL VENDOR SPECIFIC EXTENDED CAPABILITIES DRIVER









M:	David E. Box <david.e.box@linux.intel.com>









S:	Supported









F:	drivers/platform/x86/vsec.*

















INTEL VIRTUAL BUTTON DRIVER









M:	AceLan Kao <acelan.kao@canonical.com>









L:	platform-driver-x86@vger.kernel.org
































arch/x86/configs/openeuler_defconfig



+3
−1






























Original line number
Diff line number
Diff line







@@ -2025,6 +2025,7 @@ CONFIG_YENTA_TOSHIBA=y







#









# Generic Driver Options









#









CONFIG_AUXILIARY_BUS=y









# CONFIG_UEVENT_HELPER is not set









CONFIG_DEVTMPFS=y









CONFIG_DEVTMPFS_MOUNT=y








@@ -4297,7 +4298,6 @@ CONFIG_MFD_INTEL_LPSS=y







CONFIG_MFD_INTEL_LPSS_ACPI=y









CONFIG_MFD_INTEL_LPSS_PCI=y









# CONFIG_MFD_INTEL_PMC_BXT is not set









CONFIG_MFD_INTEL_PMT=m









# CONFIG_MFD_IQS62X is not set









# CONFIG_MFD_JANZ_CMODIO is not set









# CONFIG_MFD_KEMPLD is not set








@@ -6629,6 +6629,7 @@ CONFIG_MLX_PLATFORM=m







CONFIG_INTEL_IPS=m









CONFIG_INTEL_RST=m









# CONFIG_INTEL_SMARTCONNECT is not set









CONFIG_INTEL_TPMI=m



















#









# Intel Speed Select Technology interface support








@@ -6638,6 +6639,7 @@ CONFIG_INTEL_SPEED_SELECT_INTERFACE=m

















CONFIG_INTEL_TURBO_MAX_3=y









# CONFIG_INTEL_UNCORE_FREQ_CONTROL is not set









CONFIG_INTEL_VSEC=m









CONFIG_INTEL_PMC_CORE=m









CONFIG_INTEL_PMT_CLASS=m









CONFIG_INTEL_PMT_TELEMETRY=m
































drivers/mfd/Kconfig



+0
−10






























Original line number
Diff line number
Diff line







@@ -699,16 +699,6 @@ config MFD_INTEL_PMC_BXT







	  Register and P-unit access. In addition this creates devices









	  for iTCO watchdog and telemetry that are part of the PMC.



















config MFD_INTEL_PMT









	tristate "Intel Platform Monitoring Technology (PMT) support"









	depends on PCI









	select MFD_CORE









	help









	  The Intel Platform Monitoring Technology (PMT) is an interface that









	  provides access to hardware monitor registers. This driver supports









	  Telemetry, Watcher, and Crashlog PMT capabilities/devices for









	  platforms starting from Tiger Lake.



















config MFD_IPAQ_MICRO









	bool "Atmel Micro ASIC (iPAQ h3100/h3600/h3700) Support"









	depends on SA1100_H3100 || SA1100_H3600
































drivers/mfd/Makefile



+0
−1






























Original line number
Diff line number
Diff line







@@ -216,7 +216,6 @@ obj-$(CONFIG_MFD_INTEL_LPSS_PCI)	+= intel-lpss-pci.o







obj-$(CONFIG_MFD_INTEL_LPSS_ACPI)	+= intel-lpss-acpi.o









obj-$(CONFIG_MFD_INTEL_MSIC)	+= intel_msic.o









obj-$(CONFIG_MFD_INTEL_PMC_BXT)	+= intel_pmc_bxt.o









obj-$(CONFIG_MFD_INTEL_PMT)	+= intel_pmt.o









obj-$(CONFIG_MFD_PALMAS)	+= palmas.o









obj-$(CONFIG_MFD_VIPERBOARD)    += viperboard.o









obj-$(CONFIG_MFD_RC5T583)	+= rc5t583.o rc5t583-irq.o
































drivers/mfd/intel_pmt.c
deleted100644 → 0



+0
−261






























Original line number
Diff line number
Diff line









// SPDX-License-Identifier: GPL-2.0









/*









 * Intel Platform Monitoring Technology PMT driver









 *









 * Copyright (c) 2020, Intel Corporation.









 * All Rights Reserved.









 *









 * Author: David E. Box <david.e.box@linux.intel.com>









 */



















#include <linux/bits.h>









#include <linux/kernel.h>









#include <linux/mfd/core.h>









#include <linux/module.h>









#include <linux/pci.h>









#include <linux/platform_device.h>









#include <linux/pm.h>









#include <linux/pm_runtime.h>









#include <linux/types.h>



















/* Intel DVSEC capability vendor space offsets */









#define INTEL_DVSEC_ENTRIES		0xA









#define INTEL_DVSEC_SIZE		0xB









#define INTEL_DVSEC_TABLE		0xC









#define INTEL_DVSEC_TABLE_BAR(x)	((x) & GENMASK(2, 0))









#define INTEL_DVSEC_TABLE_OFFSET(x)	((x) & GENMASK(31, 3))









#define INTEL_DVSEC_ENTRY_SIZE		4



















/* PMT capabilities */









#define DVSEC_INTEL_ID_TELEMETRY	2









#define DVSEC_INTEL_ID_WATCHER		3









#define DVSEC_INTEL_ID_CRASHLOG		4



















struct intel_dvsec_header {









	u16	length;









	u16	id;









	u8	num_entries;









	u8	entry_size;









	u8	tbir;









	u32	offset;









};



















enum pmt_quirks {









	/* Watcher capability not supported */









	PMT_QUIRK_NO_WATCHER	= BIT(0),



















	/* Crashlog capability not supported */









	PMT_QUIRK_NO_CRASHLOG	= BIT(1),



















	/* Use shift instead of mask to read discovery table offset */









	PMT_QUIRK_TABLE_SHIFT	= BIT(2),



















	/* DVSEC not present (provided in driver data) */









	PMT_QUIRK_NO_DVSEC	= BIT(3),









};



















struct pmt_platform_info {









	unsigned long quirks;









	struct intel_dvsec_header **capabilities;









};



















static const struct pmt_platform_info tgl_info = {









	.quirks = PMT_QUIRK_NO_WATCHER | PMT_QUIRK_NO_CRASHLOG |









		  PMT_QUIRK_TABLE_SHIFT,









};



















/* DG1 Platform with DVSEC quirk*/









static struct intel_dvsec_header dg1_telemetry = {









	.length = 0x10,









	.id = 2,









	.num_entries = 1,









	.entry_size = 3,









	.tbir = 0,









	.offset = 0x466000,









};



















static struct intel_dvsec_header *dg1_capabilities[] = {









	&dg1_telemetry,









	NULL









};



















static const struct pmt_platform_info dg1_info = {









	.quirks = PMT_QUIRK_NO_DVSEC,









	.capabilities = dg1_capabilities,









};



















static int pmt_add_dev(struct pci_dev *pdev, struct intel_dvsec_header *header,









		       unsigned long quirks)









{









	struct device *dev = &pdev->dev;









	struct resource *res, *tmp;









	struct mfd_cell *cell;









	const char *name;









	int count = header->num_entries;









	int size = header->entry_size;









	int id = header->id;









	int i;



















	switch (id) {









	case DVSEC_INTEL_ID_TELEMETRY:









		name = "pmt_telemetry";









		break;









	case DVSEC_INTEL_ID_WATCHER:









		if (quirks & PMT_QUIRK_NO_WATCHER) {









			dev_info(dev, "Watcher not supported\n");









			return -EINVAL;









		}









		name = "pmt_watcher";









		break;









	case DVSEC_INTEL_ID_CRASHLOG:









		if (quirks & PMT_QUIRK_NO_CRASHLOG) {









			dev_info(dev, "Crashlog not supported\n");









			return -EINVAL;









		}









		name = "pmt_crashlog";









		break;









	default:









		return -EINVAL;









	}



















	if (!header->num_entries || !header->entry_size) {









		dev_err(dev, "Invalid count or size for %s header\n", name);









		return -EINVAL;









	}



















	cell = devm_kzalloc(dev, sizeof(*cell), GFP_KERNEL);









	if (!cell)









		return -ENOMEM;



















	res = devm_kcalloc(dev, count, sizeof(*res), GFP_KERNEL);









	if (!res)









		return -ENOMEM;



















	if (quirks & PMT_QUIRK_TABLE_SHIFT)









		header->offset >>= 3;



















	/*









	 * The PMT DVSEC contains the starting offset and count for a block of









	 * discovery tables, each providing access to monitoring facilities for









	 * a section of the device. Create a resource list of these tables to









	 * provide to the driver.









	 */









	for (i = 0, tmp = res; i < count; i++, tmp++) {









		tmp->start = pdev->resource[header->tbir].start +









			     header->offset + i * (size << 2);









		tmp->end = tmp->start + (size << 2) - 1;









		tmp->flags = IORESOURCE_MEM;









	}



















	cell->resources = res;









	cell->num_resources = count;









	cell->name = name;



















	return devm_mfd_add_devices(dev, PLATFORM_DEVID_AUTO, cell, 1, NULL, 0,









				    NULL);









}



















static int pmt_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)









{









	struct pmt_platform_info *info;









	unsigned long quirks = 0;









	bool found_devices = false;









	int ret, pos = 0;



















	ret = pcim_enable_device(pdev);









	if (ret)









		return ret;



















	info = (struct pmt_platform_info *)id->driver_data;



















	if (info)









		quirks = info->quirks;



















	if (info && (info->quirks & PMT_QUIRK_NO_DVSEC)) {









		struct intel_dvsec_header **header;



















		header = info->capabilities;









		while (*header) {









			ret = pmt_add_dev(pdev, *header, quirks);









			if (ret)









				dev_warn(&pdev->dev,









					 "Failed to add device for DVSEC id %d\n",









					 (*header)->id);









			else









				found_devices = true;



















			++header;









		}









	} else {









		do {









			struct intel_dvsec_header header;









			u32 table;









			u16 vid;



















			pos = pci_find_next_ext_capability(pdev, pos, PCI_EXT_CAP_ID_DVSEC);









			if (!pos)









				break;



















			pci_read_config_word(pdev, pos + PCI_DVSEC_HEADER1, &vid);









			if (vid != PCI_VENDOR_ID_INTEL)









				continue;



















			pci_read_config_word(pdev, pos + PCI_DVSEC_HEADER2,









					     &header.id);









			pci_read_config_byte(pdev, pos + INTEL_DVSEC_ENTRIES,









					     &header.num_entries);









			pci_read_config_byte(pdev, pos + INTEL_DVSEC_SIZE,









					     &header.entry_size);









			pci_read_config_dword(pdev, pos + INTEL_DVSEC_TABLE,









					      &table);



















			header.tbir = INTEL_DVSEC_TABLE_BAR(table);









			header.offset = INTEL_DVSEC_TABLE_OFFSET(table);



















			ret = pmt_add_dev(pdev, &header, quirks);









			if (ret)









				continue;



















			found_devices = true;









		} while (true);









	}



















	if (!found_devices)









		return -ENODEV;



















	pm_runtime_put(&pdev->dev);









	pm_runtime_allow(&pdev->dev);



















	return 0;









}



















static void pmt_pci_remove(struct pci_dev *pdev)









{









	pm_runtime_forbid(&pdev->dev);









	pm_runtime_get_sync(&pdev->dev);









}



















#define PCI_DEVICE_ID_INTEL_PMT_ADL	0x467d









#define PCI_DEVICE_ID_INTEL_PMT_DG1	0x490e









#define PCI_DEVICE_ID_INTEL_PMT_OOBMSM	0x09a7









#define PCI_DEVICE_ID_INTEL_PMT_TGL	0x9a0d









static const struct pci_device_id pmt_pci_ids[] = {









	{ PCI_DEVICE_DATA(INTEL, PMT_ADL, &tgl_info) },









	{ PCI_DEVICE_DATA(INTEL, PMT_DG1, &dg1_info) },









	{ PCI_DEVICE_DATA(INTEL, PMT_OOBMSM, NULL) },









	{ PCI_DEVICE_DATA(INTEL, PMT_TGL, &tgl_info) },









	{ }









};









MODULE_DEVICE_TABLE(pci, pmt_pci_ids);



















static struct pci_driver pmt_pci_driver = {









	.name = "intel-pmt",









	.id_table = pmt_pci_ids,









	.probe = pmt_pci_probe,









	.remove = pmt_pci_remove,









};









module_pci_driver(pmt_pci_driver);



















MODULE_AUTHOR("David E. Box <david.e.box@linux.intel.com>");









MODULE_DESCRIPTION("Intel Platform Monitoring Technology PMT driver");









MODULE_LICENSE("GPL v2");