1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * AMD HSMP Platform Driver
4 * Copyright (c) 2022, AMD.
5 * All Rights Reserved.
6 *
7 * This file provides a device implementation for HSMP interface
8 */
9
10 #include <asm/amd/hsmp.h>
11
12 #include <linux/acpi.h>
13 #include <linux/delay.h>
14 #include <linux/device.h>
15 #include <linux/semaphore.h>
16 #include <linux/sysfs.h>
17
18 #include "hsmp.h"
19
20 /* HSMP Status / Error codes */
21 #define HSMP_STATUS_NOT_READY 0x00
22 #define HSMP_STATUS_OK 0x01
23 #define HSMP_ERR_INVALID_MSG 0xFE
24 #define HSMP_ERR_INVALID_INPUT 0xFF
25 #define HSMP_ERR_PREREQ_NOT_SATISFIED 0xFD
26 #define HSMP_ERR_SMU_BUSY 0xFC
27
28 /* Timeout in millsec */
29 #define HSMP_MSG_TIMEOUT 100
30 #define HSMP_SHORT_SLEEP 1
31
32 #define HSMP_WR true
33 #define HSMP_RD false
34
35 /*
36 * When same message numbers are used for both GET and SET operation,
37 * bit:31 indicates whether its SET or GET operation.
38 */
39 #define CHECK_GET_BIT BIT(31)
40
41 static struct hsmp_plat_device hsmp_pdev;
42
43 /*
44 * Send a message to the HSMP port via PCI-e config space registers
45 * or by writing to MMIO space.
46 *
47 * The caller is expected to zero out any unused arguments.
48 * If a response is expected, the number of response words should be greater than 0.
49 *
50 * Returns 0 for success and populates the requested number of arguments.
51 * Returns a negative error code for failure.
52 */
__hsmp_send_message(struct hsmp_socket * sock,struct hsmp_message * msg)53 static int __hsmp_send_message(struct hsmp_socket *sock, struct hsmp_message *msg)
54 {
55 struct hsmp_mbaddr_info *mbinfo;
56 unsigned long timeout, short_sleep;
57 u32 mbox_status;
58 u32 index;
59 int ret;
60
61 mbinfo = &sock->mbinfo;
62
63 /* Clear the status register */
64 mbox_status = HSMP_STATUS_NOT_READY;
65 ret = sock->amd_hsmp_rdwr(sock, mbinfo->msg_resp_off, &mbox_status, HSMP_WR);
66 if (ret) {
67 dev_err(sock->dev, "Error %d clearing mailbox status register\n", ret);
68 return ret;
69 }
70
71 index = 0;
72 /* Write any message arguments */
73 while (index < msg->num_args) {
74 ret = sock->amd_hsmp_rdwr(sock, mbinfo->msg_arg_off + (index << 2),
75 &msg->args[index], HSMP_WR);
76 if (ret) {
77 dev_err(sock->dev, "Error %d writing message argument %d\n", ret, index);
78 return ret;
79 }
80 index++;
81 }
82
83 /* Write the message ID which starts the operation */
84 ret = sock->amd_hsmp_rdwr(sock, mbinfo->msg_id_off, &msg->msg_id, HSMP_WR);
85 if (ret) {
86 dev_err(sock->dev, "Error %d writing message ID %u\n", ret, msg->msg_id);
87 return ret;
88 }
89
90 /*
91 * Depending on when the trigger write completes relative to the SMU
92 * firmware 1 ms cycle, the operation may take from tens of us to 1 ms
93 * to complete. Some operations may take more. Therefore we will try
94 * a few short duration sleeps and switch to long sleeps if we don't
95 * succeed quickly.
96 */
97 short_sleep = jiffies + msecs_to_jiffies(HSMP_SHORT_SLEEP);
98 timeout = jiffies + msecs_to_jiffies(HSMP_MSG_TIMEOUT);
99
100 while (true) {
101 ret = sock->amd_hsmp_rdwr(sock, mbinfo->msg_resp_off, &mbox_status, HSMP_RD);
102 if (ret) {
103 dev_err(sock->dev, "Error %d reading mailbox status\n", ret);
104 return ret;
105 }
106
107 if (mbox_status != HSMP_STATUS_NOT_READY)
108 break;
109
110 if (!time_before(jiffies, timeout))
111 break;
112
113 if (time_before(jiffies, short_sleep))
114 usleep_range(50, 100);
115 else
116 usleep_range(1000, 2000);
117 }
118
119 if (unlikely(mbox_status == HSMP_STATUS_NOT_READY)) {
120 dev_err(sock->dev, "Message ID 0x%X failure : SMU tmeout (status = 0x%X)\n",
121 msg->msg_id, mbox_status);
122 return -ETIMEDOUT;
123 } else if (unlikely(mbox_status == HSMP_ERR_INVALID_MSG)) {
124 dev_err(sock->dev, "Message ID 0x%X failure : Invalid message (status = 0x%X)\n",
125 msg->msg_id, mbox_status);
126 return -ENOMSG;
127 } else if (unlikely(mbox_status == HSMP_ERR_INVALID_INPUT)) {
128 dev_err(sock->dev, "Message ID 0x%X failure : Invalid arguments (status = 0x%X)\n",
129 msg->msg_id, mbox_status);
130 return -EINVAL;
131 } else if (unlikely(mbox_status == HSMP_ERR_PREREQ_NOT_SATISFIED)) {
132 dev_err(sock->dev, "Message ID 0x%X failure : Prerequisite not satisfied (status = 0x%X)\n",
133 msg->msg_id, mbox_status);
134 return -EREMOTEIO;
135 } else if (unlikely(mbox_status == HSMP_ERR_SMU_BUSY)) {
136 dev_err(sock->dev, "Message ID 0x%X failure : SMU BUSY (status = 0x%X)\n",
137 msg->msg_id, mbox_status);
138 return -EBUSY;
139 } else if (unlikely(mbox_status != HSMP_STATUS_OK)) {
140 dev_err(sock->dev, "Message ID 0x%X unknown failure (status = 0x%X)\n",
141 msg->msg_id, mbox_status);
142 return -EIO;
143 }
144
145 /*
146 * SMU has responded OK. Read response data.
147 * SMU reads the input arguments from eight 32 bit registers starting
148 * from SMN_HSMP_MSG_DATA and writes the response data to the same
149 * SMN_HSMP_MSG_DATA address.
150 * We copy the response data if any, back to the args[].
151 */
152 index = 0;
153 while (index < msg->response_sz) {
154 ret = sock->amd_hsmp_rdwr(sock, mbinfo->msg_arg_off + (index << 2),
155 &msg->args[index], HSMP_RD);
156 if (ret) {
157 dev_err(sock->dev, "Error %d reading response %u for message ID:%u\n",
158 ret, index, msg->msg_id);
159 break;
160 }
161 index++;
162 }
163
164 return ret;
165 }
166
validate_message(struct hsmp_message * msg)167 static int validate_message(struct hsmp_message *msg)
168 {
169 /* msg_id against valid range of message IDs */
170 if (msg->msg_id < HSMP_TEST || msg->msg_id >= HSMP_MSG_ID_MAX)
171 return -ENOMSG;
172
173 /* msg_id is a reserved message ID */
174 if (hsmp_msg_desc_table[msg->msg_id].type == HSMP_RSVD)
175 return -ENOMSG;
176
177 /*
178 * num_args passed by user should match the num_args specified in
179 * message description table.
180 */
181 if (msg->num_args != hsmp_msg_desc_table[msg->msg_id].num_args)
182 return -EINVAL;
183
184 /*
185 * Some older HSMP SET messages are updated to add GET in the same message.
186 * In these messages, GET returns the current value and SET also returns
187 * the successfully set value. To support this GET and SET in same message
188 * while maintaining backward compatibility for the HSMP users,
189 * hsmp_msg_desc_table[] indicates only maximum allowed response_sz.
190 */
191 if (hsmp_msg_desc_table[msg->msg_id].type == HSMP_SET_GET) {
192 if (msg->response_sz > hsmp_msg_desc_table[msg->msg_id].response_sz)
193 return -EINVAL;
194 } else {
195 /* only HSMP_SET or HSMP_GET messages go through this strict check */
196 if (msg->response_sz != hsmp_msg_desc_table[msg->msg_id].response_sz)
197 return -EINVAL;
198 }
199 return 0;
200 }
201
hsmp_send_message(struct hsmp_message * msg)202 int hsmp_send_message(struct hsmp_message *msg)
203 {
204 struct hsmp_socket *sock;
205 int ret;
206
207 if (!msg)
208 return -EINVAL;
209 ret = validate_message(msg);
210 if (ret)
211 return ret;
212
213 if (!hsmp_pdev.sock || msg->sock_ind >= hsmp_pdev.num_sockets)
214 return -ENODEV;
215 sock = &hsmp_pdev.sock[msg->sock_ind];
216
217 ret = down_interruptible(&sock->hsmp_sem);
218 if (ret < 0)
219 return ret;
220
221 ret = __hsmp_send_message(sock, msg);
222
223 up(&sock->hsmp_sem);
224
225 return ret;
226 }
227 EXPORT_SYMBOL_NS_GPL(hsmp_send_message, "AMD_HSMP");
228
hsmp_msg_get_nargs(u16 sock_ind,u32 msg_id,u32 * data,u8 num_args)229 int hsmp_msg_get_nargs(u16 sock_ind, u32 msg_id, u32 *data, u8 num_args)
230 {
231 struct hsmp_message msg = {};
232 unsigned int i;
233 int ret;
234
235 if (!data)
236 return -EINVAL;
237 msg.msg_id = msg_id;
238 msg.sock_ind = sock_ind;
239 msg.response_sz = num_args;
240
241 ret = hsmp_send_message(&msg);
242 if (ret)
243 return ret;
244
245 for (i = 0; i < num_args; i++)
246 data[i] = msg.args[i];
247
248 return 0;
249 }
250 EXPORT_SYMBOL_NS_GPL(hsmp_msg_get_nargs, "AMD_HSMP");
251
hsmp_test(u16 sock_ind,u32 value)252 int hsmp_test(u16 sock_ind, u32 value)
253 {
254 struct hsmp_message msg = { 0 };
255 int ret;
256
257 /*
258 * Test the hsmp port by performing TEST command. The test message
259 * takes one argument and returns the value of that argument + 1.
260 */
261 msg.msg_id = HSMP_TEST;
262 msg.num_args = 1;
263 msg.response_sz = 1;
264 msg.args[0] = value;
265 msg.sock_ind = sock_ind;
266
267 ret = hsmp_send_message(&msg);
268 if (ret)
269 return ret;
270
271 /* Check the response value */
272 if (msg.args[0] != (value + 1)) {
273 dev_err(hsmp_pdev.sock[sock_ind].dev,
274 "Socket %d test message failed, Expected 0x%08X, received 0x%08X\n",
275 sock_ind, (value + 1), msg.args[0]);
276 return -EBADE;
277 }
278
279 return ret;
280 }
281 EXPORT_SYMBOL_NS_GPL(hsmp_test, "AMD_HSMP");
282
is_get_msg(struct hsmp_message * msg)283 static bool is_get_msg(struct hsmp_message *msg)
284 {
285 if (hsmp_msg_desc_table[msg->msg_id].type == HSMP_GET)
286 return true;
287
288 if (hsmp_msg_desc_table[msg->msg_id].type == HSMP_SET_GET &&
289 (msg->args[0] & CHECK_GET_BIT))
290 return true;
291
292 return false;
293 }
294
hsmp_ioctl(struct file * fp,unsigned int cmd,unsigned long arg)295 long hsmp_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
296 {
297 int __user *arguser = (int __user *)arg;
298 struct hsmp_message msg = { 0 };
299 int ret;
300
301 if (copy_struct_from_user(&msg, sizeof(msg), arguser, sizeof(struct hsmp_message)))
302 return -EFAULT;
303
304 /*
305 * Check msg_id is within the range of supported msg ids
306 * i.e within the array bounds of hsmp_msg_desc_table
307 */
308 if (msg.msg_id < HSMP_TEST || msg.msg_id >= HSMP_MSG_ID_MAX)
309 return -ENOMSG;
310
311 switch (fp->f_mode & (FMODE_WRITE | FMODE_READ)) {
312 case FMODE_WRITE:
313 /*
314 * Device is opened in O_WRONLY mode
315 * Execute only set/configure commands
316 */
317 if (is_get_msg(&msg))
318 return -EPERM;
319 break;
320 case FMODE_READ:
321 /*
322 * Device is opened in O_RDONLY mode
323 * Execute only get/monitor commands
324 */
325 if (!is_get_msg(&msg))
326 return -EPERM;
327 break;
328 case FMODE_READ | FMODE_WRITE:
329 /*
330 * Device is opened in O_RDWR mode
331 * Execute both get/monitor and set/configure commands
332 */
333 break;
334 default:
335 return -EPERM;
336 }
337
338 ret = hsmp_send_message(&msg);
339 if (ret)
340 return ret;
341
342 if (hsmp_msg_desc_table[msg.msg_id].response_sz > 0) {
343 /* Copy results back to user for get/monitor commands */
344 if (copy_to_user(arguser, &msg, sizeof(struct hsmp_message)))
345 return -EFAULT;
346 }
347
348 return 0;
349 }
350
hsmp_metric_tbl_read(struct hsmp_socket * sock,char * buf,size_t size)351 ssize_t hsmp_metric_tbl_read(struct hsmp_socket *sock, char *buf, size_t size)
352 {
353 struct hsmp_message msg = { 0 };
354 int ret;
355
356 if (!sock || !buf)
357 return -EINVAL;
358
359 /* Do not support lseek(), also don't allow more than the size of metric table */
360 if (size != sizeof(struct hsmp_metric_table)) {
361 dev_err(sock->dev, "Wrong buffer size\n");
362 return -EINVAL;
363 }
364
365 msg.msg_id = HSMP_GET_METRIC_TABLE;
366 msg.sock_ind = sock->sock_ind;
367
368 ret = hsmp_send_message(&msg);
369 if (ret)
370 return ret;
371 memcpy_fromio(buf, sock->metric_tbl_addr, size);
372
373 return size;
374 }
375 EXPORT_SYMBOL_NS_GPL(hsmp_metric_tbl_read, "AMD_HSMP");
376
hsmp_get_tbl_dram_base(u16 sock_ind)377 int hsmp_get_tbl_dram_base(u16 sock_ind)
378 {
379 struct hsmp_socket *sock = &hsmp_pdev.sock[sock_ind];
380 struct hsmp_message msg = { 0 };
381 phys_addr_t dram_addr;
382 int ret;
383
384 msg.sock_ind = sock_ind;
385 msg.response_sz = hsmp_msg_desc_table[HSMP_GET_METRIC_TABLE_DRAM_ADDR].response_sz;
386 msg.msg_id = HSMP_GET_METRIC_TABLE_DRAM_ADDR;
387
388 ret = hsmp_send_message(&msg);
389 if (ret)
390 return ret;
391
392 /*
393 * calculate the metric table DRAM address from lower and upper 32 bits
394 * sent from SMU and ioremap it to virtual address.
395 */
396 dram_addr = msg.args[0] | ((u64)(msg.args[1]) << 32);
397 if (!dram_addr) {
398 dev_err(sock->dev, "Invalid DRAM address for metric table\n");
399 return -ENOMEM;
400 }
401 sock->metric_tbl_addr = devm_ioremap(sock->dev, dram_addr,
402 sizeof(struct hsmp_metric_table));
403 if (!sock->metric_tbl_addr) {
404 dev_err(sock->dev, "Failed to ioremap metric table addr\n");
405 return -ENOMEM;
406 }
407 return 0;
408 }
409 EXPORT_SYMBOL_NS_GPL(hsmp_get_tbl_dram_base, "AMD_HSMP");
410
hsmp_cache_proto_ver(u16 sock_ind)411 int hsmp_cache_proto_ver(u16 sock_ind)
412 {
413 struct hsmp_message msg = { 0 };
414 int ret;
415
416 msg.msg_id = HSMP_GET_PROTO_VER;
417 msg.sock_ind = sock_ind;
418 msg.response_sz = hsmp_msg_desc_table[HSMP_GET_PROTO_VER].response_sz;
419
420 ret = hsmp_send_message(&msg);
421 if (!ret)
422 hsmp_pdev.proto_ver = msg.args[0];
423
424 return ret;
425 }
426 EXPORT_SYMBOL_NS_GPL(hsmp_cache_proto_ver, "AMD_HSMP");
427
428 static const struct file_operations hsmp_fops = {
429 .owner = THIS_MODULE,
430 .unlocked_ioctl = hsmp_ioctl,
431 .compat_ioctl = hsmp_ioctl,
432 };
433
hsmp_misc_register(struct device * dev)434 int hsmp_misc_register(struct device *dev)
435 {
436 hsmp_pdev.mdev.name = HSMP_CDEV_NAME;
437 hsmp_pdev.mdev.minor = MISC_DYNAMIC_MINOR;
438 hsmp_pdev.mdev.fops = &hsmp_fops;
439 hsmp_pdev.mdev.parent = dev;
440 hsmp_pdev.mdev.nodename = HSMP_DEVNODE_NAME;
441 hsmp_pdev.mdev.mode = 0644;
442
443 return misc_register(&hsmp_pdev.mdev);
444 }
445 EXPORT_SYMBOL_NS_GPL(hsmp_misc_register, "AMD_HSMP");
446
hsmp_misc_deregister(void)447 void hsmp_misc_deregister(void)
448 {
449 misc_deregister(&hsmp_pdev.mdev);
450 }
451 EXPORT_SYMBOL_NS_GPL(hsmp_misc_deregister, "AMD_HSMP");
452
get_hsmp_pdev(void)453 struct hsmp_plat_device *get_hsmp_pdev(void)
454 {
455 return &hsmp_pdev;
456 }
457 EXPORT_SYMBOL_NS_GPL(get_hsmp_pdev, "AMD_HSMP");
458
459 MODULE_DESCRIPTION("AMD HSMP Common driver");
460 MODULE_VERSION(DRIVER_VERSION);
461 MODULE_LICENSE("GPL");
462