1// SPDX-License-Identifier: GPL-2.0
2/*
3 * AMD Platform Security Processor (PSP) Platform Access interface
4 *
5 * Copyright (C) 2023 Advanced Micro Devices, Inc.
6 *
7 * Author: Mario Limonciello <mario.limonciello@amd.com>
8 *
9 * Some of this code is adapted from drivers/i2c/busses/i2c-designware-amdpsp.c
10 * developed by Jan Dabros <jsd@semihalf.com> and Copyright (C) 2022 Google Inc.
11 *
12 */
13
14#include <linux/bitfield.h>
15#include <linux/errno.h>
16#include <linux/iopoll.h>
17#include <linux/mutex.h>
18
19#include "platform-access.h"
20
21#define PSP_CMD_TIMEOUT_US	(500 * USEC_PER_MSEC)
22#define DOORBELL_CMDRESP_STS	GENMASK(7, 0)
23
24/* Recovery field should be equal 0 to start sending commands */
25static int check_recovery(u32 __iomem *cmd)
26{
27	return FIELD_GET(PSP_CMDRESP_RECOVERY, ioread32(cmd));
28}
29
30static int wait_cmd(u32 __iomem *cmd)
31{
32	u32 tmp, expected;
33
34	/* Expect mbox_cmd to be cleared and ready bit to be set by PSP */
35	expected = FIELD_PREP(PSP_CMDRESP_RESP, 1);
36
37	/*
38	 * Check for readiness of PSP mailbox in a tight loop in order to
39	 * process further as soon as command was consumed.
40	 */
41	return readl_poll_timeout(cmd, tmp, (tmp & expected), 0,
42				  PSP_CMD_TIMEOUT_US);
43}
44
45int psp_check_platform_access_status(void)
46{
47	struct psp_device *psp = psp_get_master_device();
48
49	if (!psp || !psp->platform_access_data)
50		return -ENODEV;
51
52	return 0;
53}
54EXPORT_SYMBOL(psp_check_platform_access_status);
55
56int psp_send_platform_access_msg(enum psp_platform_access_msg msg,
57				 struct psp_request *req)
58{
59	struct psp_device *psp = psp_get_master_device();
60	u32 __iomem *cmd, *lo, *hi;
61	struct psp_platform_access_device *pa_dev;
62	phys_addr_t req_addr;
63	u32 cmd_reg;
64	int ret;
65
66	if (!psp || !psp->platform_access_data)
67		return -ENODEV;
68
69	pa_dev = psp->platform_access_data;
70
71	if (!pa_dev->vdata->cmdresp_reg || !pa_dev->vdata->cmdbuff_addr_lo_reg ||
72	    !pa_dev->vdata->cmdbuff_addr_hi_reg)
73		return -ENODEV;
74
75	cmd = psp->io_regs + pa_dev->vdata->cmdresp_reg;
76	lo = psp->io_regs + pa_dev->vdata->cmdbuff_addr_lo_reg;
77	hi = psp->io_regs + pa_dev->vdata->cmdbuff_addr_hi_reg;
78
79	mutex_lock(&pa_dev->mailbox_mutex);
80
81	if (check_recovery(cmd)) {
82		dev_dbg(psp->dev, "platform mailbox is in recovery\n");
83		ret = -EBUSY;
84		goto unlock;
85	}
86
87	if (wait_cmd(cmd)) {
88		dev_dbg(psp->dev, "platform mailbox is not done processing command\n");
89		ret = -EBUSY;
90		goto unlock;
91	}
92
93	/*
94	 * Fill mailbox with address of command-response buffer, which will be
95	 * used for sending i2c requests as well as reading status returned by
96	 * PSP. Use physical address of buffer, since PSP will map this region.
97	 */
98	req_addr = __psp_pa(req);
99	iowrite32(lower_32_bits(req_addr), lo);
100	iowrite32(upper_32_bits(req_addr), hi);
101
102	print_hex_dump_debug("->psp ", DUMP_PREFIX_OFFSET, 16, 2, req,
103			     req->header.payload_size, false);
104
105	/* Write command register to trigger processing */
106	cmd_reg = FIELD_PREP(PSP_CMDRESP_CMD, msg);
107	iowrite32(cmd_reg, cmd);
108
109	if (wait_cmd(cmd)) {
110		ret = -ETIMEDOUT;
111		goto unlock;
112	}
113
114	/* Ensure it was triggered by this driver */
115	if (ioread32(lo) != lower_32_bits(req_addr) ||
116	    ioread32(hi) != upper_32_bits(req_addr)) {
117		ret = -EBUSY;
118		goto unlock;
119	}
120
121	/*
122	 * Read status from PSP. If status is non-zero, it indicates an error
123	 * occurred during "processing" of the command.
124	 * If status is zero, it indicates the command was "processed"
125	 * successfully, but the result of the command is in the payload.
126	 * Return both cases to the caller as -EIO to investigate.
127	 */
128	cmd_reg = ioread32(cmd);
129	if (FIELD_GET(PSP_CMDRESP_STS, cmd_reg))
130		req->header.status = FIELD_GET(PSP_CMDRESP_STS, cmd_reg);
131	if (req->header.status) {
132		ret = -EIO;
133		goto unlock;
134	}
135
136	print_hex_dump_debug("<-psp ", DUMP_PREFIX_OFFSET, 16, 2, req,
137			     req->header.payload_size, false);
138
139	ret = 0;
140
141unlock:
142	mutex_unlock(&pa_dev->mailbox_mutex);
143
144	return ret;
145}
146EXPORT_SYMBOL_GPL(psp_send_platform_access_msg);
147
148int psp_ring_platform_doorbell(int msg, u32 *result)
149{
150	struct psp_device *psp = psp_get_master_device();
151	struct psp_platform_access_device *pa_dev;
152	u32 __iomem *button, *cmd;
153	int ret, val;
154
155	if (!psp || !psp->platform_access_data)
156		return -ENODEV;
157
158	pa_dev = psp->platform_access_data;
159	button = psp->io_regs + pa_dev->vdata->doorbell_button_reg;
160	cmd = psp->io_regs + pa_dev->vdata->doorbell_cmd_reg;
161
162	mutex_lock(&pa_dev->doorbell_mutex);
163
164	if (wait_cmd(cmd)) {
165		dev_err(psp->dev, "doorbell command not done processing\n");
166		ret = -EBUSY;
167		goto unlock;
168	}
169
170	iowrite32(FIELD_PREP(DOORBELL_CMDRESP_STS, msg), cmd);
171	iowrite32(PSP_DRBL_RING, button);
172
173	if (wait_cmd(cmd)) {
174		ret = -ETIMEDOUT;
175		goto unlock;
176	}
177
178	val = FIELD_GET(DOORBELL_CMDRESP_STS, ioread32(cmd));
179	if (val) {
180		if (result)
181			*result = val;
182		ret = -EIO;
183		goto unlock;
184	}
185
186	ret = 0;
187unlock:
188	mutex_unlock(&pa_dev->doorbell_mutex);
189
190	return ret;
191}
192EXPORT_SYMBOL_GPL(psp_ring_platform_doorbell);
193
194void platform_access_dev_destroy(struct psp_device *psp)
195{
196	struct psp_platform_access_device *pa_dev = psp->platform_access_data;
197
198	if (!pa_dev)
199		return;
200
201	mutex_destroy(&pa_dev->mailbox_mutex);
202	mutex_destroy(&pa_dev->doorbell_mutex);
203	psp->platform_access_data = NULL;
204}
205
206int platform_access_dev_init(struct psp_device *psp)
207{
208	struct device *dev = psp->dev;
209	struct psp_platform_access_device *pa_dev;
210
211	pa_dev = devm_kzalloc(dev, sizeof(*pa_dev), GFP_KERNEL);
212	if (!pa_dev)
213		return -ENOMEM;
214
215	psp->platform_access_data = pa_dev;
216	pa_dev->psp = psp;
217	pa_dev->dev = dev;
218
219	pa_dev->vdata = (struct platform_access_vdata *)psp->vdata->platform_access;
220
221	mutex_init(&pa_dev->mailbox_mutex);
222	mutex_init(&pa_dev->doorbell_mutex);
223
224	dev_dbg(dev, "platform access enabled\n");
225
226	return 0;
227}
228