Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- added support for AT91SAM7A3 flash (patch from andre renaud, thanks)
[openocd.git] / src / target / arm7_9_common.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #include "config.h"
21
22 #include "embeddedice.h"
23 #include "target.h"
24 #include "armv4_5.h"
25 #include "arm_jtag.h"
26 #include "jtag.h"
27 #include "log.h"
28 #include "arm7_9_common.h"
29 #include "breakpoints.h"
30
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <sys/time.h>
38 #include <errno.h>
39
40 int arm7_9_debug_entry(target_t *target);
41 int arm7_9_enable_sw_bkpts(struct target_s *target);
42
43 /* command handler forward declarations */
44 int handle_arm7_9_write_xpsr_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
45 int handle_arm7_9_write_xpsr_im8_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
46 int handle_arm7_9_read_core_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
47 int handle_arm7_9_write_core_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
48 int handle_arm7_9_sw_bkpts_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
49 int handle_arm7_9_force_hw_bkpts_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
50 int handle_arm7_9_dbgrq_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
51 int handle_arm7_9_fast_writes_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
52 int handle_arm7_9_dcc_downloads_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
53
54 int arm7_9_reinit_embeddedice(target_t *target)
55 {
56 armv4_5_common_t *armv4_5 = target->arch_info;
57 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
58
59 breakpoint_t *breakpoint = target->breakpoints;
60
61 arm7_9->wp_available = 2;
62 arm7_9->wp0_used = 0;
63 arm7_9->wp1_used = 0;
64
65 /* mark all hardware breakpoints as unset */
66 while (breakpoint)
67 {
68 if (breakpoint->type == BKPT_HARD)
69 {
70 breakpoint->set = 0;
71 }
72 breakpoint = breakpoint->next;
73 }
74
75 if (arm7_9->sw_bkpts_enabled && arm7_9->sw_bkpts_use_wp)
76 {
77 arm7_9->sw_bkpts_enabled = 0;
78 arm7_9_enable_sw_bkpts(target);
79 }
80
81 arm7_9->reinit_embeddedice = 0;
82
83 return ERROR_OK;
84 }
85
86 int arm7_9_jtag_callback(enum jtag_event event, void *priv)
87 {
88 target_t *target = priv;
89 armv4_5_common_t *armv4_5 = target->arch_info;
90 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
91
92 /* a test-logic reset occured
93 * the EmbeddedICE registers have been reset
94 * hardware breakpoints have been cleared
95 */
96 if (event == JTAG_TRST_ASSERTED)
97 {
98 arm7_9->reinit_embeddedice = 1;
99 }
100
101 return ERROR_OK;
102 }
103
104 int arm7_9_get_arch_pointers(target_t *target, armv4_5_common_t **armv4_5_p, arm7_9_common_t **arm7_9_p)
105 {
106 armv4_5_common_t *armv4_5 = target->arch_info;
107 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
108
109 if (armv4_5->common_magic != ARMV4_5_COMMON_MAGIC)
110 {
111 return -1;
112 }
113
114 if (arm7_9->common_magic != ARM7_9_COMMON_MAGIC)
115 {
116 return -1;
117 }
118
119 *armv4_5_p = armv4_5;
120 *arm7_9_p = arm7_9;
121
122 return ERROR_OK;
123 }
124
125 int arm7_9_set_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
126 {
127 armv4_5_common_t *armv4_5 = target->arch_info;
128 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
129
130 if (target->state != TARGET_HALTED)
131 {
132 WARNING("target not halted");
133 return ERROR_TARGET_NOT_HALTED;
134 }
135
136 if (arm7_9->force_hw_bkpts)
137 breakpoint->type = BKPT_HARD;
138
139 if (breakpoint->set)
140 {
141 WARNING("breakpoint already set");
142 return ERROR_OK;
143 }
144
145 if (breakpoint->type == BKPT_HARD)
146 {
147 /* either an ARM (4 byte) or Thumb (2 byte) breakpoint */
148 u32 mask = (breakpoint->length == 4) ? 0x3u : 0x1u;
149 if (!arm7_9->wp0_used)
150 {
151 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_VALUE], breakpoint->address);
152 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], mask);
153 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0xffffffffu);
154 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
155 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
156
157 jtag_execute_queue();
158 arm7_9->wp0_used = 1;
159 breakpoint->set = 1;
160 }
161 else if (!arm7_9->wp1_used)
162 {
163 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE], breakpoint->address);
164 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK], mask);
165 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK], 0xffffffffu);
166 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
167 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
168
169 jtag_execute_queue();
170 arm7_9->wp1_used = 1;
171 breakpoint->set = 2;
172 }
173 else
174 {
175 ERROR("BUG: no hardware comparator available");
176 return ERROR_OK;
177 }
178 }
179 else if (breakpoint->type == BKPT_SOFT)
180 {
181 if (breakpoint->length == 4)
182 {
183 target->type->read_memory(target, breakpoint->address, 4, 1, breakpoint->orig_instr);
184 target->type->write_memory(target, breakpoint->address, 4, 1, (u8*)(&arm7_9->arm_bkpt));
185 }
186 else
187 {
188 target->type->read_memory(target, breakpoint->address, 2, 1, breakpoint->orig_instr);
189 target->type->read_memory(target, breakpoint->address, 2, 1, (u8*)(&arm7_9->arm_bkpt));
190 }
191 breakpoint->set = 1;
192 }
193
194 return ERROR_OK;
195
196 }
197
198 int arm7_9_unset_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
199 {
200 armv4_5_common_t *armv4_5 = target->arch_info;
201 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
202
203 if (target->state != TARGET_HALTED)
204 {
205 WARNING("target not halted");
206 return ERROR_TARGET_NOT_HALTED;
207 }
208
209 if (!breakpoint->set)
210 {
211 WARNING("breakpoint not set");
212 return ERROR_OK;
213 }
214
215 if (breakpoint->type == BKPT_HARD)
216 {
217 if (breakpoint->set == 1)
218 {
219 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x0);
220 jtag_execute_queue();
221 arm7_9->wp0_used = 0;
222 }
223 else if (breakpoint->set == 2)
224 {
225 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0);
226 jtag_execute_queue();
227 arm7_9->wp1_used = 0;
228 }
229 breakpoint->set = 0;
230 }
231 else
232 {
233 if (breakpoint->length == 4)
234 {
235 target->type->write_memory(target, breakpoint->address, 4, 1, breakpoint->orig_instr);
236 }
237 else
238 {
239 target->type->write_memory(target, breakpoint->address, 2, 1, breakpoint->orig_instr);
240 }
241 breakpoint->set = 0;
242 }
243
244 return ERROR_OK;
245 }
246
247 int arm7_9_add_breakpoint(struct target_s *target, u32 address, u32 length, enum breakpoint_type type)
248 {
249 armv4_5_common_t *armv4_5 = target->arch_info;
250 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
251
252 if (target->state != TARGET_HALTED)
253 {
254 WARNING("target not halted");
255 return ERROR_TARGET_NOT_HALTED;
256 }
257
258 if (arm7_9->force_hw_bkpts)
259 {
260 type = BKPT_HARD;
261 }
262
263 if ((type == BKPT_SOFT) && (arm7_9->sw_bkpts_enabled == 0))
264 {
265 INFO("sw breakpoint requested, but software breakpoints not enabled");
266 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
267 }
268
269 if ((type == BKPT_HARD) && (arm7_9->wp_available < 1))
270 {
271 INFO("no watchpoint unit available for hardware breakpoint");
272 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
273 }
274
275 if (type == BKPT_HARD)
276 arm7_9->wp_available--;
277
278 if ((length != 2) && (length != 4))
279 {
280 INFO("only breakpoints of two (Thumb) or four (ARM) bytes length supported");
281 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
282 }
283
284 return ERROR_OK;
285 }
286
287 int arm7_9_remove_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
288 {
289 armv4_5_common_t *armv4_5 = target->arch_info;
290 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
291
292 if (target->state != TARGET_HALTED)
293 {
294 WARNING("target not halted");
295 return ERROR_TARGET_NOT_HALTED;
296 }
297
298 if (breakpoint->set)
299 {
300 arm7_9_unset_breakpoint(target, breakpoint);
301 }
302
303 arm7_9->wp_available++;
304
305 return ERROR_OK;
306 }
307
308 int arm7_9_set_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
309 {
310 armv4_5_common_t *armv4_5 = target->arch_info;
311 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
312 int rw_mask = 1;
313 u32 mask;
314
315 mask = watchpoint->length - 1;
316
317 if (target->state != TARGET_HALTED)
318 {
319 WARNING("target not halted");
320 return ERROR_TARGET_NOT_HALTED;
321 }
322
323 if (watchpoint->rw == WPT_ACCESS)
324 rw_mask = 0;
325 else
326 rw_mask = 1;
327
328 if (!arm7_9->wp0_used)
329 {
330 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_VALUE], watchpoint->address);
331 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], mask);
332 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], watchpoint->mask);
333 if( watchpoint->mask != 0xffffffffu )
334 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_VALUE], watchpoint->value);
335 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], 0xff & ~EICE_W_CTRL_nOPC & ~rw_mask);
336 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE | EICE_W_CTRL_nOPC | (watchpoint->rw & 1));
337
338 jtag_execute_queue();
339 watchpoint->set = 1;
340 arm7_9->wp0_used = 2;
341 }
342 else if (!arm7_9->wp1_used)
343 {
344 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE], watchpoint->address);
345 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK], mask);
346 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK], watchpoint->mask);
347 if( watchpoint->mask != 0xffffffffu )
348 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_VALUE], watchpoint->value);
349 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_MASK], 0xff & ~EICE_W_CTRL_nOPC & ~rw_mask);
350 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], EICE_W_CTRL_ENABLE | EICE_W_CTRL_nOPC | (watchpoint->rw & 1));
351
352 jtag_execute_queue();
353 watchpoint->set = 2;
354 arm7_9->wp1_used = 2;
355 }
356 else
357 {
358 ERROR("BUG: no hardware comparator available");
359 return ERROR_OK;
360 }
361
362 return ERROR_OK;
363 }
364
365 int arm7_9_unset_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
366 {
367 armv4_5_common_t *armv4_5 = target->arch_info;
368 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
369
370 if (target->state != TARGET_HALTED)
371 {
372 WARNING("target not halted");
373 return ERROR_TARGET_NOT_HALTED;
374 }
375
376 if (!watchpoint->set)
377 {
378 WARNING("breakpoint not set");
379 return ERROR_OK;
380 }
381
382 if (watchpoint->set == 1)
383 {
384 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x0);
385 jtag_execute_queue();
386 arm7_9->wp0_used = 0;
387 }
388 else if (watchpoint->set == 2)
389 {
390 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0);
391 jtag_execute_queue();
392 arm7_9->wp1_used = 0;
393 }
394 watchpoint->set = 0;
395
396 return ERROR_OK;
397 }
398
399 int arm7_9_add_watchpoint(struct target_s *target, u32 address, u32 length, enum watchpoint_rw rw)
400 {
401 armv4_5_common_t *armv4_5 = target->arch_info;
402 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
403
404 if (target->state != TARGET_HALTED)
405 {
406 WARNING("target not halted");
407 return ERROR_TARGET_NOT_HALTED;
408 }
409
410 if (arm7_9->wp_available < 1)
411 {
412 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
413 }
414
415 if ((length != 1) && (length != 2) && (length != 4))
416 {
417 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
418 }
419
420 arm7_9->wp_available--;
421
422 return ERROR_OK;
423 }
424
425 int arm7_9_remove_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
426 {
427 armv4_5_common_t *armv4_5 = target->arch_info;
428 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
429
430 if (target->state != TARGET_HALTED)
431 {
432 WARNING("target not halted");
433 return ERROR_TARGET_NOT_HALTED;
434 }
435
436 if (watchpoint->set)
437 {
438 arm7_9_unset_watchpoint(target, watchpoint);
439 }
440
441 arm7_9->wp_available++;
442
443 return ERROR_OK;
444 }
445
446 int arm7_9_enable_sw_bkpts(struct target_s *target)
447 {
448 armv4_5_common_t *armv4_5 = target->arch_info;
449 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
450 int retval;
451
452 if (arm7_9->sw_bkpts_enabled)
453 return ERROR_OK;
454
455 if (arm7_9->wp_available-- < 1)
456 {
457 WARNING("can't enable sw breakpoints with no watchpoint unit available");
458 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
459 }
460
461 if (!arm7_9->wp0_used)
462 {
463 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_VALUE], arm7_9->arm_bkpt);
464 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0x0);
465 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], 0xffffffffu);
466 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
467 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
468 arm7_9->sw_bkpts_enabled = 1;
469 arm7_9->wp0_used = 3;
470 }
471 else if (!arm7_9->wp1_used)
472 {
473 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_VALUE], arm7_9->arm_bkpt);
474 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK], 0x0);
475 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK], 0xffffffffu);
476 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
477 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
478 arm7_9->sw_bkpts_enabled = 2;
479 arm7_9->wp1_used = 3;
480 }
481 else
482 {
483 ERROR("BUG: both watchpoints used, but wp_available >= 1");
484 exit(-1);
485 }
486
487 if ((retval = jtag_execute_queue()) != ERROR_OK)
488 {
489 ERROR("error writing EmbeddedICE registers to enable sw breakpoints");
490 exit(-1);
491 };
492
493 return ERROR_OK;
494 }
495
496 int arm7_9_disable_sw_bkpts(struct target_s *target)
497 {
498 armv4_5_common_t *armv4_5 = target->arch_info;
499 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
500
501 if (!arm7_9->sw_bkpts_enabled)
502 return ERROR_OK;
503
504 if (arm7_9->sw_bkpts_enabled == 1)
505 {
506 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x0);
507 arm7_9->sw_bkpts_enabled = 0;
508 arm7_9->wp0_used = 0;
509 arm7_9->wp_available++;
510 }
511 else if (arm7_9->sw_bkpts_enabled == 2)
512 {
513 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0);
514 arm7_9->sw_bkpts_enabled = 0;
515 arm7_9->wp1_used = 0;
516 arm7_9->wp_available++;
517 }
518
519 return ERROR_OK;
520 }
521
522 int arm7_9_execute_sys_speed(struct target_s *target)
523 {
524 int timeout;
525 int retval;
526
527 armv4_5_common_t *armv4_5 = target->arch_info;
528 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
529 arm_jtag_t *jtag_info = &arm7_9->jtag_info;
530 reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT];
531
532 /* set RESTART instruction */
533 jtag_add_end_state(TAP_RTI);
534 arm_jtag_set_instr(jtag_info, 0x4);
535
536 for (timeout=0; timeout<50; timeout++)
537 {
538 /* read debug status register */
539 embeddedice_read_reg(dbg_stat);
540 if ((retval = jtag_execute_queue()) != ERROR_OK)
541 return retval;
542 if ((buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1))
543 && (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_SYSCOMP, 1)))
544 break;
545 usleep(100000);
546 }
547 if (timeout == 50)
548 {
549 ERROR("timeout waiting for SYSCOMP & DBGACK, last DBG_STATUS: %x", buf_get_u32(dbg_stat->value, 0, dbg_stat->size));
550 return ERROR_TARGET_TIMEOUT;
551 }
552
553 return ERROR_OK;
554 }
555
556 int arm7_9_execute_fast_sys_speed(struct target_s *target)
557 {
558 u8 check_value[4], check_mask[4];
559
560 armv4_5_common_t *armv4_5 = target->arch_info;
561 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
562 arm_jtag_t *jtag_info = &arm7_9->jtag_info;
563 reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT];
564
565 /* set RESTART instruction */
566 jtag_add_end_state(TAP_RTI);
567 arm_jtag_set_instr(jtag_info, 0x4);
568
569 /* check for DBGACK and SYSCOMP set (others don't care) */
570 buf_set_u32(check_value, 0, 32, 0x9);
571 buf_set_u32(check_mask, 0, 32, 0x9);
572
573 /* read debug status register */
574 embeddedice_read_reg_w_check(dbg_stat, check_value, check_value);
575
576 return ERROR_OK;
577 }
578
579 enum target_state arm7_9_poll(target_t *target)
580 {
581 int retval;
582 armv4_5_common_t *armv4_5 = target->arch_info;
583 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
584 reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT];
585 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
586
587 if (arm7_9->reinit_embeddedice)
588 {
589 arm7_9_reinit_embeddedice(target);
590 }
591
592 /* read debug status register */
593 embeddedice_read_reg(dbg_stat);
594 if ((retval = jtag_execute_queue()) != ERROR_OK)
595 {
596 switch (retval)
597 {
598 case ERROR_JTAG_QUEUE_FAILED:
599 ERROR("JTAG queue failed while reading EmbeddedICE status register");
600 exit(-1);
601 break;
602 default:
603 break;
604 }
605 }
606
607 if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1))
608 {
609 DEBUG("DBGACK set, dbg_state->value: 0x%x", buf_get_u32(dbg_stat->value, 0, 32));
610 if ((target->state == TARGET_UNKNOWN))
611 {
612 WARNING("DBGACK set while target was in unknown state. Reset or initialize target before resuming");
613 target->state = TARGET_RUNNING;
614 }
615 if ((target->state == TARGET_RUNNING) || (target->state == TARGET_RESET))
616 {
617 target->state = TARGET_HALTED;
618 if ((retval = arm7_9_debug_entry(target)) != ERROR_OK)
619 return retval;
620
621 target_call_event_callbacks(target, TARGET_EVENT_HALTED);
622 }
623 if (target->state == TARGET_DEBUG_RUNNING)
624 {
625 target->state = TARGET_HALTED;
626 if ((retval = arm7_9_debug_entry(target)) != ERROR_OK)
627 return retval;
628
629 target_call_event_callbacks(target, TARGET_EVENT_DEBUG_HALTED);
630 }
631 }
632 else
633 {
634 if (target->state != TARGET_DEBUG_RUNNING)
635 target->state = TARGET_RUNNING;
636 }
637
638 return target->state;
639 }
640
641 int arm7_9_assert_reset(target_t *target)
642 {
643 int retval;
644
645 DEBUG("target->state: %s", target_state_strings[target->state]);
646
647 if (target->state == TARGET_HALTED || target->state == TARGET_UNKNOWN)
648 {
649 /* assert SRST and TRST */
650 /* system would get ouf sync if we didn't reset test-logic, too */
651 if ((retval = jtag_add_reset(1, 1)) != ERROR_OK)
652 {
653 if (retval == ERROR_JTAG_RESET_CANT_SRST)
654 {
655 WARNING("can't assert srst");
656 return retval;
657 }
658 else
659 {
660 ERROR("unknown error");
661 exit(-1);
662 }
663 }
664 jtag_add_sleep(5000);
665 if ((retval = jtag_add_reset(0, 1)) != ERROR_OK)
666 {
667 if (retval == ERROR_JTAG_RESET_WOULD_ASSERT_TRST)
668 {
669 WARNING("srst resets test logic, too");
670 retval = jtag_add_reset(1, 1);
671 }
672 }
673 }
674 else
675 {
676 if ((retval = jtag_add_reset(0, 1)) != ERROR_OK)
677 {
678 if (retval == ERROR_JTAG_RESET_WOULD_ASSERT_TRST)
679 {
680 WARNING("srst resets test logic, too");
681 retval = jtag_add_reset(1, 1);
682 }
683
684 if (retval == ERROR_JTAG_RESET_CANT_SRST)
685 {
686 WARNING("can't assert srst");
687 return retval;
688 }
689 else if (retval != ERROR_OK)
690 {
691 ERROR("unknown error");
692 exit(-1);
693 }
694 }
695 }
696
697 target->state = TARGET_RESET;
698 jtag_add_sleep(50000);
699
700 armv4_5_invalidate_core_regs(target);
701
702 return ERROR_OK;
703
704 }
705
706 int arm7_9_deassert_reset(target_t *target)
707 {
708 DEBUG("target->state: %s", target_state_strings[target->state]);
709
710 /* deassert reset lines */
711 jtag_add_reset(0, 0);
712
713 return ERROR_OK;
714
715 }
716
717 int arm7_9_soft_reset_halt(struct target_s *target)
718 {
719 armv4_5_common_t *armv4_5 = target->arch_info;
720 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
721 reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT];
722 int i;
723
724 if (target->state == TARGET_RUNNING)
725 {
726 target->type->halt(target);
727 }
728
729 while (buf_get_u32(dbg_stat->value, EICE_DBG_CONTROL_DBGACK, 1) == 0)
730 {
731 embeddedice_read_reg(dbg_stat);
732 jtag_execute_queue();
733 }
734 target->state = TARGET_HALTED;
735
736 /* all register content is now invalid */
737 armv4_5_invalidate_core_regs(target);
738
739 /* SVC, ARM state, IRQ and FIQ disabled */
740 buf_set_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8, 0xd3);
741 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].dirty = 1;
742 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].valid = 1;
743
744 /* start fetching from 0x0 */
745 buf_set_u32(armv4_5->core_cache->reg_list[15].value, 0, 32, 0x0);
746 armv4_5->core_cache->reg_list[15].dirty = 1;
747 armv4_5->core_cache->reg_list[15].valid = 1;
748
749 armv4_5->core_mode = ARMV4_5_MODE_SVC;
750 armv4_5->core_state = ARMV4_5_STATE_ARM;
751
752 /* reset registers */
753 for (i = 0; i <= 14; i++)
754 {
755 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).value, 0, 32, 0xffffffff);
756 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = 1;
757 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).valid = 1;
758 }
759
760 target_call_event_callbacks(target, TARGET_EVENT_HALTED);
761
762 return ERROR_OK;
763 }
764
765 int arm7_9_halt(target_t *target)
766 {
767 armv4_5_common_t *armv4_5 = target->arch_info;
768 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
769 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
770
771 DEBUG("target->state: %s", target_state_strings[target->state]);
772
773 if (target->state == TARGET_HALTED)
774 {
775 WARNING("target was already halted");
776 return ERROR_TARGET_ALREADY_HALTED;
777 }
778
779 if (target->state == TARGET_UNKNOWN)
780 {
781 WARNING("target was in unknown state when halt was requested");
782 }
783
784 if (arm7_9->use_dbgrq)
785 {
786 /* program EmbeddedICE Debug Control Register to assert DBGRQ
787 */
788 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGRQ, 1, 1);
789 embeddedice_store_reg(dbg_ctrl);
790 }
791 else
792 {
793 /* program watchpoint unit to match on any address
794 */
795 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], 0xffffffff);
796 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0xffffffff);
797 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x100);
798 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], 0xf7);
799 }
800
801 target->debug_reason = DBG_REASON_DBGRQ;
802
803 return ERROR_OK;
804 }
805
806 int arm7_9_clear_halt(target_t *target)
807 {
808 armv4_5_common_t *armv4_5 = target->arch_info;
809 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
810 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
811
812 if (arm7_9->use_dbgrq)
813 {
814 /* program EmbeddedICE Debug Control Register to deassert DBGRQ
815 */
816 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGRQ, 1, 0);
817 embeddedice_store_reg(dbg_ctrl);
818 }
819 else
820 {
821 /* restore registers if watchpoint unit 0 was in use
822 */
823 if (arm7_9->wp0_used)
824 {
825 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK]);
826 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK]);
827 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK]);
828 }
829 /* control value always has to be restored, as it was either disabled,
830 * or enabled with possibly different bits
831 */
832 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE]);
833 }
834
835 return ERROR_OK;
836 }
837
838 int arm7_9_debug_entry(target_t *target)
839 {
840 int i;
841 u32 context[16];
842 u32* context_p[16];
843 u32 r0_thumb, pc_thumb;
844 u32 cpsr;
845 int retval;
846 /* get pointers to arch-specific information */
847 armv4_5_common_t *armv4_5 = target->arch_info;
848 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
849 reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT];
850 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
851
852 #ifdef _DEBUG_ARM7_9_
853 DEBUG("");
854 #endif
855
856 if (arm7_9->pre_debug_entry)
857 arm7_9->pre_debug_entry(target);
858
859 /* program EmbeddedICE Debug Control Register to assert DBGACK and INTDIS
860 * ensure that DBGRQ is cleared
861 */
862 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGACK, 1, 1);
863 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGRQ, 1, 0);
864 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_INTDIS, 1, 1);
865 embeddedice_store_reg(dbg_ctrl);
866
867 arm7_9_clear_halt(target);
868
869 if ((retval = jtag_execute_queue()) != ERROR_OK)
870 {
871 switch (retval)
872 {
873 case ERROR_JTAG_QUEUE_FAILED:
874 ERROR("JTAG queue failed while writing EmbeddedICE control register");
875 exit(-1);
876 break;
877 default:
878 break;
879 }
880 }
881
882 if ((retval = arm7_9->examine_debug_reason(target)) != ERROR_OK)
883 return retval;
884
885
886 if (target->state != TARGET_HALTED)
887 {
888 WARNING("target not halted");
889 return ERROR_TARGET_NOT_HALTED;
890 }
891
892 /* if the target is in Thumb state, change to ARM state */
893 if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_ITBIT, 1))
894 {
895 DEBUG("target entered debug from Thumb state");
896 /* Entered debug from Thumb mode */
897 armv4_5->core_state = ARMV4_5_STATE_THUMB;
898 arm7_9->change_to_arm(target, &r0_thumb, &pc_thumb);
899 DEBUG("r0_thumb: 0x%8.8x, pc_thumb: 0x%8.8x", r0_thumb, pc_thumb);
900 }
901 else
902 {
903 DEBUG("target entered debug from ARM state");
904 /* Entered debug from ARM mode */
905 armv4_5->core_state = ARMV4_5_STATE_ARM;
906 }
907
908 for (i = 0; i < 16; i++)
909 context_p[i] = &context[i];
910 /* save core registers (r0 - r15 of current core mode) */
911 arm7_9->read_core_regs(target, 0xffff, context_p);
912
913 arm7_9->read_xpsr(target, &cpsr, 0);
914
915 if ((retval = jtag_execute_queue()) != ERROR_OK)
916 return retval;
917 buf_set_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 32, cpsr);
918 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].dirty = 0;
919 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].valid = 1;
920
921 armv4_5->core_mode = cpsr & 0x1f;
922 DEBUG("target entered debug state in %s mode", armv4_5_mode_strings[armv4_5_mode_to_number(armv4_5->core_mode)]);
923
924 if (armv4_5_mode_to_number(armv4_5->core_mode) == -1)
925 {
926 target->state = TARGET_UNKNOWN;
927 ERROR("cpsr contains invalid mode value - communication failure");
928 return ERROR_TARGET_FAILURE;
929 }
930
931 if (armv4_5->core_state == ARMV4_5_STATE_THUMB)
932 {
933 DEBUG("thumb state, applying fixups");
934 context[0] = r0_thumb;
935 context[15] = pc_thumb;
936 } else if (armv4_5->core_state == ARMV4_5_STATE_ARM)
937 {
938 /* adjust value stored by STM */
939 context[15] -= 3 * 4;
940 }
941
942 if ((target->debug_reason == DBG_REASON_BREAKPOINT)
943 || (target->debug_reason == DBG_REASON_SINGLESTEP)
944 || (target->debug_reason == DBG_REASON_WATCHPOINT)
945 || (target->debug_reason == DBG_REASON_WPTANDBKPT)
946 || ((target->debug_reason == DBG_REASON_DBGRQ) && (arm7_9->use_dbgrq == 0)))
947 context[15] -= 3 * ((armv4_5->core_state == ARMV4_5_STATE_ARM) ? 4 : 2);
948 else if (target->debug_reason == DBG_REASON_DBGRQ)
949 context[15] -= arm7_9->dbgreq_adjust_pc * ((armv4_5->core_state == ARMV4_5_STATE_ARM) ? 4 : 2);
950 else
951 {
952 ERROR("unknown debug reason: %i", target->debug_reason);
953 }
954
955
956 for (i=0; i<=15; i++)
957 {
958 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).value, 0, 32, context[i]);
959 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = 0;
960 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).valid = 1;
961 }
962
963 DEBUG("entered debug state at PC 0x%x", context[15]);
964
965 /* exceptions other than USR & SYS have a saved program status register */
966 if ((armv4_5_mode_to_number(armv4_5->core_mode) != ARMV4_5_MODE_USR) && (armv4_5_mode_to_number(armv4_5->core_mode) != ARMV4_5_MODE_SYS))
967 {
968 u32 spsr;
969 arm7_9->read_xpsr(target, &spsr, 1);
970 jtag_execute_queue();
971 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 16).value, 0, 32, spsr);
972 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 16).dirty = 0;
973 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 16).valid = 1;
974 }
975
976 /* r0 and r15 (pc) have to be restored later */
977 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 0).dirty = 1;
978 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 15).dirty = 1;
979
980 if ((retval = jtag->execute_queue()) != ERROR_OK)
981 return retval;
982
983 if (arm7_9->post_debug_entry)
984 arm7_9->post_debug_entry(target);
985
986 return ERROR_OK;
987 }
988
989 int arm7_9_full_context(target_t *target)
990 {
991 int i;
992 int retval;
993 armv4_5_common_t *armv4_5 = target->arch_info;
994 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
995
996 DEBUG("");
997
998 if (target->state != TARGET_HALTED)
999 {
1000 WARNING("target not halted");
1001 return ERROR_TARGET_NOT_HALTED;
1002 }
1003
1004 /* iterate through processor modes (User, FIQ, IRQ, SVC, ABT, UND)
1005 * SYS shares registers with User, so we don't touch SYS
1006 */
1007 for(i = 0; i < 6; i++)
1008 {
1009 u32 mask = 0;
1010 u32* reg_p[16];
1011 int j;
1012 int valid = 1;
1013
1014 /* check if there are invalid registers in the current mode
1015 */
1016 for (j = 0; j <= 16; j++)
1017 {
1018 if (ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j).valid == 0)
1019 valid = 0;
1020 }
1021
1022 if (!valid)
1023 {
1024 u32 tmp_cpsr;
1025
1026 /* change processor mode */
1027 tmp_cpsr = buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & 0xE0;
1028 tmp_cpsr |= armv4_5_number_to_mode(i);
1029 arm7_9->write_xpsr_im8(target, tmp_cpsr & 0xff, 0, 0);
1030
1031 for (j = 0; j < 15; j++)
1032 {
1033 if (ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j).valid == 0)
1034 {
1035 reg_p[j] = (u32*)ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j).value;
1036 mask |= 1 << j;
1037 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j).valid = 1;
1038 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j).dirty = 0;
1039 }
1040 }
1041
1042 /* if only the PSR is invalid, mask is all zeroes */
1043 if (mask)
1044 arm7_9->read_core_regs(target, mask, reg_p);
1045
1046 /* check if the PSR has to be read */
1047 if (ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), 16).valid == 0)
1048 {
1049 arm7_9->read_xpsr(target, (u32*)ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), 16).value, 1);
1050 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), 16).valid = 1;
1051 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), 16).dirty = 0;
1052 }
1053 }
1054 }
1055
1056 /* restore processor mode */
1057 arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8), 0, 0);
1058
1059 if ((retval = jtag_execute_queue()) != ERROR_OK)
1060 {
1061 ERROR("JTAG failure");
1062 exit(-1);
1063 }
1064 return ERROR_OK;
1065 }
1066
1067 int arm7_9_restore_context(target_t *target)
1068 {
1069 armv4_5_common_t *armv4_5 = target->arch_info;
1070 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1071 reg_t *reg;
1072 armv4_5_core_reg_t *reg_arch_info;
1073 enum armv4_5_mode current_mode = armv4_5->core_mode;
1074 int i, j;
1075 int dirty;
1076 int mode_change;
1077
1078 DEBUG("");
1079
1080 if (target->state != TARGET_HALTED)
1081 {
1082 WARNING("target not halted");
1083 return ERROR_TARGET_NOT_HALTED;
1084 }
1085
1086 if (arm7_9->pre_restore_context)
1087 arm7_9->pre_restore_context(target);
1088
1089 /* iterate through processor modes (User, FIQ, IRQ, SVC, ABT, UND)
1090 * SYS shares registers with User, so we don't touch SYS
1091 */
1092 for (i = 0; i < 6; i++)
1093 {
1094 DEBUG("examining %s mode", armv4_5_mode_strings[i]);
1095 dirty = 0;
1096 mode_change = 0;
1097 /* check if there are dirty registers in the current mode
1098 */
1099 for (j = 0; j <= 16; j++)
1100 {
1101 reg = &ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j);
1102 reg_arch_info = reg->arch_info;
1103 if (reg->dirty == 1)
1104 {
1105 if (reg->valid == 1)
1106 {
1107 dirty = 1;
1108 DEBUG("examining dirty reg: %s", reg->name);
1109 if ((reg_arch_info->mode != ARMV4_5_MODE_ANY)
1110 && (reg_arch_info->mode != current_mode)
1111 && !((reg_arch_info->mode == ARMV4_5_MODE_USR) && (armv4_5->core_mode == ARMV4_5_MODE_SYS))
1112 && !((reg_arch_info->mode == ARMV4_5_MODE_SYS) && (armv4_5->core_mode == ARMV4_5_MODE_USR)))
1113 {
1114 mode_change = 1;
1115 DEBUG("require mode change");
1116 }
1117 }
1118 else
1119 {
1120 ERROR("BUG: dirty register '%s', but no valid data", reg->name);
1121 exit(-1);
1122 }
1123 }
1124 }
1125
1126 if (dirty)
1127 {
1128 u32 mask = 0x0;
1129 int num_regs = 0;
1130 u32 regs[16];
1131
1132 if (mode_change)
1133 {
1134 u32 tmp_cpsr;
1135
1136 /* change processor mode */
1137 tmp_cpsr = buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & 0xE0;
1138 tmp_cpsr |= armv4_5_number_to_mode(i);
1139 arm7_9->write_xpsr_im8(target, tmp_cpsr & 0xff, 0, 0);
1140 current_mode = armv4_5_number_to_mode(i);
1141 }
1142
1143 for (j = 0; j <= 14; j++)
1144 {
1145 reg = &ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j);
1146 reg_arch_info = reg->arch_info;
1147
1148
1149 if (reg->dirty == 1)
1150 {
1151 regs[j] = buf_get_u32(reg->value, 0, 32);
1152 mask |= 1 << j;
1153 num_regs++;
1154 reg->dirty = 0;
1155 reg->valid = 1;
1156 DEBUG("writing register %i of mode %s with value 0x%8.8x", j, armv4_5_mode_strings[i], regs[j]);
1157 }
1158 }
1159
1160 if (mask)
1161 {
1162 arm7_9->write_core_regs(target, mask, regs);
1163 }
1164
1165 reg = &ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), 16);
1166 reg_arch_info = reg->arch_info;
1167 if ((reg->dirty) && (reg_arch_info->mode != ARMV4_5_MODE_ANY))
1168 {
1169 DEBUG("writing SPSR of mode %i with value 0x%8.8x", i, buf_get_u32(reg->value, 0, 32));
1170 arm7_9->write_xpsr(target, buf_get_u32(reg->value, 0, 32), 1);
1171 }
1172 }
1173 }
1174
1175 if ((armv4_5->core_cache->reg_list[ARMV4_5_CPSR].dirty == 0) && (armv4_5->core_mode != current_mode))
1176 {
1177 /* restore processor mode */
1178 u32 tmp_cpsr;
1179
1180 tmp_cpsr = buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & 0xE0;
1181 tmp_cpsr |= armv4_5_number_to_mode(i);
1182 DEBUG("writing lower 8 bit of cpsr with value 0x%2.2x", tmp_cpsr);
1183 arm7_9->write_xpsr_im8(target, tmp_cpsr & 0xff, 0, 0);
1184 }
1185 else if (armv4_5->core_cache->reg_list[ARMV4_5_CPSR].dirty == 1)
1186 {
1187 /* CPSR has been changed, full restore necessary */
1188 DEBUG("writing cpsr with value 0x%8.8x", buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 32));
1189 arm7_9->write_xpsr(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 32), 0);
1190 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].dirty = 0;
1191 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].valid = 1;
1192 }
1193
1194 /* restore PC */
1195 DEBUG("writing PC with value 0x%8.8x", buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32));
1196 arm7_9->write_pc(target, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32));
1197 armv4_5->core_cache->reg_list[15].dirty = 0;
1198
1199 if (arm7_9->post_restore_context)
1200 arm7_9->post_restore_context(target);
1201
1202 return ERROR_OK;
1203 }
1204
1205 int arm7_9_restart_core(struct target_s *target)
1206 {
1207 armv4_5_common_t *armv4_5 = target->arch_info;
1208 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1209 arm_jtag_t *jtag_info = &arm7_9->jtag_info;
1210
1211 /* set RESTART instruction */
1212 jtag_add_end_state(TAP_RTI);
1213 arm_jtag_set_instr(jtag_info, 0x4);
1214
1215 jtag_add_runtest(1, TAP_RTI);
1216 if ((jtag_execute_queue()) != ERROR_OK)
1217 {
1218 exit(-1);
1219 }
1220
1221 return ERROR_OK;
1222 }
1223
1224 void arm7_9_enable_watchpoints(struct target_s *target)
1225 {
1226 watchpoint_t *watchpoint = target->watchpoints;
1227
1228 while (watchpoint)
1229 {
1230 if (watchpoint->set == 0)
1231 arm7_9_set_watchpoint(target, watchpoint);
1232 watchpoint = watchpoint->next;
1233 }
1234 }
1235
1236 void arm7_9_enable_breakpoints(struct target_s *target)
1237 {
1238 breakpoint_t *breakpoint = target->breakpoints;
1239
1240 /* set any pending breakpoints */
1241 while (breakpoint)
1242 {
1243 if (breakpoint->set == 0)
1244 arm7_9_set_breakpoint(target, breakpoint);
1245 breakpoint = breakpoint->next;
1246 }
1247 }
1248
1249 void arm7_9_disable_bkpts_and_wpts(struct target_s *target)
1250 {
1251 breakpoint_t *breakpoint = target->breakpoints;
1252 watchpoint_t *watchpoint = target->watchpoints;
1253
1254 /* set any pending breakpoints */
1255 while (breakpoint)
1256 {
1257 if (breakpoint->set != 0)
1258 arm7_9_unset_breakpoint(target, breakpoint);
1259 breakpoint = breakpoint->next;
1260 }
1261
1262 while (watchpoint)
1263 {
1264 if (watchpoint->set != 0)
1265 arm7_9_unset_watchpoint(target, watchpoint);
1266 watchpoint = watchpoint->next;
1267 }
1268 }
1269
1270 int arm7_9_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)
1271 {
1272 armv4_5_common_t *armv4_5 = target->arch_info;
1273 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1274 breakpoint_t *breakpoint = target->breakpoints;
1275 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
1276
1277 DEBUG("");
1278
1279 if (target->state != TARGET_HALTED)
1280 {
1281 WARNING("target not halted");
1282 return ERROR_TARGET_NOT_HALTED;
1283 }
1284
1285 if (!debug_execution)
1286 {
1287 target_free_all_working_areas(target);
1288 }
1289
1290 /* current = 1: continue on current pc, otherwise continue at <address> */
1291 if (!current)
1292 buf_set_u32(armv4_5->core_cache->reg_list[15].value, 0, 32, address);
1293
1294 /* the front-end may request us not to handle breakpoints */
1295 if (handle_breakpoints)
1296 {
1297 if ((breakpoint = breakpoint_find(target, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32))))
1298 {
1299 DEBUG("unset breakpoint at 0x%8.8x", breakpoint->address);
1300 arm7_9_unset_breakpoint(target, breakpoint);
1301
1302 DEBUG("enable single-step");
1303 arm7_9->enable_single_step(target);
1304
1305 target->debug_reason = DBG_REASON_SINGLESTEP;
1306
1307 arm7_9_restore_context(target);
1308
1309 if (armv4_5->core_state == ARMV4_5_STATE_ARM)
1310 arm7_9->branch_resume(target);
1311 else if (armv4_5->core_state == ARMV4_5_STATE_THUMB)
1312 {
1313 arm7_9->branch_resume_thumb(target);
1314 }
1315 else
1316 {
1317 ERROR("unhandled core state");
1318 exit(-1);
1319 }
1320
1321 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGACK, 1, 0);
1322 embeddedice_write_reg(dbg_ctrl, buf_get_u32(dbg_ctrl->value, 0, dbg_ctrl->size));
1323 arm7_9_execute_sys_speed(target);
1324
1325 DEBUG("disable single-step");
1326 arm7_9->disable_single_step(target);
1327
1328 arm7_9_debug_entry(target);
1329 DEBUG("new PC after step: 0x%8.8x", buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32));
1330
1331 DEBUG("set breakpoint at 0x%8.8x", breakpoint->address);
1332 arm7_9_set_breakpoint(target, breakpoint);
1333 }
1334 }
1335
1336 /* enable any pending breakpoints and watchpoints */
1337 arm7_9_enable_breakpoints(target);
1338 arm7_9_enable_watchpoints(target);
1339
1340 arm7_9_restore_context(target);
1341
1342 if (armv4_5->core_state == ARMV4_5_STATE_ARM)
1343 {
1344 arm7_9->branch_resume(target);
1345 }
1346 else if (armv4_5->core_state == ARMV4_5_STATE_THUMB)
1347 {
1348 arm7_9->branch_resume_thumb(target);
1349 }
1350 else
1351 {
1352 ERROR("unhandled core state");
1353 exit(-1);
1354 }
1355
1356 /* deassert DBGACK and INTDIS */
1357 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGACK, 1, 0);
1358 /* INTDIS only when we really resume, not during debug execution */
1359 if (!debug_execution)
1360 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_INTDIS, 1, 0);
1361 embeddedice_write_reg(dbg_ctrl, buf_get_u32(dbg_ctrl->value, 0, dbg_ctrl->size));
1362
1363 arm7_9_restart_core(target);
1364
1365 target->debug_reason = DBG_REASON_NOTHALTED;
1366
1367 if (!debug_execution)
1368 {
1369 /* registers are now invalid */
1370 armv4_5_invalidate_core_regs(target);
1371 target->state = TARGET_RUNNING;
1372 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
1373 }
1374 else
1375 {
1376 target->state = TARGET_DEBUG_RUNNING;
1377 target_call_event_callbacks(target, TARGET_EVENT_DEBUG_RESUMED);
1378 }
1379
1380 DEBUG("target resumed");
1381
1382 return ERROR_OK;
1383 }
1384
1385 void arm7_9_enable_eice_step(target_t *target)
1386 {
1387 armv4_5_common_t *armv4_5 = target->arch_info;
1388 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1389
1390 /* setup an inverse breakpoint on the current PC
1391 * - comparator 1 matches the current address
1392 * - rangeout from comparator 1 is connected to comparator 0 rangein
1393 * - comparator 0 matches any address, as long as rangein is low */
1394 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], 0xffffffff);
1395 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0xffffffff);
1396 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x100);
1397 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], 0x77);
1398 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE], buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32));
1399 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK], 0);
1400 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK], 0xffffffff);
1401 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0);
1402 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_MASK], 0xf7);
1403 }
1404
1405 void arm7_9_disable_eice_step(target_t *target)
1406 {
1407 armv4_5_common_t *armv4_5 = target->arch_info;
1408 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1409
1410 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK]);
1411 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK]);
1412 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE]);
1413 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK]);
1414 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE]);
1415 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK]);
1416 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK]);
1417 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_MASK]);
1418 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE]);
1419 }
1420
1421 int arm7_9_step(struct target_s *target, int current, u32 address, int handle_breakpoints)
1422 {
1423 armv4_5_common_t *armv4_5 = target->arch_info;
1424 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1425 breakpoint_t *breakpoint = target->breakpoints;
1426
1427 if (target->state != TARGET_HALTED)
1428 {
1429 WARNING("target not halted");
1430 return ERROR_TARGET_NOT_HALTED;
1431 }
1432
1433 /* current = 1: continue on current pc, otherwise continue at <address> */
1434 if (!current)
1435 buf_set_u32(armv4_5->core_cache->reg_list[15].value, 0, 32, address);
1436
1437 /* the front-end may request us not to handle breakpoints */
1438 if (handle_breakpoints)
1439 if ((breakpoint = breakpoint_find(target, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32))))
1440 arm7_9_unset_breakpoint(target, breakpoint);
1441
1442 target->debug_reason = DBG_REASON_SINGLESTEP;
1443
1444 arm7_9_restore_context(target);
1445
1446 arm7_9->enable_single_step(target);
1447
1448 if (armv4_5->core_state == ARMV4_5_STATE_ARM)
1449 {
1450 arm7_9->branch_resume(target);
1451 }
1452 else if (armv4_5->core_state == ARMV4_5_STATE_THUMB)
1453 {
1454 arm7_9->branch_resume_thumb(target);
1455 }
1456 else
1457 {
1458 ERROR("unhandled core state");
1459 exit(-1);
1460 }
1461
1462 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
1463
1464 arm7_9_execute_sys_speed(target);
1465 arm7_9->disable_single_step(target);
1466
1467 /* registers are now invalid */
1468 armv4_5_invalidate_core_regs(target);
1469
1470 arm7_9_debug_entry(target);
1471
1472 target_call_event_callbacks(target, TARGET_EVENT_HALTED);
1473
1474 if (breakpoint)
1475 arm7_9_set_breakpoint(target, breakpoint);
1476
1477 DEBUG("target stepped");
1478
1479 return ERROR_OK;
1480
1481 }
1482
1483 int arm7_9_read_core_reg(struct target_s *target, int num, enum armv4_5_mode mode)
1484 {
1485 u32* reg_p[16];
1486 int retval;
1487 armv4_5_common_t *armv4_5 = target->arch_info;
1488 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1489 enum armv4_5_mode reg_mode = ((armv4_5_core_reg_t*)ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).arch_info)->mode;
1490
1491 if ((num < 0) || (num > 16))
1492 return ERROR_INVALID_ARGUMENTS;
1493
1494 if ((mode != ARMV4_5_MODE_ANY)
1495 && (mode != armv4_5->core_mode)
1496 && (reg_mode != ARMV4_5_MODE_ANY))
1497 {
1498 u32 tmp_cpsr;
1499
1500 /* change processor mode */
1501 tmp_cpsr = buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & 0xE0;
1502 tmp_cpsr |= mode;
1503 arm7_9->write_xpsr_im8(target, tmp_cpsr & 0xff, 0, 0);
1504 }
1505
1506 if ((num >= 0) && (num <= 15))
1507 {
1508 /* read a normal core register */
1509 reg_p[num] = (u32*)ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).value;
1510
1511 arm7_9->read_core_regs(target, 1 << num, reg_p);
1512 }
1513 else
1514 {
1515 /* read a program status register
1516 * if the register mode is MODE_ANY, we read the cpsr, otherwise a spsr
1517 */
1518 armv4_5_core_reg_t *arch_info = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).arch_info;
1519 int spsr = (arch_info->mode == ARMV4_5_MODE_ANY) ? 0 : 1;
1520
1521 arm7_9->read_xpsr(target, (u32*)ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).value, spsr);
1522 }
1523
1524 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).valid = 1;
1525 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).dirty = 0;
1526
1527 if ((mode != ARMV4_5_MODE_ANY)
1528 && (mode != armv4_5->core_mode)
1529 && (reg_mode != ARMV4_5_MODE_ANY)) {
1530 /* restore processor mode */
1531 arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8), 0, 0);
1532 }
1533
1534 if ((retval = jtag_execute_queue()) != ERROR_OK)
1535 {
1536 ERROR("JTAG failure");
1537 exit(-1);
1538 }
1539
1540 return ERROR_OK;
1541
1542 }
1543
1544 int arm7_9_write_core_reg(struct target_s *target, int num, enum armv4_5_mode mode, u32 value)
1545 {
1546 u32 reg[16];
1547 int retval;
1548 armv4_5_common_t *armv4_5 = target->arch_info;
1549 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1550 enum armv4_5_mode reg_mode = ((armv4_5_core_reg_t*)ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).arch_info)->mode;
1551
1552 if ((num < 0) || (num > 16))
1553 return ERROR_INVALID_ARGUMENTS;
1554
1555 if ((mode != ARMV4_5_MODE_ANY)
1556 && (mode != armv4_5->core_mode)
1557 && (reg_mode != ARMV4_5_MODE_ANY)) {
1558 u32 tmp_cpsr;
1559
1560 /* change processor mode */
1561 tmp_cpsr = buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & 0xE0;
1562 tmp_cpsr |= mode;
1563 arm7_9->write_xpsr_im8(target, tmp_cpsr & 0xff, 0, 0);
1564 }
1565
1566 if ((num >= 0) && (num <= 15))
1567 {
1568 /* write a normal core register */
1569 reg[num] = value;
1570
1571 arm7_9->write_core_regs(target, 1 << num, reg);
1572 }
1573 else
1574 {
1575 /* write a program status register
1576 * if the register mode is MODE_ANY, we write the cpsr, otherwise a spsr
1577 */
1578 armv4_5_core_reg_t *arch_info = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).arch_info;
1579 int spsr = (arch_info->mode == ARMV4_5_MODE_ANY) ? 0 : 1;
1580
1581 arm7_9->write_xpsr(target, value, spsr);
1582 }
1583
1584 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).valid = 1;
1585 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).dirty = 0;
1586
1587 if ((mode != ARMV4_5_MODE_ANY)
1588 && (mode != armv4_5->core_mode)
1589 && (reg_mode != ARMV4_5_MODE_ANY)) {
1590 /* restore processor mode */
1591 arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8), 0, 0);
1592 }
1593
1594 if ((retval = jtag_execute_queue()) != ERROR_OK)
1595 {
1596 ERROR("JTAG failure");
1597 exit(-1);
1598 }
1599
1600 return ERROR_OK;
1601
1602 }
1603
1604 int arm7_9_read_memory(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
1605 {
1606 armv4_5_common_t *armv4_5 = target->arch_info;
1607 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1608
1609 u32 reg[16];
1610 u32 *reg_p[16];
1611 int num_accesses = 0;
1612 int thisrun_accesses;
1613 int i;
1614 u32 cpsr;
1615 int retval;
1616 int last_reg = 0;
1617
1618 DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address, size, count);
1619
1620 if (target->state != TARGET_HALTED)
1621 {
1622 WARNING("target not halted");
1623 return ERROR_TARGET_NOT_HALTED;
1624 }
1625
1626 /* sanitize arguments */
1627 if (((size != 4) && (size != 2) && (size != 1)) || (count == 0) || !(buffer))
1628 return ERROR_INVALID_ARGUMENTS;
1629
1630 if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u)))
1631 return ERROR_TARGET_UNALIGNED_ACCESS;
1632
1633 for (i = 0; i < 16; i++)
1634 {
1635 reg_p[i] = &reg[i];
1636 }
1637
1638 /* load the base register with the address of the first word */
1639 reg[0] = address;
1640 arm7_9->write_core_regs(target, 0x1, reg);
1641
1642 switch (size)
1643 {
1644 case 4:
1645 while (num_accesses < count)
1646 {
1647 u32 reg_list;
1648 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
1649 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
1650
1651 arm7_9->load_word_regs(target, reg_list);
1652 arm7_9_execute_sys_speed(target);
1653
1654 arm7_9->read_core_regs(target, reg_list, reg_p);
1655 jtag_execute_queue();
1656
1657 for (i = 1; i <= thisrun_accesses; i++)
1658 {
1659 if (i > last_reg)
1660 last_reg = i;
1661 target_buffer_set_u32(target, buffer, reg[i]);
1662 buffer += 4;
1663 }
1664 num_accesses += thisrun_accesses;
1665 }
1666 break;
1667 case 2:
1668 while (num_accesses < count)
1669 {
1670 u32 reg_list;
1671 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
1672 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
1673
1674 for (i = 1; i <= thisrun_accesses; i++)
1675 {
1676 if (i > last_reg)
1677 last_reg = i;
1678 arm7_9->load_hword_reg(target, i);
1679 arm7_9_execute_sys_speed(target);
1680 }
1681
1682 arm7_9->read_core_regs(target, reg_list, reg_p);
1683 jtag_execute_queue();
1684
1685 for (i = 1; i <= thisrun_accesses; i++)
1686 {
1687 target_buffer_set_u16(target, buffer, reg[i]);
1688 buffer += 2;
1689 }
1690 num_accesses += thisrun_accesses;
1691 }
1692 break;
1693 case 1:
1694 while (num_accesses < count)
1695 {
1696 u32 reg_list;
1697 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
1698 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
1699
1700 for (i = 1; i <= thisrun_accesses; i++)
1701 {
1702 if (i > last_reg)
1703 last_reg = i;
1704 arm7_9->load_byte_reg(target, i);
1705 arm7_9_execute_sys_speed(target);
1706 }
1707
1708 arm7_9->read_core_regs(target, reg_list, reg_p);
1709 jtag_execute_queue();
1710
1711 for (i = 1; i <= thisrun_accesses; i++)
1712 {
1713 *(buffer++) = reg[i] & 0xff;
1714 }
1715 num_accesses += thisrun_accesses;
1716 }
1717 break;
1718 default:
1719 ERROR("BUG: we shouldn't get here");
1720 exit(-1);
1721 break;
1722 }
1723
1724 for (i=0; i<=last_reg; i++)
1725 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = 1;
1726
1727 arm7_9->read_xpsr(target, &cpsr, 0);
1728 if ((retval = jtag_execute_queue()) != ERROR_OK)
1729 {
1730 ERROR("JTAG error while reading cpsr");
1731 exit(-1);
1732 }
1733
1734 if (((cpsr & 0x1f) == ARMV4_5_MODE_ABT) && (armv4_5->core_mode != ARMV4_5_MODE_ABT))
1735 {
1736 ERROR("memory read caused data abort");
1737
1738 arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8), 0, 0);
1739
1740 return ERROR_TARGET_DATA_ABORT;
1741 }
1742
1743 return ERROR_OK;
1744 }
1745
1746 int arm7_9_write_memory(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
1747 {
1748 armv4_5_common_t *armv4_5 = target->arch_info;
1749 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1750
1751 u32 reg[16];
1752 int num_accesses = 0;
1753 int thisrun_accesses;
1754 int i;
1755 u32 cpsr;
1756 int retval;
1757 int last_reg = 0;
1758
1759 DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address, size, count);
1760
1761 if (target->state != TARGET_HALTED)
1762 {
1763 WARNING("target not halted");
1764 return ERROR_TARGET_NOT_HALTED;
1765 }
1766
1767 /* sanitize arguments */
1768 if (((size != 4) && (size != 2) && (size != 1)) || (count == 0) || !(buffer))
1769 return ERROR_INVALID_ARGUMENTS;
1770
1771 if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u)))
1772 return ERROR_TARGET_UNALIGNED_ACCESS;
1773
1774 /* load the base register with the address of the first word */
1775 reg[0] = address;
1776 arm7_9->write_core_regs(target, 0x1, reg);
1777
1778 switch (size)
1779 {
1780 case 4:
1781 while (num_accesses < count)
1782 {
1783 u32 reg_list;
1784 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
1785 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
1786
1787 for (i = 1; i <= thisrun_accesses; i++)
1788 {
1789 if (i > last_reg)
1790 last_reg = i;
1791 reg[i] = target_buffer_get_u32(target, buffer);
1792 buffer += 4;
1793 }
1794
1795 arm7_9->write_core_regs(target, reg_list, reg);
1796
1797 arm7_9->store_word_regs(target, reg_list);
1798
1799 /* fast memory writes are only safe when the target is running
1800 * from a sufficiently high clock (32 kHz is usually too slow)
1801 */
1802 if (arm7_9->fast_memory_writes)
1803 arm7_9_execute_fast_sys_speed(target);
1804 else
1805 arm7_9_execute_sys_speed(target);
1806
1807 num_accesses += thisrun_accesses;
1808 }
1809 break;
1810 case 2:
1811 while (num_accesses < count)
1812 {
1813 u32 reg_list;
1814 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
1815 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
1816
1817 for (i = 1; i <= thisrun_accesses; i++)
1818 {
1819 if (i > last_reg)
1820 last_reg = i;
1821 reg[i] = target_buffer_get_u16(target, buffer) & 0xffff;
1822 buffer += 2;
1823 }
1824
1825 arm7_9->write_core_regs(target, reg_list, reg);
1826
1827 for (i = 1; i <= thisrun_accesses; i++)
1828 {
1829 arm7_9->store_hword_reg(target, i);
1830
1831 /* fast memory writes are only safe when the target is running
1832 * from a sufficiently high clock (32 kHz is usually too slow)
1833 */
1834 if (arm7_9->fast_memory_writes)
1835 arm7_9_execute_fast_sys_speed(target);
1836 else
1837 arm7_9_execute_sys_speed(target);
1838 }
1839
1840 num_accesses += thisrun_accesses;
1841 }
1842 break;
1843 case 1:
1844 while (num_accesses < count)
1845 {
1846 u32 reg_list;
1847 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
1848 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
1849
1850 for (i = 1; i <= thisrun_accesses; i++)
1851 {
1852 if (i > last_reg)
1853 last_reg = i;
1854 reg[i] = *buffer++ & 0xff;
1855 }
1856
1857 arm7_9->write_core_regs(target, reg_list, reg);
1858
1859 for (i = 1; i <= thisrun_accesses; i++)
1860 {
1861 arm7_9->store_byte_reg(target, i);
1862 /* fast memory writes are only safe when the target is running
1863 * from a sufficiently high clock (32 kHz is usually too slow)
1864 */
1865 if (arm7_9->fast_memory_writes)
1866 arm7_9_execute_fast_sys_speed(target);
1867 else
1868 arm7_9_execute_sys_speed(target);
1869 }
1870
1871 num_accesses += thisrun_accesses;
1872 }
1873 break;
1874 default:
1875 ERROR("BUG: we shouldn't get here");
1876 exit(-1);
1877 break;
1878 }
1879
1880 if ((retval = jtag_execute_queue()) != ERROR_OK)
1881 {
1882 ERROR("JTAG error while writing target memory");
1883 exit(-1);
1884 }
1885
1886 for (i=0; i<=last_reg; i++)
1887 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = 1;
1888
1889 arm7_9->read_xpsr(target, &cpsr, 0);
1890 if ((retval = jtag_execute_queue()) != ERROR_OK)
1891 {
1892 ERROR("JTAG error while reading cpsr");
1893 exit(-1);
1894 }
1895
1896 if (((cpsr & 0x1f) == ARMV4_5_MODE_ABT) && (armv4_5->core_mode != ARMV4_5_MODE_ABT))
1897 {
1898 ERROR("memory write caused data abort");
1899
1900 arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8), 0, 0);
1901
1902 return ERROR_TARGET_DATA_ABORT;
1903 }
1904
1905 return ERROR_OK;
1906 }
1907
1908 int arm7_9_bulk_write_memory(target_t *target, u32 address, u32 count, u8 *buffer)
1909 {
1910 armv4_5_common_t *armv4_5 = target->arch_info;
1911 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1912 enum armv4_5_state core_state = armv4_5->core_state;
1913 u32 r0 = buf_get_u32(armv4_5->core_cache->reg_list[0].value, 0, 32);
1914 u32 r1 = buf_get_u32(armv4_5->core_cache->reg_list[1].value, 0, 32);
1915 u32 pc = buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32);
1916 int i;
1917
1918 u32 dcc_code[] =
1919 {
1920 /* MRC TST BNE MRC STR B */
1921 0xee101e10, 0xe3110001, 0x0afffffc, 0xee111e10, 0xe4801004, 0xeafffff9
1922 };
1923
1924 if (!arm7_9->dcc_downloads)
1925 return target->type->write_memory(target, address, 4, count, buffer);
1926
1927 /* regrab previously allocated working_area, or allocate a new one */
1928 if (!arm7_9->dcc_working_area)
1929 {
1930 /* make sure we have a working area */
1931 if (target_alloc_working_area(target, 24, &arm7_9->dcc_working_area) != ERROR_OK)
1932 {
1933 INFO("no working area available, falling back to memory writes");
1934 return target->type->write_memory(target, address, 4, count, buffer);
1935 }
1936
1937 /* write DCC code to working area */
1938 target->type->write_memory(target, arm7_9->dcc_working_area->address, 4, 6, (u8*)dcc_code);
1939 }
1940
1941 buf_set_u32(armv4_5->core_cache->reg_list[0].value, 0, 32, address);
1942 armv4_5->core_cache->reg_list[0].valid = 1;
1943 armv4_5->core_cache->reg_list[0].dirty = 1;
1944 armv4_5->core_state = ARMV4_5_STATE_ARM;
1945
1946 arm7_9_resume(target, 0, arm7_9->dcc_working_area->address, 1, 1);
1947
1948 for (i = 0; i < count; i++)
1949 {
1950 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_COMMS_DATA], target_buffer_get_u32(target, buffer));
1951 buffer += 4;
1952 }
1953
1954 target->type->halt(target);
1955
1956 while (target->state != TARGET_HALTED)
1957 target->type->poll(target);
1958
1959 /* restore target state */
1960 buf_set_u32(armv4_5->core_cache->reg_list[0].value, 0, 32, r0);
1961 armv4_5->core_cache->reg_list[0].valid = 1;
1962 armv4_5->core_cache->reg_list[0].dirty = 1;
1963 buf_set_u32(armv4_5->core_cache->reg_list[1].value, 0, 32, r1);
1964 armv4_5->core_cache->reg_list[1].valid = 1;
1965 armv4_5->core_cache->reg_list[1].dirty = 1;
1966 buf_set_u32(armv4_5->core_cache->reg_list[15].value, 0, 32, pc);
1967 armv4_5->core_cache->reg_list[15].valid = 1;
1968 armv4_5->core_cache->reg_list[15].dirty = 1;
1969 armv4_5->core_state = core_state;
1970
1971 return ERROR_OK;
1972 }
1973
1974 int arm7_9_register_commands(struct command_context_s *cmd_ctx)
1975 {
1976 command_t *arm7_9_cmd;
1977
1978 arm7_9_cmd = register_command(cmd_ctx, NULL, "arm7_9", NULL, COMMAND_ANY, NULL);
1979
1980 register_command(cmd_ctx, arm7_9_cmd, "write_xpsr", handle_arm7_9_write_xpsr_command, COMMAND_EXEC, "write program status register <value> <not cpsr|spsr>");
1981 register_command(cmd_ctx, arm7_9_cmd, "write_xpsr_im8", handle_arm7_9_write_xpsr_im8_command, COMMAND_EXEC, "write program status register <8bit immediate> <rotate> <not cpsr|spsr>");
1982
1983 register_command(cmd_ctx, arm7_9_cmd, "write_core_reg", handle_arm7_9_write_core_reg_command, COMMAND_EXEC, "write core register <num> <mode> <value>");
1984
1985 register_command(cmd_ctx, arm7_9_cmd, "sw_bkpts", handle_arm7_9_sw_bkpts_command, COMMAND_EXEC, "support for software breakpoints <enable|disable>");
1986 register_command(cmd_ctx, arm7_9_cmd, "force_hw_bkpts", handle_arm7_9_force_hw_bkpts_command, COMMAND_EXEC, "use hardware breakpoints for all breakpoints (disables sw breakpoint support) <enable|disable>");
1987 register_command(cmd_ctx, arm7_9_cmd, "dbgrq", handle_arm7_9_dbgrq_command,
1988 COMMAND_ANY, "use EmbeddedICE dbgrq instead of breakpoint for target halt requests <enable|disable>");
1989 register_command(cmd_ctx, arm7_9_cmd, "fast_writes", handle_arm7_9_fast_writes_command,
1990 COMMAND_ANY, "use fast memory writes instead of slower but potentially unsafe slow writes <enable|disable>");
1991 register_command(cmd_ctx, arm7_9_cmd, "dcc_downloads", handle_arm7_9_dcc_downloads_command,
1992 COMMAND_ANY, "use DCC downloads for larger memory writes <enable|disable>");
1993
1994 armv4_5_register_commands(cmd_ctx);
1995
1996 return ERROR_OK;
1997 }
1998
1999 int handle_arm7_9_write_xpsr_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2000 {
2001 u32 value;
2002 int spsr;
2003 int retval;
2004 target_t *target = get_current_target(cmd_ctx);
2005 armv4_5_common_t *armv4_5;
2006 arm7_9_common_t *arm7_9;
2007
2008 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2009 {
2010 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2011 return ERROR_OK;
2012 }
2013
2014 if (target->state != TARGET_HALTED)
2015 {
2016 command_print(cmd_ctx, "can't write registers while running");
2017 return ERROR_OK;
2018 }
2019
2020 if (argc < 2)
2021 {
2022 command_print(cmd_ctx, "usage: write_xpsr <value> <not cpsr|spsr>");
2023 return ERROR_OK;
2024 }
2025
2026 value = strtoul(args[0], NULL, 0);
2027 spsr = strtol(args[1], NULL, 0);
2028
2029 arm7_9->write_xpsr(target, value, spsr);
2030 if ((retval = jtag_execute_queue()) != ERROR_OK)
2031 {
2032 ERROR("JTAG error while writing to xpsr");
2033 exit(-1);
2034 }
2035
2036 return ERROR_OK;
2037 }
2038
2039 int handle_arm7_9_write_xpsr_im8_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2040 {
2041 u32 value;
2042 int rotate;
2043 int spsr;
2044 int retval;
2045 target_t *target = get_current_target(cmd_ctx);
2046 armv4_5_common_t *armv4_5;
2047 arm7_9_common_t *arm7_9;
2048
2049 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2050 {
2051 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2052 return ERROR_OK;
2053 }
2054
2055 if (target->state != TARGET_HALTED)
2056 {
2057 command_print(cmd_ctx, "can't write registers while running");
2058 return ERROR_OK;
2059 }
2060
2061 if (argc < 3)
2062 {
2063 command_print(cmd_ctx, "usage: write_xpsr_im8 <im8> <rotate> <not cpsr|spsr>");
2064 return ERROR_OK;
2065 }
2066
2067 value = strtoul(args[0], NULL, 0);
2068 rotate = strtol(args[1], NULL, 0);
2069 spsr = strtol(args[2], NULL, 0);
2070
2071 arm7_9->write_xpsr_im8(target, value, rotate, spsr);
2072 if ((retval = jtag_execute_queue()) != ERROR_OK)
2073 {
2074 ERROR("JTAG error while writing 8-bit immediate to xpsr");
2075 exit(-1);
2076 }
2077
2078 return ERROR_OK;
2079 }
2080
2081 int handle_arm7_9_write_core_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2082 {
2083 u32 value;
2084 u32 mode;
2085 int num;
2086 target_t *target = get_current_target(cmd_ctx);
2087 armv4_5_common_t *armv4_5;
2088 arm7_9_common_t *arm7_9;
2089
2090 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2091 {
2092 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2093 return ERROR_OK;
2094 }
2095
2096 if (target->state != TARGET_HALTED)
2097 {
2098 command_print(cmd_ctx, "can't write registers while running");
2099 return ERROR_OK;
2100 }
2101
2102 if (argc < 3)
2103 {
2104 command_print(cmd_ctx, "usage: write_core_reg <num> <mode> <value>");
2105 return ERROR_OK;
2106 }
2107
2108 num = strtol(args[0], NULL, 0);
2109 mode = strtoul(args[1], NULL, 0);
2110 value = strtoul(args[2], NULL, 0);
2111
2112 arm7_9_write_core_reg(target, num, mode, value);
2113
2114 return ERROR_OK;
2115 }
2116
2117 int handle_arm7_9_sw_bkpts_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2118 {
2119 target_t *target = get_current_target(cmd_ctx);
2120 armv4_5_common_t *armv4_5;
2121 arm7_9_common_t *arm7_9;
2122
2123 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2124 {
2125 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2126 return ERROR_OK;
2127 }
2128
2129 if (argc == 0)
2130 {
2131 command_print(cmd_ctx, "software breakpoints %s", (arm7_9->sw_bkpts_enabled) ? "enabled" : "disabled");
2132 return ERROR_OK;
2133 }
2134
2135 if (strcmp("enable", args[0]) == 0)
2136 {
2137 if (arm7_9->sw_bkpts_use_wp)
2138 {
2139 arm7_9_enable_sw_bkpts(target);
2140 }
2141 else
2142 {
2143 arm7_9->sw_bkpts_enabled = 1;
2144 }
2145 }
2146 else if (strcmp("disable", args[0]) == 0)
2147 {
2148 if (arm7_9->sw_bkpts_use_wp)
2149 {
2150 arm7_9_disable_sw_bkpts(target);
2151 }
2152 else
2153 {
2154 arm7_9->sw_bkpts_enabled = 0;
2155 }
2156 }
2157 else
2158 {
2159 command_print(cmd_ctx, "usage: arm7_9 sw_bkpts <enable|disable>");
2160 }
2161
2162 command_print(cmd_ctx, "software breakpoints %s", (arm7_9->sw_bkpts_enabled) ? "enabled" : "disabled");
2163
2164 return ERROR_OK;
2165 }
2166
2167 int handle_arm7_9_force_hw_bkpts_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2168 {
2169 target_t *target = get_current_target(cmd_ctx);
2170 armv4_5_common_t *armv4_5;
2171 arm7_9_common_t *arm7_9;
2172
2173 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2174 {
2175 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2176 return ERROR_OK;
2177 }
2178
2179 if ((argc >= 1) && (strcmp("enable", args[0]) == 0))
2180 {
2181 arm7_9->force_hw_bkpts = 1;
2182 if (arm7_9->sw_bkpts_use_wp)
2183 {
2184 arm7_9_disable_sw_bkpts(target);
2185 }
2186 }
2187 else if ((argc >= 1) && (strcmp("disable", args[0]) == 0))
2188 {
2189 arm7_9->force_hw_bkpts = 0;
2190 }
2191 else
2192 {
2193 command_print(cmd_ctx, "usage: arm7_9 force_hw_bkpts <enable|disable>");
2194 }
2195
2196 command_print(cmd_ctx, "force hardware breakpoints %s", (arm7_9->force_hw_bkpts) ? "enabled" : "disabled");
2197
2198 return ERROR_OK;
2199 }
2200
2201 int handle_arm7_9_dbgrq_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2202 {
2203 target_t *target = get_current_target(cmd_ctx);
2204 armv4_5_common_t *armv4_5;
2205 arm7_9_common_t *arm7_9;
2206
2207 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2208 {
2209 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2210 return ERROR_OK;
2211 }
2212
2213 if (argc > 0)
2214 {
2215 if (strcmp("enable", args[0]) == 0)
2216 {
2217 arm7_9->use_dbgrq = 1;
2218 }
2219 else if (strcmp("disable", args[0]) == 0)
2220 {
2221 arm7_9->use_dbgrq = 0;
2222 }
2223 else
2224 {
2225 command_print(cmd_ctx, "usage: arm7_9 dbgrq <enable|disable>");
2226 }
2227 }
2228
2229 command_print(cmd_ctx, "use of EmbeddedICE dbgrq instead of breakpoint for target halt %s", (arm7_9->use_dbgrq) ? "enabled" : "disabled");
2230
2231 return ERROR_OK;
2232 }
2233
2234 int handle_arm7_9_fast_writes_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2235 {
2236 target_t *target = get_current_target(cmd_ctx);
2237 armv4_5_common_t *armv4_5;
2238 arm7_9_common_t *arm7_9;
2239
2240 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2241 {
2242 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2243 return ERROR_OK;
2244 }
2245
2246 if (argc > 0)
2247 {
2248 if (strcmp("enable", args[0]) == 0)
2249 {
2250 arm7_9->fast_memory_writes = 1;
2251 }
2252 else if (strcmp("disable", args[0]) == 0)
2253 {
2254 arm7_9->fast_memory_writes = 0;
2255 }
2256 else
2257 {
2258 command_print(cmd_ctx, "usage: arm7_9 fast_writes <enable|disable>");
2259 }
2260 }
2261
2262 command_print(cmd_ctx, "fast memory writes are %s", (arm7_9->fast_memory_writes) ? "enabled" : "disabled");
2263
2264 return ERROR_OK;
2265 }
2266
2267 int handle_arm7_9_dcc_downloads_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2268 {
2269 target_t *target = get_current_target(cmd_ctx);
2270 armv4_5_common_t *armv4_5;
2271 arm7_9_common_t *arm7_9;
2272
2273 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2274 {
2275 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2276 return ERROR_OK;
2277 }
2278
2279 if (argc > 0)
2280 {
2281 if (strcmp("enable", args[0]) == 0)
2282 {
2283 arm7_9->dcc_downloads = 1;
2284 }
2285 else if (strcmp("disable", args[0]) == 0)
2286 {
2287 arm7_9->dcc_downloads = 0;
2288 }
2289 else
2290 {
2291 command_print(cmd_ctx, "usage: arm7_9 dcc_downloads <enable|disable>");
2292 }
2293 }
2294
2295 command_print(cmd_ctx, "dcc downloads are %s", (arm7_9->dcc_downloads) ? "enabled" : "disabled");
2296
2297 return ERROR_OK;
2298 }
2299
2300 int arm7_9_init_arch_info(target_t *target, arm7_9_common_t *arm7_9)
2301 {
2302 armv4_5_common_t *armv4_5 = &arm7_9->armv4_5_common;
2303
2304 arm7_9->common_magic = ARM7_9_COMMON_MAGIC;
2305
2306 arm_jtag_setup_connection(&arm7_9->jtag_info);
2307 arm7_9->wp_available = 2;
2308 arm7_9->wp0_used = 0;
2309 arm7_9->wp1_used = 0;
2310 arm7_9->force_hw_bkpts = 0;
2311 arm7_9->use_dbgrq = 0;
2312 arm7_9->has_etm = 0;
2313
2314 arm7_9->reinit_embeddedice = 0;
2315
2316 arm7_9->dcc_working_area = NULL;
2317
2318 arm7_9->fast_memory_writes = 0;
2319 arm7_9->dcc_downloads = 0;
2320
2321 jtag_register_event_callback(arm7_9_jtag_callback, target);
2322
2323 armv4_5->arch_info = arm7_9;
2324 armv4_5->read_core_reg = arm7_9_read_core_reg;
2325 armv4_5->write_core_reg = arm7_9_write_core_reg;
2326 armv4_5->full_context = arm7_9_full_context;
2327
2328 armv4_5_init_arch_info(target, armv4_5);
2329
2330 return ERROR_OK;
2331 }
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)