// SPDX-License-Identifier: GPL-2.0-only
/* Copyright(c) 2020 Intel Corporation. All rights reserved. */
#include <linux/security.h>
#include <linux/debugfs.h>
#include <linux/ktime.h>
#include <linux/mutex.h>
#include <linux/unaligned.h>
#include <cxlpci.h>
#include <cxlmem.h>
#include <cxl.h>

#include "core.h"
#include "trace.h"
#include "mce.h"

static bool cxl_raw_allow_all;

/**
 * DOC: cxl mbox
 *
 * Core implementation of the CXL 2.0 Type-3 Memory Device Mailbox. The
 * implementation is used by the cxl_pci driver to initialize the device
 * and implement the cxl_mem.h IOCTL UAPI. It also implements the
 * backend of the cxl_pmem_ctl() transport for LIBNVDIMM.
 */

#define cxl_for_each_cmd(cmd)                                                  \
        for ((cmd) = &cxl_mem_commands[0];                                     \
             ((cmd) - cxl_mem_commands) < ARRAY_SIZE(cxl_mem_commands); (cmd)++)

#define CXL_CMD(_id, sin, sout, _flags)                                        \
        [CXL_MEM_COMMAND_ID_##_id] = {                                         \
        .info = {                                                              \
                        .id = CXL_MEM_COMMAND_ID_##_id,                        \
                        .size_in = sin,                                        \
                        .size_out = sout,                                      \
                },                                                             \
        .opcode = CXL_MBOX_OP_##_id,                                           \
        .flags = _flags,                                                       \
        }

#define CXL_VARIABLE_PAYLOAD    ~0U
/*
 * This table defines the supported mailbox commands for the driver. This table
 * is made up of a UAPI structure. Non-negative values as parameters in the
 * table will be validated against the user's input. For example, if size_in is
 * 0, and the user passed in 1, it is an error.
 */
static struct cxl_mem_command cxl_mem_commands[CXL_MEM_COMMAND_ID_MAX] = {
        CXL_CMD(IDENTIFY, 0, 0x43, CXL_CMD_FLAG_FORCE_ENABLE),
#ifdef CONFIG_CXL_MEM_RAW_COMMANDS
        CXL_CMD(RAW, CXL_VARIABLE_PAYLOAD, CXL_VARIABLE_PAYLOAD, 0),
#endif
        CXL_CMD(GET_SUPPORTED_LOGS, 0, CXL_VARIABLE_PAYLOAD, CXL_CMD_FLAG_FORCE_ENABLE),
        CXL_CMD(GET_FW_INFO, 0, 0x50, 0),
        CXL_CMD(GET_PARTITION_INFO, 0, 0x20, 0),
        CXL_CMD(GET_LSA, 0x8, CXL_VARIABLE_PAYLOAD, 0),
        CXL_CMD(GET_HEALTH_INFO, 0, 0x12, 0),
        CXL_CMD(GET_LOG, 0x18, CXL_VARIABLE_PAYLOAD, CXL_CMD_FLAG_FORCE_ENABLE),
        CXL_CMD(GET_LOG_CAPS, 0x10, 0x4, 0),
        CXL_CMD(CLEAR_LOG, 0x10, 0, 0),
        CXL_CMD(GET_SUP_LOG_SUBLIST, 0x2, CXL_VARIABLE_PAYLOAD, 0),
        CXL_CMD(SET_PARTITION_INFO, 0x0a, 0, 0),
        CXL_CMD(SET_LSA, CXL_VARIABLE_PAYLOAD, 0, 0),
        CXL_CMD(GET_ALERT_CONFIG, 0, 0x10, 0),
        CXL_CMD(SET_ALERT_CONFIG, 0xc, 0, 0),
        CXL_CMD(GET_SHUTDOWN_STATE, 0, 0x1, 0),
        CXL_CMD(SET_SHUTDOWN_STATE, 0x1, 0, 0),
        CXL_CMD(GET_SCAN_MEDIA_CAPS, 0x10, 0x4, 0),
        CXL_CMD(GET_TIMESTAMP, 0, 0x8, 0),
};

/*
 * Commands that RAW doesn't permit. The rationale for each:
 *
 * CXL_MBOX_OP_ACTIVATE_FW: Firmware activation requires adjustment /
 * coordination of transaction timeout values at the root bridge level.
 *
 * CXL_MBOX_OP_SET_PARTITION_INFO: The device memory map may change live
 * and needs to be coordinated with HDM updates.
 *
 * CXL_MBOX_OP_SET_LSA: The label storage area may be cached by the
 * driver and any writes from userspace invalidates those contents.
 *
 * CXL_MBOX_OP_SET_SHUTDOWN_STATE: Set shutdown state assumes no writes
 * to the device after it is marked clean, userspace can not make that
 * assertion.
 *
 * CXL_MBOX_OP_[GET_]SCAN_MEDIA: The kernel provides a native error list that
 * is kept up to date with patrol notifications and error management.
 *
 * CXL_MBOX_OP_[GET_,INJECT_,CLEAR_]POISON: These commands require kernel
 * driver orchestration for safety.
 */
static u16 cxl_disabled_raw_commands[] = {
        CXL_MBOX_OP_ACTIVATE_FW,
        CXL_MBOX_OP_SET_PARTITION_INFO,
        CXL_MBOX_OP_SET_LSA,
        CXL_MBOX_OP_SET_SHUTDOWN_STATE,
        CXL_MBOX_OP_SCAN_MEDIA,
        CXL_MBOX_OP_GET_SCAN_MEDIA,
        CXL_MBOX_OP_GET_POISON,
        CXL_MBOX_OP_INJECT_POISON,
        CXL_MBOX_OP_CLEAR_POISON,
};

/*
 * Command sets that RAW doesn't permit. All opcodes in this set are
 * disabled because they pass plain text security payloads over the
 * user/kernel boundary. This functionality is intended to be wrapped
 * behind the keys ABI which allows for encrypted payloads in the UAPI
 */
static u8 security_command_sets[] = {
        0x44, /* Sanitize */
        0x45, /* Persistent Memory Data-at-rest Security */
        0x46, /* Security Passthrough */
};

static bool cxl_is_security_command(u16 opcode)
{
        int i;

        for (i = 0; i < ARRAY_SIZE(security_command_sets); i++)
                if (security_command_sets[i] == (opcode >> 8))
                        return true;
        return false;
}

static void cxl_set_security_cmd_enabled(struct cxl_security_state *security,
                                         u16 opcode)
{
        switch (opcode) {
        case CXL_MBOX_OP_SANITIZE:
                set_bit(CXL_SEC_ENABLED_SANITIZE, security->enabled_cmds);
                break;
        case CXL_MBOX_OP_SECURE_ERASE:
                set_bit(CXL_SEC_ENABLED_SECURE_ERASE,
                        security->enabled_cmds);
                break;
        case CXL_MBOX_OP_GET_SECURITY_STATE:
                set_bit(CXL_SEC_ENABLED_GET_SECURITY_STATE,
                        security->enabled_cmds);
                break;
        case CXL_MBOX_OP_SET_PASSPHRASE:
                set_bit(CXL_SEC_ENABLED_SET_PASSPHRASE,
                        security->enabled_cmds);
                break;
        case CXL_MBOX_OP_DISABLE_PASSPHRASE:
                set_bit(CXL_SEC_ENABLED_DISABLE_PASSPHRASE,
                        security->enabled_cmds);
                break;
        case CXL_MBOX_OP_UNLOCK:
                set_bit(CXL_SEC_ENABLED_UNLOCK, security->enabled_cmds);
                break;
        case CXL_MBOX_OP_FREEZE_SECURITY:
                set_bit(CXL_SEC_ENABLED_FREEZE_SECURITY,
                        security->enabled_cmds);
                break;
        case CXL_MBOX_OP_PASSPHRASE_SECURE_ERASE:
                set_bit(CXL_SEC_ENABLED_PASSPHRASE_SECURE_ERASE,
                        security->enabled_cmds);
                break;
        default:
                break;
        }
}

static bool cxl_is_poison_command(u16 opcode)
{
#define CXL_MBOX_OP_POISON_CMDS 0x43

        if ((opcode >> 8) == CXL_MBOX_OP_POISON_CMDS)
                return true;

        return false;
}

static void cxl_set_poison_cmd_enabled(struct cxl_poison_state *poison,
                                       u16 opcode)
{
        switch (opcode) {
        case CXL_MBOX_OP_GET_POISON:
                set_bit(CXL_POISON_ENABLED_LIST, poison->enabled_cmds);
                break;
        case CXL_MBOX_OP_INJECT_POISON:
                set_bit(CXL_POISON_ENABLED_INJECT, poison->enabled_cmds);
                break;
        case CXL_MBOX_OP_CLEAR_POISON:
                set_bit(CXL_POISON_ENABLED_CLEAR, poison->enabled_cmds);
                break;
        case CXL_MBOX_OP_GET_SCAN_MEDIA_CAPS:
                set_bit(CXL_POISON_ENABLED_SCAN_CAPS, poison->enabled_cmds);
                break;
        case CXL_MBOX_OP_SCAN_MEDIA:
                set_bit(CXL_POISON_ENABLED_SCAN_MEDIA, poison->enabled_cmds);
                break;
        case CXL_MBOX_OP_GET_SCAN_MEDIA:
                set_bit(CXL_POISON_ENABLED_SCAN_RESULTS, poison->enabled_cmds);
                break;
        default:
                break;
        }
}

static struct cxl_mem_command *cxl_mem_find_command(u16 opcode)
{
        struct cxl_mem_command *c;

        cxl_for_each_cmd(c)
                if (c->opcode == opcode)
                        return c;

        return NULL;
}

static const char *cxl_mem_opcode_to_name(u16 opcode)
{
        struct cxl_mem_command *c;

        c = cxl_mem_find_command(opcode);
        if (!c)
                return NULL;

        return cxl_command_names[c->info.id].name;
}

/**
 * cxl_internal_send_cmd() - Kernel internal interface to send a mailbox command
 * @cxl_mbox: CXL mailbox context
 * @mbox_cmd: initialized command to execute
 *
 * Context: Any context.
 * Return:
 *  * %>=0      - Number of bytes returned in @out.
 *  * %-E2BIG   - Payload is too large for hardware.
 *  * %-EBUSY   - Couldn't acquire exclusive mailbox access.
 *  * %-EFAULT  - Hardware error occurred.
 *  * %-ENXIO   - Command completed, but device reported an error.
 *  * %-EIO     - Unexpected output size.
 *
 * Mailbox commands may execute successfully yet the device itself reported an
 * error. While this distinction can be useful for commands from userspace, the
 * kernel will only be able to use results when both are successful.
 */
int cxl_internal_send_cmd(struct cxl_mailbox *cxl_mbox,
                          struct cxl_mbox_cmd *mbox_cmd)
{
        size_t out_size, min_out;
        int rc;

        if (mbox_cmd->size_in > cxl_mbox->payload_size ||
            mbox_cmd->size_out > cxl_mbox->payload_size)
                return -E2BIG;

        out_size = mbox_cmd->size_out;
        min_out = mbox_cmd->min_out;
        rc = cxl_mbox->mbox_send(cxl_mbox, mbox_cmd);
        /*
         * EIO is reserved for a payload size mismatch and mbox_send()
         * may not return this error.
         */
        if (WARN_ONCE(rc == -EIO, "Bad return code: -EIO"))
                return -ENXIO;
        if (rc)
                return rc;

        if (mbox_cmd->return_code != CXL_MBOX_CMD_RC_SUCCESS &&
            mbox_cmd->return_code != CXL_MBOX_CMD_RC_BACKGROUND)
                return cxl_mbox_cmd_rc2errno(mbox_cmd);

        if (!out_size)
                return 0;

        /*
         * Variable sized output needs to at least satisfy the caller's
         * minimum if not the fully requested size.
         */
        if (min_out == 0)
                min_out = out_size;

        if (mbox_cmd->size_out < min_out)
                return -EIO;
        return 0;
}
EXPORT_SYMBOL_NS_GPL(cxl_internal_send_cmd, "CXL");

static bool cxl_mem_raw_command_allowed(u16 opcode)
{
        int i;

        if (!IS_ENABLED(CONFIG_CXL_MEM_RAW_COMMANDS))
                return false;

        if (security_locked_down(LOCKDOWN_PCI_ACCESS))
                return false;

        if (cxl_raw_allow_all)
                return true;

        if (cxl_is_security_command(opcode))
                return false;

        for (i = 0; i < ARRAY_SIZE(cxl_disabled_raw_commands); i++)
                if (cxl_disabled_raw_commands[i] == opcode)
                        return false;

        return true;
}

/**
 * cxl_payload_from_user_allowed() - Check contents of in_payload.
 * @opcode: The mailbox command opcode.
 * @payload_in: Pointer to the input payload passed in from user space.
 * @in_size: Size of @payload_in in bytes.
 *
 * Return:
 *  * true      - payload_in passes check for @opcode.
 *  * false     - payload_in contains invalid or unsupported values.
 *
 * The driver may inspect payload contents before sending a mailbox
 * command from user space to the device. The intent is to reject
 * commands with input payloads that are known to be unsafe. This
 * check is not intended to replace the users careful selection of
 * mailbox command parameters and makes no guarantee that the user
 * command will succeed, nor that it is appropriate.
 *
 * The specific checks are determined by the opcode.
 */
static bool cxl_payload_from_user_allowed(u16 opcode, void *payload_in,
                                          size_t in_size)
{
        switch (opcode) {
        case CXL_MBOX_OP_SET_PARTITION_INFO: {
                struct cxl_mbox_set_partition_info *pi = payload_in;

                if (in_size < sizeof(*pi))
                        return false;
                if (pi->flags & CXL_SET_PARTITION_IMMEDIATE_FLAG)
                        return false;
                break;
        }
        case CXL_MBOX_OP_CLEAR_LOG: {
                const uuid_t *uuid = (uuid_t *)payload_in;

                if (in_size < sizeof(uuid_t))
                        return false;
                /*
                 * Restrict the ‘Clear log’ action to only apply to
                 * Vendor debug logs.
                 */
                return uuid_equal(uuid, &DEFINE_CXL_VENDOR_DEBUG_UUID);
        }
        default:
                break;
        }
        return true;
}

static int cxl_mbox_cmd_ctor(struct cxl_mbox_cmd *mbox_cmd,
                             struct cxl_mailbox *cxl_mbox, u16 opcode,
                             size_t in_size, size_t out_size, u64 in_payload)
{
        *mbox_cmd = (struct cxl_mbox_cmd) {
                .opcode = opcode,
                .size_in = in_size,
        };

        if (in_size) {
                mbox_cmd->payload_in = vmemdup_user(u64_to_user_ptr(in_payload),
                                                    in_size);
                if (IS_ERR(mbox_cmd->payload_in))
                        return PTR_ERR(mbox_cmd->payload_in);

                if (!cxl_payload_from_user_allowed(opcode, mbox_cmd->payload_in,
                                                  in_size)) {
                        dev_dbg(cxl_mbox->host, "%s: input payload not allowed\n",
                                cxl_mem_opcode_to_name(opcode));
                        kvfree(mbox_cmd->payload_in);
                        return -EBUSY;
                }
        }

        /* Prepare to handle a full payload for variable sized output */
        if (out_size == CXL_VARIABLE_PAYLOAD)
                mbox_cmd->size_out = cxl_mbox->payload_size;
        else
                mbox_cmd->size_out = out_size;

        if (mbox_cmd->size_out) {
                mbox_cmd->payload_out = kvzalloc(mbox_cmd->size_out, GFP_KERNEL);
                if (!mbox_cmd->payload_out) {
                        kvfree(mbox_cmd->payload_in);
                        return -ENOMEM;
                }
        }
        return 0;
}

static void cxl_mbox_cmd_dtor(struct cxl_mbox_cmd *mbox)
{
        kvfree(mbox->payload_in);
        kvfree(mbox->payload_out);
}

static int cxl_to_mem_cmd_raw(struct cxl_mem_command *mem_cmd,
                              const struct cxl_send_command *send_cmd,
                              struct cxl_mailbox *cxl_mbox)
{
        if (send_cmd->raw.rsvd)
                return -EINVAL;

        /*
         * Unlike supported commands, the output size of RAW commands
         * gets passed along without further checking, so it must be
         * validated here.
         */
        if (send_cmd->out.size > cxl_mbox->payload_size)
                return -EINVAL;

        if (!cxl_mem_raw_command_allowed(send_cmd->raw.opcode))
                return -EPERM;

        dev_WARN_ONCE(cxl_mbox->host, true, "raw command path used\n");

        *mem_cmd = (struct cxl_mem_command) {
                .info = {
                        .id = CXL_MEM_COMMAND_ID_RAW,
                        .size_in = send_cmd->in.size,
                        .size_out = send_cmd->out.size,
                },
                .opcode = send_cmd->raw.opcode
        };

        return 0;
}

static int cxl_to_mem_cmd(struct cxl_mem_command *mem_cmd,
                          const struct cxl_send_command *send_cmd,
                          struct cxl_mailbox *cxl_mbox)
{
        struct cxl_mem_command *c = &cxl_mem_commands[send_cmd->id];
        const struct cxl_command_info *info = &c->info;

        if (send_cmd->flags & ~CXL_MEM_COMMAND_FLAG_MASK)
                return -EINVAL;

        if (send_cmd->rsvd)
                return -EINVAL;

        if (send_cmd->in.rsvd || send_cmd->out.rsvd)
                return -EINVAL;

        /* Check that the command is enabled for hardware */
        if (!test_bit(info->id, cxl_mbox->enabled_cmds))
                return -ENOTTY;

        /* Check that the command is not claimed for exclusive kernel use */
        if (test_bit(info->id, cxl_mbox->exclusive_cmds))
                return -EBUSY;

        /* Check the input buffer is the expected size */
        if ((info->size_in != CXL_VARIABLE_PAYLOAD) &&
            (info->size_in != send_cmd->in.size))
                return -ENOMEM;

        /* Check the output buffer is at least large enough */
        if ((info->size_out != CXL_VARIABLE_PAYLOAD) &&
            (send_cmd->out.size < info->size_out))
                return -ENOMEM;

        *mem_cmd = (struct cxl_mem_command) {
                .info = {
                        .id = info->id,
                        .flags = info->flags,
                        .size_in = send_cmd->in.size,
                        .size_out = send_cmd->out.size,
                },
                .opcode = c->opcode
        };

        return 0;
}

/**
 * cxl_validate_cmd_from_user() - Check fields for CXL_MEM_SEND_COMMAND.
 * @mbox_cmd: Sanitized and populated &struct cxl_mbox_cmd.
 * @cxl_mbox: CXL mailbox context
 * @send_cmd: &struct cxl_send_command copied in from userspace.
 *
 * Return:
 *  * %0        - @out_cmd is ready to send.
 *  * %-ENOTTY  - Invalid command specified.
 *  * %-EINVAL  - Reserved fields or invalid values were used.
 *  * %-ENOMEM  - Input or output buffer wasn't sized properly.
 *  * %-EPERM   - Attempted to use a protected command.
 *  * %-EBUSY   - Kernel has claimed exclusive access to this opcode
 *
 * The result of this command is a fully validated command in @mbox_cmd that is
 * safe to send to the hardware.
 */
static int cxl_validate_cmd_from_user(struct cxl_mbox_cmd *mbox_cmd,
                                      struct cxl_mailbox *cxl_mbox,
                                      const struct cxl_send_command *send_cmd)
{
        struct cxl_mem_command mem_cmd;
        int rc;

        if (send_cmd->id == 0 || send_cmd->id >= CXL_MEM_COMMAND_ID_MAX)
                return -ENOTTY;

        /*
         * The user can never specify an input payload larger than what hardware
         * supports, but output can be arbitrarily large (simply write out as
         * much data as the hardware provides).
         */
        if (send_cmd->in.size > cxl_mbox->payload_size)
                return -EINVAL;

        /* Sanitize and construct a cxl_mem_command */
        if (send_cmd->id == CXL_MEM_COMMAND_ID_RAW)
                rc = cxl_to_mem_cmd_raw(&mem_cmd, send_cmd, cxl_mbox);
        else
                rc = cxl_to_mem_cmd(&mem_cmd, send_cmd, cxl_mbox);

        if (rc)
                return rc;

        /* Sanitize and construct a cxl_mbox_cmd */
        return cxl_mbox_cmd_ctor(mbox_cmd, cxl_mbox, mem_cmd.opcode,
                                 mem_cmd.info.size_in, mem_cmd.info.size_out,
                                 send_cmd->in.payload);
}

int cxl_query_cmd(struct cxl_mailbox *cxl_mbox,
                  struct cxl_mem_query_commands __user *q)
{
        struct device *dev = cxl_mbox->host;
        struct cxl_mem_command *cmd;
        u32 n_commands;
        int j = 0;

        dev_dbg(dev, "Query IOCTL\n");

        if (get_user(n_commands, &q->n_commands))
                return -EFAULT;

        /* returns the total number if 0 elements are requested. */
        if (n_commands == 0)
                return put_user(ARRAY_SIZE(cxl_mem_commands), &q->n_commands);

        /*
         * otherwise, return min(n_commands, total commands) cxl_command_info
         * structures.
         */
        cxl_for_each_cmd(cmd) {
                struct cxl_command_info info = cmd->info;

                if (test_bit(info.id, cxl_mbox->enabled_cmds))
                        info.flags |= CXL_MEM_COMMAND_FLAG_ENABLED;
                if (test_bit(info.id, cxl_mbox->exclusive_cmds))
                        info.flags |= CXL_MEM_COMMAND_FLAG_EXCLUSIVE;

                if (copy_to_user(&q->commands[j++], &info, sizeof(info)))
                        return -EFAULT;

                if (j == n_commands)
                        break;
        }

        return 0;
}

/**
 * handle_mailbox_cmd_from_user() - Dispatch a mailbox command for userspace.
 * @cxl_mbox: The mailbox context for the operation.
 * @mbox_cmd: The validated mailbox command.
 * @out_payload: Pointer to userspace's output payload.
 * @size_out: (Input) Max payload size to copy out.
 *            (Output) Payload size hardware generated.
 * @retval: Hardware generated return code from the operation.
 *
 * Return:
 *  * %0        - Mailbox transaction succeeded. This implies the mailbox
 *                protocol completed successfully not that the operation itself
 *                was successful.
 *  * %-ENOMEM  - Couldn't allocate a bounce buffer.
 *  * %-EFAULT  - Something happened with copy_to/from_user.
 *  * %-EINTR   - Mailbox acquisition interrupted.
 *  * %-EXXX    - Transaction level failures.
 *
 * Dispatches a mailbox command on behalf of a userspace request.
 * The output payload is copied to userspace.
 *
 * See cxl_send_cmd().
 */
static int handle_mailbox_cmd_from_user(struct cxl_mailbox *cxl_mbox,
                                        struct cxl_mbox_cmd *mbox_cmd,
                                        u64 out_payload, s32 *size_out,
                                        u32 *retval)
{
        struct device *dev = cxl_mbox->host;
        int rc;

        dev_dbg(dev,
                "Submitting %s command for user\n"
                "\topcode: %x\n"
                "\tsize: %zx\n",
                cxl_mem_opcode_to_name(mbox_cmd->opcode),
                mbox_cmd->opcode, mbox_cmd->size_in);

        rc = cxl_mbox->mbox_send(cxl_mbox, mbox_cmd);
        if (rc)
                goto out;

        /*
         * @size_out contains the max size that's allowed to be written back out
         * to userspace. While the payload may have written more output than
         * this it will have to be ignored.
         */
        if (mbox_cmd->size_out) {
                dev_WARN_ONCE(dev, mbox_cmd->size_out > *size_out,
                              "Invalid return size\n");
                if (copy_to_user(u64_to_user_ptr(out_payload),
                                 mbox_cmd->payload_out, mbox_cmd->size_out)) {
                        rc = -EFAULT;
                        goto out;
                }
        }

        *size_out = mbox_cmd->size_out;
        *retval = mbox_cmd->return_code;

out:
        cxl_mbox_cmd_dtor(mbox_cmd);
        return rc;
}

int cxl_send_cmd(struct cxl_mailbox *cxl_mbox, struct cxl_send_command __user *s)
{
        struct device *dev = cxl_mbox->host;
        struct cxl_send_command send;
        struct cxl_mbox_cmd mbox_cmd;
        int rc;

        dev_dbg(dev, "Send IOCTL\n");

        if (copy_from_user(&send, s, sizeof(send)))
                return -EFAULT;

        rc = cxl_validate_cmd_from_user(&mbox_cmd, cxl_mbox, &send);
        if (rc)
                return rc;

        rc = handle_mailbox_cmd_from_user(cxl_mbox, &mbox_cmd, send.out.payload,
                                          &send.out.size, &send.retval);
        if (rc)
                return rc;

        if (copy_to_user(s, &send, sizeof(send)))
                return -EFAULT;

        return 0;
}

static int cxl_xfer_log(struct cxl_memdev_state *mds, uuid_t *uuid,
                        u32 *size, u8 *out)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        u32 remaining = *size;
        u32 offset = 0;

        while (remaining) {
                u32 xfer_size = min_t(u32, remaining, cxl_mbox->payload_size);
                struct cxl_mbox_cmd mbox_cmd;
                struct cxl_mbox_get_log log;
                int rc;

                log = (struct cxl_mbox_get_log) {
                        .uuid = *uuid,
                        .offset = cpu_to_le32(offset),
                        .length = cpu_to_le32(xfer_size),
                };

                mbox_cmd = (struct cxl_mbox_cmd) {
                        .opcode = CXL_MBOX_OP_GET_LOG,
                        .size_in = sizeof(log),
                        .payload_in = &log,
                        .size_out = xfer_size,
                        .payload_out = out,
                };

                rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);

                /*
                 * The output payload length that indicates the number
                 * of valid bytes can be smaller than the Log buffer
                 * size.
                 */
                if (rc == -EIO && mbox_cmd.size_out < xfer_size) {
                        offset += mbox_cmd.size_out;
                        break;
                }

                if (rc < 0)
                        return rc;

                out += xfer_size;
                remaining -= xfer_size;
                offset += xfer_size;
        }

        *size = offset;

        return 0;
}

static int check_features_opcodes(u16 opcode, int *ro_cmds, int *wr_cmds)
{
        switch (opcode) {
        case CXL_MBOX_OP_GET_SUPPORTED_FEATURES:
        case CXL_MBOX_OP_GET_FEATURE:
                (*ro_cmds)++;
                return 1;
        case CXL_MBOX_OP_SET_FEATURE:
                (*wr_cmds)++;
                return 1;
        default:
                return 0;
        }
}

/* 'Get Supported Features' and 'Get Feature' */
#define MAX_FEATURES_READ_CMDS  2
static void set_features_cap(struct cxl_mailbox *cxl_mbox,
                             int ro_cmds, int wr_cmds)
{
        /* Setting up Features capability while walking the CEL */
        if (ro_cmds == MAX_FEATURES_READ_CMDS) {
                if (wr_cmds)
                        cxl_mbox->feat_cap = CXL_FEATURES_RW;
                else
                        cxl_mbox->feat_cap = CXL_FEATURES_RO;
        }
}

/**
 * cxl_walk_cel() - Walk through the Command Effects Log.
 * @mds: The driver data for the operation
 * @size: Length of the Command Effects Log.
 * @cel: CEL
 *
 * Iterate over each entry in the CEL and determine if the driver supports the
 * command. If so, the command is enabled for the device and can be used later.
 */
static void cxl_walk_cel(struct cxl_memdev_state *mds, size_t size, u8 *cel)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        struct cxl_cel_entry *cel_entry;
        const int cel_entries = size / sizeof(*cel_entry);
        struct device *dev = mds->cxlds.dev;
        int i, ro_cmds = 0, wr_cmds = 0;

        cel_entry = (struct cxl_cel_entry *) cel;

        for (i = 0; i < cel_entries; i++) {
                u16 opcode = le16_to_cpu(cel_entry[i].opcode);
                struct cxl_mem_command *cmd = cxl_mem_find_command(opcode);
                int enabled = 0;

                if (cmd) {
                        set_bit(cmd->info.id, cxl_mbox->enabled_cmds);
                        enabled++;
                }

                enabled += check_features_opcodes(opcode, &ro_cmds,
                                                  &wr_cmds);

                if (cxl_is_poison_command(opcode)) {
                        cxl_set_poison_cmd_enabled(&mds->poison, opcode);
                        enabled++;
                }

                if (cxl_is_security_command(opcode)) {
                        cxl_set_security_cmd_enabled(&mds->security, opcode);
                        enabled++;
                }

                dev_dbg(dev, "Opcode 0x%04x %s\n", opcode,
                        enabled ? "enabled" : "unsupported by driver");
        }

        set_features_cap(cxl_mbox, ro_cmds, wr_cmds);
}

static struct cxl_mbox_get_supported_logs *cxl_get_gsl(struct cxl_memdev_state *mds)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        struct cxl_mbox_get_supported_logs *ret;
        struct cxl_mbox_cmd mbox_cmd;
        int rc;

        ret = kvmalloc(cxl_mbox->payload_size, GFP_KERNEL);
        if (!ret)
                return ERR_PTR(-ENOMEM);

        mbox_cmd = (struct cxl_mbox_cmd) {
                .opcode = CXL_MBOX_OP_GET_SUPPORTED_LOGS,
                .size_out = cxl_mbox->payload_size,
                .payload_out = ret,
                /* At least the record number field must be valid */
                .min_out = 2,
        };
        rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
        if (rc < 0) {
                kvfree(ret);
                return ERR_PTR(rc);
        }


        return ret;
}

enum {
        CEL_UUID,
        VENDOR_DEBUG_UUID,
};

/* See CXL 2.0 Table 170. Get Log Input Payload */
static const uuid_t log_uuid[] = {
        [CEL_UUID] = DEFINE_CXL_CEL_UUID,
        [VENDOR_DEBUG_UUID] = DEFINE_CXL_VENDOR_DEBUG_UUID,
};

/**
 * cxl_enumerate_cmds() - Enumerate commands for a device.
 * @mds: The driver data for the operation
 *
 * Returns 0 if enumerate completed successfully.
 *
 * CXL devices have optional support for certain commands. This function will
 * determine the set of supported commands for the hardware and update the
 * enabled_cmds bitmap in the @mds.
 */
int cxl_enumerate_cmds(struct cxl_memdev_state *mds)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        struct cxl_mbox_get_supported_logs *gsl;
        struct device *dev = mds->cxlds.dev;
        struct cxl_mem_command *cmd;
        int i, rc;

        gsl = cxl_get_gsl(mds);
        if (IS_ERR(gsl))
                return PTR_ERR(gsl);

        rc = -ENOENT;
        for (i = 0; i < le16_to_cpu(gsl->entries); i++) {
                u32 size = le32_to_cpu(gsl->entry[i].size);
                uuid_t uuid = gsl->entry[i].uuid;
                u8 *log;

                dev_dbg(dev, "Found LOG type %pU of size %d", &uuid, size);

                if (!uuid_equal(&uuid, &log_uuid[CEL_UUID]))
                        continue;

                log = kvmalloc(size, GFP_KERNEL);
                if (!log) {
                        rc = -ENOMEM;
                        goto out;
                }

                rc = cxl_xfer_log(mds, &uuid, &size, log);
                if (rc) {
                        kvfree(log);
                        goto out;
                }

                cxl_walk_cel(mds, size, log);
                kvfree(log);

                /* In case CEL was bogus, enable some default commands. */
                cxl_for_each_cmd(cmd)
                        if (cmd->flags & CXL_CMD_FLAG_FORCE_ENABLE)
                                set_bit(cmd->info.id, cxl_mbox->enabled_cmds);

                /* Found the required CEL */
                rc = 0;
        }
out:
        kvfree(gsl);
        return rc;
}
EXPORT_SYMBOL_NS_GPL(cxl_enumerate_cmds, "CXL");

void cxl_event_trace_record(const struct cxl_memdev *cxlmd,
                            enum cxl_event_log_type type,
                            enum cxl_event_type event_type,
                            const uuid_t *uuid, union cxl_event *evt)
{
        if (event_type == CXL_CPER_EVENT_MEM_MODULE) {
                trace_cxl_memory_module(cxlmd, type, &evt->mem_module);
                return;
        }
        if (event_type == CXL_CPER_EVENT_GENERIC) {
                trace_cxl_generic_event(cxlmd, type, uuid, &evt->generic);
                return;
        }
        if (event_type == CXL_CPER_EVENT_MEM_SPARING) {
                trace_cxl_memory_sparing(cxlmd, type, &evt->mem_sparing);
                return;
        }

        if (trace_cxl_general_media_enabled() || trace_cxl_dram_enabled()) {
                u64 dpa, hpa = ULLONG_MAX, hpa_alias = ULLONG_MAX;
                struct cxl_region *cxlr;

                /*
                 * These trace points are annotated with HPA and region
                 * translations. Take topology mutation locks and lookup
                 * { HPA, REGION } from { DPA, MEMDEV } in the event record.
                 */
                guard(rwsem_read)(&cxl_rwsem.region);
                guard(rwsem_read)(&cxl_rwsem.dpa);

                dpa = le64_to_cpu(evt->media_hdr.phys_addr) & CXL_DPA_MASK;
                cxlr = cxl_dpa_to_region(cxlmd, dpa);
                if (cxlr) {
                        u64 cache_size = cxlr->params.cache_size;

                        hpa = cxl_dpa_to_hpa(cxlr, cxlmd, dpa);
                        if (cache_size)
                                hpa_alias = hpa - cache_size;
                }

                if (event_type == CXL_CPER_EVENT_GEN_MEDIA) {
                        if (cxl_store_rec_gen_media((struct cxl_memdev *)cxlmd, evt))
                                dev_dbg(&cxlmd->dev, "CXL store rec_gen_media failed\n");

                        if (evt->gen_media.media_hdr.descriptor &
                            CXL_GMER_EVT_DESC_THRESHOLD_EVENT)
                                WARN_ON_ONCE((evt->gen_media.media_hdr.type &
                                              CXL_GMER_MEM_EVT_TYPE_AP_CME_COUNTER_EXPIRE) &&
                                             !get_unaligned_le24(evt->gen_media.cme_count));
                        else
                                WARN_ON_ONCE(evt->gen_media.media_hdr.type &
                                             CXL_GMER_MEM_EVT_TYPE_AP_CME_COUNTER_EXPIRE);

                        trace_cxl_general_media(cxlmd, type, cxlr, hpa,
                                                hpa_alias, &evt->gen_media);
                } else if (event_type == CXL_CPER_EVENT_DRAM) {
                        if (cxl_store_rec_dram((struct cxl_memdev *)cxlmd, evt))
                                dev_dbg(&cxlmd->dev, "CXL store rec_dram failed\n");

                        if (evt->dram.media_hdr.descriptor &
                            CXL_GMER_EVT_DESC_THRESHOLD_EVENT)
                                WARN_ON_ONCE((evt->dram.media_hdr.type &
                                              CXL_DER_MEM_EVT_TYPE_AP_CME_COUNTER_EXPIRE) &&
                                             !get_unaligned_le24(evt->dram.cvme_count));
                        else
                                WARN_ON_ONCE(evt->dram.media_hdr.type &
                                             CXL_DER_MEM_EVT_TYPE_AP_CME_COUNTER_EXPIRE);

                        trace_cxl_dram(cxlmd, type, cxlr, hpa, hpa_alias,
                                       &evt->dram);
                }
        }
}
EXPORT_SYMBOL_NS_GPL(cxl_event_trace_record, "CXL");

static void __cxl_event_trace_record(const struct cxl_memdev *cxlmd,
                                     enum cxl_event_log_type type,
                                     struct cxl_event_record_raw *record)
{
        enum cxl_event_type ev_type = CXL_CPER_EVENT_GENERIC;
        const uuid_t *uuid = &record->id;

        if (uuid_equal(uuid, &CXL_EVENT_GEN_MEDIA_UUID))
                ev_type = CXL_CPER_EVENT_GEN_MEDIA;
        else if (uuid_equal(uuid, &CXL_EVENT_DRAM_UUID))
                ev_type = CXL_CPER_EVENT_DRAM;
        else if (uuid_equal(uuid, &CXL_EVENT_MEM_MODULE_UUID))
                ev_type = CXL_CPER_EVENT_MEM_MODULE;
        else if (uuid_equal(uuid, &CXL_EVENT_MEM_SPARING_UUID))
                ev_type = CXL_CPER_EVENT_MEM_SPARING;

        cxl_event_trace_record(cxlmd, type, ev_type, uuid, &record->event);
}

static int cxl_clear_event_record(struct cxl_memdev_state *mds,
                                  enum cxl_event_log_type log,
                                  struct cxl_get_event_payload *get_pl)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        struct cxl_mbox_clear_event_payload *payload;
        u16 total = le16_to_cpu(get_pl->record_count);
        u8 max_handles = CXL_CLEAR_EVENT_MAX_HANDLES;
        size_t pl_size = struct_size(payload, handles, max_handles);
        struct cxl_mbox_cmd mbox_cmd;
        u16 cnt;
        int rc = 0;
        int i;

        /* Payload size may limit the max handles */
        if (pl_size > cxl_mbox->payload_size) {
                max_handles = (cxl_mbox->payload_size - sizeof(*payload)) /
                              sizeof(__le16);
                pl_size = struct_size(payload, handles, max_handles);
        }

        payload = kvzalloc(pl_size, GFP_KERNEL);
        if (!payload)
                return -ENOMEM;

        *payload = (struct cxl_mbox_clear_event_payload) {
                .event_log = log,
        };

        mbox_cmd = (struct cxl_mbox_cmd) {
                .opcode = CXL_MBOX_OP_CLEAR_EVENT_RECORD,
                .payload_in = payload,
                .size_in = pl_size,
        };

        /*
         * Clear Event Records uses u8 for the handle cnt while Get Event
         * Record can return up to 0xffff records.
         */
        i = 0;
        for (cnt = 0; cnt < total; cnt++) {
                struct cxl_event_record_raw *raw = &get_pl->records[cnt];
                struct cxl_event_generic *gen = &raw->event.generic;

                payload->handles[i++] = gen->hdr.handle;
                dev_dbg(mds->cxlds.dev, "Event log '%d': Clearing %u\n", log,
                        le16_to_cpu(payload->handles[i - 1]));

                if (i == max_handles) {
                        payload->nr_recs = i;
                        rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
                        if (rc)
                                goto free_pl;
                        i = 0;
                }
        }

        /* Clear what is left if any */
        if (i) {
                payload->nr_recs = i;
                mbox_cmd.size_in = struct_size(payload, handles, i);
                rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
                if (rc)
                        goto free_pl;
        }

free_pl:
        kvfree(payload);
        return rc;
}

static void cxl_mem_get_records_log(struct cxl_memdev_state *mds,
                                    enum cxl_event_log_type type)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        struct cxl_memdev *cxlmd = mds->cxlds.cxlmd;
        struct device *dev = mds->cxlds.dev;
        struct cxl_get_event_payload *payload;
        u8 log_type = type;
        u16 nr_rec;

        mutex_lock(&mds->event.log_lock);
        payload = mds->event.buf;

        do {
                int rc, i;
                struct cxl_mbox_cmd mbox_cmd = (struct cxl_mbox_cmd) {
                        .opcode = CXL_MBOX_OP_GET_EVENT_RECORD,
                        .payload_in = &log_type,
                        .size_in = sizeof(log_type),
                        .payload_out = payload,
                        .size_out = cxl_mbox->payload_size,
                        .min_out = struct_size(payload, records, 0),
                };

                rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
                if (rc) {
                        dev_err_ratelimited(dev,
                                "Event log '%d': Failed to query event records : %d",
                                type, rc);
                        break;
                }

                nr_rec = le16_to_cpu(payload->record_count);
                if (!nr_rec)
                        break;

                for (i = 0; i < nr_rec; i++)
                        __cxl_event_trace_record(cxlmd, type,
                                                 &payload->records[i]);

                if (payload->flags & CXL_GET_EVENT_FLAG_OVERFLOW)
                        trace_cxl_overflow(cxlmd, type, payload);

                rc = cxl_clear_event_record(mds, type, payload);
                if (rc) {
                        dev_err_ratelimited(dev,
                                "Event log '%d': Failed to clear events : %d",
                                type, rc);
                        break;
                }
        } while (nr_rec);

        mutex_unlock(&mds->event.log_lock);
}

/**
 * cxl_mem_get_event_records - Get Event Records from the device
 * @mds: The driver data for the operation
 * @status: Event Status register value identifying which events are available.
 *
 * Retrieve all event records available on the device, report them as trace
 * events, and clear them.
 *
 * See CXL rev 3.0 @8.2.9.2.2 Get Event Records
 * See CXL rev 3.0 @8.2.9.2.3 Clear Event Records
 */
void cxl_mem_get_event_records(struct cxl_memdev_state *mds, u32 status)
{
        dev_dbg(mds->cxlds.dev, "Reading event logs: %x\n", status);

        if (status & CXLDEV_EVENT_STATUS_FATAL)
                cxl_mem_get_records_log(mds, CXL_EVENT_TYPE_FATAL);
        if (status & CXLDEV_EVENT_STATUS_FAIL)
                cxl_mem_get_records_log(mds, CXL_EVENT_TYPE_FAIL);
        if (status & CXLDEV_EVENT_STATUS_WARN)
                cxl_mem_get_records_log(mds, CXL_EVENT_TYPE_WARN);
        if (status & CXLDEV_EVENT_STATUS_INFO)
                cxl_mem_get_records_log(mds, CXL_EVENT_TYPE_INFO);
}
EXPORT_SYMBOL_NS_GPL(cxl_mem_get_event_records, "CXL");

/**
 * cxl_mem_get_partition_info - Get partition info
 * @mds: The driver data for the operation
 *
 * Retrieve the current partition info for the device specified.  The active
 * values are the current capacity in bytes.  If not 0, the 'next' values are
 * the pending values, in bytes, which take affect on next cold reset.
 *
 * Return: 0 if no error: or the result of the mailbox command.
 *
 * See CXL @8.2.9.5.2.1 Get Partition Info
 */
static int cxl_mem_get_partition_info(struct cxl_memdev_state *mds)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        struct cxl_mbox_get_partition_info pi;
        struct cxl_mbox_cmd mbox_cmd;
        int rc;

        mbox_cmd = (struct cxl_mbox_cmd) {
                .opcode = CXL_MBOX_OP_GET_PARTITION_INFO,
                .size_out = sizeof(pi),
                .payload_out = &pi,
        };
        rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
        if (rc)
                return rc;

        mds->active_volatile_bytes =
                le64_to_cpu(pi.active_volatile_cap) * CXL_CAPACITY_MULTIPLIER;
        mds->active_persistent_bytes =
                le64_to_cpu(pi.active_persistent_cap) * CXL_CAPACITY_MULTIPLIER;

        return 0;
}

/**
 * cxl_dev_state_identify() - Send the IDENTIFY command to the device.
 * @mds: The driver data for the operation
 *
 * Return: 0 if identify was executed successfully or media not ready.
 *
 * This will dispatch the identify command to the device and on success populate
 * structures to be exported to sysfs.
 */
int cxl_dev_state_identify(struct cxl_memdev_state *mds)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        /* See CXL 2.0 Table 175 Identify Memory Device Output Payload */
        struct cxl_mbox_identify id;
        struct cxl_mbox_cmd mbox_cmd;
        u32 val;
        int rc;

        if (!mds->cxlds.media_ready)
                return 0;

        mbox_cmd = (struct cxl_mbox_cmd) {
                .opcode = CXL_MBOX_OP_IDENTIFY,
                .size_out = sizeof(id),
                .payload_out = &id,
        };
        rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
        if (rc < 0)
                return rc;

        mds->total_bytes =
                le64_to_cpu(id.total_capacity) * CXL_CAPACITY_MULTIPLIER;
        mds->volatile_only_bytes =
                le64_to_cpu(id.volatile_capacity) * CXL_CAPACITY_MULTIPLIER;
        mds->persistent_only_bytes =
                le64_to_cpu(id.persistent_capacity) * CXL_CAPACITY_MULTIPLIER;
        mds->partition_align_bytes =
                le64_to_cpu(id.partition_align) * CXL_CAPACITY_MULTIPLIER;

        mds->lsa_size = le32_to_cpu(id.lsa_size);
        memcpy(mds->firmware_version, id.fw_revision,
               sizeof(id.fw_revision));

        if (test_bit(CXL_POISON_ENABLED_LIST, mds->poison.enabled_cmds)) {
                val = get_unaligned_le24(id.poison_list_max_mer);
                mds->poison.max_errors = min_t(u32, val, CXL_POISON_LIST_MAX);
        }

        return 0;
}
EXPORT_SYMBOL_NS_GPL(cxl_dev_state_identify, "CXL");

static int __cxl_mem_sanitize(struct cxl_memdev_state *mds, u16 cmd)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        int rc;
        u32 sec_out = 0;
        struct cxl_get_security_output {
                __le32 flags;
        } out;
        struct cxl_mbox_cmd sec_cmd = {
                .opcode = CXL_MBOX_OP_GET_SECURITY_STATE,
                .payload_out = &out,
                .size_out = sizeof(out),
        };
        struct cxl_mbox_cmd mbox_cmd = { .opcode = cmd };

        if (cmd != CXL_MBOX_OP_SANITIZE && cmd != CXL_MBOX_OP_SECURE_ERASE)
                return -EINVAL;

        rc = cxl_internal_send_cmd(cxl_mbox, &sec_cmd);
        if (rc < 0) {
                dev_err(cxl_mbox->host, "Failed to get security state : %d", rc);
                return rc;
        }

        /*
         * Prior to using these commands, any security applied to
         * the user data areas of the device shall be DISABLED (or
         * UNLOCKED for secure erase case).
         */
        sec_out = le32_to_cpu(out.flags);
        if (sec_out & CXL_PMEM_SEC_STATE_USER_PASS_SET)
                return -EINVAL;

        if (cmd == CXL_MBOX_OP_SECURE_ERASE &&
            sec_out & CXL_PMEM_SEC_STATE_LOCKED)
                return -EINVAL;

        rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
        if (rc < 0) {
                dev_err(cxl_mbox->host, "Failed to sanitize device : %d", rc);
                return rc;
        }

        return 0;
}


/**
 * cxl_mem_sanitize() - Send a sanitization command to the device.
 * @cxlmd: The device for the operation
 * @cmd: The specific sanitization command opcode
 *
 * Return: 0 if the command was executed successfully, regardless of
 * whether or not the actual security operation is done in the background,
 * such as for the Sanitize case.
 * Error return values can be the result of the mailbox command, -EINVAL
 * when security requirements are not met or invalid contexts, or -EBUSY
 * if the sanitize operation is already in flight.
 *
 * See CXL 3.0 @8.2.9.8.5.1 Sanitize and @8.2.9.8.5.2 Secure Erase.
 */
int cxl_mem_sanitize(struct cxl_memdev *cxlmd, u16 cmd)
{
        struct cxl_memdev_state *mds = to_cxl_memdev_state(cxlmd->cxlds);
        struct cxl_port  *endpoint;

        /* synchronize with cxl_mem_probe() and decoder write operations */
        guard(device)(&cxlmd->dev);
        endpoint = cxlmd->endpoint;
        guard(rwsem_read)(&cxl_rwsem.region);
        /*
         * Require an endpoint to be safe otherwise the driver can not
         * be sure that the device is unmapped.
         */
        if (cxlmd->dev.driver && cxl_num_decoders_committed(endpoint) == 0)
                return __cxl_mem_sanitize(mds, cmd);

        return -EBUSY;
}

static void add_part(struct cxl_dpa_info *info, u64 start, u64 size, enum cxl_partition_mode mode)
{
        int i = info->nr_partitions;

        if (size == 0)
                return;

        info->part[i].range = (struct range) {
                .start = start,
                .end = start + size - 1,
        };
        info->part[i].mode = mode;
        info->nr_partitions++;
}

int cxl_mem_dpa_fetch(struct cxl_memdev_state *mds, struct cxl_dpa_info *info)
{
        struct cxl_dev_state *cxlds = &mds->cxlds;
        struct device *dev = cxlds->dev;
        int rc;

        if (!cxlds->media_ready) {
                info->size = 0;
                return 0;
        }

        info->size = mds->total_bytes;

        if (mds->partition_align_bytes == 0) {
                add_part(info, 0, mds->volatile_only_bytes, CXL_PARTMODE_RAM);
                add_part(info, mds->volatile_only_bytes,
                         mds->persistent_only_bytes, CXL_PARTMODE_PMEM);
                return 0;
        }

        rc = cxl_mem_get_partition_info(mds);
        if (rc) {
                dev_err(dev, "Failed to query partition information\n");
                return rc;
        }

        add_part(info, 0, mds->active_volatile_bytes, CXL_PARTMODE_RAM);
        add_part(info, mds->active_volatile_bytes, mds->active_persistent_bytes,
                 CXL_PARTMODE_PMEM);

        return 0;
}
EXPORT_SYMBOL_NS_GPL(cxl_mem_dpa_fetch, "CXL");

int cxl_get_dirty_count(struct cxl_memdev_state *mds, u32 *count)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        struct cxl_mbox_get_health_info_out hi;
        struct cxl_mbox_cmd mbox_cmd;
        int rc;

        mbox_cmd = (struct cxl_mbox_cmd) {
                .opcode = CXL_MBOX_OP_GET_HEALTH_INFO,
                .size_out = sizeof(hi),
                .payload_out = &hi,
        };

        rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
        if (!rc)
                *count = le32_to_cpu(hi.dirty_shutdown_cnt);

        return rc;
}
EXPORT_SYMBOL_NS_GPL(cxl_get_dirty_count, "CXL");

int cxl_arm_dirty_shutdown(struct cxl_memdev_state *mds)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        struct cxl_mbox_cmd mbox_cmd;
        struct cxl_mbox_set_shutdown_state_in in = {
                .state = 1
        };

        mbox_cmd = (struct cxl_mbox_cmd) {
                .opcode = CXL_MBOX_OP_SET_SHUTDOWN_STATE,
                .size_in = sizeof(in),
                .payload_in = &in,
        };

        return cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
}
EXPORT_SYMBOL_NS_GPL(cxl_arm_dirty_shutdown, "CXL");

int cxl_set_timestamp(struct cxl_memdev_state *mds)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;
        struct cxl_mbox_cmd mbox_cmd;
        struct cxl_mbox_set_timestamp_in pi;
        int rc;

        pi.timestamp = cpu_to_le64(ktime_get_real_ns());
        mbox_cmd = (struct cxl_mbox_cmd) {
                .opcode = CXL_MBOX_OP_SET_TIMESTAMP,
                .size_in = sizeof(pi),
                .payload_in = &pi,
        };

        rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
        /*
         * Command is optional. Devices may have another way of providing
         * a timestamp, or may return all 0s in timestamp fields.
         * Don't report an error if this command isn't supported
         */
        if (rc && (mbox_cmd.return_code != CXL_MBOX_CMD_RC_UNSUPPORTED))
                return rc;

        return 0;
}
EXPORT_SYMBOL_NS_GPL(cxl_set_timestamp, "CXL");

int cxl_mem_get_poison(struct cxl_memdev *cxlmd, u64 offset, u64 len,
                       struct cxl_region *cxlr)
{
        struct cxl_memdev_state *mds = to_cxl_memdev_state(cxlmd->cxlds);
        struct cxl_mailbox *cxl_mbox = &cxlmd->cxlds->cxl_mbox;
        struct cxl_mbox_poison_out *po;
        struct cxl_mbox_poison_in pi;
        int nr_records = 0;
        int rc;

        ACQUIRE(mutex_intr, lock)(&mds->poison.mutex);
        if ((rc = ACQUIRE_ERR(mutex_intr, &lock)))
                return rc;

        po = mds->poison.list_out;
        pi.offset = cpu_to_le64(offset);
        pi.length = cpu_to_le64(len / CXL_POISON_LEN_MULT);

        do {
                struct cxl_mbox_cmd mbox_cmd = (struct cxl_mbox_cmd){
                        .opcode = CXL_MBOX_OP_GET_POISON,
                        .size_in = sizeof(pi),
                        .payload_in = &pi,
                        .size_out = cxl_mbox->payload_size,
                        .payload_out = po,
                        .min_out = struct_size(po, record, 0),
                };

                rc = cxl_internal_send_cmd(cxl_mbox, &mbox_cmd);
                if (rc)
                        break;

                for (int i = 0; i < le16_to_cpu(po->count); i++)
                        trace_cxl_poison(cxlmd, cxlr, &po->record[i],
                                         po->flags, po->overflow_ts,
                                         CXL_POISON_TRACE_LIST);

                /* Protect against an uncleared _FLAG_MORE */
                nr_records = nr_records + le16_to_cpu(po->count);
                if (nr_records >= mds->poison.max_errors) {
                        dev_dbg(&cxlmd->dev, "Max Error Records reached: %d\n",
                                nr_records);
                        break;
                }
        } while (po->flags & CXL_POISON_FLAG_MORE);

        return rc;
}
EXPORT_SYMBOL_NS_GPL(cxl_mem_get_poison, "CXL");

static void free_poison_buf(void *buf)
{
        kvfree(buf);
}

/* Get Poison List output buffer is protected by mds->poison.lock */
static int cxl_poison_alloc_buf(struct cxl_memdev_state *mds)
{
        struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox;

        mds->poison.list_out = kvmalloc(cxl_mbox->payload_size, GFP_KERNEL);
        if (!mds->poison.list_out)
                return -ENOMEM;

        return devm_add_action_or_reset(mds->cxlds.dev, free_poison_buf,
                                        mds->poison.list_out);
}

int cxl_poison_state_init(struct cxl_memdev_state *mds)
{
        int rc;

        if (!test_bit(CXL_POISON_ENABLED_LIST, mds->poison.enabled_cmds))
                return 0;

        rc = cxl_poison_alloc_buf(mds);
        if (rc) {
                clear_bit(CXL_POISON_ENABLED_LIST, mds->poison.enabled_cmds);
                return rc;
        }

        mutex_init(&mds->poison.mutex);
        return 0;
}
EXPORT_SYMBOL_NS_GPL(cxl_poison_state_init, "CXL");

int cxl_mailbox_init(struct cxl_mailbox *cxl_mbox, struct device *host)
{
        if (!cxl_mbox || !host)
                return -EINVAL;

        cxl_mbox->host = host;
        mutex_init(&cxl_mbox->mbox_mutex);
        rcuwait_init(&cxl_mbox->mbox_wait);

        return 0;
}
EXPORT_SYMBOL_NS_GPL(cxl_mailbox_init, "CXL");

struct cxl_memdev_state *cxl_memdev_state_create(struct device *dev)
{
        struct cxl_memdev_state *mds;
        int rc;

        mds = devm_kzalloc(dev, sizeof(*mds), GFP_KERNEL);
        if (!mds) {
                dev_err(dev, "No memory available\n");
                return ERR_PTR(-ENOMEM);
        }

        mutex_init(&mds->event.log_lock);
        mds->cxlds.dev = dev;
        mds->cxlds.reg_map.host = dev;
        mds->cxlds.cxl_mbox.host = dev;
        mds->cxlds.reg_map.resource = CXL_RESOURCE_NONE;
        mds->cxlds.type = CXL_DEVTYPE_CLASSMEM;

        rc = devm_cxl_register_mce_notifier(dev, &mds->mce_notifier);
        if (rc == -EOPNOTSUPP)
                dev_warn(dev, "CXL MCE unsupported\n");
        else if (rc)
                return ERR_PTR(rc);

        return mds;
}
EXPORT_SYMBOL_NS_GPL(cxl_memdev_state_create, "CXL");

void __init cxl_mbox_init(void)
{
        struct dentry *mbox_debugfs;

        mbox_debugfs = cxl_debugfs_create_dir("mbox");
        debugfs_create_bool("raw_allow_all", 0600, mbox_debugfs,
                            &cxl_raw_allow_all);
}