1 /***************************************************************************
2 * Copyright (C) 2013 Andes Technology *
3 * Hsiangkai Wang <hkwang@andestech.com> *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
19 ***************************************************************************/
25 #include "breakpoints.h"
26 #include "nds32_reg.h"
27 #include "nds32_disassembler.h"
29 #include "nds32_aice.h"
30 #include "nds32_v3_common.h"
32 static struct breakpoint syscall_breakpoint
= {
44 static struct nds32_v3_common_callback
*v3_common_callback
;
46 static int nds32_v3_register_mapping(struct nds32
*nds32
, int reg_no
)
54 static int nds32_v3_get_debug_reason(struct nds32
*nds32
, uint32_t *reason
)
57 struct aice_port_s
*aice
= target_to_aice(nds32
->target
);
58 aice_read_debug_reg(aice
, NDS_EDM_SR_EDMSW
, &edmsw
);
60 *reason
= (edmsw
>> 12) & 0x0F;
66 * Save processor state. This is called after a HALT instruction
67 * succeeds, and on other occasions the processor enters debug mode
68 * (breakpoint, watchpoint, etc).
70 static int nds32_v3_debug_entry(struct nds32
*nds32
, bool enable_watchpoint
)
72 LOG_DEBUG("nds32_v3_debug_entry");
74 enum target_state backup_state
= nds32
->target
->state
;
75 nds32
->target
->state
= TARGET_HALTED
;
77 if (nds32
->init_arch_info_after_halted
== false) {
78 /* init architecture info according to config registers */
79 CHECK_RETVAL(nds32_config(nds32
));
81 nds32
->init_arch_info_after_halted
= true;
84 /* REVISIT entire cache should already be invalid !!! */
85 register_cache_invalidate(nds32
->core_cache
);
87 /* deactivate all hardware breakpoints */
88 CHECK_RETVAL(v3_common_callback
->deactivate_hardware_breakpoint(nds32
->target
));
90 if (enable_watchpoint
)
91 CHECK_RETVAL(v3_common_callback
->deactivate_hardware_watchpoint(nds32
->target
));
93 if (nds32
->virtual_hosting
) {
94 if (syscall_breakpoint
.set
) {
95 /** disable virtual hosting */
97 /* remove breakpoint at syscall entry */
98 target_remove_breakpoint(nds32
->target
, &syscall_breakpoint
);
99 syscall_breakpoint
.set
= 0;
102 nds32_get_mapped_reg(nds32
, PC
, &value_pc
);
103 if (value_pc
== syscall_breakpoint
.address
)
104 /** process syscall for virtual hosting */
105 nds32
->hit_syscall
= true;
109 if (ERROR_OK
!= nds32_examine_debug_reason(nds32
)) {
110 nds32
->target
->state
= backup_state
;
112 /* re-activate all hardware breakpoints & watchpoints */
113 CHECK_RETVAL(v3_common_callback
->activate_hardware_breakpoint(nds32
->target
));
115 if (enable_watchpoint
)
116 CHECK_RETVAL(v3_common_callback
->activate_hardware_watchpoint(nds32
->target
));
121 /* Save registers. */
122 nds32_full_context(nds32
);
124 /* check interrupt level */
125 v3_common_callback
->check_interrupt_stack(nds32
);
131 * Restore processor state.
133 static int nds32_v3_leave_debug_state(struct nds32
*nds32
, bool enable_watchpoint
)
135 LOG_DEBUG("nds32_v3_leave_debug_state");
137 struct target
*target
= nds32
->target
;
139 /* activate all hardware breakpoints */
140 CHECK_RETVAL(v3_common_callback
->activate_hardware_breakpoint(target
));
142 if (enable_watchpoint
) {
143 /* activate all watchpoints */
144 CHECK_RETVAL(v3_common_callback
->activate_hardware_watchpoint(target
));
147 /* restore interrupt stack */
148 v3_common_callback
->restore_interrupt_stack(nds32
);
150 /* REVISIT once we start caring about MMU and cache state,
151 * address it here ...
154 /* restore PSW, PC, and R0 ... after flushing any modified
157 CHECK_RETVAL(nds32_restore_context(target
));
159 if (nds32
->virtual_hosting
) {
160 /** enable virtual hosting */
163 uint32_t syscall_address
;
165 /* get syscall entry address */
166 nds32_get_mapped_reg(nds32
, IR3
, &value_ir3
);
167 entry_size
= 0x4 << (((value_ir3
>> 14) & 0x3) << 1);
168 syscall_address
= (value_ir3
& 0xFFFF0000) + entry_size
* 8; /* The index of SYSCALL is 8 */
170 if (nds32
->hit_syscall
) {
171 /* single step to skip syscall entry */
172 /* use IRET to skip syscall */
173 struct aice_port_s
*aice
= target_to_aice(target
);
178 nds32_get_mapped_reg(nds32
, IR6
, &value_ir6
);
179 syscall_id
= (value_ir6
>> 16) & 0x7FFF;
181 if (syscall_id
== NDS32_SYSCALL_EXIT
) {
182 /* If target hits exit syscall, do not use IRET to skip handler. */
185 /* use api->read/write_reg to skip nds32 register cache */
186 uint32_t value_dimbr
;
187 aice_read_debug_reg(aice
, NDS_EDM_SR_DIMBR
, &value_dimbr
);
188 aice_write_register(aice
, IR11
, value_dimbr
+ 0xC);
190 aice_read_register(aice
, IR9
, &value_ir9
);
191 value_ir9
+= 4; /* syscall is always 4 bytes */
192 aice_write_register(aice
, IR9
, value_ir9
);
194 /* backup hardware breakpoint 0 */
195 uint32_t backup_bpa
, backup_bpam
, backup_bpc
;
196 aice_read_debug_reg(aice
, NDS_EDM_SR_BPA0
, &backup_bpa
);
197 aice_read_debug_reg(aice
, NDS_EDM_SR_BPAM0
, &backup_bpam
);
198 aice_read_debug_reg(aice
, NDS_EDM_SR_BPC0
, &backup_bpc
);
200 /* use hardware breakpoint 0 to stop cpu after skipping syscall */
201 aice_write_debug_reg(aice
, NDS_EDM_SR_BPA0
, value_ir9
);
202 aice_write_debug_reg(aice
, NDS_EDM_SR_BPAM0
, 0);
203 aice_write_debug_reg(aice
, NDS_EDM_SR_BPC0
, 0xA);
206 * First IRET is used to quit debug mode.
207 * Second IRET is used to quit current syscall. */
208 uint32_t dim_inst
[4] = {NOP
, NOP
, IRET
, IRET
};
209 aice_execute(aice
, dim_inst
, 4);
211 /* restore origin hardware breakpoint 0 */
212 aice_write_debug_reg(aice
, NDS_EDM_SR_BPA0
, backup_bpa
);
213 aice_write_debug_reg(aice
, NDS_EDM_SR_BPAM0
, backup_bpam
);
214 aice_write_debug_reg(aice
, NDS_EDM_SR_BPC0
, backup_bpc
);
217 nds32
->hit_syscall
= false;
220 /* insert breakpoint at syscall entry */
221 syscall_breakpoint
.address
= syscall_address
;
222 syscall_breakpoint
.type
= BKPT_SOFT
;
223 syscall_breakpoint
.set
= 1;
224 target_add_breakpoint(target
, &syscall_breakpoint
);
230 static int nds32_v3_get_exception_address(struct nds32
*nds32
,
231 uint32_t *address
, uint32_t reason
)
233 LOG_DEBUG("nds32_v3_get_exception_address");
235 struct aice_port_s
*aice
= target_to_aice(nds32
->target
);
236 struct target
*target
= nds32
->target
;
240 uint32_t match_count
;
242 static int32_t number_of_hard_break
;
244 if (number_of_hard_break
== 0) {
245 aice_read_debug_reg(aice
, NDS_EDM_SR_EDM_CFG
, &edm_cfg
);
246 number_of_hard_break
= (edm_cfg
& 0x7) + 1;
249 aice_read_debug_reg(aice
, NDS_EDM_SR_EDMSW
, &edmsw
);
250 /* clear matching bits (write-one-clear) */
251 aice_write_debug_reg(aice
, NDS_EDM_SR_EDMSW
, edmsw
);
252 match_bits
= (edmsw
>> 4) & 0xFF;
254 for (i
= 0 ; i
< number_of_hard_break
; i
++) {
255 if (match_bits
& (1 << i
)) {
256 aice_read_debug_reg(aice
, NDS_EDM_SR_BPA0
+ i
, address
);
261 if (match_count
> 1) { /* multiple hits */
264 } else if (match_count
== 1) {
267 struct nds32_instruction instruction
;
268 struct watchpoint
*wp
;
271 nds32_get_mapped_reg(nds32
, PC
, &val_pc
);
273 if ((NDS32_DEBUG_DATA_ADDR_WATCHPOINT_NEXT_PRECISE
== reason
) ||
274 (NDS32_DEBUG_DATA_VALUE_WATCHPOINT_NEXT_PRECISE
== reason
)) {
275 if (edmsw
& 0x4) /* check EDMSW.IS_16BIT */
281 nds32_read_opcode(nds32
, val_pc
, &opcode
);
282 nds32_evaluate_opcode(nds32
, opcode
, val_pc
, &instruction
);
284 LOG_DEBUG("PC: 0x%08x, access start: 0x%08x, end: 0x%08x", val_pc
,
285 instruction
.access_start
, instruction
.access_end
);
287 /* check if multiple hits in the access range */
288 uint32_t in_range_watch_count
= 0;
289 for (wp
= target
->watchpoints
; wp
; wp
= wp
->next
) {
290 if ((instruction
.access_start
<= wp
->address
) &&
291 (wp
->address
< instruction
.access_end
))
292 in_range_watch_count
++;
294 if (in_range_watch_count
> 1) {
295 /* Hit LSMW instruction. */
300 /* dispel false match */
302 for (wp
= target
->watchpoints
; wp
; wp
= wp
->next
) {
303 if (((*address
^ wp
->address
) & (~wp
->mask
)) == 0) {
304 uint32_t watch_start
;
307 watch_start
= wp
->address
;
308 watch_end
= wp
->address
+ wp
->length
;
310 if ((watch_end
<= instruction
.access_start
) ||
311 (instruction
.access_end
<= watch_start
))
323 } else if (match_count
== 0) {
324 /* global stop is precise exception */
325 if ((NDS32_DEBUG_LOAD_STORE_GLOBAL_STOP
== reason
) && nds32
->global_stop
) {
326 /* parse instruction to get correct access address */
329 struct nds32_instruction instruction
;
331 nds32_get_mapped_reg(nds32
, PC
, &val_pc
);
332 nds32_read_opcode(nds32
, val_pc
, &opcode
);
333 nds32_evaluate_opcode(nds32
, opcode
, val_pc
, &instruction
);
335 *address
= instruction
.access_start
;
341 *address
= 0xFFFFFFFF;
345 void nds32_v3_common_register_callback(struct nds32_v3_common_callback
*callback
)
347 v3_common_callback
= callback
;
350 /** target_type functions: */
351 /* target request support */
352 int nds32_v3_target_request_data(struct target
*target
,
353 uint32_t size
, uint8_t *buffer
)
355 /* AndesCore could use DTR register to communicate with OpenOCD
357 * Target data will be put in buffer
358 * The format of DTR is as follow
359 * DTR[31:16] => length, DTR[15:8] => size, DTR[7:0] => target_req_cmd
360 * target_req_cmd has three possible values:
361 * TARGET_REQ_TRACEMSG
362 * TARGET_REQ_DEBUGMSG
363 * TARGET_REQ_DEBUGCHAR
364 * if size == 0, target will call target_asciimsg(),
365 * else call target_hexmsg()
367 LOG_WARNING("Not implemented: %s", __func__
);
372 int nds32_v3_soft_reset_halt(struct target
*target
)
374 struct aice_port_s
*aice
= target_to_aice(target
);
375 return aice_assert_srst(aice
, AICE_RESET_HOLD
);
378 int nds32_v3_checksum_memory(struct target
*target
,
379 uint32_t address
, uint32_t count
, uint32_t *checksum
)
381 LOG_WARNING("Not implemented: %s", __func__
);
387 * find out which watchpoint hits
388 * get exception address and compare the address to watchpoints
390 int nds32_v3_hit_watchpoint(struct target
*target
,
391 struct watchpoint
**hit_watchpoint
)
393 static struct watchpoint scan_all_watchpoint
;
395 uint32_t exception_address
;
396 struct watchpoint
*wp
;
397 struct nds32
*nds32
= target_to_nds32(target
);
399 exception_address
= nds32
->watched_address
;
401 if (exception_address
== 0xFFFFFFFF)
404 if (exception_address
== 0) {
405 scan_all_watchpoint
.address
= 0;
406 scan_all_watchpoint
.rw
= WPT_WRITE
;
407 scan_all_watchpoint
.next
= 0;
408 scan_all_watchpoint
.unique_id
= 0x5CA8;
410 *hit_watchpoint
= &scan_all_watchpoint
;
414 for (wp
= target
->watchpoints
; wp
; wp
= wp
->next
) {
415 if (((exception_address
^ wp
->address
) & (~wp
->mask
)) == 0) {
416 *hit_watchpoint
= wp
;
425 int nds32_v3_target_create_common(struct target
*target
, struct nds32
*nds32
)
427 nds32
->register_map
= nds32_v3_register_mapping
;
428 nds32
->get_debug_reason
= nds32_v3_get_debug_reason
;
429 nds32
->enter_debug_state
= nds32_v3_debug_entry
;
430 nds32
->leave_debug_state
= nds32_v3_leave_debug_state
;
431 nds32
->get_watched_address
= nds32_v3_get_exception_address
;
433 /* Init target->arch_info in nds32_init_arch_info().
434 * After this, user could use target_to_nds32() to get nds32 object */
435 nds32_init_arch_info(target
, nds32
);
440 int nds32_v3_run_algorithm(struct target
*target
,
442 struct mem_param
*mem_params
,
444 struct reg_param
*reg_params
,
445 uint32_t entry_point
,
450 LOG_WARNING("Not implemented: %s", __func__
);
455 int nds32_v3_read_buffer(struct target
*target
, uint32_t address
,
456 uint32_t size
, uint8_t *buffer
)
458 struct nds32
*nds32
= target_to_nds32(target
);
459 struct nds32_memory
*memory
= &(nds32
->memory
);
461 if ((NDS_MEMORY_ACC_CPU
== memory
->access_channel
) &&
462 (target
->state
!= TARGET_HALTED
)) {
463 LOG_WARNING("target was not halted");
464 return ERROR_TARGET_NOT_HALTED
;
467 uint32_t physical_address
;
468 /* BUG: If access range crosses multiple pages, the translation will not correct
469 * for second page or so. */
471 /* When DEX is set to one, hardware will enforce the following behavior without
472 * modifying the corresponding control bits in PSW.
474 * Disable all interrupts
475 * Become superuser mode
477 * Use MMU_CFG.DE as the data access endian
478 * Use MMU_CFG.DRDE as the device register access endian if MMU_CTL.DREE is asserted
479 * Disable audio special features
480 * Disable inline function call
482 * Because hardware will turn off IT/DT by default, it MUST translate virtual address
483 * to physical address.
485 if (ERROR_OK
== target
->type
->virt2phys(target
, address
, &physical_address
))
486 address
= physical_address
;
491 struct aice_port_s
*aice
= target_to_aice(target
);
492 /* give arbitrary initial value to avoid warning messages */
493 enum nds_memory_access origin_access_channel
= NDS_MEMORY_ACC_CPU
;
495 if (nds32
->hit_syscall
) {
496 /* Use bus mode to access memory during virtual hosting */
497 origin_access_channel
= memory
->access_channel
;
498 memory
->access_channel
= NDS_MEMORY_ACC_BUS
;
499 aice_memory_access(aice
, NDS_MEMORY_ACC_BUS
);
502 result
= nds32_read_buffer(target
, address
, size
, buffer
);
504 if (nds32
->hit_syscall
) {
505 /* Restore access_channel after virtual hosting */
506 memory
->access_channel
= origin_access_channel
;
507 aice_memory_access(aice
, origin_access_channel
);
513 int nds32_v3_write_buffer(struct target
*target
, uint32_t address
,
514 uint32_t size
, const uint8_t *buffer
)
516 struct nds32
*nds32
= target_to_nds32(target
);
517 struct nds32_memory
*memory
= &(nds32
->memory
);
519 if ((NDS_MEMORY_ACC_CPU
== memory
->access_channel
) &&
520 (target
->state
!= TARGET_HALTED
)) {
521 LOG_WARNING("target was not halted");
522 return ERROR_TARGET_NOT_HALTED
;
525 uint32_t physical_address
;
526 /* BUG: If access range crosses multiple pages, the translation will not correct
527 * for second page or so. */
529 /* When DEX is set to one, hardware will enforce the following behavior without
530 * modifying the corresponding control bits in PSW.
532 * Disable all interrupts
533 * Become superuser mode
535 * Use MMU_CFG.DE as the data access endian
536 * Use MMU_CFG.DRDE as the device register access endian if MMU_CTL.DREE is asserted
537 * Disable audio special features
538 * Disable inline function call
540 * Because hardware will turn off IT/DT by default, it MUST translate virtual address
541 * to physical address.
543 if (ERROR_OK
== target
->type
->virt2phys(target
, address
, &physical_address
))
544 address
= physical_address
;
548 if (nds32
->hit_syscall
) {
549 /* Use bus mode to access memory during virtual hosting */
550 struct aice_port_s
*aice
= target_to_aice(target
);
551 enum nds_memory_access origin_access_channel
;
554 origin_access_channel
= memory
->access_channel
;
555 memory
->access_channel
= NDS_MEMORY_ACC_BUS
;
556 aice_memory_access(aice
, NDS_MEMORY_ACC_BUS
);
558 result
= nds32_gdb_fileio_write_memory(nds32
, address
, size
, buffer
);
560 memory
->access_channel
= origin_access_channel
;
561 aice_memory_access(aice
, origin_access_channel
);
566 return nds32_write_buffer(target
, address
, size
, buffer
);
569 int nds32_v3_read_memory(struct target
*target
, uint32_t address
,
570 uint32_t size
, uint32_t count
, uint8_t *buffer
)
572 struct nds32
*nds32
= target_to_nds32(target
);
573 struct nds32_memory
*memory
= &(nds32
->memory
);
575 if ((NDS_MEMORY_ACC_CPU
== memory
->access_channel
) &&
576 (target
->state
!= TARGET_HALTED
)) {
577 LOG_WARNING("target was not halted");
578 return ERROR_TARGET_NOT_HALTED
;
581 uint32_t physical_address
;
582 /* BUG: If access range crosses multiple pages, the translation will not correct
583 * for second page or so. */
585 /* When DEX is set to one, hardware will enforce the following behavior without
586 * modifying the corresponding control bits in PSW.
588 * Disable all interrupts
589 * Become superuser mode
591 * Use MMU_CFG.DE as the data access endian
592 * Use MMU_CFG.DRDE as the device register access endian if MMU_CTL.DREE is asserted
593 * Disable audio special features
594 * Disable inline function call
596 * Because hardware will turn off IT/DT by default, it MUST translate virtual address
597 * to physical address.
599 if (ERROR_OK
== target
->type
->virt2phys(target
, address
, &physical_address
))
600 address
= physical_address
;
604 struct aice_port_s
*aice
= target_to_aice(target
);
605 /* give arbitrary initial value to avoid warning messages */
606 enum nds_memory_access origin_access_channel
= NDS_MEMORY_ACC_CPU
;
609 if (nds32
->hit_syscall
) {
610 /* Use bus mode to access memory during virtual hosting */
611 origin_access_channel
= memory
->access_channel
;
612 memory
->access_channel
= NDS_MEMORY_ACC_BUS
;
613 aice_memory_access(aice
, NDS_MEMORY_ACC_BUS
);
616 result
= nds32_read_memory(target
, address
, size
, count
, buffer
);
618 if (nds32
->hit_syscall
) {
619 /* Restore access_channel after virtual hosting */
620 memory
->access_channel
= origin_access_channel
;
621 aice_memory_access(aice
, origin_access_channel
);
627 int nds32_v3_write_memory(struct target
*target
, uint32_t address
,
628 uint32_t size
, uint32_t count
, const uint8_t *buffer
)
630 struct nds32
*nds32
= target_to_nds32(target
);
631 struct nds32_memory
*memory
= &(nds32
->memory
);
633 if ((NDS_MEMORY_ACC_CPU
== memory
->access_channel
) &&
634 (target
->state
!= TARGET_HALTED
)) {
635 LOG_WARNING("target was not halted");
636 return ERROR_TARGET_NOT_HALTED
;
639 uint32_t physical_address
;
640 /* BUG: If access range crosses multiple pages, the translation will not correct
641 * for second page or so. */
643 /* When DEX is set to one, hardware will enforce the following behavior without
644 * modifying the corresponding control bits in PSW.
646 * Disable all interrupts
647 * Become superuser mode
649 * Use MMU_CFG.DE as the data access endian
650 * Use MMU_CFG.DRDE as the device register access endian if MMU_CTL.DREE is asserted
651 * Disable audio special features
652 * Disable inline function call
654 * Because hardware will turn off IT/DT by default, it MUST translate virtual address
655 * to physical address.
657 if (ERROR_OK
== target
->type
->virt2phys(target
, address
, &physical_address
))
658 address
= physical_address
;
662 return nds32_write_memory(target
, address
, size
, count
, buffer
);
665 int nds32_v3_init_target(struct command_context
*cmd_ctx
,
666 struct target
*target
)
668 /* Initialize anything we can set up without talking to the target */
669 struct nds32
*nds32
= target_to_nds32(target
);
673 target
->fileio_info
= malloc(sizeof(struct gdb_fileio_info
));
674 target
->fileio_info
->identifier
= NULL
;
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)