#include <asm/amd/hsmp.h>
#include <linux/acpi.h>
#include <linux/array_size.h>
#include <linux/build_bug.h>
#include <linux/cleanup.h>
#include <linux/compiler.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/io.h>
#include <linux/mutex.h>
#include <linux/nospec.h>
#include <linux/rwsem.h>
#include <linux/semaphore.h>
#include <linux/slab.h>
#include <linux/sysfs.h>
#include <linux/uaccess.h>
#include "hsmp.h"
#define HSMP_STATUS_NOT_READY 0x00
#define HSMP_STATUS_OK 0x01
#define HSMP_ERR_INVALID_MSG 0xFE
#define HSMP_ERR_INVALID_INPUT 0xFF
#define HSMP_ERR_PREREQ_NOT_SATISFIED 0xFD
#define HSMP_ERR_SMU_BUSY 0xFC
#define HSMP_MSG_TIMEOUT 100
#define HSMP_SHORT_SLEEP 1
#define HSMP_WR true
#define HSMP_RD false
#define CHECK_GET_BIT BIT(31)
static_assert(ARRAY_SIZE(hsmp_msg_desc_table) == HSMP_MSG_ID_MAX);
struct hsmp_plat_desc {
const struct hsmp_msg_desc *msg_desc;
u32 num_msgs;
u32 test_msg;
u32 proto_ver_msg;
u32 metric_tbl_msg;
u32 metric_dram_msg;
};
static const struct hsmp_plat_desc hsmp_desc_server = {
.msg_desc = hsmp_msg_desc_table,
.num_msgs = HSMP_MSG_ID_MAX,
.test_msg = HSMP_TEST,
.proto_ver_msg = HSMP_GET_PROTO_VER,
.metric_tbl_msg = HSMP_GET_METRIC_TABLE,
.metric_dram_msg = HSMP_GET_METRIC_TABLE_DRAM_ADDR,
};
static const struct hsmp_plat_desc hsmp_desc_client = {
.msg_desc = NULL,
.num_msgs = HSMP_CLIENT_MSG_ID_MAX,
.test_msg = HSMP_CLIENT_TEST,
.proto_ver_msg = HSMP_CLIENT_GET_INTERFACE_VER,
.metric_tbl_msg = HSMP_CLIENT_GET_METRICS_TABLE,
.metric_dram_msg = HSMP_CLIENT_GET_METRICS_TABLE_DRAM_ADDR,
};
static struct hsmp_plat_device hsmp_pdev;
static const struct hsmp_plat_desc *hsmp_desc_cache;
static const struct hsmp_plat_desc *hsmp_desc(void)
{
const struct hsmp_plat_desc *desc = READ_ONCE(hsmp_desc_cache);
if (likely(desc))
return desc;
desc = is_client_platform() ? &hsmp_desc_client : &hsmp_desc_server;
WRITE_ONCE(hsmp_desc_cache, desc);
return desc;
}
static const struct hsmp_msg_desc *get_msg_desc(u32 msg_id)
{
const struct hsmp_plat_desc *desc = hsmp_desc();
if (!desc->msg_desc)
return NULL;
if (msg_id < desc->test_msg || msg_id >= desc->num_msgs)
return NULL;
msg_id = array_index_nospec(msg_id, desc->num_msgs);
if (desc->msg_desc[msg_id].type == HSMP_RSVD)
return NULL;
return &desc->msg_desc[msg_id];
}
static u32 hsmp_msg_response_sz(u32 msg_id)
{
const struct hsmp_msg_desc *desc = get_msg_desc(msg_id);
return desc ? desc->response_sz : HSMP_CLIENT_MAX_MSG_LEN;
}
DECLARE_RWSEM(hsmp_sock_rwsem);
EXPORT_SYMBOL_NS_GPL(hsmp_sock_rwsem, "AMD_HSMP");
static int __hsmp_send_message(struct hsmp_socket *sock, struct hsmp_message *msg)
{
struct hsmp_mbaddr_info *mbinfo;
unsigned long timeout, short_sleep;
u32 mbox_status;
u32 index;
int ret;
mbinfo = &sock->mbinfo;
mbox_status = HSMP_STATUS_NOT_READY;
ret = sock->amd_hsmp_rdwr(sock, mbinfo->msg_resp_off, &mbox_status, HSMP_WR);
if (ret) {
dev_err(sock->dev, "Error %d clearing mailbox status register\n", ret);
return ret;
}
index = 0;
while (index < msg->num_args) {
ret = sock->amd_hsmp_rdwr(sock, mbinfo->msg_arg_off + (index << 2),
&msg->args[index], HSMP_WR);
if (ret) {
dev_err(sock->dev, "Error %d writing message argument %d\n", ret, index);
return ret;
}
index++;
}
ret = sock->amd_hsmp_rdwr(sock, mbinfo->msg_id_off, &msg->msg_id, HSMP_WR);
if (ret) {
dev_err(sock->dev, "Error %d writing message ID %u\n", ret, msg->msg_id);
return ret;
}
short_sleep = jiffies + msecs_to_jiffies(HSMP_SHORT_SLEEP);
timeout = jiffies + msecs_to_jiffies(HSMP_MSG_TIMEOUT);
while (true) {
ret = sock->amd_hsmp_rdwr(sock, mbinfo->msg_resp_off, &mbox_status, HSMP_RD);
if (ret) {
dev_err(sock->dev, "Error %d reading mailbox status\n", ret);
return ret;
}
if (mbox_status != HSMP_STATUS_NOT_READY)
break;
if (!time_before(jiffies, timeout))
break;
if (time_before(jiffies, short_sleep))
usleep_range(50, 100);
else
usleep_range(1000, 2000);
}
if (unlikely(mbox_status == HSMP_STATUS_NOT_READY)) {
dev_err(sock->dev, "Message ID 0x%X failure : SMU timeout (status = 0x%X)\n",
msg->msg_id, mbox_status);
return -ETIMEDOUT;
} else if (unlikely(mbox_status == HSMP_ERR_INVALID_MSG)) {
dev_err(sock->dev, "Message ID 0x%X failure : Invalid message (status = 0x%X)\n",
msg->msg_id, mbox_status);
return -ENOMSG;
} else if (unlikely(mbox_status == HSMP_ERR_INVALID_INPUT)) {
dev_err(sock->dev, "Message ID 0x%X failure : Invalid arguments (status = 0x%X)\n",
msg->msg_id, mbox_status);
return -EINVAL;
} else if (unlikely(mbox_status == HSMP_ERR_PREREQ_NOT_SATISFIED)) {
dev_err(sock->dev, "Message ID 0x%X failure : Prerequisite not satisfied (status = 0x%X)\n",
msg->msg_id, mbox_status);
return -EREMOTEIO;
} else if (unlikely(mbox_status == HSMP_ERR_SMU_BUSY)) {
dev_err(sock->dev, "Message ID 0x%X failure : SMU BUSY (status = 0x%X)\n",
msg->msg_id, mbox_status);
return -EBUSY;
} else if (unlikely(mbox_status != HSMP_STATUS_OK)) {
dev_err(sock->dev, "Message ID 0x%X unknown failure (status = 0x%X)\n",
msg->msg_id, mbox_status);
return -EIO;
}
index = 0;
while (index < msg->response_sz) {
ret = sock->amd_hsmp_rdwr(sock, mbinfo->msg_arg_off + (index << 2),
&msg->args[index], HSMP_RD);
if (ret) {
dev_err(sock->dev, "Error %d reading response %u for message ID:%u\n",
ret, index, msg->msg_id);
break;
}
index++;
}
return ret;
}
static int validate_message(struct hsmp_message *msg)
{
const struct hsmp_plat_desc *plat_desc = hsmp_desc();
const struct hsmp_msg_desc *desc;
if (!plat_desc->msg_desc) {
if (msg->num_args > HSMP_CLIENT_MAX_MSG_LEN ||
msg->response_sz > HSMP_CLIENT_MAX_MSG_LEN)
return -EINVAL;
return 0;
}
desc = get_msg_desc(msg->msg_id);
if (!desc)
return -ENOMSG;
if (msg->num_args != desc->num_args)
return -EINVAL;
if (msg->response_sz > desc->response_sz)
return -EINVAL;
return 0;
}
static int hsmp_send_message_locked(struct hsmp_message *msg)
{
struct hsmp_socket *sock;
unsigned int sock_ind;
int ret;
lockdep_assert_held(&hsmp_sock_rwsem);
if (!msg)
return -EINVAL;
ret = validate_message(msg);
if (ret)
return ret;
if (!hsmp_pdev.sock || msg->sock_ind >= hsmp_pdev.num_sockets)
return -ENODEV;
sock_ind = array_index_nospec(msg->sock_ind, hsmp_pdev.num_sockets);
sock = &hsmp_pdev.sock[sock_ind];
if (!smp_load_acquire(&sock->dev))
return -ENODEV;
ret = down_interruptible(&sock->hsmp_sem);
if (ret < 0)
return ret;
ret = __hsmp_send_message(sock, msg);
up(&sock->hsmp_sem);
return ret;
}
int hsmp_send_message(struct hsmp_message *msg)
{
guard(rwsem_read)(&hsmp_sock_rwsem);
return hsmp_send_message_locked(msg);
}
EXPORT_SYMBOL_NS_GPL(hsmp_send_message, "AMD_HSMP");
int hsmp_msg_get_nargs(u16 sock_ind, u32 msg_id, u32 *data, u8 num_args)
{
struct hsmp_message msg = {};
unsigned int i;
int ret;
if (!data)
return -EINVAL;
msg.msg_id = msg_id;
msg.sock_ind = sock_ind;
msg.response_sz = num_args;
ret = hsmp_send_message(&msg);
if (ret)
return ret;
for (i = 0; i < num_args; i++)
data[i] = msg.args[i];
return 0;
}
EXPORT_SYMBOL_NS_GPL(hsmp_msg_get_nargs, "AMD_HSMP");
int hsmp_test(u16 sock_ind, u32 value)
{
struct hsmp_message msg = { 0 };
int ret;
msg.msg_id = hsmp_desc()->test_msg;
msg.num_args = 1;
msg.response_sz = 1;
msg.args[0] = value;
msg.sock_ind = sock_ind;
ret = hsmp_send_message_locked(&msg);
if (ret)
return ret;
if (msg.args[0] != (value + 1)) {
dev_err(hsmp_pdev.sock[sock_ind].dev,
"Socket %d test message failed, Expected 0x%08X, received 0x%08X\n",
sock_ind, (value + 1), msg.args[0]);
return -EBADE;
}
return ret;
}
EXPORT_SYMBOL_NS_GPL(hsmp_test, "AMD_HSMP");
static bool is_get_msg(const struct hsmp_msg_desc *desc, struct hsmp_message *msg)
{
if (desc->type == HSMP_GET)
return true;
if (desc->type == HSMP_SET_GET && (msg->args[0] & CHECK_GET_BIT))
return true;
return false;
}
static long hsmp_ioctl_msg(struct file *fp, unsigned long arg)
{
int __user *arguser = (int __user *)arg;
struct hsmp_message msg = { 0 };
const struct hsmp_plat_desc *plat_desc = hsmp_desc();
const struct hsmp_msg_desc *desc = NULL;
int ret;
if (copy_struct_from_user(&msg, sizeof(msg), arguser, sizeof(struct hsmp_message)))
return -EFAULT;
if (plat_desc->msg_desc) {
desc = get_msg_desc(msg.msg_id);
if (!desc)
return -ENOMSG;
switch (fp->f_mode & (FMODE_WRITE | FMODE_READ)) {
case FMODE_WRITE:
if (is_get_msg(desc, &msg))
return -EPERM;
break;
case FMODE_READ:
if (!is_get_msg(desc, &msg))
return -EPERM;
break;
case FMODE_READ | FMODE_WRITE:
break;
default:
return -EPERM;
}
}
ret = hsmp_send_message(&msg);
if (ret)
return ret;
if ((desc ? desc->response_sz : msg.response_sz) > 0) {
if (copy_to_user(arguser, &msg, sizeof(struct hsmp_message)))
return -EFAULT;
}
return 0;
}
static ssize_t hsmp_metric_tbl_read_locked(struct hsmp_socket *sock, char *buf,
size_t size);
static long hsmp_ioctl_get_telemetry(struct file *fp, unsigned long arg)
{
void *kbuf __free(kvfree) = NULL;
void __user *arguser = (void __user *)arg;
struct hsmp_telemetry_data req;
struct hsmp_socket *sock;
void __user *user_buf;
size_t tbl_size;
unsigned int sock_ind;
int ret;
if (!(fp->f_mode & FMODE_READ))
return -EPERM;
if (copy_from_user(&req, arguser, sizeof(req)))
return -EFAULT;
if (req.reserved)
return -EINVAL;
user_buf = u64_to_user_ptr(req.buf);
scoped_guard(rwsem_read, &hsmp_sock_rwsem) {
if (!hsmp_pdev.sock || req.sock_ind >= hsmp_pdev.num_sockets)
return -ENODEV;
sock_ind = array_index_nospec(req.sock_ind, hsmp_pdev.num_sockets);
sock = &hsmp_pdev.sock[sock_ind];
if (!sock->metric_tbl_addr)
return -ENODEV;
tbl_size = sock->metric_tbl_size;
if (!tbl_size)
return -ENODEV;
if (!req.size || req.size > tbl_size)
return -EINVAL;
kbuf = kvmalloc(tbl_size, GFP_KERNEL);
if (!kbuf)
return -ENOMEM;
ret = hsmp_metric_tbl_read_locked(sock, kbuf, tbl_size);
}
if (ret < 0)
return ret;
if (copy_to_user(user_buf, kbuf, req.size))
return -EFAULT;
return 0;
}
long hsmp_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
{
switch (cmd) {
case HSMP_IOCTL_CMD:
return hsmp_ioctl_msg(fp, arg);
case HSMP_IOCTL_GET_TELEMETRY_DATA:
return hsmp_ioctl_get_telemetry(fp, arg);
default:
return -ENOTTY;
}
}
static ssize_t hsmp_metric_tbl_read_locked(struct hsmp_socket *sock, char *buf,
size_t size)
{
struct hsmp_message msg = { 0 };
int ret;
lockdep_assert_held(&hsmp_sock_rwsem);
if (!sock || !buf)
return -EINVAL;
if (!sock->metric_tbl_addr) {
dev_err(sock->dev, "Metrics table address not available\n");
return -ENOMEM;
}
if (size != sock->metric_tbl_size) {
dev_err(sock->dev, "Wrong buffer size\n");
return -EINVAL;
}
msg.msg_id = hsmp_desc()->metric_tbl_msg;
msg.sock_ind = sock->sock_ind;
guard(mutex)(&sock->metric_read_lock);
ret = hsmp_send_message_locked(&msg);
if (ret)
return ret;
memcpy_fromio(buf, sock->metric_tbl_addr, size);
return size;
}
ssize_t hsmp_metric_tbl_read(struct hsmp_socket *sock, char *buf, size_t size)
{
guard(rwsem_read)(&hsmp_sock_rwsem);
return hsmp_metric_tbl_read_locked(sock, buf, size);
}
EXPORT_SYMBOL_NS_GPL(hsmp_metric_tbl_read, "AMD_HSMP");
void hsmp_init_metric_read_locks(struct hsmp_plat_device *pdev)
{
u16 i;
for (i = 0; i < pdev->num_sockets; i++)
mutex_init(&pdev->sock[i].metric_read_lock);
}
EXPORT_SYMBOL_NS_GPL(hsmp_init_metric_read_locks, "AMD_HSMP");
void hsmp_destroy_metric_read_locks(struct hsmp_plat_device *pdev)
{
u16 i;
for (i = 0; i < pdev->num_sockets; i++)
mutex_destroy(&pdev->sock[i].metric_read_lock);
}
EXPORT_SYMBOL_NS_GPL(hsmp_destroy_metric_read_locks, "AMD_HSMP");
void hsmp_unmap_metric_tbls(struct hsmp_plat_device *pdev)
{
struct hsmp_socket *sock;
u16 i;
for (i = 0; i < pdev->num_sockets; i++) {
sock = &pdev->sock[i];
if (sock->metric_tbl_addr) {
iounmap(sock->metric_tbl_addr);
sock->metric_tbl_addr = NULL;
}
sock->metric_tbl_size = 0;
}
}
EXPORT_SYMBOL_NS_GPL(hsmp_unmap_metric_tbls, "AMD_HSMP");
int hsmp_get_tbl_dram_base(u16 sock_ind)
{
struct hsmp_socket *sock = &hsmp_pdev.sock[sock_ind];
struct hsmp_message msg = { 0 };
phys_addr_t dram_addr;
size_t tbl_size;
int ret;
msg.sock_ind = sock_ind;
msg.msg_id = hsmp_desc()->metric_dram_msg;
msg.response_sz = hsmp_msg_response_sz(msg.msg_id);
ret = hsmp_send_message_locked(&msg);
if (ret)
return ret;
dram_addr = msg.args[0] | ((u64)(msg.args[1]) << 32);
if (!dram_addr) {
dev_err(sock->dev, "Invalid DRAM address for metric table\n");
return -ENOMEM;
}
if (sock->metric_tbl_addr) {
iounmap(sock->metric_tbl_addr);
sock->metric_tbl_addr = NULL;
}
sock->metric_tbl_size = 0;
if (msg.args[2])
tbl_size = msg.args[2];
else
tbl_size = sizeof(struct hsmp_metric_table);
sock->metric_tbl_addr = ioremap(dram_addr, tbl_size);
if (!sock->metric_tbl_addr) {
dev_err(sock->dev, "Failed to ioremap metric table addr\n");
return -ENOMEM;
}
sock->metric_tbl_size = tbl_size;
return 0;
}
EXPORT_SYMBOL_NS_GPL(hsmp_get_tbl_dram_base, "AMD_HSMP");
int hsmp_cache_proto_ver(u16 sock_ind)
{
struct hsmp_message msg = { 0 };
int ret;
msg.msg_id = hsmp_desc()->proto_ver_msg;
msg.response_sz = hsmp_msg_response_sz(msg.msg_id);
msg.sock_ind = sock_ind;
ret = hsmp_send_message_locked(&msg);
if (!ret)
hsmp_pdev.proto_ver = msg.args[0];
return ret;
}
EXPORT_SYMBOL_NS_GPL(hsmp_cache_proto_ver, "AMD_HSMP");
static const struct file_operations hsmp_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = hsmp_ioctl,
.compat_ioctl = hsmp_ioctl,
};
int hsmp_misc_register(struct device *dev)
{
hsmp_pdev.mdev.name = HSMP_CDEV_NAME;
hsmp_pdev.mdev.minor = MISC_DYNAMIC_MINOR;
hsmp_pdev.mdev.fops = &hsmp_fops;
hsmp_pdev.mdev.parent = dev;
hsmp_pdev.mdev.nodename = HSMP_DEVNODE_NAME;
hsmp_pdev.mdev.mode = is_client_platform() ? 0600 : 0644;
return misc_register(&hsmp_pdev.mdev);
}
EXPORT_SYMBOL_NS_GPL(hsmp_misc_register, "AMD_HSMP");
void hsmp_misc_deregister(void)
{
misc_deregister(&hsmp_pdev.mdev);
hsmp_pdev.mdev.this_device = NULL;
}
EXPORT_SYMBOL_NS_GPL(hsmp_misc_deregister, "AMD_HSMP");
struct hsmp_plat_device *get_hsmp_pdev(void)
{
return &hsmp_pdev;
}
EXPORT_SYMBOL_NS_GPL(get_hsmp_pdev, "AMD_HSMP");
MODULE_DESCRIPTION("AMD HSMP Common driver");
MODULE_VERSION(DRIVER_VERSION);
MODULE_LICENSE("GPL"