2 files changed, 360 insertions, 28 deletions

diff --git a/tools/testing/nvdimm/test/nfit.c b/tools/testing/nvdimm/test/nfit.c
index 2b57254342aa..a043fea4d58d 100644
--- a/tools/testing/nvdimm/test/nfit.c
+++ b/tools/testing/nvdimm/test/nfit.c
@@ -137,6 +137,14 @@ static u32 handle[] = {
 
 static unsigned long dimm_fail_cmd_flags[NUM_DCR];
 
+struct nfit_test_fw {
+        enum intel_fw_update_state state;
+        u32 context;
+        u64 version;
+        u32 size_received;
+        u64 end_time;
+};
+
 struct nfit_test {
         struct acpi_nfit_desc acpi_desc;
         struct platform_device pdev;
@@ -172,6 +180,7 @@ struct nfit_test {
         struct nd_intel_smart_threshold *smart_threshold;
         struct badrange badrange;
         struct work_struct work;
+        struct nfit_test_fw *fw;
 };
 
 static struct workqueue_struct *nfit_wq;
@@ -183,6 +192,226 @@ static struct nfit_test *to_nfit_test(struct device *dev)
         return container_of(pdev, struct nfit_test, pdev);
 }
 
+static int nd_intel_test_get_fw_info(struct nfit_test *t,
+                struct nd_intel_fw_info *nd_cmd, unsigned int buf_len,
+                int idx)
+{
+        struct device *dev = &t->pdev.dev;
+        struct nfit_test_fw *fw = &t->fw[idx];
+
+        dev_dbg(dev, "%s(nfit_test: %p nd_cmd: %p, buf_len: %u, idx: %d\n",
+                        __func__, t, nd_cmd, buf_len, idx);
+
+        if (buf_len < sizeof(*nd_cmd))
+                return -EINVAL;
+
+        nd_cmd->status = 0;
+        nd_cmd->storage_size = INTEL_FW_STORAGE_SIZE;
+        nd_cmd->max_send_len = INTEL_FW_MAX_SEND_LEN;
+        nd_cmd->query_interval = INTEL_FW_QUERY_INTERVAL;
+        nd_cmd->max_query_time = INTEL_FW_QUERY_MAX_TIME;
+        nd_cmd->update_cap = 0;
+        nd_cmd->fis_version = INTEL_FW_FIS_VERSION;
+        nd_cmd->run_version = 0;
+        nd_cmd->updated_version = fw->version;
+
+        return 0;
+}
+
+static int nd_intel_test_start_update(struct nfit_test *t,
+                struct nd_intel_fw_start *nd_cmd, unsigned int buf_len,
+                int idx)
+{
+        struct device *dev = &t->pdev.dev;
+        struct nfit_test_fw *fw = &t->fw[idx];
+
+        dev_dbg(dev, "%s(nfit_test: %p nd_cmd: %p buf_len: %u idx: %d)\n",
+                        __func__, t, nd_cmd, buf_len, idx);
+
+        if (buf_len < sizeof(*nd_cmd))
+                return -EINVAL;
+
+        if (fw->state != FW_STATE_NEW) {
+                /* extended status, FW update in progress */
+                nd_cmd->status = 0x10007;
+                return 0;
+        }
+
+        fw->state = FW_STATE_IN_PROGRESS;
+        fw->context++;
+        fw->size_received = 0;
+        nd_cmd->status = 0;
+        nd_cmd->context = fw->context;
+
+        dev_dbg(dev, "%s: context issued: %#x\n", __func__, nd_cmd->context);
+
+        return 0;
+}
+
+static int nd_intel_test_send_data(struct nfit_test *t,
+                struct nd_intel_fw_send_data *nd_cmd, unsigned int buf_len,
+                int idx)
+{
+        struct device *dev = &t->pdev.dev;
+        struct nfit_test_fw *fw = &t->fw[idx];
+        u32 *status = (u32 *)&nd_cmd->data[nd_cmd->length];
+
+        dev_dbg(dev, "%s(nfit_test: %p nd_cmd: %p buf_len: %u idx: %d)\n",
+                        __func__, t, nd_cmd, buf_len, idx);
+
+        if (buf_len < sizeof(*nd_cmd))
+                return -EINVAL;
+
+
+        dev_dbg(dev, "%s: cmd->status: %#x\n", __func__, *status);
+        dev_dbg(dev, "%s: cmd->data[0]: %#x\n", __func__, nd_cmd->data[0]);
+        dev_dbg(dev, "%s: cmd->data[%u]: %#x\n", __func__, nd_cmd->length-1,
+                        nd_cmd->data[nd_cmd->length-1]);
+
+        if (fw->state != FW_STATE_IN_PROGRESS) {
+                dev_dbg(dev, "%s: not in IN_PROGRESS state\n", __func__);
+                *status = 0x5;
+                return 0;
+        }
+
+        if (nd_cmd->context != fw->context) {
+                dev_dbg(dev, "%s: incorrect context: in: %#x correct: %#x\n",
+                                __func__, nd_cmd->context, fw->context);
+                *status = 0x10007;
+                return 0;
+        }
+
+        /*
+         * check offset + len > size of fw storage
+         * check length is > max send length
+         */
+        if (nd_cmd->offset + nd_cmd->length > INTEL_FW_STORAGE_SIZE ||
+                        nd_cmd->length > INTEL_FW_MAX_SEND_LEN) {
+                *status = 0x3;
+                dev_dbg(dev, "%s: buffer boundary violation\n", __func__);
+                return 0;
+        }
+
+        fw->size_received += nd_cmd->length;
+        dev_dbg(dev, "%s: copying %u bytes, %u bytes so far\n",
+                        __func__, nd_cmd->length, fw->size_received);
+        *status = 0;
+        return 0;
+}
+
+static int nd_intel_test_finish_fw(struct nfit_test *t,
+                struct nd_intel_fw_finish_update *nd_cmd,
+                unsigned int buf_len, int idx)
+{
+        struct device *dev = &t->pdev.dev;
+        struct nfit_test_fw *fw = &t->fw[idx];
+
+        dev_dbg(dev, "%s(nfit_test: %p nd_cmd: %p buf_len: %u idx: %d)\n",
+                        __func__, t, nd_cmd, buf_len, idx);
+
+        if (fw->state == FW_STATE_UPDATED) {
+                /* update already done, need cold boot */
+                nd_cmd->status = 0x20007;
+                return 0;
+        }
+
+        dev_dbg(dev, "%s: context: %#x  ctrl_flags: %#x\n",
+                        __func__, nd_cmd->context, nd_cmd->ctrl_flags);
+
+        switch (nd_cmd->ctrl_flags) {
+        case 0: /* finish */
+                if (nd_cmd->context != fw->context) {
+                        dev_dbg(dev, "%s: incorrect context: in: %#x correct: %#x\n",
+                                        __func__, nd_cmd->context,
+                                        fw->context);
+                        nd_cmd->status = 0x10007;
+                        return 0;
+                }
+                nd_cmd->status = 0;
+                fw->state = FW_STATE_VERIFY;
+                /* set 1 second of time for firmware "update" */
+                fw->end_time = jiffies + HZ;
+                break;
+
+        case 1: /* abort */
+                fw->size_received = 0;
+                /* successfully aborted status */
+                nd_cmd->status = 0x40007;
+                fw->state = FW_STATE_NEW;
+                dev_dbg(dev, "%s: abort successful\n", __func__);
+                break;
+
+        default: /* bad control flag */
+                dev_warn(dev, "%s: unknown control flag: %#x\n",
+                                __func__, nd_cmd->ctrl_flags);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int nd_intel_test_finish_query(struct nfit_test *t,
+                struct nd_intel_fw_finish_query *nd_cmd,
+                unsigned int buf_len, int idx)
+{
+        struct device *dev = &t->pdev.dev;
+        struct nfit_test_fw *fw = &t->fw[idx];
+
+        dev_dbg(dev, "%s(nfit_test: %p nd_cmd: %p buf_len: %u idx: %d)\n",
+                        __func__, t, nd_cmd, buf_len, idx);
+
+        if (buf_len < sizeof(*nd_cmd))
+                return -EINVAL;
+
+        if (nd_cmd->context != fw->context) {
+                dev_dbg(dev, "%s: incorrect context: in: %#x correct: %#x\n",
+                                __func__, nd_cmd->context, fw->context);
+                nd_cmd->status = 0x10007;
+                return 0;
+        }
+
+        dev_dbg(dev, "%s context: %#x\n", __func__, nd_cmd->context);
+
+        switch (fw->state) {
+        case FW_STATE_NEW:
+                nd_cmd->updated_fw_rev = 0;
+                nd_cmd->status = 0;
+                dev_dbg(dev, "%s: new state\n", __func__);
+                break;
+
+        case FW_STATE_IN_PROGRESS:
+                /* sequencing error */
+                nd_cmd->status = 0x40007;
+                nd_cmd->updated_fw_rev = 0;
+                dev_dbg(dev, "%s: sequence error\n", __func__);
+                break;
+
+        case FW_STATE_VERIFY:
+                if (time_is_after_jiffies64(fw->end_time)) {
+                        nd_cmd->updated_fw_rev = 0;
+                        nd_cmd->status = 0x20007;
+                        dev_dbg(dev, "%s: still verifying\n", __func__);
+                        break;
+                }
+
+                dev_dbg(dev, "%s: transition out verify\n", __func__);
+                fw->state = FW_STATE_UPDATED;
+                /* we are going to fall through if it's "done" */
+        case FW_STATE_UPDATED:
+                nd_cmd->status = 0;
+                /* bogus test version */
+                fw->version = nd_cmd->updated_fw_rev =
+                        INTEL_FW_FAKE_VERSION;
+                dev_dbg(dev, "%s: updated\n", __func__);
+                break;
+
+        default: /* we should never get here */
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static int nfit_test_cmd_get_config_size(struct nd_cmd_get_config_size *nd_cmd,
                 unsigned int buf_len)
 {
@@ -592,6 +821,23 @@ static int nfit_test_cmd_ars_inject_status(struct nfit_test *t,
         return 0;
 }
 
+static int get_dimm(struct nfit_mem *nfit_mem, unsigned int func)
+{
+        int i;
+
+        /* lookup per-dimm data */
+        for (i = 0; i < ARRAY_SIZE(handle); i++)
+                if (__to_nfit_memdev(nfit_mem)->device_handle == handle[i])
+                        break;
+        if (i >= ARRAY_SIZE(handle))
+                return -ENXIO;
+
+        if ((1 << func) & dimm_fail_cmd_flags[i])
+                return -EIO;
+
+        return i;
+}
+
 static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
                 struct nvdimm *nvdimm, unsigned int cmd, void *buf,
                 unsigned int buf_len, int *cmd_rc)
@@ -620,22 +866,54 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
                         func = call_pkg->nd_command;
                         if (call_pkg->nd_family != nfit_mem->family)
                                 return -ENOTTY;
+
+                        i = get_dimm(nfit_mem, func);
+                        if (i < 0)
+                                return i;
+
+                        switch (func) {
+                        case ND_INTEL_FW_GET_INFO:
+                                return nd_intel_test_get_fw_info(t, buf,
+                                                buf_len, i - t->dcr_idx);
+                        case ND_INTEL_FW_START_UPDATE:
+                                return nd_intel_test_start_update(t, buf,
+                                                buf_len, i - t->dcr_idx);
+                        case ND_INTEL_FW_SEND_DATA:
+                                return nd_intel_test_send_data(t, buf,
+                                                buf_len, i - t->dcr_idx);
+                        case ND_INTEL_FW_FINISH_UPDATE:
+                                return nd_intel_test_finish_fw(t, buf,
+                                                buf_len, i - t->dcr_idx);
+                        case ND_INTEL_FW_FINISH_QUERY:
+                                return nd_intel_test_finish_query(t, buf,
+                                                buf_len, i - t->dcr_idx);
+                        case ND_INTEL_SMART:
+                                return nfit_test_cmd_smart(buf, buf_len,
+                                                &t->smart[i - t->dcr_idx]);
+                        case ND_INTEL_SMART_THRESHOLD:
+                                return nfit_test_cmd_smart_threshold(buf,
+                                                buf_len,
+                                                &t->smart_threshold[i -
+                                                        t->dcr_idx]);
+                        case ND_INTEL_SMART_SET_THRESHOLD:
+                                return nfit_test_cmd_smart_set_threshold(buf,
+                                                buf_len,
+                                                &t->smart_threshold[i -
+                                                        t->dcr_idx],
+                                                &t->smart[i - t->dcr_idx],
+                                                &t->pdev.dev, t->dimm_dev[i]);
+                        default:
+                                return -ENOTTY;
+                        }
                 }
 
                 if (!test_bit(cmd, &cmd_mask)
                                 || !test_bit(func, &nfit_mem->dsm_mask))
                         return -ENOTTY;
 
-                /* lookup per-dimm data */
-                for (i = 0; i < ARRAY_SIZE(handle); i++)
-                        if (__to_nfit_memdev(nfit_mem)->device_handle ==
-                                        handle[i])
-                                break;
-                if (i >= ARRAY_SIZE(handle))
-                        return -ENXIO;
-
-                if ((1 << func) & dimm_fail_cmd_flags[i])
-                        return -EIO;
+                i = get_dimm(nfit_mem, func);
+                if (i < 0)
+                        return i;
 
                 switch (func) {
                 case ND_CMD_GET_CONFIG_SIZE:
@@ -649,20 +927,6 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
                         rc = nfit_test_cmd_set_config_data(buf, buf_len,
                                 t->label[i - t->dcr_idx]);
                         break;
-                case ND_INTEL_SMART:
-                        rc = nfit_test_cmd_smart(buf, buf_len,
-                                        &t->smart[i - t->dcr_idx]);
-                        break;
-                case ND_INTEL_SMART_THRESHOLD:
-                        rc = nfit_test_cmd_smart_threshold(buf, buf_len,
-                                        &t->smart_threshold[i - t->dcr_idx]);
-                        break;
-                case ND_INTEL_SMART_SET_THRESHOLD:
-                        rc = nfit_test_cmd_smart_set_threshold(buf, buf_len,
-                                        &t->smart_threshold[i - t->dcr_idx],
-                                        &t->smart[i - t->dcr_idx],
-                                        &t->pdev.dev, t->dimm_dev[i]);
-                        break;
                 default:
                         return -ENOTTY;
                 }
@@ -1728,6 +1992,11 @@ static void nfit_test0_setup(struct nfit_test *t)
         set_bit(NFIT_CMD_ARS_INJECT_SET, &acpi_desc->bus_nfit_cmd_force_en);
         set_bit(NFIT_CMD_ARS_INJECT_CLEAR, &acpi_desc->bus_nfit_cmd_force_en);
         set_bit(NFIT_CMD_ARS_INJECT_GET, &acpi_desc->bus_nfit_cmd_force_en);
+        set_bit(ND_INTEL_FW_GET_INFO, &acpi_desc->dimm_cmd_force_en);
+        set_bit(ND_INTEL_FW_START_UPDATE, &acpi_desc->dimm_cmd_force_en);
+        set_bit(ND_INTEL_FW_SEND_DATA, &acpi_desc->dimm_cmd_force_en);
+        set_bit(ND_INTEL_FW_FINISH_UPDATE, &acpi_desc->dimm_cmd_force_en);
+        set_bit(ND_INTEL_FW_FINISH_QUERY, &acpi_desc->dimm_cmd_force_en);
 }
 
 static void nfit_test1_setup(struct nfit_test *t)
@@ -2134,10 +2403,13 @@ static int nfit_test_probe(struct platform_device *pdev)
                 nfit_test->smart_threshold = devm_kcalloc(dev, num,
                                 sizeof(struct nd_intel_smart_threshold),
                                 GFP_KERNEL);
+                nfit_test->fw = devm_kcalloc(dev, num,
+                                sizeof(struct nfit_test_fw), GFP_KERNEL);
                 if (nfit_test->dimm && nfit_test->dimm_dma && nfit_test->label
                                 && nfit_test->label_dma && nfit_test->dcr
                                 && nfit_test->dcr_dma && nfit_test->flush
-                                && nfit_test->flush_dma)
+                                && nfit_test->flush_dma
+                                && nfit_test->fw)
                         /* pass */;
                 else
                         return -ENOMEM;
diff --git a/tools/testing/nvdimm/test/nfit_test.h b/tools/testing/nvdimm/test/nfit_test.h
index ba230f6f7676..be8fa8ec0615 100644
--- a/tools/testing/nvdimm/test/nfit_test.h
+++ b/tools/testing/nvdimm/test/nfit_test.h
@@ -84,9 +84,14 @@ struct nd_cmd_ars_err_inj_stat {
         } __packed record[0];
 } __packed;
 
-#define ND_INTEL_SMART 1
-#define ND_INTEL_SMART_THRESHOLD 2
-#define ND_INTEL_SMART_SET_THRESHOLD 17
+#define ND_INTEL_SMART                   1
+#define ND_INTEL_SMART_THRESHOLD         2
+#define ND_INTEL_FW_GET_INFO            12
+#define ND_INTEL_FW_START_UPDATE        13
+#define ND_INTEL_FW_SEND_DATA           14
+#define ND_INTEL_FW_FINISH_UPDATE       15
+#define ND_INTEL_FW_FINISH_QUERY        16
+#define ND_INTEL_SMART_SET_THRESHOLD    17
 
 #define ND_INTEL_SMART_HEALTH_VALID             (1 << 0)
 #define ND_INTEL_SMART_SPARES_VALID             (1 << 1)
@@ -152,6 +157,61 @@ struct nd_intel_smart_set_threshold {
         __u32 status;
 } __packed;
 
+#define INTEL_FW_STORAGE_SIZE           0x100000
+#define INTEL_FW_MAX_SEND_LEN           0xFFEC
+#define INTEL_FW_QUERY_INTERVAL         250000
+#define INTEL_FW_QUERY_MAX_TIME         3000000
+#define INTEL_FW_FIS_VERSION            0x0105
+#define INTEL_FW_FAKE_VERSION           0xffffffffabcd
+
+enum intel_fw_update_state {
+        FW_STATE_NEW = 0,
+        FW_STATE_IN_PROGRESS,
+        FW_STATE_VERIFY,
+        FW_STATE_UPDATED,
+};
+
+struct nd_intel_fw_info {
+        __u32 status;
+        __u32 storage_size;
+        __u32 max_send_len;
+        __u32 query_interval;
+        __u32 max_query_time;
+        __u8 update_cap;
+        __u8 reserved[3];
+        __u32 fis_version;
+        __u64 run_version;
+        __u64 updated_version;
+} __packed;
+
+struct nd_intel_fw_start {
+        __u32 status;
+        __u32 context;
+} __packed;
+
+/* this one has the output first because the variable input data size */
+struct nd_intel_fw_send_data {
+        __u32 context;
+        __u32 offset;
+        __u32 length;
+        __u8 data[0];
+/* this field is not declared due ot variable data from input */
+/*      __u32 status; */
+} __packed;
+
+struct nd_intel_fw_finish_update {
+        __u8 ctrl_flags;
+        __u8 reserved[3];
+        __u32 context;
+        __u32 status;
+} __packed;
+
+struct nd_intel_fw_finish_query {
+        __u32 context;
+        __u32 status;
+        __u64 updated_fw_rev;
+} __packed;
+
 union acpi_object;
 typedef void *acpi_handle;