/* * 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>."); }