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