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

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