// SPDX-License-Identifier: GPL-2.0 /* * AMD HSMP Platform Driver * Copyright (c) 2022, AMD. * All Rights Reserved. * * This file provides a device implementation for HSMP interface */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "hsmp.h" /* HSMP Status / Error codes */ #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 /* Timeout in millsec */ #define HSMP_MSG_TIMEOUT 100 #define HSMP_SHORT_SLEEP 1 #define HSMP_WR true #define HSMP_RD false /* * When same message numbers are used for both GET and SET operation, * bit:31 indicates whether its SET or GET operation. */ #define CHECK_GET_BIT BIT(31) /* Catch a table left out of sync with its enum at build time */ static_assert(ARRAY_SIZE(hsmp_msg_desc_table) == HSMP_MSG_ID_MAX); /* Per-platform message set: which table to use, and driver-issued msg IDs */ 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, }; /* * The client drives a different mailbox with the Ryzen Master SMC message * set. It has no per-message descriptor table: num_args/response_sz are * bounded generically instead (see validate_message()), and an unsupported * or malformed msg_id is rejected by firmware with its own SMU status code. */ 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; /* Cached on first use; READ_ONCE()/WRITE_ONCE() avoid a torn access */ 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; } /* Returns NULL if the platform has no descriptor table, or msg_id is out of range or reserved */ 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; /* * Sanitize msg_id here rather than trusting a caller-side clamp: a * mispredicted branch upstream can still reach this function with * an unclamped msg_id (Spectre v1, CVE-2017-5753). */ 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]; } /* * Response size for a message the driver issues directly, such as the * probe-time test, protocol-version and metric-table messages: the * descriptor table entry for server, since these fixed, well-known message * IDs always have one; the client protocol max otherwise, since the client * set has no descriptor table and firmware reports no response length. * Callers only consume the response words they expect. */ 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; } /* * Gates the AMD HSMP data plane against socket bring-up and teardown. * * hsmp_send_message() takes it for read, so open /dev/hsmp fds and hwmon reads * run concurrently. Probe and remove take it for write: probe brings sockets * up (running the mailbox handshake via hsmp_send_message_locked()) and remove * tears them down, both excluding and draining the data plane. */ DECLARE_RWSEM(hsmp_sock_rwsem); EXPORT_SYMBOL_NS_GPL(hsmp_sock_rwsem, "AMD_HSMP"); /* * Send a message to the HSMP port via PCI-e config space registers * or by writing to MMIO space. * * The caller is expected to zero out any unused arguments. * If a response is expected, the number of response words should be greater than 0. * * Returns 0 for success and populates the requested number of arguments. * Returns a negative error code for failure. */ 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; /* Clear the status register */ 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; /* Write any message arguments */ 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++; } /* Write the message ID which starts the operation */ 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; } /* * Depending on when the trigger write completes relative to the SMU * firmware 1 ms cycle, the operation may take from tens of us to 1 ms * to complete. Some operations may take more. Therefore we will try * a few short duration sleeps and switch to long sleeps if we don't * succeed quickly. */ 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; } /* * SMU has responded OK. Read response data. * SMU reads the input arguments from eight 32 bit registers starting * from SMN_HSMP_MSG_DATA and writes the response data to the same * SMN_HSMP_MSG_DATA address. * We copy the response data if any, back to the args[]. */ 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) { /* * The client message set has no per-message descriptor * table and no msg_id range to validate against; cap * num_args/response_sz to what the Ryzen Master mailbox * supports in each direction and leave msg_id correctness, * such as an unsupported or out-of-range value, to the SMU * status code __hsmp_send_message() already translates. */ if (msg->num_args > HSMP_CLIENT_MAX_MSG_LEN || msg->response_sz > HSMP_CLIENT_MAX_MSG_LEN) return -EINVAL; return 0; } /* Out-of-range or reserved message ID for this platform */ desc = get_msg_desc(msg->msg_id); if (!desc) return -ENOMSG; /* * num_args passed by user should match the num_args specified in * message description table. */ if (msg->num_args != desc->num_args) return -EINVAL; /* * As the HSMP protocol evolves, newer platforms may define more * response arguments for existing messages. Use an upper-bound * check so that older userspace callers requesting fewer response * words than what the current descriptor table defines are still * accepted, while rejecting requests that exceed the hardware * capability. */ if (msg->response_sz > desc->response_sz) return -EINVAL; return 0; } /* * Core message send. The caller must hold hsmp_sock_rwsem: the data plane * takes it for read so many messages run concurrently, while the probe-time * senders run under the write lock taken by probe. Holding it here serializes * every message against socket teardown, which also holds it for write. */ 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; /* * Sanitize sock_ind after the bounds check. A mispredicted branch can * still let the CPU speculatively use msg->sock_ind as an index into * hsmp_pdev.sock[] (Spectre v1, CVE-2017-5753), including for callers * other than hsmp_ioctl_msg() that pass a user-derived socket index. */ sock_ind = array_index_nospec(msg->sock_ind, hsmp_pdev.num_sockets); sock = &hsmp_pdev.sock[sock_ind]; /* * A slot exists for every possible socket, but it is only usable once * that socket has actually been probed. Reject messages aimed at a * socket that was never brought up or is still in bring-up, so we never * operate on a zero-initialized semaphore or an unmapped mailbox. A * non-NULL dev also guarantees virt_base_addr, the mailbox offsets and * the semaphore are visible. * * Held under hsmp_sock_rwsem; pairs with smp_store_release(&sock->dev) * in hsmp_parse_acpi_table(). */ 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) { /* * Data-plane entry point: open /dev/hsmp fds and hwmon sysfs reads issue * messages from here. Take hsmp_sock_rwsem for read so messages run * concurrently with each other but are drained and kept out while * probe/remove hold it for write to tear a socket down. */ 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; /* * Test the hsmp port by performing TEST command. The test message * takes one argument and returns the value of that argument + 1. */ 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; /* Check the response value */ 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; /* * The client message set has no per-message descriptor table to * bounds-check msg_id against or index into, and no per-message * type to gate fd mode on, so none of that applies here. * validate_message() (called via hsmp_send_message() below) still * bounds num_args/response_sz generically, and firmware is the * final arbiter of msg_id validity via its own response status. */ if (plat_desc->msg_desc) { /* Rejects out-of-range and reserved msg_ids */ desc = get_msg_desc(msg.msg_id); if (!desc) return -ENOMSG; switch (fp->f_mode & (FMODE_WRITE | FMODE_READ)) { case FMODE_WRITE: /* * Device is opened in O_WRONLY mode * Execute only set/configure commands. */ if (is_get_msg(desc, &msg)) return -EPERM; break; case FMODE_READ: /* * Device is opened in O_RDONLY mode * Execute only get/monitor commands. */ if (!is_get_msg(desc, &msg)) return -EPERM; break; case FMODE_READ | FMODE_WRITE: /* * Device is opened in O_RDWR mode * Execute both get/monitor and set/configure commands */ break; default: return -EPERM; } } ret = hsmp_send_message(&msg); if (ret) return ret; /* * The client message set has no per-message response_sz to check * here (desc is NULL); validate_message() already bounded * msg.response_sz. */ if ((desc ? desc->response_sz : msg.response_sz) > 0) { /* Copy results back to user for get/monitor commands */ 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); /* * Fetch the firmware metric (telemetry) table for the requested socket and * copy it to the userspace buffer described by the request. * * The metric table size is variable across HSMP protocol versions and on * Family 1Ah Model 50h-5Fh exceeds PAGE_SIZE. The request carries the buffer * size, which may be anything up to the size firmware reported for this * socket's table. */ 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; /* Telemetry data is read-only; require read access on the fd. */ if (!(fp->f_mode & FMODE_READ)) return -EPERM; if (copy_from_user(&req, arguser, sizeof(req))) return -EFAULT; /* * Reserved fields must be zero so future kernels can safely * repurpose them without breaking already-deployed userspace. */ if (req.reserved) return -EINVAL; user_buf = u64_to_user_ptr(req.buf); /* * /dev/hsmp is a singleton character device that outlives an individual * socket unbind, so an ioctl on an already-open fd can run concurrently * with socket teardown. Hold hsmp_sock_rwsem for read across the socket * lookup, the checks on its metric-table state and the read itself: * probe and remove take the same lock for write, so they cannot free the * socket array, unmap the table or destroy the per-socket mutex while * this runs. * * The lock is dropped before the copy_to_user() below. Faulting in the * destination can block indefinitely on a userfaultfd-backed buffer, * which would leave a socket unbind waiting for the write lock. */ scoped_guard(rwsem_read, &hsmp_sock_rwsem) { if (!hsmp_pdev.sock || req.sock_ind >= hsmp_pdev.num_sockets) return -ENODEV; /* * Sanitize the user-controlled socket index against speculative * execution. The bounds check above retires the out-of-range * case with -ENODEV, but a mispredicted branch can still let the * CPU speculatively use sock_ind as an index into * hsmp_pdev.sock[] and pull arbitrary kernel memory into the * cache (Spectre v1, CVE-2017-5753). array_index_nospec() turns * the bounds check into a data-flow clamp so the speculative * load is in-range too. */ 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; /* * A request shorter than the firmware table is served with the * leading @size bytes of the snapshot, so userspace built * against an older table layout keeps working on firmware that * grew the table. Asking for more than firmware provides is * rejected rather than short-written, so a caller can never * mistake a partial copy for a full one. */ if (!req.size || req.size > tbl_size) return -EINVAL; /* * The bounce buffer is overwritten in full by memcpy_fromio() * inside hsmp_metric_tbl_read_locked(); use kvmalloc() to avoid * the zeroing cost of kvzalloc() on the ~13 KB allocation done * on every ioctl call. */ 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; } } /* * Caller must hold hsmp_sock_rwsem. It keeps @sock, its metric-table mapping * and its metric_read_lock alive: probe and remove take the same lock for * write while they bring sockets up and tear them down. */ 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; /* * The metric table message makes firmware refill this socket's shared * metric DRAM region, which is then copied out below. Hold the * per-socket lock across the fill-and-copy so concurrent readers of the * same socket cannot return a torn snapshot. */ 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; /* * calculate the metric table DRAM address from lower and upper 32 bits * sent from SMU and ioremap it to virtual address. */ 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; } /* * The ACPI socket array is shared across sockets and outlives a * per-socket unbind, so metric_tbl_addr may hold a mapping from an * earlier bind of this socket. Unmap it before remapping so an * unbind/rebind cycle does not leak a metric-table mapping. This runs * during probe before the metric sysfs attribute is exposed, so no * reader can be using it. */ if (sock->metric_tbl_addr) { iounmap(sock->metric_tbl_addr); sock->metric_tbl_addr = NULL; } sock->metric_tbl_size = 0; /* SMU returns table size from Family 1Ah Model 50h and forward */ 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; /* * The caller chooses the parent. The platform driver has a single * device whose lifetime matches /dev/hsmp and parents it there. The * ACPI driver passes NULL: its /dev/hsmp is a singleton shared by * per-socket devices that can be unbound individually and out of order, * so parenting it to one would leave it attached to an already-removed * device. */ hsmp_pdev.mdev.parent = dev; hsmp_pdev.mdev.nodename = HSMP_DEVNODE_NAME; /* * hsmp_msg_desc_table[] only describes server messages. On client * platforms, msg_id mappings differ, making access checks unreliable. * Restrict /dev/hsmp to root until client-specific validation is * added. */ 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");