git.gag.com Git - fw/openocd/blob - src/target/target.c

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