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