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