1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * AMD Secure Processor Dynamic Boost Control interface
4 *
5 * Copyright (C) 2023 Advanced Micro Devices, Inc.
6 *
7 * Author: Mario Limonciello <mario.limonciello@amd.com>
8 */
9
10#include "dbc.h"
11
12#define DBC_DEFAULT_TIMEOUT		(10 * MSEC_PER_SEC)
13struct error_map {
14	u32 psp;
15	int ret;
16};
17
18#define DBC_ERROR_ACCESS_DENIED		0x0001
19#define DBC_ERROR_EXCESS_DATA		0x0004
20#define DBC_ERROR_BAD_PARAMETERS	0x0006
21#define DBC_ERROR_BAD_STATE		0x0007
22#define DBC_ERROR_NOT_IMPLEMENTED	0x0009
23#define DBC_ERROR_BUSY			0x000D
24#define DBC_ERROR_MESSAGE_FAILURE	0x0307
25#define DBC_ERROR_OVERFLOW		0x300F
26#define DBC_ERROR_SIGNATURE_INVALID	0x3072
27
28static struct error_map error_codes[] = {
29	{DBC_ERROR_ACCESS_DENIED,	-EACCES},
30	{DBC_ERROR_EXCESS_DATA,		-E2BIG},
31	{DBC_ERROR_BAD_PARAMETERS,	-EINVAL},
32	{DBC_ERROR_BAD_STATE,		-EAGAIN},
33	{DBC_ERROR_MESSAGE_FAILURE,	-ENOENT},
34	{DBC_ERROR_NOT_IMPLEMENTED,	-ENOENT},
35	{DBC_ERROR_BUSY,		-EBUSY},
36	{DBC_ERROR_OVERFLOW,		-ENFILE},
37	{DBC_ERROR_SIGNATURE_INVALID,	-EPERM},
38	{0x0,	0x0},
39};
40
41static inline int send_dbc_cmd_thru_ext(struct psp_dbc_device *dbc_dev, int msg)
42{
43	dbc_dev->mbox->ext_req.header.sub_cmd_id = msg;
44
45	return psp_extended_mailbox_cmd(dbc_dev->psp,
46					DBC_DEFAULT_TIMEOUT,
47					(struct psp_ext_request *)dbc_dev->mbox);
48}
49
50static inline int send_dbc_cmd_thru_pa(struct psp_dbc_device *dbc_dev, int msg)
51{
52	return psp_send_platform_access_msg(msg,
53					    (struct psp_request *)dbc_dev->mbox);
54}
55
56static int send_dbc_cmd(struct psp_dbc_device *dbc_dev, int msg)
57{
58	int ret;
59
60	*dbc_dev->result = 0;
61	ret = dbc_dev->use_ext ? send_dbc_cmd_thru_ext(dbc_dev, msg) :
62				 send_dbc_cmd_thru_pa(dbc_dev, msg);
63	if (ret == -EIO) {
64		int i;
65
66		dev_dbg(dbc_dev->dev,
67			 "msg 0x%x failed with PSP error: 0x%x\n",
68			 msg, *dbc_dev->result);
69
70		for (i = 0; error_codes[i].psp; i++) {
71			if (*dbc_dev->result == error_codes[i].psp)
72				return error_codes[i].ret;
73		}
74	}
75
76	return ret;
77}
78
79static int send_dbc_nonce(struct psp_dbc_device *dbc_dev)
80{
81	int ret;
82
83	*dbc_dev->payload_size = dbc_dev->header_size + sizeof(struct dbc_user_nonce);
84	ret = send_dbc_cmd(dbc_dev, PSP_DYNAMIC_BOOST_GET_NONCE);
85	if (ret == -EAGAIN) {
86		dev_dbg(dbc_dev->dev, "retrying get nonce\n");
87		ret = send_dbc_cmd(dbc_dev, PSP_DYNAMIC_BOOST_GET_NONCE);
88	}
89
90	return ret;
91}
92
93static int send_dbc_parameter(struct psp_dbc_device *dbc_dev)
94{
95	struct dbc_user_param *user_param = (struct dbc_user_param *)dbc_dev->payload;
96
97	switch (user_param->msg_index) {
98	case PARAM_SET_FMAX_CAP:
99	case PARAM_SET_PWR_CAP:
100	case PARAM_SET_GFX_MODE:
101		return send_dbc_cmd(dbc_dev, PSP_DYNAMIC_BOOST_SET_PARAMETER);
102	case PARAM_GET_FMAX_CAP:
103	case PARAM_GET_PWR_CAP:
104	case PARAM_GET_CURR_TEMP:
105	case PARAM_GET_FMAX_MAX:
106	case PARAM_GET_FMAX_MIN:
107	case PARAM_GET_SOC_PWR_MAX:
108	case PARAM_GET_SOC_PWR_MIN:
109	case PARAM_GET_SOC_PWR_CUR:
110	case PARAM_GET_GFX_MODE:
111		return send_dbc_cmd(dbc_dev, PSP_DYNAMIC_BOOST_GET_PARAMETER);
112	}
113
114	return -EINVAL;
115}
116
117void dbc_dev_destroy(struct psp_device *psp)
118{
119	struct psp_dbc_device *dbc_dev = psp->dbc_data;
120
121	if (!dbc_dev)
122		return;
123
124	misc_deregister(&dbc_dev->char_dev);
125	mutex_destroy(&dbc_dev->ioctl_mutex);
126	psp->dbc_data = NULL;
127}
128
129static long dbc_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
130{
131	struct psp_device *psp_master = psp_get_master_device();
132	void __user *argp = (void __user *)arg;
133	struct psp_dbc_device *dbc_dev;
134	int ret;
135
136	if (!psp_master || !psp_master->dbc_data)
137		return -ENODEV;
138	dbc_dev = psp_master->dbc_data;
139
140	mutex_lock(&dbc_dev->ioctl_mutex);
141
142	switch (cmd) {
143	case DBCIOCNONCE:
144		if (copy_from_user(dbc_dev->payload, argp, sizeof(struct dbc_user_nonce))) {
145			ret = -EFAULT;
146			goto unlock;
147		}
148
149		ret = send_dbc_nonce(dbc_dev);
150		if (ret)
151			goto unlock;
152
153		if (copy_to_user(argp, dbc_dev->payload, sizeof(struct dbc_user_nonce))) {
154			ret = -EFAULT;
155			goto unlock;
156		}
157		break;
158	case DBCIOCUID:
159		if (copy_from_user(dbc_dev->payload, argp, sizeof(struct dbc_user_setuid))) {
160			ret = -EFAULT;
161			goto unlock;
162		}
163
164		*dbc_dev->payload_size = dbc_dev->header_size + sizeof(struct dbc_user_setuid);
165		ret = send_dbc_cmd(dbc_dev, PSP_DYNAMIC_BOOST_SET_UID);
166		if (ret)
167			goto unlock;
168
169		if (copy_to_user(argp, dbc_dev->payload, sizeof(struct dbc_user_setuid))) {
170			ret = -EFAULT;
171			goto unlock;
172		}
173		break;
174	case DBCIOCPARAM:
175		if (copy_from_user(dbc_dev->payload, argp, sizeof(struct dbc_user_param))) {
176			ret = -EFAULT;
177			goto unlock;
178		}
179
180		*dbc_dev->payload_size = dbc_dev->header_size + sizeof(struct dbc_user_param);
181		ret = send_dbc_parameter(dbc_dev);
182		if (ret)
183			goto unlock;
184
185		if (copy_to_user(argp, dbc_dev->payload, sizeof(struct dbc_user_param)))  {
186			ret = -EFAULT;
187			goto unlock;
188		}
189		break;
190	default:
191		ret = -EINVAL;
192
193	}
194unlock:
195	mutex_unlock(&dbc_dev->ioctl_mutex);
196
197	return ret;
198}
199
200static const struct file_operations dbc_fops = {
201	.owner	= THIS_MODULE,
202	.unlocked_ioctl = dbc_ioctl,
203};
204
205int dbc_dev_init(struct psp_device *psp)
206{
207	struct device *dev = psp->dev;
208	struct psp_dbc_device *dbc_dev;
209	int ret;
210
211	dbc_dev = devm_kzalloc(dev, sizeof(*dbc_dev), GFP_KERNEL);
212	if (!dbc_dev)
213		return -ENOMEM;
214
215	BUILD_BUG_ON(sizeof(union dbc_buffer) > PAGE_SIZE);
216	dbc_dev->mbox = (void *)devm_get_free_pages(dev, GFP_KERNEL | __GFP_ZERO, 0);
217	if (!dbc_dev->mbox) {
218		ret = -ENOMEM;
219		goto cleanup_dev;
220	}
221
222	psp->dbc_data = dbc_dev;
223	dbc_dev->dev = dev;
224	dbc_dev->psp = psp;
225
226	if (PSP_CAPABILITY(psp, DBC_THRU_EXT)) {
227		dbc_dev->use_ext = true;
228		dbc_dev->payload_size = &dbc_dev->mbox->ext_req.header.payload_size;
229		dbc_dev->result = &dbc_dev->mbox->ext_req.header.status;
230		dbc_dev->payload = &dbc_dev->mbox->ext_req.buf;
231		dbc_dev->header_size = sizeof(struct psp_ext_req_buffer_hdr);
232	} else {
233		dbc_dev->payload_size = &dbc_dev->mbox->pa_req.header.payload_size;
234		dbc_dev->result = &dbc_dev->mbox->pa_req.header.status;
235		dbc_dev->payload = &dbc_dev->mbox->pa_req.buf;
236		dbc_dev->header_size = sizeof(struct psp_req_buffer_hdr);
237	}
238
239	ret = send_dbc_nonce(dbc_dev);
240	if (ret == -EACCES) {
241		dev_dbg(dbc_dev->dev,
242			"dynamic boost control was previously authenticated\n");
243		ret = 0;
244	}
245	dev_dbg(dbc_dev->dev, "dynamic boost control is %savailable\n",
246		ret ? "un" : "");
247	if (ret) {
248		ret = 0;
249		goto cleanup_mbox;
250	}
251
252	dbc_dev->char_dev.minor = MISC_DYNAMIC_MINOR;
253	dbc_dev->char_dev.name = "dbc";
254	dbc_dev->char_dev.fops = &dbc_fops;
255	dbc_dev->char_dev.mode = 0600;
256	ret = misc_register(&dbc_dev->char_dev);
257	if (ret)
258		goto cleanup_mbox;
259
260	mutex_init(&dbc_dev->ioctl_mutex);
261
262	return 0;
263
264cleanup_mbox:
265	devm_free_pages(dev, (unsigned long)dbc_dev->mbox);
266
267cleanup_dev:
268	psp->dbc_data = NULL;
269	devm_kfree(dev, dbc_dev);
270
271	return ret;
272}
273