#include "config.h"
#endif
+#include <helper/align.h>
#include <helper/time_support.h>
#include <jtag/jtag.h>
#include <flash/nor/core.h>
struct target *all_targets;
static struct target_event_callback *target_event_callbacks;
static struct target_timer_callback *target_timer_callbacks;
+static int64_t target_timer_next_event_value;
static LIST_HEAD(target_reset_callback_list);
static LIST_HEAD(target_trace_callback_list);
-static const int polling_interval = 100;
+static const int polling_interval = TARGET_DEFAULT_POLLING_INTERVAL;
static const struct jim_nvp nvp_assert[] = {
{ .name = "assert", NVP_ASSERT },
return ERROR_OK;
}
+/**
+ * Reset the @c examined flag for the given target.
+ * Pure paranoia -- targets are zeroed on allocation.
+ */
+static inline void target_reset_examined(struct target *target)
+{
+ target->examined = false;
+}
+
static int default_examine(struct target *target)
{
target_set_examined(target);
int retval = target->type->examine(target);
if (retval != ERROR_OK) {
+ target_reset_examined(target);
target_call_event_callbacks(target, TARGET_EVENT_EXAMINE_FAIL);
return retval;
}
+ target_set_examined(target);
target_call_event_callbacks(target, TARGET_EVENT_EXAMINE_END);
return ERROR_OK;
int target_run_algorithm(struct target *target,
int num_mem_params, struct mem_param *mem_params,
int num_reg_params, struct reg_param *reg_param,
- uint32_t entry_point, uint32_t exit_point,
+ target_addr_t entry_point, target_addr_t exit_point,
int timeout_ms, void *arch_info)
{
int retval = ERROR_FAIL;
int target_start_algorithm(struct target *target,
int num_mem_params, struct mem_param *mem_params,
int num_reg_params, struct reg_param *reg_params,
- uint32_t entry_point, uint32_t exit_point,
+ target_addr_t entry_point, target_addr_t exit_point,
void *arch_info)
{
int retval = ERROR_FAIL;
int target_wait_algorithm(struct target *target,
int num_mem_params, struct mem_param *mem_params,
int num_reg_params, struct reg_param *reg_params,
- uint32_t exit_point, int timeout_ms,
+ target_addr_t exit_point, int timeout_ms,
void *arch_info)
{
int retval = ERROR_FAIL;
uint32_t rp = fifo_start_addr;
/* validate block_size is 2^n */
- assert(!block_size || !(block_size & (block_size - 1)));
+ assert(IS_PWR_OF_2(block_size));
retval = target_write_u32(target, wp_addr, wp);
if (retval != ERROR_OK)
break;
}
- if (((rp - fifo_start_addr) & (block_size - 1)) || rp < fifo_start_addr || rp >= fifo_end_addr) {
+ if (!IS_ALIGNED(rp - fifo_start_addr, block_size) || rp < fifo_start_addr || rp >= fifo_end_addr) {
LOG_ERROR("corrupted fifo read pointer 0x%" PRIx32, rp);
break;
}
uint32_t rp = fifo_start_addr;
/* validate block_size is 2^n */
- assert(!block_size || !(block_size & (block_size - 1)));
+ assert(IS_PWR_OF_2(block_size));
retval = target_write_u32(target, wp_addr, wp);
if (retval != ERROR_OK)
break;
}
- if (((wp - fifo_start_addr) & (block_size - 1)) || wp < fifo_start_addr || wp >= fifo_end_addr) {
+ if (!IS_ALIGNED(wp - fifo_start_addr, block_size) || wp < fifo_start_addr || wp >= fifo_end_addr) {
LOG_ERROR("corrupted fifo write pointer 0x%" PRIx32, wp);
break;
}
num_samples, seconds);
}
-/**
- * Reset the @c examined flag for the given target.
- * Pure paranoia -- targets are zeroed on allocation.
- */
-static void target_reset_examined(struct target *target)
-{
- target->examined = false;
-}
-
static int handle_target(void *priv);
static int target_init_one(struct command_context *cmd_ctx,
(*callbacks_p)->time_ms = time_ms;
(*callbacks_p)->removed = false;
- gettimeofday(&(*callbacks_p)->when, NULL);
- timeval_add_time(&(*callbacks_p)->when, 0, time_ms * 1000);
+ (*callbacks_p)->when = timeval_ms() + time_ms;
+ target_timer_next_event_value = MIN(target_timer_next_event_value, (*callbacks_p)->when);
(*callbacks_p)->priv = priv;
(*callbacks_p)->next = NULL;
}
static int target_timer_callback_periodic_restart(
- struct target_timer_callback *cb, struct timeval *now)
+ struct target_timer_callback *cb, int64_t *now)
{
- cb->when = *now;
- timeval_add_time(&cb->when, 0, cb->time_ms * 1000L);
+ cb->when = *now + cb->time_ms;
return ERROR_OK;
}
static int target_call_timer_callback(struct target_timer_callback *cb,
- struct timeval *now)
+ int64_t *now)
{
cb->callback(cb->priv);
keep_alive();
- struct timeval now;
- gettimeofday(&now, NULL);
+ int64_t now = timeval_ms();
+
+ /* Initialize to a default value that's a ways into the future.
+ * The loop below will make it closer to now if there are
+ * callbacks that want to be called sooner. */
+ target_timer_next_event_value = now + 1000;
/* Store an address of the place containing a pointer to the
* next item; initially, that's a standalone "root of the
bool call_it = (*callback)->callback &&
((!checktime && (*callback)->type == TARGET_TIMER_TYPE_PERIODIC) ||
- timeval_compare(&now, &(*callback)->when) >= 0);
+ now >= (*callback)->when);
if (call_it)
target_call_timer_callback(*callback, &now);
+ if (!(*callback)->removed && (*callback)->when < target_timer_next_event_value)
+ target_timer_next_event_value = (*callback)->when;
+
callback = &(*callback)->next;
}
return ERROR_OK;
}
-int target_call_timer_callbacks(void)
+int target_call_timer_callbacks()
{
return target_call_timer_callbacks_check_time(1);
}
/* invoke periodic callbacks immediately */
-int target_call_timer_callbacks_now(void)
+int target_call_timer_callbacks_now()
{
return target_call_timer_callbacks_check_time(0);
}
+int64_t target_timer_next_event(void)
+{
+ return target_timer_next_event_value;
+}
+
/* Prints the working area layout for debug purposes */
static void print_wa_layout(struct target *target)
{
/* Target examination could have failed due to unstable connection,
* but we set the examined flag anyway to repoll it later */
if (retval != ERROR_OK) {
- target->examined = true;
+ target_set_examined(target);
LOG_USER("Examination failed, GDB will be halted. Polling again in %dms",
target->backoff.times * polling_interval);
return retval;
if (goi->isconfigure) {
/* START_DEPRECATED_TPIU */
if (n->value == TARGET_EVENT_TRACE_CONFIG)
- LOG_INFO("DEPRECATED target event %s", n->name);
+ LOG_INFO("DEPRECATED target event %s; use TPIU events {pre,post}-{enable,disable}", n->name);
/* END_DEPRECATED_TPIU */
bool replace = true;
}
int e = target->type->examine(target);
- if (e != ERROR_OK)
+ if (e != ERROR_OK) {
+ target_reset_examined(target);
return JIM_ERR;
+ }
+
+ target_set_examined(target);
+
return JIM_OK;
}
/* COMMAND */
jim_getopt_obj(goi, &new_cmd);
/* does this command exist? */
- cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_ERRMSG);
+ cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_NONE);
if (cmd) {
cp = Jim_GetString(new_cmd, NULL);
Jim_SetResultFormatted(goi->interp, "Command/target: %s Exists", cp);
}
/* now does target type exist */
for (x = 0 ; target_types[x] ; x++) {
- if (0 == strcmp(cp, target_types[x]->name)) {
+ if (strcmp(cp, target_types[x]->name) == 0) {
/* found */
break;
}
int i;
const char *targetname;
int retval, len;
- struct target *target = (struct target *) NULL;
+ struct target *target = NULL;
struct target_list *head, *curr, *new;
- curr = (struct target_list *) NULL;
- head = (struct target_list *) NULL;
+ curr = NULL;
+ head = NULL;
retval = 0;
LOG_DEBUG("%d", argc);
if (target) {
new = malloc(sizeof(struct target_list));
new->target = target;
- new->next = (struct target_list *)NULL;
- if (head == (struct target_list *)NULL) {
+ new->next = NULL;
+ if (!head) {
head = new;
curr = head;
} else {
/* now parse the list of cpu and put the target in smp mode*/
curr = head;
- while (curr != (struct target_list *)NULL) {
+ while (curr) {
target = curr->target;
target->smp = 1;
target->head = head;