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