1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * Copyright (C) 2008 by Hongtao Zheng *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
33 #include "embeddedice.h"
34 #include "target_request.h"
35 #include "arm7_9_common.h"
36 #include "time_support.h"
37 #include "arm_simulator.h"
40 int arm7_9_debug_entry(target_t
*target
);
41 int arm7_9_enable_sw_bkpts(struct target_s
*target
);
43 /* command handler forward declarations */
44 int handle_arm7_9_write_xpsr_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
45 int handle_arm7_9_write_xpsr_im8_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
46 int handle_arm7_9_read_core_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
47 int handle_arm7_9_write_core_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
48 int handle_arm7_9_dbgrq_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 int handle_arm7_9_fast_memory_access_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_arm7_9_dcc_downloads_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_arm7_9_etm_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 * Clear watchpoints for an ARM7/9 target.
56 * @param arm7_9 Pointer to the common struct for an ARM7/9 target
57 * @return JTAG error status after executing queue
59 static int arm7_9_clear_watchpoints(arm7_9_common_t
*arm7_9
)
62 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
63 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
64 arm7_9
->sw_breakpoint_count
= 0;
65 arm7_9
->sw_breakpoints_added
= 0;
67 arm7_9
->wp1_used
= arm7_9
->wp1_used_default
;
68 arm7_9
->wp_available
= arm7_9
->wp_available_max
;
70 return jtag_execute_queue();
74 * Assign a watchpoint to one of the two available hardware comparators in an
75 * ARM7 or ARM9 target.
77 * @param arm7_9 Pointer to the common struct for an ARM7/9 target
78 * @param breakpoint Pointer to the breakpoint to be used as a watchpoint
80 static void arm7_9_assign_wp(arm7_9_common_t
*arm7_9
, breakpoint_t
*breakpoint
)
82 if (!arm7_9
->wp0_used
)
86 arm7_9
->wp_available
--;
88 else if (!arm7_9
->wp1_used
)
92 arm7_9
->wp_available
--;
96 LOG_ERROR("BUG: no hardware comparator available");
98 LOG_DEBUG("BPID: %d (0x%08" PRIx32
") using hw wp: %d",
99 breakpoint
->unique_id
,
105 * Setup an ARM7/9 target's embedded ICE registers for software breakpoints.
107 * @param arm7_9 Pointer to common struct for ARM7/9 targets
108 * @return Error codes if there is a problem finding a watchpoint or the result
109 * of executing the JTAG queue
111 static int arm7_9_set_software_breakpoints(arm7_9_common_t
*arm7_9
)
113 if (arm7_9
->sw_breakpoints_added
)
117 if (arm7_9
->wp_available
< 1)
119 LOG_WARNING("can't enable sw breakpoints with no watchpoint unit available");
120 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
122 arm7_9
->wp_available
--;
124 /* pick a breakpoint unit */
125 if (!arm7_9
->wp0_used
)
127 arm7_9
->sw_breakpoints_added
= 1;
128 arm7_9
->wp0_used
= 3;
129 } else if (!arm7_9
->wp1_used
)
131 arm7_9
->sw_breakpoints_added
= 2;
132 arm7_9
->wp1_used
= 3;
136 LOG_ERROR("BUG: both watchpoints used, but wp_available >= 1");
140 if (arm7_9
->sw_breakpoints_added
== 1)
142 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_VALUE
], arm7_9
->arm_bkpt
);
143 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0x0);
144 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffffu
);
145 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
146 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
148 else if (arm7_9
->sw_breakpoints_added
== 2)
150 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_VALUE
], arm7_9
->arm_bkpt
);
151 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0x0);
152 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], 0xffffffffu
);
153 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
154 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
158 LOG_ERROR("BUG: both watchpoints used, but wp_available >= 1");
161 LOG_DEBUG("SW BP using hw wp: %d",
162 arm7_9
->sw_breakpoints_added
);
164 return jtag_execute_queue();
168 * Setup the common pieces for an ARM7/9 target after reset or on startup.
170 * @param target Pointer to an ARM7/9 target to setup
171 * @return Result of clearing the watchpoints on the target
173 int arm7_9_setup(target_t
*target
)
175 armv4_5_common_t
*armv4_5
= target
->arch_info
;
176 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
178 return arm7_9_clear_watchpoints(arm7_9
);
182 * Retrieves the architecture information pointers for ARMv4/5 and ARM7/9
183 * targets. A return of ERROR_OK signifies that the target is a valid target
184 * and that the pointers have been set properly.
186 * @param target Pointer to the target device to get the pointers from
187 * @param armv4_5_p Pointer to be filled in with the common struct for ARMV4/5
189 * @param arm7_9_p Pointer to be filled in with the common struct for ARM7/9
191 * @return ERROR_OK if successful
193 int arm7_9_get_arch_pointers(target_t
*target
, armv4_5_common_t
**armv4_5_p
, arm7_9_common_t
**arm7_9_p
)
195 armv4_5_common_t
*armv4_5
= target
->arch_info
;
196 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
198 if (armv4_5
->common_magic
!= ARMV4_5_COMMON_MAGIC
)
203 if (arm7_9
->common_magic
!= ARM7_9_COMMON_MAGIC
)
208 *armv4_5_p
= armv4_5
;
215 * Set either a hardware or software breakpoint on an ARM7/9 target. The
216 * breakpoint is set up even if it is already set. Some actions, e.g. reset,
217 * might have erased the values in Embedded ICE.
219 * @param target Pointer to the target device to set the breakpoints on
220 * @param breakpoint Pointer to the breakpoint to be set
221 * @return For hardware breakpoints, this is the result of executing the JTAG
222 * queue. For software breakpoints, this will be the status of the
223 * required memory reads and writes
225 int arm7_9_set_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
227 armv4_5_common_t
*armv4_5
= target
->arch_info
;
228 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
229 int retval
= ERROR_OK
;
231 LOG_DEBUG("BPID: %d, Address: 0x%08" PRIx32
", Type: %d" ,
232 breakpoint
->unique_id
,
236 if (target
->state
!= TARGET_HALTED
)
238 LOG_WARNING("target not halted");
239 return ERROR_TARGET_NOT_HALTED
;
242 if (breakpoint
->type
== BKPT_HARD
)
244 /* either an ARM (4 byte) or Thumb (2 byte) breakpoint */
245 uint32_t mask
= (breakpoint
->length
== 4) ? 0x3u
: 0x1u
;
247 /* reassign a hw breakpoint */
248 if (breakpoint
->set
== 0)
250 arm7_9_assign_wp(arm7_9
, breakpoint
);
253 if (breakpoint
->set
== 1)
255 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_VALUE
], breakpoint
->address
);
256 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], mask
);
257 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffffu
);
258 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
259 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
261 else if (breakpoint
->set
== 2)
263 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], breakpoint
->address
);
264 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], mask
);
265 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0xffffffffu
);
266 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
267 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
271 LOG_ERROR("BUG: no hardware comparator available");
275 retval
= jtag_execute_queue();
277 else if (breakpoint
->type
== BKPT_SOFT
)
279 /* did we already set this breakpoint? */
283 if (breakpoint
->length
== 4)
285 uint32_t verify
= 0xffffffff;
286 /* keep the original instruction in target endianness */
287 if ((retval
= target_read_memory(target
, breakpoint
->address
, 4, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
291 /* write the breakpoint instruction in target endianness (arm7_9->arm_bkpt is host endian) */
292 if ((retval
= target_write_u32(target
, breakpoint
->address
, arm7_9
->arm_bkpt
)) != ERROR_OK
)
297 if ((retval
= target_read_u32(target
, breakpoint
->address
, &verify
)) != ERROR_OK
)
301 if (verify
!= arm7_9
->arm_bkpt
)
303 LOG_ERROR("Unable to set 32 bit software breakpoint at address %08" PRIx32
" - check that memory is read/writable", breakpoint
->address
);
309 uint16_t verify
= 0xffff;
310 /* keep the original instruction in target endianness */
311 if ((retval
= target_read_memory(target
, breakpoint
->address
, 2, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
315 /* write the breakpoint instruction in target endianness (arm7_9->thumb_bkpt is host endian) */
316 if ((retval
= target_write_u16(target
, breakpoint
->address
, arm7_9
->thumb_bkpt
)) != ERROR_OK
)
321 if ((retval
= target_read_u16(target
, breakpoint
->address
, &verify
)) != ERROR_OK
)
325 if (verify
!= arm7_9
->thumb_bkpt
)
327 LOG_ERROR("Unable to set thumb software breakpoint at address %08" PRIx32
" - check that memory is read/writable", breakpoint
->address
);
332 if ((retval
= arm7_9_set_software_breakpoints(arm7_9
)) != ERROR_OK
)
335 arm7_9
->sw_breakpoint_count
++;
344 * Unsets an existing breakpoint on an ARM7/9 target. If it is a hardware
345 * breakpoint, the watchpoint used will be freed and the Embedded ICE registers
346 * will be updated. Otherwise, the software breakpoint will be restored to its
347 * original instruction if it hasn't already been modified.
349 * @param target Pointer to ARM7/9 target to unset the breakpoint from
350 * @param breakpoint Pointer to breakpoint to be unset
351 * @return For hardware breakpoints, this is the result of executing the JTAG
352 * queue. For software breakpoints, this will be the status of the
353 * required memory reads and writes
355 int arm7_9_unset_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
357 int retval
= ERROR_OK
;
359 armv4_5_common_t
*armv4_5
= target
->arch_info
;
360 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
362 LOG_DEBUG("BPID: %d, Address: 0x%08" PRIx32
,
363 breakpoint
->unique_id
,
364 breakpoint
->address
);
366 if (!breakpoint
->set
)
368 LOG_WARNING("breakpoint not set");
372 if (breakpoint
->type
== BKPT_HARD
)
374 LOG_DEBUG("BPID: %d Releasing hw wp: %d",
375 breakpoint
->unique_id
,
377 if (breakpoint
->set
== 1)
379 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
380 arm7_9
->wp0_used
= 0;
381 arm7_9
->wp_available
++;
383 else if (breakpoint
->set
== 2)
385 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
386 arm7_9
->wp1_used
= 0;
387 arm7_9
->wp_available
++;
389 retval
= jtag_execute_queue();
394 /* restore original instruction (kept in target endianness) */
395 if (breakpoint
->length
== 4)
397 uint32_t current_instr
;
398 /* check that user program as not modified breakpoint instruction */
399 if ((retval
= target_read_memory(target
, breakpoint
->address
, 4, 1, (uint8_t*)¤t_instr
)) != ERROR_OK
)
403 if (current_instr
== arm7_9
->arm_bkpt
)
404 if ((retval
= target_write_memory(target
, breakpoint
->address
, 4, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
411 uint16_t current_instr
;
412 /* check that user program as not modified breakpoint instruction */
413 if ((retval
= target_read_memory(target
, breakpoint
->address
, 2, 1, (uint8_t*)¤t_instr
)) != ERROR_OK
)
417 if (current_instr
== arm7_9
->thumb_bkpt
)
418 if ((retval
= target_write_memory(target
, breakpoint
->address
, 2, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
424 if (--arm7_9
->sw_breakpoint_count
==0)
426 /* We have removed the last sw breakpoint, clear the hw breakpoint we used to implement it */
427 if (arm7_9
->sw_breakpoints_added
== 1)
429 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0);
431 else if (arm7_9
->sw_breakpoints_added
== 2)
433 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0);
444 * Add a breakpoint to an ARM7/9 target. This makes sure that there are no
445 * dangling breakpoints and that the desired breakpoint can be added.
447 * @param target Pointer to the target ARM7/9 device to add a breakpoint to
448 * @param breakpoint Pointer to the breakpoint to be added
449 * @return An error status if there is a problem adding the breakpoint or the
450 * result of setting the breakpoint
452 int arm7_9_add_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
454 armv4_5_common_t
*armv4_5
= target
->arch_info
;
455 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
457 if (target
->state
!= TARGET_HALTED
)
459 LOG_WARNING("target not halted");
460 return ERROR_TARGET_NOT_HALTED
;
463 if (arm7_9
->breakpoint_count
== 0)
465 /* make sure we don't have any dangling breakpoints. This is vital upon
466 * GDB connect/disconnect
468 arm7_9_clear_watchpoints(arm7_9
);
471 if ((breakpoint
->type
== BKPT_HARD
) && (arm7_9
->wp_available
< 1))
473 LOG_INFO("no watchpoint unit available for hardware breakpoint");
474 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
477 if ((breakpoint
->length
!= 2) && (breakpoint
->length
!= 4))
479 LOG_INFO("only breakpoints of two (Thumb) or four (ARM) bytes length supported");
480 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
483 if (breakpoint
->type
== BKPT_HARD
)
485 arm7_9_assign_wp(arm7_9
, breakpoint
);
488 arm7_9
->breakpoint_count
++;
490 return arm7_9_set_breakpoint(target
, breakpoint
);
494 * Removes a breakpoint from an ARM7/9 target. This will make sure there are no
495 * dangling breakpoints and updates available watchpoints if it is a hardware
498 * @param target Pointer to the target to have a breakpoint removed
499 * @param breakpoint Pointer to the breakpoint to be removed
500 * @return Error status if there was a problem unsetting the breakpoint or the
501 * watchpoints could not be cleared
503 int arm7_9_remove_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
505 int retval
= ERROR_OK
;
506 armv4_5_common_t
*armv4_5
= target
->arch_info
;
507 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
509 if ((retval
= arm7_9_unset_breakpoint(target
, breakpoint
)) != ERROR_OK
)
514 if (breakpoint
->type
== BKPT_HARD
)
515 arm7_9
->wp_available
++;
517 arm7_9
->breakpoint_count
--;
518 if (arm7_9
->breakpoint_count
== 0)
520 /* make sure we don't have any dangling breakpoints */
521 if ((retval
= arm7_9_clear_watchpoints(arm7_9
)) != ERROR_OK
)
531 * Sets a watchpoint for an ARM7/9 target in one of the watchpoint units. It is
532 * considered a bug to call this function when there are no available watchpoint
535 * @param target Pointer to an ARM7/9 target to set a watchpoint on
536 * @param watchpoint Pointer to the watchpoint to be set
537 * @return Error status if watchpoint set fails or the result of executing the
540 int arm7_9_set_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
542 int retval
= ERROR_OK
;
543 armv4_5_common_t
*armv4_5
= target
->arch_info
;
544 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
548 mask
= watchpoint
->length
- 1;
550 if (target
->state
!= TARGET_HALTED
)
552 LOG_WARNING("target not halted");
553 return ERROR_TARGET_NOT_HALTED
;
556 if (watchpoint
->rw
== WPT_ACCESS
)
561 if (!arm7_9
->wp0_used
)
563 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_VALUE
], watchpoint
->address
);
564 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], mask
);
565 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], watchpoint
->mask
);
566 if (watchpoint
->mask
!= 0xffffffffu
)
567 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_VALUE
], watchpoint
->value
);
568 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], 0xff & ~EICE_W_CTRL_nOPC
& ~rw_mask
);
569 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
| EICE_W_CTRL_nOPC
| (watchpoint
->rw
& 1));
571 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
576 arm7_9
->wp0_used
= 2;
578 else if (!arm7_9
->wp1_used
)
580 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], watchpoint
->address
);
581 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], mask
);
582 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], watchpoint
->mask
);
583 if (watchpoint
->mask
!= 0xffffffffu
)
584 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_VALUE
], watchpoint
->value
);
585 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], 0xff & ~EICE_W_CTRL_nOPC
& ~rw_mask
);
586 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
| EICE_W_CTRL_nOPC
| (watchpoint
->rw
& 1));
588 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
593 arm7_9
->wp1_used
= 2;
597 LOG_ERROR("BUG: no hardware comparator available");
605 * Unset an existing watchpoint and clear the used watchpoint unit.
607 * @param target Pointer to the target to have the watchpoint removed
608 * @param watchpoint Pointer to the watchpoint to be removed
609 * @return Error status while trying to unset the watchpoint or the result of
610 * executing the JTAG queue
612 int arm7_9_unset_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
614 int retval
= ERROR_OK
;
615 armv4_5_common_t
*armv4_5
= target
->arch_info
;
616 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
618 if (target
->state
!= TARGET_HALTED
)
620 LOG_WARNING("target not halted");
621 return ERROR_TARGET_NOT_HALTED
;
624 if (!watchpoint
->set
)
626 LOG_WARNING("breakpoint not set");
630 if (watchpoint
->set
== 1)
632 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
633 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
637 arm7_9
->wp0_used
= 0;
639 else if (watchpoint
->set
== 2)
641 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
642 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
646 arm7_9
->wp1_used
= 0;
654 * Add a watchpoint to an ARM7/9 target. If there are no watchpoint units
655 * available, an error response is returned.
657 * @param target Pointer to the ARM7/9 target to add a watchpoint to
658 * @param watchpoint Pointer to the watchpoint to be added
659 * @return Error status while trying to add the watchpoint
661 int arm7_9_add_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
663 armv4_5_common_t
*armv4_5
= target
->arch_info
;
664 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
666 if (target
->state
!= TARGET_HALTED
)
668 LOG_WARNING("target not halted");
669 return ERROR_TARGET_NOT_HALTED
;
672 if (arm7_9
->wp_available
< 1)
674 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
677 if ((watchpoint
->length
!= 1) && (watchpoint
->length
!= 2) && (watchpoint
->length
!= 4))
679 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
682 arm7_9
->wp_available
--;
688 * Remove a watchpoint from an ARM7/9 target. The watchpoint will be unset and
689 * the used watchpoint unit will be reopened.
691 * @param target Pointer to the target to remove a watchpoint from
692 * @param watchpoint Pointer to the watchpoint to be removed
693 * @return Result of trying to unset the watchpoint
695 int arm7_9_remove_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
697 int retval
= ERROR_OK
;
698 armv4_5_common_t
*armv4_5
= target
->arch_info
;
699 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
703 if ((retval
= arm7_9_unset_watchpoint(target
, watchpoint
)) != ERROR_OK
)
709 arm7_9
->wp_available
++;
715 * Restarts the target by sending a RESTART instruction and moving the JTAG
716 * state to IDLE. This includes a timeout waiting for DBGACK and SYSCOMP to be
717 * asserted by the processor.
719 * @param target Pointer to target to issue commands to
720 * @return Error status if there is a timeout or a problem while executing the
723 int arm7_9_execute_sys_speed(struct target_s
*target
)
727 armv4_5_common_t
*armv4_5
= target
->arch_info
;
728 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
729 arm_jtag_t
*jtag_info
= &arm7_9
->jtag_info
;
730 reg_t
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
732 /* set RESTART instruction */
733 jtag_set_end_state(TAP_IDLE
);
734 if (arm7_9
->need_bypass_before_restart
) {
735 arm7_9
->need_bypass_before_restart
= 0;
736 arm_jtag_set_instr(jtag_info
, 0xf, NULL
);
738 arm_jtag_set_instr(jtag_info
, 0x4, NULL
);
740 long long then
= timeval_ms();
742 while (!(timeout
= ((timeval_ms()-then
) > 1000)))
744 /* read debug status register */
745 embeddedice_read_reg(dbg_stat
);
746 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
748 if ((buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_DBGACK
, 1))
749 && (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_SYSCOMP
, 1)))
751 if (debug_level
>= 3)
761 LOG_ERROR("timeout waiting for SYSCOMP & DBGACK, last DBG_STATUS: %" PRIx32
"", buf_get_u32(dbg_stat
->value
, 0, dbg_stat
->size
));
762 return ERROR_TARGET_TIMEOUT
;
769 * Restarts the target by sending a RESTART instruction and moving the JTAG
770 * state to IDLE. This validates that DBGACK and SYSCOMP are set without
771 * waiting until they are.
773 * @param target Pointer to the target to issue commands to
774 * @return Always ERROR_OK
776 int arm7_9_execute_fast_sys_speed(struct target_s
*target
)
779 static uint8_t check_value
[4], check_mask
[4];
781 armv4_5_common_t
*armv4_5
= target
->arch_info
;
782 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
783 arm_jtag_t
*jtag_info
= &arm7_9
->jtag_info
;
784 reg_t
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
786 /* set RESTART instruction */
787 jtag_set_end_state(TAP_IDLE
);
788 if (arm7_9
->need_bypass_before_restart
) {
789 arm7_9
->need_bypass_before_restart
= 0;
790 arm_jtag_set_instr(jtag_info
, 0xf, NULL
);
792 arm_jtag_set_instr(jtag_info
, 0x4, NULL
);
796 /* check for DBGACK and SYSCOMP set (others don't care) */
798 /* NB! These are constants that must be available until after next jtag_execute() and
799 * we evaluate the values upon first execution in lieu of setting up these constants
800 * during early setup.
802 buf_set_u32(check_value
, 0, 32, 0x9);
803 buf_set_u32(check_mask
, 0, 32, 0x9);
807 /* read debug status register */
808 embeddedice_read_reg_w_check(dbg_stat
, check_value
, check_mask
);
814 * Get some data from the ARM7/9 target.
816 * @param target Pointer to the ARM7/9 target to read data from
817 * @param size The number of 32bit words to be read
818 * @param buffer Pointer to the buffer that will hold the data
819 * @return The result of receiving data from the Embedded ICE unit
821 int arm7_9_target_request_data(target_t
*target
, uint32_t size
, uint8_t *buffer
)
823 armv4_5_common_t
*armv4_5
= target
->arch_info
;
824 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
825 arm_jtag_t
*jtag_info
= &arm7_9
->jtag_info
;
827 int retval
= ERROR_OK
;
830 data
= malloc(size
* (sizeof(uint32_t)));
832 retval
= embeddedice_receive(jtag_info
, data
, size
);
834 /* return the 32-bit ints in the 8-bit array */
835 for (i
= 0; i
< size
; i
++)
837 h_u32_to_le(buffer
+ (i
* 4), data
[i
]);
846 * Handles requests to an ARM7/9 target. If debug messaging is enabled, the
847 * target is running and the DCC control register has the W bit high, this will
848 * execute the request on the target.
850 * @param priv Void pointer expected to be a target_t pointer
851 * @return ERROR_OK unless there are issues with the JTAG queue or when reading
852 * from the Embedded ICE unit
854 int arm7_9_handle_target_request(void *priv
)
856 int retval
= ERROR_OK
;
857 target_t
*target
= priv
;
858 if (!target_was_examined(target
))
860 armv4_5_common_t
*armv4_5
= target
->arch_info
;
861 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
862 arm_jtag_t
*jtag_info
= &arm7_9
->jtag_info
;
863 reg_t
*dcc_control
= &arm7_9
->eice_cache
->reg_list
[EICE_COMMS_CTRL
];
865 if (!target
->dbg_msg_enabled
)
868 if (target
->state
== TARGET_RUNNING
)
870 /* read DCC control register */
871 embeddedice_read_reg(dcc_control
);
872 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
878 if (buf_get_u32(dcc_control
->value
, 1, 1) == 1)
882 if ((retval
= embeddedice_receive(jtag_info
, &request
, 1)) != ERROR_OK
)
886 if ((retval
= target_request(target
, request
)) != ERROR_OK
)
897 * Polls an ARM7/9 target for its current status. If DBGACK is set, the target
898 * is manipulated to the right halted state based on its current state. This is
902 * <tr><th > State</th><th > Action</th></tr>
903 * <tr><td > TARGET_RUNNING | TARGET_RESET</td><td > Enters debug mode. If TARGET_RESET, pc may be checked</td></tr>
904 * <tr><td > TARGET_UNKNOWN</td><td > Warning is logged</td></tr>
905 * <tr><td > TARGET_DEBUG_RUNNING</td><td > Enters debug mode</td></tr>
906 * <tr><td > TARGET_HALTED</td><td > Nothing</td></tr>
909 * If the target does not end up in the halted state, a warning is produced. If
910 * DBGACK is cleared, then the target is expected to either be running or
913 * @param target Pointer to the ARM7/9 target to poll
914 * @return ERROR_OK or an error status if a command fails
916 int arm7_9_poll(target_t
*target
)
919 armv4_5_common_t
*armv4_5
= target
->arch_info
;
920 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
921 reg_t
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
923 /* read debug status register */
924 embeddedice_read_reg(dbg_stat
);
925 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
930 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_DBGACK
, 1))
932 /* LOG_DEBUG("DBGACK set, dbg_state->value: 0x%x", buf_get_u32(dbg_stat->value, 0, 32));*/
933 if (target
->state
== TARGET_UNKNOWN
)
935 /* Starting OpenOCD with target in debug-halt */
936 target
->state
= TARGET_RUNNING
;
937 LOG_DEBUG("DBGACK already set during server startup.");
939 if ((target
->state
== TARGET_RUNNING
) || (target
->state
== TARGET_RESET
))
942 if (target
->state
== TARGET_RESET
)
944 if (target
->reset_halt
)
946 enum reset_types jtag_reset_config
= jtag_get_reset_config();
947 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
) == 0)
954 target
->state
= TARGET_HALTED
;
956 if ((retval
= arm7_9_debug_entry(target
)) != ERROR_OK
)
961 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
962 uint32_t t
=*((uint32_t *)reg
->value
);
965 LOG_ERROR("PC was not 0. Does this target need srst_pulls_trst?");
969 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_HALTED
)) != ERROR_OK
)
974 if (target
->state
== TARGET_DEBUG_RUNNING
)
976 target
->state
= TARGET_HALTED
;
977 if ((retval
= arm7_9_debug_entry(target
)) != ERROR_OK
)
980 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_HALTED
)) != ERROR_OK
)
985 if (target
->state
!= TARGET_HALTED
)
987 LOG_WARNING("DBGACK set, but the target did not end up in the halted state %d", target
->state
);
992 if (target
->state
!= TARGET_DEBUG_RUNNING
)
993 target
->state
= TARGET_RUNNING
;
1000 * Asserts the reset (SRST) on an ARM7/9 target. Some -S targets (ARM966E-S in
1001 * the STR912 isn't affected, ARM926EJ-S in the LPC3180 and AT91SAM9260 is
1002 * affected) completely stop the JTAG clock while the core is held in reset
1003 * (SRST). It isn't possible to program the halt condition once reset is
1004 * asserted, hence a hook that allows the target to set up its reset-halt
1005 * condition is setup prior to asserting reset.
1007 * @param target Pointer to an ARM7/9 target to assert reset on
1008 * @return ERROR_FAIL if the JTAG device does not have SRST, otherwise ERROR_OK
1010 int arm7_9_assert_reset(target_t
*target
)
1012 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1013 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1014 LOG_DEBUG("target->state: %s",
1015 target_state_name(target
));
1017 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1018 if (!(jtag_reset_config
& RESET_HAS_SRST
))
1020 LOG_ERROR("Can't assert SRST");
1024 /* At this point trst has been asserted/deasserted once. We would
1025 * like to program EmbeddedICE while SRST is asserted, instead of
1026 * depending on SRST to leave that module alone. However, many CPUs
1027 * gate the JTAG clock while SRST is asserted; or JTAG may need
1028 * clock stability guarantees (adaptive clocking might help).
1030 * So we assume JTAG access during SRST is off the menu unless it's
1031 * been specifically enabled.
1033 bool srst_asserted
= false;
1035 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) == 0)
1036 && (jtag_reset_config
& RESET_SRST_NO_GATING
))
1038 jtag_add_reset(0, 1);
1039 srst_asserted
= true;
1042 if (target
->reset_halt
)
1045 * Some targets do not support communication while SRST is asserted. We need to
1046 * set up the reset vector catch here.
1048 * If TRST is asserted, then these settings will be reset anyway, so setting them
1051 if (arm7_9
->has_vector_catch
)
1053 /* program vector catch register to catch reset vector */
1054 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_VEC_CATCH
], 0x1);
1056 /* extra runtest added as issues were found with certain ARM9 cores (maybe more) - AT91SAM9260 and STR9 */
1057 jtag_add_runtest(1, jtag_get_end_state());
1061 /* program watchpoint unit to match on reset vector address */
1062 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_VALUE
], 0x0);
1063 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0x3);
1064 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffff);
1065 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
1066 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
1070 /* here we should issue an SRST only, but we may have to assert TRST as well */
1071 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
1073 jtag_add_reset(1, 1);
1074 } else if (!srst_asserted
)
1076 jtag_add_reset(0, 1);
1079 target
->state
= TARGET_RESET
;
1080 jtag_add_sleep(50000);
1082 armv4_5_invalidate_core_regs(target
);
1084 if ((target
->reset_halt
) && ((jtag_reset_config
& RESET_SRST_PULLS_TRST
) == 0))
1086 /* debug entry was already prepared in arm7_9_assert_reset() */
1087 target
->debug_reason
= DBG_REASON_DBGRQ
;
1094 * Deassert the reset (SRST) signal on an ARM7/9 target. If SRST pulls TRST
1095 * and the target is being reset into a halt, a warning will be triggered
1096 * because it is not possible to reset into a halted mode in this case. The
1097 * target is halted using the target's functions.
1099 * @param target Pointer to the target to have the reset deasserted
1100 * @return ERROR_OK or an error from polling or halting the target
1102 int arm7_9_deassert_reset(target_t
*target
)
1104 int retval
= ERROR_OK
;
1105 LOG_DEBUG("target->state: %s",
1106 target_state_name(target
));
1108 /* deassert reset lines */
1109 jtag_add_reset(0, 0);
1111 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1112 if (target
->reset_halt
&& (jtag_reset_config
& RESET_SRST_PULLS_TRST
) != 0)
1114 LOG_WARNING("srst pulls trst - can not reset into halted mode. Issuing halt after reset.");
1115 /* set up embedded ice registers again */
1116 if ((retval
= target_examine_one(target
)) != ERROR_OK
)
1119 if ((retval
= target_poll(target
)) != ERROR_OK
)
1124 if ((retval
= target_halt(target
)) != ERROR_OK
)
1134 * Clears the halt condition for an ARM7/9 target. If it isn't coming out of
1135 * reset and if DBGRQ is used, it is progammed to be deasserted. If the reset
1136 * vector catch was used, it is restored. Otherwise, the control value is
1137 * restored and the watchpoint unit is restored if it was in use.
1139 * @param target Pointer to the ARM7/9 target to have halt cleared
1140 * @return Always ERROR_OK
1142 int arm7_9_clear_halt(target_t
*target
)
1144 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1145 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1146 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1148 /* we used DBGRQ only if we didn't come out of reset */
1149 if (!arm7_9
->debug_entry_from_reset
&& arm7_9
->use_dbgrq
)
1151 /* program EmbeddedICE Debug Control Register to deassert DBGRQ
1153 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 0);
1154 embeddedice_store_reg(dbg_ctrl
);
1158 if (arm7_9
->debug_entry_from_reset
&& arm7_9
->has_vector_catch
)
1160 /* if we came out of reset, and vector catch is supported, we used
1161 * vector catch to enter debug state
1162 * restore the register in that case
1164 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_VEC_CATCH
]);
1168 /* restore registers if watchpoint unit 0 was in use
1170 if (arm7_9
->wp0_used
)
1172 if (arm7_9
->debug_entry_from_reset
)
1174 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_VALUE
]);
1176 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
]);
1177 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
]);
1178 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
]);
1180 /* control value always has to be restored, as it was either disabled,
1181 * or enabled with possibly different bits
1183 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
]);
1191 * Issue a software reset and halt to an ARM7/9 target. The target is halted
1192 * and then there is a wait until the processor shows the halt. This wait can
1193 * timeout and results in an error being returned. The software reset involves
1194 * clearing the halt, updating the debug control register, changing to ARM mode,
1195 * reset of the program counter, and reset of all of the registers.
1197 * @param target Pointer to the ARM7/9 target to be reset and halted by software
1198 * @return Error status if any of the commands fail, otherwise ERROR_OK
1200 int arm7_9_soft_reset_halt(struct target_s
*target
)
1202 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1203 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1204 reg_t
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
1205 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1209 /* FIX!!! replace some of this code with tcl commands
1211 * halt # the halt command is synchronous
1212 * armv4_5 core_state arm
1216 if ((retval
= target_halt(target
)) != ERROR_OK
)
1219 long long then
= timeval_ms();
1221 while (!(timeout
= ((timeval_ms()-then
) > 1000)))
1223 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_DBGACK
, 1) != 0)
1225 embeddedice_read_reg(dbg_stat
);
1226 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1228 if (debug_level
>= 3)
1238 LOG_ERROR("Failed to halt CPU after 1 sec");
1239 return ERROR_TARGET_TIMEOUT
;
1241 target
->state
= TARGET_HALTED
;
1243 /* program EmbeddedICE Debug Control Register to assert DBGACK and INTDIS
1244 * ensure that DBGRQ is cleared
1246 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 1);
1247 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 0);
1248 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_INTDIS
, 1, 1);
1249 embeddedice_store_reg(dbg_ctrl
);
1251 if ((retval
= arm7_9_clear_halt(target
)) != ERROR_OK
)
1256 /* if the target is in Thumb state, change to ARM state */
1257 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_ITBIT
, 1))
1259 uint32_t r0_thumb
, pc_thumb
;
1260 LOG_DEBUG("target entered debug from Thumb state, changing to ARM");
1261 /* Entered debug from Thumb mode */
1262 armv4_5
->core_state
= ARMV4_5_STATE_THUMB
;
1263 arm7_9
->change_to_arm(target
, &r0_thumb
, &pc_thumb
);
1266 /* all register content is now invalid */
1267 if ((retval
= armv4_5_invalidate_core_regs(target
)) != ERROR_OK
)
1272 /* SVC, ARM state, IRQ and FIQ disabled */
1273 buf_set_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8, 0xd3);
1274 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].dirty
= 1;
1275 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].valid
= 1;
1277 /* start fetching from 0x0 */
1278 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, 0x0);
1279 armv4_5
->core_cache
->reg_list
[15].dirty
= 1;
1280 armv4_5
->core_cache
->reg_list
[15].valid
= 1;
1282 armv4_5
->core_mode
= ARMV4_5_MODE_SVC
;
1283 armv4_5
->core_state
= ARMV4_5_STATE_ARM
;
1285 if (armv4_5_mode_to_number(armv4_5
->core_mode
)==-1)
1288 /* reset registers */
1289 for (i
= 0; i
<= 14; i
++)
1291 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).value
, 0, 32, 0xffffffff);
1292 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= 1;
1293 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).valid
= 1;
1296 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_HALTED
)) != ERROR_OK
)
1305 * Halt an ARM7/9 target. This is accomplished by either asserting the DBGRQ
1306 * line or by programming a watchpoint to trigger on any address. It is
1307 * considered a bug to call this function while the target is in the
1308 * TARGET_RESET state.
1310 * @param target Pointer to the ARM7/9 target to be halted
1311 * @return Always ERROR_OK
1313 int arm7_9_halt(target_t
*target
)
1315 if (target
->state
== TARGET_RESET
)
1317 LOG_ERROR("BUG: arm7/9 does not support halt during reset. This is handled in arm7_9_assert_reset()");
1321 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1322 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1323 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1325 LOG_DEBUG("target->state: %s",
1326 target_state_name(target
));
1328 if (target
->state
== TARGET_HALTED
)
1330 LOG_DEBUG("target was already halted");
1334 if (target
->state
== TARGET_UNKNOWN
)
1336 LOG_WARNING("target was in unknown state when halt was requested");
1339 if (arm7_9
->use_dbgrq
)
1341 /* program EmbeddedICE Debug Control Register to assert DBGRQ
1343 if (arm7_9
->set_special_dbgrq
) {
1344 arm7_9
->set_special_dbgrq(target
);
1346 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 1);
1347 embeddedice_store_reg(dbg_ctrl
);
1352 /* program watchpoint unit to match on any address
1354 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffff);
1355 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffff);
1356 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
1357 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
1360 target
->debug_reason
= DBG_REASON_DBGRQ
;
1366 * Handle an ARM7/9 target's entry into debug mode. The halt is cleared on the
1367 * ARM. The JTAG queue is then executed and the reason for debug entry is
1368 * examined. Once done, the target is verified to be halted and the processor
1369 * is forced into ARM mode. The core registers are saved for the current core
1370 * mode and the program counter (register 15) is updated as needed. The core
1371 * registers and CPSR and SPSR are saved for restoration later.
1373 * @param target Pointer to target that is entering debug mode
1374 * @return Error code if anything fails, otherwise ERROR_OK
1376 int arm7_9_debug_entry(target_t
*target
)
1379 uint32_t context
[16];
1380 uint32_t* context_p
[16];
1381 uint32_t r0_thumb
, pc_thumb
;
1384 /* get pointers to arch-specific information */
1385 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1386 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1387 reg_t
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
1388 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1390 #ifdef _DEBUG_ARM7_9_
1394 if (arm7_9
->pre_debug_entry
)
1395 arm7_9
->pre_debug_entry(target
);
1397 /* program EmbeddedICE Debug Control Register to assert DBGACK and INTDIS
1398 * ensure that DBGRQ is cleared
1400 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 1);
1401 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 0);
1402 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_INTDIS
, 1, 1);
1403 embeddedice_store_reg(dbg_ctrl
);
1405 if ((retval
= arm7_9_clear_halt(target
)) != ERROR_OK
)
1410 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1415 if ((retval
= arm7_9
->examine_debug_reason(target
)) != ERROR_OK
)
1419 if (target
->state
!= TARGET_HALTED
)
1421 LOG_WARNING("target not halted");
1422 return ERROR_TARGET_NOT_HALTED
;
1425 /* if the target is in Thumb state, change to ARM state */
1426 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_ITBIT
, 1))
1428 LOG_DEBUG("target entered debug from Thumb state");
1429 /* Entered debug from Thumb mode */
1430 armv4_5
->core_state
= ARMV4_5_STATE_THUMB
;
1431 arm7_9
->change_to_arm(target
, &r0_thumb
, &pc_thumb
);
1432 LOG_DEBUG("r0_thumb: 0x%8.8" PRIx32
", pc_thumb: 0x%8.8" PRIx32
"", r0_thumb
, pc_thumb
);
1436 LOG_DEBUG("target entered debug from ARM state");
1437 /* Entered debug from ARM mode */
1438 armv4_5
->core_state
= ARMV4_5_STATE_ARM
;
1441 for (i
= 0; i
< 16; i
++)
1442 context_p
[i
] = &context
[i
];
1443 /* save core registers (r0 - r15 of current core mode) */
1444 arm7_9
->read_core_regs(target
, 0xffff, context_p
);
1446 arm7_9
->read_xpsr(target
, &cpsr
, 0);
1448 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1451 /* if the core has been executing in Thumb state, set the T bit */
1452 if (armv4_5
->core_state
== ARMV4_5_STATE_THUMB
)
1455 buf_set_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 32, cpsr
);
1456 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].dirty
= 0;
1457 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].valid
= 1;
1459 armv4_5
->core_mode
= cpsr
& 0x1f;
1461 if (armv4_5_mode_to_number(armv4_5
->core_mode
) == -1)
1463 target
->state
= TARGET_UNKNOWN
;
1464 LOG_ERROR("cpsr contains invalid mode value - communication failure");
1465 return ERROR_TARGET_FAILURE
;
1468 LOG_DEBUG("target entered debug state in %s mode", armv4_5_mode_strings
[armv4_5_mode_to_number(armv4_5
->core_mode
)]);
1470 if (armv4_5
->core_state
== ARMV4_5_STATE_THUMB
)
1472 LOG_DEBUG("thumb state, applying fixups");
1473 context
[0] = r0_thumb
;
1474 context
[15] = pc_thumb
;
1475 } else if (armv4_5
->core_state
== ARMV4_5_STATE_ARM
)
1477 /* adjust value stored by STM */
1478 context
[15] -= 3 * 4;
1481 if ((target
->debug_reason
!= DBG_REASON_DBGRQ
) || (!arm7_9
->use_dbgrq
))
1482 context
[15] -= 3 * ((armv4_5
->core_state
== ARMV4_5_STATE_ARM
) ? 4 : 2);
1484 context
[15] -= arm7_9
->dbgreq_adjust_pc
* ((armv4_5
->core_state
== ARMV4_5_STATE_ARM
) ? 4 : 2);
1486 if (armv4_5_mode_to_number(armv4_5
->core_mode
)==-1)
1489 for (i
= 0; i
<= 15; i
++)
1491 LOG_DEBUG("r%i: 0x%8.8" PRIx32
"", i
, context
[i
]);
1492 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).value
, 0, 32, context
[i
]);
1493 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= 0;
1494 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).valid
= 1;
1497 LOG_DEBUG("entered debug state at PC 0x%" PRIx32
"", context
[15]);
1499 if (armv4_5_mode_to_number(armv4_5
->core_mode
)==-1)
1502 /* exceptions other than USR & SYS have a saved program status register */
1503 if ((armv4_5
->core_mode
!= ARMV4_5_MODE_USR
) && (armv4_5
->core_mode
!= ARMV4_5_MODE_SYS
))
1506 arm7_9
->read_xpsr(target
, &spsr
, 1);
1507 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1511 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).value
, 0, 32, spsr
);
1512 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).dirty
= 0;
1513 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).valid
= 1;
1516 /* r0 and r15 (pc) have to be restored later */
1517 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 0).dirty
= ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 0).valid
;
1518 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 15).dirty
= ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 15).valid
;
1520 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1523 if (arm7_9
->post_debug_entry
)
1524 arm7_9
->post_debug_entry(target
);
1530 * Validate the full context for an ARM7/9 target in all processor modes. If
1531 * there are any invalid registers for the target, they will all be read. This
1534 * @param target Pointer to the ARM7/9 target to capture the full context from
1535 * @return Error if the target is not halted, has an invalid core mode, or if
1536 * the JTAG queue fails to execute
1538 int arm7_9_full_context(target_t
*target
)
1542 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1543 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1547 if (target
->state
!= TARGET_HALTED
)
1549 LOG_WARNING("target not halted");
1550 return ERROR_TARGET_NOT_HALTED
;
1553 if (armv4_5_mode_to_number(armv4_5
->core_mode
)==-1)
1556 /* iterate through processor modes (User, FIQ, IRQ, SVC, ABT, UND)
1557 * SYS shares registers with User, so we don't touch SYS
1559 for (i
= 0; i
< 6; i
++)
1562 uint32_t* reg_p
[16];
1566 /* check if there are invalid registers in the current mode
1568 for (j
= 0; j
<= 16; j
++)
1570 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
== 0)
1578 /* change processor mode (and mask T bit) */
1579 tmp_cpsr
= buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & 0xE0;
1580 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1582 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1584 for (j
= 0; j
< 15; j
++)
1586 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
== 0)
1588 reg_p
[j
] = (uint32_t*)ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).value
;
1590 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
= 1;
1591 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).dirty
= 0;
1595 /* if only the PSR is invalid, mask is all zeroes */
1597 arm7_9
->read_core_regs(target
, mask
, reg_p
);
1599 /* check if the PSR has to be read */
1600 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).valid
== 0)
1602 arm7_9
->read_xpsr(target
, (uint32_t*)ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).value
, 1);
1603 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).valid
= 1;
1604 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).dirty
= 0;
1609 /* restore processor mode (mask T bit) */
1610 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & ~0x20, 0, 0);
1612 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1620 * Restore the processor context on an ARM7/9 target. The full processor
1621 * context is analyzed to see if any of the registers are dirty on this end, but
1622 * have a valid new value. If this is the case, the processor is changed to the
1623 * appropriate mode and the new register values are written out to the
1624 * processor. If there happens to be a dirty register with an invalid value, an
1625 * error will be logged.
1627 * @param target Pointer to the ARM7/9 target to have its context restored
1628 * @return Error status if the target is not halted or the core mode in the
1629 * armv4_5 struct is invalid.
1631 int arm7_9_restore_context(target_t
*target
)
1633 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1634 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1636 armv4_5_core_reg_t
*reg_arch_info
;
1637 enum armv4_5_mode current_mode
= armv4_5
->core_mode
;
1644 if (target
->state
!= TARGET_HALTED
)
1646 LOG_WARNING("target not halted");
1647 return ERROR_TARGET_NOT_HALTED
;
1650 if (arm7_9
->pre_restore_context
)
1651 arm7_9
->pre_restore_context(target
);
1653 if (armv4_5_mode_to_number(armv4_5
->core_mode
)==-1)
1656 /* iterate through processor modes (User, FIQ, IRQ, SVC, ABT, UND)
1657 * SYS shares registers with User, so we don't touch SYS
1659 for (i
= 0; i
< 6; i
++)
1661 LOG_DEBUG("examining %s mode", armv4_5_mode_strings
[i
]);
1664 /* check if there are dirty registers in the current mode
1666 for (j
= 0; j
<= 16; j
++)
1668 reg
= &ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
);
1669 reg_arch_info
= reg
->arch_info
;
1670 if (reg
->dirty
== 1)
1672 if (reg
->valid
== 1)
1675 LOG_DEBUG("examining dirty reg: %s", reg
->name
);
1676 if ((reg_arch_info
->mode
!= ARMV4_5_MODE_ANY
)
1677 && (reg_arch_info
->mode
!= current_mode
)
1678 && !((reg_arch_info
->mode
== ARMV4_5_MODE_USR
) && (armv4_5
->core_mode
== ARMV4_5_MODE_SYS
))
1679 && !((reg_arch_info
->mode
== ARMV4_5_MODE_SYS
) && (armv4_5
->core_mode
== ARMV4_5_MODE_USR
)))
1682 LOG_DEBUG("require mode change");
1687 LOG_ERROR("BUG: dirty register '%s', but no valid data", reg
->name
);
1694 uint32_t mask
= 0x0;
1702 /* change processor mode (mask T bit) */
1703 tmp_cpsr
= buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & 0xE0;
1704 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1706 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1707 current_mode
= armv4_5_number_to_mode(i
);
1710 for (j
= 0; j
<= 14; j
++)
1712 reg
= &ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
);
1713 reg_arch_info
= reg
->arch_info
;
1716 if (reg
->dirty
== 1)
1718 regs
[j
] = buf_get_u32(reg
->value
, 0, 32);
1723 LOG_DEBUG("writing register %i of mode %s with value 0x%8.8" PRIx32
"", j
, armv4_5_mode_strings
[i
], regs
[j
]);
1729 arm7_9
->write_core_regs(target
, mask
, regs
);
1732 reg
= &ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16);
1733 reg_arch_info
= reg
->arch_info
;
1734 if ((reg
->dirty
) && (reg_arch_info
->mode
!= ARMV4_5_MODE_ANY
))
1736 LOG_DEBUG("writing SPSR of mode %i with value 0x%8.8" PRIx32
"", i
, buf_get_u32(reg
->value
, 0, 32));
1737 arm7_9
->write_xpsr(target
, buf_get_u32(reg
->value
, 0, 32), 1);
1742 if ((armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].dirty
== 0) && (armv4_5
->core_mode
!= current_mode
))
1744 /* restore processor mode (mask T bit) */
1747 tmp_cpsr
= buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & 0xE0;
1748 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1750 LOG_DEBUG("writing lower 8 bit of cpsr with value 0x%2.2x", (unsigned)(tmp_cpsr
));
1751 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1753 else if (armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].dirty
== 1)
1755 /* CPSR has been changed, full restore necessary (mask T bit) */
1756 LOG_DEBUG("writing cpsr with value 0x%8.8" PRIx32
"", buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 32));
1757 arm7_9
->write_xpsr(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 32) & ~0x20, 0);
1758 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].dirty
= 0;
1759 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].valid
= 1;
1763 LOG_DEBUG("writing PC with value 0x%8.8" PRIx32
"", buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1764 arm7_9
->write_pc(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1765 armv4_5
->core_cache
->reg_list
[15].dirty
= 0;
1767 if (arm7_9
->post_restore_context
)
1768 arm7_9
->post_restore_context(target
);
1774 * Restart the core of an ARM7/9 target. A RESTART command is sent to the
1775 * instruction register and the JTAG state is set to TAP_IDLE causing a core
1778 * @param target Pointer to the ARM7/9 target to be restarted
1779 * @return Result of executing the JTAG queue
1781 int arm7_9_restart_core(struct target_s
*target
)
1783 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1784 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1785 arm_jtag_t
*jtag_info
= &arm7_9
->jtag_info
;
1787 /* set RESTART instruction */
1788 jtag_set_end_state(TAP_IDLE
);
1789 if (arm7_9
->need_bypass_before_restart
) {
1790 arm7_9
->need_bypass_before_restart
= 0;
1791 arm_jtag_set_instr(jtag_info
, 0xf, NULL
);
1793 arm_jtag_set_instr(jtag_info
, 0x4, NULL
);
1795 jtag_add_runtest(1, jtag_set_end_state(TAP_IDLE
));
1796 return jtag_execute_queue();
1800 * Enable the watchpoints on an ARM7/9 target. The target's watchpoints are
1801 * iterated through and are set on the target if they aren't already set.
1803 * @param target Pointer to the ARM7/9 target to enable watchpoints on
1805 void arm7_9_enable_watchpoints(struct target_s
*target
)
1807 watchpoint_t
*watchpoint
= target
->watchpoints
;
1811 if (watchpoint
->set
== 0)
1812 arm7_9_set_watchpoint(target
, watchpoint
);
1813 watchpoint
= watchpoint
->next
;
1818 * Enable the breakpoints on an ARM7/9 target. The target's breakpoints are
1819 * iterated through and are set on the target.
1821 * @param target Pointer to the ARM7/9 target to enable breakpoints on
1823 void arm7_9_enable_breakpoints(struct target_s
*target
)
1825 breakpoint_t
*breakpoint
= target
->breakpoints
;
1827 /* set any pending breakpoints */
1830 arm7_9_set_breakpoint(target
, breakpoint
);
1831 breakpoint
= breakpoint
->next
;
1835 int arm7_9_resume(struct target_s
*target
, int current
, uint32_t address
, int handle_breakpoints
, int debug_execution
)
1837 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1838 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1839 breakpoint_t
*breakpoint
= target
->breakpoints
;
1840 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1841 int err
, retval
= ERROR_OK
;
1845 if (target
->state
!= TARGET_HALTED
)
1847 LOG_WARNING("target not halted");
1848 return ERROR_TARGET_NOT_HALTED
;
1851 if (!debug_execution
)
1853 target_free_all_working_areas(target
);
1856 /* current = 1: continue on current pc, otherwise continue at <address> */
1858 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, address
);
1860 uint32_t current_pc
;
1861 current_pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
1863 /* the front-end may request us not to handle breakpoints */
1864 if (handle_breakpoints
)
1866 if ((breakpoint
= breakpoint_find(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32))))
1868 LOG_DEBUG("unset breakpoint at 0x%8.8" PRIx32
" (id: %d)", breakpoint
->address
, breakpoint
->unique_id
);
1869 if ((retval
= arm7_9_unset_breakpoint(target
, breakpoint
)) != ERROR_OK
)
1874 /* calculate PC of next instruction */
1876 if ((retval
= arm_simulate_step(target
, &next_pc
)) != ERROR_OK
)
1878 uint32_t current_opcode
;
1879 target_read_u32(target
, current_pc
, ¤t_opcode
);
1880 LOG_ERROR("Couldn't calculate PC of next instruction, current opcode was 0x%8.8" PRIx32
"", current_opcode
);
1884 LOG_DEBUG("enable single-step");
1885 arm7_9
->enable_single_step(target
, next_pc
);
1887 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
1889 if ((retval
= arm7_9_restore_context(target
)) != ERROR_OK
)
1894 if (armv4_5
->core_state
== ARMV4_5_STATE_ARM
)
1895 arm7_9
->branch_resume(target
);
1896 else if (armv4_5
->core_state
== ARMV4_5_STATE_THUMB
)
1898 arm7_9
->branch_resume_thumb(target
);
1902 LOG_ERROR("unhandled core state");
1906 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 0);
1907 embeddedice_write_reg(dbg_ctrl
, buf_get_u32(dbg_ctrl
->value
, 0, dbg_ctrl
->size
));
1908 err
= arm7_9_execute_sys_speed(target
);
1910 LOG_DEBUG("disable single-step");
1911 arm7_9
->disable_single_step(target
);
1913 if (err
!= ERROR_OK
)
1915 if ((retval
= arm7_9_set_breakpoint(target
, breakpoint
)) != ERROR_OK
)
1919 target
->state
= TARGET_UNKNOWN
;
1923 arm7_9_debug_entry(target
);
1924 LOG_DEBUG("new PC after step: 0x%8.8" PRIx32
"", buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1926 LOG_DEBUG("set breakpoint at 0x%8.8" PRIx32
"", breakpoint
->address
);
1927 if ((retval
= arm7_9_set_breakpoint(target
, breakpoint
)) != ERROR_OK
)
1934 /* enable any pending breakpoints and watchpoints */
1935 arm7_9_enable_breakpoints(target
);
1936 arm7_9_enable_watchpoints(target
);
1938 if ((retval
= arm7_9_restore_context(target
)) != ERROR_OK
)
1943 if (armv4_5
->core_state
== ARMV4_5_STATE_ARM
)
1945 arm7_9
->branch_resume(target
);
1947 else if (armv4_5
->core_state
== ARMV4_5_STATE_THUMB
)
1949 arm7_9
->branch_resume_thumb(target
);
1953 LOG_ERROR("unhandled core state");
1957 /* deassert DBGACK and INTDIS */
1958 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 0);
1959 /* INTDIS only when we really resume, not during debug execution */
1960 if (!debug_execution
)
1961 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_INTDIS
, 1, 0);
1962 embeddedice_write_reg(dbg_ctrl
, buf_get_u32(dbg_ctrl
->value
, 0, dbg_ctrl
->size
));
1964 if ((retval
= arm7_9_restart_core(target
)) != ERROR_OK
)
1969 target
->debug_reason
= DBG_REASON_NOTHALTED
;
1971 if (!debug_execution
)
1973 /* registers are now invalid */
1974 armv4_5_invalidate_core_regs(target
);
1975 target
->state
= TARGET_RUNNING
;
1976 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
)) != ERROR_OK
)
1983 target
->state
= TARGET_DEBUG_RUNNING
;
1984 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_RESUMED
)) != ERROR_OK
)
1990 LOG_DEBUG("target resumed");
1995 void arm7_9_enable_eice_step(target_t
*target
, uint32_t next_pc
)
1997 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1998 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
2000 uint32_t current_pc
;
2001 current_pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
2003 if (next_pc
!= current_pc
)
2005 /* setup an inverse breakpoint on the current PC
2006 * - comparator 1 matches the current address
2007 * - rangeout from comparator 1 is connected to comparator 0 rangein
2008 * - comparator 0 matches any address, as long as rangein is low */
2009 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffff);
2010 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffff);
2011 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
2012 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~(EICE_W_CTRL_RANGE
| EICE_W_CTRL_nOPC
) & 0xff);
2013 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], current_pc
);
2014 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], 0);
2015 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0xffffffff);
2016 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
2017 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
2021 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffff);
2022 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffff);
2023 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
2024 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], 0xff);
2025 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], next_pc
);
2026 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], 0);
2027 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0xffffffff);
2028 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
2029 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
2033 void arm7_9_disable_eice_step(target_t
*target
)
2035 armv4_5_common_t
*armv4_5
= target
->arch_info
;
2036 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
2038 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
]);
2039 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
]);
2040 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
]);
2041 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
]);
2042 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
]);
2043 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
]);
2044 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
]);
2045 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
]);
2046 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
]);
2049 int arm7_9_step(struct target_s
*target
, int current
, uint32_t address
, int handle_breakpoints
)
2051 armv4_5_common_t
*armv4_5
= target
->arch_info
;
2052 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
2053 breakpoint_t
*breakpoint
= NULL
;
2056 if (target
->state
!= TARGET_HALTED
)
2058 LOG_WARNING("target not halted");
2059 return ERROR_TARGET_NOT_HALTED
;
2062 /* current = 1: continue on current pc, otherwise continue at <address> */
2064 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, address
);
2066 uint32_t current_pc
;
2067 current_pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
2069 /* the front-end may request us not to handle breakpoints */
2070 if (handle_breakpoints
)
2071 if ((breakpoint
= breakpoint_find(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32))))
2072 if ((retval
= arm7_9_unset_breakpoint(target
, breakpoint
)) != ERROR_OK
)
2077 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
2079 /* calculate PC of next instruction */
2081 if ((retval
= arm_simulate_step(target
, &next_pc
)) != ERROR_OK
)
2083 uint32_t current_opcode
;
2084 target_read_u32(target
, current_pc
, ¤t_opcode
);
2085 LOG_ERROR("Couldn't calculate PC of next instruction, current opcode was 0x%8.8" PRIx32
"", current_opcode
);
2089 if ((retval
= arm7_9_restore_context(target
)) != ERROR_OK
)
2094 arm7_9
->enable_single_step(target
, next_pc
);
2096 if (armv4_5
->core_state
== ARMV4_5_STATE_ARM
)
2098 arm7_9
->branch_resume(target
);
2100 else if (armv4_5
->core_state
== ARMV4_5_STATE_THUMB
)
2102 arm7_9
->branch_resume_thumb(target
);
2106 LOG_ERROR("unhandled core state");
2110 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
)) != ERROR_OK
)
2115 err
= arm7_9_execute_sys_speed(target
);
2116 arm7_9
->disable_single_step(target
);
2118 /* registers are now invalid */
2119 armv4_5_invalidate_core_regs(target
);
2121 if (err
!= ERROR_OK
)
2123 target
->state
= TARGET_UNKNOWN
;
2125 arm7_9_debug_entry(target
);
2126 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_HALTED
)) != ERROR_OK
)
2130 LOG_DEBUG("target stepped");
2134 if ((retval
= arm7_9_set_breakpoint(target
, breakpoint
)) != ERROR_OK
)
2142 int arm7_9_read_core_reg(struct target_s
*target
, int num
, enum armv4_5_mode mode
)
2144 uint32_t* reg_p
[16];
2147 armv4_5_common_t
*armv4_5
= target
->arch_info
;
2148 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
2150 if (armv4_5_mode_to_number(armv4_5
->core_mode
)==-1)
2153 enum armv4_5_mode reg_mode
= ((armv4_5_core_reg_t
*)ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).arch_info
)->mode
;
2155 if ((num
< 0) || (num
> 16))
2156 return ERROR_INVALID_ARGUMENTS
;
2158 if ((mode
!= ARMV4_5_MODE_ANY
)
2159 && (mode
!= armv4_5
->core_mode
)
2160 && (reg_mode
!= ARMV4_5_MODE_ANY
))
2164 /* change processor mode (mask T bit) */
2165 tmp_cpsr
= buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & 0xE0;
2168 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
2171 if ((num
>= 0) && (num
<= 15))
2173 /* read a normal core register */
2174 reg_p
[num
] = &value
;
2176 arm7_9
->read_core_regs(target
, 1 << num
, reg_p
);
2180 /* read a program status register
2181 * if the register mode is MODE_ANY, we read the cpsr, otherwise a spsr
2183 armv4_5_core_reg_t
*arch_info
= ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).arch_info
;
2184 int spsr
= (arch_info
->mode
== ARMV4_5_MODE_ANY
) ? 0 : 1;
2186 arm7_9
->read_xpsr(target
, &value
, spsr
);
2189 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2194 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).valid
= 1;
2195 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).dirty
= 0;
2196 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).value
, 0, 32, value
);
2198 if ((mode
!= ARMV4_5_MODE_ANY
)
2199 && (mode
!= armv4_5
->core_mode
)
2200 && (reg_mode
!= ARMV4_5_MODE_ANY
)) {
2201 /* restore processor mode (mask T bit) */
2202 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & ~0x20, 0, 0);
2208 int arm7_9_write_core_reg(struct target_s
*target
, int num
, enum armv4_5_mode mode
, uint32_t value
)
2211 armv4_5_common_t
*armv4_5
= target
->arch_info
;
2212 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
2214 if (armv4_5_mode_to_number(armv4_5
->core_mode
)==-1)
2217 enum armv4_5_mode reg_mode
= ((armv4_5_core_reg_t
*)ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).arch_info
)->mode
;
2219 if ((num
< 0) || (num
> 16))
2220 return ERROR_INVALID_ARGUMENTS
;
2222 if ((mode
!= ARMV4_5_MODE_ANY
)
2223 && (mode
!= armv4_5
->core_mode
)
2224 && (reg_mode
!= ARMV4_5_MODE_ANY
)) {
2227 /* change processor mode (mask T bit) */
2228 tmp_cpsr
= buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & 0xE0;
2231 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
2234 if ((num
>= 0) && (num
<= 15))
2236 /* write a normal core register */
2239 arm7_9
->write_core_regs(target
, 1 << num
, reg
);
2243 /* write a program status register
2244 * if the register mode is MODE_ANY, we write the cpsr, otherwise a spsr
2246 armv4_5_core_reg_t
*arch_info
= ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).arch_info
;
2247 int spsr
= (arch_info
->mode
== ARMV4_5_MODE_ANY
) ? 0 : 1;
2249 /* if we're writing the CPSR, mask the T bit */
2253 arm7_9
->write_xpsr(target
, value
, spsr
);
2256 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).valid
= 1;
2257 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).dirty
= 0;
2259 if ((mode
!= ARMV4_5_MODE_ANY
)
2260 && (mode
!= armv4_5
->core_mode
)
2261 && (reg_mode
!= ARMV4_5_MODE_ANY
)) {
2262 /* restore processor mode (mask T bit) */
2263 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & ~0x20, 0, 0);
2266 return jtag_execute_queue();
2269 int arm7_9_read_memory(struct target_s
*target
, uint32_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
)
2271 armv4_5_common_t
*armv4_5
= target
->arch_info
;
2272 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
2275 uint32_t num_accesses
= 0;
2276 int thisrun_accesses
;
2282 LOG_DEBUG("address: 0x%8.8" PRIx32
", size: 0x%8.8" PRIx32
", count: 0x%8.8" PRIx32
"", address
, size
, count
);
2284 if (target
->state
!= TARGET_HALTED
)
2286 LOG_WARNING("target not halted");
2287 return ERROR_TARGET_NOT_HALTED
;
2290 /* sanitize arguments */
2291 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
2292 return ERROR_INVALID_ARGUMENTS
;
2294 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
2295 return ERROR_TARGET_UNALIGNED_ACCESS
;
2297 /* load the base register with the address of the first word */
2299 arm7_9
->write_core_regs(target
, 0x1, reg
);
2306 while (num_accesses
< count
)
2309 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2310 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2312 if (last_reg
<= thisrun_accesses
)
2313 last_reg
= thisrun_accesses
;
2315 arm7_9
->load_word_regs(target
, reg_list
);
2317 /* fast memory reads are only safe when the target is running
2318 * from a sufficiently high clock (32 kHz is usually too slow)
2320 if (arm7_9
->fast_memory_access
)
2321 retval
= arm7_9_execute_fast_sys_speed(target
);
2323 retval
= arm7_9_execute_sys_speed(target
);
2324 if (retval
!= ERROR_OK
)
2327 arm7_9
->read_core_regs_target_buffer(target
, reg_list
, buffer
, 4);
2329 /* advance buffer, count number of accesses */
2330 buffer
+= thisrun_accesses
* 4;
2331 num_accesses
+= thisrun_accesses
;
2333 if ((j
++%1024) == 0)
2340 while (num_accesses
< count
)
2343 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2344 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2346 for (i
= 1; i
<= thisrun_accesses
; i
++)
2350 arm7_9
->load_hword_reg(target
, i
);
2351 /* fast memory reads are only safe when the target is running
2352 * from a sufficiently high clock (32 kHz is usually too slow)
2354 if (arm7_9
->fast_memory_access
)
2355 retval
= arm7_9_execute_fast_sys_speed(target
);
2357 retval
= arm7_9_execute_sys_speed(target
);
2358 if (retval
!= ERROR_OK
)
2365 arm7_9
->read_core_regs_target_buffer(target
, reg_list
, buffer
, 2);
2367 /* advance buffer, count number of accesses */
2368 buffer
+= thisrun_accesses
* 2;
2369 num_accesses
+= thisrun_accesses
;
2371 if ((j
++%1024) == 0)
2378 while (num_accesses
< count
)
2381 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2382 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2384 for (i
= 1; i
<= thisrun_accesses
; i
++)
2388 arm7_9
->load_byte_reg(target
, i
);
2389 /* fast memory reads are only safe when the target is running
2390 * from a sufficiently high clock (32 kHz is usually too slow)
2392 if (arm7_9
->fast_memory_access
)
2393 retval
= arm7_9_execute_fast_sys_speed(target
);
2395 retval
= arm7_9_execute_sys_speed(target
);
2396 if (retval
!= ERROR_OK
)
2402 arm7_9
->read_core_regs_target_buffer(target
, reg_list
, buffer
, 1);
2404 /* advance buffer, count number of accesses */
2405 buffer
+= thisrun_accesses
* 1;
2406 num_accesses
+= thisrun_accesses
;
2408 if ((j
++%1024) == 0)
2415 LOG_ERROR("BUG: we shouldn't get here");
2420 if (armv4_5_mode_to_number(armv4_5
->core_mode
)==-1)
2423 for (i
= 0; i
<= last_reg
; i
++)
2424 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).valid
;
2426 arm7_9
->read_xpsr(target
, &cpsr
, 0);
2427 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2429 LOG_ERROR("JTAG error while reading cpsr");
2430 return ERROR_TARGET_DATA_ABORT
;
2433 if (((cpsr
& 0x1f) == ARMV4_5_MODE_ABT
) && (armv4_5
->core_mode
!= ARMV4_5_MODE_ABT
))
2435 LOG_WARNING("memory read caused data abort (address: 0x%8.8" PRIx32
", size: 0x%" PRIx32
", count: 0x%" PRIx32
")", address
, size
, count
);
2437 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & ~0x20, 0, 0);
2439 return ERROR_TARGET_DATA_ABORT
;
2445 int arm7_9_write_memory(struct target_s
*target
, uint32_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
)
2447 armv4_5_common_t
*armv4_5
= target
->arch_info
;
2448 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
2449 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
2452 uint32_t num_accesses
= 0;
2453 int thisrun_accesses
;
2459 #ifdef _DEBUG_ARM7_9_
2460 LOG_DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address
, size
, count
);
2463 if (target
->state
!= TARGET_HALTED
)
2465 LOG_WARNING("target not halted");
2466 return ERROR_TARGET_NOT_HALTED
;
2469 /* sanitize arguments */
2470 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
2471 return ERROR_INVALID_ARGUMENTS
;
2473 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
2474 return ERROR_TARGET_UNALIGNED_ACCESS
;
2476 /* load the base register with the address of the first word */
2478 arm7_9
->write_core_regs(target
, 0x1, reg
);
2480 /* Clear DBGACK, to make sure memory fetches work as expected */
2481 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 0);
2482 embeddedice_store_reg(dbg_ctrl
);
2487 while (num_accesses
< count
)
2490 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2491 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2493 for (i
= 1; i
<= thisrun_accesses
; i
++)
2497 reg
[i
] = target_buffer_get_u32(target
, buffer
);
2501 arm7_9
->write_core_regs(target
, reg_list
, reg
);
2503 arm7_9
->store_word_regs(target
, reg_list
);
2505 /* fast memory writes are only safe when the target is running
2506 * from a sufficiently high clock (32 kHz is usually too slow)
2508 if (arm7_9
->fast_memory_access
)
2509 retval
= arm7_9_execute_fast_sys_speed(target
);
2511 retval
= arm7_9_execute_sys_speed(target
);
2512 if (retval
!= ERROR_OK
)
2517 num_accesses
+= thisrun_accesses
;
2521 while (num_accesses
< count
)
2524 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2525 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2527 for (i
= 1; i
<= thisrun_accesses
; i
++)
2531 reg
[i
] = target_buffer_get_u16(target
, buffer
) & 0xffff;
2535 arm7_9
->write_core_regs(target
, reg_list
, reg
);
2537 for (i
= 1; i
<= thisrun_accesses
; i
++)
2539 arm7_9
->store_hword_reg(target
, i
);
2541 /* fast memory writes are only safe when the target is running
2542 * from a sufficiently high clock (32 kHz is usually too slow)
2544 if (arm7_9
->fast_memory_access
)
2545 retval
= arm7_9_execute_fast_sys_speed(target
);
2547 retval
= arm7_9_execute_sys_speed(target
);
2548 if (retval
!= ERROR_OK
)
2554 num_accesses
+= thisrun_accesses
;
2558 while (num_accesses
< count
)
2561 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2562 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2564 for (i
= 1; i
<= thisrun_accesses
; i
++)
2568 reg
[i
] = *buffer
++ & 0xff;
2571 arm7_9
->write_core_regs(target
, reg_list
, reg
);
2573 for (i
= 1; i
<= thisrun_accesses
; i
++)
2575 arm7_9
->store_byte_reg(target
, i
);
2576 /* fast memory writes are only safe when the target is running
2577 * from a sufficiently high clock (32 kHz is usually too slow)
2579 if (arm7_9
->fast_memory_access
)
2580 retval
= arm7_9_execute_fast_sys_speed(target
);
2582 retval
= arm7_9_execute_sys_speed(target
);
2583 if (retval
!= ERROR_OK
)
2590 num_accesses
+= thisrun_accesses
;
2594 LOG_ERROR("BUG: we shouldn't get here");
2600 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 1);
2601 embeddedice_store_reg(dbg_ctrl
);
2603 if (armv4_5_mode_to_number(armv4_5
->core_mode
)==-1)
2606 for (i
= 0; i
<= last_reg
; i
++)
2607 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).valid
;
2609 arm7_9
->read_xpsr(target
, &cpsr
, 0);
2610 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2612 LOG_ERROR("JTAG error while reading cpsr");
2613 return ERROR_TARGET_DATA_ABORT
;
2616 if (((cpsr
& 0x1f) == ARMV4_5_MODE_ABT
) && (armv4_5
->core_mode
!= ARMV4_5_MODE_ABT
))
2618 LOG_WARNING("memory write caused data abort (address: 0x%8.8" PRIx32
", size: 0x%" PRIx32
", count: 0x%" PRIx32
")", address
, size
, count
);
2620 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & ~0x20, 0, 0);
2622 return ERROR_TARGET_DATA_ABORT
;
2628 static int dcc_count
;
2629 static uint8_t *dcc_buffer
;
2631 static int arm7_9_dcc_completion(struct target_s
*target
, uint32_t exit_point
, int timeout_ms
, void *arch_info
)
2633 int retval
= ERROR_OK
;
2634 armv4_5_common_t
*armv4_5
= target
->arch_info
;
2635 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
2637 if ((retval
= target_wait_state(target
, TARGET_DEBUG_RUNNING
, 500)) != ERROR_OK
)
2640 int little
= target
->endianness
== TARGET_LITTLE_ENDIAN
;
2641 int count
= dcc_count
;
2642 uint8_t *buffer
= dcc_buffer
;
2645 /* Handle first & last using standard embeddedice_write_reg and the middle ones w/the
2646 * core function repeated. */
2647 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_COMMS_DATA
], fast_target_buffer_get_u32(buffer
, little
));
2650 embeddedice_reg_t
*ice_reg
= arm7_9
->eice_cache
->reg_list
[EICE_COMMS_DATA
].arch_info
;
2651 uint8_t reg_addr
= ice_reg
->addr
& 0x1f;
2653 tap
= ice_reg
->jtag_info
->tap
;
2655 embeddedice_write_dcc(tap
, reg_addr
, buffer
, little
, count
-2);
2656 buffer
+= (count
-2)*4;
2658 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_COMMS_DATA
], fast_target_buffer_get_u32(buffer
, little
));
2662 for (i
= 0; i
< count
; i
++)
2664 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_COMMS_DATA
], fast_target_buffer_get_u32(buffer
, little
));
2669 if ((retval
= target_halt(target
))!= ERROR_OK
)
2673 return target_wait_state(target
, TARGET_HALTED
, 500);
2676 static const uint32_t dcc_code
[] =
2678 /* r0 == input, points to memory buffer
2682 /* spin until DCC control (c0) reports data arrived */
2683 0xee101e10, /* w: mrc p14, #0, r1, c0, c0 */
2684 0xe3110001, /* tst r1, #1 */
2685 0x0afffffc, /* bne w */
2687 /* read word from DCC (c1), write to memory */
2688 0xee111e10, /* mrc p14, #0, r1, c1, c0 */
2689 0xe4801004, /* str r1, [r0], #4 */
2692 0xeafffff9 /* b w */
2695 int armv4_5_run_algorithm_inner(struct target_s
*target
, int num_mem_params
, mem_param_t
*mem_params
, int num_reg_params
, reg_param_t
*reg_params
, uint32_t entry_point
, uint32_t exit_point
, int timeout_ms
, void *arch_info
, int (*run_it
)(struct target_s
*target
, uint32_t exit_point
, int timeout_ms
, void *arch_info
));
2697 int arm7_9_bulk_write_memory(target_t
*target
, uint32_t address
, uint32_t count
, uint8_t *buffer
)
2700 armv4_5_common_t
*armv4_5
= target
->arch_info
;
2701 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
2704 if (!arm7_9
->dcc_downloads
)
2705 return target_write_memory(target
, address
, 4, count
, buffer
);
2707 /* regrab previously allocated working_area, or allocate a new one */
2708 if (!arm7_9
->dcc_working_area
)
2710 uint8_t dcc_code_buf
[6 * 4];
2712 /* make sure we have a working area */
2713 if (target_alloc_working_area(target
, 24, &arm7_9
->dcc_working_area
) != ERROR_OK
)
2715 LOG_INFO("no working area available, falling back to memory writes");
2716 return target_write_memory(target
, address
, 4, count
, buffer
);
2719 /* copy target instructions to target endianness */
2720 for (i
= 0; i
< 6; i
++)
2722 target_buffer_set_u32(target
, dcc_code_buf
+ i
*4, dcc_code
[i
]);
2725 /* write DCC code to working area */
2726 if ((retval
= target_write_memory(target
, arm7_9
->dcc_working_area
->address
, 4, 6, dcc_code_buf
)) != ERROR_OK
)
2732 armv4_5_algorithm_t armv4_5_info
;
2733 reg_param_t reg_params
[1];
2735 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
2736 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
2737 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
2739 init_reg_param(®_params
[0], "r0", 32, PARAM_IN_OUT
);
2741 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
2744 dcc_buffer
= buffer
;
2745 retval
= armv4_5_run_algorithm_inner(target
, 0, NULL
, 1, reg_params
,
2746 arm7_9
->dcc_working_area
->address
, arm7_9
->dcc_working_area
->address
+ 6*4, 20*1000, &armv4_5_info
, arm7_9_dcc_completion
);
2748 if (retval
== ERROR_OK
)
2750 uint32_t endaddress
= buf_get_u32(reg_params
[0].value
, 0, 32);
2751 if (endaddress
!= (address
+ count
*4))
2753 LOG_ERROR("DCC write failed, expected end address 0x%08" PRIx32
" got 0x%0" PRIx32
"", (address
+ count
*4), endaddress
);
2754 retval
= ERROR_FAIL
;
2758 destroy_reg_param(®_params
[0]);
2763 int arm7_9_checksum_memory(struct target_s
*target
, uint32_t address
, uint32_t count
, uint32_t* checksum
)
2765 working_area_t
*crc_algorithm
;
2766 armv4_5_algorithm_t armv4_5_info
;
2767 reg_param_t reg_params
[2];
2770 static const uint32_t arm7_9_crc_code
[] = {
2771 0xE1A02000, /* mov r2, r0 */
2772 0xE3E00000, /* mov r0, #0xffffffff */
2773 0xE1A03001, /* mov r3, r1 */
2774 0xE3A04000, /* mov r4, #0 */
2775 0xEA00000B, /* b ncomp */
2777 0xE7D21004, /* ldrb r1, [r2, r4] */
2778 0xE59F7030, /* ldr r7, CRC32XOR */
2779 0xE0200C01, /* eor r0, r0, r1, asl 24 */
2780 0xE3A05000, /* mov r5, #0 */
2782 0xE3500000, /* cmp r0, #0 */
2783 0xE1A06080, /* mov r6, r0, asl #1 */
2784 0xE2855001, /* add r5, r5, #1 */
2785 0xE1A00006, /* mov r0, r6 */
2786 0xB0260007, /* eorlt r0, r6, r7 */
2787 0xE3550008, /* cmp r5, #8 */
2788 0x1AFFFFF8, /* bne loop */
2789 0xE2844001, /* add r4, r4, #1 */
2791 0xE1540003, /* cmp r4, r3 */
2792 0x1AFFFFF1, /* bne nbyte */
2794 0xEAFFFFFE, /* b end */
2795 0x04C11DB7 /* CRC32XOR: .word 0x04C11DB7 */
2800 if (target_alloc_working_area(target
, sizeof(arm7_9_crc_code
), &crc_algorithm
) != ERROR_OK
)
2802 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
2805 /* convert flash writing code into a buffer in target endianness */
2806 for (i
= 0; i
< (sizeof(arm7_9_crc_code
)/sizeof(uint32_t)); i
++)
2808 if ((retval
= target_write_u32(target
, crc_algorithm
->address
+ i
*sizeof(uint32_t), arm7_9_crc_code
[i
])) != ERROR_OK
)
2814 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
2815 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
2816 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
2818 init_reg_param(®_params
[0], "r0", 32, PARAM_IN_OUT
);
2819 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
2821 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
2822 buf_set_u32(reg_params
[1].value
, 0, 32, count
);
2824 if ((retval
= target_run_algorithm(target
, 0, NULL
, 2, reg_params
,
2825 crc_algorithm
->address
, crc_algorithm
->address
+ (sizeof(arm7_9_crc_code
) - 8), 20000, &armv4_5_info
)) != ERROR_OK
)
2827 LOG_ERROR("error executing arm7_9 crc algorithm");
2828 destroy_reg_param(®_params
[0]);
2829 destroy_reg_param(®_params
[1]);
2830 target_free_working_area(target
, crc_algorithm
);
2834 *checksum
= buf_get_u32(reg_params
[0].value
, 0, 32);
2836 destroy_reg_param(®_params
[0]);
2837 destroy_reg_param(®_params
[1]);
2839 target_free_working_area(target
, crc_algorithm
);
2844 int arm7_9_blank_check_memory(struct target_s
*target
, uint32_t address
, uint32_t count
, uint32_t* blank
)
2846 working_area_t
*erase_check_algorithm
;
2847 reg_param_t reg_params
[3];
2848 armv4_5_algorithm_t armv4_5_info
;
2852 static const uint32_t erase_check_code
[] =
2855 0xe4d03001, /* ldrb r3, [r0], #1 */
2856 0xe0022003, /* and r2, r2, r3 */
2857 0xe2511001, /* subs r1, r1, #1 */
2858 0x1afffffb, /* bne loop */
2860 0xeafffffe /* b end */
2863 /* make sure we have a working area */
2864 if (target_alloc_working_area(target
, sizeof(erase_check_code
), &erase_check_algorithm
) != ERROR_OK
)
2866 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
2869 /* convert flash writing code into a buffer in target endianness */
2870 for (i
= 0; i
< (sizeof(erase_check_code
)/sizeof(uint32_t)); i
++)
2871 if ((retval
= target_write_u32(target
, erase_check_algorithm
->address
+ i
*sizeof(uint32_t), erase_check_code
[i
])) != ERROR_OK
)
2876 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
2877 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
2878 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
2880 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
2881 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
2883 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
2884 buf_set_u32(reg_params
[1].value
, 0, 32, count
);
2886 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
2887 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
2889 if ((retval
= target_run_algorithm(target
, 0, NULL
, 3, reg_params
,
2890 erase_check_algorithm
->address
, erase_check_algorithm
->address
+ (sizeof(erase_check_code
) - 4), 10000, &armv4_5_info
)) != ERROR_OK
)
2892 destroy_reg_param(®_params
[0]);
2893 destroy_reg_param(®_params
[1]);
2894 destroy_reg_param(®_params
[2]);
2895 target_free_working_area(target
, erase_check_algorithm
);
2899 *blank
= buf_get_u32(reg_params
[2].value
, 0, 32);
2901 destroy_reg_param(®_params
[0]);
2902 destroy_reg_param(®_params
[1]);
2903 destroy_reg_param(®_params
[2]);
2905 target_free_working_area(target
, erase_check_algorithm
);
2910 int arm7_9_register_commands(struct command_context_s
*cmd_ctx
)
2912 command_t
*arm7_9_cmd
;
2914 arm7_9_cmd
= register_command(cmd_ctx
, NULL
, "arm7_9", NULL
, COMMAND_ANY
, "arm7/9 specific commands");
2916 register_command(cmd_ctx
, arm7_9_cmd
, "write_xpsr", handle_arm7_9_write_xpsr_command
, COMMAND_EXEC
, "write program status register <value> <not cpsr | spsr>");
2917 register_command(cmd_ctx
, arm7_9_cmd
, "write_xpsr_im8", handle_arm7_9_write_xpsr_im8_command
, COMMAND_EXEC
, "write program status register <8bit immediate> <rotate> <not cpsr | spsr>");
2919 register_command(cmd_ctx
, arm7_9_cmd
, "write_core_reg", handle_arm7_9_write_core_reg_command
, COMMAND_EXEC
, "write core register <num> <mode> <value>");
2921 register_command(cmd_ctx
, arm7_9_cmd
, "dbgrq", handle_arm7_9_dbgrq_command
,
2922 COMMAND_ANY
, "use EmbeddedICE dbgrq instead of breakpoint for target halt requests <enable | disable>");
2923 register_command(cmd_ctx
, arm7_9_cmd
, "fast_memory_access", handle_arm7_9_fast_memory_access_command
,
2924 COMMAND_ANY
, "use fast memory accesses instead of slower but potentially safer accesses <enable | disable>");
2925 register_command(cmd_ctx
, arm7_9_cmd
, "dcc_downloads", handle_arm7_9_dcc_downloads_command
,
2926 COMMAND_ANY
, "use DCC downloads for larger memory writes <enable | disable>");
2928 armv4_5_register_commands(cmd_ctx
);
2930 etm_register_commands(cmd_ctx
);
2935 int handle_arm7_9_write_xpsr_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2940 target_t
*target
= get_current_target(cmd_ctx
);
2941 armv4_5_common_t
*armv4_5
;
2942 arm7_9_common_t
*arm7_9
;
2944 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2946 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2950 if (target
->state
!= TARGET_HALTED
)
2952 command_print(cmd_ctx
, "can't write registers while running");
2958 command_print(cmd_ctx
, "usage: write_xpsr <value> <not cpsr | spsr>");
2962 value
= strtoul(args
[0], NULL
, 0);
2963 spsr
= strtol(args
[1], NULL
, 0);
2965 /* if we're writing the CPSR, mask the T bit */
2969 arm7_9
->write_xpsr(target
, value
, spsr
);
2970 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2972 LOG_ERROR("JTAG error while writing to xpsr");
2979 int handle_arm7_9_write_xpsr_im8_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2985 target_t
*target
= get_current_target(cmd_ctx
);
2986 armv4_5_common_t
*armv4_5
;
2987 arm7_9_common_t
*arm7_9
;
2989 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2991 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2995 if (target
->state
!= TARGET_HALTED
)
2997 command_print(cmd_ctx
, "can't write registers while running");
3003 command_print(cmd_ctx
, "usage: write_xpsr_im8 <im8> <rotate> <not cpsr | spsr>");
3007 value
= strtoul(args
[0], NULL
, 0);
3008 rotate
= strtol(args
[1], NULL
, 0);
3009 spsr
= strtol(args
[2], NULL
, 0);
3011 arm7_9
->write_xpsr_im8(target
, value
, rotate
, spsr
);
3012 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
3014 LOG_ERROR("JTAG error while writing 8-bit immediate to xpsr");
3021 int handle_arm7_9_write_core_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3026 target_t
*target
= get_current_target(cmd_ctx
);
3027 armv4_5_common_t
*armv4_5
;
3028 arm7_9_common_t
*arm7_9
;
3030 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
3032 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
3036 if (target
->state
!= TARGET_HALTED
)
3038 command_print(cmd_ctx
, "can't write registers while running");
3044 command_print(cmd_ctx
, "usage: write_core_reg <num> <mode> <value>");
3048 num
= strtol(args
[0], NULL
, 0);
3049 mode
= strtoul(args
[1], NULL
, 0);
3050 value
= strtoul(args
[2], NULL
, 0);
3052 return arm7_9_write_core_reg(target
, num
, mode
, value
);
3055 int handle_arm7_9_dbgrq_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3057 target_t
*target
= get_current_target(cmd_ctx
);
3058 armv4_5_common_t
*armv4_5
;
3059 arm7_9_common_t
*arm7_9
;
3061 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
3063 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
3069 if (strcmp("enable", args
[0]) == 0)
3071 arm7_9
->use_dbgrq
= 1;
3073 else if (strcmp("disable", args
[0]) == 0)
3075 arm7_9
->use_dbgrq
= 0;
3079 command_print(cmd_ctx
, "usage: arm7_9 dbgrq <enable | disable>");
3083 command_print(cmd_ctx
, "use of EmbeddedICE dbgrq instead of breakpoint for target halt %s", (arm7_9
->use_dbgrq
) ? "enabled" : "disabled");
3088 int handle_arm7_9_fast_memory_access_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3090 target_t
*target
= get_current_target(cmd_ctx
);
3091 armv4_5_common_t
*armv4_5
;
3092 arm7_9_common_t
*arm7_9
;
3094 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
3096 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
3102 if (strcmp("enable", args
[0]) == 0)
3104 arm7_9
->fast_memory_access
= 1;
3106 else if (strcmp("disable", args
[0]) == 0)
3108 arm7_9
->fast_memory_access
= 0;
3112 command_print(cmd_ctx
, "usage: arm7_9 fast_memory_access <enable | disable>");
3116 command_print(cmd_ctx
, "fast memory access is %s", (arm7_9
->fast_memory_access
) ? "enabled" : "disabled");
3121 int handle_arm7_9_dcc_downloads_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3123 target_t
*target
= get_current_target(cmd_ctx
);
3124 armv4_5_common_t
*armv4_5
;
3125 arm7_9_common_t
*arm7_9
;
3127 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
3129 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
3135 if (strcmp("enable", args
[0]) == 0)
3137 arm7_9
->dcc_downloads
= 1;
3139 else if (strcmp("disable", args
[0]) == 0)
3141 arm7_9
->dcc_downloads
= 0;
3145 command_print(cmd_ctx
, "usage: arm7_9 dcc_downloads <enable | disable>");
3149 command_print(cmd_ctx
, "dcc downloads are %s", (arm7_9
->dcc_downloads
) ? "enabled" : "disabled");
3154 int arm7_9_init_arch_info(target_t
*target
, arm7_9_common_t
*arm7_9
)
3156 int retval
= ERROR_OK
;
3157 armv4_5_common_t
*armv4_5
= &arm7_9
->armv4_5_common
;
3159 arm7_9
->common_magic
= ARM7_9_COMMON_MAGIC
;
3161 if ((retval
= arm_jtag_setup_connection(&arm7_9
->jtag_info
)) != ERROR_OK
)
3166 arm7_9
->wp_available
= 0; /* this is set up in arm7_9_clear_watchpoints() */
3167 arm7_9
->wp_available_max
= 2;
3168 arm7_9
->sw_breakpoints_added
= 0;
3169 arm7_9
->sw_breakpoint_count
= 0;
3170 arm7_9
->breakpoint_count
= 0;
3171 arm7_9
->wp0_used
= 0;
3172 arm7_9
->wp1_used
= 0;
3173 arm7_9
->wp1_used_default
= 0;
3174 arm7_9
->use_dbgrq
= 0;
3176 arm7_9
->etm_ctx
= NULL
;
3177 arm7_9
->has_single_step
= 0;
3178 arm7_9
->has_monitor_mode
= 0;
3179 arm7_9
->has_vector_catch
= 0;
3181 arm7_9
->debug_entry_from_reset
= 0;
3183 arm7_9
->dcc_working_area
= NULL
;
3185 arm7_9
->fast_memory_access
= fast_and_dangerous
;
3186 arm7_9
->dcc_downloads
= fast_and_dangerous
;
3188 arm7_9
->need_bypass_before_restart
= 0;
3190 armv4_5
->arch_info
= arm7_9
;
3191 armv4_5
->read_core_reg
= arm7_9_read_core_reg
;
3192 armv4_5
->write_core_reg
= arm7_9_write_core_reg
;
3193 armv4_5
->full_context
= arm7_9_full_context
;
3195 if ((retval
= armv4_5_init_arch_info(target
, armv4_5
)) != ERROR_OK
)
3200 if ((retval
= target_register_timer_callback(arm7_9_handle_target_request
, 1, 1, target
)) != ERROR_OK
)
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)