git.sur5r.net Git - openocd/blob - src/target/target.c

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