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  if (e == JIM_OK) {
4893  /* more? */
4894  continue;
4895  }
4896  if (e == JIM_ERR) {
4897  /* An error */
4898  int reslen;
4899  const char *result = Jim_GetString(Jim_GetResult(CMD_CTX->interp), &reslen);
4900  if (reslen > 0)
4901  command_print(CMD, "%s", result);
4902  return ERROR_FAIL;
4903  }
4904  /* otherwise we 'continue' below */
4905  }
4907  if (!n->name) {
4910  }
4911  index++;
4912  switch (n->value) {
4913  case TCFG_TYPE:
4914  /* not settable */
4915  if (is_configure) {
4916  command_print(CMD, "not settable: %s", n->name);
4918  }
4919  if (index != CMD_ARGC)
4922  /* loop for more */
4923  break;
4924 
4925  case TCFG_EVENT:
4926  if (index == CMD_ARGC) {
4927  command_print(CMD, "missing event-name");
4929  }
4930 
4932  if (!n->name) {
4935  }
4936  index++;
4937 
4938  if (is_configure) {
4939  if (index == CMD_ARGC) {
4940  command_print(CMD, "missing event-body");
4942  }
4943  }
4944 
4945  {
4946  struct target_event_action *teap;
4947 
4948  /* replace existing? */
4950  if (teap->event == (enum target_event)n->value)
4951  break;
4952 
4953  /* not found! */
4954  if (&teap->list == &target->events_action)
4955  teap = NULL;
4956 
4957  if (is_configure) {
4958  /* START_DEPRECATED_TPIU */
4959  if (n->value == TARGET_EVENT_TRACE_CONFIG)
4960  LOG_INFO("DEPRECATED target event %s; use TPIU events {pre,post}-{enable,disable}", n->name);
4961  /* END_DEPRECATED_TPIU */
4962 
4963  if (strlen(CMD_ARGV[index]) == 0) {
4964  /* empty action, drop existing one */
4965  if (teap) {
4966  list_del(&teap->list);
4967  Jim_DecrRefCount(teap->interp, teap->body);
4968  free(teap);
4969  }
4970  index++;
4971  break;
4972  }
4973 
4974  bool replace = true;
4975  if (!teap) {
4976  /* create new */
4977  teap = calloc(1, sizeof(*teap));
4978  replace = false;
4979  }
4980  teap->event = n->value;
4981  teap->interp = CMD_CTX->interp;
4982  if (teap->body)
4983  Jim_DecrRefCount(teap->interp, teap->body);
4984  /* use jim object to keep its reference on tcl file and line */
4985  /* TODO: need duplicate? isn't IncrRefCount enough? */
4986  teap->body = Jim_DuplicateObj(teap->interp, CMD_JIMTCL_ARGV[index++]);
4987  /*
4988  * FIXME:
4989  * Tcl/TK - "tk events" have a nice feature.
4990  * See the "BIND" command.
4991  * We should support that here.
4992  * You can specify %X and %Y in the event code.
4993  * The idea is: %T - target name.
4994  * The idea is: %N - target number
4995  * The idea is: %E - event name.
4996  */
4997  Jim_IncrRefCount(teap->body);
4998 
4999  if (!replace) {
5000  /* add to head of event list */
5001  list_add(&teap->list, &target->events_action);
5002  }
5003  } else {
5004  /* cget */
5005  if (index != CMD_ARGC)
5007 
5008  if (teap)
5009  command_print(CMD, "%s", Jim_GetString(teap->body, NULL));
5010  }
5011  }
5012  /* loop for more */
5013  break;
5014 
5015  case TCFG_WORK_AREA_VIRT:
5016  if (is_configure) {
5017  if (index == CMD_ARGC) {
5018  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5020  }
5022  index++;
5025  } else {
5026  if (index != CMD_ARGC)
5029  }
5030  /* loop for more */
5031  break;
5032 
5033  case TCFG_WORK_AREA_PHYS:
5034  if (is_configure) {
5035  if (index == CMD_ARGC) {
5036  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5038  }
5040  index++;
5043  } else {
5044  if (index != CMD_ARGC)
5047  }
5048  /* loop for more */
5049  break;
5050 
5051  case TCFG_WORK_AREA_SIZE:
5052  if (is_configure) {
5053  if (index == CMD_ARGC) {
5054  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5056  }
5058  index++;
5060  } else {
5061  if (index != CMD_ARGC)
5063  command_print(CMD, "0x%08" PRIx32, target->working_area_size);
5064  }
5065  /* loop for more */
5066  break;
5067 
5068  case TCFG_WORK_AREA_BACKUP:
5069  if (is_configure) {
5070  if (index == CMD_ARGC) {
5071  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5073  }
5075  if (retval != ERROR_OK)
5076  return retval;
5077  index++;
5079  } else {
5080  if (index != CMD_ARGC)
5083  }
5084  /* loop for more */
5085  break;
5086 
5087  case TCFG_ENDIAN:
5088  if (is_configure) {
5089  if (index == CMD_ARGC) {
5090  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5092  }
5094  if (!n->name) {
5097  }
5098  index++;
5099  target->endianness = n->value;
5100  } else {
5101  if (index != CMD_ARGC)
5104  if (!n->name) {
5107  }
5108  command_print(CMD, "%s", n->name);
5109  }
5110  /* loop for more */
5111  break;
5112 
5113  case TCFG_COREID:
5114  if (is_configure) {
5115  if (index == CMD_ARGC) {
5116  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5118  }
5119  COMMAND_PARSE_NUMBER(s32, CMD_ARGV[index], target->coreid);
5120  index++;
5121  } else {
5122  if (index != CMD_ARGC)
5124  command_print(CMD, "%" PRIi32, target->coreid);
5125  }
5126  /* loop for more */
5127  break;
5128 
5129  case TCFG_CHAIN_POSITION:
5130  if (is_configure) {
5131  if (target->has_dap) {
5132  command_print(CMD, "target requires -dap parameter instead of -chain-position!");
5134  }
5135 
5136  if (index == CMD_ARGC) {
5137  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5139  }
5140  struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[index]);
5141  if (!tap) {
5142  command_print(CMD, "Tap '%s' could not be found", CMD_ARGV[index]);
5144  }
5145  index++;
5146  target->tap = tap;
5147  target->tap_configured = true;
5148  } else {
5149  if (index != CMD_ARGC)
5152  }
5153  /* loop for more */
5154  break;
5155 
5156  case TCFG_DBGBASE:
5157  if (is_configure) {
5158  if (index == CMD_ARGC) {
5159  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5161  }
5163  index++;
5164  target->dbgbase_set = true;
5165  } else {
5166  if (index != CMD_ARGC)
5168  command_print(CMD, "0x%08" PRIx32, target->dbgbase);
5169  }
5170  /* loop for more */
5171  break;
5172 
5173  case TCFG_RTOS:
5174  if (is_configure) {
5175  if (index == CMD_ARGC) {
5176  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5178  }
5179  struct jim_getopt_info goi;
5180  jim_getopt_setup(&goi, CMD_CTX->interp, CMD_ARGC - index, CMD_JIMTCL_ARGV + index);
5181  index++;
5182  goi.is_configure = true;
5183  int resval = rtos_create(&goi, target);
5184  int reslen;
5185  const char *result = Jim_GetString(Jim_GetResult(CMD_CTX->interp), &reslen);
5186  if (reslen > 0)
5187  command_print(CMD, "%s", result);
5188  if (resval != JIM_OK)
5189  return ERROR_FAIL;
5190  } else {
5191  if (index != CMD_ARGC)
5193  if (target->rtos)
5194  command_print(CMD, "%s", target->rtos->type->name);
5195  }
5196  /* loop for more */
5197  break;
5198 
5199  case TCFG_DEFER_EXAMINE:
5200  if (is_configure)
5201  target->defer_examine = true;
5202  else
5203  command_print(CMD, "%s", target->defer_examine ? "true" : "false");
5204  /* loop for more */
5205  break;
5206 
5207  case TCFG_GDB_PORT:
5208  if (is_configure) {
5209  if (index == CMD_ARGC) {
5210  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5212  }
5213 
5214  /* TODO: generalize test of COMMAND_CONFIG */
5215  if (CMD_CTX->mode != COMMAND_CONFIG) {
5216  command_print(CMD, "-gdb-port must be configured before 'init'");
5218  }
5219 
5220  char *s = strdup(CMD_ARGV[index]);
5221  if (!s) {
5222  LOG_ERROR("Out of memory");
5223  return ERROR_FAIL;
5224  }
5225  free(target->gdb_port_override);
5227  index++;
5228  } else {
5229  if (index != CMD_ARGC)
5232  }
5233  /* loop for more */
5234  break;
5235 
5237  if (is_configure) {
5238  if (index == CMD_ARGC) {
5239  command_print(CMD, "missing argument to %s", CMD_ARGV[index - 1]);
5241  }
5242 
5243  if (CMD_CTX->mode != COMMAND_CONFIG) {
5244  command_print(CMD, "-gdb-max-connections must be configured before 'init'");
5246  }
5247 
5249  index++;
5250  if (target->gdb_max_connections < 0)
5252  } else {
5253  if (index != CMD_ARGC)
5256  }
5257  /* loop for more */
5258  break;
5259  }
5260  }
5261 
5262  return ERROR_OK;
5263 }
5264 
5265 COMMAND_HANDLER(handle_target_configure)
5266 {
5267  if (!CMD_ARGC)
5269 
5270  bool is_configure = !strcmp(CMD_NAME, "configure");
5271 
5273 
5274  return CALL_COMMAND_HANDLER(target_configure, target, 0, is_configure);
5275 }
5276 
5277 COMMAND_HANDLER(handle_target_examine)
5278 {
5279  bool allow_defer = false;
5280 
5281  if (CMD_ARGC > 1)
5283 
5284  if (CMD_ARGC == 1) {
5285  if (strcmp(CMD_ARGV[0], "allow-defer"))
5287  allow_defer = true;
5288  }
5289 
5291  if (!target->tap->enabled) {
5292  command_print(CMD, "[TAP is disabled]");
5293  return ERROR_FAIL;
5294  }
5295 
5296  if (allow_defer && target->defer_examine) {
5297  LOG_INFO("Deferring arp_examine of %s", target_name(target));
5298  LOG_INFO("Use arp_examine command to examine it manually!");
5299  return ERROR_OK;
5300  }
5301 
5302  int retval = target->type->examine(target);
5303  if (retval != ERROR_OK) {
5305  return retval;
5306  }
5307 
5309 
5310  return ERROR_OK;
5311 }
5312 
5313 COMMAND_HANDLER(handle_target_was_examined)
5314 {
5315  if (CMD_ARGC != 0)
5317 
5319 
5320  command_print(CMD, "%d", target_was_examined(target) ? 1 : 0);
5321 
5322  return ERROR_OK;
5323 }
5324 
5325 COMMAND_HANDLER(handle_target_examine_deferred)
5326 {
5327  if (CMD_ARGC != 0)
5329 
5331 
5332  command_print(CMD, "%d", target->defer_examine ? 1 : 0);
5333 
5334  return ERROR_OK;
5335 }
5336 
5337 COMMAND_HANDLER(handle_target_halt_gdb)
5338 {
5339  if (CMD_ARGC != 0)
5341 
5343 
5345 }
5346 
5347 COMMAND_HANDLER(handle_target_poll)
5348 {
5349  if (CMD_ARGC != 0)
5351 
5353  if (!target->tap->enabled) {
5354  command_print(CMD, "[TAP is disabled]");
5355  return ERROR_FAIL;
5356  }
5357 
5358  if (!(target_was_examined(target)))
5360 
5361  return target->type->poll(target);
5362 }
5363 
5364 COMMAND_HANDLER(handle_target_reset)
5365 {
5366  if (CMD_ARGC != 2)
5368 
5369  const struct nvp *n = nvp_name2value(nvp_assert, CMD_ARGV[0]);
5370  if (!n->name) {
5373  }
5374 
5375  /* the halt or not param */
5376  int a;
5377  COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], a);
5378 
5380  if (!target->tap->enabled) {
5381  command_print(CMD, "[TAP is disabled]");
5382  return ERROR_FAIL;
5383  }
5384 
5386  command_print(CMD, "No target-specific reset for %s", target_name(target));
5387  return ERROR_FAIL;
5388  }
5389 
5390  /* determine if we should halt or not. */
5391  target->reset_halt = (a != 0);
5392  /* When this happens - all workareas are invalid. */
5394 
5395  /* do the assert */
5396  if (n->value == NVP_ASSERT) {
5397  int retval = target->type->assert_reset(target);
5398  if (target->defer_examine)
5400  return retval;
5401  }
5402 
5403  return target->type->deassert_reset(target);
5404 }
5405 
5406 COMMAND_HANDLER(handle_target_halt)
5407 {
5408  if (CMD_ARGC != 0)
5410 
5412  if (!target->tap->enabled) {
5413  command_print(CMD, "[TAP is disabled]");
5414  return ERROR_FAIL;
5415  }
5416 
5417  return target->type->halt(target);
5418 }
5419 
5420 COMMAND_HANDLER(handle_target_wait_state)
5421 {
5422  if (CMD_ARGC != 2)
5424 
5425  const struct nvp *n = nvp_name2value(nvp_target_state, CMD_ARGV[0]);
5426  if (!n->name) {
5429  }
5430 
5431  unsigned int a;
5432  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], a);
5433 
5435  if (!target->tap->enabled) {
5436  command_print(CMD, "[TAP is disabled]");
5437  return ERROR_FAIL;
5438  }
5439 
5440  int retval = target_wait_state(target, n->value, a);
5441  if (retval != ERROR_OK) {
5443  "target: %s wait %s fails (%d) %s",
5444  target_name(target), n->name,
5445  retval, target_strerror_safe(retval));
5446  return retval;
5447  }
5448  return ERROR_OK;
5449 }
5450 /* List for human, Events defined for this target.
5451  * scripts/programs should use 'name cget -event NAME'
5452  */
5453 COMMAND_HANDLER(handle_target_event_list)
5454 {
5456  struct target_event_action *teap;
5457 
5458  command_print(CMD, "Event actions for target %s\n",
5459  target_name(target));
5460  command_print(CMD, "%-25s | Body", "Event");
5461  command_print(CMD, "------------------------- | "
5462  "----------------------------------------");
5463 
5465  command_print(CMD, "%-25s | %s",
5466  target_event_name(teap->event),
5467  Jim_GetString(teap->body, NULL));
5468 
5469  command_print(CMD, "***END***");
5470  return ERROR_OK;
5471 }
5472 
5473 COMMAND_HANDLER(handle_target_current_state)
5474 {
5475  if (CMD_ARGC != 0)
5477 
5479 
5481 
5482  return ERROR_OK;
5483 }
5484 
5485 COMMAND_HANDLER(handle_target_debug_reason)
5486 {
5487  if (CMD_ARGC != 0)
5489 
5491 
5492 
5495 
5496  if (!debug_reason) {
5497  command_print(CMD, "bug: invalid debug reason (%d)",
5498  target->debug_reason);
5499  return ERROR_FAIL;
5500  }
5501 
5502  command_print(CMD, "%s", debug_reason);
5503 
5504  return ERROR_OK;
5505 }
5506 
5507 COMMAND_HANDLER(handle_target_invoke_event)
5508 {
5509  if (CMD_ARGC != 1)
5511 
5512  const struct nvp *n = nvp_name2value(nvp_target_event, CMD_ARGV[0]);
5513  if (!n->name) {
5516  }
5517 
5520  return ERROR_OK;
5521 }
5522 
5524  {
5525  .name = "configure",
5526  .mode = COMMAND_ANY,
5527  .handler = handle_target_configure,
5528  .help = "configure a new target for use",
5529  .usage = "[target_attribute ...]",
5530  },
5531  {
5532  .name = "cget",
5533  .mode = COMMAND_ANY,
5534  .handler = handle_target_configure,
5535  .help = "returns the specified target attribute",
5536  .usage = "target_attribute",
5537  },
5538  {
5539  .name = "mwd",
5540  .handler = handle_mw_command,
5541  .mode = COMMAND_EXEC,
5542  .help = "Write 64-bit word(s) to target memory",
5543  .usage = "address data [count]",
5544  },
5545  {
5546  .name = "mww",
5547  .handler = handle_mw_command,
5548  .mode = COMMAND_EXEC,
5549  .help = "Write 32-bit word(s) to target memory",
5550  .usage = "address data [count]",
5551  },
5552  {
5553  .name = "mwh",
5554  .handler = handle_mw_command,
5555  .mode = COMMAND_EXEC,
5556  .help = "Write 16-bit half-word(s) to target memory",
5557  .usage = "address data [count]",
5558  },
5559  {
5560  .name = "mwb",
5561  .handler = handle_mw_command,
5562  .mode = COMMAND_EXEC,
5563  .help = "Write byte(s) to target memory",
5564  .usage = "address data [count]",
5565  },
5566  {
5567  .name = "mdd",
5568  .handler = handle_md_command,
5569  .mode = COMMAND_EXEC,
5570  .help = "Display target memory as 64-bit words",
5571  .usage = "address [count]",
5572  },
5573  {
5574  .name = "mdw",
5575  .handler = handle_md_command,
5576  .mode = COMMAND_EXEC,
5577  .help = "Display target memory as 32-bit words",
5578  .usage = "address [count]",
5579  },
5580  {
5581  .name = "mdh",
5582  .handler = handle_md_command,
5583  .mode = COMMAND_EXEC,
5584  .help = "Display target memory as 16-bit half-words",
5585  .usage = "address [count]",
5586  },
5587  {
5588  .name = "mdb",
5589  .handler = handle_md_command,
5590  .mode = COMMAND_EXEC,
5591  .help = "Display target memory as 8-bit bytes",
5592  .usage = "address [count]",
5593  },
5594  {
5595  .name = "get_reg",
5596  .mode = COMMAND_EXEC,
5597  .handler = handle_target_get_reg,
5598  .help = "Get register values from the target",
5599  .usage = "[-force] list",
5600  },
5601  {
5602  .name = "set_reg",
5603  .mode = COMMAND_EXEC,
5604  .handler = handle_set_reg_command,
5605  .help = "Set target register values",
5606  .usage = "dict",
5607  },
5608  {
5609  .name = "read_memory",
5610  .mode = COMMAND_EXEC,
5611  .handler = handle_target_read_memory,
5612  .help = "Read Tcl list of 8/16/32/64 bit numbers from target memory",
5613  .usage = "address width count ['phys']",
5614  },
5615  {
5616  .name = "write_memory",
5617  .mode = COMMAND_EXEC,
5618  .handler = handle_target_write_memory,
5619  .help = "Write Tcl list of 8/16/32/64 bit numbers to target memory",
5620  .usage = "address width data ['phys']",
5621  },
5622  {
5623  .name = "eventlist",
5624  .handler = handle_target_event_list,
5625  .mode = COMMAND_EXEC,
5626  .help = "displays a table of events defined for this target",
5627  .usage = "",
5628  },
5629  {
5630  .name = "curstate",
5631  .mode = COMMAND_EXEC,
5632  .handler = handle_target_current_state,
5633  .help = "displays the current state of this target",
5634  .usage = "",
5635  },
5636  {
5637  .name = "debug_reason",
5638  .mode = COMMAND_EXEC,
5639  .handler = handle_target_debug_reason,
5640  .help = "displays the debug reason of this target",
5641  .usage = "",
5642  },
5643  {
5644  .name = "arp_examine",
5645  .mode = COMMAND_EXEC,
5646  .handler = handle_target_examine,
5647  .help = "used internally for reset processing",
5648  .usage = "['allow-defer']",
5649  },
5650  {
5651  .name = "was_examined",
5652  .mode = COMMAND_EXEC,
5653  .handler = handle_target_was_examined,
5654  .help = "used internally for reset processing",
5655  .usage = "",
5656  },
5657  {
5658  .name = "examine_deferred",
5659  .mode = COMMAND_EXEC,
5660  .handler = handle_target_examine_deferred,
5661  .help = "used internally for reset processing",
5662  .usage = "",
5663  },
5664  {
5665  .name = "arp_halt_gdb",
5666  .mode = COMMAND_EXEC,
5667  .handler = handle_target_halt_gdb,
5668  .help = "used internally for reset processing to halt GDB",
5669  .usage = "",
5670  },
5671  {
5672  .name = "arp_poll",
5673  .mode = COMMAND_EXEC,
5674  .handler = handle_target_poll,
5675  .help = "used internally for reset processing",
5676  .usage = "",
5677  },
5678  {
5679  .name = "arp_reset",
5680  .mode = COMMAND_EXEC,
5681  .handler = handle_target_reset,
5682  .help = "used internally for reset processing",
5683  .usage = "'assert'|'deassert' halt",
5684  },
5685  {
5686  .name = "arp_halt",
5687  .mode = COMMAND_EXEC,
5688  .handler = handle_target_halt,
5689  .help = "used internally for reset processing",
5690  .usage = "",
5691  },
5692  {
5693  .name = "arp_waitstate",
5694  .mode = COMMAND_EXEC,
5695  .handler = handle_target_wait_state,
5696  .help = "used internally for reset processing",
5697  .usage = "statename timeoutmsecs",
5698  },
5699  {
5700  .name = "invoke-event",
5701  .mode = COMMAND_EXEC,
5702  .handler = handle_target_invoke_event,
5703  .help = "invoke handler for specified event",
5704  .usage = "event_name",
5705  },
5707 };
5708 
5709 COMMAND_HANDLER(handle_target_create)
5710 {
5711  int retval = ERROR_OK;
5712  int x;
5713 
5714  if (CMD_ARGC < 4)
5716 
5717  /* check if the target name clashes with an existing command name */
5718  Jim_Cmd *jimcmd = Jim_GetCommand(CMD_CTX->interp, CMD_JIMTCL_ARGV[0], JIM_NONE);
5719  if (jimcmd) {
5720  command_print(CMD, "Command/target: %s Exists", CMD_ARGV[0]);
5721  return ERROR_FAIL;
5722  }
5723 
5724  /* TYPE */
5725  const char *cp = CMD_ARGV[1];
5726  struct transport *tr = get_current_transport();
5727  if (tr && tr->override_target) {
5728  retval = tr->override_target(&cp);
5729  if (retval != ERROR_OK) {
5730  command_print(CMD, "The selected transport doesn't support this target");
5731  return retval;
5732  }
5733  LOG_INFO("The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD");
5734  }
5735  /* now does target type exist */
5736  for (x = 0 ; target_types[x] ; x++) {
5737  if (strcmp(cp, target_types[x]->name) == 0) {
5738  /* found */
5739  break;
5740  }
5741  }
5742  if (!target_types[x]) {
5743  char *all = NULL;
5744  for (x = 0 ; target_types[x] ; x++) {
5745  char *prev = all;
5746  if (all)
5747  all = alloc_printf("%s, %s", all, target_types[x]->name);
5748  else
5749  all = alloc_printf("%s", target_types[x]->name);
5750  free(prev);
5751  if (!all) {
5752  LOG_ERROR("Out of memory");
5753  return ERROR_FAIL;
5754  }
5755  }
5756  command_print(CMD, "Unknown target type %s, try one of %s", cp, all);
5757  free(all);
5758  return ERROR_FAIL;
5759  }
5760 
5761  /* Create it */
5762  struct target *target = calloc(1, sizeof(struct target));
5763  if (!target) {
5764  LOG_ERROR("Out of memory");
5765  return ERROR_FAIL;
5766  }
5767 
5768  /* set empty smp cluster */
5769  target->smp_targets = &empty_smp_targets;
5770 
5771  /* allocate memory for each unique target type */
5772  target->type = malloc(sizeof(struct target_type));
5773  if (!target->type) {
5774  LOG_ERROR("Out of memory");
5775  free(target);
5776  return ERROR_FAIL;
5777  }
5778 
5779  memcpy(target->type, target_types[x], sizeof(struct target_type));
5780 
5781  /* default to first core, override with -coreid */
5782  target->coreid = 0;
5783 
5784  target->working_area = 0x0;
5785  target->working_area_size = 0x0;
5787  target->backup_working_area = false;
5788 
5791  target->reg_cache = NULL;
5792  target->breakpoints = NULL;
5793  target->watchpoints = NULL;
5794  target->next = NULL;
5795  target->arch_info = NULL;
5796 
5797  target->verbose_halt_msg = true;
5798 
5799  target->halt_issued = false;
5800 
5802 
5803  /* initialize trace information */
5804  target->trace_info = calloc(1, sizeof(struct trace));
5805  if (!target->trace_info) {
5806  LOG_ERROR("Out of memory");
5807  free(target->type);
5808  free(target);
5809  return ERROR_FAIL;
5810  }
5811 
5812  target->dbgmsg = NULL;
5813  target->dbg_msg_enabled = false;
5814 
5816 
5817  target->rtos = NULL;
5818  target->rtos_auto_detect = false;
5819 
5822 
5823  target->cmd_name = strdup(CMD_ARGV[0]);
5824  if (!target->cmd_name) {
5825  LOG_ERROR("Out of memory");
5826  free(target->trace_info);
5827  free(target->type);
5828  free(target);
5829  return ERROR_FAIL;
5830  }
5831 
5832  /* Do the rest as "configure" options */
5833  bool is_configure = true;
5834  retval = CALL_COMMAND_HANDLER(target_configure, target, 2, is_configure);
5835  if (retval == ERROR_OK) {
5836  if (target->has_dap) {
5837  if (!target->dap_configured) {
5838  command_print(CMD, "-dap ?name? required when creating target");
5840  }
5841  } else {
5842  if (!target->tap_configured) {
5843  command_print(CMD, "-chain-position ?name? required when creating target");
5845  }
5846  }
5847  /* tap must be set after target was configured */
5848  if (!target->tap)
5850  }
5851 
5852  if (retval != ERROR_OK) {
5854  free(target->gdb_port_override);
5855  free(target->trace_info);
5856  free(target->type);
5857  free(target->private_config);
5858  free(target);
5859  return retval;
5860  }
5861 
5863  /* default endian to little if not specified */
5865  }
5866 
5867  if (target->type->target_create) {
5868  retval = (*target->type->target_create)(target);
5869  if (retval != ERROR_OK) {
5870  LOG_DEBUG("target_create failed");
5871  free(target->cmd_name);
5873  free(target->gdb_port_override);
5874  free(target->trace_info);
5875  free(target->type);
5876  free(target->private_config);
5877  free(target);
5878  return retval;
5879  }
5880  }
5881 
5882  /* create the target specific commands */
5883  if (target->type->commands) {
5885  if (retval != ERROR_OK)
5886  LOG_ERROR("unable to register '%s' commands", CMD_ARGV[0]);
5887  }
5888 
5889  /* now - create the new target name command */
5890  const struct command_registration target_subcommands[] = {
5891  {
5893  },
5894  {
5895  .chain = target->type->commands,
5896  },
5898  };
5899  const struct command_registration target_commands[] = {
5900  {
5901  .name = CMD_ARGV[0],
5902  .mode = COMMAND_ANY,
5903  .help = "target command group",
5904  .usage = "",
5905  .chain = target_subcommands,
5906  },
5908  };
5909  retval = register_commands_override_target(CMD_CTX, NULL, target_commands, target);
5910  if (retval != ERROR_OK) {
5911  if (target->type->deinit_target)
5913  free(target->cmd_name);
5915  free(target->gdb_port_override);
5916  free(target->trace_info);
5917  free(target->type);
5918  free(target);
5919  return retval;
5920  }
5921 
5922  /* append to end of list */
5924 
5925  CMD_CTX->current_target = target;
5926  return ERROR_OK;
5927 }
5928 
5929 COMMAND_HANDLER(handle_target_current)
5930 {
5931  if (CMD_ARGC != 0)
5933 
5935  if (target)
5937 
5938  return ERROR_OK;
5939 }
5940 
5941 COMMAND_HANDLER(handle_target_types)
5942 {
5943  if (CMD_ARGC != 0)
5945 
5946  for (unsigned int x = 0; target_types[x]; x++)
5947  command_print(CMD, "%s", target_types[x]->name);
5948 
5949  return ERROR_OK;
5950 }
5951 
5952 COMMAND_HANDLER(handle_target_names)
5953 {
5954  if (CMD_ARGC != 0)
5956 
5957  struct target *target = all_targets;
5958  while (target) {
5960  target = target->next;
5961  }
5962 
5963  return ERROR_OK;
5964 }
5965 
5966 static struct target_list *
5967 __attribute__((warn_unused_result))
5968 create_target_list_node(const char *targetname)
5969 {
5970  struct target *target = get_target(targetname);
5971  LOG_DEBUG("%s ", targetname);
5972  if (!target)
5973  return NULL;
5974 
5975  struct target_list *new = malloc(sizeof(struct target_list));
5976  if (!new) {
5977  LOG_ERROR("Out of memory");
5978  return new;
5979  }
5980 
5981  new->target = target;
5982  return new;
5983 }
5984 
5986  struct list_head *lh, struct target **result)
5987 {
5988  struct target *target = NULL;
5989  struct target_list *curr;
5990  foreach_smp_target(curr, lh) {
5991  struct rtos *curr_rtos = curr->target->rtos;
5992  if (curr_rtos) {
5993  if (target && target->rtos && target->rtos->type != curr_rtos->type) {
5994  command_print(cmd, "Different rtos types in members of one smp target!");
5995  return ERROR_FAIL;
5996  }
5997  target = curr->target;
5998  }
5999  }
6000  *result = target;
6001  return ERROR_OK;
6002 }
6003 
6004 COMMAND_HANDLER(handle_target_smp)
6005 {
6006  static unsigned int smp_group = 1;
6007 
6008  if (CMD_ARGC == 0) {
6009  LOG_DEBUG("Empty SMP target");
6010  return ERROR_OK;
6011  }
6012  LOG_DEBUG("%d", CMD_ARGC);
6013  /* CMD_ARGC[0] = target to associate in smp
6014  * CMD_ARGC[1] = target to associate in smp
6015  * CMD_ARGC[2] ...
6016  */
6017 
6018  struct list_head *lh = malloc(sizeof(*lh));
6019  if (!lh) {
6020  LOG_ERROR("Out of memory");
6021  return ERROR_FAIL;
6022  }
6023  INIT_LIST_HEAD(lh);
6024 
6025  for (unsigned int i = 0; i < CMD_ARGC; i++) {
6026  struct target_list *new = create_target_list_node(CMD_ARGV[i]);
6027  if (new)
6028  list_add_tail(&new->lh, lh);
6029  }
6030  /* now parse the list of cpu and put the target in smp mode*/
6031  struct target_list *curr;
6032  foreach_smp_target(curr, lh) {
6033  struct target *target = curr->target;
6034  target->smp = smp_group;
6035  target->smp_targets = lh;
6036  }
6037  smp_group++;
6038 
6039  struct target *rtos_target;
6040  int retval = get_target_with_common_rtos_type(CMD, lh, &rtos_target);
6041  if (retval == ERROR_OK && rtos_target)
6042  retval = rtos_smp_init(rtos_target);
6043 
6044  return retval;
6045 }
6046 
6047 static const struct command_registration target_subcommand_handlers[] = {
6048  {
6049  .name = "init",
6050  .mode = COMMAND_CONFIG,
6051  .handler = handle_target_init_command,
6052  .help = "initialize targets",
6053  .usage = "",
6054  },
6055  {
6056  .name = "create",
6057  .mode = COMMAND_CONFIG,
6058  .handler = handle_target_create,
6059  .usage = "name type '-chain-position' name [options ...]",
6060  .help = "Creates and selects a new target",
6061  },
6062  {
6063  .name = "current",
6064  .mode = COMMAND_ANY,
6065  .handler = handle_target_current,
6066  .help = "Returns the currently selected target",
6067  .usage = "",
6068  },
6069  {
6070  .name = "types",
6071  .mode = COMMAND_ANY,
6072  .handler = handle_target_types,
6073  .help = "Returns the available target types as "
6074  "a list of strings",
6075  .usage = "",
6076  },
6077  {
6078  .name = "names",
6079  .mode = COMMAND_ANY,
6080  .handler = handle_target_names,
6081  .help = "Returns the names of all targets as a list of strings",
6082  .usage = "",
6083  },
6084  {
6085  .name = "smp",
6086  .mode = COMMAND_ANY,
6087  .handler = handle_target_smp,
6088  .usage = "targetname1 targetname2 ...",
6089  .help = "gather several target in a smp list"
6090  },
6091 
6093 };
6094 
6095 struct fast_load {
6097  uint8_t *data;
6098  int length;
6099 
6100 };
6101 
6102 static int fastload_num;
6103 static struct fast_load *fastload;
6104 
6105 static void free_fastload(void)
6106 {
6107  if (fastload) {
6108  for (int i = 0; i < fastload_num; i++)
6109  free(fastload[i].data);
6110  free(fastload);
6111  fastload = NULL;
6112  }
6113 }
6114 
6115 COMMAND_HANDLER(handle_fast_load_image_command)
6116 {
6117  uint8_t *buffer;
6118  size_t buf_cnt;
6119  uint32_t image_size;
6120  target_addr_t min_address = 0;
6121  target_addr_t max_address = -1;
6122 
6123  struct image image;
6124 
6125  int retval = CALL_COMMAND_HANDLER(parse_load_image_command,
6126  &image, &min_address, &max_address);
6127  if (retval != ERROR_OK)
6128  return retval;
6129 
6130  struct duration bench;
6131  duration_start(&bench);
6132 
6133  retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL);
6134  if (retval != ERROR_OK)
6135  return retval;
6136 
6137  image_size = 0x0;
6138  retval = ERROR_OK;
6140  fastload = malloc(sizeof(struct fast_load)*image.num_sections);
6141  if (!fastload) {
6142  command_print(CMD, "out of memory");
6143  image_close(&image);
6144  return ERROR_FAIL;
6145  }
6146  memset(fastload, 0, sizeof(struct fast_load)*image.num_sections);
6147  for (unsigned int i = 0; i < image.num_sections; i++) {
6148  buffer = malloc(image.sections[i].size);
6149  if (!buffer) {
6150  command_print(CMD, "error allocating buffer for section (%d bytes)",
6151  (int)(image.sections[i].size));
6152  retval = ERROR_FAIL;
6153  break;
6154  }
6155 
6156  retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt);
6157  if (retval != ERROR_OK) {
6158  free(buffer);
6159  break;
6160  }
6161 
6162  uint32_t offset = 0;
6163  uint32_t length = buf_cnt;
6164 
6165  /* DANGER!!! beware of unsigned comparison here!!! */
6166 
6167  if ((image.sections[i].base_address + buf_cnt >= min_address) &&
6168  (image.sections[i].base_address < max_address)) {
6169  if (image.sections[i].base_address < min_address) {
6170  /* clip addresses below */
6171  offset += min_address-image.sections[i].base_address;
6172  length -= offset;
6173  }
6174 
6175  if (image.sections[i].base_address + buf_cnt > max_address)
6176  length -= (image.sections[i].base_address + buf_cnt)-max_address;
6177 
6179  fastload[i].data = malloc(length);
6180  if (!fastload[i].data) {
6181  free(buffer);
6182  command_print(CMD, "error allocating buffer for section (%" PRIu32 " bytes)",
6183  length);
6184  retval = ERROR_FAIL;
6185  break;
6186  }
6187  memcpy(fastload[i].data, buffer + offset, length);
6188  fastload[i].length = length;
6189 
6190  image_size += length;
6191  command_print(CMD, "%u bytes written at address 0x%8.8x",
6192  (unsigned int)length,
6193  ((unsigned int)(image.sections[i].base_address + offset)));
6194  }
6195 
6196  free(buffer);
6197  }
6198 
6199  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
6200  command_print(CMD, "Loaded %" PRIu32 " bytes "
6201  "in %fs (%0.3f KiB/s)", image_size,
6202  duration_elapsed(&bench), duration_kbps(&bench, image_size));
6203 
6205  "WARNING: image has not been loaded to target!"
6206  "You can issue a 'fast_load' to finish loading.");
6207  }
6208 
6209  image_close(&image);
6210 
6211  if (retval != ERROR_OK)
6212  free_fastload();
6213 
6214  return retval;
6215 }
6216 
6217 COMMAND_HANDLER(handle_fast_load_command)
6218 {
6219  if (CMD_ARGC > 0)
6221  if (!fastload) {
6222  LOG_ERROR("No image in memory");
6223  return ERROR_FAIL;
6224  }
6225  int i;
6226  int64_t ms = timeval_ms();
6227  int size = 0;
6228  int retval = ERROR_OK;
6229  for (i = 0; i < fastload_num; i++) {
6231  command_print(CMD, "Write to 0x%08x, length 0x%08x",
6232  (unsigned int)(fastload[i].address),
6233  (unsigned int)(fastload[i].length));
6234  retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
6235  if (retval != ERROR_OK)
6236  break;
6237  size += fastload[i].length;
6238  }
6239  if (retval == ERROR_OK) {
6240  int64_t after = timeval_ms();
6241  command_print(CMD, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
6242  }
6243  return retval;
6244 }
6245 
6246 static const struct command_registration target_command_handlers[] = {
6247  {
6248  .name = "targets",
6249  .handler = handle_targets_command,
6250  .mode = COMMAND_ANY,
6251  .help = "change current default target (one parameter) "
6252  "or prints table of all targets (no parameters)",
6253  .usage = "[target]",
6254  },
6255  {
6256  .name = "target",
6257  .mode = COMMAND_CONFIG,
6258  .help = "configure target",
6259  .chain = target_subcommand_handlers,
6260  .usage = "",
6261  },
6263 };
6264 
6266 {
6268 }
6269 
6270 static bool target_reset_nag = true;
6271 
6273 {
6274  return target_reset_nag;
6275 }
6276 
6277 COMMAND_HANDLER(handle_target_reset_nag)
6278 {
6279  return CALL_COMMAND_HANDLER(handle_command_parse_bool,
6280  &target_reset_nag, "Nag after each reset about options to improve "
6281  "performance");
6282 }
6283 
6284 COMMAND_HANDLER(handle_ps_command)
6285 {
6287  char *display;
6288  if (target->state != TARGET_HALTED) {
6289  command_print(CMD, "Error: [%s] not halted", target_name(target));
6290  return ERROR_TARGET_NOT_HALTED;
6291  }
6292 
6293  if ((target->rtos) && (target->rtos->type)
6294  && (target->rtos->type->ps_command)) {
6295  display = target->rtos->type->ps_command(target);
6296  command_print(CMD, "%s", display);
6297  free(display);
6298  return ERROR_OK;
6299  } else {
6300  LOG_INFO("failed");
6301  return ERROR_TARGET_FAILURE;
6302  }
6303 }
6304 
6305 static void binprint(struct command_invocation *cmd, const char *text, const uint8_t *buf, int size)
6306 {
6307  if (text)
6308  command_print_sameline(cmd, "%s", text);
6309  for (int i = 0; i < size; i++)
6310  command_print_sameline(cmd, " %02x", buf[i]);
6311  command_print(cmd, " ");
6312 }
6313 
6314 COMMAND_HANDLER(handle_test_mem_access_command)
6315 {
6317  uint32_t test_size;
6318  int retval = ERROR_OK;
6319 
6320  if (target->state != TARGET_HALTED) {
6321  command_print(CMD, "Error: [%s] not halted", target_name(target));
6322  return ERROR_TARGET_NOT_HALTED;
6323  }
6324 
6325  if (CMD_ARGC != 1)
6327 
6328  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], test_size);
6329 
6330  /* Test reads */
6331  size_t num_bytes = test_size + 4;
6332 
6333  struct working_area *wa = NULL;
6334  retval = target_alloc_working_area(target, num_bytes, &wa);
6335  if (retval != ERROR_OK) {
6336  LOG_ERROR("Not enough working area");
6337  return ERROR_FAIL;
6338  }
6339 
6340  uint8_t *test_pattern = malloc(num_bytes);
6341 
6342  for (size_t i = 0; i < num_bytes; i++)
6343  test_pattern[i] = rand();
6344 
6345  retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);
6346  if (retval != ERROR_OK) {
6347  LOG_ERROR("Test pattern write failed");
6348  goto out;
6349  }
6350 
6351  for (int host_offset = 0; host_offset <= 1; host_offset++) {
6352  for (int size = 1; size <= 4; size *= 2) {
6353  for (int offset = 0; offset < 4; offset++) {
6354  uint32_t count = test_size / size;
6355  size_t host_bufsiz = (count + 2) * size + host_offset;
6356  uint8_t *read_ref = malloc(host_bufsiz);
6357  uint8_t *read_buf = malloc(host_bufsiz);
6358 
6359  for (size_t i = 0; i < host_bufsiz; i++) {
6360  read_ref[i] = rand();
6361  read_buf[i] = read_ref[i];
6362  }
6364  "Test read %" PRIu32 " x %d @ %d to %saligned buffer: ", count,
6365  size, offset, host_offset ? "un" : "");
6366 
6367  struct duration bench;
6368  duration_start(&bench);
6369 
6370  retval = target_read_memory(target, wa->address + offset, size, count,
6371  read_buf + size + host_offset);
6372 
6373  duration_measure(&bench);
6374 
6375  if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
6376  command_print(CMD, "Unsupported alignment");
6377  goto next;
6378  } else if (retval != ERROR_OK) {
6379  command_print(CMD, "Memory read failed");
6380  goto next;
6381  }
6382 
6383  /* replay on host */
6384  memcpy(read_ref + size + host_offset, test_pattern + offset, count * size);
6385 
6386  /* check result */
6387  int result = memcmp(read_ref, read_buf, host_bufsiz);
6388  if (result == 0) {
6389  command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
6390  duration_elapsed(&bench),
6391  duration_kbps(&bench, count * size));
6392  } else {
6393  command_print(CMD, "Compare failed");
6394  binprint(CMD, "ref:", read_ref, host_bufsiz);
6395  binprint(CMD, "buf:", read_buf, host_bufsiz);
6396  }
6397 next:
6398  free(read_ref);
6399  free(read_buf);
6400  }
6401  }
6402  }
6403 
6404 out:
6405  free(test_pattern);
6406 
6408 
6409  /* Test writes */
6410  num_bytes = test_size + 4 + 4 + 4;
6411 
6412  retval = target_alloc_working_area(target, num_bytes, &wa);
6413  if (retval != ERROR_OK) {
6414  LOG_ERROR("Not enough working area");
6415  return ERROR_FAIL;
6416  }
6417 
6418  test_pattern = malloc(num_bytes);
6419 
6420  for (size_t i = 0; i < num_bytes; i++)
6421  test_pattern[i] = rand();
6422 
6423  for (int host_offset = 0; host_offset <= 1; host_offset++) {
6424  for (int size = 1; size <= 4; size *= 2) {
6425  for (int offset = 0; offset < 4; offset++) {
6426  uint32_t count = test_size / size;
6427  size_t host_bufsiz = count * size + host_offset;
6428  uint8_t *read_ref = malloc(num_bytes);
6429  uint8_t *read_buf = malloc(num_bytes);
6430  uint8_t *write_buf = malloc(host_bufsiz);
6431 
6432  for (size_t i = 0; i < host_bufsiz; i++)
6433  write_buf[i] = rand();
6435  "Test write %" PRIu32 " x %d @ %d from %saligned buffer: ", count,
6436  size, offset, host_offset ? "un" : "");
6437 
6438  retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);
6439  if (retval != ERROR_OK) {
6440  command_print(CMD, "Test pattern write failed");
6441  goto nextw;
6442  }
6443 
6444  /* replay on host */
6445  memcpy(read_ref, test_pattern, num_bytes);
6446  memcpy(read_ref + size + offset, write_buf + host_offset, count * size);
6447 
6448  struct duration bench;
6449  duration_start(&bench);
6450 
6451  retval = target_write_memory(target, wa->address + size + offset, size, count,
6452  write_buf + host_offset);
6453 
6454  duration_measure(&bench);
6455 
6456  if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
6457  command_print(CMD, "Unsupported alignment");
6458  goto nextw;
6459  } else if (retval != ERROR_OK) {
6460  command_print(CMD, "Memory write failed");
6461  goto nextw;
6462  }
6463 
6464  /* read back */
6465  retval = target_read_memory(target, wa->address, 1, num_bytes, read_buf);
6466  if (retval != ERROR_OK) {
6467  command_print(CMD, "Test pattern write failed");
6468  goto nextw;
6469  }
6470 
6471  /* check result */
6472  int result = memcmp(read_ref, read_buf, num_bytes);
6473  if (result == 0) {
6474  command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
6475  duration_elapsed(&bench),
6476  duration_kbps(&bench, count * size));
6477  } else {
6478  command_print(CMD, "Compare failed");
6479  binprint(CMD, "ref:", read_ref, num_bytes);
6480  binprint(CMD, "buf:", read_buf, num_bytes);
6481  }
6482 nextw:
6483  free(read_ref);
6484  free(read_buf);
6485  }
6486  }
6487  }
6488 
6489  free(test_pattern);
6490 
6492  return retval;
6493 }
6494 
6495 static const struct command_registration target_exec_command_handlers[] = {
6496  {
6497  .name = "fast_load_image",
6498  .handler = handle_fast_load_image_command,
6499  .mode = COMMAND_ANY,
6500  .help = "Load image into server memory for later use by "
6501  "fast_load; primarily for profiling",
6502  .usage = "filename [address ['bin'|'ihex'|'elf'|'s19' "
6503  "[min_address [max_length]]]]",
6504  },
6505  {
6506  .name = "fast_load",
6507  .handler = handle_fast_load_command,
6508  .mode = COMMAND_EXEC,
6509  .help = "loads active fast load image to current target "
6510  "- mainly for profiling purposes",
6511  .usage = "",
6512  },
6513  {
6514  .name = "profile",
6515  .handler = handle_profile_command,
6516  .mode = COMMAND_EXEC,
6517  .usage = "seconds filename [start end]",
6518  .help = "profiling samples the CPU PC",
6519  },
6521  {
6522  .name = "virt2phys",
6523  .handler = handle_virt2phys_command,
6524  .mode = COMMAND_ANY,
6525  .help = "translate a virtual address into a physical address",
6526  .usage = "virtual_address",
6527  },
6528  {
6529  .name = "reg",
6530  .handler = handle_reg_command,
6531  .mode = COMMAND_EXEC,
6532  .help = "display (reread from target with \"force\") or set a register; "
6533  "with no arguments, displays all registers and their values",
6534  .usage = "[(register_number|register_name) [(value|'force')]]",
6535  },
6536  {
6537  .name = "poll",
6538  .handler = handle_poll_command,
6539  .mode = COMMAND_EXEC,
6540  .help = "poll target state; or reconfigure background polling",
6541  .usage = "['on'|'off']",
6542  },
6543  {
6544  .name = "wait_halt",
6545  .handler = handle_wait_halt_command,
6546  .mode = COMMAND_EXEC,
6547  .help = "wait up to the specified number of milliseconds "
6548  "(default 5000) for a previously requested halt",
6549  .usage = "[milliseconds]",
6550  },
6551  {
6552  .name = "halt",
6553  .handler = handle_halt_command,
6554  .mode = COMMAND_EXEC,
6555  .help = "request target to halt, then wait up to the specified "
6556  "number of milliseconds (default 5000) for it to complete",
6557  .usage = "[milliseconds]",
6558  },
6559  {
6560  .name = "resume",
6561  .handler = handle_resume_command,
6562  .mode = COMMAND_EXEC,
6563  .help = "resume target execution from current PC or address",
6564  .usage = "[address]",
6565  },
6566  {
6567  .name = "reset",
6568  .handler = handle_reset_command,
6569  .mode = COMMAND_EXEC,
6570  .usage = "[run|halt|init]",
6571  .help = "Reset all targets into the specified mode. "
6572  "Default reset mode is run, if not given.",
6573  },
6574  {
6575  .name = "soft_reset_halt",
6576  .handler = handle_soft_reset_halt_command,
6577  .mode = COMMAND_EXEC,
6578  .usage = "",
6579  .help = "halt the target and do a soft reset",
6580  },
6581  {
6582  .name = "step",
6583  .handler = handle_step_command,
6584  .mode = COMMAND_EXEC,
6585  .help = "step one instruction from current PC or address",
6586  .usage = "[address]",
6587  },
6588  {
6589  .name = "mdd",
6590  .handler = handle_md_command,
6591  .mode = COMMAND_EXEC,
6592  .help = "display memory double-words",
6593  .usage = "['phys'] address [count]",
6594  },
6595  {
6596  .name = "mdw",
6597  .handler = handle_md_command,
6598  .mode = COMMAND_EXEC,
6599  .help = "display memory words",
6600  .usage = "['phys'] address [count]",
6601  },
6602  {
6603  .name = "mdh",
6604  .handler = handle_md_command,
6605  .mode = COMMAND_EXEC,
6606  .help = "display memory half-words",
6607  .usage = "['phys'] address [count]",
6608  },
6609  {
6610  .name = "mdb",
6611  .handler = handle_md_command,
6612  .mode = COMMAND_EXEC,
6613  .help = "display memory bytes",
6614  .usage = "['phys'] address [count]",
6615  },
6616  {
6617  .name = "mwd",
6618  .handler = handle_mw_command,
6619  .mode = COMMAND_EXEC,
6620  .help = "write memory double-word",
6621  .usage = "['phys'] address value [count]",
6622  },
6623  {
6624  .name = "mww",
6625  .handler = handle_mw_command,
6626  .mode = COMMAND_EXEC,
6627  .help = "write memory word",
6628  .usage = "['phys'] address value [count]",
6629  },
6630  {
6631  .name = "mwh",
6632  .handler = handle_mw_command,
6633  .mode = COMMAND_EXEC,
6634  .help = "write memory half-word",
6635  .usage = "['phys'] address value [count]",
6636  },
6637  {
6638  .name = "mwb",
6639  .handler = handle_mw_command,
6640  .mode = COMMAND_EXEC,
6641  .help = "write memory byte",
6642  .usage = "['phys'] address value [count]",
6643  },
6644  {
6645  .name = "bp",
6646  .handler = handle_bp_command,
6647  .mode = COMMAND_EXEC,
6648  .help = "list or set hardware or software breakpoint",
6649  .usage = "[<address> [<asid>] <length> ['hw'|'hw_ctx']]",
6650  },
6651  {
6652  .name = "rbp",
6653  .handler = handle_rbp_command,
6654  .mode = COMMAND_EXEC,
6655  .help = "remove breakpoint",
6656  .usage = "'all' | address",
6657  },
6658  {
6659  .name = "wp",
6660  .handler = handle_wp_command,
6661  .mode = COMMAND_EXEC,
6662  .help = "list (no params) or create watchpoints",
6663  .usage = "[address length [('r'|'w'|'a') [value [mask]]]]",
6664  },
6665  {
6666  .name = "rwp",
6667  .handler = handle_rwp_command,
6668  .mode = COMMAND_EXEC,
6669  .help = "remove watchpoint",
6670  .usage = "'all' | address",
6671  },
6672  {
6673  .name = "load_image",
6674  .handler = handle_load_image_command,
6675  .mode = COMMAND_EXEC,
6676  .usage = "filename [address ['bin'|'ihex'|'elf'|'s19' "
6677  "[min_address [max_length]]]]",
6678  },
6679  {
6680  .name = "dump_image",
6681  .handler = handle_dump_image_command,
6682  .mode = COMMAND_EXEC,
6683  .usage = "filename address size",
6684  },
6685  {
6686  .name = "verify_image_checksum",
6687  .handler = handle_verify_image_checksum_command,
6688  .mode = COMMAND_EXEC,
6689  .usage = "filename [offset [type]]",
6690  },
6691  {
6692  .name = "verify_image",
6693  .handler = handle_verify_image_command,
6694  .mode = COMMAND_EXEC,
6695  .usage = "filename [offset [type]]",
6696  },
6697  {
6698  .name = "test_image",
6699  .handler = handle_test_image_command,
6700  .mode = COMMAND_EXEC,
6701  .usage = "filename [offset [type]]",
6702  },
6703  {
6704  .name = "get_reg",
6705  .mode = COMMAND_EXEC,
6706  .handler = handle_target_get_reg,
6707  .help = "Get register values from the target",
6708  .usage = "[-force] list",
6709  },
6710  {
6711  .name = "set_reg",
6712  .mode = COMMAND_EXEC,
6713  .handler = handle_set_reg_command,
6714  .help = "Set target register values",
6715  .usage = "dict",
6716  },
6717  {
6718  .name = "read_memory",
6719  .mode = COMMAND_EXEC,
6720  .handler = handle_target_read_memory,
6721  .help = "Read Tcl list of 8/16/32/64 bit numbers from target memory",
6722  .usage = "address width count ['phys']",
6723  },
6724  {
6725  .name = "write_memory",
6726  .mode = COMMAND_EXEC,
6727  .handler = handle_target_write_memory,
6728  .help = "Write Tcl list of 8/16/32/64 bit numbers to target memory",
6729  .usage = "address width data ['phys']",
6730  },
6731  {
6732  .name = "debug_reason",
6733  .mode = COMMAND_EXEC,
6734  .handler = handle_target_debug_reason,
6735  .help = "displays the debug reason of this target",
6736  .usage = "",
6737  },
6738  {
6739  .name = "reset_nag",
6740  .handler = handle_target_reset_nag,
6741  .mode = COMMAND_ANY,
6742  .help = "Nag after each reset about options that could have been "
6743  "enabled to improve performance.",
6744  .usage = "['enable'|'disable']",
6745  },
6746  {
6747  .name = "ps",
6748  .handler = handle_ps_command,
6749  .mode = COMMAND_EXEC,
6750  .help = "list all tasks",
6751  .usage = "",
6752  },
6753  {
6754  .name = "test_mem_access",
6755  .handler = handle_test_mem_access_command,
6756  .mode = COMMAND_EXEC,
6757  .help = "Test the target's memory access functions",
6758  .usage = "size",
6759  },
6760 
6762 };
6764 {
6765  int retval = ERROR_OK;
6766  retval = target_request_register_commands(cmd_ctx);
6767  if (retval != ERROR_OK)
6768  return retval;
6769 
6770  retval = trace_register_commands(cmd_ctx);
6771  if (retval != ERROR_OK)
6772  return retval;
6773 
6774 
6776 }
6777 
6779 {
6780  switch (reason) {
6781  case DBG_REASON_DBGRQ:
6782  return "DBGRQ";
6783  case DBG_REASON_BREAKPOINT:
6784  return "BREAKPOINT";
6785  case DBG_REASON_WATCHPOINT:
6786  return "WATCHPOINT";
6787  case DBG_REASON_WPTANDBKPT:
6788  return "WPTANDBKPT";
6789  case DBG_REASON_SINGLESTEP:
6790  return "SINGLESTEP";
6791  case DBG_REASON_NOTHALTED:
6792  return "NOTHALTED";
6793  case DBG_REASON_EXIT:
6794  return "EXIT";
6795  case DBG_REASON_EXC_CATCH:
6796  return "EXC_CATCH";
6797  case DBG_REASON_UNDEFINED:
6798  return "UNDEFINED";
6799  default:
6800  return "UNKNOWN!";
6801  }
6802 }
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:1293
void command_print_sameline(struct command_invocation *cmd, const char *format,...)
Definition: command.c:353
void command_print(struct command_invocation *cmd, const char *format,...)
Definition: command.c:376
int command_run_line(struct command_context *context, char *line)
Definition: command.c:480
#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:452
#define COMMAND_PARSE_ON_OFF(in, out)
parses an on/off command argument
Definition: command.h:530
#define ERROR_COMMAND_SYNTAX_ERROR
Definition: command.h:402
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:293
#define ERROR_COMMAND_CLOSE_CONNECTION
Definition: command.h:401
#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:442
#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:253
#define ERROR_COMMAND_ARGUMENT_INVALID
Definition: command.h:404
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:274
@ 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:3455
struct target_type cortexa_target
Definition: cortex_a.c:3375
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
void rtos_destroy(struct target *target)
Definition: rtos.c:144
int rtos_smp_init(struct target *target)
Definition: rtos.c:39
int rtos_create(struct jim_getopt_info *goi, struct target *target)
Definition: rtos.c:99
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:235
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:249
const char * usage
a string listing the options and arguments, required or optional
Definition: command.h:241
int length
Definition: target.c:6098
uint8_t * data
Definition: target.c:6097
target_addr_t address
Definition: target.c:6096
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:60
char *(* ps_command)(struct target *target)
Definition: rtos.h:72
Definition: rtos.h:36
const struct rtos_type * type
Definition: rtos.h:37
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:247
int(* halt)(struct target *target)
Definition: target_type.h:43
int(* check_reset)(struct target *target)
Definition: target_type.h:279
int(* gdb_fileio_end)(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
Definition: target_type.h:287
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:300
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:306
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:283
unsigned int(* data_bits)(struct target *target)
Definition: target_type.h:311
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:262
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:271
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:222
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:268
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:252
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:6270
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:6305
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:6246
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:6265
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:5985
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:5967
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:6047
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:6778
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:5523
bool get_target_reset_nag(void)
Definition: target.c:6272
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:6102
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:6495
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:6103
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:6105
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:6763
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