53 #define DEFAULT_HALT_TIMEOUT 5000
63 int fileio_errno,
bool ctrl_c);
128 { .name =
NULL, .value = -1 }
143 { .value = -1, .name =
NULL }
206 { .name =
NULL, .value = -1 }
215 { .name =
NULL, .value = -1 },
228 { .name =
NULL, .value = -1 },
236 { .name =
NULL, .value = -1 },
244 { .name =
NULL, .value = -1 },
255 cp =
"(*BUG*unknown*BUG*)";
266 cp =
"(*BUG*unknown*BUG*)";
270 cp =
"examine deferred";
280 LOG_ERROR(
"Invalid target event: %d", (
int)(event));
281 cp =
"(*BUG*unknown*BUG*)";
291 LOG_ERROR(
"Invalid target reset mode: %d", (
int)(reset_mode));
292 cp =
"(*BUG*unknown*BUG*)";
388 for (i = 0; i <
count; i++)
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++)
446 unsigned int index, counter;
447 if (parse_uint(
id, &index) !=
ERROR_OK)
463 LOG_ERROR(
"BUG: current_target out of bounds");
498 LOG_INFO(
"Halt timed out, wake up GDB.");
557 int handle_breakpoints,
int debug_execution)
614 sprintf(buf,
"ocd_process_reset %s", n->
name);
615 retval = Jim_Eval(
cmd->ctx->interp, buf);
619 if (retval != JIM_OK) {
620 Jim_MakeErrorMessage(
cmd->ctx->interp);
748 LOG_ERROR(
"Target %s does not support soft_reset_halt",
774 int num_mem_params,
struct mem_param *mem_params,
777 unsigned int timeout_ms,
void *
arch_info)
786 LOG_ERROR(
"Target type '%s' does not support %s",
793 num_mem_params, mem_params,
795 entry_point, exit_point, timeout_ms,
arch_info);
815 int num_mem_params,
struct mem_param *mem_params,
816 int num_reg_params,
struct reg_param *reg_params,
827 LOG_ERROR(
"Target type '%s' does not support %s",
832 LOG_ERROR(
"Target is already running an algorithm");
838 num_mem_params, mem_params,
839 num_reg_params, reg_params,
859 int num_mem_params,
struct mem_param *mem_params,
860 int num_reg_params,
struct reg_param *reg_params,
867 LOG_ERROR(
"Target type '%s' does not support %s",
872 LOG_ERROR(
"Target is not running an algorithm");
877 num_mem_params, mem_params,
878 num_reg_params, reg_params,
931 const uint8_t *
buffer, uint32_t
count,
int block_size,
932 int num_mem_params,
struct mem_param *mem_params,
933 int num_reg_params,
struct reg_param *reg_params,
934 uint32_t buffer_start, uint32_t buffer_size,
935 uint32_t entry_point, uint32_t exit_point,
void *
arch_info)
940 const uint8_t *buffer_orig =
buffer;
944 uint32_t wp_addr = buffer_start;
945 uint32_t rp_addr = buffer_start + 4;
946 uint32_t fifo_start_addr = buffer_start + 8;
947 uint32_t fifo_end_addr = buffer_start + buffer_size;
949 uint32_t wp = fifo_start_addr;
950 uint32_t rp = fifo_start_addr;
964 num_reg_params, reg_params,
970 LOG_ERROR(
"error starting target flash write algorithm");
982 LOG_DEBUG(
"offs 0x%zx count 0x%" PRIx32
" wp 0x%" PRIx32
" rp 0x%" PRIx32,
986 LOG_ERROR(
"flash write algorithm aborted by target");
991 if (!
IS_ALIGNED(rp - fifo_start_addr, block_size) || rp < fifo_start_addr || rp >= fifo_end_addr) {
992 LOG_ERROR(
"corrupted fifo read pointer 0x%" PRIx32, rp);
999 uint32_t thisrun_bytes;
1001 thisrun_bytes = rp - wp - block_size;
1002 else if (rp > fifo_start_addr)
1003 thisrun_bytes = fifo_end_addr - wp;
1005 thisrun_bytes = fifo_end_addr - wp - block_size;
1007 if (thisrun_bytes == 0) {
1017 LOG_ERROR(
"timeout waiting for algorithm, a target reset is recommended");
1027 if (thisrun_bytes >
count * block_size)
1028 thisrun_bytes =
count * block_size;
1031 if (thisrun_bytes >= 16)
1032 thisrun_bytes -= (rp + thisrun_bytes) & 0x03;
1041 count -= thisrun_bytes / block_size;
1042 wp += thisrun_bytes;
1043 if (wp >= fifo_end_addr)
1044 wp = fifo_start_addr;
1061 num_reg_params, reg_params,
1067 LOG_ERROR(
"error waiting for target flash write algorithm");
1074 if (retval ==
ERROR_OK && rp == 0) {
1075 LOG_ERROR(
"flash write algorithm aborted by target");
1085 int num_mem_params,
struct mem_param *mem_params,
1086 int num_reg_params,
struct reg_param *reg_params,
1087 uint32_t buffer_start, uint32_t buffer_size,
1088 uint32_t entry_point, uint32_t exit_point,
void *
arch_info)
1093 const uint8_t *buffer_orig =
buffer;
1097 uint32_t wp_addr = buffer_start;
1098 uint32_t rp_addr = buffer_start + 4;
1099 uint32_t fifo_start_addr = buffer_start + 8;
1100 uint32_t fifo_end_addr = buffer_start + buffer_size;
1102 uint32_t wp = fifo_start_addr;
1103 uint32_t rp = fifo_start_addr;
1117 num_reg_params, reg_params,
1123 LOG_ERROR(
"error starting target flash read algorithm");
1130 LOG_ERROR(
"failed to get write pointer");
1134 LOG_DEBUG(
"offs 0x%zx count 0x%" PRIx32
" wp 0x%" PRIx32
" rp 0x%" PRIx32,
1138 LOG_ERROR(
"flash read algorithm aborted by target");
1143 if (!
IS_ALIGNED(wp - fifo_start_addr, block_size) || wp < fifo_start_addr || wp >= fifo_end_addr) {
1144 LOG_ERROR(
"corrupted fifo write pointer 0x%" PRIx32, wp);
1150 uint32_t thisrun_bytes;
1152 thisrun_bytes = wp - rp;
1154 thisrun_bytes = fifo_end_addr - rp;
1156 if (thisrun_bytes == 0) {
1166 LOG_ERROR(
"timeout waiting for algorithm, a target reset is recommended");
1176 if (thisrun_bytes >
count * block_size)
1177 thisrun_bytes =
count * block_size;
1180 if (thisrun_bytes >= 16)
1181 thisrun_bytes -= (rp + thisrun_bytes) & 0x03;
1190 count -= thisrun_bytes / block_size;
1191 rp += thisrun_bytes;
1192 if (rp >= fifo_end_addr)
1193 rp = fifo_start_addr;
1215 num_reg_params, reg_params,
1221 LOG_ERROR(
"error waiting for target flash write algorithm");
1228 if (retval ==
ERROR_OK && wp == 0) {
1229 LOG_ERROR(
"flash read algorithm aborted by target");
1369 struct reg **reg_list[],
int *reg_list_size,
1380 reg_list_size, reg_class);
1391 struct reg **reg_list[],
int *reg_list_size,
1396 reg_list_size, reg_class) ==
ERROR_OK)
1468 uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
1471 num_samples, seconds);
1485 if (!
type->check_reset)
1488 assert(
type->init_target);
1490 int retval =
type->init_target(cmd_ctx,
target);
1500 if (!
type->virt2phys) {
1509 if (
type->write_phys_memory ||
type->read_phys_memory ||
type->virt2phys)
1513 type->write_phys_memory =
type->write_memory;
1514 type->read_phys_memory =
type->read_memory;
1569 static bool target_initialized;
1570 if (target_initialized) {
1571 LOG_INFO(
"'target init' has already been called");
1574 target_initialized =
true;
1601 while ((*callbacks_p)->next)
1602 callbacks_p = &((*callbacks_p)->next);
1603 callbacks_p = &((*callbacks_p)->next);
1607 (*callbacks_p)->callback =
callback;
1608 (*callbacks_p)->priv =
priv;
1609 (*callbacks_p)->next =
NULL;
1624 LOG_ERROR(
"error allocating buffer for reset callback entry");
1637 size_t len, uint8_t *data,
void *
priv),
void *
priv)
1646 LOG_ERROR(
"error allocating buffer for trace callback entry");
1667 while ((*callbacks_p)->next)
1668 callbacks_p = &((*callbacks_p)->next);
1669 callbacks_p = &((*callbacks_p)->next);
1673 (*callbacks_p)->callback =
callback;
1674 (*callbacks_p)->type =
type;
1675 (*callbacks_p)->time_ms =
time_ms;
1676 (*callbacks_p)->removed =
false;
1681 (*callbacks_p)->priv =
priv;
1682 (*callbacks_p)->next =
NULL;
1730 size_t len, uint8_t *data,
void *
priv),
void *
priv)
1774 LOG_DEBUG(
"target event %i (%s) for core %s", event,
1793 LOG_DEBUG(
"target reset %i (%s)", reset_mode,
1832 static bool callback_processing;
1835 if (callback_processing)
1838 callback_processing =
true;
1854 if ((*callback)->removed) {
1861 bool call_it = (*callback)->callback &&
1863 now >= (*callback)->when);
1874 callback_processing =
false;
1911 assert(size <= area->
size);
1914 if (size < area->
size) {
1925 new_wa->
free =
true;
1927 area->
next = new_wa;
1942 while (c && c->
next) {
1979 LOG_DEBUG(
"MMU disabled, using physical "
1984 LOG_ERROR(
"No working memory available. "
1985 "Specify -work-area-phys to target.");
1995 LOG_ERROR(
"No working memory available. "
1996 "Specify -work-area-virt to target.");
2009 new_wa->
free =
true;
2066 LOG_WARNING(
"not enough working area available(requested %"PRIu32
")",
size);
2088 if (!area || area->
free)
2167 uint32_t max_size = 0;
2285 int retcode,
int fileio_errno,
bool ctrl_c)
2291 uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
2298 LOG_INFO(
"Starting profiling. Halting and resuming the"
2299 " target as often as we can...");
2301 uint32_t sample_count = 0;
2310 samples[sample_count++] = t;
2319 LOG_INFO(
"Target not halted or running");
2329 LOG_INFO(
"Profiling completed. %" PRIu32
" samples.", sample_count);
2334 *num_samples = sample_count;
2355 if ((address +
size - 1) < address) {
2375 size < data_bytes && count >=
size * 2 + (address &
size);
2377 if (address &
size) {
2420 if ((address +
size - 1) < address) {
2439 size < data_bytes && count >=
size * 2 + (address &
size);
2441 if (address &
size) {
2472 uint32_t checksum = 0;
2486 LOG_ERROR(
"error allocating buffer for section (%" PRIu32
" bytes)",
size);
2496 for (i = 0; i < (
size/
sizeof(uint32_t)); i++) {
2497 uint32_t target_data;
2513 uint8_t erased_value)
2528 uint8_t value_buf[8];
2552 uint8_t value_buf[4];
2576 uint8_t value_buf[2];
2623 uint8_t value_buf[8];
2644 uint8_t value_buf[4];
2665 uint8_t value_buf[2];
2704 uint8_t value_buf[8];
2725 uint8_t value_buf[4];
2746 uint8_t value_buf[2];
2791 "can't be the current target\n",
2797 if (
cmd->ctx->current_target_override)
2798 cmd->ctx->current_target_override =
target;
2815 unsigned int index = 0;
2817 command_print(
CMD,
"-- ------------------ ---------- ------ ------------------ ------------");
2825 state =
"tap-disabled";
2832 "%2d%c %-18s %-10s %-6s %-18s %s",
2858 static int prev_srst_asserted;
2859 static int prev_power_dropout;
2871 static int64_t last_power;
2872 bool wait_more = last_power + 2000 > current;
2875 last_power = current;
2882 int srst_deasserted;
2885 static int64_t last_srst;
2886 wait_more = last_srst + 2000 > current;
2887 if (srst_deasserted && !wait_more) {
2889 last_srst = current;
2898 if (srst_deasserted || power_restored) {
2911 Jim_Interp *interp = (Jim_Interp *)
priv;
2920 static int recursive;
2928 int did_something = 0;
2930 LOG_INFO(
"srst asserted detected, running srst_asserted proc.");
2931 Jim_Eval(interp,
"srst_asserted");
2935 Jim_Eval(interp,
"srst_deasserted");
2939 LOG_INFO(
"Power dropout detected, running power_dropout proc.");
2940 Jim_Eval(interp,
"power_dropout");
2944 Jim_Eval(interp,
"power_restore");
2948 if (did_something) {
3007 LOG_USER(
"Examination failed, GDB will be halted. Polling again in %dms",
3036 unsigned int count = 0;
3052 "(%i) %s (/%" PRIu32
"): 0x%s%s",
3065 cache = cache->
next;
3077 unsigned int count = 0;
3080 for (i = 0; i < cache->
num_regs; i++) {
3081 if (
count++ == num) {
3088 cache = cache->
next;
3093 "has only %i registers (0 - %i)", num,
count,
count - 1);
3192 int retval = parse_uint(
CMD_ARGV[0], &ms);
3210 int64_t then = 0, cur;
3227 if (cur - then > 500) {
3233 if ((cur-then) > ms) {
3234 LOG_ERROR(
"timed out while waiting for target %s",
3256 unsigned wait_local;
3257 retval = parse_uint(
CMD_ARGV[0], &wait_local);
3285 const struct nvp *n;
3289 reset_mode = n->
value;
3343 const unsigned line_bytecnt = 32;
3344 unsigned line_modulo = line_bytecnt /
size;
3346 char output[line_bytecnt * 4 + 1];
3347 unsigned output_len = 0;
3349 const char *value_fmt;
3352 value_fmt =
"%16.16"PRIx64
" ";
3355 value_fmt =
"%8.8"PRIx64
" ";
3358 value_fmt =
"%4.4"PRIx64
" ";
3361 value_fmt =
"%2.2"PRIx64
" ";
3369 for (
unsigned i = 0; i <
count; i++) {
3370 if (i % line_modulo == 0) {
3371 output_len += snprintf(
output + output_len,
3372 sizeof(
output) - output_len,
3374 (address + (i *
size)));
3378 const uint8_t *value_ptr =
buffer + i *
size;
3392 output_len += snprintf(
output + output_len,
3393 sizeof(
output) - output_len,
3396 if ((i % line_modulo == line_modulo - 1) || (i ==
count - 1)) {
3426 bool physical = strcmp(
CMD_ARGV[0],
"phys") == 0;
3447 LOG_ERROR(
"Failed to allocate md read buffer");
3475 const unsigned chunk_size = 16384;
3476 uint8_t *target_buf = malloc(chunk_size * data_size);
3482 for (
unsigned i = 0; i < chunk_size; i++) {
3483 switch (data_size) {
3503 for (
unsigned x = 0; x < c; x += chunk_size) {
3506 if (current > chunk_size)
3507 current = chunk_size;
3508 retval = fn(
target, address + x * data_size, data_size, current, target_buf);
3529 bool physical = strcmp(
CMD_ARGV[0],
"phys") == 0;
3575 if (CMD_ARGC < 1 || CMD_ARGC > 5)
3595 *max_address += *min_address;
3598 if (*min_address > *max_address)
3608 uint32_t image_size;
3614 &
image, &min_address, &max_address);
3632 "error allocating buffer for section (%d bytes)",
3645 uint32_t
length = buf_cnt;
3678 "in %fs (%0.3f KiB/s)", image_size,
3692 int retval, retvaltemp;
3703 uint32_t buf_size = (
size > 4096) ? 4096 :
size;
3704 buffer = malloc(buf_size);
3717 size_t size_written;
3718 uint32_t this_run_size = (
size > buf_size) ? buf_size :
size;
3727 size -= this_run_size;
3728 address += this_run_size;
3739 "dumped %zu bytes in %fs (%0.3f KiB/s)", filesize,
3760 uint32_t image_size;
3762 uint32_t checksum = 0;
3763 uint32_t mem_checksum = 0;
3803 "error allocating buffer for section (%" PRIu32
" bytes)",
3832 if (checksum != mem_checksum) {
3837 LOG_ERROR(
"checksum mismatch - attempting binary compare");
3839 data = malloc(buf_cnt);
3844 for (t = 0; t < buf_cnt; t++) {
3845 if (data[t] !=
buffer[t]) {
3847 "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
3852 if (diffs++ >= 127) {
3877 image_size += buf_cnt;
3886 "in %fs (%0.3f KiB/s)", image_size,
3925 command_print(
cmd,
"Context breakpoint: asid=0x%8.8" PRIx32
", len=0x%x, num=%u",
3957 }
else if (
addr == 0) {
3998 if (strcmp(
CMD_ARGV[2],
"hw") == 0) {
4004 }
else if (strcmp(
CMD_ARGV[2],
"hw_ctx") == 0) {
4037 command_print(
CMD,
"Error encountered during removal of all breakpoints.");
4063 ", len: 0x%8.8" PRIx32
4064 ", r/w/a: %c, value: 0x%8.8" PRIx64
4065 ", mask: 0x%8.8" PRIx64,
4079 uint64_t data_value = 0x0;
4081 bool mask_specified =
false;
4086 mask_specified =
true;
4091 if (!mask_specified)
4120 data_value, data_mask);
4139 command_print(
CMD,
"Error encountered during removal of all watchpoints.");
4180 size_t written = fwrite(data, 1, len, f);
4182 LOG_ERROR(
"failed to write %zu bytes: %s", len, strerror(errno));
4201 static void write_gmon(uint32_t *samples, uint32_t sample_num,
const char *filename,
bool with_range,
4202 uint32_t start_address, uint32_t end_address,
struct target *
target, uint32_t duration_ms)
4205 FILE *f = fopen(filename,
"w");
4221 min = start_address;
4226 for (i = 0; i < sample_num; i++) {
4227 if (min > samples[i])
4229 if (max < samples[i])
4235 if (max < UINT32_MAX)
4239 while ((max - min) < 2) {
4240 if (max < UINT32_MAX)
4247 uint32_t address_space = max - min;
4251 static const uint32_t max_buckets = 128 * 1024;
4252 uint32_t num_buckets = address_space /
sizeof(
UNIT);
4253 if (num_buckets > max_buckets)
4254 num_buckets = max_buckets;
4255 int *buckets = malloc(
sizeof(
int) * num_buckets);
4260 memset(buckets, 0,
sizeof(
int) * num_buckets);
4261 for (i = 0; i < sample_num; i++) {
4262 uint32_t address = samples[i];
4264 if ((address < min) || (max <= address))
4267 long long a = address - min;
4268 long long b = num_buckets;
4269 long long c = address_space;
4270 int index_t = (a * b) / c;
4278 float sample_rate = sample_num / (duration_ms / 1000.0);
4281 for (i = 0; i < (15-strlen(
"seconds")); i++)
4287 char *data = malloc(2 * num_buckets);
4289 for (i = 0; i < num_buckets; i++) {
4294 data[i * 2] = val&0xff;
4295 data[i * 2 + 1] = (val >> 8) & 0xff;
4315 const uint32_t MAX_PROFILE_SAMPLE_NUM = 1000000;
4317 uint32_t num_of_samples;
4323 uint32_t start_address = 0;
4324 uint32_t end_address = 0;
4325 bool with_range =
false;
4330 if (start_address > end_address || (end_address - start_address) < 2) {
4336 uint32_t *samples = malloc(
sizeof(uint32_t) * MAX_PROFILE_SAMPLE_NUM);
4338 LOG_ERROR(
"No memory to store samples.");
4349 &num_of_samples,
offset);
4354 uint32_t duration_ms =
timeval_ms() - timestart_ms;
4356 assert(num_of_samples <= MAX_PROFILE_SAMPLE_NUM);
4389 with_range, start_address, end_address,
target, duration_ms);
4405 if (CMD_ARGC < 3 || CMD_ARGC > 4)
4413 unsigned int width_bits;
4421 bool is_phys =
false;
4431 switch (width_bits) {
4442 const unsigned int width = width_bits / 8;
4449 if (
count > 65536) {
4450 command_print(
CMD,
"read_memory: too large read request, exceeds 64K elements");
4456 const size_t buffersize = 4096;
4457 uint8_t *
buffer = malloc(buffersize);
4464 char *separator =
"";
4466 const unsigned int max_chunk_len = buffersize /
width;
4467 const size_t chunk_len =
MIN(
count, max_chunk_len);
4478 addr, width_bits, chunk_len);
4488 for (
size_t i = 0; i < chunk_len ; i++) {
4520 Jim_Obj *
const *argv)
4529 if (argc < 4 || argc > 5) {
4530 Jim_WrongNumArgs(interp, 1, argv,
"address width data ['phys']");
4537 e = Jim_GetWide(interp, argv[1], &wide_addr);
4546 e = Jim_GetLong(interp, argv[2], &l);
4551 const unsigned int width_bits = l;
4552 size_t count = Jim_ListLength(interp, argv[3]);
4555 bool is_phys =
false;
4558 const char *phys = Jim_GetString(argv[4],
NULL);
4560 if (strcmp(phys,
"phys")) {
4561 Jim_SetResultFormatted(interp,
"invalid argument '%s', must be 'phys'", phys);
4568 switch (width_bits) {
4575 Jim_SetResultString(interp,
"invalid width, must be 8, 16, 32 or 64", -1);
4579 const unsigned int width = width_bits / 8;
4582 Jim_SetResultString(interp,
"write_memory: addr + len wraps to zero", -1);
4586 if (
count > 65536) {
4587 Jim_SetResultString(interp,
"write_memory: too large memory write request, exceeds 64K elements", -1);
4592 assert(cmd_ctx !=
NULL);
4595 const size_t buffersize = 4096;
4596 uint8_t *
buffer = malloc(buffersize);
4606 const unsigned int max_chunk_len = buffersize /
width;
4607 const size_t chunk_len =
MIN(
count, max_chunk_len);
4609 for (
size_t i = 0; i < chunk_len; i++, j++) {
4610 Jim_Obj *tmp = Jim_ListGetIndex(interp, argv[3], j);
4611 jim_wide element_wide;
4612 Jim_GetWide(interp, tmp, &element_wide);
4614 const uint64_t v = element_wide;
4643 addr, width_bits, chunk_len);
4644 Jim_SetResultString(interp,
"write_memory: failed to write memory", -1);
4666 if (teap->
event == e) {
4667 LOG_DEBUG(
"target: %s (%s) event: %d (%s) action: %s",
4682 retval = Jim_EvalObj(teap->
interp, teap->
body);
4689 if (retval == JIM_RETURN)
4690 retval = teap->
interp->returnCode;
4692 if (retval != JIM_OK) {
4693 Jim_MakeErrorMessage(teap->
interp);
4694 LOG_USER(
"Error executing event %s on target %s:\n%s",
4697 Jim_GetString(Jim_GetResult(teap->
interp),
NULL));
4699 Jim_Eval(teap->
interp,
"error \"\" \"\"");
4706 Jim_Obj *
const *argv)
4711 const char *option = Jim_GetString(argv[1],
NULL);
4713 if (!strcmp(option,
"-force")) {
4718 Jim_SetResultFormatted(interp,
"invalid option '%s'", option);
4724 Jim_WrongNumArgs(interp, 1, argv,
"[-force] list");
4728 const int length = Jim_ListLength(interp, argv[1]);
4730 Jim_Obj *result_dict = Jim_NewDictObj(interp,
NULL, 0);
4736 assert(cmd_ctx !=
NULL);
4739 for (
int i = 0; i <
length; i++) {
4740 Jim_Obj *elem = Jim_ListGetIndex(interp, argv[1], i);
4745 const char *reg_name = Jim_String(elem);
4751 Jim_SetResultFormatted(interp,
"unknown register '%s'", reg_name);
4759 Jim_SetResultFormatted(interp,
"failed to read register '%s'",
4781 Jim_DictAddElement(interp, result_dict, elem,
4782 Jim_NewStringObj(interp, tmp, -1));
4787 Jim_SetResult(interp, result_dict);
4793 Jim_Obj *
const *argv)
4796 Jim_WrongNumArgs(interp, 1, argv,
"dict");
4801 #if JIM_VERSION >= 80
4802 Jim_Obj **dict = Jim_DictPairs(interp, argv[1], &tmp);
4808 int ret = Jim_DictPairs(interp, argv[1], &dict, &tmp);
4814 const unsigned int length = tmp;
4819 for (
unsigned int i = 0; i <
length; i += 2) {
4820 const char *reg_name = Jim_String(dict[i]);
4821 const char *reg_value = Jim_String(dict[i + 1]);
4826 Jim_SetResultFormatted(interp,
"unknown register '%s'", reg_name);
4842 Jim_SetResultFormatted(interp,
"failed to set '%s' to register '%s'",
4843 reg_value, reg_name);
4893 { .name =
"-rtos", .value =
TCFG_RTOS },
4897 { .name =
NULL, .value = -1 }
4908 while (goi->
argc > 0) {
4909 Jim_SetEmptyResult(goi->
interp);
4935 Jim_SetResultFormatted(goi->
interp,
4936 "not settable: %s", n->
name);
4940 if (goi->
argc != 0) {
4941 Jim_WrongNumArgs(goi->
interp,
4947 Jim_SetResultString(goi->
interp,
4952 if (goi->
argc == 0) {
4953 Jim_WrongNumArgs(goi->
interp, goi->
argc, goi->
argv,
"-event ?event-name? ...");
4964 if (goi->
argc != 1) {
4965 Jim_WrongNumArgs(goi->
interp, goi->
argc, goi->
argv,
"-event ?event-name? ?EVENT-BODY?");
4969 if (goi->
argc != 0) {
4970 Jim_WrongNumArgs(goi->
interp, goi->
argc, goi->
argv,
"-event ?event-name?");
4989 LOG_INFO(
"DEPRECATED target event %s; use TPIU events {pre,post}-{enable,disable}", n->
name);
4992 bool replace =
true;
4995 teap = calloc(1,
sizeof(*teap));
5003 teap->
body = Jim_DuplicateObj(goi->
interp, o);
5014 Jim_IncrRefCount(teap->
body);
5021 Jim_SetEmptyResult(goi->
interp);
5025 Jim_SetEmptyResult(goi->
interp);
5114 Jim_SetResultString(goi->
interp, n->
name, -1);
5138 Jim_SetResultString(goi->
interp,
5139 "target requires -dap parameter instead of -chain-position!", -1);
5177 if (result != JIM_OK)
5193 Jim_SetResultString(goi->
interp,
"-gdb-port must be configured before 'init'", -1);
5215 Jim_SetResultString(goi->
interp,
"-gdb-max-connections must be configured before 'init'", -1);
5246 "missing: -option ...");
5257 bool allow_defer =
false;
5263 if (strcmp(
CMD_ARGV[0],
"allow-defer"))
5276 LOG_INFO(
"Use arp_examine command to examine it manually!");
5419 "target: %s wait %s fails (%d) %s",
5438 "----------------------------------------");
5487 if (goi.
argc != 1) {
5488 const char *cmd_name = Jim_GetString(
argv[0],
NULL);
5489 Jim_SetResultFormatted(goi.
interp,
"%s <eventname>", cmd_name);
5507 .
name =
"configure",
5510 .help =
"configure a new target for use",
5511 .usage =
"[target_attribute ...]",
5517 .help =
"returns the specified target attribute",
5518 .usage =
"target_attribute",
5522 .handler = handle_mw_command,
5524 .help =
"Write 64-bit word(s) to target memory",
5525 .usage =
"address data [count]",
5529 .handler = handle_mw_command,
5531 .help =
"Write 32-bit word(s) to target memory",
5532 .usage =
"address data [count]",
5536 .handler = handle_mw_command,
5538 .help =
"Write 16-bit half-word(s) to target memory",
5539 .usage =
"address data [count]",
5543 .handler = handle_mw_command,
5545 .help =
"Write byte(s) to target memory",
5546 .usage =
"address data [count]",
5550 .handler = handle_md_command,
5552 .help =
"Display target memory as 64-bit words",
5553 .usage =
"address [count]",
5557 .handler = handle_md_command,
5559 .help =
"Display target memory as 32-bit words",
5560 .usage =
"address [count]",
5564 .handler = handle_md_command,
5566 .help =
"Display target memory as 16-bit half-words",
5567 .usage =
"address [count]",
5571 .handler = handle_md_command,
5573 .help =
"Display target memory as 8-bit bytes",
5574 .usage =
"address [count]",
5580 .help =
"Get register values from the target",
5587 .help =
"Set target register values",
5591 .name =
"read_memory",
5593 .handler = handle_target_read_memory,
5594 .help =
"Read Tcl list of 8/16/32/64 bit numbers from target memory",
5595 .usage =
"address width count ['phys']",
5598 .name =
"write_memory",
5601 .help =
"Write Tcl list of 8/16/32/64 bit numbers to target memory",
5602 .usage =
"address width data ['phys']",
5605 .name =
"eventlist",
5606 .handler = handle_target_event_list,
5608 .help =
"displays a table of events defined for this target",
5614 .handler = handle_target_current_state,
5615 .help =
"displays the current state of this target",
5619 .name =
"debug_reason",
5621 .handler = handle_target_debug_reason,
5622 .help =
"displays the debug reason of this target",
5626 .name =
"arp_examine",
5628 .handler = handle_target_examine,
5629 .help =
"used internally for reset processing",
5630 .usage =
"['allow-defer']",
5633 .name =
"was_examined",
5635 .handler = handle_target_was_examined,
5636 .help =
"used internally for reset processing",
5640 .name =
"examine_deferred",
5642 .handler = handle_target_examine_deferred,
5643 .help =
"used internally for reset processing",
5647 .name =
"arp_halt_gdb",
5649 .handler = handle_target_halt_gdb,
5650 .help =
"used internally for reset processing to halt GDB",
5656 .handler = handle_target_poll,
5657 .help =
"used internally for reset processing",
5661 .name =
"arp_reset",
5663 .handler = handle_target_reset,
5664 .help =
"used internally for reset processing",
5665 .usage =
"'assert'|'deassert' halt",
5670 .handler = handle_target_halt,
5671 .help =
"used internally for reset processing",
5675 .name =
"arp_waitstate",
5677 .handler = handle_target_wait_state,
5678 .help =
"used internally for reset processing",
5679 .usage =
"statename timeoutmsecs",
5682 .name =
"invoke-event",
5685 .help =
"invoke handler for specified event",
5686 .usage =
"event_name",
5704 if (goi->
argc < 3) {
5705 Jim_WrongNumArgs(goi->
interp, 1, goi->
argv,
"?name? ?type? ..options...");
5712 cmd = Jim_GetCommand(goi->
interp, new_cmd, JIM_NONE);
5714 cp = Jim_GetString(new_cmd,
NULL);
5715 Jim_SetResultFormatted(goi->
interp,
"Command/target: %s Exists", cp);
5727 LOG_ERROR(
"The selected transport doesn't support this target");
5730 LOG_INFO(
"The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD");
5740 Jim_SetResultFormatted(goi->
interp,
"Unknown target type %s, try one of ", cp);
5743 Jim_AppendStrings(goi->
interp,
5744 Jim_GetResult(goi->
interp),
5748 Jim_AppendStrings(goi->
interp,
5749 Jim_GetResult(goi->
interp),
5824 Jim_SetResultString(goi->
interp,
"-dap ?name? required when creating target", -1);
5829 Jim_SetResultString(goi->
interp,
"-chain-position ?name? required when creating target", -1);
5852 cp = Jim_GetString(new_cmd,
NULL);
5882 LOG_ERROR(
"unable to register '%s' commands", cp);
5899 .help =
"target command group",
5901 .chain = target_subcommands,
5964 create_target_list_node(
const char *targetname)
6002 static int smp_group = 1;
6021 for (
unsigned int i = 0; i <
CMD_ARGC; i++) {
6035 struct target *rtos_target;
6037 if (retval ==
ERROR_OK && rtos_target)
6049 "<name> <target_type> [<target_options> ...]");
6059 .handler = handle_target_init_command,
6060 .help =
"initialize targets",
6067 .usage =
"name type '-chain-position' name [options ...]",
6068 .help =
"Creates and selects a new target",
6073 .handler = handle_target_current,
6074 .help =
"Returns the currently selected target",
6080 .handler = handle_target_types,
6081 .help =
"Returns the available target types as "
6082 "a list of strings",
6088 .handler = handle_target_names,
6089 .help =
"Returns the names of all targets as a list of strings",
6095 .handler = handle_target_smp,
6096 .usage =
"targetname1 targetname2 ...",
6097 .help =
"gather several target in a smp list"
6127 uint32_t image_size;
6134 &
image, &min_address, &max_address);
6171 uint32_t
length = buf_cnt;
6190 command_print(
CMD,
"error allocating buffer for section (%" PRIu32
" bytes)",
6209 "in %fs (%0.3f KiB/s)", image_size,
6213 "WARNING: image has not been loaded to target!"
6214 "You can issue a 'fast_load' to finish loading.");
6240 (
unsigned int)(
fastload[i].address),
6249 command_print(
CMD,
"Loaded image %f kBytes/s", (
float)(
size/1024.0)/((
float)(after-ms)/1000.0));
6257 .handler = handle_targets_command,
6259 .help =
"change current default target (one parameter) "
6260 "or prints table of all targets (no parameters)",
6261 .usage =
"[target]",
6266 .help =
"configure target",
6317 for (
int i = 0; i <
size; i++)
6339 size_t num_bytes = test_size + 4;
6348 uint8_t *test_pattern = malloc(num_bytes);
6350 for (
size_t i = 0; i < num_bytes; i++)
6351 test_pattern[i] = rand();
6359 for (
int host_offset = 0; host_offset <= 1; host_offset++) {
6363 size_t host_bufsiz = (
count + 2) *
size + host_offset;
6364 uint8_t *read_ref = malloc(host_bufsiz);
6365 uint8_t *read_buf = malloc(host_bufsiz);
6367 for (
size_t i = 0; i < host_bufsiz; i++) {
6368 read_ref[i] = rand();
6369 read_buf[i] = read_ref[i];
6372 "Test read %" PRIu32
" x %d @ %d to %saligned buffer: ",
count,
6379 read_buf +
size + host_offset);
6395 int result = memcmp(read_ref, read_buf, host_bufsiz);
6418 num_bytes = test_size + 4 + 4 + 4;
6426 test_pattern = malloc(num_bytes);
6428 for (
size_t i = 0; i < num_bytes; i++)
6429 test_pattern[i] = rand();
6431 for (
int host_offset = 0; host_offset <= 1; host_offset++) {
6435 size_t host_bufsiz =
count *
size + host_offset;
6436 uint8_t *read_ref = malloc(num_bytes);
6437 uint8_t *read_buf = malloc(num_bytes);
6438 uint8_t *write_buf = malloc(host_bufsiz);
6440 for (
size_t i = 0; i < host_bufsiz; i++)
6441 write_buf[i] = rand();
6443 "Test write %" PRIu32
" x %d @ %d from %saligned buffer: ",
count,
6453 memcpy(read_ref, test_pattern, num_bytes);
6460 write_buf + host_offset);
6480 int result = memcmp(read_ref, read_buf, num_bytes);
6505 .
name =
"fast_load_image",
6506 .handler = handle_fast_load_image_command,
6508 .help =
"Load image into server memory for later use by "
6509 "fast_load; primarily for profiling",
6510 .usage =
"filename [address ['bin'|'ihex'|'elf'|'s19' "
6511 "[min_address [max_length]]]]",
6514 .name =
"fast_load",
6515 .handler = handle_fast_load_command,
6517 .help =
"loads active fast load image to current target "
6518 "- mainly for profiling purposes",
6523 .handler = handle_profile_command,
6525 .usage =
"seconds filename [start end]",
6526 .help =
"profiling samples the CPU PC",
6530 .name =
"virt2phys",
6531 .handler = handle_virt2phys_command,
6533 .help =
"translate a virtual address into a physical address",
6534 .usage =
"virtual_address",
6538 .handler = handle_reg_command,
6540 .help =
"display (reread from target with \"force\") or set a register; "
6541 "with no arguments, displays all registers and their values",
6542 .usage =
"[(register_number|register_name) [(value|'force')]]",
6546 .handler = handle_poll_command,
6548 .help =
"poll target state; or reconfigure background polling",
6549 .usage =
"['on'|'off']",
6552 .name =
"wait_halt",
6553 .handler = handle_wait_halt_command,
6555 .help =
"wait up to the specified number of milliseconds "
6556 "(default 5000) for a previously requested halt",
6557 .usage =
"[milliseconds]",
6561 .handler = handle_halt_command,
6563 .help =
"request target to halt, then wait up to the specified "
6564 "number of milliseconds (default 5000) for it to complete",
6565 .usage =
"[milliseconds]",
6569 .handler = handle_resume_command,
6571 .help =
"resume target execution from current PC or address",
6572 .usage =
"[address]",
6576 .handler = handle_reset_command,
6578 .usage =
"[run|halt|init]",
6579 .help =
"Reset all targets into the specified mode. "
6580 "Default reset mode is run, if not given.",
6583 .name =
"soft_reset_halt",
6584 .handler = handle_soft_reset_halt_command,
6587 .help =
"halt the target and do a soft reset",
6591 .handler = handle_step_command,
6593 .help =
"step one instruction from current PC or address",
6594 .usage =
"[address]",
6598 .handler = handle_md_command,
6600 .help =
"display memory double-words",
6601 .usage =
"['phys'] address [count]",
6605 .handler = handle_md_command,
6607 .help =
"display memory words",
6608 .usage =
"['phys'] address [count]",
6612 .handler = handle_md_command,
6614 .help =
"display memory half-words",
6615 .usage =
"['phys'] address [count]",
6619 .handler = handle_md_command,
6621 .help =
"display memory bytes",
6622 .usage =
"['phys'] address [count]",
6626 .handler = handle_mw_command,
6628 .help =
"write memory double-word",
6629 .usage =
"['phys'] address value [count]",
6633 .handler = handle_mw_command,
6635 .help =
"write memory word",
6636 .usage =
"['phys'] address value [count]",
6640 .handler = handle_mw_command,
6642 .help =
"write memory half-word",
6643 .usage =
"['phys'] address value [count]",
6647 .handler = handle_mw_command,
6649 .help =
"write memory byte",
6650 .usage =
"['phys'] address value [count]",
6654 .handler = handle_bp_command,
6656 .help =
"list or set hardware or software breakpoint",
6657 .usage =
"[<address> [<asid>] <length> ['hw'|'hw_ctx']]",
6661 .handler = handle_rbp_command,
6663 .help =
"remove breakpoint",
6664 .usage =
"'all' | address",
6668 .handler = handle_wp_command,
6670 .help =
"list (no params) or create watchpoints",
6671 .usage =
"[address length [('r'|'w'|'a') [value [mask]]]]",
6675 .handler = handle_rwp_command,
6677 .help =
"remove watchpoint",
6678 .usage =
"'all' | address",
6681 .name =
"load_image",
6682 .handler = handle_load_image_command,
6684 .usage =
"filename [address ['bin'|'ihex'|'elf'|'s19' "
6685 "[min_address [max_length]]]]",
6688 .name =
"dump_image",
6689 .handler = handle_dump_image_command,
6691 .usage =
"filename address size",
6694 .name =
"verify_image_checksum",
6695 .handler = handle_verify_image_checksum_command,
6697 .usage =
"filename [offset [type]]",
6700 .name =
"verify_image",
6701 .handler = handle_verify_image_command,
6703 .usage =
"filename [offset [type]]",
6706 .name =
"test_image",
6707 .handler = handle_test_image_command,
6709 .usage =
"filename [offset [type]]",
6715 .help =
"Get register values from the target",
6722 .help =
"Set target register values",
6726 .name =
"read_memory",
6728 .handler = handle_target_read_memory,
6729 .help =
"Read Tcl list of 8/16/32/64 bit numbers from target memory",
6730 .usage =
"address width count ['phys']",
6733 .name =
"write_memory",
6736 .help =
"Write Tcl list of 8/16/32/64 bit numbers to target memory",
6737 .usage =
"address width data ['phys']",
6740 .name =
"reset_nag",
6741 .handler = handle_target_reset_nag,
6743 .help =
"Nag after each reset about options that could have been "
6744 "enabled to improve performance.",
6745 .usage =
"['enable'|'disable']",
6749 .handler = handle_ps_command,
6751 .help =
"list all tasks",
6755 .name =
"test_mem_access",
6756 .handler = handle_test_mem_access_command,
6758 .help =
"Test the target's memory access functions",
6785 return "BREAKPOINT";
6787 return "WATCHPOINT";
6789 return "WPTANDBKPT";
6791 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 buf_len)
int str_to_buf(const char *str, unsigned str_len, void *_buf, unsigned buf_len, unsigned radix)
static uint32_t buf_get_u32(const uint8_t *_buffer, unsigned first, unsigned 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, uint32_t length, enum watchpoint_rw rw, uint64_t value, uint64_t mask)
int breakpoint_remove(struct target *target, target_addr_t address)
int hybrid_breakpoint_add(struct target *target, target_addr_t address, uint32_t asid, uint32_t length, enum breakpoint_type type)
int watchpoint_remove(struct target *target, target_addr_t address)
int context_breakpoint_add(struct target *target, uint32_t asid, uint32_t length, enum breakpoint_type type)
int watchpoint_remove_all(struct target *target)
int breakpoint_remove_all(struct target *target)
int breakpoint_add(struct target *target, target_addr_t address, uint32_t 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 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.
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)
char * alloc_printf(const char *format,...)
#define LOG_TARGET_INFO(target, fmt_str,...)
#define LOG_USER(expr ...)
#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.
size_t size
Size of the control block search area.
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.
struct target_event_action * next
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)
unsigned(* address_bits)(struct target *target)
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(* resume)(struct target *target, int current, target_addr_t address, int handle_breakpoints, int debug_execution)
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)
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(* 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(* step)(struct target *target, int current, target_addr_t address, int handle_breakpoints)
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 target_event_action * event_action
struct breakpoint * breakpoints
struct working_area * working_areas
struct gdb_fileio_info * fileio_info
struct debug_msg_receiver * dbgmsg
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 int target_jim_write_memory(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
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 int target_jim_get_reg(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
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)
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.
unsigned target_address_bits(struct target *target)
Return the number of address bits this target supports.
static int jtag_enable_callback(enum jtag_event event, void *priv)
void target_handle_md_output(struct command_invocation *cmd, struct target *target, target_addr_t address, unsigned size, unsigned count, const uint8_t *buffer)
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)
int target_step(struct target *target, int current, target_addr_t address, int handle_breakpoints)
Step the target.
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)
static int target_jim_set_reg(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
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_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.
int target_write_phys_u16(struct target *target, target_addr_t address, uint16_t value)
static void free_fastload(void)
static int handle_bp_command_set(struct command_invocation *cmd, target_addr_t addr, uint32_t asid, uint32_t length, int hw)
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_fill_mem(struct target *target, target_addr_t address, target_write_fn fn, unsigned data_size, uint64_t b, unsigned c)
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 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)
static LIST_HEAD(target_reset_callback_list)
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 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)
int target_resume(struct target *target, int current, target_addr_t address, int handle_breakpoints, int debug_execution)
Make the target (re)start executing using its saved execution context (possibly with some modificatio...
#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)