2012-03-29 08:50:31 +04:00
|
|
|
/*
|
|
|
|
* QEMU ARM CPU
|
|
|
|
*
|
|
|
|
* Copyright (c) 2012 SUSE LINUX Products GmbH
|
|
|
|
*
|
|
|
|
* 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 (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, see
|
|
|
|
* <http://www.gnu.org/licenses/gpl-2.0.html>
|
|
|
|
*/
|
|
|
|
|
2015-12-07 19:23:44 +03:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 11:01:28 +03:00
|
|
|
#include "qapi/error.h"
|
2012-04-20 11:39:14 +04:00
|
|
|
#include "cpu.h"
|
2014-04-15 22:18:37 +04:00
|
|
|
#include "internals.h"
|
2012-03-29 08:50:31 +04:00
|
|
|
#include "qemu-common.h"
|
2013-11-22 21:17:13 +04:00
|
|
|
#include "hw/qdev-properties.h"
|
2012-04-20 21:58:36 +04:00
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
#include "hw/loader.h"
|
|
|
|
#endif
|
2013-08-20 17:54:28 +04:00
|
|
|
#include "hw/arm/arm.h"
|
2012-12-17 21:20:04 +04:00
|
|
|
#include "sysemu/sysemu.h"
|
2013-08-20 17:54:28 +04:00
|
|
|
#include "sysemu/kvm.h"
|
2013-03-20 16:11:56 +04:00
|
|
|
#include "kvm_arm.h"
|
2012-03-29 08:50:31 +04:00
|
|
|
|
2013-06-21 21:09:18 +04:00
|
|
|
static void arm_cpu_set_pc(CPUState *cs, vaddr value)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
|
|
|
|
|
|
cpu->env.regs[15] = value;
|
|
|
|
}
|
|
|
|
|
2013-08-25 20:53:55 +04:00
|
|
|
static bool arm_cpu_has_work(CPUState *cs)
|
|
|
|
{
|
2014-10-24 15:19:12 +04:00
|
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
|
|
|
|
|
|
return !cpu->powered_off
|
|
|
|
&& cs->interrupt_request &
|
2014-09-29 21:48:51 +04:00
|
|
|
(CPU_INTERRUPT_FIQ | CPU_INTERRUPT_HARD
|
|
|
|
| CPU_INTERRUPT_VFIQ | CPU_INTERRUPT_VIRQ
|
|
|
|
| CPU_INTERRUPT_EXITTB);
|
2013-08-25 20:53:55 +04:00
|
|
|
}
|
|
|
|
|
2012-06-20 15:57:06 +04:00
|
|
|
static void cp_reg_reset(gpointer key, gpointer value, gpointer opaque)
|
|
|
|
{
|
|
|
|
/* Reset a single ARMCPRegInfo register */
|
|
|
|
ARMCPRegInfo *ri = value;
|
|
|
|
ARMCPU *cpu = opaque;
|
|
|
|
|
2015-06-19 16:17:44 +03:00
|
|
|
if (ri->type & (ARM_CP_SPECIAL | ARM_CP_ALIAS)) {
|
2012-06-20 15:57:06 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ri->resetfn) {
|
|
|
|
ri->resetfn(&cpu->env, ri);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* A zero offset is never possible as it would be regs[0]
|
|
|
|
* so we use it to indicate that reset is being handled elsewhere.
|
|
|
|
* This is basically only used for fields in non-core coprocessors
|
|
|
|
* (like the pxa2xx ones).
|
|
|
|
*/
|
|
|
|
if (!ri->fieldoffset) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-02-26 21:20:01 +04:00
|
|
|
if (cpreg_field_is_64bit(ri)) {
|
2012-06-20 15:57:06 +04:00
|
|
|
CPREG_FIELD64(&cpu->env, ri) = ri->resetvalue;
|
|
|
|
} else {
|
|
|
|
CPREG_FIELD32(&cpu->env, ri) = ri->resetvalue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-13 13:26:21 +03:00
|
|
|
static void cp_reg_check_reset(gpointer key, gpointer value, gpointer opaque)
|
|
|
|
{
|
|
|
|
/* Purely an assertion check: we've already done reset once,
|
|
|
|
* so now check that running the reset for the cpreg doesn't
|
|
|
|
* change its value. This traps bugs where two different cpregs
|
|
|
|
* both try to reset the same state field but to different values.
|
|
|
|
*/
|
|
|
|
ARMCPRegInfo *ri = value;
|
|
|
|
ARMCPU *cpu = opaque;
|
|
|
|
uint64_t oldvalue, newvalue;
|
|
|
|
|
|
|
|
if (ri->type & (ARM_CP_SPECIAL | ARM_CP_ALIAS | ARM_CP_NO_RAW)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
oldvalue = read_raw_cp_reg(&cpu->env, ri);
|
|
|
|
cp_reg_reset(key, value, opaque);
|
|
|
|
newvalue = read_raw_cp_reg(&cpu->env, ri);
|
|
|
|
assert(oldvalue == newvalue);
|
|
|
|
}
|
|
|
|
|
2012-03-29 08:50:31 +04:00
|
|
|
/* CPUClass::reset() */
|
|
|
|
static void arm_cpu_reset(CPUState *s)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(s);
|
|
|
|
ARMCPUClass *acc = ARM_CPU_GET_CLASS(cpu);
|
2012-04-20 21:58:36 +04:00
|
|
|
CPUARMState *env = &cpu->env;
|
|
|
|
|
2012-03-29 08:50:31 +04:00
|
|
|
acc->parent_reset(s);
|
|
|
|
|
2013-08-26 23:22:53 +04:00
|
|
|
memset(env, 0, offsetof(CPUARMState, features));
|
2012-06-20 15:57:06 +04:00
|
|
|
g_hash_table_foreach(cpu->cp_regs, cp_reg_reset, cpu);
|
2015-08-13 13:26:21 +03:00
|
|
|
g_hash_table_foreach(cpu->cp_regs, cp_reg_check_reset, cpu);
|
|
|
|
|
2012-04-20 21:58:36 +04:00
|
|
|
env->vfp.xregs[ARM_VFP_FPSID] = cpu->reset_fpsid;
|
|
|
|
env->vfp.xregs[ARM_VFP_MVFR0] = cpu->mvfr0;
|
|
|
|
env->vfp.xregs[ARM_VFP_MVFR1] = cpu->mvfr1;
|
2014-04-15 22:18:44 +04:00
|
|
|
env->vfp.xregs[ARM_VFP_MVFR2] = cpu->mvfr2;
|
2012-04-20 21:58:36 +04:00
|
|
|
|
2014-10-24 15:19:12 +04:00
|
|
|
cpu->powered_off = cpu->start_powered_off;
|
|
|
|
s->halted = cpu->start_powered_off;
|
|
|
|
|
2012-04-20 21:58:36 +04:00
|
|
|
if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
|
|
|
|
env->iwmmxt.cregs[ARM_IWMMXT_wCID] = 0x69051000 | 'Q';
|
|
|
|
}
|
|
|
|
|
2013-09-03 23:12:09 +04:00
|
|
|
if (arm_feature(env, ARM_FEATURE_AARCH64)) {
|
|
|
|
/* 64 bit CPUs always start in 64 bit mode */
|
|
|
|
env->aarch64 = 1;
|
2013-12-17 23:42:30 +04:00
|
|
|
#if defined(CONFIG_USER_ONLY)
|
|
|
|
env->pstate = PSTATE_MODE_EL0t;
|
2014-10-24 15:19:13 +04:00
|
|
|
/* Userspace expects access to DC ZVA, CTL_EL0 and the cache ops */
|
2014-12-11 15:07:50 +03:00
|
|
|
env->cp15.sctlr_el[1] |= SCTLR_UCT | SCTLR_UCI | SCTLR_DZE;
|
2014-04-15 22:18:39 +04:00
|
|
|
/* and to the FP/Neon instructions */
|
2015-04-26 18:49:25 +03:00
|
|
|
env->cp15.cpacr_el1 = deposit64(env->cp15.cpacr_el1, 20, 2, 3);
|
2013-12-17 23:42:30 +04:00
|
|
|
#else
|
2015-02-05 16:37:22 +03:00
|
|
|
/* Reset into the highest available EL */
|
|
|
|
if (arm_feature(env, ARM_FEATURE_EL3)) {
|
|
|
|
env->pstate = PSTATE_MODE_EL3h;
|
|
|
|
} else if (arm_feature(env, ARM_FEATURE_EL2)) {
|
|
|
|
env->pstate = PSTATE_MODE_EL2h;
|
|
|
|
} else {
|
|
|
|
env->pstate = PSTATE_MODE_EL1h;
|
|
|
|
}
|
2014-04-15 22:18:48 +04:00
|
|
|
env->pc = cpu->rvbar;
|
2014-04-15 22:18:39 +04:00
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
#if defined(CONFIG_USER_ONLY)
|
|
|
|
/* Userspace expects access to cp10 and cp11 for FP/Neon */
|
2015-04-26 18:49:25 +03:00
|
|
|
env->cp15.cpacr_el1 = deposit64(env->cp15.cpacr_el1, 20, 4, 0xf);
|
2013-12-17 23:42:30 +04:00
|
|
|
#endif
|
2013-09-03 23:12:09 +04:00
|
|
|
}
|
|
|
|
|
2012-04-20 21:58:36 +04:00
|
|
|
#if defined(CONFIG_USER_ONLY)
|
|
|
|
env->uncached_cpsr = ARM_CPU_MODE_USR;
|
|
|
|
/* For user mode we must enable access to coprocessors */
|
|
|
|
env->vfp.xregs[ARM_VFP_FPEXC] = 1 << 30;
|
|
|
|
if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
|
|
|
|
env->cp15.c15_cpar = 3;
|
|
|
|
} else if (arm_feature(env, ARM_FEATURE_XSCALE)) {
|
|
|
|
env->cp15.c15_cpar = 1;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
/* SVC mode with interrupts disabled. */
|
2014-02-26 21:20:06 +04:00
|
|
|
env->uncached_cpsr = ARM_CPU_MODE_SVC;
|
|
|
|
env->daif = PSTATE_D | PSTATE_A | PSTATE_I | PSTATE_F;
|
2012-04-20 21:58:36 +04:00
|
|
|
/* On ARMv7-M the CPSR_I is the value of the PRIMASK register, and is
|
2014-09-12 17:06:48 +04:00
|
|
|
* clear at reset. Initial SP and PC are loaded from ROM.
|
|
|
|
*/
|
2012-04-20 21:58:36 +04:00
|
|
|
if (IS_M(env)) {
|
2014-09-12 17:06:48 +04:00
|
|
|
uint32_t initial_msp; /* Loaded from 0x0 */
|
|
|
|
uint32_t initial_pc; /* Loaded from 0x4 */
|
2012-04-20 21:58:36 +04:00
|
|
|
uint8_t *rom;
|
2014-09-12 17:06:48 +04:00
|
|
|
|
2014-02-26 21:20:06 +04:00
|
|
|
env->daif &= ~PSTATE_I;
|
2012-04-20 21:58:36 +04:00
|
|
|
rom = rom_ptr(0);
|
|
|
|
if (rom) {
|
2014-09-12 17:06:48 +04:00
|
|
|
/* Address zero is covered by ROM which hasn't yet been
|
|
|
|
* copied into physical memory.
|
|
|
|
*/
|
|
|
|
initial_msp = ldl_p(rom);
|
|
|
|
initial_pc = ldl_p(rom + 4);
|
|
|
|
} else {
|
|
|
|
/* Address zero not covered by a ROM blob, or the ROM blob
|
|
|
|
* is in non-modifiable memory and this is a second reset after
|
|
|
|
* it got copied into memory. In the latter case, rom_ptr
|
|
|
|
* will return a NULL pointer and we should use ldl_phys instead.
|
|
|
|
*/
|
|
|
|
initial_msp = ldl_phys(s->as, 0);
|
|
|
|
initial_pc = ldl_phys(s->as, 4);
|
2012-04-20 21:58:36 +04:00
|
|
|
}
|
2014-09-12 17:06:48 +04:00
|
|
|
|
|
|
|
env->regs[13] = initial_msp & 0xFFFFFFFC;
|
|
|
|
env->regs[15] = initial_pc & ~1;
|
|
|
|
env->thumb = initial_pc & 1;
|
2012-04-20 21:58:36 +04:00
|
|
|
}
|
2013-12-17 23:42:29 +04:00
|
|
|
|
2014-12-11 15:07:50 +03:00
|
|
|
/* AArch32 has a hard highvec setting of 0xFFFF0000. If we are currently
|
|
|
|
* executing as AArch32 then check if highvecs are enabled and
|
|
|
|
* adjust the PC accordingly.
|
|
|
|
*/
|
|
|
|
if (A32_BANKED_CURRENT_REG_GET(env, sctlr) & SCTLR_V) {
|
2014-09-12 17:06:48 +04:00
|
|
|
env->regs[15] = 0xFFFF0000;
|
2013-12-17 23:42:29 +04:00
|
|
|
}
|
|
|
|
|
2012-04-20 21:58:36 +04:00
|
|
|
env->vfp.xregs[ARM_VFP_FPEXC] = 0;
|
|
|
|
#endif
|
|
|
|
set_flush_to_zero(1, &env->vfp.standard_fp_status);
|
|
|
|
set_flush_inputs_to_zero(1, &env->vfp.standard_fp_status);
|
|
|
|
set_default_nan_mode(1, &env->vfp.standard_fp_status);
|
|
|
|
set_float_detect_tininess(float_tininess_before_rounding,
|
|
|
|
&env->vfp.fp_status);
|
|
|
|
set_float_detect_tininess(float_tininess_before_rounding,
|
|
|
|
&env->vfp.standard_fp_status);
|
2013-09-04 04:19:44 +04:00
|
|
|
tlb_flush(s, 1);
|
2013-03-20 16:11:56 +04:00
|
|
|
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
if (kvm_enabled()) {
|
|
|
|
kvm_arm_reset_vcpu(cpu);
|
|
|
|
}
|
|
|
|
#endif
|
2014-09-12 17:06:49 +04:00
|
|
|
|
2014-09-29 21:48:46 +04:00
|
|
|
hw_breakpoint_update_all(cpu);
|
2014-09-12 17:06:49 +04:00
|
|
|
hw_watchpoint_update_all(cpu);
|
2012-03-29 08:50:31 +04:00
|
|
|
}
|
|
|
|
|
2014-09-13 20:45:25 +04:00
|
|
|
bool arm_cpu_exec_interrupt(CPUState *cs, int interrupt_request)
|
|
|
|
{
|
|
|
|
CPUClass *cc = CPU_GET_CLASS(cs);
|
2015-05-29 13:28:51 +03:00
|
|
|
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;
|
2014-09-13 20:45:25 +04:00
|
|
|
bool ret = false;
|
|
|
|
|
2015-05-29 13:28:51 +03:00
|
|
|
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;
|
|
|
|
}
|
2014-09-13 20:45:25 +04:00
|
|
|
}
|
2015-05-29 13:28:51 +03:00
|
|
|
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;
|
|
|
|
}
|
2014-09-13 20:45:25 +04:00
|
|
|
}
|
2015-05-29 13:28:51 +03:00
|
|
|
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;
|
|
|
|
}
|
2014-09-29 21:48:51 +04:00
|
|
|
}
|
2015-05-29 13:28:51 +03:00
|
|
|
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;
|
|
|
|
}
|
2014-09-29 21:48:51 +04:00
|
|
|
}
|
2014-09-13 20:45:25 +04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-30 18:48:51 +03:00
|
|
|
#if !defined(CONFIG_USER_ONLY) || !defined(TARGET_AARCH64)
|
|
|
|
static bool arm_v7m_cpu_exec_interrupt(CPUState *cs, int interrupt_request)
|
|
|
|
{
|
|
|
|
CPUClass *cc = CPU_GET_CLASS(cs);
|
|
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
|
|
CPUARMState *env = &cpu->env;
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
|
|
|
|
if (interrupt_request & CPU_INTERRUPT_FIQ
|
|
|
|
&& !(env->daif & PSTATE_F)) {
|
|
|
|
cs->exception_index = EXCP_FIQ;
|
|
|
|
cc->do_interrupt(cs);
|
|
|
|
ret = true;
|
|
|
|
}
|
|
|
|
/* ARMv7-M interrupt return works by loading a magic value
|
|
|
|
* into the PC. On real hardware the load causes the
|
|
|
|
* return to occur. The qemu implementation performs the
|
|
|
|
* jump normally, then does the exception return when the
|
|
|
|
* CPU tries to execute code at the magic address.
|
|
|
|
* This will cause the magic PC value to be pushed to
|
|
|
|
* the stack if an interrupt occurred at the wrong time.
|
|
|
|
* We avoid this by disabling interrupts when
|
|
|
|
* pc contains a magic address.
|
|
|
|
*/
|
|
|
|
if (interrupt_request & CPU_INTERRUPT_HARD
|
|
|
|
&& !(env->daif & PSTATE_I)
|
|
|
|
&& (env->regs[15] < 0xfffffff0)) {
|
|
|
|
cs->exception_index = EXCP_IRQ;
|
|
|
|
cc->do_interrupt(cs);
|
|
|
|
ret = true;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-08-20 17:54:28 +04:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
static void arm_cpu_set_irq(void *opaque, int irq, int level)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = opaque;
|
2014-09-29 21:48:51 +04:00
|
|
|
CPUARMState *env = &cpu->env;
|
2013-08-20 17:54:28 +04:00
|
|
|
CPUState *cs = CPU(cpu);
|
2014-09-29 21:48:51 +04:00
|
|
|
static const int mask[] = {
|
|
|
|
[ARM_CPU_IRQ] = CPU_INTERRUPT_HARD,
|
|
|
|
[ARM_CPU_FIQ] = CPU_INTERRUPT_FIQ,
|
|
|
|
[ARM_CPU_VIRQ] = CPU_INTERRUPT_VIRQ,
|
|
|
|
[ARM_CPU_VFIQ] = CPU_INTERRUPT_VFIQ
|
|
|
|
};
|
2013-08-20 17:54:28 +04:00
|
|
|
|
|
|
|
switch (irq) {
|
2014-09-29 21:48:51 +04:00
|
|
|
case ARM_CPU_VIRQ:
|
|
|
|
case ARM_CPU_VFIQ:
|
2015-09-07 12:39:29 +03:00
|
|
|
assert(arm_feature(env, ARM_FEATURE_EL2));
|
2014-09-29 21:48:51 +04:00
|
|
|
/* fall through */
|
|
|
|
case ARM_CPU_IRQ:
|
2013-08-20 17:54:28 +04:00
|
|
|
case ARM_CPU_FIQ:
|
|
|
|
if (level) {
|
2014-09-29 21:48:51 +04:00
|
|
|
cpu_interrupt(cs, mask[irq]);
|
2013-08-20 17:54:28 +04:00
|
|
|
} else {
|
2014-09-29 21:48:51 +04:00
|
|
|
cpu_reset_interrupt(cs, mask[irq]);
|
2013-08-20 17:54:28 +04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2015-09-07 12:39:29 +03:00
|
|
|
g_assert_not_reached();
|
2013-08-20 17:54:28 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void arm_cpu_kvm_set_irq(void *opaque, int irq, int level)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_KVM
|
|
|
|
ARMCPU *cpu = opaque;
|
|
|
|
CPUState *cs = CPU(cpu);
|
|
|
|
int kvm_irq = KVM_ARM_IRQ_TYPE_CPU << KVM_ARM_IRQ_TYPE_SHIFT;
|
|
|
|
|
|
|
|
switch (irq) {
|
|
|
|
case ARM_CPU_IRQ:
|
|
|
|
kvm_irq |= KVM_ARM_IRQ_CPU_IRQ;
|
|
|
|
break;
|
|
|
|
case ARM_CPU_FIQ:
|
|
|
|
kvm_irq |= KVM_ARM_IRQ_CPU_FIQ;
|
|
|
|
break;
|
|
|
|
default:
|
2015-09-07 12:39:29 +03:00
|
|
|
g_assert_not_reached();
|
2013-08-20 17:54:28 +04:00
|
|
|
}
|
|
|
|
kvm_irq |= cs->cpu_index << KVM_ARM_IRQ_VCPU_SHIFT;
|
|
|
|
kvm_set_irq(kvm_state, kvm_irq, level ? 1 : 0);
|
|
|
|
#endif
|
|
|
|
}
|
2015-02-05 16:37:25 +03:00
|
|
|
|
2016-03-04 14:30:19 +03:00
|
|
|
static bool arm_cpu_virtio_is_big_endian(CPUState *cs)
|
2015-02-05 16:37:25 +03:00
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
|
|
CPUARMState *env = &cpu->env;
|
|
|
|
|
|
|
|
cpu_synchronize_state(cs);
|
2016-03-04 14:30:19 +03:00
|
|
|
return arm_cpu_data_is_big_endian(env);
|
2015-02-05 16:37:25 +03:00
|
|
|
}
|
|
|
|
|
2013-08-20 17:54:28 +04:00
|
|
|
#endif
|
|
|
|
|
2012-04-20 21:58:31 +04:00
|
|
|
static inline void set_feature(CPUARMState *env, int feature)
|
|
|
|
{
|
2012-07-12 14:59:06 +04:00
|
|
|
env->features |= 1ULL << feature;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
2014-12-16 02:09:45 +03:00
|
|
|
static inline void unset_feature(CPUARMState *env, int feature)
|
|
|
|
{
|
|
|
|
env->features &= ~(1ULL << feature);
|
|
|
|
}
|
|
|
|
|
2015-06-24 06:57:35 +03:00
|
|
|
static int
|
|
|
|
print_insn_thumb1(bfd_vma pc, disassemble_info *info)
|
|
|
|
{
|
|
|
|
return print_insn_arm(pc | 1, info);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void arm_disas_set_info(CPUState *cpu, disassemble_info *info)
|
|
|
|
{
|
|
|
|
ARMCPU *ac = ARM_CPU(cpu);
|
|
|
|
CPUARMState *env = &ac->env;
|
|
|
|
|
|
|
|
if (is_a64(env)) {
|
|
|
|
/* We might not be compiled with the A64 disassembler
|
|
|
|
* because it needs a C++ compiler. Leave print_insn
|
|
|
|
* unset in this case to use the caller default behaviour.
|
|
|
|
*/
|
|
|
|
#if defined(CONFIG_ARM_A64_DIS)
|
|
|
|
info->print_insn = print_insn_arm_a64;
|
|
|
|
#endif
|
|
|
|
} else if (env->thumb) {
|
|
|
|
info->print_insn = print_insn_thumb1;
|
|
|
|
} else {
|
|
|
|
info->print_insn = print_insn_arm;
|
|
|
|
}
|
2016-03-04 14:30:19 +03:00
|
|
|
if (bswap_code(arm_sctlr_b(env))) {
|
2015-06-24 06:57:35 +03:00
|
|
|
#ifdef TARGET_WORDS_BIGENDIAN
|
|
|
|
info->endian = BFD_ENDIAN_LITTLE;
|
|
|
|
#else
|
|
|
|
info->endian = BFD_ENDIAN_BIG;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-15 20:06:09 +03:00
|
|
|
#define ARM_CPUS_PER_CLUSTER 8
|
|
|
|
|
2012-04-20 21:58:31 +04:00
|
|
|
static void arm_cpu_initfn(Object *obj)
|
|
|
|
{
|
2013-01-17 15:13:41 +04:00
|
|
|
CPUState *cs = CPU(obj);
|
2012-04-20 21:58:31 +04:00
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-01-19 10:37:45 +04:00
|
|
|
static bool inited;
|
2015-06-15 20:06:09 +03:00
|
|
|
uint32_t Aff1, Aff0;
|
2012-04-20 21:58:31 +04:00
|
|
|
|
2013-01-17 15:13:41 +04:00
|
|
|
cs->env_ptr = &cpu->env;
|
2015-06-24 05:31:18 +03:00
|
|
|
cpu_exec_init(cs, &error_abort);
|
2012-06-20 15:57:06 +04:00
|
|
|
cpu->cp_regs = g_hash_table_new_full(g_int_hash, g_int_equal,
|
|
|
|
g_free, g_free);
|
2013-01-19 10:37:45 +04:00
|
|
|
|
2015-06-15 20:06:09 +03:00
|
|
|
/* This cpu-id-to-MPIDR affinity is used only for TCG; KVM will override it.
|
|
|
|
* We don't support setting cluster ID ([16..23]) (known as Aff2
|
|
|
|
* in later ARM ARM versions), or any of the higher affinity level fields,
|
|
|
|
* so these bits always RAZ.
|
|
|
|
*/
|
|
|
|
Aff1 = cs->cpu_index / ARM_CPUS_PER_CLUSTER;
|
|
|
|
Aff0 = cs->cpu_index % ARM_CPUS_PER_CLUSTER;
|
2015-09-07 12:39:31 +03:00
|
|
|
cpu->mp_affinity = (Aff1 << ARM_AFF1_SHIFT) | Aff0;
|
2015-06-15 20:06:09 +03:00
|
|
|
|
2013-08-20 17:54:28 +04:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
/* Our inbound IRQ and FIQ lines */
|
|
|
|
if (kvm_enabled()) {
|
2014-09-29 21:48:51 +04:00
|
|
|
/* VIRQ and VFIQ are unused with KVM but we add them to maintain
|
|
|
|
* the same interface as non-KVM CPUs.
|
|
|
|
*/
|
|
|
|
qdev_init_gpio_in(DEVICE(cpu), arm_cpu_kvm_set_irq, 4);
|
2013-08-20 17:54:28 +04:00
|
|
|
} else {
|
2014-09-29 21:48:51 +04:00
|
|
|
qdev_init_gpio_in(DEVICE(cpu), arm_cpu_set_irq, 4);
|
2013-08-20 17:54:28 +04:00
|
|
|
}
|
2013-08-20 17:54:31 +04:00
|
|
|
|
2013-08-21 19:03:08 +04:00
|
|
|
cpu->gt_timer[GTIMER_PHYS] = timer_new(QEMU_CLOCK_VIRTUAL, GTIMER_SCALE,
|
2013-08-20 17:54:31 +04:00
|
|
|
arm_gt_ptimer_cb, cpu);
|
2013-08-21 19:03:08 +04:00
|
|
|
cpu->gt_timer[GTIMER_VIRT] = timer_new(QEMU_CLOCK_VIRTUAL, GTIMER_SCALE,
|
2013-08-20 17:54:31 +04:00
|
|
|
arm_gt_vtimer_cb, cpu);
|
2015-08-13 13:26:18 +03:00
|
|
|
cpu->gt_timer[GTIMER_HYP] = timer_new(QEMU_CLOCK_VIRTUAL, GTIMER_SCALE,
|
|
|
|
arm_gt_htimer_cb, cpu);
|
2015-08-13 13:26:22 +03:00
|
|
|
cpu->gt_timer[GTIMER_SEC] = timer_new(QEMU_CLOCK_VIRTUAL, GTIMER_SCALE,
|
|
|
|
arm_gt_stimer_cb, cpu);
|
2013-08-20 17:54:31 +04:00
|
|
|
qdev_init_gpio_out(DEVICE(cpu), cpu->gt_timer_outputs,
|
|
|
|
ARRAY_SIZE(cpu->gt_timer_outputs));
|
2013-08-20 17:54:28 +04:00
|
|
|
#endif
|
|
|
|
|
2013-11-22 21:17:12 +04:00
|
|
|
/* DTB consumers generally don't in fact care what the 'compatible'
|
|
|
|
* string is, so always provide some string and trust that a hypothetical
|
|
|
|
* picky DTB consumer will also provide a helpful error message.
|
|
|
|
*/
|
|
|
|
cpu->dtb_compatible = "qemu,unknown";
|
2014-06-19 21:06:26 +04:00
|
|
|
cpu->psci_version = 1; /* By default assume PSCI v0.1 */
|
2013-11-22 21:17:16 +04:00
|
|
|
cpu->kvm_target = QEMU_KVM_ARM_TARGET_NONE;
|
2013-11-22 21:17:12 +04:00
|
|
|
|
2014-10-24 15:19:13 +04:00
|
|
|
if (tcg_enabled()) {
|
|
|
|
cpu->psci_version = 2; /* TCG implements PSCI 0.2 */
|
|
|
|
if (!inited) {
|
|
|
|
inited = true;
|
|
|
|
arm_translate_init();
|
|
|
|
}
|
2013-01-19 10:37:45 +04:00
|
|
|
}
|
2012-06-20 15:57:06 +04:00
|
|
|
}
|
|
|
|
|
2013-12-17 23:42:28 +04:00
|
|
|
static Property arm_cpu_reset_cbar_property =
|
2014-04-15 22:18:49 +04:00
|
|
|
DEFINE_PROP_UINT64("reset-cbar", ARMCPU, reset_cbar, 0);
|
2013-12-17 23:42:28 +04:00
|
|
|
|
2013-12-17 23:42:29 +04:00
|
|
|
static Property arm_cpu_reset_hivecs_property =
|
|
|
|
DEFINE_PROP_BOOL("reset-hivecs", ARMCPU, reset_hivecs, false);
|
|
|
|
|
2014-04-15 22:18:48 +04:00
|
|
|
static Property arm_cpu_rvbar_property =
|
|
|
|
DEFINE_PROP_UINT64("rvbar", ARMCPU, rvbar, 0);
|
|
|
|
|
2014-12-16 02:09:46 +03:00
|
|
|
static Property arm_cpu_has_el3_property =
|
|
|
|
DEFINE_PROP_BOOL("has_el3", ARMCPU, has_el3, true);
|
|
|
|
|
2015-06-15 20:06:10 +03:00
|
|
|
static Property arm_cpu_has_mpu_property =
|
|
|
|
DEFINE_PROP_BOOL("has-mpu", ARMCPU, has_mpu, true);
|
|
|
|
|
2015-06-19 16:17:44 +03:00
|
|
|
static Property arm_cpu_pmsav7_dregion_property =
|
|
|
|
DEFINE_PROP_UINT32("pmsav7-dregion", ARMCPU, pmsav7_dregion, 16);
|
|
|
|
|
2013-12-17 23:42:28 +04:00
|
|
|
static void arm_cpu_post_init(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
|
2014-04-15 22:18:49 +04:00
|
|
|
if (arm_feature(&cpu->env, ARM_FEATURE_CBAR) ||
|
|
|
|
arm_feature(&cpu->env, ARM_FEATURE_CBAR_RO)) {
|
2013-12-17 23:42:28 +04:00
|
|
|
qdev_property_add_static(DEVICE(obj), &arm_cpu_reset_cbar_property,
|
2014-01-02 06:48:08 +04:00
|
|
|
&error_abort);
|
2013-12-17 23:42:28 +04:00
|
|
|
}
|
2013-12-17 23:42:29 +04:00
|
|
|
|
|
|
|
if (!arm_feature(&cpu->env, ARM_FEATURE_M)) {
|
|
|
|
qdev_property_add_static(DEVICE(obj), &arm_cpu_reset_hivecs_property,
|
2014-01-02 06:48:08 +04:00
|
|
|
&error_abort);
|
2013-12-17 23:42:29 +04:00
|
|
|
}
|
2014-04-15 22:18:48 +04:00
|
|
|
|
|
|
|
if (arm_feature(&cpu->env, ARM_FEATURE_AARCH64)) {
|
|
|
|
qdev_property_add_static(DEVICE(obj), &arm_cpu_rvbar_property,
|
|
|
|
&error_abort);
|
|
|
|
}
|
2014-12-16 02:09:46 +03:00
|
|
|
|
|
|
|
if (arm_feature(&cpu->env, ARM_FEATURE_EL3)) {
|
|
|
|
/* Add the has_el3 state CPU property only if EL3 is allowed. This will
|
|
|
|
* prevent "has_el3" from existing on CPUs which cannot support EL3.
|
|
|
|
*/
|
|
|
|
qdev_property_add_static(DEVICE(obj), &arm_cpu_has_el3_property,
|
|
|
|
&error_abort);
|
2016-01-21 17:15:06 +03:00
|
|
|
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
object_property_add_link(obj, "secure-memory",
|
|
|
|
TYPE_MEMORY_REGION,
|
|
|
|
(Object **)&cpu->secure_memory,
|
|
|
|
qdev_prop_allow_set_link_before_realize,
|
|
|
|
OBJ_PROP_LINK_UNREF_ON_RELEASE,
|
|
|
|
&error_abort);
|
|
|
|
#endif
|
2014-12-16 02:09:46 +03:00
|
|
|
}
|
2015-06-15 20:06:10 +03:00
|
|
|
|
|
|
|
if (arm_feature(&cpu->env, ARM_FEATURE_MPU)) {
|
|
|
|
qdev_property_add_static(DEVICE(obj), &arm_cpu_has_mpu_property,
|
|
|
|
&error_abort);
|
2015-06-19 16:17:44 +03:00
|
|
|
if (arm_feature(&cpu->env, ARM_FEATURE_V7)) {
|
|
|
|
qdev_property_add_static(DEVICE(obj),
|
|
|
|
&arm_cpu_pmsav7_dregion_property,
|
|
|
|
&error_abort);
|
|
|
|
}
|
2015-06-15 20:06:10 +03:00
|
|
|
}
|
|
|
|
|
2013-12-17 23:42:28 +04:00
|
|
|
}
|
|
|
|
|
2012-06-20 15:57:06 +04:00
|
|
|
static void arm_cpu_finalizefn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
g_hash_table_destroy(cpu->cp_regs);
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
2013-01-05 13:18:18 +04:00
|
|
|
static void arm_cpu_realizefn(DeviceState *dev, Error **errp)
|
2012-04-20 21:58:31 +04:00
|
|
|
{
|
2013-07-27 04:53:25 +04:00
|
|
|
CPUState *cs = CPU(dev);
|
2013-01-05 13:18:18 +04:00
|
|
|
ARMCPU *cpu = ARM_CPU(dev);
|
|
|
|
ARMCPUClass *acc = ARM_CPU_GET_CLASS(dev);
|
2012-04-20 21:58:31 +04:00
|
|
|
CPUARMState *env = &cpu->env;
|
2013-01-05 13:18:18 +04:00
|
|
|
|
2012-04-20 21:58:31 +04:00
|
|
|
/* Some features automatically imply others: */
|
2013-07-15 17:35:25 +04:00
|
|
|
if (arm_feature(env, ARM_FEATURE_V8)) {
|
|
|
|
set_feature(env, ARM_FEATURE_V7);
|
|
|
|
set_feature(env, ARM_FEATURE_ARM_DIV);
|
|
|
|
set_feature(env, ARM_FEATURE_LPAE);
|
|
|
|
}
|
2012-04-20 21:58:31 +04:00
|
|
|
if (arm_feature(env, ARM_FEATURE_V7)) {
|
|
|
|
set_feature(env, ARM_FEATURE_VAPA);
|
|
|
|
set_feature(env, ARM_FEATURE_THUMB2);
|
2012-06-20 15:57:20 +04:00
|
|
|
set_feature(env, ARM_FEATURE_MPIDR);
|
2012-04-20 21:58:31 +04:00
|
|
|
if (!arm_feature(env, ARM_FEATURE_M)) {
|
|
|
|
set_feature(env, ARM_FEATURE_V6K);
|
|
|
|
} else {
|
|
|
|
set_feature(env, ARM_FEATURE_V6);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (arm_feature(env, ARM_FEATURE_V6K)) {
|
|
|
|
set_feature(env, ARM_FEATURE_V6);
|
|
|
|
set_feature(env, ARM_FEATURE_MVFR);
|
|
|
|
}
|
|
|
|
if (arm_feature(env, ARM_FEATURE_V6)) {
|
|
|
|
set_feature(env, ARM_FEATURE_V5);
|
|
|
|
if (!arm_feature(env, ARM_FEATURE_M)) {
|
|
|
|
set_feature(env, ARM_FEATURE_AUXCR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (arm_feature(env, ARM_FEATURE_V5)) {
|
|
|
|
set_feature(env, ARM_FEATURE_V4T);
|
|
|
|
}
|
|
|
|
if (arm_feature(env, ARM_FEATURE_M)) {
|
|
|
|
set_feature(env, ARM_FEATURE_THUMB_DIV);
|
|
|
|
}
|
|
|
|
if (arm_feature(env, ARM_FEATURE_ARM_DIV)) {
|
|
|
|
set_feature(env, ARM_FEATURE_THUMB_DIV);
|
|
|
|
}
|
|
|
|
if (arm_feature(env, ARM_FEATURE_VFP4)) {
|
|
|
|
set_feature(env, ARM_FEATURE_VFP3);
|
2014-06-09 18:43:25 +04:00
|
|
|
set_feature(env, ARM_FEATURE_VFP_FP16);
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
if (arm_feature(env, ARM_FEATURE_VFP3)) {
|
|
|
|
set_feature(env, ARM_FEATURE_VFP);
|
|
|
|
}
|
2012-07-12 14:59:05 +04:00
|
|
|
if (arm_feature(env, ARM_FEATURE_LPAE)) {
|
2013-06-25 21:16:08 +04:00
|
|
|
set_feature(env, ARM_FEATURE_V7MP);
|
2012-07-12 14:59:05 +04:00
|
|
|
set_feature(env, ARM_FEATURE_PXN);
|
|
|
|
}
|
2014-04-15 22:18:49 +04:00
|
|
|
if (arm_feature(env, ARM_FEATURE_CBAR_RO)) {
|
|
|
|
set_feature(env, ARM_FEATURE_CBAR);
|
|
|
|
}
|
2015-06-15 20:06:09 +03:00
|
|
|
if (arm_feature(env, ARM_FEATURE_THUMB2) &&
|
|
|
|
!arm_feature(env, ARM_FEATURE_M)) {
|
|
|
|
set_feature(env, ARM_FEATURE_THUMB_DSP);
|
|
|
|
}
|
2012-06-20 15:57:09 +04:00
|
|
|
|
2013-12-17 23:42:29 +04:00
|
|
|
if (cpu->reset_hivecs) {
|
|
|
|
cpu->reset_sctlr |= (1 << 13);
|
|
|
|
}
|
|
|
|
|
2014-12-16 02:09:46 +03:00
|
|
|
if (!cpu->has_el3) {
|
|
|
|
/* If the has_el3 CPU property is disabled then we need to disable the
|
|
|
|
* feature.
|
|
|
|
*/
|
|
|
|
unset_feature(env, ARM_FEATURE_EL3);
|
|
|
|
|
|
|
|
/* Disable the security extension feature bits in the processor feature
|
2015-04-26 18:49:26 +03:00
|
|
|
* registers as well. These are id_pfr1[7:4] and id_aa64pfr0[15:12].
|
2014-12-16 02:09:46 +03:00
|
|
|
*/
|
|
|
|
cpu->id_pfr1 &= ~0xf0;
|
2015-04-26 18:49:26 +03:00
|
|
|
cpu->id_aa64pfr0 &= ~0xf000;
|
2014-12-16 02:09:46 +03:00
|
|
|
}
|
|
|
|
|
2016-02-02 21:20:42 +03:00
|
|
|
if (!arm_feature(env, ARM_FEATURE_EL2)) {
|
|
|
|
/* Disable the hypervisor feature bits in the processor feature
|
|
|
|
* registers if we don't have EL2. These are id_pfr1[15:12] and
|
|
|
|
* id_aa64pfr0_el1[11:8].
|
|
|
|
*/
|
|
|
|
cpu->id_aa64pfr0 &= ~0xf00;
|
|
|
|
cpu->id_pfr1 &= ~0xf000;
|
|
|
|
}
|
|
|
|
|
2015-06-15 20:06:10 +03:00
|
|
|
if (!cpu->has_mpu) {
|
|
|
|
unset_feature(env, ARM_FEATURE_MPU);
|
|
|
|
}
|
|
|
|
|
2015-06-19 16:17:44 +03:00
|
|
|
if (arm_feature(env, ARM_FEATURE_MPU) &&
|
|
|
|
arm_feature(env, ARM_FEATURE_V7)) {
|
|
|
|
uint32_t nr = cpu->pmsav7_dregion;
|
|
|
|
|
|
|
|
if (nr > 0xff) {
|
2015-12-18 18:35:19 +03:00
|
|
|
error_setg(errp, "PMSAv7 MPU #regions invalid %" PRIu32, nr);
|
2015-06-19 16:17:44 +03:00
|
|
|
return;
|
|
|
|
}
|
2015-06-19 16:17:44 +03:00
|
|
|
|
|
|
|
if (nr) {
|
|
|
|
env->pmsav7.drbar = g_new0(uint32_t, nr);
|
|
|
|
env->pmsav7.drsr = g_new0(uint32_t, nr);
|
|
|
|
env->pmsav7.dracr = g_new0(uint32_t, nr);
|
|
|
|
}
|
2015-06-19 16:17:44 +03:00
|
|
|
}
|
|
|
|
|
2012-06-20 15:57:09 +04:00
|
|
|
register_cp_regs_for_features(cpu);
|
2013-01-05 13:18:18 +04:00
|
|
|
arm_cpu_register_gdb_regs_for_features(cpu);
|
|
|
|
|
2013-06-25 21:16:07 +04:00
|
|
|
init_cpreg_list(cpu);
|
|
|
|
|
2016-01-21 17:15:06 +03:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
if (cpu->has_el3) {
|
|
|
|
cs->num_ases = 2;
|
|
|
|
} else {
|
|
|
|
cs->num_ases = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpu->has_el3) {
|
|
|
|
AddressSpace *as;
|
|
|
|
|
|
|
|
if (!cpu->secure_memory) {
|
|
|
|
cpu->secure_memory = cs->memory;
|
|
|
|
}
|
|
|
|
as = address_space_init_shareable(cpu->secure_memory,
|
|
|
|
"cpu-secure-memory");
|
|
|
|
cpu_address_space_init(cs, as, ARMASIdx_S);
|
|
|
|
}
|
|
|
|
cpu_address_space_init(cs,
|
|
|
|
address_space_init_shareable(cs->memory,
|
|
|
|
"cpu-memory"),
|
|
|
|
ARMASIdx_NS);
|
|
|
|
#endif
|
|
|
|
|
2013-07-27 04:53:25 +04:00
|
|
|
qemu_init_vcpu(cs);
|
2014-05-27 16:37:43 +04:00
|
|
|
cpu_reset(cs);
|
2013-01-05 13:18:18 +04:00
|
|
|
|
|
|
|
acc->parent_realize(dev, errp);
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
2013-01-21 19:11:43 +04:00
|
|
|
static ObjectClass *arm_cpu_class_by_name(const char *cpu_model)
|
|
|
|
{
|
|
|
|
ObjectClass *oc;
|
2013-01-27 20:30:10 +04:00
|
|
|
char *typename;
|
2015-02-13 08:46:08 +03:00
|
|
|
char **cpuname;
|
2013-01-21 19:11:43 +04:00
|
|
|
|
|
|
|
if (!cpu_model) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-02-13 08:46:08 +03:00
|
|
|
cpuname = g_strsplit(cpu_model, ",", 1);
|
|
|
|
typename = g_strdup_printf("%s-" TYPE_ARM_CPU, cpuname[0]);
|
2013-01-27 20:30:10 +04:00
|
|
|
oc = object_class_by_name(typename);
|
2015-02-13 08:46:08 +03:00
|
|
|
g_strfreev(cpuname);
|
2013-01-27 20:30:10 +04:00
|
|
|
g_free(typename);
|
2013-01-23 15:32:49 +04:00
|
|
|
if (!oc || !object_class_dynamic_cast(oc, TYPE_ARM_CPU) ||
|
|
|
|
object_class_is_abstract(oc)) {
|
2013-01-21 19:11:43 +04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return oc;
|
|
|
|
}
|
|
|
|
|
2013-09-03 23:12:08 +04:00
|
|
|
/* CPU models. These are not needed for the AArch64 linux-user build. */
|
|
|
|
#if !defined(CONFIG_USER_ONLY) || !defined(TARGET_AARCH64)
|
|
|
|
|
2012-04-20 21:58:31 +04:00
|
|
|
static void arm926_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "arm,arm926";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CACHE_TEST_CLEAN);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x41069265;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->reset_fpsid = 0x41011090;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0x1dd20d2;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00090078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void arm946_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "arm,arm946";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_MPU);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x41059461;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0x0f004006;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void arm1026_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "arm,arm1026";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_AUXCR);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CACHE_TEST_CLEAN);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x4106a262;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->reset_fpsid = 0x410110a0;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0x1dd20d2;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00090078;
|
2012-06-20 15:57:18 +04:00
|
|
|
cpu->reset_auxcr = 1;
|
2012-06-20 15:57:17 +04:00
|
|
|
{
|
|
|
|
/* The 1026 had an IFAR at c6,c0,0,1 rather than the ARMv6 c6,c0,0,2 */
|
|
|
|
ARMCPRegInfo ifar = {
|
|
|
|
.name = "IFAR", .cp = 15, .crn = 6, .crm = 0, .opc1 = 0, .opc2 = 1,
|
|
|
|
.access = PL1_RW,
|
2014-12-11 15:07:51 +03:00
|
|
|
.fieldoffset = offsetof(CPUARMState, cp15.ifar_ns),
|
2012-06-20 15:57:17 +04:00
|
|
|
.resetvalue = 0
|
|
|
|
};
|
|
|
|
define_one_arm_cp_reg(cpu, &ifar);
|
|
|
|
}
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void arm1136_r2_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2012-04-20 21:58:34 +04:00
|
|
|
/* What qemu calls "arm1136_r2" is actually the 1136 r0p2, ie an
|
|
|
|
* older core than plain "arm1136". In particular this does not
|
|
|
|
* have the v6K features.
|
|
|
|
* These ID register values are correct for 1136 but may be wrong
|
|
|
|
* for 1136_r2 (in particular r0p2 does not actually implement most
|
|
|
|
* of the ID registers).
|
|
|
|
*/
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "arm,arm1136";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V6);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CACHE_DIRTY_REG);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CACHE_BLOCK_OPS);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x4107b362;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->reset_fpsid = 0x410120b4;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->mvfr0 = 0x11111111;
|
|
|
|
cpu->mvfr1 = 0x00000000;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0x1dd20d2;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00050078;
|
2012-04-20 21:58:34 +04:00
|
|
|
cpu->id_pfr0 = 0x111;
|
|
|
|
cpu->id_pfr1 = 0x1;
|
|
|
|
cpu->id_dfr0 = 0x2;
|
|
|
|
cpu->id_afr0 = 0x3;
|
|
|
|
cpu->id_mmfr0 = 0x01130003;
|
|
|
|
cpu->id_mmfr1 = 0x10030302;
|
|
|
|
cpu->id_mmfr2 = 0x01222110;
|
|
|
|
cpu->id_isar0 = 0x00140011;
|
|
|
|
cpu->id_isar1 = 0x12002111;
|
|
|
|
cpu->id_isar2 = 0x11231111;
|
|
|
|
cpu->id_isar3 = 0x01102131;
|
|
|
|
cpu->id_isar4 = 0x141;
|
2012-06-20 15:57:18 +04:00
|
|
|
cpu->reset_auxcr = 7;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void arm1136_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "arm,arm1136";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V6K);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V6);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CACHE_DIRTY_REG);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CACHE_BLOCK_OPS);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x4117b363;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->reset_fpsid = 0x410120b4;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->mvfr0 = 0x11111111;
|
|
|
|
cpu->mvfr1 = 0x00000000;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0x1dd20d2;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00050078;
|
2012-04-20 21:58:34 +04:00
|
|
|
cpu->id_pfr0 = 0x111;
|
|
|
|
cpu->id_pfr1 = 0x1;
|
|
|
|
cpu->id_dfr0 = 0x2;
|
|
|
|
cpu->id_afr0 = 0x3;
|
|
|
|
cpu->id_mmfr0 = 0x01130003;
|
|
|
|
cpu->id_mmfr1 = 0x10030302;
|
|
|
|
cpu->id_mmfr2 = 0x01222110;
|
|
|
|
cpu->id_isar0 = 0x00140011;
|
|
|
|
cpu->id_isar1 = 0x12002111;
|
|
|
|
cpu->id_isar2 = 0x11231111;
|
|
|
|
cpu->id_isar3 = 0x01102131;
|
|
|
|
cpu->id_isar4 = 0x141;
|
2012-06-20 15:57:18 +04:00
|
|
|
cpu->reset_auxcr = 7;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void arm1176_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "arm,arm1176";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V6K);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VAPA);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CACHE_DIRTY_REG);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CACHE_BLOCK_OPS);
|
2014-12-16 02:09:52 +03:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_EL3);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x410fb767;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->reset_fpsid = 0x410120b5;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->mvfr0 = 0x11111111;
|
|
|
|
cpu->mvfr1 = 0x00000000;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0x1dd20d2;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00050078;
|
2012-04-20 21:58:34 +04:00
|
|
|
cpu->id_pfr0 = 0x111;
|
|
|
|
cpu->id_pfr1 = 0x11;
|
|
|
|
cpu->id_dfr0 = 0x33;
|
|
|
|
cpu->id_afr0 = 0;
|
|
|
|
cpu->id_mmfr0 = 0x01130003;
|
|
|
|
cpu->id_mmfr1 = 0x10030302;
|
|
|
|
cpu->id_mmfr2 = 0x01222100;
|
|
|
|
cpu->id_isar0 = 0x0140011;
|
|
|
|
cpu->id_isar1 = 0x12002111;
|
|
|
|
cpu->id_isar2 = 0x11231121;
|
|
|
|
cpu->id_isar3 = 0x01102131;
|
|
|
|
cpu->id_isar4 = 0x01141;
|
2012-06-20 15:57:18 +04:00
|
|
|
cpu->reset_auxcr = 7;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void arm11mpcore_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "arm,arm11mpcore";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V6K);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VAPA);
|
2012-06-20 15:57:20 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_MPIDR);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x410fb022;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->reset_fpsid = 0x410120b4;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->mvfr0 = 0x11111111;
|
|
|
|
cpu->mvfr1 = 0x00000000;
|
2012-06-20 15:57:06 +04:00
|
|
|
cpu->ctr = 0x1d192992; /* 32K icache 32K dcache */
|
2012-04-20 21:58:34 +04:00
|
|
|
cpu->id_pfr0 = 0x111;
|
|
|
|
cpu->id_pfr1 = 0x1;
|
|
|
|
cpu->id_dfr0 = 0;
|
|
|
|
cpu->id_afr0 = 0x2;
|
|
|
|
cpu->id_mmfr0 = 0x01100103;
|
|
|
|
cpu->id_mmfr1 = 0x10020302;
|
|
|
|
cpu->id_mmfr2 = 0x01222000;
|
|
|
|
cpu->id_isar0 = 0x00100011;
|
|
|
|
cpu->id_isar1 = 0x12002111;
|
|
|
|
cpu->id_isar2 = 0x11221011;
|
|
|
|
cpu->id_isar3 = 0x01102131;
|
|
|
|
cpu->id_isar4 = 0x141;
|
2012-06-20 15:57:18 +04:00
|
|
|
cpu->reset_auxcr = 1;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void cortex_m3_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V7);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_M);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x410fc231;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
2015-06-19 16:17:44 +03:00
|
|
|
static void cortex_m4_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V7);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_M);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_THUMB_DSP);
|
|
|
|
cpu->midr = 0x410fc240; /* r0p0 */
|
|
|
|
}
|
2013-02-02 15:33:14 +04:00
|
|
|
static void arm_v7m_class_init(ObjectClass *oc, void *data)
|
|
|
|
{
|
|
|
|
CPUClass *cc = CPU_CLASS(oc);
|
|
|
|
|
2014-10-30 18:48:51 +03:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2013-02-02 15:33:14 +04:00
|
|
|
cc->do_interrupt = arm_v7m_cpu_do_interrupt;
|
|
|
|
#endif
|
2014-10-30 18:48:51 +03:00
|
|
|
|
|
|
|
cc->cpu_exec_interrupt = arm_v7m_cpu_exec_interrupt;
|
2013-02-02 15:33:14 +04:00
|
|
|
}
|
|
|
|
|
2015-06-19 16:17:45 +03:00
|
|
|
static const ARMCPRegInfo cortexr5_cp_reginfo[] = {
|
|
|
|
/* Dummy the TCM region regs for the moment */
|
|
|
|
{ .name = "ATCM", .cp = 15, .opc1 = 0, .crn = 9, .crm = 1, .opc2 = 0,
|
|
|
|
.access = PL1_RW, .type = ARM_CP_CONST },
|
|
|
|
{ .name = "BTCM", .cp = 15, .opc1 = 0, .crn = 9, .crm = 1, .opc2 = 1,
|
|
|
|
.access = PL1_RW, .type = ARM_CP_CONST },
|
|
|
|
REGINFO_SENTINEL
|
|
|
|
};
|
|
|
|
|
|
|
|
static void cortex_r5_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V7);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_THUMB_DIV);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_ARM_DIV);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V7MP);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_MPU);
|
|
|
|
cpu->midr = 0x411fc153; /* r1p3 */
|
|
|
|
cpu->id_pfr0 = 0x0131;
|
|
|
|
cpu->id_pfr1 = 0x001;
|
|
|
|
cpu->id_dfr0 = 0x010400;
|
|
|
|
cpu->id_afr0 = 0x0;
|
|
|
|
cpu->id_mmfr0 = 0x0210030;
|
|
|
|
cpu->id_mmfr1 = 0x00000000;
|
|
|
|
cpu->id_mmfr2 = 0x01200000;
|
|
|
|
cpu->id_mmfr3 = 0x0211;
|
|
|
|
cpu->id_isar0 = 0x2101111;
|
|
|
|
cpu->id_isar1 = 0x13112111;
|
|
|
|
cpu->id_isar2 = 0x21232141;
|
|
|
|
cpu->id_isar3 = 0x01112131;
|
|
|
|
cpu->id_isar4 = 0x0010142;
|
|
|
|
cpu->id_isar5 = 0x0;
|
|
|
|
cpu->mp_is_up = true;
|
|
|
|
define_arm_cp_regs(cpu, cortexr5_cp_reginfo);
|
|
|
|
}
|
|
|
|
|
2012-06-20 15:57:18 +04:00
|
|
|
static const ARMCPRegInfo cortexa8_cp_reginfo[] = {
|
|
|
|
{ .name = "L2LOCKDOWN", .cp = 15, .crn = 9, .crm = 0, .opc1 = 1, .opc2 = 0,
|
|
|
|
.access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
|
|
|
|
{ .name = "L2AUXCR", .cp = 15, .crn = 9, .crm = 0, .opc1 = 1, .opc2 = 2,
|
|
|
|
.access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
|
|
|
|
REGINFO_SENTINEL
|
|
|
|
};
|
|
|
|
|
2012-04-20 21:58:31 +04:00
|
|
|
static void cortex_a8_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "arm,cortex-a8";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V7);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP3);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_NEON);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_THUMB2EE);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
2014-12-16 02:09:52 +03:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_EL3);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x410fc080;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->reset_fpsid = 0x410330c0;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->mvfr0 = 0x11110222;
|
|
|
|
cpu->mvfr1 = 0x00011100;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0x82048004;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00c50078;
|
2012-04-20 21:58:34 +04:00
|
|
|
cpu->id_pfr0 = 0x1031;
|
|
|
|
cpu->id_pfr1 = 0x11;
|
|
|
|
cpu->id_dfr0 = 0x400;
|
|
|
|
cpu->id_afr0 = 0;
|
|
|
|
cpu->id_mmfr0 = 0x31100003;
|
|
|
|
cpu->id_mmfr1 = 0x20000000;
|
|
|
|
cpu->id_mmfr2 = 0x01202000;
|
|
|
|
cpu->id_mmfr3 = 0x11;
|
|
|
|
cpu->id_isar0 = 0x00101111;
|
|
|
|
cpu->id_isar1 = 0x12112111;
|
|
|
|
cpu->id_isar2 = 0x21232031;
|
|
|
|
cpu->id_isar3 = 0x11112131;
|
|
|
|
cpu->id_isar4 = 0x00111142;
|
2014-08-19 21:56:25 +04:00
|
|
|
cpu->dbgdidr = 0x15141000;
|
2012-04-20 21:58:35 +04:00
|
|
|
cpu->clidr = (1 << 27) | (2 << 24) | 3;
|
|
|
|
cpu->ccsidr[0] = 0xe007e01a; /* 16k L1 dcache. */
|
|
|
|
cpu->ccsidr[1] = 0x2007e01a; /* 16k L1 icache. */
|
|
|
|
cpu->ccsidr[2] = 0xf0000000; /* No L2 icache. */
|
2012-06-20 15:57:18 +04:00
|
|
|
cpu->reset_auxcr = 2;
|
2012-06-20 15:57:18 +04:00
|
|
|
define_arm_cp_regs(cpu, cortexa8_cp_reginfo);
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
2012-06-20 15:57:15 +04:00
|
|
|
static const ARMCPRegInfo cortexa9_cp_reginfo[] = {
|
|
|
|
/* power_control should be set to maximum latency. Again,
|
|
|
|
* default to 0 and set by private hook
|
|
|
|
*/
|
|
|
|
{ .name = "A9_PWRCTL", .cp = 15, .crn = 15, .crm = 0, .opc1 = 0, .opc2 = 0,
|
|
|
|
.access = PL1_RW, .resetvalue = 0,
|
|
|
|
.fieldoffset = offsetof(CPUARMState, cp15.c15_power_control) },
|
|
|
|
{ .name = "A9_DIAG", .cp = 15, .crn = 15, .crm = 0, .opc1 = 0, .opc2 = 1,
|
|
|
|
.access = PL1_RW, .resetvalue = 0,
|
|
|
|
.fieldoffset = offsetof(CPUARMState, cp15.c15_diagnostic) },
|
|
|
|
{ .name = "A9_PWRDIAG", .cp = 15, .crn = 15, .crm = 0, .opc1 = 0, .opc2 = 2,
|
|
|
|
.access = PL1_RW, .resetvalue = 0,
|
|
|
|
.fieldoffset = offsetof(CPUARMState, cp15.c15_power_diagnostic) },
|
|
|
|
{ .name = "NEONBUSY", .cp = 15, .crn = 15, .crm = 1, .opc1 = 0, .opc2 = 0,
|
|
|
|
.access = PL1_RW, .resetvalue = 0, .type = ARM_CP_CONST },
|
|
|
|
/* TLB lockdown control */
|
|
|
|
{ .name = "TLB_LOCKR", .cp = 15, .crn = 15, .crm = 4, .opc1 = 5, .opc2 = 2,
|
|
|
|
.access = PL1_W, .resetvalue = 0, .type = ARM_CP_NOP },
|
|
|
|
{ .name = "TLB_LOCKW", .cp = 15, .crn = 15, .crm = 4, .opc1 = 5, .opc2 = 4,
|
|
|
|
.access = PL1_W, .resetvalue = 0, .type = ARM_CP_NOP },
|
|
|
|
{ .name = "TLB_VA", .cp = 15, .crn = 15, .crm = 5, .opc1 = 5, .opc2 = 2,
|
|
|
|
.access = PL1_RW, .resetvalue = 0, .type = ARM_CP_CONST },
|
|
|
|
{ .name = "TLB_PA", .cp = 15, .crn = 15, .crm = 6, .opc1 = 5, .opc2 = 2,
|
|
|
|
.access = PL1_RW, .resetvalue = 0, .type = ARM_CP_CONST },
|
|
|
|
{ .name = "TLB_ATTR", .cp = 15, .crn = 15, .crm = 7, .opc1 = 5, .opc2 = 2,
|
|
|
|
.access = PL1_RW, .resetvalue = 0, .type = ARM_CP_CONST },
|
|
|
|
REGINFO_SENTINEL
|
|
|
|
};
|
|
|
|
|
2012-04-20 21:58:31 +04:00
|
|
|
static void cortex_a9_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "arm,cortex-a9";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V7);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP3);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP_FP16);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_NEON);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_THUMB2EE);
|
2014-12-16 02:09:52 +03:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_EL3);
|
2012-04-20 21:58:31 +04:00
|
|
|
/* Note that A9 supports the MP extensions even for
|
|
|
|
* A9UP and single-core A9MP (which are both different
|
|
|
|
* and valid configurations; we don't model A9UP).
|
|
|
|
*/
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V7MP);
|
2013-12-17 23:42:28 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CBAR);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x410fc090;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->reset_fpsid = 0x41033090;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->mvfr0 = 0x11110222;
|
|
|
|
cpu->mvfr1 = 0x01111111;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0x80038003;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00c50078;
|
2012-04-20 21:58:34 +04:00
|
|
|
cpu->id_pfr0 = 0x1031;
|
|
|
|
cpu->id_pfr1 = 0x11;
|
|
|
|
cpu->id_dfr0 = 0x000;
|
|
|
|
cpu->id_afr0 = 0;
|
|
|
|
cpu->id_mmfr0 = 0x00100103;
|
|
|
|
cpu->id_mmfr1 = 0x20000000;
|
|
|
|
cpu->id_mmfr2 = 0x01230000;
|
|
|
|
cpu->id_mmfr3 = 0x00002111;
|
|
|
|
cpu->id_isar0 = 0x00101111;
|
|
|
|
cpu->id_isar1 = 0x13112111;
|
|
|
|
cpu->id_isar2 = 0x21232041;
|
|
|
|
cpu->id_isar3 = 0x11112131;
|
|
|
|
cpu->id_isar4 = 0x00111142;
|
2014-08-19 21:56:25 +04:00
|
|
|
cpu->dbgdidr = 0x35141000;
|
2012-04-20 21:58:35 +04:00
|
|
|
cpu->clidr = (1 << 27) | (1 << 24) | 3;
|
2014-08-19 21:56:27 +04:00
|
|
|
cpu->ccsidr[0] = 0xe00fe019; /* 16k L1 dcache. */
|
|
|
|
cpu->ccsidr[1] = 0x200fe019; /* 16k L1 icache. */
|
2013-12-17 23:42:28 +04:00
|
|
|
define_arm_cp_regs(cpu, cortexa9_cp_reginfo);
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
2012-06-20 15:57:18 +04:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2014-02-20 14:35:54 +04:00
|
|
|
static uint64_t a15_l2ctlr_read(CPUARMState *env, const ARMCPRegInfo *ri)
|
2012-06-20 15:57:18 +04:00
|
|
|
{
|
|
|
|
/* Linux wants the number of processors from here.
|
|
|
|
* Might as well set the interrupt-controller bit too.
|
|
|
|
*/
|
2014-02-20 14:35:54 +04:00
|
|
|
return ((smp_cpus - 1) << 24) | (1 << 23);
|
2012-06-20 15:57:18 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static const ARMCPRegInfo cortexa15_cp_reginfo[] = {
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
{ .name = "L2CTLR", .cp = 15, .crn = 9, .crm = 0, .opc1 = 1, .opc2 = 2,
|
|
|
|
.access = PL1_RW, .resetvalue = 0, .readfn = a15_l2ctlr_read,
|
|
|
|
.writefn = arm_cp_write_ignore, },
|
|
|
|
#endif
|
|
|
|
{ .name = "L2ECTLR", .cp = 15, .crn = 9, .crm = 0, .opc1 = 1, .opc2 = 3,
|
|
|
|
.access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
|
|
|
|
REGINFO_SENTINEL
|
|
|
|
};
|
|
|
|
|
2012-04-20 21:58:31 +04:00
|
|
|
static void cortex_a15_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "arm,cortex-a15";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V7);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP4);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_NEON);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_THUMB2EE);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_ARM_DIV);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_GENERIC_TIMER);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
2014-04-15 22:18:49 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CBAR_RO);
|
2012-07-12 14:59:05 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_LPAE);
|
2014-12-16 02:09:52 +03:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_EL3);
|
2013-11-22 21:17:16 +04:00
|
|
|
cpu->kvm_target = QEMU_KVM_ARM_TARGET_CORTEX_A15;
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x412fc0f1;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->reset_fpsid = 0x410430f0;
|
2012-04-20 21:58:32 +04:00
|
|
|
cpu->mvfr0 = 0x10110222;
|
|
|
|
cpu->mvfr1 = 0x11111111;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0x8444c004;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00c50078;
|
2012-04-20 21:58:34 +04:00
|
|
|
cpu->id_pfr0 = 0x00001131;
|
|
|
|
cpu->id_pfr1 = 0x00011011;
|
|
|
|
cpu->id_dfr0 = 0x02010555;
|
2016-02-18 17:16:17 +03:00
|
|
|
cpu->pmceid0 = 0x0000000;
|
|
|
|
cpu->pmceid1 = 0x00000000;
|
2012-04-20 21:58:34 +04:00
|
|
|
cpu->id_afr0 = 0x00000000;
|
|
|
|
cpu->id_mmfr0 = 0x10201105;
|
|
|
|
cpu->id_mmfr1 = 0x20000000;
|
|
|
|
cpu->id_mmfr2 = 0x01240000;
|
|
|
|
cpu->id_mmfr3 = 0x02102211;
|
|
|
|
cpu->id_isar0 = 0x02101110;
|
|
|
|
cpu->id_isar1 = 0x13112111;
|
|
|
|
cpu->id_isar2 = 0x21232041;
|
|
|
|
cpu->id_isar3 = 0x11112131;
|
|
|
|
cpu->id_isar4 = 0x10011142;
|
2014-08-19 21:56:25 +04:00
|
|
|
cpu->dbgdidr = 0x3515f021;
|
2012-04-20 21:58:35 +04:00
|
|
|
cpu->clidr = 0x0a200023;
|
|
|
|
cpu->ccsidr[0] = 0x701fe00a; /* 32K L1 dcache */
|
|
|
|
cpu->ccsidr[1] = 0x201fe00a; /* 32K L1 icache */
|
|
|
|
cpu->ccsidr[2] = 0x711fe07a; /* 4096K L2 unified cache */
|
2012-06-20 15:57:18 +04:00
|
|
|
define_arm_cp_regs(cpu, cortexa15_cp_reginfo);
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ti925t_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V4T);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_OMAPCP);
|
2012-04-20 21:58:31 +04:00
|
|
|
cpu->midr = ARM_CPUID_TI925T;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0x5109149;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000070;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sa1100_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "intel,sa1100";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_STRONGARM);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x4401A11B;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000070;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sa1110_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_STRONGARM);
|
2012-06-20 15:57:17 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x6901B119;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000070;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa250_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69052100;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa255_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69052d00;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa260_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69052903;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa261_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69052d05;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa262_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69052d06;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa270a0_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69054110;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa270a1_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69054111;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa270b0_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69054112;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa270b1_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69054113;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa270c0_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69054114;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa270c5_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-11-22 21:17:12 +04:00
|
|
|
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0x69054117;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->ctr = 0xd172172;
|
2012-04-20 21:58:33 +04:00
|
|
|
cpu->reset_sctlr = 0x00000078;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
2013-09-10 22:09:32 +04:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
2012-04-20 21:58:31 +04:00
|
|
|
static void arm_any_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
2013-07-15 17:35:25 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V8);
|
2012-04-20 21:58:31 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP4);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_NEON);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_THUMB2EE);
|
2014-06-09 18:43:24 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V8_AES);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V8_SHA1);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V8_SHA256);
|
|
|
|
set_feature(&cpu->env, ARM_FEATURE_V8_PMULL);
|
2014-02-26 21:20:07 +04:00
|
|
|
set_feature(&cpu->env, ARM_FEATURE_CRC);
|
2012-06-20 15:57:23 +04:00
|
|
|
cpu->midr = 0xffffffff;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
2013-09-10 22:09:32 +04:00
|
|
|
#endif
|
2012-04-20 21:58:31 +04:00
|
|
|
|
2013-09-03 23:12:08 +04:00
|
|
|
#endif /* !defined(CONFIG_USER_ONLY) || !defined(TARGET_AARCH64) */
|
|
|
|
|
2012-04-20 21:58:31 +04:00
|
|
|
typedef struct ARMCPUInfo {
|
|
|
|
const char *name;
|
|
|
|
void (*initfn)(Object *obj);
|
2013-02-02 15:33:14 +04:00
|
|
|
void (*class_init)(ObjectClass *oc, void *data);
|
2012-04-20 21:58:31 +04:00
|
|
|
} ARMCPUInfo;
|
|
|
|
|
|
|
|
static const ARMCPUInfo arm_cpus[] = {
|
2013-09-03 23:12:08 +04:00
|
|
|
#if !defined(CONFIG_USER_ONLY) || !defined(TARGET_AARCH64)
|
2012-04-20 21:58:31 +04:00
|
|
|
{ .name = "arm926", .initfn = arm926_initfn },
|
|
|
|
{ .name = "arm946", .initfn = arm946_initfn },
|
|
|
|
{ .name = "arm1026", .initfn = arm1026_initfn },
|
|
|
|
/* What QEMU calls "arm1136-r2" is actually the 1136 r0p2, i.e. an
|
|
|
|
* older core than plain "arm1136". In particular this does not
|
|
|
|
* have the v6K features.
|
|
|
|
*/
|
|
|
|
{ .name = "arm1136-r2", .initfn = arm1136_r2_initfn },
|
|
|
|
{ .name = "arm1136", .initfn = arm1136_initfn },
|
|
|
|
{ .name = "arm1176", .initfn = arm1176_initfn },
|
|
|
|
{ .name = "arm11mpcore", .initfn = arm11mpcore_initfn },
|
2013-02-02 15:33:14 +04:00
|
|
|
{ .name = "cortex-m3", .initfn = cortex_m3_initfn,
|
|
|
|
.class_init = arm_v7m_class_init },
|
2015-06-19 16:17:44 +03:00
|
|
|
{ .name = "cortex-m4", .initfn = cortex_m4_initfn,
|
|
|
|
.class_init = arm_v7m_class_init },
|
2015-06-19 16:17:45 +03:00
|
|
|
{ .name = "cortex-r5", .initfn = cortex_r5_initfn },
|
2012-04-20 21:58:31 +04:00
|
|
|
{ .name = "cortex-a8", .initfn = cortex_a8_initfn },
|
|
|
|
{ .name = "cortex-a9", .initfn = cortex_a9_initfn },
|
|
|
|
{ .name = "cortex-a15", .initfn = cortex_a15_initfn },
|
|
|
|
{ .name = "ti925t", .initfn = ti925t_initfn },
|
|
|
|
{ .name = "sa1100", .initfn = sa1100_initfn },
|
|
|
|
{ .name = "sa1110", .initfn = sa1110_initfn },
|
|
|
|
{ .name = "pxa250", .initfn = pxa250_initfn },
|
|
|
|
{ .name = "pxa255", .initfn = pxa255_initfn },
|
|
|
|
{ .name = "pxa260", .initfn = pxa260_initfn },
|
|
|
|
{ .name = "pxa261", .initfn = pxa261_initfn },
|
|
|
|
{ .name = "pxa262", .initfn = pxa262_initfn },
|
|
|
|
/* "pxa270" is an alias for "pxa270-a0" */
|
|
|
|
{ .name = "pxa270", .initfn = pxa270a0_initfn },
|
|
|
|
{ .name = "pxa270-a0", .initfn = pxa270a0_initfn },
|
|
|
|
{ .name = "pxa270-a1", .initfn = pxa270a1_initfn },
|
|
|
|
{ .name = "pxa270-b0", .initfn = pxa270b0_initfn },
|
|
|
|
{ .name = "pxa270-b1", .initfn = pxa270b1_initfn },
|
|
|
|
{ .name = "pxa270-c0", .initfn = pxa270c0_initfn },
|
|
|
|
{ .name = "pxa270-c5", .initfn = pxa270c5_initfn },
|
2013-09-10 22:09:32 +04:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
2012-04-20 21:58:31 +04:00
|
|
|
{ .name = "any", .initfn = arm_any_initfn },
|
2013-09-10 22:09:32 +04:00
|
|
|
#endif
|
2013-09-03 23:12:08 +04:00
|
|
|
#endif
|
2014-01-13 14:26:16 +04:00
|
|
|
{ .name = NULL }
|
2012-04-20 21:58:31 +04:00
|
|
|
};
|
|
|
|
|
2013-11-22 21:17:13 +04:00
|
|
|
static Property arm_cpu_properties[] = {
|
|
|
|
DEFINE_PROP_BOOL("start-powered-off", ARMCPU, start_powered_off, false),
|
2014-10-24 15:19:13 +04:00
|
|
|
DEFINE_PROP_UINT32("psci-conduit", ARMCPU, psci_conduit, 0),
|
2014-01-31 18:47:32 +04:00
|
|
|
DEFINE_PROP_UINT32("midr", ARMCPU, midr, 0),
|
2013-11-22 21:17:13 +04:00
|
|
|
DEFINE_PROP_END_OF_LIST()
|
|
|
|
};
|
|
|
|
|
2015-05-29 13:28:51 +03:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
static int arm_cpu_handle_mmu_fault(CPUState *cs, vaddr address, int rw,
|
|
|
|
int mmu_idx)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
|
|
CPUARMState *env = &cpu->env;
|
|
|
|
|
|
|
|
env->exception.vaddress = address;
|
|
|
|
if (rw == 2) {
|
|
|
|
cs->exception_index = EXCP_PREFETCH_ABORT;
|
|
|
|
} else {
|
|
|
|
cs->exception_index = EXCP_DATA_ABORT;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-12-03 15:14:41 +03:00
|
|
|
static gchar *arm_gdb_arch_name(CPUState *cs)
|
|
|
|
{
|
|
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
|
|
CPUARMState *env = &cpu->env;
|
|
|
|
|
|
|
|
if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
|
|
|
|
return g_strdup("iwmmxt");
|
|
|
|
}
|
|
|
|
return g_strdup("arm");
|
|
|
|
}
|
|
|
|
|
2012-03-29 08:50:31 +04:00
|
|
|
static void arm_cpu_class_init(ObjectClass *oc, void *data)
|
|
|
|
{
|
|
|
|
ARMCPUClass *acc = ARM_CPU_CLASS(oc);
|
|
|
|
CPUClass *cc = CPU_CLASS(acc);
|
2013-01-05 13:18:18 +04:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(oc);
|
|
|
|
|
|
|
|
acc->parent_realize = dc->realize;
|
|
|
|
dc->realize = arm_cpu_realizefn;
|
2013-11-22 21:17:13 +04:00
|
|
|
dc->props = arm_cpu_properties;
|
2012-03-29 08:50:31 +04:00
|
|
|
|
|
|
|
acc->parent_reset = cc->reset;
|
|
|
|
cc->reset = arm_cpu_reset;
|
2013-01-21 19:11:43 +04:00
|
|
|
|
|
|
|
cc->class_by_name = arm_cpu_class_by_name;
|
2013-08-25 20:53:55 +04:00
|
|
|
cc->has_work = arm_cpu_has_work;
|
2014-09-13 20:45:25 +04:00
|
|
|
cc->cpu_exec_interrupt = arm_cpu_exec_interrupt;
|
2013-05-27 03:33:50 +04:00
|
|
|
cc->dump_state = arm_cpu_dump_state;
|
2013-06-21 21:09:18 +04:00
|
|
|
cc->set_pc = arm_cpu_set_pc;
|
2013-06-29 06:18:45 +04:00
|
|
|
cc->gdb_read_register = arm_cpu_gdb_read_register;
|
|
|
|
cc->gdb_write_register = arm_cpu_gdb_write_register;
|
2013-08-26 05:01:33 +04:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
cc->handle_mmu_fault = arm_cpu_handle_mmu_fault;
|
|
|
|
#else
|
2014-10-24 15:19:12 +04:00
|
|
|
cc->do_interrupt = arm_cpu_do_interrupt;
|
2015-12-17 16:37:13 +03:00
|
|
|
cc->do_unaligned_access = arm_cpu_do_unaligned_access;
|
2016-01-21 17:15:07 +03:00
|
|
|
cc->get_phys_page_attrs_debug = arm_cpu_get_phys_page_attrs_debug;
|
2016-01-21 17:15:06 +03:00
|
|
|
cc->asidx_from_attrs = arm_asidx_from_attrs;
|
2013-06-29 20:55:54 +04:00
|
|
|
cc->vmsd = &vmstate_arm_cpu;
|
2016-03-04 14:30:19 +03:00
|
|
|
cc->virtio_is_big_endian = arm_cpu_virtio_is_big_endian;
|
2016-01-11 22:56:22 +03:00
|
|
|
cc->write_elf64_note = arm_cpu_write_elf64_note;
|
|
|
|
cc->write_elf32_note = arm_cpu_write_elf32_note;
|
2013-06-29 20:55:54 +04:00
|
|
|
#endif
|
2013-06-29 01:18:47 +04:00
|
|
|
cc->gdb_num_core_regs = 26;
|
2013-07-07 17:08:22 +04:00
|
|
|
cc->gdb_core_xml_file = "arm-core.xml";
|
2015-12-03 15:14:41 +03:00
|
|
|
cc->gdb_arch_name = arm_gdb_arch_name;
|
2014-09-12 22:04:17 +04:00
|
|
|
cc->gdb_stop_before_watchpoint = true;
|
2014-09-12 17:06:49 +04:00
|
|
|
cc->debug_excp_handler = arm_debug_excp_handler;
|
2016-02-11 14:17:32 +03:00
|
|
|
cc->debug_check_watchpoint = arm_debug_check_watchpoint;
|
2015-06-24 06:57:35 +03:00
|
|
|
|
|
|
|
cc->disas_set_info = arm_disas_set_info;
|
qdev: Protect device-list-properties against broken devices
Several devices don't survive object_unref(object_new(T)): they crash
or hang during cleanup, or they leave dangling pointers behind.
This breaks at least device-list-properties, because
qmp_device_list_properties() needs to create a device to find its
properties. Broken in commit f4eb32b "qmp: show QOM properties in
device-list-properties", v2.1. Example reproducer:
$ qemu-system-aarch64 -nodefaults -display none -machine none -S -qmp stdio
{"QMP": {"version": {"qemu": {"micro": 50, "minor": 4, "major": 2}, "package": ""}, "capabilities": []}}
{ "execute": "qmp_capabilities" }
{"return": {}}
{ "execute": "device-list-properties", "arguments": { "typename": "pxa2xx-pcmcia" } }
qemu-system-aarch64: /home/armbru/work/qemu/memory.c:1307: memory_region_finalize: Assertion `((&mr->subregions)->tqh_first == ((void *)0))' failed.
Aborted (core dumped)
[Exit 134 (SIGABRT)]
Unfortunately, I can't fix the problems in these devices right now.
Instead, add DeviceClass member cannot_destroy_with_object_finalize_yet
to mark them:
* Hang during cleanup (didn't debug, so I can't say why):
"realview_pci", "versatile_pci".
* Dangling pointer in cpus: most CPUs, plus "allwinner-a10", "digic",
"fsl,imx25", "fsl,imx31", "xlnx,zynqmp", because they create such
CPUs
* Assert kvm_enabled(): "host-x86_64-cpu", host-i386-cpu",
"host-powerpc64-cpu", "host-embedded-powerpc-cpu",
"host-powerpc-cpu" (the powerpc ones can't currently reach the
assertion, because the CPUs are only registered when KVM is enabled,
but the assertion is arguably in the wrong place all the same)
Make qmp_device_list_properties() fail cleanly when the device is so
marked. This improves device-list-properties from "crashes, hangs or
leaves dangling pointers behind" to "fails". Not a complete fix, just
a better-than-nothing work-around. In the above reproducer,
device-list-properties now fails with "Can't list properties of device
'pxa2xx-pcmcia'".
This also protects -device FOO,help, which uses the same machinery
since commit ef52358 "qdev-monitor: include QOM properties in -device
FOO, help output", v2.2. Example reproducer:
$ qemu-system-aarch64 -machine none -device pxa2xx-pcmcia,help
Before:
qemu-system-aarch64: .../memory.c:1307: memory_region_finalize: Assertion `((&mr->subregions)->tqh_first == ((void *)0))' failed.
After:
Can't list properties of device 'pxa2xx-pcmcia'
Cc: "Andreas Färber" <afaerber@suse.de>
Cc: "Edgar E. Iglesias" <edgar.iglesias@gmail.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Green <green@moxielogic.com>
Cc: Aurelien Jarno <aurelien@aurel32.net>
Cc: Bastian Koppelmann <kbastian@mail.uni-paderborn.de>
Cc: Blue Swirl <blauwirbel@gmail.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Guan Xuetao <gxt@mprc.pku.edu.cn>
Cc: Jia Liu <proljc@gmail.com>
Cc: Leon Alrae <leon.alrae@imgtec.com>
Cc: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
Cc: Max Filippov <jcmvbkbc@gmail.com>
Cc: Michael Walle <michael@walle.cc>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Peter Maydell <peter.maydell@linaro.org>
Cc: Richard Henderson <rth@twiddle.net>
Cc: qemu-ppc@nongnu.org
Cc: qemu-stable@nongnu.org
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <1443689999-12182-10-git-send-email-armbru@redhat.com>
2015-10-01 11:59:58 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Reason: arm_cpu_initfn() calls cpu_exec_init(), which saves
|
|
|
|
* the object in cpus -> dangling pointer after final
|
|
|
|
* object_unref().
|
|
|
|
*
|
|
|
|
* Once this is fixed, the devices that create ARM CPUs should be
|
|
|
|
* updated not to set cannot_destroy_with_object_finalize_yet,
|
|
|
|
* unless they still screw up something else.
|
|
|
|
*/
|
|
|
|
dc->cannot_destroy_with_object_finalize_yet = true;
|
2012-03-29 08:50:31 +04:00
|
|
|
}
|
|
|
|
|
2012-04-20 21:58:31 +04:00
|
|
|
static void cpu_register(const ARMCPUInfo *info)
|
|
|
|
{
|
|
|
|
TypeInfo type_info = {
|
|
|
|
.parent = TYPE_ARM_CPU,
|
|
|
|
.instance_size = sizeof(ARMCPU),
|
|
|
|
.instance_init = info->initfn,
|
|
|
|
.class_size = sizeof(ARMCPUClass),
|
2013-02-02 15:33:14 +04:00
|
|
|
.class_init = info->class_init,
|
2012-04-20 21:58:31 +04:00
|
|
|
};
|
|
|
|
|
2013-01-27 20:30:10 +04:00
|
|
|
type_info.name = g_strdup_printf("%s-" TYPE_ARM_CPU, info->name);
|
2013-01-11 19:21:22 +04:00
|
|
|
type_register(&type_info);
|
2013-01-27 20:30:10 +04:00
|
|
|
g_free((void *)type_info.name);
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
|
|
|
|
2012-03-29 08:50:31 +04:00
|
|
|
static const TypeInfo arm_cpu_type_info = {
|
|
|
|
.name = TYPE_ARM_CPU,
|
|
|
|
.parent = TYPE_CPU,
|
|
|
|
.instance_size = sizeof(ARMCPU),
|
2012-04-20 21:58:31 +04:00
|
|
|
.instance_init = arm_cpu_initfn,
|
2013-12-17 23:42:28 +04:00
|
|
|
.instance_post_init = arm_cpu_post_init,
|
2012-06-20 15:57:06 +04:00
|
|
|
.instance_finalize = arm_cpu_finalizefn,
|
2012-04-20 21:58:31 +04:00
|
|
|
.abstract = true,
|
2012-03-29 08:50:31 +04:00
|
|
|
.class_size = sizeof(ARMCPUClass),
|
|
|
|
.class_init = arm_cpu_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void arm_cpu_register_types(void)
|
|
|
|
{
|
2014-01-13 14:26:16 +04:00
|
|
|
const ARMCPUInfo *info = arm_cpus;
|
2012-04-20 21:58:31 +04:00
|
|
|
|
2012-03-29 08:50:31 +04:00
|
|
|
type_register_static(&arm_cpu_type_info);
|
2014-01-13 14:26:16 +04:00
|
|
|
|
|
|
|
while (info->name) {
|
|
|
|
cpu_register(info);
|
|
|
|
info++;
|
2012-04-20 21:58:31 +04:00
|
|
|
}
|
2012-03-29 08:50:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
type_init(arm_cpu_register_types)
|