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