Code Review / openocd.git / blob
? search:


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