Commit e2729113 authored by Alexander Duyck's avatar Alexander Duyck Committed by Lee Jones
Browse files

platform/x86: Intel PMT class driver 



Intel Platform Monitoring Technology is meant to provide a common way to
access telemetry and system metrics.

Register mappings are not provided by the driver. Instead, a GUID is read
from a header for each endpoint. The GUID identifies the device and is to
be used with an XML, provided by the vendor, to discover the available set
of metrics and their register mapping.  This allows firmware updates to
modify the register space without needing to update the driver every time
with new mappings. Firmware writes a new GUID in this case to specify the
new mapping.  Software tools with access to the associated XML file can
then interpret the changes.

The module manages access to all Intel PMT endpoints on a system,
independent of the device exporting them. It creates an intel_pmt class
to manage the devices. For each telemetry endpoint, sysfs files provide
GUID and size information as well as a pointer to the parent device the
telemetry came from. Software may discover the association between
endpoints and devices by iterating through the list in sysfs, or by looking
for the existence of the class folder under the device of interest.  A
binary sysfs attribute of the same name allows software to then read or map
the telemetry space for direct access.

Signed-off-by: default avatarAlexander Duyck <alexander.h.duyck@linux.intel.com>
Signed-off-by: default avatarDavid E. Box <david.e.box@linux.intel.com>
Reviewed-by: default avatarHans de Goede <hdegoede@redhat.com>
Signed-off-by: default avatarLee Jones <lee.jones@linaro.org>
parent 4f8217d5

Documentation/ABI/testing/sysfs-class-intel_pmt

0 → 100644
+54 −0
Original line number Diff line number Diff line 
What:		/sys/class/intel_pmt/

Date:		October 2020

KernelVersion:	5.10

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

Description:

		The intel_pmt/ class directory contains information for

		devices that expose hardware telemetry using Intel Platform

		Monitoring Technology (PMT)



What:		/sys/class/intel_pmt/telem<x>

Date:		October 2020

KernelVersion:	5.10

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

Description:

		The telem<x> directory contains files describing an instance of

		a PMT telemetry device that exposes hardware telemetry. Each

		telem<x> directory has an associated telem file. This file

		may be opened and mapped or read to access the telemetry space

		of the device. The register layout of the telemetry space is

		determined from an XML file that matches the PCI device id and

		GUID for the device.



What:		/sys/class/intel_pmt/telem<x>/telem

Date:		October 2020

KernelVersion:	5.10

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

Description:

		(RO) The telemetry data for this telemetry device. This file

		may be mapped or read to obtain the data.



What:		/sys/class/intel_pmt/telem<x>/guid

Date:		October 2020

KernelVersion:	5.10

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

Description:

		(RO) The GUID for this telemetry device. The GUID identifies

		the version of the XML file for the parent device that is to

		be used to get the register layout.



What:		/sys/class/intel_pmt/telem<x>/size

Date:		October 2020

KernelVersion:	5.10

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

Description:

		(RO) The size of telemetry region in bytes that corresponds to

		the mapping size for the telem file.



What:		/sys/class/intel_pmt/telem<x>/offset

Date:		October 2020

KernelVersion:	5.10

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

Description:

		(RO) The offset of telemetry region in bytes that corresponds to

		the mapping for the telem file.

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -9025,6 +9025,7 @@ INTEL PMT DRIVER 
M:	"David E. Box" <david.e.box@linux.intel.com>

S:	Maintained

F:	drivers/mfd/intel_pmt.c

F:	drivers/platform/x86/intel_pmt_*









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









M:	Stanislav Yakovlev <stas.yakovlev@gmail.com>
































drivers/platform/x86/Kconfig



+12
−0






























Original line number
Diff line number
Diff line







@@ -1362,6 +1362,18 @@ config INTEL_PMC_CORE







		- LTR Ignore









		- MPHY/PLL gating status (Sunrisepoint PCH only)



















config INTEL_PMT_CLASS









	tristate "Intel Platform Monitoring Technology (PMT) Class driver"









	help









	  The Intel Platform Monitoring Technology (PMT) class driver provides









	  the basic sysfs interface and file hierarchy uses by PMT devices.



















	  For more information, see:









	  <file:Documentation/ABI/testing/sysfs-class-intel_pmt>



















	  To compile this driver as a module, choose M here: the module









	  will be called intel_pmt_class.



















config INTEL_PUNIT_IPC









	tristate "Intel P-Unit IPC Driver"









	help
































drivers/platform/x86/Makefile



+1
−0






























Original line number
Diff line number
Diff line







@@ -140,6 +140,7 @@ obj-$(CONFIG_INTEL_MFLD_THERMAL)	+= intel_mid_thermal.o







obj-$(CONFIG_INTEL_MID_POWER_BUTTON)	+= intel_mid_powerbtn.o









obj-$(CONFIG_INTEL_MRFLD_PWRBTN)	+= intel_mrfld_pwrbtn.o









obj-$(CONFIG_INTEL_PMC_CORE)		+= intel_pmc_core.o intel_pmc_core_pltdrv.o









obj-$(CONFIG_INTEL_PMT_CLASS)		+= intel_pmt_class.o









obj-$(CONFIG_INTEL_PUNIT_IPC)		+= intel_punit_ipc.o









obj-$(CONFIG_INTEL_SCU_IPC)		+= intel_scu_ipc.o









obj-$(CONFIG_INTEL_SCU_PCI)		+= intel_scu_pcidrv.o
































drivers/platform/x86/intel_pmt_class.c
0 → 100644



+297
−0






























Original line number
Diff line number
Diff line









// SPDX-License-Identifier: GPL-2.0









/*









 * Intel Platform Monitory Technology Telemetry driver









 *









 * Copyright (c) 2020, Intel Corporation.









 * All Rights Reserved.









 *









 * Author: "Alexander Duyck" <alexander.h.duyck@linux.intel.com>









 */



















#include <linux/kernel.h>









#include <linux/module.h>









#include <linux/mm.h>









#include <linux/pci.h>



















#include "intel_pmt_class.h"



















#define PMT_XA_START		0









#define PMT_XA_MAX		INT_MAX









#define PMT_XA_LIMIT		XA_LIMIT(PMT_XA_START, PMT_XA_MAX)



















/*









 * sysfs









 */









static ssize_t









intel_pmt_read(struct file *filp, struct kobject *kobj,









	       struct bin_attribute *attr, char *buf, loff_t off,









	       size_t count)









{









	struct intel_pmt_entry *entry = container_of(attr,









						     struct intel_pmt_entry,









						     pmt_bin_attr);



















	if (off < 0)









		return -EINVAL;



















	if (off >= entry->size)









		return 0;



















	if (count > entry->size - off)









		count = entry->size - off;



















	memcpy_fromio(buf, entry->base + off, count);



















	return count;









}



















static int









intel_pmt_mmap(struct file *filp, struct kobject *kobj,









		struct bin_attribute *attr, struct vm_area_struct *vma)









{









	struct intel_pmt_entry *entry = container_of(attr,









						     struct intel_pmt_entry,









						     pmt_bin_attr);









	unsigned long vsize = vma->vm_end - vma->vm_start;









	struct device *dev = kobj_to_dev(kobj);









	unsigned long phys = entry->base_addr;









	unsigned long pfn = PFN_DOWN(phys);









	unsigned long psize;



















	if (vma->vm_flags & (VM_WRITE | VM_MAYWRITE))









		return -EROFS;



















	psize = (PFN_UP(entry->base_addr + entry->size) - pfn) * PAGE_SIZE;









	if (vsize > psize) {









		dev_err(dev, "Requested mmap size is too large\n");









		return -EINVAL;









	}



















	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);









	if (io_remap_pfn_range(vma, vma->vm_start, pfn,









		vsize, vma->vm_page_prot))









		return -EAGAIN;



















	return 0;









}



















static ssize_t









guid_show(struct device *dev, struct device_attribute *attr, char *buf)









{









	struct intel_pmt_entry *entry = dev_get_drvdata(dev);



















	return sprintf(buf, "0x%x\n", entry->guid);









}









static DEVICE_ATTR_RO(guid);



















static ssize_t size_show(struct device *dev, struct device_attribute *attr,









			 char *buf)









{









	struct intel_pmt_entry *entry = dev_get_drvdata(dev);



















	return sprintf(buf, "%zu\n", entry->size);









}









static DEVICE_ATTR_RO(size);



















static ssize_t









offset_show(struct device *dev, struct device_attribute *attr, char *buf)









{









	struct intel_pmt_entry *entry = dev_get_drvdata(dev);



















	return sprintf(buf, "%lu\n", offset_in_page(entry->base_addr));









}









static DEVICE_ATTR_RO(offset);



















static struct attribute *intel_pmt_attrs[] = {









	&dev_attr_guid.attr,









	&dev_attr_size.attr,









	&dev_attr_offset.attr,









	NULL









};









ATTRIBUTE_GROUPS(intel_pmt);



















static struct class intel_pmt_class = {









	.name = "intel_pmt",









	.owner = THIS_MODULE,









	.dev_groups = intel_pmt_groups,









};



















static int intel_pmt_populate_entry(struct intel_pmt_entry *entry,









				    struct intel_pmt_header *header,









				    struct device *dev,









				    struct resource *disc_res)









{









	struct pci_dev *pci_dev = to_pci_dev(dev->parent);









	u8 bir;



















	/*









	 * The base offset should always be 8 byte aligned.









	 *









	 * For non-local access types the lower 3 bits of base offset









	 * contains the index of the base address register where the









	 * telemetry can be found.









	 */









	bir = GET_BIR(header->base_offset);



















	/* Local access and BARID only for now */









	switch (header->access_type) {









	case ACCESS_LOCAL:









		if (bir) {









			dev_err(dev,









				"Unsupported BAR index %d for access type %d\n",









				bir, header->access_type);









			return -EINVAL;









		}









		/*









		 * For access_type LOCAL, the base address is as follows:









		 * base address = end of discovery region + base offset









		 */









		entry->base_addr = disc_res->end + 1 + header->base_offset;









		break;









	case ACCESS_BARID:









		/*









		 * If another BAR was specified then the base offset









		 * represents the offset within that BAR. SO retrieve the









		 * address from the parent PCI device and add offset.









		 */









		entry->base_addr = pci_resource_start(pci_dev, bir) +









				   GET_ADDRESS(header->base_offset);









		break;









	default:









		dev_err(dev, "Unsupported access type %d\n",









			header->access_type);









		return -EINVAL;









	}



















	entry->guid = header->guid;









	entry->size = header->size;



















	return 0;









}



















static int intel_pmt_dev_register(struct intel_pmt_entry *entry,









				  struct intel_pmt_namespace *ns,









				  struct device *parent)









{









	struct resource res;









	struct device *dev;









	int ret;



















	ret = xa_alloc(ns->xa, &entry->devid, entry, PMT_XA_LIMIT, GFP_KERNEL);









	if (ret)









		return ret;



















	dev = device_create(&intel_pmt_class, parent, MKDEV(0, 0), entry,









			    "%s%d", ns->name, entry->devid);



















	if (IS_ERR(dev)) {









		dev_err(parent, "Could not create %s%d device node\n",









			ns->name, entry->devid);









		ret = PTR_ERR(dev);









		goto fail_dev_create;









	}



















	entry->kobj = &dev->kobj;



















	if (ns->attr_grp) {









		ret = sysfs_create_group(entry->kobj, ns->attr_grp);









		if (ret)









			goto fail_sysfs;









	}



















	/* if size is 0 assume no data buffer, so no file needed */









	if (!entry->size)









		return 0;



















	res.start = entry->base_addr;









	res.end = res.start + entry->size - 1;









	res.flags = IORESOURCE_MEM;



















	entry->base = devm_ioremap_resource(dev, &res);









	if (IS_ERR(entry->base)) {









		ret = PTR_ERR(entry->base);









		goto fail_ioremap;









	}



















	sysfs_bin_attr_init(&entry->pmt_bin_attr);









	entry->pmt_bin_attr.attr.name = ns->name;









	entry->pmt_bin_attr.attr.mode = 0440;









	entry->pmt_bin_attr.mmap = intel_pmt_mmap;









	entry->pmt_bin_attr.read = intel_pmt_read;









	entry->pmt_bin_attr.size = entry->size;



















	ret = sysfs_create_bin_file(&dev->kobj, &entry->pmt_bin_attr);









	if (!ret)









		return 0;



















fail_ioremap:









	sysfs_remove_group(entry->kobj, ns->attr_grp);









fail_sysfs:









	device_unregister(dev);









fail_dev_create:









	xa_erase(ns->xa, entry->devid);



















	return ret;









}



















int intel_pmt_dev_create(struct intel_pmt_entry *entry,









			 struct intel_pmt_namespace *ns,









			 struct platform_device *pdev, int idx)









{









	struct intel_pmt_header header;









	struct resource	*disc_res;









	int ret = -ENODEV;



















	disc_res = platform_get_resource(pdev, IORESOURCE_MEM, idx);









	if (!disc_res)









		return ret;



















	entry->disc_table = devm_platform_ioremap_resource(pdev, idx);









	if (IS_ERR(entry->disc_table))









		return PTR_ERR(entry->disc_table);



















	ret = ns->pmt_header_decode(entry, &header, &pdev->dev);









	if (ret)









		return ret;



















	ret = intel_pmt_populate_entry(entry, &header, &pdev->dev, disc_res);









	if (ret)









		return ret;



















	return intel_pmt_dev_register(entry, ns, &pdev->dev);



















}









EXPORT_SYMBOL_GPL(intel_pmt_dev_create);



















void intel_pmt_dev_destroy(struct intel_pmt_entry *entry,









			   struct intel_pmt_namespace *ns)









{









	struct device *dev = kobj_to_dev(entry->kobj);



















	if (entry->size)









		sysfs_remove_bin_file(entry->kobj, &entry->pmt_bin_attr);



















	if (ns->attr_grp)









		sysfs_remove_group(entry->kobj, ns->attr_grp);



















	device_unregister(dev);









	xa_erase(ns->xa, entry->devid);









}









EXPORT_SYMBOL_GPL(intel_pmt_dev_destroy);



















static int __init pmt_class_init(void)









{









	return class_register(&intel_pmt_class);









}



















static void __exit pmt_class_exit(void)









{









	class_unregister(&intel_pmt_class);









}



















module_init(pmt_class_init);









module_exit(pmt_class_exit);



















MODULE_AUTHOR("Alexander Duyck <alexander.h.duyck@linux.intel.com>");









MODULE_DESCRIPTION("Intel PMT Class driver");









MODULE_LICENSE("GPL v2");
































































CRA Git | Maintained and supported by SUSTech CRA and CCSE