Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
types: write memory now uses const
[openocd.git] / src / target / xscale.c
1 /***************************************************************************
2 * Copyright (C) 2006, 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2009 Michael Schwingen *
9 * michael@schwingen.org *
10 * *
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. *
15 * *
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. *
20 * *
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 ***************************************************************************/
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #include "breakpoints.h"
31 #include "xscale.h"
32 #include "target_type.h"
33 #include "arm_jtag.h"
34 #include "arm_simulator.h"
35 #include "arm_disassembler.h"
36 #include <helper/time_support.h>
37 #include "register.h"
38 #include "image.h"
39 #include "arm_opcodes.h"
40 #include "armv4_5.h"
41
42
43 /*
44 * Important XScale documents available as of October 2009 include:
45 *
46 * Intel XScale® Core Developer’s Manual, January 2004
47 * Order Number: 273473-002
48 * This has a chapter detailing debug facilities, and punts some
49 * details to chip-specific microarchitecture documents.
50 *
51 * Hot-Debug for Intel XScale® Core Debug White Paper, May 2005
52 * Document Number: 273539-005
53 * Less detailed than the developer's manual, but summarizes those
54 * missing details (for most XScales) and gives LOTS of notes about
55 * debugger/handler interaction issues. Presents a simpler reset
56 * and load-handler sequence than the arch doc. (Note, OpenOCD
57 * doesn't currently support "Hot-Debug" as defined there.)
58 *
59 * Chip-specific microarchitecture documents may also be useful.
60 */
61
62
63 /* forward declarations */
64 static int xscale_resume(struct target *, int current,
65 uint32_t address, int handle_breakpoints, int debug_execution);
66 static int xscale_debug_entry(struct target *);
67 static int xscale_restore_banked(struct target *);
68 static int xscale_get_reg(struct reg *reg);
69 static int xscale_set_reg(struct reg *reg, uint8_t *buf);
70 static int xscale_set_breakpoint(struct target *, struct breakpoint *);
71 static int xscale_set_watchpoint(struct target *, struct watchpoint *);
72 static int xscale_unset_breakpoint(struct target *, struct breakpoint *);
73 static int xscale_read_trace(struct target *);
74
75
76 /* This XScale "debug handler" is loaded into the processor's
77 * mini-ICache, which is 2K of code writable only via JTAG.
78 *
79 * FIXME the OpenOCD "bin2char" utility currently doesn't handle
80 * binary files cleanly. It's string oriented, and terminates them
81 * with a NUL character. Better would be to generate the constants
82 * and let other code decide names, scoping, and other housekeeping.
83 */
84 static /* unsigned const char xscale_debug_handler[] = ... */
85 #include "xscale_debug.h"
86
87 static char *const xscale_reg_list[] =
88 {
89 "XSCALE_MAINID", /* 0 */
90 "XSCALE_CACHETYPE",
91 "XSCALE_CTRL",
92 "XSCALE_AUXCTRL",
93 "XSCALE_TTB",
94 "XSCALE_DAC",
95 "XSCALE_FSR",
96 "XSCALE_FAR",
97 "XSCALE_PID",
98 "XSCALE_CPACCESS",
99 "XSCALE_IBCR0", /* 10 */
100 "XSCALE_IBCR1",
101 "XSCALE_DBR0",
102 "XSCALE_DBR1",
103 "XSCALE_DBCON",
104 "XSCALE_TBREG",
105 "XSCALE_CHKPT0",
106 "XSCALE_CHKPT1",
107 "XSCALE_DCSR",
108 "XSCALE_TX",
109 "XSCALE_RX", /* 20 */
110 "XSCALE_TXRXCTRL",
111 };
112
113 static const struct xscale_reg xscale_reg_arch_info[] =
114 {
115 {XSCALE_MAINID, NULL},
116 {XSCALE_CACHETYPE, NULL},
117 {XSCALE_CTRL, NULL},
118 {XSCALE_AUXCTRL, NULL},
119 {XSCALE_TTB, NULL},
120 {XSCALE_DAC, NULL},
121 {XSCALE_FSR, NULL},
122 {XSCALE_FAR, NULL},
123 {XSCALE_PID, NULL},
124 {XSCALE_CPACCESS, NULL},
125 {XSCALE_IBCR0, NULL},
126 {XSCALE_IBCR1, NULL},
127 {XSCALE_DBR0, NULL},
128 {XSCALE_DBR1, NULL},
129 {XSCALE_DBCON, NULL},
130 {XSCALE_TBREG, NULL},
131 {XSCALE_CHKPT0, NULL},
132 {XSCALE_CHKPT1, NULL},
133 {XSCALE_DCSR, NULL}, /* DCSR accessed via JTAG or SW */
134 {-1, NULL}, /* TX accessed via JTAG */
135 {-1, NULL}, /* RX accessed via JTAG */
136 {-1, NULL}, /* TXRXCTRL implicit access via JTAG */
137 };
138
139 /* convenience wrapper to access XScale specific registers */
140 static int xscale_set_reg_u32(struct reg *reg, uint32_t value)
141 {
142 uint8_t buf[4];
143
144 buf_set_u32(buf, 0, 32, value);
145
146 return xscale_set_reg(reg, buf);
147 }
148
149 static const char xscale_not[] = "target is not an XScale";
150
151 static int xscale_verify_pointer(struct command_context *cmd_ctx,
152 struct xscale_common *xscale)
153 {
154 if (xscale->common_magic != XSCALE_COMMON_MAGIC) {
155 command_print(cmd_ctx, xscale_not);
156 return ERROR_TARGET_INVALID;
157 }
158 return ERROR_OK;
159 }
160
161 static int xscale_jtag_set_instr(struct jtag_tap *tap, uint32_t new_instr, tap_state_t end_state)
162 {
163 assert (tap != NULL);
164
165 if (buf_get_u32(tap->cur_instr, 0, tap->ir_length) != new_instr)
166 {
167 struct scan_field field;
168 uint8_t scratch[4];
169
170 memset(&field, 0, sizeof field);
171 field.num_bits = tap->ir_length;
172 field.out_value = scratch;
173 buf_set_u32(scratch, 0, field.num_bits, new_instr);
174
175 jtag_add_ir_scan(tap, &field, end_state);
176 }
177
178 return ERROR_OK;
179 }
180
181 static int xscale_read_dcsr(struct target *target)
182 {
183 struct xscale_common *xscale = target_to_xscale(target);
184 int retval;
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;
192
193 xscale_jtag_set_instr(target->tap,
194 XSCALE_SELDCSR << xscale->xscale_variant,
195 TAP_DRPAUSE);
196
197 buf_set_u32(&field0, 1, 1, xscale->hold_rst);
198 buf_set_u32(&field0, 2, 1, xscale->external_debug_break);
199
200 memset(&fields, 0, sizeof fields);
201
202 fields[0].num_bits = 3;
203 fields[0].out_value = &field0;
204 uint8_t tmp;
205 fields[0].in_value = &tmp;
206
207 fields[1].num_bits = 32;
208 fields[1].in_value = xscale->reg_cache->reg_list[XSCALE_DCSR].value;
209
210 fields[2].num_bits = 1;
211 fields[2].out_value = &field2;
212 uint8_t tmp2;
213 fields[2].in_value = &tmp2;
214
215 jtag_add_dr_scan(target->tap, 3, fields, TAP_DRPAUSE);
216
217 jtag_check_value_mask(fields + 0, &field0_check_value, &field0_check_mask);
218 jtag_check_value_mask(fields + 2, &field2_check_value, &field2_check_mask);
219
220 if ((retval = jtag_execute_queue()) != ERROR_OK)
221 {
222 LOG_ERROR("JTAG error while reading DCSR");
223 return retval;
224 }
225
226 xscale->reg_cache->reg_list[XSCALE_DCSR].dirty = 0;
227 xscale->reg_cache->reg_list[XSCALE_DCSR].valid = 1;
228
229 /* write the register with the value we just read
230 * on this second pass, only the first bit of field0 is guaranteed to be 0)
231 */
232 field0_check_mask = 0x1;
233 fields[1].out_value = xscale->reg_cache->reg_list[XSCALE_DCSR].value;
234 fields[1].in_value = NULL;
235
236 jtag_add_dr_scan(target->tap, 3, fields, TAP_DRPAUSE);
237
238 /* DANGER!!! this must be here. It will make sure that the arguments
239 * to jtag_set_check_value() does not go out of scope! */
240 return jtag_execute_queue();
241 }
242
243
244 static void xscale_getbuf(jtag_callback_data_t arg)
245 {
246 uint8_t *in = (uint8_t *)arg;
247 *((uint32_t *)arg) = buf_get_u32(in, 0, 32);
248 }
249
250 static int xscale_receive(struct target *target, uint32_t *buffer, int num_words)
251 {
252 if (num_words == 0)
253 return ERROR_INVALID_ARGUMENTS;
254
255 struct xscale_common *xscale = target_to_xscale(target);
256 int retval = ERROR_OK;
257 tap_state_t path[3];
258 struct scan_field fields[3];
259 uint8_t *field0 = malloc(num_words * 1);
260 uint8_t field0_check_value = 0x2;
261 uint8_t field0_check_mask = 0x6;
262 uint32_t *field1 = malloc(num_words * 4);
263 uint8_t field2_check_value = 0x0;
264 uint8_t field2_check_mask = 0x1;
265 int words_done = 0;
266 int words_scheduled = 0;
267 int i;
268
269 path[0] = TAP_DRSELECT;
270 path[1] = TAP_DRCAPTURE;
271 path[2] = TAP_DRSHIFT;
272
273 memset(&fields, 0, sizeof fields);
274
275 fields[0].num_bits = 3;
276 fields[0].check_value = &field0_check_value;
277 fields[0].check_mask = &field0_check_mask;
278
279 fields[1].num_bits = 32;
280
281 fields[2].num_bits = 1;
282 fields[2].check_value = &field2_check_value;
283 fields[2].check_mask = &field2_check_mask;
284
285 xscale_jtag_set_instr(target->tap,
286 XSCALE_DBGTX << xscale->xscale_variant,
287 TAP_IDLE);
288 jtag_add_runtest(1, TAP_IDLE); /* ensures that we're in the TAP_IDLE state as the above could be a no-op */
289
290 /* repeat until all words have been collected */
291 int attempts = 0;
292 while (words_done < num_words)
293 {
294 /* schedule reads */
295 words_scheduled = 0;
296 for (i = words_done; i < num_words; i++)
297 {
298 fields[0].in_value = &field0[i];
299
300 jtag_add_pathmove(3, path);
301
302 fields[1].in_value = (uint8_t *)(field1 + i);
303
304 jtag_add_dr_scan_check(target->tap, 3, fields, TAP_IDLE);
305
306 jtag_add_callback(xscale_getbuf, (jtag_callback_data_t)(field1 + i));
307
308 words_scheduled++;
309 }
310
311 if ((retval = jtag_execute_queue()) != ERROR_OK)
312 {
313 LOG_ERROR("JTAG error while receiving data from debug handler");
314 break;
315 }
316
317 /* examine results */
318 for (i = words_done; i < num_words; i++)
319 {
320 if (!(field0[0] & 1))
321 {
322 /* move backwards if necessary */
323 int j;
324 for (j = i; j < num_words - 1; j++)
325 {
326 field0[j] = field0[j + 1];
327 field1[j] = field1[j + 1];
328 }
329 words_scheduled--;
330 }
331 }
332 if (words_scheduled == 0)
333 {
334 if (attempts++==1000)
335 {
336 LOG_ERROR("Failed to receiving data from debug handler after 1000 attempts");
337 retval = ERROR_TARGET_TIMEOUT;
338 break;
339 }
340 }
341
342 words_done += words_scheduled;
343 }
344
345 for (i = 0; i < num_words; i++)
346 *(buffer++) = buf_get_u32((uint8_t*)&field1[i], 0, 32);
347
348 free(field1);
349
350 return retval;
351 }
352
353 static int xscale_read_tx(struct target *target, int consume)
354 {
355 struct xscale_common *xscale = target_to_xscale(target);
356 tap_state_t path[3];
357 tap_state_t noconsume_path[6];
358 int retval;
359 struct timeval timeout, now;
360 struct scan_field fields[3];
361 uint8_t field0_in = 0x0;
362 uint8_t field0_check_value = 0x2;
363 uint8_t field0_check_mask = 0x6;
364 uint8_t field2_check_value = 0x0;
365 uint8_t field2_check_mask = 0x1;
366
367 xscale_jtag_set_instr(target->tap,
368 XSCALE_DBGTX << xscale->xscale_variant,
369 TAP_IDLE);
370
371 path[0] = TAP_DRSELECT;
372 path[1] = TAP_DRCAPTURE;
373 path[2] = TAP_DRSHIFT;
374
375 noconsume_path[0] = TAP_DRSELECT;
376 noconsume_path[1] = TAP_DRCAPTURE;
377 noconsume_path[2] = TAP_DREXIT1;
378 noconsume_path[3] = TAP_DRPAUSE;
379 noconsume_path[4] = TAP_DREXIT2;
380 noconsume_path[5] = TAP_DRSHIFT;
381
382 memset(&fields, 0, sizeof fields);
383
384 fields[0].num_bits = 3;
385 fields[0].in_value = &field0_in;
386
387 fields[1].num_bits = 32;
388 fields[1].in_value = xscale->reg_cache->reg_list[XSCALE_TX].value;
389
390 fields[2].num_bits = 1;
391 uint8_t tmp;
392 fields[2].in_value = &tmp;
393
394 gettimeofday(&timeout, NULL);
395 timeval_add_time(&timeout, 1, 0);
396
397 for (;;)
398 {
399 /* if we want to consume the register content (i.e. clear TX_READY),
400 * we have to go straight from Capture-DR to Shift-DR
401 * otherwise, we go from Capture-DR to Exit1-DR to Pause-DR
402 */
403 if (consume)
404 jtag_add_pathmove(3, path);
405 else
406 {
407 jtag_add_pathmove(ARRAY_SIZE(noconsume_path), noconsume_path);
408 }
409
410 jtag_add_dr_scan(target->tap, 3, fields, TAP_IDLE);
411
412 jtag_check_value_mask(fields + 0, &field0_check_value, &field0_check_mask);
413 jtag_check_value_mask(fields + 2, &field2_check_value, &field2_check_mask);
414
415 if ((retval = jtag_execute_queue()) != ERROR_OK)
416 {
417 LOG_ERROR("JTAG error while reading TX");
418 return ERROR_TARGET_TIMEOUT;
419 }
420
421 gettimeofday(&now, NULL);
422 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec)&& (now.tv_usec > timeout.tv_usec)))
423 {
424 LOG_ERROR("time out reading TX register");
425 return ERROR_TARGET_TIMEOUT;
426 }
427 if (!((!(field0_in & 1)) && consume))
428 {
429 goto done;
430 }
431 if (debug_level >= 3)
432 {
433 LOG_DEBUG("waiting 100ms");
434 alive_sleep(100); /* avoid flooding the logs */
435 } else
436 {
437 keep_alive();
438 }
439 }
440 done:
441
442 if (!(field0_in & 1))
443 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
444
445 return ERROR_OK;
446 }
447
448 static int xscale_write_rx(struct target *target)
449 {
450 struct xscale_common *xscale = target_to_xscale(target);
451 int retval;
452 struct timeval timeout, now;
453 struct scan_field fields[3];
454 uint8_t field0_out = 0x0;
455 uint8_t field0_in = 0x0;
456 uint8_t field0_check_value = 0x2;
457 uint8_t field0_check_mask = 0x6;
458 uint8_t field2 = 0x0;
459 uint8_t field2_check_value = 0x0;
460 uint8_t field2_check_mask = 0x1;
461
462 xscale_jtag_set_instr(target->tap,
463 XSCALE_DBGRX << xscale->xscale_variant,
464 TAP_IDLE);
465
466 memset(&fields, 0, sizeof fields);
467
468 fields[0].num_bits = 3;
469 fields[0].out_value = &field0_out;
470 fields[0].in_value = &field0_in;
471
472 fields[1].num_bits = 32;
473 fields[1].out_value = xscale->reg_cache->reg_list[XSCALE_RX].value;
474
475 fields[2].num_bits = 1;
476 fields[2].out_value = &field2;
477 uint8_t tmp;
478 fields[2].in_value = &tmp;
479
480 gettimeofday(&timeout, NULL);
481 timeval_add_time(&timeout, 1, 0);
482
483 /* poll until rx_read is low */
484 LOG_DEBUG("polling RX");
485 for (;;)
486 {
487 jtag_add_dr_scan(target->tap, 3, fields, TAP_IDLE);
488
489 jtag_check_value_mask(fields + 0, &field0_check_value, &field0_check_mask);
490 jtag_check_value_mask(fields + 2, &field2_check_value, &field2_check_mask);
491
492 if ((retval = jtag_execute_queue()) != ERROR_OK)
493 {
494 LOG_ERROR("JTAG error while writing RX");
495 return retval;
496 }
497
498 gettimeofday(&now, NULL);
499 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec)&& (now.tv_usec > timeout.tv_usec)))
500 {
501 LOG_ERROR("time out writing RX register");
502 return ERROR_TARGET_TIMEOUT;
503 }
504 if (!(field0_in & 1))
505 goto done;
506 if (debug_level >= 3)
507 {
508 LOG_DEBUG("waiting 100ms");
509 alive_sleep(100); /* avoid flooding the logs */
510 } else
511 {
512 keep_alive();
513 }
514 }
515 done:
516
517 /* set rx_valid */
518 field2 = 0x1;
519 jtag_add_dr_scan(target->tap, 3, fields, TAP_IDLE);
520
521 if ((retval = jtag_execute_queue()) != ERROR_OK)
522 {
523 LOG_ERROR("JTAG error while writing RX");
524 return retval;
525 }
526
527 return ERROR_OK;
528 }
529
530 /* send count elements of size byte to the debug handler */
531 static int xscale_send(struct target *target, const uint8_t *buffer, int count, int size)
532 {
533 struct xscale_common *xscale = target_to_xscale(target);
534 uint32_t t[3];
535 int bits[3];
536 int retval;
537 int done_count = 0;
538
539 xscale_jtag_set_instr(target->tap,
540 XSCALE_DBGRX << xscale->xscale_variant,
541 TAP_IDLE);
542
543 bits[0]=3;
544 t[0]=0;
545 bits[1]=32;
546 t[2]=1;
547 bits[2]=1;
548 int endianness = target->endianness;
549 while (done_count++ < count)
550 {
551 switch (size)
552 {
553 case 4:
554 if (endianness == TARGET_LITTLE_ENDIAN)
555 {
556 t[1]=le_to_h_u32(buffer);
557 } else
558 {
559 t[1]=be_to_h_u32(buffer);
560 }
561 break;
562 case 2:
563 if (endianness == TARGET_LITTLE_ENDIAN)
564 {
565 t[1]=le_to_h_u16(buffer);
566 } else
567 {
568 t[1]=be_to_h_u16(buffer);
569 }
570 break;
571 case 1:
572 t[1]=buffer[0];
573 break;
574 default:
575 LOG_ERROR("BUG: size neither 4, 2 nor 1");
576 return ERROR_INVALID_ARGUMENTS;
577 }
578 jtag_add_dr_out(target->tap,
579 3,
580 bits,
581 t,
582 TAP_IDLE);
583 buffer += size;
584 }
585
586 if ((retval = jtag_execute_queue()) != ERROR_OK)
587 {
588 LOG_ERROR("JTAG error while sending data to debug handler");
589 return retval;
590 }
591
592 return ERROR_OK;
593 }
594
595 static int xscale_send_u32(struct target *target, uint32_t value)
596 {
597 struct xscale_common *xscale = target_to_xscale(target);
598
599 buf_set_u32(xscale->reg_cache->reg_list[XSCALE_RX].value, 0, 32, value);
600 return xscale_write_rx(target);
601 }
602
603 static int xscale_write_dcsr(struct target *target, int hold_rst, int ext_dbg_brk)
604 {
605 struct xscale_common *xscale = target_to_xscale(target);
606 int retval;
607 struct scan_field fields[3];
608 uint8_t field0 = 0x0;
609 uint8_t field0_check_value = 0x2;
610 uint8_t field0_check_mask = 0x7;
611 uint8_t field2 = 0x0;
612 uint8_t field2_check_value = 0x0;
613 uint8_t field2_check_mask = 0x1;
614
615 if (hold_rst != -1)
616 xscale->hold_rst = hold_rst;
617
618 if (ext_dbg_brk != -1)
619 xscale->external_debug_break = ext_dbg_brk;
620
621 xscale_jtag_set_instr(target->tap,
622 XSCALE_SELDCSR << xscale->xscale_variant,
623 TAP_IDLE);
624
625 buf_set_u32(&field0, 1, 1, xscale->hold_rst);
626 buf_set_u32(&field0, 2, 1, xscale->external_debug_break);
627
628 memset(&fields, 0, sizeof fields);
629
630 fields[0].num_bits = 3;
631 fields[0].out_value = &field0;
632 uint8_t tmp;
633 fields[0].in_value = &tmp;
634
635 fields[1].num_bits = 32;
636 fields[1].out_value = xscale->reg_cache->reg_list[XSCALE_DCSR].value;
637
638 fields[2].num_bits = 1;
639 fields[2].out_value = &field2;
640 uint8_t tmp2;
641 fields[2].in_value = &tmp2;
642
643 jtag_add_dr_scan(target->tap, 3, fields, TAP_IDLE);
644
645 jtag_check_value_mask(fields + 0, &field0_check_value, &field0_check_mask);
646 jtag_check_value_mask(fields + 2, &field2_check_value, &field2_check_mask);
647
648 if ((retval = jtag_execute_queue()) != ERROR_OK)
649 {
650 LOG_ERROR("JTAG error while writing DCSR");
651 return retval;
652 }
653
654 xscale->reg_cache->reg_list[XSCALE_DCSR].dirty = 0;
655 xscale->reg_cache->reg_list[XSCALE_DCSR].valid = 1;
656
657 return ERROR_OK;
658 }
659
660 /* parity of the number of bits 0 if even; 1 if odd. for 32 bit words */
661 static unsigned int parity (unsigned int v)
662 {
663 // unsigned int ov = v;
664 v ^= v >> 16;
665 v ^= v >> 8;
666 v ^= v >> 4;
667 v &= 0xf;
668 // LOG_DEBUG("parity of 0x%x is %i", ov, (0x6996 >> v) & 1);
669 return (0x6996 >> v) & 1;
670 }
671
672 static int xscale_load_ic(struct target *target, uint32_t va, uint32_t buffer[8])
673 {
674 struct xscale_common *xscale = target_to_xscale(target);
675 uint8_t packet[4];
676 uint8_t cmd;
677 int word;
678 struct scan_field fields[2];
679
680 LOG_DEBUG("loading miniIC at 0x%8.8" PRIx32 "", va);
681
682 /* LDIC into IR */
683 xscale_jtag_set_instr(target->tap,
684 XSCALE_LDIC << xscale->xscale_variant,
685 TAP_IDLE);
686
687 /* CMD is b011 to load a cacheline into the Mini ICache.
688 * Loading into the main ICache is deprecated, and unused.
689 * It's followed by three zero bits, and 27 address bits.
690 */
691 buf_set_u32(&cmd, 0, 6, 0x3);
692
693 /* virtual address of desired cache line */
694 buf_set_u32(packet, 0, 27, va >> 5);
695
696 memset(&fields, 0, sizeof fields);
697
698 fields[0].num_bits = 6;
699 fields[0].out_value = &cmd;
700
701 fields[1].num_bits = 27;
702 fields[1].out_value = packet;
703
704 jtag_add_dr_scan(target->tap, 2, fields, TAP_IDLE);
705
706 /* rest of packet is a cacheline: 8 instructions, with parity */
707 fields[0].num_bits = 32;
708 fields[0].out_value = packet;
709
710 fields[1].num_bits = 1;
711 fields[1].out_value = &cmd;
712
713 for (word = 0; word < 8; word++)
714 {
715 buf_set_u32(packet, 0, 32, buffer[word]);
716
717 uint32_t value;
718 memcpy(&value, packet, sizeof(uint32_t));
719 cmd = parity(value);
720
721 jtag_add_dr_scan(target->tap, 2, fields, TAP_IDLE);
722 }
723
724 return jtag_execute_queue();
725 }
726
727 static int xscale_invalidate_ic_line(struct target *target, uint32_t va)
728 {
729 struct xscale_common *xscale = target_to_xscale(target);
730 uint8_t packet[4];
731 uint8_t cmd;
732 struct scan_field fields[2];
733
734 xscale_jtag_set_instr(target->tap,
735 XSCALE_LDIC << xscale->xscale_variant,
736 TAP_IDLE);
737
738 /* CMD for invalidate IC line b000, bits [6:4] b000 */
739 buf_set_u32(&cmd, 0, 6, 0x0);
740
741 /* virtual address of desired cache line */
742 buf_set_u32(packet, 0, 27, va >> 5);
743
744 memset(&fields, 0, sizeof fields);
745
746 fields[0].num_bits = 6;
747 fields[0].out_value = &cmd;
748
749 fields[1].num_bits = 27;
750 fields[1].out_value = packet;
751
752 jtag_add_dr_scan(target->tap, 2, fields, TAP_IDLE);
753
754 return ERROR_OK;
755 }
756
757 static int xscale_update_vectors(struct target *target)
758 {
759 struct xscale_common *xscale = target_to_xscale(target);
760 int i;
761 int retval;
762
763 uint32_t low_reset_branch, high_reset_branch;
764
765 for (i = 1; i < 8; i++)
766 {
767 /* if there's a static vector specified for this exception, override */
768 if (xscale->static_high_vectors_set & (1 << i))
769 {
770 xscale->high_vectors[i] = xscale->static_high_vectors[i];
771 }
772 else
773 {
774 retval = target_read_u32(target, 0xffff0000 + 4*i, &xscale->high_vectors[i]);
775 if (retval == ERROR_TARGET_TIMEOUT)
776 return retval;
777 if (retval != ERROR_OK)
778 {
779 /* Some of these reads will fail as part of normal execution */
780 xscale->high_vectors[i] = ARMV4_5_B(0xfffffe, 0);
781 }
782 }
783 }
784
785 for (i = 1; i < 8; i++)
786 {
787 if (xscale->static_low_vectors_set & (1 << i))
788 {
789 xscale->low_vectors[i] = xscale->static_low_vectors[i];
790 }
791 else
792 {
793 retval = target_read_u32(target, 0x0 + 4*i, &xscale->low_vectors[i]);
794 if (retval == ERROR_TARGET_TIMEOUT)
795 return retval;
796 if (retval != ERROR_OK)
797 {
798 /* Some of these reads will fail as part of normal execution */
799 xscale->low_vectors[i] = ARMV4_5_B(0xfffffe, 0);
800 }
801 }
802 }
803
804 /* calculate branches to debug handler */
805 low_reset_branch = (xscale->handler_address + 0x20 - 0x0 - 0x8) >> 2;
806 high_reset_branch = (xscale->handler_address + 0x20 - 0xffff0000 - 0x8) >> 2;
807
808 xscale->low_vectors[0] = ARMV4_5_B((low_reset_branch & 0xffffff), 0);
809 xscale->high_vectors[0] = ARMV4_5_B((high_reset_branch & 0xffffff), 0);
810
811 /* invalidate and load exception vectors in mini i-cache */
812 xscale_invalidate_ic_line(target, 0x0);
813 xscale_invalidate_ic_line(target, 0xffff0000);
814
815 xscale_load_ic(target, 0x0, xscale->low_vectors);
816 xscale_load_ic(target, 0xffff0000, xscale->high_vectors);
817
818 return ERROR_OK;
819 }
820
821 static int xscale_arch_state(struct target *target)
822 {
823 struct xscale_common *xscale = target_to_xscale(target);
824 struct arm *armv4_5 = &xscale->armv4_5_common;
825
826 static const char *state[] =
827 {
828 "disabled", "enabled"
829 };
830
831 static const char *arch_dbg_reason[] =
832 {
833 "", "\n(processor reset)", "\n(trace buffer full)"
834 };
835
836 if (armv4_5->common_magic != ARM_COMMON_MAGIC)
837 {
838 LOG_ERROR("BUG: called for a non-ARMv4/5 target");
839 return ERROR_INVALID_ARGUMENTS;
840 }
841
842 arm_arch_state(target);
843 LOG_USER("MMU: %s, D-Cache: %s, I-Cache: %s%s",
844 state[xscale->armv4_5_mmu.mmu_enabled],
845 state[xscale->armv4_5_mmu.armv4_5_cache.d_u_cache_enabled],
846 state[xscale->armv4_5_mmu.armv4_5_cache.i_cache_enabled],
847 arch_dbg_reason[xscale->arch_debug_reason]);
848
849 return ERROR_OK;
850 }
851
852 static int xscale_poll(struct target *target)
853 {
854 int retval = ERROR_OK;
855
856 if ((target->state == TARGET_RUNNING) || (target->state == TARGET_DEBUG_RUNNING))
857 {
858 enum target_state previous_state = target->state;
859 if ((retval = xscale_read_tx(target, 0)) == ERROR_OK)
860 {
861
862 /* there's data to read from the tx register, we entered debug state */
863 target->state = TARGET_HALTED;
864
865 /* process debug entry, fetching current mode regs */
866 retval = xscale_debug_entry(target);
867 }
868 else if (retval != ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
869 {
870 LOG_USER("error while polling TX register, reset CPU");
871 /* here we "lie" so GDB won't get stuck and a reset can be perfomed */
872 target->state = TARGET_HALTED;
873 }
874
875 /* debug_entry could have overwritten target state (i.e. immediate resume)
876 * don't signal event handlers in that case
877 */
878 if (target->state != TARGET_HALTED)
879 return ERROR_OK;
880
881 /* if target was running, signal that we halted
882 * otherwise we reentered from debug execution */
883 if (previous_state == TARGET_RUNNING)
884 target_call_event_callbacks(target, TARGET_EVENT_HALTED);
885 else
886 target_call_event_callbacks(target, TARGET_EVENT_DEBUG_HALTED);
887 }
888
889 return retval;
890 }
891
892 static int xscale_debug_entry(struct target *target)
893 {
894 struct xscale_common *xscale = target_to_xscale(target);
895 struct arm *armv4_5 = &xscale->armv4_5_common;
896 uint32_t pc;
897 uint32_t buffer[10];
898 unsigned i;
899 int retval;
900 uint32_t moe;
901
902 /* clear external dbg break (will be written on next DCSR read) */
903 xscale->external_debug_break = 0;
904 if ((retval = xscale_read_dcsr(target)) != ERROR_OK)
905 return retval;
906
907 /* get r0, pc, r1 to r7 and cpsr */
908 if ((retval = xscale_receive(target, buffer, 10)) != ERROR_OK)
909 return retval;
910
911 /* move r0 from buffer to register cache */
912 buf_set_u32(armv4_5->core_cache->reg_list[0].value, 0, 32, buffer[0]);
913 armv4_5->core_cache->reg_list[0].dirty = 1;
914 armv4_5->core_cache->reg_list[0].valid = 1;
915 LOG_DEBUG("r0: 0x%8.8" PRIx32 "", buffer[0]);
916
917 /* move pc from buffer to register cache */
918 buf_set_u32(armv4_5->pc->value, 0, 32, buffer[1]);
919 armv4_5->pc->dirty = 1;
920 armv4_5->pc->valid = 1;
921 LOG_DEBUG("pc: 0x%8.8" PRIx32 "", buffer[1]);
922
923 /* move data from buffer to register cache */
924 for (i = 1; i <= 7; i++)
925 {
926 buf_set_u32(armv4_5->core_cache->reg_list[i].value, 0, 32, buffer[1 + i]);
927 armv4_5->core_cache->reg_list[i].dirty = 1;
928 armv4_5->core_cache->reg_list[i].valid = 1;
929 LOG_DEBUG("r%i: 0x%8.8" PRIx32 "", i, buffer[i + 1]);
930 }
931
932 arm_set_cpsr(armv4_5, buffer[9]);
933 LOG_DEBUG("cpsr: 0x%8.8" PRIx32 "", buffer[9]);
934
935 if (!is_arm_mode(armv4_5->core_mode))
936 {
937 target->state = TARGET_UNKNOWN;
938 LOG_ERROR("cpsr contains invalid mode value - communication failure");
939 return ERROR_TARGET_FAILURE;
940 }
941 LOG_DEBUG("target entered debug state in %s mode",
942 arm_mode_name(armv4_5->core_mode));
943
944 /* get banked registers, r8 to r14, and spsr if not in USR/SYS mode */
945 if (armv4_5->spsr) {
946 xscale_receive(target, buffer, 8);
947 buf_set_u32(armv4_5->spsr->value, 0, 32, buffer[7]);
948 armv4_5->spsr->dirty = false;
949 armv4_5->spsr->valid = true;
950 }
951 else
952 {
953 /* r8 to r14, but no spsr */
954 xscale_receive(target, buffer, 7);
955 }
956
957 /* move data from buffer to right banked register in cache */
958 for (i = 8; i <= 14; i++)
959 {
960 struct reg *r = arm_reg_current(armv4_5, i);
961
962 buf_set_u32(r->value, 0, 32, buffer[i - 8]);
963 r->dirty = false;
964 r->valid = true;
965 }
966
967 /* mark xscale regs invalid to ensure they are retrieved from the
968 * debug handler if requested */
969 for (i = 0; i < xscale->reg_cache->num_regs; i++)
970 xscale->reg_cache->reg_list[i].valid = 0;
971
972 /* examine debug reason */
973 xscale_read_dcsr(target);
974 moe = buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 2, 3);
975
976 /* stored PC (for calculating fixup) */
977 pc = buf_get_u32(armv4_5->pc->value, 0, 32);
978
979 switch (moe)
980 {
981 case 0x0: /* Processor reset */
982 target->debug_reason = DBG_REASON_DBGRQ;
983 xscale->arch_debug_reason = XSCALE_DBG_REASON_RESET;
984 pc -= 4;
985 break;
986 case 0x1: /* Instruction breakpoint hit */
987 target->debug_reason = DBG_REASON_BREAKPOINT;
988 xscale->arch_debug_reason = XSCALE_DBG_REASON_GENERIC;
989 pc -= 4;
990 break;
991 case 0x2: /* Data breakpoint hit */
992 target->debug_reason = DBG_REASON_WATCHPOINT;
993 xscale->arch_debug_reason = XSCALE_DBG_REASON_GENERIC;
994 pc -= 4;
995 break;
996 case 0x3: /* BKPT instruction executed */
997 target->debug_reason = DBG_REASON_BREAKPOINT;
998 xscale->arch_debug_reason = XSCALE_DBG_REASON_GENERIC;
999 pc -= 4;
1000 break;
1001 case 0x4: /* Ext. debug event */
1002 target->debug_reason = DBG_REASON_DBGRQ;
1003 xscale->arch_debug_reason = XSCALE_DBG_REASON_GENERIC;
1004 pc -= 4;
1005 break;
1006 case 0x5: /* Vector trap occured */
1007 target->debug_reason = DBG_REASON_BREAKPOINT;
1008 xscale->arch_debug_reason = XSCALE_DBG_REASON_GENERIC;
1009 pc -= 4;
1010 break;
1011 case 0x6: /* Trace buffer full break */
1012 target->debug_reason = DBG_REASON_DBGRQ;
1013 xscale->arch_debug_reason = XSCALE_DBG_REASON_TB_FULL;
1014 pc -= 4;
1015 break;
1016 case 0x7: /* Reserved (may flag Hot-Debug support) */
1017 default:
1018 LOG_ERROR("Method of Entry is 'Reserved'");
1019 exit(-1);
1020 break;
1021 }
1022
1023 /* apply PC fixup */
1024 buf_set_u32(armv4_5->pc->value, 0, 32, pc);
1025
1026 /* on the first debug entry, identify cache type */
1027 if (xscale->armv4_5_mmu.armv4_5_cache.ctype == -1)
1028 {
1029 uint32_t cache_type_reg;
1030
1031 /* read cp15 cache type register */
1032 xscale_get_reg(&xscale->reg_cache->reg_list[XSCALE_CACHETYPE]);
1033 cache_type_reg = buf_get_u32(xscale->reg_cache->reg_list[XSCALE_CACHETYPE].value, 0, 32);
1034
1035 armv4_5_identify_cache(cache_type_reg, &xscale->armv4_5_mmu.armv4_5_cache);
1036 }
1037
1038 /* examine MMU and Cache settings */
1039 /* read cp15 control register */
1040 xscale_get_reg(&xscale->reg_cache->reg_list[XSCALE_CTRL]);
1041 xscale->cp15_control_reg = buf_get_u32(xscale->reg_cache->reg_list[XSCALE_CTRL].value, 0, 32);
1042 xscale->armv4_5_mmu.mmu_enabled = (xscale->cp15_control_reg & 0x1U) ? 1 : 0;
1043 xscale->armv4_5_mmu.armv4_5_cache.d_u_cache_enabled = (xscale->cp15_control_reg & 0x4U) ? 1 : 0;
1044 xscale->armv4_5_mmu.armv4_5_cache.i_cache_enabled = (xscale->cp15_control_reg & 0x1000U) ? 1 : 0;
1045
1046 /* tracing enabled, read collected trace data */
1047 if (xscale->trace.mode != XSCALE_TRACE_DISABLED)
1048 {
1049 xscale_read_trace(target);
1050
1051 /* Resume if entered debug due to buffer fill and we're still collecting
1052 * trace data. Note that a debug exception due to trace buffer full
1053 * can only happen in fill mode. */
1054 if (xscale->arch_debug_reason == XSCALE_DBG_REASON_TB_FULL)
1055 {
1056 if (--xscale->trace.fill_counter > 0)
1057 xscale_resume(target, 1, 0x0, 1, 0);
1058 }
1059 else /* entered debug for other reason; reset counter */
1060 xscale->trace.fill_counter = 0;
1061 }
1062
1063 return ERROR_OK;
1064 }
1065
1066 static int xscale_halt(struct target *target)
1067 {
1068 struct xscale_common *xscale = target_to_xscale(target);
1069
1070 LOG_DEBUG("target->state: %s",
1071 target_state_name(target));
1072
1073 if (target->state == TARGET_HALTED)
1074 {
1075 LOG_DEBUG("target was already halted");
1076 return ERROR_OK;
1077 }
1078 else if (target->state == TARGET_UNKNOWN)
1079 {
1080 /* this must not happen for a xscale target */
1081 LOG_ERROR("target was in unknown state when halt was requested");
1082 return ERROR_TARGET_INVALID;
1083 }
1084 else if (target->state == TARGET_RESET)
1085 {
1086 LOG_DEBUG("target->state == TARGET_RESET");
1087 }
1088 else
1089 {
1090 /* assert external dbg break */
1091 xscale->external_debug_break = 1;
1092 xscale_read_dcsr(target);
1093
1094 target->debug_reason = DBG_REASON_DBGRQ;
1095 }
1096
1097 return ERROR_OK;
1098 }
1099
1100 static int xscale_enable_single_step(struct target *target, uint32_t next_pc)
1101 {
1102 struct xscale_common *xscale = target_to_xscale(target);
1103 struct reg *ibcr0 = &xscale->reg_cache->reg_list[XSCALE_IBCR0];
1104 int retval;
1105
1106 if (xscale->ibcr0_used)
1107 {
1108 struct breakpoint *ibcr0_bp = breakpoint_find(target, buf_get_u32(ibcr0->value, 0, 32) & 0xfffffffe);
1109
1110 if (ibcr0_bp)
1111 {
1112 xscale_unset_breakpoint(target, ibcr0_bp);
1113 }
1114 else
1115 {
1116 LOG_ERROR("BUG: xscale->ibcr0_used is set, but no breakpoint with that address found");
1117 exit(-1);
1118 }
1119 }
1120
1121 if ((retval = xscale_set_reg_u32(ibcr0, next_pc | 0x1)) != ERROR_OK)
1122 return retval;
1123
1124 return ERROR_OK;
1125 }
1126
1127 static int xscale_disable_single_step(struct target *target)
1128 {
1129 struct xscale_common *xscale = target_to_xscale(target);
1130 struct reg *ibcr0 = &xscale->reg_cache->reg_list[XSCALE_IBCR0];
1131 int retval;
1132
1133 if ((retval = xscale_set_reg_u32(ibcr0, 0x0)) != ERROR_OK)
1134 return retval;
1135
1136 return ERROR_OK;
1137 }
1138
1139 static void xscale_enable_watchpoints(struct target *target)
1140 {
1141 struct watchpoint *watchpoint = target->watchpoints;
1142
1143 while (watchpoint)
1144 {
1145 if (watchpoint->set == 0)
1146 xscale_set_watchpoint(target, watchpoint);
1147 watchpoint = watchpoint->next;
1148 }
1149 }
1150
1151 static void xscale_enable_breakpoints(struct target *target)
1152 {
1153 struct breakpoint *breakpoint = target->breakpoints;
1154
1155 /* set any pending breakpoints */
1156 while (breakpoint)
1157 {
1158 if (breakpoint->set == 0)
1159 xscale_set_breakpoint(target, breakpoint);
1160 breakpoint = breakpoint->next;
1161 }
1162 }
1163
1164 static void xscale_free_trace_data(struct xscale_common *xscale)
1165 {
1166 struct xscale_trace_data *td = xscale->trace.data;
1167 while (td)
1168 {
1169 struct xscale_trace_data *next_td = td->next;
1170 if (td->entries)
1171 free(td->entries);
1172 free(td);
1173 td = next_td;
1174 }
1175 xscale->trace.data = NULL;
1176 }
1177
1178 static int xscale_resume(struct target *target, int current,
1179 uint32_t address, int handle_breakpoints, int debug_execution)
1180 {
1181 struct xscale_common *xscale = target_to_xscale(target);
1182 struct arm *armv4_5 = &xscale->armv4_5_common;
1183 struct breakpoint *breakpoint = target->breakpoints;
1184 uint32_t current_pc;
1185 int retval;
1186 int i;
1187
1188 LOG_DEBUG("-");
1189
1190 if (target->state != TARGET_HALTED)
1191 {
1192 LOG_WARNING("target not halted");
1193 return ERROR_TARGET_NOT_HALTED;
1194 }
1195
1196 if (!debug_execution)
1197 {
1198 target_free_all_working_areas(target);
1199 }
1200
1201 /* update vector tables */
1202 if ((retval = xscale_update_vectors(target)) != ERROR_OK)
1203 return retval;
1204
1205 /* current = 1: continue on current pc, otherwise continue at <address> */
1206 if (!current)
1207 buf_set_u32(armv4_5->pc->value, 0, 32, address);
1208
1209 current_pc = buf_get_u32(armv4_5->pc->value, 0, 32);
1210
1211 /* if we're at the reset vector, we have to simulate the branch */
1212 if (current_pc == 0x0)
1213 {
1214 arm_simulate_step(target, NULL);
1215 current_pc = buf_get_u32(armv4_5->pc->value, 0, 32);
1216 }
1217
1218 /* the front-end may request us not to handle breakpoints */
1219 if (handle_breakpoints)
1220 {
1221 breakpoint = breakpoint_find(target,
1222 buf_get_u32(armv4_5->pc->value, 0, 32));
1223 if (breakpoint != NULL)
1224 {
1225 uint32_t next_pc;
1226 enum trace_mode saved_trace_mode;
1227
1228 /* there's a breakpoint at the current PC, we have to step over it */
1229 LOG_DEBUG("unset breakpoint at 0x%8.8" PRIx32 "", breakpoint->address);
1230 xscale_unset_breakpoint(target, breakpoint);
1231
1232 /* calculate PC of next instruction */
1233 if ((retval = arm_simulate_step(target, &next_pc)) != ERROR_OK)
1234 {
1235 uint32_t current_opcode;
1236 target_read_u32(target, current_pc, &current_opcode);
1237 LOG_ERROR("BUG: couldn't calculate PC of next instruction, current opcode was 0x%8.8" PRIx32 "", current_opcode);
1238 }
1239
1240 LOG_DEBUG("enable single-step");
1241 xscale_enable_single_step(target, next_pc);
1242
1243 /* restore banked registers */
1244 retval = xscale_restore_banked(target);
1245
1246 /* send resume request */
1247 xscale_send_u32(target, 0x30);
1248
1249 /* send CPSR */
1250 xscale_send_u32(target,
1251 buf_get_u32(armv4_5->cpsr->value, 0, 32));
1252 LOG_DEBUG("writing cpsr with value 0x%8.8" PRIx32,
1253 buf_get_u32(armv4_5->cpsr->value, 0, 32));
1254
1255 for (i = 7; i >= 0; i--)
1256 {
1257 /* send register */
1258 xscale_send_u32(target, buf_get_u32(armv4_5->core_cache->reg_list[i].value, 0, 32));
1259 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));
1260 }
1261
1262 /* send PC */
1263 xscale_send_u32(target,
1264 buf_get_u32(armv4_5->pc->value, 0, 32));
1265 LOG_DEBUG("writing PC with value 0x%8.8" PRIx32,
1266 buf_get_u32(armv4_5->pc->value, 0, 32));
1267
1268 /* disable trace data collection in xscale_debug_entry() */
1269 saved_trace_mode = xscale->trace.mode;
1270 xscale->trace.mode = XSCALE_TRACE_DISABLED;
1271
1272 /* wait for and process debug entry */
1273 xscale_debug_entry(target);
1274
1275 /* re-enable trace buffer, if enabled previously */
1276 xscale->trace.mode = saved_trace_mode;
1277
1278 LOG_DEBUG("disable single-step");
1279 xscale_disable_single_step(target);
1280
1281 LOG_DEBUG("set breakpoint at 0x%8.8" PRIx32 "", breakpoint->address);
1282 xscale_set_breakpoint(target, breakpoint);
1283 }
1284 }
1285
1286 /* enable any pending breakpoints and watchpoints */
1287 xscale_enable_breakpoints(target);
1288 xscale_enable_watchpoints(target);
1289
1290 /* restore banked registers */
1291 retval = xscale_restore_banked(target);
1292
1293 /* send resume request (command 0x30 or 0x31)
1294 * clean the trace buffer if it is to be enabled (0x62) */
1295 if (xscale->trace.mode != XSCALE_TRACE_DISABLED)
1296 {
1297 if (xscale->trace.mode == XSCALE_TRACE_FILL)
1298 {
1299 /* If trace enabled in fill mode and starting collection of new set
1300 * of buffers, initialize buffer counter and free previous buffers */
1301 if (xscale->trace.fill_counter == 0)
1302 {
1303 xscale->trace.fill_counter = xscale->trace.buffer_fill;
1304 xscale_free_trace_data(xscale);
1305 }
1306 }
1307 else /* wrap mode; free previous buffer */
1308 xscale_free_trace_data(xscale);
1309
1310 xscale_send_u32(target, 0x62);
1311 xscale_send_u32(target, 0x31);
1312 }
1313 else
1314 xscale_send_u32(target, 0x30);
1315
1316 /* send CPSR */
1317 xscale_send_u32(target, buf_get_u32(armv4_5->cpsr->value, 0, 32));
1318 LOG_DEBUG("writing cpsr with value 0x%8.8" PRIx32,
1319 buf_get_u32(armv4_5->cpsr->value, 0, 32));
1320
1321 for (i = 7; i >= 0; i--)
1322 {
1323 /* send register */
1324 xscale_send_u32(target, buf_get_u32(armv4_5->core_cache->reg_list[i].value, 0, 32));
1325 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));
1326 }
1327
1328 /* send PC */
1329 xscale_send_u32(target, buf_get_u32(armv4_5->pc->value, 0, 32));
1330 LOG_DEBUG("wrote PC with value 0x%8.8" PRIx32,
1331 buf_get_u32(armv4_5->pc->value, 0, 32));
1332
1333 target->debug_reason = DBG_REASON_NOTHALTED;
1334
1335 if (!debug_execution)
1336 {
1337 /* registers are now invalid */
1338 register_cache_invalidate(armv4_5->core_cache);
1339 target->state = TARGET_RUNNING;
1340 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
1341 }
1342 else
1343 {
1344 target->state = TARGET_DEBUG_RUNNING;
1345 target_call_event_callbacks(target, TARGET_EVENT_DEBUG_RESUMED);
1346 }
1347
1348 LOG_DEBUG("target resumed");
1349
1350 return ERROR_OK;
1351 }
1352
1353 static int xscale_step_inner(struct target *target, int current,
1354 uint32_t address, int handle_breakpoints)
1355 {
1356 struct xscale_common *xscale = target_to_xscale(target);
1357 struct arm *armv4_5 = &xscale->armv4_5_common;
1358 uint32_t next_pc;
1359 int retval;
1360 int i;
1361
1362 target->debug_reason = DBG_REASON_SINGLESTEP;
1363
1364 /* calculate PC of next instruction */
1365 if ((retval = arm_simulate_step(target, &next_pc)) != ERROR_OK)
1366 {
1367 uint32_t current_opcode, current_pc;
1368 current_pc = buf_get_u32(armv4_5->pc->value, 0, 32);
1369
1370 target_read_u32(target, current_pc, &current_opcode);
1371 LOG_ERROR("BUG: couldn't calculate PC of next instruction, current opcode was 0x%8.8" PRIx32 "", current_opcode);
1372 return retval;
1373 }
1374
1375 LOG_DEBUG("enable single-step");
1376 if ((retval = xscale_enable_single_step(target, next_pc)) != ERROR_OK)
1377 return retval;
1378
1379 /* restore banked registers */
1380 if ((retval = xscale_restore_banked(target)) != ERROR_OK)
1381 return retval;
1382
1383 /* send resume request (command 0x30 or 0x31)
1384 * clean the trace buffer if it is to be enabled (0x62) */
1385 if (xscale->trace.mode != XSCALE_TRACE_DISABLED)
1386 {
1387 if ((retval = xscale_send_u32(target, 0x62)) != ERROR_OK)
1388 return retval;
1389 if ((retval = xscale_send_u32(target, 0x31)) != ERROR_OK)
1390 return retval;
1391 }
1392 else
1393 if ((retval = xscale_send_u32(target, 0x30)) != ERROR_OK)
1394 return retval;
1395
1396 /* send CPSR */
1397 retval = xscale_send_u32(target,
1398 buf_get_u32(armv4_5->cpsr->value, 0, 32));
1399 if (retval != ERROR_OK)
1400 return retval;
1401 LOG_DEBUG("writing cpsr with value 0x%8.8" PRIx32,
1402 buf_get_u32(armv4_5->cpsr->value, 0, 32));
1403
1404 for (i = 7; i >= 0; i--)
1405 {
1406 /* send register */
1407 if ((retval = xscale_send_u32(target, buf_get_u32(armv4_5->core_cache->reg_list[i].value, 0, 32))) != ERROR_OK)
1408 return retval;
1409 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));
1410 }
1411
1412 /* send PC */
1413 retval = xscale_send_u32(target,
1414 buf_get_u32(armv4_5->pc->value, 0, 32));
1415 if (retval != ERROR_OK)
1416 return retval;
1417 LOG_DEBUG("wrote PC with value 0x%8.8" PRIx32,
1418 buf_get_u32(armv4_5->pc->value, 0, 32));
1419
1420 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
1421
1422 /* registers are now invalid */
1423 register_cache_invalidate(armv4_5->core_cache);
1424
1425 /* wait for and process debug entry */
1426 if ((retval = xscale_debug_entry(target)) != ERROR_OK)
1427 return retval;
1428
1429 LOG_DEBUG("disable single-step");
1430 if ((retval = xscale_disable_single_step(target)) != ERROR_OK)
1431 return retval;
1432
1433 target_call_event_callbacks(target, TARGET_EVENT_HALTED);
1434
1435 return ERROR_OK;
1436 }
1437
1438 static int xscale_step(struct target *target, int current,
1439 uint32_t address, int handle_breakpoints)
1440 {
1441 struct arm *armv4_5 = target_to_arm(target);
1442 struct breakpoint *breakpoint = NULL;
1443
1444 uint32_t current_pc;
1445 int retval;
1446
1447 if (target->state != TARGET_HALTED)
1448 {
1449 LOG_WARNING("target not halted");
1450 return ERROR_TARGET_NOT_HALTED;
1451 }
1452
1453 /* current = 1: continue on current pc, otherwise continue at <address> */
1454 if (!current)
1455 buf_set_u32(armv4_5->pc->value, 0, 32, address);
1456
1457 current_pc = buf_get_u32(armv4_5->pc->value, 0, 32);
1458
1459 /* if we're at the reset vector, we have to simulate the step */
1460 if (current_pc == 0x0)
1461 {
1462 if ((retval = arm_simulate_step(target, NULL)) != ERROR_OK)
1463 return retval;
1464 current_pc = buf_get_u32(armv4_5->pc->value, 0, 32);
1465
1466 target->debug_reason = DBG_REASON_SINGLESTEP;
1467 target_call_event_callbacks(target, TARGET_EVENT_HALTED);
1468
1469 return ERROR_OK;
1470 }
1471
1472 /* the front-end may request us not to handle breakpoints */
1473 if (handle_breakpoints)
1474 breakpoint = breakpoint_find(target,
1475 buf_get_u32(armv4_5->pc->value, 0, 32));
1476 if (breakpoint != NULL) {
1477 retval = xscale_unset_breakpoint(target, breakpoint);
1478 if (retval != ERROR_OK)
1479 return retval;
1480 }
1481
1482 retval = xscale_step_inner(target, current, address, handle_breakpoints);
1483
1484 if (breakpoint)
1485 {
1486 xscale_set_breakpoint(target, breakpoint);
1487 }
1488
1489 LOG_DEBUG("target stepped");
1490
1491 return ERROR_OK;
1492
1493 }
1494
1495 static int xscale_assert_reset(struct target *target)
1496 {
1497 struct xscale_common *xscale = target_to_xscale(target);
1498
1499 LOG_DEBUG("target->state: %s",
1500 target_state_name(target));
1501
1502 /* select DCSR instruction (set endstate to R-T-I to ensure we don't
1503 * end up in T-L-R, which would reset JTAG
1504 */
1505 xscale_jtag_set_instr(target->tap,
1506 XSCALE_SELDCSR << xscale->xscale_variant,
1507 TAP_IDLE);
1508
1509 /* set Hold reset, Halt mode and Trap Reset */
1510 buf_set_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 30, 1, 0x1);
1511 buf_set_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 16, 1, 0x1);
1512 xscale_write_dcsr(target, 1, 0);
1513
1514 /* select BYPASS, because having DCSR selected caused problems on the PXA27x */
1515 xscale_jtag_set_instr(target->tap, ~0, TAP_IDLE);
1516 jtag_execute_queue();
1517
1518 /* assert reset */
1519 jtag_add_reset(0, 1);
1520
1521 /* sleep 1ms, to be sure we fulfill any requirements */
1522 jtag_add_sleep(1000);
1523 jtag_execute_queue();
1524
1525 target->state = TARGET_RESET;
1526
1527 if (target->reset_halt)
1528 {
1529 int retval;
1530 if ((retval = target_halt(target)) != ERROR_OK)
1531 return retval;
1532 }
1533
1534 return ERROR_OK;
1535 }
1536
1537 static int xscale_deassert_reset(struct target *target)
1538 {
1539 struct xscale_common *xscale = target_to_xscale(target);
1540 struct breakpoint *breakpoint = target->breakpoints;
1541
1542 LOG_DEBUG("-");
1543
1544 xscale->ibcr_available = 2;
1545 xscale->ibcr0_used = 0;
1546 xscale->ibcr1_used = 0;
1547
1548 xscale->dbr_available = 2;
1549 xscale->dbr0_used = 0;
1550 xscale->dbr1_used = 0;
1551
1552 /* mark all hardware breakpoints as unset */
1553 while (breakpoint)
1554 {
1555 if (breakpoint->type == BKPT_HARD)
1556 {
1557 breakpoint->set = 0;
1558 }
1559 breakpoint = breakpoint->next;
1560 }
1561
1562 xscale->trace.mode = XSCALE_TRACE_DISABLED;
1563 xscale_free_trace_data(xscale);
1564
1565 register_cache_invalidate(xscale->armv4_5_common.core_cache);
1566
1567 /* FIXME mark hardware watchpoints got unset too. Also,
1568 * at least some of the XScale registers are invalid...
1569 */
1570
1571 /*
1572 * REVISIT: *assumes* we had a SRST+TRST reset so the mini-icache
1573 * contents got invalidated. Safer to force that, so writing new
1574 * contents can't ever fail..
1575 */
1576 {
1577 uint32_t address;
1578 unsigned buf_cnt;
1579 const uint8_t *buffer = xscale_debug_handler;
1580 int retval;
1581
1582 /* release SRST */
1583 jtag_add_reset(0, 0);
1584
1585 /* wait 300ms; 150 and 100ms were not enough */
1586 jtag_add_sleep(300*1000);
1587
1588 jtag_add_runtest(2030, TAP_IDLE);
1589 jtag_execute_queue();
1590
1591 /* set Hold reset, Halt mode and Trap Reset */
1592 buf_set_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 30, 1, 0x1);
1593 buf_set_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 16, 1, 0x1);
1594 xscale_write_dcsr(target, 1, 0);
1595
1596 /* Load the debug handler into the mini-icache. Since
1597 * it's using halt mode (not monitor mode), it runs in
1598 * "Special Debug State" for access to registers, memory,
1599 * coprocessors, trace data, etc.
1600 */
1601 address = xscale->handler_address;
1602 for (unsigned binary_size = sizeof xscale_debug_handler - 1;
1603 binary_size > 0;
1604 binary_size -= buf_cnt, buffer += buf_cnt)
1605 {
1606 uint32_t cache_line[8];
1607 unsigned i;
1608
1609 buf_cnt = binary_size;
1610 if (buf_cnt > 32)
1611 buf_cnt = 32;
1612
1613 for (i = 0; i < buf_cnt; i += 4)
1614 {
1615 /* convert LE buffer to host-endian uint32_t */
1616 cache_line[i / 4] = le_to_h_u32(&buffer[i]);
1617 }
1618
1619 for (; i < 32; i += 4)
1620 {
1621 cache_line[i / 4] = 0xe1a08008;
1622 }
1623
1624 /* only load addresses other than the reset vectors */
1625 if ((address % 0x400) != 0x0)
1626 {
1627 retval = xscale_load_ic(target, address,
1628 cache_line);
1629 if (retval != ERROR_OK)
1630 return retval;
1631 }
1632
1633 address += buf_cnt;
1634 };
1635
1636 retval = xscale_load_ic(target, 0x0,
1637 xscale->low_vectors);
1638 if (retval != ERROR_OK)
1639 return retval;
1640 retval = xscale_load_ic(target, 0xffff0000,
1641 xscale->high_vectors);
1642 if (retval != ERROR_OK)
1643 return retval;
1644
1645 jtag_add_runtest(30, TAP_IDLE);
1646
1647 jtag_add_sleep(100000);
1648
1649 /* set Hold reset, Halt mode and Trap Reset */
1650 buf_set_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 30, 1, 0x1);
1651 buf_set_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 16, 1, 0x1);
1652 xscale_write_dcsr(target, 1, 0);
1653
1654 /* clear Hold reset to let the target run (should enter debug handler) */
1655 xscale_write_dcsr(target, 0, 1);
1656 target->state = TARGET_RUNNING;
1657
1658 if (!target->reset_halt)
1659 {
1660 jtag_add_sleep(10000);
1661
1662 /* we should have entered debug now */
1663 xscale_debug_entry(target);
1664 target->state = TARGET_HALTED;
1665
1666 /* resume the target */
1667 xscale_resume(target, 1, 0x0, 1, 0);
1668 }
1669 }
1670
1671 return ERROR_OK;
1672 }
1673
1674 static int xscale_read_core_reg(struct target *target, struct reg *r,
1675 int num, enum arm_mode mode)
1676 {
1677 /** \todo add debug handler support for core register reads */
1678 LOG_ERROR("not implemented");
1679 return ERROR_OK;
1680 }
1681
1682 static int xscale_write_core_reg(struct target *target, struct reg *r,
1683 int num, enum arm_mode mode, uint32_t value)
1684 {
1685 /** \todo add debug handler support for core register writes */
1686 LOG_ERROR("not implemented");
1687 return ERROR_OK;
1688 }
1689
1690 static int xscale_full_context(struct target *target)
1691 {
1692 struct arm *armv4_5 = target_to_arm(target);
1693
1694 uint32_t *buffer;
1695
1696 int i, j;
1697
1698 LOG_DEBUG("-");
1699
1700 if (target->state != TARGET_HALTED)
1701 {
1702 LOG_WARNING("target not halted");
1703 return ERROR_TARGET_NOT_HALTED;
1704 }
1705
1706 buffer = malloc(4 * 8);
1707
1708 /* iterate through processor modes (FIQ, IRQ, SVC, ABT, UND and SYS)
1709 * we can't enter User mode on an XScale (unpredictable),
1710 * but User shares registers with SYS
1711 */
1712 for (i = 1; i < 7; i++)
1713 {
1714 enum arm_mode mode = armv4_5_number_to_mode(i);
1715 bool valid = true;
1716 struct reg *r;
1717
1718 if (mode == ARM_MODE_USR)
1719 continue;
1720
1721 /* check if there are invalid registers in the current mode
1722 */
1723 for (j = 0; valid && j <= 16; j++)
1724 {
1725 if (!ARMV4_5_CORE_REG_MODE(armv4_5->core_cache,
1726 mode, j).valid)
1727 valid = false;
1728 }
1729 if (valid)
1730 continue;
1731
1732 /* request banked registers */
1733 xscale_send_u32(target, 0x0);
1734
1735 /* send CPSR for desired bank mode */
1736 xscale_send_u32(target, mode | 0xc0 /* I/F bits */);
1737
1738 /* get banked registers: r8 to r14; and SPSR
1739 * except in USR/SYS mode
1740 */
1741 if (mode != ARM_MODE_SYS) {
1742 /* SPSR */
1743 r = &ARMV4_5_CORE_REG_MODE(armv4_5->core_cache,
1744 mode, 16);
1745
1746 xscale_receive(target, buffer, 8);
1747
1748 buf_set_u32(r->value, 0, 32, buffer[7]);
1749 r->dirty = false;
1750 r->valid = true;
1751 } else {
1752 xscale_receive(target, buffer, 7);
1753 }
1754
1755 /* move data from buffer to register cache */
1756 for (j = 8; j <= 14; j++)
1757 {
1758 r = &ARMV4_5_CORE_REG_MODE(armv4_5->core_cache,
1759 mode, j);
1760
1761 buf_set_u32(r->value, 0, 32, buffer[j - 8]);
1762 r->dirty = false;
1763 r->valid = true;
1764 }
1765 }
1766
1767 free(buffer);
1768
1769 return ERROR_OK;
1770 }
1771
1772 static int xscale_restore_banked(struct target *target)
1773 {
1774 struct arm *armv4_5 = target_to_arm(target);
1775
1776 int i, j;
1777
1778 if (target->state != TARGET_HALTED)
1779 {
1780 LOG_WARNING("target not halted");
1781 return ERROR_TARGET_NOT_HALTED;
1782 }
1783
1784 /* iterate through processor modes (FIQ, IRQ, SVC, ABT, UND and SYS)
1785 * and check if any banked registers need to be written. Ignore
1786 * USR mode (number 0) in favor of SYS; we can't enter User mode on
1787 * an XScale (unpredictable), but they share all registers.
1788 */
1789 for (i = 1; i < 7; i++)
1790 {
1791 enum arm_mode mode = armv4_5_number_to_mode(i);
1792 struct reg *r;
1793
1794 if (mode == ARM_MODE_USR)
1795 continue;
1796
1797 /* check if there are dirty registers in this mode */
1798 for (j = 8; j <= 14; j++)
1799 {
1800 if (ARMV4_5_CORE_REG_MODE(armv4_5->core_cache,
1801 mode, j).dirty)
1802 goto dirty;
1803 }
1804
1805 /* if not USR/SYS, check if the SPSR needs to be written */
1806 if (mode != ARM_MODE_SYS)
1807 {
1808 if (ARMV4_5_CORE_REG_MODE(armv4_5->core_cache,
1809 mode, 16).dirty)
1810 goto dirty;
1811 }
1812
1813 /* there's nothing to flush for this mode */
1814 continue;
1815
1816 dirty:
1817 /* command 0x1: "send banked registers" */
1818 xscale_send_u32(target, 0x1);
1819
1820 /* send CPSR for desired mode */
1821 xscale_send_u32(target, mode | 0xc0 /* I/F bits */);
1822
1823 /* send r8 to r14/lr ... only FIQ needs more than r13..r14,
1824 * but this protocol doesn't understand that nuance.
1825 */
1826 for (j = 8; j <= 14; j++) {
1827 r = &ARMV4_5_CORE_REG_MODE(armv4_5->core_cache,
1828 mode, j);
1829 xscale_send_u32(target, buf_get_u32(r->value, 0, 32));
1830 r->dirty = false;
1831 }
1832
1833 /* send spsr if not in USR/SYS mode */
1834 if (mode != ARM_MODE_SYS) {
1835 r = &ARMV4_5_CORE_REG_MODE(armv4_5->core_cache,
1836 mode, 16);
1837 xscale_send_u32(target, buf_get_u32(r->value, 0, 32));
1838 r->dirty = false;
1839 }
1840 }
1841
1842 return ERROR_OK;
1843 }
1844
1845 static int xscale_read_memory(struct target *target, uint32_t address,
1846 uint32_t size, uint32_t count, uint8_t *buffer)
1847 {
1848 struct xscale_common *xscale = target_to_xscale(target);
1849 uint32_t *buf32;
1850 uint32_t i;
1851 int retval;
1852
1853 LOG_DEBUG("address: 0x%8.8" PRIx32 ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32, address, size, count);
1854
1855 if (target->state != TARGET_HALTED)
1856 {
1857 LOG_WARNING("target not halted");
1858 return ERROR_TARGET_NOT_HALTED;
1859 }
1860
1861 /* sanitize arguments */
1862 if (((size != 4) && (size != 2) && (size != 1)) || (count == 0) || !(buffer))
1863 return ERROR_INVALID_ARGUMENTS;
1864
1865 if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u)))
1866 return ERROR_TARGET_UNALIGNED_ACCESS;
1867
1868 /* send memory read request (command 0x1n, n: access size) */
1869 if ((retval = xscale_send_u32(target, 0x10 | size)) != ERROR_OK)
1870 return retval;
1871
1872 /* send base address for read request */
1873 if ((retval = xscale_send_u32(target, address)) != ERROR_OK)
1874 return retval;
1875
1876 /* send number of requested data words */
1877 if ((retval = xscale_send_u32(target, count)) != ERROR_OK)
1878 return retval;
1879
1880 /* receive data from target (count times 32-bit words in host endianness) */
1881 buf32 = malloc(4 * count);
1882 if ((retval = xscale_receive(target, buf32, count)) != ERROR_OK)
1883 return retval;
1884
1885 /* extract data from host-endian buffer into byte stream */
1886 for (i = 0; i < count; i++)
1887 {
1888 switch (size)
1889 {
1890 case 4:
1891 target_buffer_set_u32(target, buffer, buf32[i]);
1892 buffer += 4;
1893 break;
1894 case 2:
1895 target_buffer_set_u16(target, buffer, buf32[i] & 0xffff);
1896 buffer += 2;
1897 break;
1898 case 1:
1899 *buffer++ = buf32[i] & 0xff;
1900 break;
1901 default:
1902 LOG_ERROR("invalid read size");
1903 return ERROR_INVALID_ARGUMENTS;
1904 }
1905 }
1906
1907 free(buf32);
1908
1909 /* examine DCSR, to see if Sticky Abort (SA) got set */
1910 if ((retval = xscale_read_dcsr(target)) != ERROR_OK)
1911 return retval;
1912 if (buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 5, 1) == 1)
1913 {
1914 /* clear SA bit */
1915 if ((retval = xscale_send_u32(target, 0x60)) != ERROR_OK)
1916 return retval;
1917
1918 return ERROR_TARGET_DATA_ABORT;
1919 }
1920
1921 return ERROR_OK;
1922 }
1923
1924 static int xscale_read_phys_memory(struct target *target, uint32_t address,
1925 uint32_t size, uint32_t count, uint8_t *buffer)
1926 {
1927 struct xscale_common *xscale = target_to_xscale(target);
1928
1929 /* with MMU inactive, there are only physical addresses */
1930 if (!xscale->armv4_5_mmu.mmu_enabled)
1931 return xscale_read_memory(target, address, size, count, buffer);
1932
1933 /** \todo: provide a non-stub implementation of this routine. */
1934 LOG_ERROR("%s: %s is not implemented. Disable MMU?",
1935 target_name(target), __func__);
1936 return ERROR_FAIL;
1937 }
1938
1939 static int xscale_write_memory(struct target *target, uint32_t address,
1940 uint32_t size, uint32_t count, const uint8_t *buffer)
1941 {
1942 struct xscale_common *xscale = target_to_xscale(target);
1943 int retval;
1944
1945 LOG_DEBUG("address: 0x%8.8" PRIx32 ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32, address, size, count);
1946
1947 if (target->state != TARGET_HALTED)
1948 {
1949 LOG_WARNING("target not halted");
1950 return ERROR_TARGET_NOT_HALTED;
1951 }
1952
1953 /* sanitize arguments */
1954 if (((size != 4) && (size != 2) && (size != 1)) || (count == 0) || !(buffer))
1955 return ERROR_INVALID_ARGUMENTS;
1956
1957 if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u)))
1958 return ERROR_TARGET_UNALIGNED_ACCESS;
1959
1960 /* send memory write request (command 0x2n, n: access size) */
1961 if ((retval = xscale_send_u32(target, 0x20 | size)) != ERROR_OK)
1962 return retval;
1963
1964 /* send base address for read request */
1965 if ((retval = xscale_send_u32(target, address)) != ERROR_OK)
1966 return retval;
1967
1968 /* send number of requested data words to be written*/
1969 if ((retval = xscale_send_u32(target, count)) != ERROR_OK)
1970 return retval;
1971
1972 /* extract data from host-endian buffer into byte stream */
1973 #if 0
1974 for (i = 0; i < count; i++)
1975 {
1976 switch (size)
1977 {
1978 case 4:
1979 value = target_buffer_get_u32(target, buffer);
1980 xscale_send_u32(target, value);
1981 buffer += 4;
1982 break;
1983 case 2:
1984 value = target_buffer_get_u16(target, buffer);
1985 xscale_send_u32(target, value);
1986 buffer += 2;
1987 break;
1988 case 1:
1989 value = *buffer;
1990 xscale_send_u32(target, value);
1991 buffer += 1;
1992 break;
1993 default:
1994 LOG_ERROR("should never get here");
1995 exit(-1);
1996 }
1997 }
1998 #endif
1999 if ((retval = xscale_send(target, buffer, count, size)) != ERROR_OK)
2000 return retval;
2001
2002 /* examine DCSR, to see if Sticky Abort (SA) got set */
2003 if ((retval = xscale_read_dcsr(target)) != ERROR_OK)
2004 return retval;
2005 if (buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 5, 1) == 1)
2006 {
2007 /* clear SA bit */
2008 if ((retval = xscale_send_u32(target, 0x60)) != ERROR_OK)
2009 return retval;
2010
2011 LOG_ERROR("data abort writing memory");
2012 return ERROR_TARGET_DATA_ABORT;
2013 }
2014
2015 return ERROR_OK;
2016 }
2017
2018 static int xscale_write_phys_memory(struct target *target, uint32_t address,
2019 uint32_t size, uint32_t count, const uint8_t *buffer)
2020 {
2021 struct xscale_common *xscale = target_to_xscale(target);
2022
2023 /* with MMU inactive, there are only physical addresses */
2024 if (!xscale->armv4_5_mmu.mmu_enabled)
2025 return xscale_write_memory(target, address, size, count, buffer);
2026
2027 /** \todo: provide a non-stub implementation of this routine. */
2028 LOG_ERROR("%s: %s is not implemented. Disable MMU?",
2029 target_name(target), __func__);
2030 return ERROR_FAIL;
2031 }
2032
2033 static int xscale_bulk_write_memory(struct target *target, uint32_t address,
2034 uint32_t count, const uint8_t *buffer)
2035 {
2036 return xscale_write_memory(target, address, 4, count, buffer);
2037 }
2038
2039 static int xscale_get_ttb(struct target *target, uint32_t *result)
2040 {
2041 struct xscale_common *xscale = target_to_xscale(target);
2042 uint32_t ttb;
2043 int retval;
2044
2045 retval = xscale_get_reg(&xscale->reg_cache->reg_list[XSCALE_TTB]);
2046 if (retval != ERROR_OK)
2047 return retval;
2048 ttb = buf_get_u32(xscale->reg_cache->reg_list[XSCALE_TTB].value, 0, 32);
2049
2050 *result = ttb;
2051
2052 return ERROR_OK;
2053 }
2054
2055 static int xscale_disable_mmu_caches(struct target *target, int mmu,
2056 int d_u_cache, int i_cache)
2057 {
2058 struct xscale_common *xscale = target_to_xscale(target);
2059 uint32_t cp15_control;
2060 int retval;
2061
2062 /* read cp15 control register */
2063 retval = xscale_get_reg(&xscale->reg_cache->reg_list[XSCALE_CTRL]);
2064 if (retval !=ERROR_OK)
2065 return retval;
2066 cp15_control = buf_get_u32(xscale->reg_cache->reg_list[XSCALE_CTRL].value, 0, 32);
2067
2068 if (mmu)
2069 cp15_control &= ~0x1U;
2070
2071 if (d_u_cache)
2072 {
2073 /* clean DCache */
2074 retval = xscale_send_u32(target, 0x50);
2075 if (retval !=ERROR_OK)
2076 return retval;
2077 retval = xscale_send_u32(target, xscale->cache_clean_address);
2078 if (retval !=ERROR_OK)
2079 return retval;
2080
2081 /* invalidate DCache */
2082 retval = xscale_send_u32(target, 0x51);
2083 if (retval !=ERROR_OK)
2084 return retval;
2085
2086 cp15_control &= ~0x4U;
2087 }
2088
2089 if (i_cache)
2090 {
2091 /* invalidate ICache */
2092 retval = xscale_send_u32(target, 0x52);
2093 if (retval !=ERROR_OK)
2094 return retval;
2095 cp15_control &= ~0x1000U;
2096 }
2097
2098 /* write new cp15 control register */
2099 retval = xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_CTRL], cp15_control);
2100 if (retval !=ERROR_OK)
2101 return retval;
2102
2103 /* execute cpwait to ensure outstanding operations complete */
2104 retval = xscale_send_u32(target, 0x53);
2105 return retval;
2106 }
2107
2108 static int xscale_enable_mmu_caches(struct target *target, int mmu,
2109 int d_u_cache, int i_cache)
2110 {
2111 struct xscale_common *xscale = target_to_xscale(target);
2112 uint32_t cp15_control;
2113 int retval;
2114
2115 /* read cp15 control register */
2116 retval = xscale_get_reg(&xscale->reg_cache->reg_list[XSCALE_CTRL]);
2117 if (retval !=ERROR_OK)
2118 return retval;
2119 cp15_control = buf_get_u32(xscale->reg_cache->reg_list[XSCALE_CTRL].value, 0, 32);
2120
2121 if (mmu)
2122 cp15_control |= 0x1U;
2123
2124 if (d_u_cache)
2125 cp15_control |= 0x4U;
2126
2127 if (i_cache)
2128 cp15_control |= 0x1000U;
2129
2130 /* write new cp15 control register */
2131 retval = xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_CTRL], cp15_control);
2132 if (retval !=ERROR_OK)
2133 return retval;
2134
2135 /* execute cpwait to ensure outstanding operations complete */
2136 retval = xscale_send_u32(target, 0x53);
2137 return retval;
2138 }
2139
2140 static int xscale_set_breakpoint(struct target *target,
2141 struct breakpoint *breakpoint)
2142 {
2143 int retval;
2144 struct xscale_common *xscale = target_to_xscale(target);
2145
2146 if (target->state != TARGET_HALTED)
2147 {
2148 LOG_WARNING("target not halted");
2149 return ERROR_TARGET_NOT_HALTED;
2150 }
2151
2152 if (breakpoint->set)
2153 {
2154 LOG_WARNING("breakpoint already set");
2155 return ERROR_OK;
2156 }
2157
2158 if (breakpoint->type == BKPT_HARD)
2159 {
2160 uint32_t value = breakpoint->address | 1;
2161 if (!xscale->ibcr0_used)
2162 {
2163 xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR0], value);
2164 xscale->ibcr0_used = 1;
2165 breakpoint->set = 1; /* breakpoint set on first breakpoint register */
2166 }
2167 else if (!xscale->ibcr1_used)
2168 {
2169 xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR1], value);
2170 xscale->ibcr1_used = 1;
2171 breakpoint->set = 2; /* breakpoint set on second breakpoint register */
2172 }
2173 else
2174 { /* bug: availability previously verified in xscale_add_breakpoint() */
2175 LOG_ERROR("BUG: no hardware comparator available");
2176 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
2177 }
2178 }
2179 else if (breakpoint->type == BKPT_SOFT)
2180 {
2181 if (breakpoint->length == 4)
2182 {
2183 /* keep the original instruction in target endianness */
2184 if ((retval = target_read_memory(target, breakpoint->address, 4, 1, breakpoint->orig_instr)) != ERROR_OK)
2185 {
2186 return retval;
2187 }
2188 /* write the bkpt instruction in target endianness (arm7_9->arm_bkpt is host endian) */
2189 if ((retval = target_write_u32(target, breakpoint->address, xscale->arm_bkpt)) != ERROR_OK)
2190 {
2191 return retval;
2192 }
2193 }
2194 else
2195 {
2196 /* keep the original instruction in target endianness */
2197 if ((retval = target_read_memory(target, breakpoint->address, 2, 1, breakpoint->orig_instr)) != ERROR_OK)
2198 {
2199 return retval;
2200 }
2201 /* write the bkpt instruction in target endianness (arm7_9->arm_bkpt is host endian) */
2202 if ((retval = target_write_u16(target, breakpoint->address, xscale->thumb_bkpt)) != ERROR_OK)
2203 {
2204 return retval;
2205 }
2206 }
2207 breakpoint->set = 1;
2208
2209 xscale_send_u32(target, 0x50); /* clean dcache */
2210 xscale_send_u32(target, xscale->cache_clean_address);
2211 xscale_send_u32(target, 0x51); /* invalidate dcache */
2212 xscale_send_u32(target, 0x52); /* invalidate icache and flush fetch buffers */
2213 }
2214
2215 return ERROR_OK;
2216 }
2217
2218 static int xscale_add_breakpoint(struct target *target,
2219 struct breakpoint *breakpoint)
2220 {
2221 struct xscale_common *xscale = target_to_xscale(target);
2222
2223 if ((breakpoint->type == BKPT_HARD) && (xscale->ibcr_available < 1))
2224 {
2225 LOG_ERROR("no breakpoint unit available for hardware breakpoint");
2226 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
2227 }
2228
2229 if ((breakpoint->length != 2) && (breakpoint->length != 4))
2230 {
2231 LOG_ERROR("only breakpoints of two (Thumb) or four (ARM) bytes length supported");
2232 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
2233 }
2234
2235 if (breakpoint->type == BKPT_HARD)
2236 {
2237 xscale->ibcr_available--;
2238 }
2239
2240 return xscale_set_breakpoint(target, breakpoint);
2241 }
2242
2243 static int xscale_unset_breakpoint(struct target *target,
2244 struct breakpoint *breakpoint)
2245 {
2246 int retval;
2247 struct xscale_common *xscale = target_to_xscale(target);
2248
2249 if (target->state != TARGET_HALTED)
2250 {
2251 LOG_WARNING("target not halted");
2252 return ERROR_TARGET_NOT_HALTED;
2253 }
2254
2255 if (!breakpoint->set)
2256 {
2257 LOG_WARNING("breakpoint not set");
2258 return ERROR_OK;
2259 }
2260
2261 if (breakpoint->type == BKPT_HARD)
2262 {
2263 if (breakpoint->set == 1)
2264 {
2265 xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR0], 0x0);
2266 xscale->ibcr0_used = 0;
2267 }
2268 else if (breakpoint->set == 2)
2269 {
2270 xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR1], 0x0);
2271 xscale->ibcr1_used = 0;
2272 }
2273 breakpoint->set = 0;
2274 }
2275 else
2276 {
2277 /* restore original instruction (kept in target endianness) */
2278 if (breakpoint->length == 4)
2279 {
2280 if ((retval = target_write_memory(target, breakpoint->address, 4, 1, breakpoint->orig_instr)) != ERROR_OK)
2281 {
2282 return retval;
2283 }
2284 }
2285 else
2286 {
2287 if ((retval = target_write_memory(target, breakpoint->address, 2, 1, breakpoint->orig_instr)) != ERROR_OK)
2288 {
2289 return retval;
2290 }
2291 }
2292 breakpoint->set = 0;
2293
2294 xscale_send_u32(target, 0x50); /* clean dcache */
2295 xscale_send_u32(target, xscale->cache_clean_address);
2296 xscale_send_u32(target, 0x51); /* invalidate dcache */
2297 xscale_send_u32(target, 0x52); /* invalidate icache and flush fetch buffers */
2298 }
2299
2300 return ERROR_OK;
2301 }
2302
2303 static int xscale_remove_breakpoint(struct target *target, struct breakpoint *breakpoint)
2304 {
2305 struct xscale_common *xscale = target_to_xscale(target);
2306
2307 if (target->state != TARGET_HALTED)
2308 {
2309 LOG_ERROR("target not halted");
2310 return ERROR_TARGET_NOT_HALTED;
2311 }
2312
2313 if (breakpoint->set)
2314 {
2315 xscale_unset_breakpoint(target, breakpoint);
2316 }
2317
2318 if (breakpoint->type == BKPT_HARD)
2319 xscale->ibcr_available++;
2320
2321 return ERROR_OK;
2322 }
2323
2324 static int xscale_set_watchpoint(struct target *target,
2325 struct watchpoint *watchpoint)
2326 {
2327 struct xscale_common *xscale = target_to_xscale(target);
2328 uint32_t enable = 0;
2329 struct reg *dbcon = &xscale->reg_cache->reg_list[XSCALE_DBCON];
2330 uint32_t dbcon_value = buf_get_u32(dbcon->value, 0, 32);
2331
2332 if (target->state != TARGET_HALTED)
2333 {
2334 LOG_ERROR("target not halted");
2335 return ERROR_TARGET_NOT_HALTED;
2336 }
2337
2338 switch (watchpoint->rw)
2339 {
2340 case WPT_READ:
2341 enable = 0x3;
2342 break;
2343 case WPT_ACCESS:
2344 enable = 0x2;
2345 break;
2346 case WPT_WRITE:
2347 enable = 0x1;
2348 break;
2349 default:
2350 LOG_ERROR("BUG: watchpoint->rw neither read, write nor access");
2351 }
2352
2353 /* For watchpoint across more than one word, both DBR registers must
2354 be enlisted, with the second used as a mask. */
2355 if (watchpoint->length > 4)
2356 {
2357 if (xscale->dbr0_used || xscale->dbr1_used)
2358 {
2359 LOG_ERROR("BUG: sufficient hardware comparators unavailable");
2360 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
2361 }
2362
2363 /* Write mask value to DBR1, based on the length argument.
2364 * Address bits ignored by the comparator are those set in mask. */
2365 xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_DBR1],
2366 watchpoint->length - 1);
2367 xscale->dbr1_used = 1;
2368 enable |= 0x100; /* DBCON[M] */
2369 }
2370
2371 if (!xscale->dbr0_used)
2372 {
2373 xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_DBR0], watchpoint->address);
2374 dbcon_value |= enable;
2375 xscale_set_reg_u32(dbcon, dbcon_value);
2376 watchpoint->set = 1;
2377 xscale->dbr0_used = 1;
2378 }
2379 else if (!xscale->dbr1_used)
2380 {
2381 xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_DBR1], watchpoint->address);
2382 dbcon_value |= enable << 2;
2383 xscale_set_reg_u32(dbcon, dbcon_value);
2384 watchpoint->set = 2;
2385 xscale->dbr1_used = 1;
2386 }
2387 else
2388 {
2389 LOG_ERROR("BUG: no hardware comparator available");
2390 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
2391 }
2392
2393 return ERROR_OK;
2394 }
2395
2396 static int xscale_add_watchpoint(struct target *target,
2397 struct watchpoint *watchpoint)
2398 {
2399 struct xscale_common *xscale = target_to_xscale(target);
2400
2401 if (xscale->dbr_available < 1)
2402 {
2403 LOG_ERROR("no more watchpoint registers available");
2404 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
2405 }
2406
2407 if (watchpoint->value)
2408 LOG_WARNING("xscale does not support value, mask arguments; ignoring");
2409
2410 /* check that length is a power of two */
2411 for (uint32_t len = watchpoint->length; len != 1; len /= 2)
2412 {
2413 if (len % 2)
2414 {
2415 LOG_ERROR("xscale requires that watchpoint length is a power of two");
2416 return ERROR_COMMAND_ARGUMENT_INVALID;
2417 }
2418 }
2419
2420 if (watchpoint->length == 4) /* single word watchpoint */
2421 {
2422 xscale->dbr_available--; /* one DBR reg used */
2423 return ERROR_OK;
2424 }
2425
2426 /* watchpoints across multiple words require both DBR registers */
2427 if (xscale->dbr_available < 2)
2428 {
2429 LOG_ERROR("insufficient watchpoint registers available");
2430 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
2431 }
2432
2433 if (watchpoint->length > watchpoint->address)
2434 {
2435 LOG_ERROR("xscale does not support watchpoints with length "
2436 "greater than address");
2437 return ERROR_COMMAND_ARGUMENT_INVALID;
2438 }
2439
2440 xscale->dbr_available = 0;
2441 return ERROR_OK;
2442 }
2443
2444 static int xscale_unset_watchpoint(struct target *target,
2445 struct watchpoint *watchpoint)
2446 {
2447 struct xscale_common *xscale = target_to_xscale(target);
2448 struct reg *dbcon = &xscale->reg_cache->reg_list[XSCALE_DBCON];
2449 uint32_t dbcon_value = buf_get_u32(dbcon->value, 0, 32);
2450
2451 if (target->state != TARGET_HALTED)
2452 {
2453 LOG_WARNING("target not halted");
2454 return ERROR_TARGET_NOT_HALTED;
2455 }
2456
2457 if (!watchpoint->set)
2458 {
2459 LOG_WARNING("breakpoint not set");
2460 return ERROR_OK;
2461 }
2462
2463 if (watchpoint->set == 1)
2464 {
2465 if (watchpoint->length > 4)
2466 {
2467 dbcon_value &= ~0x103; /* clear DBCON[M] as well */
2468 xscale->dbr1_used = 0; /* DBR1 was used for mask */
2469 }
2470 else
2471 dbcon_value &= ~0x3;
2472
2473 xscale_set_reg_u32(dbcon, dbcon_value);
2474 xscale->dbr0_used = 0;
2475 }
2476 else if (watchpoint->set == 2)
2477 {
2478 dbcon_value &= ~0xc;
2479 xscale_set_reg_u32(dbcon, dbcon_value);
2480 xscale->dbr1_used = 0;
2481 }
2482 watchpoint->set = 0;
2483
2484 return ERROR_OK;
2485 }
2486
2487 static int xscale_remove_watchpoint(struct target *target, struct watchpoint *watchpoint)
2488 {
2489 struct xscale_common *xscale = target_to_xscale(target);
2490
2491 if (target->state != TARGET_HALTED)
2492 {
2493 LOG_ERROR("target not halted");
2494 return ERROR_TARGET_NOT_HALTED;
2495 }
2496
2497 if (watchpoint->set)
2498 {
2499 xscale_unset_watchpoint(target, watchpoint);
2500 }
2501
2502 if (watchpoint->length > 4)
2503 xscale->dbr_available++; /* both DBR regs now available */
2504
2505 xscale->dbr_available++;
2506
2507 return ERROR_OK;
2508 }
2509
2510 static int xscale_get_reg(struct reg *reg)
2511 {
2512 struct xscale_reg *arch_info = reg->arch_info;
2513 struct target *target = arch_info->target;
2514 struct xscale_common *xscale = target_to_xscale(target);
2515
2516 /* DCSR, TX and RX are accessible via JTAG */
2517 if (strcmp(reg->name, "XSCALE_DCSR") == 0)
2518 {
2519 return xscale_read_dcsr(arch_info->target);
2520 }
2521 else if (strcmp(reg->name, "XSCALE_TX") == 0)
2522 {
2523 /* 1 = consume register content */
2524 return xscale_read_tx(arch_info->target, 1);
2525 }
2526 else if (strcmp(reg->name, "XSCALE_RX") == 0)
2527 {
2528 /* can't read from RX register (host -> debug handler) */
2529 return ERROR_OK;
2530 }
2531 else if (strcmp(reg->name, "XSCALE_TXRXCTRL") == 0)
2532 {
2533 /* can't (explicitly) read from TXRXCTRL register */
2534 return ERROR_OK;
2535 }
2536 else /* Other DBG registers have to be transfered by the debug handler */
2537 {
2538 /* send CP read request (command 0x40) */
2539 xscale_send_u32(target, 0x40);
2540
2541 /* send CP register number */
2542 xscale_send_u32(target, arch_info->dbg_handler_number);
2543
2544 /* read register value */
2545 xscale_read_tx(target, 1);
2546 buf_cpy(xscale->reg_cache->reg_list[XSCALE_TX].value, reg->value, 32);
2547
2548 reg->dirty = 0;
2549 reg->valid = 1;
2550 }
2551
2552 return ERROR_OK;
2553 }
2554
2555 static int xscale_set_reg(struct reg *reg, uint8_t* buf)
2556 {
2557 struct xscale_reg *arch_info = reg->arch_info;
2558 struct target *target = arch_info->target;
2559 struct xscale_common *xscale = target_to_xscale(target);
2560 uint32_t value = buf_get_u32(buf, 0, 32);
2561
2562 /* DCSR, TX and RX are accessible via JTAG */
2563 if (strcmp(reg->name, "XSCALE_DCSR") == 0)
2564 {
2565 buf_set_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 0, 32, value);
2566 return xscale_write_dcsr(arch_info->target, -1, -1);
2567 }
2568 else if (strcmp(reg->name, "XSCALE_RX") == 0)
2569 {
2570 buf_set_u32(xscale->reg_cache->reg_list[XSCALE_RX].value, 0, 32, value);
2571 return xscale_write_rx(arch_info->target);
2572 }
2573 else if (strcmp(reg->name, "XSCALE_TX") == 0)
2574 {
2575 /* can't write to TX register (debug-handler -> host) */
2576 return ERROR_OK;
2577 }
2578 else if (strcmp(reg->name, "XSCALE_TXRXCTRL") == 0)
2579 {
2580 /* can't (explicitly) write to TXRXCTRL register */
2581 return ERROR_OK;
2582 }
2583 else /* Other DBG registers have to be transfered by the debug handler */
2584 {
2585 /* send CP write request (command 0x41) */
2586 xscale_send_u32(target, 0x41);
2587
2588 /* send CP register number */
2589 xscale_send_u32(target, arch_info->dbg_handler_number);
2590
2591 /* send CP register value */
2592 xscale_send_u32(target, value);
2593 buf_set_u32(reg->value, 0, 32, value);
2594 }
2595
2596 return ERROR_OK;
2597 }
2598
2599 static int xscale_write_dcsr_sw(struct target *target, uint32_t value)
2600 {
2601 struct xscale_common *xscale = target_to_xscale(target);
2602 struct reg *dcsr = &xscale->reg_cache->reg_list[XSCALE_DCSR];
2603 struct xscale_reg *dcsr_arch_info = dcsr->arch_info;
2604
2605 /* send CP write request (command 0x41) */
2606 xscale_send_u32(target, 0x41);
2607
2608 /* send CP register number */
2609 xscale_send_u32(target, dcsr_arch_info->dbg_handler_number);
2610
2611 /* send CP register value */
2612 xscale_send_u32(target, value);
2613 buf_set_u32(dcsr->value, 0, 32, value);
2614
2615 return ERROR_OK;
2616 }
2617
2618 static int xscale_read_trace(struct target *target)
2619 {
2620 struct xscale_common *xscale = target_to_xscale(target);
2621 struct arm *armv4_5 = &xscale->armv4_5_common;
2622 struct xscale_trace_data **trace_data_p;
2623
2624 /* 258 words from debug handler
2625 * 256 trace buffer entries
2626 * 2 checkpoint addresses
2627 */
2628 uint32_t trace_buffer[258];
2629 int is_address[256];
2630 int i, j;
2631 unsigned int num_checkpoints = 0;
2632
2633 if (target->state != TARGET_HALTED)
2634 {
2635 LOG_WARNING("target must be stopped to read trace data");
2636 return ERROR_TARGET_NOT_HALTED;
2637 }
2638
2639 /* send read trace buffer command (command 0x61) */
2640 xscale_send_u32(target, 0x61);
2641
2642 /* receive trace buffer content */
2643 xscale_receive(target, trace_buffer, 258);
2644
2645 /* parse buffer backwards to identify address entries */
2646 for (i = 255; i >= 0; i--)
2647 {
2648 /* also count number of checkpointed entries */
2649 if ((trace_buffer[i] & 0xe0) == 0xc0)
2650 num_checkpoints++;
2651
2652 is_address[i] = 0;
2653 if (((trace_buffer[i] & 0xf0) == 0x90) ||
2654 ((trace_buffer[i] & 0xf0) == 0xd0))
2655 {
2656 if (i > 0)
2657 is_address[--i] = 1;
2658 if (i > 0)
2659 is_address[--i] = 1;
2660 if (i > 0)
2661 is_address[--i] = 1;
2662 if (i > 0)
2663 is_address[--i] = 1;
2664 }
2665 }
2666
2667
2668 /* search first non-zero entry that is not part of an address */
2669 for (j = 0; (j < 256) && (trace_buffer[j] == 0) && (!is_address[j]); j++)
2670 ;
2671
2672 if (j == 256)
2673 {
2674 LOG_DEBUG("no trace data collected");
2675 return ERROR_XSCALE_NO_TRACE_DATA;
2676 }
2677
2678 /* account for possible partial address at buffer start (wrap mode only) */
2679 if (is_address[0])
2680 { /* first entry is address; complete set of 4? */
2681 i = 1;
2682 while (i < 4)
2683 if (!is_address[i++])
2684 break;
2685 if (i < 4)
2686 j += i; /* partial address; can't use it */
2687 }
2688
2689 /* if first valid entry is indirect branch, can't use that either (no address) */
2690 if (((trace_buffer[j] & 0xf0) == 0x90) || ((trace_buffer[j] & 0xf0) == 0xd0))
2691 j++;
2692
2693 /* walk linked list to terminating entry */
2694 for (trace_data_p = &xscale->trace.data; *trace_data_p; trace_data_p = &(*trace_data_p)->next)
2695 ;
2696
2697 *trace_data_p = malloc(sizeof(struct xscale_trace_data));
2698 (*trace_data_p)->next = NULL;
2699 (*trace_data_p)->chkpt0 = trace_buffer[256];
2700 (*trace_data_p)->chkpt1 = trace_buffer[257];
2701 (*trace_data_p)->last_instruction =
2702 buf_get_u32(armv4_5->pc->value, 0, 32);
2703 (*trace_data_p)->entries = malloc(sizeof(struct xscale_trace_entry) * (256 - j));
2704 (*trace_data_p)->depth = 256 - j;
2705 (*trace_data_p)->num_checkpoints = num_checkpoints;
2706
2707 for (i = j; i < 256; i++)
2708 {
2709 (*trace_data_p)->entries[i - j].data = trace_buffer[i];
2710 if (is_address[i])
2711 (*trace_data_p)->entries[i - j].type = XSCALE_TRACE_ADDRESS;
2712 else
2713 (*trace_data_p)->entries[i - j].type = XSCALE_TRACE_MESSAGE;
2714 }
2715
2716 return ERROR_OK;
2717 }
2718
2719 static int xscale_read_instruction(struct target *target, uint32_t pc,
2720 struct arm_instruction *instruction)
2721 {
2722 struct xscale_common *const xscale = target_to_xscale(target);
2723 int i;
2724 int section = -1;
2725 size_t size_read;
2726 uint32_t opcode;
2727 int retval;
2728
2729 if (!xscale->trace.image)
2730 return ERROR_TRACE_IMAGE_UNAVAILABLE;
2731
2732 /* search for the section the current instruction belongs to */
2733 for (i = 0; i < xscale->trace.image->num_sections; i++)
2734 {
2735 if ((xscale->trace.image->sections[i].base_address <= pc) &&
2736 (xscale->trace.image->sections[i].base_address + xscale->trace.image->sections[i].size > pc))
2737 {
2738 section = i;
2739 break;
2740 }
2741 }
2742
2743 if (section == -1)
2744 {
2745 /* current instruction couldn't be found in the image */
2746 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE;
2747 }
2748
2749 if (xscale->trace.core_state == ARM_STATE_ARM)
2750 {
2751 uint8_t buf[4];
2752 if ((retval = image_read_section(xscale->trace.image, section,
2753 pc - xscale->trace.image->sections[section].base_address,
2754 4, buf, &size_read)) != ERROR_OK)
2755 {
2756 LOG_ERROR("error while reading instruction");
2757 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE;
2758 }
2759 opcode = target_buffer_get_u32(target, buf);
2760 arm_evaluate_opcode(opcode, pc, instruction);
2761 }
2762 else if (xscale->trace.core_state == ARM_STATE_THUMB)
2763 {
2764 uint8_t buf[2];
2765 if ((retval = image_read_section(xscale->trace.image, section,
2766 pc - xscale->trace.image->sections[section].base_address,
2767 2, buf, &size_read)) != ERROR_OK)
2768 {
2769 LOG_ERROR("error while reading instruction");
2770 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE;
2771 }
2772 opcode = target_buffer_get_u16(target, buf);
2773 thumb_evaluate_opcode(opcode, pc, instruction);
2774 }
2775 else
2776 {
2777 LOG_ERROR("BUG: unknown core state encountered");
2778 exit(-1);
2779 }
2780
2781 return ERROR_OK;
2782 }
2783
2784 /* Extract address encoded into trace data.
2785 * Write result to address referenced by argument 'target', or 0 if incomplete. */
2786 static inline void xscale_branch_address(struct xscale_trace_data *trace_data,
2787 int i, uint32_t *target)
2788 {
2789 /* if there are less than four entries prior to the indirect branch message
2790 * we can't extract the address */
2791 if (i < 4)
2792 *target = 0;
2793 else
2794 *target = (trace_data->entries[i-1].data) | (trace_data->entries[i-2].data << 8) |
2795 (trace_data->entries[i-3].data << 16) | (trace_data->entries[i-4].data << 24);
2796 }
2797
2798 static inline void xscale_display_instruction(struct target *target, uint32_t pc,
2799 struct arm_instruction *instruction,
2800 struct command_context *cmd_ctx)
2801 {
2802 int retval = xscale_read_instruction(target, pc, instruction);
2803 if (retval == ERROR_OK)
2804 command_print(cmd_ctx, "%s", instruction->text);
2805 else
2806 command_print(cmd_ctx, "0x%8.8" PRIx32 "\t<not found in image>", pc);
2807 }
2808
2809 static int xscale_analyze_trace(struct target *target, struct command_context *cmd_ctx)
2810 {
2811 struct xscale_common *xscale = target_to_xscale(target);
2812 struct xscale_trace_data *trace_data = xscale->trace.data;
2813 int i, retval;
2814 uint32_t breakpoint_pc;
2815 struct arm_instruction instruction;
2816 uint32_t current_pc = 0; /* initialized when address determined */
2817
2818 if (!xscale->trace.image)
2819 LOG_WARNING("No trace image loaded; use 'xscale trace_image'");
2820
2821 /* loop for each trace buffer that was loaded from target */
2822 while (trace_data)
2823 {
2824 int chkpt = 0; /* incremented as checkpointed entries found */
2825 int j;
2826
2827 /* FIXME: set this to correct mode when trace buffer is first enabled */
2828 xscale->trace.core_state = ARM_STATE_ARM;
2829
2830 /* loop for each entry in this trace buffer */
2831 for (i = 0; i < trace_data->depth; i++)
2832 {
2833 int exception = 0;
2834 uint32_t chkpt_reg = 0x0;
2835 uint32_t branch_target = 0;
2836 int count;
2837
2838 /* trace entry type is upper nybble of 'message byte' */
2839 int trace_msg_type = (trace_data->entries[i].data & 0xf0) >> 4;
2840
2841 /* Target addresses of indirect branches are written into buffer
2842 * before the message byte representing the branch. Skip past it */
2843 if (trace_data->entries[i].type == XSCALE_TRACE_ADDRESS)
2844 continue;
2845
2846 switch (trace_msg_type)
2847 {
2848 case 0: /* Exceptions */
2849 case 1:
2850 case 2:
2851 case 3:
2852 case 4:
2853 case 5:
2854 case 6:
2855 case 7:
2856 exception = (trace_data->entries[i].data & 0x70) >> 4;
2857
2858 /* FIXME: vector table may be at ffff0000 */
2859 branch_target = (trace_data->entries[i].data & 0xf0) >> 2;
2860 break;
2861
2862 case 8: /* Direct Branch */
2863 break;
2864
2865 case 9: /* Indirect Branch */
2866 xscale_branch_address(trace_data, i, &branch_target);
2867 break;
2868
2869 case 13: /* Checkpointed Indirect Branch */
2870 xscale_branch_address(trace_data, i, &branch_target);
2871 if ((trace_data->num_checkpoints == 2) && (chkpt == 0))
2872 chkpt_reg = trace_data->chkpt1; /* 2 chkpts, this is oldest */
2873 else
2874 chkpt_reg = trace_data->chkpt0; /* 1 chkpt, or 2 and newest */
2875
2876 chkpt++;
2877 break;
2878
2879 case 12: /* Checkpointed Direct Branch */
2880 if ((trace_data->num_checkpoints == 2) && (chkpt == 0))
2881 chkpt_reg = trace_data->chkpt1; /* 2 chkpts, this is oldest */
2882 else
2883 chkpt_reg = trace_data->chkpt0; /* 1 chkpt, or 2 and newest */
2884
2885 /* if no current_pc, checkpoint will be starting point */
2886 if (current_pc == 0)
2887 branch_target = chkpt_reg;
2888
2889 chkpt++;
2890 break;
2891
2892 case 15: /* Roll-over */
2893 break;
2894
2895 default: /* Reserved */
2896 LOG_WARNING("trace is suspect: invalid trace message byte");
2897 continue;
2898
2899 }
2900
2901 /* If we don't have the current_pc yet, but we did get the branch target
2902 * (either from the trace buffer on indirect branch, or from a checkpoint reg),
2903 * then we can start displaying instructions at the next iteration, with
2904 * branch_target as the starting point.
2905 */
2906 if (current_pc == 0)
2907 {
2908 current_pc = branch_target; /* remains 0 unless branch_target obtained */
2909 continue;
2910 }
2911
2912 /* We have current_pc. Read and display the instructions from the image.
2913 * First, display count instructions (lower nybble of message byte). */
2914 count = trace_data->entries[i].data & 0x0f;
2915 for (j = 0; j < count; j++)
2916 {
2917 xscale_display_instruction(target, current_pc, &instruction, cmd_ctx);
2918 current_pc += xscale->trace.core_state == ARM_STATE_ARM ? 4 : 2;
2919 }
2920
2921 /* An additional instruction is implicitly added to count for
2922 * rollover and some exceptions: undef, swi, prefetch abort. */
2923 if ((trace_msg_type == 15) || (exception > 0 && exception < 4))
2924 {
2925 xscale_display_instruction(target, current_pc, &instruction, cmd_ctx);
2926 current_pc += xscale->trace.core_state == ARM_STATE_ARM ? 4 : 2;
2927 }
2928
2929 if (trace_msg_type == 15) /* rollover */
2930 continue;
2931
2932 if (exception)
2933 {
2934 command_print(cmd_ctx, "--- exception %i ---", exception);
2935 continue;
2936 }
2937
2938 /* not exception or rollover; next instruction is a branch and is
2939 * not included in the count */
2940 xscale_display_instruction(target, current_pc, &instruction, cmd_ctx);
2941
2942 /* for direct branches, extract branch destination from instruction */
2943 if ((trace_msg_type == 8) || (trace_msg_type == 12))
2944 {
2945 retval = xscale_read_instruction(target, current_pc, &instruction);
2946 if (retval == ERROR_OK)
2947 current_pc = instruction.info.b_bl_bx_blx.target_address;
2948 else
2949 current_pc = 0; /* branch destination unknown */
2950
2951 /* direct branch w/ checkpoint; can also get from checkpoint reg */
2952 if (trace_msg_type == 12)
2953 {
2954 if (current_pc == 0)
2955 current_pc = chkpt_reg;
2956 else if (current_pc != chkpt_reg) /* sanity check */
2957 LOG_WARNING("trace is suspect: checkpoint register "
2958 "inconsistent with adddress from image");
2959 }
2960
2961 if (current_pc == 0)
2962 command_print(cmd_ctx, "address unknown");
2963
2964 continue;
2965 }
2966
2967 /* indirect branch; the branch destination was read from trace buffer */
2968 if ((trace_msg_type == 9) || (trace_msg_type == 13))
2969 {
2970 current_pc = branch_target;
2971
2972 /* sanity check (checkpoint reg is redundant) */
2973 if ((trace_msg_type == 13) && (chkpt_reg != branch_target))
2974 LOG_WARNING("trace is suspect: checkpoint register "
2975 "inconsistent with address from trace buffer");
2976 }
2977
2978 } /* END: for (i = 0; i < trace_data->depth; i++) */
2979
2980 breakpoint_pc = trace_data->last_instruction; /* used below */
2981 trace_data = trace_data->next;
2982
2983 } /* END: while (trace_data) */
2984
2985 /* Finally... display all instructions up to the value of the pc when the
2986 * debug break occurred (saved when trace data was collected from target).
2987 * This is necessary because the trace only records execution branches and 16
2988 * consecutive instructions (rollovers), so last few typically missed.
2989 */
2990 if (current_pc == 0)
2991 return ERROR_OK; /* current_pc was never found */
2992
2993 /* how many instructions remaining? */
2994 int gap_count = (breakpoint_pc - current_pc) /
2995 (xscale->trace.core_state == ARM_STATE_ARM ? 4 : 2);
2996
2997 /* should never be negative or over 16, but verify */
2998 if (gap_count < 0 || gap_count > 16)
2999 {
3000 LOG_WARNING("trace is suspect: excessive gap at end of trace");
3001 return ERROR_OK; /* bail; large number or negative value no good */
3002 }
3003
3004 /* display remaining instructions */
3005 for (i = 0; i < gap_count; i++)
3006 {
3007 xscale_display_instruction(target, current_pc, &instruction, cmd_ctx);
3008 current_pc += xscale->trace.core_state == ARM_STATE_ARM ? 4 : 2;
3009 }
3010
3011 return ERROR_OK;
3012 }
3013
3014 static const struct reg_arch_type xscale_reg_type = {
3015 .get = xscale_get_reg,
3016 .set = xscale_set_reg,
3017 };
3018
3019 static void xscale_build_reg_cache(struct target *target)
3020 {
3021 struct xscale_common *xscale = target_to_xscale(target);
3022 struct arm *armv4_5 = &xscale->armv4_5_common;
3023 struct reg_cache **cache_p = register_get_last_cache_p(&target->reg_cache);
3024 struct xscale_reg *arch_info = malloc(sizeof(xscale_reg_arch_info));
3025 int i;
3026 int num_regs = ARRAY_SIZE(xscale_reg_arch_info);
3027
3028 (*cache_p) = arm_build_reg_cache(target, armv4_5);
3029
3030 (*cache_p)->next = malloc(sizeof(struct reg_cache));
3031 cache_p = &(*cache_p)->next;
3032
3033 /* fill in values for the xscale reg cache */
3034 (*cache_p)->name = "XScale registers";
3035 (*cache_p)->next = NULL;
3036 (*cache_p)->reg_list = malloc(num_regs * sizeof(struct reg));
3037 (*cache_p)->num_regs = num_regs;
3038
3039 for (i = 0; i < num_regs; i++)
3040 {
3041 (*cache_p)->reg_list[i].name = xscale_reg_list[i];
3042 (*cache_p)->reg_list[i].value = calloc(4, 1);
3043 (*cache_p)->reg_list[i].dirty = 0;
3044 (*cache_p)->reg_list[i].valid = 0;
3045 (*cache_p)->reg_list[i].size = 32;
3046 (*cache_p)->reg_list[i].arch_info = &arch_info[i];
3047 (*cache_p)->reg_list[i].type = &xscale_reg_type;
3048 arch_info[i] = xscale_reg_arch_info[i];
3049 arch_info[i].target = target;
3050 }
3051
3052 xscale->reg_cache = (*cache_p);
3053 }
3054
3055 static int xscale_init_target(struct command_context *cmd_ctx,
3056 struct target *target)
3057 {
3058 xscale_build_reg_cache(target);
3059 return ERROR_OK;
3060 }
3061
3062 static int xscale_init_arch_info(struct target *target,
3063 struct xscale_common *xscale, struct jtag_tap *tap, const char *variant)
3064 {
3065 struct arm *armv4_5;
3066 uint32_t high_reset_branch, low_reset_branch;
3067 int i;
3068
3069 armv4_5 = &xscale->armv4_5_common;
3070
3071 /* store architecture specfic data */
3072 xscale->common_magic = XSCALE_COMMON_MAGIC;
3073
3074 /* we don't really *need* a variant param ... */
3075 if (variant) {
3076 int ir_length = 0;
3077
3078 if (strcmp(variant, "pxa250") == 0
3079 || strcmp(variant, "pxa255") == 0
3080 || strcmp(variant, "pxa26x") == 0)
3081 ir_length = 5;
3082 else if (strcmp(variant, "pxa27x") == 0
3083 || strcmp(variant, "ixp42x") == 0
3084 || strcmp(variant, "ixp45x") == 0
3085 || strcmp(variant, "ixp46x") == 0)
3086 ir_length = 7;
3087 else if (strcmp(variant, "pxa3xx") == 0)
3088 ir_length = 11;
3089 else
3090 LOG_WARNING("%s: unrecognized variant %s",
3091 tap->dotted_name, variant);
3092
3093 if (ir_length && ir_length != tap->ir_length) {
3094 LOG_WARNING("%s: IR length for %s is %d; fixing",
3095 tap->dotted_name, variant, ir_length);
3096 tap->ir_length = ir_length;
3097 }
3098 }
3099
3100 /* PXA3xx shifts the JTAG instructions */
3101 if (tap->ir_length == 11)
3102 xscale->xscale_variant = XSCALE_PXA3XX;
3103 else
3104 xscale->xscale_variant = XSCALE_IXP4XX_PXA2XX;
3105
3106 /* the debug handler isn't installed (and thus not running) at this time */
3107 xscale->handler_address = 0xfe000800;
3108
3109 /* clear the vectors we keep locally for reference */
3110 memset(xscale->low_vectors, 0, sizeof(xscale->low_vectors));
3111 memset(xscale->high_vectors, 0, sizeof(xscale->high_vectors));
3112
3113 /* no user-specified vectors have been configured yet */
3114 xscale->static_low_vectors_set = 0x0;
3115 xscale->static_high_vectors_set = 0x0;
3116
3117 /* calculate branches to debug handler */
3118 low_reset_branch = (xscale->handler_address + 0x20 - 0x0 - 0x8) >> 2;
3119 high_reset_branch = (xscale->handler_address + 0x20 - 0xffff0000 - 0x8) >> 2;
3120
3121 xscale->low_vectors[0] = ARMV4_5_B((low_reset_branch & 0xffffff), 0);
3122 xscale->high_vectors[0] = ARMV4_5_B((high_reset_branch & 0xffffff), 0);
3123
3124 for (i = 1; i <= 7; i++)
3125 {
3126 xscale->low_vectors[i] = ARMV4_5_B(0xfffffe, 0);
3127 xscale->high_vectors[i] = ARMV4_5_B(0xfffffe, 0);
3128 }
3129
3130 /* 64kB aligned region used for DCache cleaning */
3131 xscale->cache_clean_address = 0xfffe0000;
3132
3133 xscale->hold_rst = 0;
3134 xscale->external_debug_break = 0;
3135
3136 xscale->ibcr_available = 2;
3137 xscale->ibcr0_used = 0;
3138 xscale->ibcr1_used = 0;
3139
3140 xscale->dbr_available = 2;
3141 xscale->dbr0_used = 0;
3142 xscale->dbr1_used = 0;
3143
3144 LOG_INFO("%s: hardware has 2 breakpoints and 2 watchpoints",
3145 target_name(target));
3146
3147 xscale->arm_bkpt = ARMV5_BKPT(0x0);
3148 xscale->thumb_bkpt = ARMV5_T_BKPT(0x0) & 0xffff;
3149
3150 xscale->vector_catch = 0x1;
3151
3152 xscale->trace.data = NULL;
3153 xscale->trace.image = NULL;
3154 xscale->trace.mode = XSCALE_TRACE_DISABLED;
3155 xscale->trace.buffer_fill = 0;
3156 xscale->trace.fill_counter = 0;
3157
3158 /* prepare ARMv4/5 specific information */
3159 armv4_5->arch_info = xscale;
3160 armv4_5->read_core_reg = xscale_read_core_reg;
3161 armv4_5->write_core_reg = xscale_write_core_reg;
3162 armv4_5->full_context = xscale_full_context;
3163
3164 arm_init_arch_info(target, armv4_5);
3165
3166 xscale->armv4_5_mmu.armv4_5_cache.ctype = -1;
3167 xscale->armv4_5_mmu.get_ttb = xscale_get_ttb;
3168 xscale->armv4_5_mmu.read_memory = xscale_read_memory;
3169 xscale->armv4_5_mmu.write_memory = xscale_write_memory;
3170 xscale->armv4_5_mmu.disable_mmu_caches = xscale_disable_mmu_caches;
3171 xscale->armv4_5_mmu.enable_mmu_caches = xscale_enable_mmu_caches;
3172 xscale->armv4_5_mmu.has_tiny_pages = 1;
3173 xscale->armv4_5_mmu.mmu_enabled = 0;
3174
3175 return ERROR_OK;
3176 }
3177
3178 static int xscale_target_create(struct target *target, Jim_Interp *interp)
3179 {
3180 struct xscale_common *xscale;
3181
3182 if (sizeof xscale_debug_handler - 1 > 0x800) {
3183 LOG_ERROR("debug_handler.bin: larger than 2kb");
3184 return ERROR_FAIL;
3185 }
3186
3187 xscale = calloc(1, sizeof(*xscale));
3188 if (!xscale)
3189 return ERROR_FAIL;
3190
3191 return xscale_init_arch_info(target, xscale, target->tap,
3192 target->variant);
3193 }
3194
3195 COMMAND_HANDLER(xscale_handle_debug_handler_command)
3196 {
3197 struct target *target = NULL;
3198 struct xscale_common *xscale;
3199 int retval;
3200 uint32_t handler_address;
3201
3202 if (CMD_ARGC < 2)
3203 {
3204 LOG_ERROR("'xscale debug_handler <target#> <address>' command takes two required operands");
3205 return ERROR_OK;
3206 }
3207
3208 if ((target = get_target(CMD_ARGV[0])) == NULL)
3209 {
3210 LOG_ERROR("target '%s' not defined", CMD_ARGV[0]);
3211 return ERROR_FAIL;
3212 }
3213
3214 xscale = target_to_xscale(target);
3215 retval = xscale_verify_pointer(CMD_CTX, xscale);
3216 if (retval != ERROR_OK)
3217 return retval;
3218
3219 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], handler_address);
3220
3221 if (((handler_address >= 0x800) && (handler_address <= 0x1fef800)) ||
3222 ((handler_address >= 0xfe000800) && (handler_address <= 0xfffff800)))
3223 {
3224 xscale->handler_address = handler_address;
3225 }
3226 else
3227 {
3228 LOG_ERROR("xscale debug_handler <address> must be between 0x800 and 0x1fef800 or between 0xfe000800 and 0xfffff800");
3229 return ERROR_FAIL;
3230 }
3231
3232 return ERROR_OK;
3233 }
3234
3235 COMMAND_HANDLER(xscale_handle_cache_clean_address_command)
3236 {
3237 struct target *target = NULL;
3238 struct xscale_common *xscale;
3239 int retval;
3240 uint32_t cache_clean_address;
3241
3242 if (CMD_ARGC < 2)
3243 {
3244 return ERROR_COMMAND_SYNTAX_ERROR;
3245 }
3246
3247 target = get_target(CMD_ARGV[0]);
3248 if (target == NULL)
3249 {
3250 LOG_ERROR("target '%s' not defined", CMD_ARGV[0]);
3251 return ERROR_FAIL;
3252 }
3253 xscale = target_to_xscale(target);
3254 retval = xscale_verify_pointer(CMD_CTX, xscale);
3255 if (retval != ERROR_OK)
3256 return retval;
3257
3258 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], cache_clean_address);
3259
3260 if (cache_clean_address & 0xffff)
3261 {
3262 LOG_ERROR("xscale cache_clean_address <address> must be 64kb aligned");
3263 }
3264 else
3265 {
3266 xscale->cache_clean_address = cache_clean_address;
3267 }
3268
3269 return ERROR_OK;
3270 }
3271
3272 COMMAND_HANDLER(xscale_handle_cache_info_command)
3273 {
3274 struct target *target = get_current_target(CMD_CTX);
3275 struct xscale_common *xscale = target_to_xscale(target);
3276 int retval;
3277
3278 retval = xscale_verify_pointer(CMD_CTX, xscale);
3279 if (retval != ERROR_OK)
3280 return retval;
3281
3282 return armv4_5_handle_cache_info_command(CMD_CTX, &xscale->armv4_5_mmu.armv4_5_cache);
3283 }
3284
3285 static int xscale_virt2phys(struct target *target,
3286 uint32_t virtual, uint32_t *physical)
3287 {
3288 struct xscale_common *xscale = target_to_xscale(target);
3289 uint32_t cb;
3290
3291 if (xscale->common_magic != XSCALE_COMMON_MAGIC) {
3292 LOG_ERROR(xscale_not);
3293 return ERROR_TARGET_INVALID;
3294 }
3295
3296 uint32_t ret;
3297 int retval = armv4_5_mmu_translate_va(target, &xscale->armv4_5_mmu,
3298 virtual, &cb, &ret);
3299 if (retval != ERROR_OK)
3300 return retval;
3301 *physical = ret;
3302 return ERROR_OK;
3303 }
3304
3305 static int xscale_mmu(struct target *target, int *enabled)
3306 {
3307 struct xscale_common *xscale = target_to_xscale(target);
3308
3309 if (target->state != TARGET_HALTED)
3310 {
3311 LOG_ERROR("Target not halted");
3312 return ERROR_TARGET_INVALID;
3313 }
3314 *enabled = xscale->armv4_5_mmu.mmu_enabled;
3315 return ERROR_OK;
3316 }
3317
3318 COMMAND_HANDLER(xscale_handle_mmu_command)
3319 {
3320 struct target *target = get_current_target(CMD_CTX);
3321 struct xscale_common *xscale = target_to_xscale(target);
3322 int retval;
3323
3324 retval = xscale_verify_pointer(CMD_CTX, xscale);
3325 if (retval != ERROR_OK)
3326 return retval;
3327
3328 if (target->state != TARGET_HALTED)
3329 {
3330 command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
3331 return ERROR_OK;
3332 }
3333
3334 if (CMD_ARGC >= 1)
3335 {
3336 bool enable;
3337 COMMAND_PARSE_ENABLE(CMD_ARGV[0], enable);
3338 if (enable)
3339 xscale_enable_mmu_caches(target, 1, 0, 0);
3340 else
3341 xscale_disable_mmu_caches(target, 1, 0, 0);
3342 xscale->armv4_5_mmu.mmu_enabled = enable;
3343 }
3344
3345 command_print(CMD_CTX, "mmu %s", (xscale->armv4_5_mmu.mmu_enabled) ? "enabled" : "disabled");
3346
3347 return ERROR_OK;
3348 }
3349
3350 COMMAND_HANDLER(xscale_handle_idcache_command)
3351 {
3352 struct target *target = get_current_target(CMD_CTX);
3353 struct xscale_common *xscale = target_to_xscale(target);
3354
3355 int retval = xscale_verify_pointer(CMD_CTX, xscale);
3356 if (retval != ERROR_OK)
3357 return retval;
3358
3359 if (target->state != TARGET_HALTED)
3360 {
3361 command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
3362 return ERROR_OK;
3363 }
3364
3365 bool icache = false;
3366 if (strcmp(CMD_NAME, "icache") == 0)
3367 icache = true;
3368 if (CMD_ARGC >= 1)
3369 {
3370 bool enable;
3371 COMMAND_PARSE_ENABLE(CMD_ARGV[0], enable);
3372 if (icache) {
3373 xscale->armv4_5_mmu.armv4_5_cache.i_cache_enabled = enable;
3374 if (enable)
3375 xscale_enable_mmu_caches(target, 0, 0, 1);
3376 else
3377 xscale_disable_mmu_caches(target, 0, 0, 1);
3378 } else {
3379 xscale->armv4_5_mmu.armv4_5_cache.d_u_cache_enabled = enable;
3380 if (enable)
3381 xscale_enable_mmu_caches(target, 0, 1, 0);
3382 else
3383 xscale_disable_mmu_caches(target, 0, 1, 0);
3384 }
3385 }
3386
3387 bool enabled = icache ?
3388 xscale->armv4_5_mmu.armv4_5_cache.i_cache_enabled :
3389 xscale->armv4_5_mmu.armv4_5_cache.d_u_cache_enabled;
3390 const char *msg = enabled ? "enabled" : "disabled";
3391 command_print(CMD_CTX, "%s %s", CMD_NAME, msg);
3392
3393 return ERROR_OK;
3394 }
3395
3396 COMMAND_HANDLER(xscale_handle_vector_catch_command)
3397 {
3398 struct target *target = get_current_target(CMD_CTX);
3399 struct xscale_common *xscale = target_to_xscale(target);
3400 int retval;
3401
3402 retval = xscale_verify_pointer(CMD_CTX, xscale);
3403 if (retval != ERROR_OK)
3404 return retval;
3405
3406 if (CMD_ARGC < 1)
3407 {
3408 command_print(CMD_CTX, "usage: xscale vector_catch [mask]");
3409 }
3410 else
3411 {
3412 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[0], xscale->vector_catch);
3413 buf_set_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 16, 8, xscale->vector_catch);
3414 xscale_write_dcsr(target, -1, -1);
3415 }
3416
3417 command_print(CMD_CTX, "vector catch mask: 0x%2.2x", xscale->vector_catch);
3418
3419 return ERROR_OK;
3420 }
3421
3422
3423 COMMAND_HANDLER(xscale_handle_vector_table_command)
3424 {
3425 struct target *target = get_current_target(CMD_CTX);
3426 struct xscale_common *xscale = target_to_xscale(target);
3427 int err = 0;
3428 int retval;
3429
3430 retval = xscale_verify_pointer(CMD_CTX, xscale);
3431 if (retval != ERROR_OK)
3432 return retval;
3433
3434 if (CMD_ARGC == 0) /* print current settings */
3435 {
3436 int idx;
3437
3438 command_print(CMD_CTX, "active user-set static vectors:");
3439 for (idx = 1; idx < 8; idx++)
3440 if (xscale->static_low_vectors_set & (1 << idx))
3441 command_print(CMD_CTX, "low %d: 0x%" PRIx32, idx, xscale->static_low_vectors[idx]);
3442 for (idx = 1; idx < 8; idx++)
3443 if (xscale->static_high_vectors_set & (1 << idx))
3444 command_print(CMD_CTX, "high %d: 0x%" PRIx32, idx, xscale->static_high_vectors[idx]);
3445 return ERROR_OK;
3446 }
3447
3448 if (CMD_ARGC != 3)
3449 err = 1;
3450 else
3451 {
3452 int idx;
3453 COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], idx);
3454 uint32_t vec;
3455 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], vec);
3456
3457 if (idx < 1 || idx >= 8)
3458 err = 1;
3459
3460 if (!err && strcmp(CMD_ARGV[0], "low") == 0)
3461 {
3462 xscale->static_low_vectors_set |= (1<<idx);
3463 xscale->static_low_vectors[idx] = vec;
3464 }
3465 else if (!err && (strcmp(CMD_ARGV[0], "high") == 0))
3466 {
3467 xscale->static_high_vectors_set |= (1<<idx);
3468 xscale->static_high_vectors[idx] = vec;
3469 }
3470 else
3471 err = 1;
3472 }
3473
3474 if (err)
3475 command_print(CMD_CTX, "usage: xscale vector_table <high|low> <index> <code>");
3476
3477 return ERROR_OK;
3478 }
3479
3480
3481 COMMAND_HANDLER(xscale_handle_trace_buffer_command)
3482 {
3483 struct target *target = get_current_target(CMD_CTX);
3484 struct xscale_common *xscale = target_to_xscale(target);
3485 uint32_t dcsr_value;
3486 int retval;
3487
3488 retval = xscale_verify_pointer(CMD_CTX, xscale);
3489 if (retval != ERROR_OK)
3490 return retval;
3491
3492 if (target->state != TARGET_HALTED)
3493 {
3494 command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
3495 return ERROR_OK;
3496 }
3497
3498 if (CMD_ARGC >= 1)
3499 {
3500 if (strcmp("enable", CMD_ARGV[0]) == 0)
3501 xscale->trace.mode = XSCALE_TRACE_WRAP; /* default */
3502 else if (strcmp("disable", CMD_ARGV[0]) == 0)
3503 xscale->trace.mode = XSCALE_TRACE_DISABLED;
3504 else
3505 return ERROR_INVALID_ARGUMENTS;
3506 }
3507
3508 if (CMD_ARGC >= 2 && xscale->trace.mode != XSCALE_TRACE_DISABLED)
3509 {
3510 if (strcmp("fill", CMD_ARGV[1]) == 0)
3511 {
3512 int buffcount = 1; /* default */
3513 if (CMD_ARGC >= 3)
3514 COMMAND_PARSE_NUMBER(int, CMD_ARGV[2], buffcount);
3515 if (buffcount < 1) /* invalid */
3516 {
3517 command_print(CMD_CTX, "fill buffer count must be > 0");
3518 xscale->trace.mode = XSCALE_TRACE_DISABLED;
3519 return ERROR_INVALID_ARGUMENTS;
3520 }
3521 xscale->trace.buffer_fill = buffcount;
3522 xscale->trace.mode = XSCALE_TRACE_FILL;
3523 }
3524 else if (strcmp("wrap", CMD_ARGV[1]) == 0)
3525 xscale->trace.mode = XSCALE_TRACE_WRAP;
3526 else
3527 {
3528 xscale->trace.mode = XSCALE_TRACE_DISABLED;
3529 return ERROR_INVALID_ARGUMENTS;
3530 }
3531 }
3532
3533 if (xscale->trace.mode != XSCALE_TRACE_DISABLED)
3534 {
3535 char fill_string[12];
3536 sprintf(fill_string, "fill %" PRId32, xscale->trace.buffer_fill);
3537 command_print(CMD_CTX, "trace buffer enabled (%s)",
3538 (xscale->trace.mode == XSCALE_TRACE_FILL)
3539 ? fill_string : "wrap");
3540 }
3541 else
3542 command_print(CMD_CTX, "trace buffer disabled");
3543
3544 dcsr_value = buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 0, 32);
3545 if (xscale->trace.mode == XSCALE_TRACE_FILL)
3546 xscale_write_dcsr_sw(target, (dcsr_value & 0xfffffffc) | 2);
3547 else
3548 xscale_write_dcsr_sw(target, dcsr_value & 0xfffffffc);
3549
3550 return ERROR_OK;
3551 }
3552
3553 COMMAND_HANDLER(xscale_handle_trace_image_command)
3554 {
3555 struct target *target = get_current_target(CMD_CTX);
3556 struct xscale_common *xscale = target_to_xscale(target);
3557 int retval;
3558
3559 if (CMD_ARGC < 1)
3560 {
3561 command_print(CMD_CTX, "usage: xscale trace_image <file> [base address] [type]");
3562 return ERROR_OK;
3563 }
3564
3565 retval = xscale_verify_pointer(CMD_CTX, xscale);
3566 if (retval != ERROR_OK)
3567 return retval;
3568
3569 if (xscale->trace.image)
3570 {
3571 image_close(xscale->trace.image);
3572 free(xscale->trace.image);
3573 command_print(CMD_CTX, "previously loaded image found and closed");
3574 }
3575
3576 xscale->trace.image = malloc(sizeof(struct image));
3577 xscale->trace.image->base_address_set = 0;
3578 xscale->trace.image->start_address_set = 0;
3579
3580 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
3581 if (CMD_ARGC >= 2)
3582 {
3583 xscale->trace.image->base_address_set = 1;
3584 COMMAND_PARSE_NUMBER(llong, CMD_ARGV[1], xscale->trace.image->base_address);
3585 }
3586 else
3587 {
3588 xscale->trace.image->base_address_set = 0;
3589 }
3590
3591 if (image_open(xscale->trace.image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
3592 {
3593 free(xscale->trace.image);
3594 xscale->trace.image = NULL;
3595 return ERROR_OK;
3596 }
3597
3598 return ERROR_OK;
3599 }
3600
3601 COMMAND_HANDLER(xscale_handle_dump_trace_command)
3602 {
3603 struct target *target = get_current_target(CMD_CTX);
3604 struct xscale_common *xscale = target_to_xscale(target);
3605 struct xscale_trace_data *trace_data;
3606 struct fileio file;
3607 int retval;
3608
3609 retval = xscale_verify_pointer(CMD_CTX, xscale);
3610 if (retval != ERROR_OK)
3611 return retval;
3612
3613 if (target->state != TARGET_HALTED)
3614 {
3615 command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
3616 return ERROR_OK;
3617 }
3618
3619 if (CMD_ARGC < 1)
3620 {
3621 command_print(CMD_CTX, "usage: xscale dump_trace <file>");
3622 return ERROR_OK;
3623 }
3624
3625 trace_data = xscale->trace.data;
3626
3627 if (!trace_data)
3628 {
3629 command_print(CMD_CTX, "no trace data collected");
3630 return ERROR_OK;
3631 }
3632
3633 if (fileio_open(&file, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
3634 {
3635 return ERROR_OK;
3636 }
3637
3638 while (trace_data)
3639 {
3640 int i;
3641
3642 fileio_write_u32(&file, trace_data->chkpt0);
3643 fileio_write_u32(&file, trace_data->chkpt1);
3644 fileio_write_u32(&file, trace_data->last_instruction);
3645 fileio_write_u32(&file, trace_data->depth);
3646
3647 for (i = 0; i < trace_data->depth; i++)
3648 fileio_write_u32(&file, trace_data->entries[i].data | ((trace_data->entries[i].type & 0xffff) << 16));
3649
3650 trace_data = trace_data->next;
3651 }
3652
3653 fileio_close(&file);
3654
3655 return ERROR_OK;
3656 }
3657
3658 COMMAND_HANDLER(xscale_handle_analyze_trace_buffer_command)
3659 {
3660 struct target *target = get_current_target(CMD_CTX);
3661 struct xscale_common *xscale = target_to_xscale(target);
3662 int retval;
3663
3664 retval = xscale_verify_pointer(CMD_CTX, xscale);
3665 if (retval != ERROR_OK)
3666 return retval;
3667
3668 xscale_analyze_trace(target, CMD_CTX);
3669
3670 return ERROR_OK;
3671 }
3672
3673 COMMAND_HANDLER(xscale_handle_cp15)
3674 {
3675 struct target *target = get_current_target(CMD_CTX);
3676 struct xscale_common *xscale = target_to_xscale(target);
3677 int retval;
3678
3679 retval = xscale_verify_pointer(CMD_CTX, xscale);
3680 if (retval != ERROR_OK)
3681 return retval;
3682
3683 if (target->state != TARGET_HALTED)
3684 {
3685 command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
3686 return ERROR_OK;
3687 }
3688 uint32_t reg_no = 0;
3689 struct reg *reg = NULL;
3690 if (CMD_ARGC > 0)
3691 {
3692 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], reg_no);
3693 /*translate from xscale cp15 register no to openocd register*/
3694 switch (reg_no)
3695 {
3696 case 0:
3697 reg_no = XSCALE_MAINID;
3698 break;
3699 case 1:
3700 reg_no = XSCALE_CTRL;
3701 break;
3702 case 2:
3703 reg_no = XSCALE_TTB;
3704 break;
3705 case 3:
3706 reg_no = XSCALE_DAC;
3707 break;
3708 case 5:
3709 reg_no = XSCALE_FSR;
3710 break;
3711 case 6:
3712 reg_no = XSCALE_FAR;
3713 break;
3714 case 13:
3715 reg_no = XSCALE_PID;
3716 break;
3717 case 15:
3718 reg_no = XSCALE_CPACCESS;
3719 break;
3720 default:
3721 command_print(CMD_CTX, "invalid register number");
3722 return ERROR_INVALID_ARGUMENTS;
3723 }
3724 reg = &xscale->reg_cache->reg_list[reg_no];
3725
3726 }
3727 if (CMD_ARGC == 1)
3728 {
3729 uint32_t value;
3730
3731 /* read cp15 control register */
3732 xscale_get_reg(reg);
3733 value = buf_get_u32(reg->value, 0, 32);
3734 command_print(CMD_CTX, "%s (/%i): 0x%" PRIx32 "", reg->name, (int)(reg->size), value);
3735 }
3736 else if (CMD_ARGC == 2)
3737 {
3738 uint32_t value;
3739 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
3740
3741 /* send CP write request (command 0x41) */
3742 xscale_send_u32(target, 0x41);
3743
3744 /* send CP register number */
3745 xscale_send_u32(target, reg_no);
3746
3747 /* send CP register value */
3748 xscale_send_u32(target, value);
3749
3750 /* execute cpwait to ensure outstanding operations complete */
3751 xscale_send_u32(target, 0x53);
3752 }
3753 else
3754 {
3755 command_print(CMD_CTX, "usage: cp15 [register]<, [value]>");
3756 }
3757
3758 return ERROR_OK;
3759 }
3760
3761 static const struct command_registration xscale_exec_command_handlers[] = {
3762 {
3763 .name = "cache_info",
3764 .handler = xscale_handle_cache_info_command,
3765 .mode = COMMAND_EXEC,
3766 .help = "display information about CPU caches",
3767 },
3768 {
3769 .name = "mmu",
3770 .handler = xscale_handle_mmu_command,
3771 .mode = COMMAND_EXEC,
3772 .help = "enable or disable the MMU",
3773 .usage = "['enable'|'disable']",
3774 },
3775 {
3776 .name = "icache",
3777 .handler = xscale_handle_idcache_command,
3778 .mode = COMMAND_EXEC,
3779 .help = "display ICache state, optionally enabling or "
3780 "disabling it",
3781 .usage = "['enable'|'disable']",
3782 },
3783 {
3784 .name = "dcache",
3785 .handler = xscale_handle_idcache_command,
3786 .mode = COMMAND_EXEC,
3787 .help = "display DCache state, optionally enabling or "
3788 "disabling it",
3789 .usage = "['enable'|'disable']",
3790 },
3791 {
3792 .name = "vector_catch",
3793 .handler = xscale_handle_vector_catch_command,
3794 .mode = COMMAND_EXEC,
3795 .help = "set or display 8-bit mask of vectors "
3796 "that should trigger debug entry",
3797 .usage = "[mask]",
3798 },
3799 {
3800 .name = "vector_table",
3801 .handler = xscale_handle_vector_table_command,
3802 .mode = COMMAND_EXEC,
3803 .help = "set vector table entry in mini-ICache, "
3804 "or display current tables",
3805 .usage = "[('high'|'low') index code]",
3806 },
3807 {
3808 .name = "trace_buffer",
3809 .handler = xscale_handle_trace_buffer_command,
3810 .mode = COMMAND_EXEC,
3811 .help = "display trace buffer status, enable or disable "
3812 "tracing, and optionally reconfigure trace mode",
3813 .usage = "['enable'|'disable' ['fill' [number]|'wrap']]",
3814 },
3815 {
3816 .name = "dump_trace",
3817 .handler = xscale_handle_dump_trace_command,
3818 .mode = COMMAND_EXEC,
3819 .help = "dump content of trace buffer to file",
3820 .usage = "filename",
3821 },
3822 {
3823 .name = "analyze_trace",
3824 .handler = xscale_handle_analyze_trace_buffer_command,
3825 .mode = COMMAND_EXEC,
3826 .help = "analyze content of trace buffer",
3827 .usage = "",
3828 },
3829 {
3830 .name = "trace_image",
3831 .handler = xscale_handle_trace_image_command,
3832 .mode = COMMAND_EXEC,
3833 .help = "load image from file to address (default 0)",
3834 .usage = "filename [offset [filetype]]",
3835 },
3836 {
3837 .name = "cp15",
3838 .handler = xscale_handle_cp15,
3839 .mode = COMMAND_EXEC,
3840 .help = "Read or write coprocessor 15 register.",
3841 .usage = "register [value]",
3842 },
3843 COMMAND_REGISTRATION_DONE
3844 };
3845 static const struct command_registration xscale_any_command_handlers[] = {
3846 {
3847 .name = "debug_handler",
3848 .handler = xscale_handle_debug_handler_command,
3849 .mode = COMMAND_ANY,
3850 .help = "Change address used for debug handler.",
3851 .usage = "target address",
3852 },
3853 {
3854 .name = "cache_clean_address",
3855 .handler = xscale_handle_cache_clean_address_command,
3856 .mode = COMMAND_ANY,
3857 .help = "Change address used for cleaning data cache.",
3858 .usage = "address",
3859 },
3860 {
3861 .chain = xscale_exec_command_handlers,
3862 },
3863 COMMAND_REGISTRATION_DONE
3864 };
3865 static const struct command_registration xscale_command_handlers[] = {
3866 {
3867 .chain = arm_command_handlers,
3868 },
3869 {
3870 .name = "xscale",
3871 .mode = COMMAND_ANY,
3872 .help = "xscale command group",
3873 .chain = xscale_any_command_handlers,
3874 },
3875 COMMAND_REGISTRATION_DONE
3876 };
3877
3878 struct target_type xscale_target =
3879 {
3880 .name = "xscale",
3881
3882 .poll = xscale_poll,
3883 .arch_state = xscale_arch_state,
3884
3885 .target_request_data = NULL,
3886
3887 .halt = xscale_halt,
3888 .resume = xscale_resume,
3889 .step = xscale_step,
3890
3891 .assert_reset = xscale_assert_reset,
3892 .deassert_reset = xscale_deassert_reset,
3893 .soft_reset_halt = NULL,
3894
3895 /* REVISIT on some cores, allow exporting iwmmxt registers ... */
3896 .get_gdb_reg_list = arm_get_gdb_reg_list,
3897
3898 .read_memory = xscale_read_memory,
3899 .read_phys_memory = xscale_read_phys_memory,
3900 .write_memory = xscale_write_memory,
3901 .write_phys_memory = xscale_write_phys_memory,
3902 .bulk_write_memory = xscale_bulk_write_memory,
3903
3904 .checksum_memory = arm_checksum_memory,
3905 .blank_check_memory = arm_blank_check_memory,
3906
3907 .run_algorithm = armv4_5_run_algorithm,
3908
3909 .add_breakpoint = xscale_add_breakpoint,
3910 .remove_breakpoint = xscale_remove_breakpoint,
3911 .add_watchpoint = xscale_add_watchpoint,
3912 .remove_watchpoint = xscale_remove_watchpoint,
3913
3914 .commands = xscale_command_handlers,
3915 .target_create = xscale_target_create,
3916 .init_target = xscale_init_target,
3917
3918 .virt2phys = xscale_virt2phys,
3919 .mmu = xscale_mmu
3920 };
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)