dbc.c

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