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

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