54 #define DEFAULT_HALT_TIMEOUT 5000
71 int fileio_errno,
bool ctrl_c);
136 { .name =
NULL, .value = -1 }
151 { .value = -1, .name =
NULL }
214 { .name =
NULL, .value = -1 }
223 { .name =
NULL, .value = -1 },
236 { .name =
NULL, .value = -1 },
244 { .name =
NULL, .value = -1 },
252 { .name =
NULL, .value = -1 },
263 cp =
"(*BUG*unknown*BUG*)";
274 cp =
"(*BUG*unknown*BUG*)";
278 cp =
"examine deferred";
288 LOG_ERROR(
"Invalid target event: %d", (
int)(event));
289 cp =
"(*BUG*unknown*BUG*)";
299 LOG_ERROR(
"Invalid target reset mode: %d", (
int)(reset_mode));
300 cp =
"(*BUG*unknown*BUG*)";
396 for (i = 0; i <
count; i++)
404 for (i = 0; i <
count; i++)
412 for (i = 0; i <
count; i++)
420 for (i = 0; i <
count; i++)
428 for (i = 0; i <
count; i++)
436 for (i = 0; i <
count; i++)
454 unsigned int index, counter;
455 if (parse_uint(
id, &index) !=
ERROR_OK)
471 LOG_ERROR(
"BUG: current_target out of bounds");
506 LOG_INFO(
"Halt timed out, wake up GDB.");
565 bool handle_breakpoints,
bool debug_execution)
623 sprintf(buf,
"ocd_process_reset %s", n->
name);
624 retval = Jim_Eval(
cmd->ctx->interp, buf);
628 if (retval != JIM_OK) {
629 Jim_MakeErrorMessage(
cmd->ctx->interp);
757 LOG_ERROR(
"Target %s does not support soft_reset_halt",
783 int num_mem_params,
struct mem_param *mem_params,
786 unsigned int timeout_ms,
void *
arch_info)
795 LOG_ERROR(
"Target type '%s' does not support %s",
802 num_mem_params, mem_params,
804 entry_point, exit_point, timeout_ms,
arch_info);
824 int num_mem_params,
struct mem_param *mem_params,
825 int num_reg_params,
struct reg_param *reg_params,
836 LOG_ERROR(
"Target type '%s' does not support %s",
841 LOG_ERROR(
"Target is already running an algorithm");
847 num_mem_params, mem_params,
848 num_reg_params, reg_params,
868 int num_mem_params,
struct mem_param *mem_params,
869 int num_reg_params,
struct reg_param *reg_params,
876 LOG_ERROR(
"Target type '%s' does not support %s",
881 LOG_ERROR(
"Target is not running an algorithm");
886 num_mem_params, mem_params,
887 num_reg_params, reg_params,
940 const uint8_t *
buffer, uint32_t
count,
int block_size,
941 int num_mem_params,
struct mem_param *mem_params,
942 int num_reg_params,
struct reg_param *reg_params,
944 uint32_t entry_point, uint32_t exit_point,
void *
arch_info)
949 const uint8_t *buffer_orig =
buffer;
953 uint32_t wp_addr = buffer_start;
954 uint32_t rp_addr = buffer_start + 4;
955 uint32_t fifo_start_addr = buffer_start + 8;
956 uint32_t fifo_end_addr = buffer_start +
buffer_size;
958 uint32_t wp = fifo_start_addr;
959 uint32_t rp = fifo_start_addr;
973 num_reg_params, reg_params,
979 LOG_ERROR(
"error starting target flash write algorithm");
991 LOG_DEBUG(
"offs 0x%zx count 0x%" PRIx32
" wp 0x%" PRIx32
" rp 0x%" PRIx32,
995 LOG_ERROR(
"flash write algorithm aborted by target");
1000 if (!
IS_ALIGNED(rp - fifo_start_addr, block_size) || rp < fifo_start_addr || rp >= fifo_end_addr) {
1001 LOG_ERROR(
"corrupted fifo read pointer 0x%" PRIx32, rp);
1008 uint32_t thisrun_bytes;
1010 thisrun_bytes = rp - wp - block_size;
1011 else if (rp > fifo_start_addr)
1012 thisrun_bytes = fifo_end_addr - wp;
1014 thisrun_bytes = fifo_end_addr - wp - block_size;
1016 if (thisrun_bytes == 0) {
1026 LOG_ERROR(
"timeout waiting for algorithm, a target reset is recommended");
1036 if (thisrun_bytes >
count * block_size)
1037 thisrun_bytes =
count * block_size;
1040 if (thisrun_bytes >= 16)
1041 thisrun_bytes -= (rp + thisrun_bytes) & 0x03;
1050 count -= thisrun_bytes / block_size;
1051 wp += thisrun_bytes;
1052 if (wp >= fifo_end_addr)
1053 wp = fifo_start_addr;
1070 num_reg_params, reg_params,
1076 LOG_ERROR(
"error waiting for target flash write algorithm");
1083 if (retval ==
ERROR_OK && rp == 0) {
1084 LOG_ERROR(
"flash write algorithm aborted by target");
1094 int num_mem_params,
struct mem_param *mem_params,
1095 int num_reg_params,
struct reg_param *reg_params,
1097 uint32_t entry_point, uint32_t exit_point,
void *
arch_info)
1102 const uint8_t *buffer_orig =
buffer;
1106 uint32_t wp_addr = buffer_start;
1107 uint32_t rp_addr = buffer_start + 4;
1108 uint32_t fifo_start_addr = buffer_start + 8;
1109 uint32_t fifo_end_addr = buffer_start +
buffer_size;
1111 uint32_t wp = fifo_start_addr;
1112 uint32_t rp = fifo_start_addr;
1126 num_reg_params, reg_params,
1132 LOG_ERROR(
"error starting target flash read algorithm");
1139 LOG_ERROR(
"failed to get write pointer");
1143 LOG_DEBUG(
"offs 0x%zx count 0x%" PRIx32
" wp 0x%" PRIx32
" rp 0x%" PRIx32,
1147 LOG_ERROR(
"flash read algorithm aborted by target");
1152 if (!
IS_ALIGNED(wp - fifo_start_addr, block_size) || wp < fifo_start_addr || wp >= fifo_end_addr) {
1153 LOG_ERROR(
"corrupted fifo write pointer 0x%" PRIx32, wp);
1159 uint32_t thisrun_bytes;
1161 thisrun_bytes = wp - rp;
1163 thisrun_bytes = fifo_end_addr - rp;
1165 if (thisrun_bytes == 0) {
1175 LOG_ERROR(
"timeout waiting for algorithm, a target reset is recommended");
1185 if (thisrun_bytes >
count * block_size)
1186 thisrun_bytes =
count * block_size;
1189 if (thisrun_bytes >= 16)
1190 thisrun_bytes -= (rp + thisrun_bytes) & 0x03;
1199 count -= thisrun_bytes / block_size;
1200 rp += thisrun_bytes;
1201 if (rp >= fifo_end_addr)
1202 rp = fifo_start_addr;
1224 num_reg_params, reg_params,
1230 LOG_ERROR(
"error waiting for target flash write algorithm");
1237 if (retval ==
ERROR_OK && wp == 0) {
1238 LOG_ERROR(
"flash read algorithm aborted by target");
1378 struct reg **reg_list[],
int *reg_list_size,
1389 reg_list_size, reg_class);
1400 struct reg **reg_list[],
int *reg_list_size,
1405 reg_list_size, reg_class) ==
ERROR_OK)
1477 uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
1480 num_samples, seconds);
1494 if (!
type->check_reset)
1497 assert(
type->init_target);
1499 int retval =
type->init_target(cmd_ctx,
target);
1509 if (!
type->virt2phys) {
1518 if (
type->write_phys_memory ||
type->read_phys_memory ||
type->virt2phys)
1522 type->write_phys_memory =
type->write_memory;
1523 type->read_phys_memory =
type->read_memory;
1578 static bool target_initialized;
1579 if (target_initialized) {
1580 LOG_INFO(
"'target init' has already been called");
1583 target_initialized =
true;
1610 while ((*callbacks_p)->next)
1611 callbacks_p = &((*callbacks_p)->next);
1612 callbacks_p = &((*callbacks_p)->next);
1616 (*callbacks_p)->callback =
callback;
1617 (*callbacks_p)->priv =
priv;
1618 (*callbacks_p)->next =
NULL;
1633 LOG_ERROR(
"error allocating buffer for reset callback entry");
1646 size_t len, uint8_t *data,
void *
priv),
void *
priv)
1655 LOG_ERROR(
"error allocating buffer for trace callback entry");
1676 while ((*callbacks_p)->next)
1677 callbacks_p = &((*callbacks_p)->next);
1678 callbacks_p = &((*callbacks_p)->next);
1682 (*callbacks_p)->callback =
callback;
1683 (*callbacks_p)->type =
type;
1684 (*callbacks_p)->time_ms =
time_ms;
1685 (*callbacks_p)->removed =
false;
1690 (*callbacks_p)->priv =
priv;
1691 (*callbacks_p)->next =
NULL;
1739 size_t len, uint8_t *data,
void *
priv),
void *
priv)
1783 LOG_DEBUG(
"target event %i (%s) for core %s", event,
1802 LOG_DEBUG(
"target reset %i (%s)", reset_mode,
1841 static bool callback_processing;
1844 if (callback_processing)
1847 callback_processing =
true;
1863 if ((*callback)->removed) {
1870 bool call_it = (*callback)->callback &&
1872 now >= (*callback)->when);
1883 callback_processing =
false;
1920 assert(size <= area->
size);
1923 if (size < area->
size) {
1934 new_wa->
free =
true;
1936 area->
next = new_wa;
1951 while (c && c->
next) {
1988 LOG_DEBUG(
"MMU disabled, using physical "
1993 LOG_ERROR(
"No working memory available. "
1994 "Specify -work-area-phys to target.");
2004 LOG_ERROR(
"No working memory available. "
2005 "Specify -work-area-virt to target.");
2018 new_wa->
free =
true;
2075 LOG_WARNING(
"not enough working area available(requested %"PRIu32
")",
size);
2097 if (!area || area->
free)
2176 uint32_t max_size = 0;
2293 int retcode,
int fileio_errno,
bool ctrl_c)
2299 uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
2306 LOG_INFO(
"Starting profiling. Halting and resuming the"
2307 " target as often as we can...");
2309 uint32_t sample_count = 0;
2318 samples[sample_count++] = t;
2327 LOG_INFO(
"Target not halted or running");
2337 LOG_INFO(
"Profiling completed. %" PRIu32
" samples.", sample_count);
2342 *num_samples = sample_count;
2480 uint32_t checksum = 0;
2494 LOG_ERROR(
"error allocating buffer for section (%" PRIu32
" bytes)",
size);
2504 for (i = 0; i < (
size/
sizeof(uint32_t)); i++) {
2505 uint32_t target_data;
2521 uint8_t erased_value)
2536 uint8_t value_buf[8];
2560 uint8_t value_buf[4];
2584 uint8_t value_buf[2];
2631 uint8_t value_buf[8];
2652 uint8_t value_buf[4];
2673 uint8_t value_buf[2];
2712 uint8_t value_buf[8];
2733 uint8_t value_buf[4];
2754 uint8_t value_buf[2];
2799 "can't be the current target\n",
2805 if (
cmd->ctx->current_target_override)
2806 cmd->ctx->current_target_override =
target;
2823 unsigned int index = 0;
2825 command_print(
CMD,
"-- ------------------ ---------- ------ ------------------ ------------");
2833 state =
"tap-disabled";
2840 "%2d%c %-18s %-10s %-6s %-18s %s",
2866 static int prev_srst_asserted;
2867 static int prev_power_dropout;
2879 static int64_t last_power;
2880 bool wait_more = last_power + 2000 > current;
2883 last_power = current;
2890 int srst_deasserted;
2893 static int64_t last_srst;
2894 wait_more = last_srst + 2000 > current;
2895 if (srst_deasserted && !wait_more) {
2897 last_srst = current;
2906 if (srst_deasserted || power_restored) {
2919 Jim_Interp *interp = (Jim_Interp *)
priv;
2928 static int recursive;
2936 int did_something = 0;
2938 LOG_INFO(
"srst asserted detected, running srst_asserted proc.");
2939 Jim_Eval(interp,
"srst_asserted");
2943 Jim_Eval(interp,
"srst_deasserted");
2947 LOG_INFO(
"Power dropout detected, running power_dropout proc.");
2948 Jim_Eval(interp,
"power_dropout");
2952 Jim_Eval(interp,
"power_restore");
2956 if (did_something) {
3044 unsigned int count = 0;
3060 "(%i) %s (/%" PRIu32
"): 0x%s%s",
3073 cache = cache->
next;
3085 unsigned int count = 0;
3088 for (i = 0; i < cache->
num_regs; i++) {
3089 if (
count++ == num) {
3096 cache = cache->
next;
3101 "has only %i registers (0 - %i)", num,
count,
count - 1);
3207 int retval = parse_uint(
CMD_ARGV[0], &ms);
3225 int64_t then = 0, cur;
3242 if (cur - then > 500) {
3248 if ((cur-then) > ms) {
3249 LOG_ERROR(
"timed out while waiting for target %s",
3271 unsigned int wait_local;
3272 retval = parse_uint(
CMD_ARGV[0], &wait_local);
3300 const struct nvp *n;
3304 reset_mode = n->
value;
3314 bool current =
true;
3358 const unsigned int line_bytecnt = 32;
3359 unsigned int line_modulo = line_bytecnt /
size;
3361 char output[line_bytecnt * 4 + 1];
3362 unsigned int output_len = 0;
3364 const char *value_fmt;
3367 value_fmt =
"%16.16"PRIx64
" ";
3370 value_fmt =
"%8.8"PRIx64
" ";
3373 value_fmt =
"%4.4"PRIx64
" ";
3376 value_fmt =
"%2.2"PRIx64
" ";
3384 for (
unsigned int i = 0; i <
count; i++) {
3385 if (i % line_modulo == 0) {
3386 output_len += snprintf(
output + output_len,
3387 sizeof(
output) - output_len,
3393 const uint8_t *value_ptr =
buffer + i *
size;
3407 output_len += snprintf(
output + output_len,
3408 sizeof(
output) - output_len,
3411 if ((i % line_modulo == line_modulo - 1) || (i ==
count - 1)) {
3423 unsigned int size = 0;
3441 bool physical = strcmp(
CMD_ARGV[0],
"phys") == 0;
3456 unsigned int count = 1;
3462 LOG_ERROR(
"Failed to allocate md read buffer");
3482 unsigned int data_size,
3490 const unsigned int chunk_size = 16384;
3491 uint8_t *target_buf = malloc(chunk_size * data_size);
3497 for (
unsigned int i = 0; i < chunk_size; i++) {
3498 switch (data_size) {
3518 for (
unsigned int x = 0; x < c; x += chunk_size) {
3519 unsigned int current;
3521 if (current > chunk_size)
3522 current = chunk_size;
3523 retval = fn(
target,
address + x * data_size, data_size, current, target_buf);
3544 bool physical = strcmp(
CMD_ARGV[0],
"phys") == 0;
3561 unsigned int count = 1;
3566 unsigned int wordsize;
3590 if (CMD_ARGC < 1 || CMD_ARGC > 5)
3610 *max_address += *min_address;
3613 if (*min_address > *max_address)
3623 uint32_t image_size;
3629 &
image, &min_address, &max_address);
3647 "error allocating buffer for section (%d bytes)",
3660 uint32_t
length = buf_cnt;
3693 "in %fs (%0.3f KiB/s)", image_size,
3707 int retval, retvaltemp;
3718 uint32_t buf_size = (
size > 4096) ? 4096 :
size;
3719 buffer = malloc(buf_size);
3732 size_t size_written;
3733 uint32_t this_run_size = (
size > buf_size) ? buf_size :
size;
3742 size -= this_run_size;
3754 "dumped %zu bytes in %fs (%0.3f KiB/s)", filesize,
3775 uint32_t image_size;
3777 uint32_t checksum = 0;
3778 uint32_t mem_checksum = 0;
3818 "error allocating buffer for section (%" PRIu32
" bytes)",
3847 if (checksum != mem_checksum) {
3852 LOG_ERROR(
"checksum mismatch - attempting binary compare");
3854 data = malloc(buf_cnt);
3859 for (t = 0; t < buf_cnt; t++) {
3860 if (data[t] !=
buffer[t]) {
3862 "diff %d address " TARGET_ADDR_FMT ". Was 0x%02" PRIx8
" instead of 0x%02" PRIx8,
3867 if (diffs++ >= 127) {
3892 image_size += buf_cnt;
3901 "in %fs (%0.3f KiB/s)", image_size,
3940 command_print(
cmd,
"Context breakpoint: asid=0x%8.8" PRIx32
", len=0x%x, num=%u",
3972 }
else if (
addr == 0) {
4013 if (strcmp(
CMD_ARGV[2],
"hw") == 0) {
4019 }
else if (strcmp(
CMD_ARGV[2],
"hw_ctx") == 0) {
4052 command_print(
CMD,
"Error encountered during removal of all breakpoints.");
4079 ", r/w/a: %c, value: 0x%8.8" PRIx64
4080 ", mask: 0x%8.8" PRIx64,
4094 uint64_t data_value = 0x0;
4096 bool mask_specified =
false;
4101 mask_specified =
true;
4106 if (!mask_specified)
4135 data_value, data_mask);
4154 command_print(
CMD,
"Error encountered during removal of all watchpoints.");
4195 size_t written = fwrite(data, 1, len, f);
4197 LOG_ERROR(
"failed to write %zu bytes: %s", len, strerror(errno));
4216 static void write_gmon(uint32_t *samples, uint32_t sample_num,
const char *filename,
bool with_range,
4217 uint32_t start_address, uint32_t end_address,
struct target *
target, uint32_t duration_ms)
4220 FILE *f = fopen(filename,
"wb");
4236 min = start_address;
4241 for (i = 0; i < sample_num; i++) {
4242 if (min > samples[i])
4244 if (max < samples[i])
4250 if (max < UINT32_MAX)
4254 while ((max - min) < 2) {
4255 if (max < UINT32_MAX)
4262 uint32_t address_space = max - min;
4266 static const uint32_t max_buckets = 128 * 1024;
4267 uint32_t num_buckets = address_space /
sizeof(
UNIT);
4268 if (num_buckets > max_buckets)
4269 num_buckets = max_buckets;
4270 int *buckets = malloc(
sizeof(
int) * num_buckets);
4275 memset(buckets, 0,
sizeof(
int) * num_buckets);
4276 for (i = 0; i < sample_num; i++) {
4277 uint32_t
address = samples[i];
4283 long long b = num_buckets;
4284 long long c = address_space;
4285 int index_t = (a * b) / c;
4293 float sample_rate = sample_num / (duration_ms / 1000.0);
4296 for (i = 0; i < (15-strlen(
"seconds")); i++)
4302 char *data = malloc(2 * num_buckets);
4304 for (i = 0; i < num_buckets; i++) {
4309 data[i * 2] = val&0xff;
4310 data[i * 2 + 1] = (val >> 8) & 0xff;
4330 const uint32_t MAX_PROFILE_SAMPLE_NUM = 1000000;
4332 uint32_t num_of_samples;
4338 uint32_t start_address = 0;
4339 uint32_t end_address = 0;
4340 bool with_range =
false;
4345 if (start_address > end_address || (end_address - start_address) < 2) {
4351 uint32_t *samples = malloc(
sizeof(uint32_t) * MAX_PROFILE_SAMPLE_NUM);
4353 LOG_ERROR(
"No memory to store samples.");
4364 &num_of_samples,
offset);
4369 uint32_t duration_ms =
timeval_ms() - timestart_ms;
4371 assert(num_of_samples <= MAX_PROFILE_SAMPLE_NUM);
4404 with_range, start_address, end_address,
target, duration_ms);
4420 if (CMD_ARGC < 3 || CMD_ARGC > 4)
4428 unsigned int width_bits;
4436 bool is_phys =
false;
4446 switch (width_bits) {
4457 if (
count > 65536) {
4462 const unsigned int width = width_bits / 8;
4473 const size_t buffersize = 4096;
4474 uint8_t *
buffer = malloc(buffersize);
4481 char *separator =
"";
4483 const unsigned int max_chunk_len = buffersize /
width;
4484 const size_t chunk_len =
MIN(
count, max_chunk_len);
4495 addr, width_bits, chunk_len);
4505 for (
size_t i = 0; i < chunk_len ; i++) {
4545 if (CMD_ARGC < 3 || CMD_ARGC > 4)
4553 unsigned int width_bits;
4560 bool is_phys =
false;
4571 switch (width_bits) {
4582 if (
count > 65536) {
4583 command_print(
CMD,
"too large memory write request, exceeds 64K elements");
4587 const unsigned int width = width_bits / 8;
4598 const size_t buffersize = 4096;
4599 uint8_t *
buffer = malloc(buffersize);
4609 const unsigned int max_chunk_len = buffersize /
width;
4610 const size_t chunk_len =
MIN(
count, max_chunk_len);
4612 for (
size_t i = 0; i < chunk_len; i++, j++) {
4614 jim_wide element_wide;
4615 int jimretval = Jim_GetWide(
CMD_CTX->interp, tmp, &element_wide);
4616 if (jimretval != JIM_OK) {
4622 const uint64_t v = element_wide;
4651 addr, width_bits, chunk_len);
4674 if (teap->
event == e) {
4675 LOG_DEBUG(
"target: %s (%s) event: %d (%s) action: %s",
4690 retval = Jim_EvalObj(teap->
interp, teap->
body);
4697 if (retval == JIM_RETURN)
4698 retval = teap->
interp->returnCode;
4700 if (retval != JIM_OK) {
4701 Jim_MakeErrorMessage(teap->
interp);
4704 Jim_GetString(Jim_GetResult(teap->
interp),
NULL));
4706 Jim_Eval(teap->
interp,
"error \"\" \"\"");
4714 if (CMD_ARGC < 1 || CMD_ARGC > 2)
4721 if (strcmp(
CMD_ARGV[0],
"-force")) {
4730 const int length = Jim_ListLength(
CMD_CTX->interp, next_argv);
4734 for (
int i = 0; i <
length; i++) {
4735 Jim_Obj *elem = Jim_ListGetIndex(
CMD_CTX->interp, next_argv, i);
4737 const char *reg_name = Jim_String(elem);
4776 #if JIM_VERSION >= 80
4789 const unsigned int length = tmp;
4794 for (
unsigned int i = 0; i <
length; i += 2) {
4795 const char *reg_name = Jim_String(dict[i]);
4796 const char *reg_value = Jim_String(dict[i + 1]);
4821 reg_value, reg_name);
4871 { .name =
"-rtos", .value =
TCFG_RTOS },
4875 { .name =
NULL, .value = -1 }
4886 while (goi->
argc > 0) {
4887 Jim_SetEmptyResult(goi->
interp);
4913 Jim_SetResultFormatted(goi->
interp,
4914 "not settable: %s", n->
name);
4918 if (goi->
argc != 0) {
4919 Jim_WrongNumArgs(goi->
interp,
4925 Jim_SetResultString(goi->
interp,
4930 if (goi->
argc == 0) {
4931 Jim_WrongNumArgs(goi->
interp, goi->
argc, goi->
argv,
"-event ?event-name? ...");
4942 if (goi->
argc != 1) {
4943 Jim_WrongNumArgs(goi->
interp, goi->
argc, goi->
argv,
"-event ?event-name? ?EVENT-BODY?");
4947 if (goi->
argc != 0) {
4948 Jim_WrongNumArgs(goi->
interp, goi->
argc, goi->
argv,
"-event ?event-name?");
4968 LOG_INFO(
"DEPRECATED target event %s; use TPIU events {pre,post}-{enable,disable}", n->
name);
4972 if (Jim_Length(o) == 0) {
4982 bool replace =
true;
4985 teap = calloc(1,
sizeof(*teap));
4992 teap->
body = Jim_DuplicateObj(goi->
interp, o);
5003 Jim_IncrRefCount(teap->
body);
5009 Jim_SetEmptyResult(goi->
interp);
5013 Jim_SetEmptyResult(goi->
interp);
5102 Jim_SetResultString(goi->
interp, n->
name, -1);
5126 Jim_SetResultString(goi->
interp,
5127 "target requires -dap parameter instead of -chain-position!", -1);
5165 if (result != JIM_OK)
5181 Jim_SetResultString(goi->
interp,
"-gdb-port must be configured before 'init'", -1);
5203 Jim_SetResultString(goi->
interp,
"-gdb-max-connections must be configured before 'init'", -1);
5234 "missing: -option ...");
5245 bool allow_defer =
false;
5251 if (strcmp(
CMD_ARGV[0],
"allow-defer"))
5264 LOG_INFO(
"Use arp_examine command to examine it manually!");
5409 "target: %s wait %s fails (%d) %s",
5428 "----------------------------------------");
5477 if (goi.
argc != 1) {
5478 const char *cmd_name = Jim_GetString(
argv[0],
NULL);
5479 Jim_SetResultFormatted(goi.
interp,
"%s <eventname>", cmd_name);
5497 .
name =
"configure",
5500 .help =
"configure a new target for use",
5501 .usage =
"[target_attribute ...]",
5507 .help =
"returns the specified target attribute",
5508 .usage =
"target_attribute",
5512 .handler = handle_mw_command,
5514 .help =
"Write 64-bit word(s) to target memory",
5515 .usage =
"address data [count]",
5519 .handler = handle_mw_command,
5521 .help =
"Write 32-bit word(s) to target memory",
5522 .usage =
"address data [count]",
5526 .handler = handle_mw_command,
5528 .help =
"Write 16-bit half-word(s) to target memory",
5529 .usage =
"address data [count]",
5533 .handler = handle_mw_command,
5535 .help =
"Write byte(s) to target memory",
5536 .usage =
"address data [count]",
5540 .handler = handle_md_command,
5542 .help =
"Display target memory as 64-bit words",
5543 .usage =
"address [count]",
5547 .handler = handle_md_command,
5549 .help =
"Display target memory as 32-bit words",
5550 .usage =
"address [count]",
5554 .handler = handle_md_command,
5556 .help =
"Display target memory as 16-bit half-words",
5557 .usage =
"address [count]",
5561 .handler = handle_md_command,
5563 .help =
"Display target memory as 8-bit bytes",
5564 .usage =
"address [count]",
5569 .handler = handle_target_get_reg,
5570 .help =
"Get register values from the target",
5571 .usage =
"[-force] list",
5576 .handler = handle_set_reg_command,
5577 .help =
"Set target register values",
5581 .name =
"read_memory",
5583 .handler = handle_target_read_memory,
5584 .help =
"Read Tcl list of 8/16/32/64 bit numbers from target memory",
5585 .usage =
"address width count ['phys']",
5588 .name =
"write_memory",
5590 .handler = handle_target_write_memory,
5591 .help =
"Write Tcl list of 8/16/32/64 bit numbers to target memory",
5592 .usage =
"address width data ['phys']",
5595 .name =
"eventlist",
5596 .handler = handle_target_event_list,
5598 .help =
"displays a table of events defined for this target",
5604 .handler = handle_target_current_state,
5605 .help =
"displays the current state of this target",
5609 .name =
"debug_reason",
5611 .handler = handle_target_debug_reason,
5612 .help =
"displays the debug reason of this target",
5616 .name =
"arp_examine",
5618 .handler = handle_target_examine,
5619 .help =
"used internally for reset processing",
5620 .usage =
"['allow-defer']",
5623 .name =
"was_examined",
5625 .handler = handle_target_was_examined,
5626 .help =
"used internally for reset processing",
5630 .name =
"examine_deferred",
5632 .handler = handle_target_examine_deferred,
5633 .help =
"used internally for reset processing",
5637 .name =
"arp_halt_gdb",
5639 .handler = handle_target_halt_gdb,
5640 .help =
"used internally for reset processing to halt GDB",
5646 .handler = handle_target_poll,
5647 .help =
"used internally for reset processing",
5651 .name =
"arp_reset",
5653 .handler = handle_target_reset,
5654 .help =
"used internally for reset processing",
5655 .usage =
"'assert'|'deassert' halt",
5660 .handler = handle_target_halt,
5661 .help =
"used internally for reset processing",
5665 .name =
"arp_waitstate",
5667 .handler = handle_target_wait_state,
5668 .help =
"used internally for reset processing",
5669 .usage =
"statename timeoutmsecs",
5672 .name =
"invoke-event",
5675 .help =
"invoke handler for specified event",
5676 .usage =
"event_name",
5694 if (goi->
argc < 3) {
5695 Jim_WrongNumArgs(goi->
interp, 1, goi->
argv,
"?name? ?type? ..options...");
5702 cmd = Jim_GetCommand(goi->
interp, new_cmd, JIM_NONE);
5704 cp = Jim_GetString(new_cmd,
NULL);
5705 Jim_SetResultFormatted(goi->
interp,
"Command/target: %s Exists", cp);
5717 LOG_ERROR(
"The selected transport doesn't support this target");
5720 LOG_INFO(
"The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD");
5730 Jim_SetResultFormatted(goi->
interp,
"Unknown target type %s, try one of ", cp);
5733 Jim_AppendStrings(goi->
interp,
5734 Jim_GetResult(goi->
interp),
5738 Jim_AppendStrings(goi->
interp,
5739 Jim_GetResult(goi->
interp),
5809 cp = Jim_GetString(new_cmd,
NULL);
5826 Jim_SetResultString(goi->
interp,
"-dap ?name? required when creating target", -1);
5831 Jim_SetResultString(goi->
interp,
"-chain-position ?name? required when creating target", -1);
5874 LOG_ERROR(
"unable to register '%s' commands", cp);
5891 .help =
"target command group",
5893 .chain = target_subcommands,
5956 create_target_list_node(
const char *targetname)
5994 static unsigned int smp_group = 1;
6013 for (
unsigned int i = 0; i <
CMD_ARGC; i++) {
6027 struct target *rtos_target;
6029 if (retval ==
ERROR_OK && rtos_target)
6041 "<name> <target_type> [<target_options> ...]");
6051 .handler = handle_target_init_command,
6052 .help =
"initialize targets",
6059 .usage =
"name type '-chain-position' name [options ...]",
6060 .help =
"Creates and selects a new target",
6065 .handler = handle_target_current,
6066 .help =
"Returns the currently selected target",
6072 .handler = handle_target_types,
6073 .help =
"Returns the available target types as "
6074 "a list of strings",
6080 .handler = handle_target_names,
6081 .help =
"Returns the names of all targets as a list of strings",
6087 .handler = handle_target_smp,
6088 .usage =
"targetname1 targetname2 ...",
6089 .help =
"gather several target in a smp list"
6119 uint32_t image_size;
6126 &
image, &min_address, &max_address);
6163 uint32_t
length = buf_cnt;
6182 command_print(
CMD,
"error allocating buffer for section (%" PRIu32
" bytes)",
6201 "in %fs (%0.3f KiB/s)", image_size,
6205 "WARNING: image has not been loaded to target!"
6206 "You can issue a 'fast_load' to finish loading.");
6241 command_print(
CMD,
"Loaded image %f kBytes/s", (
float)(
size/1024.0)/((
float)(after-ms)/1000.0));
6249 .handler = handle_targets_command,
6251 .help =
"change current default target (one parameter) "
6252 "or prints table of all targets (no parameters)",
6253 .usage =
"[target]",
6258 .help =
"configure target",
6309 for (
int i = 0; i <
size; i++)
6331 size_t num_bytes = test_size + 4;
6340 uint8_t *test_pattern = malloc(num_bytes);
6342 for (
size_t i = 0; i < num_bytes; i++)
6343 test_pattern[i] = rand();
6351 for (
int host_offset = 0; host_offset <= 1; host_offset++) {
6355 size_t host_bufsiz = (
count + 2) *
size + host_offset;
6356 uint8_t *read_ref = malloc(host_bufsiz);
6357 uint8_t *read_buf = malloc(host_bufsiz);
6359 for (
size_t i = 0; i < host_bufsiz; i++) {
6360 read_ref[i] = rand();
6361 read_buf[i] = read_ref[i];
6364 "Test read %" PRIu32
" x %d @ %d to %saligned buffer: ",
count,
6371 read_buf +
size + host_offset);
6387 int result = memcmp(read_ref, read_buf, host_bufsiz);
6410 num_bytes = test_size + 4 + 4 + 4;
6418 test_pattern = malloc(num_bytes);
6420 for (
size_t i = 0; i < num_bytes; i++)
6421 test_pattern[i] = rand();
6423 for (
int host_offset = 0; host_offset <= 1; host_offset++) {
6427 size_t host_bufsiz =
count *
size + host_offset;
6428 uint8_t *read_ref = malloc(num_bytes);
6429 uint8_t *read_buf = malloc(num_bytes);
6430 uint8_t *write_buf = malloc(host_bufsiz);
6432 for (
size_t i = 0; i < host_bufsiz; i++)
6433 write_buf[i] = rand();
6435 "Test write %" PRIu32
" x %d @ %d from %saligned buffer: ",
count,
6445 memcpy(read_ref, test_pattern, num_bytes);
6452 write_buf + host_offset);
6472 int result = memcmp(read_ref, read_buf, num_bytes);
6497 .
name =
"fast_load_image",
6498 .handler = handle_fast_load_image_command,
6500 .help =
"Load image into server memory for later use by "
6501 "fast_load; primarily for profiling",
6502 .usage =
"filename [address ['bin'|'ihex'|'elf'|'s19' "
6503 "[min_address [max_length]]]]",
6506 .name =
"fast_load",
6507 .handler = handle_fast_load_command,
6509 .help =
"loads active fast load image to current target "
6510 "- mainly for profiling purposes",
6515 .handler = handle_profile_command,
6517 .usage =
"seconds filename [start end]",
6518 .help =
"profiling samples the CPU PC",
6522 .name =
"virt2phys",
6523 .handler = handle_virt2phys_command,
6525 .help =
"translate a virtual address into a physical address",
6526 .usage =
"virtual_address",
6530 .handler = handle_reg_command,
6532 .help =
"display (reread from target with \"force\") or set a register; "
6533 "with no arguments, displays all registers and their values",
6534 .usage =
"[(register_number|register_name) [(value|'force')]]",
6538 .handler = handle_poll_command,
6540 .help =
"poll target state; or reconfigure background polling",
6541 .usage =
"['on'|'off']",
6544 .name =
"wait_halt",
6545 .handler = handle_wait_halt_command,
6547 .help =
"wait up to the specified number of milliseconds "
6548 "(default 5000) for a previously requested halt",
6549 .usage =
"[milliseconds]",
6553 .handler = handle_halt_command,
6555 .help =
"request target to halt, then wait up to the specified "
6556 "number of milliseconds (default 5000) for it to complete",
6557 .usage =
"[milliseconds]",
6561 .handler = handle_resume_command,
6563 .help =
"resume target execution from current PC or address",
6564 .usage =
"[address]",
6568 .handler = handle_reset_command,
6570 .usage =
"[run|halt|init]",
6571 .help =
"Reset all targets into the specified mode. "
6572 "Default reset mode is run, if not given.",
6575 .name =
"soft_reset_halt",
6576 .handler = handle_soft_reset_halt_command,
6579 .help =
"halt the target and do a soft reset",
6583 .handler = handle_step_command,
6585 .help =
"step one instruction from current PC or address",
6586 .usage =
"[address]",
6590 .handler = handle_md_command,
6592 .help =
"display memory double-words",
6593 .usage =
"['phys'] address [count]",
6597 .handler = handle_md_command,
6599 .help =
"display memory words",
6600 .usage =
"['phys'] address [count]",
6604 .handler = handle_md_command,
6606 .help =
"display memory half-words",
6607 .usage =
"['phys'] address [count]",
6611 .handler = handle_md_command,
6613 .help =
"display memory bytes",
6614 .usage =
"['phys'] address [count]",
6618 .handler = handle_mw_command,
6620 .help =
"write memory double-word",
6621 .usage =
"['phys'] address value [count]",
6625 .handler = handle_mw_command,
6627 .help =
"write memory word",
6628 .usage =
"['phys'] address value [count]",
6632 .handler = handle_mw_command,
6634 .help =
"write memory half-word",
6635 .usage =
"['phys'] address value [count]",
6639 .handler = handle_mw_command,
6641 .help =
"write memory byte",
6642 .usage =
"['phys'] address value [count]",
6646 .handler = handle_bp_command,
6648 .help =
"list or set hardware or software breakpoint",
6649 .usage =
"[<address> [<asid>] <length> ['hw'|'hw_ctx']]",
6653 .handler = handle_rbp_command,
6655 .help =
"remove breakpoint",
6656 .usage =
"'all' | address",
6660 .handler = handle_wp_command,
6662 .help =
"list (no params) or create watchpoints",
6663 .usage =
"[address length [('r'|'w'|'a') [value [mask]]]]",
6667 .handler = handle_rwp_command,
6669 .help =
"remove watchpoint",
6670 .usage =
"'all' | address",
6673 .name =
"load_image",
6674 .handler = handle_load_image_command,
6676 .usage =
"filename [address ['bin'|'ihex'|'elf'|'s19' "
6677 "[min_address [max_length]]]]",
6680 .name =
"dump_image",
6681 .handler = handle_dump_image_command,
6683 .usage =
"filename address size",
6686 .name =
"verify_image_checksum",
6687 .handler = handle_verify_image_checksum_command,
6689 .usage =
"filename [offset [type]]",
6692 .name =
"verify_image",
6693 .handler = handle_verify_image_command,
6695 .usage =
"filename [offset [type]]",
6698 .name =
"test_image",
6699 .handler = handle_test_image_command,
6701 .usage =
"filename [offset [type]]",
6706 .handler = handle_target_get_reg,
6707 .help =
"Get register values from the target",
6708 .usage =
"[-force] list",
6713 .handler = handle_set_reg_command,
6714 .help =
"Set target register values",
6718 .name =
"read_memory",
6720 .handler = handle_target_read_memory,
6721 .help =
"Read Tcl list of 8/16/32/64 bit numbers from target memory",
6722 .usage =
"address width count ['phys']",
6725 .name =
"write_memory",
6727 .handler = handle_target_write_memory,
6728 .help =
"Write Tcl list of 8/16/32/64 bit numbers to target memory",
6729 .usage =
"address width data ['phys']",
6732 .name =
"debug_reason",
6734 .handler = handle_target_debug_reason,
6735 .help =
"displays the debug reason of this target",
6739 .name =
"reset_nag",
6740 .handler = handle_target_reset_nag,
6742 .help =
"Nag after each reset about options that could have been "
6743 "enabled to improve performance.",
6744 .usage =
"['enable'|'disable']",
6748 .handler = handle_ps_command,
6750 .help =
"list all tasks",
6754 .name =
"test_mem_access",
6755 .handler = handle_test_mem_access_command,
6757 .help =
"Test the target's memory access functions",
6784 return "BREAKPOINT";
6786 return "WATCHPOINT";
6788 return "WPTANDBKPT";
6790 return "SINGLESTEP";
struct target_type aarch64_target
struct target_type armv8r_target
struct target_type arcv2_target
struct target_type arm11_target
Holds methods for ARM11xx targets.
struct target_type arm720t_target
Holds methods for ARM720 targets.
struct target_type arm7tdmi_target
Holds methods for ARM7TDMI targets.
struct target_type arm920t_target
Holds methods for ARM920 targets.
struct target_type arm926ejs_target
Holds methods for ARM926 targets.
struct target_type arm946e_target
Holds methods for ARM946 targets.
struct target_type arm966e_target
Holds methods for ARM966 targets.
struct target_type arm9tdmi_target
Holds methods for ARM9TDMI targets.
struct target_type avr32_ap7k_target
struct target_type avr_target
char * buf_to_hex_str(const void *_buf, unsigned int buf_len)
static uint32_t buf_get_u32(const uint8_t *_buffer, unsigned int first, unsigned int num)
Retrieves num bits from _buffer, starting at the first bit, returning the bits in a 32-bit word.
int watchpoint_add(struct target *target, target_addr_t address, unsigned int length, enum watchpoint_rw rw, uint64_t value, uint64_t mask)
int breakpoint_remove(struct target *target, target_addr_t address)
int watchpoint_remove(struct target *target, target_addr_t address)
int breakpoint_add(struct target *target, target_addr_t address, unsigned int length, enum breakpoint_type type)
int context_breakpoint_add(struct target *target, uint32_t asid, unsigned int length, enum breakpoint_type type)
int watchpoint_remove_all(struct target *target)
int breakpoint_remove_all(struct target *target)
int hybrid_breakpoint_add(struct target *target, target_addr_t address, uint32_t asid, unsigned int length, enum breakpoint_type type)
#define WATCHPOINT_IGNORE_DATA_VALUE_MASK
struct command_context * current_command_context(Jim_Interp *interp)
void command_print_sameline(struct command_invocation *cmd, const char *format,...)
void command_print(struct command_invocation *cmd, const char *format,...)
int command_run_line(struct command_context *context, char *line)
#define CMD
Use this macro to access the command being handled, rather than accessing the variable directly.
#define CALL_COMMAND_HANDLER(name, extra ...)
Use this to macro to call a command helper (or a nested handler).
#define CMD_NAME
Use this macro to access the name of the command being handled, rather than accessing the variable di...
#define CMD_ARGV
Use this macro to access the arguments for the command being handled, rather than accessing the varia...
#define COMMAND_PARSE_ADDRESS(in, out)
#define COMMAND_PARSE_ON_OFF(in, out)
parses an on/off command argument
#define ERROR_COMMAND_SYNTAX_ERROR
static int register_commands_override_target(struct command_context *cmd_ctx, const char *cmd_prefix, const struct command_registration *cmds, struct target *target)
Register one or more commands, as register_commands(), plus specify that command should override the ...
#define ERROR_COMMAND_CLOSE_CONNECTION
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
#define CMD_JIMTCL_ARGV
Use this macro to access the jimtcl arguments for the command being handled, rather than accessing th...
#define COMMAND_PARSE_NUMBER(type, in, out)
parses the string in into out as a type, or prints a command error and passes the error code to the c...
#define CMD_CTX
Use this macro to access the context of the command being handled, rather than accessing the variable...
static struct command * jim_to_command(Jim_Interp *interp)
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
#define ERROR_COMMAND_ARGUMENT_INVALID
static int register_commands(struct command_context *cmd_ctx, const char *cmd_prefix, const struct command_registration *cmds)
Register one or more commands in the specified context, as children of parent (or top-level commends,...
struct target_type cortexr4_target
struct target_type cortexa_target
struct target_type cortexm_target
struct target_type dsp563xx_target
Holds methods for DSP563XX targets.
struct target_type dsp5680xx_target
Holds methods for dsp5680xx targets.
uint64_t buffer
Pointer to data buffer to send over SPI.
uint32_t size
Size of dw_spi_transaction::buffer.
uint32_t buffer_size
Size of dw_spi_program::buffer.
uint32_t address
Starting address. Sector aligned.
struct target_type esirisc_target
struct target_type esp32_target
Holds methods for Xtensa targets.
struct target_type esp32s2_target
struct target_type esp32s3_target
Holds methods for Xtensa targets.
static struct esp_usb_jtag * priv
struct target_type fa526_target
Holds methods for FA526 targets.
struct target_type dragonite_target
struct target_type feroceon_target
#define ERROR_FLASH_OPERATION_FAILED
int fileio_write(struct fileio *fileio, size_t size, const void *buffer, size_t *size_written)
int fileio_close(struct fileio *fileio)
int fileio_size(struct fileio *fileio, size_t *size)
FIX!!!!
int fileio_open(struct fileio **fileio, const char *url, enum fileio_access access_type, enum fileio_type type)
struct target_type hla_target
void image_close(struct image *image)
int image_read_section(struct image *image, int section, target_addr_t offset, uint32_t size, uint8_t *buffer, size_t *size_read)
int image_calculate_checksum(const uint8_t *buffer, uint32_t nbytes, uint32_t *checksum)
int image_open(struct image *image, const char *url, const char *type_string)
int jim_getopt_wide(struct jim_getopt_info *goi, jim_wide *puthere)
Remove argv[0] as wide.
int jim_getopt_setup(struct jim_getopt_info *p, Jim_Interp *interp, int argc, Jim_Obj *const *argv)
GetOpt - how to.
int jim_getopt_string(struct jim_getopt_info *goi, const char **puthere, int *len)
Remove argv[0] as string.
int jim_getopt_nvp(struct jim_getopt_info *goi, const struct jim_nvp *nvp, struct jim_nvp **puthere)
Remove argv[0] as NVP.
void jim_getopt_nvp_unknown(struct jim_getopt_info *goi, const struct jim_nvp *nvptable, int hadprefix)
Create an appropriate error message for an NVP.
int jim_getopt_obj(struct jim_getopt_info *goi, Jim_Obj **puthere)
Remove argv[0] from the list.
struct jim_nvp * jim_nvp_value2name_simple(const struct jim_nvp *p, int value)
int jtag_unregister_event_callback(jtag_event_handler_t callback, void *priv)
void jtag_poll_unmask(bool saved)
Restore saved mask for polling.
void jtag_poll_set_enabled(bool value)
Assign flag reporting whether JTAG polling is disallowed.
int jtag_srst_asserted(int *srst_asserted)
bool is_jtag_poll_safe(void)
Return true if it's safe for a background polling task to access the JTAG scan chain.
int jtag_power_dropout(int *dropout)
int jtag_register_event_callback(jtag_event_handler_t callback, void *priv)
bool jtag_poll_get_enabled(void)
Return flag reporting whether JTAG polling is disallowed.
bool jtag_poll_mask(void)
Mask (disable) polling and return the current mask status that should be feed to jtag_poll_unmask() t...
The JTAG interface can be implemented with a software or hardware fifo.
struct jtag_tap * jtag_tap_by_jim_obj(Jim_Interp *interp, Jim_Obj *obj)
static void list_add(struct list_head *new, struct list_head *head)
static void list_add_tail(struct list_head *new, struct list_head *head)
#define list_for_each_entry_safe(p, n, h, field)
#define list_for_each_entry(p, h, field)
static void list_del(struct list_head *entry)
static void INIT_LIST_HEAD(struct list_head *list)
void alive_sleep(uint64_t ms)
#define LOG_TARGET_INFO(target, fmt_str,...)
#define ERROR_NOT_IMPLEMENTED
#define LOG_WARNING(expr ...)
#define LOG_TARGET_ERROR(target, fmt_str,...)
#define LOG_TARGET_DEBUG(target, fmt_str,...)
#define LOG_ERROR(expr ...)
#define LOG_INFO(expr ...)
#define LOG_DEBUG(expr ...)
struct target_type ls1_sap_target
struct target_type mem_ap_target
struct target_type mips_m4k_target
struct target_type mips_mips64_target
Upper level NOR flash interfaces.
void nvp_unknown_command_print(struct command_invocation *cmd, const struct nvp *nvp, const char *param_name, const char *param_value)
const struct nvp * nvp_name2value(const struct nvp *p, const char *name)
const struct nvp * nvp_value2name(const struct nvp *p, int value)
static uint32_t lh(unsigned int rd, unsigned int base, uint16_t offset) __attribute__((unused))
struct target_type or1k_target
uint8_t bits[QN908X_FLASH_MAX_BLOCKS *QN908X_FLASH_PAGES_PER_BLOCK/8]
struct target_type quark_d20xx_target
struct target_type quark_x10xx_target
struct reg * register_get_by_name(struct reg_cache *first, const char *name, bool search_all)
int gettimeofday(struct timeval *tv, struct timezone *tz)
struct target_type riscv_target
void rtos_destroy(struct target *target)
int rtos_smp_init(struct target *target)
int rtos_create(struct jim_getopt_info *goi, struct target *target)
target_addr_t addr
Start address to search for the control block.
bool openocd_is_shutdown_pending(void)
#define CONNECTION_LIMIT_UNLIMITED
#define ERROR_SERVER_INTERRUPTED
#define foreach_smp_target(pos, head)
struct target_type stm8_target
enum breakpoint_type type
struct target * current_target_override
struct target * current_target
When run_command is called, a new instance will be created on the stack, filled with the proper value...
const struct command_registration * chain
If non-NULL, the commands in chain will be registered in the same context and scope of this registrat...
const char * usage
a string listing the options and arguments, required or optional
unsigned int num_sections
struct imagesection * sections
target_addr_t base_address
A TCL -ish GetOpt like code.
Name Value Pairs, aka: NVP.
bool enabled
Is this TAP currently enabled?
Name Value Pairs, aka: NVP.
int(* get)(struct reg *reg)
int(* set)(struct reg *reg, uint8_t *buf)
const struct reg_arch_type * type
char *(* ps_command)(struct target *target)
const struct rtos_type * type
char * basedir
Base directory for semihosting I/O operations.
int(* callback)(struct target *target, enum target_event event, void *priv)
struct target_event_callback * next
int(* callback)(struct target *target, enum target_reset_mode reset_mode, void *priv)
int(* callback)(void *priv)
struct target_timer_callback * next
enum target_timer_type type
int(* callback)(struct target *target, size_t len, uint8_t *data, void *priv)
This holds methods shared between all instances of a given target type.
int(* add_context_breakpoint)(struct target *target, struct breakpoint *breakpoint)
int(* add_breakpoint)(struct target *target, struct breakpoint *breakpoint)
int(* write_memory)(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Target memory write callback.
int(* hit_watchpoint)(struct target *target, struct watchpoint **hit_watchpoint)
const char * name
Name of this type of target.
int(* deassert_reset)(struct target *target)
The implementation is responsible for polling the target such that target->state reflects the state c...
int(* get_gdb_reg_list)(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class)
Target register access for GDB.
int(* target_create)(struct target *target, Jim_Interp *interp)
int(* resume)(struct target *target, bool current, target_addr_t address, bool handle_breakpoints, bool debug_execution)
void(* deinit_target)(struct target *target)
Free all the resources allocated by the target.
int(* halt)(struct target *target)
int(* check_reset)(struct target *target)
int(* gdb_fileio_end)(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
int(* blank_check_memory)(struct target *target, struct target_memory_check_block *blocks, int num_blocks, uint8_t erased_value)
int(* assert_reset)(struct target *target)
int(* run_algorithm)(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_param, target_addr_t entry_point, target_addr_t exit_point, unsigned int timeout_ms, void *arch_info)
Target algorithm support.
int(* wait_algorithm)(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_param, target_addr_t exit_point, unsigned int timeout_ms, void *arch_info)
const struct command_registration * commands
int(* profiling)(struct target *target, uint32_t *samples, uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
int(* soft_reset_halt)(struct target *target)
const char *(* get_gdb_arch)(const struct target *target)
Target architecture for GDB.
int(* arch_state)(struct target *target)
unsigned int(* address_bits)(struct target *target)
int(* read_memory)(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Target memory read callback.
int(* get_gdb_fileio_info)(struct target *target, struct gdb_fileio_info *fileio_info)
unsigned int(* data_bits)(struct target *target)
int(* target_jim_configure)(struct target *target, struct jim_getopt_info *goi)
int(* step)(struct target *target, bool current, target_addr_t address, bool handle_breakpoints)
int(* read_phys_memory)(struct target *target, target_addr_t phys_address, uint32_t size, uint32_t count, uint8_t *buffer)
int(* get_gdb_reg_list_noread)(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class)
Same as get_gdb_reg_list, but doesn't read the register values.
int(* mmu)(struct target *target, int *enabled)
int(* start_algorithm)(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_param, target_addr_t entry_point, target_addr_t exit_point, void *arch_info)
int(* read_buffer)(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
int(* add_watchpoint)(struct target *target, struct watchpoint *watchpoint)
int(* write_buffer)(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
int(* poll)(struct target *target)
int(* add_hybrid_breakpoint)(struct target *target, struct breakpoint *breakpoint)
int(* examine)(struct target *target)
This method is used to perform target setup that requires JTAG access.
int(* write_phys_memory)(struct target *target, target_addr_t phys_address, uint32_t size, uint32_t count, const uint8_t *buffer)
int(* remove_breakpoint)(struct target *target, struct breakpoint *breakpoint)
int(* virt2phys)(struct target *target, target_addr_t address, target_addr_t *physical)
int(* checksum_memory)(struct target *target, target_addr_t address, uint32_t count, uint32_t *checksum)
int(* remove_watchpoint)(struct target *target, struct watchpoint *watchpoint)
struct semihosting * semihosting
target_addr_t working_area
target_addr_t working_area_virt
uint32_t working_area_size
struct trace * trace_info
enum target_debug_reason debug_reason
enum target_endianness endianness
struct reg_cache * reg_cache
struct list_head * smp_targets
struct breakpoint * breakpoints
struct working_area * working_areas
struct gdb_fileio_info * fileio_info
struct debug_msg_receiver * dbgmsg
struct list_head events_action
struct target_type * type
struct backoff_timer backoff
target_addr_t working_area_phys
struct watchpoint * watchpoints
bool working_area_phys_spec
bool running_alg
true if the target is currently running a downloaded "algorithm" instead of arbitrary user code.
bool working_area_virt_spec
bool examined
Indicates whether this target has been examined.
bool defer_examine
Should we defer examine to later.
Wrapper for transport lifecycle operations.
int(* override_target)(const char **targetname)
Optional.
struct working_area * next
struct working_area ** user
COMMAND_HANDLER(handle_target_init_command)
static bool target_reset_nag
void target_buffer_get_u16_array(struct target *target, const uint8_t *buffer, uint32_t count, uint16_t *dstbuf)
void target_buffer_set_u24(struct target *target, uint8_t *buffer, uint32_t value)
int target_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fileio_info)
Obtain file-I/O information from target for GDB to do syscall.
static int run_srst_deasserted
int target_add_watchpoint(struct target *target, struct watchpoint *watchpoint)
Add the watchpoint for target.
static int target_call_timer_callback(struct target_timer_callback *cb, int64_t *now)
struct target * all_targets
static int target_get_gdb_fileio_info_default(struct target *target, struct gdb_fileio_info *fileio_info)
int target_run_read_async_algorithm(struct target *target, uint8_t *buffer, uint32_t count, int block_size, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_params, uint32_t buffer_start, uint32_t buffer_size, uint32_t entry_point, uint32_t exit_point, void *arch_info)
This routine is a wrapper for asynchronous algorithms.
int target_write_phys_u32(struct target *target, target_addr_t address, uint32_t value)
uint64_t target_buffer_get_u64(struct target *target, const uint8_t *buffer)
int target_call_event_callbacks(struct target *target, enum target_event event)
struct target * get_target(const char *id)
void target_free_all_working_areas(struct target *target)
int target_unregister_reset_callback(int(*callback)(struct target *target, enum target_reset_mode reset_mode, void *priv), void *priv)
int target_write_phys_u64(struct target *target, target_addr_t address, uint64_t value)
static OOCD_LIST_HEAD(target_reset_callback_list)
static int target_write_buffer_default(struct target *target, target_addr_t address, uint32_t count, const uint8_t *buffer)
int target_unregister_event_callback(int(*callback)(struct target *target, enum target_event event, void *priv), void *priv)
static void write_long(FILE *f, int l, struct target *target)
int target_read_phys_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
static void binprint(struct command_invocation *cmd, const char *text, const uint8_t *buf, int size)
int target_register_event_callback(int(*callback)(struct target *target, enum target_event event, void *priv), void *priv)
static const struct command_registration target_command_handlers[]
int target_write_phys_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
static int run_power_restore
int target_halt(struct target *target)
static struct target_timer_callback * target_timer_callbacks
int target_get_gdb_reg_list_noread(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class)
Obtain the registers for GDB, but don't read register values from the target.
bool target_supports_gdb_connection(const struct target *target)
Check if target allows GDB connections.
int target_arch_state(struct target *target)
void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value)
static int target_free_working_area_restore(struct target *target, struct working_area *area, int restore)
int target_call_timer_callbacks_now(void)
Invoke this to ensure that e.g.
int target_remove_breakpoint(struct target *target, struct breakpoint *breakpoint)
Remove the breakpoint for target.
static int target_profiling(struct target *target, uint32_t *samples, uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value)
int target_register_commands(struct command_context *cmd_ctx)
static const struct nvp nvp_target_debug_reason[]
static int target_read_buffer_default(struct target *target, target_addr_t address, uint32_t count, uint8_t *buffer)
int target_checksum_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t *crc)
static void target_merge_working_areas(struct target *target)
static const struct nvp nvp_target_state[]
static int handle_bp_command_list(struct command_invocation *cmd)
int target_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
static int get_target_with_common_rtos_type(struct command_invocation *cmd, struct list_head *lh, struct target **result)
int target_add_hybrid_breakpoint(struct target *target, struct breakpoint *breakpoint)
Add the ContextID & IVA breakpoint for target.
static int default_examine(struct target *target)
int target_write_u8(struct target *target, target_addr_t address, uint8_t value)
int target_add_breakpoint(struct target *target, struct breakpoint *breakpoint)
Add the breakpoint for target.
target_addr_t target_address_max(struct target *target)
Return the highest accessible address for this target.
int target_write_u16(struct target *target, target_addr_t address, uint16_t value)
int target_unregister_timer_callback(int(*callback)(void *priv), void *priv)
int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
Pass GDB file-I/O response to target after finishing host syscall.
static struct jim_nvp nvp_config_opts[]
int target_read_buffer(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
static int jim_target_configure(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
int target_unregister_trace_callback(int(*callback)(struct target *target, size_t len, uint8_t *data, void *priv), void *priv)
int target_read_u8(struct target *target, target_addr_t address, uint8_t *value)
static void write_string(FILE *f, char *s)
int target_blank_check_memory(struct target *target, struct target_memory_check_block *blocks, int num_blocks, uint8_t erased_value)
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, target_addr_t entry_point, target_addr_t exit_point, unsigned int timeout_ms, void *arch_info)
Downloads a target-specific native code algorithm to the target, and executes it.
static void target_buffer_set_u8(struct target *target, uint8_t *buffer, uint8_t value)
unsigned int target_address_bits(struct target *target)
Return the number of address bits this target supports.
static struct target_list * __attribute__((warn_unused_result))
int target_profiling_default(struct target *target, uint32_t *samples, uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
static const struct command_registration target_subcommand_handlers[]
int target_write_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Write count items of size bytes to the memory of target at the address given.
static int jtag_enable_callback(enum jtag_event event, void *priv)
int target_get_gdb_reg_list(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class)
Obtain the registers for GDB.
static const struct nvp nvp_error_target[]
int target_call_timer_callbacks(void)
int target_write_u64(struct target *target, target_addr_t address, uint64_t value)
static int jim_target_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
static struct target_event_callback * target_event_callbacks
static COMMAND_HELPER(parse_load_image_command, struct image *image, target_addr_t *min_address, target_addr_t *max_address)
struct target * get_current_target_or_null(struct command_context *cmd_ctx)
static void target_split_working_area(struct working_area *area, uint32_t size)
const char * target_debug_reason_str(enum target_debug_reason reason)
static int target_init(struct command_context *cmd_ctx)
int target_hit_watchpoint(struct target *target, struct watchpoint **hit_watchpoint)
Find out the just hit watchpoint for target.
static const struct jim_nvp nvp_target_event[]
int target_call_reset_callbacks(struct target *target, enum target_reset_mode reset_mode)
uint32_t target_get_working_area_avail(struct target *target)
@ TCFG_GDB_MAX_CONNECTIONS
int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
static const struct command_registration target_instance_command_handlers[]
bool get_target_reset_nag(void)
unsigned int target_data_bits(struct target *target)
Return the number of data bits this target supports.
static int find_target(struct command_invocation *cmd, const char *name)
int target_remove_watchpoint(struct target *target, struct watchpoint *watchpoint)
Remove the watchpoint for target.
const char * target_event_name(enum target_event event)
Return the name of a target event enumeration value.
int target_write_u32(struct target *target, target_addr_t address, uint32_t value)
int target_examine_one(struct target *target)
Examine the specified target, letting it perform any Initialisation that requires JTAG access.
const char * target_state_name(const struct target *t)
Return the name of this targets current state.
int(* target_write_fn)(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
static int target_create(struct jim_getopt_info *goi)
static void print_wa_layout(struct target *target)
#define DEFAULT_HALT_TIMEOUT
int target_poll(struct target *target)
static int target_call_timer_callbacks_check_time(int checktime)
static int sense_handler(void)
static int target_timer_callback_periodic_restart(struct target_timer_callback *cb, int64_t *now)
int target_free_working_area(struct target *target, struct working_area *area)
Free a working area.
int target_alloc_working_area_try(struct target *target, uint32_t size, struct working_area **area)
int target_register_timer_callback(int(*callback)(void *priv), unsigned int time_ms, enum target_timer_type type, void *priv)
The period is very approximate, the callback can happen much more often or much more rarely than spec...
int target_read_u16(struct target *target, target_addr_t address, uint16_t *value)
int target_run_flash_async_algorithm(struct target *target, const uint8_t *buffer, uint32_t count, int block_size, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_params, uint32_t buffer_start, uint32_t buffer_size, uint32_t entry_point, uint32_t exit_point, void *arch_info)
Streams data to a circular buffer on target intended for consumption by code running asynchronously o...
void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value)
static const int polling_interval
void target_buffer_set_u64_array(struct target *target, uint8_t *buffer, uint32_t count, const uint64_t *srcbuf)
static void target_reset_examined(struct target *target)
Reset the examined flag for the given target.
int target_add_context_breakpoint(struct target *target, struct breakpoint *breakpoint)
Add the ContextID breakpoint for target.
static int target_init_one(struct command_context *cmd_ctx, struct target *target)
static int run_power_dropout
int target_resume(struct target *target, bool current, target_addr_t address, bool handle_breakpoints, bool debug_execution)
Make the target (re)start executing using its saved execution context (possibly with some modificatio...
int target_read_u32(struct target *target, target_addr_t address, uint32_t *value)
uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer)
int target_read_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Read count items of size bytes from the memory of target at the address given.
bool target_has_event_action(const struct target *target, enum target_event event)
Returns true only if the target has a handler for the specified event.
static const struct command_registration target_exec_command_handlers[]
void target_buffer_get_u64_array(struct target *target, const uint8_t *buffer, uint32_t count, uint64_t *dstbuf)
static const struct nvp nvp_reset_modes[]
const char * debug_reason_name(const struct target *t)
static int default_check_reset(struct target *target)
void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, const uint16_t *srcbuf)
static struct fast_load * fastload
int target_register_reset_callback(int(*callback)(struct target *target, enum target_reset_mode reset_mode, void *priv), void *priv)
uint32_t target_buffer_get_u24(struct target *target, const uint8_t *buffer)
static int run_srst_asserted
void target_buffer_get_u32_array(struct target *target, const uint8_t *buffer, uint32_t count, uint32_t *dstbuf)
static const struct jim_nvp nvp_target_endian[]
int64_t target_timer_next_event(void)
Returns when the next registered event will take place.
void target_handle_md_output(struct command_invocation *cmd, struct target *target, target_addr_t address, unsigned int size, unsigned int count, const uint8_t *buffer)
int target_write_phys_u16(struct target *target, target_addr_t address, uint16_t value)
static void free_fastload(void)
static int handle_target(void *priv)
const char * target_get_gdb_arch(const struct target *target)
Obtain the architecture for GDB.
static int target_restore_working_area(struct target *target, struct working_area *area)
static int target_gdb_fileio_end_default(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
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, target_addr_t exit_point, unsigned int timeout_ms, void *arch_info)
Waits for an algorithm started with target_start_algorithm() to complete.
static int target_fill_mem(struct target *target, target_addr_t address, target_write_fn fn, unsigned int data_size, uint64_t b, unsigned int c)
static void target_destroy(struct target *target)
int target_wait_state(struct target *target, enum target_state state, unsigned int ms)
static int target_configure(struct jim_getopt_info *goi, struct target *target)
int target_step(struct target *target, bool current, target_addr_t address, bool handle_breakpoints)
Step the target.
int target_register_trace_callback(int(*callback)(struct target *target, size_t len, uint8_t *data, void *priv), void *priv)
struct target * get_current_target(struct command_context *cmd_ctx)
void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, const uint32_t *srcbuf)
static int handle_bp_command_set(struct command_invocation *cmd, target_addr_t addr, uint32_t asid, unsigned int length, int hw)
static void write_gmon(uint32_t *samples, uint32_t sample_num, const char *filename, bool with_range, uint32_t start_address, uint32_t end_address, struct target *target, uint32_t duration_ms)
static int identity_virt2phys(struct target *target, target_addr_t virtual, target_addr_t *physical)
static int target_register_user_commands(struct command_context *cmd_ctx)
static void append_to_list_all_targets(struct target *target)
void target_handle_event(struct target *target, enum target_event e)
uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer)
static int target_soft_reset_halt(struct target *target)
const char * target_type_name(const struct target *target)
Get the target type name.
static int jim_target_invoke_event(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
static int no_mmu(struct target *target, int *enabled)
int target_call_trace_callbacks(struct target *target, size_t len, uint8_t *data)
static int target_process_reset(struct command_invocation *cmd, enum target_reset_mode reset_mode)
static const char * target_strerror_safe(int err)
static int64_t target_timer_next_event_value
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, target_addr_t entry_point, target_addr_t exit_point, void *arch_info)
Executes a target-specific native code algorithm and leaves it running.
static void write_data(FILE *f, const void *data, size_t len)
void target_quit(void)
Free all the resources allocated by targets and the target layer.
int target_write_phys_u8(struct target *target, target_addr_t address, uint8_t value)
static struct target_type * target_types[]
int target_read_u64(struct target *target, target_addr_t address, uint64_t *value)
const char * target_reset_mode_name(enum target_reset_mode reset_mode)
Return the name of a target reset reason enumeration value.
static void target_free_all_working_areas_restore(struct target *target, int restore)
#define ERROR_TARGET_NOT_HALTED
#define ERROR_TARGET_INIT_FAILED
static bool target_was_examined(const struct target *target)
#define ERROR_TARGET_UNALIGNED_ACCESS
#define ERROR_TARGET_INVALID
@ TARGET_TIMER_TYPE_PERIODIC
@ TARGET_EVENT_DEBUG_RESUMED
@ TARGET_EVENT_EXAMINE_START
@ TARGET_EVENT_RESET_START
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X106
@ TARGET_EVENT_GDB_FLASH_WRITE_END
@ TARGET_EVENT_RESET_ASSERT_POST
@ TARGET_EVENT_RESET_DEASSERT_POST
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X102
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X107
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X105
@ TARGET_EVENT_EXAMINE_FAIL
@ TARGET_EVENT_EXAMINE_END
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X104
@ TARGET_EVENT_RESET_INIT
@ TARGET_EVENT_RESET_DEASSERT_PRE
@ TARGET_EVENT_GDB_FLASH_ERASE_START
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X103
@ TARGET_EVENT_DEBUG_HALTED
@ TARGET_EVENT_RESET_ASSERT_PRE
@ TARGET_EVENT_RESET_ASSERT
@ TARGET_EVENT_GDB_FLASH_WRITE_START
@ TARGET_EVENT_RESUME_START
@ TARGET_EVENT_STEP_START
@ TARGET_EVENT_GDB_ATTACH
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X100
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X101
@ TARGET_EVENT_RESUME_END
@ TARGET_EVENT_GDB_FLASH_ERASE_END
@ TARGET_EVENT_GDB_DETACH
@ TARGET_EVENT_TRACE_CONFIG
static const char * target_name(const struct target *target)
Returns the instance-specific name of the specified target.
#define ERROR_TARGET_NOT_EXAMINED
#define TARGET_DEFAULT_POLLING_INTERVAL
#define ERROR_TARGET_TIMEOUT
#define ERROR_TARGET_RESOURCE_NOT_AVAILABLE
static void target_set_examined(struct target *target)
Sets the examined flag for the given target.
#define ERROR_TARGET_NOT_RUNNING
#define ERROR_TARGET_DATA_ABORT
#define ERROR_TARGET_FAILURE
#define ERROR_TARGET_TRANSLATION_FAULT
int target_request_register_commands(struct command_context *cmd_ctx)
struct target_type testee_target
struct target_type xtensa_chip_target
Methods for generic example of Xtensa-based chip-level targets.
struct target_type xscale_target
float duration_elapsed(const struct duration *duration)
int timeval_compare(const struct timeval *x, const struct timeval *y)
int timeval_add_time(struct timeval *result, long sec, long usec)
int duration_measure(struct duration *duration)
Update the duration->elapsed field to finish the duration measurement.
int duration_start(struct duration *duration)
Update the duration->start field to start the duration measurement.
float duration_kbps(const struct duration *duration, size_t count)
int trace_register_commands(struct command_context *cmd_ctx)
struct transport * get_current_transport(void)
Returns the transport currently being used by this debug or programming session.
static void h_u32_to_be(uint8_t *buf, uint32_t val)
static uint64_t le_to_h_u64(const uint8_t *buf)
static uint32_t be_to_h_u24(const uint8_t *buf)
static void h_u16_to_be(uint8_t *buf, uint16_t val)
static uint64_t be_to_h_u64(const uint8_t *buf)
static uint16_t le_to_h_u16(const uint8_t *buf)
static uint32_t le_to_h_u24(const uint8_t *buf)
static void h_u32_to_le(uint8_t *buf, uint32_t val)
#define DIV_ROUND_UP(m, n)
Rounds m up to the nearest multiple of n using division.
static uint32_t be_to_h_u32(const uint8_t *buf)
static void h_u24_to_le(uint8_t *buf, unsigned int val)
static void h_u24_to_be(uint8_t *buf, unsigned int val)
static uint16_t be_to_h_u16(const uint8_t *buf)
static void h_u16_to_le(uint8_t *buf, uint16_t val)
static uint32_t le_to_h_u32(const uint8_t *buf)
static void h_u64_to_be(uint8_t *buf, uint64_t val)
static void h_u64_to_le(uint8_t *buf, uint64_t val)