Code Review / openocd.git / blob
? search:


c2fce59d61c986a1e03855eae112adc44f721020
[openocd.git] / src / target / target.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include "replacements.h"
28 #include "target.h"
29 #include "target_request.h"
30
31 #include "log.h"
32 #include "configuration.h"
33 #include "binarybuffer.h"
34 #include "jtag.h"
35
36 #include <string.h>
37 #include <stdlib.h>
38 #include <inttypes.h>
39
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <unistd.h>
43 #include <errno.h>
44
45 #include <sys/time.h>
46 #include <time.h>
47
48 #include <time_support.h>
49
50 #include <fileio.h>
51 #include <image.h>
52
53 int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
54
55 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
56 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
57
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 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
79 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
80 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
81
82
83 /* targets */
84 extern target_type_t arm7tdmi_target;
85 extern target_type_t arm720t_target;
86 extern target_type_t arm9tdmi_target;
87 extern target_type_t arm920t_target;
88 extern target_type_t arm966e_target;
89 extern target_type_t arm926ejs_target;
90 extern target_type_t feroceon_target;
91 extern target_type_t xscale_target;
92 extern target_type_t cortexm3_target;
93 extern target_type_t arm11_target;
94 extern target_type_t mips_m4k_target;
95
96 target_type_t *target_types[] =
97 {
98 &arm7tdmi_target,
99 &arm9tdmi_target,
100 &arm920t_target,
101 &arm720t_target,
102 &arm966e_target,
103 &arm926ejs_target,
104 &feroceon_target,
105 &xscale_target,
106 &cortexm3_target,
107 &arm11_target,
108 &mips_m4k_target,
109 NULL,
110 };
111
112 target_t *targets = NULL;
113 target_event_callback_t *target_event_callbacks = NULL;
114 target_timer_callback_t *target_timer_callbacks = NULL;
115
116 char *target_state_strings[] =
117 {
118 "unknown",
119 "running",
120 "halted",
121 "reset",
122 "debug_running",
123 };
124
125 char *target_debug_reason_strings[] =
126 {
127 "debug request", "breakpoint", "watchpoint",
128 "watchpoint and breakpoint", "single step",
129 "target not halted", "undefined"
130 };
131
132 char *target_endianess_strings[] =
133 {
134 "big endian",
135 "little endian",
136 };
137
138 static int target_continous_poll = 1;
139
140 /* read a u32 from a buffer in target memory endianness */
141 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
142 {
143 if (target->endianness == TARGET_LITTLE_ENDIAN)
144 return le_to_h_u32(buffer);
145 else
146 return be_to_h_u32(buffer);
147 }
148
149 /* read a u16 from a buffer in target memory endianness */
150 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
151 {
152 if (target->endianness == TARGET_LITTLE_ENDIAN)
153 return le_to_h_u16(buffer);
154 else
155 return be_to_h_u16(buffer);
156 }
157
158 /* write a u32 to a buffer in target memory endianness */
159 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
160 {
161 if (target->endianness == TARGET_LITTLE_ENDIAN)
162 h_u32_to_le(buffer, value);
163 else
164 h_u32_to_be(buffer, value);
165 }
166
167 /* write a u16 to a buffer in target memory endianness */
168 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
169 {
170 if (target->endianness == TARGET_LITTLE_ENDIAN)
171 h_u16_to_le(buffer, value);
172 else
173 h_u16_to_be(buffer, value);
174 }
175
176 /* returns a pointer to the n-th configured target */
177 target_t* get_target_by_num(int num)
178 {
179 target_t *target = targets;
180 int i = 0;
181
182 while (target)
183 {
184 if (num == i)
185 return target;
186 target = target->next;
187 i++;
188 }
189
190 return NULL;
191 }
192
193 int get_num_by_target(target_t *query_target)
194 {
195 target_t *target = targets;
196 int i = 0;
197
198 while (target)
199 {
200 if (target == query_target)
201 return i;
202 target = target->next;
203 i++;
204 }
205
206 return -1;
207 }
208
209 target_t* get_current_target(command_context_t *cmd_ctx)
210 {
211 target_t *target = get_target_by_num(cmd_ctx->current_target);
212
213 if (target == NULL)
214 {
215 LOG_ERROR("BUG: current_target out of bounds");
216 exit(-1);
217 }
218
219 return target;
220 }
221
222
223 int target_poll(struct target_s *target)
224 {
225 /* We can't poll until after examine */
226 if (!target->type->examined)
227 {
228 /* Fail silently lest we pollute the log */
229 return ERROR_FAIL;
230 }
231 return target->type->poll(target);
232 }
233
234 int target_halt(struct target_s *target)
235 {
236 /* We can't poll until after examine */
237 if (!target->type->examined)
238 {
239 LOG_ERROR("Target not examined yet");
240 return ERROR_FAIL;
241 }
242 return target->type->halt(target);
243 }
244
245 int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)
246 {
247 int retval;
248
249 /* We can't poll until after examine */
250 if (!target->type->examined)
251 {
252 LOG_ERROR("Target not examined yet");
253 return ERROR_FAIL;
254 }
255
256 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
257 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
258 * the application.
259 */
260 if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
261 return retval;
262
263 return retval;
264 }
265
266 int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
267 {
268 int retval = ERROR_OK;
269 target_t *target;
270
271 target = targets;
272 while (target)
273 {
274 target_invoke_script(cmd_ctx, target, "pre_reset");
275 target = target->next;
276 }
277
278 if ((retval = jtag_init_reset(cmd_ctx)) != ERROR_OK)
279 return retval;
280
281 keep_alive(); /* we might be running on a very slow JTAG clk */
282
283 /* First time this is executed after launching OpenOCD, it will read out
284 * the type of CPU, etc. and init Embedded ICE registers in host
285 * memory.
286 *
287 * It will also set up ICE registers in the target.
288 *
289 * However, if we assert TRST later, we need to set up the registers again.
290 *
291 * For the "reset halt/init" case we must only set up the registers here.
292 */
293 if ((retval = target_examine(cmd_ctx)) != ERROR_OK)
294 return retval;
295
296 keep_alive(); /* we might be running on a very slow JTAG clk */
297
298 target = targets;
299 while (target)
300 {
301 /* we have no idea what state the target is in, so we
302 * have to drop working areas
303 */
304 target_free_all_working_areas_restore(target, 0);
305 target->reset_halt=((reset_mode==RESET_HALT)||(reset_mode==RESET_INIT));
306 target->type->assert_reset(target);
307 target = target->next;
308 }
309 if ((retval = jtag_execute_queue()) != ERROR_OK)
310 {
311 LOG_WARNING("JTAG communication failed asserting reset.");
312 retval = ERROR_OK;
313 }
314
315 /* request target halt if necessary, and schedule further action */
316 target = targets;
317 while (target)
318 {
319 if (reset_mode!=RESET_RUN)
320 {
321 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
322 target_halt(target);
323 }
324 target = target->next;
325 }
326
327 if ((retval = jtag_execute_queue()) != ERROR_OK)
328 {
329 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
330 retval = ERROR_OK;
331 }
332
333 target = targets;
334 while (target)
335 {
336 target->type->deassert_reset(target);
337 /* We can fail to bring the target into the halted state */
338 target_poll(target);
339 if (target->reset_halt&&((target->state != TARGET_HALTED)))
340 {
341 LOG_WARNING("Failed to reset target into halted mode - issuing halt");
342 target->type->halt(target);
343 }
344
345 target = target->next;
346 }
347
348 if ((retval = jtag_execute_queue()) != ERROR_OK)
349 {
350 LOG_WARNING("JTAG communication failed while deasserting reset.");
351 retval = ERROR_OK;
352 }
353
354 if (jtag_reset_config & RESET_SRST_PULLS_TRST)
355 {
356 /* If TRST was asserted we need to set up registers again */
357 if ((retval = target_examine(cmd_ctx)) != ERROR_OK)
358 return retval;
359 }
360
361 LOG_DEBUG("Waiting for halted stated as appropriate");
362
363 if ((reset_mode == RESET_HALT) || (reset_mode == RESET_INIT))
364 {
365 target = targets;
366 while (target)
367 {
368 /* Wait for reset to complete, maximum 5 seconds. */
369 if (((retval=target_wait_state(target, TARGET_HALTED, 5000)))==ERROR_OK)
370 {
371 if (reset_mode == RESET_INIT)
372 target_invoke_script(cmd_ctx, target, "post_reset");
373 }
374 target = target->next;
375 }
376 }
377
378 /* We want any events to be processed before the prompt */
379 target_call_timer_callbacks_now();
380
381 return retval;
382 }
383
384 static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
385 {
386 *physical = virtual;
387 return ERROR_OK;
388 }
389
390 static int default_mmu(struct target_s *target, int *enabled)
391 {
392 *enabled = 0;
393 return ERROR_OK;
394 }
395
396 static int default_examine(struct command_context_s *cmd_ctx, struct target_s *target)
397 {
398 target->type->examined = 1;
399 return ERROR_OK;
400 }
401
402
403 /* Targets that correctly implement init+examine, i.e.
404 * no communication with target during init:
405 *
406 * XScale
407 */
408 int target_examine(struct command_context_s *cmd_ctx)
409 {
410 int retval = ERROR_OK;
411 target_t *target = targets;
412 while (target)
413 {
414 if ((retval = target->type->examine(cmd_ctx, target))!=ERROR_OK)
415 return retval;
416 target = target->next;
417 }
418 return retval;
419 }
420
421 static int target_write_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
422 {
423 if (!target->type->examined)
424 {
425 LOG_ERROR("Target not examined yet");
426 return ERROR_FAIL;
427 }
428 return target->type->write_memory_imp(target, address, size, count, buffer);
429 }
430
431 static int target_read_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
432 {
433 if (!target->type->examined)
434 {
435 LOG_ERROR("Target not examined yet");
436 return ERROR_FAIL;
437 }
438 return target->type->read_memory_imp(target, address, size, count, buffer);
439 }
440
441 static int target_soft_reset_halt_imp(struct target_s *target)
442 {
443 if (!target->type->examined)
444 {
445 LOG_ERROR("Target not examined yet");
446 return ERROR_FAIL;
447 }
448 return target->type->soft_reset_halt_imp(target);
449 }
450
451 static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, u32 entry_point, u32 exit_point, int timeout_ms, void *arch_info)
452 {
453 if (!target->type->examined)
454 {
455 LOG_ERROR("Target not examined yet");
456 return ERROR_FAIL;
457 }
458 return target->type->run_algorithm_imp(target, num_mem_params, mem_params, num_reg_params, reg_param, entry_point, exit_point, timeout_ms, arch_info);
459 }
460
461 int target_init(struct command_context_s *cmd_ctx)
462 {
463 target_t *target = targets;
464
465 while (target)
466 {
467 target->type->examined = 0;
468 if (target->type->examine == NULL)
469 {
470 target->type->examine = default_examine;
471 }
472
473 if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
474 {
475 LOG_ERROR("target '%s' init failed", target->type->name);
476 exit(-1);
477 }
478
479 /* Set up default functions if none are provided by target */
480 if (target->type->virt2phys == NULL)
481 {
482 target->type->virt2phys = default_virt2phys;
483 }
484 target->type->virt2phys = default_virt2phys;
485 /* a non-invasive way(in terms of patches) to add some code that
486 * runs before the type->write/read_memory implementation
487 */
488 target->type->write_memory_imp = target->type->write_memory;
489 target->type->write_memory = target_write_memory_imp;
490 target->type->read_memory_imp = target->type->read_memory;
491 target->type->read_memory = target_read_memory_imp;
492 target->type->soft_reset_halt_imp = target->type->soft_reset_halt;
493 target->type->soft_reset_halt = target_soft_reset_halt_imp;
494 target->type->run_algorithm_imp = target->type->run_algorithm;
495 target->type->run_algorithm = target_run_algorithm_imp;
496
497
498 if (target->type->mmu == NULL)
499 {
500 target->type->mmu = default_mmu;
501 }
502 target = target->next;
503 }
504
505 if (targets)
506 {
507 target_register_user_commands(cmd_ctx);
508 target_register_timer_callback(handle_target, 100, 1, NULL);
509 }
510
511 return ERROR_OK;
512 }
513
514 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
515 {
516 target_event_callback_t **callbacks_p = &target_event_callbacks;
517
518 if (callback == NULL)
519 {
520 return ERROR_INVALID_ARGUMENTS;
521 }
522
523 if (*callbacks_p)
524 {
525 while ((*callbacks_p)->next)
526 callbacks_p = &((*callbacks_p)->next);
527 callbacks_p = &((*callbacks_p)->next);
528 }
529
530 (*callbacks_p) = malloc(sizeof(target_event_callback_t));
531 (*callbacks_p)->callback = callback;
532 (*callbacks_p)->priv = priv;
533 (*callbacks_p)->next = NULL;
534
535 return ERROR_OK;
536 }
537
538 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
539 {
540 target_timer_callback_t **callbacks_p = &target_timer_callbacks;
541 struct timeval now;
542
543 if (callback == NULL)
544 {
545 return ERROR_INVALID_ARGUMENTS;
546 }
547
548 if (*callbacks_p)
549 {
550 while ((*callbacks_p)->next)
551 callbacks_p = &((*callbacks_p)->next);
552 callbacks_p = &((*callbacks_p)->next);
553 }
554
555 (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
556 (*callbacks_p)->callback = callback;
557 (*callbacks_p)->periodic = periodic;
558 (*callbacks_p)->time_ms = time_ms;
559
560 gettimeofday(&now, NULL);
561 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
562 time_ms -= (time_ms % 1000);
563 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
564 if ((*callbacks_p)->when.tv_usec > 1000000)
565 {
566 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
567 (*callbacks_p)->when.tv_sec += 1;
568 }
569
570 (*callbacks_p)->priv = priv;
571 (*callbacks_p)->next = NULL;
572
573 return ERROR_OK;
574 }
575
576 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
577 {
578 target_event_callback_t **p = &target_event_callbacks;
579 target_event_callback_t *c = target_event_callbacks;
580
581 if (callback == NULL)
582 {
583 return ERROR_INVALID_ARGUMENTS;
584 }
585
586 while (c)
587 {
588 target_event_callback_t *next = c->next;
589 if ((c->callback == callback) && (c->priv == priv))
590 {
591 *p = next;
592 free(c);
593 return ERROR_OK;
594 }
595 else
596 p = &(c->next);
597 c = next;
598 }
599
600 return ERROR_OK;
601 }
602
603 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
604 {
605 target_timer_callback_t **p = &target_timer_callbacks;
606 target_timer_callback_t *c = target_timer_callbacks;
607
608 if (callback == NULL)
609 {
610 return ERROR_INVALID_ARGUMENTS;
611 }
612
613 while (c)
614 {
615 target_timer_callback_t *next = c->next;
616 if ((c->callback == callback) && (c->priv == priv))
617 {
618 *p = next;
619 free(c);
620 return ERROR_OK;
621 }
622 else
623 p = &(c->next);
624 c = next;
625 }
626
627 return ERROR_OK;
628 }
629
630 int target_call_event_callbacks(target_t *target, enum target_event event)
631 {
632 target_event_callback_t *callback = target_event_callbacks;
633 target_event_callback_t *next_callback;
634
635 LOG_DEBUG("target event %i", event);
636
637 while (callback)
638 {
639 next_callback = callback->next;
640 callback->callback(target, event, callback->priv);
641 callback = next_callback;
642 }
643
644 return ERROR_OK;
645 }
646
647 static int target_call_timer_callbacks_check_time(int checktime)
648 {
649 target_timer_callback_t *callback = target_timer_callbacks;
650 target_timer_callback_t *next_callback;
651 struct timeval now;
652
653 keep_alive();
654
655 gettimeofday(&now, NULL);
656
657 while (callback)
658 {
659 next_callback = callback->next;
660
661 if ((!checktime&&callback->periodic)||
662 (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
663 || (now.tv_sec > callback->when.tv_sec)))
664 {
665 if(callback->callback != NULL)
666 {
667 callback->callback(callback->priv);
668 if (callback->periodic)
669 {
670 int time_ms = callback->time_ms;
671 callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
672 time_ms -= (time_ms % 1000);
673 callback->when.tv_sec = now.tv_sec + time_ms / 1000;
674 if (callback->when.tv_usec > 1000000)
675 {
676 callback->when.tv_usec = callback->when.tv_usec - 1000000;
677 callback->when.tv_sec += 1;
678 }
679 }
680 else
681 target_unregister_timer_callback(callback->callback, callback->priv);
682 }
683 }
684
685 callback = next_callback;
686 }
687
688 return ERROR_OK;
689 }
690
691 int target_call_timer_callbacks()
692 {
693 return target_call_timer_callbacks_check_time(1);
694 }
695
696 /* invoke periodic callbacks immediately */
697 int target_call_timer_callbacks_now()
698 {
699 return target_call_timer_callbacks(0);
700 }
701
702 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
703 {
704 working_area_t *c = target->working_areas;
705 working_area_t *new_wa = NULL;
706
707 /* Reevaluate working area address based on MMU state*/
708 if (target->working_areas == NULL)
709 {
710 int retval;
711 int enabled;
712 retval = target->type->mmu(target, &enabled);
713 if (retval != ERROR_OK)
714 {
715 return retval;
716 }
717 if (enabled)
718 {
719 target->working_area = target->working_area_virt;
720 }
721 else
722 {
723 target->working_area = target->working_area_phys;
724 }
725 }
726
727 /* only allocate multiples of 4 byte */
728 if (size % 4)
729 {
730 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
731 size = CEIL(size, 4);
732 }
733
734 /* see if there's already a matching working area */
735 while (c)
736 {
737 if ((c->free) && (c->size == size))
738 {
739 new_wa = c;
740 break;
741 }
742 c = c->next;
743 }
744
745 /* if not, allocate a new one */
746 if (!new_wa)
747 {
748 working_area_t **p = &target->working_areas;
749 u32 first_free = target->working_area;
750 u32 free_size = target->working_area_size;
751
752 LOG_DEBUG("allocating new working area");
753
754 c = target->working_areas;
755 while (c)
756 {
757 first_free += c->size;
758 free_size -= c->size;
759 p = &c->next;
760 c = c->next;
761 }
762
763 if (free_size < size)
764 {
765 LOG_WARNING("not enough working area available(requested %d, free %d)", size, free_size);
766 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
767 }
768
769 new_wa = malloc(sizeof(working_area_t));
770 new_wa->next = NULL;
771 new_wa->size = size;
772 new_wa->address = first_free;
773
774 if (target->backup_working_area)
775 {
776 new_wa->backup = malloc(new_wa->size);
777 target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup);
778 }
779 else
780 {
781 new_wa->backup = NULL;
782 }
783
784 /* put new entry in list */
785 *p = new_wa;
786 }
787
788 /* mark as used, and return the new (reused) area */
789 new_wa->free = 0;
790 *area = new_wa;
791
792 /* user pointer */
793 new_wa->user = area;
794
795 return ERROR_OK;
796 }
797
798 int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore)
799 {
800 if (area->free)
801 return ERROR_OK;
802
803 if (restore&&target->backup_working_area)
804 target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
805
806 area->free = 1;
807
808 /* mark user pointer invalid */
809 *area->user = NULL;
810 area->user = NULL;
811
812 return ERROR_OK;
813 }
814
815 int target_free_working_area(struct target_s *target, working_area_t *area)
816 {
817 return target_free_working_area_restore(target, area, 1);
818 }
819
820 int target_free_all_working_areas_restore(struct target_s *target, int restore)
821 {
822 working_area_t *c = target->working_areas;
823
824 while (c)
825 {
826 working_area_t *next = c->next;
827 target_free_working_area_restore(target, c, restore);
828
829 if (c->backup)
830 free(c->backup);
831
832 free(c);
833
834 c = next;
835 }
836
837 target->working_areas = NULL;
838
839 return ERROR_OK;
840 }
841
842 int target_free_all_working_areas(struct target_s *target)
843 {
844 return target_free_all_working_areas_restore(target, 1);
845 }
846
847 int target_register_commands(struct command_context_s *cmd_ctx)
848 {
849 register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
850 register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
851 register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
852 register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys <virtual address>");
853 register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "PRELIMINARY! - profile <seconds> <gmon.out>");
854
855
856 /* script procedures */
857 register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing");
858 register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values");
859 return ERROR_OK;
860 }
861
862 int target_arch_state(struct target_s *target)
863 {
864 int retval;
865 if (target==NULL)
866 {
867 LOG_USER("No target has been configured");
868 return ERROR_OK;
869 }
870
871 LOG_USER("target state: %s", target_state_strings[target->state]);
872
873 if (target->state!=TARGET_HALTED)
874 return ERROR_OK;
875
876 retval=target->type->arch_state(target);
877 return retval;
878 }
879
880 /* Single aligned words are guaranteed to use 16 or 32 bit access
881 * mode respectively, otherwise data is handled as quickly as
882 * possible
883 */
884 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
885 {
886 int retval;
887 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
888
889 if (!target->type->examined)
890 {
891 LOG_ERROR("Target not examined yet");
892 return ERROR_FAIL;
893 }
894
895 if (address+size<address)
896 {
897 /* GDB can request this when e.g. PC is 0xfffffffc*/
898 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address, size);
899 return ERROR_FAIL;
900 }
901
902 if (((address % 2) == 0) && (size == 2))
903 {
904 return target->type->write_memory(target, address, 2, 1, buffer);
905 }
906
907 /* handle unaligned head bytes */
908 if (address % 4)
909 {
910 int unaligned = 4 - (address % 4);
911
912 if (unaligned > size)
913 unaligned = size;
914
915 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
916 return retval;
917
918 buffer += unaligned;
919 address += unaligned;
920 size -= unaligned;
921 }
922
923 /* handle aligned words */
924 if (size >= 4)
925 {
926 int aligned = size - (size % 4);
927
928 /* use bulk writes above a certain limit. This may have to be changed */
929 if (aligned > 128)
930 {
931 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
932 return retval;
933 }
934 else
935 {
936 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
937 return retval;
938 }
939
940 buffer += aligned;
941 address += aligned;
942 size -= aligned;
943 }
944
945 /* handle tail writes of less than 4 bytes */
946 if (size > 0)
947 {
948 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
949 return retval;
950 }
951
952 return ERROR_OK;
953 }
954
955
956 /* Single aligned words are guaranteed to use 16 or 32 bit access
957 * mode respectively, otherwise data is handled as quickly as
958 * possible
959 */
960 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
961 {
962 int retval;
963 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
964
965 if (!target->type->examined)
966 {
967 LOG_ERROR("Target not examined yet");
968 return ERROR_FAIL;
969 }
970
971 if (address+size<address)
972 {
973 /* GDB can request this when e.g. PC is 0xfffffffc*/
974 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address, size);
975 return ERROR_FAIL;
976 }
977
978 if (((address % 2) == 0) && (size == 2))
979 {
980 return target->type->read_memory(target, address, 2, 1, buffer);
981 }
982
983 /* handle unaligned head bytes */
984 if (address % 4)
985 {
986 int unaligned = 4 - (address % 4);
987
988 if (unaligned > size)
989 unaligned = size;
990
991 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
992 return retval;
993
994 buffer += unaligned;
995 address += unaligned;
996 size -= unaligned;
997 }
998
999 /* handle aligned words */
1000 if (size >= 4)
1001 {
1002 int aligned = size - (size % 4);
1003
1004 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1005 return retval;
1006
1007 buffer += aligned;
1008 address += aligned;
1009 size -= aligned;
1010 }
1011
1012 /* handle tail writes of less than 4 bytes */
1013 if (size > 0)
1014 {
1015 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
1016 return retval;
1017 }
1018
1019 return ERROR_OK;
1020 }
1021
1022 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
1023 {
1024 u8 *buffer;
1025 int retval;
1026 int i;
1027 u32 checksum = 0;
1028 if (!target->type->examined)
1029 {
1030 LOG_ERROR("Target not examined yet");
1031 return ERROR_FAIL;
1032 }
1033
1034 if ((retval = target->type->checksum_memory(target, address,
1035 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
1036 {
1037 buffer = malloc(size);
1038 if (buffer == NULL)
1039 {
1040 LOG_ERROR("error allocating buffer for section (%d bytes)", size);
1041 return ERROR_INVALID_ARGUMENTS;
1042 }
1043 retval = target_read_buffer(target, address, size, buffer);
1044 if (retval != ERROR_OK)
1045 {
1046 free(buffer);
1047 return retval;
1048 }
1049
1050 /* convert to target endianess */
1051 for (i = 0; i < (size/sizeof(u32)); i++)
1052 {
1053 u32 target_data;
1054 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
1055 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
1056 }
1057
1058 retval = image_calculate_checksum( buffer, size, &checksum );
1059 free(buffer);
1060 }
1061
1062 *crc = checksum;
1063
1064 return retval;
1065 }
1066
1067 int target_blank_check_memory(struct target_s *target, u32 address, u32 size, u32* blank)
1068 {
1069 int retval;
1070 if (!target->type->examined)
1071 {
1072 LOG_ERROR("Target not examined yet");
1073 return ERROR_FAIL;
1074 }
1075
1076 if (target->type->blank_check_memory == 0)
1077 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1078
1079 retval = target->type->blank_check_memory(target, address, size, blank);
1080
1081 return retval;
1082 }
1083
1084 int target_read_u32(struct target_s *target, u32 address, u32 *value)
1085 {
1086 u8 value_buf[4];
1087 if (!target->type->examined)
1088 {
1089 LOG_ERROR("Target not examined yet");
1090 return ERROR_FAIL;
1091 }
1092
1093 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
1094
1095 if (retval == ERROR_OK)
1096 {
1097 *value = target_buffer_get_u32(target, value_buf);
1098 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
1099 }
1100 else
1101 {
1102 *value = 0x0;
1103 LOG_DEBUG("address: 0x%8.8x failed", address);
1104 }
1105
1106 return retval;
1107 }
1108
1109 int target_read_u16(struct target_s *target, u32 address, u16 *value)
1110 {
1111 u8 value_buf[2];
1112 if (!target->type->examined)
1113 {
1114 LOG_ERROR("Target not examined yet");
1115 return ERROR_FAIL;
1116 }
1117
1118 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
1119
1120 if (retval == ERROR_OK)
1121 {
1122 *value = target_buffer_get_u16(target, value_buf);
1123 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
1124 }
1125 else
1126 {
1127 *value = 0x0;
1128 LOG_DEBUG("address: 0x%8.8x failed", address);
1129 }
1130
1131 return retval;
1132 }
1133
1134 int target_read_u8(struct target_s *target, u32 address, u8 *value)
1135 {
1136 int retval = target->type->read_memory(target, address, 1, 1, value);
1137 if (!target->type->examined)
1138 {
1139 LOG_ERROR("Target not examined yet");
1140 return ERROR_FAIL;
1141 }
1142
1143 if (retval == ERROR_OK)
1144 {
1145 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
1146 }
1147 else
1148 {
1149 *value = 0x0;
1150 LOG_DEBUG("address: 0x%8.8x failed", address);
1151 }
1152
1153 return retval;
1154 }
1155
1156 int target_write_u32(struct target_s *target, u32 address, u32 value)
1157 {
1158 int retval;
1159 u8 value_buf[4];
1160 if (!target->type->examined)
1161 {
1162 LOG_ERROR("Target not examined yet");
1163 return ERROR_FAIL;
1164 }
1165
1166 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1167
1168 target_buffer_set_u32(target, value_buf, value);
1169 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1170 {
1171 LOG_DEBUG("failed: %i", retval);
1172 }
1173
1174 return retval;
1175 }
1176
1177 int target_write_u16(struct target_s *target, u32 address, u16 value)
1178 {
1179 int retval;
1180 u8 value_buf[2];
1181 if (!target->type->examined)
1182 {
1183 LOG_ERROR("Target not examined yet");
1184 return ERROR_FAIL;
1185 }
1186
1187 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1188
1189 target_buffer_set_u16(target, value_buf, value);
1190 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1191 {
1192 LOG_DEBUG("failed: %i", retval);
1193 }
1194
1195 return retval;
1196 }
1197
1198 int target_write_u8(struct target_s *target, u32 address, u8 value)
1199 {
1200 int retval;
1201 if (!target->type->examined)
1202 {
1203 LOG_ERROR("Target not examined yet");
1204 return ERROR_FAIL;
1205 }
1206
1207 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
1208
1209 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
1210 {
1211 LOG_DEBUG("failed: %i", retval);
1212 }
1213
1214 return retval;
1215 }
1216
1217 int target_register_user_commands(struct command_context_s *cmd_ctx)
1218 {
1219 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
1220 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1221 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1222 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1223 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1224 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1225 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init]");
1226 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1227
1228 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
1229 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
1230 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
1231
1232 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value> [count]");
1233 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value> [count]");
1234 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value> [count]");
1235
1236 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
1237 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
1238 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1239 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
1240
1241 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
1242 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1243 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1244
1245 target_request_register_commands(cmd_ctx);
1246 trace_register_commands(cmd_ctx);
1247
1248 return ERROR_OK;
1249 }
1250
1251 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1252 {
1253 target_t *target = targets;
1254 int count = 0;
1255
1256 if (argc == 1)
1257 {
1258 int num = strtoul(args[0], NULL, 0);
1259
1260 while (target)
1261 {
1262 count++;
1263 target = target->next;
1264 }
1265
1266 if (num < count)
1267 cmd_ctx->current_target = num;
1268 else
1269 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1270
1271 return ERROR_OK;
1272 }
1273
1274 while (target)
1275 {
1276 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1277 target = target->next;
1278 }
1279
1280 return ERROR_OK;
1281 }
1282
1283 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1284 {
1285 int i;
1286 int found = 0;
1287
1288 if (argc < 3)
1289 {
1290 return ERROR_COMMAND_SYNTAX_ERROR;
1291 }
1292
1293 /* search for the specified target */
1294 if (args[0] && (args[0][0] != 0))
1295 {
1296 for (i = 0; target_types[i]; i++)
1297 {
1298 if (strcmp(args[0], target_types[i]->name) == 0)
1299 {
1300 target_t **last_target_p = &targets;
1301
1302 /* register target specific commands */
1303 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1304 {
1305 LOG_ERROR("couldn't register '%s' commands", args[0]);
1306 exit(-1);
1307 }
1308
1309 if (*last_target_p)
1310 {
1311 while ((*last_target_p)->next)
1312 last_target_p = &((*last_target_p)->next);
1313 last_target_p = &((*last_target_p)->next);
1314 }
1315
1316 *last_target_p = malloc(sizeof(target_t));
1317
1318 /* allocate memory for each unique target type */
1319 (*last_target_p)->type = (target_type_t*)malloc(sizeof(target_type_t));
1320 *((*last_target_p)->type) = *target_types[i];
1321
1322 if (strcmp(args[1], "big") == 0)
1323 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1324 else if (strcmp(args[1], "little") == 0)
1325 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1326 else
1327 {
1328 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1329 return ERROR_COMMAND_SYNTAX_ERROR;
1330 }
1331
1332 if (strcmp(args[2], "reset_halt") == 0)
1333 {
1334 LOG_WARNING("reset_mode argument is obsolete.");
1335 return ERROR_COMMAND_SYNTAX_ERROR;
1336 }
1337 else if (strcmp(args[2], "reset_run") == 0)
1338 {
1339 LOG_WARNING("reset_mode argument is obsolete.");
1340 return ERROR_COMMAND_SYNTAX_ERROR;
1341 }
1342 else if (strcmp(args[2], "reset_init") == 0)
1343 {
1344 LOG_WARNING("reset_mode argument is obsolete.");
1345 return ERROR_COMMAND_SYNTAX_ERROR;
1346 }
1347 else if (strcmp(args[2], "run_and_halt") == 0)
1348 {
1349 LOG_WARNING("reset_mode argument is obsolete.");
1350 return ERROR_COMMAND_SYNTAX_ERROR;
1351 }
1352 else if (strcmp(args[2], "run_and_init") == 0)
1353 {
1354 LOG_WARNING("reset_mode argument is obsolete.");
1355 return ERROR_COMMAND_SYNTAX_ERROR;
1356 }
1357 else
1358 {
1359 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1360 args--;
1361 argc++;
1362 }
1363
1364 (*last_target_p)->working_area = 0x0;
1365 (*last_target_p)->working_area_size = 0x0;
1366 (*last_target_p)->working_areas = NULL;
1367 (*last_target_p)->backup_working_area = 0;
1368
1369 (*last_target_p)->state = TARGET_UNKNOWN;
1370 (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED;
1371 (*last_target_p)->reg_cache = NULL;
1372 (*last_target_p)->breakpoints = NULL;
1373 (*last_target_p)->watchpoints = NULL;
1374 (*last_target_p)->next = NULL;
1375 (*last_target_p)->arch_info = NULL;
1376
1377 /* initialize trace information */
1378 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1379 (*last_target_p)->trace_info->num_trace_points = 0;
1380 (*last_target_p)->trace_info->trace_points_size = 0;
1381 (*last_target_p)->trace_info->trace_points = NULL;
1382 (*last_target_p)->trace_info->trace_history_size = 0;
1383 (*last_target_p)->trace_info->trace_history = NULL;
1384 (*last_target_p)->trace_info->trace_history_pos = 0;
1385 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1386
1387 (*last_target_p)->dbgmsg = NULL;
1388 (*last_target_p)->dbg_msg_enabled = 0;
1389
1390 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1391
1392 found = 1;
1393 break;
1394 }
1395 }
1396 }
1397
1398 /* no matching target found */
1399 if (!found)
1400 {
1401 LOG_ERROR("target '%s' not found", args[0]);
1402 return ERROR_COMMAND_SYNTAX_ERROR;
1403 }
1404
1405 return ERROR_OK;
1406 }
1407
1408 int target_invoke_script(struct command_context_s *cmd_ctx, target_t *target, char *name)
1409 {
1410 return command_run_linef(cmd_ctx, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}",
1411 get_num_by_target(target), name,
1412 get_num_by_target(target), name);
1413 }
1414
1415 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1416 {
1417 target_t *target = NULL;
1418
1419 if ((argc < 4) || (argc > 5))
1420 {
1421 return ERROR_COMMAND_SYNTAX_ERROR;
1422 }
1423
1424 target = get_target_by_num(strtoul(args[0], NULL, 0));
1425 if (!target)
1426 {
1427 return ERROR_COMMAND_SYNTAX_ERROR;
1428 }
1429 target_free_all_working_areas(target);
1430
1431 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1432 if (argc == 5)
1433 {
1434 target->working_area_virt = strtoul(args[4], NULL, 0);
1435 }
1436 target->working_area_size = strtoul(args[2], NULL, 0);
1437
1438 if (strcmp(args[3], "backup") == 0)
1439 {
1440 target->backup_working_area = 1;
1441 }
1442 else if (strcmp(args[3], "nobackup") == 0)
1443 {
1444 target->backup_working_area = 0;
1445 }
1446 else
1447 {
1448 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1449 return ERROR_COMMAND_SYNTAX_ERROR;
1450 }
1451
1452 return ERROR_OK;
1453 }
1454
1455
1456 /* process target state changes */
1457 int handle_target(void *priv)
1458 {
1459 target_t *target = targets;
1460
1461 while (target)
1462 {
1463 if (target_continous_poll)
1464 {
1465 /* polling may fail silently until the target has been examined */
1466 target_poll(target);
1467 }
1468
1469 target = target->next;
1470 }
1471
1472 return ERROR_OK;
1473 }
1474
1475 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1476 {
1477 target_t *target;
1478 reg_t *reg = NULL;
1479 int count = 0;
1480 char *value;
1481
1482 LOG_DEBUG("-");
1483
1484 target = get_current_target(cmd_ctx);
1485
1486 /* list all available registers for the current target */
1487 if (argc == 0)
1488 {
1489 reg_cache_t *cache = target->reg_cache;
1490
1491 count = 0;
1492 while(cache)
1493 {
1494 int i;
1495 for (i = 0; i < cache->num_regs; i++)
1496 {
1497 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1498 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);
1499 free(value);
1500 }
1501 cache = cache->next;
1502 }
1503
1504 return ERROR_OK;
1505 }
1506
1507 /* access a single register by its ordinal number */
1508 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1509 {
1510 int num = strtoul(args[0], NULL, 0);
1511 reg_cache_t *cache = target->reg_cache;
1512
1513 count = 0;
1514 while(cache)
1515 {
1516 int i;
1517 for (i = 0; i < cache->num_regs; i++)
1518 {
1519 if (count++ == num)
1520 {
1521 reg = &cache->reg_list[i];
1522 break;
1523 }
1524 }
1525 if (reg)
1526 break;
1527 cache = cache->next;
1528 }
1529
1530 if (!reg)
1531 {
1532 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1533 return ERROR_OK;
1534 }
1535 } else /* access a single register by its name */
1536 {
1537 reg = register_get_by_name(target->reg_cache, args[0], 1);
1538
1539 if (!reg)
1540 {
1541 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1542 return ERROR_OK;
1543 }
1544 }
1545
1546 /* display a register */
1547 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1548 {
1549 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1550 reg->valid = 0;
1551
1552 if (reg->valid == 0)
1553 {
1554 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1555 if (arch_type == NULL)
1556 {
1557 LOG_ERROR("BUG: encountered unregistered arch type");
1558 return ERROR_OK;
1559 }
1560 arch_type->get(reg);
1561 }
1562 value = buf_to_str(reg->value, reg->size, 16);
1563 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1564 free(value);
1565 return ERROR_OK;
1566 }
1567
1568 /* set register value */
1569 if (argc == 2)
1570 {
1571 u8 *buf = malloc(CEIL(reg->size, 8));
1572 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1573
1574 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1575 if (arch_type == NULL)
1576 {
1577 LOG_ERROR("BUG: encountered unregistered arch type");
1578 return ERROR_OK;
1579 }
1580
1581 arch_type->set(reg, buf);
1582
1583 value = buf_to_str(reg->value, reg->size, 16);
1584 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1585 free(value);
1586
1587 free(buf);
1588
1589 return ERROR_OK;
1590 }
1591
1592 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1593
1594 return ERROR_OK;
1595 }
1596
1597
1598 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1599 {
1600 target_t *target = get_current_target(cmd_ctx);
1601
1602 if (argc == 0)
1603 {
1604 target_poll(target);
1605 target_arch_state(target);
1606 }
1607 else
1608 {
1609 if (strcmp(args[0], "on") == 0)
1610 {
1611 target_continous_poll = 1;
1612 }
1613 else if (strcmp(args[0], "off") == 0)
1614 {
1615 target_continous_poll = 0;
1616 }
1617 else
1618 {
1619 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1620 }
1621 }
1622
1623
1624 return ERROR_OK;
1625 }
1626
1627 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1628 {
1629 int ms = 5000;
1630
1631 if (argc > 0)
1632 {
1633 char *end;
1634
1635 ms = strtoul(args[0], &end, 0) * 1000;
1636 if (*end)
1637 {
1638 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1639 return ERROR_OK;
1640 }
1641 }
1642 target_t *target = get_current_target(cmd_ctx);
1643
1644 return target_wait_state(target, TARGET_HALTED, ms);
1645 }
1646
1647 int target_wait_state(target_t *target, enum target_state state, int ms)
1648 {
1649 int retval;
1650 struct timeval timeout, now;
1651 int once=1;
1652 gettimeofday(&timeout, NULL);
1653 timeval_add_time(&timeout, 0, ms * 1000);
1654
1655 for (;;)
1656 {
1657 if ((retval=target_poll(target))!=ERROR_OK)
1658 return retval;
1659 target_call_timer_callbacks_now();
1660 if (target->state == state)
1661 {
1662 break;
1663 }
1664 if (once)
1665 {
1666 once=0;
1667 LOG_USER("waiting for target %s...", target_state_strings[state]);
1668 }
1669
1670 gettimeofday(&now, NULL);
1671 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1672 {
1673 LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]);
1674 return ERROR_FAIL;
1675 }
1676 }
1677
1678 return ERROR_OK;
1679 }
1680
1681 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1682 {
1683 int retval;
1684 target_t *target = get_current_target(cmd_ctx);
1685
1686 LOG_DEBUG("-");
1687
1688 if ((retval = target_halt(target)) != ERROR_OK)
1689 {
1690 return retval;
1691 }
1692
1693 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1694 }
1695
1696 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1697 {
1698 target_t *target = get_current_target(cmd_ctx);
1699
1700 LOG_USER("requesting target halt and executing a soft reset");
1701
1702 target->type->soft_reset_halt(target);
1703
1704 return ERROR_OK;
1705 }
1706
1707 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1708 {
1709 enum target_reset_mode reset_mode = RESET_RUN;
1710
1711 if (argc >= 1)
1712 {
1713 if (strcmp("run", args[0]) == 0)
1714 reset_mode = RESET_RUN;
1715 else if (strcmp("halt", args[0]) == 0)
1716 reset_mode = RESET_HALT;
1717 else if (strcmp("init", args[0]) == 0)
1718 reset_mode = RESET_INIT;
1719 else
1720 {
1721 return ERROR_COMMAND_SYNTAX_ERROR;
1722 }
1723 }
1724
1725 /* reset *all* targets */
1726 target_process_reset(cmd_ctx, reset_mode);
1727
1728 return ERROR_OK;
1729 }
1730
1731 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1732 {
1733 int retval;
1734 target_t *target = get_current_target(cmd_ctx);
1735
1736 target_invoke_script(cmd_ctx, target, "pre_resume");
1737
1738 if (argc == 0)
1739 retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1740 else if (argc == 1)
1741 retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1742 else
1743 {
1744 return ERROR_COMMAND_SYNTAX_ERROR;
1745 }
1746
1747 return retval;
1748 }
1749
1750 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1751 {
1752 target_t *target = get_current_target(cmd_ctx);
1753
1754 LOG_DEBUG("-");
1755
1756 if (argc == 0)
1757 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1758
1759 if (argc == 1)
1760 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1761
1762 return ERROR_OK;
1763 }
1764
1765 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1766 {
1767 const int line_bytecnt = 32;
1768 int count = 1;
1769 int size = 4;
1770 u32 address = 0;
1771 int line_modulo;
1772 int i;
1773
1774 char output[128];
1775 int output_len;
1776
1777 int retval;
1778
1779 u8 *buffer;
1780 target_t *target = get_current_target(cmd_ctx);
1781
1782 if (argc < 1)
1783 return ERROR_OK;
1784
1785 if (argc == 2)
1786 count = strtoul(args[1], NULL, 0);
1787
1788 address = strtoul(args[0], NULL, 0);
1789
1790
1791 switch (cmd[2])
1792 {
1793 case 'w':
1794 size = 4; line_modulo = line_bytecnt / 4;
1795 break;
1796 case 'h':
1797 size = 2; line_modulo = line_bytecnt / 2;
1798 break;
1799 case 'b':
1800 size = 1; line_modulo = line_bytecnt / 1;
1801 break;
1802 default:
1803 return ERROR_OK;
1804 }
1805
1806 buffer = calloc(count, size);
1807 retval = target->type->read_memory(target, address, size, count, buffer);
1808 if (retval == ERROR_OK)
1809 {
1810 output_len = 0;
1811
1812 for (i = 0; i < count; i++)
1813 {
1814 if (i%line_modulo == 0)
1815 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1816
1817 switch (size)
1818 {
1819 case 4:
1820 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1821 break;
1822 case 2:
1823 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1824 break;
1825 case 1:
1826 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1827 break;
1828 }
1829
1830 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1831 {
1832 command_print(cmd_ctx, output);
1833 output_len = 0;
1834 }
1835 }
1836 }
1837
1838 free(buffer);
1839
1840 return retval;
1841 }
1842
1843 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1844 {
1845 u32 address = 0;
1846 u32 value = 0;
1847 int count = 1;
1848 int i;
1849 int wordsize;
1850 target_t *target = get_current_target(cmd_ctx);
1851 u8 value_buf[4];
1852
1853 if ((argc < 2) || (argc > 3))
1854 return ERROR_COMMAND_SYNTAX_ERROR;
1855
1856 address = strtoul(args[0], NULL, 0);
1857 value = strtoul(args[1], NULL, 0);
1858 if (argc == 3)
1859 count = strtoul(args[2], NULL, 0);
1860
1861 switch (cmd[2])
1862 {
1863 case 'w':
1864 wordsize = 4;
1865 target_buffer_set_u32(target, value_buf, value);
1866 break;
1867 case 'h':
1868 wordsize = 2;
1869 target_buffer_set_u16(target, value_buf, value);
1870 break;
1871 case 'b':
1872 wordsize = 1;
1873 value_buf[0] = value;
1874 break;
1875 default:
1876 return ERROR_COMMAND_SYNTAX_ERROR;
1877 }
1878 for (i=0; i<count; i++)
1879 {
1880 int retval;
1881 switch (wordsize)
1882 {
1883 case 4:
1884 retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
1885 break;
1886 case 2:
1887 retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
1888 break;
1889 case 1:
1890 retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
1891 break;
1892 default:
1893 return ERROR_OK;
1894 }
1895 if (retval!=ERROR_OK)
1896 {
1897 return retval;
1898 }
1899 }
1900
1901 return ERROR_OK;
1902
1903 }
1904
1905 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1906 {
1907 u8 *buffer;
1908 u32 buf_cnt;
1909 u32 image_size;
1910 u32 min_address=0;
1911 u32 max_address=0xffffffff;
1912 int i;
1913 int retval;
1914
1915 image_t image;
1916
1917 duration_t duration;
1918 char *duration_text;
1919
1920 target_t *target = get_current_target(cmd_ctx);
1921
1922 if ((argc < 1)||(argc > 5))
1923 {
1924 return ERROR_COMMAND_SYNTAX_ERROR;
1925 }
1926
1927 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1928 if (argc >= 2)
1929 {
1930 image.base_address_set = 1;
1931 image.base_address = strtoul(args[1], NULL, 0);
1932 }
1933 else
1934 {
1935 image.base_address_set = 0;
1936 }
1937
1938
1939 image.start_address_set = 0;
1940
1941 if (argc>=4)
1942 {
1943 min_address=strtoul(args[3], NULL, 0);
1944 }
1945 if (argc>=5)
1946 {
1947 max_address=strtoul(args[4], NULL, 0)+min_address;
1948 }
1949
1950 if (min_address>max_address)
1951 {
1952 return ERROR_COMMAND_SYNTAX_ERROR;
1953 }
1954
1955
1956 duration_start_measure(&duration);
1957
1958 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1959 {
1960 return ERROR_OK;
1961 }
1962
1963 image_size = 0x0;
1964 retval = ERROR_OK;
1965 for (i = 0; i < image.num_sections; i++)
1966 {
1967 buffer = malloc(image.sections[i].size);
1968 if (buffer == NULL)
1969 {
1970 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1971 break;
1972 }
1973
1974 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1975 {
1976 free(buffer);
1977 break;
1978 }
1979
1980 u32 offset=0;
1981 u32 length=buf_cnt;
1982
1983
1984 /* DANGER!!! beware of unsigned comparision here!!! */
1985
1986 if ((image.sections[i].base_address+buf_cnt>=min_address)&&
1987 (image.sections[i].base_address<max_address))
1988 {
1989 if (image.sections[i].base_address<min_address)
1990 {
1991 /* clip addresses below */
1992 offset+=min_address-image.sections[i].base_address;
1993 length-=offset;
1994 }
1995
1996 if (image.sections[i].base_address+buf_cnt>max_address)
1997 {
1998 length-=(image.sections[i].base_address+buf_cnt)-max_address;
1999 }
2000
2001 if ((retval = target_write_buffer(target, image.sections[i].base_address+offset, length, buffer+offset)) != ERROR_OK)
2002 {
2003 free(buffer);
2004 break;
2005 }
2006 image_size += length;
2007 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", length, image.sections[i].base_address+offset);
2008 }
2009
2010 free(buffer);
2011 }
2012
2013 duration_stop_measure(&duration, &duration_text);
2014 if (retval==ERROR_OK)
2015 {
2016 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
2017 }
2018 free(duration_text);
2019
2020 image_close(&image);
2021
2022 return retval;
2023
2024 }
2025
2026 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2027 {
2028 fileio_t fileio;
2029
2030 u32 address;
2031 u32 size;
2032 u8 buffer[560];
2033 int retval=ERROR_OK;
2034
2035 duration_t duration;
2036 char *duration_text;
2037
2038 target_t *target = get_current_target(cmd_ctx);
2039
2040 if (argc != 3)
2041 {
2042 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2043 return ERROR_OK;
2044 }
2045
2046 address = strtoul(args[1], NULL, 0);
2047 size = strtoul(args[2], NULL, 0);
2048
2049 if ((address & 3) || (size & 3))
2050 {
2051 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
2052 return ERROR_OK;
2053 }
2054
2055 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2056 {
2057 return ERROR_OK;
2058 }
2059
2060 duration_start_measure(&duration);
2061
2062 while (size > 0)
2063 {
2064 u32 size_written;
2065 u32 this_run_size = (size > 560) ? 560 : size;
2066
2067 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2068 if (retval != ERROR_OK)
2069 {
2070 break;
2071 }
2072
2073 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2074 if (retval != ERROR_OK)
2075 {
2076 break;
2077 }
2078
2079 size -= this_run_size;
2080 address += this_run_size;
2081 }
2082
2083 fileio_close(&fileio);
2084
2085 duration_stop_measure(&duration, &duration_text);
2086 if (retval==ERROR_OK)
2087 {
2088 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2089 }
2090 free(duration_text);
2091
2092 return ERROR_OK;
2093 }
2094
2095 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2096 {
2097 u8 *buffer;
2098 u32 buf_cnt;
2099 u32 image_size;
2100 int i;
2101 int retval;
2102 u32 checksum = 0;
2103 u32 mem_checksum = 0;
2104
2105 image_t image;
2106
2107 duration_t duration;
2108 char *duration_text;
2109
2110 target_t *target = get_current_target(cmd_ctx);
2111
2112 if (argc < 1)
2113 {
2114 return ERROR_COMMAND_SYNTAX_ERROR;
2115 }
2116
2117 if (!target)
2118 {
2119 LOG_ERROR("no target selected");
2120 return ERROR_FAIL;
2121 }
2122
2123 duration_start_measure(&duration);
2124
2125 if (argc >= 2)
2126 {
2127 image.base_address_set = 1;
2128 image.base_address = strtoul(args[1], NULL, 0);
2129 }
2130 else
2131 {
2132 image.base_address_set = 0;
2133 image.base_address = 0x0;
2134 }
2135
2136 image.start_address_set = 0;
2137
2138 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2139 {
2140 return retval;
2141 }
2142
2143 image_size = 0x0;
2144 retval=ERROR_OK;
2145 for (i = 0; i < image.num_sections; i++)
2146 {
2147 buffer = malloc(image.sections[i].size);
2148 if (buffer == NULL)
2149 {
2150 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2151 break;
2152 }
2153 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2154 {
2155 free(buffer);
2156 break;
2157 }
2158
2159 /* calculate checksum of image */
2160 image_calculate_checksum( buffer, buf_cnt, &checksum );
2161
2162 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2163 if( retval != ERROR_OK )
2164 {
2165 free(buffer);
2166 break;
2167 }
2168
2169 if( checksum != mem_checksum )
2170 {
2171 /* failed crc checksum, fall back to a binary compare */
2172 u8 *data;
2173
2174 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2175
2176 data = (u8*)malloc(buf_cnt);
2177
2178 /* Can we use 32bit word accesses? */
2179 int size = 1;
2180 int count = buf_cnt;
2181 if ((count % 4) == 0)
2182 {
2183 size *= 4;
2184 count /= 4;
2185 }
2186 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2187 if (retval == ERROR_OK)
2188 {
2189 int t;
2190 for (t = 0; t < buf_cnt; t++)
2191 {
2192 if (data[t] != buffer[t])
2193 {
2194 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]);
2195 free(data);
2196 free(buffer);
2197 retval=ERROR_FAIL;
2198 goto done;
2199 }
2200 }
2201 }
2202
2203 free(data);
2204 }
2205
2206 free(buffer);
2207 image_size += buf_cnt;
2208 }
2209 done:
2210 duration_stop_measure(&duration, &duration_text);
2211 if (retval==ERROR_OK)
2212 {
2213 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2214 }
2215 free(duration_text);
2216
2217 image_close(&image);
2218
2219 return retval;
2220 }
2221
2222 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2223 {
2224 int retval;
2225 target_t *target = get_current_target(cmd_ctx);
2226
2227 if (argc == 0)
2228 {
2229 breakpoint_t *breakpoint = target->breakpoints;
2230
2231 while (breakpoint)
2232 {
2233 if (breakpoint->type == BKPT_SOFT)
2234 {
2235 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2236 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2237 free(buf);
2238 }
2239 else
2240 {
2241 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2242 }
2243 breakpoint = breakpoint->next;
2244 }
2245 }
2246 else if (argc >= 2)
2247 {
2248 int hw = BKPT_SOFT;
2249 u32 length = 0;
2250
2251 length = strtoul(args[1], NULL, 0);
2252
2253 if (argc >= 3)
2254 if (strcmp(args[2], "hw") == 0)
2255 hw = BKPT_HARD;
2256
2257 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2258 {
2259 LOG_ERROR("Failure setting breakpoints");
2260 }
2261 else
2262 {
2263 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2264 }
2265 }
2266 else
2267 {
2268 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2269 }
2270
2271 return ERROR_OK;
2272 }
2273
2274 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2275 {
2276 target_t *target = get_current_target(cmd_ctx);
2277
2278 if (argc > 0)
2279 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2280
2281 return ERROR_OK;
2282 }
2283
2284 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2285 {
2286 target_t *target = get_current_target(cmd_ctx);
2287 int retval;
2288
2289 if (argc == 0)
2290 {
2291 watchpoint_t *watchpoint = target->watchpoints;
2292
2293 while (watchpoint)
2294 {
2295 command_print(cmd_ctx, "address: 0x%8.8x, len: 0x%8.8x, r/w/a: %i, value: 0x%8.8x, mask: 0x%8.8x", watchpoint->address, watchpoint->length, watchpoint->rw, watchpoint->value, watchpoint->mask);
2296 watchpoint = watchpoint->next;
2297 }
2298 }
2299 else if (argc >= 2)
2300 {
2301 enum watchpoint_rw type = WPT_ACCESS;
2302 u32 data_value = 0x0;
2303 u32 data_mask = 0xffffffff;
2304
2305 if (argc >= 3)
2306 {
2307 switch(args[2][0])
2308 {
2309 case 'r':
2310 type = WPT_READ;
2311 break;
2312 case 'w':
2313 type = WPT_WRITE;
2314 break;
2315 case 'a':
2316 type = WPT_ACCESS;
2317 break;
2318 default:
2319 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2320 return ERROR_OK;
2321 }
2322 }
2323 if (argc >= 4)
2324 {
2325 data_value = strtoul(args[3], NULL, 0);
2326 }
2327 if (argc >= 5)
2328 {
2329 data_mask = strtoul(args[4], NULL, 0);
2330 }
2331
2332 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2333 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2334 {
2335 LOG_ERROR("Failure setting breakpoints");
2336 }
2337 }
2338 else
2339 {
2340 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2341 }
2342
2343 return ERROR_OK;
2344 }
2345
2346 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2347 {
2348 target_t *target = get_current_target(cmd_ctx);
2349
2350 if (argc > 0)
2351 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2352
2353 return ERROR_OK;
2354 }
2355
2356 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2357 {
2358 int retval;
2359 target_t *target = get_current_target(cmd_ctx);
2360 u32 va;
2361 u32 pa;
2362
2363 if (argc != 1)
2364 {
2365 return ERROR_COMMAND_SYNTAX_ERROR;
2366 }
2367 va = strtoul(args[0], NULL, 0);
2368
2369 retval = target->type->virt2phys(target, va, &pa);
2370 if (retval == ERROR_OK)
2371 {
2372 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2373 }
2374 else
2375 {
2376 /* lower levels will have logged a detailed error which is
2377 * forwarded to telnet/GDB session.
2378 */
2379 }
2380 return retval;
2381 }
2382 static void writeLong(FILE *f, int l)
2383 {
2384 int i;
2385 for (i=0; i<4; i++)
2386 {
2387 char c=(l>>(i*8))&0xff;
2388 fwrite(&c, 1, 1, f);
2389 }
2390
2391 }
2392 static void writeString(FILE *f, char *s)
2393 {
2394 fwrite(s, 1, strlen(s), f);
2395 }
2396
2397
2398
2399 // Dump a gmon.out histogram file.
2400 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2401 {
2402 int i;
2403 FILE *f=fopen(filename, "w");
2404 if (f==NULL)
2405 return;
2406 fwrite("gmon", 1, 4, f);
2407 writeLong(f, 0x00000001); // Version
2408 writeLong(f, 0); // padding
2409 writeLong(f, 0); // padding
2410 writeLong(f, 0); // padding
2411
2412 fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST
2413
2414 // figure out bucket size
2415 u32 min=samples[0];
2416 u32 max=samples[0];
2417 for (i=0; i<sampleNum; i++)
2418 {
2419 if (min>samples[i])
2420 {
2421 min=samples[i];
2422 }
2423 if (max<samples[i])
2424 {
2425 max=samples[i];
2426 }
2427 }
2428
2429 int addressSpace=(max-min+1);
2430
2431 static int const maxBuckets=256*1024; // maximum buckets.
2432 int length=addressSpace;
2433 if (length > maxBuckets)
2434 {
2435 length=maxBuckets;
2436 }
2437 int *buckets=malloc(sizeof(int)*length);
2438 if (buckets==NULL)
2439 {
2440 fclose(f);
2441 return;
2442 }
2443 memset(buckets, 0, sizeof(int)*length);
2444 for (i=0; i<sampleNum;i++)
2445 {
2446 u32 address=samples[i];
2447 long long a=address-min;
2448 long long b=length-1;
2449 long long c=addressSpace-1;
2450 int index=(a*b)/c; // danger!!!! int32 overflows
2451 buckets[index]++;
2452 }
2453
2454 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2455 writeLong(f, min); // low_pc
2456 writeLong(f, max); // high_pc
2457 writeLong(f, length); // # of samples
2458 writeLong(f, 64000000); // 64MHz
2459 writeString(f, "seconds");
2460 for (i=0; i<(15-strlen("seconds")); i++)
2461 {
2462 fwrite("", 1, 1, f); // padding
2463 }
2464 writeString(f, "s");
2465
2466 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2467
2468 char *data=malloc(2*length);
2469 if (data!=NULL)
2470 {
2471 for (i=0; i<length;i++)
2472 {
2473 int val;
2474 val=buckets[i];
2475 if (val>65535)
2476 {
2477 val=65535;
2478 }
2479 data[i*2]=val&0xff;
2480 data[i*2+1]=(val>>8)&0xff;
2481 }
2482 free(buckets);
2483 fwrite(data, 1, length*2, f);
2484 free(data);
2485 } else
2486 {
2487 free(buckets);
2488 }
2489
2490 fclose(f);
2491 }
2492
2493 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2494 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2495 {
2496 target_t *target = get_current_target(cmd_ctx);
2497 struct timeval timeout, now;
2498
2499 gettimeofday(&timeout, NULL);
2500 if (argc!=2)
2501 {
2502 return ERROR_COMMAND_SYNTAX_ERROR;
2503 }
2504 char *end;
2505 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2506 if (*end)
2507 {
2508 return ERROR_OK;
2509 }
2510
2511 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2512
2513 static const int maxSample=10000;
2514 u32 *samples=malloc(sizeof(u32)*maxSample);
2515 if (samples==NULL)
2516 return ERROR_OK;
2517
2518 int numSamples=0;
2519 int retval=ERROR_OK;
2520 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2521 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2522
2523 for (;;)
2524 {
2525 target_poll(target);
2526 if (target->state == TARGET_HALTED)
2527 {
2528 u32 t=*((u32 *)reg->value);
2529 samples[numSamples++]=t;
2530 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2531 target_poll(target);
2532 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2533 } else if (target->state == TARGET_RUNNING)
2534 {
2535 // We want to quickly sample the PC.
2536 target_halt(target);
2537 } else
2538 {
2539 command_print(cmd_ctx, "Target not halted or running");
2540 retval=ERROR_OK;
2541 break;
2542 }
2543 if (retval!=ERROR_OK)
2544 {
2545 break;
2546 }
2547
2548 gettimeofday(&now, NULL);
2549 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2550 {
2551 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2552 target_poll(target);
2553 if (target->state == TARGET_HALTED)
2554 {
2555 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2556 }
2557 target_poll(target);
2558 writeGmon(samples, numSamples, args[1]);
2559 command_print(cmd_ctx, "Wrote %s", args[1]);
2560 break;
2561 }
2562 }
2563 free(samples);
2564
2565 return ERROR_OK;
2566 }
2567
2568 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val)
2569 {
2570 char *namebuf;
2571 Jim_Obj *nameObjPtr, *valObjPtr;
2572 int result;
2573
2574 namebuf = alloc_printf("%s(%d)", varname, idx);
2575 if (!namebuf)
2576 return JIM_ERR;
2577
2578 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2579 valObjPtr = Jim_NewIntObj(interp, val);
2580 if (!nameObjPtr || !valObjPtr)
2581 {
2582 free(namebuf);
2583 return JIM_ERR;
2584 }
2585
2586 Jim_IncrRefCount(nameObjPtr);
2587 Jim_IncrRefCount(valObjPtr);
2588 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
2589 Jim_DecrRefCount(interp, nameObjPtr);
2590 Jim_DecrRefCount(interp, valObjPtr);
2591 free(namebuf);
2592 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2593 return result;
2594 }
2595
2596 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2597 {
2598 target_t *target;
2599 command_context_t *context;
2600 long l;
2601 u32 width;
2602 u32 len;
2603 u32 addr;
2604 u32 count;
2605 u32 v;
2606 const char *varname;
2607 u8 buffer[4096];
2608 int i, n, e, retval;
2609
2610 /* argv[1] = name of array to receive the data
2611 * argv[2] = desired width
2612 * argv[3] = memory address
2613 * argv[4] = count of times to read
2614 */
2615 if (argc != 5) {
2616 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2617 return JIM_ERR;
2618 }
2619 varname = Jim_GetString(argv[1], &len);
2620 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2621
2622 e = Jim_GetLong(interp, argv[2], &l);
2623 width = l;
2624 if (e != JIM_OK) {
2625 return e;
2626 }
2627
2628 e = Jim_GetLong(interp, argv[3], &l);
2629 addr = l;
2630 if (e != JIM_OK) {
2631 return e;
2632 }
2633 e = Jim_GetLong(interp, argv[4], &l);
2634 len = l;
2635 if (e != JIM_OK) {
2636 return e;
2637 }
2638 switch (width) {
2639 case 8:
2640 width = 1;
2641 break;
2642 case 16:
2643 width = 2;
2644 break;
2645 case 32:
2646 width = 4;
2647 break;
2648 default:
2649 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2650 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2651 return JIM_ERR;
2652 }
2653 if (len == 0) {
2654 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2655 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
2656 return JIM_ERR;
2657 }
2658 if ((addr + (len * width)) < addr) {
2659 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2660 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
2661 return JIM_ERR;
2662 }
2663 /* absurd transfer size? */
2664 if (len > 65536) {
2665 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2666 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
2667 return JIM_ERR;
2668 }
2669
2670 if ((width == 1) ||
2671 ((width == 2) && ((addr & 1) == 0)) ||
2672 ((width == 4) && ((addr & 3) == 0))) {
2673 /* all is well */
2674 } else {
2675 char buf[100];
2676 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2677 sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width);
2678 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2679 return JIM_ERR;
2680 }
2681
2682 context = Jim_GetAssocData(interp, "context");
2683 if (context == NULL)
2684 {
2685 LOG_ERROR("mem2array: no command context");
2686 return JIM_ERR;
2687 }
2688 target = get_current_target(context);
2689 if (target == NULL)
2690 {
2691 LOG_ERROR("mem2array: no current target");
2692 return JIM_ERR;
2693 }
2694
2695 /* Transfer loop */
2696
2697 /* index counter */
2698 n = 0;
2699 /* assume ok */
2700 e = JIM_OK;
2701 while (len) {
2702 /* Slurp... in buffer size chunks */
2703
2704 count = len; /* in objects.. */
2705 if (count > (sizeof(buffer)/width)) {
2706 count = (sizeof(buffer)/width);
2707 }
2708
2709 retval = target->type->read_memory( target, addr, width, count, buffer );
2710 if (retval != ERROR_OK) {
2711 /* BOO !*/
2712 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2713 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2714 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2715 e = JIM_ERR;
2716 len = 0;
2717 } else {
2718 v = 0; /* shut up gcc */
2719 for (i = 0 ;i < count ;i++, n++) {
2720 switch (width) {
2721 case 4:
2722 v = target_buffer_get_u32(target, &buffer[i*width]);
2723 break;
2724 case 2:
2725 v = target_buffer_get_u16(target, &buffer[i*width]);
2726 break;
2727 case 1:
2728 v = buffer[i] & 0x0ff;
2729 break;
2730 }
2731 new_int_array_element(interp, varname, n, v);
2732 }
2733 len -= count;
2734 }
2735 }
2736
2737 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2738
2739 return JIM_OK;
2740 }
2741
2742 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val)
2743 {
2744 char *namebuf;
2745 Jim_Obj *nameObjPtr, *valObjPtr;
2746 int result;
2747 long l;
2748
2749 namebuf = alloc_printf("%s(%d)", varname, idx);
2750 if (!namebuf)
2751 return JIM_ERR;
2752
2753 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2754 if (!nameObjPtr)
2755 {
2756 free(namebuf);
2757 return JIM_ERR;
2758 }
2759
2760 Jim_IncrRefCount(nameObjPtr);
2761 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
2762 Jim_DecrRefCount(interp, nameObjPtr);
2763 free(namebuf);
2764 if (valObjPtr == NULL)
2765 return JIM_ERR;
2766
2767 result = Jim_GetLong(interp, valObjPtr, &l);
2768 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2769 *val = l;
2770 return result;
2771 }
2772
2773 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2774 {
2775 target_t *target;
2776 command_context_t *context;
2777 long l;
2778 u32 width;
2779 u32 len;
2780 u32 addr;
2781 u32 count;
2782 u32 v;
2783 const char *varname;
2784 u8 buffer[4096];
2785 int i, n, e, retval;
2786
2787 /* argv[1] = name of array to get the data
2788 * argv[2] = desired width
2789 * argv[3] = memory address
2790 * argv[4] = count to write
2791 */
2792 if (argc != 5) {
2793 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2794 return JIM_ERR;
2795 }
2796 varname = Jim_GetString(argv[1], &len);
2797 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2798
2799 e = Jim_GetLong(interp, argv[2], &l);
2800 width = l;
2801 if (e != JIM_OK) {
2802 return e;
2803 }
2804
2805 e = Jim_GetLong(interp, argv[3], &l);
2806 addr = l;
2807 if (e != JIM_OK) {
2808 return e;
2809 }
2810 e = Jim_GetLong(interp, argv[4], &l);
2811 len = l;
2812 if (e != JIM_OK) {
2813 return e;
2814 }
2815 switch (width) {
2816 case 8:
2817 width = 1;
2818 break;
2819 case 16:
2820 width = 2;
2821 break;
2822 case 32:
2823 width = 4;
2824 break;
2825 default:
2826 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2827 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2828 return JIM_ERR;
2829 }
2830 if (len == 0) {
2831 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2832 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
2833 return JIM_ERR;
2834 }
2835 if ((addr + (len * width)) < addr) {
2836 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2837 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
2838 return JIM_ERR;
2839 }
2840 /* absurd transfer size? */
2841 if (len > 65536) {
2842 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2843 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
2844 return JIM_ERR;
2845 }
2846
2847 if ((width == 1) ||
2848 ((width == 2) && ((addr & 1) == 0)) ||
2849 ((width == 4) && ((addr & 3) == 0))) {
2850 /* all is well */
2851 } else {
2852 char buf[100];
2853 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2854 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width);
2855 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2856 return JIM_ERR;
2857 }
2858
2859 context = Jim_GetAssocData(interp, "context");
2860 if (context == NULL)
2861 {
2862 LOG_ERROR("array2mem: no command context");
2863 return JIM_ERR;
2864 }
2865 target = get_current_target(context);
2866 if (target == NULL)
2867 {
2868 LOG_ERROR("array2mem: no current target");
2869 return JIM_ERR;
2870 }
2871
2872 /* Transfer loop */
2873
2874 /* index counter */
2875 n = 0;
2876 /* assume ok */
2877 e = JIM_OK;
2878 while (len) {
2879 /* Slurp... in buffer size chunks */
2880
2881 count = len; /* in objects.. */
2882 if (count > (sizeof(buffer)/width)) {
2883 count = (sizeof(buffer)/width);
2884 }
2885
2886 v = 0; /* shut up gcc */
2887 for (i = 0 ;i < count ;i++, n++) {
2888 get_int_array_element(interp, varname, n, &v);
2889 switch (width) {
2890 case 4:
2891 target_buffer_set_u32(target, &buffer[i*width], v);
2892 break;
2893 case 2:
2894 target_buffer_set_u16(target, &buffer[i*width], v);
2895 break;
2896 case 1:
2897 buffer[i] = v & 0x0ff;
2898 break;
2899 }
2900 }
2901 len -= count;
2902
2903 retval = target->type->write_memory(target, addr, width, count, buffer);
2904 if (retval != ERROR_OK) {
2905 /* BOO !*/
2906 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2907 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2908 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2909 e = JIM_ERR;
2910 len = 0;
2911 }
2912 }
2913
2914 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2915
2916 return JIM_OK;
2917 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)