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

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   Copyright (C) 2007,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                 keep_alive();
1973
1974                 if (retval!=ERROR_OK)
1975                 {
1976                         return retval;
1977                 }
1978         }
1979
1980         return ERROR_OK;
1981
1982 }
1983
1984 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1985 {
1986         u8 *buffer;
1987         u32 buf_cnt;
1988         u32 image_size;
1989         u32 min_address=0;
1990         u32 max_address=0xffffffff;
1991         int i;
1992         int retval;
1993
1994         image_t image;
1995
1996         duration_t duration;
1997         char *duration_text;
1998
1999         target_t *target = get_current_target(cmd_ctx);
2000
2001         if ((argc < 1)||(argc > 5))
2002         {
2003                 return ERROR_COMMAND_SYNTAX_ERROR;
2004         }
2005
2006         /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2007         if (argc >= 2)
2008         {
2009                 image.base_address_set = 1;
2010                 image.base_address = strtoul(args[1], NULL, 0);
2011         }
2012         else
2013         {
2014                 image.base_address_set = 0;
2015         }
2016
2017
2018         image.start_address_set = 0;
2019
2020         if (argc>=4)
2021         {
2022                 min_address=strtoul(args[3], NULL, 0);
2023         }
2024         if (argc>=5)
2025         {
2026                 max_address=strtoul(args[4], NULL, 0)+min_address;
2027         }
2028
2029         if (min_address>max_address)
2030         {
2031                 return ERROR_COMMAND_SYNTAX_ERROR;
2032         }
2033
2034
2035         duration_start_measure(&duration);
2036
2037         if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
2038         {
2039                 return ERROR_OK;
2040         }
2041
2042         image_size = 0x0;
2043         retval = ERROR_OK;
2044         for (i = 0; i < image.num_sections; i++)
2045         {
2046                 buffer = malloc(image.sections[i].size);
2047                 if (buffer == NULL)
2048                 {
2049                         command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2050                         break;
2051                 }
2052
2053                 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2054                 {
2055                         free(buffer);
2056                         break;
2057                 }
2058
2059                 u32 offset=0;
2060                 u32 length=buf_cnt;
2061
2062
2063                 /* DANGER!!! beware of unsigned comparision here!!! */
2064
2065                 if ((image.sections[i].base_address+buf_cnt>=min_address)&&
2066                                 (image.sections[i].base_address<max_address))
2067                 {
2068                         if (image.sections[i].base_address<min_address)
2069                         {
2070                                 /* clip addresses below */
2071                                 offset+=min_address-image.sections[i].base_address;
2072                                 length-=offset;
2073                         }
2074
2075                         if (image.sections[i].base_address+buf_cnt>max_address)
2076                         {
2077                                 length-=(image.sections[i].base_address+buf_cnt)-max_address;
2078                         }
2079
2080                         if ((retval = target_write_buffer(target, image.sections[i].base_address+offset, length, buffer+offset)) != ERROR_OK)
2081                         {
2082                                 free(buffer);
2083                                 break;
2084                         }
2085                         image_size += length;
2086                         command_print(cmd_ctx, "%u byte written at address 0x%8.8x", length, image.sections[i].base_address+offset);
2087                 }
2088
2089                 free(buffer);
2090         }
2091
2092         duration_stop_measure(&duration, &duration_text);
2093         if (retval==ERROR_OK)
2094         {
2095                 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
2096         }
2097         free(duration_text);
2098
2099         image_close(&image);
2100
2101         return retval;
2102
2103 }
2104
2105 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2106 {
2107         fileio_t fileio;
2108
2109         u32 address;
2110         u32 size;
2111         u8 buffer[560];
2112         int retval=ERROR_OK;
2113
2114         duration_t duration;
2115         char *duration_text;
2116
2117         target_t *target = get_current_target(cmd_ctx);
2118
2119         if (argc != 3)
2120         {
2121                 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2122                 return ERROR_OK;
2123         }
2124
2125         address = strtoul(args[1], NULL, 0);
2126         size = strtoul(args[2], NULL, 0);
2127
2128         if ((address & 3) || (size & 3))
2129         {
2130                 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
2131                 return ERROR_OK;
2132         }
2133
2134         if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2135         {
2136                 return ERROR_OK;
2137         }
2138
2139         duration_start_measure(&duration);
2140
2141         while (size > 0)
2142         {
2143                 u32 size_written;
2144                 u32 this_run_size = (size > 560) ? 560 : size;
2145
2146                 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2147                 if (retval != ERROR_OK)
2148                 {
2149                         break;
2150                 }
2151
2152                 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2153                 if (retval != ERROR_OK)
2154                 {
2155                         break;
2156                 }
2157
2158                 size -= this_run_size;
2159                 address += this_run_size;
2160         }
2161
2162         fileio_close(&fileio);
2163
2164         duration_stop_measure(&duration, &duration_text);
2165         if (retval==ERROR_OK)
2166         {
2167                 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2168         }
2169         free(duration_text);
2170
2171         return ERROR_OK;
2172 }
2173
2174 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2175 {
2176         u8 *buffer;
2177         u32 buf_cnt;
2178         u32 image_size;
2179         int i;
2180         int retval;
2181         u32 checksum = 0;
2182         u32 mem_checksum = 0;
2183
2184         image_t image;
2185
2186         duration_t duration;
2187         char *duration_text;
2188
2189         target_t *target = get_current_target(cmd_ctx);
2190
2191         if (argc < 1)
2192         {
2193                 return ERROR_COMMAND_SYNTAX_ERROR;
2194         }
2195
2196         if (!target)
2197         {
2198                 LOG_ERROR("no target selected");
2199                 return ERROR_FAIL;
2200         }
2201
2202         duration_start_measure(&duration);
2203
2204         if (argc >= 2)
2205         {
2206                 image.base_address_set = 1;
2207                 image.base_address = strtoul(args[1], NULL, 0);
2208         }
2209         else
2210         {
2211                 image.base_address_set = 0;
2212                 image.base_address = 0x0;
2213         }
2214
2215         image.start_address_set = 0;
2216
2217         if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2218         {
2219                 return retval;
2220         }
2221
2222         image_size = 0x0;
2223         retval=ERROR_OK;
2224         for (i = 0; i < image.num_sections; i++)
2225         {
2226                 buffer = malloc(image.sections[i].size);
2227                 if (buffer == NULL)
2228                 {
2229                         command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2230                         break;
2231                 }
2232                 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2233                 {
2234                         free(buffer);
2235                         break;
2236                 }
2237
2238                 /* calculate checksum of image */
2239                 image_calculate_checksum( buffer, buf_cnt, &checksum );
2240
2241                 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2242                 if( retval != ERROR_OK )
2243                 {
2244                         free(buffer);
2245                         break;
2246                 }
2247
2248                 if( checksum != mem_checksum )
2249                 {
2250                         /* failed crc checksum, fall back to a binary compare */
2251                         u8 *data;
2252
2253                         command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2254
2255                         data = (u8*)malloc(buf_cnt);
2256
2257                         /* Can we use 32bit word accesses? */
2258                         int size = 1;
2259                         int count = buf_cnt;
2260                         if ((count % 4) == 0)
2261                         {
2262                                 size *= 4;
2263                                 count /= 4;
2264                         }
2265                         retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2266                         if (retval == ERROR_OK)
2267                         {
2268                                 int t;
2269                                 for (t = 0; t < buf_cnt; t++)
2270                                 {
2271                                         if (data[t] != buffer[t])
2272                                         {
2273                                                 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]);
2274                                                 free(data);
2275                                                 free(buffer);
2276                                                 retval=ERROR_FAIL;
2277                                                 goto done;
2278                                         }
2279                                         if ((t%16384)==0)
2280                                         {
2281                                                 keep_alive();
2282                                         }
2283                                 }
2284                         }
2285
2286                         free(data);
2287                 }
2288
2289                 free(buffer);
2290                 image_size += buf_cnt;
2291         }
2292 done:
2293         duration_stop_measure(&duration, &duration_text);
2294         if (retval==ERROR_OK)
2295         {
2296                 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2297         }
2298         free(duration_text);
2299
2300         image_close(&image);
2301
2302         return retval;
2303 }
2304
2305 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2306 {
2307         int retval;
2308         target_t *target = get_current_target(cmd_ctx);
2309
2310         if (argc == 0)
2311         {
2312                 breakpoint_t *breakpoint = target->breakpoints;
2313
2314                 while (breakpoint)
2315                 {
2316                         if (breakpoint->type == BKPT_SOFT)
2317                         {
2318                                 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2319                                 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2320                                 free(buf);
2321                         }
2322                         else
2323                         {
2324                                 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2325                         }
2326                         breakpoint = breakpoint->next;
2327                 }
2328         }
2329         else if (argc >= 2)
2330         {
2331                 int hw = BKPT_SOFT;
2332                 u32 length = 0;
2333
2334                 length = strtoul(args[1], NULL, 0);
2335
2336                 if (argc >= 3)
2337                         if (strcmp(args[2], "hw") == 0)
2338                                 hw = BKPT_HARD;
2339
2340                 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2341                 {
2342                         LOG_ERROR("Failure setting breakpoints");
2343                 }
2344                 else
2345                 {
2346                         command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2347                 }
2348         }
2349         else
2350         {
2351                 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2352         }
2353
2354         return ERROR_OK;
2355 }
2356
2357 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2358 {
2359         target_t *target = get_current_target(cmd_ctx);
2360
2361         if (argc > 0)
2362                 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2363
2364         return ERROR_OK;
2365 }
2366
2367 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2368 {
2369         target_t *target = get_current_target(cmd_ctx);
2370         int retval;
2371
2372         if (argc == 0)
2373         {
2374                 watchpoint_t *watchpoint = target->watchpoints;
2375
2376                 while (watchpoint)
2377                 {
2378                         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);
2379                         watchpoint = watchpoint->next;
2380                 }
2381         }
2382         else if (argc >= 2)
2383         {
2384                 enum watchpoint_rw type = WPT_ACCESS;
2385                 u32 data_value = 0x0;
2386                 u32 data_mask = 0xffffffff;
2387
2388                 if (argc >= 3)
2389                 {
2390                         switch(args[2][0])
2391                         {
2392                                 case 'r':
2393                                         type = WPT_READ;
2394                                         break;
2395                                 case 'w':
2396                                         type = WPT_WRITE;
2397                                         break;
2398                                 case 'a':
2399                                         type = WPT_ACCESS;
2400                                         break;
2401                                 default:
2402                                         command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2403                                         return ERROR_OK;
2404                         }
2405                 }
2406                 if (argc >= 4)
2407                 {
2408                         data_value = strtoul(args[3], NULL, 0);
2409                 }
2410                 if (argc >= 5)
2411                 {
2412                         data_mask = strtoul(args[4], NULL, 0);
2413                 }
2414
2415                 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2416                                 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2417                 {
2418                         LOG_ERROR("Failure setting breakpoints");
2419                 }
2420         }
2421         else
2422         {
2423                 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2424         }
2425
2426         return ERROR_OK;
2427 }
2428
2429 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2430 {
2431         target_t *target = get_current_target(cmd_ctx);
2432
2433         if (argc > 0)
2434                 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2435
2436         return ERROR_OK;
2437 }
2438
2439 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2440 {
2441         int retval;
2442         target_t *target = get_current_target(cmd_ctx);
2443         u32 va;
2444         u32 pa;
2445
2446         if (argc != 1)
2447         {
2448                 return ERROR_COMMAND_SYNTAX_ERROR;
2449         }
2450         va = strtoul(args[0], NULL, 0);
2451
2452         retval = target->type->virt2phys(target, va, &pa);
2453         if (retval == ERROR_OK)
2454         {
2455                 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2456         }
2457         else
2458         {
2459                 /* lower levels will have logged a detailed error which is
2460                  * forwarded to telnet/GDB session.
2461                  */
2462         }
2463         return retval;
2464 }
2465 static void writeLong(FILE *f, int l)
2466 {
2467         int i;
2468         for (i=0; i<4; i++)
2469         {
2470                 char c=(l>>(i*8))&0xff;
2471                 fwrite(&c, 1, 1, f);
2472         }
2473
2474 }
2475 static void writeString(FILE *f, char *s)
2476 {
2477         fwrite(s, 1, strlen(s), f);
2478 }
2479
2480
2481
2482 // Dump a gmon.out histogram file.
2483 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2484 {
2485         int i;
2486         FILE *f=fopen(filename, "w");
2487         if (f==NULL)
2488                 return;
2489         fwrite("gmon", 1, 4, f);
2490         writeLong(f, 0x00000001); // Version
2491         writeLong(f, 0); // padding
2492         writeLong(f, 0); // padding
2493         writeLong(f, 0); // padding
2494
2495         fwrite("", 1, 1, f);  // GMON_TAG_TIME_HIST
2496
2497         // figure out bucket size
2498         u32 min=samples[0];
2499         u32 max=samples[0];
2500         for (i=0; i<sampleNum; i++)
2501         {
2502                 if (min>samples[i])
2503                 {
2504                         min=samples[i];
2505                 }
2506                 if (max<samples[i])
2507                 {
2508                         max=samples[i];
2509                 }
2510         }
2511
2512         int addressSpace=(max-min+1);
2513
2514         static int const maxBuckets=256*1024; // maximum buckets.
2515         int length=addressSpace;
2516         if (length > maxBuckets)
2517         {
2518                 length=maxBuckets;
2519         }
2520         int *buckets=malloc(sizeof(int)*length);
2521         if (buckets==NULL)
2522         {
2523                 fclose(f);
2524                 return;
2525         }
2526         memset(buckets, 0, sizeof(int)*length);
2527         for (i=0; i<sampleNum;i++)
2528         {
2529                 u32 address=samples[i];
2530                 long long a=address-min;
2531                 long long b=length-1;
2532                 long long c=addressSpace-1;
2533                 int index=(a*b)/c; // danger!!!! int32 overflows
2534                 buckets[index]++;
2535         }
2536
2537         //                         append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2538         writeLong(f, min);                                      // low_pc
2539         writeLong(f, max);              // high_pc
2540         writeLong(f, length);           // # of samples
2541         writeLong(f, 64000000);                         // 64MHz
2542         writeString(f, "seconds");
2543         for (i=0; i<(15-strlen("seconds")); i++)
2544         {
2545                 fwrite("", 1, 1, f);  // padding
2546         }
2547         writeString(f, "s");
2548
2549 //                         append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2550
2551         char *data=malloc(2*length);
2552         if (data!=NULL)
2553         {
2554                 for (i=0; i<length;i++)
2555                 {
2556                         int val;
2557                         val=buckets[i];
2558                         if (val>65535)
2559                         {
2560                                 val=65535;
2561                         }
2562                         data[i*2]=val&0xff;
2563                         data[i*2+1]=(val>>8)&0xff;
2564                 }
2565                 free(buckets);
2566                 fwrite(data, 1, length*2, f);
2567                 free(data);
2568         } else
2569         {
2570                 free(buckets);
2571         }
2572
2573         fclose(f);
2574 }
2575
2576 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2577 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2578 {
2579         target_t *target = get_current_target(cmd_ctx);
2580         struct timeval timeout, now;
2581
2582         gettimeofday(&timeout, NULL);
2583         if (argc!=2)
2584         {
2585                 return ERROR_COMMAND_SYNTAX_ERROR;
2586         }
2587         char *end;
2588         timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2589         if (*end)
2590         {
2591                 return ERROR_OK;
2592         }
2593
2594         command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2595
2596         static const int maxSample=10000;
2597         u32 *samples=malloc(sizeof(u32)*maxSample);
2598         if (samples==NULL)
2599                 return ERROR_OK;
2600
2601         int numSamples=0;
2602         int retval=ERROR_OK;
2603         // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2604         reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2605
2606         for (;;)
2607         {
2608                 target_poll(target);
2609                 if (target->state == TARGET_HALTED)
2610                 {
2611                         u32 t=*((u32 *)reg->value);
2612                         samples[numSamples++]=t;
2613                         retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2614                         target_poll(target);
2615                         alive_sleep(10); // sleep 10ms, i.e. <100 samples/second.
2616                 } else if (target->state == TARGET_RUNNING)
2617                 {
2618                         // We want to quickly sample the PC.
2619                         target_halt(target);
2620                 } else
2621                 {
2622                         command_print(cmd_ctx, "Target not halted or running");
2623                         retval=ERROR_OK;
2624                         break;
2625                 }
2626                 if (retval!=ERROR_OK)
2627                 {
2628                         break;
2629                 }
2630
2631                 gettimeofday(&now, NULL);
2632                 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2633                 {
2634                         command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2635                         target_poll(target);
2636                         if (target->state == TARGET_HALTED)
2637                         {
2638                                 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2639                         }
2640                         target_poll(target);
2641                         writeGmon(samples, numSamples, args[1]);
2642                         command_print(cmd_ctx, "Wrote %s", args[1]);
2643                         break;
2644                 }
2645         }
2646         free(samples);
2647
2648         return ERROR_OK;
2649 }
2650
2651 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val)
2652 {
2653         char *namebuf;
2654         Jim_Obj *nameObjPtr, *valObjPtr;
2655         int result;
2656
2657         namebuf = alloc_printf("%s(%d)", varname, idx);
2658         if (!namebuf)
2659                 return JIM_ERR;
2660
2661         nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2662         valObjPtr = Jim_NewIntObj(interp, val);
2663         if (!nameObjPtr || !valObjPtr)
2664         {
2665                 free(namebuf);
2666                 return JIM_ERR;
2667         }
2668
2669         Jim_IncrRefCount(nameObjPtr);
2670         Jim_IncrRefCount(valObjPtr);
2671         result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
2672         Jim_DecrRefCount(interp, nameObjPtr);
2673         Jim_DecrRefCount(interp, valObjPtr);
2674         free(namebuf);
2675         /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2676         return result;
2677 }
2678
2679 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2680 {
2681         command_context_t *context;
2682         target_t *target;
2683
2684         context = Jim_GetAssocData(interp, "context");
2685         if (context == NULL)
2686         {
2687                 LOG_ERROR("mem2array: no command context");
2688                 return JIM_ERR;
2689         }
2690         target = get_current_target(context);
2691         if (target == NULL)
2692         {
2693                 LOG_ERROR("mem2array: no current target");
2694                 return JIM_ERR;
2695         }
2696
2697         return  target_mem2array(interp, target, argc,argv);
2698 }
2699
2700 static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
2701 {
2702         long l;
2703         u32 width;
2704         u32 len;
2705         u32 addr;
2706         u32 count;
2707         u32 v;
2708         const char *varname;
2709         u8 buffer[4096];
2710         int  i, n, e, retval;
2711
2712         /* argv[1] = name of array to receive the data
2713          * argv[2] = desired width
2714          * argv[3] = memory address
2715          * argv[4] = count of times to read
2716          */
2717         if (argc != 5) {
2718                 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2719                 return JIM_ERR;
2720         }
2721         varname = Jim_GetString(argv[1], &len);
2722         /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2723
2724         e = Jim_GetLong(interp, argv[2], &l);
2725         width = l;
2726         if (e != JIM_OK) {
2727                 return e;
2728         }
2729
2730         e = Jim_GetLong(interp, argv[3], &l);
2731         addr = l;
2732         if (e != JIM_OK) {
2733                 return e;
2734         }
2735         e = Jim_GetLong(interp, argv[4], &l);
2736         len = l;
2737         if (e != JIM_OK) {
2738                 return e;
2739         }
2740         switch (width) {
2741                 case 8:
2742                         width = 1;
2743                         break;
2744                 case 16:
2745                         width = 2;
2746                         break;
2747                 case 32:
2748                         width = 4;
2749                         break;
2750                 default:
2751                         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2752                         Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2753                         return JIM_ERR;
2754         }
2755         if (len == 0) {
2756                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2757                 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
2758                 return JIM_ERR;
2759         }
2760         if ((addr + (len * width)) < addr) {
2761                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2762                 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
2763                 return JIM_ERR;
2764         }
2765         /* absurd transfer size? */
2766         if (len > 65536) {
2767                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2768                 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
2769                 return JIM_ERR;
2770         }
2771
2772         if ((width == 1) ||
2773                 ((width == 2) && ((addr & 1) == 0)) ||
2774                 ((width == 4) && ((addr & 3) == 0))) {
2775                 /* all is well */
2776         } else {
2777                 char buf[100];
2778                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2779                 sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width);
2780                 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2781                 return JIM_ERR;
2782         }
2783
2784         /* Transfer loop */
2785
2786         /* index counter */
2787         n = 0;
2788         /* assume ok */
2789         e = JIM_OK;
2790         while (len) {
2791                 /* Slurp... in buffer size chunks */
2792
2793                 count = len; /* in objects.. */
2794                 if (count > (sizeof(buffer)/width)) {
2795                         count = (sizeof(buffer)/width);
2796                 }
2797
2798                 retval = target->type->read_memory( target, addr, width, count, buffer );
2799                 if (retval != ERROR_OK) {
2800                         /* BOO !*/
2801                         LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2802                         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2803                         Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2804                         e = JIM_ERR;
2805                         len = 0;
2806                 } else {
2807                         v = 0; /* shut up gcc */
2808                         for (i = 0 ;i < count ;i++, n++) {
2809                                 switch (width) {
2810                                         case 4:
2811                                                 v = target_buffer_get_u32(target, &buffer[i*width]);
2812                                                 break;
2813                                         case 2:
2814                                                 v = target_buffer_get_u16(target, &buffer[i*width]);
2815                                                 break;
2816                                         case 1:
2817                                                 v = buffer[i] & 0x0ff;
2818                                                 break;
2819                                 }
2820                                 new_int_array_element(interp, varname, n, v);
2821                         }
2822                         len -= count;
2823                 }
2824         }
2825
2826         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2827
2828         return JIM_OK;
2829 }
2830
2831 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val)
2832 {
2833         char *namebuf;
2834         Jim_Obj *nameObjPtr, *valObjPtr;
2835         int result;
2836         long l;
2837
2838         namebuf = alloc_printf("%s(%d)", varname, idx);
2839         if (!namebuf)
2840                 return JIM_ERR;
2841
2842         nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2843         if (!nameObjPtr)
2844         {
2845                 free(namebuf);
2846                 return JIM_ERR;
2847         }
2848
2849         Jim_IncrRefCount(nameObjPtr);
2850         valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
2851         Jim_DecrRefCount(interp, nameObjPtr);
2852         free(namebuf);
2853         if (valObjPtr == NULL)
2854                 return JIM_ERR;
2855
2856         result = Jim_GetLong(interp, valObjPtr, &l);
2857         /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2858         *val = l;
2859         return result;
2860 }
2861
2862 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2863 {
2864         command_context_t *context;
2865         target_t *target;
2866
2867         context = Jim_GetAssocData(interp, "context");
2868         if (context == NULL){
2869                 LOG_ERROR("array2mem: no command context");
2870                 return JIM_ERR;
2871         }
2872         target = get_current_target(context);
2873         if (target == NULL){
2874                 LOG_ERROR("array2mem: no current target");
2875                 return JIM_ERR;
2876         }
2877
2878         return target_array2mem( interp,target, argc, argv );
2879 }
2880
2881
2882 static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
2883 {
2884         long l;
2885         u32 width;
2886         u32 len;
2887         u32 addr;
2888         u32 count;
2889         u32 v;
2890         const char *varname;
2891         u8 buffer[4096];
2892         int  i, n, e, retval;
2893
2894         /* argv[1] = name of array to get the data
2895          * argv[2] = desired width
2896          * argv[3] = memory address
2897          * argv[4] = count to write
2898          */
2899         if (argc != 5) {
2900                 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2901                 return JIM_ERR;
2902         }
2903         varname = Jim_GetString(argv[1], &len);
2904         /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2905
2906         e = Jim_GetLong(interp, argv[2], &l);
2907         width = l;
2908         if (e != JIM_OK) {
2909                 return e;
2910         }
2911
2912         e = Jim_GetLong(interp, argv[3], &l);
2913         addr = l;
2914         if (e != JIM_OK) {
2915                 return e;
2916         }
2917         e = Jim_GetLong(interp, argv[4], &l);
2918         len = l;
2919         if (e != JIM_OK) {
2920                 return e;
2921         }
2922         switch (width) {
2923                 case 8:
2924                         width = 1;
2925                         break;
2926                 case 16:
2927                         width = 2;
2928                         break;
2929                 case 32:
2930                         width = 4;
2931                         break;
2932                 default:
2933                         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2934                         Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2935                         return JIM_ERR;
2936         }
2937         if (len == 0) {
2938                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2939                 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
2940                 return JIM_ERR;
2941         }
2942         if ((addr + (len * width)) < addr) {
2943                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2944                 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
2945                 return JIM_ERR;
2946         }
2947         /* absurd transfer size? */
2948         if (len > 65536) {
2949                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2950                 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
2951                 return JIM_ERR;
2952         }
2953
2954         if ((width == 1) ||
2955                 ((width == 2) && ((addr & 1) == 0)) ||
2956                 ((width == 4) && ((addr & 3) == 0))) {
2957                 /* all is well */
2958         } else {
2959                 char buf[100];
2960                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2961                 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width);
2962                 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2963                 return JIM_ERR;
2964         }
2965
2966
2967         /* Transfer loop */
2968
2969         /* index counter */
2970         n = 0;
2971         /* assume ok */
2972         e = JIM_OK;
2973         while (len) {
2974                 /* Slurp... in buffer size chunks */
2975
2976                 count = len; /* in objects.. */
2977                 if (count > (sizeof(buffer)/width)) {
2978                         count = (sizeof(buffer)/width);
2979                 }
2980
2981                 v = 0; /* shut up gcc */
2982                 for (i = 0 ;i < count ;i++, n++) {
2983                         get_int_array_element(interp, varname, n, &v);
2984                         switch (width) {
2985                         case 4:
2986                                 target_buffer_set_u32(target, &buffer[i*width], v);
2987                                 break;
2988                         case 2:
2989                                 target_buffer_set_u16(target, &buffer[i*width], v);
2990                                 break;
2991                         case 1:
2992                                 buffer[i] = v & 0x0ff;
2993                                 break;
2994                         }
2995                 }
2996                 len -= count;
2997
2998                 retval = target->type->write_memory(target, addr, width, count, buffer);
2999                 if (retval != ERROR_OK) {
3000                         /* BOO !*/
3001                         LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
3002                         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3003                         Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: cannot read memory", NULL);
3004                         e = JIM_ERR;
3005                         len = 0;
3006                 }
3007         }
3008
3009         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3010
3011         return JIM_OK;
3012 }
3013
3014 void
3015 target_all_handle_event( enum target_event e )
3016 {
3017         target_t *target;
3018
3019
3020         LOG_DEBUG( "**all*targets: event: %d, %s",
3021                    e,
3022                    Jim_Nvp_value2name_simple( nvp_target_event, e )->name );
3023
3024         target = all_targets;
3025         while (target){
3026                 target_handle_event( target, e );
3027                 target = target->next;
3028         }
3029 }
3030
3031 void
3032 target_handle_event( target_t *target, enum target_event e )
3033 {
3034         target_event_action_t *teap;
3035         int done;
3036
3037         teap = target->event_action;
3038
3039         done = 0;
3040         while( teap ){
3041                 if( teap->event == e ){
3042                         done = 1;
3043                         LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
3044                                            target->target_number,
3045                                            target->cmd_name,
3046                                            target->type->name,
3047                                            e,
3048                                            Jim_Nvp_value2name_simple( nvp_target_event, e )->name,
3049                                            Jim_GetString( teap->body, NULL ) );
3050                         Jim_EvalObj( interp, teap->body );
3051                 }
3052                 teap = teap->next;
3053         }
3054         if( !done ){
3055                 LOG_DEBUG( "event: %d %s - no action",
3056                                    e,
3057                                    Jim_Nvp_value2name_simple( nvp_target_event, e )->name );
3058         }
3059 }
3060
3061 enum target_cfg_param {
3062         TCFG_TYPE,
3063         TCFG_EVENT,
3064         TCFG_WORK_AREA_VIRT,
3065         TCFG_WORK_AREA_PHYS,
3066         TCFG_WORK_AREA_SIZE,
3067         TCFG_WORK_AREA_BACKUP,
3068         TCFG_ENDIAN,
3069         TCFG_VARIANT,
3070         TCFG_CHAIN_POSITION,
3071 };
3072
3073
3074 static Jim_Nvp nvp_config_opts[] = {
3075         { .name = "-type",             .value = TCFG_TYPE },
3076         { .name = "-event",            .value = TCFG_EVENT },
3077         { .name = "-work-area-virt",   .value = TCFG_WORK_AREA_VIRT },
3078         { .name = "-work-area-phys",   .value = TCFG_WORK_AREA_PHYS },
3079         { .name = "-work-area-size",   .value = TCFG_WORK_AREA_SIZE },
3080         { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
3081         { .name = "-endian" ,          .value = TCFG_ENDIAN },
3082         { .name = "-variant",          .value = TCFG_VARIANT },
3083         { .name = "-chain-position",   .value = TCFG_CHAIN_POSITION },
3084
3085         { .name = NULL, .value = -1 }
3086 };
3087
3088
3089 static int
3090 target_configure( Jim_GetOptInfo *goi,
3091                                   target_t *target )
3092 {
3093         Jim_Nvp *n;
3094         Jim_Obj *o;
3095         jim_wide w;
3096         char *cp;
3097         int e;
3098
3099
3100         /* parse config or cget options ... */
3101         while( goi->argc > 0 ){
3102                 Jim_SetEmptyResult( goi->interp );
3103                 //Jim_GetOpt_Debug( goi );
3104
3105                 if( target->type->target_jim_configure ){
3106                         /* target defines a configure function */
3107                         /* target gets first dibs on parameters */
3108                         e = (*(target->type->target_jim_configure))( target, goi );
3109                         if( e == JIM_OK ){
3110                                 /* more? */
3111                                 continue;
3112                         }
3113                         if( e == JIM_ERR ){
3114                                 /* An error */
3115                                 return e;
3116                         }
3117                         /* otherwise we 'continue' below */
3118                 }
3119                 e = Jim_GetOpt_Nvp( goi, nvp_config_opts, &n );
3120                 if( e != JIM_OK ){
3121                         Jim_GetOpt_NvpUnknown( goi, nvp_config_opts, 0 );
3122                         return e;
3123                 }
3124                 switch( n->value ){
3125                 case TCFG_TYPE:
3126                         /* not setable */
3127                         if( goi->isconfigure ){
3128                                 Jim_SetResult_sprintf( goi->interp, "not setable: %s", n->name );
3129                                 return JIM_ERR;
3130                         } else {
3131                         no_params:
3132                                 if( goi->argc != 0 ){
3133                                         Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "NO PARAMS");
3134                                         return JIM_ERR;
3135                                 }
3136                         }
3137                         Jim_SetResultString( goi->interp, target->type->name, -1 );
3138                         /* loop for more */
3139                         break;
3140                 case TCFG_EVENT:
3141                         if( goi->argc == 0 ){
3142                                 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
3143                                 return JIM_ERR;
3144                         }
3145
3146                         e = Jim_GetOpt_Nvp( goi, nvp_target_event, &n );
3147                         if( e != JIM_OK ){
3148                                 Jim_GetOpt_NvpUnknown( goi, nvp_target_event, 1 );
3149                                 return e;
3150                         }
3151
3152                         if( goi->isconfigure ){
3153                                 if( goi->argc == 0 ){
3154                                         Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
3155                                         return JIM_ERR;
3156                                 }
3157                         } else {
3158                                 if( goi->argc != 0 ){
3159                                         Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
3160                                         return JIM_ERR;
3161                                 }
3162                         }
3163
3164
3165                         {
3166                                 target_event_action_t *teap;
3167
3168                                 teap = target->event_action;
3169                                 /* replace existing? */
3170                                 while( teap ){
3171                                         if( teap->event == n->value ){
3172                                                 break;
3173                                         }
3174                                         teap = teap->next;
3175                                 }
3176
3177                                 if( goi->isconfigure ){
3178                                         if( teap == NULL ){
3179                                                 /* create new */
3180                                                 teap = calloc( 1, sizeof(*teap) );
3181                                         }
3182                                         teap->event = n->value;
3183                                         Jim_GetOpt_Obj( goi, &o );
3184                                         if( teap->body ){
3185                                                 Jim_DecrRefCount( interp, teap->body );
3186                                         }
3187                                         teap->body  = Jim_DuplicateObj( goi->interp, o );
3188                                         /*
3189                                          * FIXME:
3190                                          *     Tcl/TK - "tk events" have a nice feature.
3191                                          *     See the "BIND" command.
3192                                          *    We should support that here.
3193                                          *     You can specify %X and %Y in the event code.
3194                                          *     The idea is: %T - target name.
3195                                          *     The idea is: %N - target number
3196                                          *     The idea is: %E - event name.
3197                                          */
3198                                         Jim_IncrRefCount( teap->body );
3199
3200                                         /* add to head of event list */
3201                                         teap->next = target->event_action;
3202                                         target->event_action = teap;
3203                                         Jim_SetEmptyResult(goi->interp);
3204                                 } else {
3205                                         /* get */
3206                                         if( teap == NULL ){
3207                                                 Jim_SetEmptyResult( goi->interp );
3208                                         } else {
3209                                                 Jim_SetResult( goi->interp, Jim_DuplicateObj( goi->interp, teap->body ) );
3210                                         }
3211                                 }
3212                         }
3213                         /* loop for more */
3214                         break;
3215
3216                 case TCFG_WORK_AREA_VIRT:
3217                         if( goi->isconfigure ){
3218                                 target_free_all_working_areas(target);
3219                                 e = Jim_GetOpt_Wide( goi, &w );
3220                                 if( e != JIM_OK ){
3221                                         return e;
3222                                 }
3223                                 target->working_area_virt = w;
3224                         } else {
3225                                 if( goi->argc != 0 ){
3226                                         goto no_params;
3227                                 }
3228                         }
3229                         Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_virt ) );
3230                         /* loop for more */
3231                         break;
3232
3233                 case TCFG_WORK_AREA_PHYS:
3234                         if( goi->isconfigure ){
3235                                 target_free_all_working_areas(target);
3236                                 e = Jim_GetOpt_Wide( goi, &w );
3237                                 if( e != JIM_OK ){
3238                                         return e;
3239                                 }
3240                                 target->working_area_phys = w;
3241                         } else {
3242                                 if( goi->argc != 0 ){
3243                                         goto no_params;
3244                                 }
3245                         }
3246                         Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_phys ) );
3247                         /* loop for more */
3248                         break;
3249
3250                 case TCFG_WORK_AREA_SIZE:
3251                         if( goi->isconfigure ){
3252                                 target_free_all_working_areas(target);
3253                                 e = Jim_GetOpt_Wide( goi, &w );
3254                                 if( e != JIM_OK ){
3255                                         return e;
3256                                 }
3257                                 target->working_area_size = w;
3258                         } else {
3259                                 if( goi->argc != 0 ){
3260                                         goto no_params;
3261                                 }
3262                         }
3263                         Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_size ) );
3264                         /* loop for more */
3265                         break;
3266
3267                 case TCFG_WORK_AREA_BACKUP:
3268                         if( goi->isconfigure ){
3269                                 target_free_all_working_areas(target);
3270                                 e = Jim_GetOpt_Wide( goi, &w );
3271                                 if( e != JIM_OK ){
3272                                         return e;
3273                                 }
3274                                 /* make this exactly 1 or 0 */
3275                                 target->backup_working_area = (!!w);
3276                         } else {
3277                                 if( goi->argc != 0 ){
3278                                         goto no_params;
3279                                 }
3280                         }
3281                         Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_size ) );
3282                         /* loop for more e*/
3283                         break;
3284
3285                 case TCFG_ENDIAN:
3286                         if( goi->isconfigure ){
3287                                 e = Jim_GetOpt_Nvp( goi, nvp_target_endian, &n );
3288                                 if( e != JIM_OK ){
3289                                         Jim_GetOpt_NvpUnknown( goi, nvp_target_endian, 1 );
3290                                         return e;
3291                                 }
3292                                 target->endianness = n->value;
3293                         } else {
3294                                 if( goi->argc != 0 ){
3295                                         goto no_params;
3296                                 }
3297                         }
3298                         n = Jim_Nvp_value2name_simple( nvp_target_endian, target->endianness );
3299                         if( n->name == NULL ){
3300                                 target->endianness = TARGET_LITTLE_ENDIAN;
3301                                 n = Jim_Nvp_value2name_simple( nvp_target_endian, target->endianness );
3302                         }
3303                         Jim_SetResultString( goi->interp, n->name, -1 );
3304                         /* loop for more */
3305                         break;
3306
3307                 case TCFG_VARIANT:
3308                         if( goi->isconfigure ){
3309                                 if( goi->argc < 1 ){
3310                                         Jim_SetResult_sprintf( goi->interp,
3311                                                                                    "%s ?STRING?",
3312                                                                                    n->name );
3313                                         return JIM_ERR;
3314                                 }
3315                                 if( target->variant ){
3316                                         free((void *)(target->variant));
3317                                 }
3318                                 e = Jim_GetOpt_String( goi, &cp, NULL );
3319                                 target->variant = strdup(cp);
3320                         } else {
3321                                 if( goi->argc != 0 ){
3322                                         goto no_params;
3323                                 }
3324                         }
3325                         Jim_SetResultString( goi->interp, target->variant,-1 );
3326                         /* loop for more */
3327                         break;
3328                 case TCFG_CHAIN_POSITION:
3329                         if( goi->isconfigure ){
3330                                 target_free_all_working_areas(target);
3331                                 e = Jim_GetOpt_Wide( goi, &w );
3332                                 if( e != JIM_OK ){
3333                                         return e;
3334                                 }
3335                                 /* make this exactly 1 or 0 */
3336                                 target->chain_position = w;
3337                         } else {
3338                                 if( goi->argc != 0 ){
3339                                         goto no_params;
3340                                 }
3341                         }
3342                         Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->chain_position ) );
3343                         /* loop for more e*/
3344                         break;
3345                 }
3346         } /* while( goi->argc ) */
3347                 /* done - we return */
3348         return JIM_OK;
3349 }
3350
3351
3352 /** this is the 'tcl' handler for the target specific command */
3353 static int
3354 tcl_target_func( Jim_Interp *interp,
3355                                  int argc,
3356                                  Jim_Obj *const *argv )
3357 {
3358         Jim_GetOptInfo goi;
3359         jim_wide a,b,c;
3360         int x,y,z;
3361         u8  target_buf[32];
3362         Jim_Nvp *n;
3363         target_t *target;
3364         struct command_context_s *cmd_ctx;
3365         int e;
3366
3367
3368         enum {
3369                 TS_CMD_CONFIGURE,
3370                 TS_CMD_CGET,
3371
3372                 TS_CMD_MWW, TS_CMD_MWH, TS_CMD_MWB,
3373                 TS_CMD_MDW, TS_CMD_MDH, TS_CMD_MDB,
3374                 TS_CMD_MRW, TS_CMD_MRH, TS_CMD_MRB,
3375                 TS_CMD_MEM2ARRAY, TS_CMD_ARRAY2MEM,
3376                 TS_CMD_EXAMINE,
3377                 TS_CMD_POLL,
3378                 TS_CMD_RESET,
3379                 TS_CMD_HALT,
3380                 TS_CMD_WAITSTATE,
3381                 TS_CMD_EVENTLIST,
3382                 TS_CMD_CURSTATE,
3383                 TS_CMD_INVOKE_EVENT,
3384         };
3385
3386         static const Jim_Nvp target_options[] = {
3387                 { .name = "configure", .value = TS_CMD_CONFIGURE },
3388                 { .name = "cget", .value = TS_CMD_CGET },
3389                 { .name = "mww", .value = TS_CMD_MWW },
3390                 { .name = "mwh", .value = TS_CMD_MWH },
3391                 { .name = "mwb", .value = TS_CMD_MWB },
3392                 { .name = "mdw", .value = TS_CMD_MDW },
3393                 { .name = "mdh", .value = TS_CMD_MDH },
3394                 { .name = "mdb", .value = TS_CMD_MDB },
3395                 { .name = "mem2array", .value = TS_CMD_MEM2ARRAY },
3396                 { .name = "array2mem", .value = TS_CMD_ARRAY2MEM },
3397                 { .name = "eventlist", .value = TS_CMD_EVENTLIST },
3398                 { .name = "curstate",  .value = TS_CMD_CURSTATE },
3399
3400                 { .name = "arp_examine", .value = TS_CMD_EXAMINE },
3401                 { .name = "arp_poll", .value = TS_CMD_POLL },
3402                 { .name = "arp_reset", .value = TS_CMD_RESET },
3403                 { .name = "arp_halt", .value = TS_CMD_HALT },
3404                 { .name = "arp_waitstate", .value = TS_CMD_WAITSTATE },
3405                 { .name = "invoke-event", .value = TS_CMD_INVOKE_EVENT },
3406
3407                 { .name = NULL, .value = -1 },
3408         };
3409
3410
3411         /* go past the "command" */
3412         Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
3413
3414         target = Jim_CmdPrivData( goi.interp );
3415         cmd_ctx = Jim_GetAssocData(goi.interp, "context");
3416
3417         /* commands here are in an NVP table */
3418         e = Jim_GetOpt_Nvp( &goi, target_options, &n );
3419         if( e != JIM_OK ){
3420                 Jim_GetOpt_NvpUnknown( &goi, target_options, 0 );
3421                 return e;
3422         }
3423         // Assume blank result
3424         Jim_SetEmptyResult( goi.interp );
3425
3426         switch( n->value ){
3427         case TS_CMD_CONFIGURE:
3428                 if( goi.argc < 2 ){
3429                         Jim_WrongNumArgs( goi.interp, goi.argc, goi.argv, "missing: -option VALUE ...");
3430                         return JIM_ERR;
3431                 }
3432                 goi.isconfigure = 1;
3433                 return target_configure( &goi, target );
3434         case TS_CMD_CGET:
3435                 // some things take params
3436                 if( goi.argc < 1 ){
3437                         Jim_WrongNumArgs( goi.interp, 0, goi.argv, "missing: ?-option?");
3438                         return JIM_ERR;
3439                 }
3440                 goi.isconfigure = 0;
3441                 return target_configure( &goi, target );
3442                 break;
3443         case TS_CMD_MWW:
3444         case TS_CMD_MWH:
3445         case TS_CMD_MWB:
3446                 /* argv[0] = cmd
3447                  * argv[1] = address
3448                  * argv[2] = data
3449                  * argv[3] = optional count.
3450                  */
3451
3452                 if( (goi.argc == 3) || (goi.argc == 4) ){
3453                         /* all is well */
3454                 } else {
3455                 mwx_error:
3456                         Jim_SetResult_sprintf( goi.interp, "expected: %s ADDR DATA [COUNT]", n->name );
3457                         return JIM_ERR;
3458                 }
3459
3460                 e = Jim_GetOpt_Wide( &goi, &a );
3461                 if( e != JIM_OK ){
3462                         goto mwx_error;
3463                 }
3464
3465                 e = Jim_GetOpt_Wide( &goi, &b );
3466                 if( e != JIM_OK ){
3467                         goto mwx_error;
3468                 }
3469                 if( goi.argc ){
3470                         e = Jim_GetOpt_Wide( &goi, &c );
3471                         if( e != JIM_OK ){
3472                                 goto mwx_error;
3473                         }
3474                 } else {
3475                         c = 1;
3476                 }
3477
3478                 switch( n->value ){
3479                 case TS_CMD_MWW:
3480                         target_buffer_set_u32( target, target_buf, b );
3481                         b = 4;
3482                         break;
3483                 case TS_CMD_MWH:
3484                         target_buffer_set_u16( target, target_buf, b );
3485                         b = 2;
3486                         break;
3487                 case TS_CMD_MWB:
3488                         target_buffer_set_u8( target, target_buf, b );
3489                         b = 1;
3490                         break;
3491                 }
3492                 for( x = 0 ; x < c ; x++ ){
3493                         e = target->type->write_memory( target, a, b, 1, target_buf );
3494                         if( e != ERROR_OK ){
3495                                 Jim_SetResult_sprintf( interp, "Error writing @ 0x%08x: %d\n", (int)(a), e );
3496                                 return JIM_ERR;
3497                         }
3498                         /* b = width */
3499                         a = a + b;
3500                 }
3501                 return JIM_OK;
3502                 break;
3503
3504                 /* display */
3505         case TS_CMD_MDW:
3506         case TS_CMD_MDH:
3507         case TS_CMD_MDB:
3508                 /* argv[0] = command
3509                  * argv[1] = address
3510                  * argv[2] = optional count
3511                  */
3512                 if( (goi.argc == 2) || (goi.argc == 3) ){
3513                         Jim_SetResult_sprintf( goi.interp, "expected: %s ADDR [COUNT]", n->name );
3514                         return JIM_ERR;
3515                 }
3516                 e = Jim_GetOpt_Wide( &goi, &a );
3517                 if( e != JIM_OK ){
3518                         return JIM_ERR;
3519                 }
3520                 if( goi.argc ){
3521                         e = Jim_GetOpt_Wide( &goi, &c );
3522                         if( e != JIM_OK ){
3523                                 return JIM_ERR;
3524                         }
3525                 } else {
3526                         c = 1;
3527                 }
3528                 b = 1; /* shut up gcc */
3529                 switch( n->value ){
3530                 case TS_CMD_MDW:
3531                         b =  4;
3532                         break;
3533                 case TS_CMD_MDH:
3534                         b = 2;
3535                         break;
3536                 case TS_CMD_MDB:
3537                         b = 1;
3538                         break;
3539                 }
3540
3541                 /* convert to "bytes" */
3542                 c = c * b;
3543                 /* count is now in 'BYTES' */
3544                 while( c > 0 ){
3545                         y = c;
3546                         if( y > 16 ){
3547                                 y = 16;
3548                         }
3549                         e = target->type->read_memory( target, a, b, y / b, target_buf );
3550                         if( e != ERROR_OK ){
3551                                 Jim_SetResult_sprintf( interp, "error reading target @ 0x%08lx", (int)(a) );
3552                                 return JIM_ERR;
3553                         }
3554
3555                         Jim_fprintf( interp, interp->cookie_stdout, "0x%08x ", (int)(a) );
3556                         switch( b ){
3557                         case 4:
3558                                 for( x = 0 ; (x < 16) && (x < y) ; x += 4 ){
3559                                         z = target_buffer_get_u32( target, &(target_buf[ x * 4 ]) );
3560                                         Jim_fprintf( interp, interp->cookie_stdout, "%08x ", (int)(z) );
3561                                 }
3562                                 for( ; (x < 16) ; x += 4 ){
3563                                         Jim_fprintf( interp, interp->cookie_stdout, "         " );
3564                                 }
3565                                 break;
3566                         case 2:
3567                                 for( x = 0 ; (x < 16) && (x < y) ; x += 2 ){
3568                                         z = target_buffer_get_u16( target, &(target_buf[ x * 2 ]) );
3569                                         Jim_fprintf( interp, interp->cookie_stdout, "%04x ", (int)(z) );
3570                                 }
3571                                 for( ; (x < 16) ; x += 2 ){
3572                                         Jim_fprintf( interp, interp->cookie_stdout, "     " );
3573                                 }
3574                                 break;
3575                         case 1:
3576                         default:
3577                                 for( x = 0 ; (x < 16) && (x < y) ; x += 1 ){
3578                                         z = target_buffer_get_u8( target, &(target_buf[ x * 4 ]) );
3579                                         Jim_fprintf( interp, interp->cookie_stdout, "%02x ", (int)(z) );
3580                                 }
3581                                 for( ; (x < 16) ; x += 1 ){
3582                                         Jim_fprintf( interp, interp->cookie_stdout, "   " );
3583                                 }
3584                                 break;
3585                         }
3586                         /* ascii-ify the bytes */
3587                         for( x = 0 ; x < y ; x++ ){
3588                                 if( (target_buf[x] >= 0x20) &&
3589                                         (target_buf[x] <= 0x7e) ){
3590                                         /* good */
3591                                 } else {
3592                                         /* smack it */
3593                                         target_buf[x] = '.';
3594                                 }
3595                         }
3596                         /* space pad  */
3597                         while( x < 16 ){
3598                                 target_buf[x] = ' ';
3599                                 x++;
3600                         }
3601                         /* terminate */
3602                         target_buf[16] = 0;
3603                         /* print - with a newline */
3604                         Jim_fprintf( interp, interp->cookie_stdout, "%s\n", target_buf );
3605                         /* NEXT... */
3606                         c -= 16;
3607                         a += 16;
3608                 }
3609                 return JIM_OK;
3610         case TS_CMD_MEM2ARRAY:
3611                 return target_mem2array( goi.interp, target, goi.argc, goi.argv );
3612                 break;
3613         case TS_CMD_ARRAY2MEM:
3614                 return target_array2mem( goi.interp, target, goi.argc, goi.argv );
3615                 break;
3616         case TS_CMD_EXAMINE:
3617                 if( goi.argc ){
3618                         Jim_WrongNumArgs( goi.interp, 2, argv, "[no parameters]");
3619                         return JIM_ERR;
3620                 }
3621                 e = target->type->examine( target );
3622                 if( e != ERROR_OK ){
3623                         Jim_SetResult_sprintf( interp, "examine-fails: %d", e );
3624                         return JIM_ERR;
3625                 }
3626                 return JIM_OK;
3627         case TS_CMD_POLL:
3628                 if( goi.argc ){
3629                         Jim_WrongNumArgs( goi.interp, 2, argv, "[no parameters]");
3630                         return JIM_ERR;
3631                 }
3632                 if( !(target->type->examined) ){
3633                         e = ERROR_TARGET_NOT_EXAMINED;
3634                 } else {
3635                         e = target->type->poll( target );
3636                 }
3637                 if( e != ERROR_OK ){
3638                         Jim_SetResult_sprintf( interp, "poll-fails: %d", e );
3639                         return JIM_ERR;
3640                 } else {
3641                         return JIM_OK;
3642                 }
3643                 break;
3644         case TS_CMD_RESET:
3645                 if( goi.argc != 2 ){
3646                         Jim_WrongNumArgs( interp, 2, argv, "t|f|assert|deassert BOOL");
3647                         return JIM_ERR;
3648                 }
3649                 e = Jim_GetOpt_Nvp( &goi, nvp_assert, &n );
3650                 if( e != JIM_OK ){
3651                         Jim_GetOpt_NvpUnknown( &goi, nvp_assert, 1 );
3652                         return e;
3653                 }
3654                 // the halt or not param
3655                 e = Jim_GetOpt_Wide( &goi, &a);
3656                 if( e != JIM_OK ){
3657                         return e;
3658                 }
3659                 // determine if we should halt or not.
3660                 target->reset_halt = !!a;
3661                 // When this happens - all workareas are invalid.
3662                 target_free_all_working_areas_restore(target, 0);
3663
3664                 // do the assert
3665                 if( n->value == NVP_ASSERT ){
3666                         target->type->assert_reset( target );
3667                 } else {
3668                         target->type->deassert_reset( target );
3669                 }
3670                 return JIM_OK;
3671         case TS_CMD_HALT:
3672                 if( goi.argc ){
3673                         Jim_WrongNumArgs( goi.interp, 0, argv, "halt [no parameters]");
3674                         return JIM_ERR;
3675                 }
3676                 target->type->halt( target );
3677                 return JIM_OK;
3678         case TS_CMD_WAITSTATE:
3679                 // params:  <name>  statename timeoutmsecs
3680                 if( goi.argc != 2 ){
3681                         Jim_SetResult_sprintf( goi.interp, "%s STATENAME TIMEOUTMSECS", n->name );
3682                         return JIM_ERR;
3683                 }
3684                 e = Jim_GetOpt_Nvp( &goi, nvp_target_state, &n );
3685                 if( e != JIM_OK ){
3686                         Jim_GetOpt_NvpUnknown( &goi, nvp_target_state,1 );
3687                         return e;
3688                 }
3689                 e = Jim_GetOpt_Wide( &goi, &a );
3690                 if( e != JIM_OK ){
3691                         return e;
3692                 }
3693                 e = target_wait_state( target, n->value, a );
3694                 if( e != ERROR_OK ){
3695                         Jim_SetResult_sprintf( goi.interp,
3696                                                                    "target: %s wait %s fails (%d) %s",
3697                                                                    target->cmd_name,
3698                                                                    n->name,
3699                                                e, target_strerror_safe(e) );
3700                         return JIM_ERR;
3701                 } else {
3702                         return JIM_OK;
3703                 }
3704         case TS_CMD_EVENTLIST:
3705                 /* List for human, Events defined for this target.
3706                  * scripts/programs should use 'name cget -event NAME'
3707                  */
3708                 {
3709                         target_event_action_t *teap;
3710                         teap = target->event_action;
3711                         command_print( cmd_ctx, "Event actions for target (%d) %s\n",
3712                                                    target->target_number,
3713                                                    target->cmd_name );
3714                         command_print( cmd_ctx, "%-25s | Body", "Event");
3715                         command_print( cmd_ctx, "------------------------- | ----------------------------------------");
3716                         while( teap ){
3717                                 command_print( cmd_ctx,
3718                                                            "%-25s | %s",
3719                                                            Jim_Nvp_value2name_simple( nvp_target_event, teap->event )->name,
3720                                                            Jim_GetString( teap->body, NULL ) );
3721                                 teap = teap->next;
3722                         }
3723                         command_print( cmd_ctx, "***END***");
3724                         return JIM_OK;
3725                 }
3726         case TS_CMD_CURSTATE:
3727                 if( goi.argc != 0 ){
3728                         Jim_WrongNumArgs( goi.interp, 0, argv, "[no parameters]");
3729                         return JIM_ERR;
3730                 }
3731                 Jim_SetResultString( goi.interp,
3732                                                          Jim_Nvp_value2name_simple(nvp_target_state,target->state)->name,-1);
3733                 return JIM_OK;
3734         case TS_CMD_INVOKE_EVENT:
3735                 if( goi.argc != 1 ){
3736                         Jim_SetResult_sprintf( goi.interp, "%s ?EVENTNAME?",n->name);
3737                         return JIM_ERR;
3738                 }
3739                 e = Jim_GetOpt_Nvp( &goi, nvp_target_event, &n );
3740                 if( e != JIM_OK ){
3741                         Jim_GetOpt_NvpUnknown( &goi, nvp_target_event, 1 );
3742                         return e;
3743                 }
3744                 target_handle_event( target, n->value );
3745                 return JIM_OK;
3746         }
3747         return JIM_ERR;
3748 }
3749
3750
3751 static int
3752 target_create( Jim_GetOptInfo *goi )
3753 {
3754
3755         Jim_Obj *new_cmd;
3756         Jim_Cmd *cmd;
3757         const char *cp;
3758         char *cp2;
3759         int e;
3760         int x;
3761         target_t *target;
3762         struct command_context_s *cmd_ctx;
3763
3764         cmd_ctx = Jim_GetAssocData(goi->interp, "context");
3765         if( goi->argc < 3 ){
3766                 Jim_WrongNumArgs( goi->interp, 1, goi->argv, "?name? ?type? ..options...");
3767                 return JIM_ERR;
3768         }
3769
3770         /* COMMAND */
3771         Jim_GetOpt_Obj( goi, &new_cmd );
3772         /* does this command exist? */
3773         cmd = Jim_GetCommand( goi->interp, new_cmd, JIM_ERRMSG );
3774         if( cmd ){
3775                 cp = Jim_GetString( new_cmd, NULL );
3776                 Jim_SetResult_sprintf(goi->interp, "Command/target: %s Exists", cp);
3777                 return JIM_ERR;
3778         }
3779
3780         /* TYPE */
3781         e = Jim_GetOpt_String( goi, &cp2, NULL );
3782         cp = cp2;
3783         /* now does target type exist */
3784         for( x = 0 ; target_types[x] ; x++ ){
3785                 if( 0 == strcmp( cp, target_types[x]->name ) ){
3786                         /* found */
3787                         break;
3788                 }
3789         }
3790         if( target_types[x] == NULL ){
3791                 Jim_SetResult_sprintf( goi->interp, "Unknown target type %s, try one of ", cp );
3792                 for( x = 0 ; target_types[x] ; x++ ){
3793                         if( target_types[x+1] ){
3794                                 Jim_AppendStrings( goi->interp,
3795                                                                    Jim_GetResult(goi->interp),
3796                                                                    target_types[x]->name,
3797                                                                    ", ", NULL);
3798                         } else {
3799                                 Jim_AppendStrings( goi->interp,
3800                                                                    Jim_GetResult(goi->interp),
3801                                                                    " or ",
3802                                                                    target_types[x]->name,NULL );
3803                         }
3804                 }
3805                 return JIM_ERR;
3806         }
3807
3808
3809         /* Create it */
3810         target = calloc(1,sizeof(target_t));
3811         /* set target number */
3812         target->target_number = new_target_number();
3813
3814         /* allocate memory for each unique target type */
3815         target->type = (target_type_t*)calloc(1,sizeof(target_type_t));
3816
3817         memcpy( target->type, target_types[x], sizeof(target_type_t));
3818
3819         /* will be set by "-endian" */
3820         target->endianness = TARGET_ENDIAN_UNKNOWN;
3821
3822         target->working_area        = 0x0;
3823         target->working_area_size   = 0x0;
3824         target->working_areas       = NULL;
3825         target->backup_working_area = 0;
3826
3827         target->state               = TARGET_UNKNOWN;
3828         target->debug_reason        = DBG_REASON_UNDEFINED;
3829         target->reg_cache           = NULL;
3830         target->breakpoints         = NULL;
3831         target->watchpoints         = NULL;
3832         target->next                = NULL;
3833         target->arch_info           = NULL;
3834
3835         /* initialize trace information */
3836         target->trace_info = malloc(sizeof(trace_t));
3837         target->trace_info->num_trace_points         = 0;
3838         target->trace_info->trace_points_size        = 0;
3839         target->trace_info->trace_points             = NULL;
3840         target->trace_info->trace_history_size       = 0;
3841         target->trace_info->trace_history            = NULL;
3842         target->trace_info->trace_history_pos        = 0;
3843         target->trace_info->trace_history_overflowed = 0;
3844
3845         target->dbgmsg          = NULL;
3846         target->dbg_msg_enabled = 0;
3847
3848         target->endianness = TARGET_ENDIAN_UNKNOWN;
3849
3850         /* Do the rest as "configure" options */
3851         goi->isconfigure = 1;
3852         e = target_configure( goi, target);
3853         if( e != JIM_OK ){
3854                 free( target->type );
3855                 free( target );
3856                 return e;
3857         }
3858
3859         if( target->endianness == TARGET_ENDIAN_UNKNOWN ){
3860                 /* default endian to little if not specified */
3861                 target->endianness = TARGET_LITTLE_ENDIAN;
3862         }
3863
3864         /* create the target specific commands */
3865         if( target->type->register_commands ){
3866                 (*(target->type->register_commands))( cmd_ctx );
3867         }
3868         if( target->type->target_create ){
3869                 (*(target->type->target_create))( target, goi->interp );
3870         }
3871
3872         /* append to end of list */
3873         {
3874                 target_t **tpp;
3875                 tpp = &(all_targets);
3876                 while( *tpp ){
3877                         tpp = &( (*tpp)->next );
3878                 }
3879                 *tpp = target;
3880         }
3881
3882         cp = Jim_GetString( new_cmd, NULL );
3883         target->cmd_name = strdup(cp);
3884
3885         /* now - create the new target name command */
3886         e = Jim_CreateCommand( goi->interp,
3887                                                    /* name */
3888                                                    cp,
3889                                                    tcl_target_func, /* C function */
3890                                                    target, /* private data */
3891                                                    NULL ); /* no del proc */
3892
3893         (*(target->type->target_create))( target, goi->interp );
3894         return e;
3895 }
3896
3897 static int
3898 jim_target( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
3899 {
3900         int x,r,e;
3901         jim_wide w;
3902         struct command_context_s *cmd_ctx;
3903         const char *cp;
3904         target_t *target;
3905         Jim_GetOptInfo goi;
3906         enum tcmd {
3907                 /* TG = target generic */
3908                 TG_CMD_CREATE,
3909                 TG_CMD_TYPES,
3910                 TG_CMD_NAMES,
3911                 TG_CMD_CURRENT,
3912                 TG_CMD_NUMBER,
3913                 TG_CMD_COUNT,
3914         };
3915         const char *target_cmds[] = {
3916                 "create", "types", "names", "current", "number",
3917                 "count",
3918                 NULL // terminate
3919         };
3920
3921         LOG_DEBUG("Target command params:");
3922         LOG_DEBUG(Jim_Debug_ArgvString( interp, argc, argv) );
3923
3924         cmd_ctx = Jim_GetAssocData( interp, "context" );
3925
3926         Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
3927
3928         if( goi.argc == 0 ){
3929                 Jim_WrongNumArgs(interp, 1, argv, "missing: command ...");
3930                 return JIM_ERR;
3931         }
3932
3933         /* is this old syntax? */
3934         /* To determine: We have to peek at argv[0]*/
3935         cp = Jim_GetString( goi.argv[0], NULL );
3936         for( x = 0 ; target_types[x] ; x++ ){
3937                 if( 0 == strcmp(cp,target_types[x]->name) ){
3938                         break;
3939                 }
3940         }
3941         if( target_types[x] ){
3942                 /* YES IT IS OLD SYNTAX */
3943                 Jim_Obj *new_argv[10];
3944                 int      new_argc;
3945
3946                 /* target_old_syntax
3947                  *
3948                  * argv[0] typename (above)
3949                  * argv[1] endian
3950                  * argv[2] reset method, deprecated/ignored
3951                  * argv[3] = old param
3952                  * argv[4] = old param
3953                  *
3954                  * We will combine all "old params" into a single param.
3955                  * Then later, split them again.
3956                  */
3957                 if( argc < 4 ){
3958                         Jim_WrongNumArgs( interp, 1, argv, "[OLDSYNTAX] ?TYPE? ?ENDIAN? ?RESET? ?old-params?");
3959                         return JIM_ERR;
3960                 }
3961                 /* the command */
3962                 new_argv[0] = argv[0];
3963                 new_argv[1] = Jim_NewStringObj( interp, "create", -1 );
3964                 {
3965                         char buf[ 30 ];
3966                         sprintf( buf, "target%d", new_target_number() );
3967                         new_argv[2] = Jim_NewStringObj( interp, buf , -1 );
3968                 }
3969                 new_argv[3] = goi.argv[0]; /* typename */
3970                 new_argv[4] = Jim_NewStringObj( interp, "-endian", -1 );
3971                 new_argv[5] = goi.argv[1];
3972                 new_argv[6] = Jim_NewStringObj( interp, "-chain-position", -1 );
3973                 new_argv[7] = goi.argv[2];
3974                 new_argv[8] = Jim_NewStringObj( interp, "-variant", -1 );
3975                 new_argv[9] = goi.argv[3];
3976                 new_argc = 10;
3977                 /*
3978                  * new arg syntax:
3979                  *   argv[0] = command
3980                  *   argv[1] = create
3981                  *   argv[2] = cmdname
3982                  *   argv[3] = typename
3983                  *   argv[4] = **FIRST** "configure" option.
3984                  *
3985                  * Here, we make them:
3986                  *
3987                  *   argv[4] = -endian
3988                  *   argv[5] = little
3989                  *   argv[6] = -position
3990                  *   argv[7] = NUMBER
3991                  *   argv[8] = -variant
3992                  *   argv[9] = "somestring"
3993                  */
3994
3995                 /* don't let these be released */
3996                 for( x = 0 ; x < new_argc ; x++ ){
3997                         Jim_IncrRefCount( new_argv[x]);
3998                 }
3999                 /* call our self */
4000                 LOG_DEBUG("Target OLD SYNTAX - converted to new syntax");
4001
4002                 r = jim_target( goi.interp, new_argc, new_argv );
4003
4004                 /* release? these items */
4005                 for( x = 0 ; x < new_argc ; x++ ){
4006                         Jim_DecrRefCount( interp, new_argv[x] );
4007                 }
4008                 return r;
4009         }
4010
4011         //Jim_GetOpt_Debug( &goi );
4012         r = Jim_GetOpt_Enum( &goi, target_cmds, &x   );
4013         if( r != JIM_OK ){
4014                 return r;
4015         }
4016
4017         switch(x){
4018         default:
4019                 Jim_Panic(goi.interp,"Why am I here?");
4020                 return JIM_ERR;
4021         case TG_CMD_CURRENT:
4022                 if( goi.argc != 0 ){
4023                         Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters");
4024                         return JIM_ERR;
4025                 }
4026                 Jim_SetResultString( goi.interp, get_current_target( cmd_ctx )->cmd_name, -1 );
4027                 return JIM_OK;
4028         case TG_CMD_TYPES:
4029                 if( goi.argc != 0 ){
4030                         Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters" );
4031                         return JIM_ERR;
4032                 }
4033                 Jim_SetResult( goi.interp, Jim_NewListObj( goi.interp, NULL, 0 ) );
4034                 for( x = 0 ; target_types[x] ; x++ ){
4035                         Jim_ListAppendElement( goi.interp,
4036                                                                    Jim_GetResult(goi.interp),
4037                                                                    Jim_NewStringObj( goi.interp, target_types[x]->name, -1 ) );
4038                 }
4039                 return JIM_OK;
4040         case TG_CMD_NAMES:
4041                 if( goi.argc != 0 ){
4042                         Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters" );
4043                         return JIM_ERR;
4044                 }
4045                 Jim_SetResult( goi.interp, Jim_NewListObj( goi.interp, NULL, 0 ) );
4046                 target = all_targets;
4047                 while( target ){
4048                         Jim_ListAppendElement( goi.interp,
4049                                                                    Jim_GetResult(goi.interp),
4050                                                                    Jim_NewStringObj( goi.interp, target->cmd_name, -1 ) );
4051                         target = target->next;
4052                 }
4053                 return JIM_OK;
4054         case TG_CMD_CREATE:
4055                 if( goi.argc < 3 ){
4056                         Jim_WrongNumArgs( goi.interp, goi.argc, goi.argv, "?name  ... config options ...");
4057                         return JIM_ERR;
4058                 }
4059                 return target_create( &goi );
4060                 break;
4061         case TG_CMD_NUMBER:
4062                 if( goi.argc != 1 ){
4063                         Jim_SetResult_sprintf( goi.interp, "expected: target number ?NUMBER?");
4064                         return JIM_ERR;
4065                 }
4066                 e = Jim_GetOpt_Wide( &goi, &w );
4067                 if( e != JIM_OK ){
4068                         return JIM_ERR;
4069                 }
4070                 {
4071                         target_t *t;
4072                         t = get_target_by_num(w);
4073                         if( t == NULL ){
4074                                 Jim_SetResult_sprintf( goi.interp,"Target: number %d does not exist", (int)(w));
4075                                 return JIM_ERR;
4076                         }
4077                         Jim_SetResultString( goi.interp, t->cmd_name, -1 );
4078                         return JIM_OK;
4079                 }
4080         case TG_CMD_COUNT:
4081                 if( goi.argc != 0 ){
4082                         Jim_WrongNumArgs( goi.interp, 0, goi.argv, "<no parameters>");
4083                         return JIM_ERR;
4084                 }
4085                 Jim_SetResult( goi.interp,
4086                                            Jim_NewIntObj( goi.interp, max_target_number()));
4087                 return JIM_OK;
4088         }
4089
4090         return JIM_ERR;
4091 }