/*
* Test command to get status of RTC(not config, running, finished): rtc status
*
* @param[in] argc Number of arguments in the Test Command (including group and name)
* @param[in] argv Table of null-terminated buffers containing the arguments
* @param[in] ctx The context to pass back to responses
*/
void rtc_status(int argc, char *argv[], struct tcmd_handler_ctx *ctx)
{
char answer[RTC_FINISHED_STR_LEN + DOUBLE_UINT32_ANSWER_LENGTH];
uint32_t keys = 0;
bool local_alarm_pending = false;
uint32_t local_test_rtc = 0;
uint32_t local_tcmd_user_alarm_rtc_val = 0;
uint32_t local_tcmd_alarm_rtc_read = 0;
keys = irq_lock();
local_alarm_pending = alarm_pending;
local_test_rtc = test_rtc;
local_tcmd_user_alarm_rtc_val = tcmd_user_alarm_rtc_val;
local_tcmd_alarm_rtc_read = tcmd_alarm_rtc_read;
irq_unlock(keys);
if (local_alarm_pending) {
TCMD_RSP_FINAL(ctx, "Rtc is running.");
} else if (local_test_rtc) {
snprintf(answer, RTC_FINISHED_STR_LEN +
DOUBLE_UINT32_ANSWER_LENGTH,
"Rtc finished %u %u", local_tcmd_user_alarm_rtc_val,
local_tcmd_alarm_rtc_read);
TCMD_RSP_FINAL(ctx, answer);
} else {
TCMD_RSP_ERROR(ctx, "Rtc not configured.");
}
}
void setbackend_handler(int argc, char *argv[], struct tcmd_handler_ctx *ctx)
{
if (argc > 3)
goto usage;
if (argc == 2) {
TCMD_RSP_FINAL(ctx, current_backend_name);
return;
}
if (console_manager_set_log_backend(argv[2]) != 0)
goto usage;
TCMD_RSP_FINAL(ctx, NULL);
return;
usage:
setbackend_usage(ctx);
}
/* Handles message for test command */
static void ui_svc_tcmd_handle_message(struct cfw_message *msg, void *param)
{
int ui_status;
ui_srv_data_t *priv = CFW_MESSAGE_PRIV(msg);
struct tcmd_handler_ctx *ctx = priv->context;
char *message = balloc(BUFFER_LENGTH, NULL);
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_UI_LED_RSP:
case MSG_ID_UI_VIBR_RSP:
ui_status = ((struct cfw_rsp_message *)msg)->status;
if (ui_status == DRV_RC_OK) {
TCMD_RSP_FINAL(ctx, NULL);
} else {
snprintf(message, BUFFER_LENGTH, "KO (status: %d)", ui_status);
TCMD_RSP_ERROR(ctx, message);
}
break;
default:
/* default cfw handler */
snprintf(message, BUFFER_LENGTH,
"Wrong ui_svc rsp (id: 0x%X)", CFW_MESSAGE_ID(msg));
TCMD_RSP_ERROR(ctx, message);
break;
}
cproxy_disconnect(priv->ui_service_conn);
cfw_msg_free(msg);
bfree(priv);
bfree(message);
}
/*
* Test command to read current RTC: rtc read
*
* @param[in] argc Number of arguments in the Test Command (including group and name)
* @param[in] argv Table of null-terminated buffers containing the arguments
* @param[in] ctx The context to pass back to responses
*/
void rtc_read_tcmd(int argc, char *argv[], struct tcmd_handler_ctx *ctx)
{
char answer[UINT32_ANSWER_LENGTH];
struct device *rtc_dev;
rtc_dev = device_get_binding(RTC_DRV_NAME);
assert(rtc_dev != NULL);
snprintf(answer, UINT32_ANSWER_LENGTH, "%u", rtc_read(rtc_dev));
TCMD_RSP_FINAL(ctx, answer);
}
/*
* Function called at elapsed RTC alarm time.
*
* @param[in] val input parameter for callback function
*/
static void test_rtc_interrupt_fn(struct device *rtc_dev)
{
struct tcmd_handler_ctx *ctx =
(struct tcmd_handler_ctx *)rtc_dev->driver_data;
char answer[DOUBLE_UINT32_ANSWER_LENGTH];
tcmd_alarm_rtc_read = rtc_read(rtc_dev);
test_rtc++;
snprintf(answer, DOUBLE_UINT32_ANSWER_LENGTH, "%u %u",
tcmd_user_alarm_rtc_val,
tcmd_alarm_rtc_read);
alarm_pending = false;
TCMD_RSP_FINAL(ctx, answer);
}
void version_tcmd(int argc, char **argv, struct tcmd_handler_ctx *ctx)
{
char buf[TEXT_SIZE];
snprintf(buf, TEXT_SIZE, "%d.%d.%d", p_version->major, p_version->minor,
p_version->patch);
TCMD_RSP_PROVISIONAL(ctx,buf);
snprintf(buf, TEXT_SIZE, "%.20s", p_version->version_string);
TCMD_RSP_PROVISIONAL(ctx,buf);
snprintf(buf, TEXT_SIZE, "Micro-sha1 : %02x%02x%02x%02x", p_version->hash[0],
p_version->hash[1], p_version->hash[2], p_version->hash[3]);
TCMD_RSP_PROVISIONAL(ctx,buf);
TCMD_RSP_FINAL(ctx, NULL);
}
/*
* Test command to set initial RTC time: rtc set <time>
*
* @param[in] argc Number of arguments in the Test Command (including group and name)
* @param[in] argv Table of null-terminated buffers containing the arguments
* @param[in] ctx The context to pass back to responses
*/
void rtc_set(int argc, char *argv[], struct tcmd_handler_ctx *ctx)
{
struct rtc_config config = { 0 };
uint32_t keys = 0;
struct device *rtc_dev;
if (argc == RTC_ARG_NO && isdigit(argv[RTC_TIME_IDX][0])) {
rtc_dev = device_get_binding(RTC_DRV_NAME);
assert(rtc_dev != NULL);
keys = irq_lock();
tcmd_user_initial_rtc_val = (uint32_t)strtoul(
argv[RTC_TIME_IDX], NULL, 10);
config.init_val = tcmd_user_initial_rtc_val;
irq_unlock(keys);
rtc_set_config(rtc_dev, &config);
TCMD_RSP_FINAL(ctx, NULL);
} else {
TCMD_RSP_ERROR(ctx, "Usage: rtc set <initial_time>");
}
}
void eval_jerry_script (int argc, char *argv[], struct tcmd_handler_ctx *ctx)
{
if (argc < 3)
{
TCMD_RSP_ERROR (ctx, NULL);
help ();
return;
}
else
{
OS_ERR_TYPE err;
size_t str_total_length = 0;
size_t *str_lens = (size_t *) balloc ((argc - 2) * sizeof(size_t), &err);
if (str_lens == NULL || err != E_OS_OK)
{
printk ("%s: allocate memory failed!", __func__);
TCMD_RSP_ERROR (ctx, NULL);
return;
}
for (int i = 2; i < argc; ++i)
{
str_lens[i - 2] = strlen (argv[i]);
str_total_length += str_lens[i - 2] + 1;
}
err = E_OS_OK;
char *buffer = (char *) balloc (str_total_length, &err);
if (buffer == NULL || err != E_OS_OK)
{
printk ("%s: allocate memory failed!", __func__);
TCMD_RSP_ERROR (ctx, NULL);
return;
}
char *p = buffer;
for (int i = 2; i < argc; ++i)
{
for (int j =0; j < str_lens[i - 2]; ++j)
{
*p = argv[i][j];
++p;
}
*p = ' ';
++p;
}
*p = '\0';
jerry_value_t eval_ret = jerry_eval (buffer, str_total_length - 1, false);
if (jerry_value_is_error (eval_ret))
{
jerry_resolve_error (eval_ret);
TCMD_RSP_ERROR (ctx, NULL);
}
else
{
jerry_value_t args[] = {eval_ret};
jerry_value_t ret_val_print = jerry_call_function (print_function,
jerry_create_undefined (),
args,
1);
jerry_release_value (ret_val_print);
TCMD_RSP_FINAL (ctx, NULL);
}
jerry_release_value (eval_ret);
bfree (buffer);
bfree (str_lens);
}
}
/*
* Test command for panic generator: debug panic <panic_id>
*
* @param[in] argc Number of arguments in the Test Command (including group and name)
* @param[in] argv Table of null-terminated buffers containing the arguments
* @param[in] ctx The context to pass back to responses
*/
void debug_panic(int argc, char *argv[], struct tcmd_handler_ctx *ctx)
{
volatile uint32_t panic_id;
volatile uint32_t aligned_var[2] = { 0xFFFFFFFF, 0xFFFFFFFF };
volatile uint32_t unaligned_ptr;
volatile int opcode = 0;
#ifdef CONFIG_INTEL_QRK_WDT
struct device *wdt_dev;
struct wdt_config config;
int res;
#endif
if (argc != ARGC)
goto print_help;
panic_id = strtoul(argv[PANIC_ID_IDX], NULL, 10);
switch (panic_id) {
case 0:
panic_id = 123 / panic_id;
TCMD_RSP_ERROR(
ctx,
"Division by 0 did not panic (sw implementation ?).");
break;
case 1:
unaligned_ptr = (uint32_t)&aligned_var;
if (*((uint32_t *)(unaligned_ptr + 1)))
TCMD_RSP_ERROR(
ctx,
"Unaligned access is allowed on this platform.");
break;
case 2:
#ifdef CONFIG_INTEL_QRK_WDT
config.timeout = 2097; // Timeout: 2.097s (for 32MHz)
config.mode = WDT_MODE_INTERRUPT_RESET;
extern struct device DEVICE_NAME_GET(wdt);
wdt_dev = DEVICE_GET(wdt);
res = wdt_set_config(wdt_dev, &config);
if (res == DEV_OK) {
TCMD_RSP_FINAL(ctx, "Watchdog");
irq_lock();
while (1) ;
} else
TCMD_RSP_ERROR(ctx, "Watchdog configuration failure");
#else
TCMD_RSP_ERROR(ctx, "Watchdog not supported");
#endif
break;
case 3:
TCMD_RSP_FINAL(ctx, "Invalid address");
*((volatile uint32_t *)0xFFFFFFFF) = 0xABCD;
break;
case 4:
TCMD_RSP_FINAL(ctx, "App Error.");
panic(0x123456);
break;
case 5:
/* Need MMU to support stack overflow */
TCMD_RSP_ERROR(ctx, "No Stack Overflow");
break;
case 6:
((void (*)(void))(&opcode))();
TCMD_RSP_FINAL(ctx, "Wrong OpCode.");
break;
default:
TCMD_RSP_ERROR(ctx, "KO 1");
break;
}
return;
print_help:
TCMD_RSP_ERROR(ctx, "Usage: debug panic <panic_id>.");
}
