rtos: rename CamelCase symbols

Only one exported symbol from eCos is included in this patch.
The eCos code is left untouched to prevent conflicts with patches
currently under review.

While there, remove an unused camelcase macro

Change-Id: I8d22dec6e243c00665d99a8b8ba00474b4f088db
Signed-off-by: Antonio Borneo <borneo.antonio@gmail.com>
Reviewed-on: http://openocd.zylin.com/6305
Tested-by: jenkins
Reviewed-by: Marc Schink <dev@zapb.de>

diff --git a/src/rtos/FreeRTOS.c b/src/rtos/FreeRTOS.c
index 24b82907048061c23c069adf365b725f1d794568..a480c44619ee7d1e213f61681dadcad8543a11c0 100644 (file)
--- a/src/rtos/FreeRTOS.c
+++ b/src/rtos/FreeRTOS.c
@@ -31,18 +31,14 @@
 #include "target/armv7m.h"
 #include "target/cortex_m.h"
 
-
-
 #define FREERTOS_MAX_PRIORITIES        63
 
-#define FreeRTOS_STRUCT(int_type, ptr_type, list_prev_offset)
-
 /* FIXME: none of the _width parameters are actually observed properly!
  * you WILL need to edit more if you actually attempt to target a 8/16/64
  * bit target!
  */
 
-struct FreeRTOS_params {
+struct freertos_params {
        const char *target_name;
        const unsigned char thread_count_width;
        const unsigned char pointer_width;
@@ -57,7 +53,7 @@ struct FreeRTOS_params {
        const struct rtos_register_stacking *stacking_info_cm4f_fpu;
 };
 
-static const struct FreeRTOS_params FreeRTOS_params_list[] = {
+static const struct freertos_params freertos_params_list[] = {
        {
        "cortex_m",                     /* target_name */
        4,                                              /* thread_count_width; */
@@ -68,9 +64,9 @@ static const struct FreeRTOS_params FreeRTOS_params_list[] = {
        12,                                             /* list_elem_content_offset */
        0,                                              /* thread_stack_offset; */
        52,                                             /* thread_name_offset; */
-       &rtos_standard_Cortex_M3_stacking,      /* stacking_info */
-       &rtos_standard_Cortex_M4F_stacking,
-       &rtos_standard_Cortex_M4F_FPU_stacking,
+       &rtos_standard_cortex_m3_stacking,      /* stacking_info */
+       &rtos_standard_cortex_m4f_stacking,
+       &rtos_standard_cortex_m4f_fpu_stacking,
        },
        {
        "hla_target",                   /* target_name */
@@ -82,9 +78,9 @@ static const struct FreeRTOS_params FreeRTOS_params_list[] = {
        12,                                             /* list_elem_content_offset */
        0,                                              /* thread_stack_offset; */
        52,                                             /* thread_name_offset; */
-       &rtos_standard_Cortex_M3_stacking,      /* stacking_info */
-       &rtos_standard_Cortex_M4F_stacking,
-       &rtos_standard_Cortex_M4F_FPU_stacking,
+       &rtos_standard_cortex_m3_stacking,      /* stacking_info */
+       &rtos_standard_cortex_m4f_stacking,
+       &rtos_standard_cortex_m4f_fpu_stacking,
        },
        {
        "nds32_v3",                     /* target_name */
@@ -96,30 +92,30 @@ static const struct FreeRTOS_params FreeRTOS_params_list[] = {
        12,                                             /* list_elem_content_offset */
        0,                                              /* thread_stack_offset; */
        52,                                             /* thread_name_offset; */
-       &rtos_standard_NDS32_N1068_stacking,    /* stacking_info */
-       &rtos_standard_Cortex_M4F_stacking,
-       &rtos_standard_Cortex_M4F_FPU_stacking,
+       &rtos_standard_nds32_n1068_stacking,    /* stacking_info */
+       &rtos_standard_cortex_m4f_stacking,
+       &rtos_standard_cortex_m4f_fpu_stacking,
        },
 };
 
-static bool FreeRTOS_detect_rtos(struct target *target);
-static int FreeRTOS_create(struct target *target);
-static int FreeRTOS_update_threads(struct rtos *rtos);
-static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
+static bool freertos_detect_rtos(struct target *target);
+static int freertos_create(struct target *target);
+static int freertos_update_threads(struct rtos *rtos);
+static int freertos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
                struct rtos_reg **reg_list, int *num_regs);
-static int FreeRTOS_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
+static int freertos_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
 
-struct rtos_type FreeRTOS_rtos = {
+struct rtos_type freertos_rtos = {
        .name = "FreeRTOS",
 
-       .detect_rtos = FreeRTOS_detect_rtos,
-       .create = FreeRTOS_create,
-       .update_threads = FreeRTOS_update_threads,
-       .get_thread_reg_list = FreeRTOS_get_thread_reg_list,
-       .get_symbol_list_to_lookup = FreeRTOS_get_symbol_list_to_lookup,
+       .detect_rtos = freertos_detect_rtos,
+       .create = freertos_create,
+       .update_threads = freertos_update_threads,
+       .get_thread_reg_list = freertos_get_thread_reg_list,
+       .get_symbol_list_to_lookup = freertos_get_symbol_list_to_lookup,
 };
 
-enum FreeRTOS_symbol_values {
+enum freertos_symbol_values {
        FREERTOS_VAL_PX_CURRENT_TCB = 0,
        FREERTOS_VAL_PX_READY_TASKS_LISTS = 1,
        FREERTOS_VAL_X_DELAYED_TASK_LIST1 = 2,
@@ -138,7 +134,7 @@ struct symbols {
        bool optional;
 };
 
-static const struct symbols FreeRTOS_symbol_list[] = {
+static const struct symbols freertos_symbol_list[] = {
        { "pxCurrentTCB", false },
        { "pxReadyTasksLists", false },
        { "xDelayedTaskList1", false },
@@ -158,16 +154,16 @@ static const struct symbols FreeRTOS_symbol_list[] = {
 /* may be problems reading if sizes are not 32 bit long integers. */
 /* test mallocs for failure */
 
-static int FreeRTOS_update_threads(struct rtos *rtos)
+static int freertos_update_threads(struct rtos *rtos)
 {
        int retval;
        unsigned int tasks_found = 0;
-       const struct FreeRTOS_params *param;
+       const struct freertos_params *param;
 
        if (rtos->rtos_specific_params == NULL)
                return -1;
 
-       param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
+       param = (const struct freertos_params *) rtos->rtos_specific_params;
 
        if (rtos->symbols == NULL) {
                LOG_ERROR("No symbols for FreeRTOS");
@@ -400,11 +396,11 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
        return 0;
 }
 
-static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
+static int freertos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
                struct rtos_reg **reg_list, int *num_regs)
 {
        int retval;
-       const struct FreeRTOS_params *param;
+       const struct freertos_params *param;
        int64_t stack_ptr = 0;
 
        if (rtos == NULL)
@@ -416,7 +412,7 @@ static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
        if (rtos->rtos_specific_params == NULL)
                return -1;
 
-       param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
+       param = (const struct freertos_params *) rtos->rtos_specific_params;
 
        /* Read the stack pointer */
        uint32_t pointer_casts_are_bad;
@@ -456,15 +452,15 @@ static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
 
        if (cm4_fpu_enabled == 1) {
                /* Read the LR to decide between stacking with or without FPU */
-               uint32_t LR_svc = 0;
+               uint32_t lr_svc = 0;
                retval = target_read_u32(rtos->target,
                                stack_ptr + 0x20,
-                               &LR_svc);
+                               &lr_svc);
                if (retval != ERROR_OK) {
                        LOG_OUTPUT("Error reading stack frame from FreeRTOS thread");
                        return retval;
                }
-               if ((LR_svc & 0x10) == 0)
+               if ((lr_svc & 0x10) == 0)
                        return rtos_generic_stack_read(rtos->target, param->stacking_info_cm4f_fpu, stack_ptr, reg_list, num_regs);
                else
                        return rtos_generic_stack_read(rtos->target, param->stacking_info_cm4f, stack_ptr, reg_list, num_regs);
@@ -472,15 +468,15 @@ static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
                return rtos_generic_stack_read(rtos->target, param->stacking_info_cm3, stack_ptr, reg_list, num_regs);
 }
 
-static int FreeRTOS_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
+static int freertos_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
 {
        unsigned int i;
        *symbol_list = calloc(
-                       ARRAY_SIZE(FreeRTOS_symbol_list), sizeof(struct symbol_table_elem));
+                       ARRAY_SIZE(freertos_symbol_list), sizeof(struct symbol_table_elem));
 
-       for (i = 0; i < ARRAY_SIZE(FreeRTOS_symbol_list); i++) {
-               (*symbol_list)[i].symbol_name = FreeRTOS_symbol_list[i].name;
-               (*symbol_list)[i].optional = FreeRTOS_symbol_list[i].optional;
+       for (i = 0; i < ARRAY_SIZE(freertos_symbol_list); i++) {
+               (*symbol_list)[i].symbol_name = freertos_symbol_list[i].name;
+               (*symbol_list)[i].optional = freertos_symbol_list[i].optional;
        }
 
        return 0;
@@ -488,15 +484,15 @@ static int FreeRTOS_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_l
 
 #if 0
 
-static int FreeRTOS_set_current_thread(struct rtos *rtos, threadid_t thread_id)
+static int freertos_set_current_thread(struct rtos *rtos, threadid_t thread_id)
 {
        return 0;
 }
 
-static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_id, char **info)
+static int freertos_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_id, char **info)
 {
        int retval;
-       const struct FreeRTOS_params *param;
+       const struct freertos_params *param;
 
        if (rtos == NULL)
                return -1;
@@ -507,7 +503,7 @@ static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_i
        if (rtos->rtos_specific_params == NULL)
                return -3;
 
-       param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
+       param = (const struct freertos_params *) rtos->rtos_specific_params;
 
 #define FREERTOS_THREAD_NAME_STR_SIZE (200)
        char tmp_str[FREERTOS_THREAD_NAME_STR_SIZE];
@@ -533,7 +529,7 @@ static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_i
 
 #endif
 
-static bool FreeRTOS_detect_rtos(struct target *target)
+static bool freertos_detect_rtos(struct target *target)
 {
        if ((target->rtos->symbols != NULL) &&
                        (target->rtos->symbols[FREERTOS_VAL_PX_READY_TASKS_LISTS].address != 0)) {
@@ -543,11 +539,11 @@ static bool FreeRTOS_detect_rtos(struct target *target)
        return false;
 }
 
-static int FreeRTOS_create(struct target *target)
+static int freertos_create(struct target *target)
 {
-       for (unsigned int i = 0; i < ARRAY_SIZE(FreeRTOS_params_list); i++)
-               if (strcmp(FreeRTOS_params_list[i].target_name, target->type->name) == 0) {
-                       target->rtos->rtos_specific_params = (void *)&FreeRTOS_params_list[i];
+       for (unsigned int i = 0; i < ARRAY_SIZE(freertos_params_list); i++)
+               if (strcmp(freertos_params_list[i].target_name, target->type->name) == 0) {
+                       target->rtos->rtos_specific_params = (void *)&freertos_params_list[i];
                        return 0;
                }
 

diff --git a/src/rtos/ThreadX.c b/src/rtos/ThreadX.c
index 3b4c2d701d9d21b9dc9837987c4bd0c5487097a2..5eadce9cada553c0a6ba6fa5e1839db0dfa7ee23 100644 (file)
--- a/src/rtos/ThreadX.c
+++ b/src/rtos/ThreadX.c
@@ -35,20 +35,20 @@ static const struct rtos_register_stacking *get_stacking_info_arm926ejs(const st
 static int is_thread_id_valid(const struct rtos *rtos, int64_t thread_id);
 static int is_thread_id_valid_arm926ejs(const struct rtos *rtos, int64_t thread_id);
 
-static bool ThreadX_detect_rtos(struct target *target);
-static int ThreadX_create(struct target *target);
-static int ThreadX_update_threads(struct rtos *rtos);
-static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, struct rtos_reg **reg_list, int *num_regs);
-static int ThreadX_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
+static bool threadx_detect_rtos(struct target *target);
+static int threadx_create(struct target *target);
+static int threadx_update_threads(struct rtos *rtos);
+static int threadx_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, struct rtos_reg **reg_list, int *num_regs);
+static int threadx_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
 
 
 
-struct ThreadX_thread_state {
+struct threadx_thread_state {
        int value;
        const char *desc;
 };
 
-static const struct ThreadX_thread_state ThreadX_thread_states[] = {
+static const struct threadx_thread_state threadx_thread_states[] = {
        { 0,  "Ready" },
        { 1,  "Completed" },
        { 2,  "Terminated" },
@@ -65,7 +65,7 @@ static const struct ThreadX_thread_state ThreadX_thread_states[] = {
        { 13, "Waiting - Mutex" },
 };
 
-#define THREADX_NUM_STATES ARRAY_SIZE(ThreadX_thread_states)
+#define THREADX_NUM_STATES ARRAY_SIZE(threadx_thread_states)
 
 #define ARM926EJS_REGISTERS_SIZE_SOLICITED (11 * 4)
 static const struct stack_register_offset rtos_threadx_arm926ejs_stack_offsets_solicited[] = {
@@ -127,7 +127,7 @@ static const struct rtos_register_stacking rtos_threadx_arm926ejs_stacking[] = {
 },
 };
 
-struct ThreadX_params {
+struct threadx_params {
        const char *target_name;
        unsigned char pointer_width;
        unsigned char thread_stack_offset;
@@ -140,7 +140,7 @@ struct ThreadX_params {
        int (*fn_is_thread_id_valid)(const struct rtos *rtos, int64_t thread_id);
 };
 
-static const struct ThreadX_params ThreadX_params_list[] = {
+static const struct threadx_params threadx_params_list[] = {
        {
        "cortex_m",                             /* target_name */
        4,                                                      /* pointer_width; */
@@ -148,7 +148,7 @@ static const struct ThreadX_params ThreadX_params_list[] = {
        40,                                                     /* thread_name_offset; */
        48,                                                     /* thread_state_offset; */
        136,                                            /* thread_next_offset */
-       &rtos_standard_Cortex_M3_stacking,      /* stacking_info */
+       &rtos_standard_cortex_m3_stacking,      /* stacking_info */
        1,                                                      /* stacking_info_nb */
        NULL,                                           /* fn_get_stacking_info */
        NULL,                                           /* fn_is_thread_id_valid */
@@ -160,7 +160,7 @@ static const struct ThreadX_params ThreadX_params_list[] = {
        40,                                                     /* thread_name_offset; */
        48,                                                     /* thread_state_offset; */
        136,                                            /* thread_next_offset */
-       &rtos_standard_Cortex_R4_stacking,      /* stacking_info */
+       &rtos_standard_cortex_r4_stacking,      /* stacking_info */
        1,                                                      /* stacking_info_nb */
        NULL,                                           /* fn_get_stacking_info */
        NULL,                                           /* fn_is_thread_id_valid */
@@ -179,32 +179,32 @@ static const struct ThreadX_params ThreadX_params_list[] = {
        },
 };
 
-enum ThreadX_symbol_values {
+enum threadx_symbol_values {
        THREADX_VAL_TX_THREAD_CURRENT_PTR = 0,
        THREADX_VAL_TX_THREAD_CREATED_PTR = 1,
        THREADX_VAL_TX_THREAD_CREATED_COUNT = 2,
 };
 
-static const char * const ThreadX_symbol_list[] = {
+static const char * const threadx_symbol_list[] = {
        "_tx_thread_current_ptr",
        "_tx_thread_created_ptr",
        "_tx_thread_created_count",
        NULL
 };
 
-const struct rtos_type ThreadX_rtos = {
+const struct rtos_type threadx_rtos = {
        .name = "ThreadX",
 
-       .detect_rtos = ThreadX_detect_rtos,
-       .create = ThreadX_create,
-       .update_threads = ThreadX_update_threads,
-       .get_thread_reg_list = ThreadX_get_thread_reg_list,
-       .get_symbol_list_to_lookup = ThreadX_get_symbol_list_to_lookup,
+       .detect_rtos = threadx_detect_rtos,
+       .create = threadx_create,
+       .update_threads = threadx_update_threads,
+       .get_thread_reg_list = threadx_get_thread_reg_list,
+       .get_symbol_list_to_lookup = threadx_get_symbol_list_to_lookup,
 };
 
 static const struct rtos_register_stacking *get_stacking_info(const struct rtos *rtos, int64_t stack_ptr)
 {
-       const struct ThreadX_params *param = (const struct ThreadX_params *) rtos->rtos_specific_params;
+       const struct threadx_params *param = (const struct threadx_params *) rtos->rtos_specific_params;
 
        if (param->fn_get_stacking_info != NULL)
                return param->fn_get_stacking_info(rtos, stack_ptr);
@@ -214,12 +214,12 @@ static const struct rtos_register_stacking *get_stacking_info(const struct rtos
 
 static int is_thread_id_valid(const struct rtos *rtos, int64_t thread_id)
 {
-       const struct ThreadX_params *param;
+       const struct threadx_params *param;
 
        if (rtos->rtos_specific_params == NULL)
                return 0; /* invalid */
 
-       param = (const struct ThreadX_params *) rtos->rtos_specific_params;
+       param = (const struct threadx_params *) rtos->rtos_specific_params;
 
        if (param->fn_is_thread_id_valid != NULL)
                return param->fn_is_thread_id_valid(rtos, thread_id);
@@ -229,7 +229,7 @@ static int is_thread_id_valid(const struct rtos *rtos, int64_t thread_id)
 
 static const struct rtos_register_stacking *get_stacking_info_arm926ejs(const struct rtos *rtos, int64_t stack_ptr)
 {
-       const struct ThreadX_params *param = (const struct ThreadX_params *) rtos->rtos_specific_params;
+       const struct threadx_params *param = (const struct threadx_params *) rtos->rtos_specific_params;
        int     retval;
        uint32_t flag;
 
@@ -256,12 +256,12 @@ static int is_thread_id_valid_arm926ejs(const struct rtos *rtos, int64_t thread_
        return (thread_id != 0 && thread_id != 1);
 }
 
-static int ThreadX_update_threads(struct rtos *rtos)
+static int threadx_update_threads(struct rtos *rtos)
 {
        int retval;
        int tasks_found = 0;
        int thread_list_size = 0;
-       const struct ThreadX_params *param;
+       const struct threadx_params *param;
 
        if (rtos == NULL)
                return -1;
@@ -269,7 +269,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
        if (rtos->rtos_specific_params == NULL)
                return -3;
 
-       param = (const struct ThreadX_params *) rtos->rtos_specific_params;
+       param = (const struct threadx_params *) rtos->rtos_specific_params;
 
        if (rtos->symbols == NULL) {
                LOG_ERROR("No symbols for ThreadX");
@@ -395,13 +395,13 @@ static int ThreadX_update_threads(struct rtos *rtos)
                }
 
                for (i = 0; (i < THREADX_NUM_STATES) &&
-                               (ThreadX_thread_states[i].value != thread_status); i++) {
+                               (threadx_thread_states[i].value != thread_status); i++) {
                        /* empty */
                }
 
                const char *state_desc;
                if  (i < THREADX_NUM_STATES)
-                       state_desc = ThreadX_thread_states[i].desc;
+                       state_desc = threadx_thread_states[i].desc;
                else
                        state_desc = "Unknown state";
 
@@ -431,11 +431,11 @@ static int ThreadX_update_threads(struct rtos *rtos)
        return 0;
 }
 
-static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
+static int threadx_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
                struct rtos_reg **reg_list, int *num_regs)
 {
        int retval;
-       const struct ThreadX_params *param;
+       const struct threadx_params *param;
 
        if (rtos == NULL)
                return -1;
@@ -446,7 +446,7 @@ static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
        if (rtos->rtos_specific_params == NULL)
                return -3;
 
-       param = (const struct ThreadX_params *) rtos->rtos_specific_params;
+       param = (const struct threadx_params *) rtos->rtos_specific_params;
 
        /* Read the stack pointer */
        int64_t stack_ptr = 0;
@@ -477,19 +477,19 @@ static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
        return rtos_generic_stack_read(rtos->target, stacking_info, stack_ptr, reg_list, num_regs);
 }
 
-static int ThreadX_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
+static int threadx_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
 {
        unsigned int i;
        *symbol_list = calloc(
-                       ARRAY_SIZE(ThreadX_symbol_list), sizeof(struct symbol_table_elem));
+                       ARRAY_SIZE(threadx_symbol_list), sizeof(struct symbol_table_elem));
 
-       for (i = 0; i < ARRAY_SIZE(ThreadX_symbol_list); i++)
-               (*symbol_list)[i].symbol_name = ThreadX_symbol_list[i];
+       for (i = 0; i < ARRAY_SIZE(threadx_symbol_list); i++)
+               (*symbol_list)[i].symbol_name = threadx_symbol_list[i];
 
        return 0;
 }
 
-static bool ThreadX_detect_rtos(struct target *target)
+static bool threadx_detect_rtos(struct target *target)
 {
        if ((target->rtos->symbols != NULL) &&
                        (target->rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_PTR].address != 0)) {
@@ -501,12 +501,12 @@ static bool ThreadX_detect_rtos(struct target *target)
 
 #if 0
 
-static int ThreadX_set_current_thread(struct rtos *rtos, threadid_t thread_id)
+static int threadx_set_current_thread(struct rtos *rtos, threadid_t thread_id)
 {
        return 0;
 }
 
-static int ThreadX_get_thread_detail(struct rtos *rtos,
+static int threadx_get_thread_detail(struct rtos *rtos,
        threadid_t thread_id,
        struct thread_detail *detail)
 {
@@ -516,7 +516,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
 #define THREADX_THREAD_NAME_STR_SIZE (200)
        char tmp_str[THREADX_THREAD_NAME_STR_SIZE];
 
-       const struct ThreadX_params *param;
+       const struct threadx_params *param;
 
        if (rtos == NULL)
                return -1;
@@ -527,7 +527,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
        if (rtos->rtos_specific_params == NULL)
                return -3;
 
-       param = (const struct ThreadX_params *) rtos->rtos_specific_params;
+       param = (const struct threadx_params *) rtos->rtos_specific_params;
 
        if (rtos->symbols == NULL) {
                LOG_ERROR("No symbols for ThreadX");
@@ -576,13 +576,13 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
        }
 
        for (i = 0; (i < THREADX_NUM_STATES) &&
-                       (ThreadX_thread_states[i].value != thread_status); i++) {
+                       (threadx_thread_states[i].value != thread_status); i++) {
                /* empty */
        }
 
        char *state_desc;
        if  (i < THREADX_NUM_STATES)
-               state_desc = ThreadX_thread_states[i].desc;
+               state_desc = threadx_thread_states[i].desc;
        else
                state_desc = "Unknown state";
 
@@ -595,11 +595,11 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
 
 #endif
 
-static int ThreadX_create(struct target *target)
+static int threadx_create(struct target *target)
 {
-       for (unsigned int i = 0; i < ARRAY_SIZE(ThreadX_params_list); i++)
-               if (strcmp(ThreadX_params_list[i].target_name, target->type->name) == 0) {
-                       target->rtos->rtos_specific_params = (void *)&ThreadX_params_list[i];
+       for (unsigned int i = 0; i < ARRAY_SIZE(threadx_params_list); i++)
+               if (strcmp(threadx_params_list[i].target_name, target->type->name) == 0) {
+                       target->rtos->rtos_specific_params = (void *)&threadx_params_list[i];
                        target->rtos->current_thread = 0;
                        target->rtos->thread_details = NULL;
                        return 0;

diff --git a/src/rtos/chibios.c b/src/rtos/chibios.c
index 2a23017cdbbabdf9d73d4d11b7cd4ce1609a9d68..cb471b4859d41b1dc176e8c276aed2baec6c29c7 100644 (file)
--- a/src/rtos/chibios.c
+++ b/src/rtos/chibios.c
@@ -62,9 +62,9 @@ struct chibios_chdebug {
        uint8_t   cf_off_time;            /**< @brief Offset of @p p_time field.  */
 };
 
-#define GET_CH_KERNEL_MAJOR(codedVersion) ((codedVersion >> 11) & 0x1f)
-#define GET_CH_KERNEL_MINOR(codedVersion) ((codedVersion >> 6) & 0x1f)
-#define GET_CH_KERNEL_PATCH(codedVersion) ((codedVersion >> 0) & 0x3f)
+#define GET_CH_KERNEL_MAJOR(coded_version) ((coded_version >> 11) & 0x1f)
+#define GET_CH_KERNEL_MINOR(coded_version) ((coded_version >> 6) & 0x1f)
+#define GET_CH_KERNEL_PATCH(coded_version) ((coded_version >> 0) & 0x3f)
 
 /**
  * @brief ChibiOS thread states.
@@ -184,10 +184,10 @@ static int chibios_update_memory_signature(struct rtos *rtos)
        }
 
        /* Convert endianness of version field */
-       const uint8_t *versionTarget = (const uint8_t *)
+       const uint8_t *versiontarget = (const uint8_t *)
                                                                                &signature->ch_version;
        signature->ch_version = rtos->target->endianness == TARGET_LITTLE_ENDIAN ?
-                       le_to_h_u32(versionTarget) : be_to_h_u32(versionTarget);
+                       le_to_h_u32(versiontarget) : be_to_h_u32(versiontarget);
 
        const uint16_t ch_version = signature->ch_version;
        LOG_INFO("Successfully loaded memory map of ChibiOS/RT target "

diff --git a/src/rtos/chromium-ec.c b/src/rtos/chromium-ec.c
index 05d5b29b29038fba2acab01034d00d4400488e04..1c8f4e3f4c4787f9363185b37c754ec5a691e62b 100644 (file)
--- a/src/rtos/chromium-ec.c
+++ b/src/rtos/chromium-ec.c
@@ -36,7 +36,7 @@ static const struct chromium_ec_params chromium_ec_params_list[] = {
                .task_offset_sp = 0,
                .task_offset_events = 4,
                .task_offset_runtime = 8,
-               .stacking = &rtos_standard_Cortex_M3_stacking,
+               .stacking = &rtos_standard_cortex_m3_stacking,
 
        },
        {
@@ -46,7 +46,7 @@ static const struct chromium_ec_params chromium_ec_params_list[] = {
                .task_offset_sp = 0,
                .task_offset_events = 4,
                .task_offset_runtime = 8,
-               .stacking = &rtos_standard_Cortex_M3_stacking,
+               .stacking = &rtos_standard_cortex_m3_stacking,
        },
 };
 

diff --git a/src/rtos/eCos.c b/src/rtos/eCos.c
index 1b1e73e60f87e339dd0772729e7e5481bc6757b6..a9feb8019cbb874b9afd1a716d737c2cd78c6ce4 100644 (file)
--- a/src/rtos/eCos.c
+++ b/src/rtos/eCos.c
@@ -84,7 +84,7 @@ static const char * const eCos_symbol_list[] = {
        NULL
 };
 
-const struct rtos_type eCos_rtos = {
+const struct rtos_type ecos_rtos = {
        .name = "eCos",
 
        .detect_rtos = eCos_detect_rtos,

diff --git a/src/rtos/embKernel.c b/src/rtos/embKernel.c
index 620d16baa72958d0df3d918af7e4695487c796c4..259399bc335b5a827253990e133b208ce3708b54 100644 (file)
--- a/src/rtos/embKernel.c
+++ b/src/rtos/embKernel.c
@@ -31,21 +31,21 @@
 
 #define EMBKERNEL_MAX_THREAD_NAME_STR_SIZE (64)
 
-static bool embKernel_detect_rtos(struct target *target);
-static int embKernel_create(struct target *target);
-static int embKernel_update_threads(struct rtos *rtos);
-static int embKernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
+static bool embkernel_detect_rtos(struct target *target);
+static int embkernel_create(struct target *target);
+static int embkernel_update_threads(struct rtos *rtos);
+static int embkernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
                struct rtos_reg **reg_list, int *num_regs);
-static int embKernel_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
+static int embkernel_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
 
-struct rtos_type embKernel_rtos = {
+struct rtos_type embkernel_rtos = {
                .name = "embKernel",
-               .detect_rtos = embKernel_detect_rtos,
-               .create = embKernel_create,
-               .update_threads = embKernel_update_threads,
+               .detect_rtos = embkernel_detect_rtos,
+               .create = embkernel_create,
+               .update_threads = embkernel_update_threads,
                .get_thread_reg_list =
-               embKernel_get_thread_reg_list,
-               .get_symbol_list_to_lookup = embKernel_get_symbol_list_to_lookup,
+               embkernel_get_thread_reg_list,
+               .get_symbol_list_to_lookup = embkernel_get_symbol_list_to_lookup,
 };
 
 enum {
@@ -57,7 +57,7 @@ enum {
        SYMBOL_ID_S_CURRENT_TASK_COUNT = 5,
 };
 
-static const char * const embKernel_symbol_list[] = {
+static const char * const embkernel_symbol_list[] = {
                "Rtos::sCurrentTask",
                "Rtos::sListReady",
                "Rtos::sListSleep",
@@ -66,7 +66,7 @@ static const char * const embKernel_symbol_list[] = {
                "Rtos::sCurrentTaskCount",
                NULL };
 
-struct embKernel_params {
+struct embkernel_params {
        const char *target_name;
        const unsigned char pointer_width;
        const unsigned char thread_count_width;
@@ -80,7 +80,7 @@ struct embKernel_params {
        const struct rtos_register_stacking *stacking_info;
 };
 
-static const struct embKernel_params embKernel_params_list[] = {
+static const struct embkernel_params embkernel_params_list[] = {
                {
                        "cortex_m", /* target_name */
                        4, /* pointer_width */
@@ -92,7 +92,7 @@ static const struct embKernel_params embKernel_params_list[] = {
                        4, /*thread_priority_width */
                        4, /*iterable_next_offset */
                        12, /*iterable_task_owner_offset */
-                       &rtos_embkernel_Cortex_M_stacking, /* stacking_info*/
+                       &rtos_embkernel_cortex_m_stacking, /* stacking_info*/
                },
                { "hla_target", /* target_name */
                        4, /* pointer_width */
@@ -104,11 +104,11 @@ static const struct embKernel_params embKernel_params_list[] = {
                        4, /*thread_priority_width */
                        4, /*iterable_next_offset */
                        12, /*iterable_task_owner_offset */
-                       &rtos_embkernel_Cortex_M_stacking, /* stacking_info */
+                       &rtos_embkernel_cortex_m_stacking, /* stacking_info */
                }
 };
 
-static bool embKernel_detect_rtos(struct target *target)
+static bool embkernel_detect_rtos(struct target *target)
 {
        if (target->rtos->symbols != NULL) {
                if (target->rtos->symbols[SYMBOL_ID_S_CURRENT_TASK].address != 0)
@@ -117,24 +117,24 @@ static bool embKernel_detect_rtos(struct target *target)
        return false;
 }
 
-static int embKernel_create(struct target *target)
+static int embkernel_create(struct target *target)
 {
        size_t i = 0;
-       while ((i < ARRAY_SIZE(embKernel_params_list)) &&
-                       (0 != strcmp(embKernel_params_list[i].target_name, target->type->name)))
+       while ((i < ARRAY_SIZE(embkernel_params_list)) &&
+                       (0 != strcmp(embkernel_params_list[i].target_name, target->type->name)))
                i++;
 
-       if (i >= ARRAY_SIZE(embKernel_params_list)) {
+       if (i >= ARRAY_SIZE(embkernel_params_list)) {
                LOG_WARNING("Could not find target \"%s\" in embKernel compatibility "
                                "list", target->type->name);
                return -1;
        }
 
-       target->rtos->rtos_specific_params = (void *) &embKernel_params_list[i];
+       target->rtos->rtos_specific_params = (void *) &embkernel_params_list[i];
        return 0;
 }
 
-static int embKernel_get_tasks_details(struct rtos *rtos, int64_t iterable, const struct embKernel_params *param,
+static int embkernel_get_tasks_details(struct rtos *rtos, int64_t iterable, const struct embkernel_params *param,
                struct thread_detail *details, const char *state_str)
 {
        int64_t task = 0;
@@ -181,11 +181,11 @@ static int embKernel_get_tasks_details(struct rtos *rtos, int64_t iterable, cons
        return 0;
 }
 
-static int embKernel_update_threads(struct rtos *rtos)
+static int embkernel_update_threads(struct rtos *rtos)
 {
        /* int i = 0; */
        int retval;
-       const struct embKernel_params *param;
+       const struct embkernel_params *param;
 
        if (rtos == NULL)
                return -1;
@@ -206,7 +206,7 @@ static int embKernel_update_threads(struct rtos *rtos)
        /* wipe out previous thread details if any */
        rtos_free_threadlist(rtos);
 
-       param = (const struct embKernel_params *) rtos->rtos_specific_params;
+       param = (const struct embkernel_params *) rtos->rtos_specific_params;
 
        retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_CURRENT_TASK].address, param->pointer_width,
                        (uint8_t *) &rtos->current_thread);
@@ -237,7 +237,7 @@ static int embKernel_update_threads(struct rtos *rtos)
                return ERROR_FAIL;
        }
 
-       int threadIdx = 0;
+       int thread_idx = 0;
        /* Look for ready tasks */
        for (int pri = 0; pri < max_used_priority; pri++) {
                /* Get first item in queue */
@@ -247,9 +247,9 @@ static int embKernel_update_threads(struct rtos *rtos)
                                (uint8_t *) &iterable);
                if (retval != ERROR_OK)
                        return retval;
-               for (; iterable && threadIdx < thread_list_size; threadIdx++) {
+               for (; iterable && thread_idx < thread_list_size; thread_idx++) {
                        /* Get info from this iterable item */
-                       retval = embKernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[threadIdx], "Ready");
+                       retval = embkernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[thread_idx], "Ready");
                        if (retval != ERROR_OK)
                                return retval;
                        /* Get next iterable item */
@@ -265,9 +265,9 @@ static int embKernel_update_threads(struct rtos *rtos)
                        (uint8_t *) &iterable);
        if (retval != ERROR_OK)
                return retval;
-       for (; iterable && threadIdx < thread_list_size; threadIdx++) {
+       for (; iterable && thread_idx < thread_list_size; thread_idx++) {
                /*Get info from this iterable item */
-               retval = embKernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[threadIdx], "Sleeping");
+               retval = embkernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[thread_idx], "Sleeping");
                if (retval != ERROR_OK)
                        return retval;
                /*Get next iterable item */
@@ -283,9 +283,9 @@ static int embKernel_update_threads(struct rtos *rtos)
                        (uint8_t *) &iterable);
        if (retval != ERROR_OK)
                return retval;
-       for (; iterable && threadIdx < thread_list_size; threadIdx++) {
+       for (; iterable && thread_idx < thread_list_size; thread_idx++) {
                /* Get info from this iterable item */
-               retval = embKernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[threadIdx], "Suspended");
+               retval = embkernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[thread_idx], "Suspended");
                if (retval != ERROR_OK)
                        return retval;
                /*Get next iterable item */
@@ -296,16 +296,16 @@ static int embKernel_update_threads(struct rtos *rtos)
        }
 
        rtos->thread_count = 0;
-       rtos->thread_count = threadIdx;
-       LOG_OUTPUT("Found %u tasks\n", (unsigned int)threadIdx);
+       rtos->thread_count = thread_idx;
+       LOG_OUTPUT("Found %u tasks\n", (unsigned int)thread_idx);
        return 0;
 }
 
-static int embKernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
+static int embkernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
                struct rtos_reg **reg_list, int *num_regs)
 {
        int retval;
-       const struct embKernel_params *param;
+       const struct embkernel_params *param;
        int64_t stack_ptr = 0;
 
        if (rtos == NULL)
@@ -317,7 +317,7 @@ static int embKernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
        if (rtos->rtos_specific_params == NULL)
                return -1;
 
-       param = (const struct embKernel_params *) rtos->rtos_specific_params;
+       param = (const struct embkernel_params *) rtos->rtos_specific_params;
 
        /* Read the stack pointer */
        retval = target_read_buffer(rtos->target, thread_id + param->thread_stack_offset, param->pointer_width,
@@ -330,13 +330,13 @@ static int embKernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
        return rtos_generic_stack_read(rtos->target, param->stacking_info, stack_ptr, reg_list, num_regs);
 }
 
-static int embKernel_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
+static int embkernel_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
 {
        unsigned int i;
-       *symbol_list = calloc(ARRAY_SIZE(embKernel_symbol_list), sizeof(struct symbol_table_elem));
+       *symbol_list = calloc(ARRAY_SIZE(embkernel_symbol_list), sizeof(struct symbol_table_elem));
 
-       for (i = 0; i < ARRAY_SIZE(embKernel_symbol_list); i++)
-               (*symbol_list)[i].symbol_name = embKernel_symbol_list[i];
+       for (i = 0; i < ARRAY_SIZE(embkernel_symbol_list); i++)
+               (*symbol_list)[i].symbol_name = embkernel_symbol_list[i];
 
        return 0;
 }

diff --git a/src/rtos/linux.c b/src/rtos/linux.c
index 4b96a931dafaa78c0b9133b09885b8ecf10253aa..0a15efaaca31c9ebd31a015a4d09b3136877b936 100644 (file)
--- a/src/rtos/linux.c
+++ b/src/rtos/linux.c
@@ -260,7 +260,7 @@ static int linux_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list
 
 static char *linux_ps_command(struct target *target);
 
-const struct rtos_type Linux_os = {
+const struct rtos_type linux_rtos = {
        .name = "linux",
        .detect_rtos = linux_os_detect,
        .create = linux_os_create,
@@ -431,8 +431,8 @@ static int get_current(struct target *target, int create)
                buf = reg_list[13]->value;
                val = get_buffer(target, buf);
                ti_addr = (val & 0xffffe000);
-               uint32_t TS_addr = ti_addr + 0xc;
-               retval = fill_buffer(target, TS_addr, buffer);
+               uint32_t ts_addr = ti_addr + 0xc;
+               retval = fill_buffer(target, ts_addr, buffer);
 
                if (retval == ERROR_OK) {
                        uint32_t TS = get_buffer(target, buffer);
@@ -1163,7 +1163,7 @@ static int linux_thread_extra_info(struct target *target,
        return ERROR_OK;
 }
 
-static int linux_gdb_T_packet(struct connection *connection,
+static int linux_gdb_t_packet(struct connection *connection,
        struct target *target, char const *packet, int packet_size)
 {
        int64_t threadid;
@@ -1304,7 +1304,7 @@ static int linux_thread_packet(struct connection *connection, char const *packet
        switch (packet[0]) {
                case 'T':               /* Is thread alive?*/
 
-                       linux_gdb_T_packet(connection, target, packet, packet_size);
+                       linux_gdb_t_packet(connection, target, packet, packet_size);
                        break;
                case 'H':               /* Set current thread */
                        /*  ( 'c' for step and continue, 'g' for all other operations )*/

diff --git a/src/rtos/rtos.c b/src/rtos/rtos.c
index 0374e9b5bb42c139122287e8f42a7d51b5b15c64..5fc958db20b52c1c27729674c58bc8fe5ffba489 100644 (file)
--- a/src/rtos/rtos.c
+++ b/src/rtos/rtos.c
@@ -27,30 +27,30 @@
 #include "server/gdb_server.h"
 
 /* RTOSs */
-extern struct rtos_type FreeRTOS_rtos;
-extern struct rtos_type ThreadX_rtos;
-extern struct rtos_type eCos_rtos;
-extern struct rtos_type Linux_os;
+extern struct rtos_type freertos_rtos;
+extern struct rtos_type threadx_rtos;
+extern struct rtos_type ecos_rtos;
+extern struct rtos_type linux_rtos;
 extern struct rtos_type chibios_rtos;
 extern struct rtos_type chromium_ec_rtos;
-extern struct rtos_type embKernel_rtos;
+extern struct rtos_type embkernel_rtos;
 extern struct rtos_type mqx_rtos;
-extern struct rtos_type uCOS_III_rtos;
+extern struct rtos_type ucos_iii_rtos;
 extern struct rtos_type nuttx_rtos;
 extern struct rtos_type hwthread_rtos;
 extern struct rtos_type riot_rtos;
 extern struct rtos_type zephyr_rtos;
 
 static struct rtos_type *rtos_types[] = {
-       &ThreadX_rtos,
-       &FreeRTOS_rtos,
-       &eCos_rtos,
-       &Linux_os,
+       &threadx_rtos,
+       &freertos_rtos,
+       &ecos_rtos,
+       &linux_rtos,
        &chibios_rtos,
        &chromium_ec_rtos,
-       &embKernel_rtos,
+       &embkernel_rtos,
        &mqx_rtos,
-       &uCOS_III_rtos,
+       &ucos_iii_rtos,
        &nuttx_rtos,
        &riot_rtos,
        &zephyr_rtos,

diff --git a/src/rtos/rtos_embkernel_stackings.c b/src/rtos/rtos_embkernel_stackings.c
index 543a8cd2ac4da0334a7e13128d6e444556315cf6..cd4c22eac0c4d8b9f80a87be4e1403ab9b5cd59a 100644 (file)
--- a/src/rtos/rtos_embkernel_stackings.c
+++ b/src/rtos/rtos_embkernel_stackings.c
@@ -24,7 +24,7 @@
 #include "target/armv7m.h"
 #include "rtos_standard_stackings.h"
 
-static const struct stack_register_offset rtos_embkernel_Cortex_M_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
+static const struct stack_register_offset rtos_embkernel_cortex_m_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
        { ARMV7M_R0,   0x24, 32 },              /* r0   */
        { ARMV7M_R1,   0x28, 32 },              /* r1   */
        { ARMV7M_R2,   0x2c, 32 },              /* r2   */
@@ -44,10 +44,10 @@ static const struct stack_register_offset rtos_embkernel_Cortex_M_stack_offsets[
        { ARMV7M_xPSR, 0x40, 32 },              /* xPSR */
 };
 
-const struct rtos_register_stacking rtos_embkernel_Cortex_M_stacking = {
+const struct rtos_register_stacking rtos_embkernel_cortex_m_stacking = {
        0x40,                                   /* stack_registers_size */
        -1,                                             /* stack_growth_direction */
        ARMV7M_NUM_CORE_REGS,   /* num_output_registers */
        rtos_generic_stack_align8,      /* stack_alignment */
-       rtos_embkernel_Cortex_M_stack_offsets   /* register_offsets */
+       rtos_embkernel_cortex_m_stack_offsets   /* register_offsets */
 };

diff --git a/src/rtos/rtos_embkernel_stackings.h b/src/rtos/rtos_embkernel_stackings.h
index 89a0c2f1254c241f7b47081650d6a4830dcf8ab7..7850bebcd0d23f6fe35720a356f8845e2eb1cd1e 100644 (file)
--- a/src/rtos/rtos_embkernel_stackings.h
+++ b/src/rtos/rtos_embkernel_stackings.h
@@ -25,6 +25,6 @@
 
 #include "rtos.h"
 
-extern const struct rtos_register_stacking rtos_embkernel_Cortex_M_stacking;
+extern const struct rtos_register_stacking rtos_embkernel_cortex_m_stacking;
 
 #endif /* OPENOCD_RTOS_RTOS_EMBKERNEL_STACKINGS_H */

diff --git a/src/rtos/rtos_riot_stackings.c b/src/rtos/rtos_riot_stackings.c
index 23f4d1786eebfe65e2942e6a123255cd11243b22..98e02edfcbdfbc0354cd960d3a4a50eae8829f63 100644 (file)
--- a/src/rtos/rtos_riot_stackings.c
+++ b/src/rtos/rtos_riot_stackings.c
@@ -32,7 +32,7 @@ static int64_t rtos_riot_cortex_m_stack_align(struct target *target,
        int64_t stack_ptr)
 {
        const int XPSR_OFFSET = 0x40;
-       return rtos_Cortex_M_stack_align(target, stack_data, stacking,
+       return rtos_cortex_m_stack_align(target, stack_data, stacking,
                stack_ptr, XPSR_OFFSET);
 }
 

diff --git a/src/rtos/rtos_standard_stackings.c b/src/rtos/rtos_standard_stackings.c
index 7b054cbbcb31c457860dc25f73fc8e3b4f53e9fd..90c642a0070e95ed50e5752b4dbf256bf9696735 100644 (file)
--- a/src/rtos/rtos_standard_stackings.c
+++ b/src/rtos/rtos_standard_stackings.c
@@ -23,7 +23,7 @@
 #include "rtos.h"
 #include "target/armv7m.h"
 
-static const struct stack_register_offset rtos_standard_Cortex_M3_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
+static const struct stack_register_offset rtos_standard_cortex_m3_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
        { ARMV7M_R0,   0x20, 32 },              /* r0   */
        { ARMV7M_R1,   0x24, 32 },              /* r1   */
        { ARMV7M_R2,   0x28, 32 },              /* r2   */
@@ -43,7 +43,7 @@ static const struct stack_register_offset rtos_standard_Cortex_M3_stack_offsets[
        { ARMV7M_xPSR, 0x3c, 32 },              /* xPSR */
 };
 
-static const struct stack_register_offset rtos_standard_Cortex_M4F_stack_offsets[] = {
+static const struct stack_register_offset rtos_standard_cortex_m4f_stack_offsets[] = {
        { ARMV7M_R0,   0x24, 32 },              /* r0   */
        { ARMV7M_R1,   0x28, 32 },              /* r1   */
        { ARMV7M_R2,   0x2c, 32 },              /* r2   */
@@ -63,7 +63,7 @@ static const struct stack_register_offset rtos_standard_Cortex_M4F_stack_offsets
        { ARMV7M_xPSR, 0x40, 32 },              /* xPSR */
 };
 
-static const struct stack_register_offset rtos_standard_Cortex_M4F_FPU_stack_offsets[] = {
+static const struct stack_register_offset rtos_standard_cortex_m4f_fpu_stack_offsets[] = {
        { ARMV7M_R0,   0x64, 32 },              /* r0   */
        { ARMV7M_R1,   0x68, 32 },              /* r1   */
        { ARMV7M_R2,   0x6c, 32 },              /* r2   */
@@ -84,7 +84,7 @@ static const struct stack_register_offset rtos_standard_Cortex_M4F_FPU_stack_off
 };
 
 
-static const struct stack_register_offset rtos_standard_Cortex_R4_stack_offsets[] = {
+static const struct stack_register_offset rtos_standard_cortex_r4_stack_offsets[] = {
        { 0,  0x08, 32 },               /* r0  (a1)   */
        { 1,  0x0c, 32 },               /* r1  (a2)  */
        { 2,  0x10, 32 },               /* r2  (a3)  */
@@ -113,7 +113,7 @@ static const struct stack_register_offset rtos_standard_Cortex_R4_stack_offsets[
        { 26, 0x04, 32 },               /* CSPR */
 };
 
-static const struct stack_register_offset rtos_standard_NDS32_N1068_stack_offsets[] = {
+static const struct stack_register_offset rtos_standard_nds32_n1068_stack_offsets[] = {
        { 0,  0x88, 32 },               /* R0  */
        { 1,  0x8C, 32 },               /* R1 */
        { 2,  0x14, 32 },               /* R2 */
@@ -199,7 +199,7 @@ int64_t rtos_generic_stack_align8(struct target *target,
  * This is just a helper function for use in the calculate_process_stack
  * function for a given architecture/rtos.
  */
-int64_t rtos_Cortex_M_stack_align(struct target *target,
+int64_t rtos_cortex_m_stack_align(struct target *target,
        const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
        int64_t stack_ptr, size_t xpsr_offset)
 {
@@ -220,70 +220,70 @@ int64_t rtos_Cortex_M_stack_align(struct target *target,
        return new_stack_ptr;
 }
 
-static int64_t rtos_standard_Cortex_M3_stack_align(struct target *target,
+static int64_t rtos_standard_cortex_m3_stack_align(struct target *target,
        const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
        int64_t stack_ptr)
 {
        const int XPSR_OFFSET = 0x3c;
-       return rtos_Cortex_M_stack_align(target, stack_data, stacking,
+       return rtos_cortex_m_stack_align(target, stack_data, stacking,
                stack_ptr, XPSR_OFFSET);
 }
 
-static int64_t rtos_standard_Cortex_M4F_stack_align(struct target *target,
+static int64_t rtos_standard_cortex_m4f_stack_align(struct target *target,
        const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
        int64_t stack_ptr)
 {
        const int XPSR_OFFSET = 0x40;
-       return rtos_Cortex_M_stack_align(target, stack_data, stacking,
+       return rtos_cortex_m_stack_align(target, stack_data, stacking,
                stack_ptr, XPSR_OFFSET);
 }
 
-static int64_t rtos_standard_Cortex_M4F_FPU_stack_align(struct target *target,
+static int64_t rtos_standard_cortex_m4f_fpu_stack_align(struct target *target,
        const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
        int64_t stack_ptr)
 {
        const int XPSR_OFFSET = 0x80;
-       return rtos_Cortex_M_stack_align(target, stack_data, stacking,
+       return rtos_cortex_m_stack_align(target, stack_data, stacking,
                stack_ptr, XPSR_OFFSET);
 }
 
 
-const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking = {
+const struct rtos_register_stacking rtos_standard_cortex_m3_stacking = {
        0x40,                                   /* stack_registers_size */
        -1,                                             /* stack_growth_direction */
        ARMV7M_NUM_CORE_REGS,   /* num_output_registers */
-       rtos_standard_Cortex_M3_stack_align,    /* stack_alignment */
-       rtos_standard_Cortex_M3_stack_offsets   /* register_offsets */
+       rtos_standard_cortex_m3_stack_align,    /* stack_alignment */
+       rtos_standard_cortex_m3_stack_offsets   /* register_offsets */
 };
 
-const struct rtos_register_stacking rtos_standard_Cortex_M4F_stacking = {
+const struct rtos_register_stacking rtos_standard_cortex_m4f_stacking = {
        0x44,                                   /* stack_registers_size 4 more for LR*/
        -1,                                             /* stack_growth_direction */
        ARMV7M_NUM_CORE_REGS,   /* num_output_registers */
-       rtos_standard_Cortex_M4F_stack_align,   /* stack_alignment */
-       rtos_standard_Cortex_M4F_stack_offsets  /* register_offsets */
+       rtos_standard_cortex_m4f_stack_align,   /* stack_alignment */
+       rtos_standard_cortex_m4f_stack_offsets  /* register_offsets */
 };
 
-const struct rtos_register_stacking rtos_standard_Cortex_M4F_FPU_stacking = {
+const struct rtos_register_stacking rtos_standard_cortex_m4f_fpu_stacking = {
        0xcc,                                   /* stack_registers_size 4 more for LR + 48 more for FPU S0-S15 register*/
        -1,                                             /* stack_growth_direction */
        ARMV7M_NUM_CORE_REGS,   /* num_output_registers */
-       rtos_standard_Cortex_M4F_FPU_stack_align,       /* stack_alignment */
-       rtos_standard_Cortex_M4F_FPU_stack_offsets      /* register_offsets */
+       rtos_standard_cortex_m4f_fpu_stack_align,       /* stack_alignment */
+       rtos_standard_cortex_m4f_fpu_stack_offsets      /* register_offsets */
 };
 
-const struct rtos_register_stacking rtos_standard_Cortex_R4_stacking = {
+const struct rtos_register_stacking rtos_standard_cortex_r4_stacking = {
        0x48,                           /* stack_registers_size */
        -1,                                     /* stack_growth_direction */
        26,                                     /* num_output_registers */
        rtos_generic_stack_align8,      /* stack_alignment */
-       rtos_standard_Cortex_R4_stack_offsets   /* register_offsets */
+       rtos_standard_cortex_r4_stack_offsets   /* register_offsets */
 };
 
-const struct rtos_register_stacking rtos_standard_NDS32_N1068_stacking = {
+const struct rtos_register_stacking rtos_standard_nds32_n1068_stacking = {
        0x90,                           /* stack_registers_size */
        -1,                                     /* stack_growth_direction */
        32,                                     /* num_output_registers */
        rtos_generic_stack_align8,      /* stack_alignment */
-       rtos_standard_NDS32_N1068_stack_offsets /* register_offsets */
+       rtos_standard_nds32_n1068_stack_offsets /* register_offsets */
 };

diff --git a/src/rtos/rtos_standard_stackings.h b/src/rtos/rtos_standard_stackings.h
index 6971efd1eca1be68120bea609bf9927b50d6582e..ad319d2a086aaf1971c95a4da4987519a4db3a1c 100644 (file)
--- a/src/rtos/rtos_standard_stackings.h
+++ b/src/rtos/rtos_standard_stackings.h
@@ -25,15 +25,15 @@
 
 #include "rtos.h"
 
-extern const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking;
-extern const struct rtos_register_stacking rtos_standard_Cortex_M4F_stacking;
-extern const struct rtos_register_stacking rtos_standard_Cortex_M4F_FPU_stacking;
-extern const struct rtos_register_stacking rtos_standard_Cortex_R4_stacking;
-extern const struct rtos_register_stacking rtos_standard_NDS32_N1068_stacking;
+extern const struct rtos_register_stacking rtos_standard_cortex_m3_stacking;
+extern const struct rtos_register_stacking rtos_standard_cortex_m4f_stacking;
+extern const struct rtos_register_stacking rtos_standard_cortex_m4f_fpu_stacking;
+extern const struct rtos_register_stacking rtos_standard_cortex_r4_stacking;
+extern const struct rtos_register_stacking rtos_standard_nds32_n1068_stacking;
 int64_t rtos_generic_stack_align8(struct target *target,
        const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
        int64_t stack_ptr);
-int64_t rtos_Cortex_M_stack_align(struct target *target,
+int64_t rtos_cortex_m_stack_align(struct target *target,
        const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
        int64_t stack_ptr, size_t xpsr_offset);
 

diff --git a/src/rtos/rtos_ucos_iii_stackings.c b/src/rtos/rtos_ucos_iii_stackings.c
index d093563bae899e8ee1a9b8ae48919651f855ad88..4ae0d7dc8ac6845bfb37aa5f5ef6df0366ff0215 100644 (file)
--- a/src/rtos/rtos_ucos_iii_stackings.c
+++ b/src/rtos/rtos_ucos_iii_stackings.c
@@ -26,7 +26,7 @@
 #include <target/armv7m.h>
 #include <target/esirisc.h>
 
-static const struct stack_register_offset rtos_uCOS_III_Cortex_M_stack_offsets[] = {
+static const struct stack_register_offset rtos_ucos_iii_cortex_m_stack_offsets[] = {
        { ARMV7M_R0,   0x20, 32 },      /* r0   */
        { ARMV7M_R1,   0x24, 32 },      /* r1   */
        { ARMV7M_R2,   0x28, 32 },      /* r2   */
@@ -46,7 +46,7 @@ static const struct stack_register_offset rtos_uCOS_III_Cortex_M_stack_offsets[]
        { ARMV7M_xPSR, 0x3c, 32 },      /* xPSR */
 };
 
-static const struct stack_register_offset rtos_uCOS_III_eSi_RISC_stack_offsets[] = {
+static const struct stack_register_offset rtos_ucos_iii_esi_risc_stack_offsets[] = {
        { ESIRISC_SP,  -2,   32 },      /* sp   */
        { ESIRISC_RA,  0x48, 32 },      /* ra   */
        { ESIRISC_R2,  0x44, 32 },      /* r2   */
@@ -67,18 +67,18 @@ static const struct stack_register_offset rtos_uCOS_III_eSi_RISC_stack_offsets[]
        { ESIRISC_CAS, 0x08, 32 },      /* CAS  */
 };
 
-const struct rtos_register_stacking rtos_uCOS_III_Cortex_M_stacking = {
+const struct rtos_register_stacking rtos_ucos_iii_cortex_m_stacking = {
        0x40,                                                                                           /* stack_registers_size */
        -1,                                                                                                     /* stack_growth_direction */
-       ARRAY_SIZE(rtos_uCOS_III_Cortex_M_stack_offsets),       /* num_output_registers */
+       ARRAY_SIZE(rtos_ucos_iii_cortex_m_stack_offsets),       /* num_output_registers */
        rtos_generic_stack_align8,                                                      /* stack_alignment */
-       rtos_uCOS_III_Cortex_M_stack_offsets                            /* register_offsets */
+       rtos_ucos_iii_cortex_m_stack_offsets                            /* register_offsets */
 };
 
-const struct rtos_register_stacking rtos_uCOS_III_eSi_RISC_stacking = {
+const struct rtos_register_stacking rtos_ucos_iii_esi_risc_stacking = {
        0x4c,                                                                                           /* stack_registers_size */
        -1,                                                                                                     /* stack_growth_direction */
-       ARRAY_SIZE(rtos_uCOS_III_eSi_RISC_stack_offsets),       /* num_output_registers */
+       ARRAY_SIZE(rtos_ucos_iii_esi_risc_stack_offsets),       /* num_output_registers */
        NULL,                                                                                           /* stack_alignment */
-       rtos_uCOS_III_eSi_RISC_stack_offsets                            /* register_offsets */
+       rtos_ucos_iii_esi_risc_stack_offsets                            /* register_offsets */
 };

diff --git a/src/rtos/rtos_ucos_iii_stackings.h b/src/rtos/rtos_ucos_iii_stackings.h
index a9398138b5814883996f83c8ea5511f5e133a203..f2f120fd9f218e6a31cd7394c3374a15a938d303 100644 (file)
--- a/src/rtos/rtos_ucos_iii_stackings.h
+++ b/src/rtos/rtos_ucos_iii_stackings.h
@@ -25,7 +25,7 @@
 
 #include <rtos/rtos.h>
 
-extern const struct rtos_register_stacking rtos_uCOS_III_Cortex_M_stacking;
-extern const struct rtos_register_stacking rtos_uCOS_III_eSi_RISC_stacking;
+extern const struct rtos_register_stacking rtos_ucos_iii_cortex_m_stacking;
+extern const struct rtos_register_stacking rtos_ucos_iii_esi_risc_stacking;
 
 #endif /* OPENOCD_RTOS_RTOS_UCOS_III_STACKINGS_H */

diff --git a/src/rtos/uCOS-III.c b/src/rtos/uCOS-III.c
index 1aed4846f51144a2a23ab6a203521e9cd89b4057..26b53a9271dda022bdc29526a1790b6b73885f6d 100644 (file)
--- a/src/rtos/uCOS-III.c
+++ b/src/rtos/uCOS-III.c
@@ -37,7 +37,7 @@
 #define UCOS_III_MAX_THREADS 256
 #endif
 
-struct uCOS_III_params {
+struct ucos_iii_params {
        const char *target_name;
        const unsigned char pointer_width;
        symbol_address_t thread_stack_offset;
@@ -53,7 +53,7 @@ struct uCOS_III_params {
        symbol_address_t threads[];
 };
 
-static const struct uCOS_III_params uCOS_III_params_list[] = {
+static const struct ucos_iii_params ucos_iii_params_list[] = {
        {
                "cortex_m",                                                     /* target_name */
                sizeof(uint32_t),                                       /* pointer_width */
@@ -65,7 +65,7 @@ static const struct uCOS_III_params uCOS_III_params_list[] = {
                0,                                                                      /* thread_next_offset */
                false,                                                          /* thread_offsets_updated */
                1,                                                                      /* threadid_start */
-               &rtos_uCOS_III_Cortex_M_stacking,       /* stacking_info */
+               &rtos_ucos_iii_cortex_m_stacking,       /* stacking_info */
                0,                                                                      /* num_threads */
        },
        {
@@ -79,12 +79,12 @@ static const struct uCOS_III_params uCOS_III_params_list[] = {
                0,                                                                      /* thread_next_offset */
                false,                                                          /* thread_offsets_updated */
                1,                                                                      /* threadid_start */
-               &rtos_uCOS_III_eSi_RISC_stacking,       /* stacking_info */
+               &rtos_ucos_iii_esi_risc_stacking,       /* stacking_info */
                0,                                                                      /* num_threads */
        },
 };
 
-static const char * const uCOS_III_symbol_list[] = {
+static const char * const ucos_iii_symbol_list[] = {
        "OSRunning",
        "OSTCBCurPtr",
        "OSTaskDbgListPtr",
@@ -100,7 +100,7 @@ static const char * const uCOS_III_symbol_list[] = {
        NULL
 };
 
-enum uCOS_III_symbol_values {
+enum ucos_iii_symbol_values {
        UCOS_III_VAL_OS_RUNNING,
        UCOS_III_VAL_OS_TCB_CUR_PTR,
        UCOS_III_VAL_OS_TASK_DBG_LIST_PTR,
@@ -115,7 +115,7 @@ enum uCOS_III_symbol_values {
        UCOS_III_VAL_OS_TCB_DBG_NEXT_PTR_OFFSET,
 };
 
-static const char * const uCOS_III_thread_state_list[] = {
+static const char * const ucos_iii_thread_state_list[] = {
        "Ready",
        "Delay",
        "Pend",
@@ -126,10 +126,10 @@ static const char * const uCOS_III_thread_state_list[] = {
        "Pend Timeout Suspended",
 };
 
-static int uCOS_III_find_or_create_thread(struct rtos *rtos, symbol_address_t thread_address,
+static int ucos_iii_find_or_create_thread(struct rtos *rtos, symbol_address_t thread_address,
                threadid_t *threadid)
 {
-       struct uCOS_III_params *params = rtos->rtos_specific_params;
+       struct ucos_iii_params *params = rtos->rtos_specific_params;
        size_t thread_index;
 
        for (thread_index = 0; thread_index < params->num_threads; thread_index++)
@@ -148,10 +148,10 @@ found:
        return ERROR_OK;
 }
 
-static int uCOS_III_find_thread_address(struct rtos *rtos, threadid_t threadid,
+static int ucos_iii_find_thread_address(struct rtos *rtos, threadid_t threadid,
                symbol_address_t *thread_address)
 {
-       struct uCOS_III_params *params = rtos->rtos_specific_params;
+       struct ucos_iii_params *params = rtos->rtos_specific_params;
        size_t thread_index;
 
        thread_index = threadid - params->threadid_start;
@@ -164,9 +164,9 @@ static int uCOS_III_find_thread_address(struct rtos *rtos, threadid_t threadid,
        return ERROR_OK;
 }
 
-static int uCOS_III_find_last_thread_address(struct rtos *rtos, symbol_address_t *thread_address)
+static int ucos_iii_find_last_thread_address(struct rtos *rtos, symbol_address_t *thread_address)
 {
-       struct uCOS_III_params *params = rtos->rtos_specific_params;
+       struct ucos_iii_params *params = rtos->rtos_specific_params;
        int retval;
 
        /* read the thread list head */
@@ -200,15 +200,15 @@ static int uCOS_III_find_last_thread_address(struct rtos *rtos, symbol_address_t
        return ERROR_OK;
 }
 
-static int uCOS_III_update_thread_offsets(struct rtos *rtos)
+static int ucos_iii_update_thread_offsets(struct rtos *rtos)
 {
-       struct uCOS_III_params *params = rtos->rtos_specific_params;
+       struct ucos_iii_params *params = rtos->rtos_specific_params;
 
        if (params->thread_offsets_updated)
                return ERROR_OK;
 
        const struct thread_offset_map {
-               enum uCOS_III_symbol_values symbol_value;
+               enum ucos_iii_symbol_values symbol_value;
                symbol_address_t *thread_offset;
        } thread_offset_maps[] = {
                {
@@ -255,15 +255,15 @@ static int uCOS_III_update_thread_offsets(struct rtos *rtos)
        return ERROR_OK;
 }
 
-static bool uCOS_III_detect_rtos(struct target *target)
+static bool ucos_iii_detect_rtos(struct target *target)
 {
        return target->rtos->symbols != NULL &&
                        target->rtos->symbols[UCOS_III_VAL_OS_RUNNING].address != 0;
 }
 
-static int uCOS_III_reset_handler(struct target *target, enum target_reset_mode reset_mode, void *priv)
+static int ucos_iii_reset_handler(struct target *target, enum target_reset_mode reset_mode, void *priv)
 {
-       struct uCOS_III_params *params = target->rtos->rtos_specific_params;
+       struct ucos_iii_params *params = target->rtos->rtos_specific_params;
 
        params->thread_offsets_updated = false;
        params->num_threads = 0;
@@ -271,22 +271,22 @@ static int uCOS_III_reset_handler(struct target *target, enum target_reset_mode
        return ERROR_OK;
 }
 
-static int uCOS_III_create(struct target *target)
+static int ucos_iii_create(struct target *target)
 {
-       struct uCOS_III_params *params;
+       struct ucos_iii_params *params;
 
-       for (size_t i = 0; i < ARRAY_SIZE(uCOS_III_params_list); i++)
-               if (strcmp(uCOS_III_params_list[i].target_name, target->type->name) == 0) {
+       for (size_t i = 0; i < ARRAY_SIZE(ucos_iii_params_list); i++)
+               if (strcmp(ucos_iii_params_list[i].target_name, target->type->name) == 0) {
                        params = malloc(sizeof(*params) + (UCOS_III_MAX_THREADS * sizeof(*params->threads)));
                        if (params == NULL) {
                                LOG_ERROR("uCOS-III: out of memory");
                                return ERROR_FAIL;
                        }
 
-                       memcpy(params, &uCOS_III_params_list[i], sizeof(uCOS_III_params_list[i]));
+                       memcpy(params, &ucos_iii_params_list[i], sizeof(ucos_iii_params_list[i]));
                        target->rtos->rtos_specific_params = (void *)params;
 
-                       target_register_reset_callback(uCOS_III_reset_handler, NULL);
+                       target_register_reset_callback(ucos_iii_reset_handler, NULL);
 
                        return ERROR_OK;
                }
@@ -295,9 +295,9 @@ static int uCOS_III_create(struct target *target)
        return ERROR_FAIL;
 }
 
-static int uCOS_III_update_threads(struct rtos *rtos)
+static int ucos_iii_update_threads(struct rtos *rtos)
 {
-       struct uCOS_III_params *params = rtos->rtos_specific_params;
+       struct ucos_iii_params *params = rtos->rtos_specific_params;
        int retval;
 
        if (rtos->symbols == NULL) {
@@ -340,7 +340,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
        }
 
        /* update thread offsets */
-       retval = uCOS_III_update_thread_offsets(rtos);
+       retval = ucos_iii_update_thread_offsets(rtos);
        if (retval != ERROR_OK) {
                LOG_ERROR("uCOS-III: failed to update thread offsets");
                return retval;
@@ -380,7 +380,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
         */
        symbol_address_t thread_address = 0;
 
-       retval = uCOS_III_find_last_thread_address(rtos, &thread_address);
+       retval = ucos_iii_find_last_thread_address(rtos, &thread_address);
        if (retval != ERROR_OK) {
                LOG_ERROR("uCOS-III: failed to find last thread address");
                return retval;
@@ -391,7 +391,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
                char thread_str_buffer[UCOS_III_MAX_STRLEN + 1];
 
                /* find or create new threadid */
-               retval = uCOS_III_find_or_create_thread(rtos, thread_address, &thread_detail->threadid);
+               retval = ucos_iii_find_or_create_thread(rtos, thread_address, &thread_detail->threadid);
                if (retval != ERROR_OK) {
                        LOG_ERROR("uCOS-III: failed to find or create thread");
                        return retval;
@@ -449,8 +449,8 @@ static int uCOS_III_update_threads(struct rtos *rtos)
 
                const char *thread_state_str;
 
-               if (thread_state < ARRAY_SIZE(uCOS_III_thread_state_list))
-                       thread_state_str = uCOS_III_thread_state_list[thread_state];
+               if (thread_state < ARRAY_SIZE(ucos_iii_thread_state_list))
+                       thread_state_str = ucos_iii_thread_state_list[thread_state];
                else
                        thread_state_str = "Unknown";
 
@@ -473,16 +473,16 @@ static int uCOS_III_update_threads(struct rtos *rtos)
        return ERROR_OK;
 }
 
-static int uCOS_III_get_thread_reg_list(struct rtos *rtos, threadid_t threadid,
+static int ucos_iii_get_thread_reg_list(struct rtos *rtos, threadid_t threadid,
                struct rtos_reg **reg_list, int *num_regs)
 {
-       struct uCOS_III_params *params = rtos->rtos_specific_params;
+       struct ucos_iii_params *params = rtos->rtos_specific_params;
        int retval;
 
        /* find thread address for threadid */
        symbol_address_t thread_address = 0;
 
-       retval = uCOS_III_find_thread_address(rtos, threadid, &thread_address);
+       retval = ucos_iii_find_thread_address(rtos, threadid, &thread_address);
        if (retval != ERROR_OK) {
                LOG_ERROR("uCOS-III: failed to find thread address");
                return retval;
@@ -508,25 +508,25 @@ static int uCOS_III_get_thread_reg_list(struct rtos *rtos, threadid_t threadid,
                        num_regs);
 }
 
-static int uCOS_III_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
+static int ucos_iii_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
 {
-       *symbol_list = calloc(ARRAY_SIZE(uCOS_III_symbol_list), sizeof(struct symbol_table_elem));
+       *symbol_list = calloc(ARRAY_SIZE(ucos_iii_symbol_list), sizeof(struct symbol_table_elem));
        if (*symbol_list == NULL) {
                LOG_ERROR("uCOS-III: out of memory");
                return ERROR_FAIL;
        }
 
-       for (size_t i = 0; i < ARRAY_SIZE(uCOS_III_symbol_list); i++)
-               (*symbol_list)[i].symbol_name = uCOS_III_symbol_list[i];
+       for (size_t i = 0; i < ARRAY_SIZE(ucos_iii_symbol_list); i++)
+               (*symbol_list)[i].symbol_name = ucos_iii_symbol_list[i];
 
        return ERROR_OK;
 }
 
-const struct rtos_type uCOS_III_rtos = {
+const struct rtos_type ucos_iii_rtos = {
        .name = "uCOS-III",
-       .detect_rtos = uCOS_III_detect_rtos,
-       .create = uCOS_III_create,
-       .update_threads = uCOS_III_update_threads,
-       .get_thread_reg_list = uCOS_III_get_thread_reg_list,
-       .get_symbol_list_to_lookup = uCOS_III_get_symbol_list_to_lookup,
+       .detect_rtos = ucos_iii_detect_rtos,
+       .create = ucos_iii_create,
+       .update_threads = ucos_iii_update_threads,
+       .get_thread_reg_list = ucos_iii_get_thread_reg_list,
+       .get_symbol_list_to_lookup = ucos_iii_get_symbol_list_to_lookup,
 };

diff --git a/src/rtos/zephyr.c b/src/rtos/zephyr.c
index e5d683507207d4e08f5d21b5304aecd8a7c5622e..b594b2b531366f3f487d3a2f1e037e8745c3caec 100644 (file)
--- a/src/rtos/zephyr.c
+++ b/src/rtos/zephyr.c
@@ -193,7 +193,7 @@ static int64_t zephyr_cortex_m_stack_align(struct target *target,
                const uint8_t *stack_data,
                const struct rtos_register_stacking *stacking, int64_t stack_ptr)
 {
-       return rtos_Cortex_M_stack_align(target, stack_data, stacking,
+       return rtos_cortex_m_stack_align(target, stack_data, stacking,
                        stack_ptr, ARM_XPSR_OFFSET);
 }