Menu
▾
▴
[OpenOCD-commit] Main OpenOCD repository branch, master, updated. v0.11.0-243-g3ad52aa34
|
From: OpenOCD-Gerrit <ope...@us...> - 2021-07-02 16:12:05
|
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 3ad52aa34f6763dddc2a903c255a09f7c7e21ed7 (commit)
via 11a621c7525fb295d7aa9a786a761e43377104fa (commit)
via 1887e2a273797af3d5625ea3d78df3f9ce27ead3 (commit)
via 20ee64ae4bc70b836664465daebe828caca7ccbc (commit)
via 9e358ac2c0a759982064dd53a974b50ebaeb19f5 (commit)
from 3d135a5c70db67ed13cc93eeab0b700f6ef8a412 (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 3ad52aa34f6763dddc2a903c255a09f7c7e21ed7
Author: Antonio Borneo <bor...@gm...>
Date: Tue May 25 09:53:15 2021 +0200
rtos: convert CamelCase enum in uppercase
The eCos code is not part of this patch to prevent conflicts with
patches currently under review.
Change-Id: I71369165f2eef419b83a79ffcff50287f77949c6
Signed-off-by: Antonio Borneo <bor...@gm...>
Reviewed-on: http://openocd.zylin.com/6304
Tested-by: jenkins
diff --git a/src/rtos/FreeRTOS.c b/src/rtos/FreeRTOS.c
index 30c6e34cb..24b829070 100644
--- a/src/rtos/FreeRTOS.c
+++ b/src/rtos/FreeRTOS.c
@@ -120,17 +120,17 @@ struct rtos_type FreeRTOS_rtos = {
};
enum FreeRTOS_symbol_values {
- FreeRTOS_VAL_pxCurrentTCB = 0,
- FreeRTOS_VAL_pxReadyTasksLists = 1,
- FreeRTOS_VAL_xDelayedTaskList1 = 2,
- FreeRTOS_VAL_xDelayedTaskList2 = 3,
- FreeRTOS_VAL_pxDelayedTaskList = 4,
- FreeRTOS_VAL_pxOverflowDelayedTaskList = 5,
- FreeRTOS_VAL_xPendingReadyList = 6,
- FreeRTOS_VAL_xTasksWaitingTermination = 7,
- FreeRTOS_VAL_xSuspendedTaskList = 8,
- FreeRTOS_VAL_uxCurrentNumberOfTasks = 9,
- FreeRTOS_VAL_uxTopUsedPriority = 10,
+ FREERTOS_VAL_PX_CURRENT_TCB = 0,
+ FREERTOS_VAL_PX_READY_TASKS_LISTS = 1,
+ FREERTOS_VAL_X_DELAYED_TASK_LIST1 = 2,
+ FREERTOS_VAL_X_DELAYED_TASK_LIST2 = 3,
+ FREERTOS_VAL_PX_DELAYED_TASK_LIST = 4,
+ FREERTOS_VAL_PX_OVERFLOW_DELAYED_TASK_LIST = 5,
+ FREERTOS_VAL_X_PENDING_READY_LIST = 6,
+ FREERTOS_VAL_X_TASKS_WAITING_TERMINATION = 7,
+ FREERTOS_VAL_X_SUSPENDED_TASK_LIST = 8,
+ FREERTOS_VAL_UX_CURRENT_NUMBER_OF_TASKS = 9,
+ FREERTOS_VAL_UX_TOP_USED_PRIORITY = 10,
};
struct symbols {
@@ -174,17 +174,17 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
return -3;
}
- if (rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address == 0) {
+ if (rtos->symbols[FREERTOS_VAL_UX_CURRENT_NUMBER_OF_TASKS].address == 0) {
LOG_ERROR("Don't have the number of threads in FreeRTOS");
return -2;
}
uint32_t thread_list_size = 0;
retval = target_read_u32(rtos->target,
- rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address,
+ rtos->symbols[FREERTOS_VAL_UX_CURRENT_NUMBER_OF_TASKS].address,
&thread_list_size);
LOG_DEBUG("FreeRTOS: Read uxCurrentNumberOfTasks at 0x%" PRIx64 ", value %" PRIu32,
- rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address,
+ rtos->symbols[FREERTOS_VAL_UX_CURRENT_NUMBER_OF_TASKS].address,
thread_list_size);
if (retval != ERROR_OK) {
@@ -198,7 +198,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
/* read the current thread */
uint32_t pointer_casts_are_bad;
retval = target_read_u32(rtos->target,
- rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address,
+ rtos->symbols[FREERTOS_VAL_PX_CURRENT_TCB].address,
&pointer_casts_are_bad);
if (retval != ERROR_OK) {
LOG_ERROR("Error reading current thread in FreeRTOS thread list");
@@ -206,7 +206,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
}
rtos->current_thread = pointer_casts_are_bad;
LOG_DEBUG("FreeRTOS: Read pxCurrentTCB at 0x%" PRIx64 ", value 0x%" PRIx64,
- rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address,
+ rtos->symbols[FREERTOS_VAL_PX_CURRENT_TCB].address,
rtos->current_thread);
if ((thread_list_size == 0) || (rtos->current_thread == 0)) {
@@ -243,18 +243,18 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
}
/* Find out how many lists are needed to be read from pxReadyTasksLists, */
- if (rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address == 0) {
+ if (rtos->symbols[FREERTOS_VAL_UX_TOP_USED_PRIORITY].address == 0) {
LOG_ERROR("FreeRTOS: uxTopUsedPriority is not defined, consult the OpenOCD manual for a work-around");
return ERROR_FAIL;
}
uint32_t top_used_priority = 0;
retval = target_read_u32(rtos->target,
- rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address,
+ rtos->symbols[FREERTOS_VAL_UX_TOP_USED_PRIORITY].address,
&top_used_priority);
if (retval != ERROR_OK)
return retval;
LOG_DEBUG("FreeRTOS: Read uxTopUsedPriority at 0x%" PRIx64 ", value %" PRIu32,
- rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address,
+ rtos->symbols[FREERTOS_VAL_UX_TOP_USED_PRIORITY].address,
top_used_priority);
if (top_used_priority > FREERTOS_MAX_PRIORITIES) {
LOG_ERROR("FreeRTOS top used priority is unreasonably big, not proceeding: %" PRIu32,
@@ -278,14 +278,14 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
unsigned int num_lists;
for (num_lists = 0; num_lists < config_max_priorities; num_lists++)
- list_of_lists[num_lists] = rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address +
+ list_of_lists[num_lists] = rtos->symbols[FREERTOS_VAL_PX_READY_TASKS_LISTS].address +
num_lists * param->list_width;
- list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xDelayedTaskList1].address;
- list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xDelayedTaskList2].address;
- list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xPendingReadyList].address;
- list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xSuspendedTaskList].address;
- list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xTasksWaitingTermination].address;
+ list_of_lists[num_lists++] = rtos->symbols[FREERTOS_VAL_X_DELAYED_TASK_LIST1].address;
+ list_of_lists[num_lists++] = rtos->symbols[FREERTOS_VAL_X_DELAYED_TASK_LIST2].address;
+ list_of_lists[num_lists++] = rtos->symbols[FREERTOS_VAL_X_PENDING_READY_LIST].address;
+ list_of_lists[num_lists++] = rtos->symbols[FREERTOS_VAL_X_SUSPENDED_TASK_LIST].address;
+ list_of_lists[num_lists++] = rtos->symbols[FREERTOS_VAL_X_TASKS_WAITING_TERMINATION].address;
for (unsigned int i = 0; i < num_lists; i++) {
if (list_of_lists[i] == 0)
@@ -536,7 +536,7 @@ static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_i
static bool FreeRTOS_detect_rtos(struct target *target)
{
if ((target->rtos->symbols != NULL) &&
- (target->rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address != 0)) {
+ (target->rtos->symbols[FREERTOS_VAL_PX_READY_TASKS_LISTS].address != 0)) {
/* looks like FreeRTOS */
return true;
}
diff --git a/src/rtos/ThreadX.c b/src/rtos/ThreadX.c
index 53a74f807..3b4c2d701 100644
--- a/src/rtos/ThreadX.c
+++ b/src/rtos/ThreadX.c
@@ -180,9 +180,9 @@ static const struct ThreadX_params ThreadX_params_list[] = {
};
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,
+ 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[] = {
@@ -276,14 +276,14 @@ static int ThreadX_update_threads(struct rtos *rtos)
return -4;
}
- if (rtos->symbols[ThreadX_VAL_tx_thread_created_count].address == 0) {
+ if (rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_COUNT].address == 0) {
LOG_ERROR("Don't have the number of threads in ThreadX");
return -2;
}
/* read the number of threads */
retval = target_read_buffer(rtos->target,
- rtos->symbols[ThreadX_VAL_tx_thread_created_count].address,
+ rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_COUNT].address,
4,
(uint8_t *)&thread_list_size);
@@ -297,7 +297,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
/* read the current thread id */
retval = target_read_buffer(rtos->target,
- rtos->symbols[ThreadX_VAL_tx_thread_current_ptr].address,
+ rtos->symbols[THREADX_VAL_TX_THREAD_CURRENT_PTR].address,
4,
(uint8_t *)&rtos->current_thread);
@@ -334,7 +334,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
/* Read the pointer to the first thread */
int64_t thread_ptr = 0;
retval = target_read_buffer(rtos->target,
- rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address,
+ rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_PTR].address,
param->pointer_width,
(uint8_t *)&thread_ptr);
if (retval != ERROR_OK) {
@@ -492,7 +492,7 @@ static int ThreadX_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_li
static bool ThreadX_detect_rtos(struct target *target)
{
if ((target->rtos->symbols != NULL) &&
- (target->rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address != 0)) {
+ (target->rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_PTR].address != 0)) {
/* looks like ThreadX */
return true;
}
diff --git a/src/rtos/chromium-ec.c b/src/rtos/chromium-ec.c
index 1476f1969..05d5b29b2 100644
--- a/src/rtos/chromium-ec.c
+++ b/src/rtos/chromium-ec.c
@@ -62,13 +62,13 @@ static const char * const chromium_ec_symbol_list[] = {
};
enum chromium_ec_symbol_values {
- CHROMIUM_EC_VAL_start_called = 0,
- CHROMIUM_EC_VAL_current_task,
- CHROMIUM_EC_VAL_tasks,
- CHROMIUM_EC_VAL_tasks_enabled,
- CHROMIUM_EC_VAL_tasks_ready,
- CHROMIUM_EC_VAL_task_names,
- CHROMIUM_EC_VAL_build_info,
+ CHROMIUM_EC_VAL_START_CALLED = 0,
+ CHROMIUM_EC_VAL_CURRENT_TASK,
+ CHROMIUM_EC_VAL_TASKS,
+ CHROMIUM_EC_VAL_TASKS_ENABLED,
+ CHROMIUM_EC_VAL_TASKS_READY,
+ CHROMIUM_EC_VAL_TASK_NAMES,
+ CHROMIUM_EC_VAL_BUILD_INFO,
CHROMIUM_EC_VAL_COUNT,
};
@@ -84,7 +84,7 @@ static bool chromium_ec_detect_rtos(struct target *target)
if (!target || !target->rtos || !target->rtos->symbols)
return false;
- for (sym = CHROMIUM_EC_VAL_start_called;
+ for (sym = CHROMIUM_EC_VAL_START_CALLED;
sym < CHROMIUM_EC_VAL_COUNT; sym++) {
if (target->rtos->symbols[sym].address) {
LOG_DEBUG("Chromium-EC: Symbol \"%s\" found",
@@ -97,7 +97,7 @@ static bool chromium_ec_detect_rtos(struct target *target)
}
ret = target_read_buffer(target,
- target->rtos->symbols[CHROMIUM_EC_VAL_build_info].address,
+ target->rtos->symbols[CHROMIUM_EC_VAL_BUILD_INFO].address,
sizeof(build_info_buf),
(uint8_t *)build_info_buf);
@@ -107,7 +107,7 @@ static bool chromium_ec_detect_rtos(struct target *target)
LOG_INFO("Chromium-EC: Buildinfo: %s", build_info_buf);
return target->rtos->symbols &&
- target->rtos->symbols[CHROMIUM_EC_VAL_start_called].address;
+ target->rtos->symbols[CHROMIUM_EC_VAL_START_CALLED].address;
}
static int chromium_ec_create(struct target *target)
@@ -143,7 +143,7 @@ static int chromium_ec_get_current_task_ptr(struct rtos *rtos, uint32_t *current
return ERROR_FAIL;
return target_read_u32(rtos->target,
- rtos->symbols[CHROMIUM_EC_VAL_current_task].address,
+ rtos->symbols[CHROMIUM_EC_VAL_CURRENT_TASK].address,
current_task);
}
@@ -153,7 +153,7 @@ static int chromium_ec_get_num_tasks(struct rtos *rtos, int *num_tasks)
int ret, t, found;
ret = target_read_u32(rtos->target,
- rtos->symbols[CHROMIUM_EC_VAL_tasks_enabled].address,
+ rtos->symbols[CHROMIUM_EC_VAL_TASKS_ENABLED].address,
&tasks_enabled);
if (ret != ERROR_OK) {
LOG_ERROR("Failed to determine #of tasks");
@@ -213,7 +213,7 @@ static int chromium_ec_update_threads(struct rtos *rtos)
/* One check if task switching has started ... */
start_called = 0;
- ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_start_called].address,
+ ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_START_CALLED].address,
&start_called);
if (ret != ERROR_OK) {
LOG_ERROR("Failed to load start_called");
@@ -241,7 +241,7 @@ static int chromium_ec_update_threads(struct rtos *rtos)
}
tasks_enabled = 0;
- ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_tasks_enabled].address,
+ ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_TASKS_ENABLED].address,
&tasks_enabled);
if (ret != ERROR_OK) {
LOG_ERROR("Failed to load tasks_enabled");
@@ -249,14 +249,14 @@ static int chromium_ec_update_threads(struct rtos *rtos)
}
tasks_ready = 0;
- ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_tasks_ready].address,
+ ret = target_read_u32(rtos->target, rtos->symbols[CHROMIUM_EC_VAL_TASKS_READY].address,
&tasks_ready);
if (ret != ERROR_OK) {
LOG_ERROR("Failed to load tasks_ready");
return ret;
}
- thread_ptr = rtos->symbols[CHROMIUM_EC_VAL_tasks].address;
+ thread_ptr = rtos->symbols[CHROMIUM_EC_VAL_TASKS].address;
tasks_found = 0;
for (t = 0; t < CROS_EC_MAX_TASKS; t++) {
@@ -268,7 +268,7 @@ static int chromium_ec_update_threads(struct rtos *rtos)
rtos->thread_details[tasks_found].threadid = thread_ptr;
ret = target_read_u32(rtos->target,
- rtos->symbols[CHROMIUM_EC_VAL_task_names].address +
+ rtos->symbols[CHROMIUM_EC_VAL_TASK_NAMES].address +
params->ptr_size * t, &name_ptr);
if (ret != ERROR_OK) {
LOG_ERROR("Failed to read name_ptr");
@@ -348,7 +348,7 @@ static int chromium_ec_get_thread_reg_list(struct rtos *rtos,
return ERROR_FAIL;
ret = target_read_u32(rtos->target,
- rtos->symbols[CHROMIUM_EC_VAL_tasks].address +
+ rtos->symbols[CHROMIUM_EC_VAL_TASKS].address +
params->task_offset_next * t,
&stack_ptr);
if (ret != ERROR_OK) {
diff --git a/src/rtos/embKernel.c b/src/rtos/embKernel.c
index 994cbc091..620d16baa 100644
--- a/src/rtos/embKernel.c
+++ b/src/rtos/embKernel.c
@@ -49,12 +49,12 @@ struct rtos_type embKernel_rtos = {
};
enum {
- SYMBOL_ID_sCurrentTask = 0,
- SYMBOL_ID_sListReady = 1,
- SYMBOL_ID_sListSleep = 2,
- SYMBOL_ID_sListSuspended = 3,
- SYMBOL_ID_sMaxPriorities = 4,
- SYMBOL_ID_sCurrentTaskCount = 5,
+ SYMBOL_ID_S_CURRENT_TASK = 0,
+ SYMBOL_ID_S_LIST_READY = 1,
+ SYMBOL_ID_S_LIST_SLEEP = 2,
+ SYMBOL_ID_S_LIST_SUSPENDED = 3,
+ SYMBOL_ID_S_MAX_PRIORITIES = 4,
+ SYMBOL_ID_S_CURRENT_TASK_COUNT = 5,
};
static const char * const embKernel_symbol_list[] = {
@@ -111,7 +111,7 @@ static const struct embKernel_params embKernel_params_list[] = {
static bool embKernel_detect_rtos(struct target *target)
{
if (target->rtos->symbols != NULL) {
- if (target->rtos->symbols[SYMBOL_ID_sCurrentTask].address != 0)
+ if (target->rtos->symbols[SYMBOL_ID_S_CURRENT_TASK].address != 0)
return true;
}
return false;
@@ -198,7 +198,7 @@ static int embKernel_update_threads(struct rtos *rtos)
return -4;
}
- if (rtos->symbols[SYMBOL_ID_sCurrentTask].address == 0) {
+ if (rtos->symbols[SYMBOL_ID_S_CURRENT_TASK].address == 0) {
LOG_ERROR("Don't have the thread list head");
return -2;
}
@@ -208,7 +208,7 @@ static int embKernel_update_threads(struct rtos *rtos)
param = (const struct embKernel_params *) rtos->rtos_specific_params;
- retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_sCurrentTask].address, param->pointer_width,
+ retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_CURRENT_TASK].address, param->pointer_width,
(uint8_t *) &rtos->current_thread);
if (retval != ERROR_OK) {
LOG_ERROR("Error reading current thread in embKernel thread list");
@@ -216,13 +216,13 @@ static int embKernel_update_threads(struct rtos *rtos)
}
int64_t max_used_priority = 0;
- retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_sMaxPriorities].address, param->pointer_width,
+ retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_MAX_PRIORITIES].address, param->pointer_width,
(uint8_t *) &max_used_priority);
if (retval != ERROR_OK)
return retval;
int thread_list_size = 0;
- retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_sCurrentTaskCount].address,
+ retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_CURRENT_TASK_COUNT].address,
param->thread_count_width, (uint8_t *) &thread_list_size);
if (retval != ERROR_OK) {
@@ -243,7 +243,7 @@ static int embKernel_update_threads(struct rtos *rtos)
/* Get first item in queue */
int64_t iterable = 0;
retval = target_read_buffer(rtos->target,
- rtos->symbols[SYMBOL_ID_sListReady].address + (pri * param->rtos_list_size), param->pointer_width,
+ rtos->symbols[SYMBOL_ID_S_LIST_READY].address + (pri * param->rtos_list_size), param->pointer_width,
(uint8_t *) &iterable);
if (retval != ERROR_OK)
return retval;
@@ -261,7 +261,7 @@ static int embKernel_update_threads(struct rtos *rtos)
}
/* Look for sleeping tasks */
int64_t iterable = 0;
- retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_sListSleep].address, param->pointer_width,
+ retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_LIST_SLEEP].address, param->pointer_width,
(uint8_t *) &iterable);
if (retval != ERROR_OK)
return retval;
@@ -279,7 +279,7 @@ static int embKernel_update_threads(struct rtos *rtos)
/* Look for suspended tasks */
iterable = 0;
- retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_sListSuspended].address, param->pointer_width,
+ retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_LIST_SUSPENDED].address, param->pointer_width,
(uint8_t *) &iterable);
if (retval != ERROR_OK)
return retval;
diff --git a/src/rtos/mqx.c b/src/rtos/mqx.c
index 9f895deed..377bca96c 100644
--- a/src/rtos/mqx.c
+++ b/src/rtos/mqx.c
@@ -49,8 +49,8 @@
/* types */
enum mqx_symbols {
- mqx_VAL_mqx_kernel_data,
- mqx_VAL_MQX_init_struct,
+ MQX_VAL_MQX_KERNEL_DATA,
+ MQX_VAL_MQX_INIT_STRUCT,
};
enum mqx_arch {
@@ -200,7 +200,7 @@ static int mqx_is_scheduler_running(
/* get '_mqx_kernel_data' symbol */
if (ERROR_OK != mqx_get_symbol(
- rtos, mqx_VAL_mqx_kernel_data, &kernel_data_symbol
+ rtos, MQX_VAL_MQX_KERNEL_DATA, &kernel_data_symbol
)) {
return ERROR_FAIL;
}
@@ -252,7 +252,7 @@ static bool mqx_detect_rtos(
{
if (
(target->rtos->symbols != NULL) &&
- (target->rtos->symbols[mqx_VAL_mqx_kernel_data].address != 0)
+ (target->rtos->symbols[MQX_VAL_MQX_KERNEL_DATA].address != 0)
) {
return true;
}
@@ -303,7 +303,7 @@ static int mqx_update_threads(
return ERROR_FAIL;
/* get kernel_data symbol */
if (ERROR_OK != mqx_get_symbol(
- rtos, mqx_VAL_mqx_kernel_data, &kernel_data_addr
+ rtos, MQX_VAL_MQX_KERNEL_DATA, &kernel_data_addr
)) {
return ERROR_FAIL;
}
@@ -472,7 +472,7 @@ static int mqx_get_thread_reg_list(
return ERROR_FAIL;
/* get kernel_data symbol */
if (ERROR_OK != mqx_get_symbol(
- rtos, mqx_VAL_mqx_kernel_data, &kernel_data_addr
+ rtos, MQX_VAL_MQX_KERNEL_DATA, &kernel_data_addr
)) {
return ERROR_FAIL;
}
diff --git a/src/rtos/uCOS-III.c b/src/rtos/uCOS-III.c
index d62a2199b..1aed4846f 100644
--- a/src/rtos/uCOS-III.c
+++ b/src/rtos/uCOS-III.c
@@ -101,18 +101,18 @@ static const char * const uCOS_III_symbol_list[] = {
};
enum uCOS_III_symbol_values {
- uCOS_III_VAL_OSRunning,
- uCOS_III_VAL_OSTCBCurPtr,
- uCOS_III_VAL_OSTaskDbgListPtr,
- uCOS_III_VAL_OSTaskQty,
+ UCOS_III_VAL_OS_RUNNING,
+ UCOS_III_VAL_OS_TCB_CUR_PTR,
+ UCOS_III_VAL_OS_TASK_DBG_LIST_PTR,
+ UCOS_III_VAL_OS_TASK_QTY,
/* also see: contrib/rtos-helpers/uCOS-III-openocd.c */
- uCOS_III_VAL_OS_TCB_StkPtr_offset,
- uCOS_III_VAL_OS_TCB_NamePtr_offset,
- uCOS_III_VAL_OS_TCB_TaskState_offset,
- uCOS_III_VAL_OS_TCB_Prio_offset,
- uCOS_III_VAL_OS_TCB_DbgPrevPtr_offset,
- uCOS_III_VAL_OS_TCB_DbgNextPtr_offset,
+ UCOS_III_VAL_OS_TCB_STK_PTR_OFFSET,
+ UCOS_III_VAL_OS_TCB_NAME_PTR_OFFSET,
+ UCOS_III_VAL_OS_TCB_TASK_STATE_OFFSET,
+ UCOS_III_VAL_OS_TCB_PRIO_OFFSET,
+ UCOS_III_VAL_OS_TCB_DBG_PREV_PTR_OFFSET,
+ UCOS_III_VAL_OS_TCB_DBG_NEXT_PTR_OFFSET,
};
static const char * const uCOS_III_thread_state_list[] = {
@@ -173,7 +173,7 @@ static int uCOS_III_find_last_thread_address(struct rtos *rtos, symbol_address_t
symbol_address_t thread_list_address = 0;
retval = target_read_memory(rtos->target,
- rtos->symbols[uCOS_III_VAL_OSTaskDbgListPtr].address,
+ rtos->symbols[UCOS_III_VAL_OS_TASK_DBG_LIST_PTR].address,
params->pointer_width,
1,
(void *)&thread_list_address);
@@ -212,27 +212,27 @@ static int uCOS_III_update_thread_offsets(struct rtos *rtos)
symbol_address_t *thread_offset;
} thread_offset_maps[] = {
{
- uCOS_III_VAL_OS_TCB_StkPtr_offset,
+ UCOS_III_VAL_OS_TCB_STK_PTR_OFFSET,
¶ms->thread_stack_offset,
},
{
- uCOS_III_VAL_OS_TCB_NamePtr_offset,
+ UCOS_III_VAL_OS_TCB_NAME_PTR_OFFSET,
¶ms->thread_name_offset,
},
{
- uCOS_III_VAL_OS_TCB_TaskState_offset,
+ UCOS_III_VAL_OS_TCB_TASK_STATE_OFFSET,
¶ms->thread_state_offset,
},
{
- uCOS_III_VAL_OS_TCB_Prio_offset,
+ UCOS_III_VAL_OS_TCB_PRIO_OFFSET,
¶ms->thread_priority_offset,
},
{
- uCOS_III_VAL_OS_TCB_DbgPrevPtr_offset,
+ UCOS_III_VAL_OS_TCB_DBG_PREV_PTR_OFFSET,
¶ms->thread_prev_offset,
},
{
- uCOS_III_VAL_OS_TCB_DbgNextPtr_offset,
+ UCOS_III_VAL_OS_TCB_DBG_NEXT_PTR_OFFSET,
¶ms->thread_next_offset,
},
};
@@ -258,7 +258,7 @@ static int uCOS_III_update_thread_offsets(struct rtos *rtos)
static bool uCOS_III_detect_rtos(struct target *target)
{
return target->rtos->symbols != NULL &&
- target->rtos->symbols[uCOS_III_VAL_OSRunning].address != 0;
+ 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)
@@ -312,7 +312,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
uint8_t rtos_running;
retval = target_read_u8(rtos->target,
- rtos->symbols[uCOS_III_VAL_OSRunning].address,
+ rtos->symbols[UCOS_III_VAL_OS_RUNNING].address,
&rtos_running);
if (retval != ERROR_OK) {
LOG_ERROR("uCOS-III: failed to read RTOS running");
@@ -350,7 +350,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
symbol_address_t current_thread_address = 0;
retval = target_read_memory(rtos->target,
- rtos->symbols[uCOS_III_VAL_OSTCBCurPtr].address,
+ rtos->symbols[UCOS_III_VAL_OS_TCB_CUR_PTR].address,
params->pointer_width,
1,
(void *)¤t_thread_address);
@@ -361,7 +361,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
/* read number of tasks */
retval = target_read_u16(rtos->target,
- rtos->symbols[uCOS_III_VAL_OSTaskQty].address,
+ rtos->symbols[UCOS_III_VAL_OS_TASK_QTY].address,
(void *)&rtos->thread_count);
if (retval != ERROR_OK) {
LOG_ERROR("uCOS-III: failed to read thread count");
commit 11a621c7525fb295d7aa9a786a761e43377104fa
Author: Antonio Borneo <bor...@gm...>
Date: Sun Apr 25 23:57:01 2021 +0200
server: rename CamelCase symbols
No cross dependency, just changes internal to each file/function.
Change-Id: I04153a5720b0540bc1998bafe526d523b2ee5515
Signed-off-by: Antonio Borneo <bor...@gm...>
Reviewed-on: http://openocd.zylin.com/6303
Tested-by: jenkins
diff --git a/src/server/server.c b/src/server/server.c
index 307266389..ebf88981b 100644
--- a/src/server/server.c
+++ b/src/server/server.c
@@ -609,7 +609,7 @@ static void sig_handler(int sig)
#ifdef _WIN32
-BOOL WINAPI ControlHandler(DWORD dwCtrlType)
+BOOL WINAPI control_handler(DWORD ctrl_type)
{
shutdown_openocd = SHUTDOWN_WITH_SIGNAL_CODE;
return TRUE;
@@ -634,12 +634,12 @@ int server_host_os_entry(void)
* This is an issue if you call init in your config script */
#ifdef _WIN32
- WORD wVersionRequested;
- WSADATA wsaData;
+ WORD version_requested;
+ WSADATA wsadata;
- wVersionRequested = MAKEWORD(2, 2);
+ version_requested = MAKEWORD(2, 2);
- if (WSAStartup(wVersionRequested, &wsaData) != 0) {
+ if (WSAStartup(version_requested, &wsadata) != 0) {
LOG_ERROR("Failed to Open Winsock");
return ERROR_FAIL;
}
@@ -659,7 +659,7 @@ int server_preinit(void)
{
#ifdef _WIN32
/* register ctrl-c handler */
- SetConsoleCtrlHandler(ControlHandler, TRUE);
+ SetConsoleCtrlHandler(control_handler, TRUE);
signal(SIGBREAK, sig_handler);
signal(SIGINT, sig_handler);
@@ -698,7 +698,7 @@ int server_quit(void)
target_quit();
#ifdef _WIN32
- SetConsoleCtrlHandler(ControlHandler, FALSE);
+ SetConsoleCtrlHandler(control_handler, FALSE);
return ERROR_OK;
#endif
commit 1887e2a273797af3d5625ea3d78df3f9ce27ead3
Author: Antonio Borneo <bor...@gm...>
Date: Sun Jun 6 17:20:10 2021 +0200
jtag/swd: rename CamelCase macros
Change-Id: I4bce678b67d3d2347e88da9507820837697b5aa7
Signed-off-by: Antonio Borneo <bor...@gm...>
Reviewed-on: http://openocd.zylin.com/6302
Tested-by: jenkins
diff --git a/src/jtag/drivers/bitbang.c b/src/jtag/drivers/bitbang.c
index df1d601b8..5c4febb20 100644
--- a/src/jtag/drivers/bitbang.c
+++ b/src/jtag/drivers/bitbang.c
@@ -455,7 +455,7 @@ static void swd_clear_sticky_errors(void)
static void bitbang_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
{
LOG_DEBUG("bitbang_swd_read_reg");
- assert(cmd & SWD_CMD_RnW);
+ assert(cmd & SWD_CMD_RNW);
if (queued_retval != ERROR_OK) {
LOG_DEBUG("Skip bitbang_swd_read_reg because queued_retval=%d", queued_retval);
@@ -478,8 +478,8 @@ static void bitbang_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay
LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
- cmd & SWD_CMD_APnDP ? "AP" : "DP",
- cmd & SWD_CMD_RnW ? "read" : "write",
+ cmd & SWD_CMD_APNDP ? "AP" : "DP",
+ cmd & SWD_CMD_RNW ? "read" : "write",
(cmd & SWD_CMD_A32) >> 1,
data);
@@ -492,7 +492,7 @@ static void bitbang_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay
}
if (value)
*value = data;
- if (cmd & SWD_CMD_APnDP)
+ if (cmd & SWD_CMD_APNDP)
bitbang_swd_exchange(true, NULL, 0, ap_delay_clk);
return;
case SWD_ACK_WAIT:
@@ -514,7 +514,7 @@ static void bitbang_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay
static void bitbang_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
{
LOG_DEBUG("bitbang_swd_write_reg");
- assert(!(cmd & SWD_CMD_RnW));
+ assert(!(cmd & SWD_CMD_RNW));
if (queued_retval != ERROR_OK) {
LOG_DEBUG("Skip bitbang_swd_write_reg because queued_retval=%d", queued_retval);
@@ -537,14 +537,14 @@ static void bitbang_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay
int ack = buf_get_u32(trn_ack_data_parity_trn, 1, 3);
LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
- cmd & SWD_CMD_APnDP ? "AP" : "DP",
- cmd & SWD_CMD_RnW ? "read" : "write",
+ cmd & SWD_CMD_APNDP ? "AP" : "DP",
+ cmd & SWD_CMD_RNW ? "read" : "write",
(cmd & SWD_CMD_A32) >> 1,
buf_get_u32(trn_ack_data_parity_trn, 1 + 3 + 1, 32));
switch (ack) {
case SWD_ACK_OK:
- if (cmd & SWD_CMD_APnDP)
+ if (cmd & SWD_CMD_APNDP)
bitbang_swd_exchange(true, NULL, 0, ap_delay_clk);
return;
case SWD_ACK_WAIT:
diff --git a/src/jtag/drivers/buspirate.c b/src/jtag/drivers/buspirate.c
index 12bb81e39..616832ea7 100644
--- a/src/jtag/drivers/buspirate.c
+++ b/src/jtag/drivers/buspirate.c
@@ -1365,7 +1365,7 @@ static uint8_t buspirate_swd_write_header(uint8_t cmd)
tmp[5] = 0x07; /* write mode trn_1 */
tmp[6] = 0x07; /* write mode trn_2 */
- to_send = ((cmd & SWD_CMD_RnW) == 0) ? 7 : 5;
+ to_send = ((cmd & SWD_CMD_RNW) == 0) ? 7 : 5;
buspirate_serial_write(buspirate_fd, tmp, to_send);
/* read ack */
@@ -1411,7 +1411,7 @@ static void buspirate_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_del
uint8_t tmp[16];
LOG_DEBUG("buspirate_swd_read_reg");
- assert(cmd & SWD_CMD_RnW);
+ assert(cmd & SWD_CMD_RNW);
if (queued_retval != ERROR_OK) {
LOG_DEBUG("Skip buspirate_swd_read_reg because queued_retval=%d", queued_retval);
@@ -1441,8 +1441,8 @@ static void buspirate_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_del
LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
- cmd & SWD_CMD_APnDP ? "AP" : "DP",
- cmd & SWD_CMD_RnW ? "read" : "write",
+ cmd & SWD_CMD_APNDP ? "AP" : "DP",
+ cmd & SWD_CMD_RNW ? "read" : "write",
(cmd & SWD_CMD_A32) >> 1,
data);
@@ -1455,7 +1455,7 @@ static void buspirate_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_del
}
if (value)
*value = data;
- if (cmd & SWD_CMD_APnDP)
+ if (cmd & SWD_CMD_APNDP)
buspirate_swd_idle_clocks(ap_delay_clk);
return;
case SWD_ACK_WAIT:
@@ -1478,7 +1478,7 @@ static void buspirate_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_del
uint8_t tmp[16];
LOG_DEBUG("buspirate_swd_write_reg");
- assert(!(cmd & SWD_CMD_RnW));
+ assert(!(cmd & SWD_CMD_RNW));
if (queued_retval != ERROR_OK) {
LOG_DEBUG("Skip buspirate_swd_write_reg because queued_retval=%d", queued_retval);
@@ -1499,14 +1499,14 @@ static void buspirate_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_del
LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
- cmd & SWD_CMD_APnDP ? "AP" : "DP",
- cmd & SWD_CMD_RnW ? "read" : "write",
+ cmd & SWD_CMD_APNDP ? "AP" : "DP",
+ cmd & SWD_CMD_RNW ? "read" : "write",
(cmd & SWD_CMD_A32) >> 1,
value);
switch (ack) {
case SWD_ACK_OK:
- if (cmd & SWD_CMD_APnDP)
+ if (cmd & SWD_CMD_APNDP)
buspirate_swd_idle_clocks(ap_delay_clk);
return;
case SWD_ACK_WAIT:
diff --git a/src/jtag/drivers/cmsis_dap.c b/src/jtag/drivers/cmsis_dap.c
index 4062ace23..e498ea829 100644
--- a/src/jtag/drivers/cmsis_dap.c
+++ b/src/jtag/drivers/cmsis_dap.c
@@ -787,8 +787,8 @@ static void cmsis_dap_swd_write_from_queue(struct cmsis_dap *dap)
uint32_t data = transfer->data;
LOG_DEBUG_IO("%s %s reg %x %"PRIx32,
- cmd & SWD_CMD_APnDP ? "AP" : "DP",
- cmd & SWD_CMD_RnW ? "read" : "write",
+ cmd & SWD_CMD_APNDP ? "AP" : "DP",
+ cmd & SWD_CMD_RNW ? "read" : "write",
(cmd & SWD_CMD_A32) >> 1, data);
/* When proper WAIT handling is implemented in the
@@ -802,8 +802,8 @@ static void cmsis_dap_swd_write_from_queue(struct cmsis_dap *dap)
* cmsis_dap_cmd_dap_swd_configure() in
* cmsis_dap_init().
*/
- if (!(cmd & SWD_CMD_RnW) &&
- !(cmd & SWD_CMD_APnDP) &&
+ if (!(cmd & SWD_CMD_RNW) &&
+ !(cmd & SWD_CMD_APNDP) &&
(cmd & SWD_CMD_A32) >> 1 == DP_CTRL_STAT &&
(data & CORUNDETECT)) {
LOG_DEBUG("refusing to enable sticky overrun detection");
@@ -811,7 +811,7 @@ static void cmsis_dap_swd_write_from_queue(struct cmsis_dap *dap)
}
command[idx++] = (cmd >> 1) & 0x0f;
- if (!(cmd & SWD_CMD_RnW)) {
+ if (!(cmd & SWD_CMD_RNW)) {
h_u32_to_le(&command[idx], data);
idx += 4;
}
@@ -886,7 +886,7 @@ static void cmsis_dap_swd_read_process(struct cmsis_dap *dap, int timeout_ms)
size_t idx = 3;
for (int i = 0; i < transfer_count; i++) {
struct pending_transfer_result *transfer = &(block->transfers[i]);
- if (transfer->cmd & SWD_CMD_RnW) {
+ if (transfer->cmd & SWD_CMD_RNW) {
static uint32_t last_read;
uint32_t data = le_to_h_u32(&resp[idx]);
uint32_t tmp = data;
@@ -895,7 +895,7 @@ static void cmsis_dap_swd_read_process(struct cmsis_dap *dap, int timeout_ms)
LOG_DEBUG_IO("Read result: %"PRIx32, data);
/* Imitate posted AP reads */
- if ((transfer->cmd & SWD_CMD_APnDP) ||
+ if ((transfer->cmd & SWD_CMD_APNDP) ||
((transfer->cmd & SWD_CMD_A32) >> 1 == DP_RDBUFF)) {
tmp = last_read;
last_read = data;
@@ -959,7 +959,7 @@ static void cmsis_dap_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data)
struct pending_transfer_result *transfer = &(block->transfers[block->transfer_count]);
transfer->data = data;
transfer->cmd = cmd;
- if (cmd & SWD_CMD_RnW) {
+ if (cmd & SWD_CMD_RNW) {
/* Queue a read transaction */
transfer->buffer = dst;
}
@@ -968,13 +968,13 @@ static void cmsis_dap_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data)
static void cmsis_dap_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
{
- assert(!(cmd & SWD_CMD_RnW));
+ assert(!(cmd & SWD_CMD_RNW));
cmsis_dap_swd_queue_cmd(cmd, NULL, value);
}
static void cmsis_dap_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
{
- assert(cmd & SWD_CMD_RnW);
+ assert(cmd & SWD_CMD_RNW);
cmsis_dap_swd_queue_cmd(cmd, value, 0);
}
diff --git a/src/jtag/drivers/ftdi.c b/src/jtag/drivers/ftdi.c
index 25406a4c2..1a6ba590b 100644
--- a/src/jtag/drivers/ftdi.c
+++ b/src/jtag/drivers/ftdi.c
@@ -1112,17 +1112,17 @@ static int ftdi_swd_run_queue(void)
LOG_DEBUG_IO("%s %s %s reg %X = %08"PRIx32,
ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
- swd_cmd_queue[i].cmd & SWD_CMD_APnDP ? "AP" : "DP",
- swd_cmd_queue[i].cmd & SWD_CMD_RnW ? "read" : "write",
+ swd_cmd_queue[i].cmd & SWD_CMD_APNDP ? "AP" : "DP",
+ swd_cmd_queue[i].cmd & SWD_CMD_RNW ? "read" : "write",
(swd_cmd_queue[i].cmd & SWD_CMD_A32) >> 1,
buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn,
- 1 + 3 + (swd_cmd_queue[i].cmd & SWD_CMD_RnW ? 0 : 1), 32));
+ 1 + 3 + (swd_cmd_queue[i].cmd & SWD_CMD_RNW ? 0 : 1), 32));
if (ack != SWD_ACK_OK) {
queued_retval = ack == SWD_ACK_WAIT ? ERROR_WAIT : ERROR_FAIL;
goto skip;
- } else if (swd_cmd_queue[i].cmd & SWD_CMD_RnW) {
+ } else if (swd_cmd_queue[i].cmd & SWD_CMD_RNW) {
uint32_t data = buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3, 32);
int parity = buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3 + 32, 1);
@@ -1172,7 +1172,7 @@ static void ftdi_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32
mpsse_clock_data_out(mpsse_ctx, &swd_cmd_queue[i].cmd, 0, 8, SWD_MODE);
- if (swd_cmd_queue[i].cmd & SWD_CMD_RnW) {
+ if (swd_cmd_queue[i].cmd & SWD_CMD_RNW) {
/* Queue a read transaction */
swd_cmd_queue[i].dst = dst;
@@ -1197,20 +1197,20 @@ static void ftdi_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32
}
/* Insert idle cycles after AP accesses to avoid WAIT */
- if (cmd & SWD_CMD_APnDP)
+ if (cmd & SWD_CMD_APNDP)
mpsse_clock_data_out(mpsse_ctx, NULL, 0, ap_delay_clk, SWD_MODE);
}
static void ftdi_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
{
- assert(cmd & SWD_CMD_RnW);
+ assert(cmd & SWD_CMD_RNW);
ftdi_swd_queue_cmd(cmd, value, 0, ap_delay_clk);
}
static void ftdi_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
{
- assert(!(cmd & SWD_CMD_RnW));
+ assert(!(cmd & SWD_CMD_RNW));
ftdi_swd_queue_cmd(cmd, NULL, value, ap_delay_clk);
}
diff --git a/src/jtag/drivers/jlink.c b/src/jtag/drivers/jlink.c
index 6781e14ff..7a2be61fe 100644
--- a/src/jtag/drivers/jlink.c
+++ b/src/jtag/drivers/jlink.c
@@ -1978,13 +1978,13 @@ static int jlink_swd_init(void)
static void jlink_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
{
- assert(!(cmd & SWD_CMD_RnW));
+ assert(!(cmd & SWD_CMD_RNW));
jlink_swd_queue_cmd(cmd, NULL, value, ap_delay_clk);
}
static void jlink_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
{
- assert(cmd & SWD_CMD_RnW);
+ assert(cmd & SWD_CMD_RNW);
jlink_swd_queue_cmd(cmd, value, 0, ap_delay_clk);
}
@@ -2237,7 +2237,7 @@ static void jlink_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint3
pending_scan_results_buffer[pending_scan_results_length].first = tap_length;
- if (cmd & SWD_CMD_RnW) {
+ if (cmd & SWD_CMD_RNW) {
/* Queue a read transaction. */
pending_scan_results_buffer[pending_scan_results_length].length = 32;
pending_scan_results_buffer[pending_scan_results_length].buffer = dst;
@@ -2257,7 +2257,7 @@ static void jlink_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint3
pending_scan_results_length++;
/* Insert idle cycles after AP accesses to avoid WAIT. */
- if (cmd & SWD_CMD_APnDP)
+ if (cmd & SWD_CMD_APNDP)
jlink_queue_data_out(NULL, ap_delay_clk);
}
diff --git a/src/jtag/drivers/kitprog.c b/src/jtag/drivers/kitprog.c
index 5538bcd73..00d3f5881 100644
--- a/src/jtag/drivers/kitprog.c
+++ b/src/jtag/drivers/kitprog.c
@@ -625,13 +625,13 @@ static int kitprog_swd_init(void)
static void kitprog_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
{
- assert(!(cmd & SWD_CMD_RnW));
+ assert(!(cmd & SWD_CMD_RNW));
kitprog_swd_queue_cmd(cmd, NULL, value);
}
static void kitprog_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
{
- assert(cmd & SWD_CMD_RnW);
+ assert(cmd & SWD_CMD_RNW);
kitprog_swd_queue_cmd(cmd, value, 0);
}
@@ -699,8 +699,8 @@ static int kitprog_swd_run_queue(void)
* cmsis_dap_cmd_DAP_SWD_Configure() in
* cmsis_dap_init().
*/
- if (!(cmd & SWD_CMD_RnW) &&
- !(cmd & SWD_CMD_APnDP) &&
+ if (!(cmd & SWD_CMD_RNW) &&
+ !(cmd & SWD_CMD_APNDP) &&
(cmd & SWD_CMD_A32) >> 1 == DP_CTRL_STAT &&
(data & CORUNDETECT)) {
LOG_DEBUG("refusing to enable sticky overrun detection");
@@ -708,13 +708,13 @@ static int kitprog_swd_run_queue(void)
}
LOG_DEBUG_IO("%s %s reg %x %"PRIx32,
- cmd & SWD_CMD_APnDP ? "AP" : "DP",
- cmd & SWD_CMD_RnW ? "read" : "write",
+ cmd & SWD_CMD_APNDP ? "AP" : "DP",
+ cmd & SWD_CMD_RNW ? "read" : "write",
(cmd & SWD_CMD_A32) >> 1, data);
buffer[write_count++] = (cmd | SWD_CMD_START | SWD_CMD_PARK) & ~SWD_CMD_STOP;
read_count++;
- if (!(cmd & SWD_CMD_RnW)) {
+ if (!(cmd & SWD_CMD_RNW)) {
buffer[write_count++] = (data) & 0xff;
buffer[write_count++] = (data >> 8) & 0xff;
buffer[write_count++] = (data >> 16) & 0xff;
@@ -761,7 +761,7 @@ static int kitprog_swd_run_queue(void)
}
for (int i = 0; i < pending_transfer_count; i++) {
- if (pending_transfers[i].cmd & SWD_CMD_RnW) {
+ if (pending_transfers[i].cmd & SWD_CMD_RNW) {
uint32_t data = le_to_h_u32(&buffer[read_index]);
LOG_DEBUG_IO("Read result: %"PRIx32, data);
@@ -802,7 +802,7 @@ static void kitprog_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data)
pending_transfers[pending_transfer_count].data = data;
pending_transfers[pending_transfer_count].cmd = cmd;
- if (cmd & SWD_CMD_RnW) {
+ if (cmd & SWD_CMD_RNW) {
/* Queue a read transaction */
pending_transfers[pending_transfer_count].buffer = dst;
}
diff --git a/src/jtag/drivers/xds110.c b/src/jtag/drivers/xds110.c
index 85a1b81db..23a431cf7 100644
--- a/src/jtag/drivers/xds110.c
+++ b/src/jtag/drivers/xds110.c
@@ -1165,9 +1165,9 @@ static int xds110_swd_switch_seq(enum swd_special_seq seq)
static bool xds110_legacy_read_reg(uint8_t cmd, uint32_t *value)
{
/* Make sure this is a read request */
- bool is_read_request = (0 != (SWD_CMD_RnW & cmd));
+ bool is_read_request = (0 != (SWD_CMD_RNW & cmd));
/* Determine whether this is a DP or AP register access */
- uint32_t type = (0 != (SWD_CMD_APnDP & cmd)) ? DAP_AP : DAP_DP;
+ uint32_t type = (0 != (SWD_CMD_APNDP & cmd)) ? DAP_AP : DAP_DP;
/* Determine the AP number from cached SELECT value */
uint32_t ap_num = (xds110.select & 0xff000000) >> 24;
/* Extract register address from command */
@@ -1227,9 +1227,9 @@ static bool xds110_legacy_read_reg(uint8_t cmd, uint32_t *value)
static bool xds110_legacy_write_reg(uint8_t cmd, uint32_t value)
{
/* Make sure this isn't a read request */
- bool is_read_request = (0 != (SWD_CMD_RnW & cmd));
+ bool is_read_request = (0 != (SWD_CMD_RNW & cmd));
/* Determine whether this is a DP or AP register access */
- uint32_t type = (0 != (SWD_CMD_APnDP & cmd)) ? DAP_AP : DAP_DP;
+ uint32_t type = (0 != (SWD_CMD_APNDP & cmd)) ? DAP_AP : DAP_DP;
/* Determine the AP number from cached SELECT value */
uint32_t ap_num = (xds110.select & 0xff000000) >> 24;
/* Extract register address from command */
@@ -1296,7 +1296,7 @@ static int xds110_swd_run_queue(void)
result = 0;
while (xds110.txn_requests[request] != 0) {
cmd = xds110.txn_requests[request++];
- if (0 == (SWD_CMD_RnW & cmd)) {
+ if (0 == (SWD_CMD_RNW & cmd)) {
/* DAP register write command */
value = (uint32_t)(xds110.txn_requests[request++]) << 0;
value |= (uint32_t)(xds110.txn_requests[request++]) << 8;
@@ -1329,9 +1329,9 @@ static int xds110_swd_run_queue(void)
static void xds110_swd_queue_cmd(uint8_t cmd, uint32_t *value)
{
/* Check if this is a read or write request */
- bool is_read_request = (0 != (SWD_CMD_RnW & cmd));
+ bool is_read_request = (0 != (SWD_CMD_RNW & cmd));
/* Determine whether this is a DP or AP register access */
- uint32_t type = (0 != (SWD_CMD_APnDP & cmd)) ? DAP_AP : DAP_DP;
+ uint32_t type = (0 != (SWD_CMD_APNDP & cmd)) ? DAP_AP : DAP_DP;
/* Extract register address from command */
uint32_t address = ((cmd & SWD_CMD_A32) >> 1);
uint32_t request_size = (is_read_request) ? 1 : 5;
diff --git a/src/jtag/drivers/xlnx-pcie-xvc.c b/src/jtag/drivers/xlnx-pcie-xvc.c
index 7b82218d5..27295f596 100644
--- a/src/jtag/drivers/xlnx-pcie-xvc.c
+++ b/src/jtag/drivers/xlnx-pcie-xvc.c
@@ -535,7 +535,7 @@ static void xlnx_pcie_xvc_swd_read_reg(uint8_t cmd, uint32_t *value,
uint32_t res, ack, rpar;
int err;
- assert(cmd & SWD_CMD_RnW);
+ assert(cmd & SWD_CMD_RNW);
cmd |= SWD_CMD_START | SWD_CMD_PARK;
/* cmd + ack */
@@ -558,8 +558,8 @@ static void xlnx_pcie_xvc_swd_read_reg(uint8_t cmd, uint32_t *value,
LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ?
"WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
- cmd & SWD_CMD_APnDP ? "AP" : "DP",
- cmd & SWD_CMD_RnW ? "read" : "write",
+ cmd & SWD_CMD_APNDP ? "AP" : "DP",
+ cmd & SWD_CMD_RNW ? "read" : "write",
(cmd & SWD_CMD_A32) >> 1,
res);
switch (ack) {
@@ -571,7 +571,7 @@ static void xlnx_pcie_xvc_swd_read_reg(uint8_t cmd, uint32_t *value,
}
if (value)
*value = res;
- if (cmd & SWD_CMD_APnDP)
+ if (cmd & SWD_CMD_APNDP)
err = xlnx_pcie_xvc_transact(ap_delay_clk, 0, 0, NULL);
queued_retval = err;
return;
@@ -598,7 +598,7 @@ static void xlnx_pcie_xvc_swd_write_reg(uint8_t cmd, uint32_t value,
uint32_t res, ack;
int err;
- assert(!(cmd & SWD_CMD_RnW));
+ assert(!(cmd & SWD_CMD_RNW));
cmd |= SWD_CMD_START | SWD_CMD_PARK;
/* cmd + trn + ack */
@@ -621,14 +621,14 @@ static void xlnx_pcie_xvc_swd_write_reg(uint8_t cmd, uint32_t value,
LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ?
"WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
- cmd & SWD_CMD_APnDP ? "AP" : "DP",
- cmd & SWD_CMD_RnW ? "read" : "write",
+ cmd & SWD_CMD_APNDP ? "AP" : "DP",
+ cmd & SWD_CMD_RNW ? "read" : "write",
(cmd & SWD_CMD_A32) >> 1,
value);
switch (ack) {
case SWD_ACK_OK:
- if (cmd & SWD_CMD_APnDP)
+ if (cmd & SWD_CMD_APNDP)
err = xlnx_pcie_xvc_transact(ap_delay_clk, 0, 0, NULL);
queued_retval = err;
return;
diff --git a/src/jtag/swd.h b/src/jtag/swd.h
index 487cb85bf..fe28667c6 100644
--- a/src/jtag/swd.h
+++ b/src/jtag/swd.h
@@ -24,8 +24,8 @@
* first bit on the wire is START
*/
#define SWD_CMD_START (1 << 0) /* always set */
-#define SWD_CMD_APnDP (1 << 1) /* set only for AP access */
-#define SWD_CMD_RnW (1 << 2) /* set only for read access */
+#define SWD_CMD_APNDP (1 << 1) /* set only for AP access */
+#define SWD_CMD_RNW (1 << 2) /* set only for read access */
#define SWD_CMD_A32 (3 << 3) /* bits A[3:2] of register addr */
#define SWD_CMD_PARITY (1 << 5) /* parity of APnDP|RnW|A32 */
#define SWD_CMD_STOP (0 << 6) /* always clear for synch SWD */
@@ -38,8 +38,8 @@
*/
static inline uint8_t swd_cmd(bool is_read, bool is_ap, uint8_t regnum)
{
- uint8_t cmd = (is_ap ? SWD_CMD_APnDP : 0)
- | (is_read ? SWD_CMD_RnW : 0)
+ uint8_t cmd = (is_ap ? SWD_CMD_APNDP : 0)
+ | (is_read ? SWD_CMD_RNW : 0)
| ((regnum & 0xc) << 1);
/* 8 cmd bits 4:1 may be set */
commit 20ee64ae4bc70b836664465daebe828caca7ccbc
Author: Antonio Borneo <bor...@gm...>
Date: Sun Apr 25 23:41:15 2021 +0200
jtag: rename CamelCase symbols
No major cross dependency, just changes internal to each file or
function.
Change-Id: Ie6258a090ce53de5db65df6a77d57ac6bb899488
Signed-off-by: Antonio Borneo <bor...@gm...>
Reviewed-on: http://openocd.zylin.com/6301
Tested-by: jenkins
diff --git a/src/jtag/aice/aice_transport.c b/src/jtag/aice/aice_transport.c
index 322d8ae5c..7e06760fb 100644
--- a/src/jtag/aice/aice_transport.c
+++ b/src/jtag/aice/aice_transport.c
@@ -31,7 +31,7 @@
/* */
static int jim_newtap_expected_id(struct jim_nvp *n, struct jim_getopt_info *goi,
- struct jtag_tap *pTap)
+ struct jtag_tap *tap)
{
jim_wide w;
int e = jim_getopt_wide(goi, &w);
@@ -41,21 +41,21 @@ static int jim_newtap_expected_id(struct jim_nvp *n, struct jim_getopt_info *goi
return e;
}
- unsigned expected_len = sizeof(uint32_t) * pTap->expected_ids_cnt;
+ unsigned expected_len = sizeof(uint32_t) * tap->expected_ids_cnt;
uint32_t *new_expected_ids = malloc(expected_len + sizeof(uint32_t));
if (new_expected_ids == NULL) {
Jim_SetResultFormatted(goi->interp, "no memory");
return JIM_ERR;
}
- assert(pTap->expected_ids);
- memcpy(new_expected_ids, pTap->expected_ids, expected_len);
+ assert(tap->expected_ids);
+ memcpy(new_expected_ids, tap->expected_ids, expected_len);
- new_expected_ids[pTap->expected_ids_cnt] = w;
+ new_expected_ids[tap->expected_ids_cnt] = w;
- free(pTap->expected_ids);
- pTap->expected_ids = new_expected_ids;
- pTap->expected_ids_cnt++;
+ free(tap->expected_ids);
+ tap->expected_ids = new_expected_ids;
+ tap->expected_ids_cnt++;
return JIM_OK;
}
@@ -65,7 +65,7 @@ static int jim_newtap_expected_id(struct jim_nvp *n, struct jim_getopt_info *goi
/* */
static int jim_aice_newtap_cmd(struct jim_getopt_info *goi)
{
- struct jtag_tap *pTap;
+ struct jtag_tap *tap;
int x;
int e;
struct jim_nvp *n;
@@ -75,8 +75,8 @@ static int jim_aice_newtap_cmd(struct jim_getopt_info *goi)
{.name = NULL, .value = -1},
};
- pTap = calloc(1, sizeof(struct jtag_tap));
- if (!pTap) {
+ tap = calloc(1, sizeof(struct jtag_tap));
+ if (!tap) {
Jim_SetResultFormatted(goi->interp, "no memory");
return JIM_ERR;
}
@@ -87,41 +87,41 @@ static int jim_aice_newtap_cmd(struct jim_getopt_info *goi)
if (goi->argc < 3) {
Jim_SetResultFormatted(goi->interp,
"Missing CHIP TAP OPTIONS ....");
- free(pTap);
+ free(tap);
return JIM_ERR;
}
const char *tmp;
jim_getopt_string(goi, &tmp, NULL);
- pTap->chip = strdup(tmp);
+ tap->chip = strdup(tmp);
jim_getopt_string(goi, &tmp, NULL);
- pTap->tapname = strdup(tmp);
+ tap->tapname = strdup(tmp);
/* name + dot + name + null */
- x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
+ x = strlen(tap->chip) + 1 + strlen(tap->tapname) + 1;
cp = malloc(x);
- sprintf(cp, "%s.%s", pTap->chip, pTap->tapname);
- pTap->dotted_name = cp;
+ sprintf(cp, "%s.%s", tap->chip, tap->tapname);
+ tap->dotted_name = cp;
LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
- pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
+ tap->chip, tap->tapname, tap->dotted_name, goi->argc);
while (goi->argc) {
e = jim_getopt_nvp(goi, opts, &n);
if (e != JIM_OK) {
jim_getopt_nvp_unknown(goi, opts, 0);
free(cp);
- free(pTap);
+ free(tap);
return e;
}
LOG_DEBUG("Processing option: %s", n->name);
switch (n->value) {
case NTAP_OPT_EXPECTED_ID:
- e = jim_newtap_expected_id(n, goi, pTap);
+ e = jim_newtap_expected_id(n, goi, tap);
if (JIM_OK != e) {
free(cp);
- free(pTap);
+ free(tap);
return e;
}
break;
@@ -129,9 +129,9 @@ static int jim_aice_newtap_cmd(struct jim_getopt_info *goi)
} /* while (goi->argc) */
/* default is enabled-after-reset */
- pTap->enabled = !pTap->disabled_after_reset;
+ tap->enabled = !tap->disabled_after_reset;
- jtag_tap_init(pTap);
+ jtag_tap_init(tap);
return JIM_OK;
}
diff --git a/src/jtag/drivers/libusb_helper.c b/src/jtag/drivers/libusb_helper.c
index 18fe4bad4..e214eb701 100644
--- a/src/jtag/drivers/libusb_helper.c
+++ b/src/jtag/drivers/libusb_helper.c
@@ -158,7 +158,7 @@ int jtag_libusb_open(const uint16_t vids[], const uint16_t pids[],
struct libusb_device_handle **out,
adapter_get_alternate_serial_fn adapter_get_alternate_serial)
{
- int cnt, idx, errCode;
+ int cnt, idx, err_code;
int retval = ERROR_FAIL;
bool serial_mismatch = false;
struct libusb_device_handle *libusb_handle = NULL;
@@ -180,11 +180,11 @@ int jtag_libusb_open(const uint16_t vids[], const uint16_t pids[],
if (jtag_usb_get_location() && !jtag_libusb_location_equal(devs[idx]))
continue;
- errCode = libusb_open(devs[idx], &libusb_handle);
+ err_code = libusb_open(devs[idx], &libusb_handle);
- if (errCode) {
+ if (err_code) {
LOG_ERROR("libusb_open() failed with %s",
- libusb_error_name(errCode));
+ libusb_error_name(err_code));
continue;
}
@@ -222,13 +222,13 @@ void jtag_libusb_close(struct libusb_device_handle *dev)
libusb_exit(jtag_libusb_context);
}
-int jtag_libusb_control_transfer(struct libusb_device_handle *dev, uint8_t requestType,
- uint8_t request, uint16_t wValue, uint16_t wIndex, char *bytes,
+int jtag_libusb_control_transfer(struct libusb_device_handle *dev, uint8_t request_type,
+ uint8_t request, uint16_t value, uint16_t index, char *bytes,
uint16_t size, unsigned int timeout)
{
int transferred = 0;
- transferred = libusb_control_transfer(dev, requestType, request, wValue, wIndex,
+ transferred = libusb_control_transfer(dev, request_type, request, value, index,
(unsigned char *)bytes, size, timeout);
if (transferred < 0)
@@ -275,28 +275,28 @@ int jtag_libusb_set_configuration(struct libusb_device_handle *devh,
int configuration)
{
struct libusb_device *udev = libusb_get_device(devh);
- int retCode = -99;
+ int retval = -99;
struct libusb_config_descriptor *config = NULL;
int current_config = -1;
- retCode = libusb_get_configuration(devh, ¤t_config);
- if (retCode != 0)
- return retCode;
+ retval = libusb_get_configuration(devh, ¤t_config);
+ if (retval != 0)
+ return retval;
- retCode = libusb_get_config_descriptor(udev, configuration, &config);
- if (retCode != 0 || config == NULL)
- return retCode;
+ retval = libusb_get_config_descriptor(udev, configuration, &config);
+ if (retval != 0 || config == NULL)
+ return retval;
/* Only change the configuration if it is not already set to the
same one. Otherwise this issues a lightweight reset and hangs
LPC-Link2 with JLink firmware. */
if (current_config != config->bConfigurationValue)
- retCode = libusb_set_configuration(devh, config->bConfigurationValue);
+ retval = libusb_set_configuration(devh, config->bConfigurationValue);
libusb_free_config_descriptor(config);
- return retCode;
+ return retval;
}
int jtag_libusb_choose_interface(struct libusb_device_handle *devh,
diff --git a/src/jtag/drivers/libusb_helper.h b/src/jtag/drivers/libusb_helper.h
index 3e77865d6..6087128d2 100644
--- a/src/jtag/drivers/libusb_helper.h
+++ b/src/jtag/drivers/libusb_helper.h
@@ -33,8 +33,8 @@ int jtag_libusb_open(const uint16_t vids[], const uint16_t pids[],
adapter_get_alternate_serial_fn adapter_get_alternate_serial);
void jtag_libusb_close(struct libusb_device_handle *dev);
int jtag_libusb_control_transfer(struct libusb_device_handle *dev,
- uint8_t requestType, uint8_t request, uint16_t wValue,
- uint16_t wIndex, char *bytes, uint16_t size, unsigned int timeout);
+ uint8_t request_type, uint8_t request, uint16_t value,
+ uint16_t index, char *bytes, uint16_t size, unsigned int timeout);
int jtag_libusb_bulk_write(struct libusb_device_handle *dev, int ep,
char *bytes, int size, int timeout, int *transferred);
int jtag_libusb_bulk_read(struct libusb_device_handle *dev, int ep,
diff --git a/src/jtag/drivers/rlink.c b/src/jtag/drivers/rlink.c
index a88731f4a..07e22ffb7 100644
--- a/src/jtag/drivers/rlink.c
+++ b/src/jtag/drivers/rlink.c
@@ -97,14 +97,14 @@
#define ST7_PC_TDO ST7_PC_IO9
#define ST7_PA_DBGACK ST7_PA_IO10
-static struct libusb_device_handle *pHDev;
+static struct libusb_device_handle *hdev;
/*
* ep1 commands are up to USB_EP1OUT_SIZE bytes in length.
* This function takes care of zeroing the unused bytes before sending the packet.
* Any reply packet is not handled by this function.
*/
-static int ep1_generic_commandl(struct libusb_device_handle *pHDev_param, size_t length, ...)
+static int ep1_generic_commandl(struct libusb_device_handle *hdev_param, size_t length, ...)
{
uint8_t usb_buffer[USB_EP1OUT_SIZE];
uint8_t *usb_buffer_p;
@@ -130,7 +130,7 @@ static int ep1_generic_commandl(struct libusb_device_handle *pHDev_param, size_t
);
usb_ret = jtag_libusb_bulk_write(
- pHDev_param,
+ hdev_param,
USB_EP1OUT_ADDR,
(char *)usb_buffer, sizeof(usb_buffer),
USB_TIMEOUT_MS,
@@ -144,7 +144,7 @@ static int ep1_generic_commandl(struct libusb_device_handle *pHDev_param, size_t
#if 0
static ssize_t ep1_memory_read(
- struct libusb_device_handle *pHDev_param, uint16_t addr,
+ struct libusb_device_handle *hdev_param, uint16_t addr,
size_t length, uint8_t *buffer)
{
uint8_t usb_buffer[USB_EP1OUT_SIZE];
@@ -174,7 +174,7 @@ static ssize_t ep1_memory_read(
usb_buffer[3] = length;
usb_ret = jtag_libusb_bulk_write(
- pHDev_param, USB_EP1OUT_ADDR,
+ hdev_param, USB_EP1OUT_ADDR,
(char *)usb_buffer, sizeof(usb_buffer),
USB_TIMEOUT_MS,
&transferred
@@ -184,7 +184,7 @@ static ssize_t ep1_memory_read(
break;
usb_ret = jtag_libusb_bulk_read(
- pHDev_param, USB_EP1IN_ADDR,
+ hdev_param, USB_EP1IN_ADDR,
(char *)buffer, length,
USB_TIMEOUT_MS,
&transferred
@@ -203,7 +203,7 @@ static ssize_t ep1_memory_read(
}
#endif
-static ssize_t ep1_memory_write(struct libusb_device_handle *pHDev_param, uint16_t addr,
+static ssize_t ep1_memory_write(struct libusb_device_handle *hdev_param, uint16_t addr,
size_t length, uint8_t const *buffer)
{
uint8_t usb_buffer[USB_EP1OUT_SIZE];
@@ -239,7 +239,7 @@ static ssize_t ep1_memory_write(struct libusb_device_handle *pHDev_param, uint16
int transferred;
usb_ret = jtag_libusb_bulk_write(
- pHDev_param, USB_EP1OUT_ADDR,
+ hdev_param, USB_EP1OUT_ADDR,
(char *)usb_buffer, sizeof(usb_buffer),
USB_TIMEOUT_MS,
&transferred
@@ -259,7 +259,7 @@ static ssize_t ep1_memory_write(struct libusb_device_handle *pHDev_param, uint16
#if 0
-static ssize_t ep1_memory_writel(struct libusb_device_handle *pHDev_param, uint16_t addr,
+static ssize_t ep1_memory_writel(struct libusb_device_handle *hdev_param, uint16_t addr,
size_t length, ...)
{
uint8_t buffer[USB_EP1OUT_SIZE - 4];
@@ -279,7 +279,7 @@ static ssize_t ep1_memory_writel(struct libusb_device_handle *pHDev_param, uint1
remain--;
}
- return ep1_memory_write(pHDev_param, addr, length, buffer);
+ return ep1_memory_write(hdev_param, addr, length, buffer);
}
#endif
@@ -296,7 +296,7 @@ static ssize_t ep1_memory_writel(struct libusb_device_handle *pHDev_param, uint1
static uint8_t dtc_entry_download;
/* The buffer is specially formatted to represent a valid image to load into the DTC. */
-static int dtc_load_from_buffer(struct libusb_device_handle *pHDev_param, const uint8_t *buffer,
+static int dtc_load_from_buffer(struct libusb_device_handle *hdev_param, const uint8_t *buffer,
size_t length)
{
struct header_s {
@@ -312,7 +312,7 @@ static int dtc_load_from_buffer(struct libusb_device_handle *pHDev_param, const
/* Stop the DTC before loading anything. */
usb_err = ep1_generic_commandl(
- pHDev_param, 1,
+ hdev_param, 1,
EP1_CMD_DTC_STOP
);
if (usb_err < 0)
@@ -346,7 +346,7 @@ static int dtc_load_from_buffer(struct libusb_device_handle *pHDev_param, const
case DTCLOAD_LOAD:
/* Send the DTC program to ST7 RAM. */
usb_err = ep1_memory_write(
- pHDev_param,
+ hdev_param,
DTC_LOAD_BUFFER,
header->length + 1, buffer
);
@@ -355,7 +355,7 @@ static int dtc_load_from_buffer(struct libusb_device_handle *pHDev_param, const
/* Load it into the DTC. */
usb_err = ep1_generic_commandl(
- pHDev_param, 3,
+ hdev_param, 3,
EP1_CMD_DTC_LOAD,
(DTC_LOAD_BUFFER >> 8),
DTC_LOAD_BUFFER
@@ -367,7 +367,7 @@ static int dtc_load_from_buffer(struct libusb_device_handle *pHDev_param, const
case DTCLOAD_RUN:
usb_err = ep1_generic_commandl(
- pHDev_param, 3,
+ hdev_param, 3,
EP1_CMD_DTC_CALL,
buffer[0],
EP1_CMD_DTC_WAIT
@@ -383,7 +383,7 @@ static int dtc_load_from_buffer(struct libusb_device_handle *pHDev_param, const
case DTCLOAD_LUT:
usb_err = ep1_memory_write(
- pHDev_param,
+ hdev_param,
ST7_USB_BUF_EP0OUT + lut_start,
header->length + 1, buffer
);
@@ -415,7 +415,7 @@ static int dtc_start_download(void)
/* set up for download mode and make sure EP2 is set up to transmit */
usb_err = ep1_generic_commandl(
- pHDev, 7,
+ hdev, 7,
EP1_CMD_DTC_STOP,
EP1_CMD_SET_UPLOAD,
@@ -430,7 +430,7 @@ static int dtc_start_download(void)
/* read back ep2txr */
usb_err = jtag_libusb_bulk_read(
- pHDev, USB_EP1IN_ADDR,
+ hdev, USB_EP1IN_ADDR,
(char *)&ep2txr, 1,
USB_TIMEOUT_MS,
&transferred
@@ -439,7 +439,7 @@ static int dtc_start_download(void)
return usb_err;
usb_err = ep1_generic_commandl(
- pHDev, 13,
+ hdev, 13,
EP1_CMD_MEMORY_WRITE, /* preinitialize poll byte */
DTC_STATUS_POLL_BYTE >> 8,
@@ -460,7 +460,7 @@ static int dtc_start_download(void)
/* wait for completion */
usb_err = jtag_libusb_bulk_read(
- pHDev, USB_EP1IN_ADDR,
+ hdev, USB_EP1IN_ADDR,
(char *)&ep2txr, 1,
USB_TIMEOUT_MS,
&transferred
@@ -470,7 +470,7 @@ static int dtc_start_download(void)
}
static int dtc_run_download(
- struct libusb_device_handle *pHDev_param,
+ struct libusb_device_handle *hdev_param,
uint8_t *command_buffer,
int command_buffer_size,
uint8_t *reply_buffer,
@@ -485,7 +485,7 @@ static int dtc_run_download(
LOG_DEBUG("%d/%d", command_buffer_size, reply_buffer_size);
usb_err = jtag_libusb_bulk_write(
- pHDev_param,
+ hdev_param,
USB_EP2OUT_ADDR,
(char *)command_buffer, USB_EP2BANK_SIZE,
USB_TIMEOUT_MS,
@@ -498,7 +498,7 @@ static int dtc_run_download(
/* Wait for DTC to finish running command buffer */
for (i = 50;; ) {
usb_err = ep1_generic_commandl(
- pHDev_param, 4,
+ hdev_param, 4,
EP1_CMD_MEMORY_READ,
DTC_STATUS_POLL_BYTE >> 8,
@@ -509,7 +509,7 @@ static int dtc_run_download(
return usb_err;
usb_err = jtag_libusb_bulk_read(
- pHDev_param,
+ hdev_param,
USB_EP1IN_ADDR,
&dtc_status, 1,
USB_TIMEOUT_MS,
@@ -530,7 +530,7 @@ static int dtc_run_download(
if (reply_buffer && reply_buffer_size) {
usb_err = jtag_libusb_bulk_read(
- pHDev_param,
+ hdev_param,
USB_EP2IN_ADDR,
(char *)reply_buffer, reply_buffer_size,
USB_TIMEOUT_MS,
@@ -656,7 +656,7 @@ static int dtc_queue_run(void)
dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = DTC_CMD_STOP;
- usb_err = dtc_run_download(pHDev,
+ usb_err = dtc_run_download(hdev,
dtc_queue.cmd_buffer, dtc_queue.cmd_index,
reply_buffer, sizeof(reply_buffer)
);
@@ -940,7 +940,7 @@ static void rlink_reset(int trst, int srst)
/* Read port A for bit op */
usb_err = ep1_generic_commandl(
- pHDev, 4,
+ hdev, 4,
EP1_CMD_MEMORY_READ,
ST7_PADR >> 8,
ST7_PADR,
@@ -952,7 +952,7 @@ static void rlink_reset(int trst, int srst)
}
usb_err = jtag_libusb_bulk_read(
- pHDev, USB_EP1IN_ADDR,
+ hdev, USB_EP1IN_ADDR,
(char *)&bitmap, 1,
USB_TIMEOUT_MS,
&transferred
@@...
[truncated message content] |
