Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
aarch64: fix debug entry from EL0
[openocd.git] / src / target / aarch64.c
1 /***************************************************************************
2 * Copyright (C) 2015 by David Ung *
3 * *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * *
18 ***************************************************************************/
19
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include "breakpoints.h"
25 #include "aarch64.h"
26 #include "register.h"
27 #include "target_request.h"
28 #include "target_type.h"
29 #include "armv8_opcodes.h"
30 #include "armv8_cache.h"
31 #include <helper/time_support.h>
32
33 enum restart_mode {
34 RESTART_LAZY,
35 RESTART_SYNC,
36 };
37
38 enum halt_mode {
39 HALT_LAZY,
40 HALT_SYNC,
41 };
42
43 static int aarch64_poll(struct target *target);
44 static int aarch64_debug_entry(struct target *target);
45 static int aarch64_restore_context(struct target *target, bool bpwp);
46 static int aarch64_set_breakpoint(struct target *target,
47 struct breakpoint *breakpoint, uint8_t matchmode);
48 static int aarch64_set_context_breakpoint(struct target *target,
49 struct breakpoint *breakpoint, uint8_t matchmode);
50 static int aarch64_set_hybrid_breakpoint(struct target *target,
51 struct breakpoint *breakpoint);
52 static int aarch64_unset_breakpoint(struct target *target,
53 struct breakpoint *breakpoint);
54 static int aarch64_mmu(struct target *target, int *enabled);
55 static int aarch64_virt2phys(struct target *target,
56 target_addr_t virt, target_addr_t *phys);
57 static int aarch64_read_cpu_memory(struct target *target,
58 uint64_t address, uint32_t size, uint32_t count, uint8_t *buffer);
59
60 #define foreach_smp_target(pos, head) \
61 for (pos = head; (pos != NULL); pos = pos->next)
62
63 static int aarch64_restore_system_control_reg(struct target *target)
64 {
65 enum arm_mode target_mode = ARM_MODE_ANY;
66 int retval = ERROR_OK;
67 uint32_t instr;
68
69 struct aarch64_common *aarch64 = target_to_aarch64(target);
70 struct armv8_common *armv8 = target_to_armv8(target);
71
72 if (aarch64->system_control_reg != aarch64->system_control_reg_curr) {
73 aarch64->system_control_reg_curr = aarch64->system_control_reg;
74 /* LOG_INFO("cp15_control_reg: %8.8" PRIx32, cortex_v8->cp15_control_reg); */
75
76 switch (armv8->arm.core_mode) {
77 case ARMV8_64_EL0T:
78 target_mode = ARMV8_64_EL1H;
79 /* fall through */
80 case ARMV8_64_EL1T:
81 case ARMV8_64_EL1H:
82 instr = ARMV8_MSR_GP(SYSTEM_SCTLR_EL1, 0);
83 break;
84 case ARMV8_64_EL2T:
85 case ARMV8_64_EL2H:
86 instr = ARMV8_MSR_GP(SYSTEM_SCTLR_EL2, 0);
87 break;
88 case ARMV8_64_EL3H:
89 case ARMV8_64_EL3T:
90 instr = ARMV8_MSR_GP(SYSTEM_SCTLR_EL3, 0);
91 break;
92
93 case ARM_MODE_SVC:
94 case ARM_MODE_ABT:
95 case ARM_MODE_FIQ:
96 case ARM_MODE_IRQ:
97 instr = ARMV4_5_MCR(15, 0, 0, 1, 0, 0);
98 break;
99
100 default:
101 LOG_INFO("cannot read system control register in this mode");
102 return ERROR_FAIL;
103 }
104
105 if (target_mode != ARM_MODE_ANY)
106 armv8_dpm_modeswitch(&armv8->dpm, target_mode);
107
108 retval = armv8->dpm.instr_write_data_r0(&armv8->dpm, instr, aarch64->system_control_reg);
109 if (retval != ERROR_OK)
110 return retval;
111
112 if (target_mode != ARM_MODE_ANY)
113 armv8_dpm_modeswitch(&armv8->dpm, ARM_MODE_ANY);
114 }
115
116 return retval;
117 }
118
119 /* modify system_control_reg in order to enable or disable mmu for :
120 * - virt2phys address conversion
121 * - read or write memory in phys or virt address */
122 static int aarch64_mmu_modify(struct target *target, int enable)
123 {
124 struct aarch64_common *aarch64 = target_to_aarch64(target);
125 struct armv8_common *armv8 = &aarch64->armv8_common;
126 int retval = ERROR_OK;
127 uint32_t instr = 0;
128
129 if (enable) {
130 /* if mmu enabled at target stop and mmu not enable */
131 if (!(aarch64->system_control_reg & 0x1U)) {
132 LOG_ERROR("trying to enable mmu on target stopped with mmu disable");
133 return ERROR_FAIL;
134 }
135 if (!(aarch64->system_control_reg_curr & 0x1U))
136 aarch64->system_control_reg_curr |= 0x1U;
137 } else {
138 if (aarch64->system_control_reg_curr & 0x4U) {
139 /* data cache is active */
140 aarch64->system_control_reg_curr &= ~0x4U;
141 /* flush data cache armv8 function to be called */
142 if (armv8->armv8_mmu.armv8_cache.flush_all_data_cache)
143 armv8->armv8_mmu.armv8_cache.flush_all_data_cache(target);
144 }
145 if ((aarch64->system_control_reg_curr & 0x1U)) {
146 aarch64->system_control_reg_curr &= ~0x1U;
147 }
148 }
149
150 switch (armv8->arm.core_mode) {
151 case ARMV8_64_EL0T:
152 case ARMV8_64_EL1T:
153 case ARMV8_64_EL1H:
154 instr = ARMV8_MSR_GP(SYSTEM_SCTLR_EL1, 0);
155 break;
156 case ARMV8_64_EL2T:
157 case ARMV8_64_EL2H:
158 instr = ARMV8_MSR_GP(SYSTEM_SCTLR_EL2, 0);
159 break;
160 case ARMV8_64_EL3H:
161 case ARMV8_64_EL3T:
162 instr = ARMV8_MSR_GP(SYSTEM_SCTLR_EL3, 0);
163 break;
164
165 case ARM_MODE_SVC:
166 case ARM_MODE_ABT:
167 case ARM_MODE_FIQ:
168 case ARM_MODE_IRQ:
169 instr = ARMV4_5_MCR(15, 0, 0, 1, 0, 0);
170 break;
171
172 default:
173 LOG_DEBUG("unknown cpu state 0x%" PRIx32, armv8->arm.core_mode);
174 break;
175 }
176
177 retval = armv8->dpm.instr_write_data_r0(&armv8->dpm, instr,
178 aarch64->system_control_reg_curr);
179 return retval;
180 }
181
182 /*
183 * Basic debug access, very low level assumes state is saved
184 */
185 static int aarch64_init_debug_access(struct target *target)
186 {
187 struct armv8_common *armv8 = target_to_armv8(target);
188 int retval;
189 uint32_t dummy;
190
191 LOG_DEBUG("%s", target_name(target));
192
193 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
194 armv8->debug_base + CPUV8_DBG_OSLAR, 0);
195 if (retval != ERROR_OK) {
196 LOG_DEBUG("Examine %s failed", "oslock");
197 return retval;
198 }
199
200 /* Clear Sticky Power Down status Bit in PRSR to enable access to
201 the registers in the Core Power Domain */
202 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
203 armv8->debug_base + CPUV8_DBG_PRSR, &dummy);
204 if (retval != ERROR_OK)
205 return retval;
206
207 /*
208 * Static CTI configuration:
209 * Channel 0 -> trigger outputs HALT request to PE
210 * Channel 1 -> trigger outputs Resume request to PE
211 * Gate all channel trigger events from entering the CTM
212 */
213
214 /* Enable CTI */
215 retval = arm_cti_enable(armv8->cti, true);
216 /* By default, gate all channel events to and from the CTM */
217 if (retval == ERROR_OK)
218 retval = arm_cti_write_reg(armv8->cti, CTI_GATE, 0);
219 /* output halt requests to PE on channel 0 event */
220 if (retval == ERROR_OK)
221 retval = arm_cti_write_reg(armv8->cti, CTI_OUTEN0, CTI_CHNL(0));
222 /* output restart requests to PE on channel 1 event */
223 if (retval == ERROR_OK)
224 retval = arm_cti_write_reg(armv8->cti, CTI_OUTEN1, CTI_CHNL(1));
225 if (retval != ERROR_OK)
226 return retval;
227
228 /* Resync breakpoint registers */
229
230 return ERROR_OK;
231 }
232
233 /* Write to memory mapped registers directly with no cache or mmu handling */
234 static int aarch64_dap_write_memap_register_u32(struct target *target,
235 uint32_t address,
236 uint32_t value)
237 {
238 int retval;
239 struct armv8_common *armv8 = target_to_armv8(target);
240
241 retval = mem_ap_write_atomic_u32(armv8->debug_ap, address, value);
242
243 return retval;
244 }
245
246 static int aarch64_dpm_setup(struct aarch64_common *a8, uint64_t debug)
247 {
248 struct arm_dpm *dpm = &a8->armv8_common.dpm;
249 int retval;
250
251 dpm->arm = &a8->armv8_common.arm;
252 dpm->didr = debug;
253
254 retval = armv8_dpm_setup(dpm);
255 if (retval == ERROR_OK)
256 retval = armv8_dpm_initialize(dpm);
257
258 return retval;
259 }
260
261 static int aarch64_set_dscr_bits(struct target *target, unsigned long bit_mask, unsigned long value)
262 {
263 struct armv8_common *armv8 = target_to_armv8(target);
264 return armv8_set_dbgreg_bits(armv8, CPUV8_DBG_DSCR, bit_mask, value);
265 }
266
267 static int aarch64_check_state_one(struct target *target,
268 uint32_t mask, uint32_t val, int *p_result, uint32_t *p_prsr)
269 {
270 struct armv8_common *armv8 = target_to_armv8(target);
271 uint32_t prsr;
272 int retval;
273
274 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
275 armv8->debug_base + CPUV8_DBG_PRSR, &prsr);
276 if (retval != ERROR_OK)
277 return retval;
278
279 if (p_prsr)
280 *p_prsr = prsr;
281
282 if (p_result)
283 *p_result = (prsr & mask) == (val & mask);
284
285 return ERROR_OK;
286 }
287
288 static int aarch64_wait_halt_one(struct target *target)
289 {
290 int retval = ERROR_OK;
291 uint32_t prsr;
292
293 int64_t then = timeval_ms();
294 for (;;) {
295 int halted;
296
297 retval = aarch64_check_state_one(target, PRSR_HALT, PRSR_HALT, &halted, &prsr);
298 if (retval != ERROR_OK || halted)
299 break;
300
301 if (timeval_ms() > then + 1000) {
302 retval = ERROR_TARGET_TIMEOUT;
303 LOG_DEBUG("target %s timeout, prsr=0x%08"PRIx32, target_name(target), prsr);
304 break;
305 }
306 }
307 return retval;
308 }
309
310 static int aarch64_prepare_halt_smp(struct target *target, bool exc_target, struct target **p_first)
311 {
312 int retval = ERROR_OK;
313 struct target_list *head = target->head;
314 struct target *first = NULL;
315
316 LOG_DEBUG("target %s exc %i", target_name(target), exc_target);
317
318 while (head != NULL) {
319 struct target *curr = head->target;
320 struct armv8_common *armv8 = target_to_armv8(curr);
321 head = head->next;
322
323 if (exc_target && curr == target)
324 continue;
325 if (!target_was_examined(curr))
326 continue;
327 if (curr->state != TARGET_RUNNING)
328 continue;
329
330 /* HACK: mark this target as prepared for halting */
331 curr->debug_reason = DBG_REASON_DBGRQ;
332
333 /* open the gate for channel 0 to let HALT requests pass to the CTM */
334 retval = arm_cti_ungate_channel(armv8->cti, 0);
335 if (retval == ERROR_OK)
336 retval = aarch64_set_dscr_bits(curr, DSCR_HDE, DSCR_HDE);
337 if (retval != ERROR_OK)
338 break;
339
340 LOG_DEBUG("target %s prepared", target_name(curr));
341
342 if (first == NULL)
343 first = curr;
344 }
345
346 if (p_first) {
347 if (exc_target && first)
348 *p_first = first;
349 else
350 *p_first = target;
351 }
352
353 return retval;
354 }
355
356 static int aarch64_halt_one(struct target *target, enum halt_mode mode)
357 {
358 int retval = ERROR_OK;
359 struct armv8_common *armv8 = target_to_armv8(target);
360
361 LOG_DEBUG("%s", target_name(target));
362
363 /* allow Halting Debug Mode */
364 retval = aarch64_set_dscr_bits(target, DSCR_HDE, DSCR_HDE);
365 if (retval != ERROR_OK)
366 return retval;
367
368 /* trigger an event on channel 0, this outputs a halt request to the PE */
369 retval = arm_cti_pulse_channel(armv8->cti, 0);
370 if (retval != ERROR_OK)
371 return retval;
372
373 if (mode == HALT_SYNC) {
374 retval = aarch64_wait_halt_one(target);
375 if (retval != ERROR_OK) {
376 if (retval == ERROR_TARGET_TIMEOUT)
377 LOG_ERROR("Timeout waiting for target %s halt", target_name(target));
378 return retval;
379 }
380 }
381
382 return ERROR_OK;
383 }
384
385 static int aarch64_halt_smp(struct target *target, bool exc_target)
386 {
387 struct target *next = target;
388 int retval;
389
390 /* prepare halt on all PEs of the group */
391 retval = aarch64_prepare_halt_smp(target, exc_target, &next);
392
393 if (exc_target && next == target)
394 return retval;
395
396 /* halt the target PE */
397 if (retval == ERROR_OK)
398 retval = aarch64_halt_one(next, HALT_LAZY);
399
400 if (retval != ERROR_OK)
401 return retval;
402
403 /* wait for all PEs to halt */
404 int64_t then = timeval_ms();
405 for (;;) {
406 bool all_halted = true;
407 struct target_list *head;
408 struct target *curr;
409
410 foreach_smp_target(head, target->head) {
411 int halted;
412
413 curr = head->target;
414
415 if (!target_was_examined(curr))
416 continue;
417
418 retval = aarch64_check_state_one(curr, PRSR_HALT, PRSR_HALT, &halted, NULL);
419 if (retval != ERROR_OK || !halted) {
420 all_halted = false;
421 break;
422 }
423 }
424
425 if (all_halted)
426 break;
427
428 if (timeval_ms() > then + 1000) {
429 retval = ERROR_TARGET_TIMEOUT;
430 break;
431 }
432
433 /*
434 * HACK: on Hi6220 there are 8 cores organized in 2 clusters
435 * and it looks like the CTI's are not connected by a common
436 * trigger matrix. It seems that we need to halt one core in each
437 * cluster explicitly. So if we find that a core has not halted
438 * yet, we trigger an explicit halt for the second cluster.
439 */
440 retval = aarch64_halt_one(curr, HALT_LAZY);
441 if (retval != ERROR_OK)
442 break;
443 }
444
445 return retval;
446 }
447
448 static int update_halt_gdb(struct target *target, enum target_debug_reason debug_reason)
449 {
450 struct target *gdb_target = NULL;
451 struct target_list *head;
452 struct target *curr;
453
454 if (debug_reason == DBG_REASON_NOTHALTED) {
455 LOG_DEBUG("Halting remaining targets in SMP group");
456 aarch64_halt_smp(target, true);
457 }
458
459 /* poll all targets in the group, but skip the target that serves GDB */
460 foreach_smp_target(head, target->head) {
461 curr = head->target;
462 /* skip calling context */
463 if (curr == target)
464 continue;
465 if (!target_was_examined(curr))
466 continue;
467 /* skip targets that were already halted */
468 if (curr->state == TARGET_HALTED)
469 continue;
470 /* remember the gdb_service->target */
471 if (curr->gdb_service != NULL)
472 gdb_target = curr->gdb_service->target;
473 /* skip it */
474 if (curr == gdb_target)
475 continue;
476
477 /* avoid recursion in aarch64_poll() */
478 curr->smp = 0;
479 aarch64_poll(curr);
480 curr->smp = 1;
481 }
482
483 /* after all targets were updated, poll the gdb serving target */
484 if (gdb_target != NULL && gdb_target != target)
485 aarch64_poll(gdb_target);
486
487 return ERROR_OK;
488 }
489
490 /*
491 * Aarch64 Run control
492 */
493
494 static int aarch64_poll(struct target *target)
495 {
496 enum target_state prev_target_state;
497 int retval = ERROR_OK;
498 int halted;
499
500 retval = aarch64_check_state_one(target,
501 PRSR_HALT, PRSR_HALT, &halted, NULL);
502 if (retval != ERROR_OK)
503 return retval;
504
505 if (halted) {
506 prev_target_state = target->state;
507 if (prev_target_state != TARGET_HALTED) {
508 enum target_debug_reason debug_reason = target->debug_reason;
509
510 /* We have a halting debug event */
511 target->state = TARGET_HALTED;
512 LOG_DEBUG("Target %s halted", target_name(target));
513 retval = aarch64_debug_entry(target);
514 if (retval != ERROR_OK)
515 return retval;
516
517 if (target->smp)
518 update_halt_gdb(target, debug_reason);
519
520 switch (prev_target_state) {
521 case TARGET_RUNNING:
522 case TARGET_UNKNOWN:
523 case TARGET_RESET:
524 target_call_event_callbacks(target, TARGET_EVENT_HALTED);
525 break;
526 case TARGET_DEBUG_RUNNING:
527 target_call_event_callbacks(target, TARGET_EVENT_DEBUG_HALTED);
528 break;
529 default:
530 break;
531 }
532 }
533 } else
534 target->state = TARGET_RUNNING;
535
536 return retval;
537 }
538
539 static int aarch64_halt(struct target *target)
540 {
541 if (target->smp)
542 return aarch64_halt_smp(target, false);
543
544 return aarch64_halt_one(target, HALT_SYNC);
545 }
546
547 static int aarch64_restore_one(struct target *target, int current,
548 uint64_t *address, int handle_breakpoints, int debug_execution)
549 {
550 struct armv8_common *armv8 = target_to_armv8(target);
551 struct arm *arm = &armv8->arm;
552 int retval;
553 uint64_t resume_pc;
554
555 LOG_DEBUG("%s", target_name(target));
556
557 if (!debug_execution)
558 target_free_all_working_areas(target);
559
560 /* current = 1: continue on current pc, otherwise continue at <address> */
561 resume_pc = buf_get_u64(arm->pc->value, 0, 64);
562 if (!current)
563 resume_pc = *address;
564 else
565 *address = resume_pc;
566
567 /* Make sure that the Armv7 gdb thumb fixups does not
568 * kill the return address
569 */
570 switch (arm->core_state) {
571 case ARM_STATE_ARM:
572 resume_pc &= 0xFFFFFFFC;
573 break;
574 case ARM_STATE_AARCH64:
575 resume_pc &= 0xFFFFFFFFFFFFFFFC;
576 break;
577 case ARM_STATE_THUMB:
578 case ARM_STATE_THUMB_EE:
579 /* When the return address is loaded into PC
580 * bit 0 must be 1 to stay in Thumb state
581 */
582 resume_pc |= 0x1;
583 break;
584 case ARM_STATE_JAZELLE:
585 LOG_ERROR("How do I resume into Jazelle state??");
586 return ERROR_FAIL;
587 }
588 LOG_DEBUG("resume pc = 0x%016" PRIx64, resume_pc);
589 buf_set_u64(arm->pc->value, 0, 64, resume_pc);
590 arm->pc->dirty = 1;
591 arm->pc->valid = 1;
592
593 /* called it now before restoring context because it uses cpu
594 * register r0 for restoring system control register */
595 retval = aarch64_restore_system_control_reg(target);
596 if (retval == ERROR_OK)
597 retval = aarch64_restore_context(target, handle_breakpoints);
598
599 return retval;
600 }
601
602 /**
603 * prepare single target for restart
604 *
605 *
606 */
607 static int aarch64_prepare_restart_one(struct target *target)
608 {
609 struct armv8_common *armv8 = target_to_armv8(target);
610 int retval;
611 uint32_t dscr;
612 uint32_t tmp;
613
614 LOG_DEBUG("%s", target_name(target));
615
616 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
617 armv8->debug_base + CPUV8_DBG_DSCR, &dscr);
618 if (retval != ERROR_OK)
619 return retval;
620
621 if ((dscr & DSCR_ITE) == 0)
622 LOG_ERROR("DSCR.ITE must be set before leaving debug!");
623 if ((dscr & DSCR_ERR) != 0)
624 LOG_ERROR("DSCR.ERR must be cleared before leaving debug!");
625
626 /* acknowledge a pending CTI halt event */
627 retval = arm_cti_ack_events(armv8->cti, CTI_TRIG(HALT));
628 /*
629 * open the CTI gate for channel 1 so that the restart events
630 * get passed along to all PEs. Also close gate for channel 0
631 * to isolate the PE from halt events.
632 */
633 if (retval == ERROR_OK)
634 retval = arm_cti_ungate_channel(armv8->cti, 1);
635 if (retval == ERROR_OK)
636 retval = arm_cti_gate_channel(armv8->cti, 0);
637
638 /* make sure that DSCR.HDE is set */
639 if (retval == ERROR_OK) {
640 dscr |= DSCR_HDE;
641 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
642 armv8->debug_base + CPUV8_DBG_DSCR, dscr);
643 }
644
645 if (retval == ERROR_OK) {
646 /* clear sticky bits in PRSR, SDR is now 0 */
647 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
648 armv8->debug_base + CPUV8_DBG_PRSR, &tmp);
649 }
650
651 return retval;
652 }
653
654 static int aarch64_do_restart_one(struct target *target, enum restart_mode mode)
655 {
656 struct armv8_common *armv8 = target_to_armv8(target);
657 int retval;
658
659 LOG_DEBUG("%s", target_name(target));
660
661 /* trigger an event on channel 1, generates a restart request to the PE */
662 retval = arm_cti_pulse_channel(armv8->cti, 1);
663 if (retval != ERROR_OK)
664 return retval;
665
666 if (mode == RESTART_SYNC) {
667 int64_t then = timeval_ms();
668 for (;;) {
669 int resumed;
670 /*
671 * if PRSR.SDR is set now, the target did restart, even
672 * if it's now already halted again (e.g. due to breakpoint)
673 */
674 retval = aarch64_check_state_one(target,
675 PRSR_SDR, PRSR_SDR, &resumed, NULL);
676 if (retval != ERROR_OK || resumed)
677 break;
678
679 if (timeval_ms() > then + 1000) {
680 LOG_ERROR("%s: Timeout waiting for resume"PRIx32, target_name(target));
681 retval = ERROR_TARGET_TIMEOUT;
682 break;
683 }
684 }
685 }
686
687 if (retval != ERROR_OK)
688 return retval;
689
690 target->debug_reason = DBG_REASON_NOTHALTED;
691 target->state = TARGET_RUNNING;
692
693 return ERROR_OK;
694 }
695
696 static int aarch64_restart_one(struct target *target, enum restart_mode mode)
697 {
698 int retval;
699
700 LOG_DEBUG("%s", target_name(target));
701
702 retval = aarch64_prepare_restart_one(target);
703 if (retval == ERROR_OK)
704 retval = aarch64_do_restart_one(target, mode);
705
706 return retval;
707 }
708
709 /*
710 * prepare all but the current target for restart
711 */
712 static int aarch64_prep_restart_smp(struct target *target, int handle_breakpoints, struct target **p_first)
713 {
714 int retval = ERROR_OK;
715 struct target_list *head;
716 struct target *first = NULL;
717 uint64_t address;
718
719 foreach_smp_target(head, target->head) {
720 struct target *curr = head->target;
721
722 /* skip calling target */
723 if (curr == target)
724 continue;
725 if (!target_was_examined(curr))
726 continue;
727 if (curr->state != TARGET_HALTED)
728 continue;
729
730 /* resume at current address, not in step mode */
731 retval = aarch64_restore_one(curr, 1, &address, handle_breakpoints, 0);
732 if (retval == ERROR_OK)
733 retval = aarch64_prepare_restart_one(curr);
734 if (retval != ERROR_OK) {
735 LOG_ERROR("failed to restore target %s", target_name(curr));
736 break;
737 }
738 /* remember the first valid target in the group */
739 if (first == NULL)
740 first = curr;
741 }
742
743 if (p_first)
744 *p_first = first;
745
746 return retval;
747 }
748
749
750 static int aarch64_step_restart_smp(struct target *target)
751 {
752 int retval = ERROR_OK;
753 struct target_list *head;
754 struct target *first = NULL;
755
756 LOG_DEBUG("%s", target_name(target));
757
758 retval = aarch64_prep_restart_smp(target, 0, &first);
759 if (retval != ERROR_OK)
760 return retval;
761
762 if (first != NULL)
763 retval = aarch64_do_restart_one(first, RESTART_LAZY);
764 if (retval != ERROR_OK) {
765 LOG_DEBUG("error restarting target %s", target_name(first));
766 return retval;
767 }
768
769 int64_t then = timeval_ms();
770 for (;;) {
771 struct target *curr = target;
772 bool all_resumed = true;
773
774 foreach_smp_target(head, target->head) {
775 uint32_t prsr;
776 int resumed;
777
778 curr = head->target;
779
780 if (curr == target)
781 continue;
782
783 if (!target_was_examined(curr))
784 continue;
785
786 retval = aarch64_check_state_one(curr,
787 PRSR_SDR, PRSR_SDR, &resumed, &prsr);
788 if (retval != ERROR_OK || (!resumed && (prsr & PRSR_HALT))) {
789 all_resumed = false;
790 break;
791 }
792
793 if (curr->state != TARGET_RUNNING) {
794 curr->state = TARGET_RUNNING;
795 curr->debug_reason = DBG_REASON_NOTHALTED;
796 target_call_event_callbacks(curr, TARGET_EVENT_RESUMED);
797 }
798 }
799
800 if (all_resumed)
801 break;
802
803 if (timeval_ms() > then + 1000) {
804 LOG_ERROR("%s: timeout waiting for target resume", __func__);
805 retval = ERROR_TARGET_TIMEOUT;
806 break;
807 }
808 /*
809 * HACK: on Hi6220 there are 8 cores organized in 2 clusters
810 * and it looks like the CTI's are not connected by a common
811 * trigger matrix. It seems that we need to halt one core in each
812 * cluster explicitly. So if we find that a core has not halted
813 * yet, we trigger an explicit resume for the second cluster.
814 */
815 retval = aarch64_do_restart_one(curr, RESTART_LAZY);
816 if (retval != ERROR_OK)
817 break;
818 }
819
820 return retval;
821 }
822
823 static int aarch64_resume(struct target *target, int current,
824 target_addr_t address, int handle_breakpoints, int debug_execution)
825 {
826 int retval = 0;
827 uint64_t addr = address;
828
829 if (target->state != TARGET_HALTED)
830 return ERROR_TARGET_NOT_HALTED;
831
832 /*
833 * If this target is part of a SMP group, prepare the others
834 * targets for resuming. This involves restoring the complete
835 * target register context and setting up CTI gates to accept
836 * resume events from the trigger matrix.
837 */
838 if (target->smp) {
839 retval = aarch64_prep_restart_smp(target, handle_breakpoints, NULL);
840 if (retval != ERROR_OK)
841 return retval;
842 }
843
844 /* all targets prepared, restore and restart the current target */
845 retval = aarch64_restore_one(target, current, &addr, handle_breakpoints,
846 debug_execution);
847 if (retval == ERROR_OK)
848 retval = aarch64_restart_one(target, RESTART_SYNC);
849 if (retval != ERROR_OK)
850 return retval;
851
852 if (target->smp) {
853 int64_t then = timeval_ms();
854 for (;;) {
855 struct target *curr = target;
856 struct target_list *head;
857 bool all_resumed = true;
858
859 foreach_smp_target(head, target->head) {
860 uint32_t prsr;
861 int resumed;
862
863 curr = head->target;
864 if (curr == target)
865 continue;
866 if (!target_was_examined(curr))
867 continue;
868
869 retval = aarch64_check_state_one(curr,
870 PRSR_SDR, PRSR_SDR, &resumed, &prsr);
871 if (retval != ERROR_OK || (!resumed && (prsr & PRSR_HALT))) {
872 all_resumed = false;
873 break;
874 }
875
876 if (curr->state != TARGET_RUNNING) {
877 curr->state = TARGET_RUNNING;
878 curr->debug_reason = DBG_REASON_NOTHALTED;
879 target_call_event_callbacks(curr, TARGET_EVENT_RESUMED);
880 }
881 }
882
883 if (all_resumed)
884 break;
885
886 if (timeval_ms() > then + 1000) {
887 LOG_ERROR("%s: timeout waiting for target %s to resume", __func__, target_name(curr));
888 retval = ERROR_TARGET_TIMEOUT;
889 break;
890 }
891
892 /*
893 * HACK: on Hi6220 there are 8 cores organized in 2 clusters
894 * and it looks like the CTI's are not connected by a common
895 * trigger matrix. It seems that we need to halt one core in each
896 * cluster explicitly. So if we find that a core has not halted
897 * yet, we trigger an explicit resume for the second cluster.
898 */
899 retval = aarch64_do_restart_one(curr, RESTART_LAZY);
900 if (retval != ERROR_OK)
901 break;
902 }
903 }
904
905 if (retval != ERROR_OK)
906 return retval;
907
908 target->debug_reason = DBG_REASON_NOTHALTED;
909
910 if (!debug_execution) {
911 target->state = TARGET_RUNNING;
912 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
913 LOG_DEBUG("target resumed at 0x%" PRIx64, addr);
914 } else {
915 target->state = TARGET_DEBUG_RUNNING;
916 target_call_event_callbacks(target, TARGET_EVENT_DEBUG_RESUMED);
917 LOG_DEBUG("target debug resumed at 0x%" PRIx64, addr);
918 }
919
920 return ERROR_OK;
921 }
922
923 static int aarch64_debug_entry(struct target *target)
924 {
925 int retval = ERROR_OK;
926 struct armv8_common *armv8 = target_to_armv8(target);
927 struct arm_dpm *dpm = &armv8->dpm;
928 enum arm_state core_state;
929 uint32_t dscr;
930
931 /* make sure to clear all sticky errors */
932 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
933 armv8->debug_base + CPUV8_DBG_DRCR, DRCR_CSE);
934 if (retval == ERROR_OK)
935 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
936 armv8->debug_base + CPUV8_DBG_DSCR, &dscr);
937 if (retval == ERROR_OK)
938 retval = arm_cti_ack_events(armv8->cti, CTI_TRIG(HALT));
939
940 if (retval != ERROR_OK)
941 return retval;
942
943 LOG_DEBUG("%s dscr = 0x%08" PRIx32, target_name(target), dscr);
944
945 dpm->dscr = dscr;
946 core_state = armv8_dpm_get_core_state(dpm);
947 armv8_select_opcodes(armv8, core_state == ARM_STATE_AARCH64);
948 armv8_select_reg_access(armv8, core_state == ARM_STATE_AARCH64);
949
950 /* close the CTI gate for all events */
951 if (retval == ERROR_OK)
952 retval = arm_cti_write_reg(armv8->cti, CTI_GATE, 0);
953 /* discard async exceptions */
954 if (retval == ERROR_OK)
955 retval = dpm->instr_cpsr_sync(dpm);
956 if (retval != ERROR_OK)
957 return retval;
958
959 /* Examine debug reason */
960 armv8_dpm_report_dscr(dpm, dscr);
961
962 /* save address of instruction that triggered the watchpoint? */
963 if (target->debug_reason == DBG_REASON_WATCHPOINT) {
964 uint32_t tmp;
965 uint64_t wfar = 0;
966
967 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
968 armv8->debug_base + CPUV8_DBG_WFAR1,
969 &tmp);
970 if (retval != ERROR_OK)
971 return retval;
972 wfar = tmp;
973 wfar = (wfar << 32);
974 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
975 armv8->debug_base + CPUV8_DBG_WFAR0,
976 &tmp);
977 if (retval != ERROR_OK)
978 return retval;
979 wfar |= tmp;
980 armv8_dpm_report_wfar(&armv8->dpm, wfar);
981 }
982
983 retval = armv8_dpm_read_current_registers(&armv8->dpm);
984
985 if (retval == ERROR_OK && armv8->post_debug_entry)
986 retval = armv8->post_debug_entry(target);
987
988 return retval;
989 }
990
991 static int aarch64_post_debug_entry(struct target *target)
992 {
993 struct aarch64_common *aarch64 = target_to_aarch64(target);
994 struct armv8_common *armv8 = &aarch64->armv8_common;
995 int retval;
996 enum arm_mode target_mode = ARM_MODE_ANY;
997 uint32_t instr;
998
999 switch (armv8->arm.core_mode) {
1000 case ARMV8_64_EL0T:
1001 target_mode = ARMV8_64_EL1H;
1002 /* fall through */
1003 case ARMV8_64_EL1T:
1004 case ARMV8_64_EL1H:
1005 instr = ARMV8_MRS(SYSTEM_SCTLR_EL1, 0);
1006 break;
1007 case ARMV8_64_EL2T:
1008 case ARMV8_64_EL2H:
1009 instr = ARMV8_MRS(SYSTEM_SCTLR_EL2, 0);
1010 break;
1011 case ARMV8_64_EL3H:
1012 case ARMV8_64_EL3T:
1013 instr = ARMV8_MRS(SYSTEM_SCTLR_EL3, 0);
1014 break;
1015
1016 case ARM_MODE_SVC:
1017 case ARM_MODE_ABT:
1018 case ARM_MODE_FIQ:
1019 case ARM_MODE_IRQ:
1020 instr = ARMV4_5_MRC(15, 0, 0, 1, 0, 0);
1021 break;
1022
1023 default:
1024 LOG_INFO("cannot read system control register in this mode");
1025 return ERROR_FAIL;
1026 }
1027
1028 if (target_mode != ARM_MODE_ANY)
1029 armv8_dpm_modeswitch(&armv8->dpm, target_mode);
1030
1031 retval = armv8->dpm.instr_read_data_r0(&armv8->dpm, instr, &aarch64->system_control_reg);
1032 if (retval != ERROR_OK)
1033 return retval;
1034
1035 if (target_mode != ARM_MODE_ANY)
1036 armv8_dpm_modeswitch(&armv8->dpm, ARM_MODE_ANY);
1037
1038 LOG_DEBUG("System_register: %8.8" PRIx32, aarch64->system_control_reg);
1039 aarch64->system_control_reg_curr = aarch64->system_control_reg;
1040
1041 if (armv8->armv8_mmu.armv8_cache.info == -1) {
1042 armv8_identify_cache(armv8);
1043 armv8_read_mpidr(armv8);
1044 }
1045
1046 armv8->armv8_mmu.mmu_enabled =
1047 (aarch64->system_control_reg & 0x1U) ? 1 : 0;
1048 armv8->armv8_mmu.armv8_cache.d_u_cache_enabled =
1049 (aarch64->system_control_reg & 0x4U) ? 1 : 0;
1050 armv8->armv8_mmu.armv8_cache.i_cache_enabled =
1051 (aarch64->system_control_reg & 0x1000U) ? 1 : 0;
1052 return ERROR_OK;
1053 }
1054
1055 /*
1056 * single-step a target
1057 */
1058 static int aarch64_step(struct target *target, int current, target_addr_t address,
1059 int handle_breakpoints)
1060 {
1061 struct armv8_common *armv8 = target_to_armv8(target);
1062 struct aarch64_common *aarch64 = target_to_aarch64(target);
1063 int saved_retval = ERROR_OK;
1064 int retval;
1065 uint32_t edecr;
1066
1067 if (target->state != TARGET_HALTED) {
1068 LOG_WARNING("target not halted");
1069 return ERROR_TARGET_NOT_HALTED;
1070 }
1071
1072 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
1073 armv8->debug_base + CPUV8_DBG_EDECR, &edecr);
1074 /* make sure EDECR.SS is not set when restoring the register */
1075
1076 if (retval == ERROR_OK) {
1077 edecr &= ~0x4;
1078 /* set EDECR.SS to enter hardware step mode */
1079 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
1080 armv8->debug_base + CPUV8_DBG_EDECR, (edecr|0x4));
1081 }
1082 /* disable interrupts while stepping */
1083 if (retval == ERROR_OK && aarch64->isrmasking_mode == AARCH64_ISRMASK_ON)
1084 retval = aarch64_set_dscr_bits(target, 0x3 << 22, 0x3 << 22);
1085 /* bail out if stepping setup has failed */
1086 if (retval != ERROR_OK)
1087 return retval;
1088
1089 if (target->smp && (current == 1)) {
1090 /*
1091 * isolate current target so that it doesn't get resumed
1092 * together with the others
1093 */
1094 retval = arm_cti_gate_channel(armv8->cti, 1);
1095 /* resume all other targets in the group */
1096 if (retval == ERROR_OK)
1097 retval = aarch64_step_restart_smp(target);
1098 if (retval != ERROR_OK) {
1099 LOG_ERROR("Failed to restart non-stepping targets in SMP group");
1100 return retval;
1101 }
1102 LOG_DEBUG("Restarted all non-stepping targets in SMP group");
1103 }
1104
1105 /* all other targets running, restore and restart the current target */
1106 retval = aarch64_restore_one(target, current, &address, 0, 0);
1107 if (retval == ERROR_OK)
1108 retval = aarch64_restart_one(target, RESTART_LAZY);
1109
1110 if (retval != ERROR_OK)
1111 return retval;
1112
1113 LOG_DEBUG("target step-resumed at 0x%" PRIx64, address);
1114 if (!handle_breakpoints)
1115 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
1116
1117 int64_t then = timeval_ms();
1118 for (;;) {
1119 int stepped;
1120 uint32_t prsr;
1121
1122 retval = aarch64_check_state_one(target,
1123 PRSR_SDR|PRSR_HALT, PRSR_SDR|PRSR_HALT, &stepped, &prsr);
1124 if (retval != ERROR_OK || stepped)
1125 break;
1126
1127 if (timeval_ms() > then + 100) {
1128 LOG_ERROR("timeout waiting for target %s halt after step",
1129 target_name(target));
1130 retval = ERROR_TARGET_TIMEOUT;
1131 break;
1132 }
1133 }
1134
1135 /*
1136 * At least on one SoC (Renesas R8A7795) stepping over a WFI instruction
1137 * causes a timeout. The core takes the step but doesn't complete it and so
1138 * debug state is never entered. However, you can manually halt the core
1139 * as an external debug even is also a WFI wakeup event.
1140 */
1141 if (retval == ERROR_TARGET_TIMEOUT)
1142 saved_retval = aarch64_halt_one(target, HALT_SYNC);
1143
1144 /* restore EDECR */
1145 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
1146 armv8->debug_base + CPUV8_DBG_EDECR, edecr);
1147 if (retval != ERROR_OK)
1148 return retval;
1149
1150 /* restore interrupts */
1151 if (aarch64->isrmasking_mode == AARCH64_ISRMASK_ON) {
1152 retval = aarch64_set_dscr_bits(target, 0x3 << 22, 0);
1153 if (retval != ERROR_OK)
1154 return ERROR_OK;
1155 }
1156
1157 if (saved_retval != ERROR_OK)
1158 return saved_retval;
1159
1160 return aarch64_poll(target);
1161 }
1162
1163 static int aarch64_restore_context(struct target *target, bool bpwp)
1164 {
1165 struct armv8_common *armv8 = target_to_armv8(target);
1166 struct arm *arm = &armv8->arm;
1167
1168 int retval;
1169
1170 LOG_DEBUG("%s", target_name(target));
1171
1172 if (armv8->pre_restore_context)
1173 armv8->pre_restore_context(target);
1174
1175 retval = armv8_dpm_write_dirty_registers(&armv8->dpm, bpwp);
1176 if (retval == ERROR_OK) {
1177 /* registers are now invalid */
1178 register_cache_invalidate(arm->core_cache);
1179 register_cache_invalidate(arm->core_cache->next);
1180 }
1181
1182 return retval;
1183 }
1184
1185 /*
1186 * Cortex-A8 Breakpoint and watchpoint functions
1187 */
1188
1189 /* Setup hardware Breakpoint Register Pair */
1190 static int aarch64_set_breakpoint(struct target *target,
1191 struct breakpoint *breakpoint, uint8_t matchmode)
1192 {
1193 int retval;
1194 int brp_i = 0;
1195 uint32_t control;
1196 uint8_t byte_addr_select = 0x0F;
1197 struct aarch64_common *aarch64 = target_to_aarch64(target);
1198 struct armv8_common *armv8 = &aarch64->armv8_common;
1199 struct aarch64_brp *brp_list = aarch64->brp_list;
1200
1201 if (breakpoint->set) {
1202 LOG_WARNING("breakpoint already set");
1203 return ERROR_OK;
1204 }
1205
1206 if (breakpoint->type == BKPT_HARD) {
1207 int64_t bpt_value;
1208 while (brp_list[brp_i].used && (brp_i < aarch64->brp_num))
1209 brp_i++;
1210 if (brp_i >= aarch64->brp_num) {
1211 LOG_ERROR("ERROR Can not find free Breakpoint Register Pair");
1212 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1213 }
1214 breakpoint->set = brp_i + 1;
1215 if (breakpoint->length == 2)
1216 byte_addr_select = (3 << (breakpoint->address & 0x02));
1217 control = ((matchmode & 0x7) << 20)
1218 | (1 << 13)
1219 | (byte_addr_select << 5)
1220 | (3 << 1) | 1;
1221 brp_list[brp_i].used = 1;
1222 brp_list[brp_i].value = breakpoint->address & 0xFFFFFFFFFFFFFFFC;
1223 brp_list[brp_i].control = control;
1224 bpt_value = brp_list[brp_i].value;
1225
1226 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1227 + CPUV8_DBG_BVR_BASE + 16 * brp_list[brp_i].BRPn,
1228 (uint32_t)(bpt_value & 0xFFFFFFFF));
1229 if (retval != ERROR_OK)
1230 return retval;
1231 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1232 + CPUV8_DBG_BVR_BASE + 4 + 16 * brp_list[brp_i].BRPn,
1233 (uint32_t)(bpt_value >> 32));
1234 if (retval != ERROR_OK)
1235 return retval;
1236
1237 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1238 + CPUV8_DBG_BCR_BASE + 16 * brp_list[brp_i].BRPn,
1239 brp_list[brp_i].control);
1240 if (retval != ERROR_OK)
1241 return retval;
1242 LOG_DEBUG("brp %i control 0x%0" PRIx32 " value 0x%" TARGET_PRIxADDR, brp_i,
1243 brp_list[brp_i].control,
1244 brp_list[brp_i].value);
1245
1246 } else if (breakpoint->type == BKPT_SOFT) {
1247 uint8_t code[4];
1248
1249 buf_set_u32(code, 0, 32, armv8_opcode(armv8, ARMV8_OPC_HLT));
1250 retval = target_read_memory(target,
1251 breakpoint->address & 0xFFFFFFFFFFFFFFFE,
1252 breakpoint->length, 1,
1253 breakpoint->orig_instr);
1254 if (retval != ERROR_OK)
1255 return retval;
1256
1257 armv8_cache_d_inner_flush_virt(armv8,
1258 breakpoint->address & 0xFFFFFFFFFFFFFFFE,
1259 breakpoint->length);
1260
1261 retval = target_write_memory(target,
1262 breakpoint->address & 0xFFFFFFFFFFFFFFFE,
1263 breakpoint->length, 1, code);
1264 if (retval != ERROR_OK)
1265 return retval;
1266
1267 armv8_cache_d_inner_flush_virt(armv8,
1268 breakpoint->address & 0xFFFFFFFFFFFFFFFE,
1269 breakpoint->length);
1270
1271 armv8_cache_i_inner_inval_virt(armv8,
1272 breakpoint->address & 0xFFFFFFFFFFFFFFFE,
1273 breakpoint->length);
1274
1275 breakpoint->set = 0x11; /* Any nice value but 0 */
1276 }
1277
1278 /* Ensure that halting debug mode is enable */
1279 retval = aarch64_set_dscr_bits(target, DSCR_HDE, DSCR_HDE);
1280 if (retval != ERROR_OK) {
1281 LOG_DEBUG("Failed to set DSCR.HDE");
1282 return retval;
1283 }
1284
1285 return ERROR_OK;
1286 }
1287
1288 static int aarch64_set_context_breakpoint(struct target *target,
1289 struct breakpoint *breakpoint, uint8_t matchmode)
1290 {
1291 int retval = ERROR_FAIL;
1292 int brp_i = 0;
1293 uint32_t control;
1294 uint8_t byte_addr_select = 0x0F;
1295 struct aarch64_common *aarch64 = target_to_aarch64(target);
1296 struct armv8_common *armv8 = &aarch64->armv8_common;
1297 struct aarch64_brp *brp_list = aarch64->brp_list;
1298
1299 if (breakpoint->set) {
1300 LOG_WARNING("breakpoint already set");
1301 return retval;
1302 }
1303 /*check available context BRPs*/
1304 while ((brp_list[brp_i].used ||
1305 (brp_list[brp_i].type != BRP_CONTEXT)) && (brp_i < aarch64->brp_num))
1306 brp_i++;
1307
1308 if (brp_i >= aarch64->brp_num) {
1309 LOG_ERROR("ERROR Can not find free Breakpoint Register Pair");
1310 return ERROR_FAIL;
1311 }
1312
1313 breakpoint->set = brp_i + 1;
1314 control = ((matchmode & 0x7) << 20)
1315 | (1 << 13)
1316 | (byte_addr_select << 5)
1317 | (3 << 1) | 1;
1318 brp_list[brp_i].used = 1;
1319 brp_list[brp_i].value = (breakpoint->asid);
1320 brp_list[brp_i].control = control;
1321 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1322 + CPUV8_DBG_BVR_BASE + 16 * brp_list[brp_i].BRPn,
1323 brp_list[brp_i].value);
1324 if (retval != ERROR_OK)
1325 return retval;
1326 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1327 + CPUV8_DBG_BCR_BASE + 16 * brp_list[brp_i].BRPn,
1328 brp_list[brp_i].control);
1329 if (retval != ERROR_OK)
1330 return retval;
1331 LOG_DEBUG("brp %i control 0x%0" PRIx32 " value 0x%" TARGET_PRIxADDR, brp_i,
1332 brp_list[brp_i].control,
1333 brp_list[brp_i].value);
1334 return ERROR_OK;
1335
1336 }
1337
1338 static int aarch64_set_hybrid_breakpoint(struct target *target, struct breakpoint *breakpoint)
1339 {
1340 int retval = ERROR_FAIL;
1341 int brp_1 = 0; /* holds the contextID pair */
1342 int brp_2 = 0; /* holds the IVA pair */
1343 uint32_t control_CTX, control_IVA;
1344 uint8_t CTX_byte_addr_select = 0x0F;
1345 uint8_t IVA_byte_addr_select = 0x0F;
1346 uint8_t CTX_machmode = 0x03;
1347 uint8_t IVA_machmode = 0x01;
1348 struct aarch64_common *aarch64 = target_to_aarch64(target);
1349 struct armv8_common *armv8 = &aarch64->armv8_common;
1350 struct aarch64_brp *brp_list = aarch64->brp_list;
1351
1352 if (breakpoint->set) {
1353 LOG_WARNING("breakpoint already set");
1354 return retval;
1355 }
1356 /*check available context BRPs*/
1357 while ((brp_list[brp_1].used ||
1358 (brp_list[brp_1].type != BRP_CONTEXT)) && (brp_1 < aarch64->brp_num))
1359 brp_1++;
1360
1361 printf("brp(CTX) found num: %d\n", brp_1);
1362 if (brp_1 >= aarch64->brp_num) {
1363 LOG_ERROR("ERROR Can not find free Breakpoint Register Pair");
1364 return ERROR_FAIL;
1365 }
1366
1367 while ((brp_list[brp_2].used ||
1368 (brp_list[brp_2].type != BRP_NORMAL)) && (brp_2 < aarch64->brp_num))
1369 brp_2++;
1370
1371 printf("brp(IVA) found num: %d\n", brp_2);
1372 if (brp_2 >= aarch64->brp_num) {
1373 LOG_ERROR("ERROR Can not find free Breakpoint Register Pair");
1374 return ERROR_FAIL;
1375 }
1376
1377 breakpoint->set = brp_1 + 1;
1378 breakpoint->linked_BRP = brp_2;
1379 control_CTX = ((CTX_machmode & 0x7) << 20)
1380 | (brp_2 << 16)
1381 | (0 << 14)
1382 | (CTX_byte_addr_select << 5)
1383 | (3 << 1) | 1;
1384 brp_list[brp_1].used = 1;
1385 brp_list[brp_1].value = (breakpoint->asid);
1386 brp_list[brp_1].control = control_CTX;
1387 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1388 + CPUV8_DBG_BVR_BASE + 16 * brp_list[brp_1].BRPn,
1389 brp_list[brp_1].value);
1390 if (retval != ERROR_OK)
1391 return retval;
1392 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1393 + CPUV8_DBG_BCR_BASE + 16 * brp_list[brp_1].BRPn,
1394 brp_list[brp_1].control);
1395 if (retval != ERROR_OK)
1396 return retval;
1397
1398 control_IVA = ((IVA_machmode & 0x7) << 20)
1399 | (brp_1 << 16)
1400 | (1 << 13)
1401 | (IVA_byte_addr_select << 5)
1402 | (3 << 1) | 1;
1403 brp_list[brp_2].used = 1;
1404 brp_list[brp_2].value = breakpoint->address & 0xFFFFFFFFFFFFFFFC;
1405 brp_list[brp_2].control = control_IVA;
1406 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1407 + CPUV8_DBG_BVR_BASE + 16 * brp_list[brp_2].BRPn,
1408 brp_list[brp_2].value & 0xFFFFFFFF);
1409 if (retval != ERROR_OK)
1410 return retval;
1411 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1412 + CPUV8_DBG_BVR_BASE + 4 + 16 * brp_list[brp_2].BRPn,
1413 brp_list[brp_2].value >> 32);
1414 if (retval != ERROR_OK)
1415 return retval;
1416 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1417 + CPUV8_DBG_BCR_BASE + 16 * brp_list[brp_2].BRPn,
1418 brp_list[brp_2].control);
1419 if (retval != ERROR_OK)
1420 return retval;
1421
1422 return ERROR_OK;
1423 }
1424
1425 static int aarch64_unset_breakpoint(struct target *target, struct breakpoint *breakpoint)
1426 {
1427 int retval;
1428 struct aarch64_common *aarch64 = target_to_aarch64(target);
1429 struct armv8_common *armv8 = &aarch64->armv8_common;
1430 struct aarch64_brp *brp_list = aarch64->brp_list;
1431
1432 if (!breakpoint->set) {
1433 LOG_WARNING("breakpoint not set");
1434 return ERROR_OK;
1435 }
1436
1437 if (breakpoint->type == BKPT_HARD) {
1438 if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
1439 int brp_i = breakpoint->set - 1;
1440 int brp_j = breakpoint->linked_BRP;
1441 if ((brp_i < 0) || (brp_i >= aarch64->brp_num)) {
1442 LOG_DEBUG("Invalid BRP number in breakpoint");
1443 return ERROR_OK;
1444 }
1445 LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%" TARGET_PRIxADDR, brp_i,
1446 brp_list[brp_i].control, brp_list[brp_i].value);
1447 brp_list[brp_i].used = 0;
1448 brp_list[brp_i].value = 0;
1449 brp_list[brp_i].control = 0;
1450 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1451 + CPUV8_DBG_BCR_BASE + 16 * brp_list[brp_i].BRPn,
1452 brp_list[brp_i].control);
1453 if (retval != ERROR_OK)
1454 return retval;
1455 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1456 + CPUV8_DBG_BVR_BASE + 16 * brp_list[brp_i].BRPn,
1457 (uint32_t)brp_list[brp_i].value);
1458 if (retval != ERROR_OK)
1459 return retval;
1460 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1461 + CPUV8_DBG_BVR_BASE + 4 + 16 * brp_list[brp_i].BRPn,
1462 (uint32_t)brp_list[brp_i].value);
1463 if (retval != ERROR_OK)
1464 return retval;
1465 if ((brp_j < 0) || (brp_j >= aarch64->brp_num)) {
1466 LOG_DEBUG("Invalid BRP number in breakpoint");
1467 return ERROR_OK;
1468 }
1469 LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%0" PRIx64, brp_j,
1470 brp_list[brp_j].control, brp_list[brp_j].value);
1471 brp_list[brp_j].used = 0;
1472 brp_list[brp_j].value = 0;
1473 brp_list[brp_j].control = 0;
1474 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1475 + CPUV8_DBG_BCR_BASE + 16 * brp_list[brp_j].BRPn,
1476 brp_list[brp_j].control);
1477 if (retval != ERROR_OK)
1478 return retval;
1479 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1480 + CPUV8_DBG_BVR_BASE + 16 * brp_list[brp_j].BRPn,
1481 (uint32_t)brp_list[brp_j].value);
1482 if (retval != ERROR_OK)
1483 return retval;
1484 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1485 + CPUV8_DBG_BVR_BASE + 4 + 16 * brp_list[brp_j].BRPn,
1486 (uint32_t)brp_list[brp_j].value);
1487 if (retval != ERROR_OK)
1488 return retval;
1489
1490 breakpoint->linked_BRP = 0;
1491 breakpoint->set = 0;
1492 return ERROR_OK;
1493
1494 } else {
1495 int brp_i = breakpoint->set - 1;
1496 if ((brp_i < 0) || (brp_i >= aarch64->brp_num)) {
1497 LOG_DEBUG("Invalid BRP number in breakpoint");
1498 return ERROR_OK;
1499 }
1500 LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%0" PRIx64, brp_i,
1501 brp_list[brp_i].control, brp_list[brp_i].value);
1502 brp_list[brp_i].used = 0;
1503 brp_list[brp_i].value = 0;
1504 brp_list[brp_i].control = 0;
1505 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1506 + CPUV8_DBG_BCR_BASE + 16 * brp_list[brp_i].BRPn,
1507 brp_list[brp_i].control);
1508 if (retval != ERROR_OK)
1509 return retval;
1510 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1511 + CPUV8_DBG_BVR_BASE + 16 * brp_list[brp_i].BRPn,
1512 brp_list[brp_i].value);
1513 if (retval != ERROR_OK)
1514 return retval;
1515
1516 retval = aarch64_dap_write_memap_register_u32(target, armv8->debug_base
1517 + CPUV8_DBG_BVR_BASE + 4 + 16 * brp_list[brp_i].BRPn,
1518 (uint32_t)brp_list[brp_i].value);
1519 if (retval != ERROR_OK)
1520 return retval;
1521 breakpoint->set = 0;
1522 return ERROR_OK;
1523 }
1524 } else {
1525 /* restore original instruction (kept in target endianness) */
1526
1527 armv8_cache_d_inner_flush_virt(armv8,
1528 breakpoint->address & 0xFFFFFFFFFFFFFFFE,
1529 breakpoint->length);
1530
1531 if (breakpoint->length == 4) {
1532 retval = target_write_memory(target,
1533 breakpoint->address & 0xFFFFFFFFFFFFFFFE,
1534 4, 1, breakpoint->orig_instr);
1535 if (retval != ERROR_OK)
1536 return retval;
1537 } else {
1538 retval = target_write_memory(target,
1539 breakpoint->address & 0xFFFFFFFFFFFFFFFE,
1540 2, 1, breakpoint->orig_instr);
1541 if (retval != ERROR_OK)
1542 return retval;
1543 }
1544
1545 armv8_cache_d_inner_flush_virt(armv8,
1546 breakpoint->address & 0xFFFFFFFFFFFFFFFE,
1547 breakpoint->length);
1548
1549 armv8_cache_i_inner_inval_virt(armv8,
1550 breakpoint->address & 0xFFFFFFFFFFFFFFFE,
1551 breakpoint->length);
1552 }
1553 breakpoint->set = 0;
1554
1555 return ERROR_OK;
1556 }
1557
1558 static int aarch64_add_breakpoint(struct target *target,
1559 struct breakpoint *breakpoint)
1560 {
1561 struct aarch64_common *aarch64 = target_to_aarch64(target);
1562
1563 if ((breakpoint->type == BKPT_HARD) && (aarch64->brp_num_available < 1)) {
1564 LOG_INFO("no hardware breakpoint available");
1565 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1566 }
1567
1568 if (breakpoint->type == BKPT_HARD)
1569 aarch64->brp_num_available--;
1570
1571 return aarch64_set_breakpoint(target, breakpoint, 0x00); /* Exact match */
1572 }
1573
1574 static int aarch64_add_context_breakpoint(struct target *target,
1575 struct breakpoint *breakpoint)
1576 {
1577 struct aarch64_common *aarch64 = target_to_aarch64(target);
1578
1579 if ((breakpoint->type == BKPT_HARD) && (aarch64->brp_num_available < 1)) {
1580 LOG_INFO("no hardware breakpoint available");
1581 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1582 }
1583
1584 if (breakpoint->type == BKPT_HARD)
1585 aarch64->brp_num_available--;
1586
1587 return aarch64_set_context_breakpoint(target, breakpoint, 0x02); /* asid match */
1588 }
1589
1590 static int aarch64_add_hybrid_breakpoint(struct target *target,
1591 struct breakpoint *breakpoint)
1592 {
1593 struct aarch64_common *aarch64 = target_to_aarch64(target);
1594
1595 if ((breakpoint->type == BKPT_HARD) && (aarch64->brp_num_available < 1)) {
1596 LOG_INFO("no hardware breakpoint available");
1597 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1598 }
1599
1600 if (breakpoint->type == BKPT_HARD)
1601 aarch64->brp_num_available--;
1602
1603 return aarch64_set_hybrid_breakpoint(target, breakpoint); /* ??? */
1604 }
1605
1606
1607 static int aarch64_remove_breakpoint(struct target *target, struct breakpoint *breakpoint)
1608 {
1609 struct aarch64_common *aarch64 = target_to_aarch64(target);
1610
1611 #if 0
1612 /* It is perfectly possible to remove breakpoints while the target is running */
1613 if (target->state != TARGET_HALTED) {
1614 LOG_WARNING("target not halted");
1615 return ERROR_TARGET_NOT_HALTED;
1616 }
1617 #endif
1618
1619 if (breakpoint->set) {
1620 aarch64_unset_breakpoint(target, breakpoint);
1621 if (breakpoint->type == BKPT_HARD)
1622 aarch64->brp_num_available++;
1623 }
1624
1625 return ERROR_OK;
1626 }
1627
1628 /*
1629 * Cortex-A8 Reset functions
1630 */
1631
1632 static int aarch64_assert_reset(struct target *target)
1633 {
1634 struct armv8_common *armv8 = target_to_armv8(target);
1635
1636 LOG_DEBUG(" ");
1637
1638 /* FIXME when halt is requested, make it work somehow... */
1639
1640 /* Issue some kind of warm reset. */
1641 if (target_has_event_action(target, TARGET_EVENT_RESET_ASSERT))
1642 target_handle_event(target, TARGET_EVENT_RESET_ASSERT);
1643 else if (jtag_get_reset_config() & RESET_HAS_SRST) {
1644 /* REVISIT handle "pulls" cases, if there's
1645 * hardware that needs them to work.
1646 */
1647 jtag_add_reset(0, 1);
1648 } else {
1649 LOG_ERROR("%s: how to reset?", target_name(target));
1650 return ERROR_FAIL;
1651 }
1652
1653 /* registers are now invalid */
1654 if (target_was_examined(target)) {
1655 register_cache_invalidate(armv8->arm.core_cache);
1656 register_cache_invalidate(armv8->arm.core_cache->next);
1657 }
1658
1659 target->state = TARGET_RESET;
1660
1661 return ERROR_OK;
1662 }
1663
1664 static int aarch64_deassert_reset(struct target *target)
1665 {
1666 int retval;
1667
1668 LOG_DEBUG(" ");
1669
1670 /* be certain SRST is off */
1671 jtag_add_reset(0, 0);
1672
1673 if (!target_was_examined(target))
1674 return ERROR_OK;
1675
1676 retval = aarch64_poll(target);
1677 if (retval != ERROR_OK)
1678 return retval;
1679
1680 if (target->reset_halt) {
1681 if (target->state != TARGET_HALTED) {
1682 LOG_WARNING("%s: ran after reset and before halt ...",
1683 target_name(target));
1684 retval = target_halt(target);
1685 if (retval != ERROR_OK)
1686 return retval;
1687 }
1688 }
1689
1690 return aarch64_init_debug_access(target);
1691 }
1692
1693 static int aarch64_write_cpu_memory_slow(struct target *target,
1694 uint32_t size, uint32_t count, const uint8_t *buffer, uint32_t *dscr)
1695 {
1696 struct armv8_common *armv8 = target_to_armv8(target);
1697 struct arm_dpm *dpm = &armv8->dpm;
1698 struct arm *arm = &armv8->arm;
1699 int retval;
1700
1701 armv8_reg_current(arm, 1)->dirty = true;
1702
1703 /* change DCC to normal mode if necessary */
1704 if (*dscr & DSCR_MA) {
1705 *dscr &= ~DSCR_MA;
1706 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
1707 armv8->debug_base + CPUV8_DBG_DSCR, *dscr);
1708 if (retval != ERROR_OK)
1709 return retval;
1710 }
1711
1712 while (count) {
1713 uint32_t data, opcode;
1714
1715 /* write the data to store into DTRRX */
1716 if (size == 1)
1717 data = *buffer;
1718 else if (size == 2)
1719 data = target_buffer_get_u16(target, buffer);
1720 else
1721 data = target_buffer_get_u32(target, buffer);
1722 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
1723 armv8->debug_base + CPUV8_DBG_DTRRX, data);
1724 if (retval != ERROR_OK)
1725 return retval;
1726
1727 if (arm->core_state == ARM_STATE_AARCH64)
1728 retval = dpm->instr_execute(dpm, ARMV8_MRS(SYSTEM_DBG_DTRRX_EL0, 1));
1729 else
1730 retval = dpm->instr_execute(dpm, ARMV4_5_MRC(14, 0, 1, 0, 5, 0));
1731 if (retval != ERROR_OK)
1732 return retval;
1733
1734 if (size == 1)
1735 opcode = armv8_opcode(armv8, ARMV8_OPC_STRB_IP);
1736 else if (size == 2)
1737 opcode = armv8_opcode(armv8, ARMV8_OPC_STRH_IP);
1738 else
1739 opcode = armv8_opcode(armv8, ARMV8_OPC_STRW_IP);
1740 retval = dpm->instr_execute(dpm, opcode);
1741 if (retval != ERROR_OK)
1742 return retval;
1743
1744 /* Advance */
1745 buffer += size;
1746 --count;
1747 }
1748
1749 return ERROR_OK;
1750 }
1751
1752 static int aarch64_write_cpu_memory_fast(struct target *target,
1753 uint32_t count, const uint8_t *buffer, uint32_t *dscr)
1754 {
1755 struct armv8_common *armv8 = target_to_armv8(target);
1756 struct arm *arm = &armv8->arm;
1757 int retval;
1758
1759 armv8_reg_current(arm, 1)->dirty = true;
1760
1761 /* Step 1.d - Change DCC to memory mode */
1762 *dscr |= DSCR_MA;
1763 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
1764 armv8->debug_base + CPUV8_DBG_DSCR, *dscr);
1765 if (retval != ERROR_OK)
1766 return retval;
1767
1768
1769 /* Step 2.a - Do the write */
1770 retval = mem_ap_write_buf_noincr(armv8->debug_ap,
1771 buffer, 4, count, armv8->debug_base + CPUV8_DBG_DTRRX);
1772 if (retval != ERROR_OK)
1773 return retval;
1774
1775 /* Step 3.a - Switch DTR mode back to Normal mode */
1776 *dscr &= ~DSCR_MA;
1777 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
1778 armv8->debug_base + CPUV8_DBG_DSCR, *dscr);
1779 if (retval != ERROR_OK)
1780 return retval;
1781
1782 return ERROR_OK;
1783 }
1784
1785 static int aarch64_write_cpu_memory(struct target *target,
1786 uint64_t address, uint32_t size,
1787 uint32_t count, const uint8_t *buffer)
1788 {
1789 /* write memory through APB-AP */
1790 int retval = ERROR_COMMAND_SYNTAX_ERROR;
1791 struct armv8_common *armv8 = target_to_armv8(target);
1792 struct arm_dpm *dpm = &armv8->dpm;
1793 struct arm *arm = &armv8->arm;
1794 uint32_t dscr;
1795
1796 if (target->state != TARGET_HALTED) {
1797 LOG_WARNING("target not halted");
1798 return ERROR_TARGET_NOT_HALTED;
1799 }
1800
1801 /* Mark register X0 as dirty, as it will be used
1802 * for transferring the data.
1803 * It will be restored automatically when exiting
1804 * debug mode
1805 */
1806 armv8_reg_current(arm, 0)->dirty = true;
1807
1808 /* This algorithm comes from DDI0487A.g, chapter J9.1 */
1809
1810 /* Read DSCR */
1811 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
1812 armv8->debug_base + CPUV8_DBG_DSCR, &dscr);
1813 if (retval != ERROR_OK)
1814 return retval;
1815
1816 /* Set Normal access mode */
1817 dscr = (dscr & ~DSCR_MA);
1818 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
1819 armv8->debug_base + CPUV8_DBG_DSCR, dscr);
1820 if (retval != ERROR_OK)
1821 return retval;
1822
1823 if (arm->core_state == ARM_STATE_AARCH64) {
1824 /* Write X0 with value 'address' using write procedure */
1825 /* Step 1.a+b - Write the address for read access into DBGDTR_EL0 */
1826 /* Step 1.c - Copy value from DTR to R0 using instruction mrs DBGDTR_EL0, x0 */
1827 retval = dpm->instr_write_data_dcc_64(dpm,
1828 ARMV8_MRS(SYSTEM_DBG_DBGDTR_EL0, 0), address);
1829 } else {
1830 /* Write R0 with value 'address' using write procedure */
1831 /* Step 1.a+b - Write the address for read access into DBGDTRRX */
1832 /* Step 1.c - Copy value from DTR to R0 using instruction mrc DBGDTRTXint, r0 */
1833 retval = dpm->instr_write_data_dcc(dpm,
1834 ARMV4_5_MRC(14, 0, 0, 0, 5, 0), address);
1835 }
1836
1837 if (retval != ERROR_OK)
1838 return retval;
1839
1840 if (size == 4 && (address % 4) == 0)
1841 retval = aarch64_write_cpu_memory_fast(target, count, buffer, &dscr);
1842 else
1843 retval = aarch64_write_cpu_memory_slow(target, size, count, buffer, &dscr);
1844
1845 if (retval != ERROR_OK) {
1846 /* Unset DTR mode */
1847 mem_ap_read_atomic_u32(armv8->debug_ap,
1848 armv8->debug_base + CPUV8_DBG_DSCR, &dscr);
1849 dscr &= ~DSCR_MA;
1850 mem_ap_write_atomic_u32(armv8->debug_ap,
1851 armv8->debug_base + CPUV8_DBG_DSCR, dscr);
1852 }
1853
1854 /* Check for sticky abort flags in the DSCR */
1855 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
1856 armv8->debug_base + CPUV8_DBG_DSCR, &dscr);
1857 if (retval != ERROR_OK)
1858 return retval;
1859
1860 dpm->dscr = dscr;
1861 if (dscr & (DSCR_ERR | DSCR_SYS_ERROR_PEND)) {
1862 /* Abort occurred - clear it and exit */
1863 LOG_ERROR("abort occurred - dscr = 0x%08" PRIx32, dscr);
1864 armv8_dpm_handle_exception(dpm, true);
1865 return ERROR_FAIL;
1866 }
1867
1868 /* Done */
1869 return ERROR_OK;
1870 }
1871
1872 static int aarch64_read_cpu_memory_slow(struct target *target,
1873 uint32_t size, uint32_t count, uint8_t *buffer, uint32_t *dscr)
1874 {
1875 struct armv8_common *armv8 = target_to_armv8(target);
1876 struct arm_dpm *dpm = &armv8->dpm;
1877 struct arm *arm = &armv8->arm;
1878 int retval;
1879
1880 armv8_reg_current(arm, 1)->dirty = true;
1881
1882 /* change DCC to normal mode (if necessary) */
1883 if (*dscr & DSCR_MA) {
1884 *dscr &= DSCR_MA;
1885 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
1886 armv8->debug_base + CPUV8_DBG_DSCR, *dscr);
1887 if (retval != ERROR_OK)
1888 return retval;
1889 }
1890
1891 while (count) {
1892 uint32_t opcode, data;
1893
1894 if (size == 1)
1895 opcode = armv8_opcode(armv8, ARMV8_OPC_LDRB_IP);
1896 else if (size == 2)
1897 opcode = armv8_opcode(armv8, ARMV8_OPC_LDRH_IP);
1898 else
1899 opcode = armv8_opcode(armv8, ARMV8_OPC_LDRW_IP);
1900 retval = dpm->instr_execute(dpm, opcode);
1901 if (retval != ERROR_OK)
1902 return retval;
1903
1904 if (arm->core_state == ARM_STATE_AARCH64)
1905 retval = dpm->instr_execute(dpm, ARMV8_MSR_GP(SYSTEM_DBG_DTRTX_EL0, 1));
1906 else
1907 retval = dpm->instr_execute(dpm, ARMV4_5_MCR(14, 0, 1, 0, 5, 0));
1908 if (retval != ERROR_OK)
1909 return retval;
1910
1911 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
1912 armv8->debug_base + CPUV8_DBG_DTRTX, &data);
1913 if (retval != ERROR_OK)
1914 return retval;
1915
1916 if (size == 1)
1917 *buffer = (uint8_t)data;
1918 else if (size == 2)
1919 target_buffer_set_u16(target, buffer, (uint16_t)data);
1920 else
1921 target_buffer_set_u32(target, buffer, data);
1922
1923 /* Advance */
1924 buffer += size;
1925 --count;
1926 }
1927
1928 return ERROR_OK;
1929 }
1930
1931 static int aarch64_read_cpu_memory_fast(struct target *target,
1932 uint32_t count, uint8_t *buffer, uint32_t *dscr)
1933 {
1934 struct armv8_common *armv8 = target_to_armv8(target);
1935 struct arm_dpm *dpm = &armv8->dpm;
1936 struct arm *arm = &armv8->arm;
1937 int retval;
1938 uint32_t value;
1939
1940 /* Mark X1 as dirty */
1941 armv8_reg_current(arm, 1)->dirty = true;
1942
1943 if (arm->core_state == ARM_STATE_AARCH64) {
1944 /* Step 1.d - Dummy operation to ensure EDSCR.Txfull == 1 */
1945 retval = dpm->instr_execute(dpm, ARMV8_MSR_GP(SYSTEM_DBG_DBGDTR_EL0, 0));
1946 } else {
1947 /* Step 1.d - Dummy operation to ensure EDSCR.Txfull == 1 */
1948 retval = dpm->instr_execute(dpm, ARMV4_5_MCR(14, 0, 0, 0, 5, 0));
1949 }
1950
1951 if (retval != ERROR_OK)
1952 return retval;
1953
1954 /* Step 1.e - Change DCC to memory mode */
1955 *dscr |= DSCR_MA;
1956 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
1957 armv8->debug_base + CPUV8_DBG_DSCR, *dscr);
1958 if (retval != ERROR_OK)
1959 return retval;
1960
1961 /* Step 1.f - read DBGDTRTX and discard the value */
1962 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
1963 armv8->debug_base + CPUV8_DBG_DTRTX, &value);
1964 if (retval != ERROR_OK)
1965 return retval;
1966
1967 count--;
1968 /* Read the data - Each read of the DTRTX register causes the instruction to be reissued
1969 * Abort flags are sticky, so can be read at end of transactions
1970 *
1971 * This data is read in aligned to 32 bit boundary.
1972 */
1973
1974 if (count) {
1975 /* Step 2.a - Loop n-1 times, each read of DBGDTRTX reads the data from [X0] and
1976 * increments X0 by 4. */
1977 retval = mem_ap_read_buf_noincr(armv8->debug_ap, buffer, 4, count,
1978 armv8->debug_base + CPUV8_DBG_DTRTX);
1979 if (retval != ERROR_OK)
1980 return retval;
1981 }
1982
1983 /* Step 3.a - set DTR access mode back to Normal mode */
1984 *dscr &= ~DSCR_MA;
1985 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
1986 armv8->debug_base + CPUV8_DBG_DSCR, *dscr);
1987 if (retval != ERROR_OK)
1988 return retval;
1989
1990 /* Step 3.b - read DBGDTRTX for the final value */
1991 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
1992 armv8->debug_base + CPUV8_DBG_DTRTX, &value);
1993 if (retval != ERROR_OK)
1994 return retval;
1995
1996 target_buffer_set_u32(target, buffer + count * 4, value);
1997 return retval;
1998 }
1999
2000 static int aarch64_read_cpu_memory(struct target *target,
2001 target_addr_t address, uint32_t size,
2002 uint32_t count, uint8_t *buffer)
2003 {
2004 /* read memory through APB-AP */
2005 int retval = ERROR_COMMAND_SYNTAX_ERROR;
2006 struct armv8_common *armv8 = target_to_armv8(target);
2007 struct arm_dpm *dpm = &armv8->dpm;
2008 struct arm *arm = &armv8->arm;
2009 uint32_t dscr;
2010
2011 LOG_DEBUG("Reading CPU memory address 0x%016" PRIx64 " size %" PRIu32 " count %" PRIu32,
2012 address, size, count);
2013
2014 if (target->state != TARGET_HALTED) {
2015 LOG_WARNING("target not halted");
2016 return ERROR_TARGET_NOT_HALTED;
2017 }
2018
2019 /* Mark register X0 as dirty, as it will be used
2020 * for transferring the data.
2021 * It will be restored automatically when exiting
2022 * debug mode
2023 */
2024 armv8_reg_current(arm, 0)->dirty = true;
2025
2026 /* Read DSCR */
2027 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
2028 armv8->debug_base + CPUV8_DBG_DSCR, &dscr);
2029 if (retval != ERROR_OK)
2030 return retval;
2031
2032 /* This algorithm comes from DDI0487A.g, chapter J9.1 */
2033
2034 /* Set Normal access mode */
2035 dscr &= ~DSCR_MA;
2036 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
2037 armv8->debug_base + CPUV8_DBG_DSCR, dscr);
2038 if (retval != ERROR_OK)
2039 return retval;
2040
2041 if (arm->core_state == ARM_STATE_AARCH64) {
2042 /* Write X0 with value 'address' using write procedure */
2043 /* Step 1.a+b - Write the address for read access into DBGDTR_EL0 */
2044 /* Step 1.c - Copy value from DTR to R0 using instruction mrs DBGDTR_EL0, x0 */
2045 retval = dpm->instr_write_data_dcc_64(dpm,
2046 ARMV8_MRS(SYSTEM_DBG_DBGDTR_EL0, 0), address);
2047 } else {
2048 /* Write R0 with value 'address' using write procedure */
2049 /* Step 1.a+b - Write the address for read access into DBGDTRRXint */
2050 /* Step 1.c - Copy value from DTR to R0 using instruction mrc DBGDTRTXint, r0 */
2051 retval = dpm->instr_write_data_dcc(dpm,
2052 ARMV4_5_MRC(14, 0, 0, 0, 5, 0), address);
2053 }
2054
2055 if (retval != ERROR_OK)
2056 return retval;
2057
2058 if (size == 4 && (address % 4) == 0)
2059 retval = aarch64_read_cpu_memory_fast(target, count, buffer, &dscr);
2060 else
2061 retval = aarch64_read_cpu_memory_slow(target, size, count, buffer, &dscr);
2062
2063 if (dscr & DSCR_MA) {
2064 dscr &= ~DSCR_MA;
2065 mem_ap_write_atomic_u32(armv8->debug_ap,
2066 armv8->debug_base + CPUV8_DBG_DSCR, dscr);
2067 }
2068
2069 if (retval != ERROR_OK)
2070 return retval;
2071
2072 /* Check for sticky abort flags in the DSCR */
2073 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
2074 armv8->debug_base + CPUV8_DBG_DSCR, &dscr);
2075 if (retval != ERROR_OK)
2076 return retval;
2077
2078 dpm->dscr = dscr;
2079
2080 if (dscr & (DSCR_ERR | DSCR_SYS_ERROR_PEND)) {
2081 /* Abort occurred - clear it and exit */
2082 LOG_ERROR("abort occurred - dscr = 0x%08" PRIx32, dscr);
2083 armv8_dpm_handle_exception(dpm, true);
2084 return ERROR_FAIL;
2085 }
2086
2087 /* Done */
2088 return ERROR_OK;
2089 }
2090
2091 static int aarch64_read_phys_memory(struct target *target,
2092 target_addr_t address, uint32_t size,
2093 uint32_t count, uint8_t *buffer)
2094 {
2095 int retval = ERROR_COMMAND_SYNTAX_ERROR;
2096
2097 if (count && buffer) {
2098 /* read memory through APB-AP */
2099 retval = aarch64_mmu_modify(target, 0);
2100 if (retval != ERROR_OK)
2101 return retval;
2102 retval = aarch64_read_cpu_memory(target, address, size, count, buffer);
2103 }
2104 return retval;
2105 }
2106
2107 static int aarch64_read_memory(struct target *target, target_addr_t address,
2108 uint32_t size, uint32_t count, uint8_t *buffer)
2109 {
2110 int mmu_enabled = 0;
2111 int retval;
2112
2113 /* determine if MMU was enabled on target stop */
2114 retval = aarch64_mmu(target, &mmu_enabled);
2115 if (retval != ERROR_OK)
2116 return retval;
2117
2118 if (mmu_enabled) {
2119 /* enable MMU as we could have disabled it for phys access */
2120 retval = aarch64_mmu_modify(target, 1);
2121 if (retval != ERROR_OK)
2122 return retval;
2123 }
2124 return aarch64_read_cpu_memory(target, address, size, count, buffer);
2125 }
2126
2127 static int aarch64_write_phys_memory(struct target *target,
2128 target_addr_t address, uint32_t size,
2129 uint32_t count, const uint8_t *buffer)
2130 {
2131 int retval = ERROR_COMMAND_SYNTAX_ERROR;
2132
2133 if (count && buffer) {
2134 /* write memory through APB-AP */
2135 retval = aarch64_mmu_modify(target, 0);
2136 if (retval != ERROR_OK)
2137 return retval;
2138 return aarch64_write_cpu_memory(target, address, size, count, buffer);
2139 }
2140
2141 return retval;
2142 }
2143
2144 static int aarch64_write_memory(struct target *target, target_addr_t address,
2145 uint32_t size, uint32_t count, const uint8_t *buffer)
2146 {
2147 int mmu_enabled = 0;
2148 int retval;
2149
2150 /* determine if MMU was enabled on target stop */
2151 retval = aarch64_mmu(target, &mmu_enabled);
2152 if (retval != ERROR_OK)
2153 return retval;
2154
2155 if (mmu_enabled) {
2156 /* enable MMU as we could have disabled it for phys access */
2157 retval = aarch64_mmu_modify(target, 1);
2158 if (retval != ERROR_OK)
2159 return retval;
2160 }
2161 return aarch64_write_cpu_memory(target, address, size, count, buffer);
2162 }
2163
2164 static int aarch64_handle_target_request(void *priv)
2165 {
2166 struct target *target = priv;
2167 struct armv8_common *armv8 = target_to_armv8(target);
2168 int retval;
2169
2170 if (!target_was_examined(target))
2171 return ERROR_OK;
2172 if (!target->dbg_msg_enabled)
2173 return ERROR_OK;
2174
2175 if (target->state == TARGET_RUNNING) {
2176 uint32_t request;
2177 uint32_t dscr;
2178 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
2179 armv8->debug_base + CPUV8_DBG_DSCR, &dscr);
2180
2181 /* check if we have data */
2182 while ((dscr & DSCR_DTR_TX_FULL) && (retval == ERROR_OK)) {
2183 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
2184 armv8->debug_base + CPUV8_DBG_DTRTX, &request);
2185 if (retval == ERROR_OK) {
2186 target_request(target, request);
2187 retval = mem_ap_read_atomic_u32(armv8->debug_ap,
2188 armv8->debug_base + CPUV8_DBG_DSCR, &dscr);
2189 }
2190 }
2191 }
2192
2193 return ERROR_OK;
2194 }
2195
2196 static int aarch64_examine_first(struct target *target)
2197 {
2198 struct aarch64_common *aarch64 = target_to_aarch64(target);
2199 struct armv8_common *armv8 = &aarch64->armv8_common;
2200 struct adiv5_dap *swjdp = armv8->arm.dap;
2201 uint32_t cti_base;
2202 int i;
2203 int retval = ERROR_OK;
2204 uint64_t debug, ttypr;
2205 uint32_t cpuid;
2206 uint32_t tmp0, tmp1, tmp2, tmp3;
2207 debug = ttypr = cpuid = 0;
2208
2209 retval = dap_dp_init(swjdp);
2210 if (retval != ERROR_OK)
2211 return retval;
2212
2213 /* Search for the APB-AB - it is needed for access to debug registers */
2214 retval = dap_find_ap(swjdp, AP_TYPE_APB_AP, &armv8->debug_ap);
2215 if (retval != ERROR_OK) {
2216 LOG_ERROR("Could not find APB-AP for debug access");
2217 return retval;
2218 }
2219
2220 retval = mem_ap_init(armv8->debug_ap);
2221 if (retval != ERROR_OK) {
2222 LOG_ERROR("Could not initialize the APB-AP");
2223 return retval;
2224 }
2225
2226 armv8->debug_ap->memaccess_tck = 10;
2227
2228 if (!target->dbgbase_set) {
2229 uint32_t dbgbase;
2230 /* Get ROM Table base */
2231 uint32_t apid;
2232 int32_t coreidx = target->coreid;
2233 retval = dap_get_debugbase(armv8->debug_ap, &dbgbase, &apid);
2234 if (retval != ERROR_OK)
2235 return retval;
2236 /* Lookup 0x15 -- Processor DAP */
2237 retval = dap_lookup_cs_component(armv8->debug_ap, dbgbase, 0x15,
2238 &armv8->debug_base, &coreidx);
2239 if (retval != ERROR_OK)
2240 return retval;
2241 LOG_DEBUG("Detected core %" PRId32 " dbgbase: %08" PRIx32
2242 " apid: %08" PRIx32, coreidx, armv8->debug_base, apid);
2243 } else
2244 armv8->debug_base = target->dbgbase;
2245
2246 retval = mem_ap_write_atomic_u32(armv8->debug_ap,
2247 armv8->debug_base + CPUV8_DBG_OSLAR, 0);
2248 if (retval != ERROR_OK) {
2249 LOG_DEBUG("Examine %s failed", "oslock");
2250 return retval;
2251 }
2252
2253 retval = mem_ap_read_u32(armv8->debug_ap,
2254 armv8->debug_base + CPUV8_DBG_MAINID0, &cpuid);
2255 if (retval != ERROR_OK) {
2256 LOG_DEBUG("Examine %s failed", "CPUID");
2257 return retval;
2258 }
2259
2260 retval = mem_ap_read_u32(armv8->debug_ap,
2261 armv8->debug_base + CPUV8_DBG_MEMFEATURE0, &tmp0);
2262 retval += mem_ap_read_u32(armv8->debug_ap,
2263 armv8->debug_base + CPUV8_DBG_MEMFEATURE0 + 4, &tmp1);
2264 if (retval != ERROR_OK) {
2265 LOG_DEBUG("Examine %s failed", "Memory Model Type");
2266 return retval;
2267 }
2268 retval = mem_ap_read_u32(armv8->debug_ap,
2269 armv8->debug_base + CPUV8_DBG_DBGFEATURE0, &tmp2);
2270 retval += mem_ap_read_u32(armv8->debug_ap,
2271 armv8->debug_base + CPUV8_DBG_DBGFEATURE0 + 4, &tmp3);
2272 if (retval != ERROR_OK) {
2273 LOG_DEBUG("Examine %s failed", "ID_AA64DFR0_EL1");
2274 return retval;
2275 }
2276
2277 retval = dap_run(armv8->debug_ap->dap);
2278 if (retval != ERROR_OK) {
2279 LOG_ERROR("%s: examination failed\n", target_name(target));
2280 return retval;
2281 }
2282
2283 ttypr |= tmp1;
2284 ttypr = (ttypr << 32) | tmp0;
2285 debug |= tmp3;
2286 debug = (debug << 32) | tmp2;
2287
2288 LOG_DEBUG("cpuid = 0x%08" PRIx32, cpuid);
2289 LOG_DEBUG("ttypr = 0x%08" PRIx64, ttypr);
2290 LOG_DEBUG("debug = 0x%08" PRIx64, debug);
2291
2292 if (target->ctibase == 0) {
2293 /* assume a v8 rom table layout */
2294 cti_base = armv8->debug_base + 0x10000;
2295 LOG_INFO("Target ctibase is not set, assuming 0x%0" PRIx32, cti_base);
2296 } else
2297 cti_base = target->ctibase;
2298
2299 armv8->cti = arm_cti_create(armv8->debug_ap, cti_base);
2300 if (armv8->cti == NULL)
2301 return ERROR_FAIL;
2302
2303 retval = aarch64_dpm_setup(aarch64, debug);
2304 if (retval != ERROR_OK)
2305 return retval;
2306
2307 /* Setup Breakpoint Register Pairs */
2308 aarch64->brp_num = (uint32_t)((debug >> 12) & 0x0F) + 1;
2309 aarch64->brp_num_context = (uint32_t)((debug >> 28) & 0x0F) + 1;
2310 aarch64->brp_num_available = aarch64->brp_num;
2311 aarch64->brp_list = calloc(aarch64->brp_num, sizeof(struct aarch64_brp));
2312 for (i = 0; i < aarch64->brp_num; i++) {
2313 aarch64->brp_list[i].used = 0;
2314 if (i < (aarch64->brp_num-aarch64->brp_num_context))
2315 aarch64->brp_list[i].type = BRP_NORMAL;
2316 else
2317 aarch64->brp_list[i].type = BRP_CONTEXT;
2318 aarch64->brp_list[i].value = 0;
2319 aarch64->brp_list[i].control = 0;
2320 aarch64->brp_list[i].BRPn = i;
2321 }
2322
2323 LOG_DEBUG("Configured %i hw breakpoints", aarch64->brp_num);
2324
2325 target->state = TARGET_UNKNOWN;
2326 target->debug_reason = DBG_REASON_NOTHALTED;
2327 aarch64->isrmasking_mode = AARCH64_ISRMASK_ON;
2328 target_set_examined(target);
2329 return ERROR_OK;
2330 }
2331
2332 static int aarch64_examine(struct target *target)
2333 {
2334 int retval = ERROR_OK;
2335
2336 /* don't re-probe hardware after each reset */
2337 if (!target_was_examined(target))
2338 retval = aarch64_examine_first(target);
2339
2340 /* Configure core debug access */
2341 if (retval == ERROR_OK)
2342 retval = aarch64_init_debug_access(target);
2343
2344 return retval;
2345 }
2346
2347 /*
2348 * Cortex-A8 target creation and initialization
2349 */
2350
2351 static int aarch64_init_target(struct command_context *cmd_ctx,
2352 struct target *target)
2353 {
2354 /* examine_first() does a bunch of this */
2355 return ERROR_OK;
2356 }
2357
2358 static int aarch64_init_arch_info(struct target *target,
2359 struct aarch64_common *aarch64, struct jtag_tap *tap)
2360 {
2361 struct armv8_common *armv8 = &aarch64->armv8_common;
2362
2363 /* Setup struct aarch64_common */
2364 aarch64->common_magic = AARCH64_COMMON_MAGIC;
2365 /* tap has no dap initialized */
2366 if (!tap->dap) {
2367 tap->dap = dap_init();
2368 tap->dap->tap = tap;
2369 }
2370 armv8->arm.dap = tap->dap;
2371
2372 /* register arch-specific functions */
2373 armv8->examine_debug_reason = NULL;
2374 armv8->post_debug_entry = aarch64_post_debug_entry;
2375 armv8->pre_restore_context = NULL;
2376 armv8->armv8_mmu.read_physical_memory = aarch64_read_phys_memory;
2377
2378 armv8_init_arch_info(target, armv8);
2379 target_register_timer_callback(aarch64_handle_target_request, 1, 1, target);
2380
2381 return ERROR_OK;
2382 }
2383
2384 static int aarch64_target_create(struct target *target, Jim_Interp *interp)
2385 {
2386 struct aarch64_common *aarch64 = calloc(1, sizeof(struct aarch64_common));
2387
2388 return aarch64_init_arch_info(target, aarch64, target->tap);
2389 }
2390
2391 static int aarch64_mmu(struct target *target, int *enabled)
2392 {
2393 if (target->state != TARGET_HALTED) {
2394 LOG_ERROR("%s: target %s not halted", __func__, target_name(target));
2395 return ERROR_TARGET_INVALID;
2396 }
2397
2398 *enabled = target_to_aarch64(target)->armv8_common.armv8_mmu.mmu_enabled;
2399 return ERROR_OK;
2400 }
2401
2402 static int aarch64_virt2phys(struct target *target, target_addr_t virt,
2403 target_addr_t *phys)
2404 {
2405 return armv8_mmu_translate_va_pa(target, virt, phys, 1);
2406 }
2407
2408 COMMAND_HANDLER(aarch64_handle_cache_info_command)
2409 {
2410 struct target *target = get_current_target(CMD_CTX);
2411 struct armv8_common *armv8 = target_to_armv8(target);
2412
2413 return armv8_handle_cache_info_command(CMD_CTX,
2414 &armv8->armv8_mmu.armv8_cache);
2415 }
2416
2417
2418 COMMAND_HANDLER(aarch64_handle_dbginit_command)
2419 {
2420 struct target *target = get_current_target(CMD_CTX);
2421 if (!target_was_examined(target)) {
2422 LOG_ERROR("target not examined yet");
2423 return ERROR_FAIL;
2424 }
2425
2426 return aarch64_init_debug_access(target);
2427 }
2428 COMMAND_HANDLER(aarch64_handle_smp_off_command)
2429 {
2430 struct target *target = get_current_target(CMD_CTX);
2431 /* check target is an smp target */
2432 struct target_list *head;
2433 struct target *curr;
2434 head = target->head;
2435 target->smp = 0;
2436 if (head != (struct target_list *)NULL) {
2437 while (head != (struct target_list *)NULL) {
2438 curr = head->target;
2439 curr->smp = 0;
2440 head = head->next;
2441 }
2442 /* fixes the target display to the debugger */
2443 target->gdb_service->target = target;
2444 }
2445 return ERROR_OK;
2446 }
2447
2448 COMMAND_HANDLER(aarch64_handle_smp_on_command)
2449 {
2450 struct target *target = get_current_target(CMD_CTX);
2451 struct target_list *head;
2452 struct target *curr;
2453 head = target->head;
2454 if (head != (struct target_list *)NULL) {
2455 target->smp = 1;
2456 while (head != (struct target_list *)NULL) {
2457 curr = head->target;
2458 curr->smp = 1;
2459 head = head->next;
2460 }
2461 }
2462 return ERROR_OK;
2463 }
2464
2465 COMMAND_HANDLER(aarch64_mask_interrupts_command)
2466 {
2467 struct target *target = get_current_target(CMD_CTX);
2468 struct aarch64_common *aarch64 = target_to_aarch64(target);
2469
2470 static const Jim_Nvp nvp_maskisr_modes[] = {
2471 { .name = "off", .value = AARCH64_ISRMASK_OFF },
2472 { .name = "on", .value = AARCH64_ISRMASK_ON },
2473 { .name = NULL, .value = -1 },
2474 };
2475 const Jim_Nvp *n;
2476
2477 if (CMD_ARGC > 0) {
2478 n = Jim_Nvp_name2value_simple(nvp_maskisr_modes, CMD_ARGV[0]);
2479 if (n->name == NULL) {
2480 LOG_ERROR("Unknown parameter: %s - should be off or on", CMD_ARGV[0]);
2481 return ERROR_COMMAND_SYNTAX_ERROR;
2482 }
2483
2484 aarch64->isrmasking_mode = n->value;
2485 }
2486
2487 n = Jim_Nvp_value2name_simple(nvp_maskisr_modes, aarch64->isrmasking_mode);
2488 command_print(CMD_CTX, "aarch64 interrupt mask %s", n->name);
2489
2490 return ERROR_OK;
2491 }
2492
2493 static const struct command_registration aarch64_exec_command_handlers[] = {
2494 {
2495 .name = "cache_info",
2496 .handler = aarch64_handle_cache_info_command,
2497 .mode = COMMAND_EXEC,
2498 .help = "display information about target caches",
2499 .usage = "",
2500 },
2501 {
2502 .name = "dbginit",
2503 .handler = aarch64_handle_dbginit_command,
2504 .mode = COMMAND_EXEC,
2505 .help = "Initialize core debug",
2506 .usage = "",
2507 },
2508 { .name = "smp_off",
2509 .handler = aarch64_handle_smp_off_command,
2510 .mode = COMMAND_EXEC,
2511 .help = "Stop smp handling",
2512 .usage = "",
2513 },
2514 {
2515 .name = "smp_on",
2516 .handler = aarch64_handle_smp_on_command,
2517 .mode = COMMAND_EXEC,
2518 .help = "Restart smp handling",
2519 .usage = "",
2520 },
2521 {
2522 .name = "maskisr",
2523 .handler = aarch64_mask_interrupts_command,
2524 .mode = COMMAND_ANY,
2525 .help = "mask aarch64 interrupts during single-step",
2526 .usage = "['on'|'off']",
2527 },
2528
2529 COMMAND_REGISTRATION_DONE
2530 };
2531 static const struct command_registration aarch64_command_handlers[] = {
2532 {
2533 .chain = armv8_command_handlers,
2534 },
2535 {
2536 .name = "aarch64",
2537 .mode = COMMAND_ANY,
2538 .help = "Aarch64 command group",
2539 .usage = "",
2540 .chain = aarch64_exec_command_handlers,
2541 },
2542 COMMAND_REGISTRATION_DONE
2543 };
2544
2545 struct target_type aarch64_target = {
2546 .name = "aarch64",
2547
2548 .poll = aarch64_poll,
2549 .arch_state = armv8_arch_state,
2550
2551 .halt = aarch64_halt,
2552 .resume = aarch64_resume,
2553 .step = aarch64_step,
2554
2555 .assert_reset = aarch64_assert_reset,
2556 .deassert_reset = aarch64_deassert_reset,
2557
2558 /* REVISIT allow exporting VFP3 registers ... */
2559 .get_gdb_reg_list = armv8_get_gdb_reg_list,
2560
2561 .read_memory = aarch64_read_memory,
2562 .write_memory = aarch64_write_memory,
2563
2564 .add_breakpoint = aarch64_add_breakpoint,
2565 .add_context_breakpoint = aarch64_add_context_breakpoint,
2566 .add_hybrid_breakpoint = aarch64_add_hybrid_breakpoint,
2567 .remove_breakpoint = aarch64_remove_breakpoint,
2568 .add_watchpoint = NULL,
2569 .remove_watchpoint = NULL,
2570
2571 .commands = aarch64_command_handlers,
2572 .target_create = aarch64_target_create,
2573 .init_target = aarch64_init_target,
2574 .examine = aarch64_examine,
2575
2576 .read_phys_memory = aarch64_read_phys_memory,
2577 .write_phys_memory = aarch64_write_phys_memory,
2578 .mmu = aarch64_mmu,
2579 .virt2phys = aarch64_virt2phys,
2580 };
Open On-Chip Debugger

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)