blob: 816606767b826858771785ecd7884d43dfa70a3d [file] [edit]
// SPDX-License-Identifier: GPL-2.0-only
/*
* Enumeration independent part of the Intel TPMI driver
*
* Copyright (c) 2026, Intel Corporation.
* All Rights Reserved.
*
* The TPMI (Topology Aware Register and PM Capsule Interface) provides a
* flexible, extendable and PCIe enumerable MMIO interface for PM features.
*
* For example Intel RAPL (Running Average Power Limit) provides a MMIO
* interface using TPMI. This has advantage over traditional MSR
* (Model Specific Register) interface, where a thread needs to be scheduled
* on the target CPU to read or write. Also the RAPL features vary between
* CPU models, and hence lot of model specific code. Here TPMI provides an
* architectural interface by providing hierarchical tables and fields,
* which will not need any model specific implementation.
*
* The TPMI specification defines a PFS (PM Feature Structure) table.
* This table is present in the TPMI MMIO region. Each TPMI PM feature
* has one entry in the PFS with a unique TPMI ID and its access details.
*
* The names of the devices created for the PM features start with the
* "intel_vsec.tpmi-" prefix which is followed by a specific name of the
* given PM feature (for example, "intel_vsec.tpmi-rapl.0").
*
* The device nodes are create by using interface "intel_vsec_add_aux()"
* provided by the Intel VSEC driver.
*/
#include <linux/align.h>
#include <linux/array_size.h>
#include <linux/auxiliary_bus.h>
#include <linux/bitfield.h>
#include <linux/bits.h>
#include <linux/cleanup.h>
#include <linux/compiler_attributes.h>
#include <linux/debugfs.h>
#include <linux/delay.h>
#include <linux/export.h>
#include <linux/idr.h>
#include <linux/intel_tpmi.h>
#include <linux/intel_vsec.h>
#include <linux/iopoll.h>
#include <linux/ioport.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/notifier.h>
#include <linux/pci.h>
#include <linux/security.h>
#include <linux/seq_file.h>
#include <linux/sizes.h>
#include <linux/slab.h>
#include <linux/string_helpers.h>
#include <linux/time64.h>
#include <linux/types.h>
#include "tpmi_common.h"
/**
* struct intel_tpmi_pfs_entry - TPMI PM Feature Structure (PFS) entry
* @tpmi_id: TPMI feature identifier (what the feature is and its data format).
* @num_entries: Number of feature interface instances present in the PFS.
* This represents the maximum number of Power domains in the SoC.
* @entry_size: Interface instance entry size in 32-bit words.
* @cap_offset: Offset from the PM_Features base address to the base of the PM VSEC
* register bank in KB.
* @attribute: Feature attribute: 0=BIOS. 1=OS. 2-3=Reserved.
* @reserved: Bits for use in the future.
*
* Represents one TPMI feature entry data in the PFS retrieved as is
* from the hardware.
*/
struct intel_tpmi_pfs_entry {
u64 tpmi_id:8;
u64 num_entries:8;
u64 entry_size:16;
u64 cap_offset:16;
u64 attribute:2;
u64 reserved:14;
} __packed;
/**
* struct intel_tpmi_pm_feature - TPMI PM Feature information for a TPMI ID
* @pfs_header: PFS header retireved from the hardware.
* @vsec_offset: Starting MMIO address for this feature in bytes. Essentially
* this offset = "Address" from VSEC header + PFS Capability
* offset for this feature entry.
*
* Represents TPMI instance information for one TPMI ID.
*/
struct intel_tpmi_pm_feature {
struct intel_tpmi_pfs_entry pfs_header;
u64 vsec_offset;
};
/**
* struct tpmi_info_header - CPU package ID to PCI device mapping information
* @fn: PCI function number
* @dev: PCI device number
* @bus: PCI bus number
* @pkg: CPU Package id
* @segment: PCI segment id
* @partition: Package Partition id
* @cdie_mask: Bitmap of compute dies in the current partition
* @reserved: Reserved for future use
* @lock: When set to 1 the register is locked and becomes read-only
* until next reset. Not for use by the OS driver.
*
* The structure to read hardware provided mapping information.
*/
struct tpmi_info_header {
u64 fn:3;
u64 dev:5;
u64 bus:8;
u64 pkg:8;
u64 segment:8;
u64 partition:2;
u64 cdie_mask:16;
u64 reserved:13;
u64 lock:1;
} __packed;
/**
* struct tpmi_feature_state - Structure to read hardware state of a feature
* @enabled: Enable state of a feature, 1: enabled, 0: disabled
* @reserved_1: Reserved for future use
* @write_blocked: Writes are blocked means all write operations are ignored
* @read_blocked: Reads are blocked means will read 0xFFs
* @pcs_select: Interface used by out of band software, not used in OS
* @reserved_2: Reserved for future use
* @id: TPMI ID of the feature
* @reserved_3: Reserved for future use
* @locked: When set to 1, OS can't change this register.
*
* The structure is used to read hardware state of a TPMI feature. This
* information is used for debug and restricting operations for this feature.
*/
struct tpmi_feature_state {
u32 enabled:1;
u32 reserved_1:3;
u32 write_blocked:1;
u32 read_blocked:1;
u32 pcs_select:1;
u32 reserved_2:1;
u32 id:8;
u32 reserved_3:15;
u32 locked:1;
} __packed;
/*
* Return the size of a single feature interface instance in bytes. The
* hardware reports it in u32 units. The value comes from trusted hardware,
* but is still worth verifying on pre silicon platforms, so return 0 when
* it is out of range.
*/
static u32 tpmi_get_single_entry_size(const struct intel_tpmi_pm_feature *pfs)
{
if (pfs->pfs_header.entry_size > SZ_1K)
return 0;
return pfs->pfs_header.entry_size * sizeof(u32);
}
/* Used during auxbus device creation */
static DEFINE_IDA(intel_vsec_tpmi_ida);
static BLOCKING_NOTIFIER_HEAD(tpmi_notify_list);
int tpmi_register_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_register(&tpmi_notify_list, nb);
}
EXPORT_SYMBOL_NS_GPL(tpmi_register_notifier, "INTEL_TPMI");
int tpmi_unregister_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&tpmi_notify_list, nb);
}
EXPORT_SYMBOL_NS_GPL(tpmi_unregister_notifier, "INTEL_TPMI");
struct oobmsm_plat_info *tpmi_get_platform_data(struct auxiliary_device *auxdev)
{
struct intel_vsec_device *vsec_dev = auxdev_to_ivdev(auxdev);
return vsec_dev->priv_data;
}
EXPORT_SYMBOL_NS_GPL(tpmi_get_platform_data, "INTEL_TPMI");
int tpmi_get_resource_count(struct auxiliary_device *auxdev)
{
struct intel_vsec_device *vsec_dev = auxdev_to_ivdev(auxdev);
if (vsec_dev)
return vsec_dev->num_resources;
return 0;
}
EXPORT_SYMBOL_NS_GPL(tpmi_get_resource_count, "INTEL_TPMI");
struct resource *tpmi_get_resource_at_index(struct auxiliary_device *auxdev, int index)
{
struct intel_vsec_device *vsec_dev = auxdev_to_ivdev(auxdev);
if (vsec_dev && index < vsec_dev->num_resources)
return &vsec_dev->resource[index];
return NULL;
}
EXPORT_SYMBOL_NS_GPL(tpmi_get_resource_at_index, "INTEL_TPMI");
/* TPMI Control Interface */
#define TPMI_CONTROL_STATUS_OFFSET 0x00
#define TPMI_COMMAND_OFFSET 0x08
#define TMPI_CONTROL_DATA_VAL_OFFSET 0x0c
/*
* Spec is calling for max 1 seconds to get ownership at the worst
* case. Read at 10 ms timeouts and repeat up to 1 second.
*/
#define TPMI_CONTROL_TIMEOUT_US (10 * USEC_PER_MSEC)
#define TPMI_CONTROL_TIMEOUT_MAX_US (1 * USEC_PER_SEC)
#define TPMI_RB_TIMEOUT_US (10 * USEC_PER_MSEC)
#define TPMI_RB_TIMEOUT_MAX_US USEC_PER_SEC
/* TPMI Control status register defines */
#define TPMI_CONTROL_STATUS_RB BIT_ULL(0)
#define TPMI_CONTROL_STATUS_OWNER GENMASK_ULL(5, 4)
#define TPMI_OWNER_NONE 0
#define TPMI_OWNER_IN_BAND 1
#define TPMI_CONTROL_STATUS_CPL BIT_ULL(6)
#define TPMI_CONTROL_STATUS_RESULT GENMASK_ULL(15, 8)
#define TPMI_CONTROL_STATUS_LEN GENMASK_ULL(31, 16)
#define TPMI_CMD_PKT_LEN 2
#define TPMI_CMD_STATUS_SUCCESS 0x40
/* TPMI command data registers */
#define TMPI_CONTROL_DATA_CMD GENMASK_ULL(7, 0)
#define TPMI_CONTROL_DATA_VAL_FEATURE GENMASK_ULL(48, 40)
/* Command to send via control interface */
#define TPMI_CONTROL_GET_STATE_CMD 0x10
#define TPMI_CONTROL_CMD_MASK GENMASK_ULL(48, 40)
#define TPMI_CMD_LEN_MASK GENMASK_ULL(18, 16)
/* Mutex to complete get feature status without interruption */
static DEFINE_MUTEX(tpmi_dev_lock);
static int tpmi_wait_for_owner(struct intel_tpmi_info *tpmi_info, u8 owner)
{
u64 control;
return readq_poll_timeout(tpmi_info->tpmi_control_mem + TPMI_CONTROL_STATUS_OFFSET,
control, owner == FIELD_GET(TPMI_CONTROL_STATUS_OWNER, control),
TPMI_CONTROL_TIMEOUT_US, TPMI_CONTROL_TIMEOUT_MAX_US);
}
static int tpmi_read_feature_status(struct intel_tpmi_info *tpmi_info, int feature_id,
struct tpmi_feature_state *feature_state)
{
u64 control, data;
int ret;
if (!tpmi_info->tpmi_control_mem)
return -EFAULT;
guard(mutex)(&tpmi_dev_lock);
/* Wait for owner bit set to 0 (none) */
ret = tpmi_wait_for_owner(tpmi_info, TPMI_OWNER_NONE);
if (ret)
return ret;
/*
* Set command id to 0x10 for TPMI_GET_STATE, with the feature id 32
* bits into the DATA offset, +8 for the feature_id field.
*/
data = FIELD_PREP(TMPI_CONTROL_DATA_CMD, TPMI_CONTROL_GET_STATE_CMD) |
FIELD_PREP(TPMI_CONTROL_DATA_VAL_FEATURE, feature_id);
/* Write at command offset for qword access */
writeq(data, tpmi_info->tpmi_control_mem + TPMI_COMMAND_OFFSET);
/* Wait for owner bit set to in-band */
ret = tpmi_wait_for_owner(tpmi_info, TPMI_OWNER_IN_BAND);
if (ret)
return ret;
/* Set Run Busy and packet length of 2 dwords */
control = TPMI_CONTROL_STATUS_RB |
FIELD_PREP(TPMI_CONTROL_STATUS_LEN, TPMI_CMD_PKT_LEN);
/* Write at status offset for qword access */
writeq(control, tpmi_info->tpmi_control_mem + TPMI_CONTROL_STATUS_OFFSET);
/* Wait for Run Busy clear */
ret = readq_poll_timeout(tpmi_info->tpmi_control_mem + TPMI_CONTROL_STATUS_OFFSET,
control, !(control & TPMI_CONTROL_STATUS_RB),
TPMI_RB_TIMEOUT_US, TPMI_RB_TIMEOUT_MAX_US);
if (ret)
goto done_proc;
control = FIELD_GET(TPMI_CONTROL_STATUS_RESULT, control);
if (control != TPMI_CMD_STATUS_SUCCESS) {
ret = -EBUSY;
goto done_proc;
}
/* Response is ready */
memcpy_fromio(feature_state, tpmi_info->tpmi_control_mem + TMPI_CONTROL_DATA_VAL_OFFSET,
sizeof(*feature_state));
ret = 0;
done_proc:
/* Set CPL "completion" bit */
writeq(TPMI_CONTROL_STATUS_CPL, tpmi_info->tpmi_control_mem + TPMI_CONTROL_STATUS_OFFSET);
return ret;
}
int tpmi_get_feature_status(struct auxiliary_device *auxdev,
int feature_id, bool *read_blocked, bool *write_blocked)
{
struct intel_tpmi_info *tpmi_info = dev_get_drvdata(auxdev->dev.parent);
struct tpmi_feature_state feature_state;
int ret;
ret = tpmi_read_feature_status(tpmi_info, feature_id, &feature_state);
if (ret)
return ret;
*read_blocked = feature_state.read_blocked;
*write_blocked = feature_state.write_blocked;
return 0;
}
EXPORT_SYMBOL_NS_GPL(tpmi_get_feature_status, "INTEL_TPMI");
struct dentry *tpmi_get_debugfs_dir(struct auxiliary_device *auxdev)
{
struct intel_tpmi_info *tpmi_info = dev_get_drvdata(auxdev->dev.parent);
return tpmi_info->dbgfs_dir;
}
EXPORT_SYMBOL_NS_GPL(tpmi_get_debugfs_dir, "INTEL_TPMI");
static int tpmi_pfs_dbg_show(struct seq_file *s, void *unused)
{
struct intel_tpmi_info *tpmi_info = s->private;
int locked, disabled, read_blocked, write_blocked;
struct tpmi_feature_state feature_state;
struct intel_tpmi_pm_feature *pfs;
int ret;
seq_printf(s, "tpmi PFS start offset 0x:%llx\n", tpmi_info->pfs_start);
seq_puts(s, "tpmi_id\t\tentries\t\tsize\t\tcap_offset\tattribute\tvsec_offset\tlocked\tdisabled\tread_blocked\twrite_blocked\n");
for (int i = 0; i < tpmi_info->feature_count; i++) {
pfs = &tpmi_info->tpmi_features[i];
ret = tpmi_read_feature_status(tpmi_info, pfs->pfs_header.tpmi_id, &feature_state);
if (ret) {
locked = 'U';
disabled = 'U';
read_blocked = 'U';
write_blocked = 'U';
} else {
disabled = feature_state.enabled ? 'N' : 'Y';
locked = feature_state.locked ? 'Y' : 'N';
read_blocked = feature_state.read_blocked ? 'Y' : 'N';
write_blocked = feature_state.write_blocked ? 'Y' : 'N';
}
seq_printf(s, "0x%02x\t\t0x%02x\t\t0x%04x\t\t0x%04x\t\t0x%02x\t\t0x%016llx\t%c\t%c\t\t%c\t\t%c\n",
pfs->pfs_header.tpmi_id, pfs->pfs_header.num_entries,
pfs->pfs_header.entry_size, pfs->pfs_header.cap_offset,
pfs->pfs_header.attribute, pfs->vsec_offset, locked, disabled,
read_blocked, write_blocked);
}
return 0;
}
DEFINE_SHOW_ATTRIBUTE(tpmi_pfs_dbg);
#define MEM_DUMP_COLUMN_COUNT 8
static int tpmi_mem_dump_show(struct seq_file *s, void *unused)
{
size_t row_size = MEM_DUMP_COLUMN_COUNT * sizeof(u32);
struct intel_tpmi_pm_feature *pfs = s->private;
void __iomem *mem;
u32 size;
u64 off;
size = tpmi_get_single_entry_size(pfs);
if (!size)
return -EIO;
u8 *buffer __free(kfree) = kmalloc(size, GFP_KERNEL);
if (!buffer)
return -ENOMEM;
off = pfs->vsec_offset;
guard(mutex)(&tpmi_dev_lock);
for (int count = 0; count < pfs->pfs_header.num_entries; count++) {
seq_printf(s, "TPMI Instance:%d offset:0x%llx\n", count, off);
mem = ioremap(off, size);
if (!mem)
return -ENOMEM;
memcpy_fromio(buffer, mem, size);
seq_hex_dump(s, " ", DUMP_PREFIX_OFFSET, row_size, sizeof(u32), buffer, size,
false);
iounmap(mem);
off += size;
}
return 0;
}
DEFINE_SHOW_ATTRIBUTE(tpmi_mem_dump);
static ssize_t mem_write_write(struct file *file, const char __user *userbuf, size_t len,
loff_t *ppos)
{
struct seq_file *m = file->private_data;
struct intel_tpmi_pm_feature *pfs = m->private;
u32 addr, value, punit, size;
u32 num_elems;
void __iomem *mem;
int ret;
size = tpmi_get_single_entry_size(pfs);
if (!size)
return -EIO;
u32 *array __free(kfree) = NULL;
ret = parse_int_array_user(userbuf, len, (int **)&array);
if (ret < 0)
return ret;
num_elems = *array;
if (num_elems != 3)
return -EINVAL;
punit = array[1];
addr = array[2];
value = array[3];
if (!IS_ALIGNED(addr, sizeof(u32)))
return -EINVAL;
if (punit >= pfs->pfs_header.num_entries)
return -EINVAL;
if (addr >= size)
return -EINVAL;
guard(mutex)(&tpmi_dev_lock);
mem = ioremap(pfs->vsec_offset + punit * size, size);
if (!mem)
return -ENOMEM;
writel(value, mem + addr);
iounmap(mem);
return len;
}
static int mem_write_show(struct seq_file *s, void *unused)
{
return 0;
}
DEFINE_SHOW_STORE_ATTRIBUTE(mem_write);
static void tpmi_dbgfs_register(struct intel_tpmi_info *tpmi_info)
{
char name[64];
scnprintf(name, sizeof(name), "tpmi-%s", dev_name(tpmi_info->parent));
tpmi_info->dbgfs_dir = debugfs_create_dir(name, NULL);
debugfs_create_file("pfs_dump", 0444, tpmi_info->dbgfs_dir, tpmi_info, &tpmi_pfs_dbg_fops);
for (int i = 0; i < tpmi_info->feature_count; i++) {
struct intel_tpmi_pm_feature *pfs;
struct dentry *dir;
pfs = &tpmi_info->tpmi_features[i];
scnprintf(name, sizeof(name), "tpmi-id-%02x", pfs->pfs_header.tpmi_id);
dir = debugfs_create_dir(name, tpmi_info->dbgfs_dir);
debugfs_create_file("mem_dump", 0444, dir, pfs, &tpmi_mem_dump_fops);
debugfs_create_file("mem_write", 0644, dir, pfs, &mem_write_fops);
}
}
static void tpmi_set_control_base(struct intel_tpmi_info *tpmi_info,
struct intel_tpmi_pm_feature *pfs)
{
void __iomem *mem;
u32 size;
size = tpmi_get_single_entry_size(pfs);
if (!size)
return;
mem = devm_ioremap(tpmi_info->tpmi_dev, pfs->vsec_offset, size);
if (!mem)
return;
/* mem is pointing to TPMI CONTROL base */
tpmi_info->tpmi_control_mem = mem;
}
/*
* The TPMI IDs are sparse, so the unused entries are left NULL and are
* rejected by the caller like any other unsupported feature.
*/
static const char * const intel_tpmi_names[] = {
[TPMI_ID_RAPL] = "tpmi-rapl",
[TPMI_ID_PEM] = "tpmi-pem",
[TPMI_ID_UNCORE] = "tpmi-uncore",
[TPMI_ID_SST] = "tpmi-sst",
[TPMI_ID_PLR] = "tpmi-plr",
};
static const char *intel_tpmi_name(enum intel_tpmi_id id)
{
if (id >= ARRAY_SIZE(intel_tpmi_names))
return NULL;
return intel_tpmi_names[id];
}
static int tpmi_create_device(struct intel_tpmi_info *tpmi_info,
struct intel_tpmi_pm_feature *pfs,
u64 pfs_start)
{
struct intel_vsec_device *feature_vsec_dev;
struct tpmi_feature_state feature_state;
struct resource *res;
const char *name;
int ret;
ret = tpmi_read_feature_status(tpmi_info, pfs->pfs_header.tpmi_id, &feature_state);
if (ret)
return ret;
/*
* If not enabled, continue to look at other features in the PFS, so return -EOPNOTSUPP.
* This will not cause failure of loading of this driver.
*/
if (!feature_state.enabled)
return -EOPNOTSUPP;
name = intel_tpmi_name(pfs->pfs_header.tpmi_id);
if (!name)
return -EOPNOTSUPP;
feature_vsec_dev = kzalloc_flex(*feature_vsec_dev, resource, pfs->pfs_header.num_entries);
if (!feature_vsec_dev)
return -ENOMEM;
feature_vsec_dev->num_resources = pfs->pfs_header.num_entries;
res = feature_vsec_dev->resource;
for (int i = 0; i < pfs->pfs_header.num_entries; i++) {
u64 entry_size_bytes = pfs->pfs_header.entry_size * sizeof(u32);
res[i] = DEFINE_RES_MEM(pfs->vsec_offset + entry_size_bytes * i, entry_size_bytes);
}
feature_vsec_dev->dev = tpmi_info->parent;
feature_vsec_dev->priv_data = &tpmi_info->plat_info;
feature_vsec_dev->priv_data_size = sizeof(tpmi_info->plat_info);
feature_vsec_dev->ida = &intel_vsec_tpmi_ida;
/*
* intel_vsec_add_aux() is resource managed, no explicit
* delete is required on error or on module unload.
* feature_vsec_dev and res memory are also freed as part of
* device deletion.
*
* "name" must outlive the auxiliary device, as the auxiliary bus
* stores the pointer rather than a copy of the string.
*/
return intel_vsec_add_aux(tpmi_info->tpmi_dev, feature_vsec_dev, name);
}
/*
* Create a device for every feature in the PFS that has one.
*
* A feature that is not supported is reported as -EOPNOTSUPP and skipped.
* Any other error fails the driver load. intel_vsec_add_aux() is resource
* managed, so the devices created before such a failure need no clean up
* here.
*/
static int tpmi_create_devices(struct intel_tpmi_info *tpmi_info)
{
int ret;
for (int i = 0; i < tpmi_info->feature_count; i++) {
ret = tpmi_create_device(tpmi_info, &tpmi_info->tpmi_features[i],
tpmi_info->pfs_start);
if (ret == -EOPNOTSUPP)
continue;
if (ret)
return ret;
}
return 0;
}
#define TPMI_INFO_BUS_INFO_OFFSET 0x08
#define TPMI_INFO_MAJOR_VERSION 0x00
#define TPMI_INFO_MINOR_VERSION 0x02
static int tpmi_process_info(struct intel_tpmi_info *tpmi_info,
struct intel_tpmi_pm_feature *pfs)
{
struct tpmi_info_header header;
void __iomem *info_mem;
u64 feature_header;
int ret = 0;
info_mem = ioremap(pfs->vsec_offset, pfs->pfs_header.entry_size * sizeof(u32));
if (!info_mem)
return -ENOMEM;
feature_header = readq(info_mem);
if (TPMI_MAJOR_VERSION(feature_header) != TPMI_INFO_MAJOR_VERSION) {
ret = -ENODEV;
goto error_info_header;
}
memcpy_fromio(&header, info_mem + TPMI_INFO_BUS_INFO_OFFSET, sizeof(header));
tpmi_info->plat_info.package_id = header.pkg;
tpmi_info->plat_info.bus_number = header.bus;
tpmi_info->plat_info.device_number = header.dev;
tpmi_info->plat_info.function_number = header.fn;
if (TPMI_MINOR_VERSION(feature_header) >= TPMI_INFO_MINOR_VERSION) {
tpmi_info->plat_info.cdie_mask = header.cdie_mask;
tpmi_info->plat_info.partition = header.partition;
tpmi_info->plat_info.segment = header.segment;
}
error_info_header:
iounmap(info_mem);
return ret;
}
static int tpmi_fetch_pfs_header(struct intel_tpmi_pm_feature *pfs, u64 start, int size)
{
void __iomem *pfs_mem;
pfs_mem = ioremap(start, size);
if (!pfs_mem)
return -ENOMEM;
memcpy_fromio(&pfs->pfs_header, pfs_mem, sizeof(pfs->pfs_header));
iounmap(pfs_mem);
return 0;
}
#define TPMI_CAP_OFFSET_UNIT 1024
/**
* intel_tpmi_init() - Bring up a TPMI instance
* @tpmi_info: Caller allocated and zeroed state of the TPMI instance
* @tpmi_dev: Device representing the TPMI instance. Owns the devm
* allocations and parents the TPMI feature devices
* @parent: Device the TPMI instance was enumerated from
* @resource: Array of @feature_count MMIO resources, one per PFS entry
* @feature_count: Number of entries in @resource
*
* Walk the PFS of the TPMI instance described by @resource, register the
* debugfs interface and create a device for each supported PM feature.
*
* Return: 0 on success, negative errno otherwise.
*/
int intel_tpmi_init(struct intel_tpmi_info *tpmi_info, struct device *tpmi_dev,
struct device *parent, struct resource *resource, int feature_count)
{
struct pci_dev *pci_dev = dev_is_pci(parent) ? to_pci_dev(parent) : NULL;
u64 pfs_start = 0;
int ret;
tpmi_info->tpmi_dev = tpmi_dev;
tpmi_info->parent = parent;
tpmi_info->feature_count = feature_count;
tpmi_info->resource = resource;
/*
* Seed the bus number from the enumerating device. It is only a
* fallback, tpmi_process_info() replaces it with the value the
* TPMI_INFO feature reports.
*/
if (pci_dev)
tpmi_info->plat_info.bus_number = pci_dev->bus->number;
tpmi_info->tpmi_features = devm_kzalloc_objs(tpmi_info->tpmi_dev,
*tpmi_info->tpmi_features,
tpmi_info->feature_count);
if (!tpmi_info->tpmi_features)
return -ENOMEM;
for (int i = 0; i < tpmi_info->feature_count; i++) {
struct intel_tpmi_pm_feature *pfs;
struct resource *res;
u64 res_start;
int size, ret;
pfs = &tpmi_info->tpmi_features[i];
res = &tpmi_info->resource[i];
if (!res)
continue;
res_start = res->start;
size = resource_size(res);
if (size < 0)
continue;
ret = tpmi_fetch_pfs_header(pfs, res_start, size);
if (ret)
continue;
if (!pfs_start)
pfs_start = res_start;
pfs->vsec_offset = pfs_start + pfs->pfs_header.cap_offset * TPMI_CAP_OFFSET_UNIT;
/*
* Process TPMI_INFO to get PCI device to CPU package ID.
* Device nodes for TPMI features are not created in this
* for loop. So, the mapping information will be available
* when actual device nodes created outside this
* loop via tpmi_create_devices().
*/
if (pfs->pfs_header.tpmi_id == TPMI_INFO_ID) {
ret = tpmi_process_info(tpmi_info, pfs);
if (ret)
return ret;
/*
* The mapping is looked up by pci_dev, so it is only
* meaningful for PCI enumerated TPMI instances.
*/
if (pci_dev) {
ret = intel_vsec_set_mapping(&tpmi_info->plat_info,
&pci_dev->dev);
if (ret)
return ret;
}
}
if (pfs->pfs_header.tpmi_id == TPMI_CONTROL_ID)
tpmi_set_control_base(tpmi_info, pfs);
}
tpmi_info->pfs_start = pfs_start;
dev_set_drvdata(tpmi_info->tpmi_dev, tpmi_info);
/*
* Allow debugfs when security policy allows. Everything this debugfs
* interface provides, can also be done via /dev/mem access. If
* /dev/mem interface is locked, don't allow debugfs to present any
* information. Also check for CAP_SYS_RAWIO as /dev/mem interface.
*/
if (!security_locked_down(LOCKDOWN_DEV_MEM) && capable(CAP_SYS_RAWIO))
tpmi_dbgfs_register(tpmi_info);
ret = tpmi_create_devices(tpmi_info);
if (ret) {
debugfs_remove_recursive(tpmi_info->dbgfs_dir);
return ret;
}
blocking_notifier_call_chain(&tpmi_notify_list, TPMI_CORE_INIT, tpmi_info->tpmi_dev);
return 0;
}
EXPORT_SYMBOL_NS_GPL(intel_tpmi_init, "INTEL_TPMI");
/**
* intel_tpmi_deinit() - Tear a TPMI instance down
* @tpmi_info: State of the TPMI instance, as passed to intel_tpmi_init()
*
* The TPMI feature devices and the devm allocations are released by the
* device core when the TPMI device goes away.
*/
void intel_tpmi_deinit(struct intel_tpmi_info *tpmi_info)
{
blocking_notifier_call_chain(&tpmi_notify_list, TPMI_CORE_EXIT, tpmi_info->tpmi_dev);
debugfs_remove_recursive(tpmi_info->dbgfs_dir);
}
EXPORT_SYMBOL_NS_GPL(intel_tpmi_deinit, "INTEL_TPMI");
MODULE_IMPORT_NS("INTEL_VSEC");
MODULE_DESCRIPTION("Intel TPMI core support");
MODULE_LICENSE("GPL");