1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
22 #include "embeddedice.h"
28 #include "arm7_9_common.h"
29 #include "breakpoints.h"
35 #include <sys/types.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_sw_bkpts_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 int handle_arm7_9_force_hw_bkpts_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_arm7_9_dbgrq_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_arm7_9_fast_writes_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_arm7_9_dcc_downloads_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int arm7_9_reinit_embeddedice(target_t
*target
)
56 armv4_5_common_t
*armv4_5
= target
->arch_info
;
57 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
59 breakpoint_t
*breakpoint
= target
->breakpoints
;
61 arm7_9
->wp_available
= 2;
65 /* mark all hardware breakpoints as unset */
68 if (breakpoint
->type
== BKPT_HARD
)
72 breakpoint
= breakpoint
->next
;
75 if (arm7_9
->sw_bkpts_enabled
&& arm7_9
->sw_bkpts_use_wp
)
77 arm7_9
->sw_bkpts_enabled
= 0;
78 arm7_9_enable_sw_bkpts(target
);
81 arm7_9
->reinit_embeddedice
= 0;
86 int arm7_9_jtag_callback(enum jtag_event event
, void *priv
)
88 target_t
*target
= priv
;
89 armv4_5_common_t
*armv4_5
= target
->arch_info
;
90 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
92 /* a test-logic reset occured
93 * the EmbeddedICE registers have been reset
94 * hardware breakpoints have been cleared
96 if (event
== JTAG_TRST_ASSERTED
)
98 arm7_9
->reinit_embeddedice
= 1;
104 int arm7_9_get_arch_pointers(target_t
*target
, armv4_5_common_t
**armv4_5_p
, arm7_9_common_t
**arm7_9_p
)
106 armv4_5_common_t
*armv4_5
= target
->arch_info
;
107 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
109 if (armv4_5
->common_magic
!= ARMV4_5_COMMON_MAGIC
)
114 if (arm7_9
->common_magic
!= ARM7_9_COMMON_MAGIC
)
119 *armv4_5_p
= armv4_5
;
125 int arm7_9_set_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
127 armv4_5_common_t
*armv4_5
= target
->arch_info
;
128 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
130 if (target
->state
!= TARGET_HALTED
)
132 WARNING("target not halted");
133 return ERROR_TARGET_NOT_HALTED
;
136 if (arm7_9
->force_hw_bkpts
)
137 breakpoint
->type
= BKPT_HARD
;
141 WARNING("breakpoint already set");
145 if (breakpoint
->type
== BKPT_HARD
)
147 /* either an ARM (4 byte) or Thumb (2 byte) breakpoint */
148 u32 mask
= (breakpoint
->length
== 4) ? 0x3u
: 0x1u
;
149 if (!arm7_9
->wp0_used
)
151 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_VALUE
], breakpoint
->address
);
152 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], mask
);
153 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffffu
);
154 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
155 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
157 jtag_execute_queue();
158 arm7_9
->wp0_used
= 1;
161 else if (!arm7_9
->wp1_used
)
163 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], breakpoint
->address
);
164 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], mask
);
165 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0xffffffffu
);
166 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
167 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
169 jtag_execute_queue();
170 arm7_9
->wp1_used
= 1;
175 ERROR("BUG: no hardware comparator available");
179 else if (breakpoint
->type
== BKPT_SOFT
)
181 if (breakpoint
->length
== 4)
183 target
->type
->read_memory(target
, breakpoint
->address
, 4, 1, breakpoint
->orig_instr
);
184 target
->type
->write_memory(target
, breakpoint
->address
, 4, 1, (u8
*)(&arm7_9
->arm_bkpt
));
188 target
->type
->read_memory(target
, breakpoint
->address
, 2, 1, breakpoint
->orig_instr
);
189 target
->type
->read_memory(target
, breakpoint
->address
, 2, 1, (u8
*)(&arm7_9
->arm_bkpt
));
198 int arm7_9_unset_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
200 armv4_5_common_t
*armv4_5
= target
->arch_info
;
201 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
203 if (target
->state
!= TARGET_HALTED
)
205 WARNING("target not halted");
206 return ERROR_TARGET_NOT_HALTED
;
209 if (!breakpoint
->set
)
211 WARNING("breakpoint not set");
215 if (breakpoint
->type
== BKPT_HARD
)
217 if (breakpoint
->set
== 1)
219 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
220 jtag_execute_queue();
221 arm7_9
->wp0_used
= 0;
223 else if (breakpoint
->set
== 2)
225 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
226 jtag_execute_queue();
227 arm7_9
->wp1_used
= 0;
233 if (breakpoint
->length
== 4)
235 target
->type
->write_memory(target
, breakpoint
->address
, 4, 1, breakpoint
->orig_instr
);
239 target
->type
->write_memory(target
, breakpoint
->address
, 2, 1, breakpoint
->orig_instr
);
247 int arm7_9_add_breakpoint(struct target_s
*target
, u32 address
, u32 length
, enum breakpoint_type type
)
249 armv4_5_common_t
*armv4_5
= target
->arch_info
;
250 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
252 if (target
->state
!= TARGET_HALTED
)
254 WARNING("target not halted");
255 return ERROR_TARGET_NOT_HALTED
;
258 if (arm7_9
->force_hw_bkpts
)
263 if ((type
== BKPT_SOFT
) && (arm7_9
->sw_bkpts_enabled
== 0))
265 INFO("sw breakpoint requested, but software breakpoints not enabled");
266 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
269 if ((type
== BKPT_HARD
) && (arm7_9
->wp_available
< 1))
271 INFO("no watchpoint unit available for hardware breakpoint");
272 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
275 if (type
== BKPT_HARD
)
276 arm7_9
->wp_available
--;
278 if ((length
!= 2) && (length
!= 4))
280 INFO("only breakpoints of two (Thumb) or four (ARM) bytes length supported");
281 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
287 int arm7_9_remove_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
289 armv4_5_common_t
*armv4_5
= target
->arch_info
;
290 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
292 if (target
->state
!= TARGET_HALTED
)
294 WARNING("target not halted");
295 return ERROR_TARGET_NOT_HALTED
;
300 arm7_9_unset_breakpoint(target
, breakpoint
);
303 arm7_9
->wp_available
++;
308 int arm7_9_set_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
310 armv4_5_common_t
*armv4_5
= target
->arch_info
;
311 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
315 mask
= watchpoint
->length
- 1;
317 if (target
->state
!= TARGET_HALTED
)
319 WARNING("target not halted");
320 return ERROR_TARGET_NOT_HALTED
;
323 if (watchpoint
->rw
== WPT_ACCESS
)
328 if (!arm7_9
->wp0_used
)
330 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_VALUE
], watchpoint
->address
);
331 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], mask
);
332 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], watchpoint
->mask
);
333 if( watchpoint
->mask
!= 0xffffffffu
)
334 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_VALUE
], watchpoint
->value
);
335 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], 0xff & ~EICE_W_CTRL_nOPC
& ~rw_mask
);
336 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
| EICE_W_CTRL_nOPC
| (watchpoint
->rw
& 1));
338 jtag_execute_queue();
340 arm7_9
->wp0_used
= 2;
342 else if (!arm7_9
->wp1_used
)
344 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], watchpoint
->address
);
345 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], mask
);
346 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], watchpoint
->mask
);
347 if( watchpoint
->mask
!= 0xffffffffu
)
348 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_VALUE
], watchpoint
->value
);
349 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], 0xff & ~EICE_W_CTRL_nOPC
& ~rw_mask
);
350 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
| EICE_W_CTRL_nOPC
| (watchpoint
->rw
& 1));
352 jtag_execute_queue();
354 arm7_9
->wp1_used
= 2;
358 ERROR("BUG: no hardware comparator available");
365 int arm7_9_unset_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
367 armv4_5_common_t
*armv4_5
= target
->arch_info
;
368 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
370 if (target
->state
!= TARGET_HALTED
)
372 WARNING("target not halted");
373 return ERROR_TARGET_NOT_HALTED
;
376 if (!watchpoint
->set
)
378 WARNING("breakpoint not set");
382 if (watchpoint
->set
== 1)
384 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
385 jtag_execute_queue();
386 arm7_9
->wp0_used
= 0;
388 else if (watchpoint
->set
== 2)
390 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
391 jtag_execute_queue();
392 arm7_9
->wp1_used
= 0;
399 int arm7_9_add_watchpoint(struct target_s
*target
, u32 address
, u32 length
, enum watchpoint_rw rw
)
401 armv4_5_common_t
*armv4_5
= target
->arch_info
;
402 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
404 if (target
->state
!= TARGET_HALTED
)
406 WARNING("target not halted");
407 return ERROR_TARGET_NOT_HALTED
;
410 if (arm7_9
->wp_available
< 1)
412 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
415 if ((length
!= 1) && (length
!= 2) && (length
!= 4))
417 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
420 arm7_9
->wp_available
--;
425 int arm7_9_remove_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
427 armv4_5_common_t
*armv4_5
= target
->arch_info
;
428 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
430 if (target
->state
!= TARGET_HALTED
)
432 WARNING("target not halted");
433 return ERROR_TARGET_NOT_HALTED
;
438 arm7_9_unset_watchpoint(target
, watchpoint
);
441 arm7_9
->wp_available
++;
446 int arm7_9_enable_sw_bkpts(struct target_s
*target
)
448 armv4_5_common_t
*armv4_5
= target
->arch_info
;
449 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
452 if (arm7_9
->sw_bkpts_enabled
)
455 if (arm7_9
->wp_available
-- < 1)
457 WARNING("can't enable sw breakpoints with no watchpoint unit available");
458 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
461 if (!arm7_9
->wp0_used
)
463 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_VALUE
], arm7_9
->arm_bkpt
);
464 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0x0);
465 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffffu
);
466 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
467 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
468 arm7_9
->sw_bkpts_enabled
= 1;
469 arm7_9
->wp0_used
= 3;
471 else if (!arm7_9
->wp1_used
)
473 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_VALUE
], arm7_9
->arm_bkpt
);
474 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0x0);
475 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], 0xffffffffu
);
476 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
477 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
478 arm7_9
->sw_bkpts_enabled
= 2;
479 arm7_9
->wp1_used
= 3;
483 ERROR("BUG: both watchpoints used, but wp_available >= 1");
487 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
489 ERROR("error writing EmbeddedICE registers to enable sw breakpoints");
496 int arm7_9_disable_sw_bkpts(struct target_s
*target
)
498 armv4_5_common_t
*armv4_5
= target
->arch_info
;
499 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
501 if (!arm7_9
->sw_bkpts_enabled
)
504 if (arm7_9
->sw_bkpts_enabled
== 1)
506 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
507 arm7_9
->sw_bkpts_enabled
= 0;
508 arm7_9
->wp0_used
= 0;
509 arm7_9
->wp_available
++;
511 else if (arm7_9
->sw_bkpts_enabled
== 2)
513 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
514 arm7_9
->sw_bkpts_enabled
= 0;
515 arm7_9
->wp1_used
= 0;
516 arm7_9
->wp_available
++;
522 int arm7_9_execute_sys_speed(struct target_s
*target
)
527 armv4_5_common_t
*armv4_5
= target
->arch_info
;
528 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
529 arm_jtag_t
*jtag_info
= &arm7_9
->jtag_info
;
530 reg_t
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
532 /* set RESTART instruction */
533 jtag_add_end_state(TAP_RTI
);
534 arm_jtag_set_instr(jtag_info
, 0x4);
536 for (timeout
=0; timeout
<50; timeout
++)
538 /* read debug status register */
539 embeddedice_read_reg(dbg_stat
);
540 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
542 if ((buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_DBGACK
, 1))
543 && (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_SYSCOMP
, 1)))
549 ERROR("timeout waiting for SYSCOMP & DBGACK, last DBG_STATUS: %x", buf_get_u32(dbg_stat
->value
, 0, dbg_stat
->size
));
550 return ERROR_TARGET_TIMEOUT
;
556 int arm7_9_execute_fast_sys_speed(struct target_s
*target
)
558 u8 check_value
[4], check_mask
[4];
560 armv4_5_common_t
*armv4_5
= target
->arch_info
;
561 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
562 arm_jtag_t
*jtag_info
= &arm7_9
->jtag_info
;
563 reg_t
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
565 /* set RESTART instruction */
566 jtag_add_end_state(TAP_RTI
);
567 arm_jtag_set_instr(jtag_info
, 0x4);
569 /* check for DBGACK and SYSCOMP set (others don't care) */
570 buf_set_u32(check_value
, 0, 32, 0x9);
571 buf_set_u32(check_mask
, 0, 32, 0x9);
573 /* read debug status register */
574 embeddedice_read_reg_w_check(dbg_stat
, check_value
, check_value
);
579 enum target_state
arm7_9_poll(target_t
*target
)
582 armv4_5_common_t
*armv4_5
= target
->arch_info
;
583 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
584 reg_t
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
585 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
587 if (arm7_9
->reinit_embeddedice
)
589 arm7_9_reinit_embeddedice(target
);
592 /* read debug status register */
593 embeddedice_read_reg(dbg_stat
);
594 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
598 case ERROR_JTAG_QUEUE_FAILED
:
599 ERROR("JTAG queue failed while reading EmbeddedICE status register");
607 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_DBGACK
, 1))
609 DEBUG("DBGACK set, dbg_state->value: 0x%x", buf_get_u32(dbg_stat
->value
, 0, 32));
610 if ((target
->state
== TARGET_UNKNOWN
))
612 WARNING("DBGACK set while target was in unknown state. Reset or initialize target before resuming");
613 target
->state
= TARGET_RUNNING
;
615 if ((target
->state
== TARGET_RUNNING
) || (target
->state
== TARGET_RESET
))
617 target
->state
= TARGET_HALTED
;
618 if ((retval
= arm7_9_debug_entry(target
)) != ERROR_OK
)
621 target_call_event_callbacks(target
, TARGET_EVENT_HALTED
);
623 if (target
->state
== TARGET_DEBUG_RUNNING
)
625 target
->state
= TARGET_HALTED
;
626 if ((retval
= arm7_9_debug_entry(target
)) != ERROR_OK
)
629 target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_HALTED
);
634 if (target
->state
!= TARGET_DEBUG_RUNNING
)
635 target
->state
= TARGET_RUNNING
;
638 return target
->state
;
641 int arm7_9_assert_reset(target_t
*target
)
645 DEBUG("target->state: %s", target_state_strings
[target
->state
]);
647 if (target
->state
== TARGET_HALTED
|| target
->state
== TARGET_UNKNOWN
)
649 /* assert SRST and TRST */
650 /* system would get ouf sync if we didn't reset test-logic, too */
651 if ((retval
= jtag_add_reset(1, 1)) != ERROR_OK
)
653 if (retval
== ERROR_JTAG_RESET_CANT_SRST
)
655 WARNING("can't assert srst");
660 ERROR("unknown error");
664 jtag_add_sleep(5000);
665 if ((retval
= jtag_add_reset(0, 1)) != ERROR_OK
)
667 if (retval
== ERROR_JTAG_RESET_WOULD_ASSERT_TRST
)
669 WARNING("srst resets test logic, too");
670 retval
= jtag_add_reset(1, 1);
676 if ((retval
= jtag_add_reset(0, 1)) != ERROR_OK
)
678 if (retval
== ERROR_JTAG_RESET_WOULD_ASSERT_TRST
)
680 WARNING("srst resets test logic, too");
681 retval
= jtag_add_reset(1, 1);
684 if (retval
== ERROR_JTAG_RESET_CANT_SRST
)
686 WARNING("can't assert srst");
689 else if (retval
!= ERROR_OK
)
691 ERROR("unknown error");
697 target
->state
= TARGET_RESET
;
698 jtag_add_sleep(50000);
700 armv4_5_invalidate_core_regs(target
);
706 int arm7_9_deassert_reset(target_t
*target
)
708 DEBUG("target->state: %s", target_state_strings
[target
->state
]);
710 /* deassert reset lines */
711 jtag_add_reset(0, 0);
717 int arm7_9_soft_reset_halt(struct target_s
*target
)
719 armv4_5_common_t
*armv4_5
= target
->arch_info
;
720 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
721 reg_t
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
724 if (target
->state
== TARGET_RUNNING
)
726 target
->type
->halt(target
);
729 while (buf_get_u32(dbg_stat
->value
, EICE_DBG_CONTROL_DBGACK
, 1) == 0)
731 embeddedice_read_reg(dbg_stat
);
732 jtag_execute_queue();
734 target
->state
= TARGET_HALTED
;
736 /* all register content is now invalid */
737 armv4_5_invalidate_core_regs(target
);
739 /* SVC, ARM state, IRQ and FIQ disabled */
740 buf_set_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8, 0xd3);
741 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].dirty
= 1;
742 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].valid
= 1;
744 /* start fetching from 0x0 */
745 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, 0x0);
746 armv4_5
->core_cache
->reg_list
[15].dirty
= 1;
747 armv4_5
->core_cache
->reg_list
[15].valid
= 1;
749 armv4_5
->core_mode
= ARMV4_5_MODE_SVC
;
750 armv4_5
->core_state
= ARMV4_5_STATE_ARM
;
752 /* reset registers */
753 for (i
= 0; i
<= 14; i
++)
755 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).value
, 0, 32, 0xffffffff);
756 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= 1;
757 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).valid
= 1;
760 target_call_event_callbacks(target
, TARGET_EVENT_HALTED
);
765 int arm7_9_halt(target_t
*target
)
767 armv4_5_common_t
*armv4_5
= target
->arch_info
;
768 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
769 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
771 DEBUG("target->state: %s", target_state_strings
[target
->state
]);
773 if (target
->state
== TARGET_HALTED
)
775 WARNING("target was already halted");
776 return ERROR_TARGET_ALREADY_HALTED
;
779 if (target
->state
== TARGET_UNKNOWN
)
781 WARNING("target was in unknown state when halt was requested");
784 if (arm7_9
->use_dbgrq
)
786 /* program EmbeddedICE Debug Control Register to assert DBGRQ
788 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 1);
789 embeddedice_store_reg(dbg_ctrl
);
793 /* program watchpoint unit to match on any address
795 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffff);
796 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffff);
797 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x100);
798 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], 0xf7);
801 target
->debug_reason
= DBG_REASON_DBGRQ
;
806 int arm7_9_clear_halt(target_t
*target
)
808 armv4_5_common_t
*armv4_5
= target
->arch_info
;
809 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
810 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
812 if (arm7_9
->use_dbgrq
)
814 /* program EmbeddedICE Debug Control Register to deassert DBGRQ
816 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 0);
817 embeddedice_store_reg(dbg_ctrl
);
821 /* restore registers if watchpoint unit 0 was in use
823 if (arm7_9
->wp0_used
)
825 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
]);
826 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
]);
827 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
]);
829 /* control value always has to be restored, as it was either disabled,
830 * or enabled with possibly different bits
832 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
]);
838 int arm7_9_debug_entry(target_t
*target
)
843 u32 r0_thumb
, pc_thumb
;
846 /* get pointers to arch-specific information */
847 armv4_5_common_t
*armv4_5
= target
->arch_info
;
848 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
849 reg_t
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
850 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
852 #ifdef _DEBUG_ARM7_9_
856 if (arm7_9
->pre_debug_entry
)
857 arm7_9
->pre_debug_entry(target
);
859 /* program EmbeddedICE Debug Control Register to assert DBGACK and INTDIS
860 * ensure that DBGRQ is cleared
862 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 1);
863 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 0);
864 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_INTDIS
, 1, 1);
865 embeddedice_store_reg(dbg_ctrl
);
867 arm7_9_clear_halt(target
);
869 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
873 case ERROR_JTAG_QUEUE_FAILED
:
874 ERROR("JTAG queue failed while writing EmbeddedICE control register");
882 if ((retval
= arm7_9
->examine_debug_reason(target
)) != ERROR_OK
)
886 if (target
->state
!= TARGET_HALTED
)
888 WARNING("target not halted");
889 return ERROR_TARGET_NOT_HALTED
;
892 /* if the target is in Thumb state, change to ARM state */
893 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_ITBIT
, 1))
895 DEBUG("target entered debug from Thumb state");
896 /* Entered debug from Thumb mode */
897 armv4_5
->core_state
= ARMV4_5_STATE_THUMB
;
898 arm7_9
->change_to_arm(target
, &r0_thumb
, &pc_thumb
);
899 DEBUG("r0_thumb: 0x%8.8x, pc_thumb: 0x%8.8x", r0_thumb
, pc_thumb
);
903 DEBUG("target entered debug from ARM state");
904 /* Entered debug from ARM mode */
905 armv4_5
->core_state
= ARMV4_5_STATE_ARM
;
908 for (i
= 0; i
< 16; i
++)
909 context_p
[i
] = &context
[i
];
910 /* save core registers (r0 - r15 of current core mode) */
911 arm7_9
->read_core_regs(target
, 0xffff, context_p
);
913 arm7_9
->read_xpsr(target
, &cpsr
, 0);
915 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
917 buf_set_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 32, cpsr
);
918 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].dirty
= 0;
919 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].valid
= 1;
921 armv4_5
->core_mode
= cpsr
& 0x1f;
922 DEBUG("target entered debug state in %s mode", armv4_5_mode_strings
[armv4_5_mode_to_number(armv4_5
->core_mode
)]);
924 if (armv4_5_mode_to_number(armv4_5
->core_mode
) == -1)
926 target
->state
= TARGET_UNKNOWN
;
927 ERROR("cpsr contains invalid mode value - communication failure");
928 return ERROR_TARGET_FAILURE
;
931 if (armv4_5
->core_state
== ARMV4_5_STATE_THUMB
)
933 DEBUG("thumb state, applying fixups");
934 context
[0] = r0_thumb
;
935 context
[15] = pc_thumb
;
936 } else if (armv4_5
->core_state
== ARMV4_5_STATE_ARM
)
938 /* adjust value stored by STM */
939 context
[15] -= 3 * 4;
942 if ((target
->debug_reason
== DBG_REASON_BREAKPOINT
)
943 || (target
->debug_reason
== DBG_REASON_SINGLESTEP
)
944 || (target
->debug_reason
== DBG_REASON_WATCHPOINT
)
945 || (target
->debug_reason
== DBG_REASON_WPTANDBKPT
)
946 || ((target
->debug_reason
== DBG_REASON_DBGRQ
) && (arm7_9
->use_dbgrq
== 0)))
947 context
[15] -= 3 * ((armv4_5
->core_state
== ARMV4_5_STATE_ARM
) ? 4 : 2);
948 else if (target
->debug_reason
== DBG_REASON_DBGRQ
)
949 context
[15] -= arm7_9
->dbgreq_adjust_pc
* ((armv4_5
->core_state
== ARMV4_5_STATE_ARM
) ? 4 : 2);
952 ERROR("unknown debug reason: %i", target
->debug_reason
);
956 for (i
=0; i
<=15; i
++)
958 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).value
, 0, 32, context
[i
]);
959 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= 0;
960 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).valid
= 1;
963 DEBUG("entered debug state at PC 0x%x", context
[15]);
965 /* exceptions other than USR & SYS have a saved program status register */
966 if ((armv4_5_mode_to_number(armv4_5
->core_mode
) != ARMV4_5_MODE_USR
) && (armv4_5_mode_to_number(armv4_5
->core_mode
) != ARMV4_5_MODE_SYS
))
969 arm7_9
->read_xpsr(target
, &spsr
, 1);
970 jtag_execute_queue();
971 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).value
, 0, 32, spsr
);
972 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).dirty
= 0;
973 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).valid
= 1;
976 /* r0 and r15 (pc) have to be restored later */
977 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 0).dirty
= 1;
978 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 15).dirty
= 1;
980 if ((retval
= jtag
->execute_queue()) != ERROR_OK
)
983 if (arm7_9
->post_debug_entry
)
984 arm7_9
->post_debug_entry(target
);
989 int arm7_9_full_context(target_t
*target
)
993 armv4_5_common_t
*armv4_5
= target
->arch_info
;
994 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
998 if (target
->state
!= TARGET_HALTED
)
1000 WARNING("target not halted");
1001 return ERROR_TARGET_NOT_HALTED
;
1004 /* iterate through processor modes (User, FIQ, IRQ, SVC, ABT, UND)
1005 * SYS shares registers with User, so we don't touch SYS
1007 for(i
= 0; i
< 6; i
++)
1014 /* check if there are invalid registers in the current mode
1016 for (j
= 0; j
<= 16; j
++)
1018 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
== 0)
1026 /* change processor mode */
1027 tmp_cpsr
= buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & 0xE0;
1028 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1029 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1031 for (j
= 0; j
< 15; j
++)
1033 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
== 0)
1035 reg_p
[j
] = (u32
*)ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).value
;
1037 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
= 1;
1038 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).dirty
= 0;
1042 /* if only the PSR is invalid, mask is all zeroes */
1044 arm7_9
->read_core_regs(target
, mask
, reg_p
);
1046 /* check if the PSR has to be read */
1047 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).valid
== 0)
1049 arm7_9
->read_xpsr(target
, (u32
*)ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).value
, 1);
1050 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).valid
= 1;
1051 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).dirty
= 0;
1056 /* restore processor mode */
1057 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8), 0, 0);
1059 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1061 ERROR("JTAG failure");
1067 int arm7_9_restore_context(target_t
*target
)
1069 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1070 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1072 armv4_5_core_reg_t
*reg_arch_info
;
1073 enum armv4_5_mode current_mode
= armv4_5
->core_mode
;
1080 if (target
->state
!= TARGET_HALTED
)
1082 WARNING("target not halted");
1083 return ERROR_TARGET_NOT_HALTED
;
1086 if (arm7_9
->pre_restore_context
)
1087 arm7_9
->pre_restore_context(target
);
1089 /* iterate through processor modes (User, FIQ, IRQ, SVC, ABT, UND)
1090 * SYS shares registers with User, so we don't touch SYS
1092 for (i
= 0; i
< 6; i
++)
1094 DEBUG("examining %s mode", armv4_5_mode_strings
[i
]);
1097 /* check if there are dirty registers in the current mode
1099 for (j
= 0; j
<= 16; j
++)
1101 reg
= &ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
);
1102 reg_arch_info
= reg
->arch_info
;
1103 if (reg
->dirty
== 1)
1105 if (reg
->valid
== 1)
1108 DEBUG("examining dirty reg: %s", reg
->name
);
1109 if ((reg_arch_info
->mode
!= ARMV4_5_MODE_ANY
)
1110 && (reg_arch_info
->mode
!= current_mode
)
1111 && !((reg_arch_info
->mode
== ARMV4_5_MODE_USR
) && (armv4_5
->core_mode
== ARMV4_5_MODE_SYS
))
1112 && !((reg_arch_info
->mode
== ARMV4_5_MODE_SYS
) && (armv4_5
->core_mode
== ARMV4_5_MODE_USR
)))
1115 DEBUG("require mode change");
1120 ERROR("BUG: dirty register '%s', but no valid data", reg
->name
);
1136 /* change processor mode */
1137 tmp_cpsr
= buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & 0xE0;
1138 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1139 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1140 current_mode
= armv4_5_number_to_mode(i
);
1143 for (j
= 0; j
<= 14; j
++)
1145 reg
= &ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
);
1146 reg_arch_info
= reg
->arch_info
;
1149 if (reg
->dirty
== 1)
1151 regs
[j
] = buf_get_u32(reg
->value
, 0, 32);
1156 DEBUG("writing register %i of mode %s with value 0x%8.8x", j
, armv4_5_mode_strings
[i
], regs
[j
]);
1162 arm7_9
->write_core_regs(target
, mask
, regs
);
1165 reg
= &ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16);
1166 reg_arch_info
= reg
->arch_info
;
1167 if ((reg
->dirty
) && (reg_arch_info
->mode
!= ARMV4_5_MODE_ANY
))
1169 DEBUG("writing SPSR of mode %i with value 0x%8.8x", i
, buf_get_u32(reg
->value
, 0, 32));
1170 arm7_9
->write_xpsr(target
, buf_get_u32(reg
->value
, 0, 32), 1);
1175 if ((armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].dirty
== 0) && (armv4_5
->core_mode
!= current_mode
))
1177 /* restore processor mode */
1180 tmp_cpsr
= buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & 0xE0;
1181 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1182 DEBUG("writing lower 8 bit of cpsr with value 0x%2.2x", tmp_cpsr
);
1183 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1185 else if (armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].dirty
== 1)
1187 /* CPSR has been changed, full restore necessary */
1188 DEBUG("writing cpsr with value 0x%8.8x", buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 32));
1189 arm7_9
->write_xpsr(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 32), 0);
1190 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].dirty
= 0;
1191 armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].valid
= 1;
1195 DEBUG("writing PC with value 0x%8.8x", buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1196 arm7_9
->write_pc(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1197 armv4_5
->core_cache
->reg_list
[15].dirty
= 0;
1199 if (arm7_9
->post_restore_context
)
1200 arm7_9
->post_restore_context(target
);
1205 int arm7_9_restart_core(struct target_s
*target
)
1207 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1208 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1209 arm_jtag_t
*jtag_info
= &arm7_9
->jtag_info
;
1211 /* set RESTART instruction */
1212 jtag_add_end_state(TAP_RTI
);
1213 arm_jtag_set_instr(jtag_info
, 0x4);
1215 jtag_add_runtest(1, TAP_RTI
);
1216 if ((jtag_execute_queue()) != ERROR_OK
)
1224 void arm7_9_enable_watchpoints(struct target_s
*target
)
1226 watchpoint_t
*watchpoint
= target
->watchpoints
;
1230 if (watchpoint
->set
== 0)
1231 arm7_9_set_watchpoint(target
, watchpoint
);
1232 watchpoint
= watchpoint
->next
;
1236 void arm7_9_enable_breakpoints(struct target_s
*target
)
1238 breakpoint_t
*breakpoint
= target
->breakpoints
;
1240 /* set any pending breakpoints */
1243 if (breakpoint
->set
== 0)
1244 arm7_9_set_breakpoint(target
, breakpoint
);
1245 breakpoint
= breakpoint
->next
;
1249 void arm7_9_disable_bkpts_and_wpts(struct target_s
*target
)
1251 breakpoint_t
*breakpoint
= target
->breakpoints
;
1252 watchpoint_t
*watchpoint
= target
->watchpoints
;
1254 /* set any pending breakpoints */
1257 if (breakpoint
->set
!= 0)
1258 arm7_9_unset_breakpoint(target
, breakpoint
);
1259 breakpoint
= breakpoint
->next
;
1264 if (watchpoint
->set
!= 0)
1265 arm7_9_unset_watchpoint(target
, watchpoint
);
1266 watchpoint
= watchpoint
->next
;
1270 int arm7_9_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
1272 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1273 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1274 breakpoint_t
*breakpoint
= target
->breakpoints
;
1275 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1279 if (target
->state
!= TARGET_HALTED
)
1281 WARNING("target not halted");
1282 return ERROR_TARGET_NOT_HALTED
;
1285 if (!debug_execution
)
1287 target_free_all_working_areas(target
);
1290 /* current = 1: continue on current pc, otherwise continue at <address> */
1292 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, address
);
1294 /* the front-end may request us not to handle breakpoints */
1295 if (handle_breakpoints
)
1297 if ((breakpoint
= breakpoint_find(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32))))
1299 DEBUG("unset breakpoint at 0x%8.8x", breakpoint
->address
);
1300 arm7_9_unset_breakpoint(target
, breakpoint
);
1302 DEBUG("enable single-step");
1303 arm7_9
->enable_single_step(target
);
1305 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
1307 arm7_9_restore_context(target
);
1309 if (armv4_5
->core_state
== ARMV4_5_STATE_ARM
)
1310 arm7_9
->branch_resume(target
);
1311 else if (armv4_5
->core_state
== ARMV4_5_STATE_THUMB
)
1313 arm7_9
->branch_resume_thumb(target
);
1317 ERROR("unhandled core state");
1321 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 0);
1322 embeddedice_write_reg(dbg_ctrl
, buf_get_u32(dbg_ctrl
->value
, 0, dbg_ctrl
->size
));
1323 arm7_9_execute_sys_speed(target
);
1325 DEBUG("disable single-step");
1326 arm7_9
->disable_single_step(target
);
1328 arm7_9_debug_entry(target
);
1329 DEBUG("new PC after step: 0x%8.8x", buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1331 DEBUG("set breakpoint at 0x%8.8x", breakpoint
->address
);
1332 arm7_9_set_breakpoint(target
, breakpoint
);
1336 /* enable any pending breakpoints and watchpoints */
1337 arm7_9_enable_breakpoints(target
);
1338 arm7_9_enable_watchpoints(target
);
1340 arm7_9_restore_context(target
);
1342 if (armv4_5
->core_state
== ARMV4_5_STATE_ARM
)
1344 arm7_9
->branch_resume(target
);
1346 else if (armv4_5
->core_state
== ARMV4_5_STATE_THUMB
)
1348 arm7_9
->branch_resume_thumb(target
);
1352 ERROR("unhandled core state");
1356 /* deassert DBGACK and INTDIS */
1357 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 0);
1358 /* INTDIS only when we really resume, not during debug execution */
1359 if (!debug_execution
)
1360 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_INTDIS
, 1, 0);
1361 embeddedice_write_reg(dbg_ctrl
, buf_get_u32(dbg_ctrl
->value
, 0, dbg_ctrl
->size
));
1363 arm7_9_restart_core(target
);
1365 target
->debug_reason
= DBG_REASON_NOTHALTED
;
1367 if (!debug_execution
)
1369 /* registers are now invalid */
1370 armv4_5_invalidate_core_regs(target
);
1371 target
->state
= TARGET_RUNNING
;
1372 target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
);
1376 target
->state
= TARGET_DEBUG_RUNNING
;
1377 target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_RESUMED
);
1380 DEBUG("target resumed");
1385 void arm7_9_enable_eice_step(target_t
*target
)
1387 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1388 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1390 /* setup an inverse breakpoint on the current PC
1391 * - comparator 1 matches the current address
1392 * - rangeout from comparator 1 is connected to comparator 0 rangein
1393 * - comparator 0 matches any address, as long as rangein is low */
1394 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffff);
1395 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffff);
1396 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x100);
1397 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], 0x77);
1398 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1399 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], 0);
1400 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0xffffffff);
1401 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
1402 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], 0xf7);
1405 void arm7_9_disable_eice_step(target_t
*target
)
1407 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1408 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1410 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
]);
1411 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
]);
1412 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
]);
1413 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
]);
1414 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
]);
1415 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
]);
1416 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
]);
1417 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
]);
1418 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
]);
1421 int arm7_9_step(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
)
1423 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1424 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1425 breakpoint_t
*breakpoint
= target
->breakpoints
;
1427 if (target
->state
!= TARGET_HALTED
)
1429 WARNING("target not halted");
1430 return ERROR_TARGET_NOT_HALTED
;
1433 /* current = 1: continue on current pc, otherwise continue at <address> */
1435 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, address
);
1437 /* the front-end may request us not to handle breakpoints */
1438 if (handle_breakpoints
)
1439 if ((breakpoint
= breakpoint_find(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32))))
1440 arm7_9_unset_breakpoint(target
, breakpoint
);
1442 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
1444 arm7_9_restore_context(target
);
1446 arm7_9
->enable_single_step(target
);
1448 if (armv4_5
->core_state
== ARMV4_5_STATE_ARM
)
1450 arm7_9
->branch_resume(target
);
1452 else if (armv4_5
->core_state
== ARMV4_5_STATE_THUMB
)
1454 arm7_9
->branch_resume_thumb(target
);
1458 ERROR("unhandled core state");
1462 target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
);
1464 arm7_9_execute_sys_speed(target
);
1465 arm7_9
->disable_single_step(target
);
1467 /* registers are now invalid */
1468 armv4_5_invalidate_core_regs(target
);
1470 arm7_9_debug_entry(target
);
1472 target_call_event_callbacks(target
, TARGET_EVENT_HALTED
);
1475 arm7_9_set_breakpoint(target
, breakpoint
);
1477 DEBUG("target stepped");
1483 int arm7_9_read_core_reg(struct target_s
*target
, int num
, enum armv4_5_mode mode
)
1487 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1488 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1489 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
;
1491 if ((num
< 0) || (num
> 16))
1492 return ERROR_INVALID_ARGUMENTS
;
1494 if ((mode
!= ARMV4_5_MODE_ANY
)
1495 && (mode
!= armv4_5
->core_mode
)
1496 && (reg_mode
!= ARMV4_5_MODE_ANY
))
1500 /* change processor mode */
1501 tmp_cpsr
= buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & 0xE0;
1503 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1506 if ((num
>= 0) && (num
<= 15))
1508 /* read a normal core register */
1509 reg_p
[num
] = (u32
*)ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).value
;
1511 arm7_9
->read_core_regs(target
, 1 << num
, reg_p
);
1515 /* read a program status register
1516 * if the register mode is MODE_ANY, we read the cpsr, otherwise a spsr
1518 armv4_5_core_reg_t
*arch_info
= ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).arch_info
;
1519 int spsr
= (arch_info
->mode
== ARMV4_5_MODE_ANY
) ? 0 : 1;
1521 arm7_9
->read_xpsr(target
, (u32
*)ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).value
, spsr
);
1524 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).valid
= 1;
1525 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).dirty
= 0;
1527 if ((mode
!= ARMV4_5_MODE_ANY
)
1528 && (mode
!= armv4_5
->core_mode
)
1529 && (reg_mode
!= ARMV4_5_MODE_ANY
)) {
1530 /* restore processor mode */
1531 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8), 0, 0);
1534 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1536 ERROR("JTAG failure");
1544 int arm7_9_write_core_reg(struct target_s
*target
, int num
, enum armv4_5_mode mode
, u32 value
)
1548 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1549 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1550 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
;
1552 if ((num
< 0) || (num
> 16))
1553 return ERROR_INVALID_ARGUMENTS
;
1555 if ((mode
!= ARMV4_5_MODE_ANY
)
1556 && (mode
!= armv4_5
->core_mode
)
1557 && (reg_mode
!= ARMV4_5_MODE_ANY
)) {
1560 /* change processor mode */
1561 tmp_cpsr
= buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8) & 0xE0;
1563 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1566 if ((num
>= 0) && (num
<= 15))
1568 /* write a normal core register */
1571 arm7_9
->write_core_regs(target
, 1 << num
, reg
);
1575 /* write a program status register
1576 * if the register mode is MODE_ANY, we write the cpsr, otherwise a spsr
1578 armv4_5_core_reg_t
*arch_info
= ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).arch_info
;
1579 int spsr
= (arch_info
->mode
== ARMV4_5_MODE_ANY
) ? 0 : 1;
1581 arm7_9
->write_xpsr(target
, value
, spsr
);
1584 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).valid
= 1;
1585 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).dirty
= 0;
1587 if ((mode
!= ARMV4_5_MODE_ANY
)
1588 && (mode
!= armv4_5
->core_mode
)
1589 && (reg_mode
!= ARMV4_5_MODE_ANY
)) {
1590 /* restore processor mode */
1591 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8), 0, 0);
1594 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1596 ERROR("JTAG failure");
1604 int arm7_9_read_memory(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
1606 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1607 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1611 int num_accesses
= 0;
1612 int thisrun_accesses
;
1621 DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address
, size
, count
);
1623 if (target
->state
!= TARGET_HALTED
)
1625 WARNING("target not halted");
1626 return ERROR_TARGET_NOT_HALTED
;
1629 /* sanitize arguments */
1630 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
1631 return ERROR_INVALID_ARGUMENTS
;
1633 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
1634 return ERROR_TARGET_UNALIGNED_ACCESS
;
1636 for (i
= 0; i
< 16; i
++)
1641 /* load the base register with the address of the first word */
1643 arm7_9
->write_core_regs(target
, 0x1, reg
);
1648 buf32
= (u32
*)buffer
;
1649 while (num_accesses
< count
)
1652 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1653 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1655 arm7_9
->load_word_regs(target
, reg_list
);
1656 arm7_9_execute_sys_speed(target
);
1658 arm7_9
->read_core_regs(target
, reg_list
, reg_p
);
1659 jtag_execute_queue();
1661 for (i
= 1; i
<= thisrun_accesses
; i
++)
1665 *(buf32
++) = reg
[i
];
1667 num_accesses
+= thisrun_accesses
;
1671 buf16
= (u16
*)buffer
;
1672 while (num_accesses
< count
)
1675 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1676 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1678 for (i
= 1; i
<= thisrun_accesses
; i
++)
1682 arm7_9
->load_hword_reg(target
, i
);
1683 arm7_9_execute_sys_speed(target
);
1686 arm7_9
->read_core_regs(target
, reg_list
, reg_p
);
1687 jtag_execute_queue();
1689 for (i
= 1; i
<= thisrun_accesses
; i
++)
1691 *(buf16
++) = reg
[i
] & 0xffff;
1693 num_accesses
+= thisrun_accesses
;
1698 while (num_accesses
< count
)
1701 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1702 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1704 for (i
= 1; i
<= thisrun_accesses
; i
++)
1708 arm7_9
->load_byte_reg(target
, i
);
1709 arm7_9_execute_sys_speed(target
);
1712 arm7_9
->read_core_regs(target
, reg_list
, reg_p
);
1713 jtag_execute_queue();
1715 for (i
= 1; i
<= thisrun_accesses
; i
++)
1717 *(buf8
++) = reg
[i
] & 0xff;
1719 num_accesses
+= thisrun_accesses
;
1723 ERROR("BUG: we shouldn't get here");
1728 for (i
=0; i
<=last_reg
; i
++)
1729 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= 1;
1731 arm7_9
->read_xpsr(target
, &cpsr
, 0);
1732 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1734 ERROR("JTAG error while reading cpsr");
1738 if (((cpsr
& 0x1f) == ARMV4_5_MODE_ABT
) && (armv4_5
->core_mode
!= ARMV4_5_MODE_ABT
))
1740 ERROR("memory read caused data abort");
1742 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8), 0, 0);
1744 return ERROR_TARGET_DATA_ABORT
;
1750 int arm7_9_write_memory(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
1752 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1753 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1756 int num_accesses
= 0;
1757 int thisrun_accesses
;
1766 DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address
, size
, count
);
1768 if (target
->state
!= TARGET_HALTED
)
1770 WARNING("target not halted");
1771 return ERROR_TARGET_NOT_HALTED
;
1774 /* sanitize arguments */
1775 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
1776 return ERROR_INVALID_ARGUMENTS
;
1778 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
1779 return ERROR_TARGET_UNALIGNED_ACCESS
;
1781 /* load the base register with the address of the first word */
1783 arm7_9
->write_core_regs(target
, 0x1, reg
);
1788 buf32
= (u32
*)buffer
;
1789 while (num_accesses
< count
)
1792 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1793 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1795 for (i
= 1; i
<= thisrun_accesses
; i
++)
1802 arm7_9
->write_core_regs(target
, reg_list
, reg
);
1804 arm7_9
->store_word_regs(target
, reg_list
);
1806 /* fast memory writes are only safe when the target is running
1807 * from a sufficiently high clock (32 kHz is usually too slow)
1809 if (arm7_9
->fast_memory_writes
)
1810 arm7_9_execute_fast_sys_speed(target
);
1812 arm7_9_execute_sys_speed(target
);
1814 num_accesses
+= thisrun_accesses
;
1818 buf16
= (u16
*)buffer
;
1819 while (num_accesses
< count
)
1822 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1823 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1825 for (i
= 1; i
<= thisrun_accesses
; i
++)
1829 reg
[i
] = *buf16
++ & 0xffff;
1832 arm7_9
->write_core_regs(target
, reg_list
, reg
);
1834 for (i
= 1; i
<= thisrun_accesses
; i
++)
1836 arm7_9
->store_hword_reg(target
, i
);
1838 /* fast memory writes are only safe when the target is running
1839 * from a sufficiently high clock (32 kHz is usually too slow)
1841 if (arm7_9
->fast_memory_writes
)
1842 arm7_9_execute_fast_sys_speed(target
);
1844 arm7_9_execute_sys_speed(target
);
1847 num_accesses
+= thisrun_accesses
;
1852 while (num_accesses
< count
)
1855 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1856 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1858 for (i
= 1; i
<= thisrun_accesses
; i
++)
1862 reg
[i
] = *buf8
++ & 0xff;
1865 arm7_9
->write_core_regs(target
, reg_list
, reg
);
1867 for (i
= 1; i
<= thisrun_accesses
; i
++)
1869 arm7_9
->store_byte_reg(target
, i
);
1870 /* fast memory writes are only safe when the target is running
1871 * from a sufficiently high clock (32 kHz is usually too slow)
1873 if (arm7_9
->fast_memory_writes
)
1874 arm7_9_execute_fast_sys_speed(target
);
1876 arm7_9_execute_sys_speed(target
);
1879 num_accesses
+= thisrun_accesses
;
1883 ERROR("BUG: we shouldn't get here");
1888 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1890 ERROR("JTAG error while writing target memory");
1894 for (i
=0; i
<=last_reg
; i
++)
1895 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= 1;
1897 arm7_9
->read_xpsr(target
, &cpsr
, 0);
1898 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1900 ERROR("JTAG error while reading cpsr");
1904 if (((cpsr
& 0x1f) == ARMV4_5_MODE_ABT
) && (armv4_5
->core_mode
!= ARMV4_5_MODE_ABT
))
1906 ERROR("memory write caused data abort");
1908 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8), 0, 0);
1910 return ERROR_TARGET_DATA_ABORT
;
1916 int arm7_9_bulk_write_memory(target_t
*target
, u32 address
, u32 count
, u8
*buffer
)
1918 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1919 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1920 enum armv4_5_state core_state
= armv4_5
->core_state
;
1921 u32 r0
= buf_get_u32(armv4_5
->core_cache
->reg_list
[0].value
, 0, 32);
1922 u32 r1
= buf_get_u32(armv4_5
->core_cache
->reg_list
[1].value
, 0, 32);
1923 u32 pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
1928 /* MRC TST BNE MRC STR B */
1929 0xee101e10, 0xe3110001, 0x0afffffc, 0xee111e10, 0xe4801004, 0xeafffff9
1932 if (!arm7_9
->dcc_downloads
)
1933 return target
->type
->write_memory(target
, address
, 4, count
, buffer
);
1935 /* regrab previously allocated working_area, or allocate a new one */
1936 if (!arm7_9
->dcc_working_area
)
1938 /* make sure we have a working area */
1939 if (target_alloc_working_area(target
, 24, &arm7_9
->dcc_working_area
) != ERROR_OK
)
1941 INFO("no working area available, falling back to memory writes");
1942 return target
->type
->write_memory(target
, address
, 4, count
, buffer
);
1945 /* write DCC code to working area */
1946 target
->type
->write_memory(target
, arm7_9
->dcc_working_area
->address
, 4, 6, (u8
*)dcc_code
);
1949 buf_set_u32(armv4_5
->core_cache
->reg_list
[0].value
, 0, 32, address
);
1950 armv4_5
->core_cache
->reg_list
[0].valid
= 1;
1951 armv4_5
->core_cache
->reg_list
[0].dirty
= 1;
1952 armv4_5
->core_state
= ARMV4_5_STATE_ARM
;
1954 arm7_9_resume(target
, 0, arm7_9
->dcc_working_area
->address
, 1, 1);
1956 for (i
= 0; i
< count
; i
++)
1958 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_COMMS_DATA
], buf_get_u32(buffer
, 0, 32));
1962 target
->type
->halt(target
);
1964 while (target
->state
!= TARGET_HALTED
)
1965 target
->type
->poll(target
);
1967 /* restore target state */
1968 buf_set_u32(armv4_5
->core_cache
->reg_list
[0].value
, 0, 32, r0
);
1969 armv4_5
->core_cache
->reg_list
[0].valid
= 1;
1970 armv4_5
->core_cache
->reg_list
[0].dirty
= 1;
1971 buf_set_u32(armv4_5
->core_cache
->reg_list
[1].value
, 0, 32, r1
);
1972 armv4_5
->core_cache
->reg_list
[1].valid
= 1;
1973 armv4_5
->core_cache
->reg_list
[1].dirty
= 1;
1974 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, pc
);
1975 armv4_5
->core_cache
->reg_list
[15].valid
= 1;
1976 armv4_5
->core_cache
->reg_list
[15].dirty
= 1;
1977 armv4_5
->core_state
= core_state
;
1982 int arm7_9_register_commands(struct command_context_s
*cmd_ctx
)
1984 command_t
*arm7_9_cmd
;
1986 arm7_9_cmd
= register_command(cmd_ctx
, NULL
, "arm7_9", NULL
, COMMAND_ANY
, NULL
);
1988 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>");
1989 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>");
1991 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>");
1993 register_command(cmd_ctx
, arm7_9_cmd
, "sw_bkpts", handle_arm7_9_sw_bkpts_command
, COMMAND_EXEC
, "support for software breakpoints <enable|disable>");
1994 register_command(cmd_ctx
, arm7_9_cmd
, "force_hw_bkpts", handle_arm7_9_force_hw_bkpts_command
, COMMAND_EXEC
, "use hardware breakpoints for all breakpoints (disables sw breakpoint support) <enable|disable>");
1995 register_command(cmd_ctx
, arm7_9_cmd
, "dbgrq", handle_arm7_9_dbgrq_command
,
1996 COMMAND_ANY
, "use EmbeddedICE dbgrq instead of breakpoint for target halt requests <enable|disable>");
1997 register_command(cmd_ctx
, arm7_9_cmd
, "fast_writes", handle_arm7_9_fast_writes_command
,
1998 COMMAND_ANY
, "use fast memory writes instead of slower but potentially unsafe slow writes <enable|disable>");
1999 register_command(cmd_ctx
, arm7_9_cmd
, "dcc_downloads", handle_arm7_9_dcc_downloads_command
,
2000 COMMAND_ANY
, "use DCC downloads for larger memory writes <enable|disable>");
2002 armv4_5_register_commands(cmd_ctx
);
2007 int handle_arm7_9_write_xpsr_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2012 target_t
*target
= get_current_target(cmd_ctx
);
2013 armv4_5_common_t
*armv4_5
;
2014 arm7_9_common_t
*arm7_9
;
2016 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2018 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2022 if (target
->state
!= TARGET_HALTED
)
2024 command_print(cmd_ctx
, "can't write registers while running");
2030 command_print(cmd_ctx
, "usage: write_xpsr <value> <not cpsr|spsr>");
2034 value
= strtoul(args
[0], NULL
, 0);
2035 spsr
= strtol(args
[1], NULL
, 0);
2037 arm7_9
->write_xpsr(target
, value
, spsr
);
2038 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2040 ERROR("JTAG error while writing to xpsr");
2047 int handle_arm7_9_write_xpsr_im8_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2053 target_t
*target
= get_current_target(cmd_ctx
);
2054 armv4_5_common_t
*armv4_5
;
2055 arm7_9_common_t
*arm7_9
;
2057 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2059 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2063 if (target
->state
!= TARGET_HALTED
)
2065 command_print(cmd_ctx
, "can't write registers while running");
2071 command_print(cmd_ctx
, "usage: write_xpsr_im8 <im8> <rotate> <not cpsr|spsr>");
2075 value
= strtoul(args
[0], NULL
, 0);
2076 rotate
= strtol(args
[1], NULL
, 0);
2077 spsr
= strtol(args
[2], NULL
, 0);
2079 arm7_9
->write_xpsr_im8(target
, value
, rotate
, spsr
);
2080 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2082 ERROR("JTAG error while writing 8-bit immediate to xpsr");
2089 int handle_arm7_9_write_core_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2094 target_t
*target
= get_current_target(cmd_ctx
);
2095 armv4_5_common_t
*armv4_5
;
2096 arm7_9_common_t
*arm7_9
;
2098 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2100 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2104 if (target
->state
!= TARGET_HALTED
)
2106 command_print(cmd_ctx
, "can't write registers while running");
2112 command_print(cmd_ctx
, "usage: write_core_reg <num> <mode> <value>");
2116 num
= strtol(args
[0], NULL
, 0);
2117 mode
= strtoul(args
[1], NULL
, 0);
2118 value
= strtoul(args
[2], NULL
, 0);
2120 arm7_9_write_core_reg(target
, num
, mode
, value
);
2125 int handle_arm7_9_sw_bkpts_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2127 target_t
*target
= get_current_target(cmd_ctx
);
2128 armv4_5_common_t
*armv4_5
;
2129 arm7_9_common_t
*arm7_9
;
2131 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2133 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2139 command_print(cmd_ctx
, "software breakpoints %s", (arm7_9
->sw_bkpts_enabled
) ? "enabled" : "disabled");
2143 if (strcmp("enable", args
[0]) == 0)
2145 if (arm7_9
->sw_bkpts_use_wp
)
2147 arm7_9_enable_sw_bkpts(target
);
2151 arm7_9
->sw_bkpts_enabled
= 1;
2154 else if (strcmp("disable", args
[0]) == 0)
2156 if (arm7_9
->sw_bkpts_use_wp
)
2158 arm7_9_disable_sw_bkpts(target
);
2162 arm7_9
->sw_bkpts_enabled
= 0;
2167 command_print(cmd_ctx
, "usage: arm7_9 sw_bkpts <enable|disable>");
2170 command_print(cmd_ctx
, "software breakpoints %s", (arm7_9
->sw_bkpts_enabled
) ? "enabled" : "disabled");
2175 int handle_arm7_9_force_hw_bkpts_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2177 target_t
*target
= get_current_target(cmd_ctx
);
2178 armv4_5_common_t
*armv4_5
;
2179 arm7_9_common_t
*arm7_9
;
2181 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2183 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2187 if ((argc
>= 1) && (strcmp("enable", args
[0]) == 0))
2189 arm7_9
->force_hw_bkpts
= 1;
2190 if (arm7_9
->sw_bkpts_use_wp
)
2192 arm7_9_disable_sw_bkpts(target
);
2195 else if ((argc
>= 1) && (strcmp("disable", args
[0]) == 0))
2197 arm7_9
->force_hw_bkpts
= 0;
2201 command_print(cmd_ctx
, "usage: arm7_9 force_hw_bkpts <enable|disable>");
2204 command_print(cmd_ctx
, "force hardware breakpoints %s", (arm7_9
->force_hw_bkpts
) ? "enabled" : "disabled");
2209 int handle_arm7_9_dbgrq_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2211 target_t
*target
= get_current_target(cmd_ctx
);
2212 armv4_5_common_t
*armv4_5
;
2213 arm7_9_common_t
*arm7_9
;
2215 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2217 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2223 if (strcmp("enable", args
[0]) == 0)
2225 arm7_9
->use_dbgrq
= 1;
2227 else if (strcmp("disable", args
[0]) == 0)
2229 arm7_9
->use_dbgrq
= 0;
2233 command_print(cmd_ctx
, "usage: arm7_9 dbgrq <enable|disable>");
2237 command_print(cmd_ctx
, "use of EmbeddedICE dbgrq instead of breakpoint for target halt %s", (arm7_9
->use_dbgrq
) ? "enabled" : "disabled");
2242 int handle_arm7_9_fast_writes_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2244 target_t
*target
= get_current_target(cmd_ctx
);
2245 armv4_5_common_t
*armv4_5
;
2246 arm7_9_common_t
*arm7_9
;
2248 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2250 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2256 if (strcmp("enable", args
[0]) == 0)
2258 arm7_9
->fast_memory_writes
= 1;
2260 else if (strcmp("disable", args
[0]) == 0)
2262 arm7_9
->fast_memory_writes
= 0;
2266 command_print(cmd_ctx
, "usage: arm7_9 fast_writes <enable|disable>");
2270 command_print(cmd_ctx
, "fast memory writes are %s", (arm7_9
->fast_memory_writes
) ? "enabled" : "disabled");
2275 int handle_arm7_9_dcc_downloads_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2277 target_t
*target
= get_current_target(cmd_ctx
);
2278 armv4_5_common_t
*armv4_5
;
2279 arm7_9_common_t
*arm7_9
;
2281 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2283 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2289 if (strcmp("enable", args
[0]) == 0)
2291 arm7_9
->dcc_downloads
= 1;
2293 else if (strcmp("disable", args
[0]) == 0)
2295 arm7_9
->dcc_downloads
= 0;
2299 command_print(cmd_ctx
, "usage: arm7_9 dcc_downloads <enable|disable>");
2303 command_print(cmd_ctx
, "dcc downloads are %s", (arm7_9
->dcc_downloads
) ? "enabled" : "disabled");
2308 int arm7_9_init_arch_info(target_t
*target
, arm7_9_common_t
*arm7_9
)
2310 armv4_5_common_t
*armv4_5
= &arm7_9
->armv4_5_common
;
2312 arm7_9
->common_magic
= ARM7_9_COMMON_MAGIC
;
2314 arm_jtag_setup_connection(&arm7_9
->jtag_info
);
2315 arm7_9
->wp_available
= 2;
2316 arm7_9
->wp0_used
= 0;
2317 arm7_9
->wp1_used
= 0;
2318 arm7_9
->force_hw_bkpts
= 0;
2319 arm7_9
->use_dbgrq
= 0;
2320 arm7_9
->has_etm
= 0;
2322 arm7_9
->reinit_embeddedice
= 0;
2324 arm7_9
->dcc_working_area
= NULL
;
2326 arm7_9
->fast_memory_writes
= 0;
2327 arm7_9
->dcc_downloads
= 0;
2329 jtag_register_event_callback(arm7_9_jtag_callback
, target
);
2331 armv4_5
->arch_info
= arm7_9
;
2332 armv4_5
->read_core_reg
= arm7_9_read_core_reg
;
2333 armv4_5
->write_core_reg
= arm7_9_write_core_reg
;
2334 armv4_5
->full_context
= arm7_9_full_context
;
2336 armv4_5_init_arch_info(target
, armv4_5
);
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)