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

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