ARM: shrink offsets
[openocd.git] / src / target / target.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007-2009 √ėyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008, Duane Ellis *
9 * openocd@duaneeellis.com *
10 * *
11 * Copyright (C) 2008 by Spencer Oliver *
12 * spen@spen-soft.co.uk *
13 * *
14 * Copyright (C) 2008 by Rick Altherr *
15 * kc8apf@kc8apf.net> *
16 * *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
21 * *
22 * This program is distributed in the hope that it will be useful, *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
25 * GNU General Public License for more details. *
26 * *
27 * You should have received a copy of the GNU General Public License *
28 * along with this program; if not, write to the *
29 * Free Software Foundation, Inc., *
30 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
31 ***************************************************************************/
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #include "target.h"
37 #include "target_type.h"
38 #include "target_request.h"
39 #include "time_support.h"
40 #include "register.h"
41 #include "trace.h"
42 #include "image.h"
43 #include "jtag.h"
44
45
46 static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
47
48 static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
49 static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
50 static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
51 static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
52 static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
53 static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
54 static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
55 static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
56 static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
57 static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
58 static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
59 static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
60 static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
61 static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
62 static int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
63 static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
64 static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
65 static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
66 static int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
67 static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
68 static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
69 static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
70
71 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
72 static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
73 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
74 static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
75
76 static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv);
77 static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv);
78
79 /* targets */
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 fa526_target;
87 extern target_type_t feroceon_target;
88 extern target_type_t dragonite_target;
89 extern target_type_t xscale_target;
90 extern target_type_t cortexm3_target;
91 extern target_type_t cortexa8_target;
92 extern target_type_t arm11_target;
93 extern target_type_t mips_m4k_target;
94 extern target_type_t avr_target;
95
96 target_type_t *target_types[] =
97 {
98 &arm7tdmi_target,
99 &arm9tdmi_target,
100 &arm920t_target,
101 &arm720t_target,
102 &arm966e_target,
103 &arm926ejs_target,
104 &fa526_target,
105 &feroceon_target,
106 &dragonite_target,
107 &xscale_target,
108 &cortexm3_target,
109 &cortexa8_target,
110 &arm11_target,
111 &mips_m4k_target,
112 &avr_target,
113 NULL,
114 };
115
116 target_t *all_targets = NULL;
117 target_event_callback_t *target_event_callbacks = NULL;
118 target_timer_callback_t *target_timer_callbacks = NULL;
119
120 const Jim_Nvp nvp_assert[] = {
121 { .name = "assert", NVP_ASSERT },
122 { .name = "deassert", NVP_DEASSERT },
123 { .name = "T", NVP_ASSERT },
124 { .name = "F", NVP_DEASSERT },
125 { .name = "t", NVP_ASSERT },
126 { .name = "f", NVP_DEASSERT },
127 { .name = NULL, .value = -1 }
128 };
129
130 const Jim_Nvp nvp_error_target[] = {
131 { .value = ERROR_TARGET_INVALID, .name = "err-invalid" },
132 { .value = ERROR_TARGET_INIT_FAILED, .name = "err-init-failed" },
133 { .value = ERROR_TARGET_TIMEOUT, .name = "err-timeout" },
134 { .value = ERROR_TARGET_NOT_HALTED, .name = "err-not-halted" },
135 { .value = ERROR_TARGET_FAILURE, .name = "err-failure" },
136 { .value = ERROR_TARGET_UNALIGNED_ACCESS , .name = "err-unaligned-access" },
137 { .value = ERROR_TARGET_DATA_ABORT , .name = "err-data-abort" },
138 { .value = ERROR_TARGET_RESOURCE_NOT_AVAILABLE , .name = "err-resource-not-available" },
139 { .value = ERROR_TARGET_TRANSLATION_FAULT , .name = "err-translation-fault" },
140 { .value = ERROR_TARGET_NOT_RUNNING, .name = "err-not-running" },
141 { .value = ERROR_TARGET_NOT_EXAMINED, .name = "err-not-examined" },
142 { .value = -1, .name = NULL }
143 };
144
145 const char *target_strerror_safe(int err)
146 {
147 const Jim_Nvp *n;
148
149 n = Jim_Nvp_value2name_simple(nvp_error_target, err);
150 if (n->name == NULL) {
151 return "unknown";
152 } else {
153 return n->name;
154 }
155 }
156
157 static const Jim_Nvp nvp_target_event[] = {
158 { .value = TARGET_EVENT_OLD_gdb_program_config , .name = "old-gdb_program_config" },
159 { .value = TARGET_EVENT_OLD_pre_resume , .name = "old-pre_resume" },
160
161 { .value = TARGET_EVENT_GDB_HALT, .name = "gdb-halt" },
162 { .value = TARGET_EVENT_HALTED, .name = "halted" },
163 { .value = TARGET_EVENT_RESUMED, .name = "resumed" },
164 { .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
165 { .value = TARGET_EVENT_RESUME_END, .name = "resume-end" },
166
167 { .name = "gdb-start", .value = TARGET_EVENT_GDB_START },
168 { .name = "gdb-end", .value = TARGET_EVENT_GDB_END },
169
170 /* historical name */
171
172 { .value = TARGET_EVENT_RESET_START, .name = "reset-start" },
173
174 { .value = TARGET_EVENT_RESET_ASSERT_PRE, .name = "reset-assert-pre" },
175 { .value = TARGET_EVENT_RESET_ASSERT_POST, .name = "reset-assert-post" },
176 { .value = TARGET_EVENT_RESET_DEASSERT_PRE, .name = "reset-deassert-pre" },
177 { .value = TARGET_EVENT_RESET_DEASSERT_POST, .name = "reset-deassert-post" },
178 { .value = TARGET_EVENT_RESET_HALT_PRE, .name = "reset-halt-pre" },
179 { .value = TARGET_EVENT_RESET_HALT_POST, .name = "reset-halt-post" },
180 { .value = TARGET_EVENT_RESET_WAIT_PRE, .name = "reset-wait-pre" },
181 { .value = TARGET_EVENT_RESET_WAIT_POST, .name = "reset-wait-post" },
182 { .value = TARGET_EVENT_RESET_INIT , .name = "reset-init" },
183 { .value = TARGET_EVENT_RESET_END, .name = "reset-end" },
184
185 { .value = TARGET_EVENT_EXAMINE_START, .name = "examine-start" },
186 { .value = TARGET_EVENT_EXAMINE_END, .name = "examine-end" },
187
188 { .value = TARGET_EVENT_DEBUG_HALTED, .name = "debug-halted" },
189 { .value = TARGET_EVENT_DEBUG_RESUMED, .name = "debug-resumed" },
190
191 { .value = TARGET_EVENT_GDB_ATTACH, .name = "gdb-attach" },
192 { .value = TARGET_EVENT_GDB_DETACH, .name = "gdb-detach" },
193
194 { .value = TARGET_EVENT_GDB_FLASH_WRITE_START, .name = "gdb-flash-write-start" },
195 { .value = TARGET_EVENT_GDB_FLASH_WRITE_END , .name = "gdb-flash-write-end" },
196
197 { .value = TARGET_EVENT_GDB_FLASH_ERASE_START, .name = "gdb-flash-erase-start" },
198 { .value = TARGET_EVENT_GDB_FLASH_ERASE_END , .name = "gdb-flash-erase-end" },
199
200 { .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
201 { .value = TARGET_EVENT_RESUMED , .name = "resume-ok" },
202 { .value = TARGET_EVENT_RESUME_END , .name = "resume-end" },
203
204 { .name = NULL, .value = -1 }
205 };
206
207 const Jim_Nvp nvp_target_state[] = {
208 { .name = "unknown", .value = TARGET_UNKNOWN },
209 { .name = "running", .value = TARGET_RUNNING },
210 { .name = "halted", .value = TARGET_HALTED },
211 { .name = "reset", .value = TARGET_RESET },
212 { .name = "debug-running", .value = TARGET_DEBUG_RUNNING },
213 { .name = NULL, .value = -1 },
214 };
215
216 const Jim_Nvp nvp_target_debug_reason [] = {
217 { .name = "debug-request" , .value = DBG_REASON_DBGRQ },
218 { .name = "breakpoint" , .value = DBG_REASON_BREAKPOINT },
219 { .name = "watchpoint" , .value = DBG_REASON_WATCHPOINT },
220 { .name = "watchpoint-and-breakpoint", .value = DBG_REASON_WPTANDBKPT },
221 { .name = "single-step" , .value = DBG_REASON_SINGLESTEP },
222 { .name = "target-not-halted" , .value = DBG_REASON_NOTHALTED },
223 { .name = "undefined" , .value = DBG_REASON_UNDEFINED },
224 { .name = NULL, .value = -1 },
225 };
226
227 const Jim_Nvp nvp_target_endian[] = {
228 { .name = "big", .value = TARGET_BIG_ENDIAN },
229 { .name = "little", .value = TARGET_LITTLE_ENDIAN },
230 { .name = "be", .value = TARGET_BIG_ENDIAN },
231 { .name = "le", .value = TARGET_LITTLE_ENDIAN },
232 { .name = NULL, .value = -1 },
233 };
234
235 const Jim_Nvp nvp_reset_modes[] = {
236 { .name = "unknown", .value = RESET_UNKNOWN },
237 { .name = "run" , .value = RESET_RUN },
238 { .name = "halt" , .value = RESET_HALT },
239 { .name = "init" , .value = RESET_INIT },
240 { .name = NULL , .value = -1 },
241 };
242
243 const char *
244 target_state_name( target_t *t )
245 {
246 const char *cp;
247 cp = Jim_Nvp_value2name_simple(nvp_target_state, t->state)->name;
248 if( !cp ){
249 LOG_ERROR("Invalid target state: %d", (int)(t->state));
250 cp = "(*BUG*unknown*BUG*)";
251 }
252 return cp;
253 }
254
255 /* determine the number of the new target */
256 static int new_target_number(void)
257 {
258 target_t *t;
259 int x;
260
261 /* number is 0 based */
262 x = -1;
263 t = all_targets;
264 while (t) {
265 if (x < t->target_number) {
266 x = t->target_number;
267 }
268 t = t->next;
269 }
270 return x + 1;
271 }
272
273 /* read a uint32_t from a buffer in target memory endianness */
274 uint32_t target_buffer_get_u32(target_t *target, const uint8_t *buffer)
275 {
276 if (target->endianness == TARGET_LITTLE_ENDIAN)
277 return le_to_h_u32(buffer);
278 else
279 return be_to_h_u32(buffer);
280 }
281
282 /* read a uint16_t from a buffer in target memory endianness */
283 uint16_t target_buffer_get_u16(target_t *target, const uint8_t *buffer)
284 {
285 if (target->endianness == TARGET_LITTLE_ENDIAN)
286 return le_to_h_u16(buffer);
287 else
288 return be_to_h_u16(buffer);
289 }
290
291 /* read a uint8_t from a buffer in target memory endianness */
292 uint8_t target_buffer_get_u8(target_t *target, const uint8_t *buffer)
293 {
294 return *buffer & 0x0ff;
295 }
296
297 /* write a uint32_t to a buffer in target memory endianness */
298 void target_buffer_set_u32(target_t *target, uint8_t *buffer, uint32_t value)
299 {
300 if (target->endianness == TARGET_LITTLE_ENDIAN)
301 h_u32_to_le(buffer, value);
302 else
303 h_u32_to_be(buffer, value);
304 }
305
306 /* write a uint16_t to a buffer in target memory endianness */
307 void target_buffer_set_u16(target_t *target, uint8_t *buffer, uint16_t value)
308 {
309 if (target->endianness == TARGET_LITTLE_ENDIAN)
310 h_u16_to_le(buffer, value);
311 else
312 h_u16_to_be(buffer, value);
313 }
314
315 /* write a uint8_t to a buffer in target memory endianness */
316 void target_buffer_set_u8(target_t *target, uint8_t *buffer, uint8_t value)
317 {
318 *buffer = value;
319 }
320
321 /* return a pointer to a configured target; id is name or number */
322 target_t *get_target(const char *id)
323 {
324 target_t *target;
325
326 /* try as tcltarget name */
327 for (target = all_targets; target; target = target->next) {
328 if (target->cmd_name == NULL)
329 continue;
330 if (strcmp(id, target->cmd_name) == 0)
331 return target;
332 }
333
334 /* It's OK to remove this fallback sometime after August 2010 or so */
335
336 /* no match, try as number */
337 unsigned num;
338 if (parse_uint(id, &num) != ERROR_OK)
339 return NULL;
340
341 for (target = all_targets; target; target = target->next) {
342 if (target->target_number == (int)num) {
343 LOG_WARNING("use '%s' as target identifier, not '%u'",
344 target->cmd_name, num);
345 return target;
346 }
347 }
348
349 return NULL;
350 }
351
352 /* returns a pointer to the n-th configured target */
353 static target_t *get_target_by_num(int num)
354 {
355 target_t *target = all_targets;
356
357 while (target) {
358 if (target->target_number == num) {
359 return target;
360 }
361 target = target->next;
362 }
363
364 return NULL;
365 }
366
367 target_t* get_current_target(command_context_t *cmd_ctx)
368 {
369 target_t *target = get_target_by_num(cmd_ctx->current_target);
370
371 if (target == NULL)
372 {
373 LOG_ERROR("BUG: current_target out of bounds");
374 exit(-1);
375 }
376
377 return target;
378 }
379
380 int target_poll(struct target_s *target)
381 {
382 int retval;
383
384 /* We can't poll until after examine */
385 if (!target_was_examined(target))
386 {
387 /* Fail silently lest we pollute the log */
388 return ERROR_FAIL;
389 }
390
391 retval = target->type->poll(target);
392 if (retval != ERROR_OK)
393 return retval;
394
395 if (target->halt_issued)
396 {
397 if (target->state == TARGET_HALTED)
398 {
399 target->halt_issued = false;
400 } else
401 {
402 long long t = timeval_ms() - target->halt_issued_time;
403 if (t>1000)
404 {
405 target->halt_issued = false;
406 LOG_INFO("Halt timed out, wake up GDB.");
407 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
408 }
409 }
410 }
411
412 return ERROR_OK;
413 }
414
415 int target_halt(struct target_s *target)
416 {
417 int retval;
418 /* We can't poll until after examine */
419 if (!target_was_examined(target))
420 {
421 LOG_ERROR("Target not examined yet");
422 return ERROR_FAIL;
423 }
424
425 retval = target->type->halt(target);
426 if (retval != ERROR_OK)
427 return retval;
428
429 target->halt_issued = true;
430 target->halt_issued_time = timeval_ms();
431
432 return ERROR_OK;
433 }
434
435 int target_resume(struct target_s *target, int current, uint32_t address, int handle_breakpoints, int debug_execution)
436 {
437 int retval;
438
439 /* We can't poll until after examine */
440 if (!target_was_examined(target))
441 {
442 LOG_ERROR("Target not examined yet");
443 return ERROR_FAIL;
444 }
445
446 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
447 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
448 * the application.
449 */
450 if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
451 return retval;
452
453 return retval;
454 }
455
456 int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
457 {
458 char buf[100];
459 int retval;
460 Jim_Nvp *n;
461 n = Jim_Nvp_value2name_simple(nvp_reset_modes, reset_mode);
462 if (n->name == NULL) {
463 LOG_ERROR("invalid reset mode");
464 return ERROR_FAIL;
465 }
466
467 /* disable polling during reset to make reset event scripts
468 * more predictable, i.e. dr/irscan & pathmove in events will
469 * not have JTAG operations injected into the middle of a sequence.
470 */
471 bool save_poll = jtag_poll_get_enabled();
472
473 jtag_poll_set_enabled(false);
474
475 sprintf(buf, "ocd_process_reset %s", n->name);
476 retval = Jim_Eval(interp, buf);
477
478 jtag_poll_set_enabled(save_poll);
479
480 if (retval != JIM_OK) {
481 Jim_PrintErrorMessage(interp);
482 return ERROR_FAIL;
483 }
484
485 /* We want any events to be processed before the prompt */
486 retval = target_call_timer_callbacks_now();
487
488 return retval;
489 }
490
491 static int default_virt2phys(struct target_s *target, uint32_t virtual, uint32_t *physical)
492 {
493 *physical = virtual;
494 return ERROR_OK;
495 }
496
497 static int default_mmu(struct target_s *target, int *enabled)
498 {
499 LOG_ERROR("Not implemented.");
500 return ERROR_FAIL;
501 }
502
503 static int default_has_mmu(struct target_s *target, bool *has_mmu)
504 {
505 *has_mmu = true;
506 return ERROR_OK;
507 }
508
509 static int default_examine(struct target_s *target)
510 {
511 target_set_examined(target);
512 return ERROR_OK;
513 }
514
515 int target_examine_one(struct target_s *target)
516 {
517 return target->type->examine(target);
518 }
519
520 static int jtag_enable_callback(enum jtag_event event, void *priv)
521 {
522 target_t *target = priv;
523
524 if (event != JTAG_TAP_EVENT_ENABLE || !target->tap->enabled)
525 return ERROR_OK;
526
527 jtag_unregister_event_callback(jtag_enable_callback, target);
528 return target_examine_one(target);
529 }
530
531
532 /* Targets that correctly implement init + examine, i.e.
533 * no communication with target during init:
534 *
535 * XScale
536 */
537 int target_examine(void)
538 {
539 int retval = ERROR_OK;
540 target_t *target;
541
542 for (target = all_targets; target; target = target->next)
543 {
544 /* defer examination, but don't skip it */
545 if (!target->tap->enabled) {
546 jtag_register_event_callback(jtag_enable_callback,
547 target);
548 continue;
549 }
550 if ((retval = target_examine_one(target)) != ERROR_OK)
551 return retval;
552 }
553 return retval;
554 }
555 const char *target_get_name(struct target_s *target)
556 {
557 return target->type->name;
558 }
559
560 static int target_write_memory_imp(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
561 {
562 if (!target_was_examined(target))
563 {
564 LOG_ERROR("Target not examined yet");
565 return ERROR_FAIL;
566 }
567 return target->type->write_memory_imp(target, address, size, count, buffer);
568 }
569
570 static int target_read_memory_imp(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
571 {
572 if (!target_was_examined(target))
573 {
574 LOG_ERROR("Target not examined yet");
575 return ERROR_FAIL;
576 }
577 return target->type->read_memory_imp(target, address, size, count, buffer);
578 }
579
580 static int target_soft_reset_halt_imp(struct target_s *target)
581 {
582 if (!target_was_examined(target))
583 {
584 LOG_ERROR("Target not examined yet");
585 return ERROR_FAIL;
586 }
587 if (!target->type->soft_reset_halt_imp) {
588 LOG_ERROR("Target %s does not support soft_reset_halt",
589 target->cmd_name);
590 return ERROR_FAIL;
591 }
592 return target->type->soft_reset_halt_imp(target);
593 }
594
595 static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, uint32_t entry_point, uint32_t exit_point, int timeout_ms, void *arch_info)
596 {
597 if (!target_was_examined(target))
598 {
599 LOG_ERROR("Target not examined yet");
600 return ERROR_FAIL;
601 }
602 return target->type->run_algorithm_imp(target, num_mem_params, mem_params, num_reg_params, reg_param, entry_point, exit_point, timeout_ms, arch_info);
603 }
604
605 int target_read_memory(struct target_s *target,
606 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
607 {
608 return target->type->read_memory(target, address, size, count, buffer);
609 }
610
611 int target_read_phys_memory(struct target_s *target,
612 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
613 {
614 return target->type->read_phys_memory(target, address, size, count, buffer);
615 }
616
617 int target_write_memory(struct target_s *target,
618 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
619 {
620 return target->type->write_memory(target, address, size, count, buffer);
621 }
622
623 int target_write_phys_memory(struct target_s *target,
624 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
625 {
626 return target->type->write_phys_memory(target, address, size, count, buffer);
627 }
628
629 int target_bulk_write_memory(struct target_s *target,
630 uint32_t address, uint32_t count, uint8_t *buffer)
631 {
632 return target->type->bulk_write_memory(target, address, count, buffer);
633 }
634
635 int target_add_breakpoint(struct target_s *target,
636 struct breakpoint_s *breakpoint)
637 {
638 return target->type->add_breakpoint(target, breakpoint);
639 }
640 int target_remove_breakpoint(struct target_s *target,
641 struct breakpoint_s *breakpoint)
642 {
643 return target->type->remove_breakpoint(target, breakpoint);
644 }
645
646 int target_add_watchpoint(struct target_s *target,
647 struct watchpoint_s *watchpoint)
648 {
649 return target->type->add_watchpoint(target, watchpoint);
650 }
651 int target_remove_watchpoint(struct target_s *target,
652 struct watchpoint_s *watchpoint)
653 {
654 return target->type->remove_watchpoint(target, watchpoint);
655 }
656
657 int target_get_gdb_reg_list(struct target_s *target,
658 struct reg_s **reg_list[], int *reg_list_size)
659 {
660 return target->type->get_gdb_reg_list(target, reg_list, reg_list_size);
661 }
662 int target_step(struct target_s *target,
663 int current, uint32_t address, int handle_breakpoints)
664 {
665 return target->type->step(target, current, address, handle_breakpoints);
666 }
667
668
669 int target_run_algorithm(struct target_s *target,
670 int num_mem_params, mem_param_t *mem_params,
671 int num_reg_params, reg_param_t *reg_param,
672 uint32_t entry_point, uint32_t exit_point,
673 int timeout_ms, void *arch_info)
674 {
675 return target->type->run_algorithm(target,
676 num_mem_params, mem_params, num_reg_params, reg_param,
677 entry_point, exit_point, timeout_ms, arch_info);
678 }
679
680 /// @returns @c true if the target has been examined.
681 bool target_was_examined(struct target_s *target)
682 {
683 return target->type->examined;
684 }
685 /// Sets the @c examined flag for the given target.
686 void target_set_examined(struct target_s *target)
687 {
688 target->type->examined = true;
689 }
690 // Reset the @c examined flag for the given target.
691 void target_reset_examined(struct target_s *target)
692 {
693 target->type->examined = false;
694 }
695
696
697
698 static int default_mrc(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value)
699 {
700 LOG_ERROR("Not implemented");
701 return ERROR_FAIL;
702 }
703
704 static int default_mcr(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value)
705 {
706 LOG_ERROR("Not implemented");
707 return ERROR_FAIL;
708 }
709
710 static int arm_cp_check(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm)
711 {
712 /* basic check */
713 if (!target_was_examined(target))
714 {
715 LOG_ERROR("Target not examined yet");
716 return ERROR_FAIL;
717 }
718
719 if ((cpnum <0) || (cpnum > 15))
720 {
721 LOG_ERROR("Illegal co-processor %d", cpnum);
722 return ERROR_FAIL;
723 }
724
725 if (op1 > 7)
726 {
727 LOG_ERROR("Illegal op1");
728 return ERROR_FAIL;
729 }
730
731 if (op2 > 7)
732 {
733 LOG_ERROR("Illegal op2");
734 return ERROR_FAIL;
735 }
736
737 if (CRn > 15)
738 {
739 LOG_ERROR("Illegal CRn");
740 return ERROR_FAIL;
741 }
742
743 if (CRm > 15)
744 {
745 LOG_ERROR("Illegal CRm");
746 return ERROR_FAIL;
747 }
748
749 return ERROR_OK;
750 }
751
752 int target_mrc(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value)
753 {
754 int retval;
755
756 retval = arm_cp_check(target, cpnum, op1, op2, CRn, CRm);
757 if (retval != ERROR_OK)
758 return retval;
759
760 return target->type->mrc(target, cpnum, op1, op2, CRn, CRm, value);
761 }
762
763 int target_mcr(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value)
764 {
765 int retval;
766
767 retval = arm_cp_check(target, cpnum, op1, op2, CRn, CRm);
768 if (retval != ERROR_OK)
769 return retval;
770
771 return target->type->mcr(target, cpnum, op1, op2, CRn, CRm, value);
772 }
773
774 static int default_read_phys_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
775 {
776 int retval;
777 bool mmu;
778 retval = target->type->has_mmu(target, &mmu);
779 if (retval != ERROR_OK)
780 return retval;
781 if (mmu)
782 {
783 LOG_ERROR("Not implemented");
784 return ERROR_FAIL;
785 }
786 return target_read_memory(target, address, size, count, buffer);
787 }
788
789 static int default_write_phys_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
790 {
791 int retval;
792 bool mmu;
793 retval = target->type->has_mmu(target, &mmu);
794 if (retval != ERROR_OK)
795 return retval;
796 if (mmu)
797 {
798 LOG_ERROR("Not implemented");
799 return ERROR_FAIL;
800 }
801 return target_write_memory(target, address, size, count, buffer);
802 }
803
804
805 int target_init(struct command_context_s *cmd_ctx)
806 {
807 target_t *target = all_targets;
808 int retval;
809
810 while (target)
811 {
812 target_reset_examined(target);
813 if (target->type->examine == NULL)
814 {
815 target->type->examine = default_examine;
816 }
817
818 if ((retval = target->type->init_target(cmd_ctx, target)) != ERROR_OK)
819 {
820 LOG_ERROR("target '%s' init failed", target_get_name(target));
821 return retval;
822 }
823
824 /* Set up default functions if none are provided by target */
825 if (target->type->virt2phys == NULL)
826 {
827 target->type->virt2phys = default_virt2phys;
828 }
829
830 if (target->type->read_phys_memory == NULL)
831 {
832 target->type->read_phys_memory = default_read_phys_memory;
833 }
834
835 if (target->type->write_phys_memory == NULL)
836 {
837 target->type->write_phys_memory = default_write_phys_memory;
838 }
839
840 if (target->type->mcr == NULL)
841 {
842 target->type->mcr = default_mcr;
843 } else
844 {
845 /* FIX! multiple targets will generally register global commands
846 * multiple times. Only register this one if *one* of the
847 * targets need the command. Hmm... make it a command on the
848 * Jim Tcl target object?
849 */
850 register_jim(cmd_ctx, "mcr", jim_mcrmrc, "write coprocessor <cpnum> <op1> <op2> <CRn> <CRm> <value>");
851 }
852
853 if (target->type->mrc == NULL)
854 {
855 target->type->mrc = default_mrc;
856 } else
857 {
858 register_jim(cmd_ctx, "mrc", jim_mcrmrc, "read coprocessor <cpnum> <op1> <op2> <CRn> <CRm>");
859 }
860
861
862 /* a non-invasive way(in terms of patches) to add some code that
863 * runs before the type->write/read_memory implementation
864 */
865 target->type->write_memory_imp = target->type->write_memory;
866 target->type->write_memory = target_write_memory_imp;
867 target->type->read_memory_imp = target->type->read_memory;
868 target->type->read_memory = target_read_memory_imp;
869 target->type->soft_reset_halt_imp = target->type->soft_reset_halt;
870 target->type->soft_reset_halt = target_soft_reset_halt_imp;
871 target->type->run_algorithm_imp = target->type->run_algorithm;
872 target->type->run_algorithm = target_run_algorithm_imp;
873
874 if (target->type->mmu == NULL)
875 {
876 target->type->mmu = default_mmu;
877 }
878 if (target->type->has_mmu == NULL)
879 {
880 target->type->has_mmu = default_has_mmu;
881 }
882 target = target->next;
883 }
884
885 if (all_targets)
886 {
887 if ((retval = target_register_user_commands(cmd_ctx)) != ERROR_OK)
888 return retval;
889 if ((retval = target_register_timer_callback(handle_target, 100, 1, NULL)) != ERROR_OK)
890 return retval;
891 }
892
893 return ERROR_OK;
894 }
895
896 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
897 {
898 target_event_callback_t **callbacks_p = &target_event_callbacks;
899
900 if (callback == NULL)
901 {
902 return ERROR_INVALID_ARGUMENTS;
903 }
904
905 if (*callbacks_p)
906 {
907 while ((*callbacks_p)->next)
908 callbacks_p = &((*callbacks_p)->next);
909 callbacks_p = &((*callbacks_p)->next);
910 }
911
912 (*callbacks_p) = malloc(sizeof(target_event_callback_t));
913 (*callbacks_p)->callback = callback;
914 (*callbacks_p)->priv = priv;
915 (*callbacks_p)->next = NULL;
916
917 return ERROR_OK;
918 }
919
920 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
921 {
922 target_timer_callback_t **callbacks_p = &target_timer_callbacks;
923 struct timeval now;
924
925 if (callback == NULL)
926 {
927 return ERROR_INVALID_ARGUMENTS;
928 }
929
930 if (*callbacks_p)
931 {
932 while ((*callbacks_p)->next)
933 callbacks_p = &((*callbacks_p)->next);
934 callbacks_p = &((*callbacks_p)->next);
935 }
936
937 (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
938 (*callbacks_p)->callback = callback;
939 (*callbacks_p)->periodic = periodic;
940 (*callbacks_p)->time_ms = time_ms;
941
942 gettimeofday(&now, NULL);
943 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
944 time_ms -= (time_ms % 1000);
945 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
946 if ((*callbacks_p)->when.tv_usec > 1000000)
947 {
948 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
949 (*callbacks_p)->when.tv_sec += 1;
950 }
951
952 (*callbacks_p)->priv = priv;
953 (*callbacks_p)->next = NULL;
954
955 return ERROR_OK;
956 }
957
958 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
959 {
960 target_event_callback_t **p = &target_event_callbacks;
961 target_event_callback_t *c = target_event_callbacks;
962
963 if (callback == NULL)
964 {
965 return ERROR_INVALID_ARGUMENTS;
966 }
967
968 while (c)
969 {
970 target_event_callback_t *next = c->next;
971 if ((c->callback == callback) && (c->priv == priv))
972 {
973 *p = next;
974 free(c);
975 return ERROR_OK;
976 }
977 else
978 p = &(c->next);
979 c = next;
980 }
981
982 return ERROR_OK;
983 }
984
985 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
986 {
987 target_timer_callback_t **p = &target_timer_callbacks;
988 target_timer_callback_t *c = target_timer_callbacks;
989
990 if (callback == NULL)
991 {
992 return ERROR_INVALID_ARGUMENTS;
993 }
994
995 while (c)
996 {
997 target_timer_callback_t *next = c->next;
998 if ((c->callback == callback) && (c->priv == priv))
999 {
1000 *p = next;
1001 free(c);
1002 return ERROR_OK;
1003 }
1004 else
1005 p = &(c->next);
1006 c = next;
1007 }
1008
1009 return ERROR_OK;
1010 }
1011
1012 int target_call_event_callbacks(target_t *target, enum target_event event)
1013 {
1014 target_event_callback_t *callback = target_event_callbacks;
1015 target_event_callback_t *next_callback;
1016
1017 if (event == TARGET_EVENT_HALTED)
1018 {
1019 /* execute early halted first */
1020 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
1021 }
1022
1023 LOG_DEBUG("target event %i (%s)",
1024 event,
1025 Jim_Nvp_value2name_simple(nvp_target_event, event)->name);
1026
1027 target_handle_event(target, event);
1028
1029 while (callback)
1030 {
1031 next_callback = callback->next;
1032 callback->callback(target, event, callback->priv);
1033 callback = next_callback;
1034 }
1035
1036 return ERROR_OK;
1037 }
1038
1039 static int target_timer_callback_periodic_restart(
1040 target_timer_callback_t *cb, struct timeval *now)
1041 {
1042 int time_ms = cb->time_ms;
1043 cb->when.tv_usec = now->tv_usec + (time_ms % 1000) * 1000;
1044 time_ms -= (time_ms % 1000);
1045 cb->when.tv_sec = now->tv_sec + time_ms / 1000;
1046 if (cb->when.tv_usec > 1000000)
1047 {
1048 cb->when.tv_usec = cb->when.tv_usec - 1000000;
1049 cb->when.tv_sec += 1;
1050 }
1051 return ERROR_OK;
1052 }
1053
1054 static int target_call_timer_callback(target_timer_callback_t *cb,
1055 struct timeval *now)
1056 {
1057 cb->callback(cb->priv);
1058
1059 if (cb->periodic)
1060 return target_timer_callback_periodic_restart(cb, now);
1061
1062 return target_unregister_timer_callback(cb->callback, cb->priv);
1063 }
1064
1065 static int target_call_timer_callbacks_check_time(int checktime)
1066 {
1067 keep_alive();
1068
1069 struct timeval now;
1070 gettimeofday(&now, NULL);
1071
1072 target_timer_callback_t *callback = target_timer_callbacks;
1073 while (callback)
1074 {
1075 // cleaning up may unregister and free this callback
1076 target_timer_callback_t *next_callback = callback->next;
1077
1078 bool call_it = callback->callback &&
1079 ((!checktime && callback->periodic) ||
1080 now.tv_sec > callback->when.tv_sec ||
1081 (now.tv_sec == callback->when.tv_sec &&
1082 now.tv_usec >= callback->when.tv_usec));
1083
1084 if (call_it)
1085 {
1086 int retval = target_call_timer_callback(callback, &now);
1087 if (retval != ERROR_OK)
1088 return retval;
1089 }
1090
1091 callback = next_callback;
1092 }
1093
1094 return ERROR_OK;
1095 }
1096
1097 int target_call_timer_callbacks(void)
1098 {
1099 return target_call_timer_callbacks_check_time(1);
1100 }
1101
1102 /* invoke periodic callbacks immediately */
1103 int target_call_timer_callbacks_now(void)
1104 {
1105 return target_call_timer_callbacks_check_time(0);
1106 }
1107
1108 int target_alloc_working_area(struct target_s *target, uint32_t size, working_area_t **area)
1109 {
1110 working_area_t *c = target->working_areas;
1111 working_area_t *new_wa = NULL;
1112
1113 /* Reevaluate working area address based on MMU state*/
1114 if (target->working_areas == NULL)
1115 {
1116 int retval;
1117 int enabled;
1118 retval = target->type->mmu(target, &enabled);
1119 if (retval != ERROR_OK)
1120 {
1121 return retval;
1122 }
1123
1124 if (enabled)
1125 {
1126 if (target->working_area_phys_spec)
1127 {
1128 LOG_DEBUG("MMU disabled, using physical address for working memory 0x%08x", (unsigned)target->working_area_phys);
1129 target->working_area = target->working_area_phys;
1130 } else
1131 {
1132 LOG_ERROR("No working memory available. Specify -work-area-phys to target.");
1133 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1134 }
1135 } else
1136 {
1137 if (target->working_area_virt_spec)
1138 {
1139 LOG_DEBUG("MMU enabled, using virtual address for working memory 0x%08x", (unsigned)target->working_area_virt);
1140 target->working_area = target->working_area_virt;
1141 } else
1142 {
1143 LOG_ERROR("No working memory available. Specify -work-area-virt to target.");
1144 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1145 }
1146 }
1147 }
1148
1149 /* only allocate multiples of 4 byte */
1150 if (size % 4)
1151 {
1152 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes (0x%08x), padding", ((unsigned)(size)));
1153 size = (size + 3) & (~3);
1154 }
1155
1156 /* see if there's already a matching working area */
1157 while (c)
1158 {
1159 if ((c->free) && (c->size == size))
1160 {
1161 new_wa = c;
1162 break;
1163 }
1164 c = c->next;
1165 }
1166
1167 /* if not, allocate a new one */
1168 if (!new_wa)
1169 {
1170 working_area_t **p = &target->working_areas;
1171 uint32_t first_free = target->working_area;
1172 uint32_t free_size = target->working_area_size;
1173
1174 c = target->working_areas;
1175 while (c)
1176 {
1177 first_free += c->size;
1178 free_size -= c->size;
1179 p = &c->next;
1180 c = c->next;
1181 }
1182
1183 if (free_size < size)
1184 {
1185 LOG_WARNING("not enough working area available(requested %u, free %u)",
1186 (unsigned)(size), (unsigned)(free_size));
1187 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1188 }
1189
1190 LOG_DEBUG("allocated new working area at address 0x%08x", (unsigned)first_free);
1191
1192 new_wa = malloc(sizeof(working_area_t));
1193 new_wa->next = NULL;
1194 new_wa->size = size;
1195 new_wa->address = first_free;
1196
1197 if (target->backup_working_area)
1198 {
1199 int retval;
1200 new_wa->backup = malloc(new_wa->size);
1201 if ((retval = target_read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
1202 {
1203 free(new_wa->backup);
1204 free(new_wa);
1205 return retval;
1206 }
1207 }
1208 else
1209 {
1210 new_wa->backup = NULL;
1211 }
1212
1213 /* put new entry in list */
1214 *p = new_wa;
1215 }
1216
1217 /* mark as used, and return the new (reused) area */
1218 new_wa->free = 0;
1219 *area = new_wa;
1220
1221 /* user pointer */
1222 new_wa->user = area;
1223
1224 return ERROR_OK;
1225 }
1226
1227 int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore)
1228 {
1229 if (area->free)
1230 return ERROR_OK;
1231
1232 if (restore && target->backup_working_area)
1233 {
1234 int retval;
1235 if ((retval = target_write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
1236 return retval;
1237 }
1238
1239 area->free = 1;
1240
1241 /* mark user pointer invalid */
1242 *area->user = NULL;
1243 area->user = NULL;
1244
1245 return ERROR_OK;
1246 }
1247
1248 int target_free_working_area(struct target_s *target, working_area_t *area)
1249 {
1250 return target_free_working_area_restore(target, area, 1);
1251 }
1252
1253 /* free resources and restore memory, if restoring memory fails,
1254 * free up resources anyway
1255 */
1256 void target_free_all_working_areas_restore(struct target_s *target, int restore)
1257 {
1258 working_area_t *c = target->working_areas;
1259
1260 while (c)
1261 {
1262 working_area_t *next = c->next;
1263 target_free_working_area_restore(target, c, restore);
1264
1265 if (c->backup)
1266 free(c->backup);
1267
1268 free(c);
1269
1270 c = next;
1271 }
1272
1273 target->working_areas = NULL;
1274 }
1275
1276 void target_free_all_working_areas(struct target_s *target)
1277 {
1278 target_free_all_working_areas_restore(target, 1);
1279 }
1280
1281 int target_register_commands(struct command_context_s *cmd_ctx)
1282 {
1283
1284 register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, "change the current command line target (one parameter) or lists targets (with no parameter)");
1285
1286
1287
1288
1289 register_jim(cmd_ctx, "target", jim_target, "configure target");
1290
1291 return ERROR_OK;
1292 }
1293
1294 int target_arch_state(struct target_s *target)
1295 {
1296 int retval;
1297 if (target == NULL)
1298 {
1299 LOG_USER("No target has been configured");
1300 return ERROR_OK;
1301 }
1302
1303 LOG_USER("target state: %s", target_state_name( target ));
1304
1305 if (target->state != TARGET_HALTED)
1306 return ERROR_OK;
1307
1308 retval = target->type->arch_state(target);
1309 return retval;
1310 }
1311
1312 /* Single aligned words are guaranteed to use 16 or 32 bit access
1313 * mode respectively, otherwise data is handled as quickly as
1314 * possible
1315 */
1316 int target_write_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer)
1317 {
1318 int retval;
1319 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x",
1320 (int)size, (unsigned)address);
1321
1322 if (!target_was_examined(target))
1323 {
1324 LOG_ERROR("Target not examined yet");
1325 return ERROR_FAIL;
1326 }
1327
1328 if (size == 0) {
1329 return ERROR_OK;
1330 }
1331
1332 if ((address + size - 1) < address)
1333 {
1334 /* GDB can request this when e.g. PC is 0xfffffffc*/
1335 LOG_ERROR("address + size wrapped(0x%08x, 0x%08x)",
1336 (unsigned)address,
1337 (unsigned)size);
1338 return ERROR_FAIL;
1339 }
1340
1341 if (((address % 2) == 0) && (size == 2))
1342 {
1343 return target_write_memory(target, address, 2, 1, buffer);
1344 }
1345
1346 /* handle unaligned head bytes */
1347 if (address % 4)
1348 {
1349 uint32_t unaligned = 4 - (address % 4);
1350
1351 if (unaligned > size)
1352 unaligned = size;
1353
1354 if ((retval = target_write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1355 return retval;
1356
1357 buffer += unaligned;
1358 address += unaligned;
1359 size -= unaligned;
1360 }
1361
1362 /* handle aligned words */
1363 if (size >= 4)
1364 {
1365 int aligned = size - (size % 4);
1366
1367 /* use bulk writes above a certain limit. This may have to be changed */
1368 if (aligned > 128)
1369 {
1370 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
1371 return retval;
1372 }
1373 else
1374 {
1375 if ((retval = target_write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1376 return retval;
1377 }
1378
1379 buffer += aligned;
1380 address += aligned;
1381 size -= aligned;
1382 }
1383
1384 /* handle tail writes of less than 4 bytes */
1385 if (size > 0)
1386 {
1387 if ((retval = target_write_memory(target, address, 1, size, buffer)) != ERROR_OK)
1388 return retval;
1389 }
1390
1391 return ERROR_OK;
1392 }
1393
1394 /* Single aligned words are guaranteed to use 16 or 32 bit access
1395 * mode respectively, otherwise data is handled as quickly as
1396 * possible
1397 */
1398 int target_read_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer)
1399 {
1400 int retval;
1401 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x",
1402 (int)size, (unsigned)address);
1403
1404 if (!target_was_examined(target))
1405 {
1406 LOG_ERROR("Target not examined yet");
1407 return ERROR_FAIL;
1408 }
1409
1410 if (size == 0) {
1411 return ERROR_OK;
1412 }
1413
1414 if ((address + size - 1) < address)
1415 {
1416 /* GDB can request this when e.g. PC is 0xfffffffc*/
1417 LOG_ERROR("address + size wrapped(0x%08" PRIx32 ", 0x%08" PRIx32 ")",
1418 address,
1419 size);
1420 return ERROR_FAIL;
1421 }
1422
1423 if (((address % 2) == 0) && (size == 2))
1424 {
1425 return target_read_memory(target, address, 2, 1, buffer);
1426 }
1427
1428 /* handle unaligned head bytes */
1429 if (address % 4)
1430 {
1431 uint32_t unaligned = 4 - (address % 4);
1432
1433 if (unaligned > size)
1434 unaligned = size;
1435
1436 if ((retval = target_read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1437 return retval;
1438
1439 buffer += unaligned;
1440 address += unaligned;
1441 size -= unaligned;
1442 }
1443
1444 /* handle aligned words */
1445 if (size >= 4)
1446 {
1447 int aligned = size - (size % 4);
1448
1449 if ((retval = target_read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1450 return retval;
1451
1452 buffer += aligned;
1453 address += aligned;
1454 size -= aligned;
1455 }
1456
1457 /*prevent byte access when possible (avoid AHB access limitations in some cases)*/
1458 if(size >=2)
1459 {
1460 int aligned = size - (size%2);
1461 retval = target_read_memory(target, address, 2, aligned / 2, buffer);
1462 if (retval != ERROR_OK)
1463 return retval;
1464
1465 buffer += aligned;
1466 address += aligned;
1467 size -= aligned;
1468 }
1469 /* handle tail writes of less than 4 bytes */
1470 if (size > 0)
1471 {
1472 if ((retval = target_read_memory(target, address, 1, size, buffer)) != ERROR_OK)
1473 return retval;
1474 }
1475
1476 return ERROR_OK;
1477 }
1478
1479 int target_checksum_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* crc)
1480 {
1481 uint8_t *buffer;
1482 int retval;
1483 uint32_t i;
1484 uint32_t checksum = 0;
1485 if (!target_was_examined(target))
1486 {
1487 LOG_ERROR("Target not examined yet");
1488 return ERROR_FAIL;
1489 }
1490
1491 if ((retval = target->type->checksum_memory(target, address,
1492 size, &checksum)) != ERROR_OK)
1493 {
1494 buffer = malloc(size);
1495 if (buffer == NULL)
1496 {
1497 LOG_ERROR("error allocating buffer for section (%d bytes)", (int)size);
1498 return ERROR_INVALID_ARGUMENTS;
1499 }
1500 retval = target_read_buffer(target, address, size, buffer);
1501 if (retval != ERROR_OK)
1502 {
1503 free(buffer);
1504 return retval;
1505 }
1506
1507 /* convert to target endianess */
1508 for (i = 0; i < (size/sizeof(uint32_t)); i++)
1509 {
1510 uint32_t target_data;
1511 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(uint32_t)]);
1512 target_buffer_set_u32(target, &buffer[i*sizeof(uint32_t)], target_data);
1513 }
1514
1515 retval = image_calculate_checksum(buffer, size, &checksum);
1516 free(buffer);
1517 }
1518
1519 *crc = checksum;
1520
1521 return retval;
1522 }
1523
1524 int target_blank_check_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* blank)
1525 {
1526 int retval;
1527 if (!target_was_examined(target))
1528 {
1529 LOG_ERROR("Target not examined yet");
1530 return ERROR_FAIL;
1531 }
1532
1533 if (target->type->blank_check_memory == 0)
1534 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1535
1536 retval = target->type->blank_check_memory(target, address, size, blank);
1537
1538 return retval;
1539 }
1540
1541 int target_read_u32(struct target_s *target, uint32_t address, uint32_t *value)
1542 {
1543 uint8_t value_buf[4];
1544 if (!target_was_examined(target))
1545 {
1546 LOG_ERROR("Target not examined yet");
1547 return ERROR_FAIL;
1548 }
1549
1550 int retval = target_read_memory(target, address, 4, 1, value_buf);
1551
1552 if (retval == ERROR_OK)
1553 {
1554 *value = target_buffer_get_u32(target, value_buf);
1555 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
1556 address,
1557 *value);
1558 }
1559 else
1560 {
1561 *value = 0x0;
1562 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1563 address);
1564 }
1565
1566 return retval;
1567 }
1568
1569 int target_read_u16(struct target_s *target, uint32_t address, uint16_t *value)
1570 {
1571 uint8_t value_buf[2];
1572 if (!target_was_examined(target))
1573 {
1574 LOG_ERROR("Target not examined yet");
1575 return ERROR_FAIL;
1576 }
1577
1578 int retval = target_read_memory(target, address, 2, 1, value_buf);
1579
1580 if (retval == ERROR_OK)
1581 {
1582 *value = target_buffer_get_u16(target, value_buf);
1583 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%4.4x",
1584 address,
1585 *value);
1586 }
1587 else
1588 {
1589 *value = 0x0;
1590 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1591 address);
1592 }
1593
1594 return retval;
1595 }
1596
1597 int target_read_u8(struct target_s *target, uint32_t address, uint8_t *value)
1598 {
1599 int retval = target_read_memory(target, address, 1, 1, value);
1600 if (!target_was_examined(target))
1601 {
1602 LOG_ERROR("Target not examined yet");
1603 return ERROR_FAIL;
1604 }
1605
1606 if (retval == ERROR_OK)
1607 {
1608 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
1609 address,
1610 *value);
1611 }
1612 else
1613 {
1614 *value = 0x0;
1615 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1616 address);
1617 }
1618
1619 return retval;
1620 }
1621
1622 int target_write_u32(struct target_s *target, uint32_t address, uint32_t value)
1623 {
1624 int retval;
1625 uint8_t value_buf[4];
1626 if (!target_was_examined(target))
1627 {
1628 LOG_ERROR("Target not examined yet");
1629 return ERROR_FAIL;
1630 }
1631
1632 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
1633 address,
1634 value);
1635
1636 target_buffer_set_u32(target, value_buf, value);
1637 if ((retval = target_write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1638 {
1639 LOG_DEBUG("failed: %i", retval);
1640 }
1641
1642 return retval;
1643 }
1644
1645 int target_write_u16(struct target_s *target, uint32_t address, uint16_t value)
1646 {
1647 int retval;
1648 uint8_t value_buf[2];
1649 if (!target_was_examined(target))
1650 {
1651 LOG_ERROR("Target not examined yet");
1652 return ERROR_FAIL;
1653 }
1654
1655 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8x",
1656 address,
1657 value);
1658
1659 target_buffer_set_u16(target, value_buf, value);
1660 if ((retval = target_write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1661 {
1662 LOG_DEBUG("failed: %i", retval);
1663 }
1664
1665 return retval;
1666 }
1667
1668 int target_write_u8(struct target_s *target, uint32_t address, uint8_t value)
1669 {
1670 int retval;
1671 if (!target_was_examined(target))
1672 {
1673 LOG_ERROR("Target not examined yet");
1674 return ERROR_FAIL;
1675 }
1676
1677 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
1678 address, value);
1679
1680 if ((retval = target_write_memory(target, address, 1, 1, &value)) != ERROR_OK)
1681 {
1682 LOG_DEBUG("failed: %i", retval);
1683 }
1684
1685 return retval;
1686 }
1687
1688 int target_register_user_commands(struct command_context_s *cmd_ctx)
1689 {
1690 int retval = ERROR_OK;
1691
1692
1693 /* script procedures */
1694 register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "profiling samples the CPU PC");
1695 register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing <ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
1696 register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values <ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
1697
1698 register_command(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY,
1699 "same args as load_image, image stored in memory - mainly for profiling purposes");
1700
1701 register_command(cmd_ctx, NULL, "fast_load", handle_fast_load_command, COMMAND_ANY,
1702 "loads active fast load image to current target - mainly for profiling purposes");
1703
1704
1705 register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "translate a virtual address into a physical address");
1706 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, "display or set a register");
1707 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1708 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1709 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1710 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1711 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1712 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run | halt | init] - default is run");
1713 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1714
1715 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words [phys] <addr> [count]");
1716 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words [phys] <addr> [count]");
1717 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes [phys] <addr> [count]");
1718
1719 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word [phys] <addr> <value> [count]");
1720 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word [phys] <addr> <value> [count]");
1721 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte [phys] <addr> <value> [count]");
1722
1723 register_command(cmd_ctx, NULL, "bp",
1724 handle_bp_command, COMMAND_EXEC,
1725 "list or set breakpoint [<address> <length> [hw]]");
1726 register_command(cmd_ctx, NULL, "rbp",
1727 handle_rbp_command, COMMAND_EXEC,
1728 "remove breakpoint <address>");
1729 register_command(cmd_ctx, NULL, "wp",
1730 handle_wp_command, COMMAND_EXEC,
1731 "list or set watchpoint "
1732 "[<address> <length> <r/w/a> [value] [mask]]");
1733 register_command(cmd_ctx, NULL, "rwp",
1734 handle_rwp_command, COMMAND_EXEC,
1735 "remove watchpoint <address>");
1736
1737 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
1738 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1739 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1740 register_command(cmd_ctx, NULL, "test_image", handle_test_image_command, COMMAND_EXEC, "test_image <file> [offset] [type]");
1741
1742 if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
1743 return retval;
1744 if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
1745 return retval;
1746
1747 return retval;
1748 }
1749
1750 static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1751 {
1752 target_t *target = all_targets;
1753
1754 if (argc == 1)
1755 {
1756 target = get_target(args[0]);
1757 if (target == NULL) {
1758 command_print(cmd_ctx,"Target: %s is unknown, try one of:\n", args[0]);
1759 goto DumpTargets;
1760 }
1761 if (!target->tap->enabled) {
1762 command_print(cmd_ctx,"Target: TAP %s is disabled, "
1763 "can't be the current target\n",
1764 target->tap->dotted_name);
1765 return ERROR_FAIL;
1766 }
1767
1768 cmd_ctx->current_target = target->target_number;
1769 return ERROR_OK;
1770 }
1771 DumpTargets:
1772
1773 target = all_targets;
1774 command_print(cmd_ctx, " TargetName Type Endian TapName State ");
1775 command_print(cmd_ctx, "-- ------------------ ---------- ------ ------------------ ------------");
1776 while (target)
1777 {
1778 const char *state;
1779 char marker = ' ';
1780
1781 if (target->tap->enabled)
1782 state = target_state_name( target );
1783 else
1784 state = "tap-disabled";
1785
1786 if (cmd_ctx->current_target == target->target_number)
1787 marker = '*';
1788
1789 /* keep columns lined up to match the headers above */
1790 command_print(cmd_ctx, "%2d%c %-18s %-10s %-6s %-18s %s",
1791 target->target_number,
1792 marker,
1793 target->cmd_name,
1794 target_get_name(target),
1795 Jim_Nvp_value2name_simple(nvp_target_endian,
1796 target->endianness)->name,
1797 target->tap->dotted_name,
1798 state);
1799 target = target->next;
1800 }
1801
1802 return ERROR_OK;
1803 }
1804
1805 /* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
1806
1807 static int powerDropout;
1808 static int srstAsserted;
1809
1810 static int runPowerRestore;
1811 static int runPowerDropout;
1812 static int runSrstAsserted;
1813 static int runSrstDeasserted;
1814
1815 static int sense_handler(void)
1816 {
1817 static int prevSrstAsserted = 0;
1818 static int prevPowerdropout = 0;
1819
1820 int retval;
1821 if ((retval = jtag_power_dropout(&powerDropout)) != ERROR_OK)
1822 return retval;
1823
1824 int powerRestored;
1825 powerRestored = prevPowerdropout && !powerDropout;
1826 if (powerRestored)
1827 {
1828 runPowerRestore = 1;
1829 }
1830
1831 long long current = timeval_ms();
1832 static long long lastPower = 0;
1833 int waitMore = lastPower + 2000 > current;
1834 if (powerDropout && !waitMore)
1835 {
1836 runPowerDropout = 1;
1837 lastPower = current;
1838 }
1839
1840 if ((retval = jtag_srst_asserted(&srstAsserted)) != ERROR_OK)
1841 return retval;
1842
1843 int srstDeasserted;
1844 srstDeasserted = prevSrstAsserted && !srstAsserted;
1845
1846 static long long lastSrst = 0;
1847 waitMore = lastSrst + 2000 > current;
1848 if (srstDeasserted && !waitMore)
1849 {
1850 runSrstDeasserted = 1;
1851 lastSrst = current;
1852 }
1853
1854 if (!prevSrstAsserted && srstAsserted)
1855 {
1856 runSrstAsserted = 1;
1857 }
1858
1859 prevSrstAsserted = srstAsserted;
1860 prevPowerdropout = powerDropout;
1861
1862 if (srstDeasserted || powerRestored)
1863 {
1864 /* Other than logging the event we can't do anything here.
1865 * Issuing a reset is a particularly bad idea as we might
1866 * be inside a reset already.
1867 */
1868 }
1869
1870 return ERROR_OK;
1871 }
1872
1873 static void target_call_event_callbacks_all(enum target_event e) {
1874 target_t *target;
1875 target = all_targets;
1876 while (target) {
1877 target_call_event_callbacks(target, e);
1878 target = target->next;
1879 }
1880 }
1881
1882 /* process target state changes */
1883 int handle_target(void *priv)
1884 {
1885 int retval = ERROR_OK;
1886
1887 /* we do not want to recurse here... */
1888 static int recursive = 0;
1889 if (! recursive)
1890 {
1891 recursive = 1;
1892 sense_handler();
1893 /* danger! running these procedures can trigger srst assertions and power dropouts.
1894 * We need to avoid an infinite loop/recursion here and we do that by
1895 * clearing the flags after running these events.
1896 */
1897 int did_something = 0;
1898 if (runSrstAsserted)
1899 {
1900 target_call_event_callbacks_all(TARGET_EVENT_GDB_HALT);
1901 Jim_Eval(interp, "srst_asserted");
1902 did_something = 1;
1903 }
1904 if (runSrstDeasserted)
1905 {
1906 Jim_Eval(interp, "srst_deasserted");
1907 did_something = 1;
1908 }
1909 if (runPowerDropout)
1910 {
1911 target_call_event_callbacks_all(TARGET_EVENT_GDB_HALT);
1912 Jim_Eval(interp, "power_dropout");
1913 did_something = 1;
1914 }
1915 if (runPowerRestore)
1916 {
1917 Jim_Eval(interp, "power_restore");
1918 did_something = 1;
1919 }
1920
1921 if (did_something)
1922 {
1923 /* clear detect flags */
1924 sense_handler();
1925 }
1926
1927 /* clear action flags */
1928
1929 runSrstAsserted = 0;
1930 runSrstDeasserted = 0;
1931 runPowerRestore = 0;
1932 runPowerDropout = 0;
1933
1934 recursive = 0;
1935 }
1936
1937 /* Poll targets for state changes unless that's globally disabled.
1938 * Skip targets that are currently disabled.
1939 */
1940 for (target_t *target = all_targets;
1941 is_jtag_poll_safe() && target;
1942 target = target->next)
1943 {
1944 if (!target->tap->enabled)
1945 continue;
1946
1947 /* only poll target if we've got power and srst isn't asserted */
1948 if (!powerDropout && !srstAsserted)
1949 {
1950 /* polling may fail silently until the target has been examined */
1951 if ((retval = target_poll(target)) != ERROR_OK)
1952 {
1953 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
1954 return retval;
1955 }
1956 }
1957 }
1958
1959 return retval;
1960 }
1961
1962 static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1963 {
1964 target_t *target;
1965 reg_t *reg = NULL;
1966 int count = 0;
1967 char *value;
1968
1969 LOG_DEBUG("-");
1970
1971 target = get_current_target(cmd_ctx);
1972
1973 /* list all available registers for the current target */
1974 if (argc == 0)
1975 {
1976 reg_cache_t *cache = target->reg_cache;
1977
1978 count = 0;
1979 while (cache)
1980 {
1981 int i;
1982
1983 command_print(cmd_ctx, "===== %s", cache->name);
1984
1985 for (i = 0, reg = cache->reg_list;
1986 i < cache->num_regs;
1987 i++, reg++, count++)
1988 {
1989 /* only print cached values if they are valid */
1990 if (reg->valid) {
1991 value = buf_to_str(reg->value,
1992 reg->size, 16);
1993 command_print(cmd_ctx,
1994 "(%i) %s (/%" PRIu32 "): 0x%s%s",
1995 count, reg->name,
1996 reg->size, value,
1997 reg->dirty
1998 ? " (dirty)"
1999 : "");
2000 free(value);
2001 } else {
2002 command_print(cmd_ctx, "(%i) %s (/%" PRIu32 ")",
2003 count, reg->name,
2004 reg->size) ;
2005 }
2006 }
2007 cache = cache->next;
2008 }
2009
2010 return ERROR_OK;
2011 }
2012
2013 /* access a single register by its ordinal number */
2014 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
2015 {
2016 unsigned num;
2017 COMMAND_PARSE_NUMBER(uint, args[0], num);
2018
2019 reg_cache_t *cache = target->reg_cache;
2020 count = 0;
2021 while (cache)
2022 {
2023 int i;
2024 for (i = 0; i < cache->num_regs; i++)
2025 {
2026 if (count++ == (int)num)
2027 {
2028 reg = &cache->reg_list[i];
2029 break;
2030 }
2031 }
2032 if (reg)
2033 break;
2034 cache = cache->next;
2035 }
2036
2037 if (!reg)
2038 {
2039 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
2040 return ERROR_OK;
2041 }
2042 } else /* access a single register by its name */
2043 {
2044 reg = register_get_by_name(target->reg_cache, args[0], 1);
2045
2046 if (!reg)
2047 {
2048 command_print(cmd_ctx, "register %s not found in current target", args[0]);
2049 return ERROR_OK;
2050 }
2051 }
2052
2053 /* display a register */
2054 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
2055 {
2056 if ((argc == 2) && (strcmp(args[1], "force") == 0))
2057 reg->valid = 0;
2058
2059 if (reg->valid == 0)
2060 {
2061 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
2062 arch_type->get(reg);
2063 }
2064 value = buf_to_str(reg->value, reg->size, 16);
2065 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
2066 free(value);
2067 return ERROR_OK;
2068 }
2069
2070 /* set register value */
2071 if (argc == 2)
2072 {
2073 uint8_t *buf = malloc(CEIL(reg->size, 8));
2074 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
2075
2076 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
2077 arch_type->set(reg, buf);
2078
2079 value = buf_to_str(reg->value, reg->size, 16);
2080 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
2081 free(value);
2082
2083 free(buf);
2084
2085 return ERROR_OK;
2086 }
2087
2088 command_print(cmd_ctx, "usage: reg <#|name> [value]");
2089
2090 return ERROR_OK;
2091 }
2092
2093 static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2094 {
2095 int retval = ERROR_OK;
2096 target_t *target = get_current_target(cmd_ctx);
2097
2098 if (argc == 0)
2099 {
2100 command_print(cmd_ctx, "background polling: %s",
2101 jtag_poll_get_enabled() ? "on" : "off");
2102 command_print(cmd_ctx, "TAP: %s (%s)",
2103 target->tap->dotted_name,
2104 target->tap->enabled ? "enabled" : "disabled");
2105 if (!target->tap->enabled)
2106 return ERROR_OK;
2107 if ((retval = target_poll(target)) != ERROR_OK)
2108 return retval;
2109 if ((retval = target_arch_state(target)) != ERROR_OK)
2110 return retval;
2111
2112 }
2113 else if (argc == 1)
2114 {
2115 if (strcmp(args[0], "on") == 0)
2116 {
2117 jtag_poll_set_enabled(true);
2118 }
2119 else if (strcmp(args[0], "off") == 0)
2120 {
2121 jtag_poll_set_enabled(false);
2122 }
2123 else
2124 {
2125 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
2126 }
2127 } else
2128 {
2129 return ERROR_COMMAND_SYNTAX_ERROR;
2130 }
2131
2132 return retval;
2133 }
2134
2135 static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2136 {
2137 if (argc > 1)
2138 return ERROR_COMMAND_SYNTAX_ERROR;
2139
2140 unsigned ms = 5000;
2141 if (1 == argc)
2142 {
2143 int retval = parse_uint(args[0], &ms);
2144 if (ERROR_OK != retval)
2145 {
2146 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
2147 return ERROR_COMMAND_SYNTAX_ERROR;
2148 }
2149 // convert seconds (given) to milliseconds (needed)
2150 ms *= 1000;
2151 }
2152
2153 target_t *target = get_current_target(cmd_ctx);
2154 return target_wait_state(target, TARGET_HALTED, ms);
2155 }
2156
2157 /* wait for target state to change. The trick here is to have a low
2158 * latency for short waits and not to suck up all the CPU time
2159 * on longer waits.
2160 *
2161 * After 500ms, keep_alive() is invoked
2162 */
2163 int target_wait_state(target_t *target, enum target_state state, int ms)
2164 {
2165 int retval;
2166 long long then = 0, cur;
2167 int once = 1;
2168
2169 for (;;)
2170 {
2171 if ((retval = target_poll(target)) != ERROR_OK)
2172 return retval;
2173 if (target->state == state)
2174 {
2175 break;
2176 }
2177 cur = timeval_ms();
2178 if (once)
2179 {
2180 once = 0;
2181 then = timeval_ms();
2182 LOG_DEBUG("waiting for target %s...",
2183 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
2184 }
2185
2186 if (cur-then > 500)
2187 {
2188 keep_alive();
2189 }
2190
2191 if ((cur-then) > ms)
2192 {
2193 LOG_ERROR("timed out while waiting for target %s",
2194 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
2195 return ERROR_FAIL;
2196 }
2197 }
2198
2199 return ERROR_OK;
2200 }
2201
2202 static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2203 {
2204 LOG_DEBUG("-");
2205
2206 target_t *target = get_current_target(cmd_ctx);
2207 int retval = target_halt(target);
2208 if (ERROR_OK != retval)
2209 return retval;
2210
2211 if (argc == 1)
2212 {
2213 unsigned wait;
2214 retval = parse_uint(args[0], &wait);
2215 if (ERROR_OK != retval)
2216 return ERROR_COMMAND_SYNTAX_ERROR;
2217 if (!wait)
2218 return ERROR_OK;
2219 }
2220
2221 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
2222 }
2223
2224 static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2225 {
2226 target_t *target = get_current_target(cmd_ctx);
2227
2228 LOG_USER("requesting target halt and executing a soft reset");
2229
2230 target->type->soft_reset_halt(target);
2231
2232 return ERROR_OK;
2233 }
2234
2235 static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2236 {
2237 if (argc > 1)
2238 return ERROR_COMMAND_SYNTAX_ERROR;
2239
2240 enum target_reset_mode reset_mode = RESET_RUN;
2241 if (argc == 1)
2242 {
2243 const Jim_Nvp *n;
2244 n = Jim_Nvp_name2value_simple(nvp_reset_modes, args[0]);
2245 if ((n->name == NULL) || (n->value == RESET_UNKNOWN)) {
2246 return ERROR_COMMAND_SYNTAX_ERROR;
2247 }
2248 reset_mode = n->value;
2249 }
2250
2251 /* reset *all* targets */
2252 return target_process_reset(cmd_ctx, reset_mode);
2253 }
2254
2255
2256 static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2257 {
2258 int current = 1;
2259 if (argc > 1)
2260 return ERROR_COMMAND_SYNTAX_ERROR;
2261
2262 target_t *target = get_current_target(cmd_ctx);
2263 target_handle_event(target, TARGET_EVENT_OLD_pre_resume);
2264
2265 /* with no args, resume from current pc, addr = 0,
2266 * with one arguments, addr = args[0],
2267 * handle breakpoints, not debugging */
2268 uint32_t addr = 0;
2269 if (argc == 1)
2270 {
2271 COMMAND_PARSE_NUMBER(u32, args[0], addr);
2272 current = 0;
2273 }
2274
2275 return target_resume(target, current, addr, 1, 0);
2276 }
2277
2278 static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2279 {
2280 if (argc > 1)
2281 return ERROR_COMMAND_SYNTAX_ERROR;
2282
2283 LOG_DEBUG("-");
2284
2285 /* with no args, step from current pc, addr = 0,
2286 * with one argument addr = args[0],
2287 * handle breakpoints, debugging */
2288 uint32_t addr = 0;
2289 int current_pc = 1;
2290 if (argc == 1)
2291 {
2292 COMMAND_PARSE_NUMBER(u32, args[0], addr);
2293 current_pc = 0;
2294 }
2295
2296 target_t *target = get_current_target(cmd_ctx);
2297
2298 return target->type->step(target, current_pc, addr, 1);
2299 }
2300
2301 static void handle_md_output(struct command_context_s *cmd_ctx,
2302 struct target_s *target, uint32_t address, unsigned size,
2303 unsigned count, const uint8_t *buffer)
2304 {
2305 const unsigned line_bytecnt = 32;
2306 unsigned line_modulo = line_bytecnt / size;
2307
2308 char output[line_bytecnt * 4 + 1];
2309 unsigned output_len = 0;
2310
2311 const char *value_fmt;
2312 switch (size) {
2313 case 4: value_fmt = "%8.8x "; break;
2314 case 2: value_fmt = "%4.2x "; break;
2315 case 1: value_fmt = "%2.2x "; break;
2316 default:
2317 LOG_ERROR("invalid memory read size: %u", size);
2318 exit(-1);
2319 }
2320
2321 for (unsigned i = 0; i < count; i++)
2322 {
2323 if (i % line_modulo == 0)
2324 {
2325 output_len += snprintf(output + output_len,
2326 sizeof(output) - output_len,
2327 "0x%8.8x: ",
2328 (unsigned)(address + (i*size)));
2329 }
2330
2331 uint32_t value = 0;
2332 const uint8_t *value_ptr = buffer + i * size;
2333 switch (size) {
2334 case 4: value = target_buffer_get_u32(target, value_ptr); break;
2335 case 2: value = target_buffer_get_u16(target, value_ptr); break;
2336 case 1: value = *value_ptr;
2337 }
2338 output_len += snprintf(output + output_len,
2339 sizeof(output) - output_len,
2340 value_fmt, value);
2341
2342 if ((i % line_modulo == line_modulo - 1) || (i == count - 1))
2343 {
2344 command_print(cmd_ctx, "%s", output);
2345 output_len = 0;
2346 }
2347 }
2348 }
2349
2350 static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2351 {
2352 if (argc < 1)
2353 return ERROR_COMMAND_SYNTAX_ERROR;
2354
2355 unsigned size = 0;
2356 switch (cmd[2]) {
2357 case 'w': size = 4; break;
2358 case 'h': size = 2; break;
2359 case 'b': size = 1; break;
2360 default: return ERROR_COMMAND_SYNTAX_ERROR;
2361 }
2362
2363 bool physical=strcmp(args[0], "phys")==0;
2364 int (*fn)(struct target_s *target,
2365 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
2366 if (physical)
2367 {
2368 argc--;
2369 args++;
2370 fn=target_read_phys_memory;
2371 } else
2372 {
2373 fn=target_read_memory;
2374 }
2375 if ((argc < 1) || (argc > 2))
2376 {
2377 return ERROR_COMMAND_SYNTAX_ERROR;
2378 }
2379
2380 uint32_t address;
2381 COMMAND_PARSE_NUMBER(u32, args[0], address);
2382
2383 unsigned count = 1;
2384 if (argc == 2)
2385 COMMAND_PARSE_NUMBER(uint, args[1], count);
2386
2387 uint8_t *buffer = calloc(count, size);
2388
2389 target_t *target = get_current_target(cmd_ctx);
2390 int retval = fn(target, address, size, count, buffer);
2391 if (ERROR_OK == retval)
2392 handle_md_output(cmd_ctx, target, address, size, count, buffer);
2393
2394 free(buffer);
2395
2396 return retval;
2397 }
2398
2399 static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2400 {
2401 if (argc < 2)
2402 {
2403 return ERROR_COMMAND_SYNTAX_ERROR;
2404 }
2405 bool physical=strcmp(args[0], "phys")==0;
2406 int (*fn)(struct target_s *target,
2407 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
2408 if (physical)
2409 {
2410 argc--;
2411 args++;
2412 fn=target_write_phys_memory;
2413 } else
2414 {
2415 fn=target_write_memory;
2416 }
2417 if ((argc < 2) || (argc > 3))
2418 return ERROR_COMMAND_SYNTAX_ERROR;
2419
2420 uint32_t address;
2421 COMMAND_PARSE_NUMBER(u32, args[0], address);
2422
2423 uint32_t value;
2424 COMMAND_PARSE_NUMBER(u32, args[1], value);
2425
2426 unsigned count = 1;
2427 if (argc == 3)
2428 COMMAND_PARSE_NUMBER(uint, args[2], count);
2429
2430 target_t *target = get_current_target(cmd_ctx);
2431 unsigned wordsize;
2432 uint8_t value_buf[4];
2433 switch (cmd[2])
2434 {
2435 case 'w':
2436 wordsize = 4;
2437 target_buffer_set_u32(target, value_buf, value);
2438 break;
2439 case 'h':
2440 wordsize = 2;
2441 target_buffer_set_u16(target, value_buf, value);
2442 break;
2443 case 'b':
2444 wordsize = 1;
2445 value_buf[0] = value;
2446 break;
2447 default:
2448 return ERROR_COMMAND_SYNTAX_ERROR;
2449 }
2450 for (unsigned i = 0; i < count; i++)
2451 {
2452 int retval = fn(target,
2453 address + i * wordsize, wordsize, 1, value_buf);
2454 if (ERROR_OK != retval)
2455 return retval;
2456 keep_alive();
2457 }
2458
2459 return ERROR_OK;
2460
2461 }
2462
2463 static int parse_load_image_command_args(struct command_context_s *cmd_ctx,
2464 char **args, int argc, image_t *image,
2465 uint32_t *min_address, uint32_t *max_address)
2466 {
2467 if (argc < 1 || argc > 5)
2468 return ERROR_COMMAND_SYNTAX_ERROR;
2469
2470 /* a base address isn't always necessary,
2471 * default to 0x0 (i.e. don't relocate) */
2472 if (argc >= 2)
2473 {
2474 uint32_t addr;
2475 COMMAND_PARSE_NUMBER(u32, args[1], addr);
2476 image->base_address = addr;
2477 image->base_address_set = 1;
2478 }
2479 else
2480 image->base_address_set = 0;
2481
2482 image->start_address_set = 0;
2483
2484 if (argc >= 4)
2485 {
2486 COMMAND_PARSE_NUMBER(u32, args[3], *min_address);
2487 }
2488 if (argc == 5)
2489 {
2490 COMMAND_PARSE_NUMBER(u32, args[4], *max_address);
2491 // use size (given) to find max (required)
2492 *max_address += *min_address;
2493 }
2494
2495 if (*min_address > *max_address)
2496 return ERROR_COMMAND_SYNTAX_ERROR;
2497
2498 return ERROR_OK;
2499 }
2500
2501 static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2502 {
2503 uint8_t *buffer;
2504 uint32_t buf_cnt;
2505 uint32_t image_size;
2506 uint32_t min_address = 0;
2507 uint32_t max_address = 0xffffffff;
2508 int i;
2509 int retvaltemp;
2510
2511 image_t image;
2512
2513 duration_t duration;
2514 char *duration_text;
2515
2516 int retval = parse_load_image_command_args(cmd_ctx, args, argc,
2517 &image, &min_address, &max_address);
2518 if (ERROR_OK != retval)
2519 return retval;
2520
2521 target_t *target = get_current_target(cmd_ctx);
2522 duration_start_measure(&duration);
2523
2524 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
2525 {
2526 return ERROR_OK;
2527 }
2528
2529 image_size = 0x0;
2530 retval = ERROR_OK;
2531 for (i = 0; i < image.num_sections; i++)
2532 {
2533 buffer = malloc(image.sections[i].size);
2534 if (buffer == NULL)
2535 {
2536 command_print(cmd_ctx,
2537 "error allocating buffer for section (%d bytes)",
2538 (int)(image.sections[i].size));
2539 break;
2540 }
2541
2542 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2543 {
2544 free(buffer);
2545 break;
2546 }
2547
2548 uint32_t offset = 0;
2549 uint32_t length = buf_cnt;
2550
2551 /* DANGER!!! beware of unsigned comparision here!!! */
2552
2553 if ((image.sections[i].base_address + buf_cnt >= min_address)&&
2554 (image.sections[i].base_address < max_address))
2555 {
2556 if (image.sections[i].base_address < min_address)
2557 {
2558 /* clip addresses below */
2559 offset += min_address-image.sections[i].base_address;
2560 length -= offset;
2561 }
2562
2563 if (image.sections[i].base_address + buf_cnt > max_address)
2564 {
2565 length -= (image.sections[i].base_address + buf_cnt)-max_address;
2566 }
2567
2568 if ((retval = target_write_buffer(target, image.sections[i].base_address + offset, length, buffer + offset)) != ERROR_OK)
2569 {
2570 free(buffer);
2571 break;
2572 }
2573 image_size += length;
2574 command_print(cmd_ctx, "%u bytes written at address 0x%8.8" PRIx32 "",
2575 (unsigned int)length,
2576 image.sections[i].base_address + offset);
2577 }
2578
2579 free(buffer);
2580 }
2581
2582 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2583 {
2584 image_close(&image);
2585 return retvaltemp;
2586 }
2587
2588 if (retval == ERROR_OK)
2589 {
2590 command_print(cmd_ctx, "downloaded %u byte in %s",
2591 (unsigned int)image_size,
2592 duration_text);
2593 }
2594 free(duration_text);
2595
2596 image_close(&image);
2597
2598 return retval;
2599
2600 }
2601
2602 static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2603 {
2604 fileio_t fileio;
2605
2606 uint8_t buffer[560];
2607 int retvaltemp;
2608
2609 duration_t duration;
2610 char *duration_text;
2611
2612 target_t *target = get_current_target(cmd_ctx);
2613
2614 if (argc != 3)
2615 {
2616 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2617 return ERROR_OK;
2618 }
2619
2620 uint32_t address;
2621 COMMAND_PARSE_NUMBER(u32, args[1], address);
2622 uint32_t size;
2623 COMMAND_PARSE_NUMBER(u32, args[2], size);
2624
2625 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2626 {
2627 return ERROR_OK;
2628 }
2629
2630 duration_start_measure(&duration);
2631
2632 int retval = ERROR_OK;
2633 while (size > 0)
2634 {
2635 uint32_t size_written;
2636 uint32_t this_run_size = (size > 560) ? 560 : size;
2637 retval = target_read_buffer(target, address, this_run_size, buffer);
2638 if (retval != ERROR_OK)
2639 {
2640 break;
2641 }
2642
2643 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2644 if (retval != ERROR_OK)
2645 {
2646 break;
2647 }
2648
2649 size -= this_run_size;
2650 address += this_run_size;
2651 }
2652
2653 if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
2654 return retvaltemp;
2655
2656 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2657 return retvaltemp;
2658
2659 if (retval == ERROR_OK)
2660 {
2661 command_print(cmd_ctx, "dumped %lld byte in %s",
2662 fileio.size, duration_text);
2663 free(duration_text);
2664 }
2665
2666 return retval;
2667 }
2668
2669 static int handle_verify_image_command_internal(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, int verify)
2670 {
2671 uint8_t *buffer;
2672 uint32_t buf_cnt;
2673 uint32_t image_size;
2674 int i;
2675 int retval, retvaltemp;
2676 uint32_t checksum = 0;
2677 uint32_t mem_checksum = 0;
2678
2679 image_t image;
2680
2681 duration_t duration;
2682 char *duration_text;
2683
2684 target_t *target = get_current_target(cmd_ctx);
2685
2686 if (argc < 1)
2687 {
2688 return ERROR_COMMAND_SYNTAX_ERROR;
2689 }
2690
2691 if (!target)
2692 {
2693 LOG_ERROR("no target selected");
2694 return ERROR_FAIL;
2695 }
2696
2697 duration_start_measure(&duration);
2698
2699 if (argc >= 2)
2700 {
2701 uint32_t addr;
2702 COMMAND_PARSE_NUMBER(u32, args[1], addr);
2703 image.base_address = addr;
2704 image.base_address_set = 1;
2705 }
2706 else
2707 {
2708 image.base_address_set = 0;
2709 image.base_address = 0x0;
2710 }
2711
2712 image.start_address_set = 0;
2713
2714 if ((retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2715 {
2716 return retval;
2717 }
2718
2719 image_size = 0x0;
2720 retval = ERROR_OK;
2721 for (i = 0; i < image.num_sections; i++)
2722 {
2723 buffer = malloc(image.sections[i].size);
2724 if (buffer == NULL)
2725 {
2726 command_print(cmd_ctx,
2727 "error allocating buffer for section (%d bytes)",
2728 (int)(image.sections[i].size));
2729 break;
2730 }
2731 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2732 {
2733 free(buffer);
2734 break;
2735 }
2736
2737 if (verify)
2738 {
2739 /* calculate checksum of image */
2740 image_calculate_checksum(buffer, buf_cnt, &checksum);
2741
2742 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2743 if (retval != ERROR_OK)
2744 {
2745 free(buffer);
2746 break;
2747 }
2748
2749 if (checksum != mem_checksum)
2750 {
2751 /* failed crc checksum, fall back to a binary compare */
2752 uint8_t *data;
2753
2754 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2755
2756 data = (uint8_t*)malloc(buf_cnt);
2757
2758 /* Can we use 32bit word accesses? */
2759 int size = 1;
2760 int count = buf_cnt;
2761 if ((count % 4) == 0)
2762 {
2763 size *= 4;
2764 count /= 4;
2765 }
2766 retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
2767 if (retval == ERROR_OK)
2768 {
2769 uint32_t t;
2770 for (t = 0; t < buf_cnt; t++)
2771 {
2772 if (data[t] != buffer[t])
2773 {
2774 command_print(cmd_ctx,
2775 "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n",
2776 (unsigned)(t + image.sections[i].base_address),
2777 data[t],
2778 buffer[t]);
2779 free(data);
2780 free(buffer);
2781 retval = ERROR_FAIL;
2782 goto done;
2783 }
2784 if ((t%16384) == 0)
2785 {
2786 keep_alive();
2787 }
2788 }
2789 }
2790
2791 free(data);
2792 }
2793 } else
2794 {
2795 command_print(cmd_ctx, "address 0x%08" PRIx32 " length 0x%08" PRIx32 "",
2796 image.sections[i].base_address,
2797 buf_cnt);
2798 }
2799
2800 free(buffer);
2801 image_size += buf_cnt;
2802 }
2803 done:
2804
2805 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2806 {
2807 image_close(&image);
2808 return retvaltemp;
2809 }
2810
2811 if (retval == ERROR_OK)
2812 {
2813 command_print(cmd_ctx, "verified %u bytes in %s",
2814 (unsigned int)image_size,
2815 duration_text);
2816 }
2817 free(duration_text);
2818
2819 image_close(&image);
2820
2821 return retval;
2822 }
2823
2824 static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2825 {
2826 return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 1);
2827 }
2828
2829 static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2830 {
2831 return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 0);
2832 }
2833
2834 static int handle_bp_command_list(struct command_context_s *cmd_ctx)
2835 {
2836 target_t *target = get_current_target(cmd_ctx);
2837 breakpoint_t *breakpoint = target->breakpoints;
2838 while (breakpoint)
2839 {
2840 if (breakpoint->type == BKPT_SOFT)
2841 {
2842 char* buf = buf_to_str(breakpoint->orig_instr,
2843 breakpoint->length, 16);
2844 command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
2845 breakpoint->address,
2846 breakpoint->length,
2847 breakpoint->set, buf);
2848 free(buf);
2849 }
2850 else
2851 {
2852 command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i",
2853 breakpoint->address,
2854 breakpoint->length, breakpoint->set);
2855 }
2856
2857 breakpoint = breakpoint->next;
2858 }
2859 return ERROR_OK;
2860 }
2861
2862 static int handle_bp_command_set(struct command_context_s *cmd_ctx,
2863 uint32_t addr, uint32_t length, int hw)
2864 {
2865 target_t *target = get_current_target(cmd_ctx);
2866 int retval = breakpoint_add(target, addr, length, hw);
2867 if (ERROR_OK == retval)
2868 command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
2869 else
2870 LOG_ERROR("Failure setting breakpoint");
2871 return retval;
2872 }
2873
2874 static int handle_bp_command(struct command_context_s *cmd_ctx,
2875 char *cmd, char **args, int argc)
2876 {
2877 if (argc == 0)
2878 return handle_bp_command_list(cmd_ctx);
2879
2880 if (argc < 2 || argc > 3)
2881 {
2882 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2883 return ERROR_COMMAND_SYNTAX_ERROR;
2884 }
2885
2886 uint32_t addr;
2887 COMMAND_PARSE_NUMBER(u32, args[0], addr);
2888 uint32_t length;
2889 COMMAND_PARSE_NUMBER(u32, args[1], length);
2890
2891 int hw = BKPT_SOFT;
2892 if (argc == 3)
2893 {
2894 if (strcmp(args[2], "hw") == 0)
2895 hw = BKPT_HARD;
2896 else
2897 return ERROR_COMMAND_SYNTAX_ERROR;
2898 }
2899
2900 return handle_bp_command_set(cmd_ctx, addr, length, hw);
2901 }
2902
2903 static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2904 {
2905 if (argc != 1)
2906 return ERROR_COMMAND_SYNTAX_ERROR;
2907
2908 uint32_t addr;
2909 COMMAND_PARSE_NUMBER(u32, args[0], addr);
2910
2911 target_t *target = get_current_target(cmd_ctx);
2912 breakpoint_remove(target, addr);
2913
2914 return ERROR_OK;
2915 }
2916
2917 static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2918 {
2919 target_t *target = get_current_target(cmd_ctx);
2920
2921 if (argc == 0)
2922 {
2923 watchpoint_t *watchpoint = target->watchpoints;
2924
2925 while (watchpoint)
2926 {
2927 command_print(cmd_ctx,
2928 "address: 0x%8.8" PRIx32 ", len: 0x%8.8x, r/w/a: %i, value: 0x%8.8" PRIx32 ", mask: 0x%8.8" PRIx32 "",
2929 watchpoint->address,
2930 watchpoint->length,
2931 (int)(watchpoint->rw),
2932 watchpoint->value,
2933 watchpoint->mask);
2934 watchpoint = watchpoint->next;
2935 }
2936 return ERROR_OK;
2937 }
2938
2939 enum watchpoint_rw type = WPT_ACCESS;
2940 uint32_t addr = 0;
2941 uint32_t length = 0;
2942 uint32_t data_value = 0x0;
2943 uint32_t data_mask = 0xffffffff;
2944
2945 switch (argc)
2946 {
2947 case 5:
2948 COMMAND_PARSE_NUMBER(u32, args[4], data_mask);
2949 // fall through
2950 case 4:
2951 COMMAND_PARSE_NUMBER(u32, args[3], data_value);
2952 // fall through
2953 case 3:
2954 switch (args[2][0])
2955 {
2956 case 'r':
2957 type = WPT_READ;
2958 break;
2959 case 'w':
2960 type = WPT_WRITE;
2961 break;
2962 case 'a':
2963 type = WPT_ACCESS;
2964 break;
2965 default:
2966 LOG_ERROR("invalid watchpoint mode ('%c')", args[2][0]);
2967 return ERROR_COMMAND_SYNTAX_ERROR;
2968 }
2969 // fall through
2970 case 2:
2971 COMMAND_PARSE_NUMBER(u32, args[1], length);
2972 COMMAND_PARSE_NUMBER(u32, args[0], addr);
2973 break;
2974
2975 default:
2976 command_print(cmd_ctx, "usage: wp [address length "
2977 "[(r|w|a) [value [mask]]]]");
2978 return ERROR_COMMAND_SYNTAX_ERROR;
2979 }
2980
2981 int retval = watchpoint_add(target, addr, length, type,
2982 data_value, data_mask);
2983 if (ERROR_OK != retval)
2984 LOG_ERROR("Failure setting watchpoints");
2985
2986 return retval;
2987 }
2988
2989 static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2990 {
2991 if (argc != 1)
2992 return ERROR_COMMAND_SYNTAX_ERROR;
2993
2994 uint32_t addr;
2995 COMMAND_PARSE_NUMBER(u32, args[0], addr);
2996
2997 target_t *target = get_current_target(cmd_ctx);
2998 watchpoint_remove(target, addr);
2999
3000 return ERROR_OK;
3001 }
3002
3003
3004 /**
3005 * Translate a virtual address to a physical address.
3006 *
3007 * The low-level target implementation must have logged a detailed error
3008 * which is forwarded to telnet/GDB session.
3009 */
3010 static int handle_virt2phys_command(command_context_t *cmd_ctx,
3011 char *cmd, char **args, int argc)
3012 {
3013 if (argc != 1)
3014 return ERROR_COMMAND_SYNTAX_ERROR;
3015
3016 uint32_t va;
3017 COMMAND_PARSE_NUMBER(u32, args[0], va);
3018 uint32_t pa;
3019
3020 target_t *target = get_current_target(cmd_ctx);
3021 int retval = target->type->virt2phys(target, va, &pa);
3022 if (retval == ERROR_OK)
3023 command_print(cmd_ctx, "Physical address 0x%08" PRIx32 "", pa);
3024
3025 return retval;
3026 }
3027
3028 static void writeData(FILE *f, const void *data, size_t len)
3029 {
3030 size_t written = fwrite(data, 1, len, f);
3031 if (written != len)
3032 LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
3033 }
3034
3035 static void writeLong(FILE *f, int l)
3036 {
3037 int i;
3038 for (i = 0; i < 4; i++)
3039 {
3040 char c = (l >> (i*8))&0xff;
3041 writeData(f, &c, 1);
3042 }
3043
3044 }
3045
3046 static void writeString(FILE *f, char *s)
3047 {
3048 writeData(f, s, strlen(s));
3049 }
3050
3051 /* Dump a gmon.out histogram file. */
3052 static void writeGmon(uint32_t *samples, uint32_t sampleNum, char *filename)
3053 {
3054 uint32_t i;
3055 FILE *f = fopen(filename, "w");
3056 if (f == NULL)
3057 return;
3058 writeString(f, "gmon");
3059 writeLong(f, 0x00000001); /* Version */
3060 writeLong(f, 0); /* padding */
3061 writeLong(f, 0); /* padding */
3062 writeLong(f, 0); /* padding */
3063
3064 uint8_t zero = 0; /* GMON_TAG_TIME_HIST */
3065 writeData(f, &zero, 1);
3066
3067 /* figure out bucket size */
3068 uint32_t min = samples[0];
3069 uint32_t max = samples[0];
3070 for (i = 0; i < sampleNum; i++)
3071 {
3072 if (min > samples[i])
3073 {
3074 min = samples[i];
3075 }
3076 if (max < samples[i])
3077 {
3078 max = samples[i];
3079 }
3080 }
3081
3082 int addressSpace = (max-min + 1);
3083
3084 static const uint32_t maxBuckets = 256 * 1024; /* maximum buckets. */
3085 uint32_t length = addressSpace;
3086 if (length > maxBuckets)
3087 {
3088 length = maxBuckets;
3089 }
3090 int *buckets = malloc(sizeof(int)*length);
3091 if (buckets == NULL)
3092 {
3093 fclose(f);
3094 return;
3095 }
3096 memset(buckets, 0, sizeof(int)*length);
3097 for (i = 0; i < sampleNum;i++)
3098 {
3099 uint32_t address = samples[i];
3100 long long a = address-min;
3101 long long b = length-1;
3102 long long c = addressSpace-1;
3103 int index = (a*b)/c; /* danger!!!! int32 overflows */
3104 buckets[index]++;
3105 }
3106
3107 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
3108 writeLong(f, min); /* low_pc */
3109 writeLong(f, max); /* high_pc */
3110 writeLong(f, length); /* # of samples */
3111 writeLong(f, 64000000); /* 64MHz */
3112 writeString(f, "seconds");
3113 for (i = 0; i < (15-strlen("seconds")); i++)
3114 writeData(f, &zero, 1);
3115 writeString(f, "s");
3116
3117 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
3118
3119 char *data = malloc(2*length);
3120 if (data != NULL)
3121 {
3122 for (i = 0; i < length;i++)
3123 {
3124 int val;
3125 val = buckets[i];
3126 if (val > 65535)
3127 {
3128 val = 65535;
3129 }
3130 data[i*2]=val&0xff;
3131 data[i*2 + 1]=(val >> 8)&0xff;
3132 }
3133 free(buckets);
3134 writeData(f, data, length * 2);
3135 free(data);
3136 } else
3137 {
3138 free(buckets);
3139 }
3140
3141 fclose(f);
3142 }
3143
3144 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
3145 static int handle_profile_command(