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

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