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