Code Review / openocd.git / blob
? search:


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