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