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