1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
27 #include "replacements.h"
29 #include "embeddedice.h"
31 #include "target_request.h"
36 #include "arm7_9_common.h"
37 #include "breakpoints.h"
43 #include <sys/types.h>
48 int arm7_9_debug_entry(target_t *target);
49 int arm7_9_enable_sw_bkpts(struct target_s *target);
51 /* command handler forward declarations */
52 int handle_arm7_9_write_xpsr_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
53 int handle_arm7_9_write_xpsr_im8_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
54 int handle_arm7_9_read_core_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
55 int handle_arm7_9_write_core_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
56 int handle_arm7_9_sw_bkpts_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
57 int handle_arm7_9_force_hw_bkpts_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
58 int handle_arm7_9_dbgrq_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
59 int handle_arm7_9_fast_memory_access_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
60 int handle_arm7_9_dcc_downloads_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
61 int handle_arm7_9_etm_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
63 int arm7_9_reinit_embeddedice(target_t *target)
65 armv4_5_common_t *armv4_5 = target->arch_info;
66 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
68 breakpoint_t *breakpoint = target->breakpoints;
70 arm7_9->wp_available = 2;
74 /* mark all hardware breakpoints as unset */
77 if (breakpoint->type == BKPT_HARD)
81 breakpoint = breakpoint->next;
84 if (arm7_9->sw_bkpts_enabled && arm7_9->sw_bkpts_use_wp)
86 arm7_9->sw_bkpts_enabled = 0;
87 arm7_9_enable_sw_bkpts(target);
93 /* set things up after a reset / on startup */
94 int arm7_9_setup(target_t *target)
96 /* a test-logic reset have occured
97 * the EmbeddedICE registers have been reset
98 * hardware breakpoints have been cleared
100 return arm7_9_reinit_embeddedice(target);
103 int arm7_9_get_arch_pointers(target_t *target, armv4_5_common_t **armv4_5_p, arm7_9_common_t **arm7_9_p)
105 armv4_5_common_t *armv4_5 = target->arch_info;
106 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
108 if (armv4_5->common_magic != ARMV4_5_COMMON_MAGIC)
113 if (arm7_9->common_magic != ARM7_9_COMMON_MAGIC)
118 *armv4_5_p = armv4_5;
124 int arm7_9_set_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
126 armv4_5_common_t *armv4_5 = target->arch_info;
127 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
129 if (target->state != TARGET_HALTED)
131 LOG_WARNING("target not halted");
132 return ERROR_TARGET_NOT_HALTED;
135 if (arm7_9->force_hw_bkpts)
136 breakpoint->type = BKPT_HARD;
140 LOG_WARNING("breakpoint already set");
144 if (breakpoint->type == BKPT_HARD)
146 /* either an ARM (4 byte) or Thumb (2 byte) breakpoint */
147 u32 mask = (breakpoint->length == 4) ? 0x3u : 0x1u;
148 if (!arm7_9->wp0_used)
150 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_VALUE], breakpoint->address);
151 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], mask);
152 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0xffffffffu);
153 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
154 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
156 jtag_execute_queue();
157 arm7_9->wp0_used = 1;
160 else if (!arm7_9->wp1_used)
162 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE], breakpoint->address);
163 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK], mask);
164 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK], 0xffffffffu);
165 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
166 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
168 jtag_execute_queue();
169 arm7_9->wp1_used = 1;
174 LOG_ERROR("BUG: no hardware comparator available");
178 else if (breakpoint->type == BKPT_SOFT)
180 if (breakpoint->length == 4)
182 u32 verify = 0xffffffff;
183 /* keep the original instruction in target endianness */
184 target->type->read_memory(target, breakpoint->address, 4, 1, breakpoint->orig_instr);
185 /* write the breakpoint instruction in target endianness (arm7_9->arm_bkpt is host endian) */
186 target_write_u32(target, breakpoint->address, arm7_9->arm_bkpt);
188 target->type->read_memory(target, breakpoint->address, 4, 1, (u8 *)&verify);
189 if (verify != arm7_9->arm_bkpt)
191 LOG_ERROR("Unable to set 32 bit software breakpoint at address %08x - check that memory is read/writable", breakpoint->address);
198 /* keep the original instruction in target endianness */
199 target->type->read_memory(target, breakpoint->address, 2, 1, breakpoint->orig_instr);
200 /* write the breakpoint instruction in target endianness (arm7_9->thumb_bkpt is host endian) */
201 target_write_u16(target, breakpoint->address, arm7_9->thumb_bkpt);
203 target->type->read_memory(target, breakpoint->address, 2, 1, (u8 *)&verify);
204 if (verify != arm7_9->thumb_bkpt)
206 LOG_ERROR("Unable to set thumb software breakpoint at address %08x - check that memory is read/writable", breakpoint->address);
217 int arm7_9_unset_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
219 armv4_5_common_t *armv4_5 = target->arch_info;
220 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
222 if (target->state != TARGET_HALTED)
224 LOG_WARNING("target not halted");
225 return ERROR_TARGET_NOT_HALTED;
228 if (!breakpoint->set)
230 LOG_WARNING("breakpoint not set");
234 if (breakpoint->type == BKPT_HARD)
236 if (breakpoint->set == 1)
238 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x0);
239 jtag_execute_queue();
240 arm7_9->wp0_used = 0;
242 else if (breakpoint->set == 2)
244 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0);
245 jtag_execute_queue();
246 arm7_9->wp1_used = 0;
252 /* restore original instruction (kept in target endianness) */
253 if (breakpoint->length == 4)
256 /* check that user program as not modified breakpoint instruction */
257 target->type->read_memory(target, breakpoint->address, 4, 1, (u8*)¤t_instr);
258 if (current_instr==arm7_9->arm_bkpt)
259 target->type->write_memory(target, breakpoint->address, 4, 1, breakpoint->orig_instr);
264 /* check that user program as not modified breakpoint instruction */
265 target->type->read_memory(target, breakpoint->address, 2, 1, (u8*)¤t_instr);
266 if (current_instr==arm7_9->thumb_bkpt)
267 target->type->write_memory(target, breakpoint->address, 2, 1, breakpoint->orig_instr);
275 int arm7_9_add_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
277 armv4_5_common_t *armv4_5 = target->arch_info;
278 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
280 if (target->state != TARGET_HALTED)
282 LOG_WARNING("target not halted");
283 return ERROR_TARGET_NOT_HALTED;
286 if (arm7_9->force_hw_bkpts)
288 LOG_DEBUG("forcing use of hardware breakpoint at address 0x%8.8x", breakpoint->address);
289 breakpoint->type = BKPT_HARD;
292 if ((breakpoint->type == BKPT_SOFT) && (arm7_9->sw_bkpts_enabled == 0))
294 LOG_INFO("sw breakpoint requested, but software breakpoints not enabled");
295 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
298 if ((breakpoint->type == BKPT_HARD) && (arm7_9->wp_available < 1))
300 LOG_INFO("no watchpoint unit available for hardware breakpoint");
301 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
304 if ((breakpoint->length != 2) && (breakpoint->length != 4))
306 LOG_INFO("only breakpoints of two (Thumb) or four (ARM) bytes length supported");
307 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
310 if (breakpoint->type == BKPT_HARD)
311 arm7_9->wp_available--;
316 int arm7_9_remove_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
318 armv4_5_common_t *armv4_5 = target->arch_info;
319 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
321 if (target->state != TARGET_HALTED)
323 LOG_WARNING("target not halted");
324 return ERROR_TARGET_NOT_HALTED;
329 arm7_9_unset_breakpoint(target, breakpoint);
332 if (breakpoint->type == BKPT_HARD)
333 arm7_9->wp_available++;
338 int arm7_9_set_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
340 armv4_5_common_t *armv4_5 = target->arch_info;
341 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
345 mask = watchpoint->length - 1;
347 if (target->state != TARGET_HALTED)
349 LOG_WARNING("target not halted");
350 return ERROR_TARGET_NOT_HALTED;
353 if (watchpoint->rw == WPT_ACCESS)
358 if (!arm7_9->wp0_used)
360 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_VALUE], watchpoint->address);
361 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], mask);
362 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], watchpoint->mask);
363 if( watchpoint->mask != 0xffffffffu )
364 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_VALUE], watchpoint->value);
365 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], 0xff & ~EICE_W_CTRL_nOPC & ~rw_mask);
366 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE | EICE_W_CTRL_nOPC | (watchpoint->rw & 1));
368 jtag_execute_queue();
370 arm7_9->wp0_used = 2;
372 else if (!arm7_9->wp1_used)
374 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE], watchpoint->address);
375 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK], mask);
376 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK], watchpoint->mask);
377 if( watchpoint->mask != 0xffffffffu )
378 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_VALUE], watchpoint->value);
379 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_MASK], 0xff & ~EICE_W_CTRL_nOPC & ~rw_mask);
380 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], EICE_W_CTRL_ENABLE | EICE_W_CTRL_nOPC | (watchpoint->rw & 1));
382 jtag_execute_queue();
384 arm7_9->wp1_used = 2;
388 LOG_ERROR("BUG: no hardware comparator available");
395 int arm7_9_unset_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
397 armv4_5_common_t *armv4_5 = target->arch_info;
398 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
400 if (target->state != TARGET_HALTED)
402 LOG_WARNING("target not halted");
403 return ERROR_TARGET_NOT_HALTED;
406 if (!watchpoint->set)
408 LOG_WARNING("breakpoint not set");
412 if (watchpoint->set == 1)
414 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x0);
415 jtag_execute_queue();
416 arm7_9->wp0_used = 0;
418 else if (watchpoint->set == 2)
420 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0);
421 jtag_execute_queue();
422 arm7_9->wp1_used = 0;
429 int arm7_9_add_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
431 armv4_5_common_t *armv4_5 = target->arch_info;
432 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
434 if (target->state != TARGET_HALTED)
436 LOG_WARNING("target not halted");
437 return ERROR_TARGET_NOT_HALTED;
440 if (arm7_9->wp_available < 1)
442 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
445 if ((watchpoint->length != 1) && (watchpoint->length != 2) && (watchpoint->length != 4))
447 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
450 arm7_9->wp_available--;
455 int arm7_9_remove_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
457 armv4_5_common_t *armv4_5 = target->arch_info;
458 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
460 if (target->state != TARGET_HALTED)
462 LOG_WARNING("target not halted");
463 return ERROR_TARGET_NOT_HALTED;
468 arm7_9_unset_watchpoint(target, watchpoint);
471 arm7_9->wp_available++;
476 int arm7_9_enable_sw_bkpts(struct target_s *target)
478 armv4_5_common_t *armv4_5 = target->arch_info;
479 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
482 if (arm7_9->sw_bkpts_enabled)
485 if (arm7_9->wp_available < 1)
487 LOG_WARNING("can't enable sw breakpoints with no watchpoint unit available");
488 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
490 arm7_9->wp_available--;
492 if (!arm7_9->wp0_used)
494 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_VALUE], arm7_9->arm_bkpt);
495 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0x0);
496 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], 0xffffffffu);
497 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
498 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
499 arm7_9->sw_bkpts_enabled = 1;
500 arm7_9->wp0_used = 3;
502 else if (!arm7_9->wp1_used)
504 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_VALUE], arm7_9->arm_bkpt);
505 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK], 0x0);
506 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK], 0xffffffffu);
507 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
508 embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
509 arm7_9->sw_bkpts_enabled = 2;
510 arm7_9->wp1_used = 3;
514 LOG_ERROR("BUG: both watchpoints used, but wp_available >= 1");
518 if ((retval = jtag_execute_queue()) != ERROR_OK)
520 LOG_ERROR("error writing EmbeddedICE registers to enable sw breakpoints");
527 int arm7_9_disable_sw_bkpts(struct target_s *target)
529 armv4_5_common_t *armv4_5 = target->arch_info;
530 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
532 if (!arm7_9->sw_bkpts_enabled)
535 if (arm7_9->sw_bkpts_enabled == 1)
537 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x0);
538 arm7_9->sw_bkpts_enabled = 0;
539 arm7_9->wp0_used = 0;
540 arm7_9->wp_available++;
542 else if (arm7_9->sw_bkpts_enabled == 2)
544 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0);
545 arm7_9->sw_bkpts_enabled = 0;
546 arm7_9->wp1_used = 0;
547 arm7_9->wp_available++;
553 int arm7_9_execute_sys_speed(struct target_s *target)
558 armv4_5_common_t *armv4_5 = target->arch_info;
559 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
560 arm_jtag_t *jtag_info = &arm7_9->jtag_info;
561 reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT];
563 /* set RESTART instruction */
564 jtag_add_end_state(TAP_RTI);
565 if (arm7_9->need_bypass_before_restart) {
566 arm7_9->need_bypass_before_restart = 0;
567 arm_jtag_set_instr(jtag_info, 0xf, NULL);
569 arm_jtag_set_instr(jtag_info, 0x4, NULL);
571 for (timeout=0; timeout<50; timeout++)
573 /* read debug status register */
574 embeddedice_read_reg(dbg_stat);
575 if ((retval = jtag_execute_queue()) != ERROR_OK)
577 if ((buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1))
578 && (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_SYSCOMP, 1)))
584 LOG_ERROR("timeout waiting for SYSCOMP & DBGACK, last DBG_STATUS: %x", buf_get_u32(dbg_stat->value, 0, dbg_stat->size));
585 return ERROR_TARGET_TIMEOUT;
591 int arm7_9_execute_fast_sys_speed(struct target_s *target)
594 static u8 check_value[4], check_mask[4];
596 armv4_5_common_t *armv4_5 = target->arch_info;
597 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
598 arm_jtag_t *jtag_info = &arm7_9->jtag_info;
599 reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT];
601 /* set RESTART instruction */
602 jtag_add_end_state(TAP_RTI);
603 if (arm7_9->need_bypass_before_restart) {
604 arm7_9->need_bypass_before_restart = 0;
605 arm_jtag_set_instr(jtag_info, 0xf, NULL);
607 arm_jtag_set_instr(jtag_info, 0x4, NULL);
611 /* check for DBGACK and SYSCOMP set (others don't care) */
613 /* NB! These are constants that must be available until after next jtag_execute() and
614 we evaluate the values upon first execution in lieu of setting up these constants
617 buf_set_u32(check_value, 0, 32, 0x9);
618 buf_set_u32(check_mask, 0, 32, 0x9);
622 /* read debug status register */
623 embeddedice_read_reg_w_check(dbg_stat, check_value, check_value);
628 int arm7_9_target_request_data(target_t *target, u32 size, u8 *buffer)
630 armv4_5_common_t *armv4_5 = target->arch_info;
631 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
632 arm_jtag_t *jtag_info = &arm7_9->jtag_info;
636 data = malloc(size * (sizeof(u32)));
638 embeddedice_receive(jtag_info, data, size);
640 for (i = 0; i < size; i++)
642 h_u32_to_le(buffer + (i * 4), data[i]);
650 int arm7_9_handle_target_request(void *priv)
652 target_t *target = priv;
653 if (!target->type->examined)
655 armv4_5_common_t *armv4_5 = target->arch_info;
656 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
657 arm_jtag_t *jtag_info = &arm7_9->jtag_info;
658 reg_t *dcc_control = &arm7_9->eice_cache->reg_list[EICE_COMMS_CTRL];
661 if (!target->dbg_msg_enabled)
664 if (target->state == TARGET_RUNNING)
666 /* read DCC control register */
667 embeddedice_read_reg(dcc_control);
668 jtag_execute_queue();
671 if (buf_get_u32(dcc_control->value, 1, 1) == 1)
675 embeddedice_receive(jtag_info, &request, 1);
676 target_request(target, request);
683 int arm7_9_poll(target_t *target)
686 armv4_5_common_t *armv4_5 = target->arch_info;
687 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
688 reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT];
690 /* read debug status register */
691 embeddedice_read_reg(dbg_stat);
692 if ((retval = jtag_execute_queue()) != ERROR_OK)
697 if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1))
699 /* LOG_DEBUG("DBGACK set, dbg_state->value: 0x%x", buf_get_u32(dbg_stat->value, 0, 32));*/
700 if (target->state == TARGET_UNKNOWN)
702 target->state = TARGET_RUNNING;
703 LOG_WARNING("DBGACK set while target was in unknown state. Reset or initialize target.");
705 if ((target->state == TARGET_RUNNING) || (target->state == TARGET_RESET))
708 if (target->state == TARGET_RESET)
710 if (target->reset_halt)
712 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
719 target->state = TARGET_HALTED;
721 if ((retval = arm7_9_debug_entry(target)) != ERROR_OK)
726 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
727 u32 t=*((u32 *)reg->value);
730 LOG_ERROR("PC was not 0. Does this target need srst_pulls_trst?");
734 target_call_event_callbacks(target, TARGET_EVENT_HALTED);
736 if (target->state == TARGET_DEBUG_RUNNING)
738 target->state = TARGET_HALTED;
739 if ((retval = arm7_9_debug_entry(target)) != ERROR_OK)
742 target_call_event_callbacks(target, TARGET_EVENT_DEBUG_HALTED);
744 if (target->state != TARGET_HALTED)
746 LOG_WARNING("DBGACK set, but the target did not end up in the halted stated %d", target->state);
751 if (target->state != TARGET_DEBUG_RUNNING)
752 target->state = TARGET_RUNNING;
759 Some -S targets (ARM966E-S in the STR912 isn't affected, ARM926EJ-S
760 in the LPC3180 and AT91SAM9260 is affected) completely stop the JTAG clock
761 while the core is held in reset(SRST). It isn't possible to program the halt
762 condition once reset was asserted, hence a hook that allows the target to set
763 up its reset-halt condition prior to asserting reset.
766 int arm7_9_assert_reset(target_t *target)
768 armv4_5_common_t *armv4_5 = target->arch_info;
769 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
770 LOG_DEBUG("target->state: %s", target_state_strings[target->state]);
772 if (!(jtag_reset_config & RESET_HAS_SRST))
774 LOG_ERROR("Can't assert SRST");
778 if (target->reset_halt)
781 * Some targets do not support communication while SRST is asserted. We need to
782 * set up the reset vector catch here.
784 * If TRST is asserted, then these settings will be reset anyway, so setting them
787 if (arm7_9->has_vector_catch)
789 /* program vector catch register to catch reset vector */
790 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_VEC_CATCH], 0x1);
794 /* program watchpoint unit to match on reset vector address */
795 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_VALUE], 0x0);
796 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], 0x3);
797 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0xffffffff);
798 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
799 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
803 /* here we should issue a srst only, but we may have to assert trst as well */
804 if (jtag_reset_config & RESET_SRST_PULLS_TRST)
806 jtag_add_reset(1, 1);
809 jtag_add_reset(0, 1);
813 target->state = TARGET_RESET;
814 jtag_add_sleep(50000);
816 armv4_5_invalidate_core_regs(target);
822 int arm7_9_deassert_reset(target_t *target)
825 LOG_DEBUG("target->state: %s", target_state_strings[target->state]);
827 /* deassert reset lines */
828 jtag_add_reset(0, 0);
830 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)!=0)
832 /* set up embedded ice registers again */
833 if ((retval=target->type->examine(target))!=ERROR_OK)
836 if (target->reset_halt)
838 /* halt the CPU as embedded ice was not set up in reset */
839 if ((retval=target->type->halt(target))!=ERROR_OK)
846 int arm7_9_clear_halt(target_t *target)
848 armv4_5_common_t *armv4_5 = target->arch_info;
849 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
850 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
852 /* we used DBGRQ only if we didn't come out of reset */
853 if (!arm7_9->debug_entry_from_reset && arm7_9->use_dbgrq)
855 /* program EmbeddedICE Debug Control Register to deassert DBGRQ
857 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGRQ, 1, 0);
858 embeddedice_store_reg(dbg_ctrl);
862 if (arm7_9->debug_entry_from_reset && arm7_9->has_vector_catch)
864 /* if we came out of reset, and vector catch is supported, we used
865 * vector catch to enter debug state
866 * restore the register in that case
868 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_VEC_CATCH]);
872 /* restore registers if watchpoint unit 0 was in use
874 if (arm7_9->wp0_used)
876 if (arm7_9->debug_entry_from_reset)
878 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_VALUE]);
880 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK]);
881 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK]);
882 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK]);
884 /* control value always has to be restored, as it was either disabled,
885 * or enabled with possibly different bits
887 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE]);
894 int arm7_9_soft_reset_halt(struct target_s *target)
896 armv4_5_common_t *armv4_5 = target->arch_info;
897 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
898 reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT];
899 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
903 if ((retval=target_halt(target))!=ERROR_OK)
908 if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_DBGACK, 1) != 0)
910 embeddedice_read_reg(dbg_stat);
911 if ((retval=jtag_execute_queue())!=ERROR_OK)
913 /* do not eat all CPU, time out after 1 se*/
919 LOG_ERROR("Failed to halt CPU after 1 sec");
920 return ERROR_TARGET_TIMEOUT;
922 target->state = TARGET_HALTED;
924 /* program EmbeddedICE Debug Control Register to assert DBGACK and INTDIS
925 * ensure that DBGRQ is cleared
927 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGACK, 1, 1);
928 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGRQ, 1, 0);
929 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_INTDIS, 1, 1);
930 embeddedice_store_reg(dbg_ctrl);
932 arm7_9_clear_halt(target);
934 /* if the target is in Thumb state, change to ARM state */
935 if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_ITBIT, 1))
937 u32 r0_thumb, pc_thumb;
938 LOG_DEBUG("target entered debug from Thumb state, changing to ARM");
939 /* Entered debug from Thumb mode */
940 armv4_5->core_state = ARMV4_5_STATE_THUMB;
941 arm7_9->change_to_arm(target, &r0_thumb, &pc_thumb);
944 /* all register content is now invalid */
945 armv4_5_invalidate_core_regs(target);
947 /* SVC, ARM state, IRQ and FIQ disabled */
948 buf_set_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8, 0xd3);
949 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].dirty = 1;
950 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].valid = 1;
952 /* start fetching from 0x0 */
953 buf_set_u32(armv4_5->core_cache->reg_list[15].value, 0, 32, 0x0);
954 armv4_5->core_cache->reg_list[15].dirty = 1;
955 armv4_5->core_cache->reg_list[15].valid = 1;
957 armv4_5->core_mode = ARMV4_5_MODE_SVC;
958 armv4_5->core_state = ARMV4_5_STATE_ARM;
960 if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
963 /* reset registers */
964 for (i = 0; i <= 14; i++)
966 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).value, 0, 32, 0xffffffff);
967 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = 1;
968 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).valid = 1;
971 target_call_event_callbacks(target, TARGET_EVENT_HALTED);
976 int arm7_9_halt(target_t *target)
978 if ((target->state==TARGET_RESET)&&((jtag_reset_config & RESET_SRST_PULLS_TRST)!=0))
980 LOG_WARNING("arm7/9 can't halt a target in reset if srst pulls trst - halting after reset");
984 armv4_5_common_t *armv4_5 = target->arch_info;
985 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
986 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
988 LOG_DEBUG("target->state: %s", target_state_strings[target->state]);
990 if (target->state == TARGET_HALTED)
992 LOG_DEBUG("target was already halted");
996 if (target->state == TARGET_UNKNOWN)
998 LOG_WARNING("target was in unknown state when halt was requested");
1001 if (target->state == TARGET_RESET)
1003 if ((jtag_reset_config & RESET_SRST_PULLS_TRST) && jtag_srst)
1005 LOG_ERROR("can't request a halt while in reset if nSRST pulls nTRST");
1006 return ERROR_TARGET_FAILURE;
1010 /* we came here in a reset_halt or reset_init sequence
1011 * debug entry was already prepared in arm7_9_assert_reset()
1013 target->debug_reason = DBG_REASON_DBGRQ;
1019 if (arm7_9->use_dbgrq)
1021 /* program EmbeddedICE Debug Control Register to assert DBGRQ
1023 if (arm7_9->set_special_dbgrq) {
1024 arm7_9->set_special_dbgrq(target);
1026 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGRQ, 1, 1);
1027 embeddedice_store_reg(dbg_ctrl);
1032 /* program watchpoint unit to match on any address
1034 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], 0xffffffff);
1035 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0xffffffff);
1036 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
1037 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
1040 target->debug_reason = DBG_REASON_DBGRQ;
1045 int arm7_9_debug_entry(target_t *target)
1050 u32 r0_thumb, pc_thumb;
1053 /* get pointers to arch-specific information */
1054 armv4_5_common_t *armv4_5 = target->arch_info;
1055 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1056 reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT];
1057 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
1059 #ifdef _DEBUG_ARM7_9_
1063 if (arm7_9->pre_debug_entry)
1064 arm7_9->pre_debug_entry(target);
1066 /* program EmbeddedICE Debug Control Register to assert DBGACK and INTDIS
1067 * ensure that DBGRQ is cleared
1069 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGACK, 1, 1);
1070 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGRQ, 1, 0);
1071 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_INTDIS, 1, 1);
1072 embeddedice_store_reg(dbg_ctrl);
1074 arm7_9_clear_halt(target);
1076 if ((retval = jtag_execute_queue()) != ERROR_OK)
1081 if ((retval = arm7_9->examine_debug_reason(target)) != ERROR_OK)
1085 if (target->state != TARGET_HALTED)
1087 LOG_WARNING("target not halted");
1088 return ERROR_TARGET_NOT_HALTED;
1091 /* if the target is in Thumb state, change to ARM state */
1092 if (buf_get_u32(dbg_stat->value, EICE_DBG_STATUS_ITBIT, 1))
1094 LOG_DEBUG("target entered debug from Thumb state");
1095 /* Entered debug from Thumb mode */
1096 armv4_5->core_state = ARMV4_5_STATE_THUMB;
1097 arm7_9->change_to_arm(target, &r0_thumb, &pc_thumb);
1098 LOG_DEBUG("r0_thumb: 0x%8.8x, pc_thumb: 0x%8.8x", r0_thumb, pc_thumb);
1102 LOG_DEBUG("target entered debug from ARM state");
1103 /* Entered debug from ARM mode */
1104 armv4_5->core_state = ARMV4_5_STATE_ARM;
1107 for (i = 0; i < 16; i++)
1108 context_p[i] = &context[i];
1109 /* save core registers (r0 - r15 of current core mode) */
1110 arm7_9->read_core_regs(target, 0xffff, context_p);
1112 arm7_9->read_xpsr(target, &cpsr, 0);
1114 if ((retval = jtag_execute_queue()) != ERROR_OK)
1117 /* if the core has been executing in Thumb state, set the T bit */
1118 if (armv4_5->core_state == ARMV4_5_STATE_THUMB)
1121 buf_set_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 32, cpsr);
1122 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].dirty = 0;
1123 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].valid = 1;
1125 armv4_5->core_mode = cpsr & 0x1f;
1127 if (armv4_5_mode_to_number(armv4_5->core_mode) == -1)
1129 target->state = TARGET_UNKNOWN;
1130 LOG_ERROR("cpsr contains invalid mode value - communication failure");
1131 return ERROR_TARGET_FAILURE;
1134 LOG_DEBUG("target entered debug state in %s mode", armv4_5_mode_strings[armv4_5_mode_to_number(armv4_5->core_mode)]);
1136 if (armv4_5->core_state == ARMV4_5_STATE_THUMB)
1138 LOG_DEBUG("thumb state, applying fixups");
1139 context[0] = r0_thumb;
1140 context[15] = pc_thumb;
1141 } else if (armv4_5->core_state == ARMV4_5_STATE_ARM)
1143 /* adjust value stored by STM */
1144 context[15] -= 3 * 4;
1147 if ((target->debug_reason == DBG_REASON_BREAKPOINT)
1148 || (target->debug_reason == DBG_REASON_SINGLESTEP)
1149 || (target->debug_reason == DBG_REASON_WATCHPOINT)
1150 || (target->debug_reason == DBG_REASON_WPTANDBKPT)
1151 || ((target->debug_reason == DBG_REASON_DBGRQ) && (arm7_9->use_dbgrq == 0)))
1152 context[15] -= 3 * ((armv4_5->core_state == ARMV4_5_STATE_ARM) ? 4 : 2);
1153 else if (target->debug_reason == DBG_REASON_DBGRQ)
1154 context[15] -= arm7_9->dbgreq_adjust_pc * ((armv4_5->core_state == ARMV4_5_STATE_ARM) ? 4 : 2);
1157 LOG_ERROR("unknown debug reason: %i", target->debug_reason);
1160 if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
1163 for (i=0; i<=15; i++)
1165 LOG_DEBUG("r%i: 0x%8.8x", i, context[i]);
1166 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).value, 0, 32, context[i]);
1167 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = 0;
1168 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).valid = 1;
1171 LOG_DEBUG("entered debug state at PC 0x%x", context[15]);
1173 if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
1176 /* exceptions other than USR & SYS have a saved program status register */
1177 if ((armv4_5->core_mode != ARMV4_5_MODE_USR) && (armv4_5->core_mode != ARMV4_5_MODE_SYS))
1180 arm7_9->read_xpsr(target, &spsr, 1);
1181 jtag_execute_queue();
1182 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 16).value, 0, 32, spsr);
1183 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 16).dirty = 0;
1184 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 16).valid = 1;
1187 /* r0 and r15 (pc) have to be restored later */
1188 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 0).dirty = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 0).valid;
1189 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 15).dirty = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, 15).valid;
1191 if ((retval = jtag_execute_queue()) != ERROR_OK)
1194 if (arm7_9->post_debug_entry)
1195 arm7_9->post_debug_entry(target);
1200 int arm7_9_full_context(target_t *target)
1204 armv4_5_common_t *armv4_5 = target->arch_info;
1205 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1209 if (target->state != TARGET_HALTED)
1211 LOG_WARNING("target not halted");
1212 return ERROR_TARGET_NOT_HALTED;
1215 if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
1218 /* iterate through processor modes (User, FIQ, IRQ, SVC, ABT, UND)
1219 * SYS shares registers with User, so we don't touch SYS
1221 for(i = 0; i < 6; i++)
1228 /* check if there are invalid registers in the current mode
1230 for (j = 0; j <= 16; j++)
1232 if (ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j).valid == 0)
1240 /* change processor mode (and mask T bit) */
1241 tmp_cpsr = buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & 0xE0;
1242 tmp_cpsr |= armv4_5_number_to_mode(i);
1244 arm7_9->write_xpsr_im8(target, tmp_cpsr & 0xff, 0, 0);
1246 for (j = 0; j < 15; j++)
1248 if (ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j).valid == 0)
1250 reg_p[j] = (u32*)ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j).value;
1252 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j).valid = 1;
1253 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j).dirty = 0;
1257 /* if only the PSR is invalid, mask is all zeroes */
1259 arm7_9->read_core_regs(target, mask, reg_p);
1261 /* check if the PSR has to be read */
1262 if (ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), 16).valid == 0)
1264 arm7_9->read_xpsr(target, (u32*)ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), 16).value, 1);
1265 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), 16).valid = 1;
1266 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), 16).dirty = 0;
1271 /* restore processor mode (mask T bit) */
1272 arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & ~0x20, 0, 0);
1274 if ((retval = jtag_execute_queue()) != ERROR_OK)
1281 int arm7_9_restore_context(target_t *target)
1283 armv4_5_common_t *armv4_5 = target->arch_info;
1284 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1286 armv4_5_core_reg_t *reg_arch_info;
1287 enum armv4_5_mode current_mode = armv4_5->core_mode;
1294 if (target->state != TARGET_HALTED)
1296 LOG_WARNING("target not halted");
1297 return ERROR_TARGET_NOT_HALTED;
1300 if (arm7_9->pre_restore_context)
1301 arm7_9->pre_restore_context(target);
1303 if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
1306 /* iterate through processor modes (User, FIQ, IRQ, SVC, ABT, UND)
1307 * SYS shares registers with User, so we don't touch SYS
1309 for (i = 0; i < 6; i++)
1311 LOG_DEBUG("examining %s mode", armv4_5_mode_strings[i]);
1314 /* check if there are dirty registers in the current mode
1316 for (j = 0; j <= 16; j++)
1318 reg = &ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j);
1319 reg_arch_info = reg->arch_info;
1320 if (reg->dirty == 1)
1322 if (reg->valid == 1)
1325 LOG_DEBUG("examining dirty reg: %s", reg->name);
1326 if ((reg_arch_info->mode != ARMV4_5_MODE_ANY)
1327 && (reg_arch_info->mode != current_mode)
1328 && !((reg_arch_info->mode == ARMV4_5_MODE_USR) && (armv4_5->core_mode == ARMV4_5_MODE_SYS))
1329 && !((reg_arch_info->mode == ARMV4_5_MODE_SYS) && (armv4_5->core_mode == ARMV4_5_MODE_USR)))
1332 LOG_DEBUG("require mode change");
1337 LOG_ERROR("BUG: dirty register '%s', but no valid data", reg->name);
1352 /* change processor mode (mask T bit) */
1353 tmp_cpsr = buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & 0xE0;
1354 tmp_cpsr |= armv4_5_number_to_mode(i);
1356 arm7_9->write_xpsr_im8(target, tmp_cpsr & 0xff, 0, 0);
1357 current_mode = armv4_5_number_to_mode(i);
1360 for (j = 0; j <= 14; j++)
1362 reg = &ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), j);
1363 reg_arch_info = reg->arch_info;
1366 if (reg->dirty == 1)
1368 regs[j] = buf_get_u32(reg->value, 0, 32);
1373 LOG_DEBUG("writing register %i of mode %s with value 0x%8.8x", j, armv4_5_mode_strings[i], regs[j]);
1379 arm7_9->write_core_regs(target, mask, regs);
1382 reg = &ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5_number_to_mode(i), 16);
1383 reg_arch_info = reg->arch_info;
1384 if ((reg->dirty) && (reg_arch_info->mode != ARMV4_5_MODE_ANY))
1386 LOG_DEBUG("writing SPSR of mode %i with value 0x%8.8x", i, buf_get_u32(reg->value, 0, 32));
1387 arm7_9->write_xpsr(target, buf_get_u32(reg->value, 0, 32), 1);
1392 if ((armv4_5->core_cache->reg_list[ARMV4_5_CPSR].dirty == 0) && (armv4_5->core_mode != current_mode))
1394 /* restore processor mode (mask T bit) */
1397 tmp_cpsr = buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & 0xE0;
1398 tmp_cpsr |= armv4_5_number_to_mode(i);
1400 LOG_DEBUG("writing lower 8 bit of cpsr with value 0x%2.2x", tmp_cpsr);
1401 arm7_9->write_xpsr_im8(target, tmp_cpsr & 0xff, 0, 0);
1403 else if (armv4_5->core_cache->reg_list[ARMV4_5_CPSR].dirty == 1)
1405 /* CPSR has been changed, full restore necessary (mask T bit) */
1406 LOG_DEBUG("writing cpsr with value 0x%8.8x", buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 32));
1407 arm7_9->write_xpsr(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 32) & ~0x20, 0);
1408 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].dirty = 0;
1409 armv4_5->core_cache->reg_list[ARMV4_5_CPSR].valid = 1;
1413 LOG_DEBUG("writing PC with value 0x%8.8x", buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32));
1414 arm7_9->write_pc(target, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32));
1415 armv4_5->core_cache->reg_list[15].dirty = 0;
1417 if (arm7_9->post_restore_context)
1418 arm7_9->post_restore_context(target);
1423 int arm7_9_restart_core(struct target_s *target)
1425 armv4_5_common_t *armv4_5 = target->arch_info;
1426 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1427 arm_jtag_t *jtag_info = &arm7_9->jtag_info;
1429 /* set RESTART instruction */
1430 jtag_add_end_state(TAP_RTI);
1431 if (arm7_9->need_bypass_before_restart) {
1432 arm7_9->need_bypass_before_restart = 0;
1433 arm_jtag_set_instr(jtag_info, 0xf, NULL);
1435 arm_jtag_set_instr(jtag_info, 0x4, NULL);
1437 jtag_add_runtest(1, TAP_RTI);
1438 return jtag_execute_queue();
1441 void arm7_9_enable_watchpoints(struct target_s *target)
1443 watchpoint_t *watchpoint = target->watchpoints;
1447 if (watchpoint->set == 0)
1448 arm7_9_set_watchpoint(target, watchpoint);
1449 watchpoint = watchpoint->next;
1453 void arm7_9_enable_breakpoints(struct target_s *target)
1455 breakpoint_t *breakpoint = target->breakpoints;
1457 /* set any pending breakpoints */
1460 if (breakpoint->set == 0)
1461 arm7_9_set_breakpoint(target, breakpoint);
1462 breakpoint = breakpoint->next;
1466 void arm7_9_disable_bkpts_and_wpts(struct target_s *target)
1468 breakpoint_t *breakpoint = target->breakpoints;
1469 watchpoint_t *watchpoint = target->watchpoints;
1471 /* set any pending breakpoints */
1474 if (breakpoint->set != 0)
1475 arm7_9_unset_breakpoint(target, breakpoint);
1476 breakpoint = breakpoint->next;
1481 if (watchpoint->set != 0)
1482 arm7_9_unset_watchpoint(target, watchpoint);
1483 watchpoint = watchpoint->next;
1487 int arm7_9_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)
1489 armv4_5_common_t *armv4_5 = target->arch_info;
1490 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1491 breakpoint_t *breakpoint = target->breakpoints;
1492 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
1497 if (target->state != TARGET_HALTED)
1499 LOG_WARNING("target not halted");
1500 return ERROR_TARGET_NOT_HALTED;
1503 if (!debug_execution)
1505 target_free_all_working_areas(target);
1508 /* current = 1: continue on current pc, otherwise continue at <address> */
1510 buf_set_u32(armv4_5->core_cache->reg_list[15].value, 0, 32, address);
1512 /* the front-end may request us not to handle breakpoints */
1513 if (handle_breakpoints)
1515 if ((breakpoint = breakpoint_find(target, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32))))
1517 LOG_DEBUG("unset breakpoint at 0x%8.8x", breakpoint->address);
1518 arm7_9_unset_breakpoint(target, breakpoint);
1520 LOG_DEBUG("enable single-step");
1521 arm7_9->enable_single_step(target);
1523 target->debug_reason = DBG_REASON_SINGLESTEP;
1525 arm7_9_restore_context(target);
1527 if (armv4_5->core_state == ARMV4_5_STATE_ARM)
1528 arm7_9->branch_resume(target);
1529 else if (armv4_5->core_state == ARMV4_5_STATE_THUMB)
1531 arm7_9->branch_resume_thumb(target);
1535 LOG_ERROR("unhandled core state");
1539 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGACK, 1, 0);
1540 embeddedice_write_reg(dbg_ctrl, buf_get_u32(dbg_ctrl->value, 0, dbg_ctrl->size));
1541 err = arm7_9_execute_sys_speed(target);
1543 LOG_DEBUG("disable single-step");
1544 arm7_9->disable_single_step(target);
1546 if (err != ERROR_OK)
1548 arm7_9_set_breakpoint(target, breakpoint);
1549 target->state = TARGET_UNKNOWN;
1553 arm7_9_debug_entry(target);
1554 LOG_DEBUG("new PC after step: 0x%8.8x", buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32));
1556 LOG_DEBUG("set breakpoint at 0x%8.8x", breakpoint->address);
1557 arm7_9_set_breakpoint(target, breakpoint);
1561 /* enable any pending breakpoints and watchpoints */
1562 arm7_9_enable_breakpoints(target);
1563 arm7_9_enable_watchpoints(target);
1565 arm7_9_restore_context(target);
1567 if (armv4_5->core_state == ARMV4_5_STATE_ARM)
1569 arm7_9->branch_resume(target);
1571 else if (armv4_5->core_state == ARMV4_5_STATE_THUMB)
1573 arm7_9->branch_resume_thumb(target);
1577 LOG_ERROR("unhandled core state");
1581 /* deassert DBGACK and INTDIS */
1582 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGACK, 1, 0);
1583 /* INTDIS only when we really resume, not during debug execution */
1584 if (!debug_execution)
1585 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_INTDIS, 1, 0);
1586 embeddedice_write_reg(dbg_ctrl, buf_get_u32(dbg_ctrl->value, 0, dbg_ctrl->size));
1588 arm7_9_restart_core(target);
1590 target->debug_reason = DBG_REASON_NOTHALTED;
1592 if (!debug_execution)
1594 /* registers are now invalid */
1595 armv4_5_invalidate_core_regs(target);
1596 target->state = TARGET_RUNNING;
1597 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
1601 target->state = TARGET_DEBUG_RUNNING;
1602 target_call_event_callbacks(target, TARGET_EVENT_DEBUG_RESUMED);
1605 LOG_DEBUG("target resumed");
1610 void arm7_9_enable_eice_step(target_t *target)
1612 armv4_5_common_t *armv4_5 = target->arch_info;
1613 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1615 /* setup an inverse breakpoint on the current PC
1616 * - comparator 1 matches the current address
1617 * - rangeout from comparator 1 is connected to comparator 0 rangein
1618 * - comparator 0 matches any address, as long as rangein is low */
1619 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], 0xffffffff);
1620 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0xffffffff);
1621 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
1622 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], ~(EICE_W_CTRL_RANGE|EICE_W_CTRL_nOPC) & 0xff);
1623 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));
1624 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK], 0);
1625 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK], 0xffffffff);
1626 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0);
1627 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_MASK], ~EICE_W_CTRL_nOPC & 0xff);
1630 void arm7_9_disable_eice_step(target_t *target)
1632 armv4_5_common_t *armv4_5 = target->arch_info;
1633 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1635 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK]);
1636 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK]);
1637 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE]);
1638 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK]);
1639 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE]);
1640 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK]);
1641 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK]);
1642 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_MASK]);
1643 embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE]);
1646 int arm7_9_step(struct target_s *target, int current, u32 address, int handle_breakpoints)
1648 armv4_5_common_t *armv4_5 = target->arch_info;
1649 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1650 breakpoint_t *breakpoint = NULL;
1653 if (target->state != TARGET_HALTED)
1655 LOG_WARNING("target not halted");
1656 return ERROR_TARGET_NOT_HALTED;
1659 /* current = 1: continue on current pc, otherwise continue at <address> */
1661 buf_set_u32(armv4_5->core_cache->reg_list[15].value, 0, 32, address);
1663 /* the front-end may request us not to handle breakpoints */
1664 if (handle_breakpoints)
1665 if ((breakpoint = breakpoint_find(target, buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32))))
1666 arm7_9_unset_breakpoint(target, breakpoint);
1668 target->debug_reason = DBG_REASON_SINGLESTEP;
1670 arm7_9_restore_context(target);
1672 arm7_9->enable_single_step(target);
1674 if (armv4_5->core_state == ARMV4_5_STATE_ARM)
1676 arm7_9->branch_resume(target);
1678 else if (armv4_5->core_state == ARMV4_5_STATE_THUMB)
1680 arm7_9->branch_resume_thumb(target);
1684 LOG_ERROR("unhandled core state");
1688 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
1690 err = arm7_9_execute_sys_speed(target);
1691 arm7_9->disable_single_step(target);
1693 /* registers are now invalid */
1694 armv4_5_invalidate_core_regs(target);
1696 if (err != ERROR_OK)
1698 target->state = TARGET_UNKNOWN;
1700 arm7_9_debug_entry(target);
1701 target_call_event_callbacks(target, TARGET_EVENT_HALTED);
1702 LOG_DEBUG("target stepped");
1706 arm7_9_set_breakpoint(target, breakpoint);
1712 int arm7_9_read_core_reg(struct target_s *target, int num, enum armv4_5_mode mode)
1717 armv4_5_common_t *armv4_5 = target->arch_info;
1718 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1720 if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
1723 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;
1725 if ((num < 0) || (num > 16))
1726 return ERROR_INVALID_ARGUMENTS;
1728 if ((mode != ARMV4_5_MODE_ANY)
1729 && (mode != armv4_5->core_mode)
1730 && (reg_mode != ARMV4_5_MODE_ANY))
1734 /* change processor mode (mask T bit) */
1735 tmp_cpsr = buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & 0xE0;
1738 arm7_9->write_xpsr_im8(target, tmp_cpsr & 0xff, 0, 0);
1741 if ((num >= 0) && (num <= 15))
1743 /* read a normal core register */
1744 reg_p[num] = &value;
1746 arm7_9->read_core_regs(target, 1 << num, reg_p);
1750 /* read a program status register
1751 * if the register mode is MODE_ANY, we read the cpsr, otherwise a spsr
1753 armv4_5_core_reg_t *arch_info = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).arch_info;
1754 int spsr = (arch_info->mode == ARMV4_5_MODE_ANY) ? 0 : 1;
1756 arm7_9->read_xpsr(target, &value, spsr);
1759 if ((retval = jtag_execute_queue()) != ERROR_OK)
1764 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).valid = 1;
1765 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).dirty = 0;
1766 buf_set_u32(ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).value, 0, 32, value);
1768 if ((mode != ARMV4_5_MODE_ANY)
1769 && (mode != armv4_5->core_mode)
1770 && (reg_mode != ARMV4_5_MODE_ANY)) {
1771 /* restore processor mode (mask T bit) */
1772 arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & ~0x20, 0, 0);
1779 int arm7_9_write_core_reg(struct target_s *target, int num, enum armv4_5_mode mode, u32 value)
1782 armv4_5_common_t *armv4_5 = target->arch_info;
1783 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1785 if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
1788 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;
1790 if ((num < 0) || (num > 16))
1791 return ERROR_INVALID_ARGUMENTS;
1793 if ((mode != ARMV4_5_MODE_ANY)
1794 && (mode != armv4_5->core_mode)
1795 && (reg_mode != ARMV4_5_MODE_ANY)) {
1798 /* change processor mode (mask T bit) */
1799 tmp_cpsr = buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & 0xE0;
1802 arm7_9->write_xpsr_im8(target, tmp_cpsr & 0xff, 0, 0);
1805 if ((num >= 0) && (num <= 15))
1807 /* write a normal core register */
1810 arm7_9->write_core_regs(target, 1 << num, reg);
1814 /* write a program status register
1815 * if the register mode is MODE_ANY, we write the cpsr, otherwise a spsr
1817 armv4_5_core_reg_t *arch_info = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).arch_info;
1818 int spsr = (arch_info->mode == ARMV4_5_MODE_ANY) ? 0 : 1;
1820 /* if we're writing the CPSR, mask the T bit */
1824 arm7_9->write_xpsr(target, value, spsr);
1827 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).valid = 1;
1828 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).dirty = 0;
1830 if ((mode != ARMV4_5_MODE_ANY)
1831 && (mode != armv4_5->core_mode)
1832 && (reg_mode != ARMV4_5_MODE_ANY)) {
1833 /* restore processor mode (mask T bit) */
1834 arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & ~0x20, 0, 0);
1837 return jtag_execute_queue();
1840 int arm7_9_read_memory(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
1842 armv4_5_common_t *armv4_5 = target->arch_info;
1843 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1846 int num_accesses = 0;
1847 int thisrun_accesses;
1853 LOG_DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address, size, count);
1855 if (target->state != TARGET_HALTED)
1857 LOG_WARNING("target not halted");
1858 return ERROR_TARGET_NOT_HALTED;
1861 /* sanitize arguments */
1862 if (((size != 4) && (size != 2) && (size != 1)) || (count == 0) || !(buffer))
1863 return ERROR_INVALID_ARGUMENTS;
1865 if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u)))
1866 return ERROR_TARGET_UNALIGNED_ACCESS;
1868 /* load the base register with the address of the first word */
1870 arm7_9->write_core_regs(target, 0x1, reg);
1875 while (num_accesses < count)
1878 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
1879 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
1881 if (last_reg <= thisrun_accesses)
1882 last_reg = thisrun_accesses;
1884 arm7_9->load_word_regs(target, reg_list);
1886 /* fast memory reads are only safe when the target is running
1887 * from a sufficiently high clock (32 kHz is usually too slow)
1889 if (arm7_9->fast_memory_access)
1890 arm7_9_execute_fast_sys_speed(target);
1892 arm7_9_execute_sys_speed(target);
1894 arm7_9->read_core_regs_target_buffer(target, reg_list, buffer, 4);
1896 /* advance buffer, count number of accesses */
1897 buffer += thisrun_accesses * 4;
1898 num_accesses += thisrun_accesses;
1902 while (num_accesses < count)
1905 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
1906 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
1908 for (i = 1; i <= thisrun_accesses; i++)
1912 arm7_9->load_hword_reg(target, i);
1913 /* fast memory reads are only safe when the target is running
1914 * from a sufficiently high clock (32 kHz is usually too slow)
1916 if (arm7_9->fast_memory_access)
1917 arm7_9_execute_fast_sys_speed(target);
1919 arm7_9_execute_sys_speed(target);
1922 arm7_9->read_core_regs_target_buffer(target, reg_list, buffer, 2);
1924 /* advance buffer, count number of accesses */
1925 buffer += thisrun_accesses * 2;
1926 num_accesses += thisrun_accesses;
1930 while (num_accesses < count)
1933 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
1934 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
1936 for (i = 1; i <= thisrun_accesses; i++)
1940 arm7_9->load_byte_reg(target, i);
1941 /* fast memory reads are only safe when the target is running
1942 * from a sufficiently high clock (32 kHz is usually too slow)
1944 if (arm7_9->fast_memory_access)
1945 arm7_9_execute_fast_sys_speed(target);
1947 arm7_9_execute_sys_speed(target);
1950 arm7_9->read_core_regs_target_buffer(target, reg_list, buffer, 1);
1952 /* advance buffer, count number of accesses */
1953 buffer += thisrun_accesses * 1;
1954 num_accesses += thisrun_accesses;
1958 LOG_ERROR("BUG: we shouldn't get here");
1963 if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
1966 for (i=0; i<=last_reg; i++)
1967 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).valid;
1969 arm7_9->read_xpsr(target, &cpsr, 0);
1970 if ((retval = jtag_execute_queue()) != ERROR_OK)
1972 LOG_ERROR("JTAG error while reading cpsr");
1973 return ERROR_TARGET_DATA_ABORT;
1976 if (((cpsr & 0x1f) == ARMV4_5_MODE_ABT) && (armv4_5->core_mode != ARMV4_5_MODE_ABT))
1978 LOG_WARNING("memory read caused data abort (address: 0x%8.8x, size: 0x%x, count: 0x%x)", address, size, count);
1980 arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & ~0x20, 0, 0);
1982 return ERROR_TARGET_DATA_ABORT;
1988 int arm7_9_write_memory(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
1990 armv4_5_common_t *armv4_5 = target->arch_info;
1991 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
1992 reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL];
1995 int num_accesses = 0;
1996 int thisrun_accesses;
2002 #ifdef _DEBUG_ARM7_9_
2003 LOG_DEBUG("address: 0x%8.8x, size: 0x%8.8x, count: 0x%8.8x", address, size, count);
2006 if (target->state != TARGET_HALTED)
2008 LOG_WARNING("target not halted");
2009 return ERROR_TARGET_NOT_HALTED;
2012 /* sanitize arguments */
2013 if (((size != 4) && (size != 2) && (size != 1)) || (count == 0) || !(buffer))
2014 return ERROR_INVALID_ARGUMENTS;
2016 if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u)))
2017 return ERROR_TARGET_UNALIGNED_ACCESS;
2019 /* load the base register with the address of the first word */
2021 arm7_9->write_core_regs(target, 0x1, reg);
2023 /* Clear DBGACK, to make sure memory fetches work as expected */
2024 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGACK, 1, 0);
2025 embeddedice_store_reg(dbg_ctrl);
2030 while (num_accesses < count)
2033 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
2034 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
2036 for (i = 1; i <= thisrun_accesses; i++)
2040 reg[i] = target_buffer_get_u32(target, buffer);
2044 arm7_9->write_core_regs(target, reg_list, reg);
2046 arm7_9->store_word_regs(target, reg_list);
2048 /* fast memory writes are only safe when the target is running
2049 * from a sufficiently high clock (32 kHz is usually too slow)
2051 if (arm7_9->fast_memory_access)
2052 arm7_9_execute_fast_sys_speed(target);
2054 arm7_9_execute_sys_speed(target);
2056 num_accesses += thisrun_accesses;
2060 while (num_accesses < count)
2063 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
2064 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
2066 for (i = 1; i <= thisrun_accesses; i++)
2070 reg[i] = target_buffer_get_u16(target, buffer) & 0xffff;
2074 arm7_9->write_core_regs(target, reg_list, reg);
2076 for (i = 1; i <= thisrun_accesses; i++)
2078 arm7_9->store_hword_reg(target, i);
2080 /* fast memory writes are only safe when the target is running
2081 * from a sufficiently high clock (32 kHz is usually too slow)
2083 if (arm7_9->fast_memory_access)
2084 arm7_9_execute_fast_sys_speed(target);
2086 arm7_9_execute_sys_speed(target);
2089 num_accesses += thisrun_accesses;
2093 while (num_accesses < count)
2096 thisrun_accesses = ((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
2097 reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
2099 for (i = 1; i <= thisrun_accesses; i++)
2103 reg[i] = *buffer++ & 0xff;
2106 arm7_9->write_core_regs(target, reg_list, reg);
2108 for (i = 1; i <= thisrun_accesses; i++)
2110 arm7_9->store_byte_reg(target, i);
2111 /* fast memory writes are only safe when the target is running
2112 * from a sufficiently high clock (32 kHz is usually too slow)
2114 if (arm7_9->fast_memory_access)
2115 arm7_9_execute_fast_sys_speed(target);
2117 arm7_9_execute_sys_speed(target);
2120 num_accesses += thisrun_accesses;
2124 LOG_ERROR("BUG: we shouldn't get here");
2130 buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGACK, 1, 1);
2131 embeddedice_store_reg(dbg_ctrl);
2133 if (armv4_5_mode_to_number(armv4_5->core_mode)==-1)
2136 for (i=0; i<=last_reg; i++)
2137 ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).dirty = ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, armv4_5->core_mode, i).valid;
2139 arm7_9->read_xpsr(target, &cpsr, 0);
2140 if ((retval = jtag_execute_queue()) != ERROR_OK)
2142 LOG_ERROR("JTAG error while reading cpsr");
2143 return ERROR_TARGET_DATA_ABORT;
2146 if (((cpsr & 0x1f) == ARMV4_5_MODE_ABT) && (armv4_5->core_mode != ARMV4_5_MODE_ABT))
2148 LOG_WARNING("memory write caused data abort (address: 0x%8.8x, size: 0x%x, count: 0x%x)", address, size, count);
2150 arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & ~0x20, 0, 0);
2152 return ERROR_TARGET_DATA_ABORT;
2158 static const u32 dcc_code[] =
2160 /* MRC TST BNE MRC STR B */
2161 0xee101e10, 0xe3110001, 0x0afffffc, 0xee111e10, 0xe4801004, 0xeafffff9
2164 int arm7_9_bulk_write_memory(target_t *target, u32 address, u32 count, u8 *buffer)
2166 armv4_5_common_t *armv4_5 = target->arch_info;
2167 arm7_9_common_t *arm7_9 = armv4_5->arch_info;
2168 enum armv4_5_state core_state = armv4_5->core_state;
2169 u32 r0 = buf_get_u32(armv4_5->core_cache->reg_list[0].value, 0, 32);
2170 u32 r1 = buf_get_u32(armv4_5->core_cache->reg_list[1].value, 0, 32);
2171 u32 pc = buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32);
2174 if (!arm7_9->dcc_downloads)
2175 return target->type->write_memory(target, address, 4, count, buffer);
2177 /* regrab previously allocated working_area, or allocate a new one */
2178 if (!arm7_9->dcc_working_area)
2180 u8 dcc_code_buf[6 * 4];
2182 /* make sure we have a working area */
2183 if (target_alloc_working_area(target, 24, &arm7_9->dcc_working_area) != ERROR_OK)
2185 LOG_INFO("no working area available, falling back to memory writes");
2186 return target->type->write_memory(target, address, 4, count, buffer);
2189 /* copy target instructions to target endianness */
2190 for (i = 0; i < 6; i++)
2192 target_buffer_set_u32(target, dcc_code_buf + i*4, dcc_code[i]);
2195 /* write DCC code to working area */
2196 target->type->write_memory(target, arm7_9->dcc_working_area->address, 4, 6, dcc_code_buf);
2199 buf_set_u32(armv4_5->core_cache->reg_list[0].value, 0, 32, address);
2200 armv4_5->core_cache->reg_list[0].valid = 1;
2201 armv4_5->core_cache->reg_list[0].dirty = 1;
2202 armv4_5->core_state = ARMV4_5_STATE_ARM;
2204 arm7_9_resume(target, 0, arm7_9->dcc_working_area->address, 1, 1);
2206 int little=target->endianness==TARGET_LITTLE_ENDIAN;
2209 /* Handle first & last using standard embeddedice_write_reg and the middle ones w/the
2210 core function repeated.
2212 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_COMMS_DATA], fast_target_buffer_get_u32(buffer, little));
2215 embeddedice_reg_t *ice_reg = arm7_9->eice_cache->reg_list[EICE_COMMS_DATA].arch_info;
2216 u8 reg_addr = ice_reg->addr & 0x1f;
2217 int chain_pos = ice_reg->jtag_info->chain_pos;
2219 embeddedice_write_dcc(chain_pos, reg_addr, buffer, little, count-2);
2220 buffer += (count-2)*4;
2222 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_COMMS_DATA], fast_target_buffer_get_u32(buffer, little));
2225 for (i = 0; i < count; i++)
2227 embeddedice_write_reg(&arm7_9->eice_cache->reg_list[EICE_COMMS_DATA], fast_target_buffer_get_u32(buffer, little));
2232 target_halt(target);
2234 for (i=0; i<100; i++)
2236 target_poll(target);
2237 if (target->state == TARGET_HALTED)
2239 usleep(1000); /* sleep 1ms */
2243 LOG_ERROR("bulk write timed out, target not halted");
2244 return ERROR_TARGET_TIMEOUT;
2247 /* restore target state */
2248 buf_set_u32(armv4_5->core_cache->reg_list[0].value, 0, 32, r0);
2249 armv4_5->core_cache->reg_list[0].valid = 1;
2250 armv4_5->core_cache->reg_list[0].dirty = 1;
2251 buf_set_u32(armv4_5->core_cache->reg_list[1].value, 0, 32, r1);
2252 armv4_5->core_cache->reg_list[1].valid = 1;
2253 armv4_5->core_cache->reg_list[1].dirty = 1;
2254 buf_set_u32(armv4_5->core_cache->reg_list[15].value, 0, 32, pc);
2255 armv4_5->core_cache->reg_list[15].valid = 1;
2256 armv4_5->core_cache->reg_list[15].dirty = 1;
2257 armv4_5->core_state = core_state;
2262 int arm7_9_checksum_memory(struct target_s *target, u32 address, u32 count, u32* checksum)
2264 working_area_t *crc_algorithm;
2265 armv4_5_algorithm_t armv4_5_info;
2266 reg_param_t reg_params[2];
2269 u32 arm7_9_crc_code[] = {
2270 0xE1A02000, /* mov r2, r0 */
2271 0xE3E00000, /* mov r0, #0xffffffff */
2272 0xE1A03001, /* mov r3, r1 */
2273 0xE3A04000, /* mov r4, #0 */
2274 0xEA00000B, /* b ncomp */
2276 0xE7D21004, /* ldrb r1, [r2, r4] */
2277 0xE59F7030, /* ldr r7, CRC32XOR */
2278 0xE0200C01, /* eor r0, r0, r1, asl 24 */
2279 0xE3A05000, /* mov r5, #0 */
2281 0xE3500000, /* cmp r0, #0 */
2282 0xE1A06080, /* mov r6, r0, asl #1 */
2283 0xE2855001, /* add r5, r5, #1 */
2284 0xE1A00006, /* mov r0, r6 */
2285 0xB0260007, /* eorlt r0, r6, r7 */
2286 0xE3550008, /* cmp r5, #8 */
2287 0x1AFFFFF8, /* bne loop */
2288 0xE2844001, /* add r4, r4, #1 */
2290 0xE1540003, /* cmp r4, r3 */
2291 0x1AFFFFF1, /* bne nbyte */
2293 0xEAFFFFFE, /* b end */
2294 0x04C11DB7 /* CRC32XOR: .word 0x04C11DB7 */
2299 if (target_alloc_working_area(target, sizeof(arm7_9_crc_code), &crc_algorithm) != ERROR_OK)
2301 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
2304 /* convert flash writing code into a buffer in target endianness */
2305 for (i = 0; i < (sizeof(arm7_9_crc_code)/sizeof(u32)); i++)
2306 target_write_u32(target, crc_algorithm->address + i*sizeof(u32), arm7_9_crc_code[i]);
2308 armv4_5_info.common_magic = ARMV4_5_COMMON_MAGIC;
2309 armv4_5_info.core_mode = ARMV4_5_MODE_SVC;
2310 armv4_5_info.core_state = ARMV4_5_STATE_ARM;
2312 init_reg_param(®_params[0], "r0", 32, PARAM_IN_OUT);
2313 init_reg_param(®_params[1], "r1", 32, PARAM_OUT);
2315 buf_set_u32(reg_params[0].value, 0, 32, address);
2316 buf_set_u32(reg_params[1].value, 0, 32, count);
2318 if ((retval = target->type->run_algorithm(target, 0, NULL, 2, reg_params,
2319 crc_algorithm->address, crc_algorithm->address + (sizeof(arm7_9_crc_code) - 8), 20000, &armv4_5_info)) != ERROR_OK)
2321 LOG_ERROR("error executing arm7_9 crc algorithm");
2322 destroy_reg_param(®_params[0]);
2323 destroy_reg_param(®_params[1]);
2324 target_free_working_area(target, crc_algorithm);
2328 *checksum = buf_get_u32(reg_params[0].value, 0, 32);
2330 destroy_reg_param(®_params[0]);
2331 destroy_reg_param(®_params[1]);
2333 target_free_working_area(target, crc_algorithm);
2338 int arm7_9_blank_check_memory(struct target_s *target, u32 address, u32 count, u32* blank)
2340 working_area_t *erase_check_algorithm;
2341 reg_param_t reg_params[3];
2342 armv4_5_algorithm_t armv4_5_info;
2346 u32 erase_check_code[] =
2349 0xe4d03001, /* ldrb r3, [r0], #1 */
2350 0xe0022003, /* and r2, r2, r3 */
2351 0xe2511001, /* subs r1, r1, #1 */
2352 0x1afffffb, /* bne loop */
2354 0xeafffffe /* b end */
2357 /* make sure we have a working area */
2358 if (target_alloc_working_area(target, sizeof(erase_check_code), &erase_check_algorithm) != ERROR_OK)
2360 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
2363 /* convert flash writing code into a buffer in target endianness */
2364 for (i = 0; i < (sizeof(erase_check_code)/sizeof(u32)); i++)
2365 target_write_u32(target, erase_check_algorithm->address + i*sizeof(u32), erase_check_code[i]);
2367 armv4_5_info.common_magic = ARMV4_5_COMMON_MAGIC;
2368 armv4_5_info.core_mode = ARMV4_5_MODE_SVC;
2369 armv4_5_info.core_state = ARMV4_5_STATE_ARM;
2371 init_reg_param(®_params[0], "r0", 32, PARAM_OUT);
2372 buf_set_u32(reg_params[0].value, 0, 32, address);
2374 init_reg_param(®_params[1], "r1", 32, PARAM_OUT);
2375 buf_set_u32(reg_params[1].value, 0, 32, count);
2377 init_reg_param(®_params[2], "r2", 32, PARAM_IN_OUT);
2378 buf_set_u32(reg_params[2].value, 0, 32, 0xff);
2380 if ((retval = target->type->run_algorithm(target, 0, NULL, 3, reg_params,
2381 erase_check_algorithm->address, erase_check_algorithm->address + (sizeof(erase_check_code) - 4), 10000, &armv4_5_info)) != ERROR_OK)
2383 destroy_reg_param(®_params[0]);
2384 destroy_reg_param(®_params[1]);
2385 destroy_reg_param(®_params[2]);
2386 target_free_working_area(target, erase_check_algorithm);
2390 *blank = buf_get_u32(reg_params[2].value, 0, 32);
2392 destroy_reg_param(®_params[0]);
2393 destroy_reg_param(®_params[1]);
2394 destroy_reg_param(®_params[2]);
2396 target_free_working_area(target, erase_check_algorithm);
2401 int arm7_9_register_commands(struct command_context_s *cmd_ctx)
2403 command_t *arm7_9_cmd;
2405 arm7_9_cmd = register_command(cmd_ctx, NULL, "arm7_9", NULL, COMMAND_ANY, "arm7/9 specific commands");
2407 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>");
2408 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>");
2410 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>");
2412 register_command(cmd_ctx, arm7_9_cmd, "sw_bkpts", handle_arm7_9_sw_bkpts_command, COMMAND_EXEC, "support for software breakpoints <enable|disable>");
2413 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>");
2414 register_command(cmd_ctx, arm7_9_cmd, "dbgrq", handle_arm7_9_dbgrq_command,
2415 COMMAND_ANY, "use EmbeddedICE dbgrq instead of breakpoint for target halt requests <enable|disable>");
2416 register_command(cmd_ctx, arm7_9_cmd, "fast_writes", handle_arm7_9_fast_memory_access_command,
2417 COMMAND_ANY, "(deprecated, see: arm7_9 fast_memory_access)");
2418 register_command(cmd_ctx, arm7_9_cmd, "fast_memory_access", handle_arm7_9_fast_memory_access_command,
2419 COMMAND_ANY, "use fast memory accesses instead of slower but potentially unsafe slow accesses <enable|disable>");
2420 register_command(cmd_ctx, arm7_9_cmd, "dcc_downloads", handle_arm7_9_dcc_downloads_command,
2421 COMMAND_ANY, "use DCC downloads for larger memory writes <enable|disable>");
2423 armv4_5_register_commands(cmd_ctx);
2425 etm_register_commands(cmd_ctx);
2430 int handle_arm7_9_write_xpsr_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2435 target_t *target = get_current_target(cmd_ctx);
2436 armv4_5_common_t *armv4_5;
2437 arm7_9_common_t *arm7_9;
2439 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2441 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2445 if (target->state != TARGET_HALTED)
2447 command_print(cmd_ctx, "can't write registers while running");
2453 command_print(cmd_ctx, "usage: write_xpsr <value> <not cpsr|spsr>");
2457 value = strtoul(args[0], NULL, 0);
2458 spsr = strtol(args[1], NULL, 0);
2460 /* if we're writing the CPSR, mask the T bit */
2464 arm7_9->write_xpsr(target, value, spsr);
2465 if ((retval = jtag_execute_queue()) != ERROR_OK)
2467 LOG_ERROR("JTAG error while writing to xpsr");
2474 int handle_arm7_9_write_xpsr_im8_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2480 target_t *target = get_current_target(cmd_ctx);
2481 armv4_5_common_t *armv4_5;
2482 arm7_9_common_t *arm7_9;
2484 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2486 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2490 if (target->state != TARGET_HALTED)
2492 command_print(cmd_ctx, "can't write registers while running");
2498 command_print(cmd_ctx, "usage: write_xpsr_im8 <im8> <rotate> <not cpsr|spsr>");
2502 value = strtoul(args[0], NULL, 0);
2503 rotate = strtol(args[1], NULL, 0);
2504 spsr = strtol(args[2], NULL, 0);
2506 arm7_9->write_xpsr_im8(target, value, rotate, spsr);
2507 if ((retval = jtag_execute_queue()) != ERROR_OK)
2509 LOG_ERROR("JTAG error while writing 8-bit immediate to xpsr");
2516 int handle_arm7_9_write_core_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2521 target_t *target = get_current_target(cmd_ctx);
2522 armv4_5_common_t *armv4_5;
2523 arm7_9_common_t *arm7_9;
2525 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2527 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2531 if (target->state != TARGET_HALTED)
2533 command_print(cmd_ctx, "can't write registers while running");
2539 command_print(cmd_ctx, "usage: write_core_reg <num> <mode> <value>");
2543 num = strtol(args[0], NULL, 0);
2544 mode = strtoul(args[1], NULL, 0);
2545 value = strtoul(args[2], NULL, 0);
2547 arm7_9_write_core_reg(target, num, mode, value);
2552 int handle_arm7_9_sw_bkpts_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2554 target_t *target = get_current_target(cmd_ctx);
2555 armv4_5_common_t *armv4_5;
2556 arm7_9_common_t *arm7_9;
2558 if (target->state != TARGET_HALTED)
2560 LOG_ERROR("target not halted");
2561 return ERROR_TARGET_NOT_HALTED;
2564 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2566 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2572 command_print(cmd_ctx, "software breakpoints %s", (arm7_9->sw_bkpts_enabled) ? "enabled" : "disabled");
2576 if (strcmp("enable", args[0]) == 0)
2578 if (arm7_9->sw_bkpts_use_wp)
2580 arm7_9_enable_sw_bkpts(target);
2584 arm7_9->sw_bkpts_enabled = 1;
2587 else if (strcmp("disable", args[0]) == 0)
2589 if (arm7_9->sw_bkpts_use_wp)
2591 arm7_9_disable_sw_bkpts(target);
2595 arm7_9->sw_bkpts_enabled = 0;
2600 command_print(cmd_ctx, "usage: arm7_9 sw_bkpts <enable|disable>");
2603 command_print(cmd_ctx, "software breakpoints %s", (arm7_9->sw_bkpts_enabled) ? "enabled" : "disabled");
2608 int handle_arm7_9_force_hw_bkpts_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2610 target_t *target = get_current_target(cmd_ctx);
2611 armv4_5_common_t *armv4_5;
2612 arm7_9_common_t *arm7_9;
2614 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2616 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2620 if ((argc >= 1) && (strcmp("enable", args[0]) == 0))
2622 arm7_9->force_hw_bkpts = 1;
2623 if (arm7_9->sw_bkpts_use_wp)
2625 arm7_9_disable_sw_bkpts(target);
2628 else if ((argc >= 1) && (strcmp("disable", args[0]) == 0))
2630 arm7_9->force_hw_bkpts = 0;
2634 command_print(cmd_ctx, "usage: arm7_9 force_hw_bkpts <enable|disable>");
2637 command_print(cmd_ctx, "force hardware breakpoints %s", (arm7_9->force_hw_bkpts) ? "enabled" : "disabled");
2642 int handle_arm7_9_dbgrq_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2644 target_t *target = get_current_target(cmd_ctx);
2645 armv4_5_common_t *armv4_5;
2646 arm7_9_common_t *arm7_9;
2648 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2650 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2656 if (strcmp("enable", args[0]) == 0)
2658 arm7_9->use_dbgrq = 1;
2660 else if (strcmp("disable", args[0]) == 0)
2662 arm7_9->use_dbgrq = 0;
2666 command_print(cmd_ctx, "usage: arm7_9 dbgrq <enable|disable>");
2670 command_print(cmd_ctx, "use of EmbeddedICE dbgrq instead of breakpoint for target halt %s", (arm7_9->use_dbgrq) ? "enabled" : "disabled");
2675 int handle_arm7_9_fast_memory_access_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2677 target_t *target = get_current_target(cmd_ctx);
2678 armv4_5_common_t *armv4_5;
2679 arm7_9_common_t *arm7_9;
2681 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2683 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2689 if (strcmp("enable", args[0]) == 0)
2691 arm7_9->fast_memory_access = 1;
2693 else if (strcmp("disable", args[0]) == 0)
2695 arm7_9->fast_memory_access = 0;
2699 command_print(cmd_ctx, "usage: arm7_9 fast_memory_access <enable|disable>");
2703 command_print(cmd_ctx, "fast memory access is %s", (arm7_9->fast_memory_access) ? "enabled" : "disabled");
2708 int handle_arm7_9_dcc_downloads_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2710 target_t *target = get_current_target(cmd_ctx);
2711 armv4_5_common_t *armv4_5;
2712 arm7_9_common_t *arm7_9;
2714 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
2716 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
2722 if (strcmp("enable", args[0]) == 0)
2724 arm7_9->dcc_downloads = 1;
2726 else if (strcmp("disable", args[0]) == 0)
2728 arm7_9->dcc_downloads = 0;
2732 command_print(cmd_ctx, "usage: arm7_9 dcc_downloads <enable|disable>");
2736 command_print(cmd_ctx, "dcc downloads are %s", (arm7_9->dcc_downloads) ? "enabled" : "disabled");
2741 int arm7_9_init_arch_info(target_t *target, arm7_9_common_t *arm7_9)
2743 armv4_5_common_t *armv4_5 = &arm7_9->armv4_5_common;
2745 arm7_9->common_magic = ARM7_9_COMMON_MAGIC;
2747 arm_jtag_setup_connection(&arm7_9->jtag_info);
2748 arm7_9->wp_available = 2;
2749 arm7_9->wp0_used = 0;
2750 arm7_9->wp1_used = 0;
2751 arm7_9->force_hw_bkpts = 0;
2752 arm7_9->use_dbgrq = 0;
2754 arm7_9->etm_ctx = NULL;
2755 arm7_9->has_single_step = 0;
2756 arm7_9->has_monitor_mode = 0;
2757 arm7_9->has_vector_catch = 0;
2759 arm7_9->debug_entry_from_reset = 0;
2761 arm7_9->dcc_working_area = NULL;
2763 arm7_9->fast_memory_access = fast_and_dangerous;
2764 arm7_9->dcc_downloads = fast_and_dangerous;
2766 arm7_9->need_bypass_before_restart = 0;
2768 armv4_5->arch_info = arm7_9;
2769 armv4_5->read_core_reg = arm7_9_read_core_reg;
2770 armv4_5->write_core_reg = arm7_9_write_core_reg;
2771 armv4_5->full_context = arm7_9_full_context;
2773 armv4_5_init_arch_info(target, armv4_5);
2775 target_register_timer_callback(arm7_9_handle_target_request, 1, 1, target);