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