1 /***************************************************************************
2 * Copyright (C) 2006, 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2009 Michael Schwingen *
9 * michael@schwingen.org *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
30 #include "breakpoints.h"
32 #include "target_type.h"
34 #include "arm_simulator.h"
35 #include "arm_disassembler.h"
36 #include "time_support.h"
42 * Important XScale documents available as of October 2009 include:
44 * Intel XScale® Core Developer’s Manual, January 2004
45 * Order Number: 273473-002
46 * This has a chapter detailing debug facilities, and punts some
47 * details to chip-specific microarchitecture documents.
49 * Hot-Debug for Intel XScale® Core Debug White Paper, May 2005
50 * Document Number: 273539-005
51 * Less detailed than the developer's manual, but summarizes those
52 * missing details (for most XScales) and gives LOTS of notes about
53 * debugger/handler interaction issues. Presents a simpler reset
54 * and load-handler sequence than the arch doc. (Note, OpenOCD
55 * doesn't currently support "Hot-Debug" as defined there.)
57 * Chip-specific microarchitecture documents may also be useful.
61 /* forward declarations */
62 static int xscale_resume(struct target
*, int current
,
63 uint32_t address
, int handle_breakpoints
, int debug_execution
);
64 static int xscale_debug_entry(struct target
*);
65 static int xscale_restore_context(struct target
*);
66 static int xscale_get_reg(struct reg
*reg
);
67 static int xscale_set_reg(struct reg
*reg
, uint8_t *buf
);
68 static int xscale_set_breakpoint(struct target
*, struct breakpoint
*);
69 static int xscale_set_watchpoint(struct target
*, struct watchpoint
*);
70 static int xscale_unset_breakpoint(struct target
*, struct breakpoint
*);
71 static int xscale_read_trace(struct target
*);
74 /* This XScale "debug handler" is loaded into the processor's
75 * mini-ICache, which is 2K of code writable only via JTAG.
77 * FIXME the OpenOCD "bin2char" utility currently doesn't handle
78 * binary files cleanly. It's string oriented, and terminates them
79 * with a NUL character. Better would be to generate the constants
80 * and let other code decide names, scoping, and other housekeeping.
82 static /* unsigned const char xscale_debug_handler[] = ... */
83 #include "xscale_debug.h"
85 static char *const xscale_reg_list
[] =
87 "XSCALE_MAINID", /* 0 */
97 "XSCALE_IBCR0", /* 10 */
107 "XSCALE_RX", /* 20 */
111 static const struct xscale_reg xscale_reg_arch_info
[] =
113 {XSCALE_MAINID
, NULL
},
114 {XSCALE_CACHETYPE
, NULL
},
116 {XSCALE_AUXCTRL
, NULL
},
122 {XSCALE_CPACCESS
, NULL
},
123 {XSCALE_IBCR0
, NULL
},
124 {XSCALE_IBCR1
, NULL
},
127 {XSCALE_DBCON
, NULL
},
128 {XSCALE_TBREG
, NULL
},
129 {XSCALE_CHKPT0
, NULL
},
130 {XSCALE_CHKPT1
, NULL
},
131 {XSCALE_DCSR
, NULL
}, /* DCSR accessed via JTAG or SW */
132 {-1, NULL
}, /* TX accessed via JTAG */
133 {-1, NULL
}, /* RX accessed via JTAG */
134 {-1, NULL
}, /* TXRXCTRL implicit access via JTAG */
137 /* convenience wrapper to access XScale specific registers */
138 static int xscale_set_reg_u32(struct reg
*reg
, uint32_t value
)
142 buf_set_u32(buf
, 0, 32, value
);
144 return xscale_set_reg(reg
, buf
);
147 static const char xscale_not
[] = "target is not an XScale";
149 static int xscale_verify_pointer(struct command_context
*cmd_ctx
,
150 struct xscale_common
*xscale
)
152 if (xscale
->common_magic
!= XSCALE_COMMON_MAGIC
) {
153 command_print(cmd_ctx
, xscale_not
);
154 return ERROR_TARGET_INVALID
;
159 static int xscale_jtag_set_instr(struct jtag_tap
*tap
, uint32_t new_instr
)
164 if (buf_get_u32(tap
->cur_instr
, 0, tap
->ir_length
) != new_instr
)
166 struct scan_field field
;
169 memset(&field
, 0, sizeof field
);
171 field
.num_bits
= tap
->ir_length
;
172 field
.out_value
= scratch
;
173 buf_set_u32(field
.out_value
, 0, field
.num_bits
, new_instr
);
175 jtag_add_ir_scan(1, &field
, jtag_get_end_state());
181 static int xscale_read_dcsr(struct target
*target
)
183 struct xscale_common
*xscale
= target_to_xscale(target
);
185 struct scan_field fields
[3];
186 uint8_t field0
= 0x0;
187 uint8_t field0_check_value
= 0x2;
188 uint8_t field0_check_mask
= 0x7;
189 uint8_t field2
= 0x0;
190 uint8_t field2_check_value
= 0x0;
191 uint8_t field2_check_mask
= 0x1;
193 jtag_set_end_state(TAP_DRPAUSE
);
194 xscale_jtag_set_instr(target
->tap
, XSCALE_SELDCSR
);
196 buf_set_u32(&field0
, 1, 1, xscale
->hold_rst
);
197 buf_set_u32(&field0
, 2, 1, xscale
->external_debug_break
);
199 memset(&fields
, 0, sizeof fields
);
201 fields
[0].tap
= target
->tap
;
202 fields
[0].num_bits
= 3;
203 fields
[0].out_value
= &field0
;
205 fields
[0].in_value
= &tmp
;
207 fields
[1].tap
= target
->tap
;
208 fields
[1].num_bits
= 32;
209 fields
[1].in_value
= xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
;
211 fields
[2].tap
= target
->tap
;
212 fields
[2].num_bits
= 1;
213 fields
[2].out_value
= &field2
;
215 fields
[2].in_value
= &tmp2
;
217 jtag_add_dr_scan(3, fields
, jtag_get_end_state());
219 jtag_check_value_mask(fields
+ 0, &field0_check_value
, &field0_check_mask
);
220 jtag_check_value_mask(fields
+ 2, &field2_check_value
, &field2_check_mask
);
222 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
224 LOG_ERROR("JTAG error while reading DCSR");
228 xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].dirty
= 0;
229 xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].valid
= 1;
231 /* write the register with the value we just read
232 * on this second pass, only the first bit of field0 is guaranteed to be 0)
234 field0_check_mask
= 0x1;
235 fields
[1].out_value
= xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
;
236 fields
[1].in_value
= NULL
;
238 jtag_set_end_state(TAP_IDLE
);
240 jtag_add_dr_scan(3, fields
, jtag_get_end_state());
242 /* DANGER!!! this must be here. It will make sure that the arguments
243 * to jtag_set_check_value() does not go out of scope! */
244 return jtag_execute_queue();
248 static void xscale_getbuf(jtag_callback_data_t arg
)
250 uint8_t *in
= (uint8_t *)arg
;
251 *((uint32_t *)in
) = buf_get_u32(in
, 0, 32);
254 static int xscale_receive(struct target
*target
, uint32_t *buffer
, int num_words
)
257 return ERROR_INVALID_ARGUMENTS
;
259 int retval
= ERROR_OK
;
261 struct scan_field fields
[3];
262 uint8_t *field0
= malloc(num_words
* 1);
263 uint8_t field0_check_value
= 0x2;
264 uint8_t field0_check_mask
= 0x6;
265 uint32_t *field1
= malloc(num_words
* 4);
266 uint8_t field2_check_value
= 0x0;
267 uint8_t field2_check_mask
= 0x1;
269 int words_scheduled
= 0;
272 path
[0] = TAP_DRSELECT
;
273 path
[1] = TAP_DRCAPTURE
;
274 path
[2] = TAP_DRSHIFT
;
276 memset(&fields
, 0, sizeof fields
);
278 fields
[0].tap
= target
->tap
;
279 fields
[0].num_bits
= 3;
280 fields
[0].check_value
= &field0_check_value
;
281 fields
[0].check_mask
= &field0_check_mask
;
283 fields
[1].tap
= target
->tap
;
284 fields
[1].num_bits
= 32;
286 fields
[2].tap
= target
->tap
;
287 fields
[2].num_bits
= 1;
288 fields
[2].check_value
= &field2_check_value
;
289 fields
[2].check_mask
= &field2_check_mask
;
291 jtag_set_end_state(TAP_IDLE
);
292 xscale_jtag_set_instr(target
->tap
, XSCALE_DBGTX
);
293 jtag_add_runtest(1, jtag_get_end_state()); /* ensures that we're in the TAP_IDLE state as the above could be a no-op */
295 /* repeat until all words have been collected */
297 while (words_done
< num_words
)
301 for (i
= words_done
; i
< num_words
; i
++)
303 fields
[0].in_value
= &field0
[i
];
305 jtag_add_pathmove(3, path
);
307 fields
[1].in_value
= (uint8_t *)(field1
+ i
);
309 jtag_add_dr_scan_check(3, fields
, jtag_set_end_state(TAP_IDLE
));
311 jtag_add_callback(xscale_getbuf
, (jtag_callback_data_t
)(field1
+ i
));
316 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
318 LOG_ERROR("JTAG error while receiving data from debug handler");
322 /* examine results */
323 for (i
= words_done
; i
< num_words
; i
++)
325 if (!(field0
[0] & 1))
327 /* move backwards if necessary */
329 for (j
= i
; j
< num_words
- 1; j
++)
331 field0
[j
] = field0
[j
+ 1];
332 field1
[j
] = field1
[j
+ 1];
337 if (words_scheduled
== 0)
339 if (attempts
++==1000)
341 LOG_ERROR("Failed to receiving data from debug handler after 1000 attempts");
342 retval
= ERROR_TARGET_TIMEOUT
;
347 words_done
+= words_scheduled
;
350 for (i
= 0; i
< num_words
; i
++)
351 *(buffer
++) = buf_get_u32((uint8_t*)&field1
[i
], 0, 32);
358 static int xscale_read_tx(struct target
*target
, int consume
)
360 struct xscale_common
*xscale
= target_to_xscale(target
);
362 tap_state_t noconsume_path
[6];
364 struct timeval timeout
, now
;
365 struct scan_field fields
[3];
366 uint8_t field0_in
= 0x0;
367 uint8_t field0_check_value
= 0x2;
368 uint8_t field0_check_mask
= 0x6;
369 uint8_t field2_check_value
= 0x0;
370 uint8_t field2_check_mask
= 0x1;
372 jtag_set_end_state(TAP_IDLE
);
374 xscale_jtag_set_instr(target
->tap
, XSCALE_DBGTX
);
376 path
[0] = TAP_DRSELECT
;
377 path
[1] = TAP_DRCAPTURE
;
378 path
[2] = TAP_DRSHIFT
;
380 noconsume_path
[0] = TAP_DRSELECT
;
381 noconsume_path
[1] = TAP_DRCAPTURE
;
382 noconsume_path
[2] = TAP_DREXIT1
;
383 noconsume_path
[3] = TAP_DRPAUSE
;
384 noconsume_path
[4] = TAP_DREXIT2
;
385 noconsume_path
[5] = TAP_DRSHIFT
;
387 memset(&fields
, 0, sizeof fields
);
389 fields
[0].tap
= target
->tap
;
390 fields
[0].num_bits
= 3;
391 fields
[0].in_value
= &field0_in
;
393 fields
[1].tap
= target
->tap
;
394 fields
[1].num_bits
= 32;
395 fields
[1].in_value
= xscale
->reg_cache
->reg_list
[XSCALE_TX
].value
;
397 fields
[2].tap
= target
->tap
;
398 fields
[2].num_bits
= 1;
400 fields
[2].in_value
= &tmp
;
402 gettimeofday(&timeout
, NULL
);
403 timeval_add_time(&timeout
, 1, 0);
407 /* if we want to consume the register content (i.e. clear TX_READY),
408 * we have to go straight from Capture-DR to Shift-DR
409 * otherwise, we go from Capture-DR to Exit1-DR to Pause-DR
412 jtag_add_pathmove(3, path
);
415 jtag_add_pathmove(sizeof(noconsume_path
)/sizeof(*noconsume_path
), noconsume_path
);
418 jtag_add_dr_scan(3, fields
, jtag_set_end_state(TAP_IDLE
));
420 jtag_check_value_mask(fields
+ 0, &field0_check_value
, &field0_check_mask
);
421 jtag_check_value_mask(fields
+ 2, &field2_check_value
, &field2_check_mask
);
423 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
425 LOG_ERROR("JTAG error while reading TX");
426 return ERROR_TARGET_TIMEOUT
;
429 gettimeofday(&now
, NULL
);
430 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
)&& (now
.tv_usec
> timeout
.tv_usec
)))
432 LOG_ERROR("time out reading TX register");
433 return ERROR_TARGET_TIMEOUT
;
435 if (!((!(field0_in
& 1)) && consume
))
439 if (debug_level
>= 3)
441 LOG_DEBUG("waiting 100ms");
442 alive_sleep(100); /* avoid flooding the logs */
450 if (!(field0_in
& 1))
451 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
456 static int xscale_write_rx(struct target
*target
)
458 struct xscale_common
*xscale
= target_to_xscale(target
);
460 struct timeval timeout
, now
;
461 struct scan_field fields
[3];
462 uint8_t field0_out
= 0x0;
463 uint8_t field0_in
= 0x0;
464 uint8_t field0_check_value
= 0x2;
465 uint8_t field0_check_mask
= 0x6;
466 uint8_t field2
= 0x0;
467 uint8_t field2_check_value
= 0x0;
468 uint8_t field2_check_mask
= 0x1;
470 jtag_set_end_state(TAP_IDLE
);
472 xscale_jtag_set_instr(target
->tap
, XSCALE_DBGRX
);
474 memset(&fields
, 0, sizeof fields
);
476 fields
[0].tap
= target
->tap
;
477 fields
[0].num_bits
= 3;
478 fields
[0].out_value
= &field0_out
;
479 fields
[0].in_value
= &field0_in
;
481 fields
[1].tap
= target
->tap
;
482 fields
[1].num_bits
= 32;
483 fields
[1].out_value
= xscale
->reg_cache
->reg_list
[XSCALE_RX
].value
;
485 fields
[2].tap
= target
->tap
;
486 fields
[2].num_bits
= 1;
487 fields
[2].out_value
= &field2
;
489 fields
[2].in_value
= &tmp
;
491 gettimeofday(&timeout
, NULL
);
492 timeval_add_time(&timeout
, 1, 0);
494 /* poll until rx_read is low */
495 LOG_DEBUG("polling RX");
498 jtag_add_dr_scan(3, fields
, jtag_set_end_state(TAP_IDLE
));
500 jtag_check_value_mask(fields
+ 0, &field0_check_value
, &field0_check_mask
);
501 jtag_check_value_mask(fields
+ 2, &field2_check_value
, &field2_check_mask
);
503 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
505 LOG_ERROR("JTAG error while writing RX");
509 gettimeofday(&now
, NULL
);
510 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
)&& (now
.tv_usec
> timeout
.tv_usec
)))
512 LOG_ERROR("time out writing RX register");
513 return ERROR_TARGET_TIMEOUT
;
515 if (!(field0_in
& 1))
517 if (debug_level
>= 3)
519 LOG_DEBUG("waiting 100ms");
520 alive_sleep(100); /* avoid flooding the logs */
530 jtag_add_dr_scan(3, fields
, jtag_set_end_state(TAP_IDLE
));
532 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
534 LOG_ERROR("JTAG error while writing RX");
541 /* send count elements of size byte to the debug handler */
542 static int xscale_send(struct target
*target
, uint8_t *buffer
, int count
, int size
)
549 jtag_set_end_state(TAP_IDLE
);
551 xscale_jtag_set_instr(target
->tap
, XSCALE_DBGRX
);
558 int endianness
= target
->endianness
;
559 while (done_count
++ < count
)
564 if (endianness
== TARGET_LITTLE_ENDIAN
)
566 t
[1]=le_to_h_u32(buffer
);
569 t
[1]=be_to_h_u32(buffer
);
573 if (endianness
== TARGET_LITTLE_ENDIAN
)
575 t
[1]=le_to_h_u16(buffer
);
578 t
[1]=be_to_h_u16(buffer
);
585 LOG_ERROR("BUG: size neither 4, 2 nor 1");
586 return ERROR_INVALID_ARGUMENTS
;
588 jtag_add_dr_out(target
->tap
,
592 jtag_set_end_state(TAP_IDLE
));
596 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
598 LOG_ERROR("JTAG error while sending data to debug handler");
605 static int xscale_send_u32(struct target
*target
, uint32_t value
)
607 struct xscale_common
*xscale
= target_to_xscale(target
);
609 buf_set_u32(xscale
->reg_cache
->reg_list
[XSCALE_RX
].value
, 0, 32, value
);
610 return xscale_write_rx(target
);
613 static int xscale_write_dcsr(struct target
*target
, int hold_rst
, int ext_dbg_brk
)
615 struct xscale_common
*xscale
= target_to_xscale(target
);
617 struct scan_field fields
[3];
618 uint8_t field0
= 0x0;
619 uint8_t field0_check_value
= 0x2;
620 uint8_t field0_check_mask
= 0x7;
621 uint8_t field2
= 0x0;
622 uint8_t field2_check_value
= 0x0;
623 uint8_t field2_check_mask
= 0x1;
626 xscale
->hold_rst
= hold_rst
;
628 if (ext_dbg_brk
!= -1)
629 xscale
->external_debug_break
= ext_dbg_brk
;
631 jtag_set_end_state(TAP_IDLE
);
632 xscale_jtag_set_instr(target
->tap
, XSCALE_SELDCSR
);
634 buf_set_u32(&field0
, 1, 1, xscale
->hold_rst
);
635 buf_set_u32(&field0
, 2, 1, xscale
->external_debug_break
);
637 memset(&fields
, 0, sizeof fields
);
639 fields
[0].tap
= target
->tap
;
640 fields
[0].num_bits
= 3;
641 fields
[0].out_value
= &field0
;
643 fields
[0].in_value
= &tmp
;
645 fields
[1].tap
= target
->tap
;
646 fields
[1].num_bits
= 32;
647 fields
[1].out_value
= xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
;
649 fields
[2].tap
= target
->tap
;
650 fields
[2].num_bits
= 1;
651 fields
[2].out_value
= &field2
;
653 fields
[2].in_value
= &tmp2
;
655 jtag_add_dr_scan(3, fields
, jtag_get_end_state());
657 jtag_check_value_mask(fields
+ 0, &field0_check_value
, &field0_check_mask
);
658 jtag_check_value_mask(fields
+ 2, &field2_check_value
, &field2_check_mask
);
660 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
662 LOG_ERROR("JTAG error while writing DCSR");
666 xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].dirty
= 0;
667 xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].valid
= 1;
672 /* parity of the number of bits 0 if even; 1 if odd. for 32 bit words */
673 static unsigned int parity (unsigned int v
)
675 // unsigned int ov = v;
680 // LOG_DEBUG("parity of 0x%x is %i", ov, (0x6996 >> v) & 1);
681 return (0x6996 >> v
) & 1;
684 static int xscale_load_ic(struct target
*target
, uint32_t va
, uint32_t buffer
[8])
689 struct scan_field fields
[2];
691 LOG_DEBUG("loading miniIC at 0x%8.8" PRIx32
"", va
);
694 jtag_set_end_state(TAP_IDLE
);
695 xscale_jtag_set_instr(target
->tap
, XSCALE_LDIC
);
697 /* CMD is b011 to load a cacheline into the Mini ICache.
698 * Loading into the main ICache is deprecated, and unused.
699 * It's followed by three zero bits, and 27 address bits.
701 buf_set_u32(&cmd
, 0, 6, 0x3);
703 /* virtual address of desired cache line */
704 buf_set_u32(packet
, 0, 27, va
>> 5);
706 memset(&fields
, 0, sizeof fields
);
708 fields
[0].tap
= target
->tap
;
709 fields
[0].num_bits
= 6;
710 fields
[0].out_value
= &cmd
;
712 fields
[1].tap
= target
->tap
;
713 fields
[1].num_bits
= 27;
714 fields
[1].out_value
= packet
;
716 jtag_add_dr_scan(2, fields
, jtag_get_end_state());
718 /* rest of packet is a cacheline: 8 instructions, with parity */
719 fields
[0].num_bits
= 32;
720 fields
[0].out_value
= packet
;
722 fields
[1].num_bits
= 1;
723 fields
[1].out_value
= &cmd
;
725 for (word
= 0; word
< 8; word
++)
727 buf_set_u32(packet
, 0, 32, buffer
[word
]);
730 memcpy(&value
, packet
, sizeof(uint32_t));
733 jtag_add_dr_scan(2, fields
, jtag_get_end_state());
736 return jtag_execute_queue();
739 static int xscale_invalidate_ic_line(struct target
*target
, uint32_t va
)
743 struct scan_field fields
[2];
745 jtag_set_end_state(TAP_IDLE
);
746 xscale_jtag_set_instr(target
->tap
, XSCALE_LDIC
);
748 /* CMD for invalidate IC line b000, bits [6:4] b000 */
749 buf_set_u32(&cmd
, 0, 6, 0x0);
751 /* virtual address of desired cache line */
752 buf_set_u32(packet
, 0, 27, va
>> 5);
754 memset(&fields
, 0, sizeof fields
);
756 fields
[0].tap
= target
->tap
;
757 fields
[0].num_bits
= 6;
758 fields
[0].out_value
= &cmd
;
760 fields
[1].tap
= target
->tap
;
761 fields
[1].num_bits
= 27;
762 fields
[1].out_value
= packet
;
764 jtag_add_dr_scan(2, fields
, jtag_get_end_state());
769 static int xscale_update_vectors(struct target
*target
)
771 struct xscale_common
*xscale
= target_to_xscale(target
);
775 uint32_t low_reset_branch
, high_reset_branch
;
777 for (i
= 1; i
< 8; i
++)
779 /* if there's a static vector specified for this exception, override */
780 if (xscale
->static_high_vectors_set
& (1 << i
))
782 xscale
->high_vectors
[i
] = xscale
->static_high_vectors
[i
];
786 retval
= target_read_u32(target
, 0xffff0000 + 4*i
, &xscale
->high_vectors
[i
]);
787 if (retval
== ERROR_TARGET_TIMEOUT
)
789 if (retval
!= ERROR_OK
)
791 /* Some of these reads will fail as part of normal execution */
792 xscale
->high_vectors
[i
] = ARMV4_5_B(0xfffffe, 0);
797 for (i
= 1; i
< 8; i
++)
799 if (xscale
->static_low_vectors_set
& (1 << i
))
801 xscale
->low_vectors
[i
] = xscale
->static_low_vectors
[i
];
805 retval
= target_read_u32(target
, 0x0 + 4*i
, &xscale
->low_vectors
[i
]);
806 if (retval
== ERROR_TARGET_TIMEOUT
)
808 if (retval
!= ERROR_OK
)
810 /* Some of these reads will fail as part of normal execution */
811 xscale
->low_vectors
[i
] = ARMV4_5_B(0xfffffe, 0);
816 /* calculate branches to debug handler */
817 low_reset_branch
= (xscale
->handler_address
+ 0x20 - 0x0 - 0x8) >> 2;
818 high_reset_branch
= (xscale
->handler_address
+ 0x20 - 0xffff0000 - 0x8) >> 2;
820 xscale
->low_vectors
[0] = ARMV4_5_B((low_reset_branch
& 0xffffff), 0);
821 xscale
->high_vectors
[0] = ARMV4_5_B((high_reset_branch
& 0xffffff), 0);
823 /* invalidate and load exception vectors in mini i-cache */
824 xscale_invalidate_ic_line(target
, 0x0);
825 xscale_invalidate_ic_line(target
, 0xffff0000);
827 xscale_load_ic(target
, 0x0, xscale
->low_vectors
);
828 xscale_load_ic(target
, 0xffff0000, xscale
->high_vectors
);
833 static int xscale_arch_state(struct target
*target
)
835 struct xscale_common
*xscale
= target_to_xscale(target
);
836 struct armv4_5_common_s
*armv4_5
= &xscale
->armv4_5_common
;
838 static const char *state
[] =
840 "disabled", "enabled"
843 static const char *arch_dbg_reason
[] =
845 "", "\n(processor reset)", "\n(trace buffer full)"
848 if (armv4_5
->common_magic
!= ARMV4_5_COMMON_MAGIC
)
850 LOG_ERROR("BUG: called for a non-ARMv4/5 target");
851 return ERROR_INVALID_ARGUMENTS
;
854 LOG_USER("target halted in %s state due to %s, current mode: %s\n"
855 "cpsr: 0x%8.8" PRIx32
" pc: 0x%8.8" PRIx32
"\n"
856 "MMU: %s, D-Cache: %s, I-Cache: %s"
858 armv4_5_state_strings
[armv4_5
->core_state
],
859 Jim_Nvp_value2name_simple(nvp_target_debug_reason
, target
->debug_reason
)->name
,
860 arm_mode_name(armv4_5
->core_mode
),
861 buf_get_u32(armv4_5
->cpsr
->value
, 0, 32),
862 buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32),
863 state
[xscale
->armv4_5_mmu
.mmu_enabled
],
864 state
[xscale
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
],
865 state
[xscale
->armv4_5_mmu
.armv4_5_cache
.i_cache_enabled
],
866 arch_dbg_reason
[xscale
->arch_debug_reason
]);
871 static int xscale_poll(struct target
*target
)
873 int retval
= ERROR_OK
;
875 if ((target
->state
== TARGET_RUNNING
) || (target
->state
== TARGET_DEBUG_RUNNING
))
877 enum target_state previous_state
= target
->state
;
878 if ((retval
= xscale_read_tx(target
, 0)) == ERROR_OK
)
881 /* there's data to read from the tx register, we entered debug state */
882 target
->state
= TARGET_HALTED
;
884 /* process debug entry, fetching current mode regs */
885 retval
= xscale_debug_entry(target
);
887 else if (retval
!= ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
889 LOG_USER("error while polling TX register, reset CPU");
890 /* here we "lie" so GDB won't get stuck and a reset can be perfomed */
891 target
->state
= TARGET_HALTED
;
894 /* debug_entry could have overwritten target state (i.e. immediate resume)
895 * don't signal event handlers in that case
897 if (target
->state
!= TARGET_HALTED
)
900 /* if target was running, signal that we halted
901 * otherwise we reentered from debug execution */
902 if (previous_state
== TARGET_RUNNING
)
903 target_call_event_callbacks(target
, TARGET_EVENT_HALTED
);
905 target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_HALTED
);
911 static int xscale_debug_entry(struct target
*target
)
913 struct xscale_common
*xscale
= target_to_xscale(target
);
914 struct armv4_5_common_s
*armv4_5
= &xscale
->armv4_5_common
;
921 /* clear external dbg break (will be written on next DCSR read) */
922 xscale
->external_debug_break
= 0;
923 if ((retval
= xscale_read_dcsr(target
)) != ERROR_OK
)
926 /* get r0, pc, r1 to r7 and cpsr */
927 if ((retval
= xscale_receive(target
, buffer
, 10)) != ERROR_OK
)
930 /* move r0 from buffer to register cache */
931 buf_set_u32(armv4_5
->core_cache
->reg_list
[0].value
, 0, 32, buffer
[0]);
932 armv4_5
->core_cache
->reg_list
[0].dirty
= 1;
933 armv4_5
->core_cache
->reg_list
[0].valid
= 1;
934 LOG_DEBUG("r0: 0x%8.8" PRIx32
"", buffer
[0]);
936 /* move pc from buffer to register cache */
937 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, buffer
[1]);
938 armv4_5
->core_cache
->reg_list
[15].dirty
= 1;
939 armv4_5
->core_cache
->reg_list
[15].valid
= 1;
940 LOG_DEBUG("pc: 0x%8.8" PRIx32
"", buffer
[1]);
942 /* move data from buffer to register cache */
943 for (i
= 1; i
<= 7; i
++)
945 buf_set_u32(armv4_5
->core_cache
->reg_list
[i
].value
, 0, 32, buffer
[1 + i
]);
946 armv4_5
->core_cache
->reg_list
[i
].dirty
= 1;
947 armv4_5
->core_cache
->reg_list
[i
].valid
= 1;
948 LOG_DEBUG("r%i: 0x%8.8" PRIx32
"", i
, buffer
[i
+ 1]);
951 arm_set_cpsr(armv4_5
, buffer
[9]);
952 LOG_DEBUG("cpsr: 0x%8.8" PRIx32
"", buffer
[9]);
954 if (!is_arm_mode(armv4_5
->core_mode
))
956 target
->state
= TARGET_UNKNOWN
;
957 LOG_ERROR("cpsr contains invalid mode value - communication failure");
958 return ERROR_TARGET_FAILURE
;
960 LOG_DEBUG("target entered debug state in %s mode",
961 arm_mode_name(armv4_5
->core_mode
));
963 /* get banked registers, r8 to r14, and spsr if not in USR/SYS mode */
964 if ((armv4_5
->core_mode
!= ARMV4_5_MODE_USR
) && (armv4_5
->core_mode
!= ARMV4_5_MODE_SYS
))
966 xscale_receive(target
, buffer
, 8);
967 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).value
, 0, 32, buffer
[7]);
968 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).dirty
= 0;
969 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).valid
= 1;
973 /* r8 to r14, but no spsr */
974 xscale_receive(target
, buffer
, 7);
977 /* move data from buffer to register cache */
978 for (i
= 8; i
<= 14; i
++)
980 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).value
, 0, 32, buffer
[i
- 8]);
981 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).dirty
= 0;
982 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, i
).valid
= 1;
985 /* examine debug reason */
986 xscale_read_dcsr(target
);
987 moe
= buf_get_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 2, 3);
989 /* stored PC (for calculating fixup) */
990 pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
994 case 0x0: /* Processor reset */
995 target
->debug_reason
= DBG_REASON_DBGRQ
;
996 xscale
->arch_debug_reason
= XSCALE_DBG_REASON_RESET
;
999 case 0x1: /* Instruction breakpoint hit */
1000 target
->debug_reason
= DBG_REASON_BREAKPOINT
;
1001 xscale
->arch_debug_reason
= XSCALE_DBG_REASON_GENERIC
;
1004 case 0x2: /* Data breakpoint hit */
1005 target
->debug_reason
= DBG_REASON_WATCHPOINT
;
1006 xscale
->arch_debug_reason
= XSCALE_DBG_REASON_GENERIC
;
1009 case 0x3: /* BKPT instruction executed */
1010 target
->debug_reason
= DBG_REASON_BREAKPOINT
;
1011 xscale
->arch_debug_reason
= XSCALE_DBG_REASON_GENERIC
;
1014 case 0x4: /* Ext. debug event */
1015 target
->debug_reason
= DBG_REASON_DBGRQ
;
1016 xscale
->arch_debug_reason
= XSCALE_DBG_REASON_GENERIC
;
1019 case 0x5: /* Vector trap occured */
1020 target
->debug_reason
= DBG_REASON_BREAKPOINT
;
1021 xscale
->arch_debug_reason
= XSCALE_DBG_REASON_GENERIC
;
1024 case 0x6: /* Trace buffer full break */
1025 target
->debug_reason
= DBG_REASON_DBGRQ
;
1026 xscale
->arch_debug_reason
= XSCALE_DBG_REASON_TB_FULL
;
1029 case 0x7: /* Reserved (may flag Hot-Debug support) */
1031 LOG_ERROR("Method of Entry is 'Reserved'");
1036 /* apply PC fixup */
1037 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, pc
);
1039 /* on the first debug entry, identify cache type */
1040 if (xscale
->armv4_5_mmu
.armv4_5_cache
.ctype
== -1)
1042 uint32_t cache_type_reg
;
1044 /* read cp15 cache type register */
1045 xscale_get_reg(&xscale
->reg_cache
->reg_list
[XSCALE_CACHETYPE
]);
1046 cache_type_reg
= buf_get_u32(xscale
->reg_cache
->reg_list
[XSCALE_CACHETYPE
].value
, 0, 32);
1048 armv4_5_identify_cache(cache_type_reg
, &xscale
->armv4_5_mmu
.armv4_5_cache
);
1051 /* examine MMU and Cache settings */
1052 /* read cp15 control register */
1053 xscale_get_reg(&xscale
->reg_cache
->reg_list
[XSCALE_CTRL
]);
1054 xscale
->cp15_control_reg
= buf_get_u32(xscale
->reg_cache
->reg_list
[XSCALE_CTRL
].value
, 0, 32);
1055 xscale
->armv4_5_mmu
.mmu_enabled
= (xscale
->cp15_control_reg
& 0x1U
) ? 1 : 0;
1056 xscale
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
= (xscale
->cp15_control_reg
& 0x4U
) ? 1 : 0;
1057 xscale
->armv4_5_mmu
.armv4_5_cache
.i_cache_enabled
= (xscale
->cp15_control_reg
& 0x1000U
) ? 1 : 0;
1059 /* tracing enabled, read collected trace data */
1060 if (xscale
->trace
.buffer_enabled
)
1062 xscale_read_trace(target
);
1063 xscale
->trace
.buffer_fill
--;
1065 /* resume if we're still collecting trace data */
1066 if ((xscale
->arch_debug_reason
== XSCALE_DBG_REASON_TB_FULL
)
1067 && (xscale
->trace
.buffer_fill
> 0))
1069 xscale_resume(target
, 1, 0x0, 1, 0);
1073 xscale
->trace
.buffer_enabled
= 0;
1080 static int xscale_halt(struct target
*target
)
1082 struct xscale_common
*xscale
= target_to_xscale(target
);
1084 LOG_DEBUG("target->state: %s",
1085 target_state_name(target
));
1087 if (target
->state
== TARGET_HALTED
)
1089 LOG_DEBUG("target was already halted");
1092 else if (target
->state
== TARGET_UNKNOWN
)
1094 /* this must not happen for a xscale target */
1095 LOG_ERROR("target was in unknown state when halt was requested");
1096 return ERROR_TARGET_INVALID
;
1098 else if (target
->state
== TARGET_RESET
)
1100 LOG_DEBUG("target->state == TARGET_RESET");
1104 /* assert external dbg break */
1105 xscale
->external_debug_break
= 1;
1106 xscale_read_dcsr(target
);
1108 target
->debug_reason
= DBG_REASON_DBGRQ
;
1114 static int xscale_enable_single_step(struct target
*target
, uint32_t next_pc
)
1116 struct xscale_common
*xscale
= target_to_xscale(target
);
1117 struct reg
*ibcr0
= &xscale
->reg_cache
->reg_list
[XSCALE_IBCR0
];
1120 if (xscale
->ibcr0_used
)
1122 struct breakpoint
*ibcr0_bp
= breakpoint_find(target
, buf_get_u32(ibcr0
->value
, 0, 32) & 0xfffffffe);
1126 xscale_unset_breakpoint(target
, ibcr0_bp
);
1130 LOG_ERROR("BUG: xscale->ibcr0_used is set, but no breakpoint with that address found");
1135 if ((retval
= xscale_set_reg_u32(ibcr0
, next_pc
| 0x1)) != ERROR_OK
)
1141 static int xscale_disable_single_step(struct target
*target
)
1143 struct xscale_common
*xscale
= target_to_xscale(target
);
1144 struct reg
*ibcr0
= &xscale
->reg_cache
->reg_list
[XSCALE_IBCR0
];
1147 if ((retval
= xscale_set_reg_u32(ibcr0
, 0x0)) != ERROR_OK
)
1153 static void xscale_enable_watchpoints(struct target
*target
)
1155 struct watchpoint
*watchpoint
= target
->watchpoints
;
1159 if (watchpoint
->set
== 0)
1160 xscale_set_watchpoint(target
, watchpoint
);
1161 watchpoint
= watchpoint
->next
;
1165 static void xscale_enable_breakpoints(struct target
*target
)
1167 struct breakpoint
*breakpoint
= target
->breakpoints
;
1169 /* set any pending breakpoints */
1172 if (breakpoint
->set
== 0)
1173 xscale_set_breakpoint(target
, breakpoint
);
1174 breakpoint
= breakpoint
->next
;
1178 static int xscale_resume(struct target
*target
, int current
,
1179 uint32_t address
, int handle_breakpoints
, int debug_execution
)
1181 struct xscale_common
*xscale
= target_to_xscale(target
);
1182 struct armv4_5_common_s
*armv4_5
= &xscale
->armv4_5_common
;
1183 struct breakpoint
*breakpoint
= target
->breakpoints
;
1184 uint32_t current_pc
;
1190 if (target
->state
!= TARGET_HALTED
)
1192 LOG_WARNING("target not halted");
1193 return ERROR_TARGET_NOT_HALTED
;
1196 if (!debug_execution
)
1198 target_free_all_working_areas(target
);
1201 /* update vector tables */
1202 if ((retval
= xscale_update_vectors(target
)) != ERROR_OK
)
1205 /* current = 1: continue on current pc, otherwise continue at <address> */
1207 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, address
);
1209 current_pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
1211 /* if we're at the reset vector, we have to simulate the branch */
1212 if (current_pc
== 0x0)
1214 arm_simulate_step(target
, NULL
);
1215 current_pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
1218 /* the front-end may request us not to handle breakpoints */
1219 if (handle_breakpoints
)
1221 if ((breakpoint
= breakpoint_find(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32))))
1225 /* there's a breakpoint at the current PC, we have to step over it */
1226 LOG_DEBUG("unset breakpoint at 0x%8.8" PRIx32
"", breakpoint
->address
);
1227 xscale_unset_breakpoint(target
, breakpoint
);
1229 /* calculate PC of next instruction */
1230 if ((retval
= arm_simulate_step(target
, &next_pc
)) != ERROR_OK
)
1232 uint32_t current_opcode
;
1233 target_read_u32(target
, current_pc
, ¤t_opcode
);
1234 LOG_ERROR("BUG: couldn't calculate PC of next instruction, current opcode was 0x%8.8" PRIx32
"", current_opcode
);
1237 LOG_DEBUG("enable single-step");
1238 xscale_enable_single_step(target
, next_pc
);
1240 /* restore banked registers */
1241 xscale_restore_context(target
);
1243 /* send resume request (command 0x30 or 0x31)
1244 * clean the trace buffer if it is to be enabled (0x62) */
1245 if (xscale
->trace
.buffer_enabled
)
1247 xscale_send_u32(target
, 0x62);
1248 xscale_send_u32(target
, 0x31);
1251 xscale_send_u32(target
, 0x30);
1254 xscale_send_u32(target
,
1255 buf_get_u32(armv4_5
->cpsr
->value
, 0, 32));
1256 LOG_DEBUG("writing cpsr with value 0x%8.8" PRIx32
,
1257 buf_get_u32(armv4_5
->cpsr
->value
, 0, 32));
1259 for (i
= 7; i
>= 0; i
--)
1262 xscale_send_u32(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[i
].value
, 0, 32));
1263 LOG_DEBUG("writing r%i with value 0x%8.8" PRIx32
"", i
, buf_get_u32(armv4_5
->core_cache
->reg_list
[i
].value
, 0, 32));
1267 xscale_send_u32(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1268 LOG_DEBUG("writing PC with value 0x%8.8" PRIx32
"", buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1270 /* wait for and process debug entry */
1271 xscale_debug_entry(target
);
1273 LOG_DEBUG("disable single-step");
1274 xscale_disable_single_step(target
);
1276 LOG_DEBUG("set breakpoint at 0x%8.8" PRIx32
"", breakpoint
->address
);
1277 xscale_set_breakpoint(target
, breakpoint
);
1281 /* enable any pending breakpoints and watchpoints */
1282 xscale_enable_breakpoints(target
);
1283 xscale_enable_watchpoints(target
);
1285 /* restore banked registers */
1286 xscale_restore_context(target
);
1288 /* send resume request (command 0x30 or 0x31)
1289 * clean the trace buffer if it is to be enabled (0x62) */
1290 if (xscale
->trace
.buffer_enabled
)
1292 xscale_send_u32(target
, 0x62);
1293 xscale_send_u32(target
, 0x31);
1296 xscale_send_u32(target
, 0x30);
1299 xscale_send_u32(target
, buf_get_u32(armv4_5
->cpsr
->value
, 0, 32));
1300 LOG_DEBUG("writing cpsr with value 0x%8.8" PRIx32
,
1301 buf_get_u32(armv4_5
->cpsr
->value
, 0, 32));
1303 for (i
= 7; i
>= 0; i
--)
1306 xscale_send_u32(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[i
].value
, 0, 32));
1307 LOG_DEBUG("writing r%i with value 0x%8.8" PRIx32
"", i
, buf_get_u32(armv4_5
->core_cache
->reg_list
[i
].value
, 0, 32));
1311 xscale_send_u32(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1312 LOG_DEBUG("writing PC with value 0x%8.8" PRIx32
"", buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1314 target
->debug_reason
= DBG_REASON_NOTHALTED
;
1316 if (!debug_execution
)
1318 /* registers are now invalid */
1319 register_cache_invalidate(armv4_5
->core_cache
);
1320 target
->state
= TARGET_RUNNING
;
1321 target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
);
1325 target
->state
= TARGET_DEBUG_RUNNING
;
1326 target_call_event_callbacks(target
, TARGET_EVENT_DEBUG_RESUMED
);
1329 LOG_DEBUG("target resumed");
1334 static int xscale_step_inner(struct target
*target
, int current
,
1335 uint32_t address
, int handle_breakpoints
)
1337 struct xscale_common
*xscale
= target_to_xscale(target
);
1338 struct armv4_5_common_s
*armv4_5
= &xscale
->armv4_5_common
;
1343 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
1345 /* calculate PC of next instruction */
1346 if ((retval
= arm_simulate_step(target
, &next_pc
)) != ERROR_OK
)
1348 uint32_t current_opcode
, current_pc
;
1349 current_pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
1351 target_read_u32(target
, current_pc
, ¤t_opcode
);
1352 LOG_ERROR("BUG: couldn't calculate PC of next instruction, current opcode was 0x%8.8" PRIx32
"", current_opcode
);
1356 LOG_DEBUG("enable single-step");
1357 if ((retval
= xscale_enable_single_step(target
, next_pc
)) != ERROR_OK
)
1360 /* restore banked registers */
1361 if ((retval
= xscale_restore_context(target
)) != ERROR_OK
)
1364 /* send resume request (command 0x30 or 0x31)
1365 * clean the trace buffer if it is to be enabled (0x62) */
1366 if (xscale
->trace
.buffer_enabled
)
1368 if ((retval
= xscale_send_u32(target
, 0x62)) != ERROR_OK
)
1370 if ((retval
= xscale_send_u32(target
, 0x31)) != ERROR_OK
)
1374 if ((retval
= xscale_send_u32(target
, 0x30)) != ERROR_OK
)
1378 retval
= xscale_send_u32(target
,
1379 buf_get_u32(armv4_5
->cpsr
->value
, 0, 32));
1380 if (retval
!= ERROR_OK
)
1382 LOG_DEBUG("writing cpsr with value 0x%8.8" PRIx32
,
1383 buf_get_u32(armv4_5
->cpsr
->value
, 0, 32));
1385 for (i
= 7; i
>= 0; i
--)
1388 if ((retval
= xscale_send_u32(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[i
].value
, 0, 32))) != ERROR_OK
)
1390 LOG_DEBUG("writing r%i with value 0x%8.8" PRIx32
"", i
, buf_get_u32(armv4_5
->core_cache
->reg_list
[i
].value
, 0, 32));
1394 if ((retval
= xscale_send_u32(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32))) != ERROR_OK
)
1396 LOG_DEBUG("writing PC with value 0x%8.8" PRIx32
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32));
1398 target_call_event_callbacks(target
, TARGET_EVENT_RESUMED
);
1400 /* registers are now invalid */
1401 register_cache_invalidate(armv4_5
->core_cache
);
1403 /* wait for and process debug entry */
1404 if ((retval
= xscale_debug_entry(target
)) != ERROR_OK
)
1407 LOG_DEBUG("disable single-step");
1408 if ((retval
= xscale_disable_single_step(target
)) != ERROR_OK
)
1411 target_call_event_callbacks(target
, TARGET_EVENT_HALTED
);
1416 static int xscale_step(struct target
*target
, int current
,
1417 uint32_t address
, int handle_breakpoints
)
1419 struct armv4_5_common_s
*armv4_5
= target_to_armv4_5(target
);
1420 struct breakpoint
*breakpoint
= target
->breakpoints
;
1422 uint32_t current_pc
;
1425 if (target
->state
!= TARGET_HALTED
)
1427 LOG_WARNING("target not halted");
1428 return ERROR_TARGET_NOT_HALTED
;
1431 /* current = 1: continue on current pc, otherwise continue at <address> */
1433 buf_set_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32, address
);
1435 current_pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
1437 /* if we're at the reset vector, we have to simulate the step */
1438 if (current_pc
== 0x0)
1440 if ((retval
= arm_simulate_step(target
, NULL
)) != ERROR_OK
)
1442 current_pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
1444 target
->debug_reason
= DBG_REASON_SINGLESTEP
;
1445 target_call_event_callbacks(target
, TARGET_EVENT_HALTED
);
1450 /* the front-end may request us not to handle breakpoints */
1451 if (handle_breakpoints
)
1452 if ((breakpoint
= breakpoint_find(target
, buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32))))
1454 if ((retval
= xscale_unset_breakpoint(target
, breakpoint
)) != ERROR_OK
)
1458 retval
= xscale_step_inner(target
, current
, address
, handle_breakpoints
);
1462 xscale_set_breakpoint(target
, breakpoint
);
1465 LOG_DEBUG("target stepped");
1471 static int xscale_assert_reset(struct target
*target
)
1473 struct xscale_common
*xscale
= target_to_xscale(target
);
1475 LOG_DEBUG("target->state: %s",
1476 target_state_name(target
));
1478 /* select DCSR instruction (set endstate to R-T-I to ensure we don't
1479 * end up in T-L-R, which would reset JTAG
1481 jtag_set_end_state(TAP_IDLE
);
1482 xscale_jtag_set_instr(target
->tap
, XSCALE_SELDCSR
);
1484 /* set Hold reset, Halt mode and Trap Reset */
1485 buf_set_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 30, 1, 0x1);
1486 buf_set_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 16, 1, 0x1);
1487 xscale_write_dcsr(target
, 1, 0);
1489 /* select BYPASS, because having DCSR selected caused problems on the PXA27x */
1490 xscale_jtag_set_instr(target
->tap
, 0x7f);
1491 jtag_execute_queue();
1494 jtag_add_reset(0, 1);
1496 /* sleep 1ms, to be sure we fulfill any requirements */
1497 jtag_add_sleep(1000);
1498 jtag_execute_queue();
1500 target
->state
= TARGET_RESET
;
1502 if (target
->reset_halt
)
1505 if ((retval
= target_halt(target
)) != ERROR_OK
)
1512 static int xscale_deassert_reset(struct target
*target
)
1514 struct xscale_common
*xscale
= target_to_xscale(target
);
1515 struct breakpoint
*breakpoint
= target
->breakpoints
;
1519 xscale
->ibcr_available
= 2;
1520 xscale
->ibcr0_used
= 0;
1521 xscale
->ibcr1_used
= 0;
1523 xscale
->dbr_available
= 2;
1524 xscale
->dbr0_used
= 0;
1525 xscale
->dbr1_used
= 0;
1527 /* mark all hardware breakpoints as unset */
1530 if (breakpoint
->type
== BKPT_HARD
)
1532 breakpoint
->set
= 0;
1534 breakpoint
= breakpoint
->next
;
1537 register_cache_invalidate(xscale
->armv4_5_common
.core_cache
);
1539 /* FIXME mark hardware watchpoints got unset too. Also,
1540 * at least some of the XScale registers are invalid...
1544 * REVISIT: *assumes* we had a SRST+TRST reset so the mini-icache
1545 * contents got invalidated. Safer to force that, so writing new
1546 * contents can't ever fail..
1551 const uint8_t *buffer
= xscale_debug_handler
;
1555 jtag_add_reset(0, 0);
1557 /* wait 300ms; 150 and 100ms were not enough */
1558 jtag_add_sleep(300*1000);
1560 jtag_add_runtest(2030, jtag_set_end_state(TAP_IDLE
));
1561 jtag_execute_queue();
1563 /* set Hold reset, Halt mode and Trap Reset */
1564 buf_set_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 30, 1, 0x1);
1565 buf_set_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 16, 1, 0x1);
1566 xscale_write_dcsr(target
, 1, 0);
1568 /* Load the debug handler into the mini-icache. Since
1569 * it's using halt mode (not monitor mode), it runs in
1570 * "Special Debug State" for access to registers, memory,
1571 * coprocessors, trace data, etc.
1573 address
= xscale
->handler_address
;
1574 for (unsigned binary_size
= sizeof xscale_debug_handler
- 1;
1576 binary_size
-= buf_cnt
, buffer
+= buf_cnt
)
1578 uint32_t cache_line
[8];
1581 buf_cnt
= binary_size
;
1585 for (i
= 0; i
< buf_cnt
; i
+= 4)
1587 /* convert LE buffer to host-endian uint32_t */
1588 cache_line
[i
/ 4] = le_to_h_u32(&buffer
[i
]);
1591 for (; i
< 32; i
+= 4)
1593 cache_line
[i
/ 4] = 0xe1a08008;
1596 /* only load addresses other than the reset vectors */
1597 if ((address
% 0x400) != 0x0)
1599 retval
= xscale_load_ic(target
, address
,
1601 if (retval
!= ERROR_OK
)
1608 retval
= xscale_load_ic(target
, 0x0,
1609 xscale
->low_vectors
);
1610 if (retval
!= ERROR_OK
)
1612 retval
= xscale_load_ic(target
, 0xffff0000,
1613 xscale
->high_vectors
);
1614 if (retval
!= ERROR_OK
)
1617 jtag_add_runtest(30, jtag_set_end_state(TAP_IDLE
));
1619 jtag_add_sleep(100000);
1621 /* set Hold reset, Halt mode and Trap Reset */
1622 buf_set_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 30, 1, 0x1);
1623 buf_set_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 16, 1, 0x1);
1624 xscale_write_dcsr(target
, 1, 0);
1626 /* clear Hold reset to let the target run (should enter debug handler) */
1627 xscale_write_dcsr(target
, 0, 1);
1628 target
->state
= TARGET_RUNNING
;
1630 if (!target
->reset_halt
)
1632 jtag_add_sleep(10000);
1634 /* we should have entered debug now */
1635 xscale_debug_entry(target
);
1636 target
->state
= TARGET_HALTED
;
1638 /* resume the target */
1639 xscale_resume(target
, 1, 0x0, 1, 0);
1646 static int xscale_read_core_reg(struct target
*target
, struct reg
*r
,
1647 int num
, enum armv4_5_mode mode
)
1649 /** \todo add debug handler support for core register reads */
1650 LOG_ERROR("not implemented");
1654 static int xscale_write_core_reg(struct target
*target
, struct reg
*r
,
1655 int num
, enum armv4_5_mode mode
, uint32_t value
)
1657 /** \todo add debug handler support for core register writes */
1658 LOG_ERROR("not implemented");
1662 static int xscale_full_context(struct target
*target
)
1664 struct armv4_5_common_s
*armv4_5
= target_to_armv4_5(target
);
1672 if (target
->state
!= TARGET_HALTED
)
1674 LOG_WARNING("target not halted");
1675 return ERROR_TARGET_NOT_HALTED
;
1678 buffer
= malloc(4 * 8);
1680 /* iterate through processor modes (FIQ, IRQ, SVC, ABT, UND and SYS)
1681 * we can't enter User mode on an XScale (unpredictable),
1682 * but User shares registers with SYS
1684 for (i
= 1; i
< 7; i
++)
1688 /* check if there are invalid registers in the current mode
1690 for (j
= 0; j
<= 16; j
++)
1692 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
== 0)
1700 /* request banked registers */
1701 xscale_send_u32(target
, 0x0);
1704 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1705 tmp_cpsr
|= 0xc0; /* I/F bits */
1707 /* send CPSR for desired mode */
1708 xscale_send_u32(target
, tmp_cpsr
);
1710 /* get banked registers, r8 to r14, and spsr if not in USR/SYS mode */
1711 if ((armv4_5_number_to_mode(i
) != ARMV4_5_MODE_USR
) && (armv4_5_number_to_mode(i
) != ARMV4_5_MODE_SYS
))
1713 xscale_receive(target
, buffer
, 8);
1714 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).value
, 0, 32, buffer
[7]);
1715 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).dirty
= 0;
1716 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).valid
= 1;
1720 xscale_receive(target
, buffer
, 7);
1723 /* move data from buffer to register cache */
1724 for (j
= 8; j
<= 14; j
++)
1726 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).value
, 0, 32, buffer
[j
- 8]);
1727 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).dirty
= 0;
1728 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).valid
= 1;
1738 static int xscale_restore_context(struct target
*target
)
1740 struct armv4_5_common_s
*armv4_5
= target_to_armv4_5(target
);
1744 if (target
->state
!= TARGET_HALTED
)
1746 LOG_WARNING("target not halted");
1747 return ERROR_TARGET_NOT_HALTED
;
1750 /* iterate through processor modes (FIQ, IRQ, SVC, ABT, UND and SYS)
1751 * we can't enter User mode on an XScale (unpredictable),
1752 * but User shares registers with SYS
1754 for (i
= 1; i
< 7; i
++)
1758 /* check if there are invalid registers in the current mode
1760 for (j
= 8; j
<= 14; j
++)
1762 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).dirty
== 1)
1766 /* if not USR/SYS, check if the SPSR needs to be written */
1767 if ((armv4_5_number_to_mode(i
) != ARMV4_5_MODE_USR
) && (armv4_5_number_to_mode(i
) != ARMV4_5_MODE_SYS
))
1769 if (ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).dirty
== 1)
1777 /* send banked registers */
1778 xscale_send_u32(target
, 0x1);
1781 tmp_cpsr
|= armv4_5_number_to_mode(i
);
1782 tmp_cpsr
|= 0xc0; /* I/F bits */
1784 /* send CPSR for desired mode */
1785 xscale_send_u32(target
, tmp_cpsr
);
1787 /* send banked registers, r8 to r14, and spsr if not in USR/SYS mode */
1788 for (j
= 8; j
<= 14; j
++)
1790 xscale_send_u32(target
, buf_get_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, j
).value
, 0, 32));
1791 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), j
).dirty
= 0;
1794 if ((armv4_5_number_to_mode(i
) != ARMV4_5_MODE_USR
) && (armv4_5_number_to_mode(i
) != ARMV4_5_MODE_SYS
))
1796 xscale_send_u32(target
, buf_get_u32(ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5
->core_mode
, 16).value
, 0, 32));
1797 ARMV4_5_CORE_REG_MODE(armv4_5
->core_cache
, armv4_5_number_to_mode(i
), 16).dirty
= 0;
1805 static int xscale_read_memory(struct target
*target
, uint32_t address
,
1806 uint32_t size
, uint32_t count
, uint8_t *buffer
)
1808 struct xscale_common
*xscale
= target_to_xscale(target
);
1813 LOG_DEBUG("address: 0x%8.8" PRIx32
", size: 0x%8.8" PRIx32
", count: 0x%8.8" PRIx32
, address
, size
, count
);
1815 if (target
->state
!= TARGET_HALTED
)
1817 LOG_WARNING("target not halted");
1818 return ERROR_TARGET_NOT_HALTED
;
1821 /* sanitize arguments */
1822 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
1823 return ERROR_INVALID_ARGUMENTS
;
1825 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
1826 return ERROR_TARGET_UNALIGNED_ACCESS
;
1828 /* send memory read request (command 0x1n, n: access size) */
1829 if ((retval
= xscale_send_u32(target
, 0x10 | size
)) != ERROR_OK
)
1832 /* send base address for read request */
1833 if ((retval
= xscale_send_u32(target
, address
)) != ERROR_OK
)
1836 /* send number of requested data words */
1837 if ((retval
= xscale_send_u32(target
, count
)) != ERROR_OK
)
1840 /* receive data from target (count times 32-bit words in host endianness) */
1841 buf32
= malloc(4 * count
);
1842 if ((retval
= xscale_receive(target
, buf32
, count
)) != ERROR_OK
)
1845 /* extract data from host-endian buffer into byte stream */
1846 for (i
= 0; i
< count
; i
++)
1851 target_buffer_set_u32(target
, buffer
, buf32
[i
]);
1855 target_buffer_set_u16(target
, buffer
, buf32
[i
] & 0xffff);
1859 *buffer
++ = buf32
[i
] & 0xff;
1862 LOG_ERROR("invalid read size");
1863 return ERROR_INVALID_ARGUMENTS
;
1869 /* examine DCSR, to see if Sticky Abort (SA) got set */
1870 if ((retval
= xscale_read_dcsr(target
)) != ERROR_OK
)
1872 if (buf_get_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 5, 1) == 1)
1875 if ((retval
= xscale_send_u32(target
, 0x60)) != ERROR_OK
)
1878 return ERROR_TARGET_DATA_ABORT
;
1884 static int xscale_write_memory(struct target
*target
, uint32_t address
,
1885 uint32_t size
, uint32_t count
, uint8_t *buffer
)
1887 struct xscale_common
*xscale
= target_to_xscale(target
);
1890 LOG_DEBUG("address: 0x%8.8" PRIx32
", size: 0x%8.8" PRIx32
", count: 0x%8.8" PRIx32
, address
, size
, count
);
1892 if (target
->state
!= TARGET_HALTED
)
1894 LOG_WARNING("target not halted");
1895 return ERROR_TARGET_NOT_HALTED
;
1898 /* sanitize arguments */
1899 if (((size
!= 4) && (size
!= 2) && (size
!= 1)) || (count
== 0) || !(buffer
))
1900 return ERROR_INVALID_ARGUMENTS
;
1902 if (((size
== 4) && (address
& 0x3u
)) || ((size
== 2) && (address
& 0x1u
)))
1903 return ERROR_TARGET_UNALIGNED_ACCESS
;
1905 /* send memory write request (command 0x2n, n: access size) */
1906 if ((retval
= xscale_send_u32(target
, 0x20 | size
)) != ERROR_OK
)
1909 /* send base address for read request */
1910 if ((retval
= xscale_send_u32(target
, address
)) != ERROR_OK
)
1913 /* send number of requested data words to be written*/
1914 if ((retval
= xscale_send_u32(target
, count
)) != ERROR_OK
)
1917 /* extract data from host-endian buffer into byte stream */
1919 for (i
= 0; i
< count
; i
++)
1924 value
= target_buffer_get_u32(target
, buffer
);
1925 xscale_send_u32(target
, value
);
1929 value
= target_buffer_get_u16(target
, buffer
);
1930 xscale_send_u32(target
, value
);
1935 xscale_send_u32(target
, value
);
1939 LOG_ERROR("should never get here");
1944 if ((retval
= xscale_send(target
, buffer
, count
, size
)) != ERROR_OK
)
1947 /* examine DCSR, to see if Sticky Abort (SA) got set */
1948 if ((retval
= xscale_read_dcsr(target
)) != ERROR_OK
)
1950 if (buf_get_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 5, 1) == 1)
1953 if ((retval
= xscale_send_u32(target
, 0x60)) != ERROR_OK
)
1956 return ERROR_TARGET_DATA_ABORT
;
1962 static int xscale_bulk_write_memory(struct target
*target
, uint32_t address
,
1963 uint32_t count
, uint8_t *buffer
)
1965 return xscale_write_memory(target
, address
, 4, count
, buffer
);
1968 static uint32_t xscale_get_ttb(struct target
*target
)
1970 struct xscale_common
*xscale
= target_to_xscale(target
);
1973 xscale_get_reg(&xscale
->reg_cache
->reg_list
[XSCALE_TTB
]);
1974 ttb
= buf_get_u32(xscale
->reg_cache
->reg_list
[XSCALE_TTB
].value
, 0, 32);
1979 static void xscale_disable_mmu_caches(struct target
*target
, int mmu
,
1980 int d_u_cache
, int i_cache
)
1982 struct xscale_common
*xscale
= target_to_xscale(target
);
1983 uint32_t cp15_control
;
1985 /* read cp15 control register */
1986 xscale_get_reg(&xscale
->reg_cache
->reg_list
[XSCALE_CTRL
]);
1987 cp15_control
= buf_get_u32(xscale
->reg_cache
->reg_list
[XSCALE_CTRL
].value
, 0, 32);
1990 cp15_control
&= ~0x1U
;
1995 xscale_send_u32(target
, 0x50);
1996 xscale_send_u32(target
, xscale
->cache_clean_address
);
1998 /* invalidate DCache */
1999 xscale_send_u32(target
, 0x51);
2001 cp15_control
&= ~0x4U
;
2006 /* invalidate ICache */
2007 xscale_send_u32(target
, 0x52);
2008 cp15_control
&= ~0x1000U
;
2011 /* write new cp15 control register */
2012 xscale_set_reg_u32(&xscale
->reg_cache
->reg_list
[XSCALE_CTRL
], cp15_control
);
2014 /* execute cpwait to ensure outstanding operations complete */
2015 xscale_send_u32(target
, 0x53);
2018 static void xscale_enable_mmu_caches(struct target
*target
, int mmu
,
2019 int d_u_cache
, int i_cache
)
2021 struct xscale_common
*xscale
= target_to_xscale(target
);
2022 uint32_t cp15_control
;
2024 /* read cp15 control register */
2025 xscale_get_reg(&xscale
->reg_cache
->reg_list
[XSCALE_CTRL
]);
2026 cp15_control
= buf_get_u32(xscale
->reg_cache
->reg_list
[XSCALE_CTRL
].value
, 0, 32);
2029 cp15_control
|= 0x1U
;
2032 cp15_control
|= 0x4U
;
2035 cp15_control
|= 0x1000U
;
2037 /* write new cp15 control register */
2038 xscale_set_reg_u32(&xscale
->reg_cache
->reg_list
[XSCALE_CTRL
], cp15_control
);
2040 /* execute cpwait to ensure outstanding operations complete */
2041 xscale_send_u32(target
, 0x53);
2044 static int xscale_set_breakpoint(struct target
*target
,
2045 struct breakpoint
*breakpoint
)
2048 struct xscale_common
*xscale
= target_to_xscale(target
);
2050 if (target
->state
!= TARGET_HALTED
)
2052 LOG_WARNING("target not halted");
2053 return ERROR_TARGET_NOT_HALTED
;
2056 if (breakpoint
->set
)
2058 LOG_WARNING("breakpoint already set");
2062 if (breakpoint
->type
== BKPT_HARD
)
2064 uint32_t value
= breakpoint
->address
| 1;
2065 if (!xscale
->ibcr0_used
)
2067 xscale_set_reg_u32(&xscale
->reg_cache
->reg_list
[XSCALE_IBCR0
], value
);
2068 xscale
->ibcr0_used
= 1;
2069 breakpoint
->set
= 1; /* breakpoint set on first breakpoint register */
2071 else if (!xscale
->ibcr1_used
)
2073 xscale_set_reg_u32(&xscale
->reg_cache
->reg_list
[XSCALE_IBCR1
], value
);
2074 xscale
->ibcr1_used
= 1;
2075 breakpoint
->set
= 2; /* breakpoint set on second breakpoint register */
2079 LOG_ERROR("BUG: no hardware comparator available");
2083 else if (breakpoint
->type
== BKPT_SOFT
)
2085 if (breakpoint
->length
== 4)
2087 /* keep the original instruction in target endianness */
2088 if ((retval
= target_read_memory(target
, breakpoint
->address
, 4, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
2092 /* write the original instruction in target endianness (arm7_9->arm_bkpt is host endian) */
2093 if ((retval
= target_write_u32(target
, breakpoint
->address
, xscale
->arm_bkpt
)) != ERROR_OK
)
2100 /* keep the original instruction in target endianness */
2101 if ((retval
= target_read_memory(target
, breakpoint
->address
, 2, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
2105 /* write the original instruction in target endianness (arm7_9->arm_bkpt is host endian) */
2106 if ((retval
= target_write_u32(target
, breakpoint
->address
, xscale
->thumb_bkpt
)) != ERROR_OK
)
2111 breakpoint
->set
= 1;
2117 static int xscale_add_breakpoint(struct target
*target
,
2118 struct breakpoint
*breakpoint
)
2120 struct xscale_common
*xscale
= target_to_xscale(target
);
2122 if (target
->state
!= TARGET_HALTED
)
2124 LOG_WARNING("target not halted");
2125 return ERROR_TARGET_NOT_HALTED
;
2128 if ((breakpoint
->type
== BKPT_HARD
) && (xscale
->ibcr_available
< 1))
2130 LOG_INFO("no breakpoint unit available for hardware breakpoint");
2131 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
2134 if ((breakpoint
->length
!= 2) && (breakpoint
->length
!= 4))
2136 LOG_INFO("only breakpoints of two (Thumb) or four (ARM) bytes length supported");
2137 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
2140 if (breakpoint
->type
== BKPT_HARD
)
2142 xscale
->ibcr_available
--;
2148 static int xscale_unset_breakpoint(struct target
*target
,
2149 struct breakpoint
*breakpoint
)
2152 struct xscale_common
*xscale
= target_to_xscale(target
);
2154 if (target
->state
!= TARGET_HALTED
)
2156 LOG_WARNING("target not halted");
2157 return ERROR_TARGET_NOT_HALTED
;
2160 if (!breakpoint
->set
)
2162 LOG_WARNING("breakpoint not set");
2166 if (breakpoint
->type
== BKPT_HARD
)
2168 if (breakpoint
->set
== 1)
2170 xscale_set_reg_u32(&xscale
->reg_cache
->reg_list
[XSCALE_IBCR0
], 0x0);
2171 xscale
->ibcr0_used
= 0;
2173 else if (breakpoint
->set
== 2)
2175 xscale_set_reg_u32(&xscale
->reg_cache
->reg_list
[XSCALE_IBCR1
], 0x0);
2176 xscale
->ibcr1_used
= 0;
2178 breakpoint
->set
= 0;
2182 /* restore original instruction (kept in target endianness) */
2183 if (breakpoint
->length
== 4)
2185 if ((retval
= target_write_memory(target
, breakpoint
->address
, 4, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
2192 if ((retval
= target_write_memory(target
, breakpoint
->address
, 2, 1, breakpoint
->orig_instr
)) != ERROR_OK
)
2197 breakpoint
->set
= 0;
2203 static int xscale_remove_breakpoint(struct target
*target
, struct breakpoint
*breakpoint
)
2205 struct xscale_common
*xscale
= target_to_xscale(target
);
2207 if (target
->state
!= TARGET_HALTED
)
2209 LOG_WARNING("target not halted");
2210 return ERROR_TARGET_NOT_HALTED
;
2213 if (breakpoint
->set
)
2215 xscale_unset_breakpoint(target
, breakpoint
);
2218 if (breakpoint
->type
== BKPT_HARD
)
2219 xscale
->ibcr_available
++;
2224 static int xscale_set_watchpoint(struct target
*target
,
2225 struct watchpoint
*watchpoint
)
2227 struct xscale_common
*xscale
= target_to_xscale(target
);
2229 struct reg
*dbcon
= &xscale
->reg_cache
->reg_list
[XSCALE_DBCON
];
2230 uint32_t dbcon_value
= buf_get_u32(dbcon
->value
, 0, 32);
2232 if (target
->state
!= TARGET_HALTED
)
2234 LOG_WARNING("target not halted");
2235 return ERROR_TARGET_NOT_HALTED
;
2238 xscale_get_reg(dbcon
);
2240 switch (watchpoint
->rw
)
2252 LOG_ERROR("BUG: watchpoint->rw neither read, write nor access");
2255 if (!xscale
->dbr0_used
)
2257 xscale_set_reg_u32(&xscale
->reg_cache
->reg_list
[XSCALE_DBR0
], watchpoint
->address
);
2258 dbcon_value
|= enable
;
2259 xscale_set_reg_u32(dbcon
, dbcon_value
);
2260 watchpoint
->set
= 1;
2261 xscale
->dbr0_used
= 1;
2263 else if (!xscale
->dbr1_used
)
2265 xscale_set_reg_u32(&xscale
->reg_cache
->reg_list
[XSCALE_DBR1
], watchpoint
->address
);
2266 dbcon_value
|= enable
<< 2;
2267 xscale_set_reg_u32(dbcon
, dbcon_value
);
2268 watchpoint
->set
= 2;
2269 xscale
->dbr1_used
= 1;
2273 LOG_ERROR("BUG: no hardware comparator available");
2280 static int xscale_add_watchpoint(struct target
*target
,
2281 struct watchpoint
*watchpoint
)
2283 struct xscale_common
*xscale
= target_to_xscale(target
);
2285 if (target
->state
!= TARGET_HALTED
)
2287 LOG_WARNING("target not halted");
2288 return ERROR_TARGET_NOT_HALTED
;
2291 if (xscale
->dbr_available
< 1)
2293 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
2296 if ((watchpoint
->length
!= 1) && (watchpoint
->length
!= 2) && (watchpoint
->length
!= 4))
2298 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
2301 xscale
->dbr_available
--;
2306 static int xscale_unset_watchpoint(struct target
*target
,
2307 struct watchpoint
*watchpoint
)
2309 struct xscale_common
*xscale
= target_to_xscale(target
);
2310 struct reg
*dbcon
= &xscale
->reg_cache
->reg_list
[XSCALE_DBCON
];
2311 uint32_t dbcon_value
= buf_get_u32(dbcon
->value
, 0, 32);
2313 if (target
->state
!= TARGET_HALTED
)
2315 LOG_WARNING("target not halted");
2316 return ERROR_TARGET_NOT_HALTED
;
2319 if (!watchpoint
->set
)
2321 LOG_WARNING("breakpoint not set");
2325 if (watchpoint
->set
== 1)
2327 dbcon_value
&= ~0x3;
2328 xscale_set_reg_u32(dbcon
, dbcon_value
);
2329 xscale
->dbr0_used
= 0;
2331 else if (watchpoint
->set
== 2)
2333 dbcon_value
&= ~0xc;
2334 xscale_set_reg_u32(dbcon
, dbcon_value
);
2335 xscale
->dbr1_used
= 0;
2337 watchpoint
->set
= 0;
2342 static int xscale_remove_watchpoint(struct target
*target
, struct watchpoint
*watchpoint
)
2344 struct xscale_common
*xscale
= target_to_xscale(target
);
2346 if (target
->state
!= TARGET_HALTED
)
2348 LOG_WARNING("target not halted");
2349 return ERROR_TARGET_NOT_HALTED
;
2352 if (watchpoint
->set
)
2354 xscale_unset_watchpoint(target
, watchpoint
);
2357 xscale
->dbr_available
++;
2362 static int xscale_get_reg(struct reg
*reg
)
2364 struct xscale_reg
*arch_info
= reg
->arch_info
;
2365 struct target
*target
= arch_info
->target
;
2366 struct xscale_common
*xscale
= target_to_xscale(target
);
2368 /* DCSR, TX and RX are accessible via JTAG */
2369 if (strcmp(reg
->name
, "XSCALE_DCSR") == 0)
2371 return xscale_read_dcsr(arch_info
->target
);
2373 else if (strcmp(reg
->name
, "XSCALE_TX") == 0)
2375 /* 1 = consume register content */
2376 return xscale_read_tx(arch_info
->target
, 1);
2378 else if (strcmp(reg
->name
, "XSCALE_RX") == 0)
2380 /* can't read from RX register (host -> debug handler) */
2383 else if (strcmp(reg
->name
, "XSCALE_TXRXCTRL") == 0)
2385 /* can't (explicitly) read from TXRXCTRL register */
2388 else /* Other DBG registers have to be transfered by the debug handler */
2390 /* send CP read request (command 0x40) */
2391 xscale_send_u32(target
, 0x40);
2393 /* send CP register number */
2394 xscale_send_u32(target
, arch_info
->dbg_handler_number
);
2396 /* read register value */
2397 xscale_read_tx(target
, 1);
2398 buf_cpy(xscale
->reg_cache
->reg_list
[XSCALE_TX
].value
, reg
->value
, 32);
2407 static int xscale_set_reg(struct reg
*reg
, uint8_t* buf
)
2409 struct xscale_reg
*arch_info
= reg
->arch_info
;
2410 struct target
*target
= arch_info
->target
;
2411 struct xscale_common
*xscale
= target_to_xscale(target
);
2412 uint32_t value
= buf_get_u32(buf
, 0, 32);
2414 /* DCSR, TX and RX are accessible via JTAG */
2415 if (strcmp(reg
->name
, "XSCALE_DCSR") == 0)
2417 buf_set_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 0, 32, value
);
2418 return xscale_write_dcsr(arch_info
->target
, -1, -1);
2420 else if (strcmp(reg
->name
, "XSCALE_RX") == 0)
2422 buf_set_u32(xscale
->reg_cache
->reg_list
[XSCALE_RX
].value
, 0, 32, value
);
2423 return xscale_write_rx(arch_info
->target
);
2425 else if (strcmp(reg
->name
, "XSCALE_TX") == 0)
2427 /* can't write to TX register (debug-handler -> host) */
2430 else if (strcmp(reg
->name
, "XSCALE_TXRXCTRL") == 0)
2432 /* can't (explicitly) write to TXRXCTRL register */
2435 else /* Other DBG registers have to be transfered by the debug handler */
2437 /* send CP write request (command 0x41) */
2438 xscale_send_u32(target
, 0x41);
2440 /* send CP register number */
2441 xscale_send_u32(target
, arch_info
->dbg_handler_number
);
2443 /* send CP register value */
2444 xscale_send_u32(target
, value
);
2445 buf_set_u32(reg
->value
, 0, 32, value
);
2451 static int xscale_write_dcsr_sw(struct target
*target
, uint32_t value
)
2453 struct xscale_common
*xscale
= target_to_xscale(target
);
2454 struct reg
*dcsr
= &xscale
->reg_cache
->reg_list
[XSCALE_DCSR
];
2455 struct xscale_reg
*dcsr_arch_info
= dcsr
->arch_info
;
2457 /* send CP write request (command 0x41) */
2458 xscale_send_u32(target
, 0x41);
2460 /* send CP register number */
2461 xscale_send_u32(target
, dcsr_arch_info
->dbg_handler_number
);
2463 /* send CP register value */
2464 xscale_send_u32(target
, value
);
2465 buf_set_u32(dcsr
->value
, 0, 32, value
);
2470 static int xscale_read_trace(struct target
*target
)
2472 struct xscale_common
*xscale
= target_to_xscale(target
);
2473 struct armv4_5_common_s
*armv4_5
= &xscale
->armv4_5_common
;
2474 struct xscale_trace_data
**trace_data_p
;
2476 /* 258 words from debug handler
2477 * 256 trace buffer entries
2478 * 2 checkpoint addresses
2480 uint32_t trace_buffer
[258];
2481 int is_address
[256];
2484 if (target
->state
!= TARGET_HALTED
)
2486 LOG_WARNING("target must be stopped to read trace data");
2487 return ERROR_TARGET_NOT_HALTED
;
2490 /* send read trace buffer command (command 0x61) */
2491 xscale_send_u32(target
, 0x61);
2493 /* receive trace buffer content */
2494 xscale_receive(target
, trace_buffer
, 258);
2496 /* parse buffer backwards to identify address entries */
2497 for (i
= 255; i
>= 0; i
--)
2500 if (((trace_buffer
[i
] & 0xf0) == 0x90) ||
2501 ((trace_buffer
[i
] & 0xf0) == 0xd0))
2504 is_address
[--i
] = 1;
2506 is_address
[--i
] = 1;
2508 is_address
[--i
] = 1;
2510 is_address
[--i
] = 1;
2515 /* search first non-zero entry */
2516 for (j
= 0; (j
< 256) && (trace_buffer
[j
] == 0) && (!is_address
[j
]); j
++)
2521 LOG_DEBUG("no trace data collected");
2522 return ERROR_XSCALE_NO_TRACE_DATA
;
2525 for (trace_data_p
= &xscale
->trace
.data
; *trace_data_p
; trace_data_p
= &(*trace_data_p
)->next
)
2528 *trace_data_p
= malloc(sizeof(struct xscale_trace_data
));
2529 (*trace_data_p
)->next
= NULL
;
2530 (*trace_data_p
)->chkpt0
= trace_buffer
[256];
2531 (*trace_data_p
)->chkpt1
= trace_buffer
[257];
2532 (*trace_data_p
)->last_instruction
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
2533 (*trace_data_p
)->entries
= malloc(sizeof(struct xscale_trace_entry
) * (256 - j
));
2534 (*trace_data_p
)->depth
= 256 - j
;
2536 for (i
= j
; i
< 256; i
++)
2538 (*trace_data_p
)->entries
[i
- j
].data
= trace_buffer
[i
];
2540 (*trace_data_p
)->entries
[i
- j
].type
= XSCALE_TRACE_ADDRESS
;
2542 (*trace_data_p
)->entries
[i
- j
].type
= XSCALE_TRACE_MESSAGE
;
2548 static int xscale_read_instruction(struct target
*target
,
2549 struct arm_instruction
*instruction
)
2551 struct xscale_common
*xscale
= target_to_xscale(target
);
2558 if (!xscale
->trace
.image
)
2559 return ERROR_TRACE_IMAGE_UNAVAILABLE
;
2561 /* search for the section the current instruction belongs to */
2562 for (i
= 0; i
< xscale
->trace
.image
->num_sections
; i
++)
2564 if ((xscale
->trace
.image
->sections
[i
].base_address
<= xscale
->trace
.current_pc
) &&
2565 (xscale
->trace
.image
->sections
[i
].base_address
+ xscale
->trace
.image
->sections
[i
].size
> xscale
->trace
.current_pc
))
2574 /* current instruction couldn't be found in the image */
2575 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE
;
2578 if (xscale
->trace
.core_state
== ARMV4_5_STATE_ARM
)
2581 if ((retval
= image_read_section(xscale
->trace
.image
, section
,
2582 xscale
->trace
.current_pc
- xscale
->trace
.image
->sections
[section
].base_address
,
2583 4, buf
, &size_read
)) != ERROR_OK
)
2585 LOG_ERROR("error while reading instruction: %i", retval
);
2586 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE
;
2588 opcode
= target_buffer_get_u32(target
, buf
);
2589 arm_evaluate_opcode(opcode
, xscale
->trace
.current_pc
, instruction
);
2591 else if (xscale
->trace
.core_state
== ARMV4_5_STATE_THUMB
)
2594 if ((retval
= image_read_section(xscale
->trace
.image
, section
,
2595 xscale
->trace
.current_pc
- xscale
->trace
.image
->sections
[section
].base_address
,
2596 2, buf
, &size_read
)) != ERROR_OK
)
2598 LOG_ERROR("error while reading instruction: %i", retval
);
2599 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE
;
2601 opcode
= target_buffer_get_u16(target
, buf
);
2602 thumb_evaluate_opcode(opcode
, xscale
->trace
.current_pc
, instruction
);
2606 LOG_ERROR("BUG: unknown core state encountered");
2613 static int xscale_branch_address(struct xscale_trace_data
*trace_data
,
2614 int i
, uint32_t *target
)
2616 /* if there are less than four entries prior to the indirect branch message
2617 * we can't extract the address */
2623 *target
= (trace_data
->entries
[i
-1].data
) | (trace_data
->entries
[i
-2].data
<< 8) |
2624 (trace_data
->entries
[i
-3].data
<< 16) | (trace_data
->entries
[i
-4].data
<< 24);
2629 static int xscale_analyze_trace(struct target
*target
, struct command_context
*cmd_ctx
)
2631 struct xscale_common
*xscale
= target_to_xscale(target
);
2633 uint32_t next_pc
= 0x0;
2634 struct xscale_trace_data
*trace_data
= xscale
->trace
.data
;
2643 xscale
->trace
.core_state
= ARMV4_5_STATE_ARM
;
2648 for (i
= 0; i
< trace_data
->depth
; i
++)
2654 if (trace_data
->entries
[i
].type
== XSCALE_TRACE_ADDRESS
)
2657 switch ((trace_data
->entries
[i
].data
& 0xf0) >> 4)
2659 case 0: /* Exceptions */
2667 exception
= (trace_data
->entries
[i
].data
& 0x70) >> 4;
2669 next_pc
= (trace_data
->entries
[i
].data
& 0xf0) >> 2;
2670 command_print(cmd_ctx
, "--- exception %i ---", (trace_data
->entries
[i
].data
& 0xf0) >> 4);
2672 case 8: /* Direct Branch */
2675 case 9: /* Indirect Branch */
2677 if (xscale_branch_address(trace_data
, i
, &next_pc
) == 0)
2682 case 13: /* Checkpointed Indirect Branch */
2683 if (xscale_branch_address(trace_data
, i
, &next_pc
) == 0)
2686 if (((chkpt
== 0) && (next_pc
!= trace_data
->chkpt0
))
2687 || ((chkpt
== 1) && (next_pc
!= trace_data
->chkpt1
)))
2688 LOG_WARNING("checkpointed indirect branch target address doesn't match checkpoint");
2690 /* explicit fall-through */
2691 case 12: /* Checkpointed Direct Branch */
2696 next_pc
= trace_data
->chkpt0
;
2699 else if (chkpt
== 1)
2702 next_pc
= trace_data
->chkpt0
;
2707 LOG_WARNING("more than two checkpointed branches encountered");
2710 case 15: /* Roll-over */
2713 default: /* Reserved */
2714 command_print(cmd_ctx
, "--- reserved trace message ---");
2715 LOG_ERROR("BUG: trace message %i is reserved", (trace_data
->entries
[i
].data
& 0xf0) >> 4);
2719 if (xscale
->trace
.pc_ok
)
2721 int executed
= (trace_data
->entries
[i
].data
& 0xf) + rollover
* 16;
2722 struct arm_instruction instruction
;
2724 if ((exception
== 6) || (exception
== 7))
2726 /* IRQ or FIQ exception, no instruction executed */
2730 while (executed
-- >= 0)
2732 if ((retval
= xscale_read_instruction(target
, &instruction
)) != ERROR_OK
)
2734 /* can't continue tracing with no image available */
2735 if (retval
== ERROR_TRACE_IMAGE_UNAVAILABLE
)
2739 else if (retval
== ERROR_TRACE_INSTRUCTION_UNAVAILABLE
)
2741 /* TODO: handle incomplete images */
2745 /* a precise abort on a load to the PC is included in the incremental
2746 * word count, other instructions causing data aborts are not included
2748 if ((executed
== 0) && (exception
== 4)
2749 && ((instruction
.type
>= ARM_LDR
) && (instruction
.type
<= ARM_LDM
)))
2751 if ((instruction
.type
== ARM_LDM
)
2752 && ((instruction
.info
.load_store_multiple
.register_list
& 0x8000) == 0))
2756 else if (((instruction
.type
>= ARM_LDR
) && (instruction
.type
<= ARM_LDRSH
))
2757 && (instruction
.info
.load_store
.Rd
!= 15))
2763 /* only the last instruction executed
2764 * (the one that caused the control flow change)
2765 * could be a taken branch
2767 if (((executed
== -1) && (branch
== 1)) &&
2768 (((instruction
.type
== ARM_B
) ||
2769 (instruction
.type
== ARM_BL
) ||
2770 (instruction
.type
== ARM_BLX
)) &&
2771 (instruction
.info
.b_bl_bx_blx
.target_address
!= 0xffffffff)))
2773 xscale
->trace
.current_pc
= instruction
.info
.b_bl_bx_blx
.target_address
;
2777 xscale
->trace
.current_pc
+= (xscale
->trace
.core_state
== ARMV4_5_STATE_ARM
) ? 4 : 2;
2779 command_print(cmd_ctx
, "%s", instruction
.text
);
2787 xscale
->trace
.current_pc
= next_pc
;
2788 xscale
->trace
.pc_ok
= 1;
2792 for (; xscale
->trace
.current_pc
< trace_data
->last_instruction
; xscale
->trace
.current_pc
+= (xscale
->trace
.core_state
== ARMV4_5_STATE_ARM
) ? 4 : 2)
2794 struct arm_instruction instruction
;
2795 if ((retval
= xscale_read_instruction(target
, &instruction
)) != ERROR_OK
)
2797 /* can't continue tracing with no image available */
2798 if (retval
== ERROR_TRACE_IMAGE_UNAVAILABLE
)
2802 else if (retval
== ERROR_TRACE_INSTRUCTION_UNAVAILABLE
)
2804 /* TODO: handle incomplete images */
2807 command_print(cmd_ctx
, "%s", instruction
.text
);
2810 trace_data
= trace_data
->next
;
2816 static const struct reg_arch_type xscale_reg_type
= {
2817 .get
= xscale_get_reg
,
2818 .set
= xscale_set_reg
,
2821 static void xscale_build_reg_cache(struct target
*target
)
2823 struct xscale_common
*xscale
= target_to_xscale(target
);
2824 struct armv4_5_common_s
*armv4_5
= &xscale
->armv4_5_common
;
2825 struct reg_cache
**cache_p
= register_get_last_cache_p(&target
->reg_cache
);
2826 struct xscale_reg
*arch_info
= malloc(sizeof(xscale_reg_arch_info
));
2828 int num_regs
= sizeof(xscale_reg_arch_info
) / sizeof(struct xscale_reg
);
2830 (*cache_p
) = armv4_5_build_reg_cache(target
, armv4_5
);
2832 (*cache_p
)->next
= malloc(sizeof(struct reg_cache
));
2833 cache_p
= &(*cache_p
)->next
;
2835 /* fill in values for the xscale reg cache */
2836 (*cache_p
)->name
= "XScale registers";
2837 (*cache_p
)->next
= NULL
;
2838 (*cache_p
)->reg_list
= malloc(num_regs
* sizeof(struct reg
));
2839 (*cache_p
)->num_regs
= num_regs
;
2841 for (i
= 0; i
< num_regs
; i
++)
2843 (*cache_p
)->reg_list
[i
].name
= xscale_reg_list
[i
];
2844 (*cache_p
)->reg_list
[i
].value
= calloc(4, 1);
2845 (*cache_p
)->reg_list
[i
].dirty
= 0;
2846 (*cache_p
)->reg_list
[i
].valid
= 0;
2847 (*cache_p
)->reg_list
[i
].size
= 32;
2848 (*cache_p
)->reg_list
[i
].arch_info
= &arch_info
[i
];
2849 (*cache_p
)->reg_list
[i
].type
= &xscale_reg_type
;
2850 arch_info
[i
] = xscale_reg_arch_info
[i
];
2851 arch_info
[i
].target
= target
;
2854 xscale
->reg_cache
= (*cache_p
);
2857 static int xscale_init_target(struct command_context
*cmd_ctx
,
2858 struct target
*target
)
2860 xscale_build_reg_cache(target
);
2864 static int xscale_init_arch_info(struct target
*target
,
2865 struct xscale_common
*xscale
, struct jtag_tap
*tap
, const char *variant
)
2867 struct arm
*armv4_5
;
2868 uint32_t high_reset_branch
, low_reset_branch
;
2871 armv4_5
= &xscale
->armv4_5_common
;
2873 /* store architecture specfic data (none so far) */
2874 xscale
->common_magic
= XSCALE_COMMON_MAGIC
;
2876 /* we don't really *need* variant info ... */
2880 if (strcmp(variant
, "pxa250") == 0
2881 || strcmp(variant
, "pxa255") == 0
2882 || strcmp(variant
, "pxa26x") == 0)
2884 else if (strcmp(variant
, "pxa27x") == 0
2885 || strcmp(variant
, "ixp42x") == 0
2886 || strcmp(variant
, "ixp45x") == 0
2887 || strcmp(variant
, "ixp46x") == 0)
2890 LOG_WARNING("%s: unrecognized variant %s",
2891 tap
->dotted_name
, variant
);
2893 if (ir_length
&& ir_length
!= tap
->ir_length
) {
2894 LOG_WARNING("%s: IR length for %s is %d; fixing",
2895 tap
->dotted_name
, variant
, ir_length
);
2896 tap
->ir_length
= ir_length
;
2900 /* the debug handler isn't installed (and thus not running) at this time */
2901 xscale
->handler_address
= 0xfe000800;
2903 /* clear the vectors we keep locally for reference */
2904 memset(xscale
->low_vectors
, 0, sizeof(xscale
->low_vectors
));
2905 memset(xscale
->high_vectors
, 0, sizeof(xscale
->high_vectors
));
2907 /* no user-specified vectors have been configured yet */
2908 xscale
->static_low_vectors_set
= 0x0;
2909 xscale
->static_high_vectors_set
= 0x0;
2911 /* calculate branches to debug handler */
2912 low_reset_branch
= (xscale
->handler_address
+ 0x20 - 0x0 - 0x8) >> 2;
2913 high_reset_branch
= (xscale
->handler_address
+ 0x20 - 0xffff0000 - 0x8) >> 2;
2915 xscale
->low_vectors
[0] = ARMV4_5_B((low_reset_branch
& 0xffffff), 0);
2916 xscale
->high_vectors
[0] = ARMV4_5_B((high_reset_branch
& 0xffffff), 0);
2918 for (i
= 1; i
<= 7; i
++)
2920 xscale
->low_vectors
[i
] = ARMV4_5_B(0xfffffe, 0);
2921 xscale
->high_vectors
[i
] = ARMV4_5_B(0xfffffe, 0);
2924 /* 64kB aligned region used for DCache cleaning */
2925 xscale
->cache_clean_address
= 0xfffe0000;
2927 xscale
->hold_rst
= 0;
2928 xscale
->external_debug_break
= 0;
2930 xscale
->ibcr_available
= 2;
2931 xscale
->ibcr0_used
= 0;
2932 xscale
->ibcr1_used
= 0;
2934 xscale
->dbr_available
= 2;
2935 xscale
->dbr0_used
= 0;
2936 xscale
->dbr1_used
= 0;
2938 xscale
->arm_bkpt
= ARMV5_BKPT(0x0);
2939 xscale
->thumb_bkpt
= ARMV5_T_BKPT(0x0) & 0xffff;
2941 xscale
->vector_catch
= 0x1;
2943 xscale
->trace
.capture_status
= TRACE_IDLE
;
2944 xscale
->trace
.data
= NULL
;
2945 xscale
->trace
.image
= NULL
;
2946 xscale
->trace
.buffer_enabled
= 0;
2947 xscale
->trace
.buffer_fill
= 0;
2949 /* prepare ARMv4/5 specific information */
2950 armv4_5
->arch_info
= xscale
;
2951 armv4_5
->read_core_reg
= xscale_read_core_reg
;
2952 armv4_5
->write_core_reg
= xscale_write_core_reg
;
2953 armv4_5
->full_context
= xscale_full_context
;
2955 armv4_5_init_arch_info(target
, armv4_5
);
2957 xscale
->armv4_5_mmu
.armv4_5_cache
.ctype
= -1;
2958 xscale
->armv4_5_mmu
.get_ttb
= xscale_get_ttb
;
2959 xscale
->armv4_5_mmu
.read_memory
= xscale_read_memory
;
2960 xscale
->armv4_5_mmu
.write_memory
= xscale_write_memory
;
2961 xscale
->armv4_5_mmu
.disable_mmu_caches
= xscale_disable_mmu_caches
;
2962 xscale
->armv4_5_mmu
.enable_mmu_caches
= xscale_enable_mmu_caches
;
2963 xscale
->armv4_5_mmu
.has_tiny_pages
= 1;
2964 xscale
->armv4_5_mmu
.mmu_enabled
= 0;
2969 static int xscale_target_create(struct target
*target
, Jim_Interp
*interp
)
2971 struct xscale_common
*xscale
;
2973 if (sizeof xscale_debug_handler
- 1 > 0x800) {
2974 LOG_ERROR("debug_handler.bin: larger than 2kb");
2978 xscale
= calloc(1, sizeof(*xscale
));
2982 return xscale_init_arch_info(target
, xscale
, target
->tap
,
2986 COMMAND_HANDLER(xscale_handle_debug_handler_command
)
2988 struct target
*target
= NULL
;
2989 struct xscale_common
*xscale
;
2991 uint32_t handler_address
;
2995 LOG_ERROR("'xscale debug_handler <target#> <address>' command takes two required operands");
2999 if ((target
= get_target(CMD_ARGV
[0])) == NULL
)
3001 LOG_ERROR("target '%s' not defined", CMD_ARGV
[0]);
3005 xscale
= target_to_xscale(target
);
3006 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3007 if (retval
!= ERROR_OK
)
3010 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], handler_address
);
3012 if (((handler_address
>= 0x800) && (handler_address
<= 0x1fef800)) ||
3013 ((handler_address
>= 0xfe000800) && (handler_address
<= 0xfffff800)))
3015 xscale
->handler_address
= handler_address
;
3019 LOG_ERROR("xscale debug_handler <address> must be between 0x800 and 0x1fef800 or between 0xfe000800 and 0xfffff800");
3026 COMMAND_HANDLER(xscale_handle_cache_clean_address_command
)
3028 struct target
*target
= NULL
;
3029 struct xscale_common
*xscale
;
3031 uint32_t cache_clean_address
;
3035 return ERROR_COMMAND_SYNTAX_ERROR
;
3038 target
= get_target(CMD_ARGV
[0]);
3041 LOG_ERROR("target '%s' not defined", CMD_ARGV
[0]);
3044 xscale
= target_to_xscale(target
);
3045 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3046 if (retval
!= ERROR_OK
)
3049 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], cache_clean_address
);
3051 if (cache_clean_address
& 0xffff)
3053 LOG_ERROR("xscale cache_clean_address <address> must be 64kb aligned");
3057 xscale
->cache_clean_address
= cache_clean_address
;
3063 COMMAND_HANDLER(xscale_handle_cache_info_command
)
3065 struct target
*target
= get_current_target(CMD_CTX
);
3066 struct xscale_common
*xscale
= target_to_xscale(target
);
3069 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3070 if (retval
!= ERROR_OK
)
3073 return armv4_5_handle_cache_info_command(CMD_CTX
, &xscale
->armv4_5_mmu
.armv4_5_cache
);
3076 static int xscale_virt2phys(struct target
*target
,
3077 uint32_t virtual, uint32_t *physical
)
3079 struct xscale_common
*xscale
= target_to_xscale(target
);
3085 if (xscale
->common_magic
!= XSCALE_COMMON_MAGIC
) {
3086 LOG_ERROR(xscale_not
);
3087 return ERROR_TARGET_INVALID
;
3090 uint32_t ret
= armv4_5_mmu_translate_va(target
, &xscale
->armv4_5_mmu
, virtual, &type
, &cb
, &domain
, &ap
);
3099 static int xscale_mmu(struct target
*target
, int *enabled
)
3101 struct xscale_common
*xscale
= target_to_xscale(target
);
3103 if (target
->state
!= TARGET_HALTED
)
3105 LOG_ERROR("Target not halted");
3106 return ERROR_TARGET_INVALID
;
3108 *enabled
= xscale
->armv4_5_mmu
.mmu_enabled
;
3112 COMMAND_HANDLER(xscale_handle_mmu_command
)
3114 struct target
*target
= get_current_target(CMD_CTX
);
3115 struct xscale_common
*xscale
= target_to_xscale(target
);
3118 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3119 if (retval
!= ERROR_OK
)
3122 if (target
->state
!= TARGET_HALTED
)
3124 command_print(CMD_CTX
, "target must be stopped for \"%s\" command", CMD_NAME
);
3131 COMMAND_PARSE_ENABLE(CMD_ARGV
[0], enable
);
3133 xscale_enable_mmu_caches(target
, 1, 0, 0);
3135 xscale_disable_mmu_caches(target
, 1, 0, 0);
3136 xscale
->armv4_5_mmu
.mmu_enabled
= enable
;
3139 command_print(CMD_CTX
, "mmu %s", (xscale
->armv4_5_mmu
.mmu_enabled
) ? "enabled" : "disabled");
3144 COMMAND_HANDLER(xscale_handle_idcache_command
)
3146 struct target
*target
= get_current_target(CMD_CTX
);
3147 struct xscale_common
*xscale
= target_to_xscale(target
);
3149 int retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3150 if (retval
!= ERROR_OK
)
3153 if (target
->state
!= TARGET_HALTED
)
3155 command_print(CMD_CTX
, "target must be stopped for \"%s\" command", CMD_NAME
);
3160 COMMAND_PARSE_BOOL(CMD_NAME
, icache
, "icache", "dcache");
3165 COMMAND_PARSE_ENABLE(CMD_ARGV
[0], enable
);
3167 xscale_enable_mmu_caches(target
, 1, 0, 0);
3169 xscale_disable_mmu_caches(target
, 1, 0, 0);
3171 xscale
->armv4_5_mmu
.armv4_5_cache
.i_cache_enabled
= enable
;
3173 xscale
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
= enable
;
3176 bool enabled
= icache
?
3177 xscale
->armv4_5_mmu
.armv4_5_cache
.i_cache_enabled
:
3178 xscale
->armv4_5_mmu
.armv4_5_cache
.d_u_cache_enabled
;
3179 const char *msg
= enabled
? "enabled" : "disabled";
3180 command_print(CMD_CTX
, "%s %s", CMD_NAME
, msg
);
3185 COMMAND_HANDLER(xscale_handle_vector_catch_command
)
3187 struct target
*target
= get_current_target(CMD_CTX
);
3188 struct xscale_common
*xscale
= target_to_xscale(target
);
3191 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3192 if (retval
!= ERROR_OK
)
3197 command_print(CMD_CTX
, "usage: xscale vector_catch [mask]");
3201 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], xscale
->vector_catch
);
3202 buf_set_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 16, 8, xscale
->vector_catch
);
3203 xscale_write_dcsr(target
, -1, -1);
3206 command_print(CMD_CTX
, "vector catch mask: 0x%2.2x", xscale
->vector_catch
);
3212 COMMAND_HANDLER(xscale_handle_vector_table_command
)
3214 struct target
*target
= get_current_target(CMD_CTX
);
3215 struct xscale_common
*xscale
= target_to_xscale(target
);
3219 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3220 if (retval
!= ERROR_OK
)
3223 if (CMD_ARGC
== 0) /* print current settings */
3227 command_print(CMD_CTX
, "active user-set static vectors:");
3228 for (idx
= 1; idx
< 8; idx
++)
3229 if (xscale
->static_low_vectors_set
& (1 << idx
))
3230 command_print(CMD_CTX
, "low %d: 0x%" PRIx32
, idx
, xscale
->static_low_vectors
[idx
]);
3231 for (idx
= 1; idx
< 8; idx
++)
3232 if (xscale
->static_high_vectors_set
& (1 << idx
))
3233 command_print(CMD_CTX
, "high %d: 0x%" PRIx32
, idx
, xscale
->static_high_vectors
[idx
]);
3242 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[1], idx
);
3244 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], vec
);
3246 if (idx
< 1 || idx
>= 8)
3249 if (!err
&& strcmp(CMD_ARGV
[0], "low") == 0)
3251 xscale
->static_low_vectors_set
|= (1<<idx
);
3252 xscale
->static_low_vectors
[idx
] = vec
;
3254 else if (!err
&& (strcmp(CMD_ARGV
[0], "high") == 0))
3256 xscale
->static_high_vectors_set
|= (1<<idx
);
3257 xscale
->static_high_vectors
[idx
] = vec
;
3264 command_print(CMD_CTX
, "usage: xscale vector_table <high|low> <index> <code>");
3270 COMMAND_HANDLER(xscale_handle_trace_buffer_command
)
3272 struct target
*target
= get_current_target(CMD_CTX
);
3273 struct xscale_common
*xscale
= target_to_xscale(target
);
3274 struct armv4_5_common_s
*armv4_5
= &xscale
->armv4_5_common
;
3275 uint32_t dcsr_value
;
3278 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3279 if (retval
!= ERROR_OK
)
3282 if (target
->state
!= TARGET_HALTED
)
3284 command_print(CMD_CTX
, "target must be stopped for \"%s\" command", CMD_NAME
);
3288 if ((CMD_ARGC
>= 1) && (strcmp("enable", CMD_ARGV
[0]) == 0))
3290 struct xscale_trace_data
*td
, *next_td
;
3291 xscale
->trace
.buffer_enabled
= 1;
3293 /* free old trace data */
3294 td
= xscale
->trace
.data
;
3304 xscale
->trace
.data
= NULL
;
3306 else if ((CMD_ARGC
>= 1) && (strcmp("disable", CMD_ARGV
[0]) == 0))
3308 xscale
->trace
.buffer_enabled
= 0;
3311 if ((CMD_ARGC
>= 2) && (strcmp("fill", CMD_ARGV
[1]) == 0))
3315 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], fill
);
3316 xscale
->trace
.buffer_fill
= fill
;
3318 else if ((CMD_ARGC
>= 2) && (strcmp("wrap", CMD_ARGV
[1]) == 0))
3320 xscale
->trace
.buffer_fill
= -1;
3323 if (xscale
->trace
.buffer_enabled
)
3325 /* if we enable the trace buffer in fill-once
3326 * mode we know the address of the first instruction */
3327 xscale
->trace
.pc_ok
= 1;
3328 xscale
->trace
.current_pc
= buf_get_u32(armv4_5
->core_cache
->reg_list
[15].value
, 0, 32);
3332 /* otherwise the address is unknown, and we have no known good PC */
3333 xscale
->trace
.pc_ok
= 0;
3336 command_print(CMD_CTX
, "trace buffer %s (%s)",
3337 (xscale
->trace
.buffer_enabled
) ? "enabled" : "disabled",
3338 (xscale
->trace
.buffer_fill
> 0) ? "fill" : "wrap");
3340 dcsr_value
= buf_get_u32(xscale
->reg_cache
->reg_list
[XSCALE_DCSR
].value
, 0, 32);
3341 if (xscale
->trace
.buffer_fill
>= 0)
3342 xscale_write_dcsr_sw(target
, (dcsr_value
& 0xfffffffc) | 2);
3344 xscale_write_dcsr_sw(target
, dcsr_value
& 0xfffffffc);
3349 COMMAND_HANDLER(xscale_handle_trace_image_command
)
3351 struct target
*target
= get_current_target(CMD_CTX
);
3352 struct xscale_common
*xscale
= target_to_xscale(target
);
3357 command_print(CMD_CTX
, "usage: xscale trace_image <file> [base address] [type]");
3361 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3362 if (retval
!= ERROR_OK
)
3365 if (xscale
->trace
.image
)
3367 image_close(xscale
->trace
.image
);
3368 free(xscale
->trace
.image
);
3369 command_print(CMD_CTX
, "previously loaded image found and closed");
3372 xscale
->trace
.image
= malloc(sizeof(struct image
));
3373 xscale
->trace
.image
->base_address_set
= 0;
3374 xscale
->trace
.image
->start_address_set
= 0;
3376 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
3379 xscale
->trace
.image
->base_address_set
= 1;
3380 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[1], xscale
->trace
.image
->base_address
);
3384 xscale
->trace
.image
->base_address_set
= 0;
3387 if (image_open(xscale
->trace
.image
, CMD_ARGV
[0], (CMD_ARGC
>= 3) ? CMD_ARGV
[2] : NULL
) != ERROR_OK
)
3389 free(xscale
->trace
.image
);
3390 xscale
->trace
.image
= NULL
;
3397 COMMAND_HANDLER(xscale_handle_dump_trace_command
)
3399 struct target
*target
= get_current_target(CMD_CTX
);
3400 struct xscale_common
*xscale
= target_to_xscale(target
);
3401 struct xscale_trace_data
*trace_data
;
3405 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3406 if (retval
!= ERROR_OK
)
3409 if (target
->state
!= TARGET_HALTED
)
3411 command_print(CMD_CTX
, "target must be stopped for \"%s\" command", CMD_NAME
);
3417 command_print(CMD_CTX
, "usage: xscale dump_trace <file>");
3421 trace_data
= xscale
->trace
.data
;
3425 command_print(CMD_CTX
, "no trace data collected");
3429 if (fileio_open(&file
, CMD_ARGV
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
3438 fileio_write_u32(&file
, trace_data
->chkpt0
);
3439 fileio_write_u32(&file
, trace_data
->chkpt1
);
3440 fileio_write_u32(&file
, trace_data
->last_instruction
);
3441 fileio_write_u32(&file
, trace_data
->depth
);
3443 for (i
= 0; i
< trace_data
->depth
; i
++)
3444 fileio_write_u32(&file
, trace_data
->entries
[i
].data
| ((trace_data
->entries
[i
].type
& 0xffff) << 16));
3446 trace_data
= trace_data
->next
;
3449 fileio_close(&file
);
3454 COMMAND_HANDLER(xscale_handle_analyze_trace_buffer_command
)
3456 struct target
*target
= get_current_target(CMD_CTX
);
3457 struct xscale_common
*xscale
= target_to_xscale(target
);
3460 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3461 if (retval
!= ERROR_OK
)
3464 xscale_analyze_trace(target
, CMD_CTX
);
3469 COMMAND_HANDLER(xscale_handle_cp15
)
3471 struct target
*target
= get_current_target(CMD_CTX
);
3472 struct xscale_common
*xscale
= target_to_xscale(target
);
3475 retval
= xscale_verify_pointer(CMD_CTX
, xscale
);
3476 if (retval
!= ERROR_OK
)
3479 if (target
->state
!= TARGET_HALTED
)
3481 command_print(CMD_CTX
, "target must be stopped for \"%s\" command", CMD_NAME
);
3484 uint32_t reg_no
= 0;
3485 struct reg
*reg
= NULL
;
3488 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], reg_no
);
3489 /*translate from xscale cp15 register no to openocd register*/
3493 reg_no
= XSCALE_MAINID
;
3496 reg_no
= XSCALE_CTRL
;
3499 reg_no
= XSCALE_TTB
;
3502 reg_no
= XSCALE_DAC
;
3505 reg_no
= XSCALE_FSR
;
3508 reg_no
= XSCALE_FAR
;
3511 reg_no
= XSCALE_PID
;
3514 reg_no
= XSCALE_CPACCESS
;
3517 command_print(CMD_CTX
, "invalid register number");
3518 return ERROR_INVALID_ARGUMENTS
;
3520 reg
= &xscale
->reg_cache
->reg_list
[reg_no
];
3527 /* read cp15 control register */
3528 xscale_get_reg(reg
);
3529 value
= buf_get_u32(reg
->value
, 0, 32);
3530 command_print(CMD_CTX
, "%s (/%i): 0x%" PRIx32
"", reg
->name
, (int)(reg
->size
), value
);
3532 else if (CMD_ARGC
== 2)
3535 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], value
);
3537 /* send CP write request (command 0x41) */
3538 xscale_send_u32(target
, 0x41);
3540 /* send CP register number */
3541 xscale_send_u32(target
, reg_no
);
3543 /* send CP register value */
3544 xscale_send_u32(target
, value
);
3546 /* execute cpwait to ensure outstanding operations complete */
3547 xscale_send_u32(target
, 0x53);
3551 command_print(CMD_CTX
, "usage: cp15 [register]<, [value]>");
3557 static int xscale_register_commands(struct command_context
*cmd_ctx
)
3559 struct command
*xscale_cmd
;
3561 xscale_cmd
= register_command(cmd_ctx
, NULL
, "xscale", NULL
, COMMAND_ANY
, "xscale specific commands");
3563 register_command(cmd_ctx
, xscale_cmd
, "debug_handler", xscale_handle_debug_handler_command
, COMMAND_ANY
, "'xscale debug_handler <target#> <address>' command takes two required operands");
3564 register_command(cmd_ctx
, xscale_cmd
, "cache_clean_address", xscale_handle_cache_clean_address_command
, COMMAND_ANY
, NULL
);
3566 register_command(cmd_ctx
, xscale_cmd
, "cache_info", xscale_handle_cache_info_command
, COMMAND_EXEC
, NULL
);
3567 register_command(cmd_ctx
, xscale_cmd
, "mmu", xscale_handle_mmu_command
, COMMAND_EXEC
, "['enable'|'disable'] the MMU");
3568 register_command(cmd_ctx
, xscale_cmd
, "icache", xscale_handle_idcache_command
, COMMAND_EXEC
, "['enable'|'disable'] the ICache");
3569 register_command(cmd_ctx
, xscale_cmd
, "dcache", xscale_handle_idcache_command
, COMMAND_EXEC
, "['enable'|'disable'] the DCache");
3571 register_command(cmd_ctx
, xscale_cmd
, "vector_catch", xscale_handle_vector_catch_command
, COMMAND_EXEC
, "<mask> of vectors that should be catched");
3572 register_command(cmd_ctx
, xscale_cmd
, "vector_table", xscale_handle_vector_table_command
, COMMAND_EXEC
, "<high|low> <index> <code> set static code for exception handler entry");
3574 register_command(cmd_ctx
, xscale_cmd
, "trace_buffer", xscale_handle_trace_buffer_command
, COMMAND_EXEC
, "<enable | disable> ['fill' [n]|'wrap']");
3576 register_command(cmd_ctx
, xscale_cmd
, "dump_trace", xscale_handle_dump_trace_command
, COMMAND_EXEC
, "dump content of trace buffer to <file>");
3577 register_command(cmd_ctx
, xscale_cmd
, "analyze_trace", xscale_handle_analyze_trace_buffer_command
, COMMAND_EXEC
, "analyze content of trace buffer");
3578 register_command(cmd_ctx
, xscale_cmd
, "trace_image", xscale_handle_trace_image_command
,
3579 COMMAND_EXEC
, "load image from <file> [base address]");
3581 register_command(cmd_ctx
, xscale_cmd
, "cp15", xscale_handle_cp15
, COMMAND_EXEC
, "access coproc 15 <register> [value]");
3583 armv4_5_register_commands(cmd_ctx
);
3588 struct target_type xscale_target
=
3592 .poll
= xscale_poll
,
3593 .arch_state
= xscale_arch_state
,
3595 .target_request_data
= NULL
,
3597 .halt
= xscale_halt
,
3598 .resume
= xscale_resume
,
3599 .step
= xscale_step
,
3601 .assert_reset
= xscale_assert_reset
,
3602 .deassert_reset
= xscale_deassert_reset
,
3603 .soft_reset_halt
= NULL
,
3605 .get_gdb_reg_list
= armv4_5_get_gdb_reg_list
,
3607 .read_memory
= xscale_read_memory
,
3608 .write_memory
= xscale_write_memory
,
3609 .bulk_write_memory
= xscale_bulk_write_memory
,
3611 .checksum_memory
= arm_checksum_memory
,
3612 .blank_check_memory
= arm_blank_check_memory
,
3614 .run_algorithm
= armv4_5_run_algorithm
,
3616 .add_breakpoint
= xscale_add_breakpoint
,
3617 .remove_breakpoint
= xscale_remove_breakpoint
,
3618 .add_watchpoint
= xscale_add_watchpoint
,
3619 .remove_watchpoint
= xscale_remove_watchpoint
,
3621 .register_commands
= xscale_register_commands
,
3622 .target_create
= xscale_target_create
,
3623 .init_target
= xscale_init_target
,
3625 .virt2phys
= xscale_virt2phys
,
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)