Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- added patch to check some malloc problems.
[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 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
53 int handle_daemon_startup_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
78 /* targets
79 */
80 extern target_type_t arm7tdmi_target;
81 extern target_type_t arm720t_target;
82 extern target_type_t arm9tdmi_target;
83 extern target_type_t arm920t_target;
84 extern target_type_t arm966e_target;
85 extern target_type_t arm926ejs_target;
86 extern target_type_t xscale_target;
87 extern target_type_t cortexm3_target;
88
89 target_type_t *target_types[] =
90 {
91 &arm7tdmi_target,
92 &arm9tdmi_target,
93 &arm920t_target,
94 &arm720t_target,
95 &arm966e_target,
96 &arm926ejs_target,
97 &xscale_target,
98 &cortexm3_target,
99 NULL,
100 };
101
102 target_t *targets = NULL;
103 target_event_callback_t *target_event_callbacks = NULL;
104 target_timer_callback_t *target_timer_callbacks = NULL;
105
106 char *target_state_strings[] =
107 {
108 "unknown",
109 "running",
110 "halted",
111 "reset",
112 "debug_running",
113 };
114
115 char *target_debug_reason_strings[] =
116 {
117 "debug request", "breakpoint", "watchpoint",
118 "watchpoint and breakpoint", "single step",
119 "target not halted"
120 };
121
122 char *target_endianess_strings[] =
123 {
124 "big endian",
125 "little endian",
126 };
127
128 enum daemon_startup_mode startup_mode = DAEMON_ATTACH;
129
130 static int target_continous_poll = 1;
131
132 /* read a u32 from a buffer in target memory endianness */
133 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
134 {
135 if (target->endianness == TARGET_LITTLE_ENDIAN)
136 return le_to_h_u32(buffer);
137 else
138 return be_to_h_u32(buffer);
139 }
140
141 /* read a u16 from a buffer in target memory endianness */
142 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
143 {
144 if (target->endianness == TARGET_LITTLE_ENDIAN)
145 return le_to_h_u16(buffer);
146 else
147 return be_to_h_u16(buffer);
148 }
149
150 /* write a u32 to a buffer in target memory endianness */
151 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
152 {
153 if (target->endianness == TARGET_LITTLE_ENDIAN)
154 h_u32_to_le(buffer, value);
155 else
156 h_u32_to_be(buffer, value);
157 }
158
159 /* write a u16 to a buffer in target memory endianness */
160 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
161 {
162 if (target->endianness == TARGET_LITTLE_ENDIAN)
163 h_u16_to_le(buffer, value);
164 else
165 h_u16_to_be(buffer, value);
166 }
167
168 /* returns a pointer to the n-th configured target */
169 target_t* get_target_by_num(int num)
170 {
171 target_t *target = targets;
172 int i = 0;
173
174 while (target)
175 {
176 if (num == i)
177 return target;
178 target = target->next;
179 i++;
180 }
181
182 return NULL;
183 }
184
185 int get_num_by_target(target_t *query_target)
186 {
187 target_t *target = targets;
188 int i = 0;
189
190 while (target)
191 {
192 if (target == query_target)
193 return i;
194 target = target->next;
195 i++;
196 }
197
198 return -1;
199 }
200
201 target_t* get_current_target(command_context_t *cmd_ctx)
202 {
203 target_t *target = get_target_by_num(cmd_ctx->current_target);
204
205 if (target == NULL)
206 {
207 ERROR("BUG: current_target out of bounds");
208 exit(-1);
209 }
210
211 return target;
212 }
213
214 /* Process target initialization, when target entered debug out of reset
215 * the handler is unregistered at the end of this function, so it's only called once
216 */
217 int target_init_handler(struct target_s *target, enum target_event event, void *priv)
218 {
219 FILE *script;
220 struct command_context_s *cmd_ctx = priv;
221
222 if ((event == TARGET_EVENT_HALTED) && (target->reset_script))
223 {
224 target_unregister_event_callback(target_init_handler, priv);
225
226 script = fopen(target->reset_script, "r");
227 if (!script)
228 {
229 ERROR("couldn't open script file %s", target->reset_script);
230 return ERROR_OK;
231 }
232
233 INFO("executing reset script '%s'", target->reset_script);
234 command_run_file(cmd_ctx, script, COMMAND_EXEC);
235 fclose(script);
236
237 jtag_execute_queue();
238 }
239
240 return ERROR_OK;
241 }
242
243 int target_run_and_halt_handler(void *priv)
244 {
245 target_t *target = priv;
246
247 target->type->halt(target);
248
249 return ERROR_OK;
250 }
251
252 int target_process_reset(struct command_context_s *cmd_ctx)
253 {
254 int retval = ERROR_OK;
255 target_t *target;
256
257 /* prepare reset_halt where necessary */
258 target = targets;
259 while (target)
260 {
261 switch (target->reset_mode)
262 {
263 case RESET_HALT:
264 case RESET_INIT:
265 target->type->prepare_reset_halt(target);
266 break;
267 default:
268 break;
269 }
270 target = target->next;
271 }
272
273 target = targets;
274 while (target)
275 {
276 target->type->assert_reset(target);
277 target = target->next;
278 }
279 jtag_execute_queue();
280
281 /* request target halt if necessary, and schedule further action */
282 target = targets;
283 while (target)
284 {
285 switch (target->reset_mode)
286 {
287 case RESET_RUN:
288 /* nothing to do if target just wants to be run */
289 break;
290 case RESET_RUN_AND_HALT:
291 /* schedule halt */
292 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
293 break;
294 case RESET_RUN_AND_INIT:
295 /* schedule halt */
296 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
297 target_register_event_callback(target_init_handler, cmd_ctx);
298 break;
299 case RESET_HALT:
300 target->type->halt(target);
301 break;
302 case RESET_INIT:
303 target->type->halt(target);
304 target_register_event_callback(target_init_handler, cmd_ctx);
305 break;
306 default:
307 ERROR("BUG: unknown target->reset_mode");
308 }
309 target = target->next;
310 }
311
312 target = targets;
313 while (target)
314 {
315 target->type->deassert_reset(target);
316
317 switch (target->reset_mode)
318 {
319 case RESET_INIT:
320 case RESET_HALT:
321 // If we're already halted, then this is harmless(reducing # of execution paths here)
322 // If nSRST & nTRST are tied together then the halt during reset failed(logged) and
323 // we use this as fallback(there is no other output to tell the user that reset halt
324 // didn't work).
325 target->type->poll(target);
326 target->type->halt(target);
327 break;
328 default:
329 break;
330 }
331
332
333 target = target->next;
334 }
335 jtag_execute_queue();
336
337 return retval;
338 }
339
340 int target_init(struct command_context_s *cmd_ctx)
341 {
342 target_t *target = targets;
343
344 while (target)
345 {
346 if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
347 {
348 ERROR("target '%s' init failed", target->type->name);
349 exit(-1);
350 }
351 target = target->next;
352 }
353
354 if (targets)
355 {
356 target_register_user_commands(cmd_ctx);
357 target_register_timer_callback(handle_target, 100, 1, NULL);
358 }
359
360 if (startup_mode == DAEMON_RESET)
361 target_process_reset(cmd_ctx);
362
363 return ERROR_OK;
364 }
365
366 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
367 {
368 target_event_callback_t **callbacks_p = &target_event_callbacks;
369
370 if (callback == NULL)
371 {
372 return ERROR_INVALID_ARGUMENTS;
373 }
374
375 if (*callbacks_p)
376 {
377 while ((*callbacks_p)->next)
378 callbacks_p = &((*callbacks_p)->next);
379 callbacks_p = &((*callbacks_p)->next);
380 }
381
382 (*callbacks_p) = malloc(sizeof(target_event_callback_t));
383 (*callbacks_p)->callback = callback;
384 (*callbacks_p)->priv = priv;
385 (*callbacks_p)->next = NULL;
386
387 return ERROR_OK;
388 }
389
390 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
391 {
392 target_timer_callback_t **callbacks_p = &target_timer_callbacks;
393 struct timeval now;
394
395 if (callback == NULL)
396 {
397 return ERROR_INVALID_ARGUMENTS;
398 }
399
400 if (*callbacks_p)
401 {
402 while ((*callbacks_p)->next)
403 callbacks_p = &((*callbacks_p)->next);
404 callbacks_p = &((*callbacks_p)->next);
405 }
406
407 (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
408 (*callbacks_p)->callback = callback;
409 (*callbacks_p)->periodic = periodic;
410 (*callbacks_p)->time_ms = time_ms;
411
412 gettimeofday(&now, NULL);
413 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
414 time_ms -= (time_ms % 1000);
415 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
416 if ((*callbacks_p)->when.tv_usec > 1000000)
417 {
418 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
419 (*callbacks_p)->when.tv_sec += 1;
420 }
421
422 (*callbacks_p)->priv = priv;
423 (*callbacks_p)->next = NULL;
424
425 return ERROR_OK;
426 }
427
428 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
429 {
430 target_event_callback_t **p = &target_event_callbacks;
431 target_event_callback_t *c = target_event_callbacks;
432
433 if (callback == NULL)
434 {
435 return ERROR_INVALID_ARGUMENTS;
436 }
437
438 while (c)
439 {
440 target_event_callback_t *next = c->next;
441 if ((c->callback == callback) && (c->priv == priv))
442 {
443 *p = next;
444 free(c);
445 return ERROR_OK;
446 }
447 else
448 p = &(c->next);
449 c = next;
450 }
451
452 return ERROR_OK;
453 }
454
455 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
456 {
457 target_timer_callback_t **p = &target_timer_callbacks;
458 target_timer_callback_t *c = target_timer_callbacks;
459
460 if (callback == NULL)
461 {
462 return ERROR_INVALID_ARGUMENTS;
463 }
464
465 while (c)
466 {
467 target_timer_callback_t *next = c->next;
468 if ((c->callback == callback) && (c->priv == priv))
469 {
470 *p = next;
471 free(c);
472 return ERROR_OK;
473 }
474 else
475 p = &(c->next);
476 c = next;
477 }
478
479 return ERROR_OK;
480 }
481
482 int target_call_event_callbacks(target_t *target, enum target_event event)
483 {
484 target_event_callback_t *callback = target_event_callbacks;
485 target_event_callback_t *next_callback;
486
487 DEBUG("target event %i", event);
488
489 while (callback)
490 {
491 next_callback = callback->next;
492 callback->callback(target, event, callback->priv);
493 callback = next_callback;
494 }
495
496 return ERROR_OK;
497 }
498
499 int target_call_timer_callbacks()
500 {
501 target_timer_callback_t *callback = target_timer_callbacks;
502 target_timer_callback_t *next_callback;
503 struct timeval now;
504
505 gettimeofday(&now, NULL);
506
507 while (callback)
508 {
509 next_callback = callback->next;
510
511 if (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
512 || (now.tv_sec > callback->when.tv_sec))
513 {
514 callback->callback(callback->priv);
515 if (callback->periodic)
516 {
517 int time_ms = callback->time_ms;
518 callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
519 time_ms -= (time_ms % 1000);
520 callback->when.tv_sec = now.tv_sec + time_ms / 1000;
521 if (callback->when.tv_usec > 1000000)
522 {
523 callback->when.tv_usec = callback->when.tv_usec - 1000000;
524 callback->when.tv_sec += 1;
525 }
526 }
527 else
528 target_unregister_timer_callback(callback->callback, callback->priv);
529 }
530
531 callback = next_callback;
532 }
533
534 return ERROR_OK;
535 }
536
537 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
538 {
539 working_area_t *c = target->working_areas;
540 working_area_t *new_wa = NULL;
541
542 /* only allocate multiples of 4 byte */
543 if (size % 4)
544 {
545 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
546 size = CEIL(size, 4);
547 }
548
549 /* see if there's already a matching working area */
550 while (c)
551 {
552 if ((c->free) && (c->size == size))
553 {
554 new_wa = c;
555 break;
556 }
557 c = c->next;
558 }
559
560 /* if not, allocate a new one */
561 if (!new_wa)
562 {
563 working_area_t **p = &target->working_areas;
564 u32 first_free = target->working_area;
565 u32 free_size = target->working_area_size;
566
567 DEBUG("allocating new working area");
568
569 c = target->working_areas;
570 while (c)
571 {
572 first_free += c->size;
573 free_size -= c->size;
574 p = &c->next;
575 c = c->next;
576 }
577
578 if (free_size < size)
579 {
580 WARNING("not enough working area available");
581 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
582 }
583
584 new_wa = malloc(sizeof(working_area_t));
585 new_wa->next = NULL;
586 new_wa->size = size;
587 new_wa->address = first_free;
588
589 if (target->backup_working_area)
590 {
591 new_wa->backup = malloc(new_wa->size);
592 target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup);
593 }
594 else
595 {
596 new_wa->backup = NULL;
597 }
598
599 /* put new entry in list */
600 *p = new_wa;
601 }
602
603 /* mark as used, and return the new (reused) area */
604 new_wa->free = 0;
605 *area = new_wa;
606
607 /* user pointer */
608 new_wa->user = area;
609
610 return ERROR_OK;
611 }
612
613 int target_free_working_area(struct target_s *target, working_area_t *area)
614 {
615 if (area->free)
616 return ERROR_OK;
617
618 if (target->backup_working_area)
619 target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
620
621 area->free = 1;
622
623 /* mark user pointer invalid */
624 *area->user = NULL;
625 area->user = NULL;
626
627 return ERROR_OK;
628 }
629
630 int target_free_all_working_areas(struct target_s *target)
631 {
632 working_area_t *c = target->working_areas;
633
634 while (c)
635 {
636 working_area_t *next = c->next;
637 target_free_working_area(target, c);
638
639 if (c->backup)
640 free(c->backup);
641
642 free(c);
643
644 c = next;
645 }
646
647 target->working_areas = NULL;
648
649 return ERROR_OK;
650 }
651
652 int target_register_commands(struct command_context_s *cmd_ctx)
653 {
654 register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, NULL);
655 register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
656 register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG, NULL);
657 register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL);
658 register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, NULL);
659 register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_CONFIG, NULL);
660
661 return ERROR_OK;
662 }
663
664 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
665 {
666 int retval;
667
668 DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
669
670 /* handle writes of less than 4 byte */
671 if (size < 4)
672 {
673 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
674 return retval;
675 return ERROR_OK;
676 }
677
678 /* handle unaligned head bytes */
679 if (address % 4)
680 {
681 int unaligned = 4 - (address % 4);
682
683 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
684 return retval;
685
686 buffer += unaligned;
687 address += unaligned;
688 size -= unaligned;
689 }
690
691 /* handle aligned words */
692 if (size >= 4)
693 {
694 int aligned = size - (size % 4);
695
696 /* use bulk writes above a certain limit. This may have to be changed */
697 if (aligned > 128)
698 {
699 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
700 return retval;
701 }
702 else
703 {
704 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
705 return retval;
706 }
707
708 buffer += aligned;
709 address += aligned;
710 size -= aligned;
711 }
712
713 /* handle tail writes of less than 4 bytes */
714 if (size > 0)
715 {
716 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
717 return retval;
718 }
719
720 return ERROR_OK;
721 }
722
723 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
724 {
725 int retval;
726
727 DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
728
729 /* handle reads of less than 4 byte */
730 if (size < 4)
731 {
732 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
733 return retval;
734 return ERROR_OK;
735 }
736
737 /* handle unaligned head bytes */
738 if (address % 4)
739 {
740 int unaligned = 4 - (address % 4);
741
742 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
743 return retval;
744
745 buffer += unaligned;
746 address += unaligned;
747 size -= unaligned;
748 }
749
750 /* handle aligned words */
751 if (size >= 4)
752 {
753 int aligned = size - (size % 4);
754
755 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
756 return retval;
757
758 buffer += aligned;
759 address += aligned;
760 size -= aligned;
761 }
762
763 /* handle tail writes of less than 4 bytes */
764 if (size > 0)
765 {
766 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
767 return retval;
768 }
769
770 return ERROR_OK;
771 }
772
773 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
774 {
775 u8 *buffer;
776 int retval;
777 int i;
778 u32 checksum = 0;
779
780 if ((retval = target->type->checksum_memory(target, address,
781 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
782 {
783 buffer = malloc(size);
784 if (buffer==NULL)
785 {
786 ERROR("error allocating buffer for section (%d bytes)", size);
787 return ERROR_OK;
788 }
789 target_read_buffer(target, address, size, buffer);
790
791 /* convert to target endianess */
792 for (i = 0; i < (size/sizeof(u32)); i++)
793 {
794 u32 target_data;
795 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
796 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
797 }
798
799 retval = image_calculate_checksum( buffer, size, &checksum );
800 free(buffer);
801 }
802
803 *crc = checksum;
804
805 return retval;
806 }
807
808 int target_read_u32(struct target_s *target, u32 address, u32 *value)
809 {
810 u8 value_buf[4];
811
812 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
813
814 if (retval == ERROR_OK)
815 {
816 *value = target_buffer_get_u32(target, value_buf);
817 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
818 }
819 else
820 {
821 *value = 0x0;
822 DEBUG("address: 0x%8.8x failed", address);
823 }
824
825 return retval;
826 }
827
828 int target_read_u16(struct target_s *target, u32 address, u16 *value)
829 {
830 u8 value_buf[2];
831
832 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
833
834 if (retval == ERROR_OK)
835 {
836 *value = target_buffer_get_u16(target, value_buf);
837 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
838 }
839 else
840 {
841 *value = 0x0;
842 DEBUG("address: 0x%8.8x failed", address);
843 }
844
845 return retval;
846 }
847
848 int target_read_u8(struct target_s *target, u32 address, u8 *value)
849 {
850 int retval = target->type->read_memory(target, address, 1, 1, value);
851
852 if (retval == ERROR_OK)
853 {
854 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
855 }
856 else
857 {
858 *value = 0x0;
859 DEBUG("address: 0x%8.8x failed", address);
860 }
861
862 return retval;
863 }
864
865 int target_write_u32(struct target_s *target, u32 address, u32 value)
866 {
867 int retval;
868 u8 value_buf[4];
869
870 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
871
872 target_buffer_set_u32(target, value_buf, value);
873 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
874 {
875 DEBUG("failed: %i", retval);
876 }
877
878 return retval;
879 }
880
881 int target_write_u16(struct target_s *target, u32 address, u16 value)
882 {
883 int retval;
884 u8 value_buf[2];
885
886 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
887
888 target_buffer_set_u16(target, value_buf, value);
889 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
890 {
891 DEBUG("failed: %i", retval);
892 }
893
894 return retval;
895 }
896
897 int target_write_u8(struct target_s *target, u32 address, u8 value)
898 {
899 int retval;
900
901 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
902
903 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
904 {
905 DEBUG("failed: %i", retval);
906 }
907
908 return retval;
909 }
910
911 int target_register_user_commands(struct command_context_s *cmd_ctx)
912 {
913 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
914 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
915 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
916 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
917 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
918 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
919 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
920 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
921
922 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
923 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
924 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
925
926 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
927 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
928 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
929
930 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
931 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
932 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
933 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
934
935 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
936 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
937 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
938 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
939 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
940
941 target_request_register_commands(cmd_ctx);
942 trace_register_commands(cmd_ctx);
943
944 return ERROR_OK;
945 }
946
947 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
948 {
949 target_t *target = targets;
950 int count = 0;
951
952 if (argc == 1)
953 {
954 int num = strtoul(args[0], NULL, 0);
955
956 while (target)
957 {
958 count++;
959 target = target->next;
960 }
961
962 if (num < count)
963 cmd_ctx->current_target = num;
964 else
965 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
966
967 return ERROR_OK;
968 }
969
970 while (target)
971 {
972 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
973 target = target->next;
974 }
975
976 return ERROR_OK;
977 }
978
979 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
980 {
981 int i;
982 int found = 0;
983
984 if (argc < 3)
985 {
986 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
987 exit(-1);
988 }
989
990 /* search for the specified target */
991 if (args[0] && (args[0][0] != 0))
992 {
993 for (i = 0; target_types[i]; i++)
994 {
995 if (strcmp(args[0], target_types[i]->name) == 0)
996 {
997 target_t **last_target_p = &targets;
998
999 /* register target specific commands */
1000 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1001 {
1002 ERROR("couldn't register '%s' commands", args[0]);
1003 exit(-1);
1004 }
1005
1006 if (*last_target_p)
1007 {
1008 while ((*last_target_p)->next)
1009 last_target_p = &((*last_target_p)->next);
1010 last_target_p = &((*last_target_p)->next);
1011 }
1012
1013 *last_target_p = malloc(sizeof(target_t));
1014
1015 (*last_target_p)->type = target_types[i];
1016
1017 if (strcmp(args[1], "big") == 0)
1018 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1019 else if (strcmp(args[1], "little") == 0)
1020 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1021 else
1022 {
1023 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1024 exit(-1);
1025 }
1026
1027 /* what to do on a target reset */
1028 if (strcmp(args[2], "reset_halt") == 0)
1029 (*last_target_p)->reset_mode = RESET_HALT;
1030 else if (strcmp(args[2], "reset_run") == 0)
1031 (*last_target_p)->reset_mode = RESET_RUN;
1032 else if (strcmp(args[2], "reset_init") == 0)
1033 (*last_target_p)->reset_mode = RESET_INIT;
1034 else if (strcmp(args[2], "run_and_halt") == 0)
1035 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1036 else if (strcmp(args[2], "run_and_init") == 0)
1037 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1038 else
1039 {
1040 ERROR("unknown target startup mode %s", args[2]);
1041 exit(-1);
1042 }
1043 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1044
1045 (*last_target_p)->reset_script = NULL;
1046 (*last_target_p)->post_halt_script = NULL;
1047 (*last_target_p)->pre_resume_script = NULL;
1048 (*last_target_p)->gdb_program_script = NULL;
1049
1050 (*last_target_p)->working_area = 0x0;
1051 (*last_target_p)->working_area_size = 0x0;
1052 (*last_target_p)->working_areas = NULL;
1053 (*last_target_p)->backup_working_area = 0;
1054
1055 (*last_target_p)->state = TARGET_UNKNOWN;
1056 (*last_target_p)->reg_cache = NULL;
1057 (*last_target_p)->breakpoints = NULL;
1058 (*last_target_p)->watchpoints = NULL;
1059 (*last_target_p)->next = NULL;
1060 (*last_target_p)->arch_info = NULL;
1061
1062 /* initialize trace information */
1063 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1064 (*last_target_p)->trace_info->num_trace_points = 0;
1065 (*last_target_p)->trace_info->trace_points_size = 0;
1066 (*last_target_p)->trace_info->trace_points = NULL;
1067 (*last_target_p)->trace_info->trace_history_size = 0;
1068 (*last_target_p)->trace_info->trace_history = NULL;
1069 (*last_target_p)->trace_info->trace_history_pos = 0;
1070 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1071
1072 (*last_target_p)->dbgmsg = NULL;
1073 (*last_target_p)->dbg_msg_enabled = 0;
1074
1075 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1076
1077 found = 1;
1078 break;
1079 }
1080 }
1081 }
1082
1083 /* no matching target found */
1084 if (!found)
1085 {
1086 ERROR("target '%s' not found", args[0]);
1087 exit(-1);
1088 }
1089
1090 return ERROR_OK;
1091 }
1092
1093 /* usage: target_script <target#> <event> <script_file> */
1094 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1095 {
1096 target_t *target = NULL;
1097
1098 if (argc < 3)
1099 {
1100 ERROR("incomplete target_script command");
1101 exit(-1);
1102 }
1103
1104 target = get_target_by_num(strtoul(args[0], NULL, 0));
1105
1106 if (!target)
1107 {
1108 ERROR("target number '%s' not defined", args[0]);
1109 exit(-1);
1110 }
1111
1112 if (strcmp(args[1], "reset") == 0)
1113 {
1114 if (target->reset_script)
1115 free(target->reset_script);
1116 target->reset_script = strdup(args[2]);
1117 }
1118 else if (strcmp(args[1], "post_halt") == 0)
1119 {
1120 if (target->post_halt_script)
1121 free(target->post_halt_script);
1122 target->post_halt_script = strdup(args[2]);
1123 }
1124 else if (strcmp(args[1], "pre_resume") == 0)
1125 {
1126 if (target->pre_resume_script)
1127 free(target->pre_resume_script);
1128 target->pre_resume_script = strdup(args[2]);
1129 }
1130 else if (strcmp(args[1], "gdb_program_config") == 0)
1131 {
1132 if (target->gdb_program_script)
1133 free(target->gdb_program_script);
1134 target->gdb_program_script = strdup(args[2]);
1135 }
1136 else
1137 {
1138 ERROR("unknown event type: '%s", args[1]);
1139 exit(-1);
1140 }
1141
1142 return ERROR_OK;
1143 }
1144
1145 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1146 {
1147 target_t *target = NULL;
1148
1149 if (argc < 2)
1150 {
1151 ERROR("incomplete run_and_halt_time command");
1152 exit(-1);
1153 }
1154
1155 target = get_target_by_num(strtoul(args[0], NULL, 0));
1156
1157 if (!target)
1158 {
1159 ERROR("target number '%s' not defined", args[0]);
1160 exit(-1);
1161 }
1162
1163 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1164
1165 return ERROR_OK;
1166 }
1167
1168 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1169 {
1170 target_t *target = NULL;
1171
1172 if (argc < 4)
1173 {
1174 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1175 exit(-1);
1176 }
1177
1178 target = get_target_by_num(strtoul(args[0], NULL, 0));
1179
1180 if (!target)
1181 {
1182 ERROR("target number '%s' not defined", args[0]);
1183 exit(-1);
1184 }
1185
1186 target->working_area = strtoul(args[1], NULL, 0);
1187 target->working_area_size = strtoul(args[2], NULL, 0);
1188
1189 if (strcmp(args[3], "backup") == 0)
1190 {
1191 target->backup_working_area = 1;
1192 }
1193 else if (strcmp(args[3], "nobackup") == 0)
1194 {
1195 target->backup_working_area = 0;
1196 }
1197 else
1198 {
1199 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1200 exit(-1);
1201 }
1202
1203 return ERROR_OK;
1204 }
1205
1206
1207 /* process target state changes */
1208 int handle_target(void *priv)
1209 {
1210 int retval;
1211 target_t *target = targets;
1212
1213 while (target)
1214 {
1215 /* only poll if target isn't already halted */
1216 if (target->state != TARGET_HALTED)
1217 {
1218 if (target_continous_poll)
1219 if ((retval = target->type->poll(target)) < 0)
1220 {
1221 ERROR("couldn't poll target. It's due for a reset.");
1222 }
1223 }
1224
1225 target = target->next;
1226 }
1227
1228 return ERROR_OK;
1229 }
1230
1231 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1232 {
1233 target_t *target;
1234 reg_t *reg = NULL;
1235 int count = 0;
1236 char *value;
1237
1238 DEBUG("-");
1239
1240 target = get_current_target(cmd_ctx);
1241
1242 /* list all available registers for the current target */
1243 if (argc == 0)
1244 {
1245 reg_cache_t *cache = target->reg_cache;
1246
1247 count = 0;
1248 while(cache)
1249 {
1250 int i;
1251 for (i = 0; i < cache->num_regs; i++)
1252 {
1253 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1254 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);
1255 free(value);
1256 }
1257 cache = cache->next;
1258 }
1259
1260 return ERROR_OK;
1261 }
1262
1263 /* access a single register by its ordinal number */
1264 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1265 {
1266 int num = strtoul(args[0], NULL, 0);
1267 reg_cache_t *cache = target->reg_cache;
1268
1269 count = 0;
1270 while(cache)
1271 {
1272 int i;
1273 for (i = 0; i < cache->num_regs; i++)
1274 {
1275 if (count++ == num)
1276 {
1277 reg = &cache->reg_list[i];
1278 break;
1279 }
1280 }
1281 if (reg)
1282 break;
1283 cache = cache->next;
1284 }
1285
1286 if (!reg)
1287 {
1288 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1289 return ERROR_OK;
1290 }
1291 } else /* access a single register by its name */
1292 {
1293 reg = register_get_by_name(target->reg_cache, args[0], 1);
1294
1295 if (!reg)
1296 {
1297 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1298 return ERROR_OK;
1299 }
1300 }
1301
1302 /* display a register */
1303 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1304 {
1305 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1306 reg->valid = 0;
1307
1308 if (reg->valid == 0)
1309 {
1310 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1311 if (arch_type == NULL)
1312 {
1313 ERROR("BUG: encountered unregistered arch type");
1314 return ERROR_OK;
1315 }
1316 arch_type->get(reg);
1317 }
1318 value = buf_to_str(reg->value, reg->size, 16);
1319 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1320 free(value);
1321 return ERROR_OK;
1322 }
1323
1324 /* set register value */
1325 if (argc == 2)
1326 {
1327 u8 *buf = malloc(CEIL(reg->size, 8));
1328 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1329
1330 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1331 if (arch_type == NULL)
1332 {
1333 ERROR("BUG: encountered unregistered arch type");
1334 return ERROR_OK;
1335 }
1336
1337 arch_type->set(reg, buf);
1338
1339 value = buf_to_str(reg->value, reg->size, 16);
1340 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1341 free(value);
1342
1343 free(buf);
1344
1345 return ERROR_OK;
1346 }
1347
1348 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1349
1350 return ERROR_OK;
1351 }
1352
1353 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1354 {
1355 target_t *target = get_current_target(cmd_ctx);
1356 char buffer[512];
1357
1358 if (argc == 0)
1359 {
1360 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1361 if (target->state == TARGET_HALTED)
1362 {
1363 target->type->arch_state(target, buffer, 512);
1364 buffer[511] = 0;
1365 command_print(cmd_ctx, "%s", buffer);
1366 }
1367 }
1368 else
1369 {
1370 if (strcmp(args[0], "on") == 0)
1371 {
1372 target_continous_poll = 1;
1373 }
1374 else if (strcmp(args[0], "off") == 0)
1375 {
1376 target_continous_poll = 0;
1377 }
1378 }
1379
1380
1381 return ERROR_OK;
1382 }
1383
1384 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1385 {
1386 target_t *target = get_current_target(cmd_ctx);
1387 struct timeval timeout, now;
1388
1389 gettimeofday(&timeout, NULL);
1390 if (!argc)
1391 timeval_add_time(&timeout, 5, 0);
1392 else {
1393 char *end;
1394
1395 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
1396 if (*end) {
1397 command_print(cmd_ctx, "usage: wait_halt [seconds]");
1398 return ERROR_OK;
1399 }
1400 }
1401
1402 command_print(cmd_ctx, "waiting for target halted...");
1403
1404 while(target->type->poll(target))
1405 {
1406 if (target->state == TARGET_HALTED)
1407 {
1408 command_print(cmd_ctx, "target halted");
1409 break;
1410 }
1411 target_call_timer_callbacks();
1412
1413 gettimeofday(&now, NULL);
1414 if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
1415 {
1416 command_print(cmd_ctx, "timed out while waiting for target halt");
1417 ERROR("timed out while waiting for target halt");
1418 break;
1419 }
1420 }
1421
1422 return ERROR_OK;
1423 }
1424
1425 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1426 {
1427 int retval;
1428 target_t *target = get_current_target(cmd_ctx);
1429
1430 DEBUG("-");
1431
1432 command_print(cmd_ctx, "requesting target halt...");
1433
1434 if ((retval = target->type->halt(target)) != ERROR_OK)
1435 {
1436 switch (retval)
1437 {
1438 case ERROR_TARGET_ALREADY_HALTED:
1439 command_print(cmd_ctx, "target already halted");
1440 break;
1441 case ERROR_TARGET_TIMEOUT:
1442 command_print(cmd_ctx, "target timed out... shutting down");
1443 return retval;
1444 default:
1445 command_print(cmd_ctx, "unknown error... shutting down");
1446 return retval;
1447 }
1448 }
1449
1450 return ERROR_OK;
1451
1452 }
1453
1454 /* what to do on daemon startup */
1455 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1456 {
1457 if (argc == 1)
1458 {
1459 if (strcmp(args[0], "attach") == 0)
1460 {
1461 startup_mode = DAEMON_ATTACH;
1462 return ERROR_OK;
1463 }
1464 else if (strcmp(args[0], "reset") == 0)
1465 {
1466 startup_mode = DAEMON_RESET;
1467 return ERROR_OK;
1468 }
1469 }
1470
1471 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1472 return ERROR_OK;
1473
1474 }
1475
1476 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1477 {
1478 target_t *target = get_current_target(cmd_ctx);
1479 int retval;
1480
1481 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1482
1483 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1484 {
1485 switch (retval)
1486 {
1487 case ERROR_TARGET_TIMEOUT:
1488 command_print(cmd_ctx, "target timed out... shutting down");
1489 exit(-1);
1490 default:
1491 command_print(cmd_ctx, "unknown error... shutting down");
1492 exit(-1);
1493 }
1494 }
1495
1496 return ERROR_OK;
1497 }
1498
1499 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1500 {
1501 target_t *target = get_current_target(cmd_ctx);
1502 enum target_reset_mode reset_mode = RESET_RUN;
1503
1504 DEBUG("-");
1505
1506 if (argc >= 1)
1507 {
1508 if (strcmp("run", args[0]) == 0)
1509 reset_mode = RESET_RUN;
1510 else if (strcmp("halt", args[0]) == 0)
1511 reset_mode = RESET_HALT;
1512 else if (strcmp("init", args[0]) == 0)
1513 reset_mode = RESET_INIT;
1514 else if (strcmp("run_and_halt", args[0]) == 0)
1515 {
1516 reset_mode = RESET_RUN_AND_HALT;
1517 if (argc >= 2)
1518 {
1519 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1520 }
1521 }
1522 else if (strcmp("run_and_init", args[0]) == 0)
1523 {
1524 reset_mode = RESET_RUN_AND_INIT;
1525 if (argc >= 2)
1526 {
1527 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1528 }
1529 }
1530 else
1531 {
1532 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1533 return ERROR_OK;
1534 }
1535 target->reset_mode = reset_mode;
1536 }
1537
1538 target_process_reset(cmd_ctx);
1539
1540 return ERROR_OK;
1541 }
1542
1543 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1544 {
1545 int retval;
1546 target_t *target = get_current_target(cmd_ctx);
1547
1548 DEBUG("-");
1549
1550 if (argc == 0)
1551 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1552 else if (argc == 1)
1553 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1554 else
1555 {
1556 command_print(cmd_ctx, "usage: resume [address]");
1557 return ERROR_OK;
1558 }
1559
1560 if (retval != ERROR_OK)
1561 {
1562 switch (retval)
1563 {
1564 case ERROR_TARGET_NOT_HALTED:
1565 command_print(cmd_ctx, "target not halted");
1566 break;
1567 default:
1568 command_print(cmd_ctx, "unknown error... shutting down");
1569 exit(-1);
1570 }
1571 }
1572
1573 return ERROR_OK;
1574 }
1575
1576 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1577 {
1578 target_t *target = get_current_target(cmd_ctx);
1579
1580 DEBUG("-");
1581
1582 if (argc == 0)
1583 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1584
1585 if (argc == 1)
1586 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1587
1588 return ERROR_OK;
1589 }
1590
1591 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1592 {
1593 const int line_bytecnt = 32;
1594 int count = 1;
1595 int size = 4;
1596 u32 address = 0;
1597 int line_modulo;
1598 int i;
1599
1600 char output[128];
1601 int output_len;
1602
1603 int retval;
1604
1605 u8 *buffer;
1606 target_t *target = get_current_target(cmd_ctx);
1607
1608 if (argc < 1)
1609 return ERROR_OK;
1610
1611 if (argc == 2)
1612 count = strtoul(args[1], NULL, 0);
1613
1614 address = strtoul(args[0], NULL, 0);
1615
1616
1617 switch (cmd[2])
1618 {
1619 case 'w':
1620 size = 4; line_modulo = line_bytecnt / 4;
1621 break;
1622 case 'h':
1623 size = 2; line_modulo = line_bytecnt / 2;
1624 break;
1625 case 'b':
1626 size = 1; line_modulo = line_bytecnt / 1;
1627 break;
1628 default:
1629 return ERROR_OK;
1630 }
1631
1632 buffer = calloc(count, size);
1633 retval = target->type->read_memory(target, address, size, count, buffer);
1634 if (retval != ERROR_OK)
1635 {
1636 switch (retval)
1637 {
1638 case ERROR_TARGET_UNALIGNED_ACCESS:
1639 command_print(cmd_ctx, "error: address not aligned");
1640 break;
1641 case ERROR_TARGET_NOT_HALTED:
1642 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1643 break;
1644 case ERROR_TARGET_DATA_ABORT:
1645 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1646 break;
1647 default:
1648 command_print(cmd_ctx, "error: unknown error");
1649 break;
1650 }
1651 return ERROR_OK;
1652 }
1653
1654 output_len = 0;
1655
1656 for (i = 0; i < count; i++)
1657 {
1658 if (i%line_modulo == 0)
1659 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1660
1661 switch (size)
1662 {
1663 case 4:
1664 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1665 break;
1666 case 2:
1667 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1668 break;
1669 case 1:
1670 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1671 break;
1672 }
1673
1674 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1675 {
1676 command_print(cmd_ctx, output);
1677 output_len = 0;
1678 }
1679 }
1680
1681 free(buffer);
1682
1683 return ERROR_OK;
1684 }
1685
1686 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1687 {
1688 u32 address = 0;
1689 u32 value = 0;
1690 int retval;
1691 target_t *target = get_current_target(cmd_ctx);
1692 u8 value_buf[4];
1693
1694 if (argc < 2)
1695 return ERROR_OK;
1696
1697 address = strtoul(args[0], NULL, 0);
1698 value = strtoul(args[1], NULL, 0);
1699
1700 switch (cmd[2])
1701 {
1702 case 'w':
1703 target_buffer_set_u32(target, value_buf, value);
1704 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1705 break;
1706 case 'h':
1707 target_buffer_set_u16(target, value_buf, value);
1708 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1709 break;
1710 case 'b':
1711 value_buf[0] = value;
1712 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1713 break;
1714 default:
1715 return ERROR_OK;
1716 }
1717
1718 switch (retval)
1719 {
1720 case ERROR_TARGET_UNALIGNED_ACCESS:
1721 command_print(cmd_ctx, "error: address not aligned");
1722 break;
1723 case ERROR_TARGET_DATA_ABORT:
1724 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1725 break;
1726 case ERROR_TARGET_NOT_HALTED:
1727 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1728 break;
1729 case ERROR_OK:
1730 break;
1731 default:
1732 command_print(cmd_ctx, "error: unknown error");
1733 break;
1734 }
1735
1736 return ERROR_OK;
1737
1738 }
1739
1740 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1741 {
1742 u8 *buffer;
1743 u32 buf_cnt;
1744 u32 image_size;
1745 int i;
1746 int retval;
1747
1748 image_t image;
1749
1750 duration_t duration;
1751 char *duration_text;
1752
1753 target_t *target = get_current_target(cmd_ctx);
1754
1755 if (argc < 1)
1756 {
1757 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1758 return ERROR_OK;
1759 }
1760
1761 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1762 if (argc >= 2)
1763 {
1764 image.base_address_set = 1;
1765 image.base_address = strtoul(args[1], NULL, 0);
1766 }
1767 else
1768 {
1769 image.base_address_set = 0;
1770 }
1771
1772 image.start_address_set = 0;
1773
1774 duration_start_measure(&duration);
1775
1776 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1777 {
1778 command_print(cmd_ctx, "load_image error: %s", image.error_str);
1779 return ERROR_OK;
1780 }
1781
1782 image_size = 0x0;
1783 for (i = 0; i < image.num_sections; i++)
1784 {
1785 buffer = malloc(image.sections[i].size);
1786 if (buffer==NULL)
1787 {
1788 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1789 break;
1790 }
1791 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1792 {
1793 ERROR("image_read_section failed with error code: %i", retval);
1794 command_print(cmd_ctx, "image reading failed, download aborted");
1795 free(buffer);
1796 image_close(&image);
1797 return ERROR_OK;
1798 }
1799 target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer);
1800 image_size += buf_cnt;
1801 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1802
1803 free(buffer);
1804 }
1805
1806 duration_stop_measure(&duration, &duration_text);
1807 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1808 free(duration_text);
1809
1810 image_close(&image);
1811
1812 return ERROR_OK;
1813
1814 }
1815
1816 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1817 {
1818 fileio_t fileio;
1819
1820 u32 address;
1821 u32 size;
1822 u8 buffer[560];
1823
1824 duration_t duration;
1825 char *duration_text;
1826
1827 target_t *target = get_current_target(cmd_ctx);
1828
1829 if (argc != 3)
1830 {
1831 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1832 return ERROR_OK;
1833 }
1834
1835 address = strtoul(args[1], NULL, 0);
1836 size = strtoul(args[2], NULL, 0);
1837
1838 if ((address & 3) || (size & 3))
1839 {
1840 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1841 return ERROR_OK;
1842 }
1843
1844 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
1845 {
1846 command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
1847 return ERROR_OK;
1848 }
1849
1850 duration_start_measure(&duration);
1851
1852 while (size > 0)
1853 {
1854 u32 size_written;
1855 u32 this_run_size = (size > 560) ? 560 : size;
1856
1857 target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1858 fileio_write(&fileio, this_run_size, buffer, &size_written);
1859
1860 size -= this_run_size;
1861 address += this_run_size;
1862 }
1863
1864 fileio_close(&fileio);
1865
1866 duration_stop_measure(&duration, &duration_text);
1867 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
1868 free(duration_text);
1869
1870 return ERROR_OK;
1871
1872 }
1873
1874 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1875 {
1876 u8 *buffer;
1877 u32 buf_cnt;
1878 u32 image_size;
1879 int i;
1880 int retval;
1881 u32 checksum = 0;
1882 u32 mem_checksum = 0;
1883
1884 image_t image;
1885
1886 duration_t duration;
1887 char *duration_text;
1888
1889 target_t *target = get_current_target(cmd_ctx);
1890
1891 if (argc < 1)
1892 {
1893 command_print(cmd_ctx, "usage: verify_image <file> [offset] [type]");
1894 return ERROR_OK;
1895 }
1896
1897 if (!target)
1898 {
1899 ERROR("no target selected");
1900 return ERROR_OK;
1901 }
1902
1903 duration_start_measure(&duration);
1904
1905 if (argc >= 2)
1906 {
1907 image.base_address_set = 1;
1908 image.base_address = strtoul(args[1], NULL, 0);
1909 }
1910 else
1911 {
1912 image.base_address_set = 0;
1913 image.base_address = 0x0;
1914 }
1915
1916 image.start_address_set = 0;
1917
1918 if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK)
1919 {
1920 command_print(cmd_ctx, "verify_image error: %s", image.error_str);
1921 return ERROR_OK;
1922 }
1923
1924 image_size = 0x0;
1925 for (i = 0; i < image.num_sections; i++)
1926 {
1927 buffer = malloc(image.sections[i].size);
1928 if (buffer==NULL)
1929 {
1930 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1931 break;
1932 }
1933 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1934 {
1935 ERROR("image_read_section failed with error code: %i", retval);
1936 command_print(cmd_ctx, "image reading failed, verify aborted");
1937 free(buffer);
1938 image_close(&image);
1939 return ERROR_OK;
1940 }
1941
1942 /* calculate checksum of image */
1943 image_calculate_checksum( buffer, buf_cnt, &checksum );
1944
1945 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
1946
1947 if( retval != ERROR_OK )
1948 {
1949 command_print(cmd_ctx, "image verify failed, verify aborted");
1950 free(buffer);
1951 image_close(&image);
1952 return ERROR_OK;
1953 }
1954
1955 if( checksum != mem_checksum )
1956 {
1957 /* failed crc checksum, fall back to a binary compare */
1958 u8 *data;
1959
1960 command_print(cmd_ctx, "image verify checksum failed - attempting binary compare");
1961
1962 data = (u8*)malloc(buf_cnt);
1963
1964 /* Can we use 32bit word accesses? */
1965 int size = 1;
1966 int count = buf_cnt;
1967 if ((count % 4) == 0)
1968 {
1969 size *= 4;
1970 count /= 4;
1971 }
1972 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
1973
1974 if (retval == ERROR_OK)
1975 {
1976 int t;
1977 for (t = 0; t < buf_cnt; t++)
1978 {
1979 if (data[t] != buffer[t])
1980 {
1981 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]);
1982 free(data);
1983 free(buffer);
1984 image_close(&image);
1985 return ERROR_OK;
1986 }
1987 }
1988 }
1989
1990 free(data);
1991 }
1992
1993 free(buffer);
1994 image_size += buf_cnt;
1995 }
1996
1997 duration_stop_measure(&duration, &duration_text);
1998 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
1999 free(duration_text);
2000
2001 image_close(&image);
2002
2003 return ERROR_OK;
2004 }
2005
2006 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2007 {
2008 int retval;
2009 target_t *target = get_current_target(cmd_ctx);
2010
2011 if (argc == 0)
2012 {
2013 breakpoint_t *breakpoint = target->breakpoints;
2014
2015 while (breakpoint)
2016 {
2017 if (breakpoint->type == BKPT_SOFT)
2018 {
2019 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2020 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2021 free(buf);
2022 }
2023 else
2024 {
2025 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2026 }
2027 breakpoint = breakpoint->next;
2028 }
2029 }
2030 else if (argc >= 2)
2031 {
2032 int hw = BKPT_SOFT;
2033 u32 length = 0;
2034
2035 length = strtoul(args[1], NULL, 0);
2036
2037 if (argc >= 3)
2038 if (strcmp(args[2], "hw") == 0)
2039 hw = BKPT_HARD;
2040
2041 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2042 {
2043 switch (retval)
2044 {
2045 case ERROR_TARGET_NOT_HALTED:
2046 command_print(cmd_ctx, "target must be halted to set breakpoints");
2047 break;
2048 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2049 command_print(cmd_ctx, "no more breakpoints available");
2050 break;
2051 default:
2052 command_print(cmd_ctx, "unknown error, breakpoint not set");
2053 break;
2054 }
2055 }
2056 else
2057 {
2058 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2059 }
2060 }
2061 else
2062 {
2063 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2064 }
2065
2066 return ERROR_OK;
2067 }
2068
2069 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2070 {
2071 target_t *target = get_current_target(cmd_ctx);
2072
2073 if (argc > 0)
2074 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2075
2076 return ERROR_OK;
2077 }
2078
2079 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2080 {
2081 target_t *target = get_current_target(cmd_ctx);
2082 int retval;
2083
2084 if (argc == 0)
2085 {
2086 watchpoint_t *watchpoint = target->watchpoints;
2087
2088 while (watchpoint)
2089 {
2090 command_print(cmd_ctx, "address: 0x%8.8x, mask: 0x%8.8x, r/w/a: %i, value: 0x%8.8x, mask: 0x%8.8x", watchpoint->address, watchpoint->length, watchpoint->rw, watchpoint->value, watchpoint->mask);
2091 watchpoint = watchpoint->next;
2092 }
2093 }
2094 else if (argc >= 2)
2095 {
2096 enum watchpoint_rw type = WPT_ACCESS;
2097 u32 data_value = 0x0;
2098 u32 data_mask = 0xffffffff;
2099
2100 if (argc >= 3)
2101 {
2102 switch(args[2][0])
2103 {
2104 case 'r':
2105 type = WPT_READ;
2106 break;
2107 case 'w':
2108 type = WPT_WRITE;
2109 break;
2110 case 'a':
2111 type = WPT_ACCESS;
2112 break;
2113 default:
2114 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2115 return ERROR_OK;
2116 }
2117 }
2118 if (argc >= 4)
2119 {
2120 data_value = strtoul(args[3], NULL, 0);
2121 }
2122 if (argc >= 5)
2123 {
2124 data_mask = strtoul(args[4], NULL, 0);
2125 }
2126
2127 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2128 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2129 {
2130 switch (retval)
2131 {
2132 case ERROR_TARGET_NOT_HALTED:
2133 command_print(cmd_ctx, "target must be halted to set watchpoints");
2134 break;
2135 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2136 command_print(cmd_ctx, "no more watchpoints available");
2137 break;
2138 default:
2139 command_print(cmd_ctx, "unknown error, watchpoint not set");
2140 break;
2141 }
2142 }
2143 }
2144 else
2145 {
2146 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2147 }
2148
2149 return ERROR_OK;
2150 }
2151
2152 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2153 {
2154 target_t *target = get_current_target(cmd_ctx);
2155
2156 if (argc > 0)
2157 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2158
2159 return ERROR_OK;
2160 }
2161
2162
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)