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

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   Copyright (C) 2007-2009 Ø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  *   This program is free software; you can redistribute it and/or modify  *
  18  *   it under the terms of the GNU General Public License as published by  *
  19  *   the Free Software Foundation; either version 2 of the License, or     *
  20  *   (at your option) any later version.                                   *
  21  *                                                                         *
  22  *   This program is distributed in the hope that it will be useful,       *
  23  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  24  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  25  *   GNU General Public License for more details.                          *
  26  *                                                                         *
  27  *   You should have received a copy of the GNU General Public License     *
  28  *   along with this program; if not, write to the                         *
  29  *   Free Software Foundation, Inc.,                                       *
  30  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  31  ***************************************************************************/
  32 #ifdef HAVE_CONFIG_H
  33 #include "config.h"
  34 #endif
  35
  36 #include "target.h"
  37 #include "target_type.h"
  38 #include "target_request.h"
  39 #include "time_support.h"
  40 #include "register.h"
  41 #include "trace.h"
  42 #include "image.h"
  43 #include "jtag.h"
  44
  45
  46 static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  47
  48 static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  49 static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  50 static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  51 static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  52 static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  53 static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  54 static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  55 static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  56 static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  57 static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  58 static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  59 static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  60 static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  61 static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  62 static int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  63 static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  64 static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  65 static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  66 static int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
  67 static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  68 static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  69 static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  70
  71 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
  72 static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
  73 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
  74 static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
  75
  76 static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv);
  77 static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv);
  78
  79 /* targets */
  80 extern target_type_t arm7tdmi_target;
  81 extern target_type_t arm720t_target;
  82 extern target_type_t arm9tdmi_target;
  83 extern target_type_t arm920t_target;
  84 extern target_type_t arm966e_target;
  85 extern target_type_t arm926ejs_target;
  86 extern target_type_t fa526_target;
  87 extern target_type_t feroceon_target;
  88 extern target_type_t dragonite_target;
  89 extern target_type_t xscale_target;
  90 extern target_type_t cortexm3_target;
  91 extern target_type_t cortexa8_target;
  92 extern target_type_t arm11_target;
  93 extern target_type_t mips_m4k_target;
  94 extern target_type_t avr_target;
  95
  96 target_type_t *target_types[] =
  97 {
  98         &arm7tdmi_target,
  99         &arm9tdmi_target,
 100         &arm920t_target,
 101         &arm720t_target,
 102         &arm966e_target,
 103         &arm926ejs_target,
 104         &fa526_target,
 105         &feroceon_target,
 106         &dragonite_target,
 107         &xscale_target,
 108         &cortexm3_target,
 109         &cortexa8_target,
 110         &arm11_target,
 111         &mips_m4k_target,
 112         &avr_target,
 113         NULL,
 114 };
 115
 116 target_t *all_targets = NULL;
 117 target_event_callback_t *target_event_callbacks = NULL;
 118 target_timer_callback_t *target_timer_callbacks = NULL;
 119
 120 const Jim_Nvp nvp_assert[] = {
 121         { .name = "assert", NVP_ASSERT },
 122         { .name = "deassert", NVP_DEASSERT },
 123         { .name = "T", NVP_ASSERT },
 124         { .name = "F", NVP_DEASSERT },
 125         { .name = "t", NVP_ASSERT },
 126         { .name = "f", NVP_DEASSERT },
 127         { .name = NULL, .value = -1 }
 128 };
 129
 130 const Jim_Nvp nvp_error_target[] = {
 131         { .value = ERROR_TARGET_INVALID, .name = "err-invalid" },
 132         { .value = ERROR_TARGET_INIT_FAILED, .name = "err-init-failed" },
 133         { .value = ERROR_TARGET_TIMEOUT, .name = "err-timeout" },
 134         { .value = ERROR_TARGET_NOT_HALTED, .name = "err-not-halted" },
 135         { .value = ERROR_TARGET_FAILURE, .name = "err-failure" },
 136         { .value = ERROR_TARGET_UNALIGNED_ACCESS   , .name = "err-unaligned-access" },
 137         { .value = ERROR_TARGET_DATA_ABORT , .name = "err-data-abort" },
 138         { .value = ERROR_TARGET_RESOURCE_NOT_AVAILABLE , .name = "err-resource-not-available" },
 139         { .value = ERROR_TARGET_TRANSLATION_FAULT  , .name = "err-translation-fault" },
 140         { .value = ERROR_TARGET_NOT_RUNNING, .name = "err-not-running" },
 141         { .value = ERROR_TARGET_NOT_EXAMINED, .name = "err-not-examined" },
 142         { .value = -1, .name = NULL }
 143 };
 144
 145 const char *target_strerror_safe(int err)
 146 {
 147         const Jim_Nvp *n;
 148
 149         n = Jim_Nvp_value2name_simple(nvp_error_target, err);
 150         if (n->name == NULL) {
 151                 return "unknown";
 152         } else {
 153                 return n->name;
 154         }
 155 }
 156
 157 static const Jim_Nvp nvp_target_event[] = {
 158         { .value = TARGET_EVENT_OLD_gdb_program_config , .name = "old-gdb_program_config" },
 159         { .value = TARGET_EVENT_OLD_pre_resume         , .name = "old-pre_resume" },
 160
 161         { .value = TARGET_EVENT_GDB_HALT, .name = "gdb-halt" },
 162         { .value = TARGET_EVENT_HALTED, .name = "halted" },
 163         { .value = TARGET_EVENT_RESUMED, .name = "resumed" },
 164         { .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
 165         { .value = TARGET_EVENT_RESUME_END, .name = "resume-end" },
 166
 167         { .name = "gdb-start", .value = TARGET_EVENT_GDB_START },
 168         { .name = "gdb-end", .value = TARGET_EVENT_GDB_END },
 169
 170         /* historical name */
 171
 172         { .value = TARGET_EVENT_RESET_START, .name = "reset-start" },
 173
 174         { .value = TARGET_EVENT_RESET_ASSERT_PRE,    .name = "reset-assert-pre" },
 175         { .value = TARGET_EVENT_RESET_ASSERT_POST,   .name = "reset-assert-post" },
 176         { .value = TARGET_EVENT_RESET_DEASSERT_PRE,  .name = "reset-deassert-pre" },
 177         { .value = TARGET_EVENT_RESET_DEASSERT_POST, .name = "reset-deassert-post" },
 178         { .value = TARGET_EVENT_RESET_HALT_PRE,      .name = "reset-halt-pre" },
 179         { .value = TARGET_EVENT_RESET_HALT_POST,     .name = "reset-halt-post" },
 180         { .value = TARGET_EVENT_RESET_WAIT_PRE,      .name = "reset-wait-pre" },
 181         { .value = TARGET_EVENT_RESET_WAIT_POST,     .name = "reset-wait-post" },
 182         { .value = TARGET_EVENT_RESET_INIT , .name = "reset-init" },
 183         { .value = TARGET_EVENT_RESET_END, .name = "reset-end" },
 184
 185         { .value = TARGET_EVENT_EXAMINE_START, .name = "examine-start" },
 186         { .value = TARGET_EVENT_EXAMINE_END, .name = "examine-end" },
 187
 188         { .value = TARGET_EVENT_DEBUG_HALTED, .name = "debug-halted" },
 189         { .value = TARGET_EVENT_DEBUG_RESUMED, .name = "debug-resumed" },
 190
 191         { .value = TARGET_EVENT_GDB_ATTACH, .name = "gdb-attach" },
 192         { .value = TARGET_EVENT_GDB_DETACH, .name = "gdb-detach" },
 193
 194         { .value = TARGET_EVENT_GDB_FLASH_WRITE_START, .name = "gdb-flash-write-start" },
 195         { .value = TARGET_EVENT_GDB_FLASH_WRITE_END  , .name = "gdb-flash-write-end"   },
 196
 197         { .value = TARGET_EVENT_GDB_FLASH_ERASE_START, .name = "gdb-flash-erase-start" },
 198         { .value = TARGET_EVENT_GDB_FLASH_ERASE_END  , .name = "gdb-flash-erase-end" },
 199
 200         { .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
 201         { .value = TARGET_EVENT_RESUMED     , .name = "resume-ok" },
 202         { .value = TARGET_EVENT_RESUME_END  , .name = "resume-end" },
 203
 204         { .name = NULL, .value = -1 }
 205 };
 206
 207 const Jim_Nvp nvp_target_state[] = {
 208         { .name = "unknown", .value = TARGET_UNKNOWN },
 209         { .name = "running", .value = TARGET_RUNNING },
 210         { .name = "halted",  .value = TARGET_HALTED },
 211         { .name = "reset",   .value = TARGET_RESET },
 212         { .name = "debug-running", .value = TARGET_DEBUG_RUNNING },
 213         { .name = NULL, .value = -1 },
 214 };
 215
 216 const Jim_Nvp nvp_target_debug_reason [] = {
 217         { .name = "debug-request"            , .value = DBG_REASON_DBGRQ },
 218         { .name = "breakpoint"               , .value = DBG_REASON_BREAKPOINT },
 219         { .name = "watchpoint"               , .value = DBG_REASON_WATCHPOINT },
 220         { .name = "watchpoint-and-breakpoint", .value = DBG_REASON_WPTANDBKPT },
 221         { .name = "single-step"              , .value = DBG_REASON_SINGLESTEP },
 222         { .name = "target-not-halted"        , .value = DBG_REASON_NOTHALTED  },
 223         { .name = "undefined"                , .value = DBG_REASON_UNDEFINED },
 224         { .name = NULL, .value = -1 },
 225 };
 226
 227 const Jim_Nvp nvp_target_endian[] = {
 228         { .name = "big",    .value = TARGET_BIG_ENDIAN },
 229         { .name = "little", .value = TARGET_LITTLE_ENDIAN },
 230         { .name = "be",     .value = TARGET_BIG_ENDIAN },
 231         { .name = "le",     .value = TARGET_LITTLE_ENDIAN },
 232         { .name = NULL,     .value = -1 },
 233 };
 234
 235 const Jim_Nvp nvp_reset_modes[] = {
 236         { .name = "unknown", .value = RESET_UNKNOWN },
 237         { .name = "run"    , .value = RESET_RUN },
 238         { .name = "halt"   , .value = RESET_HALT },
 239         { .name = "init"   , .value = RESET_INIT },
 240         { .name = NULL     , .value = -1 },
 241 };
 242
 243 const char *
 244 target_state_name( target_t *t )
 245 {
 246         const char *cp;
 247         cp = Jim_Nvp_value2name_simple(nvp_target_state, t->state)->name;
 248         if( !cp ){
 249                 LOG_ERROR("Invalid target state: %d", (int)(t->state));
 250                 cp = "(*BUG*unknown*BUG*)";
 251         }
 252         return cp;
 253 }
 254
 255 /* determine the number of the new target */
 256 static int new_target_number(void)
 257 {
 258         target_t *t;
 259         int x;
 260
 261         /* number is 0 based */
 262         x = -1;
 263         t = all_targets;
 264         while (t) {
 265                 if (x < t->target_number) {
 266                         x = t->target_number;
 267                 }
 268                 t = t->next;
 269         }
 270         return x + 1;
 271 }
 272
 273 /* read a uint32_t from a buffer in target memory endianness */
 274 uint32_t target_buffer_get_u32(target_t *target, const uint8_t *buffer)
 275 {
 276         if (target->endianness == TARGET_LITTLE_ENDIAN)
 277                 return le_to_h_u32(buffer);
 278         else
 279                 return be_to_h_u32(buffer);
 280 }
 281
 282 /* read a uint16_t from a buffer in target memory endianness */
 283 uint16_t target_buffer_get_u16(target_t *target, const uint8_t *buffer)
 284 {
 285         if (target->endianness == TARGET_LITTLE_ENDIAN)
 286                 return le_to_h_u16(buffer);
 287         else
 288                 return be_to_h_u16(buffer);
 289 }
 290
 291 /* read a uint8_t from a buffer in target memory endianness */
 292 uint8_t target_buffer_get_u8(target_t *target, const uint8_t *buffer)
 293 {
 294         return *buffer & 0x0ff;
 295 }
 296
 297 /* write a uint32_t to a buffer in target memory endianness */
 298 void target_buffer_set_u32(target_t *target, uint8_t *buffer, uint32_t value)
 299 {
 300         if (target->endianness == TARGET_LITTLE_ENDIAN)
 301                 h_u32_to_le(buffer, value);
 302         else
 303                 h_u32_to_be(buffer, value);
 304 }
 305
 306 /* write a uint16_t to a buffer in target memory endianness */
 307 void target_buffer_set_u16(target_t *target, uint8_t *buffer, uint16_t value)
 308 {
 309         if (target->endianness == TARGET_LITTLE_ENDIAN)
 310                 h_u16_to_le(buffer, value);
 311         else
 312                 h_u16_to_be(buffer, value);
 313 }
 314
 315 /* write a uint8_t to a buffer in target memory endianness */
 316 void target_buffer_set_u8(target_t *target, uint8_t *buffer, uint8_t value)
 317 {
 318         *buffer = value;
 319 }
 320
 321 /* return a pointer to a configured target; id is name or number */
 322 target_t *get_target(const char *id)
 323 {
 324         target_t *target;
 325
 326         /* try as tcltarget name */
 327         for (target = all_targets; target; target = target->next) {
 328                 if (target->cmd_name == NULL)
 329                         continue;
 330                 if (strcmp(id, target->cmd_name) == 0)
 331                         return target;
 332         }
 333
 334         /* It's OK to remove this fallback sometime after August 2010 or so */
 335
 336         /* no match, try as number */
 337         unsigned num;
 338         if (parse_uint(id, &num) != ERROR_OK)
 339                 return NULL;
 340
 341         for (target = all_targets; target; target = target->next) {
 342                 if (target->target_number == (int)num) {
 343                         LOG_WARNING("use '%s' as target identifier, not '%u'",
 344                                         target->cmd_name, num);
 345                         return target;
 346                 }
 347         }
 348
 349         return NULL;
 350 }
 351
 352 /* returns a pointer to the n-th configured target */
 353 static target_t *get_target_by_num(int num)
 354 {
 355         target_t *target = all_targets;
 356
 357         while (target) {
 358                 if (target->target_number == num) {
 359                         return target;
 360                 }
 361                 target = target->next;
 362         }
 363
 364         return NULL;
 365 }
 366
 367 target_t* get_current_target(command_context_t *cmd_ctx)
 368 {
 369         target_t *target = get_target_by_num(cmd_ctx->current_target);
 370
 371         if (target == NULL)
 372         {
 373                 LOG_ERROR("BUG: current_target out of bounds");
 374                 exit(-1);
 375         }
 376
 377         return target;
 378 }
 379
 380 int target_poll(struct target_s *target)
 381 {
 382         int retval;
 383
 384         /* We can't poll until after examine */
 385         if (!target_was_examined(target))
 386         {
 387                 /* Fail silently lest we pollute the log */
 388                 return ERROR_FAIL;
 389         }
 390
 391         retval = target->type->poll(target);
 392         if (retval != ERROR_OK)
 393                 return retval;
 394
 395         if (target->halt_issued)
 396         {
 397                 if (target->state == TARGET_HALTED)
 398                 {
 399                         target->halt_issued = false;
 400                 } else
 401                 {
 402                         long long t = timeval_ms() - target->halt_issued_time;
 403                         if (t>1000)
 404                         {
 405                                 target->halt_issued = false;
 406                                 LOG_INFO("Halt timed out, wake up GDB.");
 407                                 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
 408                         }
 409                 }
 410         }
 411
 412         return ERROR_OK;
 413 }
 414
 415 int target_halt(struct target_s *target)
 416 {
 417         int retval;
 418         /* We can't poll until after examine */
 419         if (!target_was_examined(target))
 420         {
 421                 LOG_ERROR("Target not examined yet");
 422                 return ERROR_FAIL;
 423         }
 424
 425         retval = target->type->halt(target);
 426         if (retval != ERROR_OK)
 427                 return retval;
 428
 429         target->halt_issued = true;
 430         target->halt_issued_time = timeval_ms();
 431
 432         return ERROR_OK;
 433 }
 434
 435 int target_resume(struct target_s *target, int current, uint32_t address, int handle_breakpoints, int debug_execution)
 436 {
 437         int retval;
 438
 439         /* We can't poll until after examine */
 440         if (!target_was_examined(target))
 441         {
 442                 LOG_ERROR("Target not examined yet");
 443                 return ERROR_FAIL;
 444         }
 445
 446         /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
 447          * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
 448          * the application.
 449          */
 450         if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
 451                 return retval;
 452
 453         return retval;
 454 }
 455
 456 int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
 457 {
 458         char buf[100];
 459         int retval;
 460         Jim_Nvp *n;
 461         n = Jim_Nvp_value2name_simple(nvp_reset_modes, reset_mode);
 462         if (n->name == NULL) {
 463                 LOG_ERROR("invalid reset mode");
 464                 return ERROR_FAIL;
 465         }
 466
 467         /* disable polling during reset to make reset event scripts
 468          * more predictable, i.e. dr/irscan & pathmove in events will
 469          * not have JTAG operations injected into the middle of a sequence.
 470          */
 471         bool save_poll = jtag_poll_get_enabled();
 472
 473         jtag_poll_set_enabled(false);
 474
 475         sprintf(buf, "ocd_process_reset %s", n->name);
 476         retval = Jim_Eval(interp, buf);
 477
 478         jtag_poll_set_enabled(save_poll);
 479
 480         if (retval != JIM_OK) {
 481                 Jim_PrintErrorMessage(interp);
 482                 return ERROR_FAIL;
 483         }
 484
 485         /* We want any events to be processed before the prompt */
 486         retval = target_call_timer_callbacks_now();
 487
 488         return retval;
 489 }
 490
 491 static int default_virt2phys(struct target_s *target, uint32_t virtual, uint32_t *physical)
 492 {
 493         *physical = virtual;
 494         return ERROR_OK;
 495 }
 496
 497 static int default_mmu(struct target_s *target, int *enabled)
 498 {
 499         *enabled = 0;
 500         return ERROR_OK;
 501 }
 502
 503 static int default_examine(struct target_s *target)
 504 {
 505         target_set_examined(target);
 506         return ERROR_OK;
 507 }
 508
 509 int target_examine_one(struct target_s *target)
 510 {
 511         return target->type->examine(target);
 512 }
 513
 514 static int jtag_enable_callback(enum jtag_event event, void *priv)
 515 {
 516         target_t *target = priv;
 517
 518         if (event != JTAG_TAP_EVENT_ENABLE || !target->tap->enabled)
 519                 return ERROR_OK;
 520
 521         jtag_unregister_event_callback(jtag_enable_callback, target);
 522         return target_examine_one(target);
 523 }
 524
 525
 526 /* Targets that correctly implement init + examine, i.e.
 527  * no communication with target during init:
 528  *
 529  * XScale
 530  */
 531 int target_examine(void)
 532 {
 533         int retval = ERROR_OK;
 534         target_t *target;
 535
 536         for (target = all_targets; target; target = target->next)
 537         {
 538                 /* defer examination, but don't skip it */
 539                 if (!target->tap->enabled) {
 540                         jtag_register_event_callback(jtag_enable_callback,
 541                                         target);
 542                         continue;
 543                 }
 544                 if ((retval = target_examine_one(target)) != ERROR_OK)
 545                         return retval;
 546         }
 547         return retval;
 548 }
 549 const char *target_get_name(struct target_s *target)
 550 {
 551         return target->type->name;
 552 }
 553
 554 static int target_write_memory_imp(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 555 {
 556         if (!target_was_examined(target))
 557         {
 558                 LOG_ERROR("Target not examined yet");
 559                 return ERROR_FAIL;
 560         }
 561         return target->type->write_memory_imp(target, address, size, count, buffer);
 562 }
 563
 564 static int target_read_memory_imp(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 565 {
 566         if (!target_was_examined(target))
 567         {
 568                 LOG_ERROR("Target not examined yet");
 569                 return ERROR_FAIL;
 570         }
 571         return target->type->read_memory_imp(target, address, size, count, buffer);
 572 }
 573
 574 static int target_soft_reset_halt_imp(struct target_s *target)
 575 {
 576         if (!target_was_examined(target))
 577         {
 578                 LOG_ERROR("Target not examined yet");
 579                 return ERROR_FAIL;
 580         }
 581         if (!target->type->soft_reset_halt_imp) {
 582                 LOG_ERROR("Target %s does not support soft_reset_halt",
 583                                 target->cmd_name);
 584                 return ERROR_FAIL;
 585         }
 586         return target->type->soft_reset_halt_imp(target);
 587 }
 588
 589 static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, uint32_t entry_point, uint32_t exit_point, int timeout_ms, void *arch_info)
 590 {
 591         if (!target_was_examined(target))
 592         {
 593                 LOG_ERROR("Target not examined yet");
 594                 return ERROR_FAIL;
 595         }
 596         return target->type->run_algorithm_imp(target, num_mem_params, mem_params, num_reg_params, reg_param, entry_point, exit_point, timeout_ms, arch_info);
 597 }
 598
 599 int target_read_memory(struct target_s *target,
 600                 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 601 {
 602         return target->type->read_memory(target, address, size, count, buffer);
 603 }
 604
 605 int target_read_phys_memory(struct target_s *target,
 606                 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 607 {
 608         return target->type->read_phys_memory(target, address, size, count, buffer);
 609 }
 610
 611 int target_write_memory(struct target_s *target,
 612                 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 613 {
 614         return target->type->write_memory(target, address, size, count, buffer);
 615 }
 616
 617 int target_write_phys_memory(struct target_s *target,
 618                 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 619 {
 620         return target->type->write_phys_memory(target, address, size, count, buffer);
 621 }
 622
 623 int target_bulk_write_memory(struct target_s *target,
 624                 uint32_t address, uint32_t count, uint8_t *buffer)
 625 {
 626         return target->type->bulk_write_memory(target, address, count, buffer);
 627 }
 628
 629 int target_add_breakpoint(struct target_s *target,
 630                 struct breakpoint_s *breakpoint)
 631 {
 632         return target->type->add_breakpoint(target, breakpoint);
 633 }
 634 int target_remove_breakpoint(struct target_s *target,
 635                 struct breakpoint_s *breakpoint)
 636 {
 637         return target->type->remove_breakpoint(target, breakpoint);
 638 }
 639
 640 int target_add_watchpoint(struct target_s *target,
 641                 struct watchpoint_s *watchpoint)
 642 {
 643         return target->type->add_watchpoint(target, watchpoint);
 644 }
 645 int target_remove_watchpoint(struct target_s *target,
 646                 struct watchpoint_s *watchpoint)
 647 {
 648         return target->type->remove_watchpoint(target, watchpoint);
 649 }
 650
 651 int target_get_gdb_reg_list(struct target_s *target,
 652                 struct reg_s **reg_list[], int *reg_list_size)
 653 {
 654         return target->type->get_gdb_reg_list(target, reg_list, reg_list_size);
 655 }
 656 int target_step(struct target_s *target,
 657                 int current, uint32_t address, int handle_breakpoints)
 658 {
 659         return target->type->step(target, current, address, handle_breakpoints);
 660 }
 661
 662
 663 int target_run_algorithm(struct target_s *target,
 664                 int num_mem_params, mem_param_t *mem_params,
 665                 int num_reg_params, reg_param_t *reg_param,
 666                 uint32_t entry_point, uint32_t exit_point,
 667                 int timeout_ms, void *arch_info)
 668 {
 669         return target->type->run_algorithm(target,
 670                         num_mem_params, mem_params, num_reg_params, reg_param,
 671                         entry_point, exit_point, timeout_ms, arch_info);
 672 }
 673
 674 /// @returns @c true if the target has been examined.
 675 bool target_was_examined(struct target_s *target)
 676 {
 677         return target->type->examined;
 678 }
 679 /// Sets the @c examined flag for the given target.
 680 void target_set_examined(struct target_s *target)
 681 {
 682         target->type->examined = true;
 683 }
 684 // Reset the @c examined flag for the given target.
 685 void target_reset_examined(struct target_s *target)
 686 {
 687         target->type->examined = false;
 688 }
 689
 690
 691
 692 static int default_mrc(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value)
 693 {
 694         LOG_ERROR("Not implemented");
 695         return ERROR_FAIL;
 696 }
 697
 698 static int default_mcr(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value)
 699 {
 700         LOG_ERROR("Not implemented");
 701         return ERROR_FAIL;
 702 }
 703
 704 static int arm_cp_check(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm)
 705 {
 706         /* basic check */
 707         if (!target_was_examined(target))
 708         {
 709                 LOG_ERROR("Target not examined yet");
 710                 return ERROR_FAIL;
 711         }
 712
 713         if ((cpnum <0) || (cpnum > 15))
 714         {
 715                 LOG_ERROR("Illegal co-processor %d", cpnum);
 716                 return ERROR_FAIL;
 717         }
 718
 719         return ERROR_OK;
 720 }
 721
 722 int target_mrc(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value)
 723 {
 724         int retval;
 725
 726         retval = arm_cp_check(target, cpnum, op1, op2, CRn, CRm);
 727         if (retval != ERROR_OK)
 728                 return retval;
 729
 730         return target->type->mrc(target, cpnum, op1, op2, CRn, CRm, value);
 731 }
 732
 733 int target_mcr(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value)
 734 {
 735         int retval;
 736
 737         retval = arm_cp_check(target, cpnum, op1, op2, CRn, CRm);
 738         if (retval != ERROR_OK)
 739                 return retval;
 740
 741         return target->type->mcr(target, cpnum, op1, op2, CRn, CRm, value);
 742 }
 743
 744
 745 int target_init(struct command_context_s *cmd_ctx)
 746 {
 747         target_t *target = all_targets;
 748         int retval;
 749
 750         while (target)
 751         {
 752                 target_reset_examined(target);
 753                 if (target->type->examine == NULL)
 754                 {
 755                         target->type->examine = default_examine;
 756                 }
 757
 758                 if ((retval = target->type->init_target(cmd_ctx, target)) != ERROR_OK)
 759                 {
 760                         LOG_ERROR("target '%s' init failed", target_get_name(target));
 761                         return retval;
 762                 }
 763
 764                 /* Set up default functions if none are provided by target */
 765                 if (target->type->virt2phys == NULL)
 766                 {
 767                         target->type->virt2phys = default_virt2phys;
 768                 }
 769
 770                 if (target->type->read_phys_memory == NULL)
 771                 {
 772                         target->type->read_phys_memory = target->type->read_memory;
 773                 }
 774
 775                 if (target->type->write_phys_memory == NULL)
 776                 {
 777                         target->type->write_phys_memory = target->type->write_memory;
 778                 }
 779
 780                 if (target->type->mcr == NULL)
 781                 {
 782                         target->type->mcr = default_mcr;
 783                 }
 784
 785                 if (target->type->mrc == NULL)
 786                 {
 787                         target->type->mrc = default_mrc;
 788                 }
 789
 790
 791                 /* a non-invasive way(in terms of patches) to add some code that
 792                  * runs before the type->write/read_memory implementation
 793                  */
 794                 target->type->write_memory_imp = target->type->write_memory;
 795                 target->type->write_memory = target_write_memory_imp;
 796                 target->type->read_memory_imp = target->type->read_memory;
 797                 target->type->read_memory = target_read_memory_imp;
 798                 target->type->soft_reset_halt_imp = target->type->soft_reset_halt;
 799                 target->type->soft_reset_halt = target_soft_reset_halt_imp;
 800                 target->type->run_algorithm_imp = target->type->run_algorithm;
 801                 target->type->run_algorithm = target_run_algorithm_imp;
 802
 803                 if (target->type->mmu == NULL)
 804                 {
 805                         target->type->mmu = default_mmu;
 806                 }
 807                 target = target->next;
 808         }
 809
 810         if (all_targets)
 811         {
 812                 if ((retval = target_register_user_commands(cmd_ctx)) != ERROR_OK)
 813                         return retval;
 814                 if ((retval = target_register_timer_callback(handle_target, 100, 1, NULL)) != ERROR_OK)
 815                         return retval;
 816         }
 817
 818         return ERROR_OK;
 819 }
 820
 821 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
 822 {
 823         target_event_callback_t **callbacks_p = &target_event_callbacks;
 824
 825         if (callback == NULL)
 826         {
 827                 return ERROR_INVALID_ARGUMENTS;
 828         }
 829
 830         if (*callbacks_p)
 831         {
 832                 while ((*callbacks_p)->next)
 833                         callbacks_p = &((*callbacks_p)->next);
 834                 callbacks_p = &((*callbacks_p)->next);
 835         }
 836
 837         (*callbacks_p) = malloc(sizeof(target_event_callback_t));
 838         (*callbacks_p)->callback = callback;
 839         (*callbacks_p)->priv = priv;
 840         (*callbacks_p)->next = NULL;
 841
 842         return ERROR_OK;
 843 }
 844
 845 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
 846 {
 847         target_timer_callback_t **callbacks_p = &target_timer_callbacks;
 848         struct timeval now;
 849
 850         if (callback == NULL)
 851         {
 852                 return ERROR_INVALID_ARGUMENTS;
 853         }
 854
 855         if (*callbacks_p)
 856         {
 857                 while ((*callbacks_p)->next)
 858                         callbacks_p = &((*callbacks_p)->next);
 859                 callbacks_p = &((*callbacks_p)->next);
 860         }
 861
 862         (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
 863         (*callbacks_p)->callback = callback;
 864         (*callbacks_p)->periodic = periodic;
 865         (*callbacks_p)->time_ms = time_ms;
 866
 867         gettimeofday(&now, NULL);
 868         (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
 869         time_ms -= (time_ms % 1000);
 870         (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
 871         if ((*callbacks_p)->when.tv_usec > 1000000)
 872         {
 873                 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
 874                 (*callbacks_p)->when.tv_sec += 1;
 875         }
 876
 877         (*callbacks_p)->priv = priv;
 878         (*callbacks_p)->next = NULL;
 879
 880         return ERROR_OK;
 881 }
 882
 883 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
 884 {
 885         target_event_callback_t **p = &target_event_callbacks;
 886         target_event_callback_t *c = target_event_callbacks;
 887
 888         if (callback == NULL)
 889         {
 890                 return ERROR_INVALID_ARGUMENTS;
 891         }
 892
 893         while (c)
 894         {
 895                 target_event_callback_t *next = c->next;
 896                 if ((c->callback == callback) && (c->priv == priv))
 897                 {
 898                         *p = next;
 899                         free(c);
 900                         return ERROR_OK;
 901                 }
 902                 else
 903                         p = &(c->next);
 904                 c = next;
 905         }
 906
 907         return ERROR_OK;
 908 }
 909
 910 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
 911 {
 912         target_timer_callback_t **p = &target_timer_callbacks;
 913         target_timer_callback_t *c = target_timer_callbacks;
 914
 915         if (callback == NULL)
 916         {
 917                 return ERROR_INVALID_ARGUMENTS;
 918         }
 919
 920         while (c)
 921         {
 922                 target_timer_callback_t *next = c->next;
 923                 if ((c->callback == callback) && (c->priv == priv))
 924                 {
 925                         *p = next;
 926                         free(c);
 927                         return ERROR_OK;
 928                 }
 929                 else
 930                         p = &(c->next);
 931                 c = next;
 932         }
 933
 934         return ERROR_OK;
 935 }
 936
 937 int target_call_event_callbacks(target_t *target, enum target_event event)
 938 {
 939         target_event_callback_t *callback = target_event_callbacks;
 940         target_event_callback_t *next_callback;
 941
 942         if (event == TARGET_EVENT_HALTED)
 943         {
 944                 /* execute early halted first */
 945                 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
 946         }
 947
 948         LOG_DEBUG("target event %i (%s)",
 949                           event,
 950                           Jim_Nvp_value2name_simple(nvp_target_event, event)->name);
 951
 952         target_handle_event(target, event);
 953
 954         while (callback)
 955         {
 956                 next_callback = callback->next;
 957                 callback->callback(target, event, callback->priv);
 958                 callback = next_callback;
 959         }
 960
 961         return ERROR_OK;
 962 }
 963
 964 static int target_timer_callback_periodic_restart(
 965                 target_timer_callback_t *cb, struct timeval *now)
 966 {
 967         int time_ms = cb->time_ms;
 968         cb->when.tv_usec = now->tv_usec + (time_ms % 1000) * 1000;
 969         time_ms -= (time_ms % 1000);
 970         cb->when.tv_sec = now->tv_sec + time_ms / 1000;
 971         if (cb->when.tv_usec > 1000000)
 972         {
 973                 cb->when.tv_usec = cb->when.tv_usec - 1000000;
 974                 cb->when.tv_sec += 1;
 975         }
 976         return ERROR_OK;
 977 }
 978
 979 static int target_call_timer_callback(target_timer_callback_t *cb,
 980                 struct timeval *now)
 981 {
 982         cb->callback(cb->priv);
 983
 984         if (cb->periodic)
 985                 return target_timer_callback_periodic_restart(cb, now);
 986
 987         return target_unregister_timer_callback(cb->callback, cb->priv);
 988 }
 989
 990 static int target_call_timer_callbacks_check_time(int checktime)
 991 {
 992         keep_alive();
 993
 994         struct timeval now;
 995         gettimeofday(&now, NULL);
 996
 997         target_timer_callback_t *callback = target_timer_callbacks;
 998         while (callback)
 999         {
1000                 // cleaning up may unregister and free this callback
1001                 target_timer_callback_t *next_callback = callback->next;
1002
1003                 bool call_it = callback->callback &&
1004                         ((!checktime && callback->periodic) ||
1005                           now.tv_sec > callback->when.tv_sec ||
1006                          (now.tv_sec == callback->when.tv_sec &&
1007                           now.tv_usec >= callback->when.tv_usec));
1008
1009                 if (call_it)
1010                 {
1011                         int retval = target_call_timer_callback(callback, &now);
1012                         if (retval != ERROR_OK)
1013                                 return retval;
1014                 }
1015
1016                 callback = next_callback;
1017         }
1018
1019         return ERROR_OK;
1020 }
1021
1022 int target_call_timer_callbacks(void)
1023 {
1024         return target_call_timer_callbacks_check_time(1);
1025 }
1026
1027 /* invoke periodic callbacks immediately */
1028 int target_call_timer_callbacks_now(void)
1029 {
1030         return target_call_timer_callbacks_check_time(0);
1031 }
1032
1033 int target_alloc_working_area(struct target_s *target, uint32_t size, working_area_t **area)
1034 {
1035         working_area_t *c = target->working_areas;
1036         working_area_t *new_wa = NULL;
1037
1038         /* Reevaluate working area address based on MMU state*/
1039         if (target->working_areas == NULL)
1040         {
1041                 int retval;
1042                 int enabled;
1043                 retval = target->type->mmu(target, &enabled);
1044                 if (retval != ERROR_OK)
1045                 {
1046                         return retval;
1047                 }
1048
1049                 if (enabled)
1050                 {
1051                         if (target->working_area_phys_spec)
1052                         {
1053                                 LOG_DEBUG("MMU disabled, using physical address for working memory 0x%08x", (unsigned)target->working_area_phys);
1054                                 target->working_area = target->working_area_phys;
1055                         } else
1056                         {
1057                                 LOG_ERROR("No working memory available. Specify -work-area-phys to target.");
1058                                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1059                         }
1060                 } else
1061                 {
1062                         if (target->working_area_virt_spec)
1063                         {
1064                                 LOG_DEBUG("MMU enabled, using virtual address for working memory 0x%08x", (unsigned)target->working_area_virt);
1065                                 target->working_area = target->working_area_virt;
1066                         } else
1067                         {
1068                                 LOG_ERROR("No working memory available. Specify -work-area-virt to target.");
1069                                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1070                         }
1071                 }
1072         }
1073
1074         /* only allocate multiples of 4 byte */
1075         if (size % 4)
1076         {
1077                 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes (0x%08x), padding", ((unsigned)(size)));
1078                 size = (size + 3) & (~3);
1079         }
1080
1081         /* see if there's already a matching working area */
1082         while (c)
1083         {
1084                 if ((c->free) && (c->size == size))
1085                 {
1086                         new_wa = c;
1087                         break;
1088                 }
1089                 c = c->next;
1090         }
1091
1092         /* if not, allocate a new one */
1093         if (!new_wa)
1094         {
1095                 working_area_t **p = &target->working_areas;
1096                 uint32_t first_free = target->working_area;
1097                 uint32_t free_size = target->working_area_size;
1098
1099                 c = target->working_areas;
1100                 while (c)
1101                 {
1102                         first_free += c->size;
1103                         free_size -= c->size;
1104                         p = &c->next;
1105                         c = c->next;
1106                 }
1107
1108                 if (free_size < size)
1109                 {
1110                         LOG_WARNING("not enough working area available(requested %u, free %u)",
1111                                     (unsigned)(size), (unsigned)(free_size));
1112                         return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1113                 }
1114
1115                 LOG_DEBUG("allocated new working area at address 0x%08x", (unsigned)first_free);
1116
1117                 new_wa = malloc(sizeof(working_area_t));
1118                 new_wa->next = NULL;
1119                 new_wa->size = size;
1120                 new_wa->address = first_free;
1121
1122                 if (target->backup_working_area)
1123                 {
1124                         int retval;
1125                         new_wa->backup = malloc(new_wa->size);
1126                         if ((retval = target_read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
1127                         {
1128                                 free(new_wa->backup);
1129                                 free(new_wa);
1130                                 return retval;
1131                         }
1132                 }
1133                 else
1134                 {
1135                         new_wa->backup = NULL;
1136                 }
1137
1138                 /* put new entry in list */
1139                 *p = new_wa;
1140         }
1141
1142         /* mark as used, and return the new (reused) area */
1143         new_wa->free = 0;
1144         *area = new_wa;
1145
1146         /* user pointer */
1147         new_wa->user = area;
1148
1149         return ERROR_OK;
1150 }
1151
1152 int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore)
1153 {
1154         if (area->free)
1155                 return ERROR_OK;
1156
1157         if (restore && target->backup_working_area)
1158         {
1159                 int retval;
1160                 if ((retval = target_write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
1161                         return retval;
1162         }
1163
1164         area->free = 1;
1165
1166         /* mark user pointer invalid */
1167         *area->user = NULL;
1168         area->user = NULL;
1169
1170         return ERROR_OK;
1171 }
1172
1173 int target_free_working_area(struct target_s *target, working_area_t *area)
1174 {
1175         return target_free_working_area_restore(target, area, 1);
1176 }
1177
1178 /* free resources and restore memory, if restoring memory fails,
1179  * free up resources anyway
1180  */
1181 void target_free_all_working_areas_restore(struct target_s *target, int restore)
1182 {
1183         working_area_t *c = target->working_areas;
1184
1185         while (c)
1186         {
1187                 working_area_t *next = c->next;
1188                 target_free_working_area_restore(target, c, restore);
1189
1190                 if (c->backup)
1191                         free(c->backup);
1192
1193                 free(c);
1194
1195                 c = next;
1196         }
1197
1198         target->working_areas = NULL;
1199 }
1200
1201 void target_free_all_working_areas(struct target_s *target)
1202 {
1203         target_free_all_working_areas_restore(target, 1);
1204 }
1205
1206 int target_register_commands(struct command_context_s *cmd_ctx)
1207 {
1208
1209         register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, "change the current command line target (one parameter) or lists targets (with no parameter)");
1210
1211
1212
1213
1214         register_jim(cmd_ctx, "target", jim_target, "configure target");
1215
1216         return ERROR_OK;
1217 }
1218
1219 int target_arch_state(struct target_s *target)
1220 {
1221         int retval;
1222         if (target == NULL)
1223         {
1224                 LOG_USER("No target has been configured");
1225                 return ERROR_OK;
1226         }
1227
1228         LOG_USER("target state: %s", target_state_name( target ));
1229
1230         if (target->state != TARGET_HALTED)
1231                 return ERROR_OK;
1232
1233         retval = target->type->arch_state(target);
1234         return retval;
1235 }
1236
1237 /* Single aligned words are guaranteed to use 16 or 32 bit access
1238  * mode respectively, otherwise data is handled as quickly as
1239  * possible
1240  */
1241 int target_write_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer)
1242 {
1243         int retval;
1244         LOG_DEBUG("writing buffer of %i byte at 0x%8.8x",
1245                   (int)size, (unsigned)address);
1246
1247         if (!target_was_examined(target))
1248         {
1249                 LOG_ERROR("Target not examined yet");
1250                 return ERROR_FAIL;
1251         }
1252
1253         if (size == 0) {
1254                 return ERROR_OK;
1255         }
1256
1257         if ((address + size - 1) < address)
1258         {
1259                 /* GDB can request this when e.g. PC is 0xfffffffc*/
1260                 LOG_ERROR("address + size wrapped(0x%08x, 0x%08x)",
1261                                   (unsigned)address,
1262                                   (unsigned)size);
1263                 return ERROR_FAIL;
1264         }
1265
1266         if (((address % 2) == 0) && (size == 2))
1267         {
1268                 return target_write_memory(target, address, 2, 1, buffer);
1269         }
1270
1271         /* handle unaligned head bytes */
1272         if (address % 4)
1273         {
1274                 uint32_t unaligned = 4 - (address % 4);
1275
1276                 if (unaligned > size)
1277                         unaligned = size;
1278
1279                 if ((retval = target_write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1280                         return retval;
1281
1282                 buffer += unaligned;
1283                 address += unaligned;
1284                 size -= unaligned;
1285         }
1286
1287         /* handle aligned words */
1288         if (size >= 4)
1289         {
1290                 int aligned = size - (size % 4);
1291
1292                 /* use bulk writes above a certain limit. This may have to be changed */
1293                 if (aligned > 128)
1294                 {
1295                         if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
1296                                 return retval;
1297                 }
1298                 else
1299                 {
1300                         if ((retval = target_write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1301                                 return retval;
1302                 }
1303
1304                 buffer += aligned;
1305                 address += aligned;
1306                 size -= aligned;
1307         }
1308
1309         /* handle tail writes of less than 4 bytes */
1310         if (size > 0)
1311         {
1312                 if ((retval = target_write_memory(target, address, 1, size, buffer)) != ERROR_OK)
1313                         return retval;
1314         }
1315
1316         return ERROR_OK;
1317 }
1318
1319 /* Single aligned words are guaranteed to use 16 or 32 bit access
1320  * mode respectively, otherwise data is handled as quickly as
1321  * possible
1322  */
1323 int target_read_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer)
1324 {
1325         int retval;
1326         LOG_DEBUG("reading buffer of %i byte at 0x%8.8x",
1327                           (int)size, (unsigned)address);
1328
1329         if (!target_was_examined(target))
1330         {
1331                 LOG_ERROR("Target not examined yet");
1332                 return ERROR_FAIL;
1333         }
1334
1335         if (size == 0) {
1336                 return ERROR_OK;
1337         }
1338
1339         if ((address + size - 1) < address)
1340         {
1341                 /* GDB can request this when e.g. PC is 0xfffffffc*/
1342                 LOG_ERROR("address + size wrapped(0x%08" PRIx32 ", 0x%08" PRIx32 ")",
1343                                   address,
1344                                   size);
1345                 return ERROR_FAIL;
1346         }
1347
1348         if (((address % 2) == 0) && (size == 2))
1349         {
1350                 return target_read_memory(target, address, 2, 1, buffer);
1351         }
1352
1353         /* handle unaligned head bytes */
1354         if (address % 4)
1355         {
1356                 uint32_t unaligned = 4 - (address % 4);
1357
1358                 if (unaligned > size)
1359                         unaligned = size;
1360
1361                 if ((retval = target_read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1362                         return retval;
1363
1364                 buffer += unaligned;
1365                 address += unaligned;
1366                 size -= unaligned;
1367         }
1368
1369         /* handle aligned words */
1370         if (size >= 4)
1371         {
1372                 int aligned = size - (size % 4);
1373
1374                 if ((retval = target_read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1375                         return retval;
1376
1377                 buffer += aligned;
1378                 address += aligned;
1379                 size -= aligned;
1380         }
1381
1382         /*prevent byte access when possible (avoid AHB access limitations in some cases)*/
1383         if(size >=2)
1384         {
1385                 int aligned = size - (size%2);
1386                 retval = target_read_memory(target, address, 2, aligned / 2, buffer);
1387                 if (retval != ERROR_OK)
1388                         return retval;
1389
1390                 buffer += aligned;
1391                 address += aligned;
1392                 size -= aligned;
1393         }
1394         /* handle tail writes of less than 4 bytes */
1395         if (size > 0)
1396         {
1397                 if ((retval = target_read_memory(target, address, 1, size, buffer)) != ERROR_OK)
1398                         return retval;
1399         }
1400
1401         return ERROR_OK;
1402 }
1403
1404 int target_checksum_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* crc)
1405 {
1406         uint8_t *buffer;
1407         int retval;
1408         uint32_t i;
1409         uint32_t checksum = 0;
1410         if (!target_was_examined(target))
1411         {
1412                 LOG_ERROR("Target not examined yet");
1413                 return ERROR_FAIL;
1414         }
1415
1416         if ((retval = target->type->checksum_memory(target, address,
1417                 size, &checksum)) != ERROR_OK)
1418         {
1419                 buffer = malloc(size);
1420                 if (buffer == NULL)
1421                 {
1422                         LOG_ERROR("error allocating buffer for section (%d bytes)", (int)size);
1423                         return ERROR_INVALID_ARGUMENTS;
1424                 }
1425                 retval = target_read_buffer(target, address, size, buffer);
1426                 if (retval != ERROR_OK)
1427                 {
1428                         free(buffer);
1429                         return retval;
1430                 }
1431
1432                 /* convert to target endianess */
1433                 for (i = 0; i < (size/sizeof(uint32_t)); i++)
1434                 {
1435                         uint32_t target_data;
1436                         target_data = target_buffer_get_u32(target, &buffer[i*sizeof(uint32_t)]);
1437                         target_buffer_set_u32(target, &buffer[i*sizeof(uint32_t)], target_data);
1438                 }
1439
1440                 retval = image_calculate_checksum(buffer, size, &checksum);
1441                 free(buffer);
1442         }
1443
1444         *crc = checksum;
1445
1446         return retval;
1447 }
1448
1449 int target_blank_check_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* blank)
1450 {
1451         int retval;
1452         if (!target_was_examined(target))
1453         {
1454                 LOG_ERROR("Target not examined yet");
1455                 return ERROR_FAIL;
1456         }
1457
1458         if (target->type->blank_check_memory == 0)
1459                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1460
1461         retval = target->type->blank_check_memory(target, address, size, blank);
1462
1463         return retval;
1464 }
1465
1466 int target_read_u32(struct target_s *target, uint32_t address, uint32_t *value)
1467 {
1468         uint8_t value_buf[4];
1469         if (!target_was_examined(target))
1470         {
1471                 LOG_ERROR("Target not examined yet");
1472                 return ERROR_FAIL;
1473         }
1474
1475         int retval = target_read_memory(target, address, 4, 1, value_buf);
1476
1477         if (retval == ERROR_OK)
1478         {
1479                 *value = target_buffer_get_u32(target, value_buf);
1480                 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
1481                                   address,
1482                                   *value);
1483         }
1484         else
1485         {
1486                 *value = 0x0;
1487                 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1488                                   address);
1489         }
1490
1491         return retval;
1492 }
1493
1494 int target_read_u16(struct target_s *target, uint32_t address, uint16_t *value)
1495 {
1496         uint8_t value_buf[2];
1497         if (!target_was_examined(target))
1498         {
1499                 LOG_ERROR("Target not examined yet");
1500                 return ERROR_FAIL;
1501         }
1502
1503         int retval = target_read_memory(target, address, 2, 1, value_buf);
1504
1505         if (retval == ERROR_OK)
1506         {
1507                 *value = target_buffer_get_u16(target, value_buf);
1508                 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%4.4x",
1509                                   address,
1510                                   *value);
1511         }
1512         else
1513         {
1514                 *value = 0x0;
1515                 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1516                                   address);
1517         }
1518
1519         return retval;
1520 }
1521
1522 int target_read_u8(struct target_s *target, uint32_t address, uint8_t *value)
1523 {
1524         int retval = target_read_memory(target, address, 1, 1, value);
1525         if (!target_was_examined(target))
1526         {
1527                 LOG_ERROR("Target not examined yet");
1528                 return ERROR_FAIL;
1529         }
1530
1531         if (retval == ERROR_OK)
1532         {
1533                 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
1534                                   address,
1535                                   *value);
1536         }
1537         else
1538         {
1539                 *value = 0x0;
1540                 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1541                                   address);
1542         }
1543
1544         return retval;
1545 }
1546
1547 int target_write_u32(struct target_s *target, uint32_t address, uint32_t value)
1548 {
1549         int retval;
1550         uint8_t value_buf[4];
1551         if (!target_was_examined(target))
1552         {
1553                 LOG_ERROR("Target not examined yet");
1554                 return ERROR_FAIL;
1555         }
1556
1557         LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
1558                           address,
1559                           value);
1560
1561         target_buffer_set_u32(target, value_buf, value);
1562         if ((retval = target_write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1563         {
1564                 LOG_DEBUG("failed: %i", retval);
1565         }
1566
1567         return retval;
1568 }
1569
1570 int target_write_u16(struct target_s *target, uint32_t address, uint16_t value)
1571 {
1572         int retval;
1573         uint8_t value_buf[2];
1574         if (!target_was_examined(target))
1575         {
1576                 LOG_ERROR("Target not examined yet");
1577                 return ERROR_FAIL;
1578         }
1579
1580         LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8x",
1581                           address,
1582                           value);
1583
1584         target_buffer_set_u16(target, value_buf, value);
1585         if ((retval = target_write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1586         {
1587                 LOG_DEBUG("failed: %i", retval);
1588         }
1589
1590         return retval;
1591 }
1592
1593 int target_write_u8(struct target_s *target, uint32_t address, uint8_t value)
1594 {
1595         int retval;
1596         if (!target_was_examined(target))
1597         {
1598                 LOG_ERROR("Target not examined yet");
1599                 return ERROR_FAIL;
1600         }
1601
1602         LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
1603                           address, value);
1604
1605         if ((retval = target_write_memory(target, address, 1, 1, &value)) != ERROR_OK)
1606         {
1607                 LOG_DEBUG("failed: %i", retval);
1608         }
1609
1610         return retval;
1611 }
1612
1613 int target_register_user_commands(struct command_context_s *cmd_ctx)
1614 {
1615         int retval = ERROR_OK;
1616
1617
1618         /* script procedures */
1619         register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "profiling samples the CPU PC");
1620         register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing <ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
1621         register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values  <ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
1622
1623         register_jim(cmd_ctx, "mrc", jim_mcrmrc, "read coprocessor <cpnum> <op1> <op2> <CRn> <CRm>");
1624         register_jim(cmd_ctx, "mcr", jim_mcrmrc, "write coprocessor <cpnum> <op1> <op2> <CRn> <CRm> <value>");
1625
1626         register_command(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY,
1627                         "same args as load_image, image stored in memory - mainly for profiling purposes");
1628
1629         register_command(cmd_ctx, NULL, "fast_load", handle_fast_load_command, COMMAND_ANY,
1630                         "loads active fast load image to current target - mainly for profiling purposes");
1631
1632
1633         register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "translate a virtual address into a physical address");
1634         register_command(cmd_ctx,  NULL, "reg", handle_reg_command, COMMAND_EXEC, "display or set a register");
1635         register_command(cmd_ctx,  NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1636         register_command(cmd_ctx,  NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1637         register_command(cmd_ctx,  NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1638         register_command(cmd_ctx,  NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1639         register_command(cmd_ctx,  NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1640         register_command(cmd_ctx,  NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run | halt | init] - default is run");
1641         register_command(cmd_ctx,  NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1642
1643         register_command(cmd_ctx,  NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words [phys] <addr> [count]");
1644         register_command(cmd_ctx,  NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words [phys] <addr> [count]");
1645         register_command(cmd_ctx,  NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes [phys] <addr> [count]");
1646
1647         register_command(cmd_ctx,  NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word [phys]  <addr> <value> [count]");
1648         register_command(cmd_ctx,  NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word [phys]  <addr> <value> [count]");
1649         register_command(cmd_ctx,  NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte [phys] <addr> <value> [count]");
1650
1651         register_command(cmd_ctx,  NULL, "bp",
1652                         handle_bp_command, COMMAND_EXEC,
1653                         "list or set breakpoint [<address> <length> [hw]]");
1654         register_command(cmd_ctx,  NULL, "rbp",
1655                         handle_rbp_command, COMMAND_EXEC,
1656                         "remove breakpoint <address>");
1657         register_command(cmd_ctx,  NULL, "wp",
1658                         handle_wp_command, COMMAND_EXEC,
1659                         "list or set watchpoint "
1660                                 "[<address> <length> <r/w/a> [value] [mask]]");
1661         register_command(cmd_ctx,  NULL, "rwp",
1662                         handle_rwp_command, COMMAND_EXEC,
1663                         "remove watchpoint <address>");
1664
1665         register_command(cmd_ctx,  NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
1666         register_command(cmd_ctx,  NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1667         register_command(cmd_ctx,  NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1668         register_command(cmd_ctx,  NULL, "test_image", handle_test_image_command, COMMAND_EXEC, "test_image <file> [offset] [type]");
1669
1670         if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
1671                 return retval;
1672         if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
1673                 return retval;
1674
1675         return retval;
1676 }
1677
1678 static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1679 {
1680         target_t *target = all_targets;
1681
1682         if (argc == 1)
1683         {
1684                 target = get_target(args[0]);
1685                 if (target == NULL) {
1686                         command_print(cmd_ctx,"Target: %s is unknown, try one of:\n", args[0]);
1687                         goto DumpTargets;
1688                 }
1689                 if (!target->tap->enabled) {
1690                         command_print(cmd_ctx,"Target: TAP %s is disabled, "
1691                                         "can't be the current target\n",
1692                                         target->tap->dotted_name);
1693                         return ERROR_FAIL;
1694                 }
1695
1696                 cmd_ctx->current_target = target->target_number;
1697                 return ERROR_OK;
1698         }
1699 DumpTargets:
1700
1701         target = all_targets;
1702         command_print(cmd_ctx, "    TargetName         Type       Endian TapName            State       ");
1703         command_print(cmd_ctx, "--  ------------------ ---------- ------ ------------------ ------------");
1704         while (target)
1705         {
1706                 const char *state;
1707                 char marker = ' ';
1708
1709                 if (target->tap->enabled)
1710                         state = target_state_name( target );
1711                 else
1712                         state = "tap-disabled";
1713
1714                 if (cmd_ctx->current_target == target->target_number)
1715                         marker = '*';
1716
1717                 /* keep columns lined up to match the headers above */
1718                 command_print(cmd_ctx, "%2d%c %-18s %-10s %-6s %-18s %s",
1719                                           target->target_number,
1720                                           marker,
1721                                           target->cmd_name,
1722                                           target_get_name(target),
1723                                           Jim_Nvp_value2name_simple(nvp_target_endian,
1724                                                                 target->endianness)->name,
1725                                           target->tap->dotted_name,
1726                                           state);
1727                 target = target->next;
1728         }
1729
1730         return ERROR_OK;
1731 }
1732
1733 /* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
1734
1735 static int powerDropout;
1736 static int srstAsserted;
1737
1738 static int runPowerRestore;
1739 static int runPowerDropout;
1740 static int runSrstAsserted;
1741 static int runSrstDeasserted;
1742
1743 static int sense_handler(void)
1744 {
1745         static int prevSrstAsserted = 0;
1746         static int prevPowerdropout = 0;
1747
1748         int retval;
1749         if ((retval = jtag_power_dropout(&powerDropout)) != ERROR_OK)
1750                 return retval;
1751
1752         int powerRestored;
1753         powerRestored = prevPowerdropout && !powerDropout;
1754         if (powerRestored)
1755         {
1756                 runPowerRestore = 1;
1757         }
1758
1759         long long current = timeval_ms();
1760         static long long lastPower = 0;
1761         int waitMore = lastPower + 2000 > current;
1762         if (powerDropout && !waitMore)
1763         {
1764                 runPowerDropout = 1;
1765                 lastPower = current;
1766         }
1767
1768         if ((retval = jtag_srst_asserted(&srstAsserted)) != ERROR_OK)
1769                 return retval;
1770
1771         int srstDeasserted;
1772         srstDeasserted = prevSrstAsserted && !srstAsserted;
1773
1774         static long long lastSrst = 0;
1775         waitMore = lastSrst + 2000 > current;
1776         if (srstDeasserted && !waitMore)
1777         {
1778                 runSrstDeasserted = 1;
1779                 lastSrst = current;
1780         }
1781
1782         if (!prevSrstAsserted && srstAsserted)
1783         {
1784                 runSrstAsserted = 1;
1785         }
1786
1787         prevSrstAsserted = srstAsserted;
1788         prevPowerdropout = powerDropout;
1789
1790         if (srstDeasserted || powerRestored)
1791         {
1792                 /* Other than logging the event we can't do anything here.
1793                  * Issuing a reset is a particularly bad idea as we might
1794                  * be inside a reset already.
1795                  */
1796         }
1797
1798         return ERROR_OK;
1799 }
1800
1801 static void target_call_event_callbacks_all(enum target_event e) {
1802         target_t *target;
1803         target = all_targets;
1804         while (target) {
1805                 target_call_event_callbacks(target, e);
1806                 target = target->next;
1807         }
1808 }
1809
1810 /* process target state changes */
1811 int handle_target(void *priv)
1812 {
1813         int retval = ERROR_OK;
1814
1815         /* we do not want to recurse here... */
1816         static int recursive = 0;
1817         if (! recursive)
1818         {
1819                 recursive = 1;
1820                 sense_handler();
1821                 /* danger! running these procedures can trigger srst assertions and power dropouts.
1822                  * We need to avoid an infinite loop/recursion here and we do that by
1823                  * clearing the flags after running these events.
1824                  */
1825                 int did_something = 0;
1826                 if (runSrstAsserted)
1827                 {
1828                         target_call_event_callbacks_all(TARGET_EVENT_GDB_HALT);
1829                         Jim_Eval(interp, "srst_asserted");
1830                         did_something = 1;
1831                 }
1832                 if (runSrstDeasserted)
1833                 {
1834                         Jim_Eval(interp, "srst_deasserted");
1835                         did_something = 1;
1836                 }
1837                 if (runPowerDropout)
1838                 {
1839                         target_call_event_callbacks_all(TARGET_EVENT_GDB_HALT);
1840                         Jim_Eval(interp, "power_dropout");
1841                         did_something = 1;
1842                 }
1843                 if (runPowerRestore)
1844                 {
1845                         Jim_Eval(interp, "power_restore");
1846                         did_something = 1;
1847                 }
1848
1849                 if (did_something)
1850                 {
1851                         /* clear detect flags */
1852                         sense_handler();
1853                 }
1854
1855                 /* clear action flags */
1856
1857                 runSrstAsserted = 0;
1858                 runSrstDeasserted = 0;
1859                 runPowerRestore = 0;
1860                 runPowerDropout = 0;
1861
1862                 recursive = 0;
1863         }
1864
1865         /* Poll targets for state changes unless that's globally disabled.
1866          * Skip targets that are currently disabled.
1867          */
1868         for (target_t *target = all_targets;
1869                         is_jtag_poll_safe() && target;
1870                         target = target->next)
1871         {
1872                 if (!target->tap->enabled)
1873                         continue;
1874
1875                 /* only poll target if we've got power and srst isn't asserted */
1876                 if (!powerDropout && !srstAsserted)
1877                 {
1878                         /* polling may fail silently until the target has been examined */
1879                         if ((retval = target_poll(target)) != ERROR_OK)
1880                         {
1881                                 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
1882                                 return retval;
1883                         }
1884                 }
1885         }
1886
1887         return retval;
1888 }
1889
1890 static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1891 {
1892         target_t *target;
1893         reg_t *reg = NULL;
1894         int count = 0;
1895         char *value;
1896
1897         LOG_DEBUG("-");
1898
1899         target = get_current_target(cmd_ctx);
1900
1901         /* list all available registers for the current target */
1902         if (argc == 0)
1903         {
1904                 reg_cache_t *cache = target->reg_cache;
1905
1906                 count = 0;
1907                 while (cache)
1908                 {
1909                         int i;
1910
1911                         command_print(cmd_ctx, "===== %s", cache->name);
1912
1913                         for (i = 0, reg = cache->reg_list;
1914                                         i < cache->num_regs;
1915                                         i++, reg++, count++)
1916                         {
1917                                 /* only print cached values if they are valid */
1918                                 if (reg->valid) {
1919                                         value = buf_to_str(reg->value,
1920                                                         reg->size, 16);
1921                                         command_print(cmd_ctx,
1922                                                         "(%i) %s (/%" PRIu32 "): 0x%s%s",
1923                                                         count, reg->name,
1924                                                         reg->size, value,
1925                                                         reg->dirty
1926                                                                 ? " (dirty)"
1927                                                                 : "");
1928                                         free(value);
1929                                 } else {
1930                                         command_print(cmd_ctx, "(%i) %s (/%" PRIu32 ")",
1931                                                           count, reg->name,
1932                                                           reg->size) ;
1933                                 }
1934                         }
1935                         cache = cache->next;
1936                 }
1937
1938                 return ERROR_OK;
1939         }
1940
1941         /* access a single register by its ordinal number */
1942         if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1943         {
1944                 unsigned num;
1945                 int retval = parse_uint(args[0], &num);
1946                 if (ERROR_OK != retval)
1947                         return ERROR_COMMAND_SYNTAX_ERROR;
1948
1949                 reg_cache_t *cache = target->reg_cache;
1950                 count = 0;
1951                 while (cache)
1952                 {
1953                         int i;
1954                         for (i = 0; i < cache->num_regs; i++)
1955                         {
1956                                 if (count++ == (int)num)
1957                                 {
1958                                         reg = &cache->reg_list[i];
1959                                         break;
1960                                 }
1961                         }
1962                         if (reg)
1963                                 break;
1964                         cache = cache->next;
1965                 }
1966
1967                 if (!reg)
1968                 {
1969                         command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1970                         return ERROR_OK;
1971                 }
1972         } else /* access a single register by its name */
1973         {
1974                 reg = register_get_by_name(target->reg_cache, args[0], 1);
1975
1976                 if (!reg)
1977                 {
1978                         command_print(cmd_ctx, "register %s not found in current target", args[0]);
1979                         return ERROR_OK;
1980                 }
1981         }
1982
1983         /* display a register */
1984         if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1985         {
1986                 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1987                         reg->valid = 0;
1988
1989                 if (reg->valid == 0)
1990                 {
1991                         reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1992                         arch_type->get(reg);
1993                 }
1994                 value = buf_to_str(reg->value, reg->size, 16);
1995                 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
1996                 free(value);
1997                 return ERROR_OK;
1998         }
1999
2000         /* set register value */
2001         if (argc == 2)
2002         {
2003                 uint8_t *buf = malloc(CEIL(reg->size, 8));
2004                 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
2005
2006                 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
2007                 arch_type->set(reg, buf);
2008
2009                 value = buf_to_str(reg->value, reg->size, 16);
2010                 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
2011                 free(value);
2012
2013                 free(buf);
2014
2015                 return ERROR_OK;
2016         }
2017
2018         command_print(cmd_ctx, "usage: reg <#|name> [value]");
2019
2020         return ERROR_OK;
2021 }
2022
2023 static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2024 {
2025         int retval = ERROR_OK;
2026         target_t *target = get_current_target(cmd_ctx);
2027
2028         if (argc == 0)
2029         {
2030                 command_print(cmd_ctx, "background polling: %s",
2031                                 jtag_poll_get_enabled() ? "on" : "off");
2032                 command_print(cmd_ctx, "TAP: %s (%s)",
2033                                 target->tap->dotted_name,
2034                                 target->tap->enabled ? "enabled" : "disabled");
2035                 if (!target->tap->enabled)
2036                         return ERROR_OK;
2037                 if ((retval = target_poll(target)) != ERROR_OK)
2038                         return retval;
2039                 if ((retval = target_arch_state(target)) != ERROR_OK)
2040                         return retval;
2041
2042         }
2043         else if (argc == 1)
2044         {
2045                 if (strcmp(args[0], "on") == 0)
2046                 {
2047                         jtag_poll_set_enabled(true);
2048                 }
2049                 else if (strcmp(args[0], "off") == 0)
2050                 {
2051                         jtag_poll_set_enabled(false);
2052                 }
2053                 else
2054                 {
2055                         command_print(cmd_ctx, "arg is \"on\" or \"off\"");
2056                 }
2057         } else
2058         {
2059                 return ERROR_COMMAND_SYNTAX_ERROR;
2060         }
2061
2062         return retval;
2063 }
2064
2065 static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2066 {
2067         if (argc > 1)
2068                 return ERROR_COMMAND_SYNTAX_ERROR;
2069
2070         unsigned ms = 5000;
2071         if (1 == argc)
2072         {
2073                 int retval = parse_uint(args[0], &ms);
2074                 if (ERROR_OK != retval)
2075                 {
2076                         command_print(cmd_ctx, "usage: %s [seconds]", cmd);
2077                         return ERROR_COMMAND_SYNTAX_ERROR;
2078                 }
2079                 // convert seconds (given) to milliseconds (needed)
2080                 ms *= 1000;
2081         }
2082
2083         target_t *target = get_current_target(cmd_ctx);
2084         return target_wait_state(target, TARGET_HALTED, ms);
2085 }
2086
2087 /* wait for target state to change. The trick here is to have a low
2088  * latency for short waits and not to suck up all the CPU time
2089  * on longer waits.
2090  *
2091  * After 500ms, keep_alive() is invoked
2092  */
2093 int target_wait_state(target_t *target, enum target_state state, int ms)
2094 {
2095         int retval;
2096         long long then = 0, cur;
2097         int once = 1;
2098
2099         for (;;)
2100         {
2101                 if ((retval = target_poll(target)) != ERROR_OK)
2102                         return retval;
2103                 if (target->state == state)
2104                 {
2105                         break;
2106                 }
2107                 cur = timeval_ms();
2108                 if (once)
2109                 {
2110                         once = 0;
2111                         then = timeval_ms();
2112                         LOG_DEBUG("waiting for target %s...",
2113                                 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
2114                 }
2115
2116                 if (cur-then > 500)
2117                 {
2118                         keep_alive();
2119                 }
2120
2121                 if ((cur-then) > ms)
2122                 {
2123                         LOG_ERROR("timed out while waiting for target %s",
2124                                 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
2125                         return ERROR_FAIL;
2126                 }
2127         }
2128
2129         return ERROR_OK;
2130 }
2131
2132 static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2133 {
2134         LOG_DEBUG("-");
2135
2136         target_t *target = get_current_target(cmd_ctx);
2137         int retval = target_halt(target);
2138         if (ERROR_OK != retval)
2139                 return retval;
2140
2141         if (argc == 1)
2142         {
2143                 unsigned wait;
2144                 retval = parse_uint(args[0], &wait);
2145                 if (ERROR_OK != retval)
2146                         return ERROR_COMMAND_SYNTAX_ERROR;
2147                 if (!wait)
2148                         return ERROR_OK;
2149         }
2150
2151         return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
2152 }
2153
2154 static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2155 {
2156         target_t *target = get_current_target(cmd_ctx);
2157
2158         LOG_USER("requesting target halt and executing a soft reset");
2159
2160         target->type->soft_reset_halt(target);
2161
2162         return ERROR_OK;
2163 }
2164
2165 static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2166 {
2167         if (argc > 1)
2168                 return ERROR_COMMAND_SYNTAX_ERROR;
2169
2170         enum target_reset_mode reset_mode = RESET_RUN;
2171         if (argc == 1)
2172         {
2173                 const Jim_Nvp *n;
2174                 n = Jim_Nvp_name2value_simple(nvp_reset_modes, args[0]);
2175                 if ((n->name == NULL) || (n->value == RESET_UNKNOWN)) {
2176                         return ERROR_COMMAND_SYNTAX_ERROR;
2177                 }
2178                 reset_mode = n->value;
2179         }
2180
2181         /* reset *all* targets */
2182         return target_process_reset(cmd_ctx, reset_mode);
2183 }
2184
2185
2186 static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2187 {
2188         int current = 1;
2189         if (argc > 1)
2190                 return ERROR_COMMAND_SYNTAX_ERROR;
2191
2192         target_t *target = get_current_target(cmd_ctx);
2193         target_handle_event(target, TARGET_EVENT_OLD_pre_resume);
2194
2195         /* with no args, resume from current pc, addr = 0,
2196          * with one arguments, addr = args[0],
2197          * handle breakpoints, not debugging */
2198         uint32_t addr = 0;
2199         if (argc == 1)
2200         {
2201                 int retval = parse_u32(args[0], &addr);
2202                 if (ERROR_OK != retval)
2203                         return retval;
2204                 current = 0;
2205         }
2206
2207         return target_resume(target, current, addr, 1, 0);
2208 }
2209
2210 static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2211 {
2212         if (argc > 1)
2213                 return ERROR_COMMAND_SYNTAX_ERROR;
2214
2215         LOG_DEBUG("-");
2216
2217         /* with no args, step from current pc, addr = 0,
2218          * with one argument addr = args[0],
2219          * handle breakpoints, debugging */
2220         uint32_t addr = 0;
2221         int current_pc = 1;
2222         if (argc == 1)
2223         {
2224                 int retval = parse_u32(args[0], &addr);
2225                 if (ERROR_OK != retval)
2226                         return retval;
2227                 current_pc = 0;
2228         }
2229
2230         target_t *target = get_current_target(cmd_ctx);
2231
2232         return target->type->step(target, current_pc, addr, 1);
2233 }
2234
2235 static void handle_md_output(struct command_context_s *cmd_ctx,
2236                 struct target_s *target, uint32_t address, unsigned size,
2237                 unsigned count, const uint8_t *buffer)
2238 {
2239         const unsigned line_bytecnt = 32;
2240         unsigned line_modulo = line_bytecnt / size;
2241
2242         char output[line_bytecnt * 4 + 1];
2243         unsigned output_len = 0;
2244
2245         const char *value_fmt;
2246         switch (size) {
2247         case 4: value_fmt = "%8.8x "; break;
2248         case 2: value_fmt = "%4.2x "; break;
2249         case 1: value_fmt = "%2.2x "; break;
2250         default:
2251                 LOG_ERROR("invalid memory read size: %u", size);
2252                 exit(-1);
2253         }
2254
2255         for (unsigned i = 0; i < count; i++)
2256         {
2257                 if (i % line_modulo == 0)
2258                 {
2259                         output_len += snprintf(output + output_len,
2260                                         sizeof(output) - output_len,
2261                                         "0x%8.8x: ",
2262                                         (unsigned)(address + (i*size)));
2263                 }
2264
2265                 uint32_t value = 0;
2266                 const uint8_t *value_ptr = buffer + i * size;
2267                 switch (size) {
2268                 case 4: value = target_buffer_get_u32(target, value_ptr); break;
2269                 case 2: value = target_buffer_get_u16(target, value_ptr); break;
2270                 case 1: value = *value_ptr;
2271                 }
2272                 output_len += snprintf(output + output_len,
2273                                 sizeof(output) - output_len,
2274                                 value_fmt, value);
2275
2276                 if ((i % line_modulo == line_modulo - 1) || (i == count - 1))
2277                 {
2278                         command_print(cmd_ctx, "%s", output);
2279                         output_len = 0;
2280                 }
2281         }
2282 }
2283
2284 static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2285 {
2286         if (argc < 1)
2287                 return ERROR_COMMAND_SYNTAX_ERROR;
2288
2289         unsigned size = 0;
2290         switch (cmd[2]) {
2291         case 'w': size = 4; break;
2292         case 'h': size = 2; break;
2293         case 'b': size = 1; break;
2294         default: return ERROR_COMMAND_SYNTAX_ERROR;
2295         }
2296
2297         bool physical=strcmp(args[0], "phys")==0;
2298         int (*fn)(struct target_s *target,
2299                         uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
2300         if (physical)
2301         {
2302                 argc--;
2303                 args++;
2304                 fn=target_read_phys_memory;
2305         } else
2306         {
2307                 fn=target_read_memory;
2308         }
2309         if ((argc < 1) || (argc > 2))
2310         {
2311                 return ERROR_COMMAND_SYNTAX_ERROR;
2312         }
2313         uint32_t address;
2314         int retval = parse_u32(args[0], &address);
2315         if (ERROR_OK != retval)
2316                 return retval;
2317
2318         unsigned count = 1;
2319         if (argc == 2)
2320         {
2321                 retval = parse_uint(args[1], &count);
2322                 if (ERROR_OK != retval)
2323                         return retval;
2324         }
2325
2326         uint8_t *buffer = calloc(count, size);
2327
2328         target_t *target = get_current_target(cmd_ctx);
2329         retval = fn(target, address, size, count, buffer);
2330         if (ERROR_OK == retval)
2331                 handle_md_output(cmd_ctx, target, address, size, count, buffer);
2332
2333         free(buffer);
2334
2335         return retval;
2336 }
2337
2338 static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2339 {
2340         if (argc < 2)
2341         {
2342                 return ERROR_COMMAND_SYNTAX_ERROR;
2343         }
2344         bool physical=strcmp(args[0], "phys")==0;
2345         int (*fn)(struct target_s *target,
2346                         uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
2347         if (physical)
2348         {
2349                 argc--;
2350                 args++;
2351                 fn=target_write_phys_memory;
2352         } else
2353         {
2354                 fn=target_write_memory;
2355         }
2356         if ((argc < 2) || (argc > 3))
2357                 return ERROR_COMMAND_SYNTAX_ERROR;
2358
2359         uint32_t address;
2360         int retval = parse_u32(args[0], &address);
2361         if (ERROR_OK != retval)
2362                 return retval;
2363
2364         uint32_t value;
2365         retval = parse_u32(args[1], &value);
2366         if (ERROR_OK != retval)
2367                 return retval;
2368
2369         unsigned count = 1;
2370         if (argc == 3)
2371         {
2372                 retval = parse_uint(args[2], &count);
2373                 if (ERROR_OK != retval)
2374                         return retval;
2375         }
2376
2377         target_t *target = get_current_target(cmd_ctx);
2378         unsigned wordsize;
2379         uint8_t value_buf[4];
2380         switch (cmd[2])
2381         {
2382                 case 'w':
2383                         wordsize = 4;
2384                         target_buffer_set_u32(target, value_buf, value);
2385                         break;
2386                 case 'h':
2387                         wordsize = 2;
2388                         target_buffer_set_u16(target, value_buf, value);
2389                         break;
2390                 case 'b':
2391                         wordsize = 1;
2392                         value_buf[0] = value;
2393                         break;
2394                 default:
2395                         return ERROR_COMMAND_SYNTAX_ERROR;
2396         }
2397         for (unsigned i = 0; i < count; i++)
2398         {
2399                 retval = fn(target,
2400                                 address + i * wordsize, wordsize, 1, value_buf);
2401                 if (ERROR_OK != retval)
2402                         return retval;
2403                 keep_alive();
2404         }
2405
2406         return ERROR_OK;
2407
2408 }
2409
2410 static int parse_load_image_command_args(char **args, int argc,
2411                 image_t *image, uint32_t *min_address, uint32_t *max_address)
2412 {
2413         if (argc < 1 || argc > 5)
2414                 return ERROR_COMMAND_SYNTAX_ERROR;
2415
2416         /* a base address isn't always necessary,
2417          * default to 0x0 (i.e. don't relocate) */
2418         if (argc >= 2)
2419         {
2420                 uint32_t addr;
2421                 int retval = parse_u32(args[1], &addr);
2422                 if (ERROR_OK != retval)
2423                         return ERROR_COMMAND_SYNTAX_ERROR;
2424                 image->base_address = addr;
2425                 image->base_address_set = 1;
2426         }
2427         else
2428                 image->base_address_set = 0;
2429
2430         image->start_address_set = 0;
2431
2432         if (argc >= 4)
2433         {
2434                 int retval = parse_u32(args[3], min_address);
2435                 if (ERROR_OK != retval)
2436                         return ERROR_COMMAND_SYNTAX_ERROR;
2437         }
2438         if (argc == 5)
2439         {
2440                 int retval = parse_u32(args[4], max_address);
2441                 if (ERROR_OK != retval)
2442                         return ERROR_COMMAND_SYNTAX_ERROR;
2443                 // use size (given) to find max (required)
2444                 *max_address += *min_address;
2445         }
2446
2447         if (*min_address > *max_address)
2448                 return ERROR_COMMAND_SYNTAX_ERROR;
2449
2450         return ERROR_OK;
2451 }
2452
2453 static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2454 {
2455         uint8_t *buffer;
2456         uint32_t buf_cnt;
2457         uint32_t image_size;
2458         uint32_t min_address = 0;
2459         uint32_t max_address = 0xffffffff;
2460         int i;
2461         int retvaltemp;
2462
2463         image_t image;
2464
2465         duration_t duration;
2466         char *duration_text;
2467
2468         int retval = parse_load_image_command_args(args, argc,
2469                         &image, &min_address, &max_address);
2470         if (ERROR_OK != retval)
2471                 return retval;
2472
2473         target_t *target = get_current_target(cmd_ctx);
2474         duration_start_measure(&duration);
2475
2476         if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
2477         {
2478                 return ERROR_OK;
2479         }
2480
2481         image_size = 0x0;
2482         retval = ERROR_OK;
2483         for (i = 0; i < image.num_sections; i++)
2484         {
2485                 buffer = malloc(image.sections[i].size);
2486                 if (buffer == NULL)
2487                 {
2488                         command_print(cmd_ctx,
2489                                                   "error allocating buffer for section (%d bytes)",
2490                                                   (int)(image.sections[i].size));
2491                         break;
2492                 }
2493
2494                 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2495                 {
2496                         free(buffer);
2497                         break;
2498                 }
2499
2500                 uint32_t offset = 0;
2501                 uint32_t length = buf_cnt;
2502
2503                 /* DANGER!!! beware of unsigned comparision here!!! */
2504
2505                 if ((image.sections[i].base_address + buf_cnt >= min_address)&&
2506                                 (image.sections[i].base_address < max_address))
2507                 {
2508                         if (image.sections[i].base_address < min_address)
2509                         {
2510                                 /* clip addresses below */
2511                                 offset += min_address-image.sections[i].base_address;
2512                                 length -= offset;
2513                         }
2514
2515                         if (image.sections[i].base_address + buf_cnt > max_address)
2516                         {
2517                                 length -= (image.sections[i].base_address + buf_cnt)-max_address;
2518                         }
2519
2520                         if ((retval = target_write_buffer(target, image.sections[i].base_address + offset, length, buffer + offset)) != ERROR_OK)
2521                         {
2522                                 free(buffer);
2523                                 break;
2524                         }
2525                         image_size += length;
2526                         command_print(cmd_ctx, "%u bytes written at address 0x%8.8" PRIx32 "",
2527                                                   (unsigned int)length,
2528                                                   image.sections[i].base_address + offset);
2529                 }
2530
2531                 free(buffer);
2532         }
2533
2534         if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2535         {
2536                 image_close(&image);
2537                 return retvaltemp;
2538         }
2539
2540         if (retval == ERROR_OK)
2541         {
2542                 command_print(cmd_ctx, "downloaded %u byte in %s",
2543                                           (unsigned int)image_size,
2544                                           duration_text);
2545         }
2546         free(duration_text);
2547
2548         image_close(&image);
2549
2550         return retval;
2551
2552 }
2553
2554 static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2555 {
2556         fileio_t fileio;
2557
2558         uint8_t buffer[560];
2559         int retvaltemp;
2560
2561         duration_t duration;
2562         char *duration_text;
2563
2564         target_t *target = get_current_target(cmd_ctx);
2565
2566         if (argc != 3)
2567         {
2568                 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2569                 return ERROR_OK;
2570         }
2571
2572         uint32_t address;
2573         int retval = parse_u32(args[1], &address);
2574         if (ERROR_OK != retval)
2575                 return retval;
2576
2577         uint32_t size;
2578         retval = parse_u32(args[2], &size);
2579         if (ERROR_OK != retval)
2580                 return retval;
2581
2582         if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2583         {
2584                 return ERROR_OK;
2585         }
2586
2587         duration_start_measure(&duration);
2588
2589         while (size > 0)
2590         {
2591                 uint32_t size_written;
2592                 uint32_t this_run_size = (size > 560) ? 560 : size;
2593
2594                 retval = target_read_buffer(target, address, this_run_size, buffer);
2595                 if (retval != ERROR_OK)
2596                 {
2597                         break;
2598                 }
2599
2600                 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2601                 if (retval != ERROR_OK)
2602                 {
2603                         break;
2604                 }
2605
2606                 size -= this_run_size;
2607                 address += this_run_size;
2608         }
2609
2610         if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
2611                 return retvaltemp;
2612
2613         if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2614                 return retvaltemp;
2615
2616         if (retval == ERROR_OK)
2617         {
2618                 command_print(cmd_ctx, "dumped %lld byte in %s",
2619                                 fileio.size, duration_text);
2620                 free(duration_text);
2621         }
2622
2623         return retval;
2624 }
2625
2626 static int handle_verify_image_command_internal(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, int verify)
2627 {
2628         uint8_t *buffer;
2629         uint32_t buf_cnt;
2630         uint32_t image_size;
2631         int i;
2632         int retval, retvaltemp;
2633         uint32_t checksum = 0;
2634         uint32_t mem_checksum = 0;
2635
2636         image_t image;
2637
2638         duration_t duration;
2639         char *duration_text;
2640
2641         target_t *target = get_current_target(cmd_ctx);
2642
2643         if (argc < 1)
2644         {
2645                 return ERROR_COMMAND_SYNTAX_ERROR;
2646         }
2647
2648         if (!target)
2649         {
2650                 LOG_ERROR("no target selected");
2651                 return ERROR_FAIL;
2652         }
2653
2654         duration_start_measure(&duration);
2655
2656         if (argc >= 2)
2657         {
2658                 uint32_t addr;
2659                 retval = parse_u32(args[1], &addr);
2660                 if (ERROR_OK != retval)
2661                         return ERROR_COMMAND_SYNTAX_ERROR;
2662                 image.base_address = addr;
2663                 image.base_address_set = 1;
2664         }
2665         else
2666         {
2667                 image.base_address_set = 0;
2668                 image.base_address = 0x0;
2669         }
2670
2671         image.start_address_set = 0;
2672
2673         if ((retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2674         {
2675                 return retval;
2676         }
2677
2678         image_size = 0x0;
2679         retval = ERROR_OK;
2680         for (i = 0; i < image.num_sections; i++)
2681         {
2682                 buffer = malloc(image.sections[i].size);
2683                 if (buffer == NULL)
2684                 {
2685                         command_print(cmd_ctx,
2686                                                   "error allocating buffer for section (%d bytes)",
2687                                                   (int)(image.sections[i].size));
2688                         break;
2689                 }
2690                 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2691                 {
2692                         free(buffer);
2693                         break;
2694                 }
2695
2696                 if (verify)
2697                 {
2698                         /* calculate checksum of image */
2699                         image_calculate_checksum(buffer, buf_cnt, &checksum);
2700
2701                         retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2702                         if (retval != ERROR_OK)
2703                         {
2704                                 free(buffer);
2705                                 break;
2706                         }
2707
2708                         if (checksum != mem_checksum)
2709                         {
2710                                 /* failed crc checksum, fall back to a binary compare */
2711                                 uint8_t *data;
2712
2713                                 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2714
2715                                 data = (uint8_t*)malloc(buf_cnt);
2716
2717                                 /* Can we use 32bit word accesses? */
2718                                 int size = 1;
2719                                 int count = buf_cnt;
2720                                 if ((count % 4) == 0)
2721                                 {
2722                                         size *= 4;
2723                                         count /= 4;
2724                                 }
2725                                 retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
2726                                 if (retval == ERROR_OK)
2727                                 {
2728                                         uint32_t t;
2729                                         for (t = 0; t < buf_cnt; t++)
2730                                         {
2731                                                 if (data[t] != buffer[t])
2732                                                 {
2733                                                         command_print(cmd_ctx,
2734                                                                                   "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n",
2735                                                                                   (unsigned)(t + image.sections[i].base_address),
2736                                                                                   data[t],
2737                                                                                   buffer[t]);
2738                                                         free(data);
2739                                                         free(buffer);
2740                                                         retval = ERROR_FAIL;
2741                                                         goto done;
2742                                                 }
2743                                                 if ((t%16384) == 0)
2744                                                 {
2745                                                         keep_alive();
2746                                                 }
2747                                         }
2748                                 }
2749
2750                                 free(data);
2751                         }
2752                 } else
2753                 {
2754                         command_print(cmd_ctx, "address 0x%08" PRIx32 " length 0x%08" PRIx32 "",
2755                                                   image.sections[i].base_address,
2756                                                   buf_cnt);
2757                 }
2758
2759                 free(buffer);
2760                 image_size += buf_cnt;
2761         }
2762 done:
2763
2764         if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2765         {
2766                 image_close(&image);
2767                 return retvaltemp;
2768         }
2769
2770         if (retval == ERROR_OK)
2771         {
2772                 command_print(cmd_ctx, "verified %u bytes in %s",
2773                                           (unsigned int)image_size,
2774                                           duration_text);
2775         }
2776         free(duration_text);
2777
2778         image_close(&image);
2779
2780         return retval;
2781 }
2782
2783 static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2784 {
2785         return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 1);
2786 }
2787
2788 static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2789 {
2790         return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 0);
2791 }
2792
2793 static int handle_bp_command_list(struct command_context_s *cmd_ctx)
2794 {
2795         target_t *target = get_current_target(cmd_ctx);
2796         breakpoint_t *breakpoint = target->breakpoints;
2797         while (breakpoint)
2798         {
2799                 if (breakpoint->type == BKPT_SOFT)
2800                 {
2801                         char* buf = buf_to_str(breakpoint->orig_instr,
2802                                         breakpoint->length, 16);
2803                         command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
2804                                         breakpoint->address,
2805                                         breakpoint->length,
2806                                         breakpoint->set, buf);
2807                         free(buf);
2808                 }
2809                 else
2810                 {
2811                         command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i",
2812                                                   breakpoint->address,
2813                                                   breakpoint->length, breakpoint->set);
2814                 }
2815
2816                 breakpoint = breakpoint->next;
2817         }
2818         return ERROR_OK;
2819 }
2820
2821 static int handle_bp_command_set(struct command_context_s *cmd_ctx,
2822                 uint32_t addr, uint32_t length, int hw)
2823 {
2824         target_t *target = get_current_target(cmd_ctx);
2825         int retval = breakpoint_add(target, addr, length, hw);
2826         if (ERROR_OK == retval)
2827                 command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
2828         else
2829                 LOG_ERROR("Failure setting breakpoint");
2830         return retval;
2831 }
2832
2833 static int handle_bp_command(struct command_context_s *cmd_ctx,
2834                 char *cmd, char **args, int argc)
2835 {
2836         if (argc == 0)
2837                 return handle_bp_command_list(cmd_ctx);
2838
2839         if (argc < 2 || argc > 3)
2840         {
2841                 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2842                 return ERROR_COMMAND_SYNTAX_ERROR;
2843         }
2844
2845         uint32_t addr;
2846         int retval = parse_u32(args[0], &addr);
2847         if (ERROR_OK != retval)
2848                 return retval;
2849
2850         uint32_t length;
2851         retval = parse_u32(args[1], &length);
2852         if (ERROR_OK != retval)
2853                 return retval;
2854
2855         int hw = BKPT_SOFT;
2856         if (argc == 3)
2857         {
2858                 if (strcmp(args[2], "hw") == 0)
2859                         hw = BKPT_HARD;
2860                 else
2861                         return ERROR_COMMAND_SYNTAX_ERROR;
2862         }
2863
2864         return handle_bp_command_set(cmd_ctx, addr, length, hw);
2865 }
2866
2867 static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2868 {
2869         if (argc != 1)
2870                 return ERROR_COMMAND_SYNTAX_ERROR;
2871
2872         uint32_t addr;
2873         int retval = parse_u32(args[0], &addr);
2874         if (ERROR_OK != retval)
2875                 return retval;
2876
2877         target_t *target = get_current_target(cmd_ctx);
2878         breakpoint_remove(target, addr);
2879
2880         return ERROR_OK;
2881 }
2882
2883 static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2884 {
2885         target_t *target = get_current_target(cmd_ctx);
2886
2887         if (argc == 0)
2888         {
2889                 watchpoint_t *watchpoint = target->watchpoints;
2890
2891                 while (watchpoint)
2892                 {
2893                         command_print(cmd_ctx,
2894                                                   "address: 0x%8.8" PRIx32 ", len: 0x%8.8x, r/w/a: %i, value: 0x%8.8" PRIx32 ", mask: 0x%8.8" PRIx32 "",
2895                                                   watchpoint->address,
2896                                                   watchpoint->length,
2897                                                   (int)(watchpoint->rw),
2898                                                   watchpoint->value,
2899                                                   watchpoint->mask);
2900                         watchpoint = watchpoint->next;
2901                 }
2902                 return ERROR_OK;
2903         }
2904
2905         enum watchpoint_rw type = WPT_ACCESS;
2906         uint32_t addr = 0;
2907         uint32_t length = 0;
2908         uint32_t data_value = 0x0;
2909         uint32_t data_mask = 0xffffffff;
2910         int retval;
2911
2912         switch (argc)
2913         {
2914         case 5:
2915                 retval = parse_u32(args[4], &data_mask);
2916                 if (ERROR_OK != retval)
2917                         return retval;
2918                 // fall through
2919         case 4:
2920                 retval = parse_u32(args[3], &data_value);
2921                 if (ERROR_OK != retval)
2922                         return retval;
2923                 // fall through
2924         case 3:
2925                 switch (args[2][0])
2926                 {
2927                 case 'r':
2928                         type = WPT_READ;
2929                         break;
2930                 case 'w':
2931                         type = WPT_WRITE;
2932                         break;
2933                 case 'a':
2934                         type = WPT_ACCESS;
2935                         break;
2936                 default:
2937                         LOG_ERROR("invalid watchpoint mode ('%c')", args[2][0]);
2938                         return ERROR_COMMAND_SYNTAX_ERROR;
2939                 }
2940                 // fall through
2941         case 2:
2942                 retval = parse_u32(args[1], &length);
2943                 if (ERROR_OK != retval)
2944                         return retval;
2945                 retval = parse_u32(args[0], &addr);
2946                 if (ERROR_OK != retval)
2947                         return retval;
2948                 break;
2949
2950         default:
2951                 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2952                 return ERROR_COMMAND_SYNTAX_ERROR;
2953         }
2954
2955         retval = watchpoint_add(target, addr, length, type,
2956                         data_value, data_mask);
2957         if (ERROR_OK != retval)
2958                 LOG_ERROR("Failure setting watchpoints");
2959
2960         return retval;
2961 }
2962
2963 static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2964 {
2965         if (argc != 1)
2966                 return ERROR_COMMAND_SYNTAX_ERROR;
2967
2968         uint32_t addr;
2969         int retval = parse_u32(args[0], &addr);
2970         if (ERROR_OK != retval)
2971                 return retval;
2972
2973         target_t *target = get_current_target(cmd_ctx);
2974         watchpoint_remove(target, addr);
2975
2976         return ERROR_OK;
2977 }
2978
2979
2980 /**
2981  * Translate a virtual address to a physical address.
2982  *
2983  * The low-level target implementation must have logged a detailed error
2984  * which is forwarded to telnet/GDB session.
2985  */
2986 static int handle_virt2phys_command(command_context_t *cmd_ctx,
2987                 char *cmd, char **args, int argc)
2988 {
2989         if (argc != 1)
2990                 return ERROR_COMMAND_SYNTAX_ERROR;
2991
2992         uint32_t va;
2993         int retval = parse_u32(args[0], &va);
2994         if (ERROR_OK != retval)
2995                 return retval;
2996         uint32_t pa;
2997
2998         target_t *target = get_current_target(cmd_ctx);
2999         retval = target->type->virt2phys(target, va, &pa);
3000         if (retval == ERROR_OK)
3001                 command_print(cmd_ctx, "Physical address 0x%08" PRIx32 "", pa);
3002
3003         return retval;
3004 }
3005
3006 static void writeData(FILE *f, const void *data, size_t len)
3007 {
3008         size_t written = fwrite(data, 1, len, f);
3009         if (written != len)
3010                 LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
3011 }
3012
3013 static void writeLong(FILE *f, int l)
3014 {
3015         int i;
3016         for (i = 0; i < 4; i++)
3017         {
3018                 char c = (l >> (i*8))&0xff;
3019                 writeData(f, &c, 1);
3020         }
3021
3022 }
3023
3024 static void writeString(FILE *f, char *s)
3025 {
3026         writeData(f, s, strlen(s));
3027 }
3028
3029 /* Dump a gmon.out histogram file. */
3030 static void writeGmon(uint32_t *samples, uint32_t sampleNum, char *filename)
3031 {
3032         uint32_t i;
3033         FILE *f = fopen(filename, "w");
3034         if (f == NULL)
3035                 return;
3036         writeString(f, "gmon");
3037         writeLong(f, 0x00000001); /* Version */
3038         writeLong(f, 0); /* padding */
3039         writeLong(f, 0); /* padding */
3040         writeLong(f, 0); /* padding */
3041
3042         uint8_t zero = 0;  /* GMON_TAG_TIME_HIST */
3043         writeData(f, &zero, 1);
3044
3045         /* figure out bucket size */
3046         uint32_t min = samples[0];
3047         uint32_t max = samples[0];
3048         for (i = 0; i < sampleNum; i++)
3049         {
3050                 if (min > samples[i])
3051                 {
3052                         min = samples[i];
3053                 }
3054                 if (max < samples[i])
3055                 {
3056                         max = samples[i];
3057                 }
3058         }
3059
3060         int addressSpace = (max-min + 1);
3061
3062         static const uint32_t maxBuckets = 256 * 1024; /* maximum buckets. */
3063         uint32_t length = addressSpace;
3064         if (length > maxBuckets)
3065         {
3066                 length = maxBuckets;
3067         }
3068         int *buckets = malloc(sizeof(int)*length);
3069         if (buckets == NULL)
3070         {
3071                 fclose(f);
3072                 return;
3073         }
3074         memset(buckets, 0, sizeof(int)*length);
3075         for (i = 0; i < sampleNum;i++)
3076         {
3077                 uint32_t address = samples[i];
3078                 long long a = address-min;
3079                 long long b = length-1;
3080                 long long c = addressSpace-1;
3081                 int index = (a*b)/c; /* danger!!!! int32 overflows */
3082                 buckets[index]++;
3083         }
3084
3085         /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
3086         writeLong(f, min);                      /* low_pc */
3087         writeLong(f, max);                      /* high_pc */
3088         writeLong(f, length);           /* # of samples */
3089         writeLong(f, 64000000);         /* 64MHz */
3090         writeString(f, "seconds");
3091         for (i = 0; i < (15-strlen("seconds")); i++)
3092                 writeData(f, &zero, 1);
3093         writeString(f, "s");
3094
3095         /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
3096
3097         char *data = malloc(2*length);
3098         if (data != NULL)
3099         {
3100                 for (i = 0; i < length;i++)
3101                 {
3102                         int val;
3103                         val = buckets[i];
3104                         if (val > 65535)
3105                         {
3106                                 val = 65535;
3107                         }
3108                         data[i*2]=val&0xff;
3109                         data[i*2 + 1]=(val >> 8)&0xff;
3110                 }
3111                 free(buckets);
3112                 writeData(f, data, length * 2);
3113                 free(data);
3114         } else
3115         {
3116                 free(buckets);
3117         }
3118
3119         fclose(f);
3120 }
3121
3122 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
3123 static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3124 {
3125         target_t *target = get_current_target(cmd_ctx);
3126         struct timeval timeout, now;
3127
3128         gettimeofday(&timeout, NULL);
3129         if (argc != 2)
3130         {
3131                 return ERROR_COMMAND_SYNTAX_ERROR;
3132         }
3133         unsigned offset;
3134         int retval = parse_uint(args[0], &offset);
3135         if (ERROR_OK != retval)
3136                 return retval;
3137
3138         timeval_add_time(&timeout, offset, 0);
3139
3140         command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
3141
3142         static const int maxSample = 10000;
3143         uint32_t *samples = malloc(sizeof(uint32_t)*maxSample);
3144         if (samples == NULL)
3145                 return ERROR_OK;
3146
3147         int numSamples = 0;
3148         /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
3149         reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
3150
3151         for (;;)
3152         {
3153                 target_poll(target);
3154                 if (target->state == TARGET_HALTED)
3155                 {
3156                         uint32_t t=*((uint32_t *)reg->value);
3157                         samples[numSamples++]=t;
3158                         retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
3159                         target_poll(target);
3160                         alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
3161                 } else if (target->state == TARGET_RUNNING)
3162                 {
3163                         /* We want to quickly sample the PC. */
3164                         if ((retval = target_halt(target)) != ERROR_OK)
3165                         {
3166                                 free(samples);
3167                                 return retval;
3168                         }
3169                 } else
3170                 {
3171                         command_print(cmd_ctx, "Target not halted or running");
3172                         retval = ERROR_OK;
3173                         break;
3174                 }
3175                 if (retval != ERROR_OK)
3176                 {
3177                         break;
3178                 }
3179
3180                 gettimeofday(&now, NULL);
3181                 if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
3182                 {
3183                         command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
3184                         if ((retval = target_poll(target)) != ERROR_OK)
3185                         {
3186                                 free(samples);
3187                                 return retval;
3188                         }
3189                         if (target->state == TARGET_HALTED)
3190                         {
3191                                 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
3192                         }
3193                         if ((retval = target_poll(target)) != ERROR_OK)
3194                         {
3195                                 free(samples);
3196                                 return retval;
3197                         }
3198                         writeGmon(samples, numSamples, args[1]);
3199                         command_print(cmd_ctx, "Wrote %s", args[1]);
3200                         break;
3201                 }
3202         }
3203         free(samples);
3204
3205         return ERROR_OK;
3206 }
3207
3208 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t val)
3209 {
3210         char *namebuf;
3211         Jim_Obj *nameObjPtr, *valObjPtr;
3212         int result;
3213
3214         namebuf = alloc_printf("%s(%d)", varname, idx);
3215         if (!namebuf)
3216                 return JIM_ERR;
3217
3218         nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3219         valObjPtr = Jim_NewIntObj(interp, val);
3220         if (!nameObjPtr || !valObjPtr)
3221         {
3222                 free(namebuf);
3223                 return JIM_ERR;
3224         }
3225
3226         Jim_IncrRefCount(nameObjPtr);
3227         Jim_IncrRefCount(valObjPtr);
3228         result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
3229         Jim_DecrRefCount(interp, nameObjPtr);
3230         Jim_DecrRefCount(interp, valObjPtr);
3231         free(namebuf);
3232         /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
3233         return result;
3234 }
3235
3236 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3237 {
3238         command_context_t *context;
3239         target_t *target;
3240
3241         context = Jim_GetAssocData(interp, "context");
3242         if (context == NULL)
3243         {
3244                 LOG_ERROR("mem2array: no command context");
3245                 return JIM_ERR;
3246         }
3247         target = get_current_target(context);
3248         if (target == NULL)
3249         {
3250                 LOG_ERROR("mem2array: no current target");
3251                 return JIM_ERR;
3252         }
3253
3254         return  target_mem2array(interp, target, argc-1, argv + 1);
3255 }
3256
3257 static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
3258 {
3259         long l;
3260         uint32_t width;
3261         int len;
3262         uint32_t addr;
3263         uint32_t count;
3264         uint32_t v;
3265         const char *varname;
3266         uint8_t buffer[4096];
3267         int  n, e, retval;
3268         uint32_t i;
3269
3270         /* argv[1] = name of array to receive the data
3271          * argv[2] = desired width
3272          * argv[3] = memory address
3273          * argv[4] = count of times to read
3274          */
3275         if (argc != 4) {
3276                 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
3277                 return JIM_ERR;
3278         }
3279         varname = Jim_GetString(argv[0], &len);
3280         /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3281
3282         e = Jim_GetLong(interp, argv[1], &l);
3283         width = l;
3284         if (e != JIM_OK) {
3285                 return e;
3286         }
3287
3288         e = Jim_GetLong(interp, argv[2], &l);
3289         addr = l;
3290         if (e != JIM_OK) {
3291                 return e;
3292         }
3293         e = Jim_GetLong(interp, argv[3], &l);
3294         len = l;
3295         if (e != JIM_OK) {
3296                 return e;
3297         }
3298         switch (width) {
3299                 case 8:
3300                         width = 1;
3301                         break;
3302                 case 16:
3303                         width = 2;
3304                         break;
3305                 case 32:
3306                         width = 4;
3307                         break;
3308                 default:
3309                         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3310                         Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3311                         return JIM_ERR;
3312         }
3313         if (len == 0) {
3314                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3315                 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
3316                 return JIM_ERR;
3317         }
3318         if ((addr + (len * width)) < addr) {
3319                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3320                 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
3321                 return JIM_ERR;
3322         }
3323         /* absurd transfer size? */
3324         if (len > 65536) {
3325                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3326                 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
3327                 return JIM_ERR;
3328         }
3329
3330         if ((width == 1) ||
3331                 ((width == 2) && ((addr & 1) == 0)) ||
3332                 ((width == 4) && ((addr & 3) == 0))) {
3333                 /* all is well */
3334         } else {
3335                 char buf[100];
3336                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3337                 sprintf(buf, "mem2array address: 0x%08" PRIx32 " is not aligned for %" PRId32 " byte reads",
3338                                 addr,
3339                                 width);
3340                 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3341                 return JIM_ERR;
3342         }
3343
3344         /* Transfer loop */
3345
3346         /* index counter */
3347         n = 0;
3348         /* assume ok */
3349         e = JIM_OK;
3350         while (len) {
3351                 /* Slurp... in buffer size chunks */
3352
3353                 count = len; /* in objects.. */
3354                 if (count > (sizeof(buffer)/width)) {
3355                         count = (sizeof(buffer)/width);
3356                 }
3357
3358                 retval = target_read_memory(target, addr, width, count, buffer);
3359                 if (retval != ERROR_OK) {
3360                         /* BOO !*/
3361                         LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed",
3362                                           (unsigned int)addr,
3363                                           (int)width,
3364                                           (int)count);
3365                         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3366                         Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
3367                         e = JIM_ERR;
3368                         len = 0;
3369                 } else {
3370                         v = 0; /* shut up gcc */
3371                         for (i = 0 ;i < count ;i++, n++) {
3372                                 switch (width) {
3373                                         case 4:
3374                                                 v = target_buffer_get_u32(target, &buffer[i*width]);
3375                                                 break;
3376                                         case 2:
3377                                                 v = target_buffer_get_u16(target, &buffer[i*width]);
3378                                                 break;
3379                                         case 1:
3380                                                 v = buffer[i] & 0x0ff;
3381                                                 break;
3382                                 }
3383                                 new_int_array_element(interp, varname, n, v);
3384                         }
3385                         len -= count;
3386                 }
3387         }
3388
3389         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3390
3391         return JIM_OK;
3392 }
3393
3394 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t *val)
3395 {
3396         char *namebuf;
3397         Jim_Obj *nameObjPtr, *valObjPtr;
3398         int result;
3399         long l;
3400
3401         namebuf = alloc_printf("%s(%d)", varname, idx);
3402         if (!namebuf)
3403                 return JIM_ERR;
3404
3405         nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3406         if (!nameObjPtr)
3407         {
3408                 free(namebuf);
3409                 return JIM_ERR;
3410         }
3411
3412         Jim_IncrRefCount(nameObjPtr);
3413         valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
3414         Jim_DecrRefCount(interp, nameObjPtr);
3415         free(namebuf);
3416         if (valObjPtr == NULL)
3417                 return JIM_ERR;
3418
3419         result = Jim_GetLong(interp, valObjPtr, &l);
3420         /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
3421         *val = l;
3422         return result;
3423 }
3424
3425 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3426 {
3427         command_context_t *context;
3428         target_t *target;
3429
3430         context = Jim_GetAssocData(interp, "context");
3431         if (context == NULL) {
3432                 LOG_ERROR("array2mem: no command context");
3433                 return JIM_ERR;
3434         }
3435         target = get_current_target(context);
3436         if (target == NULL) {
3437                 LOG_ERROR("array2mem: no current target");
3438                 return JIM_ERR;
3439         }
3440
3441         return target_array2mem(interp,target, argc-1, argv + 1);
3442 }
3443 static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
3444 {
3445         long l;
3446         uint32_t width;
3447         int len;
3448         uint32_t addr;
3449         uint32_t count;
3450         uint32_t v;
3451         const char *varname;
3452         uint8_t buffer[4096];
3453         int  n, e, retval;
3454         uint32_t i;
3455
3456         /* argv[1] = name of array to get the data
3457          * argv[2] = desired width
3458          * argv[3] = memory address
3459          * argv[4] = count to write
3460          */
3461         if (argc != 4) {
3462                 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
3463                 return JIM_ERR;
3464         }
3465         varname = Jim_GetString(argv[0], &len);
3466         /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3467
3468         e = Jim_GetLong(interp, argv[1], &l);
3469         width = l;
3470         if (e != JIM_OK) {
3471                 return e;
3472         }
3473
3474         e = Jim_GetLong(interp, argv[2], &l);
3475         addr = l;
3476         if (e != JIM_OK) {
3477                 return e;
3478         }
3479         e = Jim_GetLong(interp, argv[3], &l);
3480         len = l;
3481         if (e != JIM_OK) {
3482                 return e;
3483         }
3484         switch (width) {
3485                 case 8:
3486                         width = 1;
3487                         break;
3488                 case 16:
3489                         width = 2;
3490                         break;
3491                 case 32:
3492                         width = 4;
3493                         break;
3494                 default:
3495                         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3496                         Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3497                         return JIM_ERR;
3498         }
3499         if (len == 0) {
3500                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3501                 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
3502                 return JIM_ERR;
3503         }
3504         if ((addr + (len * width)) < addr) {
3505                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3506                 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
3507                 return JIM_ERR;
3508         }
3509         /* absurd transfer size? */
3510         if (len > 65536) {
3511                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3512                 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
3513                 return JIM_ERR;
3514         }
3515
3516         if ((width == 1) ||
3517                 ((width == 2) && ((addr & 1) == 0)) ||
3518                 ((width == 4) && ((addr & 3) == 0))) {
3519                 /* all is well */
3520         } else {
3521                 char buf[100];
3522                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3523                 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads",
3524                                 (unsigned int)addr,
3525                                 (int)width);
3526                 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3527                 return JIM_ERR;
3528         }
3529
3530         /* Transfer loop */
3531
3532         /* index counter */
3533         n = 0;
3534         /* assume ok */
3535         e = JIM_OK;
3536         while (len) {
3537                 /* Slurp... in buffer size chunks */
3538
3539                 count = len; /* in objects.. */
3540                 if (count > (sizeof(buffer)/width)) {
3541                         count = (sizeof(buffer)/width);
3542                 }
3543
3544                 v = 0; /* shut up gcc */
3545                 for (i = 0 ;i < count ;i++, n++) {
3546                         get_int_array_element(interp, varname, n, &v);
3547                         switch (width) {
3548                         case 4:
3549                                 target_buffer_set_u32(target, &buffer[i*width], v);
3550                                 break;
3551                         case 2:
3552                                 target_buffer_set_u16(target, &buffer[i*width], v);
3553                                 break;
3554                         case 1:
3555                                 buffer[i] = v & 0x0ff;
3556                                 break;
3557                         }
3558                 }
3559                 len -= count;
3560
3561                 retval = target_write_memory(target, addr, width, count, buffer);
3562                 if (retval != ERROR_OK) {
3563                         /* BOO !*/
3564                         LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed",
3565                                           (unsigned int)addr,
3566                                           (int)width,
3567                                           (int)count);
3568                         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3569                         Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: cannot read memory", NULL);
3570                         e = JIM_ERR;
3571                         len = 0;
3572                 }
3573         }
3574
3575         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3576
3577         return JIM_OK;
3578 }
3579
3580 void target_all_handle_event(enum target_event e)
3581 {
3582         target_t *target;
3583
3584         LOG_DEBUG("**all*targets: event: %d, %s",
3585                            (int)e,
3586                            Jim_Nvp_value2name_simple(nvp_target_event, e)->name);
3587
3588         target = all_targets;
3589         while (target) {
3590                 target_handle_event(target, e);
3591                 target = target->next;
3592         }
3593 }
3594
3595
3596 /* FIX? should we propagate errors here rather than printing them
3597  * and continuing?
3598  */
3599 void target_handle_event(target_t *target, enum target_event e)
3600 {
3601         target_event_action_t *teap;
3602
3603         for (teap = target->event_action; teap != NULL; teap = teap->next) {
3604                 if (teap->event == e) {
3605                         LOG_DEBUG("target: (%d) %s (%s) event: %d (%s) action: %s",
3606                                            target->target_number,
3607                                            target->cmd_name,
3608                                            target_get_name(target),
3609                                            e,
3610                                            Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
3611                                            Jim_GetString(teap->body, NULL));
3612                         if (Jim_EvalObj(interp, teap->body) != JIM_OK)
3613                         {
3614                                 Jim_PrintErrorMessage(interp);
3615                         }
3616                 }
3617         }
3618 }
3619
3620 enum target_cfg_param {
3621         TCFG_TYPE,
3622         TCFG_EVENT,
3623         TCFG_WORK_AREA_VIRT,
3624         TCFG_WORK_AREA_PHYS,
3625         TCFG_WORK_AREA_SIZE,
3626         TCFG_WORK_AREA_BACKUP,
3627         TCFG_ENDIAN,
3628         TCFG_VARIANT,
3629         TCFG_CHAIN_POSITION,
3630 };
3631
3632 static Jim_Nvp nvp_config_opts[] = {
3633         { .name = "-type",             .value = TCFG_TYPE },
3634         { .name = "-event",            .value = TCFG_EVENT },
3635         { .name = "-work-area-virt",   .value = TCFG_WORK_AREA_VIRT },
3636         { .name = "-work-area-phys",   .value = TCFG_WORK_AREA_PHYS },
3637         { .name = "-work-area-size",   .value = TCFG_WORK_AREA_SIZE },
3638         { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
3639         { .name = "-endian" ,          .value = TCFG_ENDIAN },
3640         { .name = "-variant",          .value = TCFG_VARIANT },
3641         { .name = "-chain-position",   .value = TCFG_CHAIN_POSITION },
3642
3643         { .name = NULL, .value = -1 }
3644 };
3645
3646 static int target_configure(Jim_GetOptInfo *goi, target_t *target)
3647 {
3648         Jim_Nvp *n;
3649         Jim_Obj *o;
3650         jim_wide w;
3651         char *cp;
3652         int e;
3653
3654         /* parse config or cget options ... */
3655         while (goi->argc > 0) {
3656                 Jim_SetEmptyResult(goi->interp);
3657                 /* Jim_GetOpt_Debug(goi); */
3658
3659                 if (target->type->target_jim_configure) {
3660                         /* target defines a configure function */
3661                         /* target gets first dibs on parameters */
3662                         e = (*(target->type->target_jim_configure))(target, goi);
3663                         if (e == JIM_OK) {
3664                                 /* more? */
3665                                 continue;
3666                         }
3667                         if (e == JIM_ERR) {
3668                                 /* An error */
3669                                 return e;
3670                         }
3671                         /* otherwise we 'continue' below */
3672                 }
3673                 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
3674                 if (e != JIM_OK) {
3675                         Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
3676                         return e;
3677                 }
3678                 switch (n->value) {
3679                 case TCFG_TYPE:
3680                         /* not setable */
3681                         if (goi->isconfigure) {
3682                                 Jim_SetResult_sprintf(goi->interp, "not setable: %s", n->name);
3683                                 return JIM_ERR;
3684                         } else {
3685                         no_params:
3686                                 if (goi->argc != 0) {
3687                                         Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "NO PARAMS");
3688                                         return JIM_ERR;
3689                                 }
3690                         }
3691                         Jim_SetResultString(goi->interp, target_get_name(target), -1);
3692                         /* loop for more */
3693                         break;
3694                 case TCFG_EVENT:
3695                         if (goi->argc == 0) {
3696                                 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
3697                                 return JIM_ERR;
3698                         }
3699
3700                         e = Jim_GetOpt_Nvp(goi, nvp_target_event, &n);
3701                         if (e != JIM_OK) {
3702                                 Jim_GetOpt_NvpUnknown(goi, nvp_target_event, 1);
3703                                 return e;
3704                         }
3705
3706                         if (goi->isconfigure) {
3707                                 if (goi->argc != 1) {
3708                                         Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
3709                                         return JIM_ERR;
3710                                 }
3711                         } else {
3712                                 if (goi->argc != 0) {
3713                                         Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
3714                                         return JIM_ERR;
3715                                 }
3716                         }
3717
3718                         {
3719                                 target_event_action_t *teap;
3720
3721                                 teap = target->event_action;
3722                                 /* replace existing? */
3723                                 while (teap) {
3724                                         if (teap->event == (enum target_event)n->value) {
3725                                                 break;
3726                                         }
3727                                         teap = teap->next;
3728                                 }
3729
3730                                 if (goi->isconfigure) {
3731                                         bool replace = true;
3732                                         if (teap == NULL) {
3733                                                 /* create new */
3734                                                 teap = calloc(1, sizeof(*teap));
3735                                                 replace = false;
3736                                         }
3737                                         teap->event = n->value;
3738                                         Jim_GetOpt_Obj(goi, &o);
3739                                         if (teap->body) {
3740                                                 Jim_DecrRefCount(interp, teap->body);
3741                                         }
3742                                         teap->body  = Jim_DuplicateObj(goi->interp, o);
3743                                         /*
3744                                          * FIXME:
3745                                          *     Tcl/TK - "tk events" have a nice feature.
3746                                          *     See the "BIND" command.
3747                                          *    We should support that here.
3748                                          *     You can specify %X and %Y in the event code.
3749                                          *     The idea is: %T - target name.
3750                                          *     The idea is: %N - target number
3751                                          *     The idea is: %E - event name.
3752                                          */
3753                                         Jim_IncrRefCount(teap->body);
3754
3755                                         if (!replace)
3756                                         {
3757                                                 /* add to head of event list */
3758                                                 teap->next = target->event_action;
3759                                                 target->event_action = teap;
3760                                         }
3761                                         Jim_SetEmptyResult(goi->interp);
3762                                 } else {
3763                                         /* get */
3764                                         if (teap == NULL) {
3765                                                 Jim_SetEmptyResult(goi->interp);
3766                                         } else {
3767                                                 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, teap->body));
3768                                         }
3769                                 }
3770                         }
3771                         /* loop for more */
3772                         break;
3773
3774                 case TCFG_WORK_AREA_VIRT:
3775                         if (goi->isconfigure) {
3776                                 target_free_all_working_areas(target);
3777                                 e = Jim_GetOpt_Wide(goi, &w);
3778                                 if (e != JIM_OK) {
3779                                         return e;
3780                                 }
3781                                 target->working_area_virt = w;
3782                                 target->working_area_virt_spec = true;
3783                         } else {
3784                                 if (goi->argc != 0) {
3785                                         goto no_params;
3786                                 }
3787                         }
3788                         Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_virt));
3789                         /* loop for more */
3790                         break;
3791
3792                 case TCFG_WORK_AREA_PHYS:
3793                         if (goi->isconfigure) {
3794                                 target_free_all_working_areas(target);
3795                                 e = Jim_GetOpt_Wide(goi, &w);
3796                                 if (e != JIM_OK) {
3797                                         return e;
3798                                 }
3799                                 target->working_area_phys = w;
3800                                 target->working_area_phys_spec = true;
3801                         } else {
3802                                 if (goi->argc != 0) {
3803                                         goto no_params;
3804                                 }
3805                         }
3806                         Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_phys));
3807                         /* loop for more */
3808                         break;
3809
3810                 case TCFG_WORK_AREA_SIZE:
3811                         if (goi->isconfigure) {
3812                                 target_free_all_working_areas(target);
3813                                 e = Jim_GetOpt_Wide(goi, &w);
3814                                 if (e != JIM_OK) {
3815                                         return e;
3816                                 }
3817                                 target->working_area_size = w;
3818                         } else {
3819                                 if (goi->argc != 0) {
3820                                         goto no_params;
3821                                 }
3822                         }
3823                         Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_size));
3824                         /* loop for more */
3825                         break;
3826
3827                 case TCFG_WORK_AREA_BACKUP:
3828                         if (goi->isconfigure) {
3829                                 target_free_all_working_areas(target);
3830                                 e = Jim_GetOpt_Wide(goi, &w);
3831                                 if (e != JIM_OK) {
3832                                         return e;
3833                                 }
3834                                 /* make this exactly 1 or 0 */
3835                                 target->backup_working_area = (!!w);
3836                         } else {
3837                                 if (goi->argc != 0) {
3838                                         goto no_params;
3839                                 }
3840                         }
3841                         Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->backup_working_area));
3842                         /* loop for more e*/
3843                         break;
3844
3845                 case TCFG_ENDIAN:
3846                         if (goi->isconfigure) {
3847                                 e = Jim_GetOpt_Nvp(goi, nvp_target_endian, &n);
3848                                 if (e != JIM_OK) {
3849                                         Jim_GetOpt_NvpUnknown(goi, nvp_target_endian, 1);
3850                                         return e;
3851                                 }
3852                                 target->endianness = n->value;
3853                         } else {
3854                                 if (goi->argc != 0) {
3855                                         goto no_params;
3856                                 }
3857                         }
3858                         n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
3859                         if (n->name == NULL) {
3860                                 target->endianness = TARGET_LITTLE_ENDIAN;
3861                                 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
3862                         }
3863                         Jim_SetResultString(goi->interp, n->name, -1);
3864                         /* loop for more */
3865                         break;
3866
3867                 case TCFG_VARIANT:
3868                         if (goi->isconfigure) {
3869                                 if (goi->argc < 1) {
3870                                         Jim_SetResult_sprintf(goi->interp,
3871                                                                                    "%s ?STRING?",
3872                                                                                    n->name);
3873                                         return JIM_ERR;
3874                                 }
3875                                 if (target->variant) {
3876                                         free((void *)(target->variant));
3877                                 }
3878                                 e = Jim_GetOpt_String(goi, &cp, NULL);
3879                                 target->variant = strdup(cp);
3880                         } else {
3881                                 if (goi->argc != 0) {
3882                                         goto no_params;
3883                                 }
3884                         }
3885                         Jim_SetResultString(goi->interp, target->variant,-1);
3886                         /* loop for more */
3887                         break;
3888                 case TCFG_CHAIN_POSITION:
3889                         if (goi->isconfigure) {
3890                                 Jim_Obj *o;
3891                                 jtag_tap_t *tap;
3892                                 target_free_all_working_areas(target);
3893                                 e = Jim_GetOpt_Obj(goi, &o);
3894                                 if (e != JIM_OK) {
3895                                         return e;
3896                                 }
3897                                 tap = jtag_tap_by_jim_obj(goi->interp, o);
3898                                 if (tap == NULL) {
3899                                         return JIM_ERR;
3900                                 }
3901                                 /* make this exactly 1 or 0 */
3902                                 target->tap = tap;
3903                         } else {
3904                                 if (goi->argc != 0) {
3905                                         goto no_params;
3906                                 }
3907                         }
3908                         Jim_SetResultString(interp, target->tap->dotted_name, -1);
3909                         /* loop for more e*/
3910                         break;
3911                 }
3912         } /* while (goi->argc) */
3913
3914
3915                 /* done - we return */
3916         return JIM_OK;
3917 }
3918
3919 /** this is the 'tcl' handler for the target specific command */
3920 static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3921 {
3922         Jim_GetOptInfo goi;
3923         jim_wide a,b,c;
3924         int x,y,z;
3925         uint8_t  target_buf[32];
3926         Jim_Nvp *n;
3927         target_t *target;
3928         struct command_context_s *cmd_ctx;
3929         int e;
3930
3931         enum {
3932                 TS_CMD_CONFIGURE,
3933                 TS_CMD_CGET,
3934
3935                 TS_CMD_MWW, TS_CMD_MWH, TS_CMD_MWB,
3936                 TS_CMD_MDW, TS_CMD_MDH, TS_CMD_MDB,
3937                 TS_CMD_MRW, TS_CMD_MRH, TS_CMD_MRB,
3938                 TS_CMD_MEM2ARRAY, TS_CMD_ARRAY2MEM,
3939                 TS_CMD_EXAMINE,
3940                 TS_CMD_POLL,
3941                 TS_CMD_RESET,
3942                 TS_CMD_HALT,
3943                 TS_CMD_WAITSTATE,
3944                 TS_CMD_EVENTLIST,
3945                 TS_CMD_CURSTATE,
3946                 TS_CMD_INVOKE_EVENT,
3947         };
3948
3949         static const Jim_Nvp target_options[] = {
3950                 { .name = "configure", .value = TS_CMD_CONFIGURE },
3951                 { .name = "cget", .value = TS_CMD_CGET },
3952                 { .name = "mww", .value = TS_CMD_MWW },
3953                 { .name = "mwh", .value = TS_CMD_MWH },
3954                 { .name = "mwb", .value = TS_CMD_MWB },
3955                 { .name = "mdw", .value = TS_CMD_MDW },
3956                 { .name = "mdh", .value = TS_CMD_MDH },
3957                 { .name = "mdb", .value = TS_CMD_MDB },
3958                 { .name = "mem2array", .value = TS_CMD_MEM2ARRAY },
3959                 { .name = "array2mem", .value = TS_CMD_ARRAY2MEM },
3960                 { .name = "eventlist", .value = TS_CMD_EVENTLIST },
3961                 { .name = "curstate",  .value = TS_CMD_CURSTATE },
3962
3963                 { .name = "arp_examine", .value = TS_CMD_EXAMINE },
3964                 { .name = "arp_poll", .value = TS_CMD_POLL },
3965                 { .name = "arp_reset", .value = TS_CMD_RESET },
3966                 { .name = "arp_halt", .value = TS_CMD_HALT },
3967                 { .name = "arp_waitstate", .value = TS_CMD_WAITSTATE },
3968                 { .name = "invoke-event", .value = TS_CMD_INVOKE_EVENT },
3969
3970                 { .name = NULL, .value = -1 },
3971         };
3972
3973         /* go past the "command" */
3974         Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
3975
3976         target = Jim_CmdPrivData(goi.interp);
3977         cmd_ctx = Jim_GetAssocData(goi.interp, "context");
3978
3979         /* commands here are in an NVP table */
3980         e = Jim_GetOpt_Nvp(&goi, target_options, &n);
3981         if (e != JIM_OK) {
3982                 Jim_GetOpt_NvpUnknown(&goi, target_options, 0);
3983                 return e;
3984         }
3985         /* Assume blank result */
3986         Jim_SetEmptyResult(goi.interp);
3987
3988         switch (n->value) {
3989         case TS_CMD_CONFIGURE:
3990                 if (goi.argc < 2) {
3991                         Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "missing: -option VALUE ...");
3992                         return JIM_ERR;
3993                 }
3994                 goi.isconfigure = 1;
3995                 return target_configure(&goi, target);
3996         case TS_CMD_CGET:
3997                 // some things take params
3998                 if (goi.argc < 1) {
3999                         Jim_WrongNumArgs(goi.interp, 0, goi.argv, "missing: ?-option?");
4000                         return JIM_ERR;
4001                 }
4002                 goi.isconfigure = 0;
4003                 return target_configure(&goi, target);
4004                 break;
4005         case TS_CMD_MWW:
4006         case TS_CMD_MWH:
4007         case TS_CMD_MWB:
4008                 /* argv[0] = cmd
4009                  * argv[1] = address
4010                  * argv[2] = data
4011                  * argv[3] = optional count.
4012                  */
4013
4014                 if ((goi.argc == 2) || (goi.argc == 3)) {
4015                         /* all is well */
4016                 } else {
4017                 mwx_error:
4018                         Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR DATA [COUNT]", n->name);
4019                         return JIM_ERR;
4020                 }
4021
4022                 e = Jim_GetOpt_Wide(&goi, &a);
4023                 if (e != JIM_OK) {
4024                         goto mwx_error;
4025                 }
4026
4027                 e = Jim_GetOpt_Wide(&goi, &b);
4028                 if (e != JIM_OK) {
4029                         goto mwx_error;
4030                 }
4031                 if (goi.argc == 3) {
4032                         e = Jim_GetOpt_Wide(&goi, &c);
4033                         if (e != JIM_OK) {
4034                                 goto mwx_error;
4035                         }
4036                 } else {
4037                         c = 1;
4038                 }
4039
4040                 switch (n->value) {
4041                 case TS_CMD_MWW:
4042                         target_buffer_set_u32(target, target_buf, b);
4043                         b = 4;
4044                         break;
4045                 case TS_CMD_MWH:
4046                         target_buffer_set_u16(target, target_buf, b);
4047                         b = 2;
4048                         break;
4049                 case TS_CMD_MWB:
4050                         target_buffer_set_u8(target, target_buf, b);
4051                         b = 1;
4052                         break;
4053                 }
4054                 for (x = 0 ; x < c ; x++) {
4055                         e = target_write_memory(target, a, b, 1, target_buf);
4056                         if (e != ERROR_OK) {
4057                                 Jim_SetResult_sprintf(interp, "Error writing @ 0x%08x: %d\n", (int)(a), e);
4058                                 return JIM_ERR;
4059                         }
4060                         /* b = width */
4061                         a = a + b;
4062                 }
4063                 return JIM_OK;
4064                 break;
4065
4066                 /* display */
4067         case TS_CMD_MDW:
4068         case TS_CMD_MDH:
4069         case TS_CMD_MDB:
4070                 /* argv[0] = command
4071                  * argv[1] = address
4072                  * argv[2] = optional count
4073                  */
4074                 if ((goi.argc == 2) || (goi.argc == 3)) {
4075                         Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR [COUNT]", n->name);
4076                         return JIM_ERR;
4077                 }
4078                 e = Jim_GetOpt_Wide(&goi, &a);
4079                 if (e != JIM_OK) {
4080                         return JIM_ERR;
4081                 }
4082                 if (goi.argc) {
4083                         e = Jim_GetOpt_Wide(&goi, &c);
4084                         if (e != JIM_OK) {
4085                                 return JIM_ERR;
4086                         }
4087                 } else {
4088                         c = 1;
4089                 }
4090                 b = 1; /* shut up gcc */
4091                 switch (n->value) {
4092                 case TS_CMD_MDW:
4093                         b =  4;
4094                         break;
4095                 case TS_CMD_MDH:
4096                         b = 2;
4097                         break;
4098                 case TS_CMD_MDB:
4099                         b = 1;
4100                         break;
4101                 }
4102
4103                 /* convert to "bytes" */
4104                 c = c * b;
4105                 /* count is now in 'BYTES' */
4106                 while (c > 0) {
4107                         y = c;
4108                         if (y > 16) {
4109                                 y = 16;
4110                         }
4111                         e = target_read_memory(target, a, b, y / b, target_buf);
4112                         if (e != ERROR_OK) {
4113                                 Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a));
4114                                 return JIM_ERR;
4115                         }
4116
4117                         Jim_fprintf(interp, interp->cookie_stdout, "0x%08x ", (int)(a));
4118                         switch (b) {
4119                         case 4:
4120                                 for (x = 0 ; (x < 16) && (x < y) ; x += 4) {
4121                                         z = target_buffer_get_u32(target, &(target_buf[ x * 4 ]));
4122                                         Jim_fprintf(interp, interp->cookie_stdout, "%08x ", (int)(z));
4123                                 }
4124                                 for (; (x < 16) ; x += 4) {
4125                                         Jim_fprintf(interp, interp->cookie_stdout, "         ");
4126                                 }
4127                                 break;
4128                         case 2:
4129                                 for (x = 0 ; (x < 16) && (x < y) ; x += 2) {
4130                                         z = target_buffer_get_u16(target, &(target_buf[ x * 2 ]));
4131                                         Jim_fprintf(interp, interp->cookie_stdout, "%04x ", (int)(z));
4132                                 }
4133                                 for (; (x < 16) ; x += 2) {
4134                                         Jim_fprintf(interp, interp->cookie_stdout, "     ");
4135                                 }
4136                                 break;
4137                         case 1:
4138                         default:
4139                                 for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
4140                                         z = target_buffer_get_u8(target, &(target_buf[ x * 4 ]));
4141                                         Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z));
4142                                 }
4143                                 for (; (x < 16) ; x += 1) {
4144                                         Jim_fprintf(interp, interp->cookie_stdout, "   ");
4145                                 }
4146                                 break;
4147                         }
4148                         /* ascii-ify the bytes */
4149                         for (x = 0 ; x < y ; x++) {
4150                                 if ((target_buf[x] >= 0x20) &&
4151                                         (target_buf[x] <= 0x7e)) {
4152                                         /* good */
4153                                 } else {
4154                                         /* smack it */
4155                                         target_buf[x] = '.';
4156                                 }
4157                         }
4158                         /* space pad  */
4159                         while (x < 16) {
4160                                 target_buf[x] = ' ';
4161                                 x++;
4162                         }
4163                         /* terminate */
4164                         target_buf[16] = 0;
4165                         /* print - with a newline */
4166                         Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf);
4167                         /* NEXT... */
4168                         c -= 16;
4169                         a += 16;
4170                 }
4171                 return JIM_OK;
4172         case TS_CMD_MEM2ARRAY:
4173                 return target_mem2array(goi.interp, target, goi.argc, goi.argv);
4174                 break;
4175         case TS_CMD_ARRAY2MEM:
4176                 return target_array2mem(goi.interp, target, goi.argc, goi.argv);
4177                 break;
4178         case TS_CMD_EXAMINE:
4179                 if (goi.argc) {
4180                         Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
4181                         return JIM_ERR;
4182                 }
4183                 if (!target->tap->enabled)
4184                         goto err_tap_disabled;
4185                 e = target->type->examine(target);
4186                 if (e != ERROR_OK) {
4187                         Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
4188                         return JIM_ERR;
4189                 }
4190                 return JIM_OK;
4191         case TS_CMD_POLL:
4192                 if (goi.argc) {
4193                         Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
4194                         return JIM_ERR;
4195                 }
4196                 if (!target->tap->enabled)
4197                         goto err_tap_disabled;
4198                 if (!(target_was_examined(target))) {
4199                         e = ERROR_TARGET_NOT_EXAMINED;
4200                 } else {
4201                         e = target->type->poll(target);
4202                 }
4203                 if (e != ERROR_OK) {
4204                         Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
4205                         return JIM_ERR;
4206                 } else {
4207                         return JIM_OK;
4208                 }
4209                 break;
4210         case TS_CMD_RESET:
4211                 if (goi.argc != 2) {
4212                         Jim_WrongNumArgs(interp, 2, argv,
4213                                         "([tT]|[fF]|assert|deassert) BOOL");
4214                         return JIM_ERR;
4215                 }
4216                 e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
4217                 if (e != JIM_OK) {
4218                         Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
4219                         return e;
4220                 }
4221                 /* the halt or not param */
4222                 e = Jim_GetOpt_Wide(&goi, &a);
4223                 if (e != JIM_OK) {
4224                         return e;
4225                 }
4226                 if (!target->tap->enabled)
4227                         goto err_tap_disabled;
4228                 if (!target->type->assert_reset
4229                                 || !target->type->deassert_reset) {
4230                         Jim_SetResult_sprintf(interp,
4231                                         "No target-specific reset for %s",
4232                                         target->cmd_name);
4233                         return JIM_ERR;
4234                 }
4235                 /* determine if we should halt or not. */
4236                 target->reset_halt = !!a;
4237                 /* When this happens - all workareas are invalid. */
4238                 target_free_all_working_areas_restore(target, 0);
4239
4240                 /* do the assert */
4241                 if (n->value == NVP_ASSERT) {
4242                         e = target->type->assert_reset(target);
4243                 } else {
4244                         e = target->type->deassert_reset(target);
4245                 }
4246                 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4247         case TS_CMD_HALT:
4248                 if (goi.argc) {
4249                         Jim_WrongNumArgs(goi.interp, 0, argv, "halt [no parameters]");
4250                         return JIM_ERR;
4251                 }
4252                 if (!target->tap->enabled)
4253                         goto err_tap_disabled;
4254                 e = target->type->halt(target);
4255                 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4256         case TS_CMD_WAITSTATE:
4257                 /* params:  <name>  statename timeoutmsecs */
4258                 if (goi.argc != 2) {
4259                         Jim_SetResult_sprintf(goi.interp, "%s STATENAME TIMEOUTMSECS", n->name);
4260                         return JIM_ERR;
4261                 }
4262                 e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
4263                 if (e != JIM_OK) {
4264                         Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1);
4265                         return e;
4266                 }
4267                 e = Jim_GetOpt_Wide(&goi, &a);
4268                 if (e != JIM_OK) {
4269                         return e;
4270                 }
4271                 if (!target->tap->enabled)
4272                         goto err_tap_disabled;
4273                 e = target_wait_state(target, n->value, a);
4274                 if (e != ERROR_OK) {
4275                         Jim_SetResult_sprintf(goi.interp,
4276                                                                    "target: %s wait %s fails (%d) %s",
4277                                                                    target->cmd_name,
4278                                                                    n->name,
4279                                                                    e, target_strerror_safe(e));
4280                         return JIM_ERR;
4281                 } else {
4282                         return JIM_OK;
4283                 }
4284         case TS_CMD_EVENTLIST:
4285                 /* List for human, Events defined for this target.
4286                  * scripts/programs should use 'name cget -event NAME'
4287                  */
4288                 {
4289                         target_event_action_t *teap;
4290                         teap = target->event_action;
4291                         command_print(cmd_ctx, "Event actions for target (%d) %s\n",
4292                                                    target->target_number,
4293                                                    target->cmd_name);
4294                         command_print(cmd_ctx, "%-25s | Body", "Event");
4295                         command_print(cmd_ctx, "------------------------- | ----------------------------------------");
4296                         while (teap) {
4297                                 command_print(cmd_ctx,
4298                                                            "%-25s | %s",
4299                                                            Jim_Nvp_value2name_simple(nvp_target_event, teap->event)->name,
4300                                                            Jim_GetString(teap->body, NULL));
4301                                 teap = teap->next;
4302                         }
4303                         command_print(cmd_ctx, "***END***");
4304                         return JIM_OK;
4305                 }
4306         case TS_CMD_CURSTATE:
4307                 if (goi.argc != 0) {
4308                         Jim_WrongNumArgs(goi.interp, 0, argv, "[no parameters]");
4309                         return JIM_ERR;
4310                 }
4311                 Jim_SetResultString(goi.interp,
4312                                                         target_state_name( target ),
4313                                                         -1);
4314                 return JIM_OK;
4315         case TS_CMD_INVOKE_EVENT:
4316                 if (goi.argc != 1) {
4317                         Jim_SetResult_sprintf(goi.interp, "%s ?EVENTNAME?",n->name);
4318                         return JIM_ERR;
4319                 }
4320                 e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
4321                 if (e != JIM_OK) {
4322                         Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
4323                         return e;
4324                 }
4325                 target_handle_event(target, n->value);
4326                 return JIM_OK;
4327         }
4328         return JIM_ERR;
4329
4330 err_tap_disabled:
4331         Jim_SetResult_sprintf(interp, "[TAP is disabled]");
4332         return JIM_ERR;
4333 }
4334
4335 static int target_create(Jim_GetOptInfo *goi)
4336 {
4337         Jim_Obj *new_cmd;
4338         Jim_Cmd *cmd;
4339         const char *cp;
4340         char *cp2;
4341         int e;
4342         int x;
4343         target_t *target;
4344         struct command_context_s *cmd_ctx;
4345
4346         cmd_ctx = Jim_GetAssocData(goi->interp, "context");
4347         if (goi->argc < 3) {
4348                 Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ?type? ..options...");
4349                 return JIM_ERR;
4350         }
4351
4352         /* COMMAND */
4353         Jim_GetOpt_Obj(goi, &new_cmd);
4354         /* does this command exist? */
4355         cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_ERRMSG);
4356         if (cmd) {
4357                 cp = Jim_GetString(new_cmd, NULL);
4358                 Jim_SetResult_sprintf(goi->interp, "Command/target: %s Exists", cp);
4359                 return JIM_ERR;
4360         }
4361
4362         /* TYPE */
4363         e = Jim_GetOpt_String(goi, &cp2, NULL);
4364         cp = cp2;
4365         /* now does target type exist */
4366         for (x = 0 ; target_types[x] ; x++) {
4367                 if (0 == strcmp(cp, target_types[x]->name)) {
4368                         /* found */
4369                         break;
4370                 }
4371         }
4372         if (target_types[x] == NULL) {
4373                 Jim_SetResult_sprintf(goi->interp, "Unknown target type %s, try one of ", cp);
4374                 for (x = 0 ; target_types[x] ; x++) {
4375                         if (target_types[x + 1]) {
4376                                 Jim_AppendStrings(goi->interp,
4377                                                                    Jim_GetResult(goi->interp),
4378                                                                    target_types[x]->name,
4379                                                                    ", ", NULL);
4380                         } else {
4381                                 Jim_AppendStrings(goi->interp,
4382                                                                    Jim_GetResult(goi->interp),
4383                                                                    " or ",
4384                                                                    target_types[x]->name,NULL);
4385                         }
4386                 }
4387                 return JIM_ERR;
4388         }
4389
4390         /* Create it */
4391         target = calloc(1,sizeof(target_t));
4392         /* set target number */
4393         target->target_number = new_target_number();
4394
4395         /* allocate memory for each unique target type */
4396         target->type = (target_type_t*)calloc(1,sizeof(target_type_t));
4397
4398         memcpy(target->type, target_types[x], sizeof(target_type_t));
4399
4400         /* will be set by "-endian" */
4401         target->endianness = TARGET_ENDIAN_UNKNOWN;
4402
4403         target->working_area        = 0x0;
4404         target->working_area_size   = 0x0;
4405         target->working_areas       = NULL;
4406         target->backup_working_area = 0;
4407
4408         target->state               = TARGET_UNKNOWN;
4409         target->debug_reason        = DBG_REASON_UNDEFINED;
4410         target->reg_cache           = NULL;
4411         target->breakpoints         = NULL;
4412         target->watchpoints         = NULL;
4413         target->next                = NULL;
4414         target->arch_info           = NULL;
4415
4416         target->display             = 1;
4417
4418         target->halt_issued                     = false;
4419
4420         /* initialize trace information */
4421         target->trace_info = malloc(sizeof(trace_t));
4422         target->trace_info->num_trace_points         = 0;
4423         target->trace_info->trace_points_size        = 0;
4424         target->trace_info->trace_points             = NULL;
4425         target->trace_info->trace_history_size       = 0;
4426         target->trace_info->trace_history            = NULL;
4427         target->trace_info->trace_history_pos        = 0;
4428         target->trace_info->trace_history_overflowed = 0;
4429
4430         target->dbgmsg          = NULL;
4431         target->dbg_msg_enabled = 0;
4432
4433         target->endianness = TARGET_ENDIAN_UNKNOWN;
4434
4435         /* Do the rest as "configure" options */
4436         goi->isconfigure = 1;
4437         e = target_configure(goi, target);
4438
4439         if (target->tap == NULL)
4440         {
4441                 Jim_SetResultString(interp, "-chain-position required when creating target", -1);
4442                 e = JIM_ERR;
4443         }
4444
4445         if (e != JIM_OK) {
4446                 free(target->type);
4447                 free(target);
4448                 return e;
4449         }
4450
4451         if (target->endianness == TARGET_ENDIAN_UNKNOWN) {
4452                 /* default endian to little if not specified */
4453                 target->endianness = TARGET_LITTLE_ENDIAN;
4454         }
4455
4456         /* incase variant is not set */
4457         if (!target->variant)
4458                 target->variant = strdup("");
4459
4460         /* create the target specific commands */
4461         if (target->type->register_commands) {
4462                 (*(target->type->register_commands))(cmd_ctx);
4463         }
4464         if (target->type->target_create) {
4465                 (*(target->type->target_create))(target, goi->interp);
4466         }
4467
4468         /* append to end of list */
4469         {
4470                 target_t **tpp;
4471                 tpp = &(all_targets);
4472                 while (*tpp) {
4473                         tpp = &((*tpp)->next);
4474                 }
4475                 *tpp = target;
4476         }
4477
4478         cp = Jim_GetString(new_cmd, NULL);
4479         target->cmd_name = strdup(cp);
4480
4481         /* now - create the new target name command */
4482         e = Jim_CreateCommand(goi->interp,
4483                                                    /* name */
4484                                                    cp,
4485                                                    tcl_target_func, /* C function */
4486                                                    target, /* private data */
4487                                                    NULL); /* no del proc */
4488
4489         return e;
4490 }
4491
4492 static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4493 {
4494         int x,r,e;
4495         jim_wide w;
4496         struct command_context_s *cmd_ctx;
4497         target_t *target;
4498         Jim_GetOptInfo goi;
4499         enum tcmd {
4500                 /* TG = target generic */
4501                 TG_CMD_CREATE,
4502                 TG_CMD_TYPES,
4503                 TG_CMD_NAMES,
4504                 TG_CMD_CURRENT,
4505                 TG_CMD_NUMBER,
4506                 TG_CMD_COUNT,
4507         };
4508         const char *target_cmds[] = {
4509                 "create", "types", "names", "current", "number",
4510                 "count",
4511                 NULL /* terminate */
4512         };
4513
4514         LOG_DEBUG("Target command params:");
4515         LOG_DEBUG("%s", Jim_Debug_ArgvString(interp, argc, argv));
4516
4517         cmd_ctx = Jim_GetAssocData(interp, "context");
4518
4519         Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
4520
4521         if (goi.argc == 0) {
4522                 Jim_WrongNumArgs(interp, 1, argv, "missing: command ...");
4523                 return JIM_ERR;
4524         }
4525
4526         /* Jim_GetOpt_Debug(&goi); */
4527         r = Jim_GetOpt_Enum(&goi, target_cmds, &x);
4528         if (r != JIM_OK) {
4529                 return r;
4530         }
4531
4532         switch (x) {
4533         default:
4534                 Jim_Panic(goi.interp,"Why am I here?");
4535                 return JIM_ERR;
4536         case TG_CMD_CURRENT:
4537                 if (goi.argc != 0) {
4538                         Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
4539                         return JIM_ERR;
4540                 }
4541                 Jim_SetResultString(goi.interp, get_current_target(cmd_ctx)->cmd_name, -1);
4542                 return JIM_OK;
4543         case TG_CMD_TYPES:
4544                 if (goi.argc != 0) {
4545                         Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
4546                         return JIM_ERR;
4547                 }
4548                 Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
4549                 for (x = 0 ; target_types[x] ; x++) {
4550                         Jim_ListAppendElement(goi.interp,
4551                                                                    Jim_GetResult(goi.interp),
4552                                                                    Jim_NewStringObj(goi.interp, target_types[x]->name, -1));
4553                 }
4554                 return JIM_OK;
4555         case TG_CMD_NAMES:
4556                 if (goi.argc != 0) {
4557                         Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
4558                         return JIM_ERR;
4559                 }
4560                 Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
4561                 target = all_targets;
4562                 while (target) {
4563                         Jim_ListAppendElement(goi.interp,
4564                                                                    Jim_GetResult(goi.interp),
4565                                                                    Jim_NewStringObj(goi.interp, target->cmd_name, -1));
4566                         target = target->next;
4567                 }
4568                 return JIM_OK;
4569         case TG_CMD_CREATE:
4570                 if (goi.argc < 3) {
4571                         Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "?name  ... config options ...");
4572                         return JIM_ERR;
4573                 }
4574                 return target_create(&goi);
4575                 break;
4576         case TG_CMD_NUMBER:
4577                 /* It's OK to remove this mechanism sometime after August 2010 or so */
4578                 LOG_WARNING("don't use numbers as target identifiers; use names");
4579                 if (goi.argc != 1) {
4580                         Jim_SetResult_sprintf(goi.interp, "expected: target number ?NUMBER?");
4581                         return JIM_ERR;
4582                 }
4583                 e = Jim_GetOpt_Wide(&goi, &w);
4584                 if (e != JIM_OK) {
4585                         return JIM_ERR;
4586                 }
4587                 for (x = 0, target = all_targets; target; target = target->next, x++) {
4588                         if (target->target_number == w)
4589                                 break;
4590                 }
4591                 if (target == NULL) {
4592                         Jim_SetResult_sprintf(goi.interp,
4593                                         "Target: number %d does not exist", (int)(w));
4594                         return JIM_ERR;
4595                 }
4596                 Jim_SetResultString(goi.interp, target->cmd_name, -1);
4597                 return JIM_OK;
4598         case TG_CMD_COUNT:
4599                 if (goi.argc != 0) {
4600                         Jim_WrongNumArgs(goi.interp, 0, goi.argv, "<no parameters>");
4601                         return JIM_ERR;
4602                 }
4603                 for (x = 0, target = all_targets; target; target = target->next, x++)
4604                         continue;
4605                 Jim_SetResult(goi.interp, Jim_NewIntObj(goi.interp, x));
4606                 return JIM_OK;
4607         }
4608
4609         return JIM_ERR;
4610 }
4611
4612
4613 struct FastLoad
4614 {
4615         uint32_t address;
4616         uint8_t *data;
4617         int length;
4618
4619 };
4620
4621 static int fastload_num;
4622 static struct FastLoad *fastload;
4623
4624 static void free_fastload(void)
4625 {
4626         if (fastload != NULL)
4627         {
4628                 int i;
4629                 for (i = 0; i < fastload_num; i++)
4630                 {
4631                         if (fastload[i].data)
4632                                 free(fastload[i].data);
4633                 }
4634                 free(fastload);
4635                 fastload = NULL;
4636         }
4637 }
4638
4639
4640
4641
4642 static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
4643 {
4644         uint8_t *buffer;
4645         uint32_t buf_cnt;
4646         uint32_t image_size;
4647         uint32_t min_address = 0;
4648         uint32_t max_address = 0xffffffff;
4649         int i;
4650
4651         image_t image;
4652
4653         duration_t duration;
4654         char *duration_text;
4655
4656         int retval = parse_load_image_command_args(args, argc,
4657                         &image, &min_address, &max_address);
4658         if (ERROR_OK != retval)
4659                 return retval;
4660
4661         duration_start_measure(&duration);
4662
4663         if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
4664         {
4665                 return ERROR_OK;
4666         }
4667
4668         image_size = 0x0;
4669         retval = ERROR_OK;
4670         fastload_num = image.num_sections;
4671         fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
4672         if (fastload == NULL)
4673         {
4674                 image_close(&image);
4675                 return ERROR_FAIL;
4676         }
4677         memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
4678         for (i = 0; i < image.num_sections; i++)
4679         {
4680                 buffer = malloc(image.sections[i].size);
4681                 if (buffer == NULL)
4682                 {
4683                         command_print(cmd_ctx, "error allocating buffer for section (%d bytes)",
4684                                                   (int)(image.sections[i].size));
4685                         break;
4686                 }
4687
4688                 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
4689                 {
4690                         free(buffer);
4691                         break;
4692                 }
4693
4694                 uint32_t offset = 0;
4695                 uint32_t length = buf_cnt;
4696
4697
4698                 /* DANGER!!! beware of unsigned comparision here!!! */
4699
4700                 if ((image.sections[i].base_address + buf_cnt >= min_address)&&
4701                                 (image.sections[i].base_address < max_address))
4702                 {
4703                         if (image.sections[i].base_address < min_address)
4704                         {
4705                                 /* clip addresses below */
4706                                 offset += min_address-image.sections[i].base_address;
4707                                 length -= offset;
4708                         }
4709
4710                         if (image.sections[i].base_address + buf_cnt > max_address)
4711                         {
4712                                 length -= (image.sections[i].base_address + buf_cnt)-max_address;
4713                         }
4714
4715                         fastload[i].address = image.sections[i].base_address + offset;
4716                         fastload[i].data = malloc(length);
4717                         if (fastload[i].data == NULL)
4718                         {
4719                                 free(buffer);
4720                                 break;
4721                         }
4722                         memcpy(fastload[i].data, buffer + offset, length);
4723                         fastload[i].length = length;
4724
4725                         image_size += length;
4726                         command_print(cmd_ctx, "%u bytes written at address 0x%8.8x",
4727                                                   (unsigned int)length,
4728                                                   ((unsigned int)(image.sections[i].base_address + offset)));
4729                 }
4730
4731                 free(buffer);
4732         }
4733
4734         duration_stop_measure(&duration, &duration_text);
4735         if (retval == ERROR_OK)
4736         {
4737                 command_print(cmd_ctx, "Loaded %u bytes in %s", (unsigned int)image_size, duration_text);
4738                 command_print(cmd_ctx, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4739         }
4740         free(duration_text);
4741
4742         image_close(&image);
4743
4744         if (retval != ERROR_OK)
4745         {
4746                 free_fastload();
4747         }
4748
4749         return retval;
4750 }
4751
4752 static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
4753 {
4754         if (argc > 0)
4755                 return ERROR_COMMAND_SYNTAX_ERROR;
4756         if (fastload == NULL)
4757         {
4758                 LOG_ERROR("No image in memory");
4759                 return ERROR_FAIL;
4760         }
4761         int i;
4762         int ms = timeval_ms();
4763         int size = 0;
4764         int retval = ERROR_OK;
4765         for (i = 0; i < fastload_num;i++)
4766         {
4767                 target_t *target = get_current_target(cmd_ctx);
4768                 command_print(cmd_ctx, "Write to 0x%08x, length 0x%08x",
4769                                           (unsigned int)(fastload[i].address),
4770                                           (unsigned int)(fastload[i].length));
4771                 if (retval == ERROR_OK)
4772                 {
4773                         retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
4774                 }
4775                 size += fastload[i].length;
4776         }
4777         int after = timeval_ms();
4778         command_print(cmd_ctx, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
4779         return retval;
4780 }
4781
4782 static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4783 {
4784         command_context_t *context;
4785         target_t *target;
4786         int retval;
4787
4788         context = Jim_GetAssocData(interp, "context");
4789         if (context == NULL) {
4790                 LOG_ERROR("array2mem: no command context");
4791                 return JIM_ERR;
4792         }
4793         target = get_current_target(context);
4794         if (target == NULL) {
4795                 LOG_ERROR("array2mem: no current target");
4796                 return JIM_ERR;
4797         }
4798
4799         if ((argc < 6) || (argc > 7))
4800         {
4801                 return JIM_ERR;
4802         }
4803
4804         int cpnum;
4805         uint32_t op1;
4806         uint32_t op2;
4807         uint32_t CRn;
4808         uint32_t CRm;
4809         uint32_t value;
4810
4811         int e;
4812         long l;
4813         e = Jim_GetLong(interp, argv[1], &l);
4814         if (e != JIM_OK) {
4815                 return e;
4816         }
4817         cpnum = l;
4818
4819         e = Jim_GetLong(interp, argv[2], &l);
4820         if (e != JIM_OK) {
4821                 return e;
4822         }
4823         op1 = l;
4824
4825         e = Jim_GetLong(interp, argv[3], &l);
4826         if (e != JIM_OK) {
4827                 return e;
4828         }
4829         op2 = l;
4830
4831         e = Jim_GetLong(interp, argv[4], &l);
4832         if (e != JIM_OK) {
4833                 return e;
4834         }
4835         CRn = l;
4836
4837         e = Jim_GetLong(interp, argv[5], &l);
4838         if (e != JIM_OK) {
4839                 return e;
4840         }
4841         CRm = l;
4842
4843         value = 0;
4844
4845         if (argc == 7)
4846         {
4847                 e = Jim_GetLong(interp, argv[6], &l);
4848                 if (e != JIM_OK) {
4849                         return e;
4850                 }
4851                 value = l;
4852
4853                 retval = target_mcr(target, cpnum, op1, op2, CRn, CRm, value);
4854                 if (retval != ERROR_OK)
4855                         return JIM_ERR;
4856         } else
4857         {
4858                 retval = target_mrc(target, cpnum, op1, op2, CRn, CRm, &value);
4859                 if (retval != ERROR_OK)
4860                         return JIM_ERR;
4861
4862                 Jim_SetResult(interp, Jim_NewIntObj(interp, value));
4863         }
4864
4865         return JIM_OK;
4866 }