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