Code Review / openocd.git / blob
? search:


f9d957d69e0927b561c727b8e1d60b398fe93e00
[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 target_read_buffer(target, address, size, buffer);
768
769 /* convert to target endianess */
770 for (i = 0; i < (size/sizeof(u32)); i++)
771 {
772 u32 target_data;
773 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
774 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
775 }
776
777 retval = image_calculate_checksum( buffer, size, &checksum );
778 free(buffer);
779 }
780
781 *crc = checksum;
782
783 return retval;
784 }
785
786 int target_read_u32(struct target_s *target, u32 address, u32 *value)
787 {
788 u8 value_buf[4];
789
790 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
791
792 if (retval == ERROR_OK)
793 {
794 *value = target_buffer_get_u32(target, value_buf);
795 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
796 }
797 else
798 {
799 *value = 0x0;
800 DEBUG("address: 0x%8.8x failed", address);
801 }
802
803 return retval;
804 }
805
806 int target_read_u16(struct target_s *target, u32 address, u16 *value)
807 {
808 u8 value_buf[2];
809
810 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
811
812 if (retval == ERROR_OK)
813 {
814 *value = target_buffer_get_u16(target, value_buf);
815 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
816 }
817 else
818 {
819 *value = 0x0;
820 DEBUG("address: 0x%8.8x failed", address);
821 }
822
823 return retval;
824 }
825
826 int target_read_u8(struct target_s *target, u32 address, u8 *value)
827 {
828 int retval = target->type->read_memory(target, address, 1, 1, value);
829
830 if (retval == ERROR_OK)
831 {
832 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
833 }
834 else
835 {
836 *value = 0x0;
837 DEBUG("address: 0x%8.8x failed", address);
838 }
839
840 return retval;
841 }
842
843 int target_write_u32(struct target_s *target, u32 address, u32 value)
844 {
845 int retval;
846 u8 value_buf[4];
847
848 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
849
850 target_buffer_set_u32(target, value_buf, value);
851 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
852 {
853 DEBUG("failed: %i", retval);
854 }
855
856 return retval;
857 }
858
859 int target_write_u16(struct target_s *target, u32 address, u16 value)
860 {
861 int retval;
862 u8 value_buf[2];
863
864 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
865
866 target_buffer_set_u16(target, value_buf, value);
867 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
868 {
869 DEBUG("failed: %i", retval);
870 }
871
872 return retval;
873 }
874
875 int target_write_u8(struct target_s *target, u32 address, u8 value)
876 {
877 int retval;
878
879 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
880
881 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
882 {
883 DEBUG("failed: %i", retval);
884 }
885
886 return retval;
887 }
888
889 int target_register_user_commands(struct command_context_s *cmd_ctx)
890 {
891 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
892 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
893 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
894 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
895 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
896 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
897 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
898 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
899
900 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
901 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
902 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
903
904 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
905 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
906 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
907
908 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
909 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
910 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
911 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
912
913 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
914 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
915 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
916 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
917 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
918
919 target_request_register_commands(cmd_ctx);
920 trace_register_commands(cmd_ctx);
921
922 return ERROR_OK;
923 }
924
925 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
926 {
927 target_t *target = targets;
928 int count = 0;
929
930 if (argc == 1)
931 {
932 int num = strtoul(args[0], NULL, 0);
933
934 while (target)
935 {
936 count++;
937 target = target->next;
938 }
939
940 if (num < count)
941 cmd_ctx->current_target = num;
942 else
943 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
944
945 return ERROR_OK;
946 }
947
948 while (target)
949 {
950 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
951 target = target->next;
952 }
953
954 return ERROR_OK;
955 }
956
957 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
958 {
959 int i;
960 int found = 0;
961
962 if (argc < 3)
963 {
964 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
965 exit(-1);
966 }
967
968 /* search for the specified target */
969 if (args[0] && (args[0][0] != 0))
970 {
971 for (i = 0; target_types[i]; i++)
972 {
973 if (strcmp(args[0], target_types[i]->name) == 0)
974 {
975 target_t **last_target_p = &targets;
976
977 /* register target specific commands */
978 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
979 {
980 ERROR("couldn't register '%s' commands", args[0]);
981 exit(-1);
982 }
983
984 if (*last_target_p)
985 {
986 while ((*last_target_p)->next)
987 last_target_p = &((*last_target_p)->next);
988 last_target_p = &((*last_target_p)->next);
989 }
990
991 *last_target_p = malloc(sizeof(target_t));
992
993 (*last_target_p)->type = target_types[i];
994
995 if (strcmp(args[1], "big") == 0)
996 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
997 else if (strcmp(args[1], "little") == 0)
998 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
999 else
1000 {
1001 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1002 exit(-1);
1003 }
1004
1005 /* what to do on a target reset */
1006 if (strcmp(args[2], "reset_halt") == 0)
1007 (*last_target_p)->reset_mode = RESET_HALT;
1008 else if (strcmp(args[2], "reset_run") == 0)
1009 (*last_target_p)->reset_mode = RESET_RUN;
1010 else if (strcmp(args[2], "reset_init") == 0)
1011 (*last_target_p)->reset_mode = RESET_INIT;
1012 else if (strcmp(args[2], "run_and_halt") == 0)
1013 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1014 else if (strcmp(args[2], "run_and_init") == 0)
1015 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1016 else
1017 {
1018 ERROR("unknown target startup mode %s", args[2]);
1019 exit(-1);
1020 }
1021 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1022
1023 (*last_target_p)->reset_script = NULL;
1024 (*last_target_p)->post_halt_script = NULL;
1025 (*last_target_p)->pre_resume_script = NULL;
1026
1027 (*last_target_p)->working_area = 0x0;
1028 (*last_target_p)->working_area_size = 0x0;
1029 (*last_target_p)->working_areas = NULL;
1030 (*last_target_p)->backup_working_area = 0;
1031
1032 (*last_target_p)->state = TARGET_UNKNOWN;
1033 (*last_target_p)->reg_cache = NULL;
1034 (*last_target_p)->breakpoints = NULL;
1035 (*last_target_p)->watchpoints = NULL;
1036 (*last_target_p)->next = NULL;
1037 (*last_target_p)->arch_info = NULL;
1038
1039 /* initialize trace information */
1040 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1041 (*last_target_p)->trace_info->num_trace_points = 0;
1042 (*last_target_p)->trace_info->trace_points_size = 0;
1043 (*last_target_p)->trace_info->trace_points = NULL;
1044 (*last_target_p)->trace_info->trace_history_size = 0;
1045 (*last_target_p)->trace_info->trace_history = NULL;
1046 (*last_target_p)->trace_info->trace_history_pos = 0;
1047 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1048
1049 (*last_target_p)->dbgmsg = NULL;
1050
1051 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1052
1053 found = 1;
1054 break;
1055 }
1056 }
1057 }
1058
1059 /* no matching target found */
1060 if (!found)
1061 {
1062 ERROR("target '%s' not found", args[0]);
1063 exit(-1);
1064 }
1065
1066 return ERROR_OK;
1067 }
1068
1069 /* usage: target_script <target#> <event> <script_file> */
1070 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1071 {
1072 target_t *target = NULL;
1073
1074 if (argc < 3)
1075 {
1076 ERROR("incomplete target_script command");
1077 exit(-1);
1078 }
1079
1080 target = get_target_by_num(strtoul(args[0], NULL, 0));
1081
1082 if (!target)
1083 {
1084 ERROR("target number '%s' not defined", args[0]);
1085 exit(-1);
1086 }
1087
1088 if (strcmp(args[1], "reset") == 0)
1089 {
1090 if (target->reset_script)
1091 free(target->reset_script);
1092 target->reset_script = strdup(args[2]);
1093 }
1094 else if (strcmp(args[1], "post_halt") == 0)
1095 {
1096 if (target->post_halt_script)
1097 free(target->post_halt_script);
1098 target->post_halt_script = strdup(args[2]);
1099 }
1100 else if (strcmp(args[1], "pre_resume") == 0)
1101 {
1102 if (target->pre_resume_script)
1103 free(target->pre_resume_script);
1104 target->pre_resume_script = strdup(args[2]);
1105 }
1106 else
1107 {
1108 ERROR("unknown event type: '%s", args[1]);
1109 exit(-1);
1110 }
1111
1112 return ERROR_OK;
1113 }
1114
1115 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1116 {
1117 target_t *target = NULL;
1118
1119 if (argc < 2)
1120 {
1121 ERROR("incomplete run_and_halt_time command");
1122 exit(-1);
1123 }
1124
1125 target = get_target_by_num(strtoul(args[0], NULL, 0));
1126
1127 if (!target)
1128 {
1129 ERROR("target number '%s' not defined", args[0]);
1130 exit(-1);
1131 }
1132
1133 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1134
1135 return ERROR_OK;
1136 }
1137
1138 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1139 {
1140 target_t *target = NULL;
1141
1142 if (argc < 4)
1143 {
1144 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1145 exit(-1);
1146 }
1147
1148 target = get_target_by_num(strtoul(args[0], NULL, 0));
1149
1150 if (!target)
1151 {
1152 ERROR("target number '%s' not defined", args[0]);
1153 exit(-1);
1154 }
1155
1156 target->working_area = strtoul(args[1], NULL, 0);
1157 target->working_area_size = strtoul(args[2], NULL, 0);
1158
1159 if (strcmp(args[3], "backup") == 0)
1160 {
1161 target->backup_working_area = 1;
1162 }
1163 else if (strcmp(args[3], "nobackup") == 0)
1164 {
1165 target->backup_working_area = 0;
1166 }
1167 else
1168 {
1169 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1170 exit(-1);
1171 }
1172
1173 return ERROR_OK;
1174 }
1175
1176
1177 /* process target state changes */
1178 int handle_target(void *priv)
1179 {
1180 int retval;
1181 target_t *target = targets;
1182
1183 while (target)
1184 {
1185 /* only poll if target isn't already halted */
1186 if (target->state != TARGET_HALTED)
1187 {
1188 if (target_continous_poll)
1189 if ((retval = target->type->poll(target)) < 0)
1190 {
1191 ERROR("couldn't poll target, exiting");
1192 exit(-1);
1193 }
1194 }
1195
1196 target = target->next;
1197 }
1198
1199 return ERROR_OK;
1200 }
1201
1202 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1203 {
1204 target_t *target;
1205 reg_t *reg = NULL;
1206 int count = 0;
1207 char *value;
1208
1209 DEBUG("-");
1210
1211 target = get_current_target(cmd_ctx);
1212
1213 /* list all available registers for the current target */
1214 if (argc == 0)
1215 {
1216 reg_cache_t *cache = target->reg_cache;
1217
1218 count = 0;
1219 while(cache)
1220 {
1221 int i;
1222 for (i = 0; i < cache->num_regs; i++)
1223 {
1224 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1225 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);
1226 free(value);
1227 }
1228 cache = cache->next;
1229 }
1230
1231 return ERROR_OK;
1232 }
1233
1234 /* access a single register by its ordinal number */
1235 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1236 {
1237 int num = strtoul(args[0], NULL, 0);
1238 reg_cache_t *cache = target->reg_cache;
1239
1240 count = 0;
1241 while(cache)
1242 {
1243 int i;
1244 for (i = 0; i < cache->num_regs; i++)
1245 {
1246 if (count++ == num)
1247 {
1248 reg = &cache->reg_list[i];
1249 break;
1250 }
1251 }
1252 if (reg)
1253 break;
1254 cache = cache->next;
1255 }
1256
1257 if (!reg)
1258 {
1259 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1260 return ERROR_OK;
1261 }
1262 } else /* access a single register by its name */
1263 {
1264 reg = register_get_by_name(target->reg_cache, args[0], 1);
1265
1266 if (!reg)
1267 {
1268 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1269 return ERROR_OK;
1270 }
1271 }
1272
1273 /* display a register */
1274 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1275 {
1276 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1277 reg->valid = 0;
1278
1279 if (reg->valid == 0)
1280 {
1281 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1282 if (arch_type == NULL)
1283 {
1284 ERROR("BUG: encountered unregistered arch type");
1285 return ERROR_OK;
1286 }
1287 arch_type->get(reg);
1288 }
1289 value = buf_to_str(reg->value, reg->size, 16);
1290 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1291 free(value);
1292 return ERROR_OK;
1293 }
1294
1295 /* set register value */
1296 if (argc == 2)
1297 {
1298 u8 *buf = malloc(CEIL(reg->size, 8));
1299 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1300
1301 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1302 if (arch_type == NULL)
1303 {
1304 ERROR("BUG: encountered unregistered arch type");
1305 return ERROR_OK;
1306 }
1307
1308 arch_type->set(reg, buf);
1309
1310 value = buf_to_str(reg->value, reg->size, 16);
1311 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1312 free(value);
1313
1314 free(buf);
1315
1316 return ERROR_OK;
1317 }
1318
1319 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1320
1321 return ERROR_OK;
1322 }
1323
1324 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1325 {
1326 target_t *target = get_current_target(cmd_ctx);
1327 char buffer[512];
1328
1329 if (argc == 0)
1330 {
1331 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1332 if (target->state == TARGET_HALTED)
1333 {
1334 target->type->arch_state(target, buffer, 512);
1335 buffer[511] = 0;
1336 command_print(cmd_ctx, "%s", buffer);
1337 }
1338 }
1339 else
1340 {
1341 if (strcmp(args[0], "on") == 0)
1342 {
1343 target_continous_poll = 1;
1344 }
1345 else if (strcmp(args[0], "off") == 0)
1346 {
1347 target_continous_poll = 0;
1348 }
1349 }
1350
1351
1352 return ERROR_OK;
1353 }
1354
1355 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1356 {
1357 target_t *target = get_current_target(cmd_ctx);
1358 struct timeval timeout, now;
1359
1360 gettimeofday(&timeout, NULL);
1361 if (!argc)
1362 timeval_add_time(&timeout, 5, 0);
1363 else {
1364 char *end;
1365
1366 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
1367 if (*end) {
1368 command_print(cmd_ctx, "usage: wait_halt [seconds]");
1369 return ERROR_OK;
1370 }
1371 }
1372
1373 command_print(cmd_ctx, "waiting for target halted...");
1374
1375 while(target->type->poll(target))
1376 {
1377 if (target->state == TARGET_HALTED)
1378 {
1379 command_print(cmd_ctx, "target halted");
1380 break;
1381 }
1382 target_call_timer_callbacks();
1383
1384 gettimeofday(&now, NULL);
1385 if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
1386 {
1387 command_print(cmd_ctx, "timed out while waiting for target halt");
1388 ERROR("timed out while waiting for target halt");
1389 break;
1390 }
1391 }
1392
1393 return ERROR_OK;
1394 }
1395
1396 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1397 {
1398 int retval;
1399 target_t *target = get_current_target(cmd_ctx);
1400
1401 DEBUG("-");
1402
1403 command_print(cmd_ctx, "requesting target halt...");
1404
1405 if ((retval = target->type->halt(target)) != ERROR_OK)
1406 {
1407 switch (retval)
1408 {
1409 case ERROR_TARGET_ALREADY_HALTED:
1410 command_print(cmd_ctx, "target already halted");
1411 break;
1412 case ERROR_TARGET_TIMEOUT:
1413 command_print(cmd_ctx, "target timed out... shutting down");
1414 exit(-1);
1415 default:
1416 command_print(cmd_ctx, "unknown error... shutting down");
1417 exit(-1);
1418 }
1419 }
1420
1421 return ERROR_OK;
1422
1423 }
1424
1425 /* what to do on daemon startup */
1426 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1427 {
1428 if (argc == 1)
1429 {
1430 if (strcmp(args[0], "attach") == 0)
1431 {
1432 startup_mode = DAEMON_ATTACH;
1433 return ERROR_OK;
1434 }
1435 else if (strcmp(args[0], "reset") == 0)
1436 {
1437 startup_mode = DAEMON_RESET;
1438 return ERROR_OK;
1439 }
1440 }
1441
1442 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1443 return ERROR_OK;
1444
1445 }
1446
1447 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1448 {
1449 target_t *target = get_current_target(cmd_ctx);
1450 int retval;
1451
1452 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1453
1454 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1455 {
1456 switch (retval)
1457 {
1458 case ERROR_TARGET_TIMEOUT:
1459 command_print(cmd_ctx, "target timed out... shutting down");
1460 exit(-1);
1461 default:
1462 command_print(cmd_ctx, "unknown error... shutting down");
1463 exit(-1);
1464 }
1465 }
1466
1467 return ERROR_OK;
1468 }
1469
1470 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1471 {
1472 target_t *target = get_current_target(cmd_ctx);
1473 enum target_reset_mode reset_mode = RESET_RUN;
1474
1475 DEBUG("-");
1476
1477 if (argc >= 1)
1478 {
1479 if (strcmp("run", args[0]) == 0)
1480 reset_mode = RESET_RUN;
1481 else if (strcmp("halt", args[0]) == 0)
1482 reset_mode = RESET_HALT;
1483 else if (strcmp("init", args[0]) == 0)
1484 reset_mode = RESET_INIT;
1485 else if (strcmp("run_and_halt", args[0]) == 0)
1486 {
1487 reset_mode = RESET_RUN_AND_HALT;
1488 if (argc >= 2)
1489 {
1490 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1491 }
1492 }
1493 else if (strcmp("run_and_init", args[0]) == 0)
1494 {
1495 reset_mode = RESET_RUN_AND_INIT;
1496 if (argc >= 2)
1497 {
1498 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1499 }
1500 }
1501 else
1502 {
1503 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1504 return ERROR_OK;
1505 }
1506 target->reset_mode = reset_mode;
1507 }
1508
1509 target_process_reset(cmd_ctx);
1510
1511 return ERROR_OK;
1512 }
1513
1514 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1515 {
1516 int retval;
1517 target_t *target = get_current_target(cmd_ctx);
1518
1519 DEBUG("-");
1520
1521 if (argc == 0)
1522 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1523 else if (argc == 1)
1524 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1525 else
1526 {
1527 command_print(cmd_ctx, "usage: resume [address]");
1528 return ERROR_OK;
1529 }
1530
1531 if (retval != ERROR_OK)
1532 {
1533 switch (retval)
1534 {
1535 case ERROR_TARGET_NOT_HALTED:
1536 command_print(cmd_ctx, "target not halted");
1537 break;
1538 default:
1539 command_print(cmd_ctx, "unknown error... shutting down");
1540 exit(-1);
1541 }
1542 }
1543
1544 return ERROR_OK;
1545 }
1546
1547 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1548 {
1549 target_t *target = get_current_target(cmd_ctx);
1550
1551 DEBUG("-");
1552
1553 if (argc == 0)
1554 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1555
1556 if (argc == 1)
1557 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1558
1559 return ERROR_OK;
1560 }
1561
1562 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1563 {
1564 int count = 1;
1565 int size = 4;
1566 u32 address = 0;
1567 int i;
1568
1569 char output[128];
1570 int output_len;
1571
1572 int retval;
1573
1574 u8 *buffer;
1575 target_t *target = get_current_target(cmd_ctx);
1576
1577 if (argc < 1)
1578 return ERROR_OK;
1579
1580 if (argc == 2)
1581 count = strtoul(args[1], NULL, 0);
1582
1583 address = strtoul(args[0], NULL, 0);
1584
1585
1586 switch (cmd[2])
1587 {
1588 case 'w':
1589 size = 4;
1590 break;
1591 case 'h':
1592 size = 2;
1593 break;
1594 case 'b':
1595 size = 1;
1596 break;
1597 default:
1598 return ERROR_OK;
1599 }
1600
1601 buffer = calloc(count, size);
1602 if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
1603 {
1604 switch (retval)
1605 {
1606 case ERROR_TARGET_UNALIGNED_ACCESS:
1607 command_print(cmd_ctx, "error: address not aligned");
1608 break;
1609 case ERROR_TARGET_NOT_HALTED:
1610 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1611 break;
1612 case ERROR_TARGET_DATA_ABORT:
1613 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1614 break;
1615 default:
1616 command_print(cmd_ctx, "error: unknown error");
1617 break;
1618 }
1619 return ERROR_OK;
1620 }
1621
1622 output_len = 0;
1623
1624 for (i = 0; i < count; i++)
1625 {
1626 if (i%8 == 0)
1627 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1628
1629 switch (size)
1630 {
1631 case 4:
1632 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1633 break;
1634 case 2:
1635 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1636 break;
1637 case 1:
1638 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1639 break;
1640 }
1641
1642 if ((i%8 == 7) || (i == count - 1))
1643 {
1644 command_print(cmd_ctx, output);
1645 output_len = 0;
1646 }
1647 }
1648
1649 free(buffer);
1650
1651 return ERROR_OK;
1652 }
1653
1654 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1655 {
1656 u32 address = 0;
1657 u32 value = 0;
1658 int retval;
1659 target_t *target = get_current_target(cmd_ctx);
1660 u8 value_buf[4];
1661
1662 if (argc < 2)
1663 return ERROR_OK;
1664
1665 address = strtoul(args[0], NULL, 0);
1666 value = strtoul(args[1], NULL, 0);
1667
1668 switch (cmd[2])
1669 {
1670 case 'w':
1671 target_buffer_set_u32(target, value_buf, value);
1672 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1673 break;
1674 case 'h':
1675 target_buffer_set_u16(target, value_buf, value);
1676 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1677 break;
1678 case 'b':
1679 value_buf[0] = value;
1680 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1681 break;
1682 default:
1683 return ERROR_OK;
1684 }
1685
1686 switch (retval)
1687 {
1688 case ERROR_TARGET_UNALIGNED_ACCESS:
1689 command_print(cmd_ctx, "error: address not aligned");
1690 break;
1691 case ERROR_TARGET_DATA_ABORT:
1692 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1693 break;
1694 case ERROR_TARGET_NOT_HALTED:
1695 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1696 break;
1697 case ERROR_OK:
1698 break;
1699 default:
1700 command_print(cmd_ctx, "error: unknown error");
1701 break;
1702 }
1703
1704 return ERROR_OK;
1705
1706 }
1707
1708 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1709 {
1710 u8 *buffer;
1711 u32 buf_cnt;
1712 u32 image_size;
1713 int i;
1714 int retval;
1715
1716 image_t image;
1717
1718 duration_t duration;
1719 char *duration_text;
1720
1721 target_t *target = get_current_target(cmd_ctx);
1722
1723 if (argc < 1)
1724 {
1725 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1726 return ERROR_OK;
1727 }
1728
1729 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1730 if (argc >= 2)
1731 {
1732 image.base_address_set = 1;
1733 image.base_address = strtoul(args[1], NULL, 0);
1734 }
1735 else
1736 {
1737 image.base_address_set = 0;
1738 }
1739
1740 image.start_address_set = 0;
1741
1742 duration_start_measure(&duration);
1743
1744 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1745 {
1746 command_print(cmd_ctx, "load_image error: %s", image.error_str);
1747 return ERROR_OK;
1748 }
1749
1750 image_size = 0x0;
1751 for (i = 0; i < image.num_sections; i++)
1752 {
1753 buffer = malloc(image.sections[i].size);
1754 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1755 {
1756 ERROR("image_read_section failed with error code: %i", retval);
1757 command_print(cmd_ctx, "image reading failed, download aborted");
1758 free(buffer);
1759 image_close(&image);
1760 return ERROR_OK;
1761 }
1762 target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer);
1763 image_size += buf_cnt;
1764 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1765
1766 free(buffer);
1767 }
1768
1769 duration_stop_measure(&duration, &duration_text);
1770 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1771 free(duration_text);
1772
1773 image_close(&image);
1774
1775 return ERROR_OK;
1776
1777 }
1778
1779 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1780 {
1781 fileio_t fileio;
1782
1783 u32 address;
1784 u32 size;
1785 u8 buffer[560];
1786
1787 duration_t duration;
1788 char *duration_text;
1789
1790 target_t *target = get_current_target(cmd_ctx);
1791
1792 if (argc != 3)
1793 {
1794 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1795 return ERROR_OK;
1796 }
1797
1798 address = strtoul(args[1], NULL, 0);
1799 size = strtoul(args[2], NULL, 0);
1800
1801 if ((address & 3) || (size & 3))
1802 {
1803 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1804 return ERROR_OK;
1805 }
1806
1807 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
1808 {
1809 command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
1810 return ERROR_OK;
1811 }
1812
1813 duration_start_measure(&duration);
1814
1815 while (size > 0)
1816 {
1817 u32 size_written;
1818 u32 this_run_size = (size > 560) ? 560 : size;
1819
1820 target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1821 fileio_write(&fileio, this_run_size, buffer, &size_written);
1822
1823 size -= this_run_size;
1824 address += this_run_size;
1825 }
1826
1827 fileio_close(&fileio);
1828
1829 duration_stop_measure(&duration, &duration_text);
1830 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
1831 free(duration_text);
1832
1833 return ERROR_OK;
1834
1835 }
1836
1837 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1838 {
1839 u8 *buffer;
1840 u32 buf_cnt;
1841 u32 image_size;
1842 int i;
1843 int retval;
1844 u32 checksum = 0;
1845 u32 mem_checksum = 0;
1846
1847 image_t image;
1848
1849 duration_t duration;
1850 char *duration_text;
1851
1852 target_t *target = get_current_target(cmd_ctx);
1853
1854 if (argc < 1)
1855 {
1856 command_print(cmd_ctx, "usage: verify_image <file> [offset] [type]");
1857 return ERROR_OK;
1858 }
1859
1860 if (!target)
1861 {
1862 ERROR("no target selected");
1863 return ERROR_OK;
1864 }
1865
1866 duration_start_measure(&duration);
1867
1868 if (argc >= 2)
1869 {
1870 image.base_address_set = 1;
1871 image.base_address = strtoul(args[1], NULL, 0);
1872 }
1873 else
1874 {
1875 image.base_address_set = 0;
1876 image.base_address = 0x0;
1877 }
1878
1879 image.start_address_set = 0;
1880
1881 if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK)
1882 {
1883 command_print(cmd_ctx, "verify_image error: %s", image.error_str);
1884 return ERROR_OK;
1885 }
1886
1887 image_size = 0x0;
1888 for (i = 0; i < image.num_sections; i++)
1889 {
1890 buffer = malloc(image.sections[i].size);
1891 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1892 {
1893 ERROR("image_read_section failed with error code: %i", retval);
1894 command_print(cmd_ctx, "image reading failed, verify aborted");
1895 free(buffer);
1896 image_close(&image);
1897 return ERROR_OK;
1898 }
1899
1900 /* calculate checksum of image */
1901 image_calculate_checksum( buffer, buf_cnt, &checksum );
1902 free(buffer);
1903
1904 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
1905
1906 if( retval != ERROR_OK )
1907 {
1908 command_print(cmd_ctx, "image verify failed, verify aborted");
1909 image_close(&image);
1910 return ERROR_OK;
1911 }
1912
1913 if( checksum != mem_checksum )
1914 {
1915 command_print(cmd_ctx, "image verify failed, verify aborted");
1916 image_close(&image);
1917 return ERROR_OK;
1918 }
1919
1920 image_size += buf_cnt;
1921 }
1922
1923 duration_stop_measure(&duration, &duration_text);
1924 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
1925 free(duration_text);
1926
1927 image_close(&image);
1928
1929 return ERROR_OK;
1930 }
1931
1932 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1933 {
1934 int retval;
1935 target_t *target = get_current_target(cmd_ctx);
1936
1937 if (argc == 0)
1938 {
1939 breakpoint_t *breakpoint = target->breakpoints;
1940
1941 while (breakpoint)
1942 {
1943 if (breakpoint->type == BKPT_SOFT)
1944 {
1945 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
1946 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
1947 free(buf);
1948 }
1949 else
1950 {
1951 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
1952 }
1953 breakpoint = breakpoint->next;
1954 }
1955 }
1956 else if (argc >= 2)
1957 {
1958 int hw = BKPT_SOFT;
1959 u32 length = 0;
1960
1961 length = strtoul(args[1], NULL, 0);
1962
1963 if (argc >= 3)
1964 if (strcmp(args[2], "hw") == 0)
1965 hw = BKPT_HARD;
1966
1967 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
1968 {
1969 switch (retval)
1970 {
1971 case ERROR_TARGET_NOT_HALTED:
1972 command_print(cmd_ctx, "target must be halted to set breakpoints");
1973 break;
1974 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1975 command_print(cmd_ctx, "no more breakpoints available");
1976 break;
1977 default:
1978 command_print(cmd_ctx, "unknown error, breakpoint not set");
1979 break;
1980 }
1981 }
1982 else
1983 {
1984 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
1985 }
1986 }
1987 else
1988 {
1989 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
1990 }
1991
1992 return ERROR_OK;
1993 }
1994
1995 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1996 {
1997 target_t *target = get_current_target(cmd_ctx);
1998
1999 if (argc > 0)
2000 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2001
2002 return ERROR_OK;
2003 }
2004
2005 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2006 {
2007 target_t *target = get_current_target(cmd_ctx);
2008 int retval;
2009
2010 if (argc == 0)
2011 {
2012 watchpoint_t *watchpoint = target->watchpoints;
2013
2014 while (watchpoint)
2015 {
2016 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);
2017 watchpoint = watchpoint->next;
2018 }
2019 }
2020 else if (argc >= 2)
2021 {
2022 enum watchpoint_rw type = WPT_ACCESS;
2023 u32 data_value = 0x0;
2024 u32 data_mask = 0xffffffff;
2025
2026 if (argc >= 3)
2027 {
2028 switch(args[2][0])
2029 {
2030 case 'r':
2031 type = WPT_READ;
2032 break;
2033 case 'w':
2034 type = WPT_WRITE;
2035 break;
2036 case 'a':
2037 type = WPT_ACCESS;
2038 break;
2039 default:
2040 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2041 return ERROR_OK;
2042 }
2043 }
2044 if (argc >= 4)
2045 {
2046 data_value = strtoul(args[3], NULL, 0);
2047 }
2048 if (argc >= 5)
2049 {
2050 data_mask = strtoul(args[4], NULL, 0);
2051 }
2052
2053 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2054 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2055 {
2056 switch (retval)
2057 {
2058 case ERROR_TARGET_NOT_HALTED:
2059 command_print(cmd_ctx, "target must be halted to set watchpoints");
2060 break;
2061 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2062 command_print(cmd_ctx, "no more watchpoints available");
2063 break;
2064 default:
2065 command_print(cmd_ctx, "unknown error, watchpoint not set");
2066 break;
2067 }
2068 }
2069 }
2070 else
2071 {
2072 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2073 }
2074
2075 return ERROR_OK;
2076 }
2077
2078 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2079 {
2080 target_t *target = get_current_target(cmd_ctx);
2081
2082 if (argc > 0)
2083 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2084
2085 return ERROR_OK;
2086 }
2087
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)