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 | */ |
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(ptr: req)) |
27 | return PTR_ERR(ptr: 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 | */ |
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(ptr: req)) |
55 | return PTR_ERR(ptr: 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 | */ |
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(ptr: req)) |
90 | return PTR_ERR(ptr: 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 | */ |
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(ptr: req)) |
126 | return PTR_ERR(ptr: 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 | */ |
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, offset: address); |
162 | if (IS_ERR(ptr: req)) |
163 | return PTR_ERR(ptr: 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 | |
187 | static void adev_release(struct device *dev) |
188 | { |
189 | struct auxiliary_device *adev = to_auxiliary_dev(dev); |
190 | |
191 | kfree(objp: adev->name); |
192 | kfree(objp: adev); |
193 | } |
194 | |
195 | static struct auxiliary_device *adev_alloc(struct peci_cpu *priv, int idx) |
196 | { |
197 | struct peci_controller *controller = to_peci_controller(d: priv->device->dev.parent); |
198 | struct auxiliary_device *adev; |
199 | const char *name; |
200 | int ret; |
201 | |
202 | adev = kzalloc(size: sizeof(*adev), GFP_KERNEL); |
203 | if (!adev) |
204 | return ERR_PTR(error: -ENOMEM); |
205 | |
206 | name = kasprintf(GFP_KERNEL, fmt: "%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(auxdev: adev); |
218 | if (ret) |
219 | goto free_name; |
220 | |
221 | return adev; |
222 | |
223 | free_name: |
224 | kfree(objp: name); |
225 | free_adev: |
226 | kfree(objp: adev); |
227 | return ERR_PTR(error: ret); |
228 | } |
229 | |
230 | static void unregister_adev(void *_adev) |
231 | { |
232 | struct auxiliary_device *adev = _adev; |
233 | |
234 | auxiliary_device_delete(auxdev: adev); |
235 | auxiliary_device_uninit(auxdev: adev); |
236 | } |
237 | |
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(ptr: adev)) |
246 | return PTR_ERR(ptr: adev); |
247 | |
248 | ret = auxiliary_device_add(adev); |
249 | if (ret) { |
250 | auxiliary_device_uninit(auxdev: 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 | |
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, idx: 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 |
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, size: sizeof(*priv), GFP_KERNEL); |
283 | if (!priv) |
284 | return -ENOMEM; |
285 | |
286 | dev_set_drvdata(dev, data: 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 | .family = 6, |
298 | .model = INTEL_FAM6_HASWELL_X, |
299 | .data = "hsx" , |
300 | }, |
301 | { /* Broadwell Xeon */ |
302 | .family = 6, |
303 | .model = INTEL_FAM6_BROADWELL_X, |
304 | .data = "bdx" , |
305 | }, |
306 | { /* Broadwell Xeon D */ |
307 | .family = 6, |
308 | .model = INTEL_FAM6_BROADWELL_D, |
309 | .data = "bdxd" , |
310 | }, |
311 | { /* Skylake Xeon */ |
312 | .family = 6, |
313 | .model = INTEL_FAM6_SKYLAKE_X, |
314 | .data = "skx" , |
315 | }, |
316 | { /* Icelake Xeon */ |
317 | .family = 6, |
318 | .model = INTEL_FAM6_ICELAKE_X, |
319 | .data = "icx" , |
320 | }, |
321 | { /* Icelake Xeon D */ |
322 | .family = 6, |
323 | .model = INTEL_FAM6_ICELAKE_D, |
324 | .data = "icxd" , |
325 | }, |
326 | { /* Sapphire Rapids Xeon */ |
327 | .family = 6, |
328 | .model = INTEL_FAM6_SAPPHIRERAPIDS_X, |
329 | .data = "spr" , |
330 | }, |
331 | { } |
332 | }; |
333 | MODULE_DEVICE_TABLE(peci, peci_cpu_device_ids); |
334 | |
335 | static struct peci_driver peci_cpu_driver = { |
336 | .probe = peci_cpu_probe, |
337 | .id_table = peci_cpu_device_ids, |
338 | .driver = { |
339 | .name = "peci-cpu" , |
340 | }, |
341 | }; |
342 | module_peci_driver(peci_cpu_driver); |
343 | |
344 | MODULE_AUTHOR("Iwona Winiarska <iwona.winiarska@intel.com>" ); |
345 | MODULE_DESCRIPTION("PECI CPU driver" ); |
346 | MODULE_LICENSE("GPL" ); |
347 | MODULE_IMPORT_NS(PECI); |
348 | |