[OpenOCD-commit] Main OpenOCD repository branch, master, updated. v0.11.0-245-g920cacd74

[OpenOCD-Gerrit <ope...@us...>]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Main OpenOCD repository".

The branch, master has been updated
       via  920cacd74c4cd9c54d20c5c0738d8d28a456fdf1 (commit)
       via  a489058d7b1d7bab8d0e4db53f98b7762d7482a2 (commit)
      from  3ad52aa34f6763dddc2a903c255a09f7c7e21ed7 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 920cacd74c4cd9c54d20c5c0738d8d28a456fdf1
Author: Antonio Borneo <bor...@gm...>
Date:   Sun Jun 6 19:22:30 2021 +0200

    rtos/eCos: rename CamelCase symbols
    
    Convert CamelCase enum in uppercase and the other symbols in
    lowercase.
    
    Change-Id: I141c55bdfe6ef2a2da28d1da15a283a644ae7cb2
    Signed-off-by: Antonio Borneo <bor...@gm...>
    Reviewed-on: http://openocd.zylin.com/6306
    Tested-by: jenkins

diff --git a/src/rtos/eCos.c b/src/rtos/eCos.c
index a9feb8019..b060a812a 100644
--- a/src/rtos/eCos.c
+++ b/src/rtos/eCos.c
@@ -27,18 +27,18 @@
 #include "helper/types.h"
 #include "rtos_ecos_stackings.h"
 
-static bool eCos_detect_rtos(struct target *target);
-static int eCos_create(struct target *target);
-static int eCos_update_threads(struct rtos *rtos);
-static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, struct rtos_reg **reg_list, int *num_regs);
-static int eCos_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
+static bool ecos_detect_rtos(struct target *target);
+static int ecos_create(struct target *target);
+static int ecos_update_threads(struct rtos *rtos);
+static int ecos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, struct rtos_reg **reg_list, int *num_regs);
+static int ecos_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
 
-struct eCos_thread_state {
+struct ecos_thread_state {
 	int value;
 	const char *desc;
 };
 
-static const struct eCos_thread_state eCos_thread_states[] = {
+static const struct ecos_thread_state ecos_thread_states[] = {
 	{ 0, "Ready" },
 	{ 1, "Sleeping" },
 	{ 2, "Countsleep" },
@@ -47,9 +47,9 @@ static const struct eCos_thread_state eCos_thread_states[] = {
 	{ 16, "Exited" }
 };
 
-#define ECOS_NUM_STATES ARRAY_SIZE(eCos_thread_states)
+#define ECOS_NUM_STATES ARRAY_SIZE(ecos_thread_states)
 
-struct eCos_params {
+struct ecos_params {
 	const char *target_name;
 	unsigned char pointer_width;
 	unsigned char thread_stack_offset;
@@ -60,7 +60,7 @@ struct eCos_params {
 	const struct rtos_register_stacking *stacking_info;
 };
 
-static const struct eCos_params eCos_params_list[] = {
+static const struct ecos_params ecos_params_list[] = {
 	{
 	"cortex_m",			/* target_name */
 	4,						/* pointer_width; */
@@ -69,16 +69,16 @@ static const struct eCos_params eCos_params_list[] = {
 	0x3c,					/* thread_state_offset; */
 	0xa0,					/* thread_next_offset */
 	0x4c,					/* thread_uniqueid_offset */
-	&rtos_eCos_Cortex_M3_stacking	/* stacking_info */
+	&rtos_ecos_cortex_m3_stacking	/* stacking_info */
 	}
 };
 
-enum eCos_symbol_values {
-	eCos_VAL_thread_list = 0,
-	eCos_VAL_current_thread_ptr = 1
+enum ecos_symbol_values {
+	ECOS_VAL_THREAD_LIST = 0,
+	ECOS_VAL_CURRENT_THREAD_PTR = 1
 };
 
-static const char * const eCos_symbol_list[] = {
+static const char * const ecos_symbol_list[] = {
 	"Cyg_Thread::thread_list",
 	"Cyg_Scheduler_Base::current_thread",
 	NULL
@@ -87,20 +87,20 @@ static const char * const eCos_symbol_list[] = {
 const struct rtos_type ecos_rtos = {
 	.name = "eCos",
 
-	.detect_rtos = eCos_detect_rtos,
-	.create = eCos_create,
-	.update_threads = eCos_update_threads,
-	.get_thread_reg_list = eCos_get_thread_reg_list,
-	.get_symbol_list_to_lookup = eCos_get_symbol_list_to_lookup,
+	.detect_rtos = ecos_detect_rtos,
+	.create = ecos_create,
+	.update_threads = ecos_update_threads,
+	.get_thread_reg_list = ecos_get_thread_reg_list,
+	.get_symbol_list_to_lookup = ecos_get_symbol_list_to_lookup,
 
 };
 
-static int eCos_update_threads(struct rtos *rtos)
+static int ecos_update_threads(struct rtos *rtos)
 {
 	int retval;
 	int tasks_found = 0;
 	int thread_list_size = 0;
-	const struct eCos_params *param;
+	const struct ecos_params *param;
 
 	if (rtos == NULL)
 		return -1;
@@ -108,14 +108,14 @@ static int eCos_update_threads(struct rtos *rtos)
 	if (rtos->rtos_specific_params == NULL)
 		return -3;
 
-	param = (const struct eCos_params *) rtos->rtos_specific_params;
+	param = (const struct ecos_params *) rtos->rtos_specific_params;
 
 	if (rtos->symbols == NULL) {
 		LOG_ERROR("No symbols for eCos");
 		return -4;
 	}
 
-	if (rtos->symbols[eCos_VAL_thread_list].address == 0) {
+	if (rtos->symbols[ECOS_VAL_THREAD_LIST].address == 0) {
 		LOG_ERROR("Don't have the thread list head");
 		return -2;
 	}
@@ -124,7 +124,7 @@ static int eCos_update_threads(struct rtos *rtos)
 	rtos_free_threadlist(rtos);
 
 	/* determine the number of current threads */
-	uint32_t thread_list_head = rtos->symbols[eCos_VAL_thread_list].address;
+	uint32_t thread_list_head = rtos->symbols[ECOS_VAL_THREAD_LIST].address;
 	uint32_t thread_index;
 	target_read_buffer(rtos->target,
 		thread_list_head,
@@ -144,7 +144,7 @@ static int eCos_update_threads(struct rtos *rtos)
 	/* read the current thread id */
 	uint32_t current_thread_addr;
 	retval = target_read_buffer(rtos->target,
-			rtos->symbols[eCos_VAL_current_thread_ptr].address,
+			rtos->symbols[ECOS_VAL_CURRENT_THREAD_PTR].address,
 			4,
 			(uint8_t *)&current_thread_addr);
 	if (retval != ERROR_OK)
@@ -246,7 +246,7 @@ static int eCos_update_threads(struct rtos *rtos)
 			return retval;
 		}
 
-		for (i = 0; (i < ECOS_NUM_STATES) && (eCos_thread_states[i].value != thread_status); i++) {
+		for (i = 0; (i < ECOS_NUM_STATES) && (ecos_thread_states[i].value != thread_status); i++) {
 			/*
 			 * empty
 			 */
@@ -254,7 +254,7 @@ static int eCos_update_threads(struct rtos *rtos)
 
 		const char *state_desc;
 		if  (i < ECOS_NUM_STATES)
-			state_desc = eCos_thread_states[i].desc;
+			state_desc = ecos_thread_states[i].desc;
 		else
 			state_desc = "Unknown state";
 
@@ -268,7 +268,7 @@ static int eCos_update_threads(struct rtos *rtos)
 		prev_thread_ptr = thread_index;
 
 		/* Get the location of the next thread structure. */
-		thread_index = rtos->symbols[eCos_VAL_thread_list].address;
+		thread_index = rtos->symbols[ECOS_VAL_THREAD_LIST].address;
 		retval = target_read_buffer(rtos->target,
 				prev_thread_ptr + param->thread_next_offset,
 				param->pointer_width,
@@ -283,11 +283,11 @@ static int eCos_update_threads(struct rtos *rtos)
 	return 0;
 }
 
-static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
+static int ecos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
 		struct rtos_reg **reg_list, int *num_regs)
 {
 	int retval;
-	const struct eCos_params *param;
+	const struct ecos_params *param;
 
 	if (rtos == NULL)
 		return -1;
@@ -298,11 +298,11 @@ static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
 	if (rtos->rtos_specific_params == NULL)
 		return -3;
 
-	param = (const struct eCos_params *) rtos->rtos_specific_params;
+	param = (const struct ecos_params *) rtos->rtos_specific_params;
 
 	/* Find the thread with that thread id */
 	uint16_t id = 0;
-	uint32_t thread_list_head = rtos->symbols[eCos_VAL_thread_list].address;
+	uint32_t thread_list_head = rtos->symbols[ECOS_VAL_THREAD_LIST].address;
 	uint32_t thread_index;
 	target_read_buffer(rtos->target, thread_list_head, param->pointer_width,
 			(uint8_t *)&thread_index);
@@ -349,33 +349,33 @@ static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
 	return -1;
 }
 
-static int eCos_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
+static int ecos_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
 {
 	unsigned int i;
 	*symbol_list = calloc(
-			ARRAY_SIZE(eCos_symbol_list), sizeof(struct symbol_table_elem));
+			ARRAY_SIZE(ecos_symbol_list), sizeof(struct symbol_table_elem));
 
-	for (i = 0; i < ARRAY_SIZE(eCos_symbol_list); i++)
-		(*symbol_list)[i].symbol_name = eCos_symbol_list[i];
+	for (i = 0; i < ARRAY_SIZE(ecos_symbol_list); i++)
+		(*symbol_list)[i].symbol_name = ecos_symbol_list[i];
 
 	return 0;
 }
 
-static bool eCos_detect_rtos(struct target *target)
+static bool ecos_detect_rtos(struct target *target)
 {
 	if ((target->rtos->symbols != NULL) &&
-			(target->rtos->symbols[eCos_VAL_thread_list].address != 0)) {
+			(target->rtos->symbols[ECOS_VAL_THREAD_LIST].address != 0)) {
 		/* looks like eCos */
 		return true;
 	}
 	return false;
 }
 
-static int eCos_create(struct target *target)
+static int ecos_create(struct target *target)
 {
-	for (unsigned int i = 0; i < ARRAY_SIZE(eCos_params_list); i++)
-		if (strcmp(eCos_params_list[i].target_name, target->type->name) == 0) {
-			target->rtos->rtos_specific_params = (void *)&eCos_params_list[i];
+	for (unsigned int i = 0; i < ARRAY_SIZE(ecos_params_list); i++)
+		if (strcmp(ecos_params_list[i].target_name, target->type->name) == 0) {
+			target->rtos->rtos_specific_params = (void *)&ecos_params_list[i];
 			target->rtos->current_thread = 0;
 			target->rtos->thread_details = NULL;
 			return 0;
diff --git a/src/rtos/rtos_ecos_stackings.c b/src/rtos/rtos_ecos_stackings.c
index ca98d9417..e2119423a 100644
--- a/src/rtos/rtos_ecos_stackings.c
+++ b/src/rtos/rtos_ecos_stackings.c
@@ -22,7 +22,7 @@
 #include "rtos_standard_stackings.h"
 #include "target/armv7m.h"
 
-static const struct stack_register_offset rtos_eCos_Cortex_M3_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
+static const struct stack_register_offset rtos_ecos_cortex_m3_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
 	{ ARMV7M_R0,   0x0c, 32 },		/* r0   */
 	{ ARMV7M_R1,   0x10, 32 },		/* r1   */
 	{ ARMV7M_R2,   0x14, 32 },		/* r2   */
@@ -42,10 +42,10 @@ static const struct stack_register_offset rtos_eCos_Cortex_M3_stack_offsets[ARMV
 	{ ARMV7M_xPSR, -1,   32 },		/* xPSR */
 };
 
-const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking = {
+const struct rtos_register_stacking rtos_ecos_cortex_m3_stacking = {
 	0x44,					/* stack_registers_size */
 	-1,						/* stack_growth_direction */
 	ARMV7M_NUM_CORE_REGS,	/* num_output_registers */
 	rtos_generic_stack_align8,	/* stack_alignment */
-	rtos_eCos_Cortex_M3_stack_offsets	/* register_offsets */
+	rtos_ecos_cortex_m3_stack_offsets	/* register_offsets */
 };
diff --git a/src/rtos/rtos_ecos_stackings.h b/src/rtos/rtos_ecos_stackings.h
index 951f7de50..d66d05fe9 100644
--- a/src/rtos/rtos_ecos_stackings.h
+++ b/src/rtos/rtos_ecos_stackings.h
@@ -23,6 +23,6 @@
 
 #include "rtos.h"
 
-extern const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking;
+extern const struct rtos_register_stacking rtos_ecos_cortex_m3_stacking;
 
 #endif /* OPENOCD_RTOS_RTOS_ECOS_STACKINGS_H */

commit a489058d7b1d7bab8d0e4db53f98b7762d7482a2
Author: Antonio Borneo <bor...@gm...>
Date:   Tue May 25 09:55:22 2021 +0200

    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 <bor...@gm...>
    Reviewed-on: http://openocd.zylin.com/6305
    Tested-by: jenkins
    Reviewed-by: Marc Schink <de...@za...>

diff --git a/src/rtos/FreeRTOS.c b/src/rtos/FreeRTOS.c
index 24b829070..a480c4461 100644
--- 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 3b4c2d701..5eadce9ca 100644
--- 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 2a23017cd..cb471b485 100644
--- 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 05d5b29b2..1c8f4e3f4 100644
--- 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 1b1e73e60..a9feb8019 100644
--- 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 620d16baa..259399bc3 100644
--- 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 4b96a931d..0a15efaac 100644
--- 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 0374e9b5b..5fc958db2 100644
--- 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 543a8cd2a..cd4c22eac 100644
--- 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 89a0c2f12..7850bebcd 100644
--- 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 23f4d1786..98e02edfc 100644
--- 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 7b054cbbc..90c642a00 100644
--- 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 6971efd1e..ad319d2a0 100644
--- 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 d093563ba..4ae0d7dc8 100644
--- 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 a9398138b..f2f120fd9 100644
--- 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 1aed4846f..26b53a927 100644
--- 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...
 
[truncated message content]