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
 19enum 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
 30static DEFINE_MUTEX(psp_i2c_access_mutex);
 31static unsigned long psp_i2c_sem_acquired;
 32static u32 psp_i2c_access_count;
 33static bool psp_i2c_mbox_fail;
 34static struct device *psp_i2c_dev;
 35
 36static int (*_psp_send_i2c_req)(struct psp_i2c_req *req);
 37
 38/* Helper to verify status returned by PSP */
 39static 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 */
 67static 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
 78static 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
 89static 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
125cleanup:
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
135static 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
170static 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	 */
204cleanup:
205	mutex_unlock(&psp_i2c_access_mutex);
206	return 0;
207}
208
209static 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
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{
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}