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 	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 
165 cleanup:
166 	mutex_unlock(&psp_i2c_access_mutex);
167 }
168 static DECLARE_DELAYED_WORK(release_queue, psp_release_i2c_bus_deferred);
169 
psp_acquire_i2c_bus(void)170 static 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 
180 	psp_i2c_access_count++;
181 
182 	/*
183 	 * No need to request bus arbitration once we are inside semaphore
184 	 * reservation period.
185 	 */
186 	if (psp_i2c_sem_acquired)
187 		goto cleanup;
188 
189 	status = psp_send_i2c_req(PSP_I2C_REQ_ACQUIRE);
190 	if (status)
191 		goto cleanup;
192 
193 	psp_i2c_sem_acquired = jiffies;
194 
195 	schedule_delayed_work(&release_queue,
196 			      msecs_to_jiffies(PSP_I2C_RESERVATION_TIME_MS));
197 
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 	 */
204 cleanup:
205 	mutex_unlock(&psp_i2c_access_mutex);
206 	return 0;
207 }
208 
psp_release_i2c_bus(void)209 static void psp_release_i2c_bus(void)
210 {
211 	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 
225 	/*
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();
231 
232 cleanup:
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  */
i2c_adapter_dw_psp_lock_bus(struct i2c_adapter * adapter,unsigned int flags)243 static 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 
i2c_adapter_dw_psp_trylock_bus(struct i2c_adapter * adapter,unsigned int flags)250 static 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 
i2c_adapter_dw_psp_unlock_bus(struct i2c_adapter * adapter,unsigned int flags)264 static 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 
271 static 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 
i2c_dw_amdpsp_probe_lock_support(struct dw_i2c_dev * dev)277 int i2c_dw_amdpsp_probe_lock_support(struct dw_i2c_dev *dev)
278 {
279 	struct pci_dev *rdev;
280 
281 	if (!IS_REACHABLE(CONFIG_CRYPTO_DEV_CCP_DD))
282 		return -ENODEV;
283 
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 
294 	/* 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 
302 	if (psp_check_platform_access_status())
303 		return -EPROBE_DEFER;
304 
305 	psp_i2c_dev = dev->dev;
306 
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 }
319