1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2006 by Magnus Lundin *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * Copyright (C) 2009 by Dirk Behme *
12 * dirk.behme@gmail.com - copy from cortex_m3 *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
29 * Cortex-A8(tm) TRM, ARM DDI 0344H *
31 ***************************************************************************/
36 #include "breakpoints.h"
37 #include "cortex_a8.h"
39 #include "target_request.h"
40 #include "target_type.h"
42 static int cortex_a8_poll(struct target
*target
);
43 static int cortex_a8_debug_entry(struct target
*target
);
44 static int cortex_a8_restore_context(struct target
*target
);
45 static int cortex_a8_set_breakpoint(struct target
*target
,
46 struct breakpoint
*breakpoint
, uint8_t matchmode
);
47 static int cortex_a8_unset_breakpoint(struct target
*target
,
48 struct breakpoint
*breakpoint
);
49 static int cortex_a8_dap_read_coreregister_u32(struct target
*target
,
50 uint32_t *value
, int regnum
);
51 static int cortex_a8_dap_write_coreregister_u32(struct target
*target
,
52 uint32_t value
, int regnum
);
54 * FIXME do topology discovery using the ROM; don't
55 * assume this is an OMAP3.
57 #define swjdp_memoryap 0
58 #define swjdp_debugap 1
59 #define OMAP3530_DEBUG_BASE 0x54011000
62 * Cortex-A8 Basic debug access, very low level assumes state is saved
64 static int cortex_a8_init_debug_access(struct target
*target
)
66 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
67 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
74 /* Unlocking the debug registers for modification */
75 /* The debugport might be uninitialised so try twice */
76 retval
= mem_ap_write_atomic_u32(swjdp
, armv7a
->debug_base
+ CPUDBG_LOCKACCESS
, 0xC5ACCE55);
77 if (retval
!= ERROR_OK
)
78 mem_ap_write_atomic_u32(swjdp
, armv7a
->debug_base
+ CPUDBG_LOCKACCESS
, 0xC5ACCE55);
79 /* Clear Sticky Power Down status Bit in PRSR to enable access to
80 the registers in the Core Power Domain */
81 retval
= mem_ap_read_atomic_u32(swjdp
, armv7a
->debug_base
+ CPUDBG_PRSR
, &dummy
);
82 /* Enabling of instruction execution in debug mode is done in debug_entry code */
84 /* Resync breakpoint registers */
86 /* Since this is likley called from init or reset, update targtet state information*/
87 cortex_a8_poll(target
);
92 int cortex_a8_exec_opcode(struct target
*target
, uint32_t opcode
)
96 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
97 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
99 LOG_DEBUG("exec opcode 0x%08" PRIx32
, opcode
);
102 retval
= mem_ap_read_atomic_u32(swjdp
,
103 armv7a
->debug_base
+ CPUDBG_DSCR
, &dscr
);
104 if (retval
!= ERROR_OK
)
106 LOG_ERROR("Could not read DSCR register, opcode = 0x%08" PRIx32
, opcode
);
110 while ((dscr
& (1 << DSCR_INSTR_COMP
)) == 0); /* Wait for InstrCompl bit to be set */
112 mem_ap_write_u32(swjdp
, armv7a
->debug_base
+ CPUDBG_ITR
, opcode
);
116 retval
= mem_ap_read_atomic_u32(swjdp
,
117 armv7a
->debug_base
+ CPUDBG_DSCR
, &dscr
);
118 if (retval
!= ERROR_OK
)
120 LOG_ERROR("Could not read DSCR register");
124 while ((dscr
& (1 << DSCR_INSTR_COMP
)) == 0); /* Wait for InstrCompl bit to be set */
129 /**************************************************************************
130 Read core register with very few exec_opcode, fast but needs work_area.
131 This can cause problems with MMU active.
132 **************************************************************************/
133 static int cortex_a8_read_regs_through_mem(struct target
*target
, uint32_t address
,
136 int retval
= ERROR_OK
;
137 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
138 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
140 cortex_a8_dap_read_coreregister_u32(target
, regfile
, 0);
141 cortex_a8_dap_write_coreregister_u32(target
, address
, 0);
142 cortex_a8_exec_opcode(target
, ARMV4_5_STMIA(0, 0xFFFE, 0, 0));
143 dap_ap_select(swjdp
, swjdp_memoryap
);
144 mem_ap_read_buf_u32(swjdp
, (uint8_t *)(®file
[1]), 4*15, address
);
145 dap_ap_select(swjdp
, swjdp_debugap
);
150 static int cortex_a8_read_cp(struct target
*target
, uint32_t *value
, uint8_t CP
,
151 uint8_t op1
, uint8_t CRn
, uint8_t CRm
, uint8_t op2
)
154 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
155 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
157 cortex_a8_exec_opcode(target
, ARMV4_5_MRC(CP
, op1
, 0, CRn
, CRm
, op2
));
158 /* Move R0 to DTRTX */
159 cortex_a8_exec_opcode(target
, ARMV4_5_MCR(14, 0, 0, 0, 5, 0));
162 retval
= mem_ap_read_atomic_u32(swjdp
,
163 armv7a
->debug_base
+ CPUDBG_DTRTX
, value
);
168 static int cortex_a8_write_cp(struct target
*target
, uint32_t value
,
169 uint8_t CP
, uint8_t op1
, uint8_t CRn
, uint8_t CRm
, uint8_t op2
)
173 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
174 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
176 LOG_DEBUG("CP%i, CRn %i, value 0x%08" PRIx32
, CP
, CRn
, value
);
178 /* Check that DCCRX is not full */
179 retval
= mem_ap_read_atomic_u32(swjdp
,
180 armv7a
->debug_base
+ CPUDBG_DSCR
, &dscr
);
181 if (dscr
& (1 << DSCR_DTR_RX_FULL
))
183 LOG_ERROR("DSCR_DTR_RX_FULL, dscr 0x%08" PRIx32
, dscr
);
184 /* Clear DCCRX with MCR(p14, 0, Rd, c0, c5, 0), opcode 0xEE000E15 */
185 cortex_a8_exec_opcode(target
, ARMV4_5_MRC(14, 0, 0, 0, 5, 0));
188 retval
= mem_ap_write_u32(swjdp
,
189 armv7a
->debug_base
+ CPUDBG_DTRRX
, value
);
190 /* Move DTRRX to r0 */
191 cortex_a8_exec_opcode(target
, ARMV4_5_MRC(14, 0, 0, 0, 5, 0));
193 cortex_a8_exec_opcode(target
, ARMV4_5_MCR(CP
, op1
, 0, CRn
, CRm
, op2
));
197 static int cortex_a8_read_cp15(struct target
*target
, uint32_t op1
, uint32_t op2
,
198 uint32_t CRn
, uint32_t CRm
, uint32_t *value
)
200 return cortex_a8_read_cp(target
, value
, 15, op1
, CRn
, CRm
, op2
);
203 static int cortex_a8_write_cp15(struct target
*target
, uint32_t op1
, uint32_t op2
,
204 uint32_t CRn
, uint32_t CRm
, uint32_t value
)
206 return cortex_a8_write_cp(target
, value
, 15, op1
, CRn
, CRm
, op2
);
209 static int cortex_a8_mrc(struct target
*target
, int cpnum
, uint32_t op1
, uint32_t op2
, uint32_t CRn
, uint32_t CRm
, uint32_t *value
)
213 LOG_ERROR("Only cp15 is supported");
216 return cortex_a8_read_cp15(target
, op1
, op2
, CRn
, CRm
, value
);
219 static int cortex_a8_mcr(struct target
*target
, int cpnum
, uint32_t op1
, uint32_t op2
, uint32_t CRn
, uint32_t CRm
, uint32_t value
)
223 LOG_ERROR("Only cp15 is supported");
226 return cortex_a8_write_cp15(target
, op1
, op2
, CRn
, CRm
, value
);
231 static int cortex_a8_dap_read_coreregister_u32(struct target
*target
,
232 uint32_t *value
, int regnum
)
234 int retval
= ERROR_OK
;
235 uint8_t reg
= regnum
&0xFF;
237 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
238 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
245 /* Rn to DCCTX, "MCR p14, 0, Rn, c0, c5, 0" 0xEE00nE15 */
246 cortex_a8_exec_opcode(target
, ARMV4_5_MCR(14, 0, reg
, 0, 5, 0));
250 /* "MOV r0, r15"; then move r0 to DCCTX */
251 cortex_a8_exec_opcode(target
, 0xE1A0000F);
252 cortex_a8_exec_opcode(target
, ARMV4_5_MCR(14, 0, 0, 0, 5, 0));
256 /* "MRS r0, CPSR"; then move r0 to DCCTX */
257 cortex_a8_exec_opcode(target
, ARMV4_5_MRS(0, 0));
258 cortex_a8_exec_opcode(target
, ARMV4_5_MCR(14, 0, 0, 0, 5, 0));
264 retval
= mem_ap_read_atomic_u32(swjdp
,
265 armv7a
->debug_base
+ CPUDBG_DSCR
, &dscr
);
267 while ((dscr
& (1 << DSCR_DTR_TX_FULL
)) == 0); /* Wait for DTRRXfull */
269 retval
= mem_ap_read_atomic_u32(swjdp
,
270 armv7a
->debug_base
+ CPUDBG_DTRTX
, value
);
275 static int cortex_a8_dap_write_coreregister_u32(struct target
*target
, uint32_t value
, int regnum
)
277 int retval
= ERROR_OK
;
278 uint8_t Rd
= regnum
&0xFF;
280 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
281 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
283 LOG_DEBUG("register %i, value 0x%08" PRIx32
, regnum
, value
);
285 /* Check that DCCRX is not full */
286 retval
= mem_ap_read_atomic_u32(swjdp
,
287 armv7a
->debug_base
+ CPUDBG_DSCR
, &dscr
);
288 if (dscr
& (1 << DSCR_DTR_RX_FULL
))
290 LOG_ERROR("DSCR_DTR_RX_FULL, dscr 0x%08" PRIx32
, dscr
);
291 /* Clear DCCRX with MCR(p14, 0, Rd, c0, c5, 0), opcode 0xEE000E15 */
292 cortex_a8_exec_opcode(target
, ARMV4_5_MRC(14, 0, 0, 0, 5, 0));
299 retval
= mem_ap_write_u32(swjdp
,
300 armv7a
->debug_base
+ CPUDBG_DTRRX
, value
);
304 /* DCCRX to Rd, MCR p14, 0, Rd, c0, c5, 0, 0xEE000E15 */
305 cortex_a8_exec_opcode(target
, ARMV4_5_MRC(14, 0, Rd
, 0, 5, 0));
309 cortex_a8_exec_opcode(target
, ARMV4_5_MRC(14, 0, 0, 0, 5, 0));
310 cortex_a8_exec_opcode(target
, 0xE1A0F000);
314 cortex_a8_exec_opcode(target
, ARMV4_5_MRC(14, 0, 0, 0, 5, 0));
315 cortex_a8_exec_opcode(target
, ARMV4_5_MSR_GP(0, 0xF, 0));
316 /* Execute a PrefetchFlush instruction through the ITR. */
317 cortex_a8_exec_opcode(target
, ARMV4_5_MCR(15, 0, 0, 7, 5, 4));
323 /* Write to memory mapped registers directly with no cache or mmu handling */
324 static int cortex_a8_dap_write_memap_register_u32(struct target
*target
, uint32_t address
, uint32_t value
)
327 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
328 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
330 retval
= mem_ap_write_atomic_u32(swjdp
, address
, value
);
336 * Cortex-A8 Run control
339 static int cortex_a8_poll(struct target
*target
)
341 int retval
= ERROR_OK
;
343 struct cortex_a8_common
*cortex_a8
= target_to_cortex_a8(target
);
344 struct armv7a_common
*armv7a
= &cortex_a8
->armv7a_common
;
345 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
346 enum target_state prev_target_state
= target
->state
;
347 uint8_t saved_apsel
= dap_ap_get_select(swjdp
);
349 dap_ap_select(swjdp
, swjdp_debugap
);
350 retval
= mem_ap_read_atomic_u32(swjdp
,
351 armv7a
->debug_base
+ CPUDBG_DSCR
, &dscr
);
352 if (retval
!= ERROR_OK
)
354 dap_ap_select(swjdp
, saved_apsel
);
357 cortex_a8
->cpudbg_dscr
= dscr
;
359 if ((dscr
& 0x3) == 0x3)
361 if (prev_target_state
!= TARGET_HALTED
)
363 /* We have a halting debug event */
364 LOG_DEBUG("Target halted");
365 target
->state
= TARGET_HALTED
;
366 if ((prev_target_state
== TARGET_RUNNING
)
367 || (prev_target_state
== TARGET_RESET
))
369 retval
= cortex_a8_debug_entry(target
);
370 if (retval
!= ERROR_OK
)
373 target_call_event_callbacks(target
,
374 TARGET_EVENT_HALTED
);
376 if (prev_target_state
== TARGET_DEBUG_RUNNING
)
380 retval
= cortex_a8_debug_entry(target
);
381 if (retval
!= ERROR_OK
)
384 target_call_event_callbacks(target
,
385 TARGET_EVENT_DEBUG_HALTED
);
389 else if ((dscr
& 0x3) == 0x2)
391 target
->state
= TARGET_RUNNING
;
395 LOG_DEBUG("Unknown target state dscr = 0x%08" PRIx32
, dscr
);
396 target
->state
= TARGET_UNKNOWN
;
399 dap_ap_select(swjdp
, saved_apsel
);
404 static int cortex_a8_halt(struct target
*target
)
406 int retval
= ERROR_OK
;
408 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
409 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
410 uint8_t saved_apsel
= dap_ap_get_select(swjdp
);
411 dap_ap_select(swjdp
, swjdp_debugap
);
414 * Tell the core to be halted by writing DRCR with 0x1
415 * and then wait for the core to be halted.
417 retval
= mem_ap_write_atomic_u32(swjdp
,
418 armv7a
->debug_base
+ CPUDBG_DRCR
, 0x1);
421 * enter halting debug mode
423 mem_ap_read_atomic_u32(swjdp
, armv7a
->debug_base
+ CPUDBG_DSCR
, &dscr
);
424 retval
= mem_ap_write_atomic_u32(swjdp
,
425 armv7a
->debug_base
+ CPUDBG_DSCR
, dscr
| (1 << DSCR_HALT_DBG_MODE
));
427 if (retval
!= ERROR_OK
)
431 mem_ap_read_atomic_u32(swjdp
,
432 armv7a
->debug_base
+ CPUDBG_DSCR
, &dscr
);
433 } while ((dscr
& (1 << DSCR_CORE_HALTED
)) == 0);
435 target
->debug_reason
= DBG_REASON_DBGRQ
;
438 dap_ap_select(swjdp
, saved_apsel
);
442 static int cortex_a8_resume(struct target
*target
, int current
,
443 uint32_t address
, int handle_breakpoints
, int debug_execution
)
445 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
446 struct armv4_5_common_s
*armv4_5
= &armv7a
->armv4_5_common
;
447 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
449 // struct breakpoint *breakpoint = NULL;
450 uint32_t resume_pc
, dscr
;
452 uint8_t saved_apsel
= dap_ap_get_select(swjdp
);
453 dap_ap_select(swjdp
, swjdp_debugap
);
455 if (!debug_execution
)
457 target_free_all_working_areas(target
);
458 // cortex_m3_enable_breakpoints(target);
459 // cortex_m3_enable_watchpoints(target);
465 /* Disable interrupts */
466 /* We disable interrupts in the PRIMASK register instead of
467 * masking with C_MASKINTS,
468 * This is probably the same issue as Cortex-M3 Errata 377493:
469 * C_MASKINTS in parallel with disabled interrupts can cause
470 * local faults to not be taken. */
471 buf_set_u32(armv7m
->core_cache
->reg_list
[ARMV7M_PRIMASK
].value
, 0, 32, 1);
472 armv7m
->core_cache
->reg_list
[ARMV7M_PRIMASK
].dirty
= 1;
473 armv7m
->core_cache
->reg_list
[ARMV7M_PRIMASK
].valid
= 1;
475 /* Make sure we are in Thumb mode */
476 buf_set_u32(armv7m
->core_cache
->reg_list
[ARMV7M_xPSR
].value
, 0, 32,
477 buf_get_u32(armv7m
->core_cache
->reg_list
[ARMV7M_xPSR
].value
, 0, 32) | (1 << 24));
478 armv7m
->core_cache
->reg_list
[ARMV7M_xPSR
].dirty
= 1;
479 armv7m
->core_cache
->reg_list
[ARMV7M_xPSR
].valid
= 1;
483 /* current = 1: continue on current pc, otherwise continue at <address> */
484 resume_pc
= buf_get_u32(
485 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
486 armv4_5
->core_mode
, 15).value
,
491 /* Make sure that the Armv7 gdb thumb fixups does not
492 * kill the return address
494 switch (armv4_5
->core_state
)
496 case ARMV4_5_STATE_ARM
:
497 resume_pc
&= 0xFFFFFFFC;
499 case ARMV4_5_STATE_THUMB
:
500 case ARM_STATE_THUMB_EE
:
501 /* When the return address is loaded into PC
502 * bit 0 must be 1 to stay in Thumb state
506 case ARMV4_5_STATE_JAZELLE
:
507 LOG_ERROR("How do I resume into Jazelle state??");
510 LOG_DEBUG("resume pc = 0x%08" PRIx32
, resume_pc
);
511 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
512 armv4_5
->core_mode
, 15).value
,
514 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
515 armv4_5
->core_mode
, 15).dirty
= 1;
516 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
517 armv4_5
->core_mode
, 15).valid
= 1;
519 cortex_a8_restore_context(target
);
520 // arm7_9_restore_context(target); TODO Context is currently NOT Properly restored
522 /* the front-end may request us not to handle breakpoints */
523 if (handle_breakpoints
)
525 /* Single step past breakpoint at current address */
526 if ((breakpoint
= breakpoint_find(target
, resume_pc
)))
528 LOG_DEBUG("unset breakpoint at 0x%8.8x", breakpoint
->address
);
529 cortex_m3_unset_breakpoint(target
, breakpoint
);
530 cortex_m3_single_step_core(target
);
531 cortex_m3_set_breakpoint(target
, breakpoint
);
536 /* Restart core and wait for it to be started */
537 mem_ap_write_atomic_u32(swjdp
, armv7a
->debug_base
+ CPUDBG_DRCR
, 0x2);
540 mem_ap_read_atomic_u32(swjdp
,
541 armv7a
->debug_base
+ CPUDBG_DSCR
, &dscr
);
542 } while ((dscr
& (1 << DSCR_CORE_RESTARTED
)) == 0);
544 target
->debug_reason
= DBG_REASON_NOTHALTED
;
545 target
->state
= TARGET_RUNNING
;
547 /* registers are now invalid */
548 register_cache_invalidate(armv4_5
->core_cache
);
550 if (!debug_execution
)
552 target
->state
= TARGET_RUNNING
;
553 target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
);
554 LOG_DEBUG("target resumed at 0x%" PRIx32
, resume_pc
);
558 target
->state
= TARGET_DEBUG_RUNNING
;
559 target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_RESUMED
);
560 LOG_DEBUG("target debug resumed at 0x%" PRIx32
, resume_pc
);
563 dap_ap_select(swjdp
, saved_apsel
);
568 static int cortex_a8_debug_entry(struct target
*target
)
571 uint32_t regfile
[16], pc
, cpsr
, dscr
;
572 int retval
= ERROR_OK
;
573 struct working_area
*regfile_working_area
= NULL
;
574 struct cortex_a8_common
*cortex_a8
= target_to_cortex_a8(target
);
575 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
576 struct armv4_5_common_s
*armv4_5
= &armv7a
->armv4_5_common
;
577 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
580 LOG_DEBUG("dscr = 0x%08" PRIx32
, cortex_a8
->cpudbg_dscr
);
582 /* Enable the ITR execution once we are in debug mode */
583 mem_ap_read_atomic_u32(swjdp
,
584 armv7a
->debug_base
+ CPUDBG_DSCR
, &dscr
);
585 dscr
|= (1 << DSCR_EXT_INT_EN
);
586 retval
= mem_ap_write_atomic_u32(swjdp
,
587 armv7a
->debug_base
+ CPUDBG_DSCR
, dscr
);
589 /* Examine debug reason */
590 switch ((cortex_a8
->cpudbg_dscr
>> 2)&0xF)
594 target
->debug_reason
= DBG_REASON_DBGRQ
;
598 target
->debug_reason
= DBG_REASON_BREAKPOINT
;
601 target
->debug_reason
= DBG_REASON_WATCHPOINT
;
604 target
->debug_reason
= DBG_REASON_UNDEFINED
;
608 /* Examine target state and mode */
609 if (cortex_a8
->fast_reg_read
)
610 target_alloc_working_area(target
, 64, ®file_working_area
);
612 /* First load register acessible through core debug port*/
613 if (!regfile_working_area
)
615 /* FIXME we don't actually need all these registers;
616 * reading them slows us down. Just R0, PC, CPSR...
618 for (i
= 0; i
<= 15; i
++)
619 cortex_a8_dap_read_coreregister_u32(target
,
624 dap_ap_select(swjdp
, swjdp_memoryap
);
625 cortex_a8_read_regs_through_mem(target
,
626 regfile_working_area
->address
, regfile
);
627 dap_ap_select(swjdp
, swjdp_memoryap
);
628 target_free_working_area(target
, regfile_working_area
);
631 /* read Current PSR */
632 cortex_a8_dap_read_coreregister_u32(target
, &cpsr
, 16);
634 dap_ap_select(swjdp
, swjdp_debugap
);
635 LOG_DEBUG("cpsr: %8.8" PRIx32
, cpsr
);
637 armv4_5
->core_mode
= cpsr
& 0x1F;
639 i
= (cpsr
>> 5) & 1; /* T */
640 i
|= (cpsr
>> 23) & 1; /* J << 1 */
642 case 0: /* J = 0, T = 0 */
643 armv4_5
->core_state
= ARMV4_5_STATE_ARM
;
645 case 1: /* J = 0, T = 1 */
646 armv4_5
->core_state
= ARMV4_5_STATE_THUMB
;
648 case 2: /* J = 1, T = 0 */
649 LOG_WARNING("Jazelle state -- not handled");
650 armv4_5
->core_state
= ARMV4_5_STATE_JAZELLE
;
652 case 3: /* J = 1, T = 1 */
653 /* ThumbEE is very much like Thumb, but some of the
654 * instructions are different. Single stepping and
655 * breakpoints need updating...
657 LOG_WARNING("ThumbEE -- incomplete support");
658 armv4_5
->core_state
= ARM_STATE_THUMB_EE
;
663 reg
= armv4_5
->core_cache
->reg_list
+ ARMV4_5_CPSR
;
664 buf_set_u32(reg
->value
, 0, 32, cpsr
);
668 for (i
= 0; i
<= ARM_PC
; i
++)
670 reg
= &ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
671 armv4_5
->core_mode
, i
);
673 buf_set_u32(reg
->value
, 0, 32, regfile
[i
]);
678 /* Fixup PC Resume Address */
681 // T bit set for Thumb or ThumbEE state
682 regfile
[ARM_PC
] -= 4;
687 regfile
[ARM_PC
] -= 8;
689 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
690 armv4_5
->core_mode
, ARM_PC
).value
,
691 0, 32, regfile
[ARM_PC
]);
693 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 0)
694 .dirty
= ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
695 armv4_5
->core_mode
, 0).valid
;
696 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 15)
697 .dirty
= ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
698 armv4_5
->core_mode
, 15).valid
;
701 /* TODO, Move this */
702 uint32_t cp15_control_register
, cp15_cacr
, cp15_nacr
;
703 cortex_a8_read_cp(target
, &cp15_control_register
, 15, 0, 1, 0, 0);
704 LOG_DEBUG("cp15_control_register = 0x%08x", cp15_control_register
);
706 cortex_a8_read_cp(target
, &cp15_cacr
, 15, 0, 1, 0, 2);
707 LOG_DEBUG("cp15 Coprocessor Access Control Register = 0x%08x", cp15_cacr
);
709 cortex_a8_read_cp(target
, &cp15_nacr
, 15, 0, 1, 1, 2);
710 LOG_DEBUG("cp15 Nonsecure Access Control Register = 0x%08x", cp15_nacr
);
713 /* Are we in an exception handler */
714 // armv4_5->exception_number = 0;
715 if (armv7a
->post_debug_entry
)
716 armv7a
->post_debug_entry(target
);
724 static void cortex_a8_post_debug_entry(struct target
*target
)
726 struct cortex_a8_common
*cortex_a8
= target_to_cortex_a8(target
);
727 struct armv7a_common
*armv7a
= &cortex_a8
->armv7a_common
;
729 // cortex_a8_read_cp(target, &cp15_control_register, 15, 0, 1, 0, 0);
730 /* examine cp15 control reg */
731 armv7a
->read_cp15(target
, 0, 0, 1, 0, &cortex_a8
->cp15_control_reg
);
732 jtag_execute_queue();
733 LOG_DEBUG("cp15_control_reg: %8.8" PRIx32
, cortex_a8
->cp15_control_reg
);
735 if (armv7a
->armv4_5_mmu
.armv4_5_cache
.ctype
== -1)
737 uint32_t cache_type_reg
;
738 /* identify caches */
739 armv7a
->read_cp15(target
, 0, 1, 0, 0, &cache_type_reg
);
740 jtag_execute_queue();
741 /* FIXME the armv4_4 cache info DOES NOT APPLY to Cortex-A8 */
742 armv4_5_identify_cache(cache_type_reg
,
743 &armv7a
->armv4_5_mmu
.armv4_5_cache
);
746 armv7a
->armv4_5_mmu
.mmu_enabled
=
747 (cortex_a8
->cp15_control_reg
& 0x1U
) ? 1 : 0;
748 armv7a
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
=
749 (cortex_a8
->cp15_control_reg
& 0x4U
) ? 1 : 0;
750 armv7a
->armv4_5_mmu
.armv4_5_cache
.i_cache_enabled
=
751 (cortex_a8
->cp15_control_reg
& 0x1000U
) ? 1 : 0;
756 static int cortex_a8_step(struct target
*target
, int current
, uint32_t address
,
757 int handle_breakpoints
)
759 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
760 struct armv4_5_common_s
*armv4_5
= &armv7a
->armv4_5_common
;
761 struct breakpoint
*breakpoint
= NULL
;
762 struct breakpoint stepbreakpoint
;
766 if (target
->state
!= TARGET_HALTED
)
768 LOG_WARNING("target not halted");
769 return ERROR_TARGET_NOT_HALTED
;
772 /* current = 1: continue on current pc, otherwise continue at <address> */
775 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
776 armv4_5
->core_mode
, ARM_PC
).value
,
781 address
= buf_get_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
782 armv4_5
->core_mode
, ARM_PC
).value
,
786 /* The front-end may request us not to handle breakpoints.
787 * But since Cortex-A8 uses breakpoint for single step,
788 * we MUST handle breakpoints.
790 handle_breakpoints
= 1;
791 if (handle_breakpoints
) {
792 breakpoint
= breakpoint_find(target
,
793 buf_get_u32(ARMV4_5_CORE_REG_MODE(
795 armv4_5
->core_mode
, 15).value
,
798 cortex_a8_unset_breakpoint(target
, breakpoint
);
801 /* Setup single step breakpoint */
802 stepbreakpoint
.address
= address
;
803 stepbreakpoint
.length
= (armv4_5
->core_state
== ARMV4_5_STATE_THUMB
)
805 stepbreakpoint
.type
= BKPT_HARD
;
806 stepbreakpoint
.set
= 0;
808 /* Break on IVA mismatch */
809 cortex_a8_set_breakpoint(target
, &stepbreakpoint
, 0x04);
811 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
813 cortex_a8_resume(target
, 1, address
, 0, 0);
815 while (target
->state
!= TARGET_HALTED
)
817 cortex_a8_poll(target
);
820 LOG_WARNING("timeout waiting for target halt");
825 cortex_a8_unset_breakpoint(target
, &stepbreakpoint
);
826 if (timeout
> 0) target
->debug_reason
= DBG_REASON_BREAKPOINT
;
829 cortex_a8_set_breakpoint(target
, breakpoint
, 0);
831 if (target
->state
!= TARGET_HALTED
)
832 LOG_DEBUG("target stepped");
837 static int cortex_a8_restore_context(struct target
*target
)
841 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
842 struct armv4_5_common_s
*armv4_5
= &armv7a
->armv4_5_common
;
846 if (armv7a
->pre_restore_context
)
847 armv7a
->pre_restore_context(target
);
849 for (i
= 15; i
>= 0; i
--)
851 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
852 armv4_5
->core_mode
, i
).dirty
)
854 value
= buf_get_u32(ARMV4_5_CORE_REG_MODE(
856 armv4_5
->core_mode
, i
).value
,
858 /* TODO Check return values */
859 cortex_a8_dap_write_coreregister_u32(target
, value
, i
);
863 if (armv7a
->post_restore_context
)
864 armv7a
->post_restore_context(target
);
872 * Cortex-A8 Core register functions
874 static int cortex_a8_load_core_reg_u32(struct target
*target
, int num
,
875 armv4_5_mode_t mode
, uint32_t * value
)
878 struct armv4_5_common_s
*armv4_5
= target_to_armv4_5(target
);
880 if ((num
<= ARM_CPSR
))
882 /* read a normal core register */
883 retval
= cortex_a8_dap_read_coreregister_u32(target
, value
, num
);
885 if (retval
!= ERROR_OK
)
887 LOG_ERROR("JTAG failure %i", retval
);
888 return ERROR_JTAG_DEVICE_ERROR
;
890 LOG_DEBUG("load from core reg %i value 0x%" PRIx32
, num
, *value
);
894 return ERROR_INVALID_ARGUMENTS
;
897 /* Register other than r0 - r14 uses r0 for access */
899 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
900 armv4_5
->core_mode
, 0).dirty
=
901 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
902 armv4_5
->core_mode
, 0).valid
;
903 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
904 armv4_5
->core_mode
, 15).dirty
=
905 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
906 armv4_5
->core_mode
, 15).valid
;
911 static int cortex_a8_store_core_reg_u32(struct target
*target
, int num
,
912 armv4_5_mode_t mode
, uint32_t value
)
916 struct armv4_5_common_s
*armv4_5
= target_to_armv4_5(target
);
918 #ifdef ARMV7_GDB_HACKS
919 /* If the LR register is being modified, make sure it will put us
920 * in "thumb" mode, or an INVSTATE exception will occur. This is a
921 * hack to deal with the fact that gdb will sometimes "forge"
922 * return addresses, and doesn't set the LSB correctly (i.e., when
923 * printing expressions containing function calls, it sets LR=0.) */
929 if ((num
<= ARM_CPSR
))
931 retval
= cortex_a8_dap_write_coreregister_u32(target
, value
, num
);
932 if (retval
!= ERROR_OK
)
934 LOG_ERROR("JTAG failure %i", retval
);
935 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
936 armv4_5
->core_mode
, num
).dirty
=
937 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
938 armv4_5
->core_mode
, num
).valid
;
939 return ERROR_JTAG_DEVICE_ERROR
;
941 LOG_DEBUG("write core reg %i value 0x%" PRIx32
, num
, value
);
945 return ERROR_INVALID_ARGUMENTS
;
953 static int cortex_a8_read_core_reg(struct target
*target
, int num
,
954 enum armv4_5_mode mode
)
958 struct armv4_5_common_s
*armv4_5
= target_to_armv4_5(target
);
960 /* FIXME cortex may not be in "mode" ... */
962 cortex_a8_dap_read_coreregister_u32(target
, &value
, num
);
964 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
969 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).valid
= 1;
970 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).dirty
= 0;
971 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
,
972 mode
, num
).value
, 0, 32, value
);
977 static int cortex_a8_write_core_reg(struct target
*target
, int num
,
978 enum armv4_5_mode mode
, uint32_t value
)
981 struct armv4_5_common_s
*armv4_5
= target_to_armv4_5(target
);
983 /* FIXME cortex may not be in "mode" ... */
985 cortex_a8_dap_write_coreregister_u32(target
, value
, num
);
986 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
991 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).valid
= 1;
992 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, mode
, num
).dirty
= 0;
999 * Cortex-A8 Breakpoint and watchpoint fuctions
1002 /* Setup hardware Breakpoint Register Pair */
1003 static int cortex_a8_set_breakpoint(struct target
*target
,
1004 struct breakpoint
*breakpoint
, uint8_t matchmode
)
1009 uint8_t byte_addr_select
= 0x0F;
1010 struct cortex_a8_common
*cortex_a8
= target_to_cortex_a8(target
);
1011 struct armv7a_common
*armv7a
= &cortex_a8
->armv7a_common
;
1012 struct cortex_a8_brp
* brp_list
= cortex_a8
->brp_list
;
1014 if (breakpoint
->set
)
1016 LOG_WARNING("breakpoint already set");
1020 if (breakpoint
->type
== BKPT_HARD
)
1022 while (brp_list
[brp_i
].used
&& (brp_i
< cortex_a8
->brp_num
))
1024 if (brp_i
>= cortex_a8
->brp_num
)
1026 LOG_ERROR("ERROR Can not find free Breakpoint Register Pair");
1029 breakpoint
->set
= brp_i
+ 1;
1030 if (breakpoint
->length
== 2)
1032 byte_addr_select
= (3 << (breakpoint
->address
& 0x02));
1034 control
= ((matchmode
& 0x7) << 20)
1035 | (byte_addr_select
<< 5)
1037 brp_list
[brp_i
].used
= 1;
1038 brp_list
[brp_i
].value
= (breakpoint
->address
& 0xFFFFFFFC);
1039 brp_list
[brp_i
].control
= control
;
1040 cortex_a8_dap_write_memap_register_u32(target
, armv7a
->debug_base
1041 + CPUDBG_BVR_BASE
+ 4 * brp_list
[brp_i
].BRPn
,
1042 brp_list
[brp_i
].value
);
1043 cortex_a8_dap_write_memap_register_u32(target
, armv7a
->debug_base
1044 + CPUDBG_BCR_BASE
+ 4 * brp_list
[brp_i
].BRPn
,
1045 brp_list
[brp_i
].control
);
1046 LOG_DEBUG("brp %i control 0x%0" PRIx32
" value 0x%0" PRIx32
, brp_i
,
1047 brp_list
[brp_i
].control
,
1048 brp_list
[brp_i
].value
);
1050 else if (breakpoint
->type
== BKPT_SOFT
)
1053 if (breakpoint
->length
== 2)
1055 buf_set_u32(code
, 0, 32, ARMV5_T_BKPT(0x11));
1059 buf_set_u32(code
, 0, 32, ARMV5_BKPT(0x11));
1061 retval
= target
->type
->read_memory(target
,
1062 breakpoint
->address
& 0xFFFFFFFE,
1063 breakpoint
->length
, 1,
1064 breakpoint
->orig_instr
);
1065 if (retval
!= ERROR_OK
)
1067 retval
= target
->type
->write_memory(target
,
1068 breakpoint
->address
& 0xFFFFFFFE,
1069 breakpoint
->length
, 1, code
);
1070 if (retval
!= ERROR_OK
)
1072 breakpoint
->set
= 0x11; /* Any nice value but 0 */
1078 static int cortex_a8_unset_breakpoint(struct target
*target
, struct breakpoint
*breakpoint
)
1081 struct cortex_a8_common
*cortex_a8
= target_to_cortex_a8(target
);
1082 struct armv7a_common
*armv7a
= &cortex_a8
->armv7a_common
;
1083 struct cortex_a8_brp
* brp_list
= cortex_a8
->brp_list
;
1085 if (!breakpoint
->set
)
1087 LOG_WARNING("breakpoint not set");
1091 if (breakpoint
->type
== BKPT_HARD
)
1093 int brp_i
= breakpoint
->set
- 1;
1094 if ((brp_i
< 0) || (brp_i
>= cortex_a8
->brp_num
))
1096 LOG_DEBUG("Invalid BRP number in breakpoint");
1099 LOG_DEBUG("rbp %i control 0x%0" PRIx32
" value 0x%0" PRIx32
, brp_i
,
1100 brp_list
[brp_i
].control
, brp_list
[brp_i
].value
);
1101 brp_list
[brp_i
].used
= 0;
1102 brp_list
[brp_i
].value
= 0;
1103 brp_list
[brp_i
].control
= 0;
1104 cortex_a8_dap_write_memap_register_u32(target
, armv7a
->debug_base
1105 + CPUDBG_BCR_BASE
+ 4 * brp_list
[brp_i
].BRPn
,
1106 brp_list
[brp_i
].control
);
1107 cortex_a8_dap_write_memap_register_u32(target
, armv7a
->debug_base
1108 + CPUDBG_BVR_BASE
+ 4 * brp_list
[brp_i
].BRPn
,
1109 brp_list
[brp_i
].value
);
1113 /* restore original instruction (kept in target endianness) */
1114 if (breakpoint
->length
== 4)
1116 retval
= target
->type
->write_memory(target
,
1117 breakpoint
->address
& 0xFFFFFFFE,
1118 4, 1, breakpoint
->orig_instr
);
1119 if (retval
!= ERROR_OK
)
1124 retval
= target
->type
->write_memory(target
,
1125 breakpoint
->address
& 0xFFFFFFFE,
1126 2, 1, breakpoint
->orig_instr
);
1127 if (retval
!= ERROR_OK
)
1131 breakpoint
->set
= 0;
1136 int cortex_a8_add_breakpoint(struct target
*target
, struct breakpoint
*breakpoint
)
1138 struct cortex_a8_common
*cortex_a8
= target_to_cortex_a8(target
);
1140 if ((breakpoint
->type
== BKPT_HARD
) && (cortex_a8
->brp_num_available
< 1))
1142 LOG_INFO("no hardware breakpoint available");
1143 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1146 if (breakpoint
->type
== BKPT_HARD
)
1147 cortex_a8
->brp_num_available
--;
1148 cortex_a8_set_breakpoint(target
, breakpoint
, 0x00); /* Exact match */
1153 static int cortex_a8_remove_breakpoint(struct target
*target
, struct breakpoint
*breakpoint
)
1155 struct cortex_a8_common
*cortex_a8
= target_to_cortex_a8(target
);
1158 /* It is perfectly possible to remove brakpoints while the taget is running */
1159 if (target
->state
!= TARGET_HALTED
)
1161 LOG_WARNING("target not halted");
1162 return ERROR_TARGET_NOT_HALTED
;
1166 if (breakpoint
->set
)
1168 cortex_a8_unset_breakpoint(target
, breakpoint
);
1169 if (breakpoint
->type
== BKPT_HARD
)
1170 cortex_a8
->brp_num_available
++ ;
1180 * Cortex-A8 Reset fuctions
1183 static int cortex_a8_assert_reset(struct target
*target
)
1185 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
1189 /* registers are now invalid */
1190 register_cache_invalidate(armv7a
->armv4_5_common
.core_cache
);
1192 target
->state
= TARGET_RESET
;
1197 static int cortex_a8_deassert_reset(struct target
*target
)
1202 if (target
->reset_halt
)
1205 if ((retval
= target_halt(target
)) != ERROR_OK
)
1213 * Cortex-A8 Memory access
1215 * This is same Cortex M3 but we must also use the correct
1216 * ap number for every access.
1219 static int cortex_a8_read_memory(struct target
*target
, uint32_t address
,
1220 uint32_t size
, uint32_t count
, uint8_t *buffer
)
1222 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
1223 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
1224 int retval
= ERROR_INVALID_ARGUMENTS
;
1226 /* cortex_a8 handles unaligned memory access */
1228 // ??? dap_ap_select(swjdp, swjdp_memoryap);
1230 if (count
&& buffer
) {
1233 retval
= mem_ap_read_buf_u32(swjdp
, buffer
, 4 * count
, address
);
1236 retval
= mem_ap_read_buf_u16(swjdp
, buffer
, 2 * count
, address
);
1239 retval
= mem_ap_read_buf_u8(swjdp
, buffer
, count
, address
);
1247 int cortex_a8_write_memory(struct target
*target
, uint32_t address
,
1248 uint32_t size
, uint32_t count
, uint8_t *buffer
)
1250 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
1251 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
1252 int retval
= ERROR_INVALID_ARGUMENTS
;
1254 // ??? dap_ap_select(swjdp, swjdp_memoryap);
1256 if (count
&& buffer
) {
1259 retval
= mem_ap_write_buf_u32(swjdp
, buffer
, 4 * count
, address
);
1262 retval
= mem_ap_write_buf_u16(swjdp
, buffer
, 2 * count
, address
);
1265 retval
= mem_ap_write_buf_u8(swjdp
, buffer
, count
, address
);
1270 if (retval
== ERROR_OK
&& target
->state
== TARGET_HALTED
)
1272 /* The Cache handling will NOT work with MMU active, the wrong addresses will be invalidated */
1273 /* invalidate I-Cache */
1274 if (armv7a
->armv4_5_mmu
.armv4_5_cache
.i_cache_enabled
)
1276 /* Invalidate ICache single entry with MVA, repeat this for all cache
1277 lines in the address range, Cortex-A8 has fixed 64 byte line length */
1278 /* Invalidate Cache single entry with MVA to PoU */
1279 for (uint32_t cacheline
=address
; cacheline
<address
+size
*count
; cacheline
+=64)
1280 armv7a
->write_cp15(target
, 0, 1, 7, 5, cacheline
); /* I-Cache to PoU */
1282 /* invalidate D-Cache */
1283 if (armv7a
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
)
1285 /* Invalidate Cache single entry with MVA to PoC */
1286 for (uint32_t cacheline
=address
; cacheline
<address
+size
*count
; cacheline
+=64)
1287 armv7a
->write_cp15(target
, 0, 1, 7, 6, cacheline
); /* U/D cache to PoC */
1294 static int cortex_a8_bulk_write_memory(struct target
*target
, uint32_t address
,
1295 uint32_t count
, uint8_t *buffer
)
1297 return cortex_a8_write_memory(target
, address
, 4, count
, buffer
);
1301 static int cortex_a8_dcc_read(struct swjdp_common
*swjdp
, uint8_t *value
, uint8_t *ctrl
)
1306 mem_ap_read_buf_u16(swjdp
, (uint8_t*)&dcrdr
, 1, DCB_DCRDR
);
1307 *ctrl
= (uint8_t)dcrdr
;
1308 *value
= (uint8_t)(dcrdr
>> 8);
1310 LOG_DEBUG("data 0x%x ctrl 0x%x", *value
, *ctrl
);
1312 /* write ack back to software dcc register
1313 * signify we have read data */
1314 if (dcrdr
& (1 << 0))
1317 mem_ap_write_buf_u16(swjdp
, (uint8_t*)&dcrdr
, 1, DCB_DCRDR
);
1324 static int cortex_a8_handle_target_request(void *priv
)
1326 struct target
*target
= priv
;
1327 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
1328 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
1330 if (!target_was_examined(target
))
1332 if (!target
->dbg_msg_enabled
)
1335 if (target
->state
== TARGET_RUNNING
)
1340 cortex_a8_dcc_read(swjdp
, &data
, &ctrl
);
1342 /* check if we have data */
1343 if (ctrl
& (1 << 0))
1347 /* we assume target is quick enough */
1349 cortex_a8_dcc_read(swjdp
, &data
, &ctrl
);
1350 request
|= (data
<< 8);
1351 cortex_a8_dcc_read(swjdp
, &data
, &ctrl
);
1352 request
|= (data
<< 16);
1353 cortex_a8_dcc_read(swjdp
, &data
, &ctrl
);
1354 request
|= (data
<< 24);
1355 target_request(target
, request
);
1363 * Cortex-A8 target information and configuration
1366 static int cortex_a8_examine_first(struct target
*target
)
1368 struct cortex_a8_common
*cortex_a8
= target_to_cortex_a8(target
);
1369 struct armv7a_common
*armv7a
= &cortex_a8
->armv7a_common
;
1370 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
1372 int retval
= ERROR_OK
;
1373 uint32_t didr
, ctypr
, ttypr
, cpuid
;
1377 /* Here we shall insert a proper ROM Table scan */
1378 armv7a
->debug_base
= OMAP3530_DEBUG_BASE
;
1380 /* We do one extra read to ensure DAP is configured,
1381 * we call ahbap_debugport_init(swjdp) instead
1383 ahbap_debugport_init(swjdp
);
1384 mem_ap_read_atomic_u32(swjdp
, armv7a
->debug_base
+ CPUDBG_CPUID
, &cpuid
);
1385 if ((retval
= mem_ap_read_atomic_u32(swjdp
,
1386 armv7a
->debug_base
+ CPUDBG_CPUID
, &cpuid
)) != ERROR_OK
)
1388 LOG_DEBUG("Examine failed");
1392 if ((retval
= mem_ap_read_atomic_u32(swjdp
,
1393 armv7a
->debug_base
+ CPUDBG_CTYPR
, &ctypr
)) != ERROR_OK
)
1395 LOG_DEBUG("Examine failed");
1399 if ((retval
= mem_ap_read_atomic_u32(swjdp
,
1400 armv7a
->debug_base
+ CPUDBG_TTYPR
, &ttypr
)) != ERROR_OK
)
1402 LOG_DEBUG("Examine failed");
1406 if ((retval
= mem_ap_read_atomic_u32(swjdp
,
1407 armv7a
->debug_base
+ CPUDBG_DIDR
, &didr
)) != ERROR_OK
)
1409 LOG_DEBUG("Examine failed");
1413 LOG_DEBUG("cpuid = 0x%08" PRIx32
, cpuid
);
1414 LOG_DEBUG("ctypr = 0x%08" PRIx32
, ctypr
);
1415 LOG_DEBUG("ttypr = 0x%08" PRIx32
, ttypr
);
1416 LOG_DEBUG("didr = 0x%08" PRIx32
, didr
);
1418 /* Setup Breakpoint Register Pairs */
1419 cortex_a8
->brp_num
= ((didr
>> 24) & 0x0F) + 1;
1420 cortex_a8
->brp_num_context
= ((didr
>> 20) & 0x0F) + 1;
1421 cortex_a8
->brp_num_available
= cortex_a8
->brp_num
;
1422 cortex_a8
->brp_list
= calloc(cortex_a8
->brp_num
, sizeof(struct cortex_a8_brp
));
1423 // cortex_a8->brb_enabled = ????;
1424 for (i
= 0; i
< cortex_a8
->brp_num
; i
++)
1426 cortex_a8
->brp_list
[i
].used
= 0;
1427 if (i
< (cortex_a8
->brp_num
-cortex_a8
->brp_num_context
))
1428 cortex_a8
->brp_list
[i
].type
= BRP_NORMAL
;
1430 cortex_a8
->brp_list
[i
].type
= BRP_CONTEXT
;
1431 cortex_a8
->brp_list
[i
].value
= 0;
1432 cortex_a8
->brp_list
[i
].control
= 0;
1433 cortex_a8
->brp_list
[i
].BRPn
= i
;
1436 /* Setup Watchpoint Register Pairs */
1437 cortex_a8
->wrp_num
= ((didr
>> 28) & 0x0F) + 1;
1438 cortex_a8
->wrp_num_available
= cortex_a8
->wrp_num
;
1439 cortex_a8
->wrp_list
= calloc(cortex_a8
->wrp_num
, sizeof(struct cortex_a8_wrp
));
1440 for (i
= 0; i
< cortex_a8
->wrp_num
; i
++)
1442 cortex_a8
->wrp_list
[i
].used
= 0;
1443 cortex_a8
->wrp_list
[i
].type
= 0;
1444 cortex_a8
->wrp_list
[i
].value
= 0;
1445 cortex_a8
->wrp_list
[i
].control
= 0;
1446 cortex_a8
->wrp_list
[i
].WRPn
= i
;
1448 LOG_DEBUG("Configured %i hw breakpoint pairs and %i hw watchpoint pairs",
1449 cortex_a8
->brp_num
, cortex_a8
->wrp_num
);
1451 target_set_examined(target
);
1455 static int cortex_a8_examine(struct target
*target
)
1457 int retval
= ERROR_OK
;
1459 /* don't re-probe hardware after each reset */
1460 if (!target_was_examined(target
))
1461 retval
= cortex_a8_examine_first(target
);
1463 /* Configure core debug access */
1464 if (retval
== ERROR_OK
)
1465 retval
= cortex_a8_init_debug_access(target
);
1471 * Cortex-A8 target creation and initialization
1474 static void cortex_a8_build_reg_cache(struct target
*target
)
1476 struct reg_cache
**cache_p
= register_get_last_cache_p(&target
->reg_cache
);
1477 struct armv4_5_common_s
*armv4_5
= target_to_armv4_5(target
);
1479 armv4_5
->core_type
= ARM_MODE_MON
;
1481 (*cache_p
) = armv4_5_build_reg_cache(target
, armv4_5
);
1482 armv4_5
->core_cache
= (*cache_p
);
1486 static int cortex_a8_init_target(struct command_context
*cmd_ctx
,
1487 struct target
*target
)
1489 cortex_a8_build_reg_cache(target
);
1493 int cortex_a8_init_arch_info(struct target
*target
,
1494 struct cortex_a8_common
*cortex_a8
, struct jtag_tap
*tap
)
1496 struct armv7a_common
*armv7a
= &cortex_a8
->armv7a_common
;
1497 struct arm
*armv4_5
= &armv7a
->armv4_5_common
;
1498 struct swjdp_common
*swjdp
= &armv7a
->swjdp_info
;
1500 /* Setup struct cortex_a8_common */
1501 cortex_a8
->common_magic
= CORTEX_A8_COMMON_MAGIC
;
1502 armv4_5
->arch_info
= armv7a
;
1504 /* prepare JTAG information for the new target */
1505 cortex_a8
->jtag_info
.tap
= tap
;
1506 cortex_a8
->jtag_info
.scann_size
= 4;
1508 swjdp
->dp_select_value
= -1;
1509 swjdp
->ap_csw_value
= -1;
1510 swjdp
->ap_tar_value
= -1;
1511 swjdp
->jtag_info
= &cortex_a8
->jtag_info
;
1512 swjdp
->memaccess_tck
= 80;
1514 /* Number of bits for tar autoincrement, impl. dep. at least 10 */
1515 swjdp
->tar_autoincr_block
= (1 << 10);
1517 cortex_a8
->fast_reg_read
= 0;
1520 /* register arch-specific functions */
1521 armv7a
->examine_debug_reason
= NULL
;
1523 armv7a
->post_debug_entry
= cortex_a8_post_debug_entry
;
1525 armv7a
->pre_restore_context
= NULL
;
1526 armv7a
->post_restore_context
= NULL
;
1527 armv7a
->armv4_5_mmu
.armv4_5_cache
.ctype
= -1;
1528 // armv7a->armv4_5_mmu.get_ttb = armv7a_get_ttb;
1529 armv7a
->armv4_5_mmu
.read_memory
= cortex_a8_read_memory
;
1530 armv7a
->armv4_5_mmu
.write_memory
= cortex_a8_write_memory
;
1531 // armv7a->armv4_5_mmu.disable_mmu_caches = armv7a_disable_mmu_caches;
1532 // armv7a->armv4_5_mmu.enable_mmu_caches = armv7a_enable_mmu_caches;
1533 armv7a
->armv4_5_mmu
.has_tiny_pages
= 1;
1534 armv7a
->armv4_5_mmu
.mmu_enabled
= 0;
1535 armv7a
->read_cp15
= cortex_a8_read_cp15
;
1536 armv7a
->write_cp15
= cortex_a8_write_cp15
;
1539 // arm7_9->handle_target_request = cortex_a8_handle_target_request;
1541 armv4_5
->read_core_reg
= cortex_a8_read_core_reg
;
1542 armv4_5
->write_core_reg
= cortex_a8_write_core_reg
;
1544 /* REVISIT v7a setup should be in a v7a-specific routine */
1545 armv4_5_init_arch_info(target
, armv4_5
);
1546 armv7a
->common_magic
= ARMV7_COMMON_MAGIC
;
1548 target_register_timer_callback(cortex_a8_handle_target_request
, 1, 1, target
);
1553 static int cortex_a8_target_create(struct target
*target
, Jim_Interp
*interp
)
1555 struct cortex_a8_common
*cortex_a8
= calloc(1, sizeof(struct cortex_a8_common
));
1557 cortex_a8_init_arch_info(target
, cortex_a8
, target
->tap
);
1562 COMMAND_HANDLER(cortex_a8_handle_cache_info_command
)
1564 struct target
*target
= get_current_target(CMD_CTX
);
1565 struct armv7a_common
*armv7a
= target_to_armv7a(target
);
1567 return armv4_5_handle_cache_info_command(CMD_CTX
,
1568 &armv7a
->armv4_5_mmu
.armv4_5_cache
);
1572 COMMAND_HANDLER(cortex_a8_handle_dbginit_command
)
1574 struct target
*target
= get_current_target(CMD_CTX
);
1576 cortex_a8_init_debug_access(target
);
1582 static int cortex_a8_register_commands(struct command_context
*cmd_ctx
)
1584 struct command
*cortex_a8_cmd
;
1585 int retval
= ERROR_OK
;
1587 armv4_5_register_commands(cmd_ctx
);
1588 armv7a_register_commands(cmd_ctx
);
1590 cortex_a8_cmd
= register_command(cmd_ctx
, NULL
, "cortex_a8",
1592 "cortex_a8 specific commands");
1594 register_command(cmd_ctx
, cortex_a8_cmd
, "cache_info",
1595 cortex_a8_handle_cache_info_command
, COMMAND_EXEC
,
1596 "display information about target caches");
1598 register_command(cmd_ctx
, cortex_a8_cmd
, "dbginit",
1599 cortex_a8_handle_dbginit_command
, COMMAND_EXEC
,
1600 "Initialize core debug");
1605 struct target_type cortexa8_target
= {
1606 .name
= "cortex_a8",
1608 .poll
= cortex_a8_poll
,
1609 .arch_state
= armv7a_arch_state
,
1611 .target_request_data
= NULL
,
1613 .halt
= cortex_a8_halt
,
1614 .resume
= cortex_a8_resume
,
1615 .step
= cortex_a8_step
,
1617 .assert_reset
= cortex_a8_assert_reset
,
1618 .deassert_reset
= cortex_a8_deassert_reset
,
1619 .soft_reset_halt
= NULL
,
1621 .get_gdb_reg_list
= armv4_5_get_gdb_reg_list
,
1623 .read_memory
= cortex_a8_read_memory
,
1624 .write_memory
= cortex_a8_write_memory
,
1625 .bulk_write_memory
= cortex_a8_bulk_write_memory
,
1627 .checksum_memory
= arm_checksum_memory
,
1628 .blank_check_memory
= arm_blank_check_memory
,
1630 .run_algorithm
= armv4_5_run_algorithm
,
1632 .add_breakpoint
= cortex_a8_add_breakpoint
,
1633 .remove_breakpoint
= cortex_a8_remove_breakpoint
,
1634 .add_watchpoint
= NULL
,
1635 .remove_watchpoint
= NULL
,
1637 .register_commands
= cortex_a8_register_commands
,
1638 .target_create
= cortex_a8_target_create
,
1639 .init_target
= cortex_a8_init_target
,
1640 .examine
= cortex_a8_examine
,
1641 .mrc
= cortex_a8_mrc
,
1642 .mcr
= cortex_a8_mcr
,