if (retval != JIM_OK) {
Jim_MakeErrorMessage(cmd->ctx->interp);
- command_print(cmd->ctx, "%s", Jim_GetString(Jim_GetResult(cmd->ctx->interp), NULL));
+ command_print(cmd, "%s", Jim_GetString(Jim_GetResult(cmd->ctx->interp), NULL));
return ERROR_FAIL;
}
return retval;
}
-static int find_target(struct command_context *cmd_ctx, const char *name)
+static int find_target(struct command_invocation *cmd, const char *name)
{
struct target *target = get_target(name);
if (target == NULL) {
- LOG_ERROR("Target: %s is unknown, try one of:\n", name);
+ command_print(cmd, "Target: %s is unknown, try one of:\n", name);
return ERROR_FAIL;
}
if (!target->tap->enabled) {
- LOG_USER("Target: TAP %s is disabled, "
+ command_print(cmd, "Target: TAP %s is disabled, "
"can't be the current target\n",
target->tap->dotted_name);
return ERROR_FAIL;
}
- cmd_ctx->current_target = target;
- if (cmd_ctx->current_target_override)
- cmd_ctx->current_target_override = target;
+ cmd->ctx->current_target = target;
+ if (cmd->ctx->current_target_override)
+ cmd->ctx->current_target_override = target;
return ERROR_OK;
}
{
int retval = ERROR_OK;
if (CMD_ARGC == 1) {
- retval = find_target(CMD_CTX, CMD_ARGV[0]);
+ retval = find_target(CMD, CMD_ARGV[0]);
if (retval == ERROR_OK) {
/* we're done! */
return retval;
}
struct target *target = all_targets;
- command_print(CMD_CTX, " TargetName Type Endian TapName State ");
- command_print(CMD_CTX, "-- ------------------ ---------- ------ ------------------ ------------");
+ command_print(CMD, " TargetName Type Endian TapName State ");
+ command_print(CMD, "-- ------------------ ---------- ------ ------------------ ------------");
while (target) {
const char *state;
char marker = ' ';
marker = '*';
/* keep columns lined up to match the headers above */
- command_print(CMD_CTX,
+ command_print(CMD,
"%2d%c %-18s %-10s %-6s %-18s %s",
target->target_number,
marker,
while (cache) {
unsigned i;
- command_print(CMD_CTX, "===== %s", cache->name);
+ command_print(CMD, "===== %s", cache->name);
for (i = 0, reg = cache->reg_list;
i < cache->num_regs;
if (reg->valid) {
value = buf_to_str(reg->value,
reg->size, 16);
- command_print(CMD_CTX,
+ command_print(CMD,
"(%i) %s (/%" PRIu32 "): 0x%s%s",
count, reg->name,
reg->size, value,
: "");
free(value);
} else {
- command_print(CMD_CTX, "(%i) %s (/%" PRIu32 ")",
+ command_print(CMD, "(%i) %s (/%" PRIu32 ")",
count, reg->name,
reg->size) ;
}
}
if (!reg) {
- command_print(CMD_CTX, "%i is out of bounds, the current target "
+ command_print(CMD, "%i is out of bounds, the current target "
"has only %i registers (0 - %i)", num, count, count - 1);
return ERROR_OK;
}
if (reg->valid == 0)
reg->type->get(reg);
value = buf_to_str(reg->value, reg->size, 16);
- command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
+ command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
free(value);
return ERROR_OK;
}
reg->type->set(reg, buf);
value = buf_to_str(reg->value, reg->size, 16);
- command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
+ command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
free(value);
free(buf);
return ERROR_COMMAND_SYNTAX_ERROR;
not_found:
- command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]);
+ command_print(CMD, "register %s not found in current target", CMD_ARGV[0]);
return ERROR_OK;
}
struct target *target = get_current_target(CMD_CTX);
if (CMD_ARGC == 0) {
- command_print(CMD_CTX, "background polling: %s",
+ command_print(CMD, "background polling: %s",
jtag_poll_get_enabled() ? "on" : "off");
- command_print(CMD_CTX, "TAP: %s (%s)",
+ command_print(CMD, "TAP: %s (%s)",
target->tap->dotted_name,
target->tap->enabled ? "enabled" : "disabled");
if (!target->tap->enabled)
value_fmt, value);
if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
- command_print(cmd->ctx, "%s", output);
+ command_print(cmd, "%s", output);
output_len = 0;
}
}
for (i = 0; i < image.num_sections; i++) {
buffer = malloc(image.sections[i].size);
if (buffer == NULL) {
- command_print(CMD_CTX,
+ command_print(CMD,
"error allocating buffer for section (%d bytes)",
(int)(image.sections[i].size));
retval = ERROR_FAIL;
break;
}
image_size += length;
- command_print(CMD_CTX, "%u bytes written at address " TARGET_ADDR_FMT "",
+ command_print(CMD, "%u bytes written at address " TARGET_ADDR_FMT "",
(unsigned int)length,
image.sections[i].base_address + offset);
}
}
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "downloaded %" PRIu32 " bytes "
+ command_print(CMD, "downloaded %" PRIu32 " bytes "
"in %fs (%0.3f KiB/s)", image_size,
duration_elapsed(&bench), duration_kbps(&bench, image_size));
}
retval = fileio_size(fileio, &filesize);
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX,
+ command_print(CMD,
"dumped %zu bytes in %fs (%0.3f KiB/s)", filesize,
duration_elapsed(&bench), duration_kbps(&bench, filesize));
}
for (i = 0; i < image.num_sections; i++) {
buffer = malloc(image.sections[i].size);
if (buffer == NULL) {
- command_print(CMD_CTX,
+ command_print(CMD,
"error allocating buffer for section (%d bytes)",
(int)(image.sections[i].size));
break;
uint32_t t;
for (t = 0; t < buf_cnt; t++) {
if (data[t] != buffer[t]) {
- command_print(CMD_CTX,
+ command_print(CMD,
"diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
diffs,
(unsigned)(t + image.sections[i].base_address),
data[t],
buffer[t]);
if (diffs++ >= 127) {
- command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
+ command_print(CMD, "More than 128 errors, the rest are not printed.");
free(data);
free(buffer);
goto done;
free(data);
}
} else {
- command_print(CMD_CTX, "address " TARGET_ADDR_FMT " length 0x%08zx",
+ command_print(CMD, "address " TARGET_ADDR_FMT " length 0x%08zx",
image.sections[i].base_address,
buf_cnt);
}
image_size += buf_cnt;
}
if (diffs > 0)
- command_print(CMD_CTX, "No more differences found.");
+ command_print(CMD, "No more differences found.");
done:
if (diffs > 0)
retval = ERROR_FAIL;
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "verified %" PRIu32 " bytes "
+ command_print(CMD, "verified %" PRIu32 " bytes "
"in %fs (%0.3f KiB/s)", image_size,
duration_elapsed(&bench), duration_kbps(&bench, image_size));
}
if (breakpoint->type == BKPT_SOFT) {
char *buf = buf_to_str(breakpoint->orig_instr,
breakpoint->length, 16);
- command_print(cmd->ctx, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s",
+ command_print(cmd, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s",
breakpoint->address,
breakpoint->length,
breakpoint->set, buf);
free(buf);
} else {
if ((breakpoint->address == 0) && (breakpoint->asid != 0))
- command_print(cmd->ctx, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
+ command_print(cmd, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
breakpoint->asid,
breakpoint->length, breakpoint->set);
else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
- command_print(cmd->ctx, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
+ command_print(cmd, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
breakpoint->address,
breakpoint->length, breakpoint->set);
- command_print(cmd->ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
+ command_print(cmd, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
breakpoint->asid);
} else
- command_print(cmd->ctx, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
+ command_print(cmd, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
breakpoint->address,
breakpoint->length, breakpoint->set);
}
retval = breakpoint_add(target, addr, length, hw);
/* error is always logged in breakpoint_add(), do not print it again */
if (ERROR_OK == retval)
- command_print(cmd->ctx, "breakpoint set at " TARGET_ADDR_FMT "", addr);
+ command_print(cmd, "breakpoint set at " TARGET_ADDR_FMT "", addr);
} else if (addr == 0) {
if (target->type->add_context_breakpoint == NULL) {
retval = context_breakpoint_add(target, asid, length, hw);
/* error is always logged in context_breakpoint_add(), do not print it again */
if (ERROR_OK == retval)
- command_print(cmd->ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
+ command_print(cmd, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
} else {
if (target->type->add_hybrid_breakpoint == NULL) {
retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
/* error is always logged in hybrid_breakpoint_add(), do not print it again */
if (ERROR_OK == retval)
- command_print(cmd->ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
+ command_print(cmd, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
}
return retval;
}
struct watchpoint *watchpoint = target->watchpoints;
while (watchpoint) {
- command_print(CMD_CTX, "address: " TARGET_ADDR_FMT
+ command_print(CMD, "address: " TARGET_ADDR_FMT
", len: 0x%8.8" PRIx32
", r/w/a: %i, value: 0x%8.8" PRIx32
", mask: 0x%8.8" PRIx32,
struct target *target = get_current_target(CMD_CTX);
int retval = target->type->virt2phys(target, va, &pa);
if (retval == ERROR_OK)
- command_print(CMD_CTX, "Physical address " TARGET_ADDR_FMT "", pa);
+ command_print(CMD, "Physical address " TARGET_ADDR_FMT "", pa);
return retval;
}
write_gmon(samples, num_of_samples, CMD_ARGV[1],
with_range, start_address, end_address, target, duration_ms);
- command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
+ command_print(CMD, "Wrote %s", CMD_ARGV[1]);
free(samples);
return retval;
struct target *target = get_current_target(CMD_CTX);
struct target_event_action *teap = target->event_action;
- command_print(CMD_CTX, "Event actions for target (%d) %s\n",
+ command_print(CMD, "Event actions for target (%d) %s\n",
target->target_number,
target_name(target));
- command_print(CMD_CTX, "%-25s | Body", "Event");
- command_print(CMD_CTX, "------------------------- | "
+ command_print(CMD, "%-25s | Body", "Event");
+ command_print(CMD, "------------------------- | "
"----------------------------------------");
while (teap) {
Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event);
- command_print(CMD_CTX, "%-25s | %s",
+ command_print(CMD, "%-25s | %s",
opt->name, Jim_GetString(teap->body, NULL));
teap = teap->next;
}
- command_print(CMD_CTX, "***END***");
+ command_print(CMD, "***END***");
return ERROR_OK;
}
static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
fastload_num = image.num_sections;
fastload = malloc(sizeof(struct FastLoad)*image.num_sections);
if (fastload == NULL) {
- command_print(CMD_CTX, "out of memory");
+ command_print(CMD, "out of memory");
image_close(&image);
return ERROR_FAIL;
}
for (i = 0; i < image.num_sections; i++) {
buffer = malloc(image.sections[i].size);
if (buffer == NULL) {
- command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
+ command_print(CMD, "error allocating buffer for section (%d bytes)",
(int)(image.sections[i].size));
retval = ERROR_FAIL;
break;
fastload[i].data = malloc(length);
if (fastload[i].data == NULL) {
free(buffer);
- command_print(CMD_CTX, "error allocating buffer for section (%" PRIu32 " bytes)",
+ command_print(CMD, "error allocating buffer for section (%" PRIu32 " bytes)",
length);
retval = ERROR_FAIL;
break;
fastload[i].length = length;
image_size += length;
- command_print(CMD_CTX, "%u bytes written at address 0x%8.8x",
+ command_print(CMD, "%u bytes written at address 0x%8.8x",
(unsigned int)length,
((unsigned int)(image.sections[i].base_address + offset)));
}
}
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
+ command_print(CMD, "Loaded %" PRIu32 " bytes "
"in %fs (%0.3f KiB/s)", image_size,
duration_elapsed(&bench), duration_kbps(&bench, image_size));
- command_print(CMD_CTX,
+ command_print(CMD,
"WARNING: image has not been loaded to target!"
"You can issue a 'fast_load' to finish loading.");
}
int retval = ERROR_OK;
for (i = 0; i < fastload_num; i++) {
struct target *target = get_current_target(CMD_CTX);
- command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
+ command_print(CMD, "Write to 0x%08x, length 0x%08x",
(unsigned int)(fastload[i].address),
(unsigned int)(fastload[i].length));
retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
}
if (retval == ERROR_OK) {
int64_t after = timeval_ms();
- command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
+ command_print(CMD, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
}
return retval;
}
if ((target->rtos) && (target->rtos->type)
&& (target->rtos->type->ps_command)) {
display = target->rtos->type->ps_command(target);
- command_print(CMD_CTX, "%s", display);
+ command_print(CMD, "%s", display);
free(display);
return ERROR_OK;
} else {
static void binprint(struct command_invocation *cmd, const char *text, const uint8_t *buf, int size)
{
if (text != NULL)
- command_print_sameline(cmd->ctx, "%s", text);
+ command_print_sameline(cmd, "%s", text);
for (int i = 0; i < size; i++)
- command_print_sameline(cmd->ctx, " %02x", buf[i]);
- command_print(cmd->ctx, " ");
+ command_print_sameline(cmd, " %02x", buf[i]);
+ command_print(cmd, " ");
}
COMMAND_HANDLER(handle_test_mem_access_command)
read_ref[i] = rand();
read_buf[i] = read_ref[i];
}
- command_print_sameline(CMD_CTX,
+ command_print_sameline(CMD,
"Test read %" PRIu32 " x %d @ %d to %saligned buffer: ", count,
size, offset, host_offset ? "un" : "");
duration_measure(&bench);
if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
- command_print(CMD_CTX, "Unsupported alignment");
+ command_print(CMD, "Unsupported alignment");
goto next;
} else if (retval != ERROR_OK) {
- command_print(CMD_CTX, "Memory read failed");
+ command_print(CMD, "Memory read failed");
goto next;
}
/* check result */
int result = memcmp(read_ref, read_buf, host_bufsiz);
if (result == 0) {
- command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)",
+ command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
duration_elapsed(&bench),
duration_kbps(&bench, count * size));
} else {
- command_print(CMD_CTX, "Compare failed");
+ command_print(CMD, "Compare failed");
binprint(CMD, "ref:", read_ref, host_bufsiz);
binprint(CMD, "buf:", read_buf, host_bufsiz);
}
for (size_t i = 0; i < host_bufsiz; i++)
write_buf[i] = rand();
- command_print_sameline(CMD_CTX,
+ command_print_sameline(CMD,
"Test write %" PRIu32 " x %d @ %d from %saligned buffer: ", count,
size, offset, host_offset ? "un" : "");
retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "Test pattern write failed");
+ command_print(CMD, "Test pattern write failed");
goto nextw;
}
duration_measure(&bench);
if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
- command_print(CMD_CTX, "Unsupported alignment");
+ command_print(CMD, "Unsupported alignment");
goto nextw;
} else if (retval != ERROR_OK) {
- command_print(CMD_CTX, "Memory write failed");
+ command_print(CMD, "Memory write failed");
goto nextw;
}
/* read back */
retval = target_read_memory(target, wa->address, 1, num_bytes, read_buf);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "Test pattern write failed");
+ command_print(CMD, "Test pattern write failed");
goto nextw;
}
/* check result */
int result = memcmp(read_ref, read_buf, num_bytes);
if (result == 0) {
- command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)",
+ command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
duration_elapsed(&bench),
duration_kbps(&bench, count * size));
} else {
- command_print(CMD_CTX, "Compare failed");
+ command_print(CMD, "Compare failed");
binprint(CMD, "ref:", read_ref, num_bytes);
binprint(CMD, "buf:", read_buf, num_bytes);
}
Code Review / openocd.git / blobdiff