1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2009 by Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
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 ***************************************************************************/
28 #include <helper/time_support.h>
29 #include "target_type.h"
31 #include "arm_opcodes.h"
35 * ARM720 is an ARM7TDMI-S with MMU and ETM7. For information, see
36 * ARM DDI 0229C especially Chapter 9 about debug support.
40 #define _DEBUG_INSTRUCTION_EXECUTION_
43 static int arm720t_scan_cp15(struct target
*target
,
44 uint32_t out
, uint32_t *in
, int instruction
, int clock
)
47 struct arm720t_common
*arm720t
= target_to_arm720(target
);
48 struct arm_jtag
*jtag_info
;
49 struct scan_field fields
[2];
51 uint8_t instruction_buf
= instruction
;
53 jtag_info
= &arm720t
->arm7_9_common
.jtag_info
;
55 buf_set_u32(out_buf
, 0, 32, flip_u32(out
, 32));
57 if ((retval
= arm_jtag_scann(jtag_info
, 0xf, TAP_DRPAUSE
)) != ERROR_OK
)
61 if ((retval
= arm_jtag_set_instr(jtag_info
, jtag_info
->intest_instr
, NULL
, TAP_DRPAUSE
)) != ERROR_OK
)
66 fields
[0].num_bits
= 1;
67 fields
[0].out_value
= &instruction_buf
;
68 fields
[0].in_value
= NULL
;
70 fields
[1].num_bits
= 32;
71 fields
[1].out_value
= out_buf
;
72 fields
[1].in_value
= NULL
;
76 fields
[1].in_value
= (uint8_t *)in
;
77 jtag_add_dr_scan(jtag_info
->tap
, 2, fields
, TAP_DRPAUSE
);
78 jtag_add_callback(arm7flip32
, (jtag_callback_data_t
)in
);
81 jtag_add_dr_scan(jtag_info
->tap
, 2, fields
, TAP_DRPAUSE
);
85 jtag_add_runtest(0, TAP_DRPAUSE
);
87 #ifdef _DEBUG_INSTRUCTION_EXECUTION_
88 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
94 LOG_DEBUG("out: %8.8x, in: %8.8x, instruction: %i, clock: %i", out
, *in
, instruction
, clock
);
96 LOG_DEBUG("out: %8.8x, instruction: %i, clock: %i", out
, instruction
, clock
);
98 LOG_DEBUG("out: %8.8" PRIx32
", instruction: %i, clock: %i", out
, instruction
, clock
);
104 static int arm720t_read_cp15(struct target
*target
, uint32_t opcode
, uint32_t *value
)
106 /* fetch CP15 opcode */
107 arm720t_scan_cp15(target
, opcode
, NULL
, 1, 1);
109 arm720t_scan_cp15(target
, ARMV4_5_NOP
, NULL
, 1, 1);
110 /* "EXECUTE" stage (1) */
111 arm720t_scan_cp15(target
, ARMV4_5_NOP
, NULL
, 1, 0);
112 arm720t_scan_cp15(target
, 0x0, NULL
, 0, 1);
113 /* "EXECUTE" stage (2) */
114 arm720t_scan_cp15(target
, 0x0, NULL
, 0, 1);
115 /* "EXECUTE" stage (3), CDATA is read */
116 arm720t_scan_cp15(target
, ARMV4_5_NOP
, value
, 1, 1);
121 static int arm720t_write_cp15(struct target
*target
, uint32_t opcode
, uint32_t value
)
123 /* fetch CP15 opcode */
124 arm720t_scan_cp15(target
, opcode
, NULL
, 1, 1);
126 arm720t_scan_cp15(target
, ARMV4_5_NOP
, NULL
, 1, 1);
127 /* "EXECUTE" stage (1) */
128 arm720t_scan_cp15(target
, ARMV4_5_NOP
, NULL
, 1, 0);
129 arm720t_scan_cp15(target
, 0x0, NULL
, 0, 1);
130 /* "EXECUTE" stage (2) */
131 arm720t_scan_cp15(target
, value
, NULL
, 0, 1);
132 arm720t_scan_cp15(target
, ARMV4_5_NOP
, NULL
, 1, 1);
137 static uint32_t arm720t_get_ttb(struct target
*target
)
141 arm720t_read_cp15(target
, 0xee120f10, &ttb
);
142 jtag_execute_queue();
149 static void arm720t_disable_mmu_caches(struct target
*target
,
150 int mmu
, int d_u_cache
, int i_cache
)
152 uint32_t cp15_control
;
154 /* read cp15 control register */
155 arm720t_read_cp15(target
, 0xee110f10, &cp15_control
);
156 jtag_execute_queue();
159 cp15_control
&= ~0x1U
;
161 if (d_u_cache
|| i_cache
)
162 cp15_control
&= ~0x4U
;
164 arm720t_write_cp15(target
, 0xee010f10, cp15_control
);
167 static void arm720t_enable_mmu_caches(struct target
*target
,
168 int mmu
, int d_u_cache
, int i_cache
)
170 uint32_t cp15_control
;
172 /* read cp15 control register */
173 arm720t_read_cp15(target
, 0xee110f10, &cp15_control
);
174 jtag_execute_queue();
177 cp15_control
|= 0x1U
;
179 if (d_u_cache
|| i_cache
)
180 cp15_control
|= 0x4U
;
182 arm720t_write_cp15(target
, 0xee010f10, cp15_control
);
185 static void arm720t_post_debug_entry(struct target
*target
)
187 struct arm720t_common
*arm720t
= target_to_arm720(target
);
189 /* examine cp15 control reg */
190 arm720t_read_cp15(target
, 0xee110f10, &arm720t
->cp15_control_reg
);
191 jtag_execute_queue();
192 LOG_DEBUG("cp15_control_reg: %8.8" PRIx32
"", arm720t
->cp15_control_reg
);
194 arm720t
->armv4_5_mmu
.mmu_enabled
= (arm720t
->cp15_control_reg
& 0x1U
) ? 1 : 0;
195 arm720t
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
= (arm720t
->cp15_control_reg
& 0x4U
) ? 1 : 0;
196 arm720t
->armv4_5_mmu
.armv4_5_cache
.i_cache_enabled
= 0;
198 /* save i/d fault status and address register */
199 arm720t_read_cp15(target
, 0xee150f10, &arm720t
->fsr_reg
);
200 arm720t_read_cp15(target
, 0xee160f10, &arm720t
->far_reg
);
201 jtag_execute_queue();
204 static void arm720t_pre_restore_context(struct target
*target
)
206 struct arm720t_common
*arm720t
= target_to_arm720(target
);
208 /* restore i/d fault status and address register */
209 arm720t_write_cp15(target
, 0xee050f10, arm720t
->fsr_reg
);
210 arm720t_write_cp15(target
, 0xee060f10, arm720t
->far_reg
);
213 static int arm720t_verify_pointer(struct command_context
*cmd_ctx
,
214 struct arm720t_common
*arm720t
)
216 if (arm720t
->common_magic
!= ARM720T_COMMON_MAGIC
) {
217 command_print(cmd_ctx
, "target is not an ARM720");
218 return ERROR_TARGET_INVALID
;
223 static int arm720t_arch_state(struct target
*target
)
225 struct arm720t_common
*arm720t
= target_to_arm720(target
);
228 static const char *state
[] =
230 "disabled", "enabled"
233 armv4_5
= &arm720t
->arm7_9_common
.armv4_5_common
;
235 arm_arch_state(target
);
236 LOG_USER("MMU: %s, Cache: %s",
237 state
[arm720t
->armv4_5_mmu
.mmu_enabled
],
238 state
[arm720t
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
]);
243 static int arm720_mmu(struct target
*target
, int *enabled
)
245 if (target
->state
!= TARGET_HALTED
) {
246 LOG_ERROR("%s: target not halted", __func__
);
247 return ERROR_TARGET_INVALID
;
250 *enabled
= target_to_arm720(target
)->armv4_5_mmu
.mmu_enabled
;
254 static int arm720_virt2phys(struct target
*target
,
255 uint32_t virtual, uint32_t *physical
)
261 struct arm720t_common
*arm720t
= target_to_arm720(target
);
264 int retval
= armv4_5_mmu_translate_va(target
, &arm720t
->armv4_5_mmu
, virtual, &type
, &cb
, &domain
, &ap
, &ret
);
265 if (retval
!= ERROR_OK
)
275 static int arm720t_read_memory(struct target
*target
,
276 uint32_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
)
279 struct arm720t_common
*arm720t
= target_to_arm720(target
);
281 /* disable cache, but leave MMU enabled */
282 if (arm720t
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
)
283 arm720t_disable_mmu_caches(target
, 0, 1, 0);
285 retval
= arm7_9_read_memory(target
, address
, size
, count
, buffer
);
287 if (arm720t
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
)
288 arm720t_enable_mmu_caches(target
, 0, 1, 0);
293 static int arm720t_read_phys_memory(struct target
*target
,
294 uint32_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
)
296 struct arm720t_common
*arm720t
= target_to_arm720(target
);
298 return armv4_5_mmu_read_physical(target
, &arm720t
->armv4_5_mmu
, address
, size
, count
, buffer
);
301 static int arm720t_write_phys_memory(struct target
*target
,
302 uint32_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
)
304 struct arm720t_common
*arm720t
= target_to_arm720(target
);
306 return armv4_5_mmu_write_physical(target
, &arm720t
->armv4_5_mmu
, address
, size
, count
, buffer
);
309 static int arm720t_soft_reset_halt(struct target
*target
)
311 int retval
= ERROR_OK
;
312 struct arm720t_common
*arm720t
= target_to_arm720(target
);
313 struct reg
*dbg_stat
= &arm720t
->arm7_9_common
314 .eice_cache
->reg_list
[EICE_DBG_STAT
];
315 struct arm
*armv4_5
= &arm720t
->arm7_9_common
318 if ((retval
= target_halt(target
)) != ERROR_OK
)
323 long long then
= timeval_ms();
325 while (!(timeout
= ((timeval_ms()-then
) > 1000)))
327 if (buf_get_u32(dbg_stat
->value
, EICE_DBG_STATUS_DBGACK
, 1) == 0)
329 embeddedice_read_reg(dbg_stat
);
330 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
338 if (debug_level
>= 3)
348 LOG_ERROR("Failed to halt CPU after 1 sec");
349 return ERROR_TARGET_TIMEOUT
;
352 target
->state
= TARGET_HALTED
;
354 /* SVC, ARM state, IRQ and FIQ disabled */
357 cpsr
= buf_get_u32(armv4_5
->cpsr
->value
, 0, 32);
360 arm_set_cpsr(armv4_5
, cpsr
);
361 armv4_5
->cpsr
->dirty
= 1;
363 /* start fetching from 0x0 */
364 buf_set_u32(armv4_5
->pc
->value
, 0, 32, 0x0);
365 armv4_5
->pc
->dirty
= 1;
366 armv4_5
->pc
->valid
= 1;
368 arm720t_disable_mmu_caches(target
, 1, 1, 1);
369 arm720t
->armv4_5_mmu
.mmu_enabled
= 0;
370 arm720t
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
= 0;
371 arm720t
->armv4_5_mmu
.armv4_5_cache
.i_cache_enabled
= 0;
373 if ((retval
= target_call_event_callbacks(target
, TARGET_EVENT_HALTED
)) != ERROR_OK
)
381 static int arm720t_init_target(struct command_context
*cmd_ctx
, struct target
*target
)
383 return arm7tdmi_init_target(cmd_ctx
, target
);
386 /* FIXME remove forward decls */
387 static int arm720t_mrc(struct target
*target
, int cpnum
,
388 uint32_t op1
, uint32_t op2
,
389 uint32_t CRn
, uint32_t CRm
,
391 static int arm720t_mcr(struct target
*target
, int cpnum
,
392 uint32_t op1
, uint32_t op2
,
393 uint32_t CRn
, uint32_t CRm
,
396 static int arm720t_init_arch_info(struct target
*target
,
397 struct arm720t_common
*arm720t
, struct jtag_tap
*tap
)
399 struct arm7_9_common
*arm7_9
= &arm720t
->arm7_9_common
;
401 arm7_9
->armv4_5_common
.mrc
= arm720t_mrc
;
402 arm7_9
->armv4_5_common
.mcr
= arm720t_mcr
;
404 arm7tdmi_init_arch_info(target
, arm7_9
, tap
);
406 arm720t
->common_magic
= ARM720T_COMMON_MAGIC
;
408 arm7_9
->post_debug_entry
= arm720t_post_debug_entry
;
409 arm7_9
->pre_restore_context
= arm720t_pre_restore_context
;
411 arm720t
->armv4_5_mmu
.armv4_5_cache
.ctype
= -1;
412 arm720t
->armv4_5_mmu
.get_ttb
= arm720t_get_ttb
;
413 arm720t
->armv4_5_mmu
.read_memory
= arm7_9_read_memory
;
414 arm720t
->armv4_5_mmu
.write_memory
= arm7_9_write_memory
;
415 arm720t
->armv4_5_mmu
.disable_mmu_caches
= arm720t_disable_mmu_caches
;
416 arm720t
->armv4_5_mmu
.enable_mmu_caches
= arm720t_enable_mmu_caches
;
417 arm720t
->armv4_5_mmu
.has_tiny_pages
= 0;
418 arm720t
->armv4_5_mmu
.mmu_enabled
= 0;
423 static int arm720t_target_create(struct target
*target
, Jim_Interp
*interp
)
425 struct arm720t_common
*arm720t
= calloc(1, sizeof(*arm720t
));
427 arm720t
->arm7_9_common
.armv4_5_common
.is_armv4
= true;
428 return arm720t_init_arch_info(target
, arm720t
, target
->tap
);
431 COMMAND_HANDLER(arm720t_handle_cp15_command
)
434 struct target
*target
= get_current_target(CMD_CTX
);
435 struct arm720t_common
*arm720t
= target_to_arm720(target
);
436 struct arm_jtag
*jtag_info
;
438 retval
= arm720t_verify_pointer(CMD_CTX
, arm720t
);
439 if (retval
!= ERROR_OK
)
442 jtag_info
= &arm720t
->arm7_9_common
.jtag_info
;
444 if (target
->state
!= TARGET_HALTED
)
446 command_print(CMD_CTX
, "target must be stopped for \"%s\" command", CMD_NAME
);
450 /* one or more argument, access a single register (write if second argument is given */
454 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], opcode
);
459 if ((retval
= arm720t_read_cp15(target
, opcode
, &value
)) != ERROR_OK
)
461 command_print(CMD_CTX
, "couldn't access cp15 with opcode 0x%8.8" PRIx32
"", opcode
);
465 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
470 command_print(CMD_CTX
, "0x%8.8" PRIx32
": 0x%8.8" PRIx32
"", opcode
, value
);
472 else if (CMD_ARGC
== 2)
475 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], value
);
477 if ((retval
= arm720t_write_cp15(target
, opcode
, value
)) != ERROR_OK
)
479 command_print(CMD_CTX
, "couldn't access cp15 with opcode 0x%8.8" PRIx32
"", opcode
);
482 command_print(CMD_CTX
, "0x%8.8" PRIx32
": 0x%8.8" PRIx32
"", opcode
, value
);
489 static int arm720t_mrc(struct target
*target
, int cpnum
,
490 uint32_t op1
, uint32_t op2
,
491 uint32_t CRn
, uint32_t CRm
,
496 LOG_ERROR("Only cp15 is supported");
501 return arm720t_read_cp15(target
,
502 ARMV4_5_MRC(cpnum
, op1
, 0, CRn
, CRm
, op2
),
507 static int arm720t_mcr(struct target
*target
, int cpnum
,
508 uint32_t op1
, uint32_t op2
,
509 uint32_t CRn
, uint32_t CRm
,
514 LOG_ERROR("Only cp15 is supported");
518 /* write "from" r0 */
519 return arm720t_write_cp15(target
,
520 ARMV4_5_MCR(cpnum
, op1
, 0, CRn
, CRm
, op2
),
524 static const struct command_registration arm720t_exec_command_handlers
[] = {
527 .handler
= arm720t_handle_cp15_command
,
528 .mode
= COMMAND_EXEC
,
529 /* prefer using less error-prone "arm mcr" or "arm mrc" */
530 .help
= "display/modify cp15 register using ARM opcode"
532 .usage
= "instruction [value]",
534 COMMAND_REGISTRATION_DONE
537 static const struct command_registration arm720t_command_handlers
[] = {
539 .chain
= arm7_9_command_handlers
,
544 .help
= "arm720t command group",
545 .chain
= arm720t_exec_command_handlers
,
547 COMMAND_REGISTRATION_DONE
550 /** Holds methods for ARM720 targets. */
551 struct target_type arm720t_target
=
556 .arch_state
= arm720t_arch_state
,
559 .resume
= arm7_9_resume
,
562 .assert_reset
= arm7_9_assert_reset
,
563 .deassert_reset
= arm7_9_deassert_reset
,
564 .soft_reset_halt
= arm720t_soft_reset_halt
,
566 .get_gdb_reg_list
= arm_get_gdb_reg_list
,
568 .read_memory
= arm720t_read_memory
,
569 .write_memory
= arm7_9_write_memory
,
570 .read_phys_memory
= arm720t_read_phys_memory
,
571 .write_phys_memory
= arm720t_write_phys_memory
,
573 .virt2phys
= arm720_virt2phys
,
575 .bulk_write_memory
= arm7_9_bulk_write_memory
,
577 .checksum_memory
= arm_checksum_memory
,
578 .blank_check_memory
= arm_blank_check_memory
,
580 .run_algorithm
= armv4_5_run_algorithm
,
582 .add_breakpoint
= arm7_9_add_breakpoint
,
583 .remove_breakpoint
= arm7_9_remove_breakpoint
,
584 .add_watchpoint
= arm7_9_add_watchpoint
,
585 .remove_watchpoint
= arm7_9_remove_watchpoint
,
587 .commands
= arm720t_command_handlers
,
588 .target_create
= arm720t_target_create
,
589 .init_target
= arm720t_init_target
,
590 .examine
= arm7_9_examine
,
591 .check_reset
= arm7_9_check_reset
,
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)