OpenOCD
target.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 
3 /***************************************************************************
4  * Copyright (C) 2005 by Dominic Rath *
5  * Dominic.Rath@gmx.de *
6  * *
7  * Copyright (C) 2007-2010 Øyvind Harboe *
8  * oyvind.harboe@zylin.com *
9  * *
10  * Copyright (C) 2008, Duane Ellis *
11  * openocd@duaneeellis.com *
12  * *
13  * Copyright (C) 2008 by Spencer Oliver *
14  * spen@spen-soft.co.uk *
15  * *
16  * Copyright (C) 2008 by Rick Altherr *
17  * kc8apf@kc8apf.net> *
18  * *
19  * Copyright (C) 2011 by Broadcom Corporation *
20  * Evan Hunter - ehunter@broadcom.com *
21  * *
22  * Copyright (C) ST-Ericsson SA 2011 *
23  * michel.jaouen@stericsson.com : smp minimum support *
24  * *
25  * Copyright (C) 2011 Andreas Fritiofson *
26  * andreas.fritiofson@gmail.com *
27  ***************************************************************************/
28 
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32 
33 #include <helper/align.h>
34 #include <helper/list.h>
35 #include <helper/nvp.h>
36 #include <helper/time_support.h>
37 #include <jtag/jtag.h>
38 #include <flash/nor/core.h>
39 
40 #include "target.h"
41 #include "target_type.h"
42 #include "target_request.h"
43 #include "breakpoints.h"
44 #include "register.h"
45 #include "trace.h"
46 #include "image.h"
47 #include "rtos/rtos.h"
48 #include "transport/transport.h"
49 #include "arm_cti.h"
50 #include "smp.h"
51 #include "semihosting_common.h"
52 
53 /* default halt wait timeout (ms) */
54 #define DEFAULT_HALT_TIMEOUT 5000
55 
57  enum target_event event;
58  Jim_Interp *interp;
59  Jim_Obj *body;
60  struct list_head list;
61 };
62 
64  uint32_t count, uint8_t *buffer);
66  uint32_t count, const uint8_t *buffer);
67 static int target_register_user_commands(struct command_context *cmd_ctx);
69  struct gdb_fileio_info *fileio_info);
70 static int target_gdb_fileio_end_default(struct target *target, int retcode,
71  int fileio_errno, bool ctrl_c);
72 
73 static struct target_type *target_types[] = {
81  &fa526_target,
89  &arm11_target,
92  &avr_target,
97  &hla_target,
98  &esp32_target,
101  &or1k_target,
104  &stm8_target,
105  &riscv_target,
106  &mem_ap_target,
108  &arcv2_target,
110  &armv8r_target,
112  NULL,
113 };
114 
119 static OOCD_LIST_HEAD(target_reset_callback_list);
120 static OOCD_LIST_HEAD(target_trace_callback_list);
122 static OOCD_LIST_HEAD(empty_smp_targets);
123 
127 };
128 
129 static const struct nvp nvp_assert[] = {
130  { .name = "assert", NVP_ASSERT },
131  { .name = "deassert", NVP_DEASSERT },
132  { .name = "T", NVP_ASSERT },
133  { .name = "F", NVP_DEASSERT },
134  { .name = "t", NVP_ASSERT },
135  { .name = "f", NVP_DEASSERT },
136  { .name = NULL, .value = -1 }
137 };
138 
139 static const struct nvp nvp_error_target[] = {
140  { .value = ERROR_TARGET_INVALID, .name = "err-invalid" },
141  { .value = ERROR_TARGET_INIT_FAILED, .name = "err-init-failed" },
142  { .value = ERROR_TARGET_TIMEOUT, .name = "err-timeout" },
143  { .value = ERROR_TARGET_NOT_HALTED, .name = "err-not-halted" },
144  { .value = ERROR_TARGET_FAILURE, .name = "err-failure" },
145  { .value = ERROR_TARGET_UNALIGNED_ACCESS, .name = "err-unaligned-access" },
146  { .value = ERROR_TARGET_DATA_ABORT, .name = "err-data-abort" },
147  { .value = ERROR_TARGET_RESOURCE_NOT_AVAILABLE, .name = "err-resource-not-available" },
148  { .value = ERROR_TARGET_TRANSLATION_FAULT, .name = "err-translation-fault" },
149  { .value = ERROR_TARGET_NOT_RUNNING, .name = "err-not-running" },
150  { .value = ERROR_TARGET_NOT_EXAMINED, .name = "err-not-examined" },
151  { .value = -1, .name = NULL }
152 };
153 
154 static const char *target_strerror_safe(int err)
155 {
156  const struct nvp *n;
157 
159  if (!n->name)
160  return "unknown";
161  else
162  return n->name;
163 }
164 
165 static const struct nvp nvp_target_event[] = {
166 
167  { .value = TARGET_EVENT_GDB_HALT, .name = "gdb-halt" },
168  { .value = TARGET_EVENT_HALTED, .name = "halted" },
169  { .value = TARGET_EVENT_RESUMED, .name = "resumed" },
170  { .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
171  { .value = TARGET_EVENT_RESUME_END, .name = "resume-end" },
172  { .value = TARGET_EVENT_STEP_START, .name = "step-start" },
173  { .value = TARGET_EVENT_STEP_END, .name = "step-end" },
174 
175  { .name = "gdb-start", .value = TARGET_EVENT_GDB_START },
176  { .name = "gdb-end", .value = TARGET_EVENT_GDB_END },
177 
178  { .value = TARGET_EVENT_RESET_START, .name = "reset-start" },
179  { .value = TARGET_EVENT_RESET_ASSERT_PRE, .name = "reset-assert-pre" },
180  { .value = TARGET_EVENT_RESET_ASSERT, .name = "reset-assert" },
181  { .value = TARGET_EVENT_RESET_ASSERT_POST, .name = "reset-assert-post" },
182  { .value = TARGET_EVENT_RESET_DEASSERT_PRE, .name = "reset-deassert-pre" },
183  { .value = TARGET_EVENT_RESET_DEASSERT_POST, .name = "reset-deassert-post" },
184  { .value = TARGET_EVENT_RESET_INIT, .name = "reset-init" },
185  { .value = TARGET_EVENT_RESET_END, .name = "reset-end" },
186 
187  { .value = TARGET_EVENT_EXAMINE_START, .name = "examine-start" },
188  { .value = TARGET_EVENT_EXAMINE_FAIL, .name = "examine-fail" },
189  { .value = TARGET_EVENT_EXAMINE_END, .name = "examine-end" },
190 
191  { .value = TARGET_EVENT_DEBUG_HALTED, .name = "debug-halted" },
192  { .value = TARGET_EVENT_DEBUG_RESUMED, .name = "debug-resumed" },
193 
194  { .value = TARGET_EVENT_GDB_ATTACH, .name = "gdb-attach" },
195  { .value = TARGET_EVENT_GDB_DETACH, .name = "gdb-detach" },
196 
197  { .value = TARGET_EVENT_GDB_FLASH_WRITE_START, .name = "gdb-flash-write-start" },
198  { .value = TARGET_EVENT_GDB_FLASH_WRITE_END, .name = "gdb-flash-write-end" },
199 
200  { .value = TARGET_EVENT_GDB_FLASH_ERASE_START, .name = "gdb-flash-erase-start" },
201  { .value = TARGET_EVENT_GDB_FLASH_ERASE_END, .name = "gdb-flash-erase-end" },
202 
203  { .value = TARGET_EVENT_TRACE_CONFIG, .name = "trace-config" },
204 
205  { .value = TARGET_EVENT_SEMIHOSTING_USER_CMD_0X100, .name = "semihosting-user-cmd-0x100" },
206  { .value = TARGET_EVENT_SEMIHOSTING_USER_CMD_0X101, .name = "semihosting-user-cmd-0x101" },
207  { .value = TARGET_EVENT_SEMIHOSTING_USER_CMD_0X102, .name = "semihosting-user-cmd-0x102" },
208  { .value = TARGET_EVENT_SEMIHOSTING_USER_CMD_0X103, .name = "semihosting-user-cmd-0x103" },
209  { .value = TARGET_EVENT_SEMIHOSTING_USER_CMD_0X104, .name = "semihosting-user-cmd-0x104" },
210  { .value = TARGET_EVENT_SEMIHOSTING_USER_CMD_0X105, .name = "semihosting-user-cmd-0x105" },
211  { .value = TARGET_EVENT_SEMIHOSTING_USER_CMD_0X106, .name = "semihosting-user-cmd-0x106" },
212  { .value = TARGET_EVENT_SEMIHOSTING_USER_CMD_0X107, .name = "semihosting-user-cmd-0x107" },
213 
214  { .name = NULL, .value = -1 }
215 };
216 
217 static const struct nvp nvp_target_state[] = {
218  { .name = "unknown", .value = TARGET_UNKNOWN },
219  { .name = "running", .value = TARGET_RUNNING },
220  { .name = "halted", .value = TARGET_HALTED },
221  { .name = "reset", .value = TARGET_RESET },
222  { .name = "debug-running", .value = TARGET_DEBUG_RUNNING },
223  { .name = NULL, .value = -1 },
224 };
225 
226 static const struct nvp nvp_target_debug_reason[] = {
227  { .name = "debug-request", .value = DBG_REASON_DBGRQ },
228  { .name = "breakpoint", .value = DBG_REASON_BREAKPOINT },
229  { .name = "watchpoint", .value = DBG_REASON_WATCHPOINT },
230  { .name = "watchpoint-and-breakpoint", .value = DBG_REASON_WPTANDBKPT },
231  { .name = "single-step", .value = DBG_REASON_SINGLESTEP },
232  { .name = "target-not-halted", .value = DBG_REASON_NOTHALTED },
233  { .name = "program-exit", .value = DBG_REASON_EXIT },
234  { .name = "exception-catch", .value = DBG_REASON_EXC_CATCH },
235  { .name = "undefined", .value = DBG_REASON_UNDEFINED },
236  { .name = NULL, .value = -1 },
237 };
238 
239 static const struct nvp nvp_target_endian[] = {
240  { .name = "big", .value = TARGET_BIG_ENDIAN },
241  { .name = "little", .value = TARGET_LITTLE_ENDIAN },
242  { .name = "be", .value = TARGET_BIG_ENDIAN },
243  { .name = "le", .value = TARGET_LITTLE_ENDIAN },
244  { .name = NULL, .value = -1 },
245 };
246 
247 static const struct nvp nvp_reset_modes[] = {
248  { .name = "unknown", .value = RESET_UNKNOWN },
249  { .name = "run", .value = RESET_RUN },
250  { .name = "halt", .value = RESET_HALT },
251  { .name = "init", .value = RESET_INIT },
252  { .name = NULL, .value = -1 },
253 };
254 
255 const char *debug_reason_name(const struct target *t)
256 {
257  const char *cp;
258 
260  t->debug_reason)->name;
261  if (!cp) {
262  LOG_ERROR("Invalid debug reason: %d", (int)(t->debug_reason));
263  cp = "(*BUG*unknown*BUG*)";
264  }
265  return cp;
266 }
267 
268 const char *target_state_name(const struct target *t)
269 {
270  const char *cp;
272  if (!cp) {
273  LOG_ERROR("Invalid target state: %d", (int)(t->state));
274  cp = "(*BUG*unknown*BUG*)";
275  }
276 
277  if (!target_was_examined(t) && t->defer_examine)
278  cp = "examine deferred";
279 
280  return cp;
281 }
282 
283 const char *target_event_name(enum target_event event)
284 {
285  const char *cp;
286  cp = nvp_value2name(nvp_target_event, event)->name;
287  if (!cp) {
288  LOG_ERROR("Invalid target event: %d", (int)(event));
289  cp = "(*BUG*unknown*BUG*)";
290  }
291  return cp;
292 }
293 
294 const char *target_reset_mode_name(enum target_reset_mode reset_mode)
295 {
296  const char *cp;
297  cp = nvp_value2name(nvp_reset_modes, reset_mode)->name;
298  if (!cp) {
299  LOG_ERROR("Invalid target reset mode: %d", (int)(reset_mode));
300  cp = "(*BUG*unknown*BUG*)";
301  }
302  return cp;
303 }
304 
306 {
307  struct target **t = &all_targets;
308 
309  while (*t)
310  t = &((*t)->next);
311  *t = target;
312 }
313 
314 /* read a uint64_t from a buffer in target memory endianness */
315 uint64_t target_buffer_get_u64(struct target *target, const uint8_t *buffer)
316 {
318  return le_to_h_u64(buffer);
319  else
320  return be_to_h_u64(buffer);
321 }
322 
323 /* read a uint32_t from a buffer in target memory endianness */
324 uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer)
325 {
327  return le_to_h_u32(buffer);
328  else
329  return be_to_h_u32(buffer);
330 }
331 
332 /* read a uint24_t from a buffer in target memory endianness */
333 uint32_t target_buffer_get_u24(struct target *target, const uint8_t *buffer)
334 {
336  return le_to_h_u24(buffer);
337  else
338  return be_to_h_u24(buffer);
339 }
340 
341 /* read a uint16_t from a buffer in target memory endianness */
342 uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer)
343 {
345  return le_to_h_u16(buffer);
346  else
347  return be_to_h_u16(buffer);
348 }
349 
350 /* write a uint64_t to a buffer in target memory endianness */
351 void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value)
352 {
354  h_u64_to_le(buffer, value);
355  else
356  h_u64_to_be(buffer, value);
357 }
358 
359 /* write a uint32_t to a buffer in target memory endianness */
360 void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value)
361 {
363  h_u32_to_le(buffer, value);
364  else
365  h_u32_to_be(buffer, value);
366 }
367 
368 /* write a uint24_t to a buffer in target memory endianness */
369 void target_buffer_set_u24(struct target *target, uint8_t *buffer, uint32_t value)
370 {
372  h_u24_to_le(buffer, value);
373  else
374  h_u24_to_be(buffer, value);
375 }
376 
377 /* write a uint16_t to a buffer in target memory endianness */
378 void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value)
379 {
381  h_u16_to_le(buffer, value);
382  else
383  h_u16_to_be(buffer, value);
384 }
385 
386 /* write a uint8_t to a buffer in target memory endianness */
387 static void target_buffer_set_u8(struct target *target, uint8_t *buffer, uint8_t value)
388 {
389  *buffer = value;
390 }
391 
392 /* write a uint64_t array to a buffer in target memory endianness */
393 void target_buffer_get_u64_array(struct target *target, const uint8_t *buffer, uint32_t count, uint64_t *dstbuf)
394 {
395  uint32_t i;
396  for (i = 0; i < count; i++)
397  dstbuf[i] = target_buffer_get_u64(target, &buffer[i * 8]);
398 }
399 
400 /* write a uint32_t array to a buffer in target memory endianness */
401 void target_buffer_get_u32_array(struct target *target, const uint8_t *buffer, uint32_t count, uint32_t *dstbuf)
402 {
403  uint32_t i;
404  for (i = 0; i < count; i++)
405  dstbuf[i] = target_buffer_get_u32(target, &buffer[i * 4]);
406 }
407 
408 /* write a uint16_t array to a buffer in target memory endianness */
409 void target_buffer_get_u16_array(struct target *target, const uint8_t *buffer, uint32_t count, uint16_t *dstbuf)
410 {
411  uint32_t i;
412  for (i = 0; i < count; i++)
413  dstbuf[i] = target_buffer_get_u16(target, &buffer[i * 2]);
414 }
415 
416 /* write a uint64_t array to a buffer in target memory endianness */
417 void target_buffer_set_u64_array(struct target *target, uint8_t *buffer, uint32_t count, const uint64_t *srcbuf)
418 {
419  uint32_t i;
420  for (i = 0; i < count; i++)
421  target_buffer_set_u64(target, &buffer[i * 8], srcbuf[i]);
422 }
423 
424 /* write a uint32_t array to a buffer in target memory endianness */
425 void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, const uint32_t *srcbuf)
426 {
427  uint32_t i;
428  for (i = 0; i < count; i++)
429  target_buffer_set_u32(target, &buffer[i * 4], srcbuf[i]);
430 }
431 
432 /* write a uint16_t array to a buffer in target memory endianness */
433 void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, const uint16_t *srcbuf)
434 {
435  uint32_t i;
436  for (i = 0; i < count; i++)
437  target_buffer_set_u16(target, &buffer[i * 2], srcbuf[i]);
438 }
439 
440 /* return a pointer to a configured target; id is name or index in all_targets */
441 struct target *get_target(const char *id)
442 {
443  struct target *target;
444 
445  /* try as tcltarget name */
446  for (target = all_targets; target; target = target->next) {
447  if (!target_name(target))
448  continue;
449  if (strcmp(id, target_name(target)) == 0)
450  return target;
451  }
452 
453  /* try as index */
454  unsigned int index, counter;
455  if (parse_uint(id, &index) != ERROR_OK)
456  return NULL;
457 
458  for (target = all_targets, counter = index;
459  target && counter;
460  target = target->next, --counter)
461  ;
462 
463  return target;
464 }
465 
466 struct target *get_current_target(struct command_context *cmd_ctx)
467 {
468  struct target *target = get_current_target_or_null(cmd_ctx);
469 
470  if (!target) {
471  LOG_ERROR("BUG: current_target out of bounds");
472  exit(-1);
473  }
474 
475  return target;
476 }
477 
479 {
480  return cmd_ctx->current_target_override
481  ? cmd_ctx->current_target_override
482  : cmd_ctx->current_target;
483 }
484 
486 {
487  int retval;
488 
489  /* We can't poll until after examine */
490  if (!target_was_examined(target)) {
491  /* Fail silently lest we pollute the log */
492  return ERROR_FAIL;
493  }
494 
495  retval = target->type->poll(target);
496  if (retval != ERROR_OK)
497  return retval;
498 
499  if (target->halt_issued) {
500  if (target->state == TARGET_HALTED)
501  target->halt_issued = false;
502  else {
503  int64_t t = timeval_ms() - target->halt_issued_time;
504  if (t > DEFAULT_HALT_TIMEOUT) {
505  target->halt_issued = false;
506  LOG_INFO("Halt timed out, wake up GDB.");
508  }
509  }
510  }
511 
512  return ERROR_OK;
513 }
514 
516 {
517  int retval;
518  /* We can't poll until after examine */
519  if (!target_was_examined(target)) {
520  LOG_ERROR("Target not examined yet");
521  return ERROR_FAIL;
522  }
523 
524  retval = target->type->halt(target);
525  if (retval != ERROR_OK)
526  return retval;
527 
528  target->halt_issued = true;
530 
531  return ERROR_OK;
532 }
533 
564 int target_resume(struct target *target, bool current, target_addr_t address,
565  bool handle_breakpoints, bool debug_execution)
566 {
567  int retval;
568 
569  /* We can't poll until after examine */
570  if (!target_was_examined(target)) {
571  LOG_ERROR("Target not examined yet");
572  return ERROR_FAIL;
573  }
574 
576 
577  /* note that resume *must* be asynchronous. The CPU can halt before
578  * we poll. The CPU can even halt at the current PC as a result of
579  * a software breakpoint being inserted by (a bug?) the application.
580  */
581  /*
582  * resume() triggers the event 'resumed'. The execution of TCL commands
583  * in the event handler causes the polling of targets. If the target has
584  * already halted for a breakpoint, polling will run the 'halted' event
585  * handler before the pending 'resumed' handler.
586  * Disable polling during resume() to guarantee the execution of handlers
587  * in the correct order.
588  */
589  bool save_poll_mask = jtag_poll_mask();
590  retval = target->type->resume(target, current, address, handle_breakpoints,
591  debug_execution);
592  jtag_poll_unmask(save_poll_mask);
593 
594  if (retval != ERROR_OK)
595  return retval;
596 
598 
599  return retval;
600 }
601 
602 static int target_process_reset(struct command_invocation *cmd, enum target_reset_mode reset_mode)
603 {
604  char buf[100];
605  int retval;
606  const struct nvp *n;
607  n = nvp_value2name(nvp_reset_modes, reset_mode);
608  if (!n->name) {
609  LOG_ERROR("invalid reset mode");
610  return ERROR_FAIL;
611  }
612 
613  struct target *target;
615  target_call_reset_callbacks(target, reset_mode);
616 
617  /* disable polling during reset to make reset event scripts
618  * more predictable, i.e. dr/irscan & pathmove in events will
619  * not have JTAG operations injected into the middle of a sequence.
620  */
621  bool save_poll_mask = jtag_poll_mask();
622 
623  sprintf(buf, "ocd_process_reset %s", n->name);
624  retval = Jim_Eval(cmd->ctx->interp, buf);
625 
626  jtag_poll_unmask(save_poll_mask);
627 
628  if (retval != JIM_OK) {
629  Jim_MakeErrorMessage(cmd->ctx->interp);
630  command_print(cmd, "%s", Jim_GetString(Jim_GetResult(cmd->ctx->interp), NULL));
631  return ERROR_FAIL;
632  }
633 
634  /* We want any events to be processed before the prompt */
636 
637  for (target = all_targets; target; target = target->next) {
639  target->running_alg = false;
640  }
641 
642  return retval;
643 }
644 
645 static int identity_virt2phys(struct target *target,
646  target_addr_t virtual, target_addr_t *physical)
647 {
648  *physical = virtual;
649  return ERROR_OK;
650 }
651 
652 static int no_mmu(struct target *target, int *enabled)
653 {
654  *enabled = 0;
655  return ERROR_OK;
656 }
657 
662 static inline void target_reset_examined(struct target *target)
663 {
664  target->examined = false;
665 }
666 
667 static int default_examine(struct target *target)
668 {
670  return ERROR_OK;
671 }
672 
673 /* no check by default */
674 static int default_check_reset(struct target *target)
675 {
676  return ERROR_OK;
677 }
678 
679 /* Equivalent Tcl code arp_examine_one is in src/target/startup.tcl
680  * Keep in sync */
682 {
683  LOG_TARGET_DEBUG(target, "Examination started");
684 
686 
687  int retval = target->type->examine(target);
688  if (retval != ERROR_OK) {
689  LOG_TARGET_ERROR(target, "Examination failed");
690  LOG_TARGET_DEBUG(target, "examine() returned error code %d", retval);
693  return retval;
694  }
695 
698 
699  LOG_TARGET_INFO(target, "Examination succeed");
700  return ERROR_OK;
701 }
702 
703 static int jtag_enable_callback(enum jtag_event event, void *priv)
704 {
705  struct target *target = priv;
706 
707  if (event != JTAG_TAP_EVENT_ENABLE || !target->tap->enabled)
708  return ERROR_OK;
709 
711 
712  return target_examine_one(target);
713 }
714 
715 /* Targets that correctly implement init + examine, i.e.
716  * no communication with target during init:
717  *
718  * XScale
719  */
720 int target_examine(void)
721 {
722  int retval = ERROR_OK;
723  struct target *target;
724 
725  for (target = all_targets; target; target = target->next) {
726  /* defer examination, but don't skip it */
727  if (!target->tap->enabled) {
729  target);
730  continue;
731  }
732 
733  if (target->defer_examine)
734  continue;
735 
736  int retval2 = target_examine_one(target);
737  if (retval2 != ERROR_OK) {
738  LOG_WARNING("target %s examination failed", target_name(target));
739  retval = retval2;
740  }
741  }
742  return retval;
743 }
744 
745 const char *target_type_name(const struct target *target)
746 {
747  return target->type->name;
748 }
749 
751 {
752  if (!target_was_examined(target)) {
753  LOG_ERROR("Target not examined yet");
754  return ERROR_FAIL;
755  }
756  if (!target->type->soft_reset_halt) {
757  LOG_ERROR("Target %s does not support soft_reset_halt",
759  return ERROR_FAIL;
760  }
761  return target->type->soft_reset_halt(target);
762 }
763 
783  int num_mem_params, struct mem_param *mem_params,
784  int num_reg_params, struct reg_param *reg_param,
785  target_addr_t entry_point, target_addr_t exit_point,
786  unsigned int timeout_ms, void *arch_info)
787 {
788  int retval = ERROR_FAIL;
789 
790  if (!target_was_examined(target)) {
791  LOG_ERROR("Target not examined yet");
792  goto done;
793  }
794  if (!target->type->run_algorithm) {
795  LOG_ERROR("Target type '%s' does not support %s",
796  target_type_name(target), __func__);
797  goto done;
798  }
799 
800  target->running_alg = true;
801  retval = target->type->run_algorithm(target,
802  num_mem_params, mem_params,
803  num_reg_params, reg_param,
804  entry_point, exit_point, timeout_ms, arch_info);
805  target->running_alg = false;
806 
807 done:
808  return retval;
809 }
810 
824  int num_mem_params, struct mem_param *mem_params,
825  int num_reg_params, struct reg_param *reg_params,
826  target_addr_t entry_point, target_addr_t exit_point,
827  void *arch_info)
828 {
829  int retval = ERROR_FAIL;
830 
831  if (!target_was_examined(target)) {
832  LOG_ERROR("Target not examined yet");
833  goto done;
834  }
835  if (!target->type->start_algorithm) {
836  LOG_ERROR("Target type '%s' does not support %s",
837  target_type_name(target), __func__);
838  goto done;
839  }
840  if (target->running_alg) {
841  LOG_ERROR("Target is already running an algorithm");
842  goto done;
843  }
844 
845  target->running_alg = true;
846  retval = target->type->start_algorithm(target,
847  num_mem_params, mem_params,
848  num_reg_params, reg_params,
849  entry_point, exit_point, arch_info);
850 
851 done:
852  return retval;
853 }
854 
868  int num_mem_params, struct mem_param *mem_params,
869  int num_reg_params, struct reg_param *reg_params,
870  target_addr_t exit_point, unsigned int timeout_ms,
871  void *arch_info)
872 {
873  int retval = ERROR_FAIL;
874 
875  if (!target->type->wait_algorithm) {
876  LOG_ERROR("Target type '%s' does not support %s",
877  target_type_name(target), __func__);
878  goto done;
879  }
880  if (!target->running_alg) {
881  LOG_ERROR("Target is not running an algorithm");
882  goto done;
883  }
884 
885  retval = target->type->wait_algorithm(target,
886  num_mem_params, mem_params,
887  num_reg_params, reg_params,
888  exit_point, timeout_ms, arch_info);
889  if (retval != ERROR_TARGET_TIMEOUT)
890  target->running_alg = false;
891 
892 done:
893  return retval;
894 }
895 
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,
943  uint32_t buffer_start, uint32_t buffer_size,
944  uint32_t entry_point, uint32_t exit_point, void *arch_info)
945 {
946  int retval;
947  int timeout = 0;
948 
949  const uint8_t *buffer_orig = buffer;
950 
951  /* Set up working area. First word is write pointer, second word is read pointer,
952  * rest is fifo data area. */
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;
957 
958  uint32_t wp = fifo_start_addr;
959  uint32_t rp = fifo_start_addr;
960 
961  /* validate block_size is 2^n */
962  assert(IS_PWR_OF_2(block_size));
963 
964  retval = target_write_u32(target, wp_addr, wp);
965  if (retval != ERROR_OK)
966  return retval;
967  retval = target_write_u32(target, rp_addr, rp);
968  if (retval != ERROR_OK)
969  return retval;
970 
971  /* Start up algorithm on target and let it idle while writing the first chunk */
972  retval = target_start_algorithm(target, num_mem_params, mem_params,
973  num_reg_params, reg_params,
974  entry_point,
975  exit_point,
976  arch_info);
977 
978  if (retval != ERROR_OK) {
979  LOG_ERROR("error starting target flash write algorithm");
980  return retval;
981  }
982 
983  while (count > 0) {
984 
985  retval = target_read_u32(target, rp_addr, &rp);
986  if (retval != ERROR_OK) {
987  LOG_ERROR("failed to get read pointer");
988  break;
989  }
990 
991  LOG_DEBUG("offs 0x%zx count 0x%" PRIx32 " wp 0x%" PRIx32 " rp 0x%" PRIx32,
992  (size_t) (buffer - buffer_orig), count, wp, rp);
993 
994  if (rp == 0) {
995  LOG_ERROR("flash write algorithm aborted by target");
997  break;
998  }
999 
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);
1002  break;
1003  }
1004 
1005  /* Count the number of bytes available in the fifo without
1006  * crossing the wrap around. Make sure to not fill it completely,
1007  * because that would make wp == rp and that's the empty condition. */
1008  uint32_t thisrun_bytes;
1009  if (rp > wp)
1010  thisrun_bytes = rp - wp - block_size;
1011  else if (rp > fifo_start_addr)
1012  thisrun_bytes = fifo_end_addr - wp;
1013  else
1014  thisrun_bytes = fifo_end_addr - wp - block_size;
1015 
1016  if (thisrun_bytes == 0) {
1017  /* Throttle polling a bit if transfer is (much) faster than flash
1018  * programming. The exact delay shouldn't matter as long as it's
1019  * less than buffer size / flash speed. This is very unlikely to
1020  * run when using high latency connections such as USB. */
1021  alive_sleep(2);
1022 
1023  /* to stop an infinite loop on some targets check and increment a timeout
1024  * this issue was observed on a stellaris using the new ICDI interface */
1025  if (timeout++ >= 2500) {
1026  LOG_ERROR("timeout waiting for algorithm, a target reset is recommended");
1028  }
1029  continue;
1030  }
1031 
1032  /* reset our timeout */
1033  timeout = 0;
1034 
1035  /* Limit to the amount of data we actually want to write */
1036  if (thisrun_bytes > count * block_size)
1037  thisrun_bytes = count * block_size;
1038 
1039  /* Force end of large blocks to be word aligned */
1040  if (thisrun_bytes >= 16)
1041  thisrun_bytes -= (rp + thisrun_bytes) & 0x03;
1042 
1043  /* Write data to fifo */
1044  retval = target_write_buffer(target, wp, thisrun_bytes, buffer);
1045  if (retval != ERROR_OK)
1046  break;
1047 
1048  /* Update counters and wrap write pointer */
1049  buffer += thisrun_bytes;
1050  count -= thisrun_bytes / block_size;
1051  wp += thisrun_bytes;
1052  if (wp >= fifo_end_addr)
1053  wp = fifo_start_addr;
1054 
1055  /* Store updated write pointer to target */
1056  retval = target_write_u32(target, wp_addr, wp);
1057  if (retval != ERROR_OK)
1058  break;
1059 
1060  /* Avoid GDB timeouts */
1061  keep_alive();
1062  }
1063 
1064  if (retval != ERROR_OK) {
1065  /* abort flash write algorithm on target */
1066  target_write_u32(target, wp_addr, 0);
1067  }
1068 
1069  int retval2 = target_wait_algorithm(target, num_mem_params, mem_params,
1070  num_reg_params, reg_params,
1071  exit_point,
1072  10000,
1073  arch_info);
1074 
1075  if (retval2 != ERROR_OK) {
1076  LOG_ERROR("error waiting for target flash write algorithm");
1077  retval = retval2;
1078  }
1079 
1080  if (retval == ERROR_OK) {
1081  /* check if algorithm set rp = 0 after fifo writer loop finished */
1082  retval = target_read_u32(target, rp_addr, &rp);
1083  if (retval == ERROR_OK && rp == 0) {
1084  LOG_ERROR("flash write algorithm aborted by target");
1086  }
1087  }
1088 
1089  return retval;
1090 }
1091 
1093  uint8_t *buffer, uint32_t count, int block_size,
1094  int num_mem_params, struct mem_param *mem_params,
1095  int num_reg_params, struct reg_param *reg_params,
1096  uint32_t buffer_start, uint32_t buffer_size,
1097  uint32_t entry_point, uint32_t exit_point, void *arch_info)
1098 {
1099  int retval;
1100  int timeout = 0;
1101 
1102  const uint8_t *buffer_orig = buffer;
1103 
1104  /* Set up working area. First word is write pointer, second word is read pointer,
1105  * rest is fifo data area. */
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;
1110 
1111  uint32_t wp = fifo_start_addr;
1112  uint32_t rp = fifo_start_addr;
1113 
1114  /* validate block_size is 2^n */
1115  assert(IS_PWR_OF_2(block_size));
1116 
1117  retval = target_write_u32(target, wp_addr, wp);
1118  if (retval != ERROR_OK)
1119  return retval;
1120  retval = target_write_u32(target, rp_addr, rp);
1121  if (retval != ERROR_OK)
1122  return retval;
1123 
1124  /* Start up algorithm on target */
1125  retval = target_start_algorithm(target, num_mem_params, mem_params,
1126  num_reg_params, reg_params,
1127  entry_point,
1128  exit_point,
1129  arch_info);
1130 
1131  if (retval != ERROR_OK) {
1132  LOG_ERROR("error starting target flash read algorithm");
1133  return retval;
1134  }
1135 
1136  while (count > 0) {
1137  retval = target_read_u32(target, wp_addr, &wp);
1138  if (retval != ERROR_OK) {
1139  LOG_ERROR("failed to get write pointer");
1140  break;
1141  }
1142 
1143  LOG_DEBUG("offs 0x%zx count 0x%" PRIx32 " wp 0x%" PRIx32 " rp 0x%" PRIx32,
1144  (size_t)(buffer - buffer_orig), count, wp, rp);
1145 
1146  if (wp == 0) {
1147  LOG_ERROR("flash read algorithm aborted by target");
1149  break;
1150  }
1151 
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);
1154  break;
1155  }
1156 
1157  /* Count the number of bytes available in the fifo without
1158  * crossing the wrap around. */
1159  uint32_t thisrun_bytes;
1160  if (wp >= rp)
1161  thisrun_bytes = wp - rp;
1162  else
1163  thisrun_bytes = fifo_end_addr - rp;
1164 
1165  if (thisrun_bytes == 0) {
1166  /* Throttle polling a bit if transfer is (much) faster than flash
1167  * reading. The exact delay shouldn't matter as long as it's
1168  * less than buffer size / flash speed. This is very unlikely to
1169  * run when using high latency connections such as USB. */
1170  alive_sleep(2);
1171 
1172  /* to stop an infinite loop on some targets check and increment a timeout
1173  * this issue was observed on a stellaris using the new ICDI interface */
1174  if (timeout++ >= 2500) {
1175  LOG_ERROR("timeout waiting for algorithm, a target reset is recommended");
1177  }
1178  continue;
1179  }
1180 
1181  /* Reset our timeout */
1182  timeout = 0;
1183 
1184  /* Limit to the amount of data we actually want to read */
1185  if (thisrun_bytes > count * block_size)
1186  thisrun_bytes = count * block_size;
1187 
1188  /* Force end of large blocks to be word aligned */
1189  if (thisrun_bytes >= 16)
1190  thisrun_bytes -= (rp + thisrun_bytes) & 0x03;
1191 
1192  /* Read data from fifo */
1193  retval = target_read_buffer(target, rp, thisrun_bytes, buffer);
1194  if (retval != ERROR_OK)
1195  break;
1196 
1197  /* Update counters and wrap write pointer */
1198  buffer += thisrun_bytes;
1199  count -= thisrun_bytes / block_size;
1200  rp += thisrun_bytes;
1201  if (rp >= fifo_end_addr)
1202  rp = fifo_start_addr;
1203 
1204  /* Store updated write pointer to target */
1205  retval = target_write_u32(target, rp_addr, rp);
1206  if (retval != ERROR_OK)
1207  break;
1208 
1209  /* Avoid GDB timeouts */
1210  keep_alive();
1211 
1213  retval = ERROR_SERVER_INTERRUPTED;
1214  break;
1215  }
1216  }
1217 
1218  if (retval != ERROR_OK) {
1219  /* abort flash write algorithm on target */
1220  target_write_u32(target, rp_addr, 0);
1221  }
1222 
1223  int retval2 = target_wait_algorithm(target, num_mem_params, mem_params,
1224  num_reg_params, reg_params,
1225  exit_point,
1226  10000,
1227  arch_info);
1228 
1229  if (retval2 != ERROR_OK) {
1230  LOG_ERROR("error waiting for target flash write algorithm");
1231  retval = retval2;
1232  }
1233 
1234  if (retval == ERROR_OK) {
1235  /* check if algorithm set wp = 0 after fifo writer loop finished */
1236  retval = target_read_u32(target, wp_addr, &wp);
1237  if (retval == ERROR_OK && wp == 0) {
1238  LOG_ERROR("flash read algorithm aborted by target");
1240  }
1241  }
1242 
1243  return retval;
1244 }
1245 
1247  target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
1248 {
1249  if (!target_was_examined(target)) {
1250  LOG_ERROR("Target not examined yet");
1251  return ERROR_FAIL;
1252  }
1253  if (!target->type->read_memory) {
1254  LOG_ERROR("Target %s doesn't support read_memory", target_name(target));
1255  return ERROR_FAIL;
1256  }
1258 }
1259 
1261  target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
1262 {
1263  if (!target_was_examined(target)) {
1264  LOG_ERROR("Target not examined yet");
1265  return ERROR_FAIL;
1266  }
1267  if (!target->type->read_phys_memory) {
1268  LOG_ERROR("Target %s doesn't support read_phys_memory", target_name(target));
1269  return ERROR_FAIL;
1270  }
1272 }
1273 
1275  target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
1276 {
1277  if (!target_was_examined(target)) {
1278  LOG_ERROR("Target not examined yet");
1279  return ERROR_FAIL;
1280  }
1281  if (!target->type->write_memory) {
1282  LOG_ERROR("Target %s doesn't support write_memory", target_name(target));
1283  return ERROR_FAIL;
1284  }
1286 }
1287 
1289  target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
1290 {
1291  if (!target_was_examined(target)) {
1292  LOG_ERROR("Target not examined yet");
1293  return ERROR_FAIL;
1294  }
1295  if (!target->type->write_phys_memory) {
1296  LOG_ERROR("Target %s doesn't support write_phys_memory", target_name(target));
1297  return ERROR_FAIL;
1298  }
1300 }
1301 
1303  struct breakpoint *breakpoint)
1304 {
1305  if ((target->state != TARGET_HALTED) && (breakpoint->type != BKPT_HARD)) {
1306  LOG_TARGET_ERROR(target, "not halted (add breakpoint)");
1307  return ERROR_TARGET_NOT_HALTED;
1308  }
1310 }
1311 
1313  struct breakpoint *breakpoint)
1314 {
1315  if (target->state != TARGET_HALTED) {
1316  LOG_TARGET_ERROR(target, "not halted (add context breakpoint)");
1317  return ERROR_TARGET_NOT_HALTED;
1318  }
1320 }
1321 
1323  struct breakpoint *breakpoint)
1324 {
1325  if (target->state != TARGET_HALTED) {
1326  LOG_TARGET_ERROR(target, "not halted (add hybrid breakpoint)");
1327  return ERROR_TARGET_NOT_HALTED;
1328  }
1330 }
1331 
1333  struct breakpoint *breakpoint)
1334 {
1336 }
1337 
1339  struct watchpoint *watchpoint)
1340 {
1341  if (target->state != TARGET_HALTED) {
1342  LOG_TARGET_ERROR(target, "not halted (add watchpoint)");
1343  return ERROR_TARGET_NOT_HALTED;
1344  }
1346 }
1348  struct watchpoint *watchpoint)
1349 {
1351 }
1353  struct watchpoint **hit_watchpoint)
1354 {
1355  if (target->state != TARGET_HALTED) {
1356  LOG_TARGET_ERROR(target, "not halted (hit watchpoint)");
1357  return ERROR_TARGET_NOT_HALTED;
1358  }
1359 
1360  if (!target->type->hit_watchpoint) {
1361  /* For backward compatible, if hit_watchpoint is not implemented,
1362  * return ERROR_FAIL such that gdb_server will not take the nonsense
1363  * information. */
1364  return ERROR_FAIL;
1365  }
1366 
1367  return target->type->hit_watchpoint(target, hit_watchpoint);
1368 }
1369 
1370 const char *target_get_gdb_arch(const struct target *target)
1371 {
1372  if (!target->type->get_gdb_arch)
1373  return NULL;
1374  return target->type->get_gdb_arch(target);
1375 }
1376 
1378  struct reg **reg_list[], int *reg_list_size,
1379  enum target_register_class reg_class)
1380 {
1381  int result = ERROR_FAIL;
1382 
1383  if (!target_was_examined(target)) {
1384  LOG_ERROR("Target not examined yet");
1385  goto done;
1386  }
1387 
1388  result = target->type->get_gdb_reg_list(target, reg_list,
1389  reg_list_size, reg_class);
1390 
1391 done:
1392  if (result != ERROR_OK) {
1393  *reg_list = NULL;
1394  *reg_list_size = 0;
1395  }
1396  return result;
1397 }
1398 
1400  struct reg **reg_list[], int *reg_list_size,
1401  enum target_register_class reg_class)
1402 {
1405  reg_list_size, reg_class) == ERROR_OK)
1406  return ERROR_OK;
1407  return target_get_gdb_reg_list(target, reg_list, reg_list_size, reg_class);
1408 }
1409 
1411 {
1412  /*
1413  * exclude all the targets that don't provide get_gdb_reg_list
1414  * or that have explicit gdb_max_connection == 0
1415  */
1417 }
1418 
1420  bool current, target_addr_t address, bool handle_breakpoints)
1421 {
1422  int retval;
1423 
1425 
1426  retval = target->type->step(target, current, address, handle_breakpoints);
1427  if (retval != ERROR_OK)
1428  return retval;
1429 
1431 
1432  return retval;
1433 }
1434 
1436 {
1437  if (target->state != TARGET_HALTED) {
1438  LOG_TARGET_ERROR(target, "not halted (gdb fileio)");
1439  return ERROR_TARGET_NOT_HALTED;
1440  }
1442 }
1443 
1444 int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
1445 {
1446  if (target->state != TARGET_HALTED) {
1447  LOG_TARGET_ERROR(target, "not halted (gdb fileio end)");
1448  return ERROR_TARGET_NOT_HALTED;
1449  }
1450  return target->type->gdb_fileio_end(target, retcode, fileio_errno, ctrl_c);
1451 }
1452 
1454 {
1455  unsigned int bits = target_address_bits(target);
1456  if (sizeof(target_addr_t) * 8 == bits)
1457  return (target_addr_t) -1;
1458  else
1459  return (((target_addr_t) 1) << bits) - 1;
1460 }
1461 
1462 unsigned int target_address_bits(struct target *target)
1463 {
1464  if (target->type->address_bits)
1465  return target->type->address_bits(target);
1466  return 32;
1467 }
1468 
1469 unsigned int target_data_bits(struct target *target)
1470 {
1471  if (target->type->data_bits)
1472  return target->type->data_bits(target);
1473  return 32;
1474 }
1475 
1476 static int target_profiling(struct target *target, uint32_t *samples,
1477  uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
1478 {
1479  return target->type->profiling(target, samples, max_num_samples,
1480  num_samples, seconds);
1481 }
1482 
1483 static int handle_target(void *priv);
1484 
1485 static int target_init_one(struct command_context *cmd_ctx,
1486  struct target *target)
1487 {
1489 
1490  struct target_type *type = target->type;
1491  if (!type->examine)
1492  type->examine = default_examine;
1493 
1494  if (!type->check_reset)
1495  type->check_reset = default_check_reset;
1496 
1497  assert(type->init_target);
1498 
1499  int retval = type->init_target(cmd_ctx, target);
1500  if (retval != ERROR_OK) {
1501  LOG_ERROR("target '%s' init failed", target_name(target));
1502  return retval;
1503  }
1504 
1505  /* Sanity-check MMU support ... stub in what we must, to help
1506  * implement it in stages, but warn if we need to do so.
1507  */
1508  if (type->mmu) {
1509  if (!type->virt2phys) {
1510  LOG_ERROR("type '%s' is missing virt2phys", target_name(target));
1511  type->virt2phys = identity_virt2phys;
1512  }
1513  } else {
1514  /* Make sure no-MMU targets all behave the same: make no
1515  * distinction between physical and virtual addresses, and
1516  * ensure that virt2phys() is always an identity mapping.
1517  */
1518  if (type->write_phys_memory || type->read_phys_memory || type->virt2phys)
1519  LOG_WARNING("type '%s' has bad MMU hooks", target_name(target));
1520 
1521  type->mmu = no_mmu;
1522  type->write_phys_memory = type->write_memory;
1523  type->read_phys_memory = type->read_memory;
1524  type->virt2phys = identity_virt2phys;
1525  }
1526 
1527  if (!target->type->read_buffer)
1529 
1530  if (!target->type->write_buffer)
1532 
1535 
1536  if (!target->type->gdb_fileio_end)
1538 
1539  if (!target->type->profiling)
1541 
1542  return ERROR_OK;
1543 }
1544 
1545 static int target_init(struct command_context *cmd_ctx)
1546 {
1547  struct target *target;
1548  int retval;
1549 
1550  for (target = all_targets; target; target = target->next) {
1551  retval = target_init_one(cmd_ctx, target);
1552  if (retval != ERROR_OK)
1553  return retval;
1554  }
1555 
1556  if (!all_targets)
1557  return ERROR_OK;
1558 
1559  retval = target_register_user_commands(cmd_ctx);
1560  if (retval != ERROR_OK)
1561  return retval;
1562 
1565  if (retval != ERROR_OK)
1566  return retval;
1567 
1568  return ERROR_OK;
1569 }
1570 
1571 COMMAND_HANDLER(handle_target_init_command)
1572 {
1573  int retval;
1574 
1575  if (CMD_ARGC != 0)
1577 
1578  static bool target_initialized;
1579  if (target_initialized) {
1580  LOG_INFO("'target init' has already been called");
1581  return ERROR_OK;
1582  }
1583  target_initialized = true;
1584 
1585  retval = command_run_line(CMD_CTX, "init_targets");
1586  if (retval != ERROR_OK)
1587  return retval;
1588 
1589  retval = command_run_line(CMD_CTX, "init_target_events");
1590  if (retval != ERROR_OK)
1591  return retval;
1592 
1593  retval = command_run_line(CMD_CTX, "init_board");
1594  if (retval != ERROR_OK)
1595  return retval;
1596 
1597  LOG_DEBUG("Initializing targets...");
1598  return target_init(CMD_CTX);
1599 }
1600 
1601 int target_register_event_callback(int (*callback)(struct target *target,
1602  enum target_event event, void *priv), void *priv)
1603 {
1604  struct target_event_callback **callbacks_p = &target_event_callbacks;
1605 
1606  if (!callback)
1608 
1609  if (*callbacks_p) {
1610  while ((*callbacks_p)->next)
1611  callbacks_p = &((*callbacks_p)->next);
1612  callbacks_p = &((*callbacks_p)->next);
1613  }
1614 
1615  (*callbacks_p) = malloc(sizeof(struct target_event_callback));
1616  (*callbacks_p)->callback = callback;
1617  (*callbacks_p)->priv = priv;
1618  (*callbacks_p)->next = NULL;
1619 
1620  return ERROR_OK;
1621 }
1622 
1624  enum target_reset_mode reset_mode, void *priv), void *priv)
1625 {
1626  struct target_reset_callback *entry;
1627 
1628  if (!callback)
1630 
1631  entry = malloc(sizeof(struct target_reset_callback));
1632  if (!entry) {
1633  LOG_ERROR("error allocating buffer for reset callback entry");
1635  }
1636 
1637  entry->callback = callback;
1638  entry->priv = priv;
1639  list_add(&entry->list, &target_reset_callback_list);
1640 
1641 
1642  return ERROR_OK;
1643 }
1644 
1646  size_t len, uint8_t *data, void *priv), void *priv)
1647 {
1648  struct target_trace_callback *entry;
1649 
1650  if (!callback)
1652 
1653  entry = malloc(sizeof(struct target_trace_callback));
1654  if (!entry) {
1655  LOG_ERROR("error allocating buffer for trace callback entry");
1657  }
1658 
1659  entry->callback = callback;
1660  entry->priv = priv;
1661  list_add(&entry->list, &target_trace_callback_list);
1662 
1663 
1664  return ERROR_OK;
1665 }
1666 
1668  unsigned int time_ms, enum target_timer_type type, void *priv)
1669 {
1670  struct target_timer_callback **callbacks_p = &target_timer_callbacks;
1671 
1672  if (!callback)
1674 
1675  if (*callbacks_p) {
1676  while ((*callbacks_p)->next)
1677  callbacks_p = &((*callbacks_p)->next);
1678  callbacks_p = &((*callbacks_p)->next);
1679  }
1680 
1681  (*callbacks_p) = malloc(sizeof(struct target_timer_callback));
1682  (*callbacks_p)->callback = callback;
1683  (*callbacks_p)->type = type;
1684  (*callbacks_p)->time_ms = time_ms;
1685  (*callbacks_p)->removed = false;
1686 
1687  (*callbacks_p)->when = timeval_ms() + time_ms;
1689 
1690  (*callbacks_p)->priv = priv;
1691  (*callbacks_p)->next = NULL;
1692 
1693  return ERROR_OK;
1694 }
1695 
1697  enum target_event event, void *priv), void *priv)
1698 {
1701 
1702  if (!callback)
1704 
1705  while (c) {
1706  struct target_event_callback *next = c->next;
1707  if ((c->callback == callback) && (c->priv == priv)) {
1708  *p = next;
1709  free(c);
1710  return ERROR_OK;
1711  } else
1712  p = &(c->next);
1713  c = next;
1714  }
1715 
1716  return ERROR_OK;
1717 }
1718 
1720  enum target_reset_mode reset_mode, void *priv), void *priv)
1721 {
1722  struct target_reset_callback *entry;
1723 
1724  if (!callback)
1726 
1727  list_for_each_entry(entry, &target_reset_callback_list, list) {
1728  if (entry->callback == callback && entry->priv == priv) {
1729  list_del(&entry->list);
1730  free(entry);
1731  break;
1732  }
1733  }
1734 
1735  return ERROR_OK;
1736 }
1737 
1739  size_t len, uint8_t *data, void *priv), void *priv)
1740 {
1741  struct target_trace_callback *entry;
1742 
1743  if (!callback)
1745 
1746  list_for_each_entry(entry, &target_trace_callback_list, list) {
1747  if (entry->callback == callback && entry->priv == priv) {
1748  list_del(&entry->list);
1749  free(entry);
1750  break;
1751  }
1752  }
1753 
1754  return ERROR_OK;
1755 }
1756 
1758 {
1759  if (!callback)
1761 
1763  c; c = c->next) {
1764  if ((c->callback == callback) && (c->priv == priv)) {
1765  c->removed = true;
1766  return ERROR_OK;
1767  }
1768  }
1769 
1770  return ERROR_FAIL;
1771 }
1772 
1774 {
1776  struct target_event_callback *next_callback;
1777 
1778  if (event == TARGET_EVENT_HALTED) {
1779  /* execute early halted first */
1781  }
1782 
1783  LOG_DEBUG("target event %i (%s) for core %s", event,
1784  target_event_name(event),
1785  target_name(target));
1786 
1787  target_handle_event(target, event);
1788 
1789  while (callback) {
1790  next_callback = callback->next;
1791  callback->callback(target, event, callback->priv);
1792  callback = next_callback;
1793  }
1794 
1795  return ERROR_OK;
1796 }
1797 
1799 {
1801 
1802  LOG_DEBUG("target reset %i (%s)", reset_mode,
1803  nvp_value2name(nvp_reset_modes, reset_mode)->name);
1804 
1805  list_for_each_entry(callback, &target_reset_callback_list, list)
1806  callback->callback(target, reset_mode, callback->priv);
1807 
1808  return ERROR_OK;
1809 }
1810 
1811 int target_call_trace_callbacks(struct target *target, size_t len, uint8_t *data)
1812 {
1814 
1815  list_for_each_entry(callback, &target_trace_callback_list, list)
1816  callback->callback(target, len, data, callback->priv);
1817 
1818  return ERROR_OK;
1819 }
1820 
1822  struct target_timer_callback *cb, int64_t *now)
1823 {
1824  cb->when = *now + cb->time_ms;
1825  return ERROR_OK;
1826 }
1827 
1829  int64_t *now)
1830 {
1831  cb->callback(cb->priv);
1832 
1833  if (cb->type == TARGET_TIMER_TYPE_PERIODIC)
1835 
1837 }
1838 
1840 {
1841  static bool callback_processing;
1842 
1843  /* Do not allow nesting */
1844  if (callback_processing)
1845  return ERROR_OK;
1846 
1847  callback_processing = true;
1848 
1849  keep_alive();
1850 
1851  int64_t now = timeval_ms();
1852 
1853  /* Initialize to a default value that's a ways into the future.
1854  * The loop below will make it closer to now if there are
1855  * callbacks that want to be called sooner. */
1856  target_timer_next_event_value = now + 1000;
1857 
1858  /* Store an address of the place containing a pointer to the
1859  * next item; initially, that's a standalone "root of the
1860  * list" variable. */
1862  while (callback && *callback) {
1863  if ((*callback)->removed) {
1864  struct target_timer_callback *p = *callback;
1865  *callback = (*callback)->next;
1866  free(p);
1867  continue;
1868  }
1869 
1870  bool call_it = (*callback)->callback &&
1871  ((!checktime && (*callback)->type == TARGET_TIMER_TYPE_PERIODIC) ||
1872  now >= (*callback)->when);
1873 
1874  if (call_it)
1876 
1877  if (!(*callback)->removed && (*callback)->when < target_timer_next_event_value)
1878  target_timer_next_event_value = (*callback)->when;
1879 
1880  callback = &(*callback)->next;
1881  }
1882 
1883  callback_processing = false;
1884  return ERROR_OK;
1885 }
1886 
1888 {
1890 }
1891 
1892 /* invoke periodic callbacks immediately */
1894 {
1896 }
1897 
1899 {
1901 }
1902 
1903 /* Prints the working area layout for debug purposes */
1904 static void print_wa_layout(struct target *target)
1905 {
1906  struct working_area *c = target->working_areas;
1907 
1908  while (c) {
1909  LOG_DEBUG("%c%c " TARGET_ADDR_FMT "-" TARGET_ADDR_FMT " (%" PRIu32 " bytes)",
1910  c->backup ? 'b' : ' ', c->free ? ' ' : '*',
1911  c->address, c->address + c->size - 1, c->size);
1912  c = c->next;
1913  }
1914 }
1915 
1916 /* Reduce area to size bytes, create a new free area from the remaining bytes, if any. */
1917 static void target_split_working_area(struct working_area *area, uint32_t size)
1918 {
1919  assert(area->free); /* Shouldn't split an allocated area */
1920  assert(size <= area->size); /* Caller should guarantee this */
1921 
1922  /* Split only if not already the right size */
1923  if (size < area->size) {
1924  struct working_area *new_wa = malloc(sizeof(*new_wa));
1925 
1926  if (!new_wa)
1927  return;
1928 
1929  new_wa->next = area->next;
1930  new_wa->size = area->size - size;
1931  new_wa->address = area->address + size;
1932  new_wa->backup = NULL;
1933  new_wa->user = NULL;
1934  new_wa->free = true;
1935 
1936  area->next = new_wa;
1937  area->size = size;
1938 
1939  /* If backup memory was allocated to this area, it has the wrong size
1940  * now so free it and it will be reallocated if/when needed */
1941  free(area->backup);
1942  area->backup = NULL;
1943  }
1944 }
1945 
1946 /* Merge all adjacent free areas into one */
1948 {
1949  struct working_area *c = target->working_areas;
1950 
1951  while (c && c->next) {
1952  assert(c->next->address == c->address + c->size); /* This is an invariant */
1953 
1954  /* Find two adjacent free areas */
1955  if (c->free && c->next->free) {
1956  /* Merge the last into the first */
1957  c->size += c->next->size;
1958 
1959  /* Remove the last */
1960  struct working_area *to_be_freed = c->next;
1961  c->next = c->next->next;
1962  free(to_be_freed->backup);
1963  free(to_be_freed);
1964 
1965  /* If backup memory was allocated to the remaining area, it's has
1966  * the wrong size now */
1967  free(c->backup);
1968  c->backup = NULL;
1969  } else {
1970  c = c->next;
1971  }
1972  }
1973 }
1974 
1975 int target_alloc_working_area_try(struct target *target, uint32_t size, struct working_area **area)
1976 {
1977  /* Reevaluate working area address based on MMU state*/
1978  if (!target->working_areas) {
1979  int retval;
1980  int enabled;
1981 
1982  retval = target->type->mmu(target, &enabled);
1983  if (retval != ERROR_OK)
1984  return retval;
1985 
1986  if (!enabled) {
1988  LOG_DEBUG("MMU disabled, using physical "
1989  "address for working memory " TARGET_ADDR_FMT,
1992  } else {
1993  LOG_ERROR("No working memory available. "
1994  "Specify -work-area-phys to target.");
1996  }
1997  } else {
1999  LOG_DEBUG("MMU enabled, using virtual "
2000  "address for working memory " TARGET_ADDR_FMT,
2003  } else {
2004  LOG_ERROR("No working memory available. "
2005  "Specify -work-area-virt to target.");
2007  }
2008  }
2009 
2010  /* Set up initial working area on first call */
2011  struct working_area *new_wa = malloc(sizeof(*new_wa));
2012  if (new_wa) {
2013  new_wa->next = NULL;
2014  new_wa->size = ALIGN_DOWN(target->working_area_size, 4); /* 4-byte align */
2015  new_wa->address = target->working_area;
2016  new_wa->backup = NULL;
2017  new_wa->user = NULL;
2018  new_wa->free = true;
2019  }
2020 
2021  target->working_areas = new_wa;
2022  }
2023 
2024  /* only allocate multiples of 4 byte */
2025  size = ALIGN_UP(size, 4);
2026 
2027  struct working_area *c = target->working_areas;
2028 
2029  /* Find the first large enough working area */
2030  while (c) {
2031  if (c->free && c->size >= size)
2032  break;
2033  c = c->next;
2034  }
2035 
2036  if (!c)
2038 
2039  /* Split the working area into the requested size */
2041 
2042  LOG_DEBUG("allocated new working area of %" PRIu32 " bytes at address " TARGET_ADDR_FMT,
2043  size, c->address);
2044 
2045  if (target->backup_working_area) {
2046  if (!c->backup) {
2047  c->backup = malloc(c->size);
2048  if (!c->backup)
2049  return ERROR_FAIL;
2050  }
2051 
2052  int retval = target_read_memory(target, c->address, 4, c->size / 4, c->backup);
2053  if (retval != ERROR_OK)
2054  return retval;
2055  }
2056 
2057  /* mark as used, and return the new (reused) area */
2058  c->free = false;
2059  *area = c;
2060 
2061  /* user pointer */
2062  c->user = area;
2063 
2065 
2066  return ERROR_OK;
2067 }
2068 
2069 int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
2070 {
2071  int retval;
2072 
2073  retval = target_alloc_working_area_try(target, size, area);
2075  LOG_WARNING("not enough working area available(requested %"PRIu32")", size);
2076  return retval;
2077 
2078 }
2079 
2080 static int target_restore_working_area(struct target *target, struct working_area *area)
2081 {
2082  int retval = ERROR_OK;
2083 
2084  if (target->backup_working_area && area->backup) {
2085  retval = target_write_memory(target, area->address, 4, area->size / 4, area->backup);
2086  if (retval != ERROR_OK)
2087  LOG_ERROR("failed to restore %" PRIu32 " bytes of working area at address " TARGET_ADDR_FMT,
2088  area->size, area->address);
2089  }
2090 
2091  return retval;
2092 }
2093 
2094 /* Restore the area's backup memory, if any, and return the area to the allocation pool */
2095 static int target_free_working_area_restore(struct target *target, struct working_area *area, int restore)
2096 {
2097  if (!area || area->free)
2098  return ERROR_OK;
2099 
2100  int retval = ERROR_OK;
2101  if (restore) {
2102  retval = target_restore_working_area(target, area);
2103  /* REVISIT: Perhaps the area should be freed even if restoring fails. */
2104  if (retval != ERROR_OK)
2105  return retval;
2106  }
2107 
2108  area->free = true;
2109 
2110  LOG_DEBUG("freed %" PRIu32 " bytes of working area at address " TARGET_ADDR_FMT,
2111  area->size, area->address);
2112 
2113  /* mark user pointer invalid */
2114  /* TODO: Is this really safe? It points to some previous caller's memory.
2115  * How could we know that the area pointer is still in that place and not
2116  * some other vital data? What's the purpose of this, anyway? */
2117  *area->user = NULL;
2118  area->user = NULL;
2119 
2121 
2123 
2124  return retval;
2125 }
2126 
2128 {
2129  return target_free_working_area_restore(target, area, 1);
2130 }
2131 
2132 /* free resources and restore memory, if restoring memory fails,
2133  * free up resources anyway
2134  */
2135 static void target_free_all_working_areas_restore(struct target *target, int restore)
2136 {
2137  struct working_area *c = target->working_areas;
2138 
2139  LOG_DEBUG("freeing all working areas");
2140 
2141  /* Loop through all areas, restoring the allocated ones and marking them as free */
2142  while (c) {
2143  if (!c->free) {
2144  if (restore)
2146  c->free = true;
2147  *c->user = NULL; /* Same as above */
2148  c->user = NULL;
2149  }
2150  c = c->next;
2151  }
2152 
2153  /* Run a merge pass to combine all areas into one */
2155 
2157 }
2158 
2160 {
2162 
2163  /* Now we have none or only one working area marked as free */
2164  if (target->working_areas) {
2165  /* Free the last one to allow on-the-fly moving and resizing */
2169  }
2170 }
2171 
2172 /* Find the largest number of bytes that can be allocated */
2174 {
2175  struct working_area *c = target->working_areas;
2176  uint32_t max_size = 0;
2177 
2178  if (!c)
2179  return ALIGN_DOWN(target->working_area_size, 4);
2180 
2181  while (c) {
2182  if (c->free && max_size < c->size)
2183  max_size = c->size;
2184 
2185  c = c->next;
2186  }
2187 
2188  return max_size;
2189 }
2190 
2191 static void target_destroy(struct target *target)
2192 {
2195 
2196  if (target->type->deinit_target)
2198 
2199  if (target->semihosting)
2202 
2204 
2205  struct target_event_action *teap, *temp;
2207  list_del(&teap->list);
2208  Jim_DecrRefCount(teap->interp, teap->body);
2209  free(teap);
2210  }
2211 
2213 
2214  /* release the targets SMP list */
2215  if (target->smp) {
2216  struct target_list *head, *tmp;
2217 
2219  list_del(&head->lh);
2220  head->target->smp = 0;
2221  free(head);
2222  }
2223  if (target->smp_targets != &empty_smp_targets)
2224  free(target->smp_targets);
2225  target->smp = 0;
2226  }
2227 
2229 
2230  free(target->gdb_port_override);
2231  free(target->type);
2232  free(target->trace_info);
2233  free(target->fileio_info);
2234  free(target->cmd_name);
2235  free(target);
2236 }
2237 
2238 void target_quit(void)
2239 {
2241  while (pe) {
2242  struct target_event_callback *t = pe->next;
2243  free(pe);
2244  pe = t;
2245  }
2247 
2249  while (pt) {
2250  struct target_timer_callback *t = pt->next;
2251  free(pt);
2252  pt = t;
2253  }
2255 
2256  for (struct target *target = all_targets; target;) {
2257  struct target *tmp;
2258 
2259  tmp = target->next;
2261  target = tmp;
2262  }
2263 
2264  all_targets = NULL;
2265 }
2266 
2268 {
2269  int retval;
2270  if (!target) {
2271  LOG_WARNING("No target has been configured");
2272  return ERROR_OK;
2273  }
2274 
2275  if (target->state != TARGET_HALTED)
2276  return ERROR_OK;
2277 
2278  retval = target->type->arch_state(target);
2279  return retval;
2280 }
2281 
2283  struct gdb_fileio_info *fileio_info)
2284 {
2285  /* If target does not support semi-hosting function, target
2286  has no need to provide .get_gdb_fileio_info callback.
2287  It just return ERROR_FAIL and gdb_server will return "Txx"
2288  as target halted every time. */
2289  return ERROR_FAIL;
2290 }
2291 
2293  int retcode, int fileio_errno, bool ctrl_c)
2294 {
2295  return ERROR_OK;
2296 }
2297 
2298 int target_profiling_default(struct target *target, uint32_t *samples,
2299  uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
2300 {
2301  struct timeval timeout, now;
2302 
2304  timeval_add_time(&timeout, seconds, 0);
2305 
2306  LOG_INFO("Starting profiling. Halting and resuming the"
2307  " target as often as we can...");
2308 
2309  uint32_t sample_count = 0;
2310  /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
2311  struct reg *reg = register_get_by_name(target->reg_cache, "pc", true);
2312 
2313  int retval = ERROR_OK;
2314  for (;;) {
2316  if (target->state == TARGET_HALTED) {
2317  uint32_t t = buf_get_u32(reg->value, 0, 32);
2318  samples[sample_count++] = t;
2319  /* current pc, addr = 0, do not handle breakpoints, not debugging */
2320  retval = target_resume(target, true, 0, false, false);
2322  alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
2323  } else if (target->state == TARGET_RUNNING) {
2324  /* We want to quickly sample the PC. */
2325  retval = target_halt(target);
2326  } else {
2327  LOG_INFO("Target not halted or running");
2328  retval = ERROR_OK;
2329  break;
2330  }
2331 
2332  if (retval != ERROR_OK)
2333  break;
2334 
2335  gettimeofday(&now, NULL);
2336  if ((sample_count >= max_num_samples) || timeval_compare(&now, &timeout) >= 0) {
2337  LOG_INFO("Profiling completed. %" PRIu32 " samples.", sample_count);
2338  break;
2339  }
2340  }
2341 
2342  *num_samples = sample_count;
2343  return retval;
2344 }
2345 
2346 /* Single aligned words are guaranteed to use 16 or 32 bit access
2347  * mode respectively, otherwise data is handled as quickly as
2348  * possible
2349  */
2350 int target_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
2351 {
2352  LOG_DEBUG("writing buffer of %" PRIu32 " byte at " TARGET_ADDR_FMT,
2353  size, address);
2354 
2355  if (!target_was_examined(target)) {
2356  LOG_ERROR("Target not examined yet");
2357  return ERROR_FAIL;
2358  }
2359 
2360  if (size == 0)
2361  return ERROR_OK;
2362 
2363  if ((address + size - 1) < address) {
2364  /* GDB can request this when e.g. PC is 0xfffffffc */
2365  LOG_ERROR("address + size wrapped (" TARGET_ADDR_FMT ", 0x%08" PRIx32 ")",
2366  address,
2367  size);
2368  return ERROR_FAIL;
2369  }
2370 
2372 }
2373 
2375  target_addr_t address, uint32_t count, const uint8_t *buffer)
2376 {
2377  uint32_t size;
2378  unsigned int data_bytes = target_data_bits(target) / 8;
2379 
2380  /* Align up to maximum bytes. The loop condition makes sure the next pass
2381  * will have something to do with the size we leave to it. */
2382  for (size = 1;
2383  size < data_bytes && count >= size * 2 + (address & size);
2384  size *= 2) {
2385  if (address & size) {
2386  int retval = target_write_memory(target, address, size, 1, buffer);
2387  if (retval != ERROR_OK)
2388  return retval;
2389  address += size;
2390  count -= size;
2391  buffer += size;
2392  }
2393  }
2394 
2395  /* Write the data with as large access size as possible. */
2396  for (; size > 0; size /= 2) {
2397  uint32_t aligned = count - count % size;
2398  if (aligned > 0) {
2399  int retval = target_write_memory(target, address, size, aligned / size, buffer);
2400  if (retval != ERROR_OK)
2401  return retval;
2402  address += aligned;
2403  count -= aligned;
2404  buffer += aligned;
2405  }
2406  }
2407 
2408  return ERROR_OK;
2409 }
2410 
2411 /* Single aligned words are guaranteed to use 16 or 32 bit access
2412  * mode respectively, otherwise data is handled as quickly as
2413  * possible
2414  */
2416 {
2417  LOG_DEBUG("reading buffer of %" PRIu32 " byte at " TARGET_ADDR_FMT,
2418  size, address);
2419 
2420  if (!target_was_examined(target)) {
2421  LOG_ERROR("Target not examined yet");
2422  return ERROR_FAIL;
2423  }
2424 
2425  if (size == 0)
2426  return ERROR_OK;
2427 
2428  if ((address + size - 1) < address) {
2429  /* GDB can request this when e.g. PC is 0xfffffffc */
2430  LOG_ERROR("address + size wrapped (" TARGET_ADDR_FMT ", 0x%08" PRIx32 ")",
2431  address,
2432  size);
2433  return ERROR_FAIL;
2434  }
2435 
2437 }
2438 
2440 {
2441  uint32_t size;
2442  unsigned int data_bytes = target_data_bits(target) / 8;
2443 
2444  /* Align up to maximum bytes. The loop condition makes sure the next pass
2445  * will have something to do with the size we leave to it. */
2446  for (size = 1;
2447  size < data_bytes && count >= size * 2 + (address & size);
2448  size *= 2) {
2449  if (address & size) {
2450  int retval = target_read_memory(target, address, size, 1, buffer);
2451  if (retval != ERROR_OK)
2452  return retval;
2453  address += size;
2454  count -= size;
2455  buffer += size;
2456  }
2457  }
2458 
2459  /* Read the data with as large access size as possible. */
2460  for (; size > 0; size /= 2) {
2461  uint32_t aligned = count - count % size;
2462  if (aligned > 0) {
2463  int retval = target_read_memory(target, address, size, aligned / size, buffer);
2464  if (retval != ERROR_OK)
2465  return retval;
2466  address += aligned;
2467  count -= aligned;
2468  buffer += aligned;
2469  }
2470  }
2471 
2472  return ERROR_OK;
2473 }
2474 
2475 int target_checksum_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t *crc)
2476 {
2477  uint8_t *buffer;
2478  int retval;
2479  uint32_t i;
2480  uint32_t checksum = 0;
2481  if (!target_was_examined(target)) {
2482  LOG_ERROR("Target not examined yet");
2483  return ERROR_FAIL;
2484  }
2485  if (!target->type->checksum_memory) {
2486  LOG_ERROR("Target %s doesn't support checksum_memory", target_name(target));
2487  return ERROR_FAIL;
2488  }
2489 
2490  retval = target->type->checksum_memory(target, address, size, &checksum);
2491  if (retval != ERROR_OK) {
2492  buffer = malloc(size);
2493  if (!buffer) {
2494  LOG_ERROR("error allocating buffer for section (%" PRIu32 " bytes)", size);
2496  }
2498  if (retval != ERROR_OK) {
2499  free(buffer);
2500  return retval;
2501  }
2502 
2503  /* convert to target endianness */
2504  for (i = 0; i < (size/sizeof(uint32_t)); i++) {
2505  uint32_t target_data;
2506  target_data = target_buffer_get_u32(target, &buffer[i*sizeof(uint32_t)]);
2507  target_buffer_set_u32(target, &buffer[i*sizeof(uint32_t)], target_data);
2508  }
2509 
2510  retval = image_calculate_checksum(buffer, size, &checksum);
2511  free(buffer);
2512  }
2513 
2514  *crc = checksum;
2515 
2516  return retval;
2517 }
2518 
2520  struct target_memory_check_block *blocks, int num_blocks,
2521  uint8_t erased_value)
2522 {
2523  if (!target_was_examined(target)) {
2524  LOG_ERROR("Target not examined yet");
2525  return ERROR_FAIL;
2526  }
2527 
2529  return ERROR_NOT_IMPLEMENTED;
2530 
2531  return target->type->blank_check_memory(target, blocks, num_blocks, erased_value);
2532 }
2533 
2535 {
2536  uint8_t value_buf[8];
2537  if (!target_was_examined(target)) {
2538  LOG_ERROR("Target not examined yet");
2539  return ERROR_FAIL;
2540  }
2541 
2542  int retval = target_read_memory(target, address, 8, 1, value_buf);
2543 
2544  if (retval == ERROR_OK) {
2545  *value = target_buffer_get_u64(target, value_buf);
2546  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%16.16" PRIx64 "",
2547  address,
2548  *value);
2549  } else {
2550  *value = 0x0;
2551  LOG_DEBUG("address: " TARGET_ADDR_FMT " failed",
2552  address);
2553  }
2554 
2555  return retval;
2556 }
2557 
2559 {
2560  uint8_t value_buf[4];
2561  if (!target_was_examined(target)) {
2562  LOG_ERROR("Target not examined yet");
2563  return ERROR_FAIL;
2564  }
2565 
2566  int retval = target_read_memory(target, address, 4, 1, value_buf);
2567 
2568  if (retval == ERROR_OK) {
2569  *value = target_buffer_get_u32(target, value_buf);
2570  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%8.8" PRIx32 "",
2571  address,
2572  *value);
2573  } else {
2574  *value = 0x0;
2575  LOG_DEBUG("address: " TARGET_ADDR_FMT " failed",
2576  address);
2577  }
2578 
2579  return retval;
2580 }
2581 
2583 {
2584  uint8_t value_buf[2];
2585  if (!target_was_examined(target)) {
2586  LOG_ERROR("Target not examined yet");
2587  return ERROR_FAIL;
2588  }
2589 
2590  int retval = target_read_memory(target, address, 2, 1, value_buf);
2591 
2592  if (retval == ERROR_OK) {
2593  *value = target_buffer_get_u16(target, value_buf);
2594  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%4.4" PRIx16,
2595  address,
2596  *value);
2597  } else {
2598  *value = 0x0;
2599  LOG_DEBUG("address: " TARGET_ADDR_FMT " failed",
2600  address);
2601  }
2602 
2603  return retval;
2604 }
2605 
2607 {
2608  if (!target_was_examined(target)) {
2609  LOG_ERROR("Target not examined yet");
2610  return ERROR_FAIL;
2611  }
2612 
2613  int retval = target_read_memory(target, address, 1, 1, value);
2614 
2615  if (retval == ERROR_OK) {
2616  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%2.2" PRIx8,
2617  address,
2618  *value);
2619  } else {
2620  *value = 0x0;
2621  LOG_DEBUG("address: " TARGET_ADDR_FMT " failed",
2622  address);
2623  }
2624 
2625  return retval;
2626 }
2627 
2629 {
2630  int retval;
2631  uint8_t value_buf[8];
2632  if (!target_was_examined(target)) {
2633  LOG_ERROR("Target not examined yet");
2634  return ERROR_FAIL;
2635  }
2636 
2637  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%16.16" PRIx64 "",
2638  address,
2639  value);
2640 
2641  target_buffer_set_u64(target, value_buf, value);
2642  retval = target_write_memory(target, address, 8, 1, value_buf);
2643  if (retval != ERROR_OK)
2644  LOG_DEBUG("failed: %i", retval);
2645 
2646  return retval;
2647 }
2648 
2650 {
2651  int retval;
2652  uint8_t value_buf[4];
2653  if (!target_was_examined(target)) {
2654  LOG_ERROR("Target not examined yet");
2655  return ERROR_FAIL;
2656  }
2657 
2658  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%8.8" PRIx32 "",
2659  address,
2660  value);
2661 
2662  target_buffer_set_u32(target, value_buf, value);
2663  retval = target_write_memory(target, address, 4, 1, value_buf);
2664  if (retval != ERROR_OK)
2665  LOG_DEBUG("failed: %i", retval);
2666 
2667  return retval;
2668 }
2669 
2671 {
2672  int retval;
2673  uint8_t value_buf[2];
2674  if (!target_was_examined(target)) {
2675  LOG_ERROR("Target not examined yet");
2676  return ERROR_FAIL;
2677  }
2678 
2679  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%8.8" PRIx16,
2680  address,
2681  value);
2682 
2683  target_buffer_set_u16(target, value_buf, value);
2684  retval = target_write_memory(target, address, 2, 1, value_buf);
2685  if (retval != ERROR_OK)
2686  LOG_DEBUG("failed: %i", retval);
2687 
2688  return retval;
2689 }
2690 
2692 {
2693  int retval;
2694  if (!target_was_examined(target)) {
2695  LOG_ERROR("Target not examined yet");
2696  return ERROR_FAIL;
2697  }
2698 
2699  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%2.2" PRIx8,
2700  address, value);
2701 
2702  retval = target_write_memory(target, address, 1, 1, &value);
2703  if (retval != ERROR_OK)
2704  LOG_DEBUG("failed: %i", retval);
2705 
2706  return retval;
2707 }
2708 
2710 {
2711  int retval;
2712  uint8_t value_buf[8];
2713  if (!target_was_examined(target)) {
2714  LOG_ERROR("Target not examined yet");
2715  return ERROR_FAIL;
2716  }
2717 
2718  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%16.16" PRIx64 "",
2719  address,
2720  value);
2721 
2722  target_buffer_set_u64(target, value_buf, value);
2723  retval = target_write_phys_memory(target, address, 8, 1, value_buf);
2724  if (retval != ERROR_OK)
2725  LOG_DEBUG("failed: %i", retval);
2726 
2727  return retval;
2728 }
2729 
2731 {
2732  int retval;
2733  uint8_t value_buf[4];
2734  if (!target_was_examined(target)) {
2735  LOG_ERROR("Target not examined yet");
2736  return ERROR_FAIL;
2737  }
2738 
2739  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%8.8" PRIx32 "",
2740  address,
2741  value);
2742 
2743  target_buffer_set_u32(target, value_buf, value);
2744  retval = target_write_phys_memory(target, address, 4, 1, value_buf);
2745  if (retval != ERROR_OK)
2746  LOG_DEBUG("failed: %i", retval);
2747 
2748  return retval;
2749 }
2750 
2752 {
2753  int retval;
2754  uint8_t value_buf[2];
2755  if (!target_was_examined(target)) {
2756  LOG_ERROR("Target not examined yet");
2757  return ERROR_FAIL;
2758  }
2759 
2760  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%8.8" PRIx16,
2761  address,
2762  value);
2763 
2764  target_buffer_set_u16(target, value_buf, value);
2765  retval = target_write_phys_memory(target, address, 2, 1, value_buf);
2766  if (retval != ERROR_OK)
2767  LOG_DEBUG("failed: %i", retval);
2768 
2769  return retval;
2770 }
2771 
2773 {
2774  int retval;
2775  if (!target_was_examined(target)) {
2776  LOG_ERROR("Target not examined yet");
2777  return ERROR_FAIL;
2778  }
2779 
2780  LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%2.2" PRIx8,
2781  address, value);
2782 
2783  retval = target_write_phys_memory(target, address, 1, 1, &value);
2784  if (retval != ERROR_OK)
2785  LOG_DEBUG("failed: %i", retval);
2786 
2787  return retval;
2788 }
2789 
2790 static int find_target(struct command_invocation *cmd, const char *name)
2791 {
2792  struct target *target = get_target(name);
2793  if (!target) {
2794  command_print(cmd, "Target: %s is unknown, try one of:\n", name);
2795  return ERROR_FAIL;
2796  }
2797  if (!target->tap->enabled) {
2798  command_print(cmd, "Target: TAP %s is disabled, "
2799  "can't be the current target\n",
2800  target->tap->dotted_name);
2801  return ERROR_FAIL;
2802  }
2803 
2804  cmd->ctx->current_target = target;
2805  if (cmd->ctx->current_target_override)
2806  cmd->ctx->current_target_override = target;
2807 
2808  return ERROR_OK;
2809 }
2810 
2811 
2812 COMMAND_HANDLER(handle_targets_command)
2813 {
2814  int retval = ERROR_OK;
2815  if (CMD_ARGC == 1) {
2816  retval = find_target(CMD, CMD_ARGV[0]);
2817  if (retval == ERROR_OK) {
2818  /* we're done! */
2819  return retval;
2820  }
2821  }
2822 
2823  unsigned int index = 0;
2824  command_print(CMD, " TargetName Type Endian TapName State ");
2825  command_print(CMD, "-- ------------------ ---------- ------ ------------------ ------------");
2826  for (struct target *target = all_targets; target; target = target->next, ++index) {
2827  const char *state;
2828  char marker = ' ';
2829 
2830  if (target->tap->enabled)
2832  else
2833  state = "tap-disabled";
2834 
2835  if (CMD_CTX->current_target == target)
2836  marker = '*';
2837 
2838  /* keep columns lined up to match the headers above */
2840  "%2d%c %-18s %-10s %-6s %-18s %s",
2841  index,
2842  marker,
2847  state);
2848  }
2849 
2850  return retval;
2851 }
2852 
2853 /* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
2854 
2855 static int power_dropout;
2856 static int srst_asserted;
2857 
2862 
2863 static int sense_handler(void)
2864 {
2865  static int prev_srst_asserted;
2866  static int prev_power_dropout;
2867 
2868  int retval = jtag_power_dropout(&power_dropout);
2869  if (retval != ERROR_OK)
2870  return retval;
2871 
2872  int power_restored;
2873  power_restored = prev_power_dropout && !power_dropout;
2874  if (power_restored)
2875  run_power_restore = 1;
2876 
2877  int64_t current = timeval_ms();
2878  static int64_t last_power;
2879  bool wait_more = last_power + 2000 > current;
2880  if (power_dropout && !wait_more) {
2881  run_power_dropout = 1;
2882  last_power = current;
2883  }
2884 
2885  retval = jtag_srst_asserted(&srst_asserted);
2886  if (retval != ERROR_OK)
2887  return retval;
2888 
2889  int srst_deasserted;
2890  srst_deasserted = prev_srst_asserted && !srst_asserted;
2891 
2892  static int64_t last_srst;
2893  wait_more = last_srst + 2000 > current;
2894  if (srst_deasserted && !wait_more) {
2895  run_srst_deasserted = 1;
2896  last_srst = current;
2897  }
2898 
2899  if (!prev_srst_asserted && srst_asserted)
2900  run_srst_asserted = 1;
2901 
2902  prev_srst_asserted = srst_asserted;
2903  prev_power_dropout = power_dropout;
2904 
2905  if (srst_deasserted || power_restored) {
2906  /* Other than logging the event we can't do anything here.
2907  * Issuing a reset is a particularly bad idea as we might
2908  * be inside a reset already.
2909  */
2910  }
2911 
2912  return ERROR_OK;
2913 }
2914 
2915 /* process target state changes */
2916 static int handle_target(void *priv)
2917 {
2918  Jim_Interp *interp = (Jim_Interp *)priv;
2919  int retval = ERROR_OK;
2920 
2921  if (!is_jtag_poll_safe()) {
2922  /* polling is disabled currently */
2923  return ERROR_OK;
2924  }
2925 
2926  /* we do not want to recurse here... */
2927  static int recursive;
2928  if (!recursive) {
2929  recursive = 1;
2930  sense_handler();
2931  /* danger! running these procedures can trigger srst assertions and power dropouts.
2932  * We need to avoid an infinite loop/recursion here and we do that by
2933  * clearing the flags after running these events.
2934  */
2935  int did_something = 0;
2936  if (run_srst_asserted) {
2937  LOG_INFO("srst asserted detected, running srst_asserted proc.");
2938  Jim_Eval(interp, "srst_asserted");
2939  did_something = 1;
2940  }
2941  if (run_srst_deasserted) {
2942  Jim_Eval(interp, "srst_deasserted");
2943  did_something = 1;
2944  }
2945  if (run_power_dropout) {
2946  LOG_INFO("Power dropout detected, running power_dropout proc.");
2947  Jim_Eval(interp, "power_dropout");
2948  did_something = 1;
2949  }
2950  if (run_power_restore) {
2951  Jim_Eval(interp, "power_restore");
2952  did_something = 1;
2953  }
2954 
2955  if (did_something) {
2956  /* clear detect flags */
2957  sense_handler();
2958  }
2959 
2960  /* clear action flags */
2961 
2962  run_srst_asserted = 0;
2963  run_srst_deasserted = 0;
2964  run_power_restore = 0;
2965  run_power_dropout = 0;
2966 
2967  recursive = 0;
2968  }
2969 
2970  /* Poll targets for state changes unless that's globally disabled.
2971  * Skip targets that are currently disabled.
2972  */
2973  for (struct target *target = all_targets;
2975  target = target->next) {
2976 
2978  continue;
2979 
2980  if (!target->tap->enabled)
2981  continue;
2982 
2983  if (target->backoff.times > target->backoff.count) {
2984  /* do not poll this time as we failed previously */
2985  target->backoff.count++;
2986  continue;
2987  }
2988  target->backoff.count = 0;
2989 
2990  /* only poll target if we've got power and srst isn't asserted */
2991  if (!power_dropout && !srst_asserted) {
2992  /* polling may fail silently until the target has been examined */
2993  retval = target_poll(target);
2994  if (retval != ERROR_OK) {
2995  /* 100ms polling interval. Increase interval between polling up to 5000ms */
2996  if (target->backoff.times * polling_interval < 5000) {
2997  target->backoff.times *= 2;
2998  target->backoff.times++;
2999  }
3000 
3001  /* Tell GDB to halt the debugger. This allows the user to
3002  * run monitor commands to handle the situation.
3003  */
3005  }
3006  if (target->backoff.times > 0) {
3007  LOG_TARGET_ERROR(target, "Polling failed, trying to reexamine");
3009  retval = target_examine_one(target);
3010  /* Target examination could have failed due to unstable connection,
3011  * but we set the examined flag anyway to repoll it later */
3012  if (retval != ERROR_OK) {
3014  LOG_TARGET_ERROR(target, "Examination failed, GDB will be halted. Polling again in %dms",
3016  return retval;
3017  }
3018  }
3019 
3020  /* Since we succeeded, we reset backoff count */
3021  target->backoff.times = 0;
3022  }
3023  }
3024 
3025  return retval;
3026 }
3027 
3028 COMMAND_HANDLER(handle_reg_command)
3029 {
3030  LOG_DEBUG("-");
3031 
3033  if (!target_was_examined(target)) {
3034  LOG_ERROR("Target not examined yet");
3036  }
3037  struct reg *reg = NULL;
3038 
3039  /* list all available registers for the current target */
3040  if (CMD_ARGC == 0) {
3041  struct reg_cache *cache = target->reg_cache;
3042 
3043  unsigned int count = 0;
3044  while (cache) {
3045  unsigned int i;
3046 
3047  command_print(CMD, "===== %s", cache->name);
3048 
3049  for (i = 0, reg = cache->reg_list;
3050  i < cache->num_regs;
3051  i++, reg++, count++) {
3052  if (!reg->exist || reg->hidden)
3053  continue;
3054  /* only print cached values if they are valid */
3055  if (reg->valid) {
3056  char *value = buf_to_hex_str(reg->value,
3057  reg->size);
3059  "(%i) %s (/%" PRIu32 "): 0x%s%s",
3060  count, reg->name,
3061  reg->size, value,
3062  reg->dirty
3063  ? " (dirty)"
3064  : "");
3065  free(value);
3066  } else {
3067  command_print(CMD, "(%i) %s (/%" PRIu32 ")",
3068  count, reg->name,
3069  reg->size);
3070  }
3071  }
3072  cache = cache->next;
3073  }
3074 
3075  return ERROR_OK;
3076  }
3077 
3078  /* access a single register by its ordinal number */
3079  if ((CMD_ARGV[0][0] >= '0') && (CMD_ARGV[0][0] <= '9')) {
3080  unsigned int num;
3081  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
3082 
3083  struct reg_cache *cache = target->reg_cache;
3084  unsigned int count = 0;
3085  while (cache) {
3086  unsigned int i;
3087  for (i = 0; i < cache->num_regs; i++) {
3088  if (count++ == num) {
3089  reg = &cache->reg_list[i];
3090  break;
3091  }
3092  }
3093  if (reg)
3094  break;
3095  cache = cache->next;
3096  }
3097 
3098  if (!reg) {
3099  command_print(CMD, "%i is out of bounds, the current target "
3100  "has only %i registers (0 - %i)", num, count, count - 1);
3101  return ERROR_FAIL;
3102  }
3103  } else {
3104  /* access a single register by its name */
3106 
3107  if (!reg)
3108  goto not_found;
3109  }
3110 
3111  assert(reg); /* give clang a hint that we *know* reg is != NULL here */
3112 
3113  if (!reg->exist)
3114  goto not_found;
3115 
3116  /* display a register */
3117  if ((CMD_ARGC == 1) || ((CMD_ARGC == 2) && !((CMD_ARGV[1][0] >= '0')
3118  && (CMD_ARGV[1][0] <= '9')))) {
3119  if ((CMD_ARGC == 2) && (strcmp(CMD_ARGV[1], "force") == 0))
3120  reg->valid = false;
3121 
3122  if (!reg->valid) {
3123  int retval = reg->type->get(reg);
3124  if (retval != ERROR_OK) {
3125  LOG_ERROR("Could not read register '%s'", reg->name);
3126  return retval;
3127  }
3128  }
3129  char *value = buf_to_hex_str(reg->value, reg->size);
3130  command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
3131  free(value);
3132  return ERROR_OK;
3133  }
3134 
3135  /* set register value */
3136  if (CMD_ARGC == 2) {
3137  uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8));
3138  if (!buf) {
3139  LOG_ERROR("Failed to allocate memory");
3140  return ERROR_FAIL;
3141  }
3142 
3143  int retval = CALL_COMMAND_HANDLER(command_parse_str_to_buf, CMD_ARGV[1], buf, reg->size);
3144  if (retval != ERROR_OK) {
3145  free(buf);
3146  return retval;
3147  }
3148 
3149  retval = reg->type->set(reg, buf);
3150  if (retval != ERROR_OK) {
3151  LOG_ERROR("Could not write to register '%s'", reg->name);
3152  } else {
3153  char *value = buf_to_hex_str(reg->value, reg->size);
3154  command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
3155  free(value);
3156  }
3157 
3158  free(buf);
3159 
3160  return retval;
3161  }
3162 
3164 
3165 not_found:
3166  command_print(CMD, "register %s not found in current target", CMD_ARGV[0]);
3167  return ERROR_FAIL;
3168 }
3169 
3170 COMMAND_HANDLER(handle_poll_command)
3171 {
3172  int retval = ERROR_OK;
3174 
3175  if (CMD_ARGC == 0) {
3176  command_print(CMD, "background polling: %s",
3177  jtag_poll_get_enabled() ? "on" : "off");
3178  command_print(CMD, "TAP: %s (%s)",
3180  target->tap->enabled ? "enabled" : "disabled");
3181  if (!target->tap->enabled)
3182  return ERROR_OK;
3183  retval = target_poll(target);
3184  if (retval != ERROR_OK)
3185  return retval;
3186  retval = target_arch_state(target);
3187  if (retval != ERROR_OK)
3188  return retval;
3189  } else if (CMD_ARGC == 1) {
3190  bool enable;
3191  COMMAND_PARSE_ON_OFF(CMD_ARGV[0], enable);
3192  jtag_poll_set_enabled(enable);
3193  } else
3195 
3196  return retval;
3197 }
3198 
3199 COMMAND_HANDLER(handle_wait_halt_command)
3200 {
3201  if (CMD_ARGC > 1)
3203 
3204  unsigned int ms = DEFAULT_HALT_TIMEOUT;
3205  if (1 == CMD_ARGC) {
3206  int retval = parse_uint(CMD_ARGV[0], &ms);
3207  if (retval != ERROR_OK)
3209  }
3210 
3212  return target_wait_state(target, TARGET_HALTED, ms);
3213 }
3214 
3215 /* wait for target state to change. The trick here is to have a low
3216  * latency for short waits and not to suck up all the CPU time
3217  * on longer waits.
3218  *
3219  * After 500ms, keep_alive() is invoked
3220  */
3221 int target_wait_state(struct target *target, enum target_state state, unsigned int ms)
3222 {
3223  int retval;
3224  int64_t then = 0, cur;
3225  bool once = true;
3226 
3227  for (;;) {
3228  retval = target_poll(target);
3229  if (retval != ERROR_OK)
3230  return retval;
3231  if (target->state == state)
3232  break;
3233  cur = timeval_ms();
3234  if (once) {
3235  once = false;
3236  then = timeval_ms();
3237  LOG_DEBUG("waiting for target %s...",
3239  }
3240 
3241  if (cur - then > 500) {
3242  keep_alive();
3244  return ERROR_SERVER_INTERRUPTED;
3245  }
3246 
3247  if ((cur-then) > ms) {
3248  LOG_ERROR("timed out while waiting for target %s",
3250  return ERROR_FAIL;
3251  }
3252  }
3253 
3254  return ERROR_OK;
3255 }
3256 
3257 COMMAND_HANDLER(handle_halt_command)
3258 {
3259  LOG_DEBUG("-");
3260 
3262 
3263  target->verbose_halt_msg = true;
3264 
3265  int retval = target_halt(target);
3266  if (retval != ERROR_OK)
3267  return retval;
3268 
3269  if (CMD_ARGC == 1) {
3270  unsigned int wait_local;
3271  retval = parse_uint(CMD_ARGV[0], &wait_local);
3272  if (retval != ERROR_OK)
3274  if (!wait_local)
3275  return ERROR_OK;
3276  }
3277 
3278  return CALL_COMMAND_HANDLER(handle_wait_halt_command);
3279 }
3280 
3281 COMMAND_HANDLER(handle_soft_reset_halt_command)
3282 {
3284 
3285  LOG_TARGET_INFO(target, "requesting target halt and executing a soft reset");
3286 
3288 
3289  return ERROR_OK;
3290 }
3291 
3292 COMMAND_HANDLER(handle_reset_command)
3293 {
3294  if (CMD_ARGC > 1)
3296 
3297  enum target_reset_mode reset_mode = RESET_RUN;
3298  if (CMD_ARGC == 1) {
3299  const struct nvp *n;
3301  if ((!n->name) || (n->value == RESET_UNKNOWN))
3303  reset_mode = n->value;
3304  }
3305 
3306  /* reset *all* targets */
3307  return target_process_reset(CMD, reset_mode);
3308 }
3309 
3310 
3311 COMMAND_HANDLER(handle_resume_command)
3312 {
3313  bool current = true;
3314  if (CMD_ARGC > 1)
3316 
3318 
3319  /* with no CMD_ARGV, resume from current pc, addr = 0,
3320  * with one arguments, addr = CMD_ARGV[0],
3321  * handle breakpoints, not debugging */
3322  target_addr_t addr = 0;
3323  if (CMD_ARGC == 1) {
3325  current = false;
3326  }
3327 
3328  return target_resume(target, current, addr, true, false);
3329 }
3330 
3331 COMMAND_HANDLER(handle_step_command)
3332 {
3333  if (CMD_ARGC > 1)
3335 
3336  LOG_DEBUG("-");
3337 
3338  /* with no CMD_ARGV, step from current pc, addr = 0,
3339  * with one argument addr = CMD_ARGV[0],
3340  * handle breakpoints, debugging */
3341  target_addr_t addr = 0;
3342  int current_pc = 1;
3343  if (CMD_ARGC == 1) {
3345  current_pc = 0;
3346  }
3347 
3349 
3350  return target_step(target, current_pc, addr, true);
3351 }
3352 
3354  struct target *target, target_addr_t address, unsigned int size,
3355  unsigned int count, const uint8_t *buffer)
3356 {
3357  const unsigned int line_bytecnt = 32;
3358  unsigned int line_modulo = line_bytecnt / size;
3359 
3360  char output[line_bytecnt * 4 + 1];
3361  unsigned int output_len = 0;
3362 
3363  const char *value_fmt;
3364  switch (size) {
3365  case 8:
3366  value_fmt = "%16.16"PRIx64" ";
3367  break;
3368  case 4:
3369  value_fmt = "%8.8"PRIx64" ";
3370  break;
3371  case 2:
3372  value_fmt = "%4.4"PRIx64" ";
3373  break;
3374  case 1:
3375  value_fmt = "%2.2"PRIx64" ";
3376  break;
3377  default:
3378  /* "can't happen", caller checked */
3379  LOG_ERROR("invalid memory read size: %u", size);
3380  return;
3381  }
3382 
3383  for (unsigned int i = 0; i < count; i++) {
3384  if (i % line_modulo == 0) {
3385  output_len += snprintf(output + output_len,
3386  sizeof(output) - output_len,
3387  TARGET_ADDR_FMT ": ",
3388  (address + (i * size)));
3389  }
3390 
3391  uint64_t value = 0;
3392  const uint8_t *value_ptr = buffer + i * size;
3393  switch (size) {
3394  case 8:
3395  value = target_buffer_get_u64(target, value_ptr);
3396  break;
3397  case 4:
3398  value = target_buffer_get_u32(target, value_ptr);
3399  break;
3400  case 2:
3401  value = target_buffer_get_u16(target, value_ptr);
3402  break;
3403  case 1:
3404  value = *value_ptr;
3405  }
3406  output_len += snprintf(output + output_len,
3407  sizeof(output) - output_len,
3408  value_fmt, value);
3409 
3410  if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
3411  command_print(cmd, "%s", output);
3412  output_len = 0;
3413  }
3414  }
3415 }
3416 
3417 COMMAND_HANDLER(handle_md_command)
3418 {
3419  if (CMD_ARGC < 1)
3421 
3422  unsigned int size = 0;
3423  switch (CMD_NAME[2]) {
3424  case 'd':
3425  size = 8;
3426  break;
3427  case 'w':
3428  size = 4;
3429  break;
3430  case 'h':
3431  size = 2;
3432  break;
3433  case 'b':
3434  size = 1;
3435  break;
3436  default:
3438  }
3439 
3440  bool physical = strcmp(CMD_ARGV[0], "phys") == 0;
3441  int (*fn)(struct target *target,
3442  target_addr_t address, uint32_t size_value, uint32_t count, uint8_t *buffer);
3443  if (physical) {
3444  CMD_ARGC--;
3445  CMD_ARGV++;
3447  } else
3448  fn = target_read_memory;
3449  if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
3451 
3454 
3455  unsigned int count = 1;
3456  if (CMD_ARGC == 2)
3457  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], count);
3458 
3459  uint8_t *buffer = calloc(count, size);
3460  if (!buffer) {
3461  LOG_ERROR("Failed to allocate md read buffer");
3462  return ERROR_FAIL;
3463  }
3464 
3466  int retval = fn(target, address, size, count, buffer);
3467  if (retval == ERROR_OK)
3469 
3470  free(buffer);
3471 
3472  return retval;
3473 }
3474 
3475 typedef int (*target_write_fn)(struct target *target,
3476  target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
3477 
3478 static int target_fill_mem(struct target *target,
3480  target_write_fn fn,
3481  unsigned int data_size,
3482  /* value */
3483  uint64_t b,
3484  /* count */
3485  unsigned int c)
3486 {
3487  /* We have to write in reasonably large chunks to be able
3488  * to fill large memory areas with any sane speed */
3489  const unsigned int chunk_size = 16384;
3490  uint8_t *target_buf = malloc(chunk_size * data_size);
3491  if (!target_buf) {
3492  LOG_ERROR("Out of memory");
3493  return ERROR_FAIL;
3494  }
3495 
3496  for (unsigned int i = 0; i < chunk_size; i++) {
3497  switch (data_size) {
3498  case 8:
3499  target_buffer_set_u64(target, target_buf + i * data_size, b);
3500  break;
3501  case 4:
3502  target_buffer_set_u32(target, target_buf + i * data_size, b);
3503  break;
3504  case 2:
3505  target_buffer_set_u16(target, target_buf + i * data_size, b);
3506  break;
3507  case 1:
3508  target_buffer_set_u8(target, target_buf + i * data_size, b);
3509  break;
3510  default:
3511  exit(-1);
3512  }
3513  }
3514 
3515  int retval = ERROR_OK;
3516 
3517  for (unsigned int x = 0; x < c; x += chunk_size) {
3518  unsigned int current;
3519  current = c - x;
3520  if (current > chunk_size)
3521  current = chunk_size;
3522  retval = fn(target, address + x * data_size, data_size, current, target_buf);
3523  if (retval != ERROR_OK)
3524  break;
3525  /* avoid GDB timeouts */
3526  keep_alive();
3527 
3529  retval = ERROR_SERVER_INTERRUPTED;
3530  break;
3531  }
3532  }
3533  free(target_buf);
3534 
3535  return retval;
3536 }
3537 
3538 
3539 COMMAND_HANDLER(handle_mw_command)
3540 {
3541  if (CMD_ARGC < 2)
3543  bool physical = strcmp(CMD_ARGV[0], "phys") == 0;
3544  target_write_fn fn;
3545  if (physical) {
3546  CMD_ARGC--;
3547  CMD_ARGV++;
3549  } else
3550  fn = target_write_memory;
3551  if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
3553 
3556 
3557  uint64_t value;
3558  COMMAND_PARSE_NUMBER(u64, CMD_ARGV[1], value);
3559 
3560  unsigned int count = 1;
3561  if (CMD_ARGC == 3)
3562  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[2], count);
3563 
3565  unsigned int wordsize;
3566  switch (CMD_NAME[2]) {
3567  case 'd':
3568  wordsize = 8;
3569  break;
3570  case 'w':
3571  wordsize = 4;
3572  break;
3573  case 'h':
3574  wordsize = 2;
3575  break;
3576  case 'b':
3577  wordsize = 1;
3578  break;
3579  default:
3581  }
3582 
3583  return target_fill_mem(target, address, fn, wordsize, value, count);
3584 }
3585 
3586 static COMMAND_HELPER(parse_load_image_command, struct image *image,
3587  target_addr_t *min_address, target_addr_t *max_address)
3588 {
3589  if (CMD_ARGC < 1 || CMD_ARGC > 5)
3591 
3592  /* a base address isn't always necessary,
3593  * default to 0x0 (i.e. don't relocate) */
3594  if (CMD_ARGC >= 2) {
3597  image->base_address = addr;
3598  image->base_address_set = true;
3599  } else
3600  image->base_address_set = false;
3601 
3602  image->start_address_set = false;
3603 
3604  if (CMD_ARGC >= 4)
3605  COMMAND_PARSE_ADDRESS(CMD_ARGV[3], *min_address);
3606  if (CMD_ARGC == 5) {
3607  COMMAND_PARSE_ADDRESS(CMD_ARGV[4], *max_address);
3608  /* use size (given) to find max (required) */
3609  *max_address += *min_address;
3610  }
3611 
3612  if (*min_address > *max_address)
3614 
3615  return ERROR_OK;
3616 }
3617 
3618 COMMAND_HANDLER(handle_load_image_command)
3619 {
3620  uint8_t *buffer;
3621  size_t buf_cnt;
3622  uint32_t image_size;
3623  target_addr_t min_address = 0;
3624  target_addr_t max_address = -1;
3625  struct image image;
3626 
3627  int retval = CALL_COMMAND_HANDLER(parse_load_image_command,
3628  &image, &min_address, &max_address);
3629  if (retval != ERROR_OK)
3630  return retval;
3631 
3633 
3634  struct duration bench;
3635  duration_start(&bench);
3636 
3637  if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
3638  return ERROR_FAIL;
3639 
3640  image_size = 0x0;
3641  retval = ERROR_OK;
3642  for (unsigned int i = 0; i < image.num_sections; i++) {
3643  buffer = malloc(image.sections[i].size);
3644  if (!buffer) {
3646  "error allocating buffer for section (%d bytes)",
3647  (int)(image.sections[i].size));
3648  retval = ERROR_FAIL;
3649  break;
3650  }
3651 
3652  retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt);
3653  if (retval != ERROR_OK) {
3654  free(buffer);
3655  break;
3656  }
3657 
3658  uint32_t offset = 0;
3659  uint32_t length = buf_cnt;
3660 
3661  /* DANGER!!! beware of unsigned comparison here!!! */
3662 
3663  if ((image.sections[i].base_address + buf_cnt >= min_address) &&
3664  (image.sections[i].base_address < max_address)) {
3665 
3666  if (image.sections[i].base_address < min_address) {
3667  /* clip addresses below */
3668  offset += min_address-image.sections[i].base_address;
3669  length -= offset;
3670  }
3671 
3672  if (image.sections[i].base_address + buf_cnt > max_address)
3673  length -= (image.sections[i].base_address + buf_cnt)-max_address;
3674 
3675  retval = target_write_buffer(target,
3677  if (retval != ERROR_OK) {
3678  free(buffer);
3679  break;
3680  }
3681  image_size += length;
3682  command_print(CMD, "%u bytes written at address " TARGET_ADDR_FMT "",
3683  (unsigned int)length,
3685  }
3686 
3687  free(buffer);
3688  }
3689 
3690  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
3691  command_print(CMD, "downloaded %" PRIu32 " bytes "
3692  "in %fs (%0.3f KiB/s)", image_size,
3693  duration_elapsed(&bench), duration_kbps(&bench, image_size));
3694  }
3695 
3696  image_close(&image);
3697 
3698  return retval;
3699 
3700 }
3701 
3702 COMMAND_HANDLER(handle_dump_image_command)
3703 {
3704  struct fileio *fileio;
3705  uint8_t *buffer;
3706  int retval, retvaltemp;
3708  struct duration bench;
3710 
3711  if (CMD_ARGC != 3)
3713 
3716 
3717  uint32_t buf_size = (size > 4096) ? 4096 : size;
3718  buffer = malloc(buf_size);
3719  if (!buffer)
3720  return ERROR_FAIL;
3721 
3723  if (retval != ERROR_OK) {
3724  free(buffer);
3725  return retval;
3726  }
3727 
3728  duration_start(&bench);
3729 
3730  while (size > 0) {
3731  size_t size_written;
3732  uint32_t this_run_size = (size > buf_size) ? buf_size : size;
3733  retval = target_read_buffer(target, address, this_run_size, buffer);
3734  if (retval != ERROR_OK)
3735  break;
3736 
3737  retval = fileio_write(fileio, this_run_size, buffer, &size_written);
3738  if (retval != ERROR_OK)
3739  break;
3740 
3741  size -= this_run_size;
3742  address += this_run_size;
3743  }
3744 
3745  free(buffer);
3746 
3747  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
3748  size_t filesize;
3749  retval = fileio_size(fileio, &filesize);
3750  if (retval != ERROR_OK)
3751  return retval;
3753  "dumped %zu bytes in %fs (%0.3f KiB/s)", filesize,
3754  duration_elapsed(&bench), duration_kbps(&bench, filesize));
3755  }
3756 
3757  retvaltemp = fileio_close(fileio);
3758  if (retvaltemp != ERROR_OK)
3759  return retvaltemp;
3760 
3761  return retval;
3762 }
3763 
3768 };
3769 
3770 static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode verify)
3771 {
3772  uint8_t *buffer;
3773  size_t buf_cnt;
3774  uint32_t image_size;
3775  int retval;
3776  uint32_t checksum = 0;
3777  uint32_t mem_checksum = 0;
3778 
3779  struct image image;
3780 
3782 
3783  if (CMD_ARGC < 1)
3785 
3786  if (!target) {
3787  LOG_ERROR("no target selected");
3788  return ERROR_FAIL;
3789  }
3790 
3791  struct duration bench;
3792  duration_start(&bench);
3793 
3794  if (CMD_ARGC >= 2) {
3798  image.base_address_set = true;
3799  } else {
3800  image.base_address_set = false;
3801  image.base_address = 0x0;
3802  }
3803 
3804  image.start_address_set = false;
3805 
3806  retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
3807  if (retval != ERROR_OK)
3808  return retval;
3809 
3810  image_size = 0x0;
3811  int diffs = 0;
3812  retval = ERROR_OK;
3813  for (unsigned int i = 0; i < image.num_sections; i++) {
3814  buffer = malloc(image.sections[i].size);
3815  if (!buffer) {
3817  "error allocating buffer for section (%" PRIu32 " bytes)",
3818  image.sections[i].size);
3819  break;
3820  }
3821  retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt);
3822  if (retval != ERROR_OK) {
3823  free(buffer);
3824  break;
3825  }
3826 
3827  if (verify >= IMAGE_VERIFY) {
3828  /* calculate checksum of image */
3829  retval = image_calculate_checksum(buffer, buf_cnt, &checksum);
3830  if (retval != ERROR_OK) {
3831  free(buffer);
3832  break;
3833  }
3834 
3835  retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
3836  if (retval != ERROR_OK) {
3837  free(buffer);
3838  break;
3839  }
3840  if ((checksum != mem_checksum) && (verify == IMAGE_CHECKSUM_ONLY)) {
3841  LOG_ERROR("checksum mismatch");
3842  free(buffer);
3843  retval = ERROR_FAIL;
3844  goto done;
3845  }
3846  if (checksum != mem_checksum) {
3847  /* failed crc checksum, fall back to a binary compare */
3848  uint8_t *data;
3849 
3850  if (diffs == 0)
3851  LOG_ERROR("checksum mismatch - attempting binary compare");
3852 
3853  data = malloc(buf_cnt);
3854 
3855  retval = target_read_buffer(target, image.sections[i].base_address, buf_cnt, data);
3856  if (retval == ERROR_OK) {
3857  uint32_t t;
3858  for (t = 0; t < buf_cnt; t++) {
3859  if (data[t] != buffer[t]) {
3861  "diff %d address " TARGET_ADDR_FMT ". Was 0x%02" PRIx8 " instead of 0x%02" PRIx8,
3862  diffs,
3863  t + image.sections[i].base_address,
3864  data[t],
3865  buffer[t]);
3866  if (diffs++ >= 127) {
3867  command_print(CMD, "More than 128 errors, the rest are not printed.");
3868  free(data);
3869  free(buffer);
3870  goto done;
3871  }
3872  }
3873  keep_alive();
3875  retval = ERROR_SERVER_INTERRUPTED;
3876  free(data);
3877  free(buffer);
3878  goto done;
3879  }
3880  }
3881  }
3882  free(data);
3883  }
3884  } else {
3885  command_print(CMD, "address " TARGET_ADDR_FMT " length 0x%08zx",
3887  buf_cnt);
3888  }
3889 
3890  free(buffer);
3891  image_size += buf_cnt;
3892  }
3893  if (diffs > 0)
3894  command_print(CMD, "No more differences found.");
3895 done:
3896  if (diffs > 0)
3897  retval = ERROR_FAIL;
3898  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
3899  command_print(CMD, "verified %" PRIu32 " bytes "
3900  "in %fs (%0.3f KiB/s)", image_size,
3901  duration_elapsed(&bench), duration_kbps(&bench, image_size));
3902  }
3903 
3904  image_close(&image);
3905 
3906  return retval;
3907 }
3908 
3909 COMMAND_HANDLER(handle_verify_image_checksum_command)
3910 {
3911  return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, IMAGE_CHECKSUM_ONLY);
3912 }
3913 
3914 COMMAND_HANDLER(handle_verify_image_command)
3915 {
3916  return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, IMAGE_VERIFY);
3917 }
3918 
3919 COMMAND_HANDLER(handle_test_image_command)
3920 {
3921  return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, IMAGE_TEST);
3922 }
3923 
3925 {
3926  struct target *target = get_current_target(cmd->ctx);
3928  while (breakpoint) {
3929  if (breakpoint->type == BKPT_SOFT) {
3930  char *buf = buf_to_hex_str(breakpoint->orig_instr,
3931  breakpoint->length * 8);
3932  command_print(cmd, "Software breakpoint(IVA): addr=" TARGET_ADDR_FMT ", len=0x%x, orig_instr=0x%s",
3934  breakpoint->length,
3935  buf);
3936  free(buf);
3937  } else {
3938  if ((breakpoint->address == 0) && (breakpoint->asid != 0))
3939  command_print(cmd, "Context breakpoint: asid=0x%8.8" PRIx32 ", len=0x%x, num=%u",
3940  breakpoint->asid,
3942  else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
3943  command_print(cmd, "Hybrid breakpoint(IVA): addr=" TARGET_ADDR_FMT ", len=0x%x, num=%u",
3946  command_print(cmd, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
3947  breakpoint->asid);
3948  } else
3949  command_print(cmd, "Hardware breakpoint(IVA): addr=" TARGET_ADDR_FMT ", len=0x%x, num=%u",
3952  }
3953 
3955  }
3956  return ERROR_OK;
3957 }
3958 
3960  target_addr_t addr, uint32_t asid, unsigned int length, int hw)
3961 {
3962  struct target *target = get_current_target(cmd->ctx);
3963  int retval;
3964 
3965  if (asid == 0) {
3966  retval = breakpoint_add(target, addr, length, hw);
3967  /* error is always logged in breakpoint_add(), do not print it again */
3968  if (retval == ERROR_OK)
3969  command_print(cmd, "breakpoint set at " TARGET_ADDR_FMT "", addr);
3970 
3971  } else if (addr == 0) {
3973  LOG_TARGET_ERROR(target, "Context breakpoint not available");
3975  }
3976  retval = context_breakpoint_add(target, asid, length, hw);
3977  /* error is always logged in context_breakpoint_add(), do not print it again */
3978  if (retval == ERROR_OK)
3979  command_print(cmd, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
3980 
3981  } else {
3983  LOG_TARGET_ERROR(target, "Hybrid breakpoint not available");
3985  }
3986  retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
3987  /* error is always logged in hybrid_breakpoint_add(), do not print it again */
3988  if (retval == ERROR_OK)
3989  command_print(cmd, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
3990  }
3991  return retval;
3992 }
3993 
3994 COMMAND_HANDLER(handle_bp_command)
3995 {
3997  uint32_t asid;
3998  uint32_t length;
3999  int hw = BKPT_SOFT;
4000 
4001  switch (CMD_ARGC) {
4002  case 0:
4003  return handle_bp_command_list(CMD);
4004 
4005  case 2:
4006  asid = 0;
4009  return handle_bp_command_set(CMD, addr, asid, length, hw);
4010 
4011  case 3:
4012  if (strcmp(CMD_ARGV[2], "hw") == 0) {
4013  hw = BKPT_HARD;
4016  asid = 0;
4017  return handle_bp_command_set(CMD, addr, asid, length, hw);
4018  } else if (strcmp(CMD_ARGV[2], "hw_ctx") == 0) {
4019  hw = BKPT_HARD;
4020  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], asid);
4022  addr = 0;
4023  return handle_bp_command_set(CMD, addr, asid, length, hw);
4024  }
4025  /* fallthrough */
4026  case 4:
4027  hw = BKPT_HARD;
4029  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], asid);
4031  return handle_bp_command_set(CMD, addr, asid, length, hw);
4032 
4033  default:
4035  }
4036 }
4037 
4038 COMMAND_HANDLER(handle_rbp_command)
4039 {
4040  int retval;
4041 
4042  if (CMD_ARGC != 1)
4044 
4046 
4047  if (!strcmp(CMD_ARGV[0], "all")) {
4048  retval = breakpoint_remove_all(target);
4049 
4050  if (retval != ERROR_OK) {
4051  command_print(CMD, "Error encountered during removal of all breakpoints.");
4052  command_print(CMD, "Some breakpoints may have remained set.");
4053  }
4054  } else {
4057 
4058  retval = breakpoint_remove(target, addr);
4059 
4060  if (retval != ERROR_OK)
4061  command_print(CMD, "Error during removal of breakpoint at address " TARGET_ADDR_FMT, addr);
4062  }
4063 
4064  return retval;
4065 }
4066 
4067 COMMAND_HANDLER(handle_wp_command)
4068 {
4070 
4071  if (CMD_ARGC == 0) {
4073 
4074  while (watchpoint) {
4075  char wp_type = (watchpoint->rw == WPT_READ ? 'r' : (watchpoint->rw == WPT_WRITE ? 'w' : 'a'));
4076  command_print(CMD, "address: " TARGET_ADDR_FMT
4077  ", len: 0x%8.8x"
4078  ", r/w/a: %c, value: 0x%8.8" PRIx64
4079  ", mask: 0x%8.8" PRIx64,
4081  watchpoint->length,
4082  wp_type,
4083  watchpoint->value,
4084  watchpoint->mask);
4086  }
4087  return ERROR_OK;
4088  }
4089 
4090  enum watchpoint_rw type = WPT_ACCESS;
4091  target_addr_t addr = 0;
4092  uint32_t length = 0;
4093  uint64_t data_value = 0x0;
4094  uint64_t data_mask = WATCHPOINT_IGNORE_DATA_VALUE_MASK;
4095  bool mask_specified = false;
4096 
4097  switch (CMD_ARGC) {
4098  case 5:
4099  COMMAND_PARSE_NUMBER(u64, CMD_ARGV[4], data_mask);
4100  mask_specified = true;
4101  /* fall through */
4102  case 4:
4103  COMMAND_PARSE_NUMBER(u64, CMD_ARGV[3], data_value);
4104  // if user specified only data value without mask - the mask should be 0
4105  if (!mask_specified)
4106  data_mask = 0;
4107  /* fall through */
4108  case 3:
4109  switch (CMD_ARGV[2][0]) {
4110  case 'r':
4111  type = WPT_READ;
4112  break;
4113  case 'w':
4114  type = WPT_WRITE;
4115  break;
4116  case 'a':
4117  type = WPT_ACCESS;
4118  break;
4119  default:
4120  LOG_TARGET_ERROR(target, "invalid watchpoint mode ('%c')", CMD_ARGV[2][0]);
4122  }
4123  /* fall through */
4124  case 2:
4127  break;
4128 
4129  default:
4131  }
4132 
4133  int retval = watchpoint_add(target, addr, length, type,
4134  data_value, data_mask);
4135  if (retval != ERROR_OK)
4136  LOG_TARGET_ERROR(target, "Failure setting watchpoints");
4137 
4138  return retval;
4139 }
4140 
4141 COMMAND_HANDLER(handle_rwp_command)
4142 {
4143  int retval;
4144 
4145  if (CMD_ARGC != 1)
4147 
4149  if (!strcmp(CMD_ARGV[0], "all")) {
4150  retval = watchpoint_remove_all(target);
4151 
4152  if (retval != ERROR_OK) {
4153  command_print(CMD, "Error encountered during removal of all watchpoints.");
4154  command_print(CMD, "Some watchpoints may have remained set.");
4155  }
4156  } else {
4159 
4160  retval = watchpoint_remove(target, addr);
4161 
4162  if (retval != ERROR_OK)
4163  command_print(CMD, "Error during removal of watchpoint at address " TARGET_ADDR_FMT, addr);
4164  }
4165 
4166  return retval;
4167 }
4168 
4175 COMMAND_HANDLER(handle_virt2phys_command)
4176 {
4177  if (CMD_ARGC != 1)
4179 
4180  target_addr_t va;
4182  target_addr_t pa;
4183 
4185  int retval = target->type->virt2phys(target, va, &pa);
4186  if (retval == ERROR_OK)
4187  command_print(CMD, "Physical address " TARGET_ADDR_FMT "", pa);
4188 
4189  return retval;
4190 }
4191 
4192 static void write_data(FILE *f, const void *data, size_t len)
4193 {
4194  size_t written = fwrite(data, 1, len, f);
4195  if (written != len)
4196  LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
4197 }
4198 
4199 static void write_long(FILE *f, int l, struct target *target)
4200 {
4201  uint8_t val[4];
4202 
4203  target_buffer_set_u32(target, val, l);
4204  write_data(f, val, 4);
4205 }
4206 
4207 static void write_string(FILE *f, char *s)
4208 {
4209  write_data(f, s, strlen(s));
4210 }
4211 
4212 typedef unsigned char UNIT[2]; /* unit of profiling */
4213 
4214 /* Dump a gmon.out histogram file. */
4215 static void write_gmon(uint32_t *samples, uint32_t sample_num, const char *filename, bool with_range,
4216  uint32_t start_address, uint32_t end_address, struct target *target, uint32_t duration_ms)
4217 {
4218  uint32_t i;
4219  FILE *f = fopen(filename, "wb");
4220  if (!f)
4221  return;
4222  write_string(f, "gmon");
4223  write_long(f, 0x00000001, target); /* Version */
4224  write_long(f, 0, target); /* padding */
4225  write_long(f, 0, target); /* padding */
4226  write_long(f, 0, target); /* padding */
4227 
4228  uint8_t zero = 0; /* GMON_TAG_TIME_HIST */
4229  write_data(f, &zero, 1);
4230 
4231  /* figure out bucket size */
4232  uint32_t min;
4233  uint32_t max;
4234  if (with_range) {
4235  min = start_address;
4236  max = end_address;
4237  } else {
4238  min = samples[0];
4239  max = samples[0];
4240  for (i = 0; i < sample_num; i++) {
4241  if (min > samples[i])
4242  min = samples[i];
4243  if (max < samples[i])
4244  max = samples[i];
4245  }
4246 
4247  /* max should be (largest sample + 1)
4248  * Refer to binutils/gprof/hist.c (find_histogram_for_pc) */
4249  if (max < UINT32_MAX)
4250  max++;
4251 
4252  /* gprof requires (max - min) >= 2 */
4253  while ((max - min) < 2) {
4254  if (max < UINT32_MAX)
4255  max++;
4256  else
4257  min--;
4258  }
4259  }
4260 
4261  uint32_t address_space = max - min;
4262 
4263  /* FIXME: What is the reasonable number of buckets?
4264  * The profiling result will be more accurate if there are enough buckets. */
4265  static const uint32_t max_buckets = 128 * 1024; /* maximum buckets. */
4266  uint32_t num_buckets = address_space / sizeof(UNIT);
4267  if (num_buckets > max_buckets)
4268  num_buckets = max_buckets;
4269  int *buckets = malloc(sizeof(int) * num_buckets);
4270  if (!buckets) {
4271  fclose(f);
4272  return;
4273  }
4274  memset(buckets, 0, sizeof(int) * num_buckets);
4275  for (i = 0; i < sample_num; i++) {
4276  uint32_t address = samples[i];
4277 
4278  if ((address < min) || (max <= address))
4279  continue;
4280 
4281  long long a = address - min;
4282  long long b = num_buckets;
4283  long long c = address_space;
4284  int index_t = (a * b) / c; /* danger!!!! int32 overflows */
4285  buckets[index_t]++;
4286  }
4287 
4288  /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
4289  write_long(f, min, target); /* low_pc */
4290  write_long(f, max, target); /* high_pc */
4291  write_long(f, num_buckets, target); /* # of buckets */
4292  float sample_rate = sample_num / (duration_ms / 1000.0);
4293  write_long(f, sample_rate, target);
4294  write_string(f, "seconds");
4295  for (i = 0; i < (15-strlen("seconds")); i++)
4296  write_data(f, &zero, 1);
4297  write_string(f, "s");
4298 
4299  /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
4300 
4301  char *data = malloc(2 * num_buckets);
4302  if (data) {
4303  for (i = 0; i < num_buckets; i++) {
4304  int val;
4305  val = buckets[i];
4306  if (val > 65535)
4307  val = 65535;
4308  data[i * 2] = val&0xff;
4309  data[i * 2 + 1] = (val >> 8) & 0xff;
4310  }
4311  free(buckets);
4312  write_data(f, data, num_buckets * 2);
4313  free(data);
4314  } else
4315  free(buckets);
4316 
4317  fclose(f);
4318 }
4319 
4320 /* profiling samples the CPU PC as quickly as OpenOCD is able,
4321  * which will be used as a random sampling of PC */
4322 COMMAND_HANDLER(handle_profile_command)
4323 {
4325 
4326  if ((CMD_ARGC != 2) && (CMD_ARGC != 4))
4328 
4329  const uint32_t MAX_PROFILE_SAMPLE_NUM = 1000000;
4330  uint32_t offset;
4331  uint32_t num_of_samples;
4332  int retval = ERROR_OK;
4333  bool halted_before_profiling = target->state == TARGET_HALTED;
4334 
4336 
4337  uint32_t start_address = 0;
4338  uint32_t end_address = 0;
4339  bool with_range = false;
4340  if (CMD_ARGC == 4) {
4341  with_range = true;
4342  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], start_address);
4343  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], end_address);
4344  if (start_address > end_address || (end_address - start_address) < 2) {
4345  command_print(CMD, "Error: end - start < 2");
4347  }
4348  }
4349 
4350  uint32_t *samples = malloc(sizeof(uint32_t) * MAX_PROFILE_SAMPLE_NUM);
4351  if (!samples) {
4352  LOG_ERROR("No memory to store samples.");
4353  return ERROR_FAIL;
4354  }
4355 
4356  uint64_t timestart_ms = timeval_ms();
4362  retval = target_profiling(target, samples, MAX_PROFILE_SAMPLE_NUM,
4363  &num_of_samples, offset);
4364  if (retval != ERROR_OK) {
4365  free(samples);
4366  return retval;
4367  }
4368  uint32_t duration_ms = timeval_ms() - timestart_ms;
4369 
4370  assert(num_of_samples <= MAX_PROFILE_SAMPLE_NUM);
4371 
4372  retval = target_poll(target);
4373  if (retval != ERROR_OK) {
4374  free(samples);
4375  return retval;
4376  }
4377 
4378  if (target->state == TARGET_RUNNING && halted_before_profiling) {
4379  /* The target was halted before we started and is running now. Halt it,
4380  * for consistency. */
4381  retval = target_halt(target);
4382  if (retval != ERROR_OK) {
4383  free(samples);
4384  return retval;
4385  }
4386  } else if (target->state == TARGET_HALTED && !halted_before_profiling) {
4387  /* The target was running before we started and is halted now. Resume
4388  * it, for consistency. */
4389  retval = target_resume(target, true, 0, false, false);
4390  if (retval != ERROR_OK) {
4391  free(samples);
4392  return retval;
4393  }
4394  }
4395 
4396  retval = target_poll(target);
4397  if (retval != ERROR_OK) {
4398  free(samples);
4399  return retval;
4400  }
4401 
4402  write_gmon(samples, num_of_samples, CMD_ARGV[1],
4403  with_range, start_address, end_address, target, duration_ms);
4404  command_print(CMD, "Wrote %s", CMD_ARGV[1]);
4405 
4406  free(samples);
4407  return retval;
4408 }
4409 
4410 COMMAND_HANDLER(handle_target_read_memory)
4411 {
4412  /*
4413  * CMD_ARGV[0] = memory address
4414  * CMD_ARGV[1] = desired element width in bits
4415  * CMD_ARGV[2] = number of elements to read
4416  * CMD_ARGV[3] = optional "phys"
4417  */
4418 
4419  if (CMD_ARGC < 3 || CMD_ARGC > 4)
4421 
4422  /* Arg 1: Memory address. */
4425 
4426  /* Arg 2: Bit width of one element. */
4427  unsigned int width_bits;
4428  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], width_bits);
4429 
4430  /* Arg 3: Number of elements to read. */
4431  unsigned int count;
4432  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[2], count);
4433 
4434  /* Arg 4: Optional 'phys'. */
4435  bool is_phys = false;
4436  if (CMD_ARGC == 4) {
4437  if (strcmp(CMD_ARGV[3], "phys")) {
4438  command_print(CMD, "invalid argument '%s', must be 'phys'", CMD_ARGV[3]);
4440  }
4441 
4442  is_phys = true;
4443  }
4444 
4445  switch (width_bits) {
4446  case 8:
4447  case 16:
4448  case 32:
4449  case 64:
4450  break;
4451  default:
4452  command_print(CMD, "invalid width, must be 8, 16, 32 or 64");
4454  }
4455 
4456  if (count > 65536) {
4457  command_print(CMD, "too large read request, exceeds 64K elements");
4459  }
4460 
4461  const unsigned int width = width_bits / 8;
4462  /* -1 is needed to handle cases when (addr + count * width) results in zero
4463  * due to overflow.
4464  */
4465  if ((addr + count * width - 1) < addr) {
4466  command_print(CMD, "memory region wraps over address zero");
4468  }
4469 
4471 
4472  const size_t buffersize = 4096;
4473  uint8_t *buffer = malloc(buffersize);
4474 
4475  if (!buffer) {
4476  LOG_ERROR("Failed to allocate memory");
4477  return ERROR_FAIL;
4478  }
4479 
4480  char *separator = "";
4481  while (count > 0) {
4482  const unsigned int max_chunk_len = buffersize / width;
4483  const size_t chunk_len = MIN(count, max_chunk_len);
4484 
4485  int retval;
4486 
4487  if (is_phys)
4488  retval = target_read_phys_memory(target, addr, width, chunk_len, buffer);
4489  else
4490  retval = target_read_memory(target, addr, width, chunk_len, buffer);
4491 
4492  if (retval != ERROR_OK) {
4493  LOG_DEBUG("read at " TARGET_ADDR_FMT " with width=%u and count=%zu failed",
4494  addr, width_bits, chunk_len);
4495  /*
4496  * FIXME: we append the errmsg to the list of value already read.
4497  * Add a way to flush and replace old output, but LOG_DEBUG() it
4498  */
4499  command_print(CMD, "failed to read memory");
4500  free(buffer);
4501  return retval;
4502  }
4503 
4504  for (size_t i = 0; i < chunk_len ; i++) {
4505  uint64_t v = 0;
4506 
4507  switch (width) {
4508  case 8:
4510  break;
4511  case 4:
4513  break;
4514  case 2:
4516  break;
4517  case 1:
4518  v = buffer[i];
4519  break;
4520  }
4521 
4522  command_print_sameline(CMD, "%s0x%" PRIx64, separator, v);
4523  separator = " ";
4524  }
4525 
4526  count -= chunk_len;
4527  addr += chunk_len * width;
4528  }
4529 
4530  free(buffer);
4531 
4532  return ERROR_OK;
4533 }
4534 
4535 COMMAND_HANDLER(handle_target_write_memory)
4536 {
4537  /*
4538  * CMD_ARGV[0] = memory address
4539  * CMD_ARGV[1] = desired element width in bits
4540  * CMD_ARGV[2] = list of data to write
4541  * CMD_ARGV[3] = optional "phys"
4542  */
4543 
4544  if (CMD_ARGC < 3 || CMD_ARGC > 4)
4546 
4547  /* Arg 1: Memory address. */
4550 
4551  /* Arg 2: Bit width of one element. */
4552  unsigned int width_bits;
4553  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], width_bits);
4554 
4555  /* Arg 3: Elements to write. */
4556  size_t count = Jim_ListLength(CMD_CTX->interp, CMD_JIMTCL_ARGV[2]);
4557 
4558  /* Arg 4: Optional 'phys'. */
4559  bool is_phys = false;
4560 
4561  if (CMD_ARGC == 4) {
4562  if (strcmp(CMD_ARGV[3], "phys")) {
4563  command_print(CMD, "invalid argument '%s', must be 'phys'", CMD_ARGV[3]);
4565  }
4566 
4567  is_phys = true;
4568  }
4569 
4570  switch (width_bits) {
4571  case 8:
4572  case 16:
4573  case 32:
4574  case 64:
4575  break;
4576  default:
4577  command_print(CMD, "invalid width, must be 8, 16, 32 or 64");
4579  }
4580 
4581  if (count > 65536) {
4582  command_print(CMD, "too large memory write request, exceeds 64K elements");
4584  }
4585 
4586  const unsigned int width = width_bits / 8;
4587  /* -1 is needed to handle cases when (addr + count * width) results in zero
4588  * due to overflow.
4589  */
4590  if ((addr + count * width - 1) < addr) {
4591  command_print(CMD, "memory region wraps over address zero");
4593  }
4594 
4596 
4597  const size_t buffersize = 4096;
4598  uint8_t *buffer = malloc(buffersize);
4599 
4600  if (!buffer) {
4601  LOG_ERROR("Failed to allocate memory");
4602  return ERROR_FAIL;
4603  }
4604 
4605  size_t j = 0;
4606 
4607  while (count > 0) {
4608  const unsigned int max_chunk_len = buffersize / width;
4609  const size_t chunk_len = MIN(count, max_chunk_len);
4610 
4611  for (size_t i = 0; i < chunk_len; i++, j++) {
4612  Jim_Obj *tmp = Jim_ListGetIndex(CMD_CTX->interp, CMD_JIMTCL_ARGV[2], j);
4613  jim_wide element_wide;
4614  int jimretval = Jim_GetWide(CMD_CTX->interp, tmp, &element_wide);
4615  if (jimretval != JIM_OK) {
4616  command_print(CMD, "invalid value \"%s\"", Jim_GetString(tmp, NULL));
4617  free(buffer);
4619  }
4620 
4621  const uint64_t v = element_wide;
4622 
4623  switch (width) {
4624  case 8:
4626  break;
4627  case 4:
4629  break;
4630  case 2:
4632  break;
4633  case 1:
4634  buffer[i] = v & 0x0ff;
4635  break;
4636  }
4637  }
4638 
4639  count -= chunk_len;
4640 
4641  int retval;
4642 
4643  if (is_phys)
4644  retval = target_write_phys_memory(target, addr, width, chunk_len, buffer);
4645  else
4646  retval = target_write_memory(target, addr, width, chunk_len, buffer);
4647 
4648  if (retval != ERROR_OK) {
4649  LOG_DEBUG("write at " TARGET_ADDR_FMT " with width=%u and count=%zu failed",
4650  addr, width_bits, chunk_len);
4651  command_print(CMD, "failed to write memory");
4652  free(buffer);
4653  return retval;
4654  }
4655 
4656  addr += chunk_len * width;
4657  }
4658 
4659  free(buffer);
4660 
4661  return ERROR_OK;
4662 }
4663 
4664 /* FIX? should we propagate errors here rather than printing them
4665  * and continuing?
4666  */
4668 {
4669  struct target_event_action *teap;
4670  int retval;
4671 
4673  if (teap->event == e) {
4674  LOG_DEBUG("target: %s (%s) event: %d (%s) action: %s",
4677  e,
4678  target_event_name(e),
4679  Jim_GetString(teap->body, NULL));
4680 
4681  /* Override current target by the target an event
4682  * is issued from (lot of scripts need it).
4683  * Return back to previous override as soon
4684  * as the handler processing is done */
4685  struct command_context *cmd_ctx = current_command_context(teap->interp);
4686  struct target *saved_target_override = cmd_ctx->current_target_override;
4687  cmd_ctx->current_target_override = target;
4688 
4689  retval = Jim_EvalObj(teap->interp, teap->body);
4690 
4691  cmd_ctx->current_target_override = saved_target_override;
4692 
4693  if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
4694  return;
4695 
4696  if (retval == JIM_RETURN)
4697  retval = teap->interp->returnCode;
4698 
4699  if (retval != JIM_OK) {
4700  Jim_MakeErrorMessage(teap->interp);
4701  LOG_TARGET_ERROR(target, "Execution of event %s failed:\n%s",
4702  target_event_name(e),
4703  Jim_GetString(Jim_GetResult(teap->interp), NULL));
4704  /* clean both error code and stacktrace before return */
4705  Jim_Eval(teap->interp, "error \"\" \"\"");
4706  }
4707  }
4708  }
4709 }
4710 
4711 COMMAND_HANDLER(handle_target_get_reg)
4712 {
4713  if (CMD_ARGC < 1 || CMD_ARGC > 2)
4715 
4716  bool force = false;
4717  Jim_Obj *next_argv = CMD_JIMTCL_ARGV[0];
4718 
4719  if (CMD_ARGC == 2) {
4720  if (strcmp(CMD_ARGV[0], "-force")) {
4721  command_print(CMD, "invalid argument '%s', must be '-force'", CMD_ARGV[0]);
4723  }
4724 
4725  force = true;
4726  next_argv = CMD_JIMTCL_ARGV[1];
4727  }
4728 
4729  const int length = Jim_ListLength(CMD_CTX->interp, next_argv);
4730 
4731  const struct target *target = get_current_target(CMD_CTX);
4732 
4733  for (int i = 0; i < length; i++) {
4734  Jim_Obj *elem = Jim_ListGetIndex(CMD_CTX->interp, next_argv, i);
4735 
4736  const char *reg_name = Jim_String(elem);
4737 
4738  struct reg *reg = register_get_by_name(target->reg_cache, reg_name, false);
4739 
4740  if (!reg || !reg->exist) {
4741  command_print(CMD, "unknown register '%s'", reg_name);
4743  }
4744 
4745  if (force || !reg->valid) {
4746  int retval = reg->type->get(reg);
4747 
4748  if (retval != ERROR_OK) {
4749  command_print(CMD, "failed to read register '%s'", reg_name);
4750  return retval;
4751  }
4752  }
4753 
4754  char *reg_value = buf_to_hex_str(reg->value, reg->size);
4755 
4756  if (!reg_value) {
4757  LOG_ERROR("Failed to allocate memory");
4758  return ERROR_FAIL;
4759  }
4760 
4761  command_print(CMD, "%s 0x%s", reg_name, reg_value);
4762 
4763  free(reg_value);
4764  }
4765 
4766  return ERROR_OK;
4767 }
4768 
4769 COMMAND_HANDLER(handle_set_reg_command)
4770 {
4771  if (CMD_ARGC != 1)
4773 
4774  int tmp;
4775 #if JIM_VERSION >= 80
4776  Jim_Obj **dict = Jim_DictPairs(CMD_CTX->interp, CMD_JIMTCL_ARGV[0], &tmp);
4777 
4778  if (!dict)
4779  return ERROR_FAIL;
4780 #else
4781  Jim_Obj **dict;
4782  int ret = Jim_DictPairs(CMD_CTX->interp, CMD_JIMTCL_ARGV[0], &dict, &tmp);
4783 
4784  if (ret != JIM_OK)
4785  return ERROR_FAIL;
4786 #endif
4787 
4788  const unsigned int length = tmp;
4789 
4790  const struct target *target = get_current_target(CMD_CTX);
4791  assert(target);
4792 
4793  for (unsigned int i = 0; i < length; i += 2) {
4794  const char *reg_name = Jim_String(dict[i]);
4795  const char *reg_value = Jim_String(dict[i + 1]);
4796  struct reg *reg = register_get_by_name(target->reg_cache, reg_name, false);
4797 
4798  if (!reg || !reg->exist) {
4799  command_print(CMD, "unknown register '%s'", reg_name);
4800  return ERROR_FAIL;
4801  }
4802 
4803  uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8));
4804  if (!buf) {
4805  LOG_ERROR("Failed to allocate memory");
4806  return ERROR_FAIL;
4807  }
4808 
4809  int retval = CALL_COMMAND_HANDLER(command_parse_str_to_buf, reg_value, buf, reg->size);
4810  if (retval != ERROR_OK) {
4811  free(buf);
4812  return retval;
4813  }
4814 
4815  retval = reg->type->set(reg, buf);
4816  free(buf);
4817 
4818  if (retval != ERROR_OK) {
4819  command_print(CMD, "failed to set '%s' to register '%s'",
4820  reg_value, reg_name);
4821  return retval;
4822  }
4823  }
4824 
4825  return ERROR_OK;
4826 }
4827 
4831 bool target_has_event_action(const struct target *target, enum target_event event)
4832 {
4833  struct target_event_action *teap;
4834 
4836  if (teap->event == event)
4837  return true;
4838  }
4839  return false;
4840 }
4841 
4857 };
4858 
4859 static struct nvp nvp_config_opts[] = {
4860  { .name = "-type", .value = TCFG_TYPE },
4861  { .name = "-event", .value = TCFG_EVENT },
4862  { .name = "-work-area-virt", .value = TCFG_WORK_AREA_VIRT },
4863  { .name = "-work-area-phys", .value = TCFG_WORK_AREA_PHYS },
4864  { .name = "-work-area-size", .value = TCFG_WORK_AREA_SIZE },
4865  { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
4866  { .name = "-endian", .value = TCFG_ENDIAN },
4867  { .name = "-coreid", .value = TCFG_COREID },
4868  { .name = "-chain-position", .value = TCFG_CHAIN_POSITION },
4869  { .name = "-dbgbase", .value = TCFG_DBGBASE },
4870  { .name = "-rtos", .value = TCFG_RTOS },
4871  { .name = "-defer-examine", .value = TCFG_DEFER_EXAMINE },
4872  { .name = "-gdb-port", .value = TCFG_GDB_PORT },
4873  { .name = "-gdb-max-connections", .value = TCFG_GDB_MAX_CONNECTIONS },
4874  { .name = NULL, .value = -1 }
4875 };
4876 
4877 static COMMAND_HELPER(target_configure, struct target *target, unsigned int index, bool is_configure)
4878 {
4879  const struct nvp *n;
4880  int retval;
4881 
4882  /* parse config or cget options ... */
4883  while (index < CMD_ARGC) {
4885  /* target defines a configure function */
4886  /* target gets first dibs on parameters */
4887  struct jim_getopt_info goi;
4888  jim_getopt_setup(&goi, CMD_CTX->interp, CMD_ARGC - index, CMD_JIMTCL_ARGV + index);
4889  goi.is_configure = is_configure;
4890  int e = (*target->type->target_jim_configure)(target, &goi);
4891  index = CMD_ARGC - goi.argc;
4892 
4893  int reslen;
4894  const char *result = Jim_GetString(Jim_GetResult(CMD_CTX->interp), &reslen);
4895  if (reslen > 0)
4896  command_print(CMD, "%s", result);
4897 
4898  if (e == JIM_OK) {
4899  /* more? */
4900  continue;
4901  }
4902  if (e == JIM_ERR) {
4903  /* An error */
4904  return ERROR_FAIL;
4905  }
4906  /* otherwise we 'continue' below */
4907  }
4909  if (!n->name) {
4912  }
4913  index++;
4914  switch (n->value) {
4915  case TCFG_TYPE:
4916  /* not settable */
4917  if (is_configure) {
4918  command_print(CMD, "not settable: %s", n->name);
4920  }
4921  if (index != CMD_ARGC)
4924  /* loop for more */
4925  break;
4926 
4927  case TCFG_EVENT:
4928  if (index == CMD_ARGC) {
4929  command_print(CMD, "expecting %s event-name event-body",
4930  CMD_ARGV[index - 1]);
4932  }
4933 
4935  if (!n->name) {
4938  }
4939  index++;
4940 
4941  if (is_configure) {
4942  if (index == CMD_ARGC) {
4943  command_print(CMD, "expecting %s %s event-body",
4944  CMD_ARGV[index - 2], CMD_ARGV[index - 1]);
4946  }
4947  }
4948 
4949  {
4950  struct target_event_action *teap;
4951 
4952  /* replace existing? */
4954  if (teap->event == (enum target_event)n->value)
4955  break;
4956 
4957  /* not found! */
4958  if (&teap->list == &target->events_action)
4959  teap = NULL;
4960 
4961  if (is_configure) {
4962  /* START_DEPRECATED_TPIU */
4963  if (n->value == TARGET_EVENT_TRACE_CONFIG)
4964  LOG_INFO("DEPRECATED target event %s; use TPIU events {pre,post}-{enable,disable}", n->name);
4965  /* END_DEPRECATED_TPIU */
4966 
4967  if (strlen(CMD_ARGV[index]) == 0) {
4968  /* empty action, drop existing one */
4969  if (teap) {
4970  list_del(&teap->list);
4971  Jim_DecrRefCount(teap->interp, teap->body);
4972  free(teap);
4973  }
4974  index++;
4975  break;
4976  }
4977 
4978  bool replace = true;
4979  if (!teap) {
4980  /* create new */
4981  teap = calloc(1, sizeof(*teap));
4982  replace = false;
4983  }
4984  teap->event = n->value;
4985  teap->interp = CMD_CTX->interp;
4986  if (teap->body)
4987  Jim_DecrRefCount(teap->interp, teap->body);
4988  /* use jim object to keep its reference on tcl file and line */
4989  /* TODO: need duplicate? isn't IncrRefCount enough? */
4990  teap->body = Jim_DuplicateObj(teap->interp, CMD_JIMTCL_ARGV[index++]);
4991  /*
4992  * FIXME:
4993  * Tcl/TK - "tk events" have a nice feature.
4994  * See the "BIND" command.
4995  * We should support that here.
4996  * You can specify %X and %Y in the event code.
4997  * The idea is: %T - target name.
4998  * The idea is: %N - target number
4999  * The idea is: %E - event name.
5000  */
5001  Jim_IncrRefCount(teap->body);
5002 
5003  if (!replace) {
5004  /* add to head of event list */
5005  list_add(&teap->list, &target->events_action);
5006  }
5007  } else {
5008  /* cget */
5009  if (index != CMD_ARGC)
5011 
5012  if (teap)
5013  command_print(CMD, "%s", Jim_GetString(teap->body, NULL));
5014  }
5015  }
5016  /* loop for more */
5017  break;
5018 
5019  case TCFG_WORK_AREA_VIRT:
5020  if (is_configure) {
5021  if (index == CMD_ARGC) {
5022  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5024  }
5026  index++;
5029  } else {
5030  if (index != CMD_ARGC)
5033  }
5034  /* loop for more */
5035  break;
5036 
5037  case TCFG_WORK_AREA_PHYS:
5038  if (is_configure) {
5039  if (index == CMD_ARGC) {
5040  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5042  }
5044  index++;
5047  } else {
5048  if (index != CMD_ARGC)
5051  }
5052  /* loop for more */
5053  break;
5054 
5055  case TCFG_WORK_AREA_SIZE:
5056  if (is_configure) {
5057  if (index == CMD_ARGC) {
5058  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5060  }
5062  index++;
5064  } else {
5065  if (index != CMD_ARGC)
5067  command_print(CMD, "0x%08" PRIx32, target->working_area_size);
5068  }
5069  /* loop for more */
5070  break;
5071 
5072  case TCFG_WORK_AREA_BACKUP:
5073  if (is_configure) {
5074  if (index == CMD_ARGC) {
5075  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5077  }
5079  if (retval != ERROR_OK)
5080  return retval;
5081  index++;
5083  } else {
5084  if (index != CMD_ARGC)
5087  }
5088  /* loop for more */
5089  break;
5090 
5091  case TCFG_ENDIAN:
5092  if (is_configure) {
5093  if (index == CMD_ARGC) {
5094  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5096  }
5098  if (!n->name) {
5101  }
5102  index++;
5103  target->endianness = n->value;
5104  } else {
5105  if (index != CMD_ARGC)
5108  if (!n->name) {
5111  }
5112  command_print(CMD, "%s", n->name);
5113  }
5114  /* loop for more */
5115  break;
5116 
5117  case TCFG_COREID:
5118  if (is_configure) {
5119  if (index == CMD_ARGC) {
5120  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5122  }
5123  COMMAND_PARSE_NUMBER(s32, CMD_ARGV[index], target->coreid);
5124  index++;
5125  } else {
5126  if (index != CMD_ARGC)
5128  command_print(CMD, "%" PRIi32, target->coreid);
5129  }
5130  /* loop for more */
5131  break;
5132 
5133  case TCFG_CHAIN_POSITION:
5134  if (is_configure) {
5135  if (target->has_dap) {
5136  command_print(CMD, "target requires -dap parameter instead of -chain-position!");
5138  }
5139 
5140  if (index == CMD_ARGC) {
5141  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5143  }
5144  struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[index]);
5145  if (!tap) {
5146  command_print(CMD, "Tap '%s' could not be found", CMD_ARGV[index]);
5148  }
5149  index++;
5150  target->tap = tap;
5151  target->tap_configured = true;
5152  } else {
5153  if (index != CMD_ARGC)
5156  }
5157  /* loop for more */
5158  break;
5159 
5160  case TCFG_DBGBASE:
5161  if (is_configure) {
5162  if (index == CMD_ARGC) {
5163  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5165  }
5167  index++;
5168  target->dbgbase_set = true;
5169  } else {
5170  if (index != CMD_ARGC)
5172  command_print(CMD, "0x%08" PRIx32, target->dbgbase);
5173  }
5174  /* loop for more */
5175  break;
5176 
5177  case TCFG_RTOS:
5178  if (is_configure) {
5179  if (index == CMD_ARGC) {
5180  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5182  }
5183  retval = rtos_create(CMD, target, CMD_ARGV[index]);
5184  if (retval != ERROR_OK)
5185  return retval;
5186  index++;
5187  } else {
5188  if (index != CMD_ARGC)
5190  if (target->rtos)
5191  command_print(CMD, "%s", target->rtos->type->name);
5192  }
5193  /* loop for more */
5194  break;
5195 
5196  case TCFG_DEFER_EXAMINE:
5197  if (is_configure)
5198  target->defer_examine = true;
5199  else
5200  command_print(CMD, "%s", target->defer_examine ? "true" : "false");
5201  /* loop for more */
5202  break;
5203 
5204  case TCFG_GDB_PORT:
5205  if (is_configure) {
5206  if (index == CMD_ARGC) {
5207  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5209  }
5210 
5211  /* TODO: generalize test of COMMAND_CONFIG */
5212  if (CMD_CTX->mode != COMMAND_CONFIG) {
5213  command_print(CMD, "-gdb-port must be configured before 'init'");
5215  }
5216 
5217  char *s = strdup(CMD_ARGV[index]);
5218  if (!s) {
5219  LOG_ERROR("Out of memory");
5220  return ERROR_FAIL;
5221  }
5222  free(target->gdb_port_override);
5224  index++;
5225  } else {
5226  if (index != CMD_ARGC)
5229  }
5230  /* loop for more */
5231  break;
5232 
5234  if (is_configure) {
5235  if (index == CMD_ARGC) {
5236  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5238  }
5239 
5240  if (CMD_CTX->mode != COMMAND_CONFIG) {
5241  command_print(CMD, "-gdb-max-connections must be configured before 'init'");
5243  }
5244 
5246  index++;
5247  if (target->gdb_max_connections < 0)
5249  } else {
5250  if (index != CMD_ARGC)
5253  }
5254  /* loop for more */
5255  break;
5256  }
5257  }
5258 
5259  return ERROR_OK;
5260 }
5261 
5262 COMMAND_HANDLER(handle_target_configure)
5263 {
5264  if (!CMD_ARGC)
5266 
5267  bool is_configure = !strcmp(CMD_NAME, "configure");
5268 
5270 
5271  return CALL_COMMAND_HANDLER(target_configure, target, 0, is_configure);
5272 }
5273 
5274 COMMAND_HANDLER(handle_target_examine)
5275 {
5276  bool allow_defer = false;
5277 
5278  if (CMD_ARGC > 1)
5280 
5281  if (CMD_ARGC == 1) {
5282  if (strcmp(CMD_ARGV[0], "allow-defer"))
5284  allow_defer = true;
5285  }
5286 
5288  if (!target->tap->enabled) {
5289  command_print(CMD, "[TAP is disabled]");
5290  return ERROR_FAIL;
5291  }
5292 
5293  if (allow_defer && target->defer_examine) {
5294  LOG_INFO("Deferring arp_examine of %s", target_name(target));
5295  LOG_INFO("Use arp_examine command to examine it manually!");
5296  return ERROR_OK;
5297  }
5298 
5299  int retval = target->type->examine(target);
5300  if (retval != ERROR_OK) {
5302  return retval;
5303  }
5304 
5306 
5307  return ERROR_OK;
5308 }
5309 
5310 COMMAND_HANDLER(handle_target_was_examined)
5311 {
5312  if (CMD_ARGC != 0)
5314 
5316 
5317  command_print(CMD, "%d", target_was_examined(target) ? 1 : 0);
5318 
5319  return ERROR_OK;
5320 }
5321 
5322 COMMAND_HANDLER(handle_target_examine_deferred)
5323 {
5324  if (CMD_ARGC != 0)
5326 
5328 
5329  command_print(CMD, "%d", target->defer_examine ? 1 : 0);
5330 
5331  return ERROR_OK;
5332 }
5333 
5334 COMMAND_HANDLER(handle_target_halt_gdb)
5335 {
5336  if (CMD_ARGC != 0)
5338 
5340 
5342 }
5343 
5344 COMMAND_HANDLER(handle_target_poll)
5345 {
5346  if (CMD_ARGC != 0)
5348 
5350  if (!target->tap->enabled) {
5351  command_print(CMD, "[TAP is disabled]");
5352  return ERROR_FAIL;
5353  }
5354 
5355  if (!(target_was_examined(target)))
5357 
5358  return target->type->poll(target);
5359 }
5360 
5361 COMMAND_HANDLER(handle_target_reset)
5362 {
5363  if (CMD_ARGC != 2)
5365 
5366  const struct nvp *n = nvp_name2value(nvp_assert, CMD_ARGV[0]);
5367  if (!n->name) {
5370  }
5371 
5372  /* the halt or not param */
5373  int a;
5374  COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], a);
5375 
5377  if (!target->tap->enabled) {
5378  command_print(CMD, "[TAP is disabled]");
5379  return ERROR_FAIL;
5380  }
5381 
5383  command_print(CMD, "No target-specific reset for %s", target_name(target));
5384  return ERROR_FAIL;
5385  }
5386 
5387  /* determine if we should halt or not. */
5388  target->reset_halt = (a != 0);
5389  /* When this happens - all workareas are invalid. */
5391 
5392  /* do the assert */
5393  if (n->value == NVP_ASSERT) {
5394  int retval = target->type->assert_reset(target);
5395  if (target->defer_examine)
5397  return retval;
5398  }
5399 
5400  return target->type->deassert_reset(target);
5401 }
5402 
5403 COMMAND_HANDLER(handle_target_halt)
5404 {
5405  if (CMD_ARGC != 0)
5407 
5409  if (!target->tap->enabled) {
5410  command_print(CMD, "[TAP is disabled]");
5411  return ERROR_FAIL;
5412  }
5413 
5414  return target->type->halt(target);
5415 }
5416 
5417 COMMAND_HANDLER(handle_target_wait_state)
5418 {
5419  if (CMD_ARGC != 2)
5421 
5422  const struct nvp *n = nvp_name2value(nvp_target_state, CMD_ARGV[0]);
5423  if (!n->name) {
5426  }
5427 
5428  unsigned int a;
5429  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], a);
5430 
5432  if (!target->tap->enabled) {
5433  command_print(CMD, "[TAP is disabled]");
5434  return ERROR_FAIL;
5435  }
5436 
5437  int retval = target_wait_state(target, n->value, a);
5438  if (retval != ERROR_OK) {
5440  "target: %s wait %s fails (%d) %s",
5441  target_name(target), n->name,
5442  retval, target_strerror_safe(retval));
5443  return retval;
5444  }
5445  return ERROR_OK;
5446 }
5447 /* List for human, Events defined for this target.
5448  * scripts/programs should use 'name cget -event NAME'
5449  */
5450 COMMAND_HANDLER(handle_target_event_list)
5451 {
5453  struct target_event_action *teap;
5454 
5455  command_print(CMD, "Event actions for target %s\n",
5456  target_name(target));
5457  command_print(CMD, "%-25s | Body", "Event");
5458  command_print(CMD, "------------------------- | "
5459  "----------------------------------------");
5460 
5462  command_print(CMD, "%-25s | %s",
5463  target_event_name(teap->event),
5464  Jim_GetString(teap->body, NULL));
5465 
5466  command_print(CMD, "***END***");
5467  return ERROR_OK;
5468 }
5469 
5470 COMMAND_HANDLER(handle_target_current_state)
5471 {
5472  if (CMD_ARGC != 0)
5474 
5476 
5478 
5479  return ERROR_OK;
5480 }
5481 
5482 COMMAND_HANDLER(handle_target_debug_reason)
5483 {
5484  if (CMD_ARGC != 0)
5486 
5488 
5489 
5492 
5493  if (!debug_reason) {
5494  command_print(CMD, "bug: invalid debug reason (%d)",
5495  target->debug_reason);
5496  return ERROR_FAIL;
5497  }
5498 
5499  command_print(CMD, "%s", debug_reason);
5500 
5501  return ERROR_OK;
5502 }
5503 
5504 COMMAND_HANDLER(handle_target_invoke_event)
5505 {
5506  if (CMD_ARGC != 1)
5508 
5509  const struct nvp *n = nvp_name2value(nvp_target_event, CMD_ARGV[0]);
5510  if (!n->name) {
5513  }
5514 
5517  return ERROR_OK;
5518 }
5519 
5521  {
5522  .name = "configure",
5523  .mode = COMMAND_ANY,
5524  .handler = handle_target_configure,
5525  .help = "configure a new target for use",
5526  .usage = "[target_attribute ...]",
5527  },
5528  {
5529  .name = "cget",
5530  .mode = COMMAND_ANY,
5531  .handler = handle_target_configure,
5532  .help = "returns the specified target attribute",
5533  .usage = "target_attribute",
5534  },
5535  {
5536  .name = "mwd",
5537  .handler = handle_mw_command,
5538  .mode = COMMAND_EXEC,
5539  .help = "Write 64-bit word(s) to target memory",
5540  .usage = "address data [count]",
5541  },
5542  {
5543  .name = "mww",
5544  .handler = handle_mw_command,
5545  .mode = COMMAND_EXEC,
5546  .help = "Write 32-bit word(s) to target memory",
5547  .usage = "address data [count]",
5548  },
5549  {
5550  .name = "mwh",
5551  .handler = handle_mw_command,
5552  .mode = COMMAND_EXEC,
5553  .help = "Write 16-bit half-word(s) to target memory",
5554  .usage = "address data [count]",
5555  },
5556  {
5557  .name = "mwb",
5558  .handler = handle_mw_command,
5559  .mode = COMMAND_EXEC,
5560  .help = "Write byte(s) to target memory",
5561  .usage = "address data [count]",
5562  },
5563  {
5564  .name = "mdd",
5565  .handler = handle_md_command,
5566  .mode = COMMAND_EXEC,
5567  .help = "Display target memory as 64-bit words",
5568  .usage = "address [count]",
5569  },
5570  {
5571  .name = "mdw",
5572  .handler = handle_md_command,
5573  .mode = COMMAND_EXEC,
5574  .help = "Display target memory as 32-bit words",
5575  .usage = "address [count]",
5576  },
5577  {
5578  .name = "mdh",
5579  .handler = handle_md_command,
5580  .mode = COMMAND_EXEC,
5581  .help = "Display target memory as 16-bit half-words",
5582  .usage = "address [count]",
5583  },
5584  {
5585  .name = "mdb",
5586  .handler = handle_md_command,
5587  .mode = COMMAND_EXEC,
5588  .help = "Display target memory as 8-bit bytes",
5589  .usage = "address [count]",
5590  },
5591  {
5592  .name = "get_reg",
5593  .mode = COMMAND_EXEC,
5594  .handler = handle_target_get_reg,
5595  .help = "Get register values from the target",
5596  .usage = "[-force] list",
5597  },
5598  {
5599  .name = "set_reg",
5600  .mode = COMMAND_EXEC,
5601  .handler = handle_set_reg_command,
5602  .help = "Set target register values",
5603  .usage = "dict",
5604  },
5605  {
5606  .name = "read_memory",
5607  .mode = COMMAND_EXEC,
5608  .handler = handle_target_read_memory,
5609  .help = "Read Tcl list of 8/16/32/64 bit numbers from target memory",
5610  .usage = "address width count ['phys']",
5611  },
5612  {
5613  .name = "write_memory",
5614  .mode = COMMAND_EXEC,
5615  .handler = handle_target_write_memory,
5616  .help = "Write Tcl list of 8/16/32/64 bit numbers to target memory",
5617  .usage = "address width data ['phys']",
5618  },
5619  {
5620  .name = "eventlist",
5621  .handler = handle_target_event_list,
5622  .mode = COMMAND_EXEC,
5623  .help = "displays a table of events defined for this target",
5624  .usage = "",
5625  },
5626  {
5627  .name = "curstate",
5628  .mode = COMMAND_EXEC,
5629  .handler = handle_target_current_state,
5630  .help = "displays the current state of this target",
5631  .usage = "",
5632  },
5633  {
5634  .name = "debug_reason",
5635  .mode = COMMAND_EXEC,
5636  .handler = handle_target_debug_reason,
5637  .help = "displays the debug reason of this target",
5638  .usage = "",
5639  },
5640  {
5641  .name = "arp_examine",
5642  .mode = COMMAND_EXEC,
5643  .handler = handle_target_examine,
5644  .help = "used internally for reset processing",
5645  .usage = "['allow-defer']",
5646  },
5647  {
5648  .name = "was_examined",
5649  .mode = COMMAND_EXEC,
5650  .handler = handle_target_was_examined,
5651  .help = "used internally for reset processing",
5652  .usage = "",
5653  },
5654  {
5655  .name = "examine_deferred",
5656  .mode = COMMAND_EXEC,
5657  .handler = handle_target_examine_deferred,
5658  .help = "used internally for reset processing",
5659  .usage = "",
5660  },
5661  {
5662  .name = "arp_halt_gdb",
5663  .mode = COMMAND_EXEC,
5664  .handler = handle_target_halt_gdb,
5665  .help = "used internally for reset processing to halt GDB",
5666  .usage = "",
5667  },
5668  {
5669  .name = "arp_poll",
5670  .mode = COMMAND_EXEC,
5671  .handler = handle_target_poll,
5672  .help = "used internally for reset processing",
5673  .usage = "",
5674  },
5675  {
5676  .name = "arp_reset",
5677  .mode = COMMAND_EXEC,
5678  .handler = handle_target_reset,
5679  .help = "used internally for reset processing",
5680  .usage = "'assert'|'deassert' halt",
5681  },
5682  {
5683  .name = "arp_halt",
5684  .mode = COMMAND_EXEC,
5685  .handler = handle_target_halt,
5686  .help = "used internally for reset processing",
5687  .usage = "",
5688  },
5689  {
5690  .name = "arp_waitstate",
5691  .mode = COMMAND_EXEC,
5692  .handler = handle_target_wait_state,
5693  .help = "used internally for reset processing",
5694  .usage = "statename timeoutmsecs",
5695  },
5696  {
5697  .name = "invoke-event",
5698  .mode = COMMAND_EXEC,
5699  .handler = handle_target_invoke_event,
5700  .help = "invoke handler for specified event",
5701  .usage = "event_name",
5702  },
5704 };
5705 
5706 COMMAND_HANDLER(handle_target_create)
5707 {
5708  int retval = ERROR_OK;
5709  int x;
5710 
5711  if (CMD_ARGC < 2)
5713 
5714  /* check if the target name clashes with an existing command name */
5715  Jim_Cmd *jimcmd = Jim_GetCommand(CMD_CTX->interp, CMD_JIMTCL_ARGV[0], JIM_NONE);
5716  if (jimcmd) {
5717  command_print(CMD, "Command/target: %s Exists", CMD_ARGV[0]);
5718  return ERROR_FAIL;
5719  }
5720 
5721  /* TYPE */
5722  const char *cp = CMD_ARGV[1];
5723  struct transport *tr = get_current_transport();
5724  if (tr && tr->override_target) {
5725  retval = tr->override_target(&cp);
5726  if (retval != ERROR_OK) {
5727  command_print(CMD, "The selected transport doesn't support this target");
5728  return retval;
5729  }
5730  LOG_INFO("The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD");
5731  }
5732  /* now does target type exist */
5733  for (x = 0 ; target_types[x] ; x++) {
5734  if (strcmp(cp, target_types[x]->name) == 0) {
5735  /* found */
5736  break;
5737  }
5738  }
5739  if (!target_types[x]) {
5740  char *all = NULL;
5741  for (x = 0 ; target_types[x] ; x++) {
5742  char *prev = all;
5743  if (all)
5744  all = alloc_printf("%s, %s", all, target_types[x]->name);
5745  else
5746  all = alloc_printf("%s", target_types[x]->name);
5747  free(prev);
5748  if (!all) {
5749  LOG_ERROR("Out of memory");
5750  return ERROR_FAIL;
5751  }
5752  }
5753  command_print(CMD, "Unknown target type %s, try one of %s", cp, all);
5754  free(all);
5755  return ERROR_FAIL;
5756  }
5757 
5758  /* Create it */
5759  struct target *target = calloc(1, sizeof(struct target));
5760  if (!target) {
5761  LOG_ERROR("Out of memory");
5762  return ERROR_FAIL;
5763  }
5764 
5765  /* set empty smp cluster */
5766  target->smp_targets = &empty_smp_targets;
5767 
5768  /* allocate memory for each unique target type */
5769  target->type = malloc(sizeof(struct target_type));
5770  if (!target->type) {
5771  LOG_ERROR("Out of memory");
5772  free(target);
5773  return ERROR_FAIL;
5774  }
5775 
5776  memcpy(target->type, target_types[x], sizeof(struct target_type));
5777 
5778  /* default to first core, override with -coreid */
5779  target->coreid = 0;
5780 
5781  target->working_area = 0x0;
5782  target->working_area_size = 0x0;
5784  target->backup_working_area = false;
5785 
5788  target->reg_cache = NULL;
5789  target->breakpoints = NULL;
5790  target->watchpoints = NULL;
5791  target->next = NULL;
5792  target->arch_info = NULL;
5793 
5794  target->verbose_halt_msg = true;
5795 
5796  target->halt_issued = false;
5797 
5799 
5800  /* initialize trace information */
5801  target->trace_info = calloc(1, sizeof(struct trace));
5802  if (!target->trace_info) {
5803  LOG_ERROR("Out of memory");
5804  free(target->type);
5805  free(target);
5806  return ERROR_FAIL;
5807  }
5808 
5809  target->dbgmsg = NULL;
5810  target->dbg_msg_enabled = false;
5811 
5813 
5814  target->rtos = NULL;
5815  target->rtos_auto_detect = false;
5816 
5819 
5820  target->cmd_name = strdup(CMD_ARGV[0]);
5821  if (!target->cmd_name) {
5822  LOG_ERROR("Out of memory");
5823  free(target->trace_info);
5824  free(target->type);
5825  free(target);
5826  return ERROR_FAIL;
5827  }
5828 
5829  /* Do the rest as "configure" options */
5830  bool is_configure = true;
5831  retval = CALL_COMMAND_HANDLER(target_configure, target, 2, is_configure);
5832  if (retval == ERROR_OK) {
5833  if (target->has_dap) {
5834  if (!target->dap_configured) {
5835  command_print(CMD, "-dap ?name? required when creating target");
5837  }
5838  } else {
5839  if (!target->tap_configured) {
5840  command_print(CMD, "-chain-position ?name? required when creating target");
5842  }
5843  }
5844  /* tap must be set after target was configured */
5845  if (!target->tap)
5847  }
5848 
5849  if (retval != ERROR_OK) {
5851  free(target->gdb_port_override);
5852  free(target->trace_info);
5853  free(target->type);
5854  free(target->private_config);
5855  free(target);
5856  return retval;
5857  }
5858 
5860  /* default endian to little if not specified */
5862  }
5863 
5864  if (target->type->target_create) {
5865  retval = (*target->type->target_create)(target);
5866  if (retval != ERROR_OK) {
5867  LOG_DEBUG("target_create failed");
5868  free(target->cmd_name);
5870  free(target->gdb_port_override);
5871  free(target->trace_info);
5872  free(target->type);
5873  free(target->private_config);
5874  free(target);
5875  return retval;
5876  }
5877  }
5878 
5879  /* create the target specific commands */
5880  if (target->type->commands) {
5882  if (retval != ERROR_OK)
5883  LOG_ERROR("unable to register '%s' commands", CMD_ARGV[0]);
5884  }
5885 
5886  /* now - create the new target name command */
5887  const struct command_registration target_subcommands[] = {
5888  {
5890  },
5891  {
5892  .chain = target->type->commands,
5893  },
5895  };
5896  const struct command_registration target_commands[] = {
5897  {
5898  .name = CMD_ARGV[0],
5899  .mode = COMMAND_ANY,
5900  .help = "target command group",
5901  .usage = "",
5902  .chain = target_subcommands,
5903  },
5905  };
5906  retval = register_commands_override_target(CMD_CTX, NULL, target_commands, target);
5907  if (retval != ERROR_OK) {
5908  if (target->type->deinit_target)
5910  free(target->cmd_name);
5912  free(target->gdb_port_override);
5913  free(target->trace_info);
5914  free(target->type);
5915  free(target);
5916  return retval;
5917  }
5918 
5919  /* append to end of list */
5921 
5922  CMD_CTX->current_target = target;
5923  return ERROR_OK;
5924 }
5925 
5926 COMMAND_HANDLER(handle_target_current)
5927 {
5928  if (CMD_ARGC != 0)
5930 
5932  if (target)
5934 
5935  return ERROR_OK;
5936 }
5937 
5938 COMMAND_HANDLER(handle_target_types)
5939 {
5940  if (CMD_ARGC != 0)
5942 
5943  for (unsigned int x = 0; target_types[x]; x++)
5944  command_print(CMD, "%s", target_types[x]->name);
5945 
5946  return ERROR_OK;
5947 }
5948 
5949 COMMAND_HANDLER(handle_target_names)
5950 {
5951  if (CMD_ARGC != 0)
5953 
5954  struct target *target = all_targets;
5955  while (target) {
5957  target = target->next;
5958  }
5959 
5960  return ERROR_OK;
5961 }
5962 
5963 static struct target_list *
5964 __attribute__((warn_unused_result))
5965 create_target_list_node(const char *targetname)
5966 {
5967  struct target *target = get_target(targetname);
5968  LOG_DEBUG("%s ", targetname);
5969  if (!target)
5970  return NULL;
5971 
5972  struct target_list *new = malloc(sizeof(struct target_list));
5973  if (!new) {
5974  LOG_ERROR("Out of memory");
5975  return new;
5976  }
5977 
5978  new->target = target;
5979  return new;
5980 }
5981 
5983  struct list_head *lh, struct target **result)
5984 {
5985  struct target *target = NULL;
5986  struct target_list *curr;
5987  foreach_smp_target(curr, lh) {
5988  struct rtos *curr_rtos = curr->target->rtos;
5989  if (curr_rtos) {
5990  if (target && target->rtos && target->rtos->type != curr_rtos->type) {
5991  command_print(cmd, "Different rtos types in members of one smp target!");
5992  return ERROR_FAIL;
5993  }
5994  target = curr->target;
5995  }
5996  }
5997  *result = target;
5998  return ERROR_OK;
5999 }
6000 
6001 COMMAND_HANDLER(handle_target_smp)
6002 {
6003  static unsigned int smp_group = 1;
6004 
6005  if (CMD_ARGC == 0) {
6006  LOG_DEBUG("Empty SMP target");
6007  return ERROR_OK;
6008  }
6009  LOG_DEBUG("%d", CMD_ARGC);
6010  /* CMD_ARGC[0] = target to associate in smp
6011  * CMD_ARGC[1] = target to associate in smp
6012  * CMD_ARGC[2] ...
6013  */
6014 
6015  struct list_head *lh = malloc(sizeof(*lh));
6016  if (!lh) {
6017  LOG_ERROR("Out of memory");
6018  return ERROR_FAIL;
6019  }
6020  INIT_LIST_HEAD(lh);
6021 
6022  for (unsigned int i = 0; i < CMD_ARGC; i++) {
6023  struct target_list *new = create_target_list_node(CMD_ARGV[i]);
6024  if (new)
6025  list_add_tail(&new->lh, lh);
6026  }
6027  /* now parse the list of cpu and put the target in smp mode*/
6028  struct target_list *curr;
6029  foreach_smp_target(curr, lh) {
6030  struct target *target = curr->target;
6031  target->smp = smp_group;
6032  target->smp_targets = lh;
6033  }
6034  smp_group++;
6035 
6036  struct target *rtos_target;
6037  int retval = get_target_with_common_rtos_type(CMD, lh, &rtos_target);
6038  if (retval == ERROR_OK && rtos_target)
6039  retval = rtos_smp_init(rtos_target);
6040 
6041  return retval;
6042 }
6043 
6044 static const struct command_registration target_subcommand_handlers[] = {
6045  {
6046  .name = "init",
6047  .mode = COMMAND_CONFIG,
6048  .handler = handle_target_init_command,
6049  .help = "initialize targets",
6050  .usage = "",
6051  },
6052  {
6053  .name = "create",
6054  .mode = COMMAND_CONFIG,
6055  .handler = handle_target_create,
6056  .usage = "name type [options ...]",
6057  .help = "Creates and selects a new target",
6058  },
6059  {
6060  .name = "current",
6061  .mode = COMMAND_ANY,
6062  .handler = handle_target_current,
6063  .help = "Returns the currently selected target",
6064  .usage = "",
6065  },
6066  {
6067  .name = "types",
6068  .mode = COMMAND_ANY,
6069  .handler = handle_target_types,
6070  .help = "Returns the available target types as "
6071  "a list of strings",
6072  .usage = "",
6073  },
6074  {
6075  .name = "names",
6076  .mode = COMMAND_ANY,
6077  .handler = handle_target_names,
6078  .help = "Returns the names of all targets as a list of strings",
6079  .usage = "",
6080  },
6081  {
6082  .name = "smp",
6083  .mode = COMMAND_ANY,
6084  .handler = handle_target_smp,
6085  .usage = "targetname1 targetname2 ...",
6086  .help = "gather several target in a smp list"
6087  },
6088 
6090 };
6091 
6092 struct fast_load {
6094  uint8_t *data;
6095  int length;
6096 
6097 };
6098 
6099 static int fastload_num;
6100 static struct fast_load *fastload;
6101 
6102 static void free_fastload(void)
6103 {
6104  if (fastload) {
6105  for (int i = 0; i < fastload_num; i++)
6106  free(fastload[i].data);
6107  free(fastload);
6108  fastload = NULL;
6109  }
6110 }
6111 
6112 COMMAND_HANDLER(handle_fast_load_image_command)
6113 {
6114  uint8_t *buffer;
6115  size_t buf_cnt;
6116  uint32_t image_size;
6117  target_addr_t min_address = 0;
6118  target_addr_t max_address = -1;
6119 
6120  struct image image;
6121 
6122  int retval = CALL_COMMAND_HANDLER(parse_load_image_command,
6123  &image, &min_address, &max_address);
6124  if (retval != ERROR_OK)
6125  return retval;
6126 
6127  struct duration bench;
6128  duration_start(&bench);
6129 
6130  retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL);
6131  if (retval != ERROR_OK)
6132  return retval;
6133 
6134  image_size = 0x0;
6135  retval = ERROR_OK;
6137  fastload = malloc(sizeof(struct fast_load)*image.num_sections);
6138  if (!fastload) {
6139  command_print(CMD, "out of memory");
6140  image_close(&image);
6141  return ERROR_FAIL;
6142  }
6143  memset(fastload, 0, sizeof(struct fast_load)*image.num_sections);
6144  for (unsigned int i = 0; i < image.num_sections; i++) {
6145  buffer = malloc(image.sections[i].size);
6146  if (!buffer) {
6147  command_print(CMD, "error allocating buffer for section (%d bytes)",
6148  (int)(image.sections[i].size));
6149  retval = ERROR_FAIL;
6150  break;
6151  }
6152 
6153  retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt);
6154  if (retval != ERROR_OK) {
6155  free(buffer);
6156  break;
6157  }
6158 
6159  uint32_t offset = 0;
6160  uint32_t length = buf_cnt;
6161 
6162  /* DANGER!!! beware of unsigned comparison here!!! */
6163 
6164  if ((image.sections[i].base_address + buf_cnt >= min_address) &&
6165  (image.sections[i].base_address < max_address)) {
6166  if (image.sections[i].base_address < min_address) {
6167  /* clip addresses below */
6168  offset += min_address-image.sections[i].base_address;
6169  length -= offset;
6170  }
6171 
6172  if (image.sections[i].base_address + buf_cnt > max_address)
6173  length -= (image.sections[i].base_address + buf_cnt)-max_address;
6174 
6176  fastload[i].data = malloc(length);
6177  if (!fastload[i].data) {
6178  free(buffer);
6179  command_print(CMD, "error allocating buffer for section (%" PRIu32 " bytes)",
6180  length);
6181  retval = ERROR_FAIL;
6182  break;
6183  }
6184  memcpy(fastload[i].data, buffer + offset, length);
6185  fastload[i].length = length;
6186 
6187  image_size += length;
6188  command_print(CMD, "%u bytes written at address 0x%8.8x",
6189  (unsigned int)length,
6190  ((unsigned int)(image.sections[i].base_address + offset)));
6191  }
6192 
6193  free(buffer);
6194  }
6195 
6196  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
6197  command_print(CMD, "Loaded %" PRIu32 " bytes "
6198  "in %fs (%0.3f KiB/s)", image_size,
6199  duration_elapsed(&bench), duration_kbps(&bench, image_size));
6200 
6202  "WARNING: image has not been loaded to target!"
6203  "You can issue a 'fast_load' to finish loading.");
6204  }
6205 
6206  image_close(&image);
6207 
6208  if (retval != ERROR_OK)
6209  free_fastload();
6210 
6211  return retval;
6212 }
6213 
6214 COMMAND_HANDLER(handle_fast_load_command)
6215 {
6216  if (CMD_ARGC > 0)
6218  if (!fastload) {
6219  LOG_ERROR("No image in memory");
6220  return ERROR_FAIL;
6221  }
6222  int i;
6223  int64_t ms = timeval_ms();
6224  int size = 0;
6225  int retval = ERROR_OK;
6226  for (i = 0; i < fastload_num; i++) {
6228  command_print(CMD, "Write to 0x%08x, length 0x%08x",
6229  (unsigned int)(fastload[i].address),
6230  (unsigned int)(fastload[i].length));
6231  retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
6232  if (retval != ERROR_OK)
6233  break;
6234  size += fastload[i].length;
6235  }
6236  if (retval == ERROR_OK) {
6237  int64_t after = timeval_ms();
6238  command_print(CMD, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
6239  }
6240  return retval;
6241 }
6242 
6243 static const struct command_registration target_command_handlers[] = {
6244  {
6245  .name = "targets",
6246  .handler = handle_targets_command,
6247  .mode = COMMAND_ANY,
6248  .help = "change current default target (one parameter) "
6249  "or prints table of all targets (no parameters)",
6250  .usage = "[target]",
6251  },
6252  {
6253  .name = "target",
6254  .mode = COMMAND_CONFIG,
6255  .help = "configure target",
6256  .chain = target_subcommand_handlers,
6257  .usage = "",
6258  },
6260 };
6261 
6263 {
6265 }
6266 
6267 static bool target_reset_nag = true;
6268 
6270 {
6271  return target_reset_nag;
6272 }
6273 
6274 COMMAND_HANDLER(handle_target_reset_nag)
6275 {
6276  return CALL_COMMAND_HANDLER(handle_command_parse_bool,
6277  &target_reset_nag, "Nag after each reset about options to improve "
6278  "performance");
6279 }
6280 
6281 COMMAND_HANDLER(handle_ps_command)
6282 {
6284  char *display;
6285  if (target->state != TARGET_HALTED) {
6286  command_print(CMD, "Error: [%s] not halted", target_name(target));
6287  return ERROR_TARGET_NOT_HALTED;
6288  }
6289 
6290  if ((target->rtos) && (target->rtos->type)
6291  && (target->rtos->type->ps_command)) {
6292  display = target->rtos->type->ps_command(target);
6293  command_print(CMD, "%s", display);
6294  free(display);
6295  return ERROR_OK;
6296  } else {
6297  LOG_INFO("failed");
6298  return ERROR_TARGET_FAILURE;
6299  }
6300 }
6301 
6302 static void binprint(struct command_invocation *cmd, const char *text, const uint8_t *buf, int size)
6303 {
6304  if (text)
6305  command_print_sameline(cmd, "%s", text);
6306  for (int i = 0; i < size; i++)
6307  command_print_sameline(cmd, " %02x", buf[i]);
6308  command_print(cmd, " ");
6309 }
6310 
6311 COMMAND_HANDLER(handle_test_mem_access_command)
6312 {
6314  uint32_t test_size;
6315  int retval = ERROR_OK;
6316 
6317  if (target->state != TARGET_HALTED) {
6318  command_print(CMD, "Error: [%s] not halted", target_name(target));
6319  return ERROR_TARGET_NOT_HALTED;
6320  }
6321 
6322  if (CMD_ARGC != 1)
6324 
6325  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], test_size);
6326 
6327  /* Test reads */
6328  size_t num_bytes = test_size + 4;
6329 
6330  struct working_area *wa = NULL;
6331  retval = target_alloc_working_area(target, num_bytes, &wa);
6332  if (retval != ERROR_OK) {
6333  LOG_ERROR("Not enough working area");
6334  return ERROR_FAIL;
6335  }
6336 
6337  uint8_t *test_pattern = malloc(num_bytes);
6338 
6339  for (size_t i = 0; i < num_bytes; i++)
6340  test_pattern[i] = rand();
6341 
6342  retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);
6343  if (retval != ERROR_OK) {
6344  LOG_ERROR("Test pattern write failed");
6345  goto out;
6346  }
6347 
6348  for (int host_offset = 0; host_offset <= 1; host_offset++) {
6349  for (int size = 1; size <= 4; size *= 2) {
6350  for (int offset = 0; offset < 4; offset++) {
6351  uint32_t count = test_size / size;
6352  size_t host_bufsiz = (count + 2) * size + host_offset;
6353  uint8_t *read_ref = malloc(host_bufsiz);
6354  uint8_t *read_buf = malloc(host_bufsiz);
6355 
6356  for (size_t i = 0; i < host_bufsiz; i++) {
6357  read_ref[i] = rand();
6358  read_buf[i] = read_ref[i];
6359  }
6361  "Test read %" PRIu32 " x %d @ %d to %saligned buffer: ", count,
6362  size, offset, host_offset ? "un" : "");
6363 
6364  struct duration bench;
6365  duration_start(&bench);
6366 
6367  retval = target_read_memory(target, wa->address + offset, size, count,
6368  read_buf + size + host_offset);
6369 
6370  duration_measure(&bench);
6371 
6372  if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
6373  command_print(CMD, "Unsupported alignment");
6374  goto next;
6375  } else if (retval != ERROR_OK) {
6376  command_print(CMD, "Memory read failed");
6377  goto next;
6378  }
6379 
6380  /* replay on host */
6381  memcpy(read_ref + size + host_offset, test_pattern + offset, count * size);
6382 
6383  /* check result */
6384  int result = memcmp(read_ref, read_buf, host_bufsiz);
6385  if (result == 0) {
6386  command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
6387  duration_elapsed(&bench),
6388  duration_kbps(&bench, count * size));
6389  } else {
6390  command_print(CMD, "Compare failed");
6391  binprint(CMD, "ref:", read_ref, host_bufsiz);
6392  binprint(CMD, "buf:", read_buf, host_bufsiz);
6393  }
6394 next:
6395  free(read_ref);
6396  free(read_buf);
6397  }
6398  }
6399  }
6400 
6401 out:
6402  free(test_pattern);
6403 
6405 
6406  /* Test writes */
6407  num_bytes = test_size + 4 + 4 + 4;
6408 
6409  retval = target_alloc_working_area(target, num_bytes, &wa);
6410  if (retval != ERROR_OK) {
6411  LOG_ERROR("Not enough working area");
6412  return ERROR_FAIL;
6413  }
6414 
6415  test_pattern = malloc(num_bytes);
6416 
6417  for (size_t i = 0; i < num_bytes; i++)
6418  test_pattern[i] = rand();
6419 
6420  for (int host_offset = 0; host_offset <= 1; host_offset++) {
6421  for (int size = 1; size <= 4; size *= 2) {
6422  for (int offset = 0; offset < 4; offset++) {
6423  uint32_t count = test_size / size;
6424  size_t host_bufsiz = count * size + host_offset;
6425  uint8_t *read_ref = malloc(num_bytes);
6426  uint8_t *read_buf = malloc(num_bytes);
6427  uint8_t *write_buf = malloc(host_bufsiz);
6428 
6429  for (size_t i = 0; i < host_bufsiz; i++)
6430  write_buf[i] = rand();
6432  "Test write %" PRIu32 " x %d @ %d from %saligned buffer: ", count,
6433  size, offset, host_offset ? "un" : "");
6434 
6435  retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);
6436  if (retval != ERROR_OK) {
6437  command_print(CMD, "Test pattern write failed");
6438  goto nextw;
6439  }
6440 
6441  /* replay on host */
6442  memcpy(read_ref, test_pattern, num_bytes);
6443  memcpy(read_ref + size + offset, write_buf + host_offset, count * size);
6444 
6445  struct duration bench;
6446  duration_start(&bench);
6447 
6448  retval = target_write_memory(target, wa->address + size + offset, size, count,
6449  write_buf + host_offset);
6450 
6451  duration_measure(&bench);
6452 
6453  if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
6454  command_print(CMD, "Unsupported alignment");
6455  goto nextw;
6456  } else if (retval != ERROR_OK) {
6457  command_print(CMD, "Memory write failed");
6458  goto nextw;
6459  }
6460 
6461  /* read back */
6462  retval = target_read_memory(target, wa->address, 1, num_bytes, read_buf);
6463  if (retval != ERROR_OK) {
6464  command_print(CMD, "Test pattern write failed");
6465  goto nextw;
6466  }
6467 
6468  /* check result */
6469  int result = memcmp(read_ref, read_buf, num_bytes);
6470  if (result == 0) {
6471  command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
6472  duration_elapsed(&bench),
6473  duration_kbps(&bench, count * size));
6474  } else {
6475  command_print(CMD, "Compare failed");
6476  binprint(CMD, "ref:", read_ref, num_bytes);
6477  binprint(CMD, "buf:", read_buf, num_bytes);
6478  }
6479 nextw:
6480  free(read_ref);
6481  free(read_buf);
6482  }
6483  }
6484  }
6485 
6486  free(test_pattern);
6487 
6489  return retval;
6490 }
6491 
6492 static const struct command_registration target_exec_command_handlers[] = {
6493  {
6494  .name = "fast_load_image",
6495  .handler = handle_fast_load_image_command,
6496  .mode = COMMAND_ANY,
6497  .help = "Load image into server memory for later use by "
6498  "fast_load; primarily for profiling",
6499  .usage = "filename [address ['bin'|'ihex'|'elf'|'s19' "
6500  "[min_address [max_length]]]]",
6501  },
6502  {
6503  .name = "fast_load",
6504  .handler = handle_fast_load_command,
6505  .mode = COMMAND_EXEC,
6506  .help = "loads active fast load image to current target "
6507  "- mainly for profiling purposes",
6508  .usage = "",
6509  },
6510  {
6511  .name = "profile",
6512  .handler = handle_profile_command,
6513  .mode = COMMAND_EXEC,
6514  .usage = "seconds filename [start end]",
6515  .help = "profiling samples the CPU PC",
6516  },
6518  {
6519  .name = "virt2phys",
6520  .handler = handle_virt2phys_command,
6521  .mode = COMMAND_ANY,
6522  .help = "translate a virtual address into a physical address",
6523  .usage = "virtual_address",
6524  },
6525  {
6526  .name = "reg",
6527  .handler = handle_reg_command,
6528  .mode = COMMAND_EXEC,
6529  .help = "display (reread from target with \"force\") or set a register; "
6530  "with no arguments, displays all registers and their values",
6531  .usage = "[(register_number|register_name) [(value|'force')]]",
6532  },
6533  {
6534  .name = "poll",
6535  .handler = handle_poll_command,
6536  .mode = COMMAND_EXEC,
6537  .help = "poll target state; or reconfigure background polling",
6538  .usage = "['on'|'off']",
6539  },
6540  {
6541  .name = "wait_halt",
6542  .handler = handle_wait_halt_command,
6543  .mode = COMMAND_EXEC,
6544  .help = "wait up to the specified number of milliseconds "
6545  "(default 5000) for a previously requested halt",
6546  .usage = "[milliseconds]",
6547  },
6548  {
6549  .name = "halt",
6550  .handler = handle_halt_command,
6551  .mode = COMMAND_EXEC,
6552  .help = "request target to halt, then wait up to the specified "
6553  "number of milliseconds (default 5000) for it to complete",
6554  .usage = "[milliseconds]",
6555  },
6556  {
6557  .name = "resume",
6558  .handler = handle_resume_command,
6559  .mode = COMMAND_EXEC,
6560  .help = "resume target execution from current PC or address",
6561  .usage = "[address]",
6562  },
6563  {
6564  .name = "reset",
6565  .handler = handle_reset_command,
6566  .mode = COMMAND_EXEC,
6567  .usage = "[run|halt|init]",
6568  .help = "Reset all targets into the specified mode. "
6569  "Default reset mode is run, if not given.",
6570  },
6571  {
6572  .name = "soft_reset_halt",
6573  .handler = handle_soft_reset_halt_command,
6574  .mode = COMMAND_EXEC,
6575  .usage = "",
6576  .help = "halt the target and do a soft reset",
6577  },
6578  {
6579  .name = "step",
6580  .handler = handle_step_command,
6581  .mode = COMMAND_EXEC,
6582  .help = "step one instruction from current PC or address",
6583  .usage = "[address]",
6584  },
6585  {
6586  .name = "mdd",
6587  .handler = handle_md_command,
6588  .mode = COMMAND_EXEC,
6589  .help = "display memory double-words",
6590  .usage = "['phys'] address [count]",
6591  },
6592  {
6593  .name = "mdw",
6594  .handler = handle_md_command,
6595  .mode = COMMAND_EXEC,
6596  .help = "display memory words",
6597  .usage = "['phys'] address [count]",
6598  },
6599  {
6600  .name = "mdh",
6601  .handler = handle_md_command,
6602  .mode = COMMAND_EXEC,
6603  .help = "display memory half-words",
6604  .usage = "['phys'] address [count]",
6605  },
6606  {
6607  .name = "mdb",
6608  .handler = handle_md_command,
6609  .mode = COMMAND_EXEC,
6610  .help = "display memory bytes",
6611  .usage = "['phys'] address [count]",
6612  },
6613  {
6614  .name = "mwd",
6615  .handler = handle_mw_command,
6616  .mode = COMMAND_EXEC,
6617  .help = "write memory double-word",
6618  .usage = "['phys'] address value [count]",
6619  },
6620  {
6621  .name = "mww",
6622  .handler = handle_mw_command,
6623  .mode = COMMAND_EXEC,
6624  .help = "write memory word",
6625  .usage = "['phys'] address value [count]",
6626  },
6627  {
6628  .name = "mwh",
6629  .handler = handle_mw_command,
6630  .mode = COMMAND_EXEC,
6631  .help = "write memory half-word",
6632  .usage = "['phys'] address value [count]",
6633  },
6634  {
6635  .name = "mwb",
6636  .handler = handle_mw_command,
6637  .mode = COMMAND_EXEC,
6638  .help = "write memory byte",
6639  .usage = "['phys'] address value [count]",
6640  },
6641  {
6642  .name = "bp",
6643  .handler = handle_bp_command,
6644  .mode = COMMAND_EXEC,
6645  .help = "list or set hardware or software breakpoint",
6646  .usage = "[<address> [<asid>] <length> ['hw'|'hw_ctx']]",
6647  },
6648  {
6649  .name = "rbp",
6650  .handler = handle_rbp_command,
6651  .mode = COMMAND_EXEC,
6652  .help = "remove breakpoint",
6653  .usage = "'all' | address",
6654  },
6655  {
6656  .name = "wp",
6657  .handler = handle_wp_command,
6658  .mode = COMMAND_EXEC,
6659  .help = "list (no params) or create watchpoints",
6660  .usage = "[address length [('r'|'w'|'a') [value [mask]]]]",
6661  },
6662  {
6663  .name = "rwp",
6664  .handler = handle_rwp_command,
6665  .mode = COMMAND_EXEC,
6666  .help = "remove watchpoint",
6667  .usage = "'all' | address",
6668  },
6669  {
6670  .name = "load_image",
6671  .handler = handle_load_image_command,
6672  .mode = COMMAND_EXEC,
6673  .usage = "filename [address ['bin'|'ihex'|'elf'|'s19' "
6674  "[min_address [max_length]]]]",
6675  },
6676  {
6677  .name = "dump_image",
6678  .handler = handle_dump_image_command,
6679  .mode = COMMAND_EXEC,
6680  .usage = "filename address size",
6681  },
6682  {
6683  .name = "verify_image_checksum",
6684  .handler = handle_verify_image_checksum_command,
6685  .mode = COMMAND_EXEC,
6686  .usage = "filename [offset [type]]",
6687  },
6688  {
6689  .name = "verify_image",
6690  .handler = handle_verify_image_command,
6691  .mode = COMMAND_EXEC,
6692  .usage = "filename [offset [type]]",
6693  },
6694  {
6695  .name = "test_image",
6696  .handler = handle_test_image_command,
6697  .mode = COMMAND_EXEC,
6698  .usage = "filename [offset [type]]",
6699  },
6700  {
6701  .name = "get_reg",
6702  .mode = COMMAND_EXEC,
6703  .handler = handle_target_get_reg,
6704  .help = "Get register values from the target",
6705  .usage = "[-force] list",
6706  },
6707  {
6708  .name = "set_reg",
6709  .mode = COMMAND_EXEC,
6710  .handler = handle_set_reg_command,
6711  .help = "Set target register values",
6712  .usage = "dict",
6713  },
6714  {
6715  .name = "read_memory",
6716  .mode = COMMAND_EXEC,
6717  .handler = handle_target_read_memory,
6718  .help = "Read Tcl list of 8/16/32/64 bit numbers from target memory",
6719  .usage = "address width count ['phys']",
6720  },
6721  {
6722  .name = "write_memory",
6723  .mode = COMMAND_EXEC,
6724  .handler = handle_target_write_memory,
6725  .help = "Write Tcl list of 8/16/32/64 bit numbers to target memory",
6726  .usage = "address width data ['phys']",
6727  },
6728  {
6729  .name = "debug_reason",
6730  .mode = COMMAND_EXEC,
6731  .handler = handle_target_debug_reason,
6732  .help = "displays the debug reason of this target",
6733  .usage = "",
6734  },
6735  {
6736  .name = "reset_nag",
6737  .handler = handle_target_reset_nag,
6738  .mode = COMMAND_ANY,
6739  .help = "Nag after each reset about options that could have been "
6740  "enabled to improve performance.",
6741  .usage = "['enable'|'disable']",
6742  },
6743  {
6744  .name = "ps",
6745  .handler = handle_ps_command,
6746  .mode = COMMAND_EXEC,
6747  .help = "list all tasks",
6748  .usage = "",
6749  },
6750  {
6751  .name = "test_mem_access",
6752  .handler = handle_test_mem_access_command,
6753  .mode = COMMAND_EXEC,
6754  .help = "Test the target's memory access functions",
6755  .usage = "size",
6756  },
6757 
6759 };
6761 {
6762  int retval = ERROR_OK;
6763  retval = target_request_register_commands(cmd_ctx);
6764  if (retval != ERROR_OK)
6765  return retval;
6766 
6767  retval = trace_register_commands(cmd_ctx);
6768  if (retval != ERROR_OK)
6769  return retval;
6770 
6771 
6773 }
6774 
6776 {
6777  switch (reason) {
6778  case DBG_REASON_DBGRQ:
6779  return "DBGRQ";
6780  case DBG_REASON_BREAKPOINT:
6781  return "BREAKPOINT";
6782  case DBG_REASON_WATCHPOINT:
6783  return "WATCHPOINT";
6784  case DBG_REASON_WPTANDBKPT:
6785  return "WPTANDBKPT";
6786  case DBG_REASON_SINGLESTEP:
6787  return "SINGLESTEP";
6788  case DBG_REASON_NOTHALTED:
6789  return "NOTHALTED";
6790  case DBG_REASON_EXIT:
6791  return "EXIT";
6792  case DBG_REASON_EXC_CATCH:
6793  return "EXC_CATCH";
6794  case DBG_REASON_UNDEFINED:
6795  return "UNDEFINED";
6796  default:
6797  return "UNKNOWN!";
6798  }
6799 }
struct target_type aarch64_target
Definition: aarch64.c:3246
struct target_type armv8r_target
Definition: aarch64.c:3287
#define IS_ALIGNED(x, a)
Definition: align.h:22
#define IS_PWR_OF_2(x)
Definition: align.h:24
#define ALIGN_DOWN(x, a)
Definition: align.h:21
#define ALIGN_UP(x, a)
Definition: align.h:20
struct target_type arcv2_target
Definition: arc.c:2321
struct target_type arm11_target
Holds methods for ARM11xx targets.
Definition: arm11.c:1346
struct target_type arm720t_target
Holds methods for ARM720 targets.
Definition: arm720t.c:464
struct target_type arm7tdmi_target
Holds methods for ARM7TDMI targets.
Definition: arm7tdmi.c:684
struct target_type arm920t_target
Holds methods for ARM920 targets.
Definition: arm920t.c:1596
struct target_type arm926ejs_target
Holds methods for ARM926 targets.
Definition: arm926ejs.c:790
struct target_type arm946e_target
Holds methods for ARM946 targets.
Definition: arm946e.c:738
struct target_type arm966e_target
Holds methods for ARM966 targets.
Definition: arm966e.c:245
struct target_type arm9tdmi_target
Holds methods for ARM9TDMI targets.
Definition: arm9tdmi.c:888
const char * name
Definition: armv4_5.c:76
struct target_type avr32_ap7k_target
Definition: avr32_ap7k.c:581
struct target_type avr_target
Definition: avrt.c:39
char * buf_to_hex_str(const void *_buf, unsigned int buf_len)
Definition: binarybuffer.c:178
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.
Definition: binarybuffer.h:104
int watchpoint_add(struct target *target, target_addr_t address, unsigned int length, enum watchpoint_rw rw, uint64_t value, uint64_t mask)
Definition: breakpoints.c:568
int breakpoint_remove(struct target *target, target_addr_t address)
Definition: breakpoints.c:344
int watchpoint_remove(struct target *target, target_addr_t address)
Definition: breakpoints.c:605
int breakpoint_add(struct target *target, target_addr_t address, unsigned int length, enum breakpoint_type type)
Definition: breakpoints.c:208
int context_breakpoint_add(struct target *target, uint32_t asid, unsigned int length, enum breakpoint_type type)
Definition: breakpoints.c:234
int watchpoint_remove_all(struct target *target)
Definition: breakpoints.c:463
int breakpoint_remove_all(struct target *target)
Definition: breakpoints.c:458
int hybrid_breakpoint_add(struct target *target, target_addr_t address, uint32_t asid, unsigned int length, enum breakpoint_type type)
Definition: breakpoints.c:255
@ BKPT_HARD
Definition: breakpoints.h:18
@ BKPT_SOFT
Definition: breakpoints.h:19
#define WATCHPOINT_IGNORE_DATA_VALUE_MASK
Definition: breakpoints.h:39
watchpoint_rw
Definition: breakpoints.h:22
@ WPT_ACCESS
Definition: breakpoints.h:23
@ WPT_READ
Definition: breakpoints.h:23
@ WPT_WRITE
Definition: breakpoints.h:23
struct command_context * current_command_context(Jim_Interp *interp)
Definition: command.c:90
int command_parse_bool_arg(const char *in, bool *out)
Definition: command.c:1289
void command_print_sameline(struct command_invocation *cmd, const char *format,...)
Definition: command.c:352
void command_print(struct command_invocation *cmd, const char *format,...)
Definition: command.c:375
int command_run_line(struct command_context *context, char *line)
Definition: command.c:476
#define CMD
Use this macro to access the command being handled, rather than accessing the variable directly.
Definition: command.h:141
#define CALL_COMMAND_HANDLER(name, extra ...)
Use this to macro to call a command helper (or a nested handler).
Definition: command.h:118
#define CMD_NAME
Use this macro to access the name of the command being handled, rather than accessing the variable di...
Definition: command.h:166
#define CMD_ARGV
Use this macro to access the arguments for the command being handled, rather than accessing the varia...
Definition: command.h:156
#define COMMAND_PARSE_ADDRESS(in, out)
Definition: command.h:450
#define COMMAND_PARSE_ON_OFF(in, out)
parses an on/off command argument
Definition: command.h:528
#define ERROR_COMMAND_SYNTAX_ERROR
Definition: command.h:400
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 ...
Definition: command.h:291
#define ERROR_COMMAND_CLOSE_CONNECTION
Definition: command.h:399
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
Definition: command.h:151
#define CMD_JIMTCL_ARGV
Use this macro to access the jimtcl arguments for the command being handled, rather than accessing th...
Definition: command.h:161
#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...
Definition: command.h:440
#define CMD_CTX
Use this macro to access the context of the command being handled, rather than accessing the variable...
Definition: command.h:146
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
Definition: command.h:251
#define ERROR_COMMAND_ARGUMENT_INVALID
Definition: command.h:402
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,...
Definition: command.h:272
@ COMMAND_CONFIG
Definition: command.h:41
@ COMMAND_ANY
Definition: command.h:42
@ COMMAND_EXEC
Definition: command.h:40
struct target_type cortexr4_target
Definition: cortex_a.c:3494
struct target_type cortexa_target
Definition: cortex_a.c:3414
struct target_type cortexm_target
Definition: cortex_m.c:3183
struct target_type dsp563xx_target
Holds methods for DSP563XX targets.
Definition: dsp563xx.c:2250
struct target_type dsp5680xx_target
Holds methods for dsp5680xx targets.
Definition: dsp5680xx.c:2245
uint64_t buffer
Pointer to data buffer to send over SPI.
Definition: dw-spi-helper.h:0
uint32_t size
Size of dw_spi_transaction::buffer.
Definition: dw-spi-helper.h:4
uint32_t buffer_size
Size of dw_spi_program::buffer.
Definition: dw-spi-helper.h:5
uint32_t address
Starting address. Sector aligned.
Definition: dw-spi-helper.h:0
unsigned short width
Definition: embeddedice.c:47
struct target_type esirisc_target
Definition: esirisc.c:1834
struct target_type esp32_target
Holds methods for Xtensa targets.
Definition: esp32.c:461
struct target_type esp32s2_target
Definition: esp32s2.c:498
struct target_type esp32s3_target
Holds methods for Xtensa targets.
Definition: esp32s3.c:382
uint8_t type
Definition: esp_usb_jtag.c:0
static struct esp_usb_jtag * priv
Definition: esp_usb_jtag.c:219
uint8_t length
Definition: esp_usb_jtag.c:1
struct target_type fa526_target
Holds methods for FA526 targets.
Definition: fa526.c:350
struct target_type dragonite_target
Definition: feroceon.c:730
struct target_type feroceon_target
Definition: feroceon.c:691
#define ERROR_FLASH_OPERATION_FAILED
Definition: flash/common.h:30
static uint16_t output
Definition: ftdi.c:119
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)
@ FILEIO_WRITE
Definition: helper/fileio.h:29
@ FILEIO_BINARY
Definition: helper/fileio.h:23
struct target_type hla_target
Definition: hla_target.c:640
void image_close(struct image *image)
Definition: image.c:1211
int image_read_section(struct image *image, int section, target_addr_t offset, uint32_t size, uint8_t *buffer, size_t *size_read)
Definition: image.c:1079
int image_calculate_checksum(const uint8_t *buffer, uint32_t nbytes, uint32_t *checksum)
Definition: image.c:1268
int image_open(struct image *image, const char *url, const char *type_string)
Definition: image.c:957
int jim_getopt_setup(struct jim_getopt_info *p, Jim_Interp *interp, int argc, Jim_Obj *const *argv)
GetOpt - how to.
Definition: jim-nvp.c:149
int jtag_unregister_event_callback(jtag_event_handler_t callback, void *priv)
Definition: jtag/core.c:309
void jtag_poll_unmask(bool saved)
Restore saved mask for polling.
Definition: jtag/core.c:183
struct jtag_tap * jtag_tap_by_string(const char *s)
Definition: jtag/core.c:243
void jtag_poll_set_enabled(bool value)
Assign flag reporting whether JTAG polling is disallowed.
Definition: jtag/core.c:171
int jtag_srst_asserted(int *srst_asserted)
Definition: jtag/core.c:1738
bool is_jtag_poll_safe(void)
Return true if it's safe for a background polling task to access the JTAG scan chain.
Definition: jtag/core.c:148
int jtag_power_dropout(int *dropout)
Definition: jtag/core.c:1723
int jtag_register_event_callback(jtag_event_handler_t callback, void *priv)
Definition: jtag/core.c:288
bool jtag_poll_get_enabled(void)
Return flag reporting whether JTAG polling is disallowed.
Definition: jtag/core.c:166
bool jtag_poll_mask(void)
Mask (disable) polling and return the current mask status that should be feed to jtag_poll_unmask() t...
Definition: jtag/core.c:176
The JTAG interface can be implemented with a software or hardware fifo.
jtag_event
Definition: jtag.h:179
@ JTAG_TAP_EVENT_ENABLE
Definition: jtag.h:182
static void list_add(struct list_head *new, struct list_head *head)
Definition: list.h:197
static void list_add_tail(struct list_head *new, struct list_head *head)
Definition: list.h:203
#define list_for_each_entry_safe(p, n, h, field)
Definition: list.h:159
#define list_for_each_entry(p, h, field)
Definition: list.h:155
static void list_del(struct list_head *entry)
Definition: list.h:88
static void INIT_LIST_HEAD(struct list_head *list)
Definition: list.h:54
void alive_sleep(uint64_t ms)
Definition: log.c:467
void keep_alive(void)
Definition: log.c:426
char * alloc_printf(const char *format,...)
Definition: log.c:375
#define LOG_TARGET_INFO(target, fmt_str,...)
Definition: log.h:153
#define ERROR_NOT_IMPLEMENTED
Definition: log.h:178
#define LOG_WARNING(expr ...)
Definition: log.h:130
#define ERROR_FAIL
Definition: log.h:174
#define LOG_TARGET_ERROR(target, fmt_str,...)
Definition: log.h:162
#define LOG_TARGET_DEBUG(target, fmt_str,...)
Definition: log.h:150
#define LOG_ERROR(expr ...)
Definition: log.h:133
#define LOG_INFO(expr ...)
Definition: log.h:127
#define LOG_DEBUG(expr ...)
Definition: log.h:110
#define ERROR_OK
Definition: log.h:168
struct target_type ls1_sap_target
Definition: ls1_sap.c:216
struct target_type mem_ap_target
Definition: mem_ap.c:265
#define zero
Definition: mips32.c:181
struct target_type mips_m4k_target
Definition: mips_m4k.c:1451
struct target_type mips_mips64_target
Definition: mips_mips64.c:1151
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)
Definition: nvp.c:49
const struct nvp * nvp_name2value(const struct nvp *p, const char *name)
Definition: nvp.c:29
const struct nvp * nvp_value2name(const struct nvp *p, int value)
Definition: nvp.c:39
static uint32_t lh(unsigned int rd, unsigned int base, uint16_t offset) __attribute__((unused))
Definition: opcodes.h:117
struct target_type or1k_target
Definition: or1k.c:1416
uint8_t bits[QN908X_FLASH_MAX_BLOCKS *QN908X_FLASH_PAGES_PER_BLOCK/8]
Definition: qn908x.c:0
struct target_type quark_d20xx_target
Definition: quark_d20xx.c:79
struct target_type quark_x10xx_target
Definition: quark_x10xx.c:57
struct reg * register_get_by_name(struct reg_cache *first, const char *name, bool search_all)
Definition: register.c:50
#define MIN(a, b)
Definition: replacements.h:22
int gettimeofday(struct timeval *tv, struct timezone *tz)
struct target_type riscv_target
Definition: riscv.c:3069
int rtos_create(struct command_invocation *cmd, struct target *target, const char *rtos_name)
Definition: rtos.c:97
void rtos_destroy(struct target *target)
Definition: rtos.c:142
int rtos_smp_init(struct target *target)
Definition: rtos.c:37
target_addr_t addr
Start address to search for the control block.
Definition: rtt/rtt.c:28
struct target * target
Definition: rtt/rtt.c:26
bool openocd_is_shutdown_pending(void)
Definition: server.c:752
#define CONNECTION_LIMIT_UNLIMITED
Definition: server.h:34
#define ERROR_SERVER_INTERRUPTED
Definition: server.h:121
#define foreach_smp_target(pos, head)
Definition: smp.h:15
struct target_type stm8_target
Definition: stm8.c:2202
struct breakpoint * next
Definition: breakpoints.h:34
unsigned int length
Definition: breakpoints.h:29
uint8_t * orig_instr
Definition: breakpoints.h:33
enum breakpoint_type type
Definition: breakpoints.h:30
unsigned int number
Definition: breakpoints.h:32
uint32_t asid
Definition: breakpoints.h:28
target_addr_t address
Definition: breakpoints.h:27
Jim_Interp * interp
Definition: command.h:53
struct target * current_target_override
Definition: command.h:57
struct target * current_target
Definition: command.h:55
When run_command is called, a new instance will be created on the stack, filled with the proper value...
Definition: command.h:76
const char * name
Definition: command.h:234
const struct command_registration * chain
If non-NULL, the commands in chain will be registered in the same context and scope of this registrat...
Definition: command.h:247
const char * usage
a string listing the options and arguments, required or optional
Definition: command.h:239
int length
Definition: target.c:6095
uint8_t * data
Definition: target.c:6094
target_addr_t address
Definition: target.c:6093
Definition: image.h:48
unsigned int num_sections
Definition: image.h:51
bool start_address_set
Definition: image.h:55
struct imagesection * sections
Definition: image.h:52
long long base_address
Definition: image.h:54
bool base_address_set
Definition: image.h:53
target_addr_t base_address
Definition: image.h:42
uint32_t size
Definition: image.h:43
A TCL -ish GetOpt like code.
Definition: jim-nvp.h:136
bool is_configure
Definition: jim-nvp.h:140
Definition: jtag.h:101
bool enabled
Is this TAP currently enabled?
Definition: jtag.h:109
char * dotted_name
Definition: jtag.h:104
Definition: list.h:41
Name Value Pairs, aka: NVP.
Definition: nvp.h:61
int value
Definition: nvp.h:63
const char * name
Definition: nvp.h:62
int(* get)(struct reg *reg)
Definition: register.h:152
int(* set)(struct reg *reg, uint8_t *buf)
Definition: register.h:153
const char * name
Definition: register.h:145
unsigned int num_regs
Definition: register.h:148
struct reg * reg_list
Definition: register.h:147
struct reg_cache * next
Definition: register.h:146
Definition: register.h:111
bool valid
Definition: register.h:126
bool exist
Definition: register.h:128
uint32_t size
Definition: register.h:132
uint8_t * value
Definition: register.h:122
bool hidden
Definition: register.h:130
bool dirty
Definition: register.h:124
const struct reg_arch_type * type
Definition: register.h:141
const char * name
Definition: register.h:113
const char * name
Definition: rtos.h:59
char *(* ps_command)(struct target *target)
Definition: rtos.h:71
Definition: rtos.h:35
const struct rtos_type * type
Definition: rtos.h:36
char * basedir
Base directory for semihosting I/O operations.
Jim_Interp * interp
Definition: target.c:58
Jim_Obj * body
Definition: target.c:59
struct list_head list
Definition: target.c:60
enum target_event event
Definition: target.c:57
int(* callback)(struct target *target, enum target_event event, void *priv)
Definition: target.h:301
struct target_event_callback * next
Definition: target.h:303
struct list_head lh
Definition: target.h:213
struct target * target
Definition: target.h:214
int(* callback)(struct target *target, enum target_reset_mode reset_mode, void *priv)
Definition: target.h:309
struct list_head list
Definition: target.h:307
int(* callback)(void *priv)
Definition: target.h:324
struct target_timer_callback * next
Definition: target.h:330
unsigned int time_ms
Definition: target.h:325
enum target_timer_type type
Definition: target.h:326
int(* callback)(struct target *target, size_t len, uint8_t *data, void *priv)
Definition: target.h:315
struct list_head list
Definition: target.h:313
This holds methods shared between all instances of a given target type.
Definition: target_type.h:26
int(* add_context_breakpoint)(struct target *target, struct breakpoint *breakpoint)
Definition: target_type.h:154
int(* add_breakpoint)(struct target *target, struct breakpoint *breakpoint)
Definition: target_type.h:153
int(* write_memory)(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Target memory write callback.
Definition: target_type.h:124
int(* hit_watchpoint)(struct target *target, struct watchpoint **hit_watchpoint)
Definition: target_type.h:175
const char * name
Name of this type of target.
Definition: target_type.h:31
int(* deassert_reset)(struct target *target)
The implementation is responsible for polling the target such that target->state reflects the state c...
Definition: target_type.h:76
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.
Definition: target_type.h:99
int(* resume)(struct target *target, bool current, target_addr_t address, bool handle_breakpoints, bool debug_execution)
Definition: target_type.h:45
void(* deinit_target)(struct target *target)
Free all the resources allocated by the target.
Definition: target_type.h:243
int(* halt)(struct target *target)
Definition: target_type.h:43
int(* check_reset)(struct target *target)
Definition: target_type.h:275
int(* gdb_fileio_end)(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
Definition: target_type.h:283
int(* blank_check_memory)(struct target *target, struct target_memory_check_block *blocks, int num_blocks, uint8_t erased_value)
Definition: target_type.h:137
int(* assert_reset)(struct target *target)
Definition: target_type.h:64
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.
Definition: target_type.h:181
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)
Definition: target_type.h:189
const struct command_registration * commands
Definition: target_type.h:194
int(* profiling)(struct target *target, uint32_t *samples, uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
Definition: target_type.h:296
int(* soft_reset_halt)(struct target *target)
Definition: target_type.h:77
const char *(* get_gdb_arch)(const struct target *target)
Target architecture for GDB.
Definition: target_type.h:86
int(* arch_state)(struct target *target)
Definition: target_type.h:37
unsigned int(* address_bits)(struct target *target)
Definition: target_type.h:302
int(* read_memory)(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Target memory read callback.
Definition: target_type.h:118
int(* get_gdb_fileio_info)(struct target *target, struct gdb_fileio_info *fileio_info)
Definition: target_type.h:279
unsigned int(* data_bits)(struct target *target)
Definition: target_type.h:307
int(* target_jim_configure)(struct target *target, struct jim_getopt_info *goi)
Definition: target_type.h:202
int(* step)(struct target *target, bool current, target_addr_t address, bool handle_breakpoints)
Definition: target_type.h:47
int(* read_phys_memory)(struct target *target, target_addr_t phys_address, uint32_t size, uint32_t count, uint8_t *buffer)
Definition: target_type.h:258
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.
Definition: target_type.h:105
int(* mmu)(struct target *target, int *enabled)
Definition: target_type.h:267
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)
Definition: target_type.h:185
int(* read_buffer)(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
Definition: target_type.h:128
int(* add_watchpoint)(struct target *target, struct watchpoint *watchpoint)
Definition: target_type.h:164
int(* target_create)(struct target *target)
Definition: target_type.h:197
int(* write_buffer)(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
Definition: target_type.h:132
int(* poll)(struct target *target)
Definition: target_type.h:34
int(* add_hybrid_breakpoint)(struct target *target, struct breakpoint *breakpoint)
Definition: target_type.h:155
int(* examine)(struct target *target)
This method is used to perform target setup that requires JTAG access.
Definition: target_type.h:218
int(* write_phys_memory)(struct target *target, target_addr_t phys_address, uint32_t size, uint32_t count, const uint8_t *buffer)
Definition: target_type.h:264
int(* remove_breakpoint)(struct target *target, struct breakpoint *breakpoint)
Definition: target_type.h:161
int(* virt2phys)(struct target *target, target_addr_t address, target_addr_t *physical)
Definition: target_type.h:248
int(* checksum_memory)(struct target *target, target_addr_t address, uint32_t count, uint32_t *checksum)
Definition: target_type.h:135
int(* remove_watchpoint)(struct target *target, struct watchpoint *watchpoint)
Definition: target_type.h:170
Definition: target.h:116
int32_t coreid
Definition: target.h:120
struct semihosting * semihosting
Definition: target.h:209
target_addr_t working_area
Definition: target.h:145
target_addr_t working_area_virt
Definition: target.h:148
uint32_t working_area_size
Definition: target.h:151
struct jtag_tap * tap
Definition: target.h:119
bool dbgbase_set
Definition: target.h:174
struct trace * trace_info
Definition: target.h:161
bool dbg_msg_enabled
Definition: target.h:163
enum target_debug_reason debug_reason
Definition: target.h:154
enum target_state state
Definition: target.h:157
uint32_t dbgbase
Definition: target.h:175
void * private_config
Definition: target.h:165
char * gdb_port_override
Definition: target.h:204
enum target_endianness endianness
Definition: target.h:155
struct reg_cache * reg_cache
Definition: target.h:158
bool backup_working_area
Definition: target.h:152
bool halt_issued
Definition: target.h:170
struct list_head * smp_targets
Definition: target.h:188
struct breakpoint * breakpoints
Definition: target.h:159
struct working_area * working_areas
Definition: target.h:153
bool verbose_halt_msg
Definition: target.h:168
bool dap_configured
Definition: target.h:179
struct rtos * rtos
Definition: target.h:183
struct gdb_fileio_info * fileio_info
Definition: target.h:202
struct debug_msg_receiver * dbgmsg
Definition: target.h:162
bool rtos_auto_detect
Definition: target.h:184
int64_t halt_issued_time
Definition: target.h:171
unsigned int smp
Definition: target.h:187
struct list_head events_action
Definition: target.h:142
struct target_type * type
Definition: target.h:117
struct backoff_timer backoff
Definition: target.h:186
target_addr_t working_area_phys
Definition: target.h:150
bool has_dap
Definition: target.h:178
bool tap_configured
Definition: target.h:180
struct watchpoint * watchpoints
Definition: target.h:160
bool working_area_phys_spec
Definition: target.h:149
bool running_alg
true if the target is currently running a downloaded "algorithm" instead of arbitrary user code.
Definition: target.h:140
void * arch_info
Definition: target.h:164
int gdb_max_connections
Definition: target.h:206
bool working_area_virt_spec
Definition: target.h:147
bool reset_halt
Definition: target.h:144
bool examined
Indicates whether this target has been examined.
Definition: target.h:131
char * cmd_name
Definition: target.h:118
bool defer_examine
Should we defer examine to later.
Definition: target.h:123
struct target * next
Definition: target.h:166
Definition: psoc6.c:83
Definition: trace.h:21
Wrapper for transport lifecycle operations.
Definition: transport.h:55
int(* override_target)(const char **targetname)
Optional.
Definition: transport.h:85
uint64_t mask
Definition: breakpoints.h:44
enum watchpoint_rw rw
Definition: breakpoints.h:46
struct watchpoint * next
Definition: breakpoints.h:49
unsigned int length
Definition: breakpoints.h:43
uint64_t value
Definition: breakpoints.h:45
target_addr_t address
Definition: breakpoints.h:42
uint32_t size
Definition: target.h:87
bool free
Definition: target.h:88
struct working_area * next
Definition: target.h:91
target_addr_t address
Definition: target.h:86
struct working_area ** user
Definition: target.h:90
uint8_t * backup
Definition: target.h:89
COMMAND_HANDLER(handle_target_init_command)
Definition: target.c:1571
static bool target_reset_nag
Definition: target.c:6267
void target_buffer_get_u16_array(struct target *target, const uint8_t *buffer, uint32_t count, uint16_t *dstbuf)
Definition: target.c:409
void target_buffer_set_u24(struct target *target, uint8_t *buffer, uint32_t value)
Definition: target.c:369
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.
Definition: target.c:1435
unsigned char UNIT[2]
Definition: target.c:4212
static int run_srst_deasserted
Definition: target.c:2861
int target_add_watchpoint(struct target *target, struct watchpoint *watchpoint)
Add the watchpoint for target.
Definition: target.c:1338
static int target_call_timer_callback(struct target_timer_callback *cb, int64_t *now)
Definition: target.c:1828
struct target * all_targets
Definition: target.c:115
static int target_get_gdb_fileio_info_default(struct target *target, struct gdb_fileio_info *fileio_info)
Definition: target.c:2282
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.
Definition: target.c:1092
int target_write_phys_u32(struct target *target, target_addr_t address, uint32_t value)
Definition: target.c:2730
uint64_t target_buffer_get_u64(struct target *target, const uint8_t *buffer)
Definition: target.c:315
int target_call_event_callbacks(struct target *target, enum target_event event)
Definition: target.c:1773
struct target * get_target(const char *id)
Definition: target.c:441
void target_free_all_working_areas(struct target *target)
Definition: target.c:2159
int target_unregister_reset_callback(int(*callback)(struct target *target, enum target_reset_mode reset_mode, void *priv), void *priv)
Definition: target.c:1719
int target_write_phys_u64(struct target *target, target_addr_t address, uint64_t value)
Definition: target.c:2709
static const struct nvp nvp_target_event[]
Definition: target.c:165
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)
Definition: target.c:2374
int target_unregister_event_callback(int(*callback)(struct target *target, enum target_event event, void *priv), void *priv)
Definition: target.c:1696
static void write_long(FILE *f, int l, struct target *target)
Definition: target.c:4199
int target_read_phys_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Definition: target.c:1260
static void binprint(struct command_invocation *cmd, const char *text, const uint8_t *buf, int size)
Definition: target.c:6302
int target_register_event_callback(int(*callback)(struct target *target, enum target_event event, void *priv), void *priv)
Definition: target.c:1601
static const struct command_registration target_command_handlers[]
Definition: target.c:6243
int target_write_phys_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Definition: target.c:1288
static int run_power_restore
Definition: target.c:2858
int target_halt(struct target *target)
Definition: target.c:515
static struct target_timer_callback * target_timer_callbacks
Definition: target.c:117
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.
Definition: target.c:1399
bool target_supports_gdb_connection(const struct target *target)
Check if target allows GDB connections.
Definition: target.c:1410
int target_arch_state(struct target *target)
Definition: target.c:2267
void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value)
Definition: target.c:378
static int target_free_working_area_restore(struct target *target, struct working_area *area, int restore)
Definition: target.c:2095
int target_call_timer_callbacks_now(void)
Invoke this to ensure that e.g.
Definition: target.c:1893
int target_remove_breakpoint(struct target *target, struct breakpoint *breakpoint)
Remove the breakpoint for target.
Definition: target.c:1332
static int target_profiling(struct target *target, uint32_t *samples, uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
Definition: target.c:1476
void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value)
Definition: target.c:360
int target_register_commands(struct command_context *cmd_ctx)
Definition: target.c:6262
static const struct nvp nvp_target_debug_reason[]
Definition: target.c:226
static int target_read_buffer_default(struct target *target, target_addr_t address, uint32_t count, uint8_t *buffer)
Definition: target.c:2439
int target_checksum_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t *crc)
Definition: target.c:2475
static void target_merge_working_areas(struct target *target)
Definition: target.c:1947
static const struct nvp nvp_target_state[]
Definition: target.c:217
static int handle_bp_command_list(struct command_invocation *cmd)
Definition: target.c:3924
int target_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
Definition: target.c:2350
static int get_target_with_common_rtos_type(struct command_invocation *cmd, struct list_head *lh, struct target **result)
Definition: target.c:5982
int target_add_hybrid_breakpoint(struct target *target, struct breakpoint *breakpoint)
Add the ContextID & IVA breakpoint for target.
Definition: target.c:1322
static int default_examine(struct target *target)
Definition: target.c:667
int target_write_u8(struct target *target, target_addr_t address, uint8_t value)
Definition: target.c:2691
int target_add_breakpoint(struct target *target, struct breakpoint *breakpoint)
Add the breakpoint for target.
Definition: target.c:1302
target_addr_t target_address_max(struct target *target)
Return the highest accessible address for this target.
Definition: target.c:1453
int target_write_u16(struct target *target, target_addr_t address, uint16_t value)
Definition: target.c:2670
int target_unregister_timer_callback(int(*callback)(void *priv), void *priv)
Definition: target.c:1757
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.
Definition: target.c:1444
int target_read_buffer(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
Definition: target.c:2415
int target_unregister_trace_callback(int(*callback)(struct target *target, size_t len, uint8_t *data, void *priv), void *priv)
Definition: target.c:1738
int target_read_u8(struct target *target, target_addr_t address, uint8_t *value)
Definition: target.c:2606
static void write_string(FILE *f, char *s)
Definition: target.c:4207
int target_blank_check_memory(struct target *target, struct target_memory_check_block *blocks, int num_blocks, uint8_t erased_value)
Definition: target.c:2519
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.
Definition: target.c:782
static void target_buffer_set_u8(struct target *target, uint8_t *buffer, uint8_t value)
Definition: target.c:387
unsigned int target_address_bits(struct target *target)
Return the number of address bits this target supports.
Definition: target.c:1462
static struct target_list * __attribute__((warn_unused_result))
Definition: target.c:5964
int target_profiling_default(struct target *target, uint32_t *samples, uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
Definition: target.c:2298
static const struct command_registration target_subcommand_handlers[]
Definition: target.c:6044
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.
Definition: target.c:1274
static int jtag_enable_callback(enum jtag_event event, void *priv)
Definition: target.c:703
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.
Definition: target.c:1377
static const struct nvp nvp_error_target[]
Definition: target.c:139
int target_call_timer_callbacks(void)
Definition: target.c:1887
int target_write_u64(struct target *target, target_addr_t address, uint64_t value)
Definition: target.c:2628
static struct target_event_callback * target_event_callbacks
Definition: target.c:116
static COMMAND_HELPER(parse_load_image_command, struct image *image, target_addr_t *min_address, target_addr_t *max_address)
Definition: target.c:3586
struct target * get_current_target_or_null(struct command_context *cmd_ctx)
Definition: target.c:478
static void target_split_working_area(struct working_area *area, uint32_t size)
Definition: target.c:1917
const char * target_debug_reason_str(enum target_debug_reason reason)
Definition: target.c:6775
static int target_init(struct command_context *cmd_ctx)
Definition: target.c:1545
int target_hit_watchpoint(struct target *target, struct watchpoint **hit_watchpoint)
Find out the just hit watchpoint for target.
Definition: target.c:1352
int target_call_reset_callbacks(struct target *target, enum target_reset_mode reset_mode)
Definition: target.c:1798
uint32_t target_get_working_area_avail(struct target *target)
Definition: target.c:2173
target_cfg_param
Definition: target.c:4842
@ TCFG_GDB_MAX_CONNECTIONS
Definition: target.c:4856
@ TCFG_CHAIN_POSITION
Definition: target.c:4851
@ TCFG_GDB_PORT
Definition: target.c:4855
@ TCFG_WORK_AREA_VIRT
Definition: target.c:4845
@ TCFG_TYPE
Definition: target.c:4843
@ TCFG_WORK_AREA_BACKUP
Definition: target.c:4848
@ TCFG_RTOS
Definition: target.c:4853
@ TCFG_DBGBASE
Definition: target.c:4852
@ TCFG_WORK_AREA_PHYS
Definition: target.c:4846
@ TCFG_ENDIAN
Definition: target.c:4849
@ TCFG_WORK_AREA_SIZE
Definition: target.c:4847
@ TCFG_EVENT
Definition: target.c:4844
@ TCFG_DEFER_EXAMINE
Definition: target.c:4854
@ TCFG_COREID
Definition: target.c:4850
int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
Definition: target.c:2069
static const struct command_registration target_instance_command_handlers[]
Definition: target.c:5520
bool get_target_reset_nag(void)
Definition: target.c:6269
unsigned int target_data_bits(struct target *target)
Return the number of data bits this target supports.
Definition: target.c:1469
static int find_target(struct command_invocation *cmd, const char *name)
Definition: target.c:2790
int target_remove_watchpoint(struct target *target, struct watchpoint *watchpoint)
Remove the watchpoint for target.
Definition: target.c:1347
const char * target_event_name(enum target_event event)
Return the name of a target event enumeration value.
Definition: target.c:283
int target_write_u32(struct target *target, target_addr_t address, uint32_t value)
Definition: target.c:2649
int target_examine_one(struct target *target)
Examine the specified target, letting it perform any Initialisation that requires JTAG access.
Definition: target.c:681
static int power_dropout
Definition: target.c:2855
const char * target_state_name(const struct target *t)
Return the name of this targets current state.
Definition: target.c:268
int(* target_write_fn)(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Definition: target.c:3475
static void print_wa_layout(struct target *target)
Definition: target.c:1904
#define DEFAULT_HALT_TIMEOUT
Definition: target.c:54
int target_poll(struct target *target)
Definition: target.c:485
static int target_call_timer_callbacks_check_time(int checktime)
Definition: target.c:1839
static int sense_handler(void)
Definition: target.c:2863
static int target_timer_callback_periodic_restart(struct target_timer_callback *cb, int64_t *now)
Definition: target.c:1821
int target_free_working_area(struct target *target, struct working_area *area)
Free a working area.
Definition: target.c:2127
static int srst_asserted
Definition: target.c:2856
static int fastload_num
Definition: target.c:6099
static const struct nvp nvp_target_endian[]
Definition: target.c:239
int target_alloc_working_area_try(struct target *target, uint32_t size, struct working_area **area)
Definition: target.c:1975
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...
Definition: target.c:1667
static struct nvp nvp_config_opts[]
Definition: target.c:4859
int target_read_u16(struct target *target, target_addr_t address, uint16_t *value)
Definition: target.c:2582
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...
Definition: target.c:939
void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value)
Definition: target.c:351
static const int polling_interval
Definition: target.c:121
void target_buffer_set_u64_array(struct target *target, uint8_t *buffer, uint32_t count, const uint64_t *srcbuf)
Definition: target.c:417
static void target_reset_examined(struct target *target)
Reset the examined flag for the given target.
Definition: target.c:662
int target_add_context_breakpoint(struct target *target, struct breakpoint *breakpoint)
Add the ContextID breakpoint for target.
Definition: target.c:1312
static int target_init_one(struct command_context *cmd_ctx, struct target *target)
Definition: target.c:1485
static int run_power_dropout
Definition: target.c:2859
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...
Definition: target.c:564
int target_read_u32(struct target *target, target_addr_t address, uint32_t *value)
Definition: target.c:2558
uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer)
Definition: target.c:342
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.
Definition: target.c:1246
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.
Definition: target.c:4831
static const struct command_registration target_exec_command_handlers[]
Definition: target.c:6492
void target_buffer_get_u64_array(struct target *target, const uint8_t *buffer, uint32_t count, uint64_t *dstbuf)
Definition: target.c:393
static const struct nvp nvp_reset_modes[]
Definition: target.c:247
const char * debug_reason_name(const struct target *t)
Definition: target.c:255
static int default_check_reset(struct target *target)
Definition: target.c:674
void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, const uint16_t *srcbuf)
Definition: target.c:433
static struct fast_load * fastload
Definition: target.c:6100
int target_register_reset_callback(int(*callback)(struct target *target, enum target_reset_mode reset_mode, void *priv), void *priv)
Definition: target.c:1623
uint32_t target_buffer_get_u24(struct target *target, const uint8_t *buffer)
Definition: target.c:333
static int run_srst_asserted
Definition: target.c:2860
void target_buffer_get_u32_array(struct target *target, const uint8_t *buffer, uint32_t count, uint32_t *dstbuf)
Definition: target.c:401
int64_t target_timer_next_event(void)
Returns when the next registered event will take place.
Definition: target.c:1898
verify_mode
Definition: target.c:3764
@ IMAGE_TEST
Definition: target.c:3765
@ IMAGE_VERIFY
Definition: target.c:3766
@ IMAGE_CHECKSUM_ONLY
Definition: target.c:3767
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)
Definition: target.c:3353
int target_write_phys_u16(struct target *target, target_addr_t address, uint16_t value)
Definition: target.c:2751
static void free_fastload(void)
Definition: target.c:6102
static int handle_target(void *priv)
Definition: target.c:2916
const char * target_get_gdb_arch(const struct target *target)
Obtain the architecture for GDB.
Definition: target.c:1370
static int target_restore_working_area(struct target *target, struct working_area *area)
Definition: target.c:2080
nvp_assert
Definition: target.c:124
@ NVP_ASSERT
Definition: target.c:126
@ NVP_DEASSERT
Definition: target.c:125
static int target_gdb_fileio_end_default(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
Definition: target.c:2292
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.
Definition: target.c:867
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)
Definition: target.c:3478
static void target_destroy(struct target *target)
Definition: target.c:2191
int target_wait_state(struct target *target, enum target_state state, unsigned int ms)
Definition: target.c:3221
int target_step(struct target *target, bool current, target_addr_t address, bool handle_breakpoints)
Step the target.
Definition: target.c:1419
int target_examine(void)
Definition: target.c:720
int target_register_trace_callback(int(*callback)(struct target *target, size_t len, uint8_t *data, void *priv), void *priv)
Definition: target.c:1645
struct target * get_current_target(struct command_context *cmd_ctx)
Definition: target.c:466
void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, const uint32_t *srcbuf)
Definition: target.c:425
static int handle_bp_command_set(struct command_invocation *cmd, target_addr_t addr, uint32_t asid, unsigned int length, int hw)
Definition: target.c:3959
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)
Definition: target.c:4215
static int identity_virt2phys(struct target *target, target_addr_t virtual, target_addr_t *physical)
Definition: target.c:645
static int target_register_user_commands(struct command_context *cmd_ctx)
Definition: target.c:6760
static void append_to_list_all_targets(struct target *target)
Definition: target.c:305
void target_handle_event(struct target *target, enum target_event e)
Definition: target.c:4667
uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer)
Definition: target.c:324
static int target_soft_reset_halt(struct target *target)
Definition: target.c:750
const char * target_type_name(const struct target *target)
Get the target type name.
Definition: target.c:745
static int no_mmu(struct target *target, int *enabled)
Definition: target.c:652
int target_call_trace_callbacks(struct target *target, size_t len, uint8_t *data)
Definition: target.c:1811
static int target_process_reset(struct command_invocation *cmd, enum target_reset_mode reset_mode)
Definition: target.c:602
static const char * target_strerror_safe(int err)
Definition: target.c:154
static int64_t target_timer_next_event_value
Definition: target.c:118
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.
Definition: target.c:823
static void write_data(FILE *f, const void *data, size_t len)
Definition: target.c:4192
void target_quit(void)
Free all the resources allocated by targets and the target layer.
Definition: target.c:2238
int target_write_phys_u8(struct target *target, target_addr_t address, uint8_t value)
Definition: target.c:2772
static struct target_type * target_types[]
Definition: target.c:73
int target_read_u64(struct target *target, target_addr_t address, uint64_t *value)
Definition: target.c:2534
const char * target_reset_mode_name(enum target_reset_mode reset_mode)
Return the name of a target reset reason enumeration value.
Definition: target.c:294
static void target_free_all_working_areas_restore(struct target *target, int restore)
Definition: target.c:2135
target_debug_reason
Definition: target.h:68
@ DBG_REASON_WPTANDBKPT
Definition: target.h:72
@ DBG_REASON_UNDEFINED
Definition: target.h:77
@ DBG_REASON_EXIT
Definition: target.h:75
@ DBG_REASON_NOTHALTED
Definition: target.h:74
@ DBG_REASON_DBGRQ
Definition: target.h:69
@ DBG_REASON_SINGLESTEP
Definition: target.h:73
@ DBG_REASON_WATCHPOINT
Definition: target.h:71
@ DBG_REASON_EXC_CATCH
Definition: target.h:76
@ DBG_REASON_BREAKPOINT
Definition: target.h:70
target_reset_mode
Definition: target.h:61
@ RESET_RUN
Definition: target.h:63
@ RESET_HALT
Definition: target.h:64
@ RESET_UNKNOWN
Definition: target.h:62
@ RESET_INIT
Definition: target.h:65
target_register_class
Definition: target.h:110
#define ERROR_TARGET_NOT_HALTED
Definition: target.h:783
#define ERROR_TARGET_INIT_FAILED
Definition: target.h:781
static bool target_was_examined(const struct target *target)
Definition: target.h:429
#define ERROR_TARGET_UNALIGNED_ACCESS
Definition: target.h:785
#define ERROR_TARGET_INVALID
Definition: target.h:780
target_timer_type
Definition: target.h:318
@ TARGET_TIMER_TYPE_PERIODIC
Definition: target.h:320
target_event
Definition: target.h:240
@ TARGET_EVENT_DEBUG_RESUMED
Definition: target.h:272
@ TARGET_EVENT_EXAMINE_START
Definition: target.h:274
@ TARGET_EVENT_RESET_START
Definition: target.h:262
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X106
Definition: target.h:294
@ TARGET_EVENT_GDB_FLASH_WRITE_END
Definition: target.h:284
@ TARGET_EVENT_RESET_END
Definition: target.h:269
@ TARGET_EVENT_RESET_ASSERT_POST
Definition: target.h:265
@ TARGET_EVENT_RESET_DEASSERT_POST
Definition: target.h:267
@ TARGET_EVENT_HALTED
Definition: target.h:252
@ TARGET_EVENT_RESUMED
Definition: target.h:253
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X102
Definition: target.h:290
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X107
Definition: target.h:295
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X105
Definition: target.h:293
@ TARGET_EVENT_EXAMINE_FAIL
Definition: target.h:275
@ TARGET_EVENT_GDB_START
Definition: target.h:259
@ TARGET_EVENT_EXAMINE_END
Definition: target.h:276
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X104
Definition: target.h:292
@ TARGET_EVENT_RESET_INIT
Definition: target.h:268
@ TARGET_EVENT_GDB_END
Definition: target.h:260
@ TARGET_EVENT_RESET_DEASSERT_PRE
Definition: target.h:266
@ TARGET_EVENT_GDB_FLASH_ERASE_START
Definition: target.h:281
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X103
Definition: target.h:291
@ TARGET_EVENT_DEBUG_HALTED
Definition: target.h:271
@ TARGET_EVENT_RESET_ASSERT_PRE
Definition: target.h:263
@ TARGET_EVENT_RESET_ASSERT
Definition: target.h:264
@ TARGET_EVENT_GDB_FLASH_WRITE_START
Definition: target.h:283
@ TARGET_EVENT_RESUME_START
Definition: target.h:254
@ TARGET_EVENT_STEP_END
Definition: target.h:257
@ TARGET_EVENT_STEP_START
Definition: target.h:256
@ TARGET_EVENT_GDB_ATTACH
Definition: target.h:278
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X100
Definition: target.h:288
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X101
Definition: target.h:289
@ TARGET_EVENT_RESUME_END
Definition: target.h:255
@ TARGET_EVENT_GDB_FLASH_ERASE_END
Definition: target.h:282
@ TARGET_EVENT_GDB_DETACH
Definition: target.h:279
@ TARGET_EVENT_TRACE_CONFIG
Definition: target.h:286
@ TARGET_EVENT_GDB_HALT
Definition: target.h:251
static const char * target_name(const struct target *target)
Returns the instance-specific name of the specified target.
Definition: target.h:233
target_state
Definition: target.h:53
@ TARGET_RESET
Definition: target.h:57
@ TARGET_DEBUG_RUNNING
Definition: target.h:58
@ TARGET_UNKNOWN
Definition: target.h:54
@ TARGET_HALTED
Definition: target.h:56
@ TARGET_RUNNING
Definition: target.h:55
#define ERROR_TARGET_NOT_EXAMINED
Definition: target.h:790
@ TARGET_BIG_ENDIAN
Definition: target.h:82
@ TARGET_ENDIAN_UNKNOWN
Definition: target.h:81
@ TARGET_LITTLE_ENDIAN
Definition: target.h:82
#define TARGET_DEFAULT_POLLING_INTERVAL
Definition: target.h:799
#define ERROR_TARGET_TIMEOUT
Definition: target.h:782
#define ERROR_TARGET_RESOURCE_NOT_AVAILABLE
Definition: target.h:787
static void target_set_examined(struct target *target)
Sets the examined flag for the given target.
Definition: target.h:436
#define ERROR_TARGET_NOT_RUNNING
Definition: target.h:789
#define ERROR_TARGET_DATA_ABORT
Definition: target.h:786
#define ERROR_TARGET_FAILURE
Definition: target.h:784
#define ERROR_TARGET_TRANSLATION_FAULT
Definition: target.h:788
int target_request_register_commands(struct command_context *cmd_ctx)
struct target_type testee_target
Definition: testee.c:53
struct target_type xtensa_chip_target
Methods for generic example of Xtensa-based chip-level targets.
Definition: xtensa_chip.c:151
struct target_type xscale_target
Definition: xscale.c:3705
float duration_elapsed(const struct duration *duration)
Definition: time_support.c:83
int timeval_compare(const struct timeval *x, const struct timeval *y)
Definition: time_support.c:55
int timeval_add_time(struct timeval *result, long sec, long usec)
Definition: time_support.c:41
int duration_measure(struct duration *duration)
Update the duration->elapsed field to finish the duration measurement.
Definition: time_support.c:74
int duration_start(struct duration *duration)
Update the duration->start field to start the duration measurement.
Definition: time_support.c:69
float duration_kbps(const struct duration *duration, size_t count)
Definition: time_support.c:90
int64_t timeval_ms(void)
int trace_register_commands(struct command_context *cmd_ctx)
Definition: trace.c:159
struct transport * get_current_transport(void)
Returns the transport currently being used by this debug or programming session.
Definition: transport.c:252
static void h_u32_to_be(uint8_t *buf, uint32_t val)
Definition: types.h:186
static uint64_t le_to_h_u64(const uint8_t *buf)
Definition: types.h:100
static uint32_t be_to_h_u24(const uint8_t *buf)
Definition: types.h:144
static void h_u16_to_be(uint8_t *buf, uint16_t val)
Definition: types.h:214
static uint64_t be_to_h_u64(const uint8_t *buf)
Definition: types.h:127
static uint16_t le_to_h_u16(const uint8_t *buf)
Definition: types.h:122
static uint32_t le_to_h_u24(const uint8_t *buf)
Definition: types.h:117
#define TARGET_ADDR_FMT
Definition: types.h:342
static void h_u32_to_le(uint8_t *buf, uint32_t val)
Definition: types.h:178
#define DIV_ROUND_UP(m, n)
Rounds m up to the nearest multiple of n using division.
Definition: types.h:79
static uint32_t be_to_h_u32(const uint8_t *buf)
Definition: types.h:139
uint64_t target_addr_t
Definition: types.h:335
static void h_u24_to_le(uint8_t *buf, unsigned int val)
Definition: types.h:194
static void h_u24_to_be(uint8_t *buf, unsigned int val)
Definition: types.h:201
static uint16_t be_to_h_u16(const uint8_t *buf)
Definition: types.h:149
static void h_u16_to_le(uint8_t *buf, uint16_t val)
Definition: types.h:208
static uint32_t le_to_h_u32(const uint8_t *buf)
Definition: types.h:112
static void h_u64_to_be(uint8_t *buf, uint64_t val)
Definition: types.h:166
static void h_u64_to_le(uint8_t *buf, uint64_t val)
Definition: types.h:154
#define NULL
Definition: usb.h:16
uint8_t cmd
Definition: vdebug.c:1
uint8_t offset[4]
Definition: vdebug.c:9
uint8_t state[4]
Definition: vdebug.c:21
uint8_t count[4]
Definition: vdebug.c:22