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