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

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