porting_assistant.c

Go to the documentation of this file.

/*
 * Copyright 2021-2023 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include "porting_assistant.h"
#include "mmhal_core.h"
#include "mmhal_app.h"
#include "mmversion.h"
 
#if defined(ENABLE_EXT_XTAL_INIT) && ENABLE_EXT_XTAL_INIT
/* The crystal initialization requires chip specific configuration which we do not have access
 * to in the porting assistant example application. */
#error "With ENABLE_EXT_XTAL_INIT defined this device is not supported by porting assistant."
#endif
 
/* Test step declarations */
extern const struct test_step test_step_os_malloc; 
extern const struct test_step test_step_os_realloc; 
extern const struct test_step test_step_os_task_creation; 
extern const struct test_step test_step_os_active_context; 
extern const struct test_step test_step_os_time; 
extern const struct test_step test_step_os_task_preemption; 
extern const struct test_step test_step_mmhal_wlan_init; 
extern const struct test_step test_step_mmhal_wlan_hard_reset; 
extern const struct test_step test_step_mmhal_wlan_sdio_startup; 
extern const struct test_step test_step_read_chip_id; 
extern const struct test_step test_step_bulk_write_read; 
extern const struct test_step test_step_raw_tput; 
extern const struct test_step test_step_mmhal_wlan_validate_fw; 
extern const struct test_step test_step_mmhal_wlan_validate_bcf; 
extern const struct test_step test_step_verify_busy_pin; 
extern const struct test_step test_step_benchmark_cpu_mem_stack_perf; 
static const struct test_step *const test_steps[] = {
    &test_step_os_malloc,
    &test_step_os_realloc,
    &test_step_os_task_creation,
    /* task_creation and active_context tests essential OS pre-conditions and therefore
     * MUST be tested before other os tests to flag failure early. */
    &test_step_os_active_context,
    &test_step_os_time,
    &test_step_os_task_preemption,
    &test_step_mmhal_wlan_init,
    &test_step_mmhal_wlan_hard_reset,
    &test_step_mmhal_wlan_sdio_startup,
    &test_step_read_chip_id,
    &test_step_verify_busy_pin,
    &test_step_bulk_write_read,
    &test_step_raw_tput,
    &test_step_mmhal_wlan_validate_fw,
    &test_step_mmhal_wlan_validate_bcf,
    &test_step_benchmark_cpu_mem_stack_perf,
};
 
struct test_counters
{
    unsigned no_result;
    unsigned pass;
    unsigned fail;
};
 
static const char *result_code_to_string(enum test_result result)
{
    switch (result)
    {
        case TEST_NO_RESULT:
            return "";
        case TEST_PASSED:
            return F_GREEN("PASS");
        case TEST_SKIPPED:
            return F_BLUE("SKIP");
        case TEST_FAILED:
            return F_RED("FAIL");
        case TEST_FAILED_NON_CRITICAL:
            return F_YELLOW("FAIL");
    }
    MMOSAL_ASSERT(false);
}
 
static void run_test_steps(const struct test_step *const steps[],
                           size_t num_steps,
                           struct test_counters *ctrs)
{
    static char log_buf[1024];
 
    size_t ii;
    for (ii = 0; ii < num_steps; ii++)
    {
        const struct test_step *step = steps[ii];
        size_t log_buf_len = sizeof(log_buf);
        log_buf[0] = '\0';
 
        LOG_PRINTF(F_BOLD("%-60s "), step->description);
        LOG_FLUSH();
 
        enum test_result result = step->exec(log_buf, log_buf_len);
        if (result != TEST_NO_RESULT)
        {
            LOG_PRINTF("[ %s ]", result_code_to_string(result));
        }
        LOG_WRITE("\n");
 
        if (log_buf[0] != '\0')
        {
            LOG_WRITE("\n");
            LOG_WRITE(log_buf);
        }
        LOG_FLUSH();
        switch (result)
        {
            case TEST_NO_RESULT:
                ctrs->no_result++;
                break;
            case TEST_PASSED:
                ctrs->pass++;
                break;
            case TEST_SKIPPED:
                break;
            case TEST_FAILED:
                ctrs->fail++;
                break;
            case TEST_FAILED_NON_CRITICAL:
                ctrs->fail++;
                break;
        }
 
        if (result == TEST_FAILED)
        {
            break;
        }
    }
}
 
void app_init(void)
{
    /* Having deep sleep enabled can complicate debugging. Given the purpose of this applications
     * is to validate that you can communicate to the MM-Chip it will be disabled by default. */
    mmhal_set_deep_sleep_veto(MMHAL_VETO_ID_APP_MIN);
 
    struct test_counters ctrs = { 0 };
    unsigned num_tests = sizeof(test_steps) / sizeof(test_steps[0]);
 
    char hw_version_string[32] = { 0 };
 
    bool ok = mmhal_get_hardware_version(hw_version_string, sizeof(hw_version_string));
    if (!ok)
    {
        snprintf(hw_version_string, sizeof(hw_version_string), "%s", "Unknown");
    }
 
    LOG_WRITE(F_BOLD("\n\nMM-IoT-SDK Porting Assistant\n"));
    LOG_WRITE("----------------------------\n");
    LOG_PRINTF("  HW Version:              %s\n", hw_version_string);
    LOG_PRINTF("  Morselib version:        %s\n", MM_VERSION_BUILDID);
    LOG_WRITE("----------------------------\n\n");
 
    run_test_steps(test_steps, num_tests, &ctrs);
 
    LOG_PRINTF("\n\n%u total test steps. %u passed, %u failed, %u no result, %u skipped\n",
               num_tests,
               ctrs.pass,
               ctrs.fail,
               ctrs.no_result,
               num_tests - ctrs.no_result - ctrs.pass - ctrs.fail);
}