intel_rapl_tpmi.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * intel_rapl_tpmi: Intel RAPL driver via TPMI interface
  4 *
  5 * Copyright (c) 2023, Intel Corporation.
  6 * All Rights Reserved.
  7 *
  8 */
  9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 10
 11#include <linux/auxiliary_bus.h>
 12#include <linux/intel_rapl.h>
 13#include <linux/intel_tpmi.h>
 14#include <linux/intel_vsec.h>
 15#include <linux/io.h>
 16#include <linux/module.h>
 17#include <linux/slab.h>
 18
 19#define TPMI_RAPL_MAJOR_VERSION 0
 20#define TPMI_RAPL_MINOR_VERSION 1
 21
 22/* 1 header + 10 registers + 5 reserved. 8 bytes for each. */
 23#define TPMI_RAPL_DOMAIN_SIZE 128
 24
 25enum tpmi_rapl_domain_type {
 26	TPMI_RAPL_DOMAIN_INVALID,
 27	TPMI_RAPL_DOMAIN_SYSTEM,
 28	TPMI_RAPL_DOMAIN_PACKAGE,
 29	TPMI_RAPL_DOMAIN_RESERVED,
 30	TPMI_RAPL_DOMAIN_MEMORY,
 31	TPMI_RAPL_DOMAIN_MAX,
 32};
 33
 34enum tpmi_rapl_register {
 35	TPMI_RAPL_REG_HEADER,
 36	TPMI_RAPL_REG_UNIT,
 37	TPMI_RAPL_REG_PL1,
 38	TPMI_RAPL_REG_PL2,
 39	TPMI_RAPL_REG_PL3,
 40	TPMI_RAPL_REG_PL4,
 41	TPMI_RAPL_REG_RESERVED,
 42	TPMI_RAPL_REG_ENERGY_STATUS,
 43	TPMI_RAPL_REG_PERF_STATUS,
 44	TPMI_RAPL_REG_POWER_INFO,
 45	TPMI_RAPL_REG_DOMAIN_INFO,
 46	TPMI_RAPL_REG_INTERRUPT,
 47	TPMI_RAPL_REG_MAX = 15,
 48};
 49
 50struct tpmi_rapl_package {
 51	struct rapl_if_priv priv;
 52	struct oobmsm_plat_info *tpmi_info;
 53	struct rapl_package *rp;
 54	void __iomem *base;
 55	struct list_head node;
 56};
 57
 58static LIST_HEAD(tpmi_rapl_packages);
 59static DEFINE_MUTEX(tpmi_rapl_lock);
 60
 61static struct powercap_control_type *tpmi_control_type;
 62
 63static int tpmi_rapl_read_raw(int id, struct reg_action *ra, bool atomic)
 64{
 65	if (!ra->reg.mmio)
 66		return -EINVAL;
 67
 68	ra->value = readq(ra->reg.mmio);
 69
 70	ra->value &= ra->mask;
 71	return 0;
 72}
 73
 74static int tpmi_rapl_write_raw(int id, struct reg_action *ra)
 75{
 76	u64 val;
 77
 78	if (!ra->reg.mmio)
 79		return -EINVAL;
 80
 81	val = readq(ra->reg.mmio);
 82
 83	val &= ~ra->mask;
 84	val |= ra->value;
 85
 86	writeq(val, ra->reg.mmio);
 87	return 0;
 88}
 89
 90static struct tpmi_rapl_package *trp_alloc(int pkg_id)
 91{
 92	struct tpmi_rapl_package *trp;
 93	int ret;
 94
 95	mutex_lock(&tpmi_rapl_lock);
 96
 97	if (list_empty(&tpmi_rapl_packages)) {
 98		tpmi_control_type = powercap_register_control_type(NULL, "intel-rapl", NULL);
 99		if (IS_ERR(tpmi_control_type)) {
100			ret = PTR_ERR(tpmi_control_type);
101			goto err_unlock;
102		}
103	}
104
105	trp = kzalloc(sizeof(*trp), GFP_KERNEL);
106	if (!trp) {
107		ret = -ENOMEM;
108		goto err_del_powercap;
109	}
110
111	list_add(&trp->node, &tpmi_rapl_packages);
112
113	mutex_unlock(&tpmi_rapl_lock);
114	return trp;
115
116err_del_powercap:
117	if (list_empty(&tpmi_rapl_packages))
118		powercap_unregister_control_type(tpmi_control_type);
119err_unlock:
120	mutex_unlock(&tpmi_rapl_lock);
121	return ERR_PTR(ret);
122}
123
124static void trp_release(struct tpmi_rapl_package *trp)
125{
126	mutex_lock(&tpmi_rapl_lock);
127	list_del(&trp->node);
128
129	if (list_empty(&tpmi_rapl_packages))
130		powercap_unregister_control_type(tpmi_control_type);
131
132	kfree(trp);
133	mutex_unlock(&tpmi_rapl_lock);
134}
135
136/*
137 * Bit 0 of TPMI_RAPL_REG_DOMAIN_INFO indicates if the current package is a domain
138 * root or not. Only domain root packages can enumerate System (Psys) Domain.
139 */
140#define TPMI_RAPL_DOMAIN_ROOT	BIT(0)
141
142static int parse_one_domain(struct tpmi_rapl_package *trp, u32 offset)
143{
144	u8 tpmi_domain_version;
145	enum rapl_domain_type domain_type;
146	enum tpmi_rapl_domain_type tpmi_domain_type;
147	enum tpmi_rapl_register reg_index;
148	enum rapl_domain_reg_id reg_id;
149	int tpmi_domain_size, tpmi_domain_flags;
150	u64 tpmi_domain_header = readq(trp->base + offset);
151	u64 tpmi_domain_info;
152
153	/* Domain Parent bits are ignored for now */
154	tpmi_domain_version = tpmi_domain_header & 0xff;
155	tpmi_domain_type = tpmi_domain_header >> 8 & 0xff;
156	tpmi_domain_size = tpmi_domain_header >> 16 & 0xff;
157	tpmi_domain_flags = tpmi_domain_header >> 32 & 0xffff;
158
159	if (tpmi_domain_version == TPMI_VERSION_INVALID) {
160		pr_debug("Invalid version, other instances may be valid\n");
161		return -ENODEV;
162	}
163
164	if (TPMI_MAJOR_VERSION(tpmi_domain_version) != TPMI_RAPL_MAJOR_VERSION) {
165		pr_warn(FW_BUG "Unsupported major version:%ld\n",
166			TPMI_MAJOR_VERSION(tpmi_domain_version));
167		return -ENODEV;
168	}
169
170	if (TPMI_MINOR_VERSION(tpmi_domain_version) > TPMI_RAPL_MINOR_VERSION)
171		pr_info("Ignore: Unsupported minor version:%ld\n",
172			TPMI_MINOR_VERSION(tpmi_domain_version));
173
174	/* Domain size: in unit of 128 Bytes */
175	if (tpmi_domain_size != 1) {
176		pr_warn(FW_BUG "Invalid Domain size %d\n", tpmi_domain_size);
177		return -EINVAL;
178	}
179
180	/* Unit register and Energy Status register are mandatory for each domain */
181	if (!(tpmi_domain_flags & BIT(TPMI_RAPL_REG_UNIT)) ||
182	    !(tpmi_domain_flags & BIT(TPMI_RAPL_REG_ENERGY_STATUS))) {
183		pr_warn(FW_BUG "Invalid Domain flag 0x%x\n", tpmi_domain_flags);
184		return -EINVAL;
185	}
186
187	switch (tpmi_domain_type) {
188	case TPMI_RAPL_DOMAIN_PACKAGE:
189		domain_type = RAPL_DOMAIN_PACKAGE;
190		break;
191	case TPMI_RAPL_DOMAIN_SYSTEM:
192		if (!(tpmi_domain_flags & BIT(TPMI_RAPL_REG_DOMAIN_INFO))) {
193			pr_warn(FW_BUG "System domain must support Domain Info register\n");
194			return -ENODEV;
195		}
196		tpmi_domain_info = readq(trp->base + offset + TPMI_RAPL_REG_DOMAIN_INFO * 8);
197		if (!(tpmi_domain_info & TPMI_RAPL_DOMAIN_ROOT))
198			return 0;
199		domain_type = RAPL_DOMAIN_PLATFORM;
200		break;
201	case TPMI_RAPL_DOMAIN_MEMORY:
202		domain_type = RAPL_DOMAIN_DRAM;
203		break;
204	default:
205		pr_warn(FW_BUG "Unsupported Domain type %d\n", tpmi_domain_type);
206		return -EINVAL;
207	}
208
209	if (trp->priv.regs[domain_type][RAPL_DOMAIN_REG_UNIT].mmio) {
210		pr_warn(FW_BUG "Duplicate Domain type %d\n", tpmi_domain_type);
211		return -EINVAL;
212	}
213
214	reg_index = TPMI_RAPL_REG_HEADER;
215	while (++reg_index != TPMI_RAPL_REG_MAX) {
216		if (!(tpmi_domain_flags & BIT(reg_index)))
217			continue;
218
219		switch (reg_index) {
220		case TPMI_RAPL_REG_UNIT:
221			reg_id = RAPL_DOMAIN_REG_UNIT;
222			break;
223		case TPMI_RAPL_REG_PL1:
224			reg_id = RAPL_DOMAIN_REG_LIMIT;
225			trp->priv.limits[domain_type] |= BIT(POWER_LIMIT1);
226			break;
227		case TPMI_RAPL_REG_PL2:
228			reg_id = RAPL_DOMAIN_REG_PL2;
229			trp->priv.limits[domain_type] |= BIT(POWER_LIMIT2);
230			break;
231		case TPMI_RAPL_REG_PL4:
232			reg_id = RAPL_DOMAIN_REG_PL4;
233			trp->priv.limits[domain_type] |= BIT(POWER_LIMIT4);
234			break;
235		case TPMI_RAPL_REG_ENERGY_STATUS:
236			reg_id = RAPL_DOMAIN_REG_STATUS;
237			break;
238		case TPMI_RAPL_REG_PERF_STATUS:
239			reg_id = RAPL_DOMAIN_REG_PERF;
240			break;
241		case TPMI_RAPL_REG_POWER_INFO:
242			reg_id = RAPL_DOMAIN_REG_INFO;
243			break;
244		default:
245			continue;
246		}
247		trp->priv.regs[domain_type][reg_id].mmio = trp->base + offset + reg_index * 8;
248	}
249
250	return 0;
251}
252
253static int intel_rapl_tpmi_probe(struct auxiliary_device *auxdev,
254				 const struct auxiliary_device_id *id)
255{
256	struct tpmi_rapl_package *trp;
257	struct oobmsm_plat_info *info;
258	struct resource *res;
259	u32 offset;
260	int ret;
261
262	info = tpmi_get_platform_data(auxdev);
263	if (!info)
264		return -ENODEV;
265
266	trp = trp_alloc(info->package_id);
267	if (IS_ERR(trp))
268		return PTR_ERR(trp);
269
270	if (tpmi_get_resource_count(auxdev) > 1) {
271		dev_err(&auxdev->dev, "does not support multiple resources\n");
272		ret = -EINVAL;
273		goto err;
274	}
275
276	res = tpmi_get_resource_at_index(auxdev, 0);
277	if (!res) {
278		dev_err(&auxdev->dev, "can't fetch device resource info\n");
279		ret = -EIO;
280		goto err;
281	}
282
283	trp->base = devm_ioremap_resource(&auxdev->dev, res);
284	if (IS_ERR(trp->base)) {
285		ret = PTR_ERR(trp->base);
286		goto err;
287	}
288
289	for (offset = 0; offset < resource_size(res); offset += TPMI_RAPL_DOMAIN_SIZE) {
290		ret = parse_one_domain(trp, offset);
291		if (ret)
292			goto err;
293	}
294
295	trp->tpmi_info = info;
296	trp->priv.type = RAPL_IF_TPMI;
297	trp->priv.read_raw = tpmi_rapl_read_raw;
298	trp->priv.write_raw = tpmi_rapl_write_raw;
299	trp->priv.control_type = tpmi_control_type;
300
301	/* RAPL TPMI I/F is per physical package */
302	trp->rp = rapl_find_package_domain(info->package_id, &trp->priv, false);
303	if (trp->rp) {
304		dev_err(&auxdev->dev, "Domain for Package%d already exists\n", info->package_id);
305		ret = -EEXIST;
306		goto err;
307	}
308
309	trp->rp = rapl_add_package(info->package_id, &trp->priv, false);
310	if (IS_ERR(trp->rp)) {
311		dev_err(&auxdev->dev, "Failed to add RAPL Domain for Package%d, %ld\n",
312			info->package_id, PTR_ERR(trp->rp));
313		ret = PTR_ERR(trp->rp);
314		goto err;
315	}
316
317	rapl_package_add_pmu(trp->rp);
318
319	auxiliary_set_drvdata(auxdev, trp);
320
321	return 0;
322err:
323	trp_release(trp);
324	return ret;
325}
326
327static void intel_rapl_tpmi_remove(struct auxiliary_device *auxdev)
328{
329	struct tpmi_rapl_package *trp = auxiliary_get_drvdata(auxdev);
330
331	rapl_package_remove_pmu(trp->rp);
332	rapl_remove_package(trp->rp);
333	trp_release(trp);
334}
335
336static const struct auxiliary_device_id intel_rapl_tpmi_ids[] = {
337	{.name = "intel_vsec.tpmi-rapl" },
338	{ }
339};
340
341MODULE_DEVICE_TABLE(auxiliary, intel_rapl_tpmi_ids);
342
343static struct auxiliary_driver intel_rapl_tpmi_driver = {
344	.probe = intel_rapl_tpmi_probe,
345	.remove = intel_rapl_tpmi_remove,
346	.id_table = intel_rapl_tpmi_ids,
347};
348
349module_auxiliary_driver(intel_rapl_tpmi_driver)
350
351MODULE_IMPORT_NS("INTEL_TPMI");
352
353MODULE_DESCRIPTION("Intel RAPL TPMI Driver");
354MODULE_LICENSE("GPL");