xref: /linux/drivers/peci/cpu.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright (c) 2021 Intel Corporation
3 
4 #include <linux/auxiliary_bus.h>
5 #include <linux/module.h>
6 #include <linux/peci.h>
7 #include <linux/peci-cpu.h>
8 #include <linux/slab.h>
9 
10 #include "internal.h"
11 
12 /**
13  * peci_temp_read() - read the maximum die temperature from PECI target device
14  * @device: PECI device to which request is going to be sent
15  * @temp_raw: where to store the read temperature
16  *
17  * It uses GetTemp PECI command.
18  *
19  * Return: 0 if succeeded, other values in case errors.
20  */
peci_temp_read(struct peci_device * device,s16 * temp_raw)21 int peci_temp_read(struct peci_device *device, s16 *temp_raw)
22 {
23 	struct peci_request *req;
24 
25 	req = peci_xfer_get_temp(device);
26 	if (IS_ERR(req))
27 		return PTR_ERR(req);
28 
29 	*temp_raw = peci_request_temp_read(req);
30 
31 	peci_request_free(req);
32 
33 	return 0;
34 }
35 EXPORT_SYMBOL_NS_GPL(peci_temp_read, PECI_CPU);
36 
37 /**
38  * peci_pcs_read() - read PCS register
39  * @device: PECI device to which request is going to be sent
40  * @index: PCS index
41  * @param: PCS parameter
42  * @data: where to store the read data
43  *
44  * It uses RdPkgConfig PECI command.
45  *
46  * Return: 0 if succeeded, other values in case errors.
47  */
peci_pcs_read(struct peci_device * device,u8 index,u16 param,u32 * data)48 int peci_pcs_read(struct peci_device *device, u8 index, u16 param, u32 *data)
49 {
50 	struct peci_request *req;
51 	int ret;
52 
53 	req = peci_xfer_pkg_cfg_readl(device, index, param);
54 	if (IS_ERR(req))
55 		return PTR_ERR(req);
56 
57 	ret = peci_request_status(req);
58 	if (ret)
59 		goto out_req_free;
60 
61 	*data = peci_request_data_readl(req);
62 out_req_free:
63 	peci_request_free(req);
64 
65 	return ret;
66 }
67 EXPORT_SYMBOL_NS_GPL(peci_pcs_read, PECI_CPU);
68 
69 /**
70  * peci_pci_local_read() - read 32-bit memory location using raw address
71  * @device: PECI device to which request is going to be sent
72  * @bus: bus
73  * @dev: device
74  * @func: function
75  * @reg: register
76  * @data: where to store the read data
77  *
78  * It uses RdPCIConfigLocal PECI command.
79  *
80  * Return: 0 if succeeded, other values in case errors.
81  */
peci_pci_local_read(struct peci_device * device,u8 bus,u8 dev,u8 func,u16 reg,u32 * data)82 int peci_pci_local_read(struct peci_device *device, u8 bus, u8 dev, u8 func,
83 			u16 reg, u32 *data)
84 {
85 	struct peci_request *req;
86 	int ret;
87 
88 	req = peci_xfer_pci_cfg_local_readl(device, bus, dev, func, reg);
89 	if (IS_ERR(req))
90 		return PTR_ERR(req);
91 
92 	ret = peci_request_status(req);
93 	if (ret)
94 		goto out_req_free;
95 
96 	*data = peci_request_data_readl(req);
97 out_req_free:
98 	peci_request_free(req);
99 
100 	return ret;
101 }
102 EXPORT_SYMBOL_NS_GPL(peci_pci_local_read, PECI_CPU);
103 
104 /**
105  * peci_ep_pci_local_read() - read 32-bit memory location using raw address
106  * @device: PECI device to which request is going to be sent
107  * @seg: PCI segment
108  * @bus: bus
109  * @dev: device
110  * @func: function
111  * @reg: register
112  * @data: where to store the read data
113  *
114  * Like &peci_pci_local_read, but it uses RdEndpointConfig PECI command.
115  *
116  * Return: 0 if succeeded, other values in case errors.
117  */
peci_ep_pci_local_read(struct peci_device * device,u8 seg,u8 bus,u8 dev,u8 func,u16 reg,u32 * data)118 int peci_ep_pci_local_read(struct peci_device *device, u8 seg,
119 			   u8 bus, u8 dev, u8 func, u16 reg, u32 *data)
120 {
121 	struct peci_request *req;
122 	int ret;
123 
124 	req = peci_xfer_ep_pci_cfg_local_readl(device, seg, bus, dev, func, reg);
125 	if (IS_ERR(req))
126 		return PTR_ERR(req);
127 
128 	ret = peci_request_status(req);
129 	if (ret)
130 		goto out_req_free;
131 
132 	*data = peci_request_data_readl(req);
133 out_req_free:
134 	peci_request_free(req);
135 
136 	return ret;
137 }
138 EXPORT_SYMBOL_NS_GPL(peci_ep_pci_local_read, PECI_CPU);
139 
140 /**
141  * peci_mmio_read() - read 32-bit memory location using 64-bit bar offset address
142  * @device: PECI device to which request is going to be sent
143  * @bar: PCI bar
144  * @seg: PCI segment
145  * @bus: bus
146  * @dev: device
147  * @func: function
148  * @address: 64-bit MMIO address
149  * @data: where to store the read data
150  *
151  * It uses RdEndpointConfig PECI command.
152  *
153  * Return: 0 if succeeded, other values in case errors.
154  */
peci_mmio_read(struct peci_device * device,u8 bar,u8 seg,u8 bus,u8 dev,u8 func,u64 address,u32 * data)155 int peci_mmio_read(struct peci_device *device, u8 bar, u8 seg,
156 		   u8 bus, u8 dev, u8 func, u64 address, u32 *data)
157 {
158 	struct peci_request *req;
159 	int ret;
160 
161 	req = peci_xfer_ep_mmio64_readl(device, bar, seg, bus, dev, func, address);
162 	if (IS_ERR(req))
163 		return PTR_ERR(req);
164 
165 	ret = peci_request_status(req);
166 	if (ret)
167 		goto out_req_free;
168 
169 	*data = peci_request_data_readl(req);
170 out_req_free:
171 	peci_request_free(req);
172 
173 	return ret;
174 }
175 EXPORT_SYMBOL_NS_GPL(peci_mmio_read, PECI_CPU);
176 
177 static const char * const peci_adev_types[] = {
178 	"cputemp",
179 	"dimmtemp",
180 };
181 
182 struct peci_cpu {
183 	struct peci_device *device;
184 	const struct peci_device_id *id;
185 };
186 
adev_release(struct device * dev)187 static void adev_release(struct device *dev)
188 {
189 	struct auxiliary_device *adev = to_auxiliary_dev(dev);
190 
191 	kfree(adev->name);
192 	kfree(adev);
193 }
194 
adev_alloc(struct peci_cpu * priv,int idx)195 static struct auxiliary_device *adev_alloc(struct peci_cpu *priv, int idx)
196 {
197 	struct peci_controller *controller = to_peci_controller(priv->device->dev.parent);
198 	struct auxiliary_device *adev;
199 	const char *name;
200 	int ret;
201 
202 	adev = kzalloc(sizeof(*adev), GFP_KERNEL);
203 	if (!adev)
204 		return ERR_PTR(-ENOMEM);
205 
206 	name = kasprintf(GFP_KERNEL, "%s.%s", peci_adev_types[idx], (const char *)priv->id->data);
207 	if (!name) {
208 		ret = -ENOMEM;
209 		goto free_adev;
210 	}
211 
212 	adev->name = name;
213 	adev->dev.parent = &priv->device->dev;
214 	adev->dev.release = adev_release;
215 	adev->id = (controller->id << 16) | (priv->device->addr);
216 
217 	ret = auxiliary_device_init(adev);
218 	if (ret)
219 		goto free_name;
220 
221 	return adev;
222 
223 free_name:
224 	kfree(name);
225 free_adev:
226 	kfree(adev);
227 	return ERR_PTR(ret);
228 }
229 
unregister_adev(void * _adev)230 static void unregister_adev(void *_adev)
231 {
232 	struct auxiliary_device *adev = _adev;
233 
234 	auxiliary_device_delete(adev);
235 	auxiliary_device_uninit(adev);
236 }
237 
devm_adev_add(struct device * dev,int idx)238 static int devm_adev_add(struct device *dev, int idx)
239 {
240 	struct peci_cpu *priv = dev_get_drvdata(dev);
241 	struct auxiliary_device *adev;
242 	int ret;
243 
244 	adev = adev_alloc(priv, idx);
245 	if (IS_ERR(adev))
246 		return PTR_ERR(adev);
247 
248 	ret = auxiliary_device_add(adev);
249 	if (ret) {
250 		auxiliary_device_uninit(adev);
251 		return ret;
252 	}
253 
254 	ret = devm_add_action_or_reset(&priv->device->dev, unregister_adev, adev);
255 	if (ret)
256 		return ret;
257 
258 	return 0;
259 }
260 
peci_cpu_add_adevices(struct peci_cpu * priv)261 static void peci_cpu_add_adevices(struct peci_cpu *priv)
262 {
263 	struct device *dev = &priv->device->dev;
264 	int ret, i;
265 
266 	for (i = 0; i < ARRAY_SIZE(peci_adev_types); i++) {
267 		ret = devm_adev_add(dev, i);
268 		if (ret) {
269 			dev_warn(dev, "Failed to register PECI auxiliary: %s, ret = %d\n",
270 				 peci_adev_types[i], ret);
271 			continue;
272 		}
273 	}
274 }
275 
276 static int
peci_cpu_probe(struct peci_device * device,const struct peci_device_id * id)277 peci_cpu_probe(struct peci_device *device, const struct peci_device_id *id)
278 {
279 	struct device *dev = &device->dev;
280 	struct peci_cpu *priv;
281 
282 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
283 	if (!priv)
284 		return -ENOMEM;
285 
286 	dev_set_drvdata(dev, priv);
287 	priv->device = device;
288 	priv->id = id;
289 
290 	peci_cpu_add_adevices(priv);
291 
292 	return 0;
293 }
294 
295 static const struct peci_device_id peci_cpu_device_ids[] = {
296 	{ /* Haswell Xeon */
297 		.x86_vfm = INTEL_HASWELL_X,
298 		.data	= "hsx",
299 	},
300 	{ /* Broadwell Xeon */
301 		.x86_vfm = INTEL_BROADWELL_X,
302 		.data	= "bdx",
303 	},
304 	{ /* Broadwell Xeon D */
305 		.x86_vfm = INTEL_BROADWELL_D,
306 		.data	= "bdxd",
307 	},
308 	{ /* Skylake Xeon */
309 		.x86_vfm = INTEL_SKYLAKE_X,
310 		.data	= "skx",
311 	},
312 	{ /* Icelake Xeon */
313 		.x86_vfm = INTEL_ICELAKE_X,
314 		.data	= "icx",
315 	},
316 	{ /* Icelake Xeon D */
317 		.x86_vfm = INTEL_ICELAKE_D,
318 		.data	= "icxd",
319 	},
320 	{ /* Sapphire Rapids Xeon */
321 		.x86_vfm = INTEL_SAPPHIRERAPIDS_X,
322 		.data	= "spr",
323 	},
324 	{ }
325 };
326 MODULE_DEVICE_TABLE(peci, peci_cpu_device_ids);
327 
328 static struct peci_driver peci_cpu_driver = {
329 	.probe		= peci_cpu_probe,
330 	.id_table	= peci_cpu_device_ids,
331 	.driver		= {
332 		.name		= "peci-cpu",
333 	},
334 };
335 module_peci_driver(peci_cpu_driver);
336 
337 MODULE_AUTHOR("Iwona Winiarska <iwona.winiarska@intel.com>");
338 MODULE_DESCRIPTION("PECI CPU driver");
339 MODULE_LICENSE("GPL");
340 MODULE_IMPORT_NS(PECI);
341