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  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include "replacements.h"
  25 #include "target.h"
  26 #include "target_request.h"
  27
  28 #include "log.h"
  29 #include "configuration.h"
  30 #include "binarybuffer.h"
  31 #include "jtag.h"
  32
  33 #include <string.h>
  34 #include <stdlib.h>
  35 #include <inttypes.h>
  36
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <unistd.h>
  40 #include <errno.h>
  41
  42 #include <sys/time.h>
  43 #include <time.h>
  44
  45 #include <time_support.h>
  46
  47 #include <fileio.h>
  48 #include <image.h>
  49
  50 int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
  51
  52 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  53 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  54 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  55
  56 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  57 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  58 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  59
  60 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  61 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  62 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  63 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  64 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  65 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  66 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  67 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  68 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  69 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  70 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  71 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  72 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  73 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  74 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  75 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  76 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  77 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
  78
  79 /* targets
  80  */
  81 extern target_type_t arm7tdmi_target;
  82 extern target_type_t arm720t_target;
  83 extern target_type_t arm9tdmi_target;
  84 extern target_type_t arm920t_target;
  85 extern target_type_t arm966e_target;
  86 extern target_type_t arm926ejs_target;
  87 extern target_type_t feroceon_target;
  88 extern target_type_t xscale_target;
  89 extern target_type_t cortexm3_target;
  90
  91 target_type_t *target_types[] =
  92 {
  93         &arm7tdmi_target,
  94         &arm9tdmi_target,
  95         &arm920t_target,
  96         &arm720t_target,
  97         &arm966e_target,
  98         &arm926ejs_target,
  99         &feroceon_target,
 100         &xscale_target,
 101         &cortexm3_target,
 102         NULL,
 103 };
 104
 105 target_t *targets = NULL;
 106 target_event_callback_t *target_event_callbacks = NULL;
 107 target_timer_callback_t *target_timer_callbacks = NULL;
 108
 109 char *target_state_strings[] =
 110 {
 111         "unknown",
 112         "running",
 113         "halted",
 114         "reset",
 115         "debug_running",
 116 };
 117
 118 char *target_debug_reason_strings[] =
 119 {
 120         "debug request", "breakpoint", "watchpoint",
 121         "watchpoint and breakpoint", "single step",
 122         "target not halted"
 123 };
 124
 125 char *target_endianess_strings[] =
 126 {
 127         "big endian",
 128         "little endian",
 129 };
 130
 131 enum daemon_startup_mode startup_mode = DAEMON_ATTACH;
 132
 133 static int target_continous_poll = 1;
 134
 135 /* read a u32 from a buffer in target memory endianness */
 136 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
 137 {
 138         if (target->endianness == TARGET_LITTLE_ENDIAN)
 139                 return le_to_h_u32(buffer);
 140         else
 141                 return be_to_h_u32(buffer);
 142 }
 143
 144 /* read a u16 from a buffer in target memory endianness */
 145 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
 146 {
 147         if (target->endianness == TARGET_LITTLE_ENDIAN)
 148                 return le_to_h_u16(buffer);
 149         else
 150                 return be_to_h_u16(buffer);
 151 }
 152
 153 /* write a u32 to a buffer in target memory endianness */
 154 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
 155 {
 156         if (target->endianness == TARGET_LITTLE_ENDIAN)
 157                 h_u32_to_le(buffer, value);
 158         else
 159                 h_u32_to_be(buffer, value);
 160 }
 161
 162 /* write a u16 to a buffer in target memory endianness */
 163 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
 164 {
 165         if (target->endianness == TARGET_LITTLE_ENDIAN)
 166                 h_u16_to_le(buffer, value);
 167         else
 168                 h_u16_to_be(buffer, value);
 169 }
 170
 171 /* returns a pointer to the n-th configured target */
 172 target_t* get_target_by_num(int num)
 173 {
 174         target_t *target = targets;
 175         int i = 0;
 176
 177         while (target)
 178         {
 179                 if (num == i)
 180                         return target;
 181                 target = target->next;
 182                 i++;
 183         }
 184
 185         return NULL;
 186 }
 187
 188 int get_num_by_target(target_t *query_target)
 189 {
 190         target_t *target = targets;
 191         int i = 0;
 192
 193         while (target)
 194         {
 195                 if (target == query_target)
 196                         return i;
 197                 target = target->next;
 198                 i++;
 199         }
 200
 201         return -1;
 202 }
 203
 204 target_t* get_current_target(command_context_t *cmd_ctx)
 205 {
 206         target_t *target = get_target_by_num(cmd_ctx->current_target);
 207
 208         if (target == NULL)
 209         {
 210                 ERROR("BUG: current_target out of bounds");
 211                 exit(-1);
 212         }
 213
 214         return target;
 215 }
 216
 217 /* Process target initialization, when target entered debug out of reset
 218  * the handler is unregistered at the end of this function, so it's only called once
 219  */
 220 int target_init_handler(struct target_s *target, enum target_event event, void *priv)
 221 {
 222         FILE *script;
 223         struct command_context_s *cmd_ctx = priv;
 224
 225         if ((event == TARGET_EVENT_HALTED) && (target->reset_script))
 226         {
 227                 target_unregister_event_callback(target_init_handler, priv);
 228
 229                 script = open_file_from_path(cmd_ctx, target->reset_script, "r");
 230                 if (!script)
 231                 {
 232                         ERROR("couldn't open script file %s", target->reset_script);
 233                                 return ERROR_OK;
 234                 }
 235
 236                 INFO("executing reset script '%s'", target->reset_script);
 237                 command_run_file(cmd_ctx, script, COMMAND_EXEC);
 238                 fclose(script);
 239
 240                 jtag_execute_queue();
 241         }
 242
 243         return ERROR_OK;
 244 }
 245
 246 int target_run_and_halt_handler(void *priv)
 247 {
 248         target_t *target = priv;
 249
 250         target->type->halt(target);
 251
 252         return ERROR_OK;
 253 }
 254
 255 int target_process_reset(struct command_context_s *cmd_ctx)
 256 {
 257         int retval = ERROR_OK;
 258         target_t *target;
 259         struct timeval timeout, now;
 260
 261         /* prepare reset_halt where necessary */
 262         target = targets;
 263         while (target)
 264         {
 265                 if (jtag_reset_config & RESET_SRST_PULLS_TRST)
 266                 {
 267                         switch (target->reset_mode)
 268                         {
 269                                 case RESET_HALT:
 270                                         command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_HALT");
 271                                         target->reset_mode = RESET_RUN_AND_HALT;
 272                                         break;
 273                                 case RESET_INIT:
 274                                         command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_INIT");
 275                                         target->reset_mode = RESET_RUN_AND_INIT;
 276                                         break;
 277                                 default:
 278                                         break;
 279                         }
 280                 }
 281                 switch (target->reset_mode)
 282                 {
 283                         case RESET_HALT:
 284                         case RESET_INIT:
 285                                 target->type->prepare_reset_halt(target);
 286                                 break;
 287                         default:
 288                                 break;
 289                 }
 290                 target = target->next;
 291         }
 292
 293         target = targets;
 294         while (target)
 295         {
 296                 target->type->assert_reset(target);
 297                 target = target->next;
 298         }
 299         jtag_execute_queue();
 300
 301         /* request target halt if necessary, and schedule further action */
 302         target = targets;
 303         while (target)
 304         {
 305                 switch (target->reset_mode)
 306                 {
 307                         case RESET_RUN:
 308                                 /* nothing to do if target just wants to be run */
 309                                 break;
 310                         case RESET_RUN_AND_HALT:
 311                                 /* schedule halt */
 312                                 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
 313                                 break;
 314                         case RESET_RUN_AND_INIT:
 315                                 /* schedule halt */
 316                                 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
 317                                 target_register_event_callback(target_init_handler, cmd_ctx);
 318                                 break;
 319                         case RESET_HALT:
 320                                 target->type->halt(target);
 321                                 break;
 322                         case RESET_INIT:
 323                                 target->type->halt(target);
 324                                 target_register_event_callback(target_init_handler, cmd_ctx);
 325                                 break;
 326                         default:
 327                                 ERROR("BUG: unknown target->reset_mode");
 328                 }
 329                 target = target->next;
 330         }
 331
 332         target = targets;
 333         while (target)
 334         {
 335                 target->type->deassert_reset(target);
 336                 target = target->next;
 337         }
 338         jtag_execute_queue();
 339
 340         /* Wait for reset to complete, maximum 5 seconds. */
 341         gettimeofday(&timeout, NULL);
 342         timeval_add_time(&timeout, 5, 0);
 343         for(;;)
 344         {
 345                 gettimeofday(&now, NULL);
 346
 347                 target_call_timer_callbacks();
 348
 349                 target = targets;
 350                 while (target)
 351                 {
 352                         target->type->poll(target);
 353                         if ((target->reset_mode == RESET_RUN_AND_INIT) || (target->reset_mode == RESET_RUN_AND_HALT))
 354                         {
 355                                 if (target->state != TARGET_HALTED)
 356                                 {
 357                                         if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
 358                                         {
 359                                                 command_print(cmd_ctx, "Timed out waiting for reset");
 360                                                 goto done;
 361                                         }
 362                                         usleep(100*1000); /* Do not eat all cpu */
 363                                         goto again;
 364                                 }
 365                         }
 366                         target = target->next;
 367                 }
 368                 /* All targets we're waiting for are halted */
 369                 break;
 370
 371                 again:;
 372         }
 373         done:
 374
 375
 376         /* We want any events to be processed before the prompt */
 377         target_call_timer_callbacks();
 378
 379         return retval;
 380 }
 381
 382 static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
 383 {
 384         *physical = virtual;
 385         return ERROR_OK;
 386 }
 387
 388 static int default_mmu(struct target_s *target, int *enabled)
 389 {
 390         USER("No MMU present");
 391         *enabled = 0;
 392         return ERROR_OK;
 393 }
 394
 395 int target_init(struct command_context_s *cmd_ctx)
 396 {
 397         target_t *target = targets;
 398
 399         while (target)
 400         {
 401                 if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
 402                 {
 403                         ERROR("target '%s' init failed", target->type->name);
 404                         exit(-1);
 405                 }
 406
 407                 /* Set up default functions if none are provided by target */
 408                 if (target->type->virt2phys == NULL)
 409                 {
 410                         target->type->virt2phys = default_virt2phys;
 411                 }
 412                 if (target->type->mmu == NULL)
 413                 {
 414                         target->type->mmu = default_mmu;
 415                 }
 416                 target = target->next;
 417         }
 418
 419         if (targets)
 420         {
 421                 target_register_user_commands(cmd_ctx);
 422                 target_register_timer_callback(handle_target, 100, 1, NULL);
 423         }
 424
 425         return ERROR_OK;
 426 }
 427
 428 int target_init_reset(struct command_context_s *cmd_ctx)
 429 {
 430         if (startup_mode == DAEMON_RESET)
 431                 target_process_reset(cmd_ctx);
 432
 433         return ERROR_OK;
 434 }
 435
 436 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
 437 {
 438         target_event_callback_t **callbacks_p = &target_event_callbacks;
 439
 440         if (callback == NULL)
 441         {
 442                 return ERROR_INVALID_ARGUMENTS;
 443         }
 444
 445         if (*callbacks_p)
 446         {
 447                 while ((*callbacks_p)->next)
 448                         callbacks_p = &((*callbacks_p)->next);
 449                 callbacks_p = &((*callbacks_p)->next);
 450         }
 451
 452         (*callbacks_p) = malloc(sizeof(target_event_callback_t));
 453         (*callbacks_p)->callback = callback;
 454         (*callbacks_p)->priv = priv;
 455         (*callbacks_p)->next = NULL;
 456
 457         return ERROR_OK;
 458 }
 459
 460 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
 461 {
 462         target_timer_callback_t **callbacks_p = &target_timer_callbacks;
 463         struct timeval now;
 464
 465         if (callback == NULL)
 466         {
 467                 return ERROR_INVALID_ARGUMENTS;
 468         }
 469
 470         if (*callbacks_p)
 471         {
 472                 while ((*callbacks_p)->next)
 473                         callbacks_p = &((*callbacks_p)->next);
 474                 callbacks_p = &((*callbacks_p)->next);
 475         }
 476
 477         (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
 478         (*callbacks_p)->callback = callback;
 479         (*callbacks_p)->periodic = periodic;
 480         (*callbacks_p)->time_ms = time_ms;
 481
 482         gettimeofday(&now, NULL);
 483         (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
 484         time_ms -= (time_ms % 1000);
 485         (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
 486         if ((*callbacks_p)->when.tv_usec > 1000000)
 487         {
 488                 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
 489                 (*callbacks_p)->when.tv_sec += 1;
 490         }
 491
 492         (*callbacks_p)->priv = priv;
 493         (*callbacks_p)->next = NULL;
 494
 495         return ERROR_OK;
 496 }
 497
 498 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
 499 {
 500         target_event_callback_t **p = &target_event_callbacks;
 501         target_event_callback_t *c = target_event_callbacks;
 502
 503         if (callback == NULL)
 504         {
 505                 return ERROR_INVALID_ARGUMENTS;
 506         }
 507
 508         while (c)
 509         {
 510                 target_event_callback_t *next = c->next;
 511                 if ((c->callback == callback) && (c->priv == priv))
 512                 {
 513                         *p = next;
 514                         free(c);
 515                         return ERROR_OK;
 516                 }
 517                 else
 518                         p = &(c->next);
 519                 c = next;
 520         }
 521
 522         return ERROR_OK;
 523 }
 524
 525 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
 526 {
 527         target_timer_callback_t **p = &target_timer_callbacks;
 528         target_timer_callback_t *c = target_timer_callbacks;
 529
 530         if (callback == NULL)
 531         {
 532                 return ERROR_INVALID_ARGUMENTS;
 533         }
 534
 535         while (c)
 536         {
 537                 target_timer_callback_t *next = c->next;
 538                 if ((c->callback == callback) && (c->priv == priv))
 539                 {
 540                         *p = next;
 541                         free(c);
 542                         return ERROR_OK;
 543                 }
 544                 else
 545                         p = &(c->next);
 546                 c = next;
 547         }
 548
 549         return ERROR_OK;
 550 }
 551
 552 int target_call_event_callbacks(target_t *target, enum target_event event)
 553 {
 554         target_event_callback_t *callback = target_event_callbacks;
 555         target_event_callback_t *next_callback;
 556
 557         DEBUG("target event %i", event);
 558
 559         while (callback)
 560         {
 561                 next_callback = callback->next;
 562                 callback->callback(target, event, callback->priv);
 563                 callback = next_callback;
 564         }
 565
 566         return ERROR_OK;
 567 }
 568
 569 int target_call_timer_callbacks()
 570 {
 571         target_timer_callback_t *callback = target_timer_callbacks;
 572         target_timer_callback_t *next_callback;
 573         struct timeval now;
 574
 575         gettimeofday(&now, NULL);
 576
 577         while (callback)
 578         {
 579                 next_callback = callback->next;
 580
 581                 if (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
 582                         || (now.tv_sec > callback->when.tv_sec))
 583                 {
 584                         callback->callback(callback->priv);
 585                         if (callback->periodic)
 586                         {
 587                                 int time_ms = callback->time_ms;
 588                                 callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
 589                                 time_ms -= (time_ms % 1000);
 590                                 callback->when.tv_sec = now.tv_sec + time_ms / 1000;
 591                                 if (callback->when.tv_usec > 1000000)
 592                                 {
 593                                         callback->when.tv_usec = callback->when.tv_usec - 1000000;
 594                                         callback->when.tv_sec += 1;
 595                                 }
 596                         }
 597                         else
 598                                 target_unregister_timer_callback(callback->callback, callback->priv);
 599                 }
 600
 601                 callback = next_callback;
 602         }
 603
 604         return ERROR_OK;
 605 }
 606
 607 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
 608 {
 609         working_area_t *c = target->working_areas;
 610         working_area_t *new_wa = NULL;
 611
 612         /* Reevaluate working area address based on MMU state*/
 613         if (target->working_areas == NULL)
 614         {
 615                 int retval;
 616                 int enabled;
 617                 retval = target->type->mmu(target, &enabled);
 618                 if (retval != ERROR_OK)
 619                 {
 620                         return retval;
 621                 }
 622                 if (enabled)
 623                 {
 624                         target->working_area = target->working_area_virt;
 625                 }
 626                 else
 627                 {
 628                         target->working_area = target->working_area_phys;
 629                 }
 630         }
 631
 632         /* only allocate multiples of 4 byte */
 633         if (size % 4)
 634         {
 635                 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
 636                 size = CEIL(size, 4);
 637         }
 638
 639         /* see if there's already a matching working area */
 640         while (c)
 641         {
 642                 if ((c->free) && (c->size == size))
 643                 {
 644                         new_wa = c;
 645                         break;
 646                 }
 647                 c = c->next;
 648         }
 649
 650         /* if not, allocate a new one */
 651         if (!new_wa)
 652         {
 653                 working_area_t **p = &target->working_areas;
 654                 u32 first_free = target->working_area;
 655                 u32 free_size = target->working_area_size;
 656
 657                 DEBUG("allocating new working area");
 658
 659                 c = target->working_areas;
 660                 while (c)
 661                 {
 662                         first_free += c->size;
 663                         free_size -= c->size;
 664                         p = &c->next;
 665                         c = c->next;
 666                 }
 667
 668                 if (free_size < size)
 669                 {
 670                         WARNING("not enough working area available(requested %d, free %d)", size, free_size);
 671                         return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 672                 }
 673
 674                 new_wa = malloc(sizeof(working_area_t));
 675                 new_wa->next = NULL;
 676                 new_wa->size = size;
 677                 new_wa->address = first_free;
 678
 679                 if (target->backup_working_area)
 680                 {
 681                         new_wa->backup = malloc(new_wa->size);
 682                         target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup);
 683                 }
 684                 else
 685                 {
 686                         new_wa->backup = NULL;
 687                 }
 688
 689                 /* put new entry in list */
 690                 *p = new_wa;
 691         }
 692
 693         /* mark as used, and return the new (reused) area */
 694         new_wa->free = 0;
 695         *area = new_wa;
 696
 697         /* user pointer */
 698         new_wa->user = area;
 699
 700         return ERROR_OK;
 701 }
 702
 703 int target_free_working_area(struct target_s *target, working_area_t *area)
 704 {
 705         if (area->free)
 706                 return ERROR_OK;
 707
 708         if (target->backup_working_area)
 709                 target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
 710
 711         area->free = 1;
 712
 713         /* mark user pointer invalid */
 714         *area->user = NULL;
 715         area->user = NULL;
 716
 717         return ERROR_OK;
 718 }
 719
 720 int target_free_all_working_areas(struct target_s *target)
 721 {
 722         working_area_t *c = target->working_areas;
 723
 724         while (c)
 725         {
 726                 working_area_t *next = c->next;
 727                 target_free_working_area(target, c);
 728
 729                 if (c->backup)
 730                         free(c->backup);
 731
 732                 free(c);
 733
 734                 c = next;
 735         }
 736
 737         target->working_areas = NULL;
 738
 739         return ERROR_OK;
 740 }
 741
 742 int target_register_commands(struct command_context_s *cmd_ctx)
 743 {
 744         register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, NULL);
 745         register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
 746         register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG, NULL);
 747         register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL);
 748         register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, NULL);
 749         register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
 750         register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys <virtual address>");
 751
 752         return ERROR_OK;
 753 }
 754
 755 /* Single aligned words are guaranteed to use 16 or 32 bit access
 756  * mode respectively, otherwise data is handled as quickly as
 757  * possible
 758  */
 759 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
 760 {
 761         int retval;
 762
 763         DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
 764
 765         if (((address % 2) == 0) && (size == 2))
 766         {
 767                 return target->type->write_memory(target, address, 2, 1, buffer);
 768         }
 769
 770         /* handle unaligned head bytes */
 771         if (address % 4)
 772         {
 773                 int unaligned = 4 - (address % 4);
 774
 775                 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
 776                         return retval;
 777
 778                 buffer += unaligned;
 779                 address += unaligned;
 780                 size -= unaligned;
 781         }
 782
 783         /* handle aligned words */
 784         if (size >= 4)
 785         {
 786                 int aligned = size - (size % 4);
 787
 788                 /* use bulk writes above a certain limit. This may have to be changed */
 789                 if (aligned > 128)
 790                 {
 791                         if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
 792                                 return retval;
 793                 }
 794                 else
 795                 {
 796                         if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
 797                                 return retval;
 798                 }
 799
 800                 buffer += aligned;
 801                 address += aligned;
 802                 size -= aligned;
 803         }
 804
 805         /* handle tail writes of less than 4 bytes */
 806         if (size > 0)
 807         {
 808                 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
 809                         return retval;
 810         }
 811
 812         return ERROR_OK;
 813 }
 814
 815
 816 /* Single aligned words are guaranteed to use 16 or 32 bit access
 817  * mode respectively, otherwise data is handled as quickly as
 818  * possible
 819  */
 820 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
 821 {
 822         int retval;
 823
 824         DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
 825
 826         if (((address % 2) == 0) && (size == 2))
 827         {
 828                 return target->type->read_memory(target, address, 2, 1, buffer);
 829         }
 830
 831         /* handle unaligned head bytes */
 832         if (address % 4)
 833         {
 834                 int unaligned = 4 - (address % 4);
 835
 836                 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
 837                         return retval;
 838
 839                 buffer += unaligned;
 840                 address += unaligned;
 841                 size -= unaligned;
 842         }
 843
 844         /* handle aligned words */
 845         if (size >= 4)
 846         {
 847                 int aligned = size - (size % 4);
 848
 849                 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
 850                         return retval;
 851
 852                 buffer += aligned;
 853                 address += aligned;
 854                 size -= aligned;
 855         }
 856
 857         /* handle tail writes of less than 4 bytes */
 858         if (size > 0)
 859         {
 860                 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
 861                         return retval;
 862         }
 863
 864         return ERROR_OK;
 865 }
 866
 867 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
 868 {
 869         u8 *buffer;
 870         int retval;
 871         int i;
 872         u32 checksum = 0;
 873
 874         if ((retval = target->type->checksum_memory(target, address,
 875                 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
 876         {
 877                 buffer = malloc(size);
 878                 if (buffer == NULL)
 879                 {
 880                         ERROR("error allocating buffer for section (%d bytes)", size);
 881                         return ERROR_INVALID_ARGUMENTS;
 882                 }
 883                 retval = target_read_buffer(target, address, size, buffer);
 884                 if (retval != ERROR_OK)
 885                 {
 886                         free(buffer);
 887                         return retval;
 888                 }
 889
 890                 /* convert to target endianess */
 891                 for (i = 0; i < (size/sizeof(u32)); i++)
 892                 {
 893                         u32 target_data;
 894                         target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
 895                         target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
 896                 }
 897
 898                 retval = image_calculate_checksum( buffer, size, &checksum );
 899                 free(buffer);
 900         }
 901
 902         *crc = checksum;
 903
 904         return retval;
 905 }
 906
 907 int target_read_u32(struct target_s *target, u32 address, u32 *value)
 908 {
 909         u8 value_buf[4];
 910
 911         int retval = target->type->read_memory(target, address, 4, 1, value_buf);
 912
 913         if (retval == ERROR_OK)
 914         {
 915                 *value = target_buffer_get_u32(target, value_buf);
 916                 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
 917         }
 918         else
 919         {
 920                 *value = 0x0;
 921                 DEBUG("address: 0x%8.8x failed", address);
 922         }
 923
 924         return retval;
 925 }
 926
 927 int target_read_u16(struct target_s *target, u32 address, u16 *value)
 928 {
 929         u8 value_buf[2];
 930
 931         int retval = target->type->read_memory(target, address, 2, 1, value_buf);
 932
 933         if (retval == ERROR_OK)
 934         {
 935                 *value = target_buffer_get_u16(target, value_buf);
 936                 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
 937         }
 938         else
 939         {
 940                 *value = 0x0;
 941                 DEBUG("address: 0x%8.8x failed", address);
 942         }
 943
 944         return retval;
 945 }
 946
 947 int target_read_u8(struct target_s *target, u32 address, u8 *value)
 948 {
 949         int retval = target->type->read_memory(target, address, 1, 1, value);
 950
 951         if (retval == ERROR_OK)
 952         {
 953                 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
 954         }
 955         else
 956         {
 957                 *value = 0x0;
 958                 DEBUG("address: 0x%8.8x failed", address);
 959         }
 960
 961         return retval;
 962 }
 963
 964 int target_write_u32(struct target_s *target, u32 address, u32 value)
 965 {
 966         int retval;
 967         u8 value_buf[4];
 968
 969         DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
 970
 971         target_buffer_set_u32(target, value_buf, value);
 972         if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
 973         {
 974                 DEBUG("failed: %i", retval);
 975         }
 976
 977         return retval;
 978 }
 979
 980 int target_write_u16(struct target_s *target, u32 address, u16 value)
 981 {
 982         int retval;
 983         u8 value_buf[2];
 984
 985         DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
 986
 987         target_buffer_set_u16(target, value_buf, value);
 988         if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
 989         {
 990                 DEBUG("failed: %i", retval);
 991         }
 992
 993         return retval;
 994 }
 995
 996 int target_write_u8(struct target_s *target, u32 address, u8 value)
 997 {
 998         int retval;
 999
1000         DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
1001
1002         if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
1003         {
1004                 DEBUG("failed: %i", retval);
1005         }
1006
1007         return retval;
1008 }
1009
1010 int target_register_user_commands(struct command_context_s *cmd_ctx)
1011 {
1012         register_command(cmd_ctx,  NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
1013         register_command(cmd_ctx,  NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1014         register_command(cmd_ctx,  NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1015         register_command(cmd_ctx,  NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1016         register_command(cmd_ctx,  NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1017         register_command(cmd_ctx,  NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1018         register_command(cmd_ctx,  NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
1019         register_command(cmd_ctx,  NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1020
1021         register_command(cmd_ctx,  NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
1022         register_command(cmd_ctx,  NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
1023         register_command(cmd_ctx,  NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
1024
1025         register_command(cmd_ctx,  NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
1026         register_command(cmd_ctx,  NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
1027         register_command(cmd_ctx,  NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
1028
1029         register_command(cmd_ctx,  NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
1030         register_command(cmd_ctx,  NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
1031         register_command(cmd_ctx,  NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1032         register_command(cmd_ctx,  NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
1033
1034         register_command(cmd_ctx,  NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1035         register_command(cmd_ctx,  NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1036         register_command(cmd_ctx,  NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1037         register_command(cmd_ctx,  NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
1038         register_command(cmd_ctx,  NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
1039
1040         target_request_register_commands(cmd_ctx);
1041         trace_register_commands(cmd_ctx);
1042
1043         return ERROR_OK;
1044 }
1045
1046 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1047 {
1048         target_t *target = targets;
1049         int count = 0;
1050
1051         if (argc == 1)
1052         {
1053                 int num = strtoul(args[0], NULL, 0);
1054
1055                 while (target)
1056                 {
1057                         count++;
1058                         target = target->next;
1059                 }
1060
1061                 if (num < count)
1062                         cmd_ctx->current_target = num;
1063                 else
1064                         command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1065
1066                 return ERROR_OK;
1067         }
1068
1069         while (target)
1070         {
1071                 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1072                 target = target->next;
1073         }
1074
1075         return ERROR_OK;
1076 }
1077
1078 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1079 {
1080         int i;
1081         int found = 0;
1082
1083         if (argc < 3)
1084         {
1085                 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1086                 exit(-1);
1087         }
1088
1089         /* search for the specified target */
1090         if (args[0] && (args[0][0] != 0))
1091         {
1092                 for (i = 0; target_types[i]; i++)
1093                 {
1094                         if (strcmp(args[0], target_types[i]->name) == 0)
1095                         {
1096                                 target_t **last_target_p = &targets;
1097
1098                                 /* register target specific commands */
1099                                 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1100                                 {
1101                                         ERROR("couldn't register '%s' commands", args[0]);
1102                                         exit(-1);
1103                                 }
1104
1105                                 if (*last_target_p)
1106                                 {
1107                                         while ((*last_target_p)->next)
1108                                                 last_target_p = &((*last_target_p)->next);
1109                                         last_target_p = &((*last_target_p)->next);
1110                                 }
1111
1112                                 *last_target_p = malloc(sizeof(target_t));
1113
1114                                 (*last_target_p)->type = target_types[i];
1115
1116                                 if (strcmp(args[1], "big") == 0)
1117                                         (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1118                                 else if (strcmp(args[1], "little") == 0)
1119                                         (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1120                                 else
1121                                 {
1122                                         ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1123                                         exit(-1);
1124                                 }
1125
1126                                 /* what to do on a target reset */
1127                                 if (strcmp(args[2], "reset_halt") == 0)
1128                                         (*last_target_p)->reset_mode = RESET_HALT;
1129                                 else if (strcmp(args[2], "reset_run") == 0)
1130                                         (*last_target_p)->reset_mode = RESET_RUN;
1131                                 else if (strcmp(args[2], "reset_init") == 0)
1132                                         (*last_target_p)->reset_mode = RESET_INIT;
1133                                 else if (strcmp(args[2], "run_and_halt") == 0)
1134                                         (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1135                                 else if (strcmp(args[2], "run_and_init") == 0)
1136                                         (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1137                                 else
1138                                 {
1139                                         ERROR("unknown target startup mode %s", args[2]);
1140                                         exit(-1);
1141                                 }
1142                                 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1143
1144                                 (*last_target_p)->reset_script = NULL;
1145                                 (*last_target_p)->post_halt_script = NULL;
1146                                 (*last_target_p)->pre_resume_script = NULL;
1147                                 (*last_target_p)->gdb_program_script = NULL;
1148
1149                                 (*last_target_p)->working_area = 0x0;
1150                                 (*last_target_p)->working_area_size = 0x0;
1151                                 (*last_target_p)->working_areas = NULL;
1152                                 (*last_target_p)->backup_working_area = 0;
1153
1154                                 (*last_target_p)->state = TARGET_UNKNOWN;
1155                                 (*last_target_p)->reg_cache = NULL;
1156                                 (*last_target_p)->breakpoints = NULL;
1157                                 (*last_target_p)->watchpoints = NULL;
1158                                 (*last_target_p)->next = NULL;
1159                                 (*last_target_p)->arch_info = NULL;
1160
1161                                 /* initialize trace information */
1162                                 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1163                                 (*last_target_p)->trace_info->num_trace_points = 0;
1164                                 (*last_target_p)->trace_info->trace_points_size = 0;
1165                                 (*last_target_p)->trace_info->trace_points = NULL;
1166                                 (*last_target_p)->trace_info->trace_history_size = 0;
1167                                 (*last_target_p)->trace_info->trace_history = NULL;
1168                                 (*last_target_p)->trace_info->trace_history_pos = 0;
1169                                 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1170
1171                                 (*last_target_p)->dbgmsg = NULL;
1172                                 (*last_target_p)->dbg_msg_enabled = 0;
1173
1174                                 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1175
1176                                 found = 1;
1177                                 break;
1178                         }
1179                 }
1180         }
1181
1182         /* no matching target found */
1183         if (!found)
1184         {
1185                 ERROR("target '%s' not found", args[0]);
1186                 exit(-1);
1187         }
1188
1189         return ERROR_OK;
1190 }
1191
1192 /* usage: target_script <target#> <event> <script_file> */
1193 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1194 {
1195         target_t *target = NULL;
1196
1197         if (argc < 3)
1198         {
1199                 ERROR("incomplete target_script command");
1200                 exit(-1);
1201         }
1202
1203         target = get_target_by_num(strtoul(args[0], NULL, 0));
1204
1205         if (!target)
1206         {
1207                 ERROR("target number '%s' not defined", args[0]);
1208                 exit(-1);
1209         }
1210
1211         if (strcmp(args[1], "reset") == 0)
1212         {
1213                 if (target->reset_script)
1214                         free(target->reset_script);
1215                 target->reset_script = strdup(args[2]);
1216         }
1217         else if (strcmp(args[1], "post_halt") == 0)
1218         {
1219                 if (target->post_halt_script)
1220                         free(target->post_halt_script);
1221                 target->post_halt_script = strdup(args[2]);
1222         }
1223         else if (strcmp(args[1], "pre_resume") == 0)
1224         {
1225                 if (target->pre_resume_script)
1226                         free(target->pre_resume_script);
1227                 target->pre_resume_script = strdup(args[2]);
1228         }
1229         else if (strcmp(args[1], "gdb_program_config") == 0)
1230         {
1231                 if (target->gdb_program_script)
1232                         free(target->gdb_program_script);
1233                 target->gdb_program_script = strdup(args[2]);
1234         }
1235         else
1236         {
1237                 ERROR("unknown event type: '%s", args[1]);
1238                 exit(-1);
1239         }
1240
1241         return ERROR_OK;
1242 }
1243
1244 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1245 {
1246         target_t *target = NULL;
1247
1248         if (argc < 2)
1249         {
1250                 ERROR("incomplete run_and_halt_time command");
1251                 exit(-1);
1252         }
1253
1254         target = get_target_by_num(strtoul(args[0], NULL, 0));
1255
1256         if (!target)
1257         {
1258                 ERROR("target number '%s' not defined", args[0]);
1259                 exit(-1);
1260         }
1261
1262         target->run_and_halt_time = strtoul(args[1], NULL, 0);
1263
1264         return ERROR_OK;
1265 }
1266
1267 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1268 {
1269         target_t *target = NULL;
1270
1271         if ((argc < 4) || (argc > 5))
1272         {
1273                 return ERROR_COMMAND_SYNTAX_ERROR;
1274         }
1275
1276         target = get_target_by_num(strtoul(args[0], NULL, 0));
1277
1278         if (!target)
1279         {
1280                 ERROR("target number '%s' not defined", args[0]);
1281                 exit(-1);
1282         }
1283         target_free_all_working_areas(target);
1284
1285         target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1286         if (argc == 5)
1287         {
1288                 target->working_area_virt = strtoul(args[4], NULL, 0);
1289         }
1290         target->working_area_size = strtoul(args[2], NULL, 0);
1291
1292         if (strcmp(args[3], "backup") == 0)
1293         {
1294                 target->backup_working_area = 1;
1295         }
1296         else if (strcmp(args[3], "nobackup") == 0)
1297         {
1298                 target->backup_working_area = 0;
1299         }
1300         else
1301         {
1302                 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1303                 return ERROR_COMMAND_SYNTAX_ERROR;
1304         }
1305
1306         return ERROR_OK;
1307 }
1308
1309
1310 /* process target state changes */
1311 int handle_target(void *priv)
1312 {
1313         int retval;
1314         target_t *target = targets;
1315
1316         while (target)
1317         {
1318                 /* only poll if target isn't already halted */
1319                 if (target->state != TARGET_HALTED)
1320                 {
1321                         if (target_continous_poll)
1322                                 if ((retval = target->type->poll(target)) < 0)
1323                                 {
1324                                         ERROR("couldn't poll target. It's due for a reset.");
1325                                 }
1326                 }
1327
1328                 target = target->next;
1329         }
1330
1331         return ERROR_OK;
1332 }
1333
1334 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1335 {
1336         target_t *target;
1337         reg_t *reg = NULL;
1338         int count = 0;
1339         char *value;
1340
1341         DEBUG("-");
1342
1343         target = get_current_target(cmd_ctx);
1344
1345         /* list all available registers for the current target */
1346         if (argc == 0)
1347         {
1348                 reg_cache_t *cache = target->reg_cache;
1349
1350                 count = 0;
1351                 while(cache)
1352                 {
1353                         int i;
1354                         for (i = 0; i < cache->num_regs; i++)
1355                         {
1356                                 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1357                                 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);
1358                                 free(value);
1359                         }
1360                         cache = cache->next;
1361                 }
1362
1363                 return ERROR_OK;
1364         }
1365
1366         /* access a single register by its ordinal number */
1367         if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1368         {
1369                 int num = strtoul(args[0], NULL, 0);
1370                 reg_cache_t *cache = target->reg_cache;
1371
1372                 count = 0;
1373                 while(cache)
1374                 {
1375                         int i;
1376                         for (i = 0; i < cache->num_regs; i++)
1377                         {
1378                                 if (count++ == num)
1379                                 {
1380                                         reg = &cache->reg_list[i];
1381                                         break;
1382                                 }
1383                         }
1384                         if (reg)
1385                                 break;
1386                         cache = cache->next;
1387                 }
1388
1389                 if (!reg)
1390                 {
1391                         command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1392                         return ERROR_OK;
1393                 }
1394         } else /* access a single register by its name */
1395         {
1396                 reg = register_get_by_name(target->reg_cache, args[0], 1);
1397
1398                 if (!reg)
1399                 {
1400                         command_print(cmd_ctx, "register %s not found in current target", args[0]);
1401                         return ERROR_OK;
1402                 }
1403         }
1404
1405         /* display a register */
1406         if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1407         {
1408                 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1409                         reg->valid = 0;
1410
1411                 if (reg->valid == 0)
1412                 {
1413                         reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1414                         if (arch_type == NULL)
1415                         {
1416                                 ERROR("BUG: encountered unregistered arch type");
1417                                 return ERROR_OK;
1418                         }
1419                         arch_type->get(reg);
1420                 }
1421                 value = buf_to_str(reg->value, reg->size, 16);
1422                 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1423                 free(value);
1424                 return ERROR_OK;
1425         }
1426
1427         /* set register value */
1428         if (argc == 2)
1429         {
1430                 u8 *buf = malloc(CEIL(reg->size, 8));
1431                 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1432
1433                 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1434                 if (arch_type == NULL)
1435                 {
1436                         ERROR("BUG: encountered unregistered arch type");
1437                         return ERROR_OK;
1438                 }
1439
1440                 arch_type->set(reg, buf);
1441
1442                 value = buf_to_str(reg->value, reg->size, 16);
1443                 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1444                 free(value);
1445
1446                 free(buf);
1447
1448                 return ERROR_OK;
1449         }
1450
1451         command_print(cmd_ctx, "usage: reg <#|name> [value]");
1452
1453         return ERROR_OK;
1454 }
1455
1456 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1457
1458 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1459 {
1460         target_t *target = get_current_target(cmd_ctx);
1461         char buffer[512];
1462
1463         if (argc == 0)
1464         {
1465                 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1466                 if (target->state == TARGET_HALTED)
1467                 {
1468                         target->type->arch_state(target, buffer, 512);
1469                         buffer[511] = 0;
1470                         command_print(cmd_ctx, "%s", buffer);
1471                 }
1472         }
1473         else
1474         {
1475                 if (strcmp(args[0], "on") == 0)
1476                 {
1477                         target_continous_poll = 1;
1478                 }
1479                 else if (strcmp(args[0], "off") == 0)
1480                 {
1481                         target_continous_poll = 0;
1482                 }
1483                 else
1484                 {
1485                         command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1486                 }
1487         }
1488
1489
1490         return ERROR_OK;
1491 }
1492
1493 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1494 {
1495         int ms = 5000;
1496
1497         if (argc > 0)
1498         {
1499                 char *end;
1500
1501                 ms = strtoul(args[0], &end, 0) * 1000;
1502                 if (*end)
1503                 {
1504                         command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1505                         return ERROR_OK;
1506                 }
1507         }
1508
1509         return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1510 }
1511
1512 static void target_process_events(struct command_context_s *cmd_ctx)
1513 {
1514         target_t *target = get_current_target(cmd_ctx);
1515         target->type->poll(target);
1516         target_call_timer_callbacks();
1517 }
1518
1519 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1520 {
1521         struct timeval timeout, now;
1522
1523         gettimeofday(&timeout, NULL);
1524         timeval_add_time(&timeout, 0, ms * 1000);
1525         command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1526
1527         target_t *target = get_current_target(cmd_ctx);
1528         while (target->type->poll(target))
1529         {
1530                 target_call_timer_callbacks();
1531                 if (target->state == state)
1532                 {
1533                         command_print(cmd_ctx, "target %s", target_state_strings[state]);
1534                         break;
1535                 }
1536
1537                 gettimeofday(&now, NULL);
1538                 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1539                 {
1540                         command_print(cmd_ctx, "timed out while waiting for target %s", target_state_strings[state]);
1541                         ERROR("timed out while waiting for target %s", target_state_strings[state]);
1542                         break;
1543                 }
1544         }
1545
1546         return ERROR_OK;
1547 }
1548
1549 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1550 {
1551         int retval;
1552         target_t *target = get_current_target(cmd_ctx);
1553
1554         DEBUG("-");
1555
1556         command_print(cmd_ctx, "requesting target halt...");
1557
1558         if ((retval = target->type->halt(target)) != ERROR_OK)
1559         {
1560                 switch (retval)
1561                 {
1562                         case ERROR_TARGET_ALREADY_HALTED:
1563                                 command_print(cmd_ctx, "target already halted");
1564                                 break;
1565                         case ERROR_TARGET_TIMEOUT:
1566                                 command_print(cmd_ctx, "target timed out... shutting down");
1567                                 return retval;
1568                         default:
1569                                 command_print(cmd_ctx, "unknown error... shutting down");
1570                                 return retval;
1571                 }
1572         }
1573
1574         return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1575 }
1576
1577 /* what to do on daemon startup */
1578 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1579 {
1580         if (argc == 1)
1581         {
1582                 if (strcmp(args[0], "attach") == 0)
1583                 {
1584                         startup_mode = DAEMON_ATTACH;
1585                         return ERROR_OK;
1586                 }
1587                 else if (strcmp(args[0], "reset") == 0)
1588                 {
1589                         startup_mode = DAEMON_RESET;
1590                         return ERROR_OK;
1591                 }
1592         }
1593
1594         WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1595         return ERROR_OK;
1596
1597 }
1598
1599 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1600 {
1601         target_t *target = get_current_target(cmd_ctx);
1602         int retval;
1603
1604         command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1605
1606         if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1607         {
1608                 switch (retval)
1609                 {
1610                         case ERROR_TARGET_TIMEOUT:
1611                                 command_print(cmd_ctx, "target timed out... shutting down");
1612                                 exit(-1);
1613                         default:
1614                                 command_print(cmd_ctx, "unknown error... shutting down");
1615                                 exit(-1);
1616                 }
1617         }
1618
1619         return ERROR_OK;
1620 }
1621
1622 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1623 {
1624         target_t *target = get_current_target(cmd_ctx);
1625         enum target_reset_mode reset_mode = target->reset_mode;
1626         enum target_reset_mode save = target->reset_mode;
1627
1628         DEBUG("-");
1629
1630         if (argc >= 1)
1631         {
1632                 if (strcmp("run", args[0]) == 0)
1633                         reset_mode = RESET_RUN;
1634                 else if (strcmp("halt", args[0]) == 0)
1635                         reset_mode = RESET_HALT;
1636                 else if (strcmp("init", args[0]) == 0)
1637                         reset_mode = RESET_INIT;
1638                 else if (strcmp("run_and_halt", args[0]) == 0)
1639                 {
1640                         reset_mode = RESET_RUN_AND_HALT;
1641                         if (argc >= 2)
1642                         {
1643                                 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1644                         }
1645                 }
1646                 else if (strcmp("run_and_init", args[0]) == 0)
1647                 {
1648                         reset_mode = RESET_RUN_AND_INIT;
1649                         if (argc >= 2)
1650                         {
1651                                 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1652                         }
1653                 }
1654                 else
1655                 {
1656                         command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1657                         return ERROR_OK;
1658                 }
1659         }
1660
1661         /* temporarily modify mode of current reset target */
1662         target->reset_mode = reset_mode;
1663
1664         /* reset *all* targets */
1665         target_process_reset(cmd_ctx);
1666
1667         /* Restore default reset mode for this target */
1668     target->reset_mode = save;
1669
1670         return ERROR_OK;
1671 }
1672
1673 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1674 {
1675         int retval;
1676         target_t *target = get_current_target(cmd_ctx);
1677
1678         DEBUG("-");
1679
1680         if (argc == 0)
1681                 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1682         else if (argc == 1)
1683                 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1684         else
1685         {
1686                 command_print(cmd_ctx, "usage: resume [address]");
1687                 return ERROR_OK;
1688         }
1689
1690         if (retval != ERROR_OK)
1691         {
1692                 switch (retval)
1693                 {
1694                         case ERROR_TARGET_NOT_HALTED:
1695                                 command_print(cmd_ctx, "target not halted");
1696                                 break;
1697                         default:
1698                                 command_print(cmd_ctx, "unknown error... shutting down");
1699                                 exit(-1);
1700                 }
1701         }
1702
1703         target_process_events(cmd_ctx);
1704
1705         return ERROR_OK;
1706 }
1707
1708 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1709 {
1710         target_t *target = get_current_target(cmd_ctx);
1711
1712         DEBUG("-");
1713
1714         if (argc == 0)
1715                 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1716
1717         if (argc == 1)
1718                 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1719
1720         return ERROR_OK;
1721 }
1722
1723 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1724 {
1725         const int line_bytecnt = 32;
1726         int count = 1;
1727         int size = 4;
1728         u32 address = 0;
1729         int line_modulo;
1730         int i;
1731
1732         char output[128];
1733         int output_len;
1734
1735         int retval;
1736
1737         u8 *buffer;
1738         target_t *target = get_current_target(cmd_ctx);
1739
1740         if (argc < 1)
1741                 return ERROR_OK;
1742
1743         if (argc == 2)
1744                 count = strtoul(args[1], NULL, 0);
1745
1746         address = strtoul(args[0], NULL, 0);
1747
1748
1749         switch (cmd[2])
1750         {
1751                 case 'w':
1752                         size = 4; line_modulo = line_bytecnt / 4;
1753                         break;
1754                 case 'h':
1755                         size = 2; line_modulo = line_bytecnt / 2;
1756                         break;
1757                 case 'b':
1758                         size = 1; line_modulo = line_bytecnt / 1;
1759                         break;
1760                 default:
1761                         return ERROR_OK;
1762         }
1763
1764         buffer = calloc(count, size);
1765         retval  = target->type->read_memory(target, address, size, count, buffer);
1766         if (retval != ERROR_OK)
1767         {
1768                 switch (retval)
1769                 {
1770                         case ERROR_TARGET_UNALIGNED_ACCESS:
1771                                 command_print(cmd_ctx, "error: address not aligned");
1772                                 break;
1773                         case ERROR_TARGET_NOT_HALTED:
1774                                 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1775                                 break;
1776                         case ERROR_TARGET_DATA_ABORT:
1777                                 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1778                                 break;
1779                         default:
1780                                 command_print(cmd_ctx, "error: unknown error");
1781                                 break;
1782                 }
1783                 return ERROR_OK;
1784         }
1785
1786         output_len = 0;
1787
1788         for (i = 0; i < count; i++)
1789         {
1790                 if (i%line_modulo == 0)
1791                         output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1792
1793                 switch (size)
1794                 {
1795                         case 4:
1796                                 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1797                                 break;
1798                         case 2:
1799                                 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1800                                 break;
1801                         case 1:
1802                                 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1803                                 break;
1804                 }
1805
1806                 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1807                 {
1808                         command_print(cmd_ctx, output);
1809                         output_len = 0;
1810                 }
1811         }
1812
1813         free(buffer);
1814
1815         return ERROR_OK;
1816 }
1817
1818 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1819 {
1820         u32 address = 0;
1821         u32 value = 0;
1822         int retval;
1823         target_t *target = get_current_target(cmd_ctx);
1824         u8 value_buf[4];
1825
1826         if (argc < 2)
1827                 return ERROR_OK;
1828
1829         address = strtoul(args[0], NULL, 0);
1830         value = strtoul(args[1], NULL, 0);
1831
1832         switch (cmd[2])
1833         {
1834                 case 'w':
1835                         target_buffer_set_u32(target, value_buf, value);
1836                         retval = target->type->write_memory(target, address, 4, 1, value_buf);
1837                         break;
1838                 case 'h':
1839                         target_buffer_set_u16(target, value_buf, value);
1840                         retval = target->type->write_memory(target, address, 2, 1, value_buf);
1841                         break;
1842                 case 'b':
1843                         value_buf[0] = value;
1844                         retval = target->type->write_memory(target, address, 1, 1, value_buf);
1845                         break;
1846                 default:
1847                         return ERROR_OK;
1848         }
1849
1850         switch (retval)
1851         {
1852                 case ERROR_TARGET_UNALIGNED_ACCESS:
1853                         command_print(cmd_ctx, "error: address not aligned");
1854                         break;
1855                 case ERROR_TARGET_DATA_ABORT:
1856                         command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1857                         break;
1858                 case ERROR_TARGET_NOT_HALTED:
1859                         command_print(cmd_ctx, "error: target must be halted for memory accesses");
1860                         break;
1861                 case ERROR_OK:
1862                         break;
1863                 default:
1864                         command_print(cmd_ctx, "error: unknown error");
1865                         break;
1866         }
1867
1868         return ERROR_OK;
1869
1870 }
1871
1872 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1873 {
1874         u8 *buffer;
1875         u32 buf_cnt;
1876         u32 image_size;
1877         int i;
1878         int retval;
1879
1880         image_t image;
1881
1882         duration_t duration;
1883         char *duration_text;
1884
1885         target_t *target = get_current_target(cmd_ctx);
1886
1887         if (argc < 1)
1888         {
1889                 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1890                 return ERROR_OK;
1891         }
1892
1893         /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1894         if (argc >= 2)
1895         {
1896                 image.base_address_set = 1;
1897                 image.base_address = strtoul(args[1], NULL, 0);
1898         }
1899         else
1900         {
1901                 image.base_address_set = 0;
1902         }
1903
1904         image.start_address_set = 0;
1905
1906         duration_start_measure(&duration);
1907
1908         if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1909         {
1910                 command_print(cmd_ctx, "load_image error: %s", image.error_str);
1911                 return ERROR_OK;
1912         }
1913
1914         image_size = 0x0;
1915         for (i = 0; i < image.num_sections; i++)
1916         {
1917                 buffer = malloc(image.sections[i].size);
1918                 if (buffer == NULL)
1919                 {
1920                         command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1921                         break;
1922                 }
1923
1924                 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1925                 {
1926                         ERROR("image_read_section failed with error code: %i", retval);
1927                         command_print(cmd_ctx, "image reading failed, download aborted");
1928                         free(buffer);
1929                         image_close(&image);
1930                         return ERROR_OK;
1931                 }
1932                 target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer);
1933                 image_size += buf_cnt;
1934                 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1935
1936                 free(buffer);
1937         }
1938
1939         duration_stop_measure(&duration, &duration_text);
1940         command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1941         free(duration_text);
1942
1943         image_close(&image);
1944
1945         return ERROR_OK;
1946
1947 }
1948
1949 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1950 {
1951         fileio_t fileio;
1952
1953         u32 address;
1954         u32 size;
1955         u8 buffer[560];
1956         int retval;
1957
1958         duration_t duration;
1959         char *duration_text;
1960
1961         target_t *target = get_current_target(cmd_ctx);
1962
1963         if (argc != 3)
1964         {
1965                 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1966                 return ERROR_OK;
1967         }
1968
1969         address = strtoul(args[1], NULL, 0);
1970         size = strtoul(args[2], NULL, 0);
1971
1972         if ((address & 3) || (size & 3))
1973         {
1974                 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1975                 return ERROR_OK;
1976         }
1977
1978         if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
1979         {
1980                 command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
1981                 return ERROR_OK;
1982         }
1983
1984         duration_start_measure(&duration);
1985
1986         while (size > 0)
1987         {
1988                 u32 size_written;
1989                 u32 this_run_size = (size > 560) ? 560 : size;
1990
1991                 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1992                 if (retval != ERROR_OK)
1993                 {
1994                         command_print(cmd_ctx, "Reading memory failed %d", retval);
1995                         break;
1996                 }
1997
1998                 fileio_write(&fileio, this_run_size, buffer, &size_written);
1999
2000                 size -= this_run_size;
2001                 address += this_run_size;
2002         }
2003
2004         fileio_close(&fileio);
2005
2006         duration_stop_measure(&duration, &duration_text);
2007         command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2008         free(duration_text);
2009
2010         return ERROR_OK;
2011 }
2012
2013 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2014 {
2015         u8 *buffer;
2016         u32 buf_cnt;
2017         u32 image_size;
2018         int i;
2019         int retval;
2020         u32 checksum = 0;
2021         u32 mem_checksum = 0;
2022
2023         image_t image;
2024
2025         duration_t duration;
2026         char *duration_text;
2027
2028         target_t *target = get_current_target(cmd_ctx);
2029
2030         if (argc < 1)
2031         {
2032                 command_print(cmd_ctx, "usage: verify_image <file> [offset] [type]");
2033                 return ERROR_OK;
2034         }
2035
2036         if (!target)
2037         {
2038                 ERROR("no target selected");
2039                 return ERROR_OK;
2040         }
2041
2042         duration_start_measure(&duration);
2043
2044         if (argc >= 2)
2045         {
2046                 image.base_address_set = 1;
2047                 image.base_address = strtoul(args[1], NULL, 0);
2048         }
2049         else
2050         {
2051                 image.base_address_set = 0;
2052                 image.base_address = 0x0;
2053         }
2054
2055         image.start_address_set = 0;
2056
2057         if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK)
2058         {
2059                 command_print(cmd_ctx, "verify_image error: %s", image.error_str);
2060                 return ERROR_OK;
2061         }
2062
2063         image_size = 0x0;
2064         for (i = 0; i < image.num_sections; i++)
2065         {
2066                 buffer = malloc(image.sections[i].size);
2067                 if (buffer == NULL)
2068                 {
2069                         command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2070                         break;
2071                 }
2072                 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2073                 {
2074                         ERROR("image_read_section failed with error code: %i", retval);
2075                         command_print(cmd_ctx, "image reading failed, verify aborted");
2076                         free(buffer);
2077                         image_close(&image);
2078                         return ERROR_OK;
2079                 }
2080
2081                 /* calculate checksum of image */
2082                 image_calculate_checksum( buffer, buf_cnt, &checksum );
2083
2084                 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2085
2086                 if( retval != ERROR_OK )
2087                 {
2088                         command_print(cmd_ctx, "could not calculate checksum, verify aborted");
2089                         free(buffer);
2090                         image_close(&image);
2091                         return ERROR_OK;
2092                 }
2093
2094                 if( checksum != mem_checksum )
2095                 {
2096                         /* failed crc checksum, fall back to a binary compare */
2097                         u8 *data;
2098
2099                         command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2100
2101                         data = (u8*)malloc(buf_cnt);
2102
2103                         /* Can we use 32bit word accesses? */
2104                         int size = 1;
2105                         int count = buf_cnt;
2106                         if ((count % 4) == 0)
2107                         {
2108                                 size *= 4;
2109                                 count /= 4;
2110                         }
2111                         retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2112
2113                         if (retval == ERROR_OK)
2114                         {
2115                                 int t;
2116                                 for (t = 0; t < buf_cnt; t++)
2117                                 {
2118                                         if (data[t] != buffer[t])
2119                                         {
2120                                                 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]);
2121                                                 free(data);
2122                                                 free(buffer);
2123                                                 image_close(&image);
2124                                                 return ERROR_OK;
2125                                         }
2126                                 }
2127                         }
2128
2129                         free(data);
2130                 }
2131
2132                 free(buffer);
2133                 image_size += buf_cnt;
2134         }
2135
2136         duration_stop_measure(&duration, &duration_text);
2137         command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2138         free(duration_text);
2139
2140         image_close(&image);
2141
2142         return ERROR_OK;
2143 }
2144
2145 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2146 {
2147         int retval;
2148         target_t *target = get_current_target(cmd_ctx);
2149
2150         if (argc == 0)
2151         {
2152                 breakpoint_t *breakpoint = target->breakpoints;
2153
2154                 while (breakpoint)
2155                 {
2156                         if (breakpoint->type == BKPT_SOFT)
2157                         {
2158                                 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2159                                 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2160                                 free(buf);
2161                         }
2162                         else
2163                         {
2164                                 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2165                         }
2166                         breakpoint = breakpoint->next;
2167                 }
2168         }
2169         else if (argc >= 2)
2170         {
2171                 int hw = BKPT_SOFT;
2172                 u32 length = 0;
2173
2174                 length = strtoul(args[1], NULL, 0);
2175
2176                 if (argc >= 3)
2177                         if (strcmp(args[2], "hw") == 0)
2178                                 hw = BKPT_HARD;
2179
2180                 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2181                 {
2182                         switch (retval)
2183                         {
2184                                 case ERROR_TARGET_NOT_HALTED:
2185                                         command_print(cmd_ctx, "target must be halted to set breakpoints");
2186                                         break;
2187                                 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2188                                         command_print(cmd_ctx, "no more breakpoints available");
2189                                         break;
2190                                 default:
2191                                         command_print(cmd_ctx, "unknown error, breakpoint not set");
2192                                         break;
2193                         }
2194                 }
2195                 else
2196                 {
2197                         command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2198                 }
2199         }
2200         else
2201         {
2202                 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2203         }
2204
2205         return ERROR_OK;
2206 }
2207
2208 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2209 {
2210         target_t *target = get_current_target(cmd_ctx);
2211
2212         if (argc > 0)
2213                 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2214
2215         return ERROR_OK;
2216 }
2217
2218 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2219 {
2220         target_t *target = get_current_target(cmd_ctx);
2221         int retval;
2222
2223         if (argc == 0)
2224         {
2225                 watchpoint_t *watchpoint = target->watchpoints;
2226
2227                 while (watchpoint)
2228                 {
2229                         command_print(cmd_ctx, "address: 0x%8.8x, mask: 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);
2230                         watchpoint = watchpoint->next;
2231                 }
2232         }
2233         else if (argc >= 2)
2234         {
2235                 enum watchpoint_rw type = WPT_ACCESS;
2236                 u32 data_value = 0x0;
2237                 u32 data_mask = 0xffffffff;
2238
2239                 if (argc >= 3)
2240                 {
2241                         switch(args[2][0])
2242                         {
2243                                 case 'r':
2244                                         type = WPT_READ;
2245                                         break;
2246                                 case 'w':
2247                                         type = WPT_WRITE;
2248                                         break;
2249                                 case 'a':
2250                                         type = WPT_ACCESS;
2251                                         break;
2252                                 default:
2253                                         command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2254                                         return ERROR_OK;
2255                         }
2256                 }
2257                 if (argc >= 4)
2258                 {
2259                         data_value = strtoul(args[3], NULL, 0);
2260                 }
2261                 if (argc >= 5)
2262                 {
2263                         data_mask = strtoul(args[4], NULL, 0);
2264                 }
2265
2266                 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2267                                 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2268                 {
2269                         switch (retval)
2270                         {
2271                                 case ERROR_TARGET_NOT_HALTED:
2272                                         command_print(cmd_ctx, "target must be halted to set watchpoints");
2273                                         break;
2274                                 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2275                                         command_print(cmd_ctx, "no more watchpoints available");
2276                                         break;
2277                                 default:
2278                                         command_print(cmd_ctx, "unknown error, watchpoint not set");
2279                                         break;
2280                         }
2281                 }
2282         }
2283         else
2284         {
2285                 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2286         }
2287
2288         return ERROR_OK;
2289 }
2290
2291 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2292 {
2293         target_t *target = get_current_target(cmd_ctx);
2294
2295         if (argc > 0)
2296                 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2297
2298         return ERROR_OK;
2299 }
2300
2301 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2302 {
2303         int retval;
2304         target_t *target = get_current_target(cmd_ctx);
2305         u32 va;
2306         u32 pa;
2307
2308         if (argc != 1)
2309         {
2310                 return ERROR_COMMAND_SYNTAX_ERROR;
2311         }
2312         va = strtoul(args[0], NULL, 0);
2313
2314         retval = target->type->virt2phys(target, va, &pa);
2315         if (retval == ERROR_OK)
2316         {
2317                 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2318         }
2319         else
2320         {
2321                 /* lower levels will have logged a detailed error which is
2322                  * forwarded to telnet/GDB session.
2323                  */
2324         }
2325         return retval;
2326 }