1 // SPDX-License-Identifier: GPL-2.0
2
3 #include <linux/i2c.h>
4 #include <linux/pci.h>
5 #include <linux/psp-platform-access.h>
6 #include <linux/psp.h>
7 #include <linux/workqueue.h>
8
9 #include "i2c-designware-core.h"
10
11 #define PSP_I2C_RESERVATION_TIME_MS 100
12
13 #define PSP_I2C_REQ_RETRY_CNT 400
14 #define PSP_I2C_REQ_RETRY_DELAY_US (25 * USEC_PER_MSEC)
15 #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
19 enum psp_i2c_req_type {
20 PSP_I2C_REQ_ACQUIRE,
21 PSP_I2C_REQ_RELEASE,
22 PSP_I2C_REQ_MAX
23 };
24
25 struct psp_i2c_req {
26 struct psp_req_buffer_hdr hdr;
27 enum psp_i2c_req_type type;
28 };
29
30 static DEFINE_MUTEX(psp_i2c_access_mutex);
31 static unsigned long psp_i2c_sem_acquired;
32 static u32 psp_i2c_access_count;
33 static bool psp_i2c_mbox_fail;
34 static struct device *psp_i2c_dev;
35
36 static int (*_psp_send_i2c_req)(struct psp_i2c_req *req);
37
38 /* Helper to verify status returned by PSP */
check_i2c_req_sts(struct psp_i2c_req * req)39 static int check_i2c_req_sts(struct psp_i2c_req *req)
40 {
41 u32 status;
42
43 /* Status field in command-response buffer is updated by PSP */
44 status = READ_ONCE(req->hdr.status);
45
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;
54 }
55 }
56
57 /*
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 */
psp_send_i2c_req_cezanne(struct psp_i2c_req * req)67 static int psp_send_i2c_req_cezanne(struct psp_i2c_req *req)
68 {
69 int ret;
70
71 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;
76 }
77
psp_send_i2c_req_doorbell(struct psp_i2c_req * req)78 static 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
psp_send_i2c_req(enum psp_i2c_req_type i2c_req_type)89 static 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
100 req->hdr.payload_size = sizeof(*req);
101 req->type = i2c_req_type;
102
103 start = jiffies;
104 ret = read_poll_timeout(_psp_send_i2c_req, status,
105 (status != -EBUSY),
106 PSP_I2C_REQ_RETRY_DELAY_US,
107 PSP_I2C_REQ_RETRY_CNT * PSP_I2C_REQ_RETRY_DELAY_US,
108 0, req);
109 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");
113 goto cleanup;
114 }
115
116 ret = status;
117 if (ret) {
118 dev_err(psp_i2c_dev, "PSP communication error\n");
119 goto cleanup;
120 }
121
122 dev_dbg(psp_i2c_dev, "Request accepted by PSP after %ums\n",
123 jiffies_to_msecs(jiffies - start));
124
125 cleanup:
126 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
131 kfree(req);
132 return ret;
133 }
134
release_bus(void)135 static 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
psp_release_i2c_bus_deferred(struct work_struct * work)152 static void psp_release_i2c_bus_deferred(struct work_struct *work)
153 {
154 guard(mutex)(&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 return;
162
163 release_bus();
164 }
165 static DECLARE_DELAYED_WORK(release_queue, psp_release_i2c_bus_deferred);
166
psp_acquire_i2c_bus(void)167 static int psp_acquire_i2c_bus(void)
168 {
169 int status;
170
171 guard(mutex)(&psp_i2c_access_mutex);
172
173 /* Return early if mailbox malfunctioned */
174 if (psp_i2c_mbox_fail)
175 return 0;
176
177 psp_i2c_access_count++;
178
179 /*
180 * No need to request bus arbitration once we are inside semaphore
181 * reservation period.
182 */
183 if (psp_i2c_sem_acquired)
184 return 0;
185
186 status = psp_send_i2c_req(PSP_I2C_REQ_ACQUIRE);
187 if (status)
188 return 0;
189
190 psp_i2c_sem_acquired = jiffies;
191
192 schedule_delayed_work(&release_queue,
193 msecs_to_jiffies(PSP_I2C_RESERVATION_TIME_MS));
194
195 /*
196 * In case of errors with PSP arbitrator psp_i2c_mbox_fail variable is
197 * set above. As a consequence consecutive calls to acquire will bypass
198 * communication with PSP. At any case i2c bus is granted to the caller,
199 * thus always return success.
200 */
201 return 0;
202 }
203
psp_release_i2c_bus(void)204 static void psp_release_i2c_bus(void)
205 {
206 guard(mutex)(&psp_i2c_access_mutex);
207
208 /* Return early if mailbox was malfunctioned */
209 if (psp_i2c_mbox_fail)
210 return;
211
212 /*
213 * If we are last owner of PSP semaphore, need to release arbitration
214 * via mailbox.
215 */
216 psp_i2c_access_count--;
217 if (psp_i2c_access_count)
218 return;
219
220 /*
221 * Send a release command to PSP if the semaphore reservation timeout
222 * elapsed but x86 still owns the controller.
223 */
224 if (!delayed_work_pending(&release_queue))
225 release_bus();
226 }
227
228 /*
229 * Locking methods are based on the default implementation from
230 * drivers/i2c/i2c-core-base.c, but with PSP acquire and release operations
231 * added. With this in place we can ensure that i2c clients on the bus shared
232 * with PSP are able to lock HW access to the bus for arbitrary number of
233 * operations - that is e.g. write-wait-read.
234 */
i2c_adapter_dw_psp_lock_bus(struct i2c_adapter * adapter,unsigned int flags)235 static void i2c_adapter_dw_psp_lock_bus(struct i2c_adapter *adapter,
236 unsigned int flags)
237 {
238 psp_acquire_i2c_bus();
239 rt_mutex_lock_nested(&adapter->bus_lock, i2c_adapter_depth(adapter));
240 }
241
i2c_adapter_dw_psp_trylock_bus(struct i2c_adapter * adapter,unsigned int flags)242 static int i2c_adapter_dw_psp_trylock_bus(struct i2c_adapter *adapter,
243 unsigned int flags)
244 {
245 int ret;
246
247 ret = rt_mutex_trylock(&adapter->bus_lock);
248 if (ret)
249 return ret;
250
251 psp_acquire_i2c_bus();
252
253 return ret;
254 }
255
i2c_adapter_dw_psp_unlock_bus(struct i2c_adapter * adapter,unsigned int flags)256 static void i2c_adapter_dw_psp_unlock_bus(struct i2c_adapter *adapter,
257 unsigned int flags)
258 {
259 psp_release_i2c_bus();
260 rt_mutex_unlock(&adapter->bus_lock);
261 }
262
263 static const struct i2c_lock_operations i2c_dw_psp_lock_ops = {
264 .lock_bus = i2c_adapter_dw_psp_lock_bus,
265 .trylock_bus = i2c_adapter_dw_psp_trylock_bus,
266 .unlock_bus = i2c_adapter_dw_psp_unlock_bus,
267 };
268
i2c_dw_amdpsp_probe_lock_support(struct dw_i2c_dev * dev)269 int i2c_dw_amdpsp_probe_lock_support(struct dw_i2c_dev *dev)
270 {
271 struct pci_dev *rdev;
272
273 if (!IS_REACHABLE(CONFIG_CRYPTO_DEV_CCP_DD))
274 return -ENODEV;
275
276 if (!dev)
277 return -ENODEV;
278
279 if (!(dev->flags & ARBITRATION_SEMAPHORE))
280 return -ENODEV;
281
282 /* Allow to bind only one instance of a driver */
283 if (psp_i2c_dev)
284 return -EEXIST;
285
286 /* Cezanne uses platform mailbox, Mendocino and later use doorbell */
287 rdev = pci_get_domain_bus_and_slot(0, 0, PCI_DEVFN(0, 0));
288 if (rdev->device == 0x1630)
289 _psp_send_i2c_req = psp_send_i2c_req_cezanne;
290 else
291 _psp_send_i2c_req = psp_send_i2c_req_doorbell;
292 pci_dev_put(rdev);
293
294 if (psp_check_platform_access_status())
295 return -EPROBE_DEFER;
296
297 psp_i2c_dev = dev->dev;
298
299 dev_info(psp_i2c_dev, "I2C bus managed by AMD PSP\n");
300
301 /*
302 * Install global locking callbacks for adapter as well as internal i2c
303 * controller locks.
304 */
305 dev->adapter.lock_ops = &i2c_dw_psp_lock_ops;
306 dev->acquire_lock = psp_acquire_i2c_bus;
307 dev->release_lock = psp_release_i2c_bus;
308
309 return 0;
310 }
311