/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2024 Oxide Computer Company
 */

/*
 * This file implements the firmware download and commit pieces of libnvme.
 */

#include <string.h>
#include <unistd.h>

#include "libnvme_impl.h"

static const nvme_field_check_t nvme_fw_load_check_numd = {
        nvme_fw_load_fields, NVME_FW_LOAD_REQ_FIELD_NUMD,
        NVME_ERR_FW_LOAD_LEN_RANGE, 0, 0
};

static const nvme_field_check_t nvme_fw_load_check_offset = {
        nvme_fw_load_fields, NVME_FW_LOAD_REQ_FIELD_OFFSET,
        NVME_ERR_FW_LOAD_OFFSET_RANGE, 0, 0
};

bool
nvme_fw_load(nvme_ctrl_t *ctrl, const void *buf, size_t len, uint64_t off)
{
        nvme_ioctl_fw_load_t fw;
        nvme_valid_ctrl_data_t data;

        if (buf == NULL) {
                return (nvme_ctrl_error(ctrl, NVME_ERR_BAD_PTR, 0,
                    "encountered invalid data buffer pointer: %p", buf));
        }

        data.vcd_vers = &ctrl->nc_vers;
        data.vcd_id = &ctrl->nc_info;

        if (!nvme_fw_cmds_supported(&data)) {
                return (nvme_ctrl_error(ctrl, NVME_ERR_FW_UNSUP_BY_DEV, 0,
                    "controller does not support firmware download"));
        }

        if (!nvme_field_check_one(ctrl, len, "firmware download",
            &nvme_fw_load_check_numd, 0)) {
                return (false);
        }

        if (!nvme_field_check_one(ctrl, off, "firmware download",
            &nvme_fw_load_check_offset, 0)) {
                return (false);
        }

        (void) memset(&fw, 0, sizeof (fw));
        fw.fwl_buf = (uintptr_t)buf;
        fw.fwl_len = len;
        fw.fwl_off = off;

        if (ioctl(ctrl->nc_fd, NVME_IOC_FIRMWARE_DOWNLOAD, &fw) != 0) {
                int e = errno;
                return (nvme_ioctl_syserror(ctrl, e, "firmware load"));
        }

        if (fw.fwl_common.nioc_drv_err != NVME_IOCTL_E_OK) {
                return (nvme_ioctl_error(ctrl, &fw.fwl_common,
                    "firmware load"));
        }

        return (nvme_ctrl_success(ctrl));
}

void
nvme_fw_commit_req_fini(nvme_fw_commit_req_t *req)
{
        free(req);
}

bool
nvme_fw_commit_req_init(nvme_ctrl_t *ctrl, nvme_fw_commit_req_t **reqp)
{
        nvme_fw_commit_req_t *req;
        nvme_valid_ctrl_data_t data;

        if (reqp == NULL) {
                return (nvme_ctrl_error(ctrl, NVME_ERR_BAD_PTR, 0,
                    "encountered invalid nvme_commit_req_t output pointer: %p",
                    reqp));
        }

        data.vcd_vers = &ctrl->nc_vers;
        data.vcd_id = &ctrl->nc_info;

        if (!nvme_fw_cmds_supported(&data)) {
                return (nvme_ctrl_error(ctrl, NVME_ERR_FW_UNSUP_BY_DEV, 0,
                    "controller does not support firmware download"));
        }

        req = calloc(1, sizeof (nvme_fw_commit_req_t));
        if (req == NULL) {
                int e = errno;
                return (nvme_ctrl_error(ctrl, NVME_ERR_NO_MEM, e, "failed to "
                    "allocate memory for a new nvme_log_req_t: %s",
                    strerror(e)));
        }

        req->fwc_ctrl = ctrl;

        for (size_t i = 0; i < nvme_fw_commit_nfields; i++) {
                if (nvme_fw_commit_fields[i].nlfi_def_req) {
                        req->fwc_need |= 1 << i;
                }
        }

        *reqp = req;
        return (nvme_ctrl_success(ctrl));
}

static void
nvme_fw_commit_req_clear_need(nvme_fw_commit_req_t *req,
    nvme_fw_commit_req_field_t field)
{
        req->fwc_need &= ~(1 << field);
}

static const nvme_field_check_t nvme_fw_commit_check_slot = {
        nvme_fw_commit_fields, NVME_FW_COMMIT_REQ_FIELD_SLOT,
        NVME_ERR_FW_COMMIT_SLOT_RANGE, 0, 0
};

bool
nvme_fw_commit_req_set_slot(nvme_fw_commit_req_t *req, uint32_t slot)
{
        if (!nvme_field_check_one(req->fwc_ctrl, slot, "firmware commit",
            &nvme_fw_commit_check_slot, 0)) {
                return (false);
        }

        req->fwc_slot = slot;
        nvme_fw_commit_req_clear_need(req, NVME_FW_COMMIT_REQ_FIELD_SLOT);
        return (nvme_ctrl_success(req->fwc_ctrl));
}

static const nvme_field_check_t nvme_fw_commit_check_act = {
        nvme_fw_commit_fields, NVME_FW_COMMIT_REQ_FIELD_ACT,
        NVME_ERR_FW_COMMIT_ACTION_RANGE, 0, 0
};

bool
nvme_fw_commit_req_set_action(nvme_fw_commit_req_t *req, uint32_t act)
{
        if (!nvme_field_check_one(req->fwc_ctrl, act, "firmware commit",
            &nvme_fw_commit_check_act, 0)) {
                return (false);
        }

        req->fwc_action = act;
        nvme_fw_commit_req_clear_need(req, NVME_FW_COMMIT_REQ_FIELD_ACT);
        return (nvme_ctrl_success(req->fwc_ctrl));
}

bool
nvme_fw_commit_req_exec(nvme_fw_commit_req_t *req)
{
        nvme_ctrl_t *ctrl = req->fwc_ctrl;
        nvme_ioctl_fw_commit_t fw;

        if (req->fwc_need != 0) {
                return (nvme_field_miss_err(ctrl, nvme_fw_commit_fields,
                    nvme_fw_commit_nfields,
                    NVME_ERR_FW_COMMIT_REQ_MISSING_FIELDS, "firmware commit",
                    req->fwc_need));
        }

        (void) memset(&fw, 0, sizeof (fw));
        fw.fwc_slot = req->fwc_slot;
        fw.fwc_action = req->fwc_action;

        if (ioctl(ctrl->nc_fd, NVME_IOC_FIRMWARE_COMMIT, &fw) != 0) {
                int e = errno;
                return (nvme_ioctl_syserror(ctrl, e, "firmware commit"));
        }

        if (fw.fwc_common.nioc_drv_err != NVME_IOCTL_E_OK) {
                return (nvme_ioctl_error(ctrl, &fw.fwc_common,
                    "firmware commit"));
        }

        return (nvme_ctrl_success(ctrl));
}