1 // SPDX-License-Identifier: GPL-2.0
2
3 #include <linux/bitfield.h>
4 #include <linux/bits.h>
5 #include <linux/i2c.h>
6 #include <linux/io-64-nonatomic-lo-hi.h>
7 #include <linux/psp-sev.h>
8 #include <linux/types.h>
9
10 #include <asm/msr.h>
11
12 #include "i2c-designware-core.h"
13
14 #define MSR_AMD_PSP_ADDR 0xc00110a2
15 #define PSP_MBOX_OFFSET 0x10570
16 #define PSP_CMD_TIMEOUT_US (500 * USEC_PER_MSEC)
17
18 #define PSP_I2C_REQ_BUS_CMD 0x64
19 #define PSP_I2C_REQ_RETRY_CNT 400
20 #define PSP_I2C_REQ_RETRY_DELAY_US (25 * USEC_PER_MSEC)
21 #define PSP_I2C_REQ_STS_OK 0x0
22 #define PSP_I2C_REQ_STS_BUS_BUSY 0x1
23 #define PSP_I2C_REQ_STS_INV_PARAM 0x3
24
25 #define PSP_MBOX_FIELDS_STS GENMASK(15, 0)
26 #define PSP_MBOX_FIELDS_CMD GENMASK(23, 16)
27 #define PSP_MBOX_FIELDS_RESERVED GENMASK(29, 24)
28 #define PSP_MBOX_FIELDS_RECOVERY BIT(30)
29 #define PSP_MBOX_FIELDS_READY BIT(31)
30
31 struct psp_req_buffer_hdr {
32 u32 total_size;
33 u32 status;
34 };
35
36 enum psp_i2c_req_type {
37 PSP_I2C_REQ_ACQUIRE,
38 PSP_I2C_REQ_RELEASE,
39 PSP_I2C_REQ_MAX
40 };
41
42 struct psp_i2c_req {
43 struct psp_req_buffer_hdr hdr;
44 enum psp_i2c_req_type type;
45 };
46
47 struct psp_mbox {
48 u32 cmd_fields;
49 u64 i2c_req_addr;
50 } __packed;
51
52 static DEFINE_MUTEX(psp_i2c_access_mutex);
53 static unsigned long psp_i2c_sem_acquired;
54 static void __iomem *mbox_iomem;
55 static u32 psp_i2c_access_count;
56 static bool psp_i2c_mbox_fail;
57 static struct device *psp_i2c_dev;
58
59 /*
60 * Implementation of PSP-x86 i2c-arbitration mailbox introduced for AMD Cezanne
61 * family of SoCs.
62 */
63
psp_get_mbox_addr(unsigned long * mbox_addr)64 static int psp_get_mbox_addr(unsigned long *mbox_addr)
65 {
66 unsigned long long psp_mmio;
67
68 if (rdmsrl_safe(MSR_AMD_PSP_ADDR, &psp_mmio))
69 return -EIO;
70
71 *mbox_addr = (unsigned long)(psp_mmio + PSP_MBOX_OFFSET);
72
73 return 0;
74 }
75
psp_mbox_probe(void)76 static int psp_mbox_probe(void)
77 {
78 unsigned long mbox_addr;
79 int ret;
80
81 ret = psp_get_mbox_addr(&mbox_addr);
82 if (ret)
83 return ret;
84
85 mbox_iomem = ioremap(mbox_addr, sizeof(struct psp_mbox));
86 if (!mbox_iomem)
87 return -ENOMEM;
88
89 return 0;
90 }
91
92 /* Recovery field should be equal 0 to start sending commands */
psp_check_mbox_recovery(struct psp_mbox __iomem * mbox)93 static int psp_check_mbox_recovery(struct psp_mbox __iomem *mbox)
94 {
95 u32 tmp;
96
97 tmp = readl(&mbox->cmd_fields);
98
99 return FIELD_GET(PSP_MBOX_FIELDS_RECOVERY, tmp);
100 }
101
psp_wait_cmd(struct psp_mbox __iomem * mbox)102 static int psp_wait_cmd(struct psp_mbox __iomem *mbox)
103 {
104 u32 tmp, expected;
105
106 /* Expect mbox_cmd to be cleared and ready bit to be set by PSP */
107 expected = FIELD_PREP(PSP_MBOX_FIELDS_READY, 1);
108
109 /*
110 * Check for readiness of PSP mailbox in a tight loop in order to
111 * process further as soon as command was consumed.
112 */
113 return readl_poll_timeout(&mbox->cmd_fields, tmp, (tmp == expected),
114 0, PSP_CMD_TIMEOUT_US);
115 }
116
117 /* Status equal to 0 means that PSP succeed processing command */
psp_check_mbox_sts(struct psp_mbox __iomem * mbox)118 static u32 psp_check_mbox_sts(struct psp_mbox __iomem *mbox)
119 {
120 u32 cmd_reg;
121
122 cmd_reg = readl(&mbox->cmd_fields);
123
124 return FIELD_GET(PSP_MBOX_FIELDS_STS, cmd_reg);
125 }
126
psp_send_cmd(struct psp_i2c_req * req)127 static int psp_send_cmd(struct psp_i2c_req *req)
128 {
129 struct psp_mbox __iomem *mbox = mbox_iomem;
130 phys_addr_t req_addr;
131 u32 cmd_reg;
132
133 if (psp_check_mbox_recovery(mbox))
134 return -EIO;
135
136 if (psp_wait_cmd(mbox))
137 return -EBUSY;
138
139 /*
140 * Fill mailbox with address of command-response buffer, which will be
141 * used for sending i2c requests as well as reading status returned by
142 * PSP. Use physical address of buffer, since PSP will map this region.
143 */
144 req_addr = __psp_pa((void *)req);
145 writeq(req_addr, &mbox->i2c_req_addr);
146
147 /* Write command register to trigger processing */
148 cmd_reg = FIELD_PREP(PSP_MBOX_FIELDS_CMD, PSP_I2C_REQ_BUS_CMD);
149 writel(cmd_reg, &mbox->cmd_fields);
150
151 if (psp_wait_cmd(mbox))
152 return -ETIMEDOUT;
153
154 if (psp_check_mbox_sts(mbox))
155 return -EIO;
156
157 return 0;
158 }
159
160 /* Helper to verify status returned by PSP */
check_i2c_req_sts(struct psp_i2c_req * req)161 static int check_i2c_req_sts(struct psp_i2c_req *req)
162 {
163 u32 status;
164
165 /* Status field in command-response buffer is updated by PSP */
166 status = READ_ONCE(req->hdr.status);
167
168 switch (status) {
169 case PSP_I2C_REQ_STS_OK:
170 return 0;
171 case PSP_I2C_REQ_STS_BUS_BUSY:
172 return -EBUSY;
173 case PSP_I2C_REQ_STS_INV_PARAM:
174 default:
175 return -EIO;
176 }
177 }
178
psp_send_check_i2c_req(struct psp_i2c_req * req)179 static int psp_send_check_i2c_req(struct psp_i2c_req *req)
180 {
181 /*
182 * Errors in x86-PSP i2c-arbitration protocol may occur at two levels:
183 * 1. mailbox communication - PSP is not operational or some IO errors
184 * with basic communication had happened;
185 * 2. i2c-requests - PSP refuses to grant i2c arbitration to x86 for too
186 * long.
187 * In order to distinguish between these two in error handling code, all
188 * errors on the first level (returned by psp_send_cmd) are shadowed by
189 * -EIO.
190 */
191 if (psp_send_cmd(req))
192 return -EIO;
193
194 return check_i2c_req_sts(req);
195 }
196
psp_send_i2c_req(enum psp_i2c_req_type i2c_req_type)197 static int psp_send_i2c_req(enum psp_i2c_req_type i2c_req_type)
198 {
199 struct psp_i2c_req *req;
200 unsigned long start;
201 int status, ret;
202
203 /* Allocate command-response buffer */
204 req = kzalloc(sizeof(*req), GFP_KERNEL);
205 if (!req)
206 return -ENOMEM;
207
208 req->hdr.total_size = sizeof(*req);
209 req->type = i2c_req_type;
210
211 start = jiffies;
212 ret = read_poll_timeout(psp_send_check_i2c_req, status,
213 (status != -EBUSY),
214 PSP_I2C_REQ_RETRY_DELAY_US,
215 PSP_I2C_REQ_RETRY_CNT * PSP_I2C_REQ_RETRY_DELAY_US,
216 0, req);
217 if (ret) {
218 dev_err(psp_i2c_dev, "Timed out waiting for PSP to %s I2C bus\n",
219 (i2c_req_type == PSP_I2C_REQ_ACQUIRE) ?
220 "release" : "acquire");
221 goto cleanup;
222 }
223
224 ret = status;
225 if (ret) {
226 dev_err(psp_i2c_dev, "PSP communication error\n");
227 goto cleanup;
228 }
229
230 dev_dbg(psp_i2c_dev, "Request accepted by PSP after %ums\n",
231 jiffies_to_msecs(jiffies - start));
232
233 cleanup:
234 if (ret) {
235 dev_err(psp_i2c_dev, "Assume i2c bus is for exclusive host usage\n");
236 psp_i2c_mbox_fail = true;
237 }
238
239 kfree(req);
240 return ret;
241 }
242
psp_acquire_i2c_bus(void)243 static int psp_acquire_i2c_bus(void)
244 {
245 int status;
246
247 mutex_lock(&psp_i2c_access_mutex);
248
249 /* Return early if mailbox malfunctioned */
250 if (psp_i2c_mbox_fail)
251 goto cleanup;
252
253 /*
254 * Simply increment usage counter and return if PSP semaphore was
255 * already taken by kernel.
256 */
257 if (psp_i2c_access_count) {
258 psp_i2c_access_count++;
259 goto cleanup;
260 }
261
262 status = psp_send_i2c_req(PSP_I2C_REQ_ACQUIRE);
263 if (status)
264 goto cleanup;
265
266 psp_i2c_sem_acquired = jiffies;
267 psp_i2c_access_count++;
268
269 /*
270 * In case of errors with PSP arbitrator psp_i2c_mbox_fail variable is
271 * set above. As a consequence consecutive calls to acquire will bypass
272 * communication with PSP. At any case i2c bus is granted to the caller,
273 * thus always return success.
274 */
275 cleanup:
276 mutex_unlock(&psp_i2c_access_mutex);
277 return 0;
278 }
279
psp_release_i2c_bus(void)280 static void psp_release_i2c_bus(void)
281 {
282 int status;
283
284 mutex_lock(&psp_i2c_access_mutex);
285
286 /* Return early if mailbox was malfunctional */
287 if (psp_i2c_mbox_fail)
288 goto cleanup;
289
290 /*
291 * If we are last owner of PSP semaphore, need to release aribtration
292 * via mailbox.
293 */
294 psp_i2c_access_count--;
295 if (psp_i2c_access_count)
296 goto cleanup;
297
298 /* Send a release command to PSP */
299 status = psp_send_i2c_req(PSP_I2C_REQ_RELEASE);
300 if (status)
301 goto cleanup;
302
303 dev_dbg(psp_i2c_dev, "PSP semaphore held for %ums\n",
304 jiffies_to_msecs(jiffies - psp_i2c_sem_acquired));
305
306 cleanup:
307 mutex_unlock(&psp_i2c_access_mutex);
308 }
309
310 /*
311 * Locking methods are based on the default implementation from
312 * drivers/i2c/i2c-core-base.c, but with psp acquire and release operations
313 * added. With this in place we can ensure that i2c clients on the bus shared
314 * with psp are able to lock HW access to the bus for arbitrary number of
315 * operations - that is e.g. write-wait-read.
316 */
i2c_adapter_dw_psp_lock_bus(struct i2c_adapter * adapter,unsigned int flags)317 static void i2c_adapter_dw_psp_lock_bus(struct i2c_adapter *adapter,
318 unsigned int flags)
319 {
320 psp_acquire_i2c_bus();
321 rt_mutex_lock_nested(&adapter->bus_lock, i2c_adapter_depth(adapter));
322 }
323
i2c_adapter_dw_psp_trylock_bus(struct i2c_adapter * adapter,unsigned int flags)324 static int i2c_adapter_dw_psp_trylock_bus(struct i2c_adapter *adapter,
325 unsigned int flags)
326 {
327 int ret;
328
329 ret = rt_mutex_trylock(&adapter->bus_lock);
330 if (ret)
331 return ret;
332
333 psp_acquire_i2c_bus();
334
335 return ret;
336 }
337
i2c_adapter_dw_psp_unlock_bus(struct i2c_adapter * adapter,unsigned int flags)338 static void i2c_adapter_dw_psp_unlock_bus(struct i2c_adapter *adapter,
339 unsigned int flags)
340 {
341 psp_release_i2c_bus();
342 rt_mutex_unlock(&adapter->bus_lock);
343 }
344
345 static const struct i2c_lock_operations i2c_dw_psp_lock_ops = {
346 .lock_bus = i2c_adapter_dw_psp_lock_bus,
347 .trylock_bus = i2c_adapter_dw_psp_trylock_bus,
348 .unlock_bus = i2c_adapter_dw_psp_unlock_bus,
349 };
350
i2c_dw_amdpsp_probe_lock_support(struct dw_i2c_dev * dev)351 int i2c_dw_amdpsp_probe_lock_support(struct dw_i2c_dev *dev)
352 {
353 int ret;
354
355 if (!dev)
356 return -ENODEV;
357
358 if (!(dev->flags & ARBITRATION_SEMAPHORE))
359 return -ENODEV;
360
361 /* Allow to bind only one instance of a driver */
362 if (psp_i2c_dev)
363 return -EEXIST;
364
365 psp_i2c_dev = dev->dev;
366
367 ret = psp_mbox_probe();
368 if (ret)
369 return ret;
370
371 dev_info(psp_i2c_dev, "I2C bus managed by AMD PSP\n");
372
373 /*
374 * Install global locking callbacks for adapter as well as internal i2c
375 * controller locks.
376 */
377 dev->adapter.lock_ops = &i2c_dw_psp_lock_ops;
378 dev->acquire_lock = psp_acquire_i2c_bus;
379 dev->release_lock = psp_release_i2c_bus;
380
381 return 0;
382 }
383
384 /* Unmap area used as a mailbox with PSP */
i2c_dw_amdpsp_remove_lock_support(struct dw_i2c_dev * dev)385 void i2c_dw_amdpsp_remove_lock_support(struct dw_i2c_dev *dev)
386 {
387 iounmap(mbox_iomem);
388 }
389