X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Ftarget%2Farm11.c;h=85d45b009185a20b20c99df7b0f6911b463d1a85;hb=f0c0256b1f05a04a58d857e9d865a0be0dd1680d;hp=970738c9ed2dbab3e0d6eb398b638c8195246c41;hpb=bb77e5d32f67870e304011fc6e9d47257569f323;p=openocd.git diff --git a/src/target/arm11.c b/src/target/arm11.c index 970738c9ed..85d45b0091 100644 --- a/src/target/arm11.c +++ b/src/target/arm11.c @@ -6,6 +6,8 @@ * * * Copyright (C) 2008 Georg Acher * * * + * Copyright (C) 2009 David Brownell * + * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * @@ -42,15 +44,6 @@ #endif -/* FIXME none of these flags should be global to all ARM11 cores! - * Most of them shouldn't exist at all, once the code works... - */ -static bool arm11_config_memwrite_burst = true; -static bool arm11_config_memwrite_error_fatal = true; -static uint32_t arm11_vcr = 0; -static bool arm11_config_step_irq_enable = false; -static bool arm11_config_hardware_step = false; - static int arm11_step(struct target *target, int current, uint32_t address, int handle_breakpoints); @@ -62,14 +55,14 @@ static int arm11_step(struct target *target, int current, static int arm11_check_init(struct arm11_common *arm11) { CHECK_RETVAL(arm11_read_DSCR(arm11)); - LOG_DEBUG("DSCR %08x", (unsigned) arm11->dscr); if (!(arm11->dscr & DSCR_HALT_DBG_MODE)) { + LOG_DEBUG("DSCR %08x", (unsigned) arm11->dscr); LOG_DEBUG("Bringing target into debug mode"); arm11->dscr |= DSCR_HALT_DBG_MODE; - arm11_write_DSCR(arm11, arm11->dscr); + CHECK_RETVAL(arm11_write_DSCR(arm11, arm11->dscr)); /* add further reset initialization here */ @@ -92,7 +85,7 @@ static int arm11_check_init(struct arm11_common *arm11) arm11->arm.target->debug_reason = DBG_REASON_NOTHALTED; } - arm11_sc7_clear_vbw(arm11); + CHECK_RETVAL(arm11_sc7_clear_vbw(arm11)); } return ERROR_OK; @@ -130,7 +123,7 @@ static int arm11_debug_entry(struct arm11_common *arm11) arm11_setup_field(arm11, 1, NULL, NULL, chain5_fields + 1); arm11_setup_field(arm11, 1, NULL, NULL, chain5_fields + 2); - arm11_add_dr_scan_vc(ARRAY_SIZE(chain5_fields), chain5_fields, TAP_DRPAUSE); + arm11_add_dr_scan_vc(arm11->arm.target->tap, ARRAY_SIZE(chain5_fields), chain5_fields, TAP_DRPAUSE); } @@ -140,7 +133,7 @@ static int arm11_debug_entry(struct arm11_common *arm11) * but not to issue ITRs(?). The ARMv7 arch spec says it's required * for executing instructions via ITR. */ - arm11_write_DSCR(arm11, DSCR_ITR_EN | arm11->dscr); + CHECK_RETVAL(arm11_write_DSCR(arm11, DSCR_ITR_EN | arm11->dscr)); /* From the spec: @@ -298,14 +291,14 @@ static int arm11_leave_debug_state(struct arm11_common *arm11, bool bpwp) /* restore CPSR, PC, and R0 ... after flushing any modified * registers. */ - retval = arm_dpm_write_dirty_registers(&arm11->dpm, bpwp); + CHECK_RETVAL(arm_dpm_write_dirty_registers(&arm11->dpm, bpwp)); - retval = arm11_bpwp_flush(arm11); + CHECK_RETVAL(arm11_bpwp_flush(arm11)); register_cache_invalidate(arm11->arm.core_cache); /* restore DSCR */ - arm11_write_DSCR(arm11, arm11->dscr); + CHECK_RETVAL(arm11_write_DSCR(arm11, arm11->dscr)); /* maybe restore rDTR */ if (arm11->is_rdtr_saved) @@ -324,7 +317,7 @@ static int arm11_leave_debug_state(struct arm11_common *arm11, bool bpwp) arm11_setup_field(arm11, 1, &Ready, NULL, chain5_fields + 1); arm11_setup_field(arm11, 1, &Valid, NULL, chain5_fields + 2); - arm11_add_dr_scan_vc(ARRAY_SIZE(chain5_fields), chain5_fields, TAP_DRPAUSE); + arm11_add_dr_scan_vc(arm11->arm.target->tap, ARRAY_SIZE(chain5_fields), chain5_fields, TAP_DRPAUSE); } /* now processor is ready to RESTART */ @@ -446,7 +439,7 @@ static int arm11_halt(struct target *target) enum target_state old_state = target->state; - arm11_debug_entry(arm11); + CHECK_RETVAL(arm11_debug_entry(arm11)); CHECK_RETVAL( target_call_event_callbacks(target, @@ -458,7 +451,7 @@ static int arm11_halt(struct target *target) static uint32_t arm11_nextpc(struct arm11_common *arm11, int current, uint32_t address) { - void *value = arm11->arm.core_cache->reg_list[15].value; + void *value = arm11->arm.pc->value; if (!current) buf_set_u32(value, 0, 32, address); @@ -491,17 +484,14 @@ static int arm11_resume(struct target *target, int current, LOG_DEBUG("RESUME PC %08" PRIx32 "%s", address, !current ? "!" : ""); /* clear breakpoints/watchpoints and VCR*/ - arm11_sc7_clear_vbw(arm11); + CHECK_RETVAL(arm11_sc7_clear_vbw(arm11)); if (!debug_execution) target_free_all_working_areas(target); - /* Set up breakpoints */ - if (handle_breakpoints) - { - /* check if one matches PC and step over it if necessary */ - - struct breakpoint * bp; + /* Should we skip over breakpoints matching the PC? */ + if (handle_breakpoints) { + struct breakpoint *bp; for (bp = target->breakpoints; bp; bp = bp->next) { @@ -512,9 +502,11 @@ static int arm11_resume(struct target *target, int current, break; } } + } - /* set all breakpoints */ - + /* activate all breakpoints */ + if (true) { + struct breakpoint *bp; unsigned brp_num = 0; for (bp = target->breakpoints; bp; bp = bp->next) @@ -528,7 +520,7 @@ static int arm11_resume(struct target *target, int current, brp[1].address = ARM11_SC7_BCR0 + brp_num; brp[1].value = 0x1 | (3 << 1) | (0x0F << 5) | (0 << 14) | (0 << 16) | (0 << 20) | (0 << 21); - arm11_sc7_run(arm11, brp, ARRAY_SIZE(brp)); + CHECK_RETVAL(arm11_sc7_run(arm11, brp, ARRAY_SIZE(brp))); LOG_DEBUG("Add BP %d at %08" PRIx32, brp_num, bp->address); @@ -536,11 +528,12 @@ static int arm11_resume(struct target *target, int current, brp_num++; } - if (arm11_vcr) - arm11_sc7_set_vcr(arm11, arm11_vcr); + if (arm11->vcr) + CHECK_RETVAL(arm11_sc7_set_vcr(arm11, arm11->vcr)); } - arm11_leave_debug_state(arm11, handle_breakpoints); + /* activate all watchpoints and breakpoints */ + CHECK_RETVAL(arm11_leave_debug_state(arm11, true)); arm11_add_IR(arm11, ARM11_RESTART, TAP_IDLE); @@ -644,7 +637,7 @@ static int arm11_step(struct target *target, int current, brp[1].write = 1; brp[1].address = ARM11_SC7_BCR0; - if (arm11_config_hardware_step) + if (arm11->hardware_step) { /* Hardware single stepping ("instruction address * mismatch") is used if enabled. It's not quite @@ -688,7 +681,7 @@ static int arm11_step(struct target *target, int current, /* resume */ - if (arm11_config_step_irq_enable) + if (arm11->step_irq_enable) /* this disable should be redundant ... */ arm11->dscr &= ~DSCR_INT_DIS; else @@ -732,7 +725,7 @@ static int arm11_step(struct target *target, int current, } /* clear breakpoint */ - arm11_sc7_clear_vbw(arm11); + CHECK_RETVAL(arm11_sc7_clear_vbw(arm11)); /* save state */ CHECK_RETVAL(arm11_debug_entry(arm11)); @@ -754,8 +747,8 @@ static int arm11_assert_reset(struct target *target) struct arm11_common *arm11 = target_to_arm11(target); /* optionally catch reset vector */ - if (target->reset_halt && !(arm11_vcr & 1)) - arm11_sc7_set_vcr(arm11, arm11_vcr | 1); + if (target->reset_halt && !(arm11->vcr & 1)) + CHECK_RETVAL(arm11_sc7_set_vcr(arm11, arm11->vcr | 1)); /* Issue some kind of warm reset. */ if (target_has_event_action(target, TARGET_EVENT_RESET_ASSERT)) { @@ -802,7 +795,7 @@ static int arm11_deassert_reset(struct target *target) */ jtag_add_tlr(); - retval = arm11_poll(target); + CHECK_RETVAL(arm11_poll(target)); if (target->reset_halt) { if (target->state != TARGET_HALTED) { @@ -814,8 +807,8 @@ static int arm11_deassert_reset(struct target *target) } /* maybe restore vector catch config */ - if (target->reset_halt && !(arm11_vcr & 1)) - arm11_sc7_set_vcr(arm11, arm11_vcr); + if (target->reset_halt && !(arm11->vcr & 1)) + CHECK_RETVAL(arm11_sc7_set_vcr(arm11, arm11->vcr)); return ERROR_OK; } @@ -870,12 +863,12 @@ static int arm11_read_memory_inner(struct target *target, { /* ldrb r1, [r0], #1 */ /* ldrb r1, [r0] */ - arm11_run_instr_no_data1(arm11, - !arm11_config_memrw_no_increment ? 0xe4d01001 : 0xe5d01000); + CHECK_RETVAL(arm11_run_instr_no_data1(arm11, + !arm11_config_memrw_no_increment ? 0xe4d01001 : 0xe5d01000)); uint32_t res; /* MCR p14,0,R1,c0,c5,0 */ - arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1); + CHECK_RETVAL(arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1)); *buffer++ = res; } @@ -889,13 +882,13 @@ static int arm11_read_memory_inner(struct target *target, for (size_t i = 0; i < count; i++) { /* ldrh r1, [r0], #2 */ - arm11_run_instr_no_data1(arm11, - !arm11_config_memrw_no_increment ? 0xe0d010b2 : 0xe1d010b0); + CHECK_RETVAL(arm11_run_instr_no_data1(arm11, + !arm11_config_memrw_no_increment ? 0xe0d010b2 : 0xe1d010b0)); uint32_t res; /* MCR p14,0,R1,c0,c5,0 */ - arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1); + CHECK_RETVAL(arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1)); uint16_t svalue = res; memcpy(buffer + i * sizeof(uint16_t), &svalue, sizeof(uint16_t)); @@ -912,7 +905,7 @@ static int arm11_read_memory_inner(struct target *target, /* LDC p14,c5,[R0],#4 */ /* LDC p14,c5,[R0] */ - arm11_run_instr_data_from_core(arm11, instr, words, count); + CHECK_RETVAL(arm11_run_instr_data_from_core(arm11, instr, words, count)); break; } } @@ -951,6 +944,7 @@ static int arm11_write_memory_inner(struct target *target, if (retval != ERROR_OK) return retval; + /* load r0 with buffer address */ /* MRC p14,0,r0,c0,c5,0 */ retval = arm11_run_instr_data_to_core1(arm11, 0xee100e15, address); if (retval != ERROR_OK) @@ -963,7 +957,7 @@ static int arm11_write_memory_inner(struct target *target, * now exercise both burst and non-burst code paths with the * default settings, increasing code coverage. */ - bool burst = arm11_config_memwrite_burst && (count > 1); + bool burst = arm11->memwrite_burst && (count > 1); switch (size) { @@ -973,11 +967,13 @@ static int arm11_write_memory_inner(struct target *target, for (size_t i = 0; i < count; i++) { + /* load r1 from DCC with byte data */ /* MRC p14,0,r1,c0,c5,0 */ retval = arm11_run_instr_data_to_core1(arm11, 0xee101e15, *buffer++); if (retval != ERROR_OK) return retval; + /* write r1 to memory */ /* strb r1, [r0], #1 */ /* strb r1, [r0] */ retval = arm11_run_instr_no_data1(arm11, @@ -1000,11 +996,13 @@ static int arm11_write_memory_inner(struct target *target, uint16_t value; memcpy(&value, buffer + i * sizeof(uint16_t), sizeof(uint16_t)); + /* load r1 from DCC with halfword data */ /* MRC p14,0,r1,c0,c5,0 */ retval = arm11_run_instr_data_to_core1(arm11, 0xee101e15, value); if (retval != ERROR_OK) return retval; + /* write r1 to memory */ /* strh r1, [r0], #2 */ /* strh r1, [r0] */ retval = arm11_run_instr_no_data1(arm11, @@ -1019,6 +1017,7 @@ static int arm11_write_memory_inner(struct target *target, } case 4: { + /* stream word data through DCC directly to memory */ /* increment: STC p14,c5,[R0],#4 */ /* no increment: STC p14,c5,[R0]*/ uint32_t instr = !no_increment ? 0xeca05e01 : 0xed805e00; @@ -1063,7 +1062,7 @@ static int arm11_write_memory_inner(struct target *target, if (burst) LOG_ERROR("use 'arm11 memwrite burst disable' to disable fast burst mode"); - if (arm11_config_memwrite_error_fatal) + if (arm11->memwrite_error_fatal) return ERROR_FAIL; } } @@ -1163,6 +1162,9 @@ static int arm11_target_create(struct target *target, Jim_Interp *interp) arm11->jtag_info.cur_scan_chain = ~0; /* invalid/unknown */ arm11->jtag_info.intest_instr = ARM11_INTEST; + arm11->memwrite_burst = true; + arm11->memwrite_error_fatal = true; + return ERROR_OK; } @@ -1192,7 +1194,7 @@ static int arm11_examine(struct target *target) arm11_setup_field(arm11, 32, NULL, &device_id, &idcode_field); - arm11_add_dr_scan_vc(1, &idcode_field, TAP_DRPAUSE); + arm11_add_dr_scan_vc(arm11->arm.target->tap, 1, &idcode_field, TAP_DRPAUSE); /* check DIDR */ @@ -1205,24 +1207,29 @@ static int arm11_examine(struct target *target) arm11_setup_field(arm11, 32, NULL, &didr, chain0_fields + 0); arm11_setup_field(arm11, 8, NULL, &implementor, chain0_fields + 1); - arm11_add_dr_scan_vc(ARRAY_SIZE(chain0_fields), chain0_fields, TAP_IDLE); + arm11_add_dr_scan_vc(arm11->arm.target->tap, ARRAY_SIZE(chain0_fields), chain0_fields, TAP_IDLE); CHECK_RETVAL(jtag_execute_queue()); - switch (device_id & 0x0FFFF000) + /* assume the manufacturer id is ok; check the part # */ + switch ((device_id >> 12) & 0xFFFF) { - case 0x07B36000: + case 0x7B36: type = "ARM1136"; break; - case 0x07B56000: + case 0x7B37: + type = "ARM11 MPCore"; + break; + case 0x7B56: type = "ARM1156"; break; - case 0x07B76000: + case 0x7B76: arm11->arm.core_type = ARM_MODE_MON; + /* NOTE: could default arm11->hardware_step to true */ type = "ARM1176"; break; default: - LOG_ERROR("'target arm11' expects IDCODE 0x*7B*7****"); + LOG_ERROR("unexpected ARM11 ID code"); return ERROR_FAIL; } LOG_INFO("found %s", type); @@ -1258,14 +1265,14 @@ static int arm11_examine(struct target *target) * want to know if this core supports Secure Monitor mode. */ if (!target_was_examined(target)) - retval = arm11_dpm_init(arm11, didr); + CHECK_RETVAL(arm11_dpm_init(arm11, didr)); /* ETM on ARM11 still uses original scanchain 6 access mode */ if (arm11->arm.etm && !target_was_examined(target)) { *register_get_last_cache_p(&target->reg_cache) = etm_build_reg_cache(target, &arm11->jtag_info, arm11->arm.etm); - retval = etm_setup(target); + CHECK_RETVAL(etm_setup(target)); } target_set_examined(target); @@ -1274,55 +1281,61 @@ static int arm11_examine(struct target *target) } -/* FIXME all these BOOL_WRAPPER things should be modifying - * per-instance state, not shared state; ditto the vector - * catch register support. Scan chains with multiple cores - * should be able to say "work with this core like this, - * that core like that". Example, ARM11 MPCore ... - */ - #define ARM11_BOOL_WRAPPER(name, print_name) \ - COMMAND_HANDLER(arm11_handle_bool_##name) \ - { \ - return CALL_COMMAND_HANDLER(handle_command_parse_bool, \ - &arm11_config_##name, print_name); \ - } + COMMAND_HANDLER(arm11_handle_bool_##name) \ + { \ + struct target *target = get_current_target(CMD_CTX); \ + struct arm11_common *arm11 = target_to_arm11(target); \ + \ + return CALL_COMMAND_HANDLER(handle_command_parse_bool, \ + &arm11->name, print_name); \ + } ARM11_BOOL_WRAPPER(memwrite_burst, "memory write burst mode") ARM11_BOOL_WRAPPER(memwrite_error_fatal, "fatal error mode for memory writes") ARM11_BOOL_WRAPPER(step_irq_enable, "IRQs while stepping") ARM11_BOOL_WRAPPER(hardware_step, "hardware single step") +/* REVISIT handle the VCR bits like other ARMs: use symbols for + * input and output values. + */ + COMMAND_HANDLER(arm11_handle_vcr) { + struct target *target = get_current_target(CMD_CTX); + struct arm11_common *arm11 = target_to_arm11(target); + switch (CMD_ARGC) { case 0: break; case 1: - COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], arm11_vcr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], arm11->vcr); break; default: return ERROR_COMMAND_SYNTAX_ERROR; } - LOG_INFO("VCR 0x%08" PRIx32 "", arm11_vcr); + LOG_INFO("VCR 0x%08" PRIx32 "", arm11->vcr); return ERROR_OK; } static const struct command_registration arm11_mw_command_handlers[] = { { .name = "burst", - .handler = &arm11_handle_bool_memwrite_burst, + .handler = arm11_handle_bool_memwrite_burst, .mode = COMMAND_ANY, - .help = "Enable/Disable potentially risky fast burst mode" - " (default: enabled)", + .help = "Display or modify flag controlling potentially " + "risky fast burst mode (default: enabled)", + .usage = "['enable'|'disable']", }, { .name = "error_fatal", - .handler = &arm11_handle_bool_memwrite_error_fatal, + .handler = arm11_handle_bool_memwrite_error_fatal, .mode = COMMAND_ANY, - .help = "Terminate program if transfer error was found" + .help = "Display or modify flag controlling transfer " + "termination on transfer errors" " (default: enabled)", + .usage = "['enable'|'disable']", }, COMMAND_REGISTRATION_DONE }; @@ -1332,11 +1345,11 @@ static const struct command_registration arm11_any_command_handlers[] = { * simulate + breakpoint implementation is broken. * TEMPORARY! NOT DOCUMENTED! */ .name = "hardware_step", - .handler = &arm11_handle_bool_hardware_step, + .handler = arm11_handle_bool_hardware_step, .mode = COMMAND_ANY, .help = "DEBUG ONLY - Hardware single stepping" " (default: disabled)", - .usage = "(enable|disable)", + .usage = "['enable'|'disable']", }, { .name = "memwrite", @@ -1346,19 +1359,22 @@ static const struct command_registration arm11_any_command_handlers[] = { }, { .name = "step_irq_enable", - .handler = &arm11_handle_bool_step_irq_enable, + .handler = arm11_handle_bool_step_irq_enable, .mode = COMMAND_ANY, - .help = "Enable interrupts while stepping" - " (default: disabled)", + .help = "Display or modify flag controlling interrupt " + "enable while stepping (default: disabled)", + .usage = "['enable'|'disable']", }, { .name = "vcr", - .handler = &arm11_handle_vcr, + .handler = arm11_handle_vcr, .mode = COMMAND_ANY, - .help = "Control (Interrupt) Vector Catch Register", + .help = "Display or modify Vector Catch Register", + .usage = "[value]", }, COMMAND_REGISTRATION_DONE }; + static const struct command_registration arm11_command_handlers[] = { { .chain = arm_command_handlers,