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

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