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