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
->write_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
;
1618 DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address
, size
, count
);
1620 if (target
->state
!= TARGET_HALTED
)
1622 WARNING("target not halted");
1623 return ERROR_TARGET_NOT_HALTED
;
1626 /* sanitize arguments */
1627 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
1628 return ERROR_INVALID_ARGUMENTS
;
1630 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
1631 return ERROR_TARGET_UNALIGNED_ACCESS
;
1633 for (i
= 0; i
< 16; i
++)
1638 /* load the base register with the address of the first word */
1640 arm7_9
->write_core_regs(target
, 0x1, reg
);
1645 while (num_accesses
< count
)
1648 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1649 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1651 arm7_9
->load_word_regs(target
, reg_list
);
1652 arm7_9_execute_sys_speed(target
);
1654 arm7_9
->read_core_regs(target
, reg_list
, reg_p
);
1655 jtag_execute_queue();
1657 for (i
= 1; i
<= thisrun_accesses
; i
++)
1661 target_buffer_set_u32(target
, buffer
, reg
[i
]);
1664 num_accesses
+= thisrun_accesses
;
1668 while (num_accesses
< count
)
1671 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1672 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1674 for (i
= 1; i
<= thisrun_accesses
; i
++)
1678 arm7_9
->load_hword_reg(target
, i
);
1679 arm7_9_execute_sys_speed(target
);
1682 arm7_9
->read_core_regs(target
, reg_list
, reg_p
);
1683 jtag_execute_queue();
1685 for (i
= 1; i
<= thisrun_accesses
; i
++)
1687 target_buffer_set_u16(target
, buffer
, reg
[i
]);
1690 num_accesses
+= thisrun_accesses
;
1694 while (num_accesses
< count
)
1697 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1698 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1700 for (i
= 1; i
<= thisrun_accesses
; i
++)
1704 arm7_9
->load_byte_reg(target
, i
);
1705 arm7_9_execute_sys_speed(target
);
1708 arm7_9
->read_core_regs(target
, reg_list
, reg_p
);
1709 jtag_execute_queue();
1711 for (i
= 1; i
<= thisrun_accesses
; i
++)
1713 *(buffer
++) = reg
[i
] & 0xff;
1715 num_accesses
+= thisrun_accesses
;
1719 ERROR("BUG: we shouldn't get here");
1724 for (i
=0; i
<=last_reg
; i
++)
1725 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= 1;
1727 arm7_9
->read_xpsr(target
, &cpsr
, 0);
1728 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1730 ERROR("JTAG error while reading cpsr");
1734 if (((cpsr
& 0x1f) == ARMV4_5_MODE_ABT
) && (armv4_5
->core_mode
!= ARMV4_5_MODE_ABT
))
1736 ERROR("memory read caused data abort");
1738 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8), 0, 0);
1740 return ERROR_TARGET_DATA_ABORT
;
1746 int arm7_9_write_memory(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
1748 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1749 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1752 int num_accesses
= 0;
1753 int thisrun_accesses
;
1759 DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address
, size
, count
);
1761 if (target
->state
!= TARGET_HALTED
)
1763 WARNING("target not halted");
1764 return ERROR_TARGET_NOT_HALTED
;
1767 /* sanitize arguments */
1768 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
1769 return ERROR_INVALID_ARGUMENTS
;
1771 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
1772 return ERROR_TARGET_UNALIGNED_ACCESS
;
1774 /* load the base register with the address of the first word */
1776 arm7_9
->write_core_regs(target
, 0x1, reg
);
1781 while (num_accesses
< count
)
1784 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1785 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1787 for (i
= 1; i
<= thisrun_accesses
; i
++)
1791 reg
[i
] = target_buffer_get_u32(target
, buffer
);
1795 arm7_9
->write_core_regs(target
, reg_list
, reg
);
1797 arm7_9
->store_word_regs(target
, reg_list
);
1799 /* fast memory writes are only safe when the target is running
1800 * from a sufficiently high clock (32 kHz is usually too slow)
1802 if (arm7_9
->fast_memory_writes
)
1803 arm7_9_execute_fast_sys_speed(target
);
1805 arm7_9_execute_sys_speed(target
);
1807 num_accesses
+= thisrun_accesses
;
1811 while (num_accesses
< count
)
1814 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1815 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1817 for (i
= 1; i
<= thisrun_accesses
; i
++)
1821 reg
[i
] = target_buffer_get_u16(target
, buffer
) & 0xffff;
1825 arm7_9
->write_core_regs(target
, reg_list
, reg
);
1827 for (i
= 1; i
<= thisrun_accesses
; i
++)
1829 arm7_9
->store_hword_reg(target
, i
);
1831 /* fast memory writes are only safe when the target is running
1832 * from a sufficiently high clock (32 kHz is usually too slow)
1834 if (arm7_9
->fast_memory_writes
)
1835 arm7_9_execute_fast_sys_speed(target
);
1837 arm7_9_execute_sys_speed(target
);
1840 num_accesses
+= thisrun_accesses
;
1844 while (num_accesses
< count
)
1847 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
1848 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
1850 for (i
= 1; i
<= thisrun_accesses
; i
++)
1854 reg
[i
] = *buffer
++ & 0xff;
1857 arm7_9
->write_core_regs(target
, reg_list
, reg
);
1859 for (i
= 1; i
<= thisrun_accesses
; i
++)
1861 arm7_9
->store_byte_reg(target
, i
);
1862 /* fast memory writes are only safe when the target is running
1863 * from a sufficiently high clock (32 kHz is usually too slow)
1865 if (arm7_9
->fast_memory_writes
)
1866 arm7_9_execute_fast_sys_speed(target
);
1868 arm7_9_execute_sys_speed(target
);
1871 num_accesses
+= thisrun_accesses
;
1875 ERROR("BUG: we shouldn't get here");
1880 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1882 ERROR("JTAG error while writing target memory");
1886 for (i
=0; i
<=last_reg
; i
++)
1887 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= 1;
1889 arm7_9
->read_xpsr(target
, &cpsr
, 0);
1890 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1892 ERROR("JTAG error while reading cpsr");
1896 if (((cpsr
& 0x1f) == ARMV4_5_MODE_ABT
) && (armv4_5
->core_mode
!= ARMV4_5_MODE_ABT
))
1898 ERROR("memory write caused data abort");
1900 arm7_9
->write_xpsr_im8(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[ARMV4_5_CPSR
].value
, 0, 8), 0, 0);
1902 return ERROR_TARGET_DATA_ABORT
;
1908 int arm7_9_bulk_write_memory(target_t
*target
, u32 address
, u32 count
, u8
*buffer
)
1910 armv4_5_common_t
*armv4_5
= target
->arch_info
;
1911 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
1912 enum armv4_5_state core_state
= armv4_5
->core_state
;
1913 u32 r0
= buf_get_u32(armv4_5
->core_cache
->reg_list
[0].value
, 0, 32);
1914 u32 r1
= buf_get_u32(armv4_5
->core_cache
->reg_list
[1].value
, 0, 32);
1915 u32 pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
1920 /* MRC TST BNE MRC STR B */
1921 0xee101e10, 0xe3110001, 0x0afffffc, 0xee111e10, 0xe4801004, 0xeafffff9
1924 if (!arm7_9
->dcc_downloads
)
1925 return target
->type
->write_memory(target
, address
, 4, count
, buffer
);
1927 /* regrab previously allocated working_area, or allocate a new one */
1928 if (!arm7_9
->dcc_working_area
)
1930 /* make sure we have a working area */
1931 if (target_alloc_working_area(target
, 24, &arm7_9
->dcc_working_area
) != ERROR_OK
)
1933 INFO("no working area available, falling back to memory writes");
1934 return target
->type
->write_memory(target
, address
, 4, count
, buffer
);
1937 /* write DCC code to working area */
1938 target
->type
->write_memory(target
, arm7_9
->dcc_working_area
->address
, 4, 6, (u8
*)dcc_code
);
1941 buf_set_u32(armv4_5
->core_cache
->reg_list
[0].value
, 0, 32, address
);
1942 armv4_5
->core_cache
->reg_list
[0].valid
= 1;
1943 armv4_5
->core_cache
->reg_list
[0].dirty
= 1;
1944 armv4_5
->core_state
= ARMV4_5_STATE_ARM
;
1946 arm7_9_resume(target
, 0, arm7_9
->dcc_working_area
->address
, 1, 1);
1948 for (i
= 0; i
< count
; i
++)
1950 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_COMMS_DATA
], target_buffer_get_u32(target
, buffer
));
1954 target
->type
->halt(target
);
1956 while (target
->state
!= TARGET_HALTED
)
1957 target
->type
->poll(target
);
1959 /* restore target state */
1960 buf_set_u32(armv4_5
->core_cache
->reg_list
[0].value
, 0, 32, r0
);
1961 armv4_5
->core_cache
->reg_list
[0].valid
= 1;
1962 armv4_5
->core_cache
->reg_list
[0].dirty
= 1;
1963 buf_set_u32(armv4_5
->core_cache
->reg_list
[1].value
, 0, 32, r1
);
1964 armv4_5
->core_cache
->reg_list
[1].valid
= 1;
1965 armv4_5
->core_cache
->reg_list
[1].dirty
= 1;
1966 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, pc
);
1967 armv4_5
->core_cache
->reg_list
[15].valid
= 1;
1968 armv4_5
->core_cache
->reg_list
[15].dirty
= 1;
1969 armv4_5
->core_state
= core_state
;
1974 int arm7_9_register_commands(struct command_context_s
*cmd_ctx
)
1976 command_t
*arm7_9_cmd
;
1978 arm7_9_cmd
= register_command(cmd_ctx
, NULL
, "arm7_9", NULL
, COMMAND_ANY
, NULL
);
1980 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>");
1981 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>");
1983 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>");
1985 register_command(cmd_ctx
, arm7_9_cmd
, "sw_bkpts", handle_arm7_9_sw_bkpts_command
, COMMAND_EXEC
, "support for software breakpoints <enable|disable>");
1986 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>");
1987 register_command(cmd_ctx
, arm7_9_cmd
, "dbgrq", handle_arm7_9_dbgrq_command
,
1988 COMMAND_ANY
, "use EmbeddedICE dbgrq instead of breakpoint for target halt requests <enable|disable>");
1989 register_command(cmd_ctx
, arm7_9_cmd
, "fast_writes", handle_arm7_9_fast_writes_command
,
1990 COMMAND_ANY
, "use fast memory writes instead of slower but potentially unsafe slow writes <enable|disable>");
1991 register_command(cmd_ctx
, arm7_9_cmd
, "dcc_downloads", handle_arm7_9_dcc_downloads_command
,
1992 COMMAND_ANY
, "use DCC downloads for larger memory writes <enable|disable>");
1994 armv4_5_register_commands(cmd_ctx
);
1999 int handle_arm7_9_write_xpsr_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2004 target_t
*target
= get_current_target(cmd_ctx
);
2005 armv4_5_common_t
*armv4_5
;
2006 arm7_9_common_t
*arm7_9
;
2008 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2010 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2014 if (target
->state
!= TARGET_HALTED
)
2016 command_print(cmd_ctx
, "can't write registers while running");
2022 command_print(cmd_ctx
, "usage: write_xpsr <value> <not cpsr|spsr>");
2026 value
= strtoul(args
[0], NULL
, 0);
2027 spsr
= strtol(args
[1], NULL
, 0);
2029 arm7_9
->write_xpsr(target
, value
, spsr
);
2030 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2032 ERROR("JTAG error while writing to xpsr");
2039 int handle_arm7_9_write_xpsr_im8_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2045 target_t
*target
= get_current_target(cmd_ctx
);
2046 armv4_5_common_t
*armv4_5
;
2047 arm7_9_common_t
*arm7_9
;
2049 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2051 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2055 if (target
->state
!= TARGET_HALTED
)
2057 command_print(cmd_ctx
, "can't write registers while running");
2063 command_print(cmd_ctx
, "usage: write_xpsr_im8 <im8> <rotate> <not cpsr|spsr>");
2067 value
= strtoul(args
[0], NULL
, 0);
2068 rotate
= strtol(args
[1], NULL
, 0);
2069 spsr
= strtol(args
[2], NULL
, 0);
2071 arm7_9
->write_xpsr_im8(target
, value
, rotate
, spsr
);
2072 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2074 ERROR("JTAG error while writing 8-bit immediate to xpsr");
2081 int handle_arm7_9_write_core_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2086 target_t
*target
= get_current_target(cmd_ctx
);
2087 armv4_5_common_t
*armv4_5
;
2088 arm7_9_common_t
*arm7_9
;
2090 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2092 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2096 if (target
->state
!= TARGET_HALTED
)
2098 command_print(cmd_ctx
, "can't write registers while running");
2104 command_print(cmd_ctx
, "usage: write_core_reg <num> <mode> <value>");
2108 num
= strtol(args
[0], NULL
, 0);
2109 mode
= strtoul(args
[1], NULL
, 0);
2110 value
= strtoul(args
[2], NULL
, 0);
2112 arm7_9_write_core_reg(target
, num
, mode
, value
);
2117 int handle_arm7_9_sw_bkpts_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2119 target_t
*target
= get_current_target(cmd_ctx
);
2120 armv4_5_common_t
*armv4_5
;
2121 arm7_9_common_t
*arm7_9
;
2123 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2125 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2131 command_print(cmd_ctx
, "software breakpoints %s", (arm7_9
->sw_bkpts_enabled
) ? "enabled" : "disabled");
2135 if (strcmp("enable", args
[0]) == 0)
2137 if (arm7_9
->sw_bkpts_use_wp
)
2139 arm7_9_enable_sw_bkpts(target
);
2143 arm7_9
->sw_bkpts_enabled
= 1;
2146 else if (strcmp("disable", args
[0]) == 0)
2148 if (arm7_9
->sw_bkpts_use_wp
)
2150 arm7_9_disable_sw_bkpts(target
);
2154 arm7_9
->sw_bkpts_enabled
= 0;
2159 command_print(cmd_ctx
, "usage: arm7_9 sw_bkpts <enable|disable>");
2162 command_print(cmd_ctx
, "software breakpoints %s", (arm7_9
->sw_bkpts_enabled
) ? "enabled" : "disabled");
2167 int handle_arm7_9_force_hw_bkpts_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2169 target_t
*target
= get_current_target(cmd_ctx
);
2170 armv4_5_common_t
*armv4_5
;
2171 arm7_9_common_t
*arm7_9
;
2173 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2175 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2179 if ((argc
>= 1) && (strcmp("enable", args
[0]) == 0))
2181 arm7_9
->force_hw_bkpts
= 1;
2182 if (arm7_9
->sw_bkpts_use_wp
)
2184 arm7_9_disable_sw_bkpts(target
);
2187 else if ((argc
>= 1) && (strcmp("disable", args
[0]) == 0))
2189 arm7_9
->force_hw_bkpts
= 0;
2193 command_print(cmd_ctx
, "usage: arm7_9 force_hw_bkpts <enable|disable>");
2196 command_print(cmd_ctx
, "force hardware breakpoints %s", (arm7_9
->force_hw_bkpts
) ? "enabled" : "disabled");
2201 int handle_arm7_9_dbgrq_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2203 target_t
*target
= get_current_target(cmd_ctx
);
2204 armv4_5_common_t
*armv4_5
;
2205 arm7_9_common_t
*arm7_9
;
2207 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2209 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2215 if (strcmp("enable", args
[0]) == 0)
2217 arm7_9
->use_dbgrq
= 1;
2219 else if (strcmp("disable", args
[0]) == 0)
2221 arm7_9
->use_dbgrq
= 0;
2225 command_print(cmd_ctx
, "usage: arm7_9 dbgrq <enable|disable>");
2229 command_print(cmd_ctx
, "use of EmbeddedICE dbgrq instead of breakpoint for target halt %s", (arm7_9
->use_dbgrq
) ? "enabled" : "disabled");
2234 int handle_arm7_9_fast_writes_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2236 target_t
*target
= get_current_target(cmd_ctx
);
2237 armv4_5_common_t
*armv4_5
;
2238 arm7_9_common_t
*arm7_9
;
2240 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2242 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2248 if (strcmp("enable", args
[0]) == 0)
2250 arm7_9
->fast_memory_writes
= 1;
2252 else if (strcmp("disable", args
[0]) == 0)
2254 arm7_9
->fast_memory_writes
= 0;
2258 command_print(cmd_ctx
, "usage: arm7_9 fast_writes <enable|disable>");
2262 command_print(cmd_ctx
, "fast memory writes are %s", (arm7_9
->fast_memory_writes
) ? "enabled" : "disabled");
2267 int handle_arm7_9_dcc_downloads_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2269 target_t
*target
= get_current_target(cmd_ctx
);
2270 armv4_5_common_t
*armv4_5
;
2271 arm7_9_common_t
*arm7_9
;
2273 if (arm7_9_get_arch_pointers(target
, &armv4_5
, &arm7_9
) != ERROR_OK
)
2275 command_print(cmd_ctx
, "current target isn't an ARM7/ARM9 target");
2281 if (strcmp("enable", args
[0]) == 0)
2283 arm7_9
->dcc_downloads
= 1;
2285 else if (strcmp("disable", args
[0]) == 0)
2287 arm7_9
->dcc_downloads
= 0;
2291 command_print(cmd_ctx
, "usage: arm7_9 dcc_downloads <enable|disable>");
2295 command_print(cmd_ctx
, "dcc downloads are %s", (arm7_9
->dcc_downloads
) ? "enabled" : "disabled");
2300 int arm7_9_init_arch_info(target_t
*target
, arm7_9_common_t
*arm7_9
)
2302 armv4_5_common_t
*armv4_5
= &arm7_9
->armv4_5_common
;
2304 arm7_9
->common_magic
= ARM7_9_COMMON_MAGIC
;
2306 arm_jtag_setup_connection(&arm7_9
->jtag_info
);
2307 arm7_9
->wp_available
= 2;
2308 arm7_9
->wp0_used
= 0;
2309 arm7_9
->wp1_used
= 0;
2310 arm7_9
->force_hw_bkpts
= 0;
2311 arm7_9
->use_dbgrq
= 0;
2312 arm7_9
->has_etm
= 0;
2314 arm7_9
->reinit_embeddedice
= 0;
2316 arm7_9
->dcc_working_area
= NULL
;
2318 arm7_9
->fast_memory_writes
= 0;
2319 arm7_9
->dcc_downloads
= 0;
2321 jtag_register_event_callback(arm7_9_jtag_callback
, target
);
2323 armv4_5
->arch_info
= arm7_9
;
2324 armv4_5
->read_core_reg
= arm7_9_read_core_reg
;
2325 armv4_5
->write_core_reg
= arm7_9_write_core_reg
;
2326 armv4_5
->full_context
= arm7_9_full_context
;
2328 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)