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