Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
ARM11: switch to new "arm" base type
[openocd.git] / src / target / arm11.c
1 /***************************************************************************
2 * Copyright (C) 2008 digenius technology GmbH. *
3 * Michael Bruck *
4 * *
5 * Copyright (C) 2008,2009 Oyvind Harboe oyvind.harboe@zylin.com *
6 * *
7 * Copyright (C) 2008 Georg Acher <acher@in.tum.de> *
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 * This program is distributed in the hope that it will be useful, *
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
17 * GNU General Public License for more details. *
18 * *
19 * You should have received a copy of the GNU General Public License *
20 * along with this program; if not, write to the *
21 * Free Software Foundation, Inc., *
22 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
23 ***************************************************************************/
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include "arm11.h"
30 #include "arm11_dbgtap.h"
31 #include "armv4_5.h"
32 #include "arm_simulator.h"
33 #include "time_support.h"
34 #include "target_type.h"
35
36
37 #if 0
38 #define _DEBUG_INSTRUCTION_EXECUTION_
39 #endif
40
41 #if 0
42 #define FNC_INFO LOG_DEBUG("-")
43 #else
44 #define FNC_INFO
45 #endif
46
47 #if 1
48 #define FNC_INFO_NOTIMPLEMENTED do { LOG_DEBUG("NOT IMPLEMENTED"); /*exit(-1);*/ } while (0)
49 #else
50 #define FNC_INFO_NOTIMPLEMENTED
51 #endif
52
53 static bool arm11_config_memwrite_burst = true;
54 static bool arm11_config_memwrite_error_fatal = true;
55 static uint32_t arm11_vcr = 0;
56 static bool arm11_config_step_irq_enable = false;
57 static bool arm11_config_hardware_step = false;
58
59 static int arm11_regs_arch_type = -1;
60
61 enum arm11_regtype
62 {
63 ARM11_REGISTER_CORE,
64 ARM11_REGISTER_CPSR,
65
66 ARM11_REGISTER_FX,
67 ARM11_REGISTER_FPS,
68
69 ARM11_REGISTER_FIQ,
70 ARM11_REGISTER_SVC,
71 ARM11_REGISTER_ABT,
72 ARM11_REGISTER_IRQ,
73 ARM11_REGISTER_UND,
74 ARM11_REGISTER_MON,
75
76 ARM11_REGISTER_SPSR_FIQ,
77 ARM11_REGISTER_SPSR_SVC,
78 ARM11_REGISTER_SPSR_ABT,
79 ARM11_REGISTER_SPSR_IRQ,
80 ARM11_REGISTER_SPSR_UND,
81 ARM11_REGISTER_SPSR_MON,
82
83 /* debug regs */
84 ARM11_REGISTER_DSCR,
85 ARM11_REGISTER_WDTR,
86 ARM11_REGISTER_RDTR,
87 };
88
89
90 struct arm11_reg_defs
91 {
92 char * name;
93 uint32_t num;
94 int gdb_num;
95 enum arm11_regtype type;
96 };
97
98 /* update arm11_regcache_ids when changing this */
99 static const struct arm11_reg_defs arm11_reg_defs[] =
100 {
101 {"r0", 0, 0, ARM11_REGISTER_CORE},
102 {"r1", 1, 1, ARM11_REGISTER_CORE},
103 {"r2", 2, 2, ARM11_REGISTER_CORE},
104 {"r3", 3, 3, ARM11_REGISTER_CORE},
105 {"r4", 4, 4, ARM11_REGISTER_CORE},
106 {"r5", 5, 5, ARM11_REGISTER_CORE},
107 {"r6", 6, 6, ARM11_REGISTER_CORE},
108 {"r7", 7, 7, ARM11_REGISTER_CORE},
109 {"r8", 8, 8, ARM11_REGISTER_CORE},
110 {"r9", 9, 9, ARM11_REGISTER_CORE},
111 {"r10", 10, 10, ARM11_REGISTER_CORE},
112 {"r11", 11, 11, ARM11_REGISTER_CORE},
113 {"r12", 12, 12, ARM11_REGISTER_CORE},
114 {"sp", 13, 13, ARM11_REGISTER_CORE},
115 {"lr", 14, 14, ARM11_REGISTER_CORE},
116 {"pc", 15, 15, ARM11_REGISTER_CORE},
117
118 #if ARM11_REGCACHE_FREGS
119 {"f0", 0, 16, ARM11_REGISTER_FX},
120 {"f1", 1, 17, ARM11_REGISTER_FX},
121 {"f2", 2, 18, ARM11_REGISTER_FX},
122 {"f3", 3, 19, ARM11_REGISTER_FX},
123 {"f4", 4, 20, ARM11_REGISTER_FX},
124 {"f5", 5, 21, ARM11_REGISTER_FX},
125 {"f6", 6, 22, ARM11_REGISTER_FX},
126 {"f7", 7, 23, ARM11_REGISTER_FX},
127 {"fps", 0, 24, ARM11_REGISTER_FPS},
128 #endif
129
130 {"cpsr", 0, 25, ARM11_REGISTER_CPSR},
131
132 #if ARM11_REGCACHE_MODEREGS
133 {"r8_fiq", 8, -1, ARM11_REGISTER_FIQ},
134 {"r9_fiq", 9, -1, ARM11_REGISTER_FIQ},
135 {"r10_fiq", 10, -1, ARM11_REGISTER_FIQ},
136 {"r11_fiq", 11, -1, ARM11_REGISTER_FIQ},
137 {"r12_fiq", 12, -1, ARM11_REGISTER_FIQ},
138 {"r13_fiq", 13, -1, ARM11_REGISTER_FIQ},
139 {"r14_fiq", 14, -1, ARM11_REGISTER_FIQ},
140 {"spsr_fiq", 0, -1, ARM11_REGISTER_SPSR_FIQ},
141
142 {"r13_svc", 13, -1, ARM11_REGISTER_SVC},
143 {"r14_svc", 14, -1, ARM11_REGISTER_SVC},
144 {"spsr_svc", 0, -1, ARM11_REGISTER_SPSR_SVC},
145
146 {"r13_abt", 13, -1, ARM11_REGISTER_ABT},
147 {"r14_abt", 14, -1, ARM11_REGISTER_ABT},
148 {"spsr_abt", 0, -1, ARM11_REGISTER_SPSR_ABT},
149
150 {"r13_irq", 13, -1, ARM11_REGISTER_IRQ},
151 {"r14_irq", 14, -1, ARM11_REGISTER_IRQ},
152 {"spsr_irq", 0, -1, ARM11_REGISTER_SPSR_IRQ},
153
154 {"r13_und", 13, -1, ARM11_REGISTER_UND},
155 {"r14_und", 14, -1, ARM11_REGISTER_UND},
156 {"spsr_und", 0, -1, ARM11_REGISTER_SPSR_UND},
157
158 /* ARM1176 only */
159 {"r13_mon", 13, -1, ARM11_REGISTER_MON},
160 {"r14_mon", 14, -1, ARM11_REGISTER_MON},
161 {"spsr_mon", 0, -1, ARM11_REGISTER_SPSR_MON},
162 #endif
163
164 /* Debug Registers */
165 {"dscr", 0, -1, ARM11_REGISTER_DSCR},
166 {"wdtr", 0, -1, ARM11_REGISTER_WDTR},
167 {"rdtr", 0, -1, ARM11_REGISTER_RDTR},
168 };
169
170 enum arm11_regcache_ids
171 {
172 ARM11_RC_R0,
173 ARM11_RC_RX = ARM11_RC_R0,
174
175 ARM11_RC_R1,
176 ARM11_RC_R2,
177 ARM11_RC_R3,
178 ARM11_RC_R4,
179 ARM11_RC_R5,
180 ARM11_RC_R6,
181 ARM11_RC_R7,
182 ARM11_RC_R8,
183 ARM11_RC_R9,
184 ARM11_RC_R10,
185 ARM11_RC_R11,
186 ARM11_RC_R12,
187 ARM11_RC_R13,
188 ARM11_RC_SP = ARM11_RC_R13,
189 ARM11_RC_R14,
190 ARM11_RC_LR = ARM11_RC_R14,
191 ARM11_RC_R15,
192 ARM11_RC_PC = ARM11_RC_R15,
193
194 #if ARM11_REGCACHE_FREGS
195 ARM11_RC_F0,
196 ARM11_RC_FX = ARM11_RC_F0,
197 ARM11_RC_F1,
198 ARM11_RC_F2,
199 ARM11_RC_F3,
200 ARM11_RC_F4,
201 ARM11_RC_F5,
202 ARM11_RC_F6,
203 ARM11_RC_F7,
204 ARM11_RC_FPS,
205 #endif
206
207 ARM11_RC_CPSR,
208
209 #if ARM11_REGCACHE_MODEREGS
210 ARM11_RC_R8_FIQ,
211 ARM11_RC_R9_FIQ,
212 ARM11_RC_R10_FIQ,
213 ARM11_RC_R11_FIQ,
214 ARM11_RC_R12_FIQ,
215 ARM11_RC_R13_FIQ,
216 ARM11_RC_R14_FIQ,
217 ARM11_RC_SPSR_FIQ,
218
219 ARM11_RC_R13_SVC,
220 ARM11_RC_R14_SVC,
221 ARM11_RC_SPSR_SVC,
222
223 ARM11_RC_R13_ABT,
224 ARM11_RC_R14_ABT,
225 ARM11_RC_SPSR_ABT,
226
227 ARM11_RC_R13_IRQ,
228 ARM11_RC_R14_IRQ,
229 ARM11_RC_SPSR_IRQ,
230
231 ARM11_RC_R13_UND,
232 ARM11_RC_R14_UND,
233 ARM11_RC_SPSR_UND,
234
235 ARM11_RC_R13_MON,
236 ARM11_RC_R14_MON,
237 ARM11_RC_SPSR_MON,
238 #endif
239
240 ARM11_RC_DSCR,
241 ARM11_RC_WDTR,
242 ARM11_RC_RDTR,
243
244 ARM11_RC_MAX,
245 };
246
247 #define ARM11_GDB_REGISTER_COUNT 26
248
249 /* FIXME these are *identical* to the ARMv4_5 dummies ... except
250 * for their names, and being static vs global, and having different
251 * addresses. Ditto ARMv7a and ARMv7m dummies.
252 */
253
254 static uint8_t arm11_gdb_dummy_fp_value[12];
255
256 static struct reg arm11_gdb_dummy_fp_reg =
257 {
258 .name = "GDB dummy floating-point register",
259 .value = arm11_gdb_dummy_fp_value,
260 .dirty = 0,
261 .valid = 1,
262 .size = 96,
263 .arch_info = NULL,
264 .arch_type = 0,
265 };
266
267 static uint8_t arm11_gdb_dummy_fps_value[4];
268
269 static struct reg arm11_gdb_dummy_fps_reg =
270 {
271 .name = "GDB dummy floating-point status register",
272 .value = arm11_gdb_dummy_fps_value,
273 .dirty = 0,
274 .valid = 1,
275 .size = 32,
276 .arch_info = NULL,
277 .arch_type = 0,
278 };
279
280
281 static int arm11_on_enter_debug_state(struct arm11_common *arm11);
282 static int arm11_step(struct target *target, int current,
283 uint32_t address, int handle_breakpoints);
284 /* helpers */
285 static int arm11_build_reg_cache(struct target *target);
286 static int arm11_set_reg(struct reg *reg, uint8_t *buf);
287 static int arm11_get_reg(struct reg *reg);
288
289 static void arm11_record_register_history(struct arm11_common * arm11);
290 static void arm11_dump_reg_changes(struct arm11_common * arm11);
291
292
293 /** Check and if necessary take control of the system
294 *
295 * \param arm11 Target state variable.
296 * \param dscr If the current DSCR content is
297 * available a pointer to a word holding the
298 * DSCR can be passed. Otherwise use NULL.
299 */
300 static int arm11_check_init(struct arm11_common *arm11, uint32_t *dscr)
301 {
302 FNC_INFO;
303
304 uint32_t dscr_local_tmp_copy;
305
306 if (!dscr)
307 {
308 dscr = &dscr_local_tmp_copy;
309
310 CHECK_RETVAL(arm11_read_DSCR(arm11, dscr));
311 }
312
313 if (!(*dscr & ARM11_DSCR_MODE_SELECT))
314 {
315 LOG_DEBUG("Bringing target into debug mode");
316
317 *dscr |= ARM11_DSCR_MODE_SELECT; /* Halt debug-mode */
318 arm11_write_DSCR(arm11, *dscr);
319
320 /* add further reset initialization here */
321
322 arm11->simulate_reset_on_next_halt = true;
323
324 if (*dscr & ARM11_DSCR_CORE_HALTED)
325 {
326 /** \todo TODO: this needs further scrutiny because
327 * arm11_on_enter_debug_state() never gets properly called.
328 * As a result we don't read the actual register states from
329 * the target.
330 */
331
332 arm11->target->state = TARGET_HALTED;
333 arm11->target->debug_reason = arm11_get_DSCR_debug_reason(*dscr);
334 }
335 else
336 {
337 arm11->target->state = TARGET_RUNNING;
338 arm11->target->debug_reason = DBG_REASON_NOTHALTED;
339 }
340
341 arm11_sc7_clear_vbw(arm11);
342 }
343
344 return ERROR_OK;
345 }
346
347
348
349 #define R(x) \
350 (arm11->reg_values[ARM11_RC_##x])
351
352 /** Save processor state.
353 *
354 * This is called when the HALT instruction has succeeded
355 * or on other occasions that stop the processor.
356 *
357 */
358 static int arm11_on_enter_debug_state(struct arm11_common *arm11)
359 {
360 int retval;
361 FNC_INFO;
362
363 for (size_t i = 0; i < asizeof(arm11->reg_values); i++)
364 {
365 arm11->reg_list[i].valid = 1;
366 arm11->reg_list[i].dirty = 0;
367 }
368
369 /* Save DSCR */
370 CHECK_RETVAL(arm11_read_DSCR(arm11, &R(DSCR)));
371
372 /* Save wDTR */
373
374 if (R(DSCR) & ARM11_DSCR_WDTR_FULL)
375 {
376 arm11_add_debug_SCAN_N(arm11, 0x05, ARM11_TAP_DEFAULT);
377
378 arm11_add_IR(arm11, ARM11_INTEST, ARM11_TAP_DEFAULT);
379
380 struct scan_field chain5_fields[3];
381
382 arm11_setup_field(arm11, 32, NULL, &R(WDTR), chain5_fields + 0);
383 arm11_setup_field(arm11, 1, NULL, NULL, chain5_fields + 1);
384 arm11_setup_field(arm11, 1, NULL, NULL, chain5_fields + 2);
385
386 arm11_add_dr_scan_vc(asizeof(chain5_fields), chain5_fields, TAP_DRPAUSE);
387 }
388 else
389 {
390 arm11->reg_list[ARM11_RC_WDTR].valid = 0;
391 }
392
393
394 /* DSCR: set ARM11_DSCR_EXECUTE_ARM_INSTRUCTION_ENABLE */
395 /* ARM1176 spec says this is needed only for wDTR/rDTR's "ITR mode", but not to issue ITRs
396 ARM1136 seems to require this to issue ITR's as well */
397
398 uint32_t new_dscr = R(DSCR) | ARM11_DSCR_EXECUTE_ARM_INSTRUCTION_ENABLE;
399
400 /* this executes JTAG queue: */
401
402 arm11_write_DSCR(arm11, new_dscr);
403
404
405 /* From the spec:
406 Before executing any instruction in debug state you have to drain the write buffer.
407 This ensures that no imprecise Data Aborts can return at a later point:*/
408
409 /** \todo TODO: Test drain write buffer. */
410
411 #if 0
412 while (1)
413 {
414 /* MRC p14,0,R0,c5,c10,0 */
415 // arm11_run_instr_no_data1(arm11, /*0xee150e1a*/0xe320f000);
416
417 /* mcr 15, 0, r0, cr7, cr10, {4} */
418 arm11_run_instr_no_data1(arm11, 0xee070f9a);
419
420 uint32_t dscr = arm11_read_DSCR(arm11);
421
422 LOG_DEBUG("DRAIN, DSCR %08x", dscr);
423
424 if (dscr & ARM11_DSCR_STICKY_IMPRECISE_DATA_ABORT)
425 {
426 arm11_run_instr_no_data1(arm11, 0xe320f000);
427
428 dscr = arm11_read_DSCR(arm11);
429
430 LOG_DEBUG("DRAIN, DSCR %08x (DONE)", dscr);
431
432 break;
433 }
434 }
435 #endif
436
437 retval = arm11_run_instr_data_prepare(arm11);
438 if (retval != ERROR_OK)
439 return retval;
440
441 /* save r0 - r14 */
442
443 /** \todo TODO: handle other mode registers */
444
445 for (size_t i = 0; i < 15; i++)
446 {
447 /* MCR p14,0,R?,c0,c5,0 */
448 retval = arm11_run_instr_data_from_core(arm11, 0xEE000E15 | (i << 12), &R(RX + i), 1);
449 if (retval != ERROR_OK)
450 return retval;
451 }
452
453 /* save rDTR */
454
455 /* check rDTRfull in DSCR */
456
457 if (R(DSCR) & ARM11_DSCR_RDTR_FULL)
458 {
459 /* MRC p14,0,R0,c0,c5,0 (move rDTR -> r0 (-> wDTR -> local var)) */
460 retval = arm11_run_instr_data_from_core_via_r0(arm11, 0xEE100E15, &R(RDTR));
461 if (retval != ERROR_OK)
462 return retval;
463 }
464 else
465 {
466 arm11->reg_list[ARM11_RC_RDTR].valid = 0;
467 }
468
469 /* save CPSR */
470
471 /* MRS r0,CPSR (move CPSR -> r0 (-> wDTR -> local var)) */
472 retval = arm11_run_instr_data_from_core_via_r0(arm11, 0xE10F0000, &R(CPSR));
473 if (retval != ERROR_OK)
474 return retval;
475
476 /* save PC */
477
478 /* MOV R0,PC (move PC -> r0 (-> wDTR -> local var)) */
479 retval = arm11_run_instr_data_from_core_via_r0(arm11, 0xE1A0000F, &R(PC));
480 if (retval != ERROR_OK)
481 return retval;
482
483 /* adjust PC depending on ARM state */
484
485 if (R(CPSR) & ARM11_CPSR_J) /* Java state */
486 {
487 arm11->reg_values[ARM11_RC_PC] -= 0;
488 }
489 else if (R(CPSR) & ARM11_CPSR_T) /* Thumb state */
490 {
491 arm11->reg_values[ARM11_RC_PC] -= 4;
492 }
493 else /* ARM state */
494 {
495 arm11->reg_values[ARM11_RC_PC] -= 8;
496 }
497
498 if (arm11->simulate_reset_on_next_halt)
499 {
500 arm11->simulate_reset_on_next_halt = false;
501
502 LOG_DEBUG("Reset c1 Control Register");
503
504 /* Write 0 (reset value) to Control register 0 to disable MMU/Cache etc. */
505
506 /* MCR p15,0,R0,c1,c0,0 */
507 retval = arm11_run_instr_data_to_core_via_r0(arm11, 0xee010f10, 0);
508 if (retval != ERROR_OK)
509 return retval;
510
511 }
512
513 retval = arm11_run_instr_data_finish(arm11);
514 if (retval != ERROR_OK)
515 return retval;
516
517 arm11_dump_reg_changes(arm11);
518
519 return ERROR_OK;
520 }
521
522 void arm11_dump_reg_changes(struct arm11_common * arm11)
523 {
524
525 if (!(debug_level >= LOG_LVL_DEBUG))
526 {
527 return;
528 }
529
530 for (size_t i = 0; i < ARM11_REGCACHE_COUNT; i++)
531 {
532 if (!arm11->reg_list[i].valid)
533 {
534 if (arm11->reg_history[i].valid)
535 LOG_DEBUG("%8s INVALID (%08" PRIx32 ")", arm11_reg_defs[i].name, arm11->reg_history[i].value);
536 }
537 else
538 {
539 if (arm11->reg_history[i].valid)
540 {
541 if (arm11->reg_history[i].value != arm11->reg_values[i])
542 LOG_DEBUG("%8s %08" PRIx32 " (%08" PRIx32 ")", arm11_reg_defs[i].name, arm11->reg_values[i], arm11->reg_history[i].value);
543 }
544 else
545 {
546 LOG_DEBUG("%8s %08" PRIx32 " (INVALID)", arm11_reg_defs[i].name, arm11->reg_values[i]);
547 }
548 }
549 }
550 }
551
552 /** Restore processor state
553 *
554 * This is called in preparation for the RESTART function.
555 *
556 */
557 static int arm11_leave_debug_state(struct arm11_common *arm11)
558 {
559 FNC_INFO;
560 int retval;
561
562 retval = arm11_run_instr_data_prepare(arm11);
563 if (retval != ERROR_OK)
564 return retval;
565
566 /** \todo TODO: handle other mode registers */
567
568 /* restore R1 - R14 */
569
570 for (size_t i = 1; i < 15; i++)
571 {
572 if (!arm11->reg_list[ARM11_RC_RX + i].dirty)
573 continue;
574
575 /* MRC p14,0,r?,c0,c5,0 */
576 arm11_run_instr_data_to_core1(arm11, 0xee100e15 | (i << 12), R(RX + i));
577
578 // LOG_DEBUG("RESTORE R" ZU " %08x", i, R(RX + i));
579 }
580
581 retval = arm11_run_instr_data_finish(arm11);
582 if (retval != ERROR_OK)
583 return retval;
584
585 /* spec says clear wDTR and rDTR; we assume they are clear as
586 otherwise our programming would be sloppy */
587 {
588 uint32_t DSCR;
589
590 CHECK_RETVAL(arm11_read_DSCR(arm11, &DSCR));
591
592 if (DSCR & (ARM11_DSCR_RDTR_FULL | ARM11_DSCR_WDTR_FULL))
593 {
594 /*
595 The wDTR/rDTR two registers that are used to send/receive data to/from
596 the core in tandem with corresponding instruction codes that are
597 written into the core. The RDTR FULL/WDTR FULL flag indicates that the
598 registers hold data that was written by one side (CPU or JTAG) and not
599 read out by the other side.
600 */
601 LOG_ERROR("wDTR/rDTR inconsistent (DSCR %08" PRIx32 ")", DSCR);
602 return ERROR_FAIL;
603 }
604 }
605
606 retval = arm11_run_instr_data_prepare(arm11);
607 if (retval != ERROR_OK)
608 return retval;
609
610 /* restore original wDTR */
611
612 if ((R(DSCR) & ARM11_DSCR_WDTR_FULL) || arm11->reg_list[ARM11_RC_WDTR].dirty)
613 {
614 /* MCR p14,0,R0,c0,c5,0 */
615 retval = arm11_run_instr_data_to_core_via_r0(arm11, 0xee000e15, R(WDTR));
616 if (retval != ERROR_OK)
617 return retval;
618 }
619
620 /* restore CPSR */
621
622 /* MSR CPSR,R0*/
623 retval = arm11_run_instr_data_to_core_via_r0(arm11, 0xe129f000, R(CPSR));
624 if (retval != ERROR_OK)
625 return retval;
626
627
628 /* restore PC */
629
630 /* MOV PC,R0 */
631 retval = arm11_run_instr_data_to_core_via_r0(arm11, 0xe1a0f000, R(PC));
632 if (retval != ERROR_OK)
633 return retval;
634
635
636 /* restore R0 */
637
638 /* MRC p14,0,r0,c0,c5,0 */
639 arm11_run_instr_data_to_core1(arm11, 0xee100e15, R(R0));
640
641 retval = arm11_run_instr_data_finish(arm11);
642 if (retval != ERROR_OK)
643 return retval;
644
645 /* restore DSCR */
646
647 arm11_write_DSCR(arm11, R(DSCR));
648
649 /* restore rDTR */
650
651 if (R(DSCR) & ARM11_DSCR_RDTR_FULL || arm11->reg_list[ARM11_RC_RDTR].dirty)
652 {
653 arm11_add_debug_SCAN_N(arm11, 0x05, ARM11_TAP_DEFAULT);
654
655 arm11_add_IR(arm11, ARM11_EXTEST, ARM11_TAP_DEFAULT);
656
657 struct scan_field chain5_fields[3];
658
659 uint8_t Ready = 0; /* ignored */
660 uint8_t Valid = 0; /* ignored */
661
662 arm11_setup_field(arm11, 32, &R(RDTR), NULL, chain5_fields + 0);
663 arm11_setup_field(arm11, 1, &Ready, NULL, chain5_fields + 1);
664 arm11_setup_field(arm11, 1, &Valid, NULL, chain5_fields + 2);
665
666 arm11_add_dr_scan_vc(asizeof(chain5_fields), chain5_fields, TAP_DRPAUSE);
667 }
668
669 arm11_record_register_history(arm11);
670
671 return ERROR_OK;
672 }
673
674 static void arm11_record_register_history(struct arm11_common *arm11)
675 {
676 for (size_t i = 0; i < ARM11_REGCACHE_COUNT; i++)
677 {
678 arm11->reg_history[i].value = arm11->reg_values[i];
679 arm11->reg_history[i].valid = arm11->reg_list[i].valid;
680
681 arm11->reg_list[i].valid = 0;
682 arm11->reg_list[i].dirty = 0;
683 }
684 }
685
686
687 /* poll current target status */
688 static int arm11_poll(struct target *target)
689 {
690 FNC_INFO;
691 int retval;
692 struct arm11_common *arm11 = target_to_arm11(target);
693 uint32_t dscr;
694
695 CHECK_RETVAL(arm11_read_DSCR(arm11, &dscr));
696
697 LOG_DEBUG("DSCR %08" PRIx32 "", dscr);
698
699 CHECK_RETVAL(arm11_check_init(arm11, &dscr));
700
701 if (dscr & ARM11_DSCR_CORE_HALTED)
702 {
703 if (target->state != TARGET_HALTED)
704 {
705 enum target_state old_state = target->state;
706
707 LOG_DEBUG("enter TARGET_HALTED");
708 target->state = TARGET_HALTED;
709 target->debug_reason = arm11_get_DSCR_debug_reason(dscr);
710 retval = arm11_on_enter_debug_state(arm11);
711 if (retval != ERROR_OK)
712 return retval;
713
714 target_call_event_callbacks(target,
715 old_state == TARGET_DEBUG_RUNNING ? TARGET_EVENT_DEBUG_HALTED : TARGET_EVENT_HALTED);
716 }
717 }
718 else
719 {
720 if (target->state != TARGET_RUNNING && target->state != TARGET_DEBUG_RUNNING)
721 {
722 LOG_DEBUG("enter TARGET_RUNNING");
723 target->state = TARGET_RUNNING;
724 target->debug_reason = DBG_REASON_NOTHALTED;
725 }
726 }
727
728 return ERROR_OK;
729 }
730 /* architecture specific status reply */
731 static int arm11_arch_state(struct target *target)
732 {
733 struct arm11_common *arm11 = target_to_arm11(target);
734
735 LOG_USER("target halted due to %s\ncpsr: 0x%8.8" PRIx32 " pc: 0x%8.8" PRIx32 "",
736 Jim_Nvp_value2name_simple(nvp_target_debug_reason, target->debug_reason)->name,
737 R(CPSR),
738 R(PC));
739
740 return ERROR_OK;
741 }
742
743 /* target request support */
744 static int arm11_target_request_data(struct target *target,
745 uint32_t size, uint8_t *buffer)
746 {
747 FNC_INFO_NOTIMPLEMENTED;
748
749 return ERROR_OK;
750 }
751
752 /* target execution control */
753 static int arm11_halt(struct target *target)
754 {
755 FNC_INFO;
756 struct arm11_common *arm11 = target_to_arm11(target);
757
758 LOG_DEBUG("target->state: %s",
759 target_state_name(target));
760
761 if (target->state == TARGET_UNKNOWN)
762 {
763 arm11->simulate_reset_on_next_halt = true;
764 }
765
766 if (target->state == TARGET_HALTED)
767 {
768 LOG_DEBUG("target was already halted");
769 return ERROR_OK;
770 }
771
772 arm11_add_IR(arm11, ARM11_HALT, TAP_IDLE);
773
774 CHECK_RETVAL(jtag_execute_queue());
775
776 uint32_t dscr;
777
778 int i = 0;
779 while (1)
780 {
781 CHECK_RETVAL(arm11_read_DSCR(arm11, &dscr));
782
783 if (dscr & ARM11_DSCR_CORE_HALTED)
784 break;
785
786
787 long long then = 0;
788 if (i == 1000)
789 {
790 then = timeval_ms();
791 }
792 if (i >= 1000)
793 {
794 if ((timeval_ms()-then) > 1000)
795 {
796 LOG_WARNING("Timeout (1000ms) waiting for instructions to complete");
797 return ERROR_FAIL;
798 }
799 }
800 i++;
801 }
802
803 arm11_on_enter_debug_state(arm11);
804
805 enum target_state old_state = target->state;
806
807 target->state = TARGET_HALTED;
808 target->debug_reason = arm11_get_DSCR_debug_reason(dscr);
809
810 CHECK_RETVAL(
811 target_call_event_callbacks(target,
812 old_state == TARGET_DEBUG_RUNNING ? TARGET_EVENT_DEBUG_HALTED : TARGET_EVENT_HALTED));
813
814 return ERROR_OK;
815 }
816
817 static int arm11_resume(struct target *target, int current,
818 uint32_t address, int handle_breakpoints, int debug_execution)
819 {
820 FNC_INFO;
821
822 // LOG_DEBUG("current %d address %08x handle_breakpoints %d debug_execution %d",
823 // current, address, handle_breakpoints, debug_execution);
824
825 struct arm11_common *arm11 = target_to_arm11(target);
826
827 LOG_DEBUG("target->state: %s",
828 target_state_name(target));
829
830
831 if (target->state != TARGET_HALTED)
832 {
833 LOG_ERROR("Target not halted");
834 return ERROR_TARGET_NOT_HALTED;
835 }
836
837 if (!current)
838 R(PC) = address;
839
840 LOG_DEBUG("RESUME PC %08" PRIx32 "%s", R(PC), !current ? "!" : "");
841
842 /* clear breakpoints/watchpoints and VCR*/
843 arm11_sc7_clear_vbw(arm11);
844
845 /* Set up breakpoints */
846 if (!debug_execution)
847 {
848 /* check if one matches PC and step over it if necessary */
849
850 struct breakpoint * bp;
851
852 for (bp = target->breakpoints; bp; bp = bp->next)
853 {
854 if (bp->address == R(PC))
855 {
856 LOG_DEBUG("must step over %08" PRIx32 "", bp->address);
857 arm11_step(target, 1, 0, 0);
858 break;
859 }
860 }
861
862 /* set all breakpoints */
863
864 size_t brp_num = 0;
865
866 for (bp = target->breakpoints; bp; bp = bp->next)
867 {
868 struct arm11_sc7_action brp[2];
869
870 brp[0].write = 1;
871 brp[0].address = ARM11_SC7_BVR0 + brp_num;
872 brp[0].value = bp->address;
873 brp[1].write = 1;
874 brp[1].address = ARM11_SC7_BCR0 + brp_num;
875 brp[1].value = 0x1 | (3 << 1) | (0x0F << 5) | (0 << 14) | (0 << 16) | (0 << 20) | (0 << 21);
876
877 arm11_sc7_run(arm11, brp, asizeof(brp));
878
879 LOG_DEBUG("Add BP " ZU " at %08" PRIx32 "", brp_num, bp->address);
880
881 brp_num++;
882 }
883
884 arm11_sc7_set_vcr(arm11, arm11_vcr);
885 }
886
887 arm11_leave_debug_state(arm11);
888
889 arm11_add_IR(arm11, ARM11_RESTART, TAP_IDLE);
890
891 CHECK_RETVAL(jtag_execute_queue());
892
893 int i = 0;
894 while (1)
895 {
896 uint32_t dscr;
897
898 CHECK_RETVAL(arm11_read_DSCR(arm11, &dscr));
899
900 LOG_DEBUG("DSCR %08" PRIx32 "", dscr);
901
902 if (dscr & ARM11_DSCR_CORE_RESTARTED)
903 break;
904
905
906 long long then = 0;
907 if (i == 1000)
908 {
909 then = timeval_ms();
910 }
911 if (i >= 1000)
912 {
913 if ((timeval_ms()-then) > 1000)
914 {
915 LOG_WARNING("Timeout (1000ms) waiting for instructions to complete");
916 return ERROR_FAIL;
917 }
918 }
919 i++;
920 }
921
922 if (!debug_execution)
923 {
924 target->state = TARGET_RUNNING;
925 target->debug_reason = DBG_REASON_NOTHALTED;
926
927 CHECK_RETVAL(target_call_event_callbacks(target, TARGET_EVENT_RESUMED));
928 }
929 else
930 {
931 target->state = TARGET_DEBUG_RUNNING;
932 target->debug_reason = DBG_REASON_NOTHALTED;
933
934 CHECK_RETVAL(target_call_event_callbacks(target, TARGET_EVENT_RESUMED));
935 }
936
937 return ERROR_OK;
938 }
939
940
941 static int armv4_5_to_arm11(int reg)
942 {
943 if (reg < 16)
944 return reg;
945 switch (reg)
946 {
947 case ARMV4_5_CPSR:
948 return ARM11_RC_CPSR;
949 case 16:
950 /* FIX!!! handle thumb better! */
951 return ARM11_RC_CPSR;
952 default:
953 LOG_ERROR("BUG: register translation from armv4_5 to arm11 not supported %d", reg);
954 exit(-1);
955 }
956 }
957
958
959 static uint32_t arm11_sim_get_reg(struct arm_sim_interface *sim, int reg)
960 {
961 struct arm11_common * arm11 = (struct arm11_common *)sim->user_data;
962
963 reg=armv4_5_to_arm11(reg);
964
965 return buf_get_u32(arm11->reg_list[reg].value, 0, 32);
966 }
967
968 static void arm11_sim_set_reg(struct arm_sim_interface *sim,
969 int reg, uint32_t value)
970 {
971 struct arm11_common * arm11 = (struct arm11_common *)sim->user_data;
972
973 reg=armv4_5_to_arm11(reg);
974
975 buf_set_u32(arm11->reg_list[reg].value, 0, 32, value);
976 }
977
978 static uint32_t arm11_sim_get_cpsr(struct arm_sim_interface *sim,
979 int pos, int bits)
980 {
981 struct arm11_common * arm11 = (struct arm11_common *)sim->user_data;
982
983 return buf_get_u32(arm11->reg_list[ARM11_RC_CPSR].value, pos, bits);
984 }
985
986 static enum armv4_5_state arm11_sim_get_state(struct arm_sim_interface *sim)
987 {
988 // struct arm11_common * arm11 = (struct arm11_common *)sim->user_data;
989
990 /* FIX!!!! we should implement thumb for arm11 */
991 return ARMV4_5_STATE_ARM;
992 }
993
994 static void arm11_sim_set_state(struct arm_sim_interface *sim,
995 enum armv4_5_state mode)
996 {
997 // struct arm11_common * arm11 = (struct arm11_common *)sim->user_data;
998
999 /* FIX!!!! we should implement thumb for arm11 */
1000 LOG_ERROR("Not implemetned!");
1001 }
1002
1003
1004 static enum armv4_5_mode arm11_sim_get_mode(struct arm_sim_interface *sim)
1005 {
1006 //struct arm11_common * arm11 = (struct arm11_common *)sim->user_data;
1007
1008 /* FIX!!!! we should implement something that returns the current mode here!!! */
1009 return ARMV4_5_MODE_USR;
1010 }
1011
1012 static int arm11_simulate_step(struct target *target, uint32_t *dry_run_pc)
1013 {
1014 struct arm_sim_interface sim;
1015
1016 sim.user_data=target->arch_info;
1017 sim.get_reg=&arm11_sim_get_reg;
1018 sim.set_reg=&arm11_sim_set_reg;
1019 sim.get_reg_mode=&arm11_sim_get_reg;
1020 sim.set_reg_mode=&arm11_sim_set_reg;
1021 sim.get_cpsr=&arm11_sim_get_cpsr;
1022 sim.get_mode=&arm11_sim_get_mode;
1023 sim.get_state=&arm11_sim_get_state;
1024 sim.set_state=&arm11_sim_set_state;
1025
1026 return arm_simulate_step_core(target, dry_run_pc, &sim);
1027
1028 }
1029
1030 static int arm11_step(struct target *target, int current,
1031 uint32_t address, int handle_breakpoints)
1032 {
1033 FNC_INFO;
1034
1035 LOG_DEBUG("target->state: %s",
1036 target_state_name(target));
1037
1038 if (target->state != TARGET_HALTED)
1039 {
1040 LOG_WARNING("target was not halted");
1041 return ERROR_TARGET_NOT_HALTED;
1042 }
1043
1044 struct arm11_common *arm11 = target_to_arm11(target);
1045
1046 if (!current)
1047 R(PC) = address;
1048
1049 LOG_DEBUG("STEP PC %08" PRIx32 "%s", R(PC), !current ? "!" : "");
1050
1051
1052 /** \todo TODO: Thumb not supported here */
1053
1054 uint32_t next_instruction;
1055
1056 CHECK_RETVAL(arm11_read_memory_word(arm11, R(PC), &next_instruction));
1057
1058 /* skip over BKPT */
1059 if ((next_instruction & 0xFFF00070) == 0xe1200070)
1060 {
1061 R(PC) += 4;
1062 arm11->reg_list[ARM11_RC_PC].valid = 1;
1063 arm11->reg_list[ARM11_RC_PC].dirty = 0;
1064 LOG_DEBUG("Skipping BKPT");
1065 }
1066 /* skip over Wait for interrupt / Standby */
1067 /* mcr 15, 0, r?, cr7, cr0, {4} */
1068 else if ((next_instruction & 0xFFFF0FFF) == 0xee070f90)
1069 {
1070 R(PC) += 4;
1071 arm11->reg_list[ARM11_RC_PC].valid = 1;
1072 arm11->reg_list[ARM11_RC_PC].dirty = 0;
1073 LOG_DEBUG("Skipping WFI");
1074 }
1075 /* ignore B to self */
1076 else if ((next_instruction & 0xFEFFFFFF) == 0xeafffffe)
1077 {
1078 LOG_DEBUG("Not stepping jump to self");
1079 }
1080 else
1081 {
1082 /** \todo TODO: check if break-/watchpoints make any sense at all in combination
1083 * with this. */
1084
1085 /** \todo TODO: check if disabling IRQs might be a good idea here. Alternatively
1086 * the VCR might be something worth looking into. */
1087
1088
1089 /* Set up breakpoint for stepping */
1090
1091 struct arm11_sc7_action brp[2];
1092
1093 brp[0].write = 1;
1094 brp[0].address = ARM11_SC7_BVR0;
1095 brp[1].write = 1;
1096 brp[1].address = ARM11_SC7_BCR0;
1097
1098 if (arm11_config_hardware_step)
1099 {
1100 /* hardware single stepping be used if possible or is it better to
1101 * always use the same code path? Hardware single stepping is not supported
1102 * on all hardware
1103 */
1104 brp[0].value = R(PC);
1105 brp[1].value = 0x1 | (3 << 1) | (0x0F << 5) | (0 << 14) | (0 << 16) | (0 << 20) | (2 << 21);
1106 } else
1107 {
1108 /* sets a breakpoint on the next PC(calculated by simulation),
1109 */
1110 uint32_t next_pc;
1111 int retval;
1112 retval = arm11_simulate_step(target, &next_pc);
1113 if (retval != ERROR_OK)
1114 return retval;
1115
1116 brp[0].value = next_pc;
1117 brp[1].value = 0x1 | (3 << 1) | (0x0F << 5) | (0 << 14) | (0 << 16) | (0 << 20) | (0 << 21);
1118 }
1119
1120 CHECK_RETVAL(arm11_sc7_run(arm11, brp, asizeof(brp)));
1121
1122 /* resume */
1123
1124
1125 if (arm11_config_step_irq_enable)
1126 R(DSCR) &= ~ARM11_DSCR_INTERRUPTS_DISABLE; /* should be redundant */
1127 else
1128 R(DSCR) |= ARM11_DSCR_INTERRUPTS_DISABLE;
1129
1130
1131 CHECK_RETVAL(arm11_leave_debug_state(arm11));
1132
1133 arm11_add_IR(arm11, ARM11_RESTART, TAP_IDLE);
1134
1135 CHECK_RETVAL(jtag_execute_queue());
1136
1137 /* wait for halt */
1138 int i = 0;
1139 while (1)
1140 {
1141 uint32_t dscr;
1142
1143 CHECK_RETVAL(arm11_read_DSCR(arm11, &dscr));
1144
1145 LOG_DEBUG("DSCR %08" PRIx32 "e", dscr);
1146
1147 if ((dscr & (ARM11_DSCR_CORE_RESTARTED | ARM11_DSCR_CORE_HALTED)) ==
1148 (ARM11_DSCR_CORE_RESTARTED | ARM11_DSCR_CORE_HALTED))
1149 break;
1150
1151 long long then = 0;
1152 if (i == 1000)
1153 {
1154 then = timeval_ms();
1155 }
1156 if (i >= 1000)
1157 {
1158 if ((timeval_ms()-then) > 1000)
1159 {
1160 LOG_WARNING("Timeout (1000ms) waiting for instructions to complete");
1161 return ERROR_FAIL;
1162 }
1163 }
1164 i++;
1165 }
1166
1167 /* clear breakpoint */
1168 arm11_sc7_clear_vbw(arm11);
1169
1170 /* save state */
1171 CHECK_RETVAL(arm11_on_enter_debug_state(arm11));
1172
1173 /* restore default state */
1174 R(DSCR) &= ~ARM11_DSCR_INTERRUPTS_DISABLE;
1175
1176 }
1177
1178 // target->state = TARGET_HALTED;
1179 target->debug_reason = DBG_REASON_SINGLESTEP;
1180
1181 CHECK_RETVAL(target_call_event_callbacks(target, TARGET_EVENT_HALTED));
1182
1183 return ERROR_OK;
1184 }
1185
1186 static int arm11_assert_reset(struct target *target)
1187 {
1188 FNC_INFO;
1189 int retval;
1190 struct arm11_common *arm11 = target_to_arm11(target);
1191
1192 retval = arm11_check_init(arm11, NULL);
1193 if (retval != ERROR_OK)
1194 return retval;
1195
1196 target->state = TARGET_UNKNOWN;
1197
1198 /* we would very much like to reset into the halted, state,
1199 * but resetting and halting is second best... */
1200 if (target->reset_halt)
1201 {
1202 CHECK_RETVAL(target_halt(target));
1203 }
1204
1205
1206 /* srst is funny. We can not do *anything* else while it's asserted
1207 * and it has unkonwn side effects. Make sure no other code runs
1208 * meanwhile.
1209 *
1210 * Code below assumes srst:
1211 *
1212 * - Causes power-on-reset (but of what parts of the system?). Bug
1213 * in arm11?
1214 *
1215 * - Messes us TAP state without asserting trst.
1216 *
1217 * - There is another bug in the arm11 core. When you generate an access to
1218 * external logic (for example ddr controller via AHB bus) and that block
1219 * is not configured (perhaps it is still held in reset), that transaction
1220 * will never complete. This will hang arm11 core but it will also hang
1221 * JTAG controller. Nothing, short of srst assertion will bring it out of
1222 * this.
1223 *
1224 * Mysteries:
1225 *
1226 * - What should the PC be after an srst reset when starting in the halted
1227 * state?
1228 */
1229
1230 jtag_add_reset(0, 1);
1231 jtag_add_reset(0, 0);
1232
1233 /* How long do we have to wait? */
1234 jtag_add_sleep(5000);
1235
1236 /* un-mess up TAP state */
1237 jtag_add_tlr();
1238
1239 retval = jtag_execute_queue();
1240 if (retval != ERROR_OK)
1241 {
1242 return retval;
1243 }
1244
1245 return ERROR_OK;
1246 }
1247
1248 static int arm11_deassert_reset(struct target *target)
1249 {
1250 return ERROR_OK;
1251 }
1252
1253 static int arm11_soft_reset_halt(struct target *target)
1254 {
1255 FNC_INFO_NOTIMPLEMENTED;
1256
1257 return ERROR_OK;
1258 }
1259
1260 /* target register access for gdb */
1261 static int arm11_get_gdb_reg_list(struct target *target,
1262 struct reg **reg_list[], int *reg_list_size)
1263 {
1264 FNC_INFO;
1265 struct arm11_common *arm11 = target_to_arm11(target);
1266
1267 *reg_list_size = ARM11_GDB_REGISTER_COUNT;
1268 *reg_list = malloc(sizeof(struct reg*) * ARM11_GDB_REGISTER_COUNT);
1269
1270 for (size_t i = 16; i < 24; i++)
1271 {
1272 (*reg_list)[i] = &arm11_gdb_dummy_fp_reg;
1273 }
1274
1275 (*reg_list)[24] = &arm11_gdb_dummy_fps_reg;
1276
1277 for (size_t i = 0; i < ARM11_REGCACHE_COUNT; i++)
1278 {
1279 if (arm11_reg_defs[i].gdb_num == -1)
1280 continue;
1281
1282 (*reg_list)[arm11_reg_defs[i].gdb_num] = arm11->reg_list + i;
1283 }
1284
1285 return ERROR_OK;
1286 }
1287
1288 /* target memory access
1289 * size: 1 = byte (8bit), 2 = half-word (16bit), 4 = word (32bit)
1290 * count: number of items of <size>
1291 *
1292 * arm11_config_memrw_no_increment - in the future we may want to be able
1293 * to read/write a range of data to a "port". a "port" is an action on
1294 * read memory address for some peripheral.
1295 */
1296 static int arm11_read_memory_inner(struct target *target,
1297 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer,
1298 bool arm11_config_memrw_no_increment)
1299 {
1300 /** \todo TODO: check if buffer cast to uint32_t* and uint16_t* might cause alignment problems */
1301 int retval;
1302
1303 FNC_INFO;
1304
1305 if (target->state != TARGET_HALTED)
1306 {
1307 LOG_WARNING("target was not halted");
1308 return ERROR_TARGET_NOT_HALTED;
1309 }
1310
1311 LOG_DEBUG("ADDR %08" PRIx32 " SIZE %08" PRIx32 " COUNT %08" PRIx32 "", address, size, count);
1312
1313 struct arm11_common *arm11 = target_to_arm11(target);
1314
1315 retval = arm11_run_instr_data_prepare(arm11);
1316 if (retval != ERROR_OK)
1317 return retval;
1318
1319 /* MRC p14,0,r0,c0,c5,0 */
1320 retval = arm11_run_instr_data_to_core1(arm11, 0xee100e15, address);
1321 if (retval != ERROR_OK)
1322 return retval;
1323
1324 switch (size)
1325 {
1326 case 1:
1327 /** \todo TODO: check if dirty is the right choice to force a rewrite on arm11_resume() */
1328 arm11->reg_list[ARM11_RC_R1].dirty = 1;
1329
1330 for (size_t i = 0; i < count; i++)
1331 {
1332 /* ldrb r1, [r0], #1 */
1333 /* ldrb r1, [r0] */
1334 arm11_run_instr_no_data1(arm11,
1335 !arm11_config_memrw_no_increment ? 0xe4d01001 : 0xe5d01000);
1336
1337 uint32_t res;
1338 /* MCR p14,0,R1,c0,c5,0 */
1339 arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1);
1340
1341 *buffer++ = res;
1342 }
1343
1344 break;
1345
1346 case 2:
1347 {
1348 arm11->reg_list[ARM11_RC_R1].dirty = 1;
1349
1350 for (size_t i = 0; i < count; i++)
1351 {
1352 /* ldrh r1, [r0], #2 */
1353 arm11_run_instr_no_data1(arm11,
1354 !arm11_config_memrw_no_increment ? 0xe0d010b2 : 0xe1d010b0);
1355
1356 uint32_t res;
1357
1358 /* MCR p14,0,R1,c0,c5,0 */
1359 arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1);
1360
1361 uint16_t svalue = res;
1362 memcpy(buffer + i * sizeof(uint16_t), &svalue, sizeof(uint16_t));
1363 }
1364
1365 break;
1366 }
1367
1368 case 4:
1369 {
1370 uint32_t instr = !arm11_config_memrw_no_increment ? 0xecb05e01 : 0xed905e00;
1371 /** \todo TODO: buffer cast to uint32_t* causes alignment warnings */
1372 uint32_t *words = (uint32_t *)buffer;
1373
1374 /* LDC p14,c5,[R0],#4 */
1375 /* LDC p14,c5,[R0] */
1376 arm11_run_instr_data_from_core(arm11, instr, words, count);
1377 break;
1378 }
1379 }
1380
1381 return arm11_run_instr_data_finish(arm11);
1382 }
1383
1384 static int arm11_read_memory(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
1385 {
1386 return arm11_read_memory_inner(target, address, size, count, buffer, false);
1387 }
1388
1389 /*
1390 * arm11_config_memrw_no_increment - in the future we may want to be able
1391 * to read/write a range of data to a "port". a "port" is an action on
1392 * read memory address for some peripheral.
1393 */
1394 static int arm11_write_memory_inner(struct target *target,
1395 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer,
1396 bool arm11_config_memrw_no_increment)
1397 {
1398 int retval;
1399 FNC_INFO;
1400
1401 if (target->state != TARGET_HALTED)
1402 {
1403 LOG_WARNING("target was not halted");
1404 return ERROR_TARGET_NOT_HALTED;
1405 }
1406
1407 LOG_DEBUG("ADDR %08" PRIx32 " SIZE %08" PRIx32 " COUNT %08" PRIx32 "", address, size, count);
1408
1409 struct arm11_common *arm11 = target_to_arm11(target);
1410
1411 retval = arm11_run_instr_data_prepare(arm11);
1412 if (retval != ERROR_OK)
1413 return retval;
1414
1415 /* MRC p14,0,r0,c0,c5,0 */
1416 retval = arm11_run_instr_data_to_core1(arm11, 0xee100e15, address);
1417 if (retval != ERROR_OK)
1418 return retval;
1419
1420 /* burst writes are not used for single words as those may well be
1421 * reset init script writes.
1422 *
1423 * The other advantage is that as burst writes are default, we'll
1424 * now exercise both burst and non-burst code paths with the
1425 * default settings, increasing code coverage.
1426 */
1427 bool burst = arm11_config_memwrite_burst && (count > 1);
1428
1429 switch (size)
1430 {
1431 case 1:
1432 {
1433 arm11->reg_list[ARM11_RC_R1].dirty = 1;
1434
1435 for (size_t i = 0; i < count; i++)
1436 {
1437 /* MRC p14,0,r1,c0,c5,0 */
1438 retval = arm11_run_instr_data_to_core1(arm11, 0xee101e15, *buffer++);
1439 if (retval != ERROR_OK)
1440 return retval;
1441
1442 /* strb r1, [r0], #1 */
1443 /* strb r1, [r0] */
1444 retval = arm11_run_instr_no_data1(arm11,
1445 !arm11_config_memrw_no_increment ? 0xe4c01001 : 0xe5c01000);
1446 if (retval != ERROR_OK)
1447 return retval;
1448 }
1449
1450 break;
1451 }
1452
1453 case 2:
1454 {
1455 arm11->reg_list[ARM11_RC_R1].dirty = 1;
1456
1457 for (size_t i = 0; i < count; i++)
1458 {
1459 uint16_t value;
1460 memcpy(&value, buffer + i * sizeof(uint16_t), sizeof(uint16_t));
1461
1462 /* MRC p14,0,r1,c0,c5,0 */
1463 retval = arm11_run_instr_data_to_core1(arm11, 0xee101e15, value);
1464 if (retval != ERROR_OK)
1465 return retval;
1466
1467 /* strh r1, [r0], #2 */
1468 /* strh r1, [r0] */
1469 retval = arm11_run_instr_no_data1(arm11,
1470 !arm11_config_memrw_no_increment ? 0xe0c010b2 : 0xe1c010b0);
1471 if (retval != ERROR_OK)
1472 return retval;
1473 }
1474
1475 break;
1476 }
1477
1478 case 4: {
1479 uint32_t instr = !arm11_config_memrw_no_increment ? 0xeca05e01 : 0xed805e00;
1480
1481 /** \todo TODO: buffer cast to uint32_t* causes alignment warnings */
1482 uint32_t *words = (uint32_t*)buffer;
1483
1484 if (!burst)
1485 {
1486 /* STC p14,c5,[R0],#4 */
1487 /* STC p14,c5,[R0]*/
1488 retval = arm11_run_instr_data_to_core(arm11, instr, words, count);
1489 if (retval != ERROR_OK)
1490 return retval;
1491 }
1492 else
1493 {
1494 /* STC p14,c5,[R0],#4 */
1495 /* STC p14,c5,[R0]*/
1496 retval = arm11_run_instr_data_to_core_noack(arm11, instr, words, count);
1497 if (retval != ERROR_OK)
1498 return retval;
1499 }
1500
1501 break;
1502 }
1503 }
1504
1505 /* r0 verification */
1506 if (!arm11_config_memrw_no_increment)
1507 {
1508 uint32_t r0;
1509
1510 /* MCR p14,0,R0,c0,c5,0 */
1511 retval = arm11_run_instr_data_from_core(arm11, 0xEE000E15, &r0, 1);
1512 if (retval != ERROR_OK)
1513 return retval;
1514
1515 if (address + size * count != r0)
1516 {
1517 LOG_ERROR("Data transfer failed. Expected end "
1518 "address 0x%08x, got 0x%08x",
1519 (unsigned) (address + size * count),
1520 (unsigned) r0);
1521
1522 if (burst)
1523 LOG_ERROR("use 'arm11 memwrite burst disable' to disable fast burst mode");
1524
1525 if (arm11_config_memwrite_error_fatal)
1526 return ERROR_FAIL;
1527 }
1528 }
1529
1530 return arm11_run_instr_data_finish(arm11);
1531 }
1532
1533 static int arm11_write_memory(struct target *target,
1534 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
1535 {
1536 return arm11_write_memory_inner(target, address, size, count, buffer, false);
1537 }
1538
1539 /* write target memory in multiples of 4 byte, optimized for writing large quantities of data */
1540 static int arm11_bulk_write_memory(struct target *target,
1541 uint32_t address, uint32_t count, uint8_t *buffer)
1542 {
1543 FNC_INFO;
1544
1545 if (target->state != TARGET_HALTED)
1546 {
1547 LOG_WARNING("target was not halted");
1548 return ERROR_TARGET_NOT_HALTED;
1549 }
1550
1551 return arm11_write_memory(target, address, 4, count, buffer);
1552 }
1553
1554 /* here we have nothing target specific to contribute, so we fail and then the
1555 * fallback code will read data from the target and calculate the CRC on the
1556 * host.
1557 */
1558 static int arm11_checksum_memory(struct target *target,
1559 uint32_t address, uint32_t count, uint32_t* checksum)
1560 {
1561 return ERROR_FAIL;
1562 }
1563
1564 /* target break-/watchpoint control
1565 * rw: 0 = write, 1 = read, 2 = access
1566 */
1567 static int arm11_add_breakpoint(struct target *target,
1568 struct breakpoint *breakpoint)
1569 {
1570 FNC_INFO;
1571 struct arm11_common *arm11 = target_to_arm11(target);
1572
1573 #if 0
1574 if (breakpoint->type == BKPT_SOFT)
1575 {
1576 LOG_INFO("sw breakpoint requested, but software breakpoints not enabled");
1577 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1578 }
1579 #endif
1580
1581 if (!arm11->free_brps)
1582 {
1583 LOG_DEBUG("no breakpoint unit available for hardware breakpoint");
1584 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1585 }
1586
1587 if (breakpoint->length != 4)
1588 {
1589 LOG_DEBUG("only breakpoints of four bytes length supported");
1590 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1591 }
1592
1593 arm11->free_brps--;
1594
1595 return ERROR_OK;
1596 }
1597
1598 static int arm11_remove_breakpoint(struct target *target,
1599 struct breakpoint *breakpoint)
1600 {
1601 FNC_INFO;
1602 struct arm11_common *arm11 = target_to_arm11(target);
1603
1604 arm11->free_brps++;
1605
1606 return ERROR_OK;
1607 }
1608
1609 static int arm11_add_watchpoint(struct target *target,
1610 struct watchpoint *watchpoint)
1611 {
1612 FNC_INFO_NOTIMPLEMENTED;
1613
1614 return ERROR_OK;
1615 }
1616
1617 static int arm11_remove_watchpoint(struct target *target,
1618 struct watchpoint *watchpoint)
1619 {
1620 FNC_INFO_NOTIMPLEMENTED;
1621
1622 return ERROR_OK;
1623 }
1624
1625 // HACKHACKHACK - FIXME mode/state
1626 /* target algorithm support */
1627 static int arm11_run_algorithm(struct target *target,
1628 int num_mem_params, struct mem_param *mem_params,
1629 int num_reg_params, struct reg_param *reg_params,
1630 uint32_t entry_point, uint32_t exit_point,
1631 int timeout_ms, void *arch_info)
1632 {
1633 struct arm11_common *arm11 = target_to_arm11(target);
1634 // enum armv4_5_state core_state = arm11->core_state;
1635 // enum armv4_5_mode core_mode = arm11->core_mode;
1636 uint32_t context[16];
1637 uint32_t cpsr;
1638 int exit_breakpoint_size = 0;
1639 int retval = ERROR_OK;
1640 LOG_DEBUG("Running algorithm");
1641
1642
1643 if (target->state != TARGET_HALTED)
1644 {
1645 LOG_WARNING("target not halted");
1646 return ERROR_TARGET_NOT_HALTED;
1647 }
1648
1649 // FIXME
1650 // if (armv4_5_mode_to_number(arm11->core_mode)==-1)
1651 // return ERROR_FAIL;
1652
1653 // Save regs
1654 for (unsigned i = 0; i < 16; i++)
1655 {
1656 context[i] = buf_get_u32((uint8_t*)(&arm11->reg_values[i]),0,32);
1657 LOG_DEBUG("Save %u: 0x%" PRIx32 "", i, context[i]);
1658 }
1659
1660 cpsr = buf_get_u32((uint8_t*)(arm11->reg_values + ARM11_RC_CPSR),0,32);
1661 LOG_DEBUG("Save CPSR: 0x%" PRIx32 "", cpsr);
1662
1663 for (int i = 0; i < num_mem_params; i++)
1664 {
1665 target_write_buffer(target, mem_params[i].address, mem_params[i].size, mem_params[i].value);
1666 }
1667
1668 // Set register parameters
1669 for (int i = 0; i < num_reg_params; i++)
1670 {
1671 struct reg *reg = register_get_by_name(arm11->core_cache, reg_params[i].reg_name, 0);
1672 if (!reg)
1673 {
1674 LOG_ERROR("BUG: register '%s' not found", reg_params[i].reg_name);
1675 exit(-1);
1676 }
1677
1678 if (reg->size != reg_params[i].size)
1679 {
1680 LOG_ERROR("BUG: register '%s' size doesn't match reg_params[i].size", reg_params[i].reg_name);
1681 exit(-1);
1682 }
1683 arm11_set_reg(reg,reg_params[i].value);
1684 // printf("%i: Set %s =%08x\n", i, reg_params[i].reg_name,val);
1685 }
1686
1687 exit_breakpoint_size = 4;
1688
1689 /* arm11->core_state = arm11_algorithm_info->core_state;
1690 if (arm11->core_state == ARMV4_5_STATE_ARM)
1691 exit_breakpoint_size = 4;
1692 else if (arm11->core_state == ARMV4_5_STATE_THUMB)
1693 exit_breakpoint_size = 2;
1694 else
1695 {
1696 LOG_ERROR("BUG: can't execute algorithms when not in ARM or Thumb state");
1697 exit(-1);
1698 }
1699 */
1700
1701
1702 /* arm11 at this point only supports ARM not THUMB mode
1703 however if this test needs to be reactivated the current state can be read back
1704 from CPSR */
1705 #if 0
1706 if (arm11_algorithm_info->core_mode != ARMV4_5_MODE_ANY)
1707 {
1708 LOG_DEBUG("setting core_mode: 0x%2.2x", arm11_algorithm_info->core_mode);
1709 buf_set_u32(arm11->reg_list[ARM11_RC_CPSR].value, 0, 5, arm11_algorithm_info->core_mode);
1710 arm11->reg_list[ARM11_RC_CPSR].dirty = 1;
1711 arm11->reg_list[ARM11_RC_CPSR].valid = 1;
1712 }
1713 #endif
1714
1715 if ((retval = breakpoint_add(target, exit_point, exit_breakpoint_size, BKPT_HARD)) != ERROR_OK)
1716 {
1717 LOG_ERROR("can't add breakpoint to finish algorithm execution");
1718 retval = ERROR_TARGET_FAILURE;
1719 goto restore;
1720 }
1721
1722 // no debug, otherwise breakpoint is not set
1723 CHECK_RETVAL(target_resume(target, 0, entry_point, 1, 0));
1724
1725 CHECK_RETVAL(target_wait_state(target, TARGET_HALTED, timeout_ms));
1726
1727 if (target->state != TARGET_HALTED)
1728 {
1729 CHECK_RETVAL(target_halt(target));
1730
1731 CHECK_RETVAL(target_wait_state(target, TARGET_HALTED, 500));
1732
1733 retval = ERROR_TARGET_TIMEOUT;
1734
1735 goto del_breakpoint;
1736 }
1737
1738 if (buf_get_u32(arm11->reg_list[15].value, 0, 32) != exit_point)
1739 {
1740 LOG_WARNING("target reentered debug state, but not at the desired exit point: 0x%4.4" PRIx32 "",
1741 buf_get_u32(arm11->reg_list[15].value, 0, 32));
1742 retval = ERROR_TARGET_TIMEOUT;
1743 goto del_breakpoint;
1744 }
1745
1746 for (int i = 0; i < num_mem_params; i++)
1747 {
1748 if (mem_params[i].direction != PARAM_OUT)
1749 target_read_buffer(target, mem_params[i].address, mem_params[i].size, mem_params[i].value);
1750 }
1751
1752 for (int i = 0; i < num_reg_params; i++)
1753 {
1754 if (reg_params[i].direction != PARAM_OUT)
1755 {
1756 struct reg *reg = register_get_by_name(arm11->core_cache, reg_params[i].reg_name, 0);
1757 if (!reg)
1758 {
1759 LOG_ERROR("BUG: register '%s' not found", reg_params[i].reg_name);
1760 exit(-1);
1761 }
1762
1763 if (reg->size != reg_params[i].size)
1764 {
1765 LOG_ERROR("BUG: register '%s' size doesn't match reg_params[i].size", reg_params[i].reg_name);
1766 exit(-1);
1767 }
1768
1769 buf_set_u32(reg_params[i].value, 0, 32, buf_get_u32(reg->value, 0, 32));
1770 }
1771 }
1772
1773 del_breakpoint:
1774 breakpoint_remove(target, exit_point);
1775
1776 restore:
1777 // Restore context
1778 for (size_t i = 0; i < 16; i++)
1779 {
1780 LOG_DEBUG("restoring register %s with value 0x%8.8" PRIx32 "",
1781 arm11->reg_list[i].name, context[i]);
1782 arm11_set_reg(&arm11->reg_list[i], (uint8_t*)&context[i]);
1783 }
1784 LOG_DEBUG("restoring CPSR with value 0x%8.8" PRIx32 "", cpsr);
1785 arm11_set_reg(&arm11->reg_list[ARM11_RC_CPSR], (uint8_t*)&cpsr);
1786
1787 // arm11->core_state = core_state;
1788 // arm11->core_mode = core_mode;
1789
1790 return retval;
1791 }
1792
1793 static int arm11_target_create(struct target *target, Jim_Interp *interp)
1794 {
1795 FNC_INFO;
1796
1797 NEW(struct arm11_common, arm11, 1);
1798
1799 arm11->target = target;
1800
1801 if (target->tap == NULL)
1802 return ERROR_FAIL;
1803
1804 if (target->tap->ir_length != 5)
1805 {
1806 LOG_ERROR("'target arm11' expects IR LENGTH = 5");
1807 return ERROR_COMMAND_SYNTAX_ERROR;
1808 }
1809
1810 armv4_5_init_arch_info(target, &arm11->arm);
1811
1812 arm11->jtag_info.tap = target->tap;
1813 arm11->jtag_info.scann_size = 5;
1814 arm11->jtag_info.scann_instr = ARM11_SCAN_N;
1815 /* cur_scan_chain == 0 */
1816 arm11->jtag_info.intest_instr = ARM11_INTEST;
1817
1818 return ERROR_OK;
1819 }
1820
1821 static int arm11_init_target(struct command_context *cmd_ctx,
1822 struct target *target)
1823 {
1824 /* Initialize anything we can set up without talking to the target */
1825 return arm11_build_reg_cache(target);
1826 }
1827
1828 /* talk to the target and set things up */
1829 static int arm11_examine(struct target *target)
1830 {
1831 int retval;
1832
1833 FNC_INFO;
1834 struct arm11_common *arm11 = target_to_arm11(target);
1835
1836 /* check IDCODE */
1837
1838 arm11_add_IR(arm11, ARM11_IDCODE, ARM11_TAP_DEFAULT);
1839
1840 struct scan_field idcode_field;
1841
1842 arm11_setup_field(arm11, 32, NULL, &arm11->device_id, &idcode_field);
1843
1844 arm11_add_dr_scan_vc(1, &idcode_field, TAP_DRPAUSE);
1845
1846 /* check DIDR */
1847
1848 arm11_add_debug_SCAN_N(arm11, 0x00, ARM11_TAP_DEFAULT);
1849
1850 arm11_add_IR(arm11, ARM11_INTEST, ARM11_TAP_DEFAULT);
1851
1852 struct scan_field chain0_fields[2];
1853
1854 arm11_setup_field(arm11, 32, NULL, &arm11->didr, chain0_fields + 0);
1855 arm11_setup_field(arm11, 8, NULL, &arm11->implementor, chain0_fields + 1);
1856
1857 arm11_add_dr_scan_vc(asizeof(chain0_fields), chain0_fields, TAP_IDLE);
1858
1859 CHECK_RETVAL(jtag_execute_queue());
1860
1861 switch (arm11->device_id & 0x0FFFF000)
1862 {
1863 case 0x07B36000: LOG_INFO("found ARM1136"); break;
1864 case 0x07B56000: LOG_INFO("found ARM1156"); break;
1865 case 0x07B76000: LOG_INFO("found ARM1176"); break;
1866 default:
1867 LOG_ERROR("'target arm11' expects IDCODE 0x*7B*7****");
1868 return ERROR_FAIL;
1869 }
1870
1871 arm11->debug_version = (arm11->didr >> 16) & 0x0F;
1872
1873 if (arm11->debug_version != ARM11_DEBUG_V6 &&
1874 arm11->debug_version != ARM11_DEBUG_V61)
1875 {
1876 LOG_ERROR("Only ARMv6 v6 and v6.1 architectures supported.");
1877 return ERROR_FAIL;
1878 }
1879
1880 arm11->brp = ((arm11->didr >> 24) & 0x0F) + 1;
1881 arm11->wrp = ((arm11->didr >> 28) & 0x0F) + 1;
1882
1883 /** \todo TODO: reserve one brp slot if we allow breakpoints during step */
1884 arm11->free_brps = arm11->brp;
1885 arm11->free_wrps = arm11->wrp;
1886
1887 LOG_DEBUG("IDCODE %08" PRIx32 " IMPLEMENTOR %02x DIDR %08" PRIx32 "",
1888 arm11->device_id,
1889 (int)(arm11->implementor),
1890 arm11->didr);
1891
1892 /* as a side-effect this reads DSCR and thus
1893 * clears the ARM11_DSCR_STICKY_PRECISE_DATA_ABORT / Sticky Precise Data Abort Flag
1894 * as suggested by the spec.
1895 */
1896
1897 retval = arm11_check_init(arm11, NULL);
1898 if (retval != ERROR_OK)
1899 return retval;
1900
1901 target_set_examined(target);
1902
1903 return ERROR_OK;
1904 }
1905
1906
1907 /** Load a register that is marked !valid in the register cache */
1908 static int arm11_get_reg(struct reg *reg)
1909 {
1910 FNC_INFO;
1911
1912 struct target * target = ((struct arm11_reg_state *)reg->arch_info)->target;
1913
1914 if (target->state != TARGET_HALTED)
1915 {
1916 LOG_WARNING("target was not halted");
1917 return ERROR_TARGET_NOT_HALTED;
1918 }
1919
1920 /** \todo TODO: Check this. We assume that all registers are fetched at debug entry. */
1921
1922 #if 0
1923 struct arm11_common *arm11 = target_to_arm11(target);
1924 const struct arm11_reg_defs *arm11_reg_info = arm11_reg_defs + ((struct arm11_reg_state *)reg->arch_info)->def_index;
1925 #endif
1926
1927 return ERROR_OK;
1928 }
1929
1930 /** Change a value in the register cache */
1931 static int arm11_set_reg(struct reg *reg, uint8_t *buf)
1932 {
1933 FNC_INFO;
1934
1935 struct target *target = ((struct arm11_reg_state *)reg->arch_info)->target;
1936 struct arm11_common *arm11 = target_to_arm11(target);
1937 // const struct arm11_reg_defs *arm11_reg_info = arm11_reg_defs + ((struct arm11_reg_state *)reg->arch_info)->def_index;
1938
1939 arm11->reg_values[((struct arm11_reg_state *)reg->arch_info)->def_index] = buf_get_u32(buf, 0, 32);
1940 reg->valid = 1;
1941 reg->dirty = 1;
1942
1943 return ERROR_OK;
1944 }
1945
1946 static int arm11_build_reg_cache(struct target *target)
1947 {
1948 struct arm11_common *arm11 = target_to_arm11(target);
1949
1950 NEW(struct reg_cache, cache, 1);
1951 NEW(struct reg, reg_list, ARM11_REGCACHE_COUNT);
1952 NEW(struct arm11_reg_state, arm11_reg_states, ARM11_REGCACHE_COUNT);
1953
1954 if (arm11_regs_arch_type == -1)
1955 arm11_regs_arch_type = register_reg_arch_type(arm11_get_reg, arm11_set_reg);
1956
1957 register_init_dummy(&arm11_gdb_dummy_fp_reg);
1958 register_init_dummy(&arm11_gdb_dummy_fps_reg);
1959
1960 arm11->reg_list = reg_list;
1961
1962 /* Build the process context cache */
1963 cache->name = "arm11 registers";
1964 cache->next = NULL;
1965 cache->reg_list = reg_list;
1966 cache->num_regs = ARM11_REGCACHE_COUNT;
1967
1968 struct reg_cache **cache_p = register_get_last_cache_p(&target->reg_cache);
1969 (*cache_p) = cache;
1970
1971 arm11->core_cache = cache;
1972 // armv7m->process_context = cache;
1973
1974 size_t i;
1975
1976 /* Not very elegant assertion */
1977 if (ARM11_REGCACHE_COUNT != asizeof(arm11->reg_values) ||
1978 ARM11_REGCACHE_COUNT != asizeof(arm11_reg_defs) ||
1979 ARM11_REGCACHE_COUNT != ARM11_RC_MAX)
1980 {
1981 LOG_ERROR("BUG: arm11->reg_values inconsistent (%d " ZU " " ZU " %d)", ARM11_REGCACHE_COUNT, asizeof(arm11->reg_values), asizeof(arm11_reg_defs), ARM11_RC_MAX);
1982 exit(-1);
1983 }
1984
1985 for (i = 0; i < ARM11_REGCACHE_COUNT; i++)
1986 {
1987 struct reg * r = reg_list + i;
1988 const struct arm11_reg_defs * rd = arm11_reg_defs + i;
1989 struct arm11_reg_state * rs = arm11_reg_states + i;
1990
1991 r->name = rd->name;
1992 r->size = 32;
1993 r->value = (uint8_t *)(arm11->reg_values + i);
1994 r->dirty = 0;
1995 r->valid = 0;
1996 r->arch_type = arm11_regs_arch_type;
1997 r->arch_info = rs;
1998
1999 rs->def_index = i;
2000 rs->target = target;
2001 }
2002
2003 return ERROR_OK;
2004 }
2005
2006 static COMMAND_HELPER(arm11_handle_bool, bool *var, char *name)
2007 {
2008 if (argc == 0)
2009 {
2010 LOG_INFO("%s is %s.", name, *var ? "enabled" : "disabled");
2011 return ERROR_OK;
2012 }
2013
2014 if (argc != 1)
2015 return ERROR_COMMAND_SYNTAX_ERROR;
2016
2017 switch (args[0][0])
2018 {
2019 case '0': /* 0 */
2020 case 'f': /* false */
2021 case 'F':
2022 case 'd': /* disable */
2023 case 'D':
2024 *var = false;
2025 break;
2026
2027 case '1': /* 1 */
2028 case 't': /* true */
2029 case 'T':
2030 case 'e': /* enable */
2031 case 'E':
2032 *var = true;
2033 break;
2034 }
2035
2036 LOG_INFO("%s %s.", *var ? "Enabled" : "Disabled", name);
2037
2038 return ERROR_OK;
2039 }
2040
2041 #define BOOL_WRAPPER(name, print_name) \
2042 COMMAND_HANDLER(arm11_handle_bool_##name) \
2043 { \
2044 return CALL_COMMAND_HANDLER(arm11_handle_bool, \
2045 &arm11_config_##name, print_name); \
2046 }
2047
2048 BOOL_WRAPPER(memwrite_burst, "memory write burst mode")
2049 BOOL_WRAPPER(memwrite_error_fatal, "fatal error mode for memory writes")
2050 BOOL_WRAPPER(step_irq_enable, "IRQs while stepping")
2051 BOOL_WRAPPER(hardware_step, "hardware single step")
2052
2053 COMMAND_HANDLER(arm11_handle_vcr)
2054 {
2055 switch (argc) {
2056 case 0:
2057 break;
2058 case 1:
2059 COMMAND_PARSE_NUMBER(u32, args[0], arm11_vcr);
2060 break;
2061 default:
2062 return ERROR_COMMAND_SYNTAX_ERROR;
2063 }
2064
2065 LOG_INFO("VCR 0x%08" PRIx32 "", arm11_vcr);
2066 return ERROR_OK;
2067 }
2068
2069 static const uint32_t arm11_coproc_instruction_limits[] =
2070 {
2071 15, /* coprocessor */
2072 7, /* opcode 1 */
2073 15, /* CRn */
2074 15, /* CRm */
2075 7, /* opcode 2 */
2076 0xFFFFFFFF, /* value */
2077 };
2078
2079 static struct arm11_common * arm11_find_target(const char * arg)
2080 {
2081 struct jtag_tap * tap;
2082 struct target * t;
2083
2084 tap = jtag_tap_by_string(arg);
2085
2086 if (!tap)
2087 return 0;
2088
2089 for (t = all_targets; t; t = t->next)
2090 {
2091 if (t->tap != tap)
2092 continue;
2093
2094 /* if (t->type == arm11_target) */
2095 if (0 == strcmp(target_get_name(t), "arm11"))
2096 return t->arch_info;
2097 }
2098
2099 return 0;
2100 }
2101
2102 static int arm11_mrc_inner(struct target *target, int cpnum,
2103 uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm,
2104 uint32_t *value, bool read)
2105 {
2106 int retval;
2107 struct arm11_common *arm11 = target_to_arm11(target);
2108
2109 if (target->state != TARGET_HALTED)
2110 {
2111 LOG_ERROR("Target not halted");
2112 return ERROR_FAIL;
2113 }
2114
2115 uint32_t instr = 0xEE000010 |
2116 (cpnum << 8) |
2117 (op1 << 21) |
2118 (CRn << 16) |
2119 (CRm << 0) |
2120 (op2 << 5);
2121
2122 if (read)
2123 instr |= 0x00100000;
2124
2125 retval = arm11_run_instr_data_prepare(arm11);
2126 if (retval != ERROR_OK)
2127 return retval;
2128
2129 if (read)
2130 {
2131 retval = arm11_run_instr_data_from_core_via_r0(arm11, instr, value);
2132 if (retval != ERROR_OK)
2133 return retval;
2134 }
2135 else
2136 {
2137 retval = arm11_run_instr_data_to_core_via_r0(arm11, instr, *value);
2138 if (retval != ERROR_OK)
2139 return retval;
2140 }
2141
2142 return arm11_run_instr_data_finish(arm11);
2143 }
2144
2145 static int arm11_mrc(struct target *target, int cpnum,
2146 uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value)
2147 {
2148 return arm11_mrc_inner(target, cpnum, op1, op2, CRn, CRm, value, true);
2149 }
2150
2151 static int arm11_mcr(struct target *target, int cpnum,
2152 uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value)
2153 {
2154 return arm11_mrc_inner(target, cpnum, op1, op2, CRn, CRm, &value, false);
2155 }
2156
2157 static COMMAND_HELPER(arm11_handle_etm_read_write, bool read)
2158 {
2159 if (argc != (read ? 2 : 3))
2160 {
2161 LOG_ERROR("Invalid number of arguments.");
2162 return ERROR_COMMAND_SYNTAX_ERROR;
2163 }
2164
2165 struct arm11_common * arm11 = arm11_find_target(args[0]);
2166
2167 if (!arm11)
2168 {
2169 LOG_ERROR("Parameter 1 is not the target name of an ARM11 device.");
2170 return ERROR_COMMAND_SYNTAX_ERROR;
2171 }
2172
2173 uint32_t address;
2174 COMMAND_PARSE_NUMBER(u32, args[1], address);
2175
2176 if (!read)
2177 {
2178 uint32_t value;
2179 COMMAND_PARSE_NUMBER(u32, args[2], value);
2180
2181 LOG_INFO("ETM write register 0x%02" PRIx32 " (%" PRId32 ") = 0x%08" PRIx32 " (%" PRId32 ")",
2182 address, address, value, value);
2183
2184 CHECK_RETVAL(arm11_write_etm(arm11, address, value));
2185 }
2186 else
2187 {
2188 uint32_t value;
2189
2190 CHECK_RETVAL(arm11_read_etm(arm11, address, &value));
2191
2192 LOG_INFO("ETM read register 0x%02" PRIx32 " (%" PRId32 ") = 0x%08" PRIx32 " (%" PRId32 ")",
2193 address, address, value, value);
2194 }
2195
2196 return ERROR_OK;
2197 }
2198
2199 COMMAND_HANDLER(arm11_handle_etmr)
2200 {
2201 return CALL_COMMAND_HANDLER(arm11_handle_etm_read_write, true);
2202 }
2203
2204 COMMAND_HANDLER(arm11_handle_etmw)
2205 {
2206 return CALL_COMMAND_HANDLER(arm11_handle_etm_read_write, false);
2207 }
2208
2209 #define ARM11_HANDLER(x) .x = arm11_##x
2210
2211 struct target_type arm11_target = {
2212 .name = "arm11",
2213
2214 ARM11_HANDLER(poll),
2215 ARM11_HANDLER(arch_state),
2216
2217 ARM11_HANDLER(target_request_data),
2218
2219 ARM11_HANDLER(halt),
2220 ARM11_HANDLER(resume),
2221 ARM11_HANDLER(step),
2222
2223 ARM11_HANDLER(assert_reset),
2224 ARM11_HANDLER(deassert_reset),
2225 ARM11_HANDLER(soft_reset_halt),
2226
2227 ARM11_HANDLER(get_gdb_reg_list),
2228
2229 ARM11_HANDLER(read_memory),
2230 ARM11_HANDLER(write_memory),
2231
2232 ARM11_HANDLER(bulk_write_memory),
2233
2234 ARM11_HANDLER(checksum_memory),
2235
2236 ARM11_HANDLER(add_breakpoint),
2237 ARM11_HANDLER(remove_breakpoint),
2238 ARM11_HANDLER(add_watchpoint),
2239 ARM11_HANDLER(remove_watchpoint),
2240
2241 ARM11_HANDLER(run_algorithm),
2242
2243 ARM11_HANDLER(register_commands),
2244 ARM11_HANDLER(target_create),
2245 ARM11_HANDLER(init_target),
2246 ARM11_HANDLER(examine),
2247
2248 ARM11_HANDLER(mrc),
2249 ARM11_HANDLER(mcr),
2250 };
2251
2252
2253 int arm11_register_commands(struct command_context *cmd_ctx)
2254 {
2255 FNC_INFO;
2256
2257 struct command *top_cmd, *mw_cmd;
2258
2259 top_cmd = register_command(cmd_ctx, NULL, "arm11",
2260 NULL, COMMAND_ANY, NULL);
2261
2262 register_command(cmd_ctx, top_cmd, "etmr",
2263 arm11_handle_etmr, COMMAND_ANY,
2264 "Read Embedded Trace Macrocell (ETM) register. etmr <jtag_target> <ETM register address>");
2265
2266 register_command(cmd_ctx, top_cmd, "etmw",
2267 arm11_handle_etmw, COMMAND_ANY,
2268 "Write Embedded Trace Macrocell (ETM) register. etmr <jtag_target> <ETM register address> <value>");
2269
2270 /* "hardware_step" is only here to check if the default
2271 * simulate + breakpoint implementation is broken.
2272 * TEMPORARY! NOT DOCUMENTED!
2273 */
2274 register_command(cmd_ctx, top_cmd, "hardware_step",
2275 arm11_handle_bool_hardware_step, COMMAND_ANY,
2276 "DEBUG ONLY - Hardware single stepping"
2277 " (default: disabled)");
2278
2279 mw_cmd = register_command(cmd_ctx, top_cmd, "memwrite",
2280 NULL, COMMAND_ANY, NULL);
2281 register_command(cmd_ctx, mw_cmd, "burst",
2282 arm11_handle_bool_memwrite_burst, COMMAND_ANY,
2283 "Enable/Disable non-standard but fast burst mode"
2284 " (default: enabled)");
2285 register_command(cmd_ctx, mw_cmd, "error_fatal",
2286 arm11_handle_bool_memwrite_error_fatal, COMMAND_ANY,
2287 "Terminate program if transfer error was found"
2288 " (default: enabled)");
2289
2290 register_command(cmd_ctx, top_cmd, "step_irq_enable",
2291 arm11_handle_bool_step_irq_enable, COMMAND_ANY,
2292 "Enable interrupts while stepping"
2293 " (default: disabled)");
2294 register_command(cmd_ctx, top_cmd, "vcr",
2295 arm11_handle_vcr, COMMAND_ANY,
2296 "Control (Interrupt) Vector Catch Register");
2297
2298 return ERROR_OK;
2299 }
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)