projects/linux·blob master · refs

251 lines · 5.2 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2// Copyright (c) 2018-2021 Intel Corporation
3
4#include <linux/bitfield.h>
5#include <linux/peci.h>
6#include <linux/peci-cpu.h>
7#include <linux/slab.h>
8
9#include "internal.h"
10
11/*
12 * PECI device can be removed using sysfs, but the removal can also happen as
13 * a result of controller being removed.
14 * Mutex is used to protect PECI device from being double-deleted.
15 */
16static DEFINE_MUTEX(peci_device_del_lock);
17
18#define REVISION_NUM_MASK GENMASK(15, 8)
19static int peci_get_revision(struct peci_device *device, u8 *revision)
20{
21 struct peci_request *req;
22 u64 dib;
23
24 req = peci_xfer_get_dib(device);
25 if (IS_ERR(req))
26 return PTR_ERR(req);
27
28 /*
29 * PECI device may be in a state where it is unable to return a proper
30 * DIB, in which case it returns 0 as DIB value.
31 * Let's treat this as an error to avoid carrying on with the detection
32 * using invalid revision.
33 */
34 dib = peci_request_dib_read(req);
35 if (dib == 0) {
36 peci_request_free(req);
37 return -EIO;
38 }
39
40 *revision = FIELD_GET(REVISION_NUM_MASK, dib);
41
42 peci_request_free(req);
43
44 return 0;
45}
46
47static int peci_get_cpu_id(struct peci_device *device, u32 *cpu_id)
48{
49 struct peci_request *req;
50 int ret;
51
52 req = peci_xfer_pkg_cfg_readl(device, PECI_PCS_PKG_ID, PECI_PKG_ID_CPU_ID);
53 if (IS_ERR(req))
54 return PTR_ERR(req);
55
56 ret = peci_request_status(req);
57 if (ret)
58 goto out_req_free;
59
60 *cpu_id = peci_request_data_readl(req);
61out_req_free:
62 peci_request_free(req);
63
64 return ret;
65}
66
67static unsigned int peci_x86_cpu_family(unsigned int sig)
68{
69 unsigned int x86;
70
71 x86 = (sig >> 8) & 0xf;
72
73 if (x86 == 0xf)
74 x86 += (sig >> 20) & 0xff;
75
76 return x86;
77}
78
79static unsigned int peci_x86_cpu_model(unsigned int sig)
80{
81 unsigned int fam, model;
82
83 fam = peci_x86_cpu_family(sig);
84
85 model = (sig >> 4) & 0xf;
86
87 if (fam >= 0x6)
88 model += ((sig >> 16) & 0xf) << 4;
89
90 return model;
91}
92
93static int peci_device_info_init(struct peci_device *device)
94{
95 u8 revision;
96 u32 cpu_id;
97 int ret;
98
99 ret = peci_get_cpu_id(device, &cpu_id);
100 if (ret)
101 return ret;
102
103 device->info.x86_vfm = IFM(peci_x86_cpu_family(cpu_id), peci_x86_cpu_model(cpu_id));
104
105 ret = peci_get_revision(device, &revision);
106 if (ret)
107 return ret;
108 device->info.peci_revision = revision;
109
110 device->info.socket_id = device->addr - PECI_BASE_ADDR;
111
112 return 0;
113}
114
115static int peci_detect(struct peci_controller *controller, u8 addr)
116{
117 /*
118 * PECI Ping is a command encoded by tx_len = 0, rx_len = 0.
119 * We expect correct Write FCS if the device at the target address
120 * is able to respond.
121 */
122 struct peci_request req = { 0 };
123 int ret;
124
125 mutex_lock(&controller->bus_lock);
126 ret = controller->ops->xfer(controller, addr, &req);
127 mutex_unlock(&controller->bus_lock);
128
129 return ret;
130}
131
132static bool peci_addr_valid(u8 addr)
133{
134 return addr >= PECI_BASE_ADDR && addr < PECI_BASE_ADDR + PECI_DEVICE_NUM_MAX;
135}
136
137static int peci_dev_exists(struct device *dev, void *data)
138{
139 struct peci_device *device = to_peci_device(dev);
140 u8 *addr = data;
141
142 if (device->addr == *addr)
143 return -EBUSY;
144
145 return 0;
146}
147
148int peci_device_create(struct peci_controller *controller, u8 addr)
149{
150 struct peci_device *device;
151 int ret;
152
153 if (!peci_addr_valid(addr))
154 return -EINVAL;
155
156 /* Check if we have already detected this device before. */
157 ret = device_for_each_child(&controller->dev, &addr, peci_dev_exists);
158 if (ret)
159 return 0;
160
161 ret = peci_detect(controller, addr);
162 if (ret) {
163 /*
164 * Device not present or host state doesn't allow successful
165 * detection at this time.
166 */
167 if (ret == -EIO || ret == -ETIMEDOUT)
168 return 0;
169
170 return ret;
171 }
172
173 device = kzalloc_obj(*device);
174 if (!device)
175 return -ENOMEM;
176
177 device_initialize(&device->dev);
178
179 device->addr = addr;
180 device->dev.parent = &controller->dev;
181 device->dev.bus = &peci_bus_type;
182 device->dev.type = &peci_device_type;
183
184 ret = peci_device_info_init(device);
185 if (ret)
186 goto err_put;
187
188 ret = dev_set_name(&device->dev, "%d-%02x", controller->id, device->addr);
189 if (ret)
190 goto err_put;
191
192 ret = device_add(&device->dev);
193 if (ret)
194 goto err_put;
195
196 return 0;
197
198err_put:
199 put_device(&device->dev);
200
201 return ret;
202}
203
204void peci_device_destroy(struct peci_device *device)
205{
206 mutex_lock(&peci_device_del_lock);
207 if (!device->deleted) {
208 device_unregister(&device->dev);
209 device->deleted = true;
210 }
211 mutex_unlock(&peci_device_del_lock);
212}
213
214int __peci_driver_register(struct peci_driver *driver, struct module *owner,
215 const char *mod_name)
216{
217 driver->driver.bus = &peci_bus_type;
218 driver->driver.owner = owner;
219 driver->driver.mod_name = mod_name;
220
221 if (!driver->probe) {
222 pr_err("peci: trying to register driver without probe callback\n");
223 return -EINVAL;
224 }
225
226 if (!driver->id_table) {
227 pr_err("peci: trying to register driver without device id table\n");
228 return -EINVAL;
229 }
230
231 return driver_register(&driver->driver);
232}
233EXPORT_SYMBOL_NS_GPL(__peci_driver_register, "PECI");
234
235void peci_driver_unregister(struct peci_driver *driver)
236{
237 driver_unregister(&driver->driver);
238}
239EXPORT_SYMBOL_NS_GPL(peci_driver_unregister, "PECI");
240
241static void peci_device_release(struct device *dev)
242{
243 struct peci_device *device = to_peci_device(dev);
244
245 kfree(device);
246}
247
248const struct device_type peci_device_type = {
249 .groups = peci_device_groups,
250 .release = peci_device_release,
251};