[Cryptech-Commits] [sw/stm32] 04/05: Integrate test code for MKMIF.

[git at cryptech.is]

This is an automated email from the git hooks/post-receive script.

fredrik at thulin.net pushed a commit to branch master
in repository sw/stm32.

commit 055ba65f4a5b7435f22a52312d44b4dfe5433b0c
Author: Fredrik Thulin <fredrik at thulin.net>
AuthorDate: Sat Jul 9 21:55:20 2016 +0200

    Integrate test code for MKMIF.
    
    There seems to be a timing issue (?) with the MKMIF. If SCLK_DIV is
    set to a higher value (was: 0x20) then the CLI command "test mkmif" will
    fail with only occasional success runs. With divisor 0x01, it works most
    of the time but not allways.
---
 projects/cli-test/mgmt-test.c  |   4 +
 projects/cli-test/test-mkmif.c | 162 +++++++++++++++++++++++++++++++++++++++++
 projects/cli-test/test_mkmif.h |  40 ++++++++++
 3 files changed, 206 insertions(+)

diff --git a/projects/cli-test/mgmt-test.c b/projects/cli-test/mgmt-test.c
index c1f255e..35c6fb6 100644
--- a/projects/cli-test/mgmt-test.c
+++ b/projects/cli-test/mgmt-test.c
@@ -40,6 +40,7 @@
 #include "mgmt-test.h"
 
 #include "test_sdram.h"
+#include "test_mkmif.h"
 
 #include <stdlib.h>
 
@@ -114,4 +115,7 @@ void configure_cli_test(struct cli_def *cli)
 
     /* test sdram */
     cli_command_node(test, sdram, "Run SDRAM tests");
+
+    /* test mkmif */
+    cli_command_node(test, mkmif, "Run Master Key Memory Interface tests");
 }
diff --git a/projects/cli-test/test-mkmif.c b/projects/cli-test/test-mkmif.c
new file mode 100644
index 0000000..af222bc
--- /dev/null
+++ b/projects/cli-test/test-mkmif.c
@@ -0,0 +1,162 @@
+/*
+ * Test Joachim's MKMIF core.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+
+#include <sys/time.h>
+
+/* Rename both CMSIS HAL_OK and libhal HAL_OK to disambiguate */
+#define HAL_OK CMSIS_HAL_OK
+#include "mgmt-cli.h"
+
+#undef HAL_OK
+#define HAL_OK LIBHAL_OK
+#include "hal.h"
+#undef HAL_OK
+
+
+#define SCLK_DIV 0x01
+
+typedef union {
+    uint8_t byte[4];
+    uint32_t word;
+} byteword_t;
+
+static hal_error_t sclk_test(struct cli_def *cli, const hal_core_t *core, const uint32_t divisor)
+{
+    uint32_t readback;
+    hal_error_t err;
+
+    cli_print(cli, "Trying to adjust the clockspeed (divisor %x).\n", (unsigned int) divisor);
+
+    if ((err = hal_mkmif_set_clockspeed(core, divisor)) != LIBHAL_OK) {
+        cli_print(cli, "hal_mkmif_set_clockspeed: %s\n", hal_error_string(err));
+        return err;
+    }
+    if ((err = hal_mkmif_get_clockspeed(core, &readback)) != LIBHAL_OK) {
+        cli_print(cli, "hal_mkmif_get_clockspeed: %s\n", hal_error_string(err));
+        return err;
+    }
+    if (readback != divisor) {
+        cli_print(cli, "expected %x, got %x\n", (unsigned int)divisor, (unsigned int)readback);
+        return HAL_ERROR_IO_UNEXPECTED;
+    }
+    return LIBHAL_OK;
+}
+
+static hal_error_t init_test(struct cli_def *cli, const hal_core_t *core)
+{
+    hal_error_t err;
+
+    cli_print(cli, "Trying to init to the memory in continuous mode.\n");
+
+    if ((err = hal_mkmif_init(core)) != LIBHAL_OK) {
+        cli_print(cli, "hal_mkmif_init: %s\n", hal_error_string(err));
+        return err;
+    }
+
+    return LIBHAL_OK;
+}
+
+static hal_error_t write_test(struct cli_def *cli, const hal_core_t *core)
+{
+    uint32_t write_data;
+    uint32_t write_address;
+    int i;
+    hal_error_t err;
+
+    for (write_data = 0x01020304, write_address = 0, i = 0;
+         i < 0x10;
+         write_data += 0x01010101, write_address += 4, ++i) {
+
+        cli_print(cli, "Trying to write 0x%08x to memory address 0x%08x.\n",
+               (unsigned int)write_data, (unsigned int)write_address);
+
+        if ((err = hal_mkmif_write_word(core, write_address, write_data)) != LIBHAL_OK) {
+            cli_print(cli, "hal_mkmif_write: %s\n", hal_error_string(err));
+            return err;
+        }
+    }
+
+    return LIBHAL_OK;
+}
+
+static hal_error_t read_test(struct cli_def *cli, const hal_core_t *core)
+{
+    uint32_t read_data;
+    uint32_t read_address;
+    int i;
+    hal_error_t err;
+
+    for (read_address = 0, i = 0;
+         i < 0x10;
+         read_address += 4, ++i) {
+
+        cli_print(cli, "Trying to read from memory address 0x%08x.\n", (unsigned int)read_address);
+
+        if ((err = hal_mkmif_read_word(core, read_address, &read_data)) != LIBHAL_OK) {
+            cli_print(cli, "hal_mkmif_read: %s\n", hal_error_string(err));
+            return err;
+        }
+        cli_print(cli, "Data read: 0x%08x\n", (unsigned int)read_data);
+    }
+
+    return LIBHAL_OK;
+}
+
+static hal_error_t write_read_test(struct cli_def *cli, const hal_core_t *core)
+{
+    uint32_t data;
+    uint32_t readback;
+    hal_error_t err;
+
+    cli_print(cli, "Trying to write 0xdeadbeef to the memory and then read back.\n");
+
+    data = 0xdeadbeef;
+
+    if ((err = hal_mkmif_write_word(core, 0x00000000, data)) != LIBHAL_OK) {
+        cli_print(cli, "write error: %s\n", hal_error_string(err));
+        return err;
+    }
+
+    if ((err = hal_mkmif_read_word(core, 0x00000000, &readback)) != LIBHAL_OK) {
+        cli_print(cli, "read error: %s\n", hal_error_string(err));
+        return err;
+    }
+
+    if (readback != data) {
+        cli_print(cli, "read %08x, expected %08x\n", (unsigned int)readback, (unsigned int)data);
+        return HAL_ERROR_IO_UNEXPECTED;
+    }
+
+    return LIBHAL_OK;
+}
+
+int cmd_test_mkmif(struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+    const hal_core_t *core = hal_core_find(MKMIF_NAME, NULL);
+    hal_error_t res;
+
+    if (core == NULL) {
+        cli_print(cli, "MKMIF core not present, not testing.\n");
+        return HAL_ERROR_CORE_NOT_FOUND;
+    }
+
+    res =
+        sclk_test(cli, core, SCLK_DIV) ||
+        init_test(cli, core) ||
+        write_read_test(cli, core) ||
+        write_test(cli, core) ||
+        read_test(cli, core);
+
+    if (res != LIBHAL_OK) {
+	cli_print(cli, "\nTest FAILED");
+    }
+
+    return CLI_OK;
+}
diff --git a/projects/cli-test/test_mkmif.h b/projects/cli-test/test_mkmif.h
new file mode 100644
index 0000000..d5f2f75
--- /dev/null
+++ b/projects/cli-test/test_mkmif.h
@@ -0,0 +1,40 @@
+/*
+ * test_mkmif.h
+ * ------------
+ * Prototypes and defines for testing the master key memory interface.
+ *
+ * Copyright (c) 2016, NORDUnet A/S All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the NORDUnet nor the names of its contributors may
+ *   be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+ * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __STM32_CLI_TEST_MKMIF_H
+#define __STM32_CLI_TEST_MKMIF_H
+
+extern int cmd_test_mkmif(struct cli_def *cli, const char *command, char *argv[], int argc);
+
+
+#endif /* __STM32_CLI_TEST_MKMIF_H */