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