1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2006 by Magnus Lundin *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
27 #include "replacements.h"
29 #include "cortex_m3.h"
34 #include "target_request.h"
43 int cortex_m3_register_commands(struct command_context_s
*cmd_ctx
);
45 /* forward declarations */
46 void cortex_m3_enable_breakpoints(struct target_s
*target
);
47 void cortex_m3_enable_watchpoints(struct target_s
*target
);
48 int cortex_m3_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, struct target_s
*target
);
49 int cortex_m3_init_target(struct command_context_s
*cmd_ctx
, struct target_s
*target
);
51 int cortex_m3_load_core_reg_u32(target_t
*target
, enum armv7m_regtype type
, u32 num
, u32
*value
);
52 int cortex_m3_store_core_reg_u32(target_t
*target
, enum armv7m_regtype type
, u32 num
, u32 value
);
53 int cortex_m3_target_request_data(target_t
*target
, u32 size
, u8
*buffer
);
54 int cortex_m3_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
);
56 target_type_t cortexm3_target
=
60 .poll
= cortex_m3_poll
,
61 .arch_state
= armv7m_arch_state
,
63 .target_request_data
= cortex_m3_target_request_data
,
65 .halt
= cortex_m3_halt
,
66 .resume
= cortex_m3_resume
,
67 .step
= cortex_m3_step
,
69 .assert_reset
= cortex_m3_assert_reset
,
70 .deassert_reset
= cortex_m3_deassert_reset
,
71 .soft_reset_halt
= cortex_m3_soft_reset_halt
,
73 .get_gdb_reg_list
= armv7m_get_gdb_reg_list
,
75 .read_memory
= cortex_m3_read_memory
,
76 .write_memory
= cortex_m3_write_memory
,
77 .bulk_write_memory
= cortex_m3_bulk_write_memory
,
78 .checksum_memory
= armv7m_checksum_memory
,
80 .run_algorithm
= armv7m_run_algorithm
,
82 .add_breakpoint
= cortex_m3_add_breakpoint
,
83 .remove_breakpoint
= cortex_m3_remove_breakpoint
,
84 .add_watchpoint
= cortex_m3_add_watchpoint
,
85 .remove_watchpoint
= cortex_m3_remove_watchpoint
,
87 .register_commands
= cortex_m3_register_commands
,
88 .target_command
= cortex_m3_target_command
,
89 .init_target
= cortex_m3_init_target
,
90 .examine
= cortex_m3_examine
,
91 .quit
= cortex_m3_quit
94 int cortex_m3_clear_halt(target_t
*target
)
96 /* get pointers to arch-specific information */
97 armv7m_common_t
*armv7m
= target
->arch_info
;
98 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
99 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
101 /* Read Debug Fault Status Register */
102 ahbap_read_system_atomic_u32(swjdp
, NVIC_DFSR
, &cortex_m3
->nvic_dfsr
);
103 /* Write Debug Fault Status Register to enable processing to resume ?? Try with and without this !! */
104 ahbap_write_system_atomic_u32(swjdp
, NVIC_DFSR
, cortex_m3
->nvic_dfsr
);
105 LOG_DEBUG(" NVIC_DFSR 0x%x", cortex_m3
->nvic_dfsr
);
110 int cortex_m3_single_step_core(target_t
*target
)
112 /* get pointers to arch-specific information */
113 armv7m_common_t
*armv7m
= target
->arch_info
;
114 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
115 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
117 if (!(cortex_m3
->dcb_dhcsr
& C_MASKINTS
))
118 ahbap_write_system_atomic_u32(swjdp
, DCB_DHCSR
, DBGKEY
| C_MASKINTS
| C_HALT
| C_DEBUGEN
);
119 ahbap_write_system_atomic_u32(swjdp
, DCB_DHCSR
, DBGKEY
| C_MASKINTS
| C_STEP
| C_DEBUGEN
);
120 cortex_m3
->dcb_dhcsr
|= C_MASKINTS
;
122 cortex_m3_clear_halt(target
);
127 int cortex_m3_exec_opcode(target_t
*target
,u32 opcode
, int len
/* MODE, r0_invalue, &r0_outvalue */ )
129 /* get pointers to arch-specific information */
130 armv7m_common_t
*armv7m
= target
->arch_info
;
131 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
132 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
136 ahbap_read_system_u32(swjdp
, 0x20000000, &savedram
);
137 ahbap_write_system_u32(swjdp
, 0x20000000, opcode
);
138 ahbap_write_coreregister_u32(swjdp
, 0x20000000, 15);
139 cortex_m3_single_step_core(target
);
140 armv7m
->core_cache
->reg_list
[15].dirty
= armv7m
->core_cache
->reg_list
[15].valid
;
141 retvalue
= ahbap_write_system_atomic_u32(swjdp
, 0x20000000, savedram
);
147 /* Enable interrupts */
148 int cortex_m3_cpsie(target_t
*target
, u32 IF
)
150 return cortex_m3_exec_opcode(target
, ARMV7M_T_CPSIE(IF
), 2);
153 /* Disable interrupts */
154 int cortex_m3_cpsid(target_t
*target
, u32 IF
)
156 return cortex_m3_exec_opcode(target
, ARMV7M_T_CPSID(IF
), 2);
160 int cortex_m3_endreset_event(target_t
*target
)
165 /* get pointers to arch-specific information */
166 armv7m_common_t
*armv7m
= target
->arch_info
;
167 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
168 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
169 cortex_m3_fp_comparator_t
*fp_list
= cortex_m3
->fp_comparator_list
;
170 cortex_m3_dwt_comparator_t
*dwt_list
= cortex_m3
->dwt_comparator_list
;
172 ahbap_read_system_atomic_u32(swjdp
, DCB_DEMCR
, &dcb_demcr
);
173 LOG_DEBUG("DCB_DEMCR = 0x%8.8x",dcb_demcr
);
175 ahbap_write_system_u32(swjdp
, DCB_DCRDR
, 0 );
177 /* Enable debug requests */
178 ahbap_read_system_atomic_u32(swjdp
, DCB_DHCSR
, &cortex_m3
->dcb_dhcsr
);
179 if (!(cortex_m3
->dcb_dhcsr
& C_DEBUGEN
))
180 ahbap_write_system_u32(swjdp
, DCB_DHCSR
, DBGKEY
| C_DEBUGEN
);
181 /* Enable trace and dwt */
182 ahbap_write_system_u32(swjdp
, DCB_DEMCR
, TRCENA
| VC_HARDERR
| VC_BUSERR
);
183 /* Monitor bus faults */
184 ahbap_write_system_u32(swjdp
, NVIC_SHCSR
, SHCSR_BUSFAULTENA
);
187 target_write_u32(target
, FP_CTRL
, 3);
189 /* Restore FPB registers */
190 for (i
= 0; i
< cortex_m3
->fp_num_code
+ cortex_m3
->fp_num_lit
; i
++)
192 target_write_u32(target
, fp_list
[i
].fpcr_address
, fp_list
[i
].fpcr_value
);
195 /* Restore DWT registers */
196 for (i
= 0; i
< cortex_m3
->dwt_num_comp
; i
++)
198 target_write_u32(target
, dwt_list
[i
].dwt_comparator_address
, dwt_list
[i
].comp
);
199 target_write_u32(target
, dwt_list
[i
].dwt_comparator_address
| 0x4, dwt_list
[i
].mask
);
200 target_write_u32(target
, dwt_list
[i
].dwt_comparator_address
| 0x8, dwt_list
[i
].function
);
202 swjdp_transaction_endcheck(swjdp
);
204 armv7m_invalidate_core_regs(target
);
208 int cortex_m3_examine_debug_reason(target_t
*target
)
210 /* get pointers to arch-specific information */
211 armv7m_common_t
*armv7m
= target
->arch_info
;
212 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
214 /* THIS IS NOT GOOD, TODO - better logic for detection of debug state reason */
215 /* only check the debug reason if we don't know it already */
217 if ((target
->debug_reason
!= DBG_REASON_DBGRQ
)
218 && (target
->debug_reason
!= DBG_REASON_SINGLESTEP
))
222 if (cortex_m3
->nvic_dfsr
& DFSR_BKPT
)
224 target
->debug_reason
= DBG_REASON_BREAKPOINT
;
225 if (cortex_m3
->nvic_dfsr
& DFSR_DWTTRAP
)
226 target
->debug_reason
= DBG_REASON_WPTANDBKPT
;
228 else if (cortex_m3
->nvic_dfsr
& DFSR_DWTTRAP
)
229 target
->debug_reason
= DBG_REASON_WATCHPOINT
;
235 int cortex_m3_examine_exception_reason(target_t
*target
)
237 u32 shcsr
, except_sr
, cfsr
= -1, except_ar
= -1;
239 /* get pointers to arch-specific information */
240 armv7m_common_t
*armv7m
= target
->arch_info
;
241 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
242 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
244 ahbap_read_system_u32(swjdp
, NVIC_SHCSR
, &shcsr
);
245 switch (armv7m
->exception_number
)
249 case 3: /* Hard Fault */
250 ahbap_read_system_atomic_u32(swjdp
, NVIC_HFSR
, &except_sr
);
251 if (except_sr
& 0x40000000)
253 ahbap_read_system_u32(swjdp
, NVIC_CFSR
, &cfsr
);
256 case 4: /* Memory Management */
257 ahbap_read_system_u32(swjdp
, NVIC_CFSR
, &except_sr
);
258 ahbap_read_system_u32(swjdp
, NVIC_MMFAR
, &except_ar
);
260 case 5: /* Bus Fault */
261 ahbap_read_system_u32(swjdp
, NVIC_CFSR
, &except_sr
);
262 ahbap_read_system_u32(swjdp
, NVIC_BFAR
, &except_ar
);
264 case 6: /* Usage Fault */
265 ahbap_read_system_u32(swjdp
, NVIC_CFSR
, &except_sr
);
267 case 11: /* SVCall */
269 case 12: /* Debug Monitor */
270 ahbap_read_system_u32(swjdp
, NVIC_DFSR
, &except_sr
);
272 case 14: /* PendSV */
274 case 15: /* SysTick */
280 swjdp_transaction_endcheck(swjdp
);
281 LOG_DEBUG("%s SHCSR 0x%x, SR 0x%x, CFSR 0x%x, AR 0x%x", armv7m_exception_string(armv7m
->exception_number
), \
282 shcsr
, except_sr
, cfsr
, except_ar
);
286 int cortex_m3_debug_entry(target_t
*target
)
292 /* get pointers to arch-specific information */
293 armv7m_common_t
*armv7m
= target
->arch_info
;
294 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
295 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
298 if (armv7m
->pre_debug_entry
)
299 armv7m
->pre_debug_entry(target
);
301 cortex_m3_clear_halt(target
);
302 ahbap_read_system_atomic_u32(swjdp
, DCB_DHCSR
, &cortex_m3
->dcb_dhcsr
);
304 if ((retval
= armv7m
->examine_debug_reason(target
)) != ERROR_OK
)
307 /* Examine target state and mode */
308 /* First load register acessible through core debug port*/
309 for (i
= 0; i
< ARMV7M_PRIMASK
; i
++)
311 if (!armv7m
->core_cache
->reg_list
[i
].valid
)
312 armv7m
->read_core_reg(target
, i
);
315 xPSR
= buf_get_u32(armv7m
->core_cache
->reg_list
[ARMV7M_xPSR
].value
, 0, 32);
317 /* For IT instructions xPSR must be reloaded on resume and clear on debug exec */
320 armv7m
->core_cache
->reg_list
[ARMV7M_xPSR
].dirty
= armv7m
->core_cache
->reg_list
[ARMV7M_xPSR
].valid
;
321 cortex_m3_store_core_reg_u32(target
, ARMV7M_REGISTER_CORE_GP
, 16, xPSR
&~ 0xff);
324 /* Now we can load SP core registers */
325 for (i
= ARMV7M_PRIMASK
; i
< ARMV7NUMCOREREGS
; i
++)
327 if (!armv7m
->core_cache
->reg_list
[i
].valid
)
328 armv7m
->read_core_reg(target
, i
);
331 /* Are we in an exception handler */
334 armv7m
->core_mode
= ARMV7M_MODE_HANDLER
;
335 armv7m
->exception_number
= (xPSR
& 0x1FF);
339 armv7m
->core_mode
= buf_get_u32(armv7m
->core_cache
->reg_list
[ARMV7M_CONTROL
].value
, 0, 1);
340 armv7m
->exception_number
= 0;
343 if (armv7m
->exception_number
)
345 cortex_m3_examine_exception_reason(target
);
348 LOG_DEBUG("entered debug state in core mode: %s at PC 0x%x, target->state: %s", armv7m_mode_strings
[armv7m
->core_mode
], \
349 *(u32
*)(armv7m
->core_cache
->reg_list
[15].value
), target_state_strings
[target
->state
]);
351 if (armv7m
->post_debug_entry
)
352 armv7m
->post_debug_entry(target
);
357 int cortex_m3_poll(target_t
*target
)
360 u32 prev_target_state
= target
->state
;
362 /* get pointers to arch-specific information */
363 armv7m_common_t
*armv7m
= target
->arch_info
;
364 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
365 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
367 /* Read from Debug Halting Control and Status Register */
368 retval
= ahbap_read_system_atomic_u32(swjdp
, DCB_DHCSR
, &cortex_m3
->dcb_dhcsr
);
369 if (retval
!= ERROR_OK
)
371 target
->state
= TARGET_UNKNOWN
;
375 if (cortex_m3
->dcb_dhcsr
& S_RESET_ST
)
377 /* check if still in reset */
378 ahbap_read_system_atomic_u32(swjdp
, DCB_DHCSR
, &cortex_m3
->dcb_dhcsr
);
380 if (cortex_m3
->dcb_dhcsr
& S_RESET_ST
)
382 target
->state
= TARGET_RESET
;
387 if (target
->state
== TARGET_RESET
)
389 /* Cannot switch context while running so endreset is called with target->state == TARGET_RESET */
390 LOG_DEBUG("Exit from reset with dcb_dhcsr 0x%x", cortex_m3
->dcb_dhcsr
);
391 cortex_m3_endreset_event(target
);
392 target
->state
= TARGET_RUNNING
;
393 prev_target_state
= TARGET_RUNNING
;
396 if (cortex_m3
->dcb_dhcsr
& S_HALT
)
398 target
->state
= TARGET_HALTED
;
400 if ((prev_target_state
== TARGET_RUNNING
) || (prev_target_state
== TARGET_RESET
))
402 if ((retval
= cortex_m3_debug_entry(target
)) != ERROR_OK
)
405 target_call_event_callbacks(target
, TARGET_EVENT_HALTED
);
407 if (prev_target_state
== TARGET_DEBUG_RUNNING
)
410 if ((retval
= cortex_m3_debug_entry(target
)) != ERROR_OK
)
413 target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_HALTED
);
418 if (cortex_m3->dcb_dhcsr & S_SLEEP)
419 target->state = TARGET_SLEEP;
423 /* Read Debug Fault Status Register, added to figure out the lockup when running flashtest.script */
424 ahbap_read_system_atomic_u32(swjdp
, NVIC_DFSR
, &cortex_m3
->nvic_dfsr
);
425 LOG_DEBUG("dcb_dhcsr 0x%x, nvic_dfsr 0x%x, target->state: %s", cortex_m3
->dcb_dhcsr
, cortex_m3
->nvic_dfsr
, target_state_strings
[target
->state
]);
431 int cortex_m3_halt(target_t
*target
)
433 /* get pointers to arch-specific information */
434 armv7m_common_t
*armv7m
= target
->arch_info
;
435 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
436 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
438 LOG_DEBUG("target->state: %s", target_state_strings
[target
->state
]);
440 if (target
->state
== TARGET_HALTED
)
442 LOG_DEBUG("target was already halted");
446 if (target
->state
== TARGET_UNKNOWN
)
448 LOG_WARNING("target was in unknown state when halt was requested");
451 if (target
->state
== TARGET_RESET
)
453 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && jtag_srst
)
455 LOG_ERROR("can't request a halt while in reset if nSRST pulls nTRST");
456 return ERROR_TARGET_FAILURE
;
460 /* we came here in a reset_halt or reset_init sequence
461 * debug entry was already prepared in cortex_m3_prepare_reset_halt()
463 target
->debug_reason
= DBG_REASON_DBGRQ
;
469 /* Write to Debug Halting Control and Status Register */
470 ahbap_write_system_atomic_u32(swjdp
, DCB_DHCSR
, DBGKEY
| C_DEBUGEN
| C_HALT
);
472 target
->debug_reason
= DBG_REASON_DBGRQ
;
477 int cortex_m3_soft_reset_halt(struct target_s
*target
)
479 /* get pointers to arch-specific information */
480 armv7m_common_t
*armv7m
= target
->arch_info
;
481 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
482 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
484 int retval
, timeout
= 0;
486 /* Enter debug state on reset, cf. end_reset_event() */
487 ahbap_write_system_u32(swjdp
, DCB_DEMCR
, TRCENA
| VC_HARDERR
| VC_BUSERR
| VC_CORERESET
);
489 /* Request a reset */
490 ahbap_write_system_atomic_u32(swjdp
, NVIC_AIRCR
, AIRCR_VECTKEY
| AIRCR_VECTRESET
);
491 target
->state
= TARGET_RESET
;
493 /* registers are now invalid */
494 armv7m_invalidate_core_regs(target
);
496 while (timeout
< 100)
498 retval
= ahbap_read_system_atomic_u32(swjdp
, DCB_DHCSR
, &dcb_dhcsr
);
499 if (retval
== ERROR_OK
)
501 ahbap_read_system_atomic_u32(swjdp
, NVIC_DFSR
, &cortex_m3
->nvic_dfsr
);
502 if ((dcb_dhcsr
& S_HALT
) && (cortex_m3
->nvic_dfsr
& DFSR_VCATCH
))
504 LOG_DEBUG("system reset-halted, dcb_dhcsr 0x%x, nvic_dfsr 0x%x", dcb_dhcsr
, cortex_m3
->nvic_dfsr
);
505 cortex_m3_poll(target
);
509 LOG_DEBUG("waiting for system reset-halt, dcb_dhcsr 0x%x, %i ms", dcb_dhcsr
, timeout
);
518 int cortex_m3_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
520 /* get pointers to arch-specific information */
521 armv7m_common_t
*armv7m
= target
->arch_info
;
522 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
523 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
524 breakpoint_t
*breakpoint
= NULL
;
525 u32 dcb_dhcsr
, resume_pc
;
527 if (target
->state
!= TARGET_HALTED
)
529 LOG_WARNING("target not halted");
530 return ERROR_TARGET_NOT_HALTED
;
533 if (!debug_execution
)
535 target_free_all_working_areas(target
);
536 cortex_m3_enable_breakpoints(target
);
537 cortex_m3_enable_watchpoints(target
);
539 /* TODOLATER Interrupt handling/disable for debug execution, cache ... ... */
542 dcb_dhcsr
= DBGKEY
| C_DEBUGEN
;
545 /* Disable interrupts */
547 We disable interrupts in the PRIMASK register instead of masking with C_MASKINTS,
548 This is probably the same inssue as Cortex-M3 Errata 377493:
549 C_MASKINTS in parallel with disabled interrupts can cause local faults to not be taken.
551 buf_set_u32(armv7m
->core_cache
->reg_list
[ARMV7M_PRIMASK
].value
, 0, 32, 1);
552 /* Make sure we are in Thumb mode */
553 buf_set_u32(armv7m
->core_cache
->reg_list
[ARMV7M_xPSR
].value
, 0, 32,
554 buf_get_u32(armv7m
->core_cache
->reg_list
[ARMV7M_xPSR
].value
, 0, 32) | (1<<24));
557 /* current = 1: continue on current pc, otherwise continue at <address> */
560 buf_set_u32(armv7m
->core_cache
->reg_list
[15].value
, 0, 32, address
);
561 armv7m
->core_cache
->reg_list
[15].dirty
= 1;
562 armv7m
->core_cache
->reg_list
[15].valid
= 1;
565 resume_pc
= buf_get_u32(armv7m
->core_cache
->reg_list
[15].value
, 0, 32);
567 armv7m_restore_context(target
);
569 /* the front-end may request us not to handle breakpoints */
570 if (handle_breakpoints
)
572 /* Single step past breakpoint at current address */
573 if ((breakpoint
= breakpoint_find(target
, resume_pc
)))
575 LOG_DEBUG("unset breakpoint at 0x%8.8x", breakpoint
->address
);
576 cortex_m3_unset_breakpoint(target
, breakpoint
);
577 cortex_m3_single_step_core(target
);
578 cortex_m3_set_breakpoint(target
, breakpoint
);
582 /* Set/Clear C_MASKINTS in a separate operation */
583 if ((cortex_m3
->dcb_dhcsr
& C_MASKINTS
) != (dcb_dhcsr
& C_MASKINTS
))
584 ahbap_write_system_atomic_u32(swjdp
, DCB_DHCSR
, dcb_dhcsr
| C_HALT
);
587 ahbap_write_system_atomic_u32(swjdp
, DCB_DHCSR
, dcb_dhcsr
);
588 target
->debug_reason
= DBG_REASON_NOTHALTED
;
590 /* registers are now invalid */
591 armv7m_invalidate_core_regs(target
);
592 if (!debug_execution
)
594 target
->state
= TARGET_RUNNING
;
595 target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
);
596 LOG_DEBUG("target resumed at 0x%x",resume_pc
);
600 target
->state
= TARGET_DEBUG_RUNNING
;
601 target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_RESUMED
);
602 LOG_DEBUG("target debug resumed at 0x%x",resume_pc
);
608 /* int irqstepcount=0; */
609 int cortex_m3_step(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
)
611 /* get pointers to arch-specific information */
612 armv7m_common_t
*armv7m
= target
->arch_info
;
613 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
614 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
615 breakpoint_t
*breakpoint
= NULL
;
617 if (target
->state
!= TARGET_HALTED
)
619 LOG_WARNING("target not halted");
620 return ERROR_TARGET_NOT_HALTED
;
623 /* current = 1: continue on current pc, otherwise continue at <address> */
625 buf_set_u32(armv7m
->core_cache
->reg_list
[15].value
, 0, 32, address
);
627 /* the front-end may request us not to handle breakpoints */
628 if (handle_breakpoints
)
629 if ((breakpoint
= breakpoint_find(target
, buf_get_u32(armv7m
->core_cache
->reg_list
[15].value
, 0, 32))))
630 cortex_m3_unset_breakpoint(target
, breakpoint
);
632 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
634 armv7m_restore_context(target
);
636 target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
);
638 if (cortex_m3
->dcb_dhcsr
& C_MASKINTS
)
639 ahbap_write_system_atomic_u32(swjdp
, DCB_DHCSR
, DBGKEY
| C_HALT
| C_DEBUGEN
);
640 ahbap_write_system_atomic_u32(swjdp
, DCB_DHCSR
, DBGKEY
| C_STEP
| C_DEBUGEN
);
641 ahbap_read_system_atomic_u32(swjdp
, DCB_DHCSR
, &cortex_m3
->dcb_dhcsr
);
643 /* registers are now invalid */
644 armv7m_invalidate_core_regs(target
);
647 cortex_m3_set_breakpoint(target
, breakpoint
);
649 LOG_DEBUG("target stepped dcb_dhcsr = 0x%x nvic_icsr = 0x%x", cortex_m3
->dcb_dhcsr
, cortex_m3
->nvic_icsr
);
651 cortex_m3_debug_entry(target
);
652 target_call_event_callbacks(target
, TARGET_EVENT_HALTED
);
654 LOG_DEBUG("target stepped dcb_dhcsr = 0x%x nvic_icsr = 0x%x", cortex_m3
->dcb_dhcsr
, cortex_m3
->nvic_icsr
);
658 int cortex_m3_assert_reset(target_t
*target
)
660 armv7m_common_t
*armv7m
= target
->arch_info
;
661 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
662 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
664 LOG_DEBUG("target->state: %s", target_state_strings
[target
->state
]);
666 if (!(jtag_reset_config
& RESET_HAS_SRST
))
668 LOG_ERROR("Can't assert SRST");
672 /* Enable debug requests */
673 ahbap_read_system_atomic_u32(swjdp
, DCB_DHCSR
, &cortex_m3
->dcb_dhcsr
);
674 if (!(cortex_m3
->dcb_dhcsr
& C_DEBUGEN
))
675 ahbap_write_system_u32(swjdp
, DCB_DHCSR
, DBGKEY
| C_DEBUGEN
);
677 ahbap_write_system_u32(swjdp
, DCB_DCRDR
, 0 );
679 if (target
->reset_mode
== RESET_RUN
)
681 /* Set/Clear C_MASKINTS in a separate operation */
682 if (cortex_m3
->dcb_dhcsr
& C_MASKINTS
)
683 ahbap_write_system_atomic_u32(swjdp
, DCB_DHCSR
, DBGKEY
| C_DEBUGEN
| C_HALT
);
685 cortex_m3_clear_halt(target
);
687 /* Enter debug state on reset, cf. end_reset_event() */
688 ahbap_write_system_u32(swjdp
, DCB_DEMCR
, TRCENA
| VC_HARDERR
| VC_BUSERR
);
692 /* Enter debug state on reset, cf. end_reset_event() */
693 ahbap_write_system_atomic_u32(swjdp
, DCB_DEMCR
, TRCENA
| VC_HARDERR
| VC_BUSERR
| VC_CORERESET
);
696 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
698 jtag_add_reset(1, 1);
702 jtag_add_reset(0, 1);
705 target
->state
= TARGET_RESET
;
706 jtag_add_sleep(50000);
708 armv7m_invalidate_core_regs(target
);
713 int cortex_m3_deassert_reset(target_t
*target
)
715 LOG_DEBUG("target->state: %s", target_state_strings
[target
->state
]);
717 /* deassert reset lines */
718 jtag_add_reset(0, 0);
723 void cortex_m3_enable_breakpoints(struct target_s
*target
)
725 breakpoint_t
*breakpoint
= target
->breakpoints
;
727 /* set any pending breakpoints */
730 if (breakpoint
->set
== 0)
731 cortex_m3_set_breakpoint(target
, breakpoint
);
732 breakpoint
= breakpoint
->next
;
736 int cortex_m3_set_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
741 /* get pointers to arch-specific information */
742 armv7m_common_t
*armv7m
= target
->arch_info
;
743 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
745 cortex_m3_fp_comparator_t
* comparator_list
= cortex_m3
->fp_comparator_list
;
749 LOG_WARNING("breakpoint already set");
753 if (cortex_m3
->auto_bp_type
)
755 breakpoint
->type
= (breakpoint
->address
< 0x20000000) ? BKPT_HARD
: BKPT_SOFT
;
758 if (breakpoint
->type
== BKPT_HARD
)
760 while(comparator_list
[fp_num
].used
&& (fp_num
< cortex_m3
->fp_num_code
))
762 if (fp_num
>= cortex_m3
->fp_num_code
)
764 LOG_DEBUG("ERROR Can not find free FP Comparator");
765 LOG_WARNING("ERROR Can not find free FP Comparator");
768 breakpoint
->set
= fp_num
+ 1;
769 hilo
= (breakpoint
->address
& 0x2) ? FPCR_REPLACE_BKPT_HIGH
: FPCR_REPLACE_BKPT_LOW
;
770 comparator_list
[fp_num
].used
= 1;
771 comparator_list
[fp_num
].fpcr_value
= (breakpoint
->address
& 0x1FFFFFFC) | hilo
| 1;
772 target_write_u32(target
, comparator_list
[fp_num
].fpcr_address
, comparator_list
[fp_num
].fpcr_value
);
773 LOG_DEBUG("fpc_num %i fpcr_value 0x%x", fp_num
, comparator_list
[fp_num
].fpcr_value
);
775 else if (breakpoint
->type
== BKPT_SOFT
)
778 buf_set_u32(code
, 0, 32, ARMV7M_T_BKPT(0x11));
779 target
->type
->read_memory(target
, breakpoint
->address
& 0xFFFFFFFE, breakpoint
->length
, 1, breakpoint
->orig_instr
);
780 target
->type
->write_memory(target
, breakpoint
->address
& 0xFFFFFFFE, breakpoint
->length
, 1, code
);
781 breakpoint
->set
= 0x11; /* Any nice value but 0 */
787 int cortex_m3_unset_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
789 /* get pointers to arch-specific information */
790 armv7m_common_t
*armv7m
= target
->arch_info
;
791 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
792 cortex_m3_fp_comparator_t
* comparator_list
= cortex_m3
->fp_comparator_list
;
794 if (!breakpoint
->set
)
796 LOG_WARNING("breakpoint not set");
800 if (breakpoint
->type
== BKPT_HARD
)
802 int fp_num
= breakpoint
->set
- 1;
803 if ((fp_num
< 0) || (fp_num
>= cortex_m3
->fp_num_code
))
805 LOG_DEBUG("Invalid FP Comparator number in breakpoint");
808 comparator_list
[fp_num
].used
= 0;
809 comparator_list
[fp_num
].fpcr_value
= 0;
810 target_write_u32(target
, comparator_list
[fp_num
].fpcr_address
, comparator_list
[fp_num
].fpcr_value
);
814 /* restore original instruction (kept in target endianness) */
815 if (breakpoint
->length
== 4)
817 target
->type
->write_memory(target
, breakpoint
->address
& 0xFFFFFFFE, 4, 1, breakpoint
->orig_instr
);
821 target
->type
->write_memory(target
, breakpoint
->address
& 0xFFFFFFFE, 2, 1, breakpoint
->orig_instr
);
829 int cortex_m3_add_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
831 /* get pointers to arch-specific information */
832 armv7m_common_t
*armv7m
= target
->arch_info
;
833 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
835 if (cortex_m3
->auto_bp_type
)
837 breakpoint
->type
= (breakpoint
->address
< 0x20000000) ? BKPT_HARD
: BKPT_SOFT
;
840 if ((breakpoint
->type
== BKPT_HARD
) && (breakpoint
->address
>= 0x20000000))
842 LOG_INFO("flash patch comparator requested outside code memory region");
843 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
846 if ((breakpoint
->type
== BKPT_SOFT
) && (breakpoint
->address
< 0x20000000))
848 LOG_INFO("soft breakpoint requested in code (flash) memory region");
849 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
852 if ((breakpoint
->type
== BKPT_HARD
) && (cortex_m3
->fp_code_available
< 1))
854 LOG_INFO("no flash patch comparator unit available for hardware breakpoint");
855 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
858 if ((breakpoint
->length
!= 2))
860 LOG_INFO("only breakpoints of two bytes length supported");
861 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
864 if (breakpoint
->type
== BKPT_HARD
)
865 cortex_m3
->fp_code_available
--;
866 cortex_m3_set_breakpoint(target
, breakpoint
);
871 int cortex_m3_remove_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
873 /* get pointers to arch-specific information */
874 armv7m_common_t
*armv7m
= target
->arch_info
;
875 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
877 if (target
->state
!= TARGET_HALTED
)
879 LOG_WARNING("target not halted");
880 return ERROR_TARGET_NOT_HALTED
;
883 if (cortex_m3
->auto_bp_type
)
885 breakpoint
->type
= (breakpoint
->address
< 0x20000000) ? BKPT_HARD
: BKPT_SOFT
;
890 cortex_m3_unset_breakpoint(target
, breakpoint
);
893 if (breakpoint
->type
== BKPT_HARD
)
894 cortex_m3
->fp_code_available
++;
899 int cortex_m3_set_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
904 /* get pointers to arch-specific information */
905 armv7m_common_t
*armv7m
= target
->arch_info
;
906 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
907 cortex_m3_dwt_comparator_t
* comparator_list
= cortex_m3
->dwt_comparator_list
;
911 LOG_WARNING("watchpoint already set");
915 if (watchpoint
->mask
== 0xffffffffu
)
917 while(comparator_list
[dwt_num
].used
&& (dwt_num
< cortex_m3
->dwt_num_comp
))
919 if (dwt_num
>= cortex_m3
->dwt_num_comp
)
921 LOG_DEBUG("ERROR Can not find free DWT Comparator");
922 LOG_WARNING("ERROR Can not find free DWT Comparator");
925 watchpoint
->set
= dwt_num
+ 1;
927 temp
= watchpoint
->length
;
933 comparator_list
[dwt_num
].used
= 1;
934 comparator_list
[dwt_num
].comp
= watchpoint
->address
;
935 comparator_list
[dwt_num
].mask
= mask
;
936 comparator_list
[dwt_num
].function
= watchpoint
->rw
+ 5;
937 target_write_u32(target
, comparator_list
[dwt_num
].dwt_comparator_address
, comparator_list
[dwt_num
].comp
);
938 target_write_u32(target
, comparator_list
[dwt_num
].dwt_comparator_address
|0x4, comparator_list
[dwt_num
].mask
);
939 target_write_u32(target
, comparator_list
[dwt_num
].dwt_comparator_address
|0x8, comparator_list
[dwt_num
].function
);
940 LOG_DEBUG("dwt_num %i 0x%x 0x%x 0x%x", dwt_num
, comparator_list
[dwt_num
].comp
, comparator_list
[dwt_num
].mask
, comparator_list
[dwt_num
].function
);
944 LOG_WARNING("Cannot watch data values"); /* Move this test to add_watchpoint */
952 int cortex_m3_unset_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
954 /* get pointers to arch-specific information */
955 armv7m_common_t
*armv7m
= target
->arch_info
;
956 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
957 cortex_m3_dwt_comparator_t
* comparator_list
= cortex_m3
->dwt_comparator_list
;
960 if (!watchpoint
->set
)
962 LOG_WARNING("watchpoint not set");
966 dwt_num
= watchpoint
->set
- 1;
968 if ((dwt_num
< 0) || (dwt_num
>= cortex_m3
->dwt_num_comp
))
970 LOG_DEBUG("Invalid DWT Comparator number in watchpoint");
973 comparator_list
[dwt_num
].used
= 0;
974 comparator_list
[dwt_num
].function
= 0;
975 target_write_u32(target
, comparator_list
[dwt_num
].dwt_comparator_address
|0x8, comparator_list
[dwt_num
].function
);
982 int cortex_m3_add_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
984 /* get pointers to arch-specific information */
985 armv7m_common_t
*armv7m
= target
->arch_info
;
986 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
988 if (target
->state
!= TARGET_HALTED
)
990 LOG_WARNING("target not halted");
991 return ERROR_TARGET_NOT_HALTED
;
994 if (cortex_m3
->dwt_comp_available
< 1)
996 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
999 if ((watchpoint
->length
!= 1) && (watchpoint
->length
!= 2) && (watchpoint
->length
!= 4))
1001 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1004 cortex_m3
->dwt_comp_available
--;
1009 int cortex_m3_remove_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
1011 /* get pointers to arch-specific information */
1012 armv7m_common_t
*armv7m
= target
->arch_info
;
1013 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
1015 if (target
->state
!= TARGET_HALTED
)
1017 LOG_WARNING("target not halted");
1018 return ERROR_TARGET_NOT_HALTED
;
1021 if (watchpoint
->set
)
1023 cortex_m3_unset_watchpoint(target
, watchpoint
);
1026 cortex_m3
->dwt_comp_available
++;
1031 void cortex_m3_enable_watchpoints(struct target_s
*target
)
1033 watchpoint_t
*watchpoint
= target
->watchpoints
;
1035 /* set any pending watchpoints */
1038 if (watchpoint
->set
== 0)
1039 cortex_m3_set_watchpoint(target
, watchpoint
);
1040 watchpoint
= watchpoint
->next
;
1044 int cortex_m3_load_core_reg_u32(struct target_s
*target
, enum armv7m_regtype type
, u32 num
, u32
* value
)
1047 /* get pointers to arch-specific information */
1048 armv7m_common_t
*armv7m
= target
->arch_info
;
1049 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
1050 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
1052 if ((type
== ARMV7M_REGISTER_CORE_GP
) && (num
<= ARMV7M_PSP
))
1054 /* read a normal core register */
1055 retval
= ahbap_read_coreregister_u32(swjdp
, value
, num
);
1057 if (retval
!= ERROR_OK
)
1059 LOG_ERROR("JTAG failure %i",retval
);
1060 return ERROR_JTAG_DEVICE_ERROR
;
1062 LOG_DEBUG("load from core reg %i value 0x%x",num
,*value
);
1064 else if (type
== ARMV7M_REGISTER_CORE_SP
) /* Special purpose core register */
1066 /* read other registers */
1067 ahbap_read_coreregister_u32(swjdp
, value
, 20);
1072 *value
= buf_get_u32((u8
*)value
, 0, 8);
1076 *value
= buf_get_u32((u8
*)value
, 8, 8);
1080 *value
= buf_get_u32((u8
*)value
, 16, 8);
1084 *value
= buf_get_u32((u8
*)value
, 24, 8);
1088 LOG_DEBUG("load from special reg %i value 0x%x", num
, *value
);
1092 return ERROR_INVALID_ARGUMENTS
;
1098 int cortex_m3_store_core_reg_u32(struct target_s
*target
, enum armv7m_regtype type
, u32 num
, u32 value
)
1103 /* get pointers to arch-specific information */
1104 armv7m_common_t
*armv7m
= target
->arch_info
;
1105 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
1106 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
1108 if ((type
== ARMV7M_REGISTER_CORE_GP
) && (num
<= ARMV7M_PSP
))
1110 retval
= ahbap_write_coreregister_u32(swjdp
, value
, num
);
1111 if (retval
!= ERROR_OK
)
1113 LOG_ERROR("JTAG failure %i", retval
);
1114 armv7m
->core_cache
->reg_list
[num
].dirty
= armv7m
->core_cache
->reg_list
[num
].valid
;
1115 return ERROR_JTAG_DEVICE_ERROR
;
1117 LOG_DEBUG("write core reg %i value 0x%x", num
, value
);
1119 else if (type
== ARMV7M_REGISTER_CORE_SP
) /* Special purpose core register */
1121 /* write other registers */
1123 ahbap_read_coreregister_u32(swjdp
, ®
, 20);
1128 buf_set_u32((u8
*)®
, 0, 8, value
);
1132 buf_set_u32((u8
*)®
, 8, 8, value
);
1136 buf_set_u32((u8
*)®
, 16, 8, value
);
1140 buf_set_u32((u8
*)®
, 24, 8, value
);
1144 ahbap_write_coreregister_u32(swjdp
, reg
, 20);
1146 LOG_DEBUG("write special reg %i value 0x%x ", num
, value
);
1150 return ERROR_INVALID_ARGUMENTS
;
1156 int cortex_m3_read_memory(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
1158 /* get pointers to arch-specific information */
1159 armv7m_common_t
*armv7m
= target
->arch_info
;
1160 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
1161 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
1164 /* sanitize arguments */
1165 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
1166 return ERROR_INVALID_ARGUMENTS
;
1168 /* cortex_m3 handles unaligned memory access */
1173 retval
= ahbap_read_buf_u32(swjdp
, buffer
, 4 * count
, address
);
1176 retval
= ahbap_read_buf_u16(swjdp
, buffer
, 2 * count
, address
);
1179 retval
= ahbap_read_buf_u8(swjdp
, buffer
, count
, address
);
1182 LOG_ERROR("BUG: we shouldn't get here");
1189 int cortex_m3_write_memory(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
1191 /* get pointers to arch-specific information */
1192 armv7m_common_t
*armv7m
= target
->arch_info
;
1193 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
1194 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
1197 /* sanitize arguments */
1198 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
1199 return ERROR_INVALID_ARGUMENTS
;
1204 retval
= ahbap_write_buf_u32(swjdp
, buffer
, 4 * count
, address
);
1207 retval
= ahbap_write_buf_u16(swjdp
, buffer
, 2 * count
, address
);
1210 retval
= ahbap_write_buf_u8(swjdp
, buffer
, count
, address
);
1213 LOG_ERROR("BUG: we shouldn't get here");
1220 int cortex_m3_bulk_write_memory(target_t
*target
, u32 address
, u32 count
, u8
*buffer
)
1222 return cortex_m3_write_memory(target
, address
, 4, count
, buffer
);
1225 void cortex_m3_build_reg_cache(target_t
*target
)
1227 armv7m_build_reg_cache(target
);
1230 int cortex_m3_init_target(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
1232 cortex_m3_build_reg_cache(target
);
1236 int cortex_m3_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
1239 u32 cpuid
, fpcr
, dwtcr
, ictr
;
1242 /* get pointers to arch-specific information */
1243 armv7m_common_t
*armv7m
= target
->arch_info
;
1244 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
1245 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
1247 target
->type
->examined
= 1;
1249 if ((retval
=ahbap_debugport_init(swjdp
))!=ERROR_OK
)
1252 /* Read from Device Identification Registers */
1253 if ((retval
=target_read_u32(target
, CPUID
, &cpuid
))!=ERROR_OK
)
1256 if (((cpuid
>> 4) & 0xc3f) == 0xc23)
1257 LOG_DEBUG("CORTEX-M3 processor detected");
1258 LOG_DEBUG("cpuid: 0x%8.8x", cpuid
);
1260 target_read_u32(target
, NVIC_ICTR
, &ictr
);
1261 cortex_m3
->intlinesnum
= (ictr
& 0x1F) + 1;
1262 cortex_m3
->intsetenable
= calloc(cortex_m3
->intlinesnum
, 4);
1263 for (i
= 0; i
< cortex_m3
->intlinesnum
; i
++)
1265 target_read_u32(target
, NVIC_ISE0
+ 4 * i
, cortex_m3
->intsetenable
+ i
);
1266 LOG_DEBUG("interrupt enable[%i] = 0x%8.8x", i
, cortex_m3
->intsetenable
[i
]);
1270 target_read_u32(target
, FP_CTRL
, &fpcr
);
1271 cortex_m3
->auto_bp_type
= 1;
1272 cortex_m3
->fp_num_code
= (fpcr
>> 4) & 0xF;
1273 cortex_m3
->fp_num_lit
= (fpcr
>> 8) & 0xF;
1274 cortex_m3
->fp_code_available
= cortex_m3
->fp_num_code
;
1275 cortex_m3
->fp_comparator_list
= calloc(cortex_m3
->fp_num_code
+ cortex_m3
->fp_num_lit
, sizeof(cortex_m3_fp_comparator_t
));
1276 for (i
= 0; i
< cortex_m3
->fp_num_code
+ cortex_m3
->fp_num_lit
; i
++)
1278 cortex_m3
->fp_comparator_list
[i
].type
= (i
< cortex_m3
->fp_num_code
) ? FPCR_CODE
: FPCR_LITERAL
;
1279 cortex_m3
->fp_comparator_list
[i
].fpcr_address
= FP_COMP0
+ 4 * i
;
1281 LOG_DEBUG("FPB fpcr 0x%x, numcode %i, numlit %i", fpcr
, cortex_m3
->fp_num_code
, cortex_m3
->fp_num_lit
);
1284 target_read_u32(target
, DWT_CTRL
, &dwtcr
);
1285 cortex_m3
->dwt_num_comp
= (dwtcr
>> 28) & 0xF;
1286 cortex_m3
->dwt_comp_available
= cortex_m3
->dwt_num_comp
;
1287 cortex_m3
->dwt_comparator_list
=calloc(cortex_m3
->dwt_num_comp
, sizeof(cortex_m3_dwt_comparator_t
));
1288 for (i
= 0; i
< cortex_m3
->dwt_num_comp
; i
++)
1290 cortex_m3
->dwt_comparator_list
[i
].dwt_comparator_address
= DWT_COMP0
+ 0x10 * i
;
1297 int cortex_m3_quit()
1303 int cortex_m3_dcc_read(swjdp_common_t
*swjdp
, u8
*value
, u8
*ctrl
)
1307 ahbap_read_buf_u16( swjdp
, (u8
*)&dcrdr
, 1, DCB_DCRDR
);
1309 *value
= (u8
)(dcrdr
>> 8);
1311 LOG_DEBUG("data 0x%x ctrl 0x%x", *value
, *ctrl
);
1313 /* write ack back to software dcc register
1314 * signify we have read data */
1315 if (dcrdr
& (1 << 0))
1318 ahbap_write_buf_u16( swjdp
, (u8
*)&dcrdr
, 1, DCB_DCRDR
);
1324 int cortex_m3_target_request_data(target_t
*target
, u32 size
, u8
*buffer
)
1326 armv7m_common_t
*armv7m
= target
->arch_info
;
1327 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
1328 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
1333 for (i
= 0; i
< (size
* 4); i
++)
1335 cortex_m3_dcc_read(swjdp
, &data
, &ctrl
);
1342 int cortex_m3_handle_target_request(void *priv
)
1344 target_t
*target
= priv
;
1345 if (!target
->type
->examined
)
1347 armv7m_common_t
*armv7m
= target
->arch_info
;
1348 cortex_m3_common_t
*cortex_m3
= armv7m
->arch_info
;
1349 swjdp_common_t
*swjdp
= &cortex_m3
->swjdp_info
;
1351 if (!target
->dbg_msg_enabled
)
1354 if (target
->state
== TARGET_RUNNING
)
1359 cortex_m3_dcc_read(swjdp
, &data
, &ctrl
);
1361 /* check if we have data */
1362 if (ctrl
& (1 << 0))
1366 /* we assume target is quick enough */
1368 cortex_m3_dcc_read(swjdp
, &data
, &ctrl
);
1369 request
|= (data
<< 8);
1370 cortex_m3_dcc_read(swjdp
, &data
, &ctrl
);
1371 request
|= (data
<< 16);
1372 cortex_m3_dcc_read(swjdp
, &data
, &ctrl
);
1373 request
|= (data
<< 24);
1374 target_request(target
, request
);
1381 int cortex_m3_init_arch_info(target_t
*target
, cortex_m3_common_t
*cortex_m3
, int chain_pos
, char *variant
)
1383 armv7m_common_t
*armv7m
;
1384 armv7m
= &cortex_m3
->armv7m
;
1386 /* prepare JTAG information for the new target */
1387 cortex_m3
->jtag_info
.chain_pos
= chain_pos
;
1388 cortex_m3
->jtag_info
.scann_size
= 4;
1390 cortex_m3
->swjdp_info
.dp_select_value
= -1;
1391 cortex_m3
->swjdp_info
.ap_csw_value
= -1;
1392 cortex_m3
->swjdp_info
.ap_tar_value
= -1;
1393 cortex_m3
->swjdp_info
.jtag_info
= &cortex_m3
->jtag_info
;
1395 /* initialize arch-specific breakpoint handling */
1397 cortex_m3
->common_magic
= CORTEX_M3_COMMON_MAGIC
;
1398 cortex_m3
->arch_info
= NULL
;
1400 /* register arch-specific functions */
1401 armv7m
->examine_debug_reason
= cortex_m3_examine_debug_reason
;
1403 armv7m
->pre_debug_entry
= NULL
;
1404 armv7m
->post_debug_entry
= NULL
;
1406 armv7m
->pre_restore_context
= NULL
;
1407 armv7m
->post_restore_context
= NULL
;
1409 armv7m_init_arch_info(target
, armv7m
);
1410 armv7m
->arch_info
= cortex_m3
;
1411 armv7m
->load_core_reg_u32
= cortex_m3_load_core_reg_u32
;
1412 armv7m
->store_core_reg_u32
= cortex_m3_store_core_reg_u32
;
1414 target_register_timer_callback(cortex_m3_handle_target_request
, 1, 1, target
);
1419 /* target cortex_m3 <endianess> <startup_mode> <chain_pos> <variant>*/
1420 int cortex_m3_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, struct target_s
*target
)
1423 char *variant
= NULL
;
1424 cortex_m3_common_t
*cortex_m3
= malloc(sizeof(cortex_m3_common_t
));
1425 memset(cortex_m3
, 0, sizeof(*cortex_m3
));
1429 LOG_ERROR("'target cortex_m3' requires at least one additional argument");
1433 chain_pos
= strtoul(args
[3], NULL
, 0);
1438 cortex_m3_init_arch_info(target
, cortex_m3
, chain_pos
, variant
);
1439 cortex_m3_register_commands(cmd_ctx
);
1444 int cortex_m3_register_commands(struct command_context_s
*cmd_ctx
)
1448 retval
= armv7m_register_commands(cmd_ctx
);
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)