1 /***************************************************************************
2 * Copyright (C) 2008 by Spencer Oliver *
3 * spen@spen-soft.co.uk *
5 * Copyright (C) 2008 by David T.L. Wong *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program; if not, write to the *
19 * Free Software Foundation, Inc., *
20 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
21 ***************************************************************************/
28 #include "mips32_dmaacc.h"
37 /* forward declarations */
38 int mips_m4k_poll(target_t
*target
);
39 int mips_m4k_halt(struct target_s
*target
);
40 int mips_m4k_soft_reset_halt(struct target_s
*target
);
41 int mips_m4k_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
);
42 int mips_m4k_step(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
);
43 int mips_m4k_read_memory(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
);
44 int mips_m4k_write_memory(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
);
45 int mips_m4k_register_commands(struct command_context_s
*cmd_ctx
);
46 int mips_m4k_init_target(struct command_context_s
*cmd_ctx
, struct target_s
*target
);
47 int mips_m4k_quit(void);
48 int mips_m4k_target_create(struct target_s
*target
, Jim_Interp
*interp
);
50 int mips_m4k_examine(struct target_s
*target
);
51 int mips_m4k_assert_reset(target_t
*target
);
52 int mips_m4k_deassert_reset(target_t
*target
);
54 target_type_t mips_m4k_target
=
58 .poll
= mips_m4k_poll
,
59 .arch_state
= mips32_arch_state
,
61 .target_request_data
= NULL
,
63 .halt
= mips_m4k_halt
,
64 .resume
= mips_m4k_resume
,
65 .step
= mips_m4k_step
,
67 .assert_reset
= mips_m4k_assert_reset
,
68 .deassert_reset
= mips_m4k_deassert_reset
,
69 .soft_reset_halt
= mips_m4k_soft_reset_halt
,
71 .get_gdb_reg_list
= mips32_get_gdb_reg_list
,
73 .read_memory
= mips_m4k_read_memory
,
74 .write_memory
= mips_m4k_write_memory
,
75 .bulk_write_memory
= mips_m4k_bulk_write_memory
,
76 .checksum_memory
= NULL
,
77 .blank_check_memory
= NULL
,
79 .run_algorithm
= mips32_run_algorithm
,
81 .add_breakpoint
= mips_m4k_add_breakpoint
,
82 .remove_breakpoint
= mips_m4k_remove_breakpoint
,
83 .add_watchpoint
= mips_m4k_add_watchpoint
,
84 .remove_watchpoint
= mips_m4k_remove_watchpoint
,
86 .register_commands
= mips_m4k_register_commands
,
87 .target_create
= mips_m4k_target_create
,
88 .init_target
= mips_m4k_init_target
,
89 .examine
= mips_m4k_examine
,
93 int mips_m4k_debug_entry(target_t
*target
)
96 mips32_common_t
*mips32
= target
->arch_info
;
97 mips_ejtag_t
*ejtag_info
= &mips32
->ejtag_info
;
99 /* read debug register */
100 mips_ejtag_read_debug(ejtag_info
, &debug_reg
);
102 if ((target
->debug_reason
!= DBG_REASON_DBGRQ
)
103 && (target
->debug_reason
!= DBG_REASON_SINGLESTEP
))
105 // if (cortex_m3->nvic_dfsr & DFSR_BKPT)
107 // target->debug_reason = DBG_REASON_BREAKPOINT;
108 // if (cortex_m3->nvic_dfsr & DFSR_DWTTRAP)
109 // target->debug_reason = DBG_REASON_WPTANDBKPT;
111 // else if (cortex_m3->nvic_dfsr & DFSR_DWTTRAP)
112 // target->debug_reason = DBG_REASON_WATCHPOINT;
115 if (debug_reg
& EJTAG_DEBUG_DSS
)
117 /* stopped due to single step - clear step bit */
118 mips_ejtag_config_step(ejtag_info
, 0);
121 mips32_save_context(target
);
123 LOG_DEBUG("entered debug state at PC 0x%x, target->state: %s",
124 *(u32
*)(mips32
->core_cache
->reg_list
[MIPS32_PC
].value
),
125 Jim_Nvp_value2name_simple( nvp_target_state
, target
->state
)->name
);
130 int mips_m4k_poll(target_t
*target
)
133 mips32_common_t
*mips32
= target
->arch_info
;
134 mips_ejtag_t
*ejtag_info
= &mips32
->ejtag_info
;
135 u32 ejtag_ctrl
= ejtag_info
->ejtag_ctrl
;
137 /* read ejtag control reg */
138 jtag_add_end_state(TAP_RTI
);
139 mips_ejtag_set_instr(ejtag_info
, EJTAG_INST_CONTROL
, NULL
);
140 mips_ejtag_drscan_32(ejtag_info
, &ejtag_ctrl
);
142 if (ejtag_ctrl
& EJTAG_CTRL_BRKST
)
144 if ((target
->state
== TARGET_RUNNING
) || (target
->state
== TARGET_RESET
))
146 jtag_add_end_state(TAP_RTI
);
147 mips_ejtag_set_instr(ejtag_info
, EJTAG_INST_NORMALBOOT
, NULL
);
149 target
->state
= TARGET_HALTED
;
151 if ((retval
= mips_m4k_debug_entry(target
)) != ERROR_OK
)
154 target_call_event_callbacks(target
, TARGET_EVENT_HALTED
);
156 else if (target
->state
== TARGET_DEBUG_RUNNING
)
158 target
->state
= TARGET_HALTED
;
160 if ((retval
= mips_m4k_debug_entry(target
)) != ERROR_OK
)
163 target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_HALTED
);
168 target
->state
= TARGET_RUNNING
;
171 if (ejtag_ctrl
& EJTAG_CTRL_ROCC
)
173 /* we have detected a reset, clear flag
174 * otherwise ejtag will not work */
175 jtag_add_end_state(TAP_RTI
);
176 ejtag_ctrl
= ejtag_info
->ejtag_ctrl
& ~EJTAG_CTRL_ROCC
;
178 mips_ejtag_set_instr(ejtag_info
, EJTAG_INST_CONTROL
, NULL
);
179 mips_ejtag_drscan_32(ejtag_info
, &ejtag_ctrl
);
180 LOG_DEBUG("Reset Detected");
183 // LOG_DEBUG("ctrl=0x%08X", ejtag_ctrl);
188 int mips_m4k_halt(struct target_s
*target
)
190 mips32_common_t
*mips32
= target
->arch_info
;
191 mips_ejtag_t
*ejtag_info
= &mips32
->ejtag_info
;
193 LOG_DEBUG("target->state: %s",
194 Jim_Nvp_value2name_simple( nvp_target_state
, target
->state
)->name
);
196 if (target
->state
== TARGET_HALTED
)
198 LOG_DEBUG("target was already halted");
202 if (target
->state
== TARGET_UNKNOWN
)
204 LOG_WARNING("target was in unknown state when halt was requested");
207 if (target
->state
== TARGET_RESET
)
209 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && jtag_srst
)
211 LOG_ERROR("can't request a halt while in reset if nSRST pulls nTRST");
212 return ERROR_TARGET_FAILURE
;
216 /* we came here in a reset_halt or reset_init sequence
217 * debug entry was already prepared in mips32_prepare_reset_halt()
219 target
->debug_reason
= DBG_REASON_DBGRQ
;
225 /* break processor */
226 mips_ejtag_enter_debug(ejtag_info
);
228 target
->debug_reason
= DBG_REASON_DBGRQ
;
233 int mips_m4k_assert_reset(target_t
*target
)
235 mips32_common_t
*mips32
= target
->arch_info
;
236 mips_ejtag_t
*ejtag_info
= &mips32
->ejtag_info
;
237 mips_m4k_common_t
*mips_m4k
= mips32
->arch_info
;
239 LOG_DEBUG("target->state: %s",
240 Jim_Nvp_value2name_simple( nvp_target_state
, target
->state
)->name
);
242 if (!(jtag_reset_config
& RESET_HAS_SRST
))
244 LOG_ERROR("Can't assert SRST");
248 if (target
->reset_halt
)
250 /* use hardware to catch reset */
251 jtag_add_end_state(TAP_RTI
);
252 mips_ejtag_set_instr(ejtag_info
, EJTAG_INST_EJTAGBOOT
, NULL
);
256 jtag_add_end_state(TAP_RTI
);
257 mips_ejtag_set_instr(ejtag_info
, EJTAG_INST_NORMALBOOT
, NULL
);
260 if (strcmp(mips_m4k
->variant
, "ejtag_srst") == 0)
262 u32 ejtag_ctrl
= ejtag_info
->ejtag_ctrl
| EJTAG_CTRL_PRRST
| EJTAG_CTRL_PERRST
;
263 LOG_DEBUG("Using EJTAG reset (PRRST) to reset processor...");
264 mips_ejtag_set_instr(ejtag_info
, EJTAG_INST_CONTROL
, NULL
);
265 mips_ejtag_drscan_32(ejtag_info
, &ejtag_ctrl
);
269 /* here we should issue a srst only, but we may have to assert trst as well */
270 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
272 jtag_add_reset(1, 1);
276 jtag_add_reset(0, 1);
280 target
->state
= TARGET_RESET
;
281 jtag_add_sleep(50000);
283 mips32_invalidate_core_regs(target
);
285 if (target
->reset_halt
)
288 if ((retval
= target_halt(target
))!=ERROR_OK
)
296 int mips_m4k_deassert_reset(target_t
*target
)
298 LOG_DEBUG("target->state: %s",
299 Jim_Nvp_value2name_simple( nvp_target_state
, target
->state
)->name
);
301 /* deassert reset lines */
302 jtag_add_reset(0, 0);
307 int mips_m4k_soft_reset_halt(struct target_s
*target
)
313 int mips_m4k_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
315 mips32_common_t
*mips32
= target
->arch_info
;
316 mips_ejtag_t
*ejtag_info
= &mips32
->ejtag_info
;
317 breakpoint_t
*breakpoint
= NULL
;
320 if (target
->state
!= TARGET_HALTED
)
322 LOG_WARNING("target not halted");
323 return ERROR_TARGET_NOT_HALTED
;
326 if (!debug_execution
)
328 target_free_all_working_areas(target
);
329 mips_m4k_enable_breakpoints(target
);
330 mips_m4k_enable_watchpoints(target
);
333 /* current = 1: continue on current pc, otherwise continue at <address> */
336 buf_set_u32(mips32
->core_cache
->reg_list
[MIPS32_PC
].value
, 0, 32, address
);
337 mips32
->core_cache
->reg_list
[MIPS32_PC
].dirty
= 1;
338 mips32
->core_cache
->reg_list
[MIPS32_PC
].valid
= 1;
341 resume_pc
= buf_get_u32(mips32
->core_cache
->reg_list
[MIPS32_PC
].value
, 0, 32);
343 mips32_restore_context(target
);
345 /* the front-end may request us not to handle breakpoints */
346 if (handle_breakpoints
)
348 /* Single step past breakpoint at current address */
349 if ((breakpoint
= breakpoint_find(target
, resume_pc
)))
351 LOG_DEBUG("unset breakpoint at 0x%8.8x", breakpoint
->address
);
352 mips_m4k_unset_breakpoint(target
, breakpoint
);
353 //mips_m4k_single_step_core(target);
354 mips_m4k_set_breakpoint(target
, breakpoint
);
358 /* exit debug mode - enable interrupts if required */
359 mips_ejtag_exit_debug(ejtag_info
, !debug_execution
);
361 /* registers are now invalid */
362 mips32_invalidate_core_regs(target
);
364 if (!debug_execution
)
366 target
->state
= TARGET_RUNNING
;
367 target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
);
368 LOG_DEBUG("target resumed at 0x%x", resume_pc
);
372 target
->state
= TARGET_DEBUG_RUNNING
;
373 target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_RESUMED
);
374 LOG_DEBUG("target debug resumed at 0x%x", resume_pc
);
380 int mips_m4k_step(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
)
382 /* get pointers to arch-specific information */
383 mips32_common_t
*mips32
= target
->arch_info
;
384 mips_ejtag_t
*ejtag_info
= &mips32
->ejtag_info
;
385 breakpoint_t
*breakpoint
= NULL
;
387 if (target
->state
!= TARGET_HALTED
)
389 LOG_WARNING("target not halted");
390 return ERROR_TARGET_NOT_HALTED
;
393 /* current = 1: continue on current pc, otherwise continue at <address> */
395 buf_set_u32(mips32
->core_cache
->reg_list
[MIPS32_PC
].value
, 0, 32, address
);
397 /* the front-end may request us not to handle breakpoints */
398 if (handle_breakpoints
)
399 if ((breakpoint
= breakpoint_find(target
, buf_get_u32(mips32
->core_cache
->reg_list
[MIPS32_PC
].value
, 0, 32))))
400 mips_m4k_unset_breakpoint(target
, breakpoint
);
402 /* restore context */
403 mips32_restore_context(target
);
405 /* configure single step mode */
406 mips_ejtag_config_step(ejtag_info
, 1);
408 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
410 target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
);
412 /* exit debug mode */
413 mips_ejtag_exit_debug(ejtag_info
, 1);
415 /* registers are now invalid */
416 mips32_invalidate_core_regs(target
);
419 mips_m4k_set_breakpoint(target
, breakpoint
);
421 LOG_DEBUG("target stepped ");
423 mips_m4k_debug_entry(target
);
424 target_call_event_callbacks(target
, TARGET_EVENT_HALTED
);
429 void mips_m4k_enable_breakpoints(struct target_s
*target
)
431 breakpoint_t
*breakpoint
= target
->breakpoints
;
433 /* set any pending breakpoints */
436 if (breakpoint
->set
== 0)
437 mips_m4k_set_breakpoint(target
, breakpoint
);
438 breakpoint
= breakpoint
->next
;
442 int mips_m4k_set_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
448 int mips_m4k_unset_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
454 int mips_m4k_add_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
460 int mips_m4k_remove_breakpoint(struct target_s
*target
, breakpoint_t
*breakpoint
)
466 int mips_m4k_set_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
472 int mips_m4k_unset_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
478 int mips_m4k_add_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
484 int mips_m4k_remove_watchpoint(struct target_s
*target
, watchpoint_t
*watchpoint
)
490 void mips_m4k_enable_watchpoints(struct target_s
*target
)
492 watchpoint_t
*watchpoint
= target
->watchpoints
;
494 /* set any pending watchpoints */
497 if (watchpoint
->set
== 0)
498 mips_m4k_set_watchpoint(target
, watchpoint
);
499 watchpoint
= watchpoint
->next
;
503 int mips_m4k_read_memory(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
505 mips32_common_t
*mips32
= target
->arch_info
;
506 mips_ejtag_t
*ejtag_info
= &mips32
->ejtag_info
;
508 LOG_DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address
, size
, count
);
510 if (target
->state
!= TARGET_HALTED
)
512 LOG_WARNING("target not halted");
513 return ERROR_TARGET_NOT_HALTED
;
516 /* sanitize arguments */
517 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
518 return ERROR_INVALID_ARGUMENTS
;
520 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
521 return ERROR_TARGET_UNALIGNED_ACCESS
;
528 /* if noDMA off, use DMAACC mode for memory read */
529 if(ejtag_info
->impcode
& EJTAG_IMP_NODMA
)
530 return mips32_pracc_read_mem(ejtag_info
, address
, size
, count
, (void *)buffer
);
532 return mips32_dmaacc_read_mem(ejtag_info
, address
, size
, count
, (void *)buffer
);
534 LOG_ERROR("BUG: we shouldn't get here");
542 int mips_m4k_write_memory(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
544 mips32_common_t
*mips32
= target
->arch_info
;
545 mips_ejtag_t
*ejtag_info
= &mips32
->ejtag_info
;
547 LOG_DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address
, size
, count
);
549 if (target
->state
!= TARGET_HALTED
)
551 LOG_WARNING("target not halted");
552 return ERROR_TARGET_NOT_HALTED
;
555 /* sanitize arguments */
556 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
557 return ERROR_INVALID_ARGUMENTS
;
559 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
560 return ERROR_TARGET_UNALIGNED_ACCESS
;
567 /* if noDMA off, use DMAACC mode for memory write */
568 if(ejtag_info
->impcode
& EJTAG_IMP_NODMA
)
569 mips32_pracc_write_mem(ejtag_info
, address
, size
, count
, (void *)buffer
);
571 mips32_dmaacc_write_mem(ejtag_info
, address
, size
, count
, (void *)buffer
);
574 LOG_ERROR("BUG: we shouldn't get here");
582 int mips_m4k_register_commands(struct command_context_s
*cmd_ctx
)
586 retval
= mips32_register_commands(cmd_ctx
);
590 int mips_m4k_init_target(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
592 mips32_build_reg_cache(target
);
597 int mips_m4k_quit(void)
602 int mips_m4k_init_arch_info(target_t
*target
, mips_m4k_common_t
*mips_m4k
, int chain_pos
, const char *variant
)
604 mips32_common_t
*mips32
= &mips_m4k
->mips32_common
;
608 mips_m4k
->variant
= strdup(variant
);
612 mips_m4k
->variant
= strdup("");
615 mips_m4k
->common_magic
= MIPSM4K_COMMON_MAGIC
;
617 /* initialize mips4k specific info */
618 mips32_init_arch_info(target
, mips32
, chain_pos
, variant
);
619 mips32
->arch_info
= mips_m4k
;
624 int mips_m4k_target_create(struct target_s
*target
, Jim_Interp
*interp
)
626 mips_m4k_common_t
*mips_m4k
= calloc(1,sizeof(mips_m4k_common_t
));
628 mips_m4k_init_arch_info(target
, mips_m4k
, target
->chain_position
, target
->variant
);
633 int mips_m4k_examine(struct target_s
*target
)
636 mips32_common_t
*mips32
= target
->arch_info
;
637 mips_ejtag_t
*ejtag_info
= &mips32
->ejtag_info
;
640 target
->type
->examined
= 1;
642 mips_ejtag_get_idcode(ejtag_info
, &idcode
, NULL
);
644 if (((idcode
>> 1) & 0x7FF) == 0x29)
646 /* we are using a pic32mx so select ejtag port
647 * as it is not selected by default */
648 mips_ejtag_set_instr(ejtag_info
, 0x05, NULL
);
649 LOG_DEBUG("PIC32MX Detected - using EJTAG Interface");
652 /* init rest of ejtag interface */
653 if ((retval
= mips_ejtag_init(ejtag_info
)) != ERROR_OK
)
659 int mips_m4k_bulk_write_memory(target_t
*target
, u32 address
, u32 count
, u8
*buffer
)
661 return mips_m4k_write_memory(target
, address
, 4, count
, buffer
);
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)