bool arm_cpu_exec_interrupt(CPUState *cs, int interrupt_request) { CPUClass *cc = CPU_GET_CLASS(cs); CPUARMState *env = cs->env_ptr; uint32_t cur_el = arm_current_el(env); bool secure = arm_is_secure(env); uint32_t target_el; uint32_t excp_idx; bool ret = false; if (interrupt_request & CPU_INTERRUPT_FIQ) { excp_idx = EXCP_FIQ; target_el = arm_phys_excp_target_el(cs, excp_idx, cur_el, secure); if (arm_excp_unmasked(cs, excp_idx, target_el)) { cs->exception_index = excp_idx; env->exception.target_el = target_el; cc->do_interrupt(cs); ret = true; } } if (interrupt_request & CPU_INTERRUPT_HARD) { excp_idx = EXCP_IRQ; target_el = arm_phys_excp_target_el(cs, excp_idx, cur_el, secure); if (arm_excp_unmasked(cs, excp_idx, target_el)) { cs->exception_index = excp_idx; env->exception.target_el = target_el; cc->do_interrupt(cs); ret = true; } } if (interrupt_request & CPU_INTERRUPT_VIRQ) { excp_idx = EXCP_VIRQ; target_el = 1; if (arm_excp_unmasked(cs, excp_idx, target_el)) { cs->exception_index = excp_idx; env->exception.target_el = target_el; cc->do_interrupt(cs); ret = true; } } if (interrupt_request & CPU_INTERRUPT_VFIQ) { excp_idx = EXCP_VFIQ; target_el = 1; if (arm_excp_unmasked(cs, excp_idx, target_el)) { cs->exception_index = excp_idx; env->exception.target_el = target_el; cc->do_interrupt(cs); ret = true; } } return ret; }
int aarch64_cpu_gdb_read_register(CPUState *cs, uint8_t *mem_buf, int n) { ARMCPU *cpu = ARM_CPU(cs); CPUARMState *env = &cpu->env; #ifndef CONFIG_USER_ONLY if (!is_a64(env)) { map_a32_to_a64_regs(env); } #endif if (n < 31) { /* Core integer register. */ return gdb_get_reg64(mem_buf, env->xregs[n]); } switch (n) { case 31: { unsigned int cur_el = arm_current_el(env); uint64_t sp; aarch64_save_sp(env, cur_el); switch (env->debug_ctx) { case DEBUG_EL0: sp = env->sp_el[0]; break; case DEBUG_EL1: sp = env->sp_el[1]; break; case DEBUG_EL2: sp = env->sp_el[2]; break; case DEBUG_EL3: sp = env->sp_el[3]; break; default: sp = env->xregs[31]; break; } return gdb_get_reg64(mem_buf, sp); } case 32: return gdb_get_reg64(mem_buf, env->pc); case 33: return gdb_get_reg32(mem_buf, pstate_read(env)); } /* Unknown register. */ return 0; }
int arm_set_cpu_on(uint64_t cpuid, uint64_t entry, uint64_t context_id, uint32_t target_el, bool target_aa64) { CPUState *target_cpu_state; ARMCPU *target_cpu; DPRINTF("cpu %" PRId64 " (EL %d, %s) @ 0x%" PRIx64 " with R0 = 0x%" PRIx64 "\n", cpuid, target_el, target_aa64 ? "aarch64" : "aarch32", entry, context_id); /* requested EL level need to be in the 1 to 3 range */ assert((target_el > 0) && (target_el < 4)); if (target_aa64 && (entry & 3)) { /* * if we are booting in AArch64 mode then "entry" needs to be 4 bytes * aligned. */ return QEMU_ARM_POWERCTL_INVALID_PARAM; } /* Retrieve the cpu we are powering up */ target_cpu_state = arm_get_cpu_by_id(cpuid); if (!target_cpu_state) { /* The cpu was not found */ return QEMU_ARM_POWERCTL_INVALID_PARAM; } target_cpu = ARM_CPU(target_cpu_state); if (!target_cpu->powered_off) { qemu_log_mask(LOG_GUEST_ERROR, "[ARM]%s: CPU %" PRId64 " is already on\n", __func__, cpuid); return QEMU_ARM_POWERCTL_ALREADY_ON; } /* * The newly brought CPU is requested to enter the exception level * "target_el" and be in the requested mode (AArch64 or AArch32). */ if (((target_el == 3) && !arm_feature(&target_cpu->env, ARM_FEATURE_EL3)) || ((target_el == 2) && !arm_feature(&target_cpu->env, ARM_FEATURE_EL2))) { /* * The CPU does not support requested level */ return QEMU_ARM_POWERCTL_INVALID_PARAM; } if (!target_aa64 && arm_feature(&target_cpu->env, ARM_FEATURE_AARCH64)) { /* * For now we don't support booting an AArch64 CPU in AArch32 mode * TODO: We should add this support later */ qemu_log_mask(LOG_UNIMP, "[ARM]%s: Starting AArch64 CPU %" PRId64 " in AArch32 mode is not supported yet\n", __func__, cpuid); return QEMU_ARM_POWERCTL_INVALID_PARAM; } /* Initialize the cpu we are turning on */ cpu_reset(target_cpu_state); target_cpu->powered_off = false; target_cpu_state->halted = 0; if (target_aa64) { if ((target_el < 3) && arm_feature(&target_cpu->env, ARM_FEATURE_EL3)) { /* * As target mode is AArch64, we need to set lower * exception level (the requested level 2) to AArch64 */ target_cpu->env.cp15.scr_el3 |= SCR_RW; } if ((target_el < 2) && arm_feature(&target_cpu->env, ARM_FEATURE_EL2)) { /* * As target mode is AArch64, we need to set lower * exception level (the requested level 1) to AArch64 */ target_cpu->env.cp15.hcr_el2 |= HCR_RW; } target_cpu->env.pstate = aarch64_pstate_mode(target_el, true); } else { /* We are requested to boot in AArch32 mode */ static uint32_t mode_for_el[] = { 0, ARM_CPU_MODE_SVC, ARM_CPU_MODE_HYP, ARM_CPU_MODE_SVC }; cpsr_write(&target_cpu->env, mode_for_el[target_el], CPSR_M, CPSRWriteRaw); } if (target_el == 3) { /* Processor is in secure mode */ target_cpu->env.cp15.scr_el3 &= ~SCR_NS; } else { /* Processor is not in secure mode */ target_cpu->env.cp15.scr_el3 |= SCR_NS; } /* We check if the started CPU is now at the correct level */ assert(target_el == arm_current_el(&target_cpu->env)); if (target_aa64) { target_cpu->env.xregs[0] = context_id; target_cpu->env.thumb = false; } else { target_cpu->env.regs[0] = context_id; target_cpu->env.thumb = entry & 1; entry &= 0xfffffffe; } /* Start the new CPU at the requested address */ cpu_set_pc(target_cpu_state, entry); /* We are good to go */ return QEMU_ARM_POWERCTL_RET_SUCCESS; }
int aarch64_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n) { ARMCPU *cpu = ARM_CPU(cs); CPUARMState *env = &cpu->env; uint64_t tmp; int rlen = 0; #ifndef CONFIG_USER_ONLY if (!is_a64(env)) { map_a32_to_a64_regs(env); } #endif tmp = ldq_p(mem_buf); if (n < 31) { /* Core integer register. */ env->xregs[n] = tmp; rlen = 8; } switch (n) { case 31: { unsigned int cur_el = arm_current_el(env); aarch64_save_sp(env, cur_el); switch (env->debug_ctx) { case DEBUG_EL0: env->sp_el[0] = tmp; break; case DEBUG_EL1: env->sp_el[1] = tmp; break; case DEBUG_EL2: env->sp_el[2] = tmp; break; case DEBUG_EL3: env->sp_el[3] = tmp; break; default: env->xregs[31] = tmp; break; } aarch64_restore_sp(env, cur_el); rlen = 8; break; } case 32: env->pc = tmp; rlen = 8; break; case 33: /* CPSR */ pstate_write(env, tmp); rlen = 4; break; } #ifndef CONFIG_USER_ONLY if (!is_a64(env)) { map_a64_to_a32_regs(env); } #endif /* Unknown register. */ return rlen; }