blob: 63454b06e5da17b648c6db3e28d4a6b76b2977f0 [file] [log] [blame]
Jan Dabros78d5e9e2022-02-08 15:12:18 +01001// SPDX-License-Identifier: GPL-2.0
2
Jan Dabros78d5e9e2022-02-08 15:12:18 +01003#include <linux/i2c.h>
Mario Limonciello482c84e2023-04-14 09:40:08 -05004#include <linux/pci.h>
Mario Limonciello440da732023-04-14 09:40:07 -05005#include <linux/psp-platform-access.h>
Mario Limoncielloae7d45fb2023-03-10 15:19:45 -06006#include <linux/psp.h>
Jan Dabros786f01d2022-08-12 09:15:26 +02007#include <linux/workqueue.h>
Jan Dabros78d5e9e2022-02-08 15:12:18 +01008
Jan Dabros78d5e9e2022-02-08 15:12:18 +01009#include "i2c-designware-core.h"
10
Jan Dabros786f01d2022-08-12 09:15:26 +020011#define PSP_I2C_RESERVATION_TIME_MS 100
12
Jan Dabrosbe18ce12022-04-28 14:26:51 +020013#define PSP_I2C_REQ_RETRY_CNT 400
14#define PSP_I2C_REQ_RETRY_DELAY_US (25 * USEC_PER_MSEC)
Jan Dabros78d5e9e2022-02-08 15:12:18 +010015#define PSP_I2C_REQ_STS_OK 0x0
16#define PSP_I2C_REQ_STS_BUS_BUSY 0x1
17#define PSP_I2C_REQ_STS_INV_PARAM 0x3
18
Jan Dabros78d5e9e2022-02-08 15:12:18 +010019enum psp_i2c_req_type {
20 PSP_I2C_REQ_ACQUIRE,
21 PSP_I2C_REQ_RELEASE,
22 PSP_I2C_REQ_MAX
23};
24
25struct psp_i2c_req {
26 struct psp_req_buffer_hdr hdr;
27 enum psp_i2c_req_type type;
28};
29
Jan Dabros78d5e9e2022-02-08 15:12:18 +010030static DEFINE_MUTEX(psp_i2c_access_mutex);
31static unsigned long psp_i2c_sem_acquired;
Jan Dabros78d5e9e2022-02-08 15:12:18 +010032static u32 psp_i2c_access_count;
33static bool psp_i2c_mbox_fail;
34static struct device *psp_i2c_dev;
35
Mario Limonciello482c84e2023-04-14 09:40:08 -050036static int (*_psp_send_i2c_req)(struct psp_i2c_req *req);
37
Jan Dabros78d5e9e2022-02-08 15:12:18 +010038/* Helper to verify status returned by PSP */
39static int check_i2c_req_sts(struct psp_i2c_req *req)
40{
Jan Dabros17ba1e82022-02-18 14:33:48 +010041 u32 status;
Jan Dabros78d5e9e2022-02-08 15:12:18 +010042
Jan Dabros17ba1e82022-02-18 14:33:48 +010043 /* Status field in command-response buffer is updated by PSP */
44 status = READ_ONCE(req->hdr.status);
Jan Dabros78d5e9e2022-02-08 15:12:18 +010045
46 switch (status) {
47 case PSP_I2C_REQ_STS_OK:
48 return 0;
49 case PSP_I2C_REQ_STS_BUS_BUSY:
50 return -EBUSY;
51 case PSP_I2C_REQ_STS_INV_PARAM:
52 default:
53 return -EIO;
Yang Li1e4fe542022-02-14 20:47:01 +080054 }
Jan Dabros78d5e9e2022-02-08 15:12:18 +010055}
56
Mario Limonciello440da732023-04-14 09:40:07 -050057/*
58 * Errors in x86-PSP i2c-arbitration protocol may occur at two levels:
59 * 1. mailbox communication - PSP is not operational or some IO errors with
60 * basic communication had happened.
61 * 2. i2c-requests - PSP refuses to grant i2c arbitration to x86 for too long.
62 *
63 * In order to distinguish between these in error handling code all mailbox
64 * communication errors on the first level (from CCP symbols) will be passed
65 * up and if -EIO is returned the second level will be checked.
66 */
67static int psp_send_i2c_req_cezanne(struct psp_i2c_req *req)
Jan Dabros78d5e9e2022-02-08 15:12:18 +010068{
Mario Limonciello440da732023-04-14 09:40:07 -050069 int ret;
Jan Dabros78d5e9e2022-02-08 15:12:18 +010070
Mario Limonciello440da732023-04-14 09:40:07 -050071 ret = psp_send_platform_access_msg(PSP_I2C_REQ_BUS_CMD, (struct psp_request *)req);
72 if (ret == -EIO)
73 return check_i2c_req_sts(req);
74
75 return ret;
Jan Dabros78d5e9e2022-02-08 15:12:18 +010076}
77
Mario Limonciello482c84e2023-04-14 09:40:08 -050078static int psp_send_i2c_req_doorbell(struct psp_i2c_req *req)
79{
80 int ret;
81
82 ret = psp_ring_platform_doorbell(req->type, &req->hdr.status);
83 if (ret == -EIO)
84 return check_i2c_req_sts(req);
85
86 return ret;
87}
88
Jan Dabros78d5e9e2022-02-08 15:12:18 +010089static int psp_send_i2c_req(enum psp_i2c_req_type i2c_req_type)
90{
91 struct psp_i2c_req *req;
92 unsigned long start;
93 int status, ret;
94
95 /* Allocate command-response buffer */
96 req = kzalloc(sizeof(*req), GFP_KERNEL);
97 if (!req)
98 return -ENOMEM;
99
Mario Limonciello440da732023-04-14 09:40:07 -0500100 req->hdr.payload_size = sizeof(*req);
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100101 req->type = i2c_req_type;
102
103 start = jiffies;
Mario Limonciello482c84e2023-04-14 09:40:08 -0500104 ret = read_poll_timeout(_psp_send_i2c_req, status,
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100105 (status != -EBUSY),
106 PSP_I2C_REQ_RETRY_DELAY_US,
107 PSP_I2C_REQ_RETRY_CNT * PSP_I2C_REQ_RETRY_DELAY_US,
108 0, req);
Jan Dabros3364c0e2022-03-14 10:03:23 +0100109 if (ret) {
110 dev_err(psp_i2c_dev, "Timed out waiting for PSP to %s I2C bus\n",
111 (i2c_req_type == PSP_I2C_REQ_ACQUIRE) ?
112 "release" : "acquire");
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100113 goto cleanup;
Jan Dabros3364c0e2022-03-14 10:03:23 +0100114 }
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100115
116 ret = status;
Jan Dabros3364c0e2022-03-14 10:03:23 +0100117 if (ret) {
118 dev_err(psp_i2c_dev, "PSP communication error\n");
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100119 goto cleanup;
Jan Dabros3364c0e2022-03-14 10:03:23 +0100120 }
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100121
122 dev_dbg(psp_i2c_dev, "Request accepted by PSP after %ums\n",
123 jiffies_to_msecs(jiffies - start));
124
125cleanup:
Jan Dabros3364c0e2022-03-14 10:03:23 +0100126 if (ret) {
127 dev_err(psp_i2c_dev, "Assume i2c bus is for exclusive host usage\n");
128 psp_i2c_mbox_fail = true;
129 }
130
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100131 kfree(req);
132 return ret;
133}
134
Jan Dabros786f01d2022-08-12 09:15:26 +0200135static void release_bus(void)
136{
137 int status;
138
139 if (!psp_i2c_sem_acquired)
140 return;
141
142 status = psp_send_i2c_req(PSP_I2C_REQ_RELEASE);
143 if (status)
144 return;
145
146 dev_dbg(psp_i2c_dev, "PSP semaphore held for %ums\n",
147 jiffies_to_msecs(jiffies - psp_i2c_sem_acquired));
148
149 psp_i2c_sem_acquired = 0;
150}
151
152static void psp_release_i2c_bus_deferred(struct work_struct *work)
153{
154 mutex_lock(&psp_i2c_access_mutex);
155
156 /*
157 * If there is any pending transaction, cannot release the bus here.
158 * psp_release_i2c_bus will take care of this later.
159 */
160 if (psp_i2c_access_count)
161 goto cleanup;
162
163 release_bus();
164
165cleanup:
166 mutex_unlock(&psp_i2c_access_mutex);
167}
168static DECLARE_DELAYED_WORK(release_queue, psp_release_i2c_bus_deferred);
169
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100170static int psp_acquire_i2c_bus(void)
171{
172 int status;
173
174 mutex_lock(&psp_i2c_access_mutex);
175
176 /* Return early if mailbox malfunctioned */
177 if (psp_i2c_mbox_fail)
178 goto cleanup;
179
Jan Dabros786f01d2022-08-12 09:15:26 +0200180 psp_i2c_access_count++;
181
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100182 /*
Jan Dabros786f01d2022-08-12 09:15:26 +0200183 * No need to request bus arbitration once we are inside semaphore
184 * reservation period.
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100185 */
Jan Dabros786f01d2022-08-12 09:15:26 +0200186 if (psp_i2c_sem_acquired)
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100187 goto cleanup;
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100188
189 status = psp_send_i2c_req(PSP_I2C_REQ_ACQUIRE);
Jan Dabros3364c0e2022-03-14 10:03:23 +0100190 if (status)
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100191 goto cleanup;
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100192
193 psp_i2c_sem_acquired = jiffies;
Jan Dabros786f01d2022-08-12 09:15:26 +0200194
195 schedule_delayed_work(&release_queue,
196 msecs_to_jiffies(PSP_I2C_RESERVATION_TIME_MS));
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100197
198 /*
199 * In case of errors with PSP arbitrator psp_i2c_mbox_fail variable is
200 * set above. As a consequence consecutive calls to acquire will bypass
201 * communication with PSP. At any case i2c bus is granted to the caller,
202 * thus always return success.
203 */
204cleanup:
205 mutex_unlock(&psp_i2c_access_mutex);
206 return 0;
207}
208
209static void psp_release_i2c_bus(void)
210{
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100211 mutex_lock(&psp_i2c_access_mutex);
212
213 /* Return early if mailbox was malfunctional */
214 if (psp_i2c_mbox_fail)
215 goto cleanup;
216
217 /*
218 * If we are last owner of PSP semaphore, need to release aribtration
219 * via mailbox.
220 */
221 psp_i2c_access_count--;
222 if (psp_i2c_access_count)
223 goto cleanup;
224
Jan Dabros786f01d2022-08-12 09:15:26 +0200225 /*
226 * Send a release command to PSP if the semaphore reservation timeout
227 * elapsed but x86 still owns the controller.
228 */
229 if (!delayed_work_pending(&release_queue))
230 release_bus();
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100231
232cleanup:
233 mutex_unlock(&psp_i2c_access_mutex);
234}
235
236/*
237 * Locking methods are based on the default implementation from
238 * drivers/i2c/i2c-core-base.c, but with psp acquire and release operations
239 * added. With this in place we can ensure that i2c clients on the bus shared
240 * with psp are able to lock HW access to the bus for arbitrary number of
241 * operations - that is e.g. write-wait-read.
242 */
243static void i2c_adapter_dw_psp_lock_bus(struct i2c_adapter *adapter,
244 unsigned int flags)
245{
246 psp_acquire_i2c_bus();
247 rt_mutex_lock_nested(&adapter->bus_lock, i2c_adapter_depth(adapter));
248}
249
250static int i2c_adapter_dw_psp_trylock_bus(struct i2c_adapter *adapter,
251 unsigned int flags)
252{
253 int ret;
254
255 ret = rt_mutex_trylock(&adapter->bus_lock);
256 if (ret)
257 return ret;
258
259 psp_acquire_i2c_bus();
260
261 return ret;
262}
263
264static void i2c_adapter_dw_psp_unlock_bus(struct i2c_adapter *adapter,
265 unsigned int flags)
266{
267 psp_release_i2c_bus();
268 rt_mutex_unlock(&adapter->bus_lock);
269}
270
271static const struct i2c_lock_operations i2c_dw_psp_lock_ops = {
272 .lock_bus = i2c_adapter_dw_psp_lock_bus,
273 .trylock_bus = i2c_adapter_dw_psp_trylock_bus,
274 .unlock_bus = i2c_adapter_dw_psp_unlock_bus,
275};
276
277int i2c_dw_amdpsp_probe_lock_support(struct dw_i2c_dev *dev)
278{
Mario Limonciello482c84e2023-04-14 09:40:08 -0500279 struct pci_dev *rdev;
280
Mario Limonciello440da732023-04-14 09:40:07 -0500281 if (!IS_REACHABLE(CONFIG_CRYPTO_DEV_CCP_DD))
282 return -ENODEV;
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100283
284 if (!dev)
285 return -ENODEV;
286
287 if (!(dev->flags & ARBITRATION_SEMAPHORE))
288 return -ENODEV;
289
290 /* Allow to bind only one instance of a driver */
291 if (psp_i2c_dev)
292 return -EEXIST;
293
Mario Limonciello482c84e2023-04-14 09:40:08 -0500294 /* Cezanne uses platform mailbox, Mendocino and later use doorbell */
295 rdev = pci_get_domain_bus_and_slot(0, 0, PCI_DEVFN(0, 0));
296 if (rdev->device == 0x1630)
297 _psp_send_i2c_req = psp_send_i2c_req_cezanne;
298 else
299 _psp_send_i2c_req = psp_send_i2c_req_doorbell;
300 pci_dev_put(rdev);
301
Mario Limonciello440da732023-04-14 09:40:07 -0500302 if (psp_check_platform_access_status())
303 return -EPROBE_DEFER;
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100304
Mario Limonciello440da732023-04-14 09:40:07 -0500305 psp_i2c_dev = dev->dev;
Jan Dabros78d5e9e2022-02-08 15:12:18 +0100306
307 dev_info(psp_i2c_dev, "I2C bus managed by AMD PSP\n");
308
309 /*
310 * Install global locking callbacks for adapter as well as internal i2c
311 * controller locks.
312 */
313 dev->adapter.lock_ops = &i2c_dw_psp_lock_ops;
314 dev->acquire_lock = psp_acquire_i2c_bus;
315 dev->release_lock = psp_release_i2c_bus;
316
317 return 0;
318}