1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007-2009 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * Copyright (C) 2008 by Hongtao Zheng *
14 * Copyright (C) 2009 by David Brownell *
16 * This program is free software; you can redistribute it and/or modify *
17 * it under the terms of the GNU General Public License as published by *
18 * the Free Software Foundation; either version 2 of the License, or *
19 * (at your option) any later version. *
21 * This program is distributed in the hope that it will be useful, *
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
24 * GNU General Public License for more details. *
26 * You should have received a copy of the GNU General Public License *
27 * along with this program; if not, write to the *
28 * Free Software Foundation, Inc., *
29 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
30 ***************************************************************************/
35 #include "breakpoints.h"
36 #include "embeddedice.h"
37 #include "target_request.h"
39 #include <helper/time_support.h>
40 #include "arm_simulator.h"
41 #include "arm_semihosting.h"
42 #include "algorithm.h"
49 * Hold common code supporting the ARM7 and ARM9 core generations.
51 * While the ARM core implementations evolved substantially during these
52 * two generations, they look quite similar from the JTAG perspective.
53 * Both have similar debug facilities, based on the same two scan chains
54 * providing access to the core and to an EmbeddedICE module. Both can
55 * support similar ETM and ETB modules, for tracing. And both expose
56 * what could be viewed as "ARM Classic", with multiple processor modes,
57 * shadowed registers, and support for the Thumb instruction set.
59 * Processor differences include things like presence or absence of MMU
60 * and cache, pipeline sizes, use of a modified Harvard Architecure
61 * (with separate instruction and data busses from the CPU), support
62 * for cpu clock gating during idle, and more.
65 static int arm7_9_debug_entry(struct target
*target
);
68 * Clear watchpoints for an ARM7/9 target.
70 * @param arm7_9 Pointer to the common struct for an ARM7/9 target
71 * @return JTAG error status after executing queue
73 static int arm7_9_clear_watchpoints(struct arm7_9_common
*arm7_9
)
76 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
77 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
78 arm7_9
->sw_breakpoint_count
= 0;
79 arm7_9
->sw_breakpoints_added
= 0;
81 arm7_9
->wp1_used
= arm7_9
->wp1_used_default
;
82 arm7_9
->wp_available
= arm7_9
->wp_available_max
;
84 return jtag_execute_queue();
88 * Assign a watchpoint to one of the two available hardware comparators in an
89 * ARM7 or ARM9 target.
91 * @param arm7_9 Pointer to the common struct for an ARM7/9 target
92 * @param breakpoint Pointer to the breakpoint to be used as a watchpoint
94 static void arm7_9_assign_wp(struct arm7_9_common
*arm7_9
, struct breakpoint
*breakpoint
)
96 if (!arm7_9
->wp0_used
)
100 arm7_9
->wp_available
--;
102 else if (!arm7_9
->wp1_used
)
104 arm7_9
->wp1_used
= 1;
106 arm7_9
->wp_available
--;
110 LOG_ERROR("BUG: no hardware comparator available");
112 LOG_DEBUG("BPID: %d (0x%08" PRIx32
") using hw wp: %d",
113 breakpoint
->unique_id
,
119 * Setup an ARM7/9 target's embedded ICE registers for software breakpoints.
121 * @param arm7_9 Pointer to common struct for ARM7/9 targets
122 * @return Error codes if there is a problem finding a watchpoint or the result
123 * of executing the JTAG queue
125 static int arm7_9_set_software_breakpoints(struct arm7_9_common
*arm7_9
)
127 if (arm7_9
->sw_breakpoints_added
)
131 if (arm7_9
->wp_available
< 1)
133 LOG_WARNING("can't enable sw breakpoints with no watchpoint unit available");
134 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
136 arm7_9
->wp_available
--;
138 /* pick a breakpoint unit */
139 if (!arm7_9
->wp0_used
)
141 arm7_9
->sw_breakpoints_added
= 1;
142 arm7_9
->wp0_used
= 3;
143 } else if (!arm7_9
->wp1_used
)
145 arm7_9
->sw_breakpoints_added
= 2;
146 arm7_9
->wp1_used
= 3;
150 LOG_ERROR("BUG: both watchpoints used, but wp_available >= 1");
154 if (arm7_9
->sw_breakpoints_added
== 1)
156 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_VALUE
], arm7_9
->arm_bkpt
);
157 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0x0);
158 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffffu
);
159 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
160 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
162 else if (arm7_9
->sw_breakpoints_added
== 2)
164 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_VALUE
], arm7_9
->arm_bkpt
);
165 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0x0);
166 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], 0xffffffffu
);
167 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
168 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
172 LOG_ERROR("BUG: both watchpoints used, but wp_available >= 1");
175 LOG_DEBUG("SW BP using hw wp: %d",
176 arm7_9
->sw_breakpoints_added
);
178 return jtag_execute_queue();
182 * Setup the common pieces for an ARM7/9 target after reset or on startup.
184 * @param target Pointer to an ARM7/9 target to setup
185 * @return Result of clearing the watchpoints on the target
187 static int arm7_9_setup(struct target
*target
)
189 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
191 return arm7_9_clear_watchpoints(arm7_9
);
195 * Set either a hardware or software breakpoint on an ARM7/9 target. The
196 * breakpoint is set up even if it is already set. Some actions, e.g. reset,
197 * might have erased the values in Embedded ICE.
199 * @param target Pointer to the target device to set the breakpoints on
200 * @param breakpoint Pointer to the breakpoint to be set
201 * @return For hardware breakpoints, this is the result of executing the JTAG
202 * queue. For software breakpoints, this will be the status of the
203 * required memory reads and writes
205 static int arm7_9_set_breakpoint(struct target
*target
, struct breakpoint
*breakpoint
)
207 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
208 int retval
= ERROR_OK
;
210 LOG_DEBUG("BPID: %d, Address: 0x%08" PRIx32
", Type: %d" ,
211 breakpoint
->unique_id
,
215 if (target
->state
!= TARGET_HALTED
)
217 LOG_WARNING("target not halted");
218 return ERROR_TARGET_NOT_HALTED
;
221 if (breakpoint
->type
== BKPT_HARD
)
223 /* either an ARM (4 byte) or Thumb (2 byte) breakpoint */
224 uint32_t mask
= (breakpoint
->length
== 4) ? 0x3u
: 0x1u
;
226 /* reassign a hw breakpoint */
227 if (breakpoint
->set
== 0)
229 arm7_9_assign_wp(arm7_9
, breakpoint
);
232 if (breakpoint
->set
== 1)
234 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_VALUE
], breakpoint
->address
);
235 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], mask
);
236 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffffu
);
237 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
238 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
240 else if (breakpoint
->set
== 2)
242 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], breakpoint
->address
);
243 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], mask
);
244 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0xffffffffu
);
245 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
246 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
250 LOG_ERROR("BUG: no hardware comparator available");
254 retval
= jtag_execute_queue();
256 else if (breakpoint
->type
== BKPT_SOFT
)
258 /* did we already set this breakpoint? */
262 if (breakpoint
->length
== 4)
264 uint32_t verify
= 0xffffffff;
265 /* keep the original instruction in target endianness */
266 if ((retval
= target_read_memory(target
, breakpoint
->address
, 4, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
270 /* write the breakpoint instruction in target endianness (arm7_9->arm_bkpt is host endian) */
271 if ((retval
= target_write_u32(target
, breakpoint
->address
, arm7_9
->arm_bkpt
)) != ERROR_OK
)
276 if ((retval
= target_read_u32(target
, breakpoint
->address
, &verify
)) != ERROR_OK
)
280 if (verify
!= arm7_9
->arm_bkpt
)
282 LOG_ERROR("Unable to set 32 bit software breakpoint at address %08" PRIx32
" - check that memory is read/writable", breakpoint
->address
);
288 uint16_t verify
= 0xffff;
289 /* keep the original instruction in target endianness */
290 if ((retval
= target_read_memory(target
, breakpoint
->address
, 2, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
294 /* write the breakpoint instruction in target endianness (arm7_9->thumb_bkpt is host endian) */
295 if ((retval
= target_write_u16(target
, breakpoint
->address
, arm7_9
->thumb_bkpt
)) != ERROR_OK
)
300 if ((retval
= target_read_u16(target
, breakpoint
->address
, &verify
)) != ERROR_OK
)
304 if (verify
!= arm7_9
->thumb_bkpt
)
306 LOG_ERROR("Unable to set thumb software breakpoint at address %08" PRIx32
" - check that memory is read/writable", breakpoint
->address
);
311 if ((retval
= arm7_9_set_software_breakpoints(arm7_9
)) != ERROR_OK
)
314 arm7_9
->sw_breakpoint_count
++;
323 * Unsets an existing breakpoint on an ARM7/9 target. If it is a hardware
324 * breakpoint, the watchpoint used will be freed and the Embedded ICE registers
325 * will be updated. Otherwise, the software breakpoint will be restored to its
326 * original instruction if it hasn't already been modified.
328 * @param target Pointer to ARM7/9 target to unset the breakpoint from
329 * @param breakpoint Pointer to breakpoint to be unset
330 * @return For hardware breakpoints, this is the result of executing the JTAG
331 * queue. For software breakpoints, this will be the status of the
332 * required memory reads and writes
334 static int arm7_9_unset_breakpoint(struct target
*target
, struct breakpoint
*breakpoint
)
336 int retval
= ERROR_OK
;
337 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
339 LOG_DEBUG("BPID: %d, Address: 0x%08" PRIx32
,
340 breakpoint
->unique_id
,
341 breakpoint
->address
);
343 if (!breakpoint
->set
)
345 LOG_WARNING("breakpoint not set");
349 if (breakpoint
->type
== BKPT_HARD
)
351 LOG_DEBUG("BPID: %d Releasing hw wp: %d",
352 breakpoint
->unique_id
,
354 if (breakpoint
->set
== 1)
356 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
357 arm7_9
->wp0_used
= 0;
358 arm7_9
->wp_available
++;
360 else if (breakpoint
->set
== 2)
362 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
363 arm7_9
->wp1_used
= 0;
364 arm7_9
->wp_available
++;
366 retval
= jtag_execute_queue();
371 /* restore original instruction (kept in target endianness) */
372 if (breakpoint
->length
== 4)
374 uint32_t current_instr
;
375 /* check that user program as not modified breakpoint instruction */
376 if ((retval
= target_read_memory(target
, breakpoint
->address
, 4, 1, (uint8_t*)¤t_instr
)) != ERROR_OK
)
380 current_instr
= target_buffer_get_u32(target
, (uint8_t *)¤t_instr
);
381 if (current_instr
== arm7_9
->arm_bkpt
)
382 if ((retval
= target_write_memory(target
, breakpoint
->address
, 4, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
389 uint16_t current_instr
;
390 /* check that user program as not modified breakpoint instruction */
391 if ((retval
= target_read_memory(target
, breakpoint
->address
, 2, 1, (uint8_t*)¤t_instr
)) != ERROR_OK
)
395 if (current_instr
== arm7_9
->thumb_bkpt
)
396 if ((retval
= target_write_memory(target
, breakpoint
->address
, 2, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
402 if (--arm7_9
->sw_breakpoint_count
==0)
404 /* We have removed the last sw breakpoint, clear the hw breakpoint we used to implement it */
405 if (arm7_9
->sw_breakpoints_added
== 1)
407 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0);
409 else if (arm7_9
->sw_breakpoints_added
== 2)
411 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0);
422 * Add a breakpoint to an ARM7/9 target. This makes sure that there are no
423 * dangling breakpoints and that the desired breakpoint can be added.
425 * @param target Pointer to the target ARM7/9 device to add a breakpoint to
426 * @param breakpoint Pointer to the breakpoint to be added
427 * @return An error status if there is a problem adding the breakpoint or the
428 * result of setting the breakpoint
430 int arm7_9_add_breakpoint(struct target
*target
, struct breakpoint
*breakpoint
)
432 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
434 if (arm7_9
->breakpoint_count
== 0)
436 /* make sure we don't have any dangling breakpoints. This is vital upon
437 * GDB connect/disconnect
439 arm7_9_clear_watchpoints(arm7_9
);
442 if ((breakpoint
->type
== BKPT_HARD
) && (arm7_9
->wp_available
< 1))
444 LOG_INFO("no watchpoint unit available for hardware breakpoint");
445 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
448 if ((breakpoint
->length
!= 2) && (breakpoint
->length
!= 4))
450 LOG_INFO("only breakpoints of two (Thumb) or four (ARM) bytes length supported");
451 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
454 if (breakpoint
->type
== BKPT_HARD
)
456 arm7_9_assign_wp(arm7_9
, breakpoint
);
459 arm7_9
->breakpoint_count
++;
461 return arm7_9_set_breakpoint(target
, breakpoint
);
465 * Removes a breakpoint from an ARM7/9 target. This will make sure there are no
466 * dangling breakpoints and updates available watchpoints if it is a hardware
469 * @param target Pointer to the target to have a breakpoint removed
470 * @param breakpoint Pointer to the breakpoint to be removed
471 * @return Error status if there was a problem unsetting the breakpoint or the
472 * watchpoints could not be cleared
474 int arm7_9_remove_breakpoint(struct target
*target
, struct breakpoint
*breakpoint
)
476 int retval
= ERROR_OK
;
477 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
479 if ((retval
= arm7_9_unset_breakpoint(target
, breakpoint
)) != ERROR_OK
)
484 if (breakpoint
->type
== BKPT_HARD
)
485 arm7_9
->wp_available
++;
487 arm7_9
->breakpoint_count
--;
488 if (arm7_9
->breakpoint_count
== 0)
490 /* make sure we don't have any dangling breakpoints */
491 if ((retval
= arm7_9_clear_watchpoints(arm7_9
)) != ERROR_OK
)
501 * Sets a watchpoint for an ARM7/9 target in one of the watchpoint units. It is
502 * considered a bug to call this function when there are no available watchpoint
505 * @param target Pointer to an ARM7/9 target to set a watchpoint on
506 * @param watchpoint Pointer to the watchpoint to be set
507 * @return Error status if watchpoint set fails or the result of executing the
510 static int arm7_9_set_watchpoint(struct target
*target
, struct watchpoint
*watchpoint
)
512 int retval
= ERROR_OK
;
513 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
517 mask
= watchpoint
->length
- 1;
519 if (target
->state
!= TARGET_HALTED
)
521 LOG_WARNING("target not halted");
522 return ERROR_TARGET_NOT_HALTED
;
525 if (watchpoint
->rw
== WPT_ACCESS
)
530 if (!arm7_9
->wp0_used
)
532 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_VALUE
], watchpoint
->address
);
533 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], mask
);
534 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], watchpoint
->mask
);
535 if (watchpoint
->mask
!= 0xffffffffu
)
536 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_VALUE
], watchpoint
->value
);
537 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], 0xff & ~EICE_W_CTRL_nOPC
& ~rw_mask
);
538 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
| EICE_W_CTRL_nOPC
| (watchpoint
->rw
& 1));
540 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
545 arm7_9
->wp0_used
= 2;
547 else if (!arm7_9
->wp1_used
)
549 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], watchpoint
->address
);
550 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], mask
);
551 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], watchpoint
->mask
);
552 if (watchpoint
->mask
!= 0xffffffffu
)
553 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_VALUE
], watchpoint
->value
);
554 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], 0xff & ~EICE_W_CTRL_nOPC
& ~rw_mask
);
555 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
| EICE_W_CTRL_nOPC
| (watchpoint
->rw
& 1));
557 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
562 arm7_9
->wp1_used
= 2;
566 LOG_ERROR("BUG: no hardware comparator available");
574 * Unset an existing watchpoint and clear the used watchpoint unit.
576 * @param target Pointer to the target to have the watchpoint removed
577 * @param watchpoint Pointer to the watchpoint to be removed
578 * @return Error status while trying to unset the watchpoint or the result of
579 * executing the JTAG queue
581 static int arm7_9_unset_watchpoint(struct target
*target
, struct watchpoint
*watchpoint
)
583 int retval
= ERROR_OK
;
584 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
586 if (target
->state
!= TARGET_HALTED
)
588 LOG_WARNING("target not halted");
589 return ERROR_TARGET_NOT_HALTED
;
592 if (!watchpoint
->set
)
594 LOG_WARNING("breakpoint not set");
598 if (watchpoint
->set
== 1)
600 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
601 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
605 arm7_9
->wp0_used
= 0;
607 else if (watchpoint
->set
== 2)
609 embeddedice_set_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
610 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
614 arm7_9
->wp1_used
= 0;
622 * Add a watchpoint to an ARM7/9 target. If there are no watchpoint units
623 * available, an error response is returned.
625 * @param target Pointer to the ARM7/9 target to add a watchpoint to
626 * @param watchpoint Pointer to the watchpoint to be added
627 * @return Error status while trying to add the watchpoint
629 int arm7_9_add_watchpoint(struct target
*target
, struct watchpoint
*watchpoint
)
631 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
633 if (arm7_9
->wp_available
< 1)
635 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
638 if ((watchpoint
->length
!= 1) && (watchpoint
->length
!= 2) && (watchpoint
->length
!= 4))
640 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
643 arm7_9
->wp_available
--;
649 * Remove a watchpoint from an ARM7/9 target. The watchpoint will be unset and
650 * the used watchpoint unit will be reopened.
652 * @param target Pointer to the target to remove a watchpoint from
653 * @param watchpoint Pointer to the watchpoint to be removed
654 * @return Result of trying to unset the watchpoint
656 int arm7_9_remove_watchpoint(struct target
*target
, struct watchpoint
*watchpoint
)
658 int retval
= ERROR_OK
;
659 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
663 if ((retval
= arm7_9_unset_watchpoint(target
, watchpoint
)) != ERROR_OK
)
669 arm7_9
->wp_available
++;
675 * Restarts the target by sending a RESTART instruction and moving the JTAG
676 * state to IDLE. This includes a timeout waiting for DBGACK and SYSCOMP to be
677 * asserted by the processor.
679 * @param target Pointer to target to issue commands to
680 * @return Error status if there is a timeout or a problem while executing the
683 int arm7_9_execute_sys_speed(struct target
*target
)
686 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
687 struct arm_jtag
*jtag_info
= &arm7_9
->jtag_info
;
688 struct reg
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
690 /* set RESTART instruction */
691 if (arm7_9
->need_bypass_before_restart
) {
692 arm7_9
->need_bypass_before_restart
= 0;
693 arm_jtag_set_instr(jtag_info
, 0xf, NULL
, TAP_IDLE
);
695 arm_jtag_set_instr(jtag_info
, 0x4, NULL
, TAP_IDLE
);
697 long long then
= timeval_ms();
699 while (!(timeout
= ((timeval_ms()-then
) > 1000)))
701 /* read debug status register */
702 embeddedice_read_reg(dbg_stat
);
703 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
705 if ((buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_DBGACK
, 1))
706 && (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_SYSCOMP
, 1)))
708 if (debug_level
>= 3)
718 LOG_ERROR("timeout waiting for SYSCOMP & DBGACK, last DBG_STATUS: %" PRIx32
"", buf_get_u32(dbg_stat
->value
, 0, dbg_stat
->size
));
719 return ERROR_TARGET_TIMEOUT
;
726 * Restarts the target by sending a RESTART instruction and moving the JTAG
727 * state to IDLE. This validates that DBGACK and SYSCOMP are set without
728 * waiting until they are.
730 * @param target Pointer to the target to issue commands to
731 * @return Always ERROR_OK
733 static int arm7_9_execute_fast_sys_speed(struct target
*target
)
736 static uint8_t check_value
[4], check_mask
[4];
738 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
739 struct arm_jtag
*jtag_info
= &arm7_9
->jtag_info
;
740 struct reg
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
742 /* set RESTART instruction */
743 if (arm7_9
->need_bypass_before_restart
) {
744 arm7_9
->need_bypass_before_restart
= 0;
745 arm_jtag_set_instr(jtag_info
, 0xf, NULL
, TAP_IDLE
);
747 arm_jtag_set_instr(jtag_info
, 0x4, NULL
, TAP_IDLE
);
751 /* check for DBGACK and SYSCOMP set (others don't care) */
753 /* NB! These are constants that must be available until after next jtag_execute() and
754 * we evaluate the values upon first execution in lieu of setting up these constants
755 * during early setup.
757 buf_set_u32(check_value
, 0, 32, 0x9);
758 buf_set_u32(check_mask
, 0, 32, 0x9);
762 /* read debug status register */
763 embeddedice_read_reg_w_check(dbg_stat
, check_value
, check_mask
);
769 * Get some data from the ARM7/9 target.
771 * @param target Pointer to the ARM7/9 target to read data from
772 * @param size The number of 32bit words to be read
773 * @param buffer Pointer to the buffer that will hold the data
774 * @return The result of receiving data from the Embedded ICE unit
776 int arm7_9_target_request_data(struct target
*target
, uint32_t size
, uint8_t *buffer
)
778 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
779 struct arm_jtag
*jtag_info
= &arm7_9
->jtag_info
;
781 int retval
= ERROR_OK
;
784 data
= malloc(size
* (sizeof(uint32_t)));
786 retval
= embeddedice_receive(jtag_info
, data
, size
);
788 /* return the 32-bit ints in the 8-bit array */
789 for (i
= 0; i
< size
; i
++)
791 h_u32_to_le(buffer
+ (i
* 4), data
[i
]);
800 * Handles requests to an ARM7/9 target. If debug messaging is enabled, the
801 * target is running and the DCC control register has the W bit high, this will
802 * execute the request on the target.
804 * @param priv Void pointer expected to be a struct target pointer
805 * @return ERROR_OK unless there are issues with the JTAG queue or when reading
806 * from the Embedded ICE unit
808 static int arm7_9_handle_target_request(void *priv
)
810 int retval
= ERROR_OK
;
811 struct target
*target
= priv
;
812 if (!target_was_examined(target
))
814 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
815 struct arm_jtag
*jtag_info
= &arm7_9
->jtag_info
;
816 struct reg
*dcc_control
= &arm7_9
->eice_cache
->reg_list
[EICE_COMMS_CTRL
];
818 if (!target
->dbg_msg_enabled
)
821 if (target
->state
== TARGET_RUNNING
)
823 /* read DCC control register */
824 embeddedice_read_reg(dcc_control
);
825 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
831 if (buf_get_u32(dcc_control
->value
, 1, 1) == 1)
835 if ((retval
= embeddedice_receive(jtag_info
, &request
, 1)) != ERROR_OK
)
839 if ((retval
= target_request(target
, request
)) != ERROR_OK
)
850 * Polls an ARM7/9 target for its current status. If DBGACK is set, the target
851 * is manipulated to the right halted state based on its current state. This is
855 * <tr><th > State</th><th > Action</th></tr>
856 * <tr><td > TARGET_RUNNING | TARGET_RESET</td><td > Enters debug mode. If TARGET_RESET, pc may be checked</td></tr>
857 * <tr><td > TARGET_UNKNOWN</td><td > Warning is logged</td></tr>
858 * <tr><td > TARGET_DEBUG_RUNNING</td><td > Enters debug mode</td></tr>
859 * <tr><td > TARGET_HALTED</td><td > Nothing</td></tr>
862 * If the target does not end up in the halted state, a warning is produced. If
863 * DBGACK is cleared, then the target is expected to either be running or
866 * @param target Pointer to the ARM7/9 target to poll
867 * @return ERROR_OK or an error status if a command fails
869 int arm7_9_poll(struct target
*target
)
872 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
873 struct reg
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
875 /* read debug status register */
876 embeddedice_read_reg(dbg_stat
);
877 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
882 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_DBGACK
, 1))
884 /* LOG_DEBUG("DBGACK set, dbg_state->value: 0x%x", buf_get_u32(dbg_stat->value, 0, 32));*/
885 if (target
->state
== TARGET_UNKNOWN
)
887 /* Starting OpenOCD with target in debug-halt */
888 target
->state
= TARGET_RUNNING
;
889 LOG_DEBUG("DBGACK already set during server startup.");
891 if ((target
->state
== TARGET_RUNNING
) || (target
->state
== TARGET_RESET
))
893 target
->state
= TARGET_HALTED
;
895 if ((retval
= arm7_9_debug_entry(target
)) != ERROR_OK
)
898 if (arm_semihosting(target
, &retval
) != 0)
901 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_HALTED
)) != ERROR_OK
)
906 if (target
->state
== TARGET_DEBUG_RUNNING
)
908 target
->state
= TARGET_HALTED
;
909 if ((retval
= arm7_9_debug_entry(target
)) != ERROR_OK
)
912 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_HALTED
)) != ERROR_OK
)
917 if (target
->state
!= TARGET_HALTED
)
919 LOG_WARNING("DBGACK set, but the target did not end up in the halted state %d", target
->state
);
924 if (target
->state
!= TARGET_DEBUG_RUNNING
)
925 target
->state
= TARGET_RUNNING
;
932 * Asserts the reset (SRST) on an ARM7/9 target. Some -S targets (ARM966E-S in
933 * the STR912 isn't affected, ARM926EJ-S in the LPC3180 and AT91SAM9260 is
934 * affected) completely stop the JTAG clock while the core is held in reset
935 * (SRST). It isn't possible to program the halt condition once reset is
936 * asserted, hence a hook that allows the target to set up its reset-halt
937 * condition is setup prior to asserting reset.
939 * @param target Pointer to an ARM7/9 target to assert reset on
940 * @return ERROR_FAIL if the JTAG device does not have SRST, otherwise ERROR_OK
942 int arm7_9_assert_reset(struct target
*target
)
944 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
945 enum reset_types jtag_reset_config
= jtag_get_reset_config();
946 bool use_event
= false;
948 LOG_DEBUG("target->state: %s",
949 target_state_name(target
));
951 if (target_has_event_action(target
, TARGET_EVENT_RESET_ASSERT
))
953 else if (!(jtag_reset_config
& RESET_HAS_SRST
)) {
954 LOG_ERROR("%s: how to reset?", target_name(target
));
958 /* At this point trst has been asserted/deasserted once. We would
959 * like to program EmbeddedICE while SRST is asserted, instead of
960 * depending on SRST to leave that module alone. However, many CPUs
961 * gate the JTAG clock while SRST is asserted; or JTAG may need
962 * clock stability guarantees (adaptive clocking might help).
964 * So we assume JTAG access during SRST is off the menu unless it's
965 * been specifically enabled.
967 bool srst_asserted
= false;
970 && !(jtag_reset_config
& RESET_SRST_PULLS_TRST
)
971 && (jtag_reset_config
& RESET_SRST_NO_GATING
))
973 jtag_add_reset(0, 1);
974 srst_asserted
= true;
977 if (target
->reset_halt
)
980 * For targets that don't support communication while SRST is
981 * asserted, we need to set up the reset vector catch first.
983 * When we use TRST+SRST and that's equivalent to a power-up
984 * reset, these settings may well be reset anyway; so setting
985 * them here won't matter.
987 if (arm7_9
->has_vector_catch
)
989 /* program vector catch register to catch reset */
990 embeddedice_write_reg(&arm7_9
->eice_cache
991 ->reg_list
[EICE_VEC_CATCH
], 0x1);
993 /* extra runtest added as issues were found with
994 * certain ARM9 cores (maybe more) - AT91SAM9260
997 jtag_add_runtest(1, TAP_IDLE
);
1001 /* program watchpoint unit to match on reset vector
1004 embeddedice_write_reg(&arm7_9
->eice_cache
1005 ->reg_list
[EICE_W0_ADDR_VALUE
], 0x0);
1006 embeddedice_write_reg(&arm7_9
->eice_cache
1007 ->reg_list
[EICE_W0_ADDR_MASK
], 0x3);
1008 embeddedice_write_reg(&arm7_9
->eice_cache
1009 ->reg_list
[EICE_W0_DATA_MASK
],
1011 embeddedice_write_reg(&arm7_9
->eice_cache
1012 ->reg_list
[EICE_W0_CONTROL_VALUE
],
1013 EICE_W_CTRL_ENABLE
);
1014 embeddedice_write_reg(&arm7_9
->eice_cache
1015 ->reg_list
[EICE_W0_CONTROL_MASK
],
1016 ~EICE_W_CTRL_nOPC
& 0xff);
1021 target_handle_event(target
, TARGET_EVENT_RESET_ASSERT
);
1023 /* If we use SRST ... we'd like to issue just SRST, but the
1024 * board or chip may be set up so we have to assert TRST as
1025 * well. On some chips that combination is equivalent to a
1026 * power-up reset, and generally clobbers EICE state.
1028 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
1029 jtag_add_reset(1, 1);
1030 else if (!srst_asserted
)
1031 jtag_add_reset(0, 1);
1032 jtag_add_sleep(50000);
1035 target
->state
= TARGET_RESET
;
1036 register_cache_invalidate(arm7_9
->armv4_5_common
.core_cache
);
1038 /* REVISIT why isn't standard debug entry logic sufficient?? */
1039 if (target
->reset_halt
1040 && (!(jtag_reset_config
& RESET_SRST_PULLS_TRST
)
1043 /* debug entry was prepared above */
1044 target
->debug_reason
= DBG_REASON_DBGRQ
;
1051 * Deassert the reset (SRST) signal on an ARM7/9 target. If SRST pulls TRST
1052 * and the target is being reset into a halt, a warning will be triggered
1053 * because it is not possible to reset into a halted mode in this case. The
1054 * target is halted using the target's functions.
1056 * @param target Pointer to the target to have the reset deasserted
1057 * @return ERROR_OK or an error from polling or halting the target
1059 int arm7_9_deassert_reset(struct target
*target
)
1061 int retval
= ERROR_OK
;
1062 LOG_DEBUG("target->state: %s",
1063 target_state_name(target
));
1065 /* deassert reset lines */
1066 jtag_add_reset(0, 0);
1068 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1069 if (target
->reset_halt
&& (jtag_reset_config
& RESET_SRST_PULLS_TRST
) != 0)
1071 LOG_WARNING("srst pulls trst - can not reset into halted mode. Issuing halt after reset.");
1072 /* set up embedded ice registers again */
1073 if ((retval
= target_examine_one(target
)) != ERROR_OK
)
1076 if ((retval
= target_poll(target
)) != ERROR_OK
)
1081 if ((retval
= target_halt(target
)) != ERROR_OK
)
1091 * Clears the halt condition for an ARM7/9 target. If it isn't coming out of
1092 * reset and if DBGRQ is used, it is progammed to be deasserted. If the reset
1093 * vector catch was used, it is restored. Otherwise, the control value is
1094 * restored and the watchpoint unit is restored if it was in use.
1096 * @param target Pointer to the ARM7/9 target to have halt cleared
1097 * @return Always ERROR_OK
1099 static int arm7_9_clear_halt(struct target
*target
)
1101 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
1102 struct reg
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1104 /* we used DBGRQ only if we didn't come out of reset */
1105 if (!arm7_9
->debug_entry_from_reset
&& arm7_9
->use_dbgrq
)
1107 /* program EmbeddedICE Debug Control Register to deassert DBGRQ
1109 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 0);
1110 embeddedice_store_reg(dbg_ctrl
);
1114 if (arm7_9
->debug_entry_from_reset
&& arm7_9
->has_vector_catch
)
1116 /* if we came out of reset, and vector catch is supported, we used
1117 * vector catch to enter debug state
1118 * restore the register in that case
1120 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_VEC_CATCH
]);
1124 /* restore registers if watchpoint unit 0 was in use
1126 if (arm7_9
->wp0_used
)
1128 if (arm7_9
->debug_entry_from_reset
)
1130 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_VALUE
]);
1132 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
]);
1133 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
]);
1134 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
]);
1136 /* control value always has to be restored, as it was either disabled,
1137 * or enabled with possibly different bits
1139 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
]);
1147 * Issue a software reset and halt to an ARM7/9 target. The target is halted
1148 * and then there is a wait until the processor shows the halt. This wait can
1149 * timeout and results in an error being returned. The software reset involves
1150 * clearing the halt, updating the debug control register, changing to ARM mode,
1151 * reset of the program counter, and reset of all of the registers.
1153 * @param target Pointer to the ARM7/9 target to be reset and halted by software
1154 * @return Error status if any of the commands fail, otherwise ERROR_OK
1156 int arm7_9_soft_reset_halt(struct target
*target
)
1158 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
1159 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
1160 struct reg
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
1161 struct reg
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1165 /* FIX!!! replace some of this code with tcl commands
1167 * halt # the halt command is synchronous
1168 * armv4_5 core_state arm
1172 if ((retval
= target_halt(target
)) != ERROR_OK
)
1175 long long then
= timeval_ms();
1177 while (!(timeout
= ((timeval_ms()-then
) > 1000)))
1179 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_DBGACK
, 1) != 0)
1181 embeddedice_read_reg(dbg_stat
);
1182 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1184 if (debug_level
>= 3)
1194 LOG_ERROR("Failed to halt CPU after 1 sec");
1195 return ERROR_TARGET_TIMEOUT
;
1197 target
->state
= TARGET_HALTED
;
1199 /* program EmbeddedICE Debug Control Register to assert DBGACK and INTDIS
1200 * ensure that DBGRQ is cleared
1202 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 1);
1203 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 0);
1204 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_INTDIS
, 1, 1);
1205 embeddedice_store_reg(dbg_ctrl
);
1207 if ((retval
= arm7_9_clear_halt(target
)) != ERROR_OK
)
1212 /* if the target is in Thumb state, change to ARM state */
1213 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_ITBIT
, 1))
1215 uint32_t r0_thumb
, pc_thumb
;
1216 LOG_DEBUG("target entered debug from Thumb state, changing to ARM");
1217 /* Entered debug from Thumb mode */
1218 armv4_5
->core_state
= ARM_STATE_THUMB
;
1219 arm7_9
->change_to_arm(target
, &r0_thumb
, &pc_thumb
);
1222 /* REVISIT likewise for bit 5 -- switch Jazelle-to-ARM */
1224 /* all register content is now invalid */
1225 register_cache_invalidate(armv4_5
->core_cache
);
1227 /* SVC, ARM state, IRQ and FIQ disabled */
1230 cpsr
= buf_get_u32(armv4_5
->cpsr
->value
, 0, 32);
1233 arm_set_cpsr(armv4_5
, cpsr
);
1234 armv4_5
->cpsr
->dirty
= 1;
1236 /* start fetching from 0x0 */
1237 buf_set_u32(armv4_5
->pc
->value
, 0, 32, 0x0);
1238 armv4_5
->pc
->dirty
= 1;
1239 armv4_5
->pc
->valid
= 1;
1241 /* reset registers */
1242 for (i
= 0; i
<= 14; i
++)
1244 struct reg
*r
= arm_reg_current(armv4_5
, i
);
1246 buf_set_u32(r
->value
, 0, 32, 0xffffffff);
1251 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_HALTED
)) != ERROR_OK
)
1260 * Halt an ARM7/9 target. This is accomplished by either asserting the DBGRQ
1261 * line or by programming a watchpoint to trigger on any address. It is
1262 * considered a bug to call this function while the target is in the
1263 * TARGET_RESET state.
1265 * @param target Pointer to the ARM7/9 target to be halted
1266 * @return Always ERROR_OK
1268 int arm7_9_halt(struct target
*target
)
1270 if (target
->state
== TARGET_RESET
)
1272 LOG_ERROR("BUG: arm7/9 does not support halt during reset. This is handled in arm7_9_assert_reset()");
1276 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
1277 struct reg
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1279 LOG_DEBUG("target->state: %s",
1280 target_state_name(target
));
1282 if (target
->state
== TARGET_HALTED
)
1284 LOG_DEBUG("target was already halted");
1288 if (target
->state
== TARGET_UNKNOWN
)
1290 LOG_WARNING("target was in unknown state when halt was requested");
1293 if (arm7_9
->use_dbgrq
)
1295 /* program EmbeddedICE Debug Control Register to assert DBGRQ
1297 if (arm7_9
->set_special_dbgrq
) {
1298 arm7_9
->set_special_dbgrq(target
);
1300 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 1);
1301 embeddedice_store_reg(dbg_ctrl
);
1306 /* program watchpoint unit to match on any address
1308 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffff);
1309 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffff);
1310 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
1311 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
1314 target
->debug_reason
= DBG_REASON_DBGRQ
;
1320 * Handle an ARM7/9 target's entry into debug mode. The halt is cleared on the
1321 * ARM. The JTAG queue is then executed and the reason for debug entry is
1322 * examined. Once done, the target is verified to be halted and the processor
1323 * is forced into ARM mode. The core registers are saved for the current core
1324 * mode and the program counter (register 15) is updated as needed. The core
1325 * registers and CPSR and SPSR are saved for restoration later.
1327 * @param target Pointer to target that is entering debug mode
1328 * @return Error code if anything fails, otherwise ERROR_OK
1330 static int arm7_9_debug_entry(struct target
*target
)
1333 uint32_t context
[16];
1334 uint32_t* context_p
[16];
1335 uint32_t r0_thumb
, pc_thumb
;
1336 uint32_t cpsr
, cpsr_mask
= 0;
1338 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
1339 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
1340 struct reg
*dbg_stat
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_STAT
];
1341 struct reg
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1343 #ifdef _DEBUG_ARM7_9_
1347 /* program EmbeddedICE Debug Control Register to assert DBGACK and INTDIS
1348 * ensure that DBGRQ is cleared
1350 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 1);
1351 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGRQ
, 1, 0);
1352 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_INTDIS
, 1, 1);
1353 embeddedice_store_reg(dbg_ctrl
);
1355 if ((retval
= arm7_9_clear_halt(target
)) != ERROR_OK
)
1360 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1365 if ((retval
= arm7_9
->examine_debug_reason(target
)) != ERROR_OK
)
1369 if (target
->state
!= TARGET_HALTED
)
1371 LOG_WARNING("target not halted");
1372 return ERROR_TARGET_NOT_HALTED
;
1375 /* if the target is in Thumb state, change to ARM state */
1376 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_ITBIT
, 1))
1378 LOG_DEBUG("target entered debug from Thumb state");
1379 /* Entered debug from Thumb mode */
1380 armv4_5
->core_state
= ARM_STATE_THUMB
;
1382 arm7_9
->change_to_arm(target
, &r0_thumb
, &pc_thumb
);
1383 LOG_DEBUG("r0_thumb: 0x%8.8" PRIx32
1384 ", pc_thumb: 0x%8.8" PRIx32
, r0_thumb
, pc_thumb
);
1385 } else if (buf_get_u32(dbg_stat
->value
, 5, 1)) {
1386 /* \todo Get some vaguely correct handling of Jazelle, if
1387 * anyone ever uses it and full info becomes available.
1388 * See ARM9EJS TRM B.7.1 for how to switch J->ARM; and
1389 * B.7.3 for the reverse. That'd be the bare minimum...
1391 LOG_DEBUG("target entered debug from Jazelle state");
1392 armv4_5
->core_state
= ARM_STATE_JAZELLE
;
1393 cpsr_mask
= 1 << 24;
1394 LOG_ERROR("Jazelle debug entry -- BROKEN!");
1396 LOG_DEBUG("target entered debug from ARM state");
1397 /* Entered debug from ARM mode */
1398 armv4_5
->core_state
= ARM_STATE_ARM
;
1401 for (i
= 0; i
< 16; i
++)
1402 context_p
[i
] = &context
[i
];
1403 /* save core registers (r0 - r15 of current core mode) */
1404 arm7_9
->read_core_regs(target
, 0xffff, context_p
);
1406 arm7_9
->read_xpsr(target
, &cpsr
, 0);
1408 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1411 /* Sync our CPSR copy with J or T bits EICE reported, but
1412 * which we then erased by putting the core into ARM mode.
1414 arm_set_cpsr(armv4_5
, cpsr
| cpsr_mask
);
1416 if (!is_arm_mode(armv4_5
->core_mode
))
1418 target
->state
= TARGET_UNKNOWN
;
1419 LOG_ERROR("cpsr contains invalid mode value - communication failure");
1420 return ERROR_TARGET_FAILURE
;
1423 LOG_DEBUG("target entered debug state in %s mode",
1424 arm_mode_name(armv4_5
->core_mode
));
1426 if (armv4_5
->core_state
== ARM_STATE_THUMB
)
1428 LOG_DEBUG("thumb state, applying fixups");
1429 context
[0] = r0_thumb
;
1430 context
[15] = pc_thumb
;
1431 } else if (armv4_5
->core_state
== ARM_STATE_ARM
)
1433 /* adjust value stored by STM */
1434 context
[15] -= 3 * 4;
1437 if ((target
->debug_reason
!= DBG_REASON_DBGRQ
) || (!arm7_9
->use_dbgrq
))
1438 context
[15] -= 3 * ((armv4_5
->core_state
== ARM_STATE_ARM
) ? 4 : 2);
1440 context
[15] -= arm7_9
->dbgreq_adjust_pc
* ((armv4_5
->core_state
== ARM_STATE_ARM
) ? 4 : 2);
1442 for (i
= 0; i
<= 15; i
++)
1444 struct reg
*r
= arm_reg_current(armv4_5
, i
);
1446 LOG_DEBUG("r%i: 0x%8.8" PRIx32
"", i
, context
[i
]);
1448 buf_set_u32(r
->value
, 0, 32, context
[i
]);
1449 /* r0 and r15 (pc) have to be restored later */
1450 r
->dirty
= (i
== 0) || (i
== 15);
1454 LOG_DEBUG("entered debug state at PC 0x%" PRIx32
"", context
[15]);
1456 /* exceptions other than USR & SYS have a saved program status register */
1457 if (armv4_5
->spsr
) {
1459 arm7_9
->read_xpsr(target
, &spsr
, 1);
1460 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1464 buf_set_u32(armv4_5
->spsr
->value
, 0, 32, spsr
);
1465 armv4_5
->spsr
->dirty
= 0;
1466 armv4_5
->spsr
->valid
= 1;
1469 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1472 if (arm7_9
->post_debug_entry
)
1474 retval
= arm7_9
->post_debug_entry(target
);
1475 if (retval
!= ERROR_OK
)
1483 * Validate the full context for an ARM7/9 target in all processor modes. If
1484 * there are any invalid registers for the target, they will all be read. This
1487 * @param target Pointer to the ARM7/9 target to capture the full context from
1488 * @return Error if the target is not halted, has an invalid core mode, or if
1489 * the JTAG queue fails to execute
1491 static int arm7_9_full_context(struct target
*target
)
1495 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
1496 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
1500 if (target
->state
!= TARGET_HALTED
)
1502 LOG_WARNING("target not halted");
1503 return ERROR_TARGET_NOT_HALTED
;
1506 if (!is_arm_mode(armv4_5
->core_mode
))
1509 /* iterate through processor modes (User, FIQ, IRQ, SVC, ABT, UND)
1510 * SYS shares registers with User, so we don't touch SYS
1512 for (i
= 0; i
< 6; i
++)
1515 uint32_t* reg_p
[16];
1519 /* check if there are invalid registers in the current mode
1521 for (j
= 0; j
<= 16; j
++)
1523 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
== 0)
1531 /* change processor mode (and mask T bit) */
1532 tmp_cpsr
= buf_get_u32(armv4_5
->cpsr
->value
, 0, 8)
1534 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1536 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1538 for (j
= 0; j
< 15; j
++)
1540 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
== 0)
1542 reg_p
[j
] = (uint32_t*)ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).value
;
1544 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
= 1;
1545 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).dirty
= 0;
1549 /* if only the PSR is invalid, mask is all zeroes */
1551 arm7_9
->read_core_regs(target
, mask
, reg_p
);
1553 /* check if the PSR has to be read */
1554 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).valid
== 0)
1556 arm7_9
->read_xpsr(target
, (uint32_t*)ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).value
, 1);
1557 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).valid
= 1;
1558 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).dirty
= 0;
1563 /* restore processor mode (mask T bit) */
1564 arm7_9
->write_xpsr_im8(target
,
1565 buf_get_u32(armv4_5
->cpsr
->value
, 0, 8) & ~0x20,
1568 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1576 * Restore the processor context on an ARM7/9 target. The full processor
1577 * context is analyzed to see if any of the registers are dirty on this end, but
1578 * have a valid new value. If this is the case, the processor is changed to the
1579 * appropriate mode and the new register values are written out to the
1580 * processor. If there happens to be a dirty register with an invalid value, an
1581 * error will be logged.
1583 * @param target Pointer to the ARM7/9 target to have its context restored
1584 * @return Error status if the target is not halted or the core mode in the
1585 * armv4_5 struct is invalid.
1587 static int arm7_9_restore_context(struct target
*target
)
1589 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
1590 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
1592 struct arm_reg
*reg_arch_info
;
1593 enum arm_mode current_mode
= armv4_5
->core_mode
;
1600 if (target
->state
!= TARGET_HALTED
)
1602 LOG_WARNING("target not halted");
1603 return ERROR_TARGET_NOT_HALTED
;
1606 if (arm7_9
->pre_restore_context
)
1607 arm7_9
->pre_restore_context(target
);
1609 if (!is_arm_mode(armv4_5
->core_mode
))
1612 /* iterate through processor modes (User, FIQ, IRQ, SVC, ABT, UND)
1613 * SYS shares registers with User, so we don't touch SYS
1615 for (i
= 0; i
< 6; i
++)
1617 LOG_DEBUG("examining %s mode",
1618 arm_mode_name(armv4_5
->core_mode
));
1621 /* check if there are dirty registers in the current mode
1623 for (j
= 0; j
<= 16; j
++)
1625 reg
= &ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
);
1626 reg_arch_info
= reg
->arch_info
;
1627 if (reg
->dirty
== 1)
1629 if (reg
->valid
== 1)
1632 LOG_DEBUG("examining dirty reg: %s", reg
->name
);
1633 if ((reg_arch_info
->mode
!= ARM_MODE_ANY
)
1634 && (reg_arch_info
->mode
!= current_mode
)
1635 && !((reg_arch_info
->mode
== ARM_MODE_USR
) && (armv4_5
->core_mode
== ARM_MODE_SYS
))
1636 && !((reg_arch_info
->mode
== ARM_MODE_SYS
) && (armv4_5
->core_mode
== ARM_MODE_USR
)))
1639 LOG_DEBUG("require mode change");
1644 LOG_ERROR("BUG: dirty register '%s', but no valid data", reg
->name
);
1651 uint32_t mask
= 0x0;
1659 /* change processor mode (mask T bit) */
1660 tmp_cpsr
= buf_get_u32(armv4_5
->cpsr
->value
,
1662 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1664 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1665 current_mode
= armv4_5_number_to_mode(i
);
1668 for (j
= 0; j
<= 14; j
++)
1670 reg
= &ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
);
1671 reg_arch_info
= reg
->arch_info
;
1674 if (reg
->dirty
== 1)
1676 regs
[j
] = buf_get_u32(reg
->value
, 0, 32);
1681 LOG_DEBUG("writing register %i mode %s "
1682 "with value 0x%8.8" PRIx32
, j
,
1683 arm_mode_name(armv4_5
->core_mode
),
1690 arm7_9
->write_core_regs(target
, mask
, regs
);
1693 reg
= &ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16);
1694 reg_arch_info
= reg
->arch_info
;
1695 if ((reg
->dirty
) && (reg_arch_info
->mode
!= ARM_MODE_ANY
))
1697 LOG_DEBUG("writing SPSR of mode %i with value 0x%8.8" PRIx32
"", i
, buf_get_u32(reg
->value
, 0, 32));
1698 arm7_9
->write_xpsr(target
, buf_get_u32(reg
->value
, 0, 32), 1);
1703 if (!armv4_5
->cpsr
->dirty
&& (armv4_5
->core_mode
!= current_mode
))
1705 /* restore processor mode (mask T bit) */
1708 tmp_cpsr
= buf_get_u32(armv4_5
->cpsr
->value
, 0, 8) & 0xE0;
1709 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1711 LOG_DEBUG("writing lower 8 bit of cpsr with value 0x%2.2x", (unsigned)(tmp_cpsr
));
1712 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
1714 else if (armv4_5
->cpsr
->dirty
)
1716 /* CPSR has been changed, full restore necessary (mask T bit) */
1717 LOG_DEBUG("writing cpsr with value 0x%8.8" PRIx32
,
1718 buf_get_u32(armv4_5
->cpsr
->value
, 0, 32));
1719 arm7_9
->write_xpsr(target
,
1720 buf_get_u32(armv4_5
->cpsr
->value
, 0, 32)
1722 armv4_5
->cpsr
->dirty
= 0;
1723 armv4_5
->cpsr
->valid
= 1;
1727 LOG_DEBUG("writing PC with value 0x%8.8" PRIx32
,
1728 buf_get_u32(armv4_5
->pc
->value
, 0, 32));
1729 arm7_9
->write_pc(target
, buf_get_u32(armv4_5
->pc
->value
, 0, 32));
1730 armv4_5
->pc
->dirty
= 0;
1736 * Restart the core of an ARM7/9 target. A RESTART command is sent to the
1737 * instruction register and the JTAG state is set to TAP_IDLE causing a core
1740 * @param target Pointer to the ARM7/9 target to be restarted
1741 * @return Result of executing the JTAG queue
1743 static int arm7_9_restart_core(struct target
*target
)
1745 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
1746 struct arm_jtag
*jtag_info
= &arm7_9
->jtag_info
;
1748 /* set RESTART instruction */
1749 if (arm7_9
->need_bypass_before_restart
) {
1750 arm7_9
->need_bypass_before_restart
= 0;
1751 arm_jtag_set_instr(jtag_info
, 0xf, NULL
, TAP_IDLE
);
1753 arm_jtag_set_instr(jtag_info
, 0x4, NULL
, TAP_IDLE
);
1755 jtag_add_runtest(1, TAP_IDLE
);
1756 return jtag_execute_queue();
1760 * Enable the watchpoints on an ARM7/9 target. The target's watchpoints are
1761 * iterated through and are set on the target if they aren't already set.
1763 * @param target Pointer to the ARM7/9 target to enable watchpoints on
1765 static void arm7_9_enable_watchpoints(struct target
*target
)
1767 struct watchpoint
*watchpoint
= target
->watchpoints
;
1771 if (watchpoint
->set
== 0)
1772 arm7_9_set_watchpoint(target
, watchpoint
);
1773 watchpoint
= watchpoint
->next
;
1778 * Enable the breakpoints on an ARM7/9 target. The target's breakpoints are
1779 * iterated through and are set on the target.
1781 * @param target Pointer to the ARM7/9 target to enable breakpoints on
1783 static void arm7_9_enable_breakpoints(struct target
*target
)
1785 struct breakpoint
*breakpoint
= target
->breakpoints
;
1787 /* set any pending breakpoints */
1790 arm7_9_set_breakpoint(target
, breakpoint
);
1791 breakpoint
= breakpoint
->next
;
1795 int arm7_9_resume(struct target
*target
, int current
, uint32_t address
, int handle_breakpoints
, int debug_execution
)
1797 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
1798 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
1799 struct breakpoint
*breakpoint
= target
->breakpoints
;
1800 struct reg
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
1801 int err
, retval
= ERROR_OK
;
1805 if (target
->state
!= TARGET_HALTED
)
1807 LOG_WARNING("target not halted");
1808 return ERROR_TARGET_NOT_HALTED
;
1811 if (!debug_execution
)
1813 target_free_all_working_areas(target
);
1816 /* current = 1: continue on current pc, otherwise continue at <address> */
1818 buf_set_u32(armv4_5
->pc
->value
, 0, 32, address
);
1820 uint32_t current_pc
;
1821 current_pc
= buf_get_u32(armv4_5
->pc
->value
, 0, 32);
1823 /* the front-end may request us not to handle breakpoints */
1824 if (handle_breakpoints
)
1826 breakpoint
= breakpoint_find(target
,
1827 buf_get_u32(armv4_5
->pc
->value
, 0, 32));
1828 if (breakpoint
!= NULL
)
1830 LOG_DEBUG("unset breakpoint at 0x%8.8" PRIx32
" (id: %d)", breakpoint
->address
, breakpoint
->unique_id
);
1831 if ((retval
= arm7_9_unset_breakpoint(target
, breakpoint
)) != ERROR_OK
)
1836 /* calculate PC of next instruction */
1838 if ((retval
= arm_simulate_step(target
, &next_pc
)) != ERROR_OK
)
1840 uint32_t current_opcode
;
1841 target_read_u32(target
, current_pc
, ¤t_opcode
);
1842 LOG_ERROR("Couldn't calculate PC of next instruction, current opcode was 0x%8.8" PRIx32
"", current_opcode
);
1846 LOG_DEBUG("enable single-step");
1847 arm7_9
->enable_single_step(target
, next_pc
);
1849 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
1851 if ((retval
= arm7_9_restore_context(target
)) != ERROR_OK
)
1856 if (armv4_5
->core_state
== ARM_STATE_ARM
)
1857 arm7_9
->branch_resume(target
);
1858 else if (armv4_5
->core_state
== ARM_STATE_THUMB
)
1860 arm7_9
->branch_resume_thumb(target
);
1864 LOG_ERROR("unhandled core state");
1868 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 0);
1869 embeddedice_write_reg(dbg_ctrl
, buf_get_u32(dbg_ctrl
->value
, 0, dbg_ctrl
->size
));
1870 err
= arm7_9_execute_sys_speed(target
);
1872 LOG_DEBUG("disable single-step");
1873 arm7_9
->disable_single_step(target
);
1875 if (err
!= ERROR_OK
)
1877 if ((retval
= arm7_9_set_breakpoint(target
, breakpoint
)) != ERROR_OK
)
1881 target
->state
= TARGET_UNKNOWN
;
1885 retval
= arm7_9_debug_entry(target
);
1886 if (retval
!= ERROR_OK
)
1888 LOG_DEBUG("new PC after step: 0x%8.8" PRIx32
,
1889 buf_get_u32(armv4_5
->pc
->value
, 0, 32));
1891 LOG_DEBUG("set breakpoint at 0x%8.8" PRIx32
"", breakpoint
->address
);
1892 if ((retval
= arm7_9_set_breakpoint(target
, breakpoint
)) != ERROR_OK
)
1899 /* enable any pending breakpoints and watchpoints */
1900 arm7_9_enable_breakpoints(target
);
1901 arm7_9_enable_watchpoints(target
);
1903 if ((retval
= arm7_9_restore_context(target
)) != ERROR_OK
)
1908 if (armv4_5
->core_state
== ARM_STATE_ARM
)
1910 arm7_9
->branch_resume(target
);
1912 else if (armv4_5
->core_state
== ARM_STATE_THUMB
)
1914 arm7_9
->branch_resume_thumb(target
);
1918 LOG_ERROR("unhandled core state");
1922 /* deassert DBGACK and INTDIS */
1923 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 0);
1924 /* INTDIS only when we really resume, not during debug execution */
1925 if (!debug_execution
)
1926 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_INTDIS
, 1, 0);
1927 embeddedice_write_reg(dbg_ctrl
, buf_get_u32(dbg_ctrl
->value
, 0, dbg_ctrl
->size
));
1929 if ((retval
= arm7_9_restart_core(target
)) != ERROR_OK
)
1934 target
->debug_reason
= DBG_REASON_NOTHALTED
;
1936 if (!debug_execution
)
1938 /* registers are now invalid */
1939 register_cache_invalidate(armv4_5
->core_cache
);
1940 target
->state
= TARGET_RUNNING
;
1941 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
)) != ERROR_OK
)
1948 target
->state
= TARGET_DEBUG_RUNNING
;
1949 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_RESUMED
)) != ERROR_OK
)
1955 LOG_DEBUG("target resumed");
1960 void arm7_9_enable_eice_step(struct target
*target
, uint32_t next_pc
)
1962 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
1963 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
1964 uint32_t current_pc
;
1965 current_pc
= buf_get_u32(armv4_5
->pc
->value
, 0, 32);
1967 if (next_pc
!= current_pc
)
1969 /* setup an inverse breakpoint on the current PC
1970 * - comparator 1 matches the current address
1971 * - rangeout from comparator 1 is connected to comparator 0 rangein
1972 * - comparator 0 matches any address, as long as rangein is low */
1973 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffff);
1974 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffff);
1975 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
1976 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], ~(EICE_W_CTRL_RANGE
| EICE_W_CTRL_nOPC
) & 0xff);
1977 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], current_pc
);
1978 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], 0);
1979 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0xffffffff);
1980 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], 0x0);
1981 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
1985 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
], 0xffffffff);
1986 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
], 0xffffffff);
1987 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
], 0x0);
1988 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
], 0xff);
1989 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
], next_pc
);
1990 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
], 0);
1991 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
], 0xffffffff);
1992 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
], EICE_W_CTRL_ENABLE
);
1993 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
], ~EICE_W_CTRL_nOPC
& 0xff);
1997 void arm7_9_disable_eice_step(struct target
*target
)
1999 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2001 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_ADDR_MASK
]);
2002 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_DATA_MASK
]);
2003 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_VALUE
]);
2004 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W0_CONTROL_MASK
]);
2005 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_VALUE
]);
2006 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_ADDR_MASK
]);
2007 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_DATA_MASK
]);
2008 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_MASK
]);
2009 embeddedice_store_reg(&arm7_9
->eice_cache
->reg_list
[EICE_W1_CONTROL_VALUE
]);
2012 int arm7_9_step(struct target
*target
, int current
, uint32_t address
, int handle_breakpoints
)
2014 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2015 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
2016 struct breakpoint
*breakpoint
= NULL
;
2019 if (target
->state
!= TARGET_HALTED
)
2021 LOG_WARNING("target not halted");
2022 return ERROR_TARGET_NOT_HALTED
;
2025 /* current = 1: continue on current pc, otherwise continue at <address> */
2027 buf_set_u32(armv4_5
->pc
->value
, 0, 32, address
);
2029 uint32_t current_pc
= buf_get_u32(armv4_5
->pc
->value
, 0, 32);
2031 /* the front-end may request us not to handle breakpoints */
2032 if (handle_breakpoints
)
2033 breakpoint
= breakpoint_find(target
, current_pc
);
2034 if (breakpoint
!= NULL
) {
2035 retval
= arm7_9_unset_breakpoint(target
, breakpoint
);
2036 if (retval
!= ERROR_OK
)
2040 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
2042 /* calculate PC of next instruction */
2044 if ((retval
= arm_simulate_step(target
, &next_pc
)) != ERROR_OK
)
2046 uint32_t current_opcode
;
2047 target_read_u32(target
, current_pc
, ¤t_opcode
);
2048 LOG_ERROR("Couldn't calculate PC of next instruction, current opcode was 0x%8.8" PRIx32
"", current_opcode
);
2052 if ((retval
= arm7_9_restore_context(target
)) != ERROR_OK
)
2057 arm7_9
->enable_single_step(target
, next_pc
);
2059 if (armv4_5
->core_state
== ARM_STATE_ARM
)
2061 arm7_9
->branch_resume(target
);
2063 else if (armv4_5
->core_state
== ARM_STATE_THUMB
)
2065 arm7_9
->branch_resume_thumb(target
);
2069 LOG_ERROR("unhandled core state");
2073 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
)) != ERROR_OK
)
2078 err
= arm7_9_execute_sys_speed(target
);
2079 arm7_9
->disable_single_step(target
);
2081 /* registers are now invalid */
2082 register_cache_invalidate(armv4_5
->core_cache
);
2084 if (err
!= ERROR_OK
)
2086 target
->state
= TARGET_UNKNOWN
;
2088 retval
= arm7_9_debug_entry(target
);
2089 if (retval
!= ERROR_OK
)
2091 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_HALTED
)) != ERROR_OK
)
2095 LOG_DEBUG("target stepped");
2099 if ((retval
= arm7_9_set_breakpoint(target
, breakpoint
)) != ERROR_OK
)
2107 static int arm7_9_read_core_reg(struct target
*target
, struct reg
*r
,
2108 int num
, enum arm_mode mode
)
2110 uint32_t* reg_p
[16];
2113 struct arm_reg
*areg
= r
->arch_info
;
2114 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2115 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
2117 if (!is_arm_mode(armv4_5
->core_mode
))
2119 if ((num
< 0) || (num
> 16))
2120 return ERROR_INVALID_ARGUMENTS
;
2122 if ((mode
!= ARM_MODE_ANY
)
2123 && (mode
!= armv4_5
->core_mode
)
2124 && (areg
->mode
!= ARM_MODE_ANY
))
2128 /* change processor mode (mask T bit) */
2129 tmp_cpsr
= buf_get_u32(armv4_5
->cpsr
->value
, 0, 8) & 0xE0;
2132 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
2135 if ((num
>= 0) && (num
<= 15))
2137 /* read a normal core register */
2138 reg_p
[num
] = &value
;
2140 arm7_9
->read_core_regs(target
, 1 << num
, reg_p
);
2144 /* read a program status register
2145 * if the register mode is MODE_ANY, we read the cpsr, otherwise a spsr
2147 arm7_9
->read_xpsr(target
, &value
, areg
->mode
!= ARM_MODE_ANY
);
2150 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2157 buf_set_u32(r
->value
, 0, 32, value
);
2159 if ((mode
!= ARM_MODE_ANY
)
2160 && (mode
!= armv4_5
->core_mode
)
2161 && (areg
->mode
!= ARM_MODE_ANY
)) {
2162 /* restore processor mode (mask T bit) */
2163 arm7_9
->write_xpsr_im8(target
,
2164 buf_get_u32(armv4_5
->cpsr
->value
, 0, 8)
2171 static int arm7_9_write_core_reg(struct target
*target
, struct reg
*r
,
2172 int num
, enum arm_mode mode
, uint32_t value
)
2175 struct arm_reg
*areg
= r
->arch_info
;
2176 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2177 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
2179 if (!is_arm_mode(armv4_5
->core_mode
))
2181 if ((num
< 0) || (num
> 16))
2182 return ERROR_INVALID_ARGUMENTS
;
2184 if ((mode
!= ARM_MODE_ANY
)
2185 && (mode
!= armv4_5
->core_mode
)
2186 && (areg
->mode
!= ARM_MODE_ANY
)) {
2189 /* change processor mode (mask T bit) */
2190 tmp_cpsr
= buf_get_u32(armv4_5
->cpsr
->value
, 0, 8) & 0xE0;
2193 arm7_9
->write_xpsr_im8(target
, tmp_cpsr
& 0xff, 0, 0);
2196 if ((num
>= 0) && (num
<= 15))
2198 /* write a normal core register */
2201 arm7_9
->write_core_regs(target
, 1 << num
, reg
);
2205 /* write a program status register
2206 * if the register mode is MODE_ANY, we write the cpsr, otherwise a spsr
2208 int spsr
= (areg
->mode
!= ARM_MODE_ANY
);
2210 /* if we're writing the CPSR, mask the T bit */
2214 arm7_9
->write_xpsr(target
, value
, spsr
);
2220 if ((mode
!= ARM_MODE_ANY
)
2221 && (mode
!= armv4_5
->core_mode
)
2222 && (areg
->mode
!= ARM_MODE_ANY
)) {
2223 /* restore processor mode (mask T bit) */
2224 arm7_9
->write_xpsr_im8(target
,
2225 buf_get_u32(armv4_5
->cpsr
->value
, 0, 8)
2229 return jtag_execute_queue();
2232 int arm7_9_read_memory(struct target
*target
, uint32_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
)
2234 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2235 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
2237 uint32_t num_accesses
= 0;
2238 int thisrun_accesses
;
2244 LOG_DEBUG("address: 0x%8.8" PRIx32
", size: 0x%8.8" PRIx32
", count: 0x%8.8" PRIx32
"", address
, size
, count
);
2246 if (target
->state
!= TARGET_HALTED
)
2248 LOG_WARNING("target not halted");
2249 return ERROR_TARGET_NOT_HALTED
;
2252 /* sanitize arguments */
2253 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
2254 return ERROR_INVALID_ARGUMENTS
;
2256 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
2257 return ERROR_TARGET_UNALIGNED_ACCESS
;
2259 /* load the base register with the address of the first word */
2261 arm7_9
->write_core_regs(target
, 0x1, reg
);
2268 while (num_accesses
< count
)
2271 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2272 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2274 if (last_reg
<= thisrun_accesses
)
2275 last_reg
= thisrun_accesses
;
2277 arm7_9
->load_word_regs(target
, reg_list
);
2279 /* fast memory reads are only safe when the target is running
2280 * from a sufficiently high clock (32 kHz is usually too slow)
2282 if (arm7_9
->fast_memory_access
)
2283 retval
= arm7_9_execute_fast_sys_speed(target
);
2285 retval
= arm7_9_execute_sys_speed(target
);
2286 if (retval
!= ERROR_OK
)
2289 arm7_9
->read_core_regs_target_buffer(target
, reg_list
, buffer
, 4);
2291 /* advance buffer, count number of accesses */
2292 buffer
+= thisrun_accesses
* 4;
2293 num_accesses
+= thisrun_accesses
;
2295 if ((j
++%1024) == 0)
2302 while (num_accesses
< count
)
2305 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2306 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2308 for (i
= 1; i
<= thisrun_accesses
; i
++)
2312 arm7_9
->load_hword_reg(target
, i
);
2313 /* fast memory reads are only safe when the target is running
2314 * from a sufficiently high clock (32 kHz is usually too slow)
2316 if (arm7_9
->fast_memory_access
)
2317 retval
= arm7_9_execute_fast_sys_speed(target
);
2319 retval
= arm7_9_execute_sys_speed(target
);
2320 if (retval
!= ERROR_OK
)
2327 arm7_9
->read_core_regs_target_buffer(target
, reg_list
, buffer
, 2);
2329 /* advance buffer, count number of accesses */
2330 buffer
+= thisrun_accesses
* 2;
2331 num_accesses
+= thisrun_accesses
;
2333 if ((j
++%1024) == 0)
2340 while (num_accesses
< count
)
2343 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2344 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2346 for (i
= 1; i
<= thisrun_accesses
; i
++)
2350 arm7_9
->load_byte_reg(target
, i
);
2351 /* fast memory reads are only safe when the target is running
2352 * from a sufficiently high clock (32 kHz is usually too slow)
2354 if (arm7_9
->fast_memory_access
)
2355 retval
= arm7_9_execute_fast_sys_speed(target
);
2357 retval
= arm7_9_execute_sys_speed(target
);
2358 if (retval
!= ERROR_OK
)
2364 arm7_9
->read_core_regs_target_buffer(target
, reg_list
, buffer
, 1);
2366 /* advance buffer, count number of accesses */
2367 buffer
+= thisrun_accesses
* 1;
2368 num_accesses
+= thisrun_accesses
;
2370 if ((j
++%1024) == 0)
2378 if (!is_arm_mode(armv4_5
->core_mode
))
2381 for (i
= 0; i
<= last_reg
; i
++) {
2382 struct reg
*r
= arm_reg_current(armv4_5
, i
);
2384 r
->dirty
= r
->valid
;
2387 arm7_9
->read_xpsr(target
, &cpsr
, 0);
2388 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2390 LOG_ERROR("JTAG error while reading cpsr");
2391 return ERROR_TARGET_DATA_ABORT
;
2394 if (((cpsr
& 0x1f) == ARM_MODE_ABT
) && (armv4_5
->core_mode
!= ARM_MODE_ABT
))
2396 LOG_WARNING("memory read caused data abort (address: 0x%8.8" PRIx32
", size: 0x%" PRIx32
", count: 0x%" PRIx32
")", address
, size
, count
);
2398 arm7_9
->write_xpsr_im8(target
,
2399 buf_get_u32(armv4_5
->cpsr
->value
, 0, 8)
2402 return ERROR_TARGET_DATA_ABORT
;
2408 int arm7_9_write_memory(struct target
*target
, uint32_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
)
2410 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2411 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
2412 struct reg
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
2415 uint32_t num_accesses
= 0;
2416 int thisrun_accesses
;
2422 #ifdef _DEBUG_ARM7_9_
2423 LOG_DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address
, size
, count
);
2426 if (target
->state
!= TARGET_HALTED
)
2428 LOG_WARNING("target not halted");
2429 return ERROR_TARGET_NOT_HALTED
;
2432 /* sanitize arguments */
2433 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
2434 return ERROR_INVALID_ARGUMENTS
;
2436 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
2437 return ERROR_TARGET_UNALIGNED_ACCESS
;
2439 /* load the base register with the address of the first word */
2441 arm7_9
->write_core_regs(target
, 0x1, reg
);
2443 /* Clear DBGACK, to make sure memory fetches work as expected */
2444 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 0);
2445 embeddedice_store_reg(dbg_ctrl
);
2450 while (num_accesses
< count
)
2453 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2454 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2456 for (i
= 1; i
<= thisrun_accesses
; i
++)
2460 reg
[i
] = target_buffer_get_u32(target
, buffer
);
2464 arm7_9
->write_core_regs(target
, reg_list
, reg
);
2466 arm7_9
->store_word_regs(target
, reg_list
);
2468 /* fast memory writes are only safe when the target is running
2469 * from a sufficiently high clock (32 kHz is usually too slow)
2471 if (arm7_9
->fast_memory_access
)
2472 retval
= arm7_9_execute_fast_sys_speed(target
);
2475 retval
= arm7_9_execute_sys_speed(target
);
2478 * if memory writes are made when the clock is running slow
2479 * (i.e. 32 kHz) which is necessary in some scripts to reconfigure
2480 * processor operations after a "reset halt" or "reset init",
2481 * need to immediately stroke the keep alive or will end up with
2482 * gdb "keep alive not sent error message" problem.
2488 if (retval
!= ERROR_OK
)
2493 num_accesses
+= thisrun_accesses
;
2497 while (num_accesses
< count
)
2500 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2501 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2503 for (i
= 1; i
<= thisrun_accesses
; i
++)
2507 reg
[i
] = target_buffer_get_u16(target
, buffer
) & 0xffff;
2511 arm7_9
->write_core_regs(target
, reg_list
, reg
);
2513 for (i
= 1; i
<= thisrun_accesses
; i
++)
2515 arm7_9
->store_hword_reg(target
, i
);
2517 /* fast memory writes are only safe when the target is running
2518 * from a sufficiently high clock (32 kHz is usually too slow)
2520 if (arm7_9
->fast_memory_access
)
2521 retval
= arm7_9_execute_fast_sys_speed(target
);
2524 retval
= arm7_9_execute_sys_speed(target
);
2527 * if memory writes are made when the clock is running slow
2528 * (i.e. 32 kHz) which is necessary in some scripts to reconfigure
2529 * processor operations after a "reset halt" or "reset init",
2530 * need to immediately stroke the keep alive or will end up with
2531 * gdb "keep alive not sent error message" problem.
2537 if (retval
!= ERROR_OK
)
2543 num_accesses
+= thisrun_accesses
;
2547 while (num_accesses
< count
)
2550 thisrun_accesses
= ((count
- num_accesses
) >= 14) ? 14 : (count
- num_accesses
);
2551 reg_list
= (0xffff >> (15 - thisrun_accesses
)) & 0xfffe;
2553 for (i
= 1; i
<= thisrun_accesses
; i
++)
2557 reg
[i
] = *buffer
++ & 0xff;
2560 arm7_9
->write_core_regs(target
, reg_list
, reg
);
2562 for (i
= 1; i
<= thisrun_accesses
; i
++)
2564 arm7_9
->store_byte_reg(target
, i
);
2565 /* fast memory writes are only safe when the target is running
2566 * from a sufficiently high clock (32 kHz is usually too slow)
2568 if (arm7_9
->fast_memory_access
)
2569 retval
= arm7_9_execute_fast_sys_speed(target
);
2572 retval
= arm7_9_execute_sys_speed(target
);
2575 * if memory writes are made when the clock is running slow
2576 * (i.e. 32 kHz) which is necessary in some scripts to reconfigure
2577 * processor operations after a "reset halt" or "reset init",
2578 * need to immediately stroke the keep alive or will end up with
2579 * gdb "keep alive not sent error message" problem.
2585 if (retval
!= ERROR_OK
)
2592 num_accesses
+= thisrun_accesses
;
2598 buf_set_u32(dbg_ctrl
->value
, EICE_DBG_CONTROL_DBGACK
, 1, 1);
2599 embeddedice_store_reg(dbg_ctrl
);
2601 if (!is_arm_mode(armv4_5
->core_mode
))
2604 for (i
= 0; i
<= last_reg
; i
++) {
2605 struct reg
*r
= arm_reg_current(armv4_5
, i
);
2607 r
->dirty
= r
->valid
;
2610 arm7_9
->read_xpsr(target
, &cpsr
, 0);
2611 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2613 LOG_ERROR("JTAG error while reading cpsr");
2614 return ERROR_TARGET_DATA_ABORT
;
2617 if (((cpsr
& 0x1f) == ARM_MODE_ABT
) && (armv4_5
->core_mode
!= ARM_MODE_ABT
))
2619 LOG_WARNING("memory write caused data abort (address: 0x%8.8" PRIx32
", size: 0x%" PRIx32
", count: 0x%" PRIx32
")", address
, size
, count
);
2621 arm7_9
->write_xpsr_im8(target
,
2622 buf_get_u32(armv4_5
->cpsr
->value
, 0, 8)
2625 return ERROR_TARGET_DATA_ABORT
;
2631 static int dcc_count
;
2632 static uint8_t *dcc_buffer
;
2634 static int arm7_9_dcc_completion(struct target
*target
, uint32_t exit_point
, int timeout_ms
, void *arch_info
)
2636 int retval
= ERROR_OK
;
2637 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2639 if ((retval
= target_wait_state(target
, TARGET_DEBUG_RUNNING
, 500)) != ERROR_OK
)
2642 int little
= target
->endianness
== TARGET_LITTLE_ENDIAN
;
2643 int count
= dcc_count
;
2644 uint8_t *buffer
= dcc_buffer
;
2647 /* Handle first & last using standard embeddedice_write_reg and the middle ones w/the
2648 * core function repeated. */
2649 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_COMMS_DATA
], fast_target_buffer_get_u32(buffer
, little
));
2652 struct embeddedice_reg
*ice_reg
= arm7_9
->eice_cache
->reg_list
[EICE_COMMS_DATA
].arch_info
;
2653 uint8_t reg_addr
= ice_reg
->addr
& 0x1f;
2654 struct jtag_tap
*tap
;
2655 tap
= ice_reg
->jtag_info
->tap
;
2657 embeddedice_write_dcc(tap
, reg_addr
, buffer
, little
, count
-2);
2658 buffer
+= (count
-2)*4;
2660 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_COMMS_DATA
], fast_target_buffer_get_u32(buffer
, little
));
2664 for (i
= 0; i
< count
; i
++)
2666 embeddedice_write_reg(&arm7_9
->eice_cache
->reg_list
[EICE_COMMS_DATA
], fast_target_buffer_get_u32(buffer
, little
));
2671 if ((retval
= target_halt(target
))!= ERROR_OK
)
2675 return target_wait_state(target
, TARGET_HALTED
, 500);
2678 static const uint32_t dcc_code
[] =
2680 /* r0 == input, points to memory buffer
2684 /* spin until DCC control (c0) reports data arrived */
2685 0xee101e10, /* w: mrc p14, #0, r1, c0, c0 */
2686 0xe3110001, /* tst r1, #1 */
2687 0x0afffffc, /* bne w */
2689 /* read word from DCC (c1), write to memory */
2690 0xee111e10, /* mrc p14, #0, r1, c1, c0 */
2691 0xe4801004, /* str r1, [r0], #4 */
2694 0xeafffff9 /* b w */
2697 int arm7_9_bulk_write_memory(struct target
*target
, uint32_t address
, uint32_t count
, uint8_t *buffer
)
2700 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2703 if (!arm7_9
->dcc_downloads
)
2704 return target_write_memory(target
, address
, 4, count
, buffer
);
2706 /* regrab previously allocated working_area, or allocate a new one */
2707 if (!arm7_9
->dcc_working_area
)
2709 uint8_t dcc_code_buf
[6 * 4];
2711 /* make sure we have a working area */
2712 if (target_alloc_working_area(target
, 24, &arm7_9
->dcc_working_area
) != ERROR_OK
)
2714 LOG_INFO("no working area available, falling back to memory writes");
2715 return target_write_memory(target
, address
, 4, count
, buffer
);
2718 /* copy target instructions to target endianness */
2719 for (i
= 0; i
< 6; i
++)
2721 target_buffer_set_u32(target
, dcc_code_buf
+ i
*4, dcc_code
[i
]);
2724 /* write DCC code to working area */
2725 if ((retval
= target_write_memory(target
, arm7_9
->dcc_working_area
->address
, 4, 6, dcc_code_buf
)) != ERROR_OK
)
2731 struct arm_algorithm armv4_5_info
;
2732 struct reg_param reg_params
[1];
2734 armv4_5_info
.common_magic
= ARM_COMMON_MAGIC
;
2735 armv4_5_info
.core_mode
= ARM_MODE_SVC
;
2736 armv4_5_info
.core_state
= ARM_STATE_ARM
;
2738 init_reg_param(®_params
[0], "r0", 32, PARAM_IN_OUT
);
2740 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
2743 dcc_buffer
= buffer
;
2744 retval
= armv4_5_run_algorithm_inner(target
, 0, NULL
, 1, reg_params
,
2745 arm7_9
->dcc_working_area
->address
,
2746 arm7_9
->dcc_working_area
->address
+ 6*4,
2747 20*1000, &armv4_5_info
, arm7_9_dcc_completion
);
2749 if (retval
== ERROR_OK
)
2751 uint32_t endaddress
= buf_get_u32(reg_params
[0].value
, 0, 32);
2752 if (endaddress
!= (address
+ count
*4))
2754 LOG_ERROR("DCC write failed, expected end address 0x%08" PRIx32
" got 0x%0" PRIx32
"", (address
+ count
*4), endaddress
);
2755 retval
= ERROR_FAIL
;
2759 destroy_reg_param(®_params
[0]);
2765 * Perform per-target setup that requires JTAG access.
2767 int arm7_9_examine(struct target
*target
)
2769 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2772 if (!target_was_examined(target
)) {
2773 struct reg_cache
*t
, **cache_p
;
2775 t
= embeddedice_build_reg_cache(target
, arm7_9
);
2779 cache_p
= register_get_last_cache_p(&target
->reg_cache
);
2781 arm7_9
->eice_cache
= (*cache_p
);
2783 if (arm7_9
->armv4_5_common
.etm
)
2784 (*cache_p
)->next
= etm_build_reg_cache(target
,
2786 arm7_9
->armv4_5_common
.etm
);
2788 target_set_examined(target
);
2791 retval
= embeddedice_setup(target
);
2792 if (retval
== ERROR_OK
)
2793 retval
= arm7_9_setup(target
);
2794 if (retval
== ERROR_OK
&& arm7_9
->armv4_5_common
.etm
)
2795 retval
= etm_setup(target
);
2800 int arm7_9_check_reset(struct target
*target
)
2802 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2804 if (get_target_reset_nag() && !arm7_9
->dcc_downloads
)
2806 LOG_WARNING("NOTE! DCC downloads have not been enabled, defaulting to slow memory writes. Type 'help dcc'.");
2809 if (get_target_reset_nag() && (target
->working_area_size
== 0))
2811 LOG_WARNING("NOTE! Severe performance degradation without working memory enabled.");
2814 if (get_target_reset_nag() && !arm7_9
->fast_memory_access
)
2816 LOG_WARNING("NOTE! Severe performance degradation without fast memory access enabled. Type 'help fast'.");
2822 COMMAND_HANDLER(handle_arm7_9_dbgrq_command
)
2824 struct target
*target
= get_current_target(CMD_CTX
);
2825 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2827 if (!is_arm7_9(arm7_9
))
2829 command_print(CMD_CTX
, "current target isn't an ARM7/ARM9 target");
2830 return ERROR_TARGET_INVALID
;
2834 COMMAND_PARSE_ENABLE(CMD_ARGV
[0],arm7_9
->use_dbgrq
);
2836 command_print(CMD_CTX
, "use of EmbeddedICE dbgrq instead of breakpoint for target halt %s", (arm7_9
->use_dbgrq
) ? "enabled" : "disabled");
2841 COMMAND_HANDLER(handle_arm7_9_fast_memory_access_command
)
2843 struct target
*target
= get_current_target(CMD_CTX
);
2844 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2846 if (!is_arm7_9(arm7_9
))
2848 command_print(CMD_CTX
, "current target isn't an ARM7/ARM9 target");
2849 return ERROR_TARGET_INVALID
;
2853 COMMAND_PARSE_ENABLE(CMD_ARGV
[0], arm7_9
->fast_memory_access
);
2855 command_print(CMD_CTX
, "fast memory access is %s", (arm7_9
->fast_memory_access
) ? "enabled" : "disabled");
2860 COMMAND_HANDLER(handle_arm7_9_dcc_downloads_command
)
2862 struct target
*target
= get_current_target(CMD_CTX
);
2863 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2865 if (!is_arm7_9(arm7_9
))
2867 command_print(CMD_CTX
, "current target isn't an ARM7/ARM9 target");
2868 return ERROR_TARGET_INVALID
;
2872 COMMAND_PARSE_ENABLE(CMD_ARGV
[0], arm7_9
->dcc_downloads
);
2874 command_print(CMD_CTX
, "dcc downloads are %s", (arm7_9
->dcc_downloads
) ? "enabled" : "disabled");
2879 static int arm7_9_setup_semihosting(struct target
*target
, int enable
)
2881 struct arm7_9_common
*arm7_9
= target_to_arm7_9(target
);
2883 if (!is_arm7_9(arm7_9
))
2885 LOG_USER("current target isn't an ARM7/ARM9 target");
2886 return ERROR_TARGET_INVALID
;
2889 if (arm7_9
->has_vector_catch
) {
2890 struct reg
*vector_catch
= &arm7_9
->eice_cache
2891 ->reg_list
[EICE_VEC_CATCH
];
2893 if (!vector_catch
->valid
)
2894 embeddedice_read_reg(vector_catch
);
2895 buf_set_u32(vector_catch
->value
, 2, 1, enable
);
2896 embeddedice_store_reg(vector_catch
);
2898 /* TODO: allow optional high vectors and/or BKPT_HARD */
2900 breakpoint_add(target
, 8, 4, BKPT_SOFT
);
2902 breakpoint_remove(target
, 8);
2908 int arm7_9_init_arch_info(struct target
*target
, struct arm7_9_common
*arm7_9
)
2910 int retval
= ERROR_OK
;
2911 struct arm
*armv4_5
= &arm7_9
->armv4_5_common
;
2913 arm7_9
->common_magic
= ARM7_9_COMMON_MAGIC
;
2915 if ((retval
= arm_jtag_setup_connection(&arm7_9
->jtag_info
)) != ERROR_OK
)
2918 /* caller must have allocated via calloc(), so everything's zeroed */
2920 arm7_9
->wp_available_max
= 2;
2922 arm7_9
->fast_memory_access
= false;
2923 arm7_9
->dcc_downloads
= false;
2925 armv4_5
->arch_info
= arm7_9
;
2926 armv4_5
->read_core_reg
= arm7_9_read_core_reg
;
2927 armv4_5
->write_core_reg
= arm7_9_write_core_reg
;
2928 armv4_5
->full_context
= arm7_9_full_context
;
2929 armv4_5
->setup_semihosting
= arm7_9_setup_semihosting
;
2931 retval
= arm_init_arch_info(target
, armv4_5
);
2932 if (retval
!= ERROR_OK
)
2935 return target_register_timer_callback(arm7_9_handle_target_request
,
2939 static const struct command_registration arm7_9_any_command_handlers
[] = {
2942 .handler
= handle_arm7_9_dbgrq_command
,
2943 .mode
= COMMAND_ANY
,
2944 .usage
= "['enable'|'disable']",
2945 .help
= "use EmbeddedICE dbgrq instead of breakpoint "
2946 "for target halt requests",
2949 "fast_memory_access",
2950 .handler
= handle_arm7_9_fast_memory_access_command
,
2951 .mode
= COMMAND_ANY
,
2952 .usage
= "['enable'|'disable']",
2953 .help
= "use fast memory accesses instead of slower "
2954 "but potentially safer accesses",
2958 .handler
= handle_arm7_9_dcc_downloads_command
,
2959 .mode
= COMMAND_ANY
,
2960 .usage
= "['enable'|'disable']",
2961 .help
= "use DCC downloads for larger memory writes",
2963 COMMAND_REGISTRATION_DONE
2965 const struct command_registration arm7_9_command_handlers
[] = {
2967 .chain
= arm_command_handlers
,
2970 .chain
= etm_command_handlers
,
2974 .mode
= COMMAND_ANY
,
2975 .help
= "arm7/9 specific commands",
2976 .chain
= arm7_9_any_command_handlers
,
2978 COMMAND_REGISTRATION_DONE
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)