The raw read and write functions were using the ARM_CP_64BIT flag in ri->type to determine whether to treat the register's state field as uint32_t or uint64_t; however AArch64 register info structs don't use that flag. Abstract out the "how big is the field?" test into a function and fix it to work for AArch64 registers. For this to work we must ensure that the reginfo structs put into the hashtable have the correct state field for their use, not the placeholder STATE_BOTH. Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
1054 lines
32 KiB
C
1054 lines
32 KiB
C
/*
|
|
* 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>
|
|
*/
|
|
|
|
#include "cpu.h"
|
|
#include "qemu-common.h"
|
|
#include "hw/qdev-properties.h"
|
|
#include "qapi/qmp/qerror.h"
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
#include "hw/loader.h"
|
|
#endif
|
|
#include "hw/arm/arm.h"
|
|
#include "sysemu/sysemu.h"
|
|
#include "sysemu/kvm.h"
|
|
|
|
static void arm_cpu_set_pc(CPUState *cs, vaddr value)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
|
|
cpu->env.regs[15] = value;
|
|
}
|
|
|
|
static void cp_reg_reset(gpointer key, gpointer value, gpointer opaque)
|
|
{
|
|
/* Reset a single ARMCPRegInfo register */
|
|
ARMCPRegInfo *ri = value;
|
|
ARMCPU *cpu = opaque;
|
|
|
|
if (ri->type & ARM_CP_SPECIAL) {
|
|
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;
|
|
}
|
|
|
|
if (cpreg_field_is_64bit(ri)) {
|
|
CPREG_FIELD64(&cpu->env, ri) = ri->resetvalue;
|
|
} else {
|
|
CPREG_FIELD32(&cpu->env, ri) = ri->resetvalue;
|
|
}
|
|
}
|
|
|
|
/* CPUClass::reset() */
|
|
static void arm_cpu_reset(CPUState *s)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(s);
|
|
ARMCPUClass *acc = ARM_CPU_GET_CLASS(cpu);
|
|
CPUARMState *env = &cpu->env;
|
|
|
|
acc->parent_reset(s);
|
|
|
|
memset(env, 0, offsetof(CPUARMState, breakpoints));
|
|
g_hash_table_foreach(cpu->cp_regs, cp_reg_reset, cpu);
|
|
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;
|
|
|
|
if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
|
|
env->iwmmxt.cregs[ARM_IWMMXT_wCID] = 0x69051000 | 'Q';
|
|
}
|
|
|
|
if (arm_feature(env, ARM_FEATURE_AARCH64)) {
|
|
/* 64 bit CPUs always start in 64 bit mode */
|
|
env->aarch64 = 1;
|
|
#if defined(CONFIG_USER_ONLY)
|
|
env->pstate = PSTATE_MODE_EL0t;
|
|
#else
|
|
env->pstate = PSTATE_D | PSTATE_A | PSTATE_I | PSTATE_F
|
|
| PSTATE_MODE_EL1h;
|
|
#endif
|
|
}
|
|
|
|
#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. */
|
|
env->uncached_cpsr = ARM_CPU_MODE_SVC | CPSR_A | CPSR_F | CPSR_I;
|
|
/* On ARMv7-M the CPSR_I is the value of the PRIMASK register, and is
|
|
clear at reset. Initial SP and PC are loaded from ROM. */
|
|
if (IS_M(env)) {
|
|
uint32_t pc;
|
|
uint8_t *rom;
|
|
env->uncached_cpsr &= ~CPSR_I;
|
|
rom = rom_ptr(0);
|
|
if (rom) {
|
|
/* We should really use ldl_phys here, in case the guest
|
|
modified flash and reset itself. However images
|
|
loaded via -kernel have not been copied yet, so load the
|
|
values directly from there. */
|
|
env->regs[13] = ldl_p(rom) & 0xFFFFFFFC;
|
|
pc = ldl_p(rom + 4);
|
|
env->thumb = pc & 1;
|
|
env->regs[15] = pc & ~1;
|
|
}
|
|
}
|
|
|
|
if (env->cp15.c1_sys & SCTLR_V) {
|
|
env->regs[15] = 0xFFFF0000;
|
|
}
|
|
|
|
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);
|
|
tlb_flush(env, 1);
|
|
/* Reset is a state change for some CPUARMState fields which we
|
|
* bake assumptions about into translated code, so we need to
|
|
* tb_flush().
|
|
*/
|
|
tb_flush(env);
|
|
}
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
static void arm_cpu_set_irq(void *opaque, int irq, int level)
|
|
{
|
|
ARMCPU *cpu = opaque;
|
|
CPUState *cs = CPU(cpu);
|
|
|
|
switch (irq) {
|
|
case ARM_CPU_IRQ:
|
|
if (level) {
|
|
cpu_interrupt(cs, CPU_INTERRUPT_HARD);
|
|
} else {
|
|
cpu_reset_interrupt(cs, CPU_INTERRUPT_HARD);
|
|
}
|
|
break;
|
|
case ARM_CPU_FIQ:
|
|
if (level) {
|
|
cpu_interrupt(cs, CPU_INTERRUPT_FIQ);
|
|
} else {
|
|
cpu_reset_interrupt(cs, CPU_INTERRUPT_FIQ);
|
|
}
|
|
break;
|
|
default:
|
|
hw_error("arm_cpu_set_irq: Bad interrupt line %d\n", irq);
|
|
}
|
|
}
|
|
|
|
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:
|
|
hw_error("arm_cpu_kvm_set_irq: Bad interrupt line %d\n", irq);
|
|
}
|
|
kvm_irq |= cs->cpu_index << KVM_ARM_IRQ_VCPU_SHIFT;
|
|
kvm_set_irq(kvm_state, kvm_irq, level ? 1 : 0);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
static inline void set_feature(CPUARMState *env, int feature)
|
|
{
|
|
env->features |= 1ULL << feature;
|
|
}
|
|
|
|
static void arm_cpu_initfn(Object *obj)
|
|
{
|
|
CPUState *cs = CPU(obj);
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
static bool inited;
|
|
|
|
cs->env_ptr = &cpu->env;
|
|
cpu_exec_init(&cpu->env);
|
|
cpu->cp_regs = g_hash_table_new_full(g_int_hash, g_int_equal,
|
|
g_free, g_free);
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
/* Our inbound IRQ and FIQ lines */
|
|
if (kvm_enabled()) {
|
|
qdev_init_gpio_in(DEVICE(cpu), arm_cpu_kvm_set_irq, 2);
|
|
} else {
|
|
qdev_init_gpio_in(DEVICE(cpu), arm_cpu_set_irq, 2);
|
|
}
|
|
|
|
cpu->gt_timer[GTIMER_PHYS] = timer_new(QEMU_CLOCK_VIRTUAL, GTIMER_SCALE,
|
|
arm_gt_ptimer_cb, cpu);
|
|
cpu->gt_timer[GTIMER_VIRT] = timer_new(QEMU_CLOCK_VIRTUAL, GTIMER_SCALE,
|
|
arm_gt_vtimer_cb, cpu);
|
|
qdev_init_gpio_out(DEVICE(cpu), cpu->gt_timer_outputs,
|
|
ARRAY_SIZE(cpu->gt_timer_outputs));
|
|
#endif
|
|
|
|
/* 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";
|
|
cpu->kvm_target = QEMU_KVM_ARM_TARGET_NONE;
|
|
|
|
if (tcg_enabled() && !inited) {
|
|
inited = true;
|
|
arm_translate_init();
|
|
}
|
|
}
|
|
|
|
static Property arm_cpu_reset_cbar_property =
|
|
DEFINE_PROP_UINT32("reset-cbar", ARMCPU, reset_cbar, 0);
|
|
|
|
static Property arm_cpu_reset_hivecs_property =
|
|
DEFINE_PROP_BOOL("reset-hivecs", ARMCPU, reset_hivecs, false);
|
|
|
|
static void arm_cpu_post_init(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
if (arm_feature(&cpu->env, ARM_FEATURE_CBAR)) {
|
|
qdev_property_add_static(DEVICE(obj), &arm_cpu_reset_cbar_property,
|
|
&error_abort);
|
|
}
|
|
|
|
if (!arm_feature(&cpu->env, ARM_FEATURE_M)) {
|
|
qdev_property_add_static(DEVICE(obj), &arm_cpu_reset_hivecs_property,
|
|
&error_abort);
|
|
}
|
|
}
|
|
|
|
static void arm_cpu_finalizefn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
g_hash_table_destroy(cpu->cp_regs);
|
|
}
|
|
|
|
static void arm_cpu_realizefn(DeviceState *dev, Error **errp)
|
|
{
|
|
CPUState *cs = CPU(dev);
|
|
ARMCPU *cpu = ARM_CPU(dev);
|
|
ARMCPUClass *acc = ARM_CPU_GET_CLASS(dev);
|
|
CPUARMState *env = &cpu->env;
|
|
|
|
/* Some features automatically imply others: */
|
|
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);
|
|
set_feature(env, ARM_FEATURE_V8_AES);
|
|
}
|
|
if (arm_feature(env, ARM_FEATURE_V7)) {
|
|
set_feature(env, ARM_FEATURE_VAPA);
|
|
set_feature(env, ARM_FEATURE_THUMB2);
|
|
set_feature(env, ARM_FEATURE_MPIDR);
|
|
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);
|
|
}
|
|
if (arm_feature(env, ARM_FEATURE_VFP3)) {
|
|
set_feature(env, ARM_FEATURE_VFP);
|
|
}
|
|
if (arm_feature(env, ARM_FEATURE_LPAE)) {
|
|
set_feature(env, ARM_FEATURE_V7MP);
|
|
set_feature(env, ARM_FEATURE_PXN);
|
|
}
|
|
|
|
if (cpu->reset_hivecs) {
|
|
cpu->reset_sctlr |= (1 << 13);
|
|
}
|
|
|
|
register_cp_regs_for_features(cpu);
|
|
arm_cpu_register_gdb_regs_for_features(cpu);
|
|
|
|
init_cpreg_list(cpu);
|
|
|
|
cpu_reset(cs);
|
|
qemu_init_vcpu(cs);
|
|
|
|
acc->parent_realize(dev, errp);
|
|
}
|
|
|
|
static ObjectClass *arm_cpu_class_by_name(const char *cpu_model)
|
|
{
|
|
ObjectClass *oc;
|
|
char *typename;
|
|
|
|
if (!cpu_model) {
|
|
return NULL;
|
|
}
|
|
|
|
typename = g_strdup_printf("%s-" TYPE_ARM_CPU, cpu_model);
|
|
oc = object_class_by_name(typename);
|
|
g_free(typename);
|
|
if (!oc || !object_class_dynamic_cast(oc, TYPE_ARM_CPU) ||
|
|
object_class_is_abstract(oc)) {
|
|
return NULL;
|
|
}
|
|
return oc;
|
|
}
|
|
|
|
/* CPU models. These are not needed for the AArch64 linux-user build. */
|
|
#if !defined(CONFIG_USER_ONLY) || !defined(TARGET_AARCH64)
|
|
|
|
static void arm926_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "arm,arm926";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
set_feature(&cpu->env, ARM_FEATURE_CACHE_TEST_CLEAN);
|
|
cpu->midr = 0x41069265;
|
|
cpu->reset_fpsid = 0x41011090;
|
|
cpu->ctr = 0x1dd20d2;
|
|
cpu->reset_sctlr = 0x00090078;
|
|
}
|
|
|
|
static void arm946_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "arm,arm946";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_MPU);
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
cpu->midr = 0x41059461;
|
|
cpu->ctr = 0x0f004006;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void arm1026_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "arm,arm1026";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
|
set_feature(&cpu->env, ARM_FEATURE_AUXCR);
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
set_feature(&cpu->env, ARM_FEATURE_CACHE_TEST_CLEAN);
|
|
cpu->midr = 0x4106a262;
|
|
cpu->reset_fpsid = 0x410110a0;
|
|
cpu->ctr = 0x1dd20d2;
|
|
cpu->reset_sctlr = 0x00090078;
|
|
cpu->reset_auxcr = 1;
|
|
{
|
|
/* 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,
|
|
.fieldoffset = offsetof(CPUARMState, cp15.c6_insn),
|
|
.resetvalue = 0
|
|
};
|
|
define_one_arm_cp_reg(cpu, &ifar);
|
|
}
|
|
}
|
|
|
|
static void arm1136_r2_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
/* 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).
|
|
*/
|
|
|
|
cpu->dtb_compatible = "arm,arm1136";
|
|
set_feature(&cpu->env, ARM_FEATURE_V6);
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
|
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);
|
|
cpu->midr = 0x4107b362;
|
|
cpu->reset_fpsid = 0x410120b4;
|
|
cpu->mvfr0 = 0x11111111;
|
|
cpu->mvfr1 = 0x00000000;
|
|
cpu->ctr = 0x1dd20d2;
|
|
cpu->reset_sctlr = 0x00050078;
|
|
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;
|
|
cpu->reset_auxcr = 7;
|
|
}
|
|
|
|
static void arm1136_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "arm,arm1136";
|
|
set_feature(&cpu->env, ARM_FEATURE_V6K);
|
|
set_feature(&cpu->env, ARM_FEATURE_V6);
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
|
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);
|
|
cpu->midr = 0x4117b363;
|
|
cpu->reset_fpsid = 0x410120b4;
|
|
cpu->mvfr0 = 0x11111111;
|
|
cpu->mvfr1 = 0x00000000;
|
|
cpu->ctr = 0x1dd20d2;
|
|
cpu->reset_sctlr = 0x00050078;
|
|
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;
|
|
cpu->reset_auxcr = 7;
|
|
}
|
|
|
|
static void arm1176_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "arm,arm1176";
|
|
set_feature(&cpu->env, ARM_FEATURE_V6K);
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
|
set_feature(&cpu->env, ARM_FEATURE_VAPA);
|
|
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);
|
|
cpu->midr = 0x410fb767;
|
|
cpu->reset_fpsid = 0x410120b5;
|
|
cpu->mvfr0 = 0x11111111;
|
|
cpu->mvfr1 = 0x00000000;
|
|
cpu->ctr = 0x1dd20d2;
|
|
cpu->reset_sctlr = 0x00050078;
|
|
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;
|
|
cpu->reset_auxcr = 7;
|
|
}
|
|
|
|
static void arm11mpcore_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "arm,arm11mpcore";
|
|
set_feature(&cpu->env, ARM_FEATURE_V6K);
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP);
|
|
set_feature(&cpu->env, ARM_FEATURE_VAPA);
|
|
set_feature(&cpu->env, ARM_FEATURE_MPIDR);
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
cpu->midr = 0x410fb022;
|
|
cpu->reset_fpsid = 0x410120b4;
|
|
cpu->mvfr0 = 0x11111111;
|
|
cpu->mvfr1 = 0x00000000;
|
|
cpu->ctr = 0x1d192992; /* 32K icache 32K dcache */
|
|
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;
|
|
cpu->reset_auxcr = 1;
|
|
}
|
|
|
|
static void cortex_m3_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
set_feature(&cpu->env, ARM_FEATURE_V7);
|
|
set_feature(&cpu->env, ARM_FEATURE_M);
|
|
cpu->midr = 0x410fc231;
|
|
}
|
|
|
|
static void arm_v7m_class_init(ObjectClass *oc, void *data)
|
|
{
|
|
#ifndef CONFIG_USER_ONLY
|
|
CPUClass *cc = CPU_CLASS(oc);
|
|
|
|
cc->do_interrupt = arm_v7m_cpu_do_interrupt;
|
|
#endif
|
|
}
|
|
|
|
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
|
|
};
|
|
|
|
static void cortex_a8_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "arm,cortex-a8";
|
|
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);
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
cpu->midr = 0x410fc080;
|
|
cpu->reset_fpsid = 0x410330c0;
|
|
cpu->mvfr0 = 0x11110222;
|
|
cpu->mvfr1 = 0x00011100;
|
|
cpu->ctr = 0x82048004;
|
|
cpu->reset_sctlr = 0x00c50078;
|
|
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;
|
|
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. */
|
|
cpu->reset_auxcr = 2;
|
|
define_arm_cp_regs(cpu, cortexa8_cp_reginfo);
|
|
}
|
|
|
|
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
|
|
};
|
|
|
|
static void cortex_a9_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "arm,cortex-a9";
|
|
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);
|
|
/* 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);
|
|
set_feature(&cpu->env, ARM_FEATURE_CBAR);
|
|
cpu->midr = 0x410fc090;
|
|
cpu->reset_fpsid = 0x41033090;
|
|
cpu->mvfr0 = 0x11110222;
|
|
cpu->mvfr1 = 0x01111111;
|
|
cpu->ctr = 0x80038003;
|
|
cpu->reset_sctlr = 0x00c50078;
|
|
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;
|
|
cpu->clidr = (1 << 27) | (1 << 24) | 3;
|
|
cpu->ccsidr[0] = 0xe00fe015; /* 16k L1 dcache. */
|
|
cpu->ccsidr[1] = 0x200fe015; /* 16k L1 icache. */
|
|
define_arm_cp_regs(cpu, cortexa9_cp_reginfo);
|
|
}
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
static uint64_t a15_l2ctlr_read(CPUARMState *env, const ARMCPRegInfo *ri)
|
|
{
|
|
/* Linux wants the number of processors from here.
|
|
* Might as well set the interrupt-controller bit too.
|
|
*/
|
|
return ((smp_cpus - 1) << 24) | (1 << 23);
|
|
}
|
|
#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
|
|
};
|
|
|
|
static void cortex_a15_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "arm,cortex-a15";
|
|
set_feature(&cpu->env, ARM_FEATURE_V7);
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP4);
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP_FP16);
|
|
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);
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
set_feature(&cpu->env, ARM_FEATURE_CBAR);
|
|
set_feature(&cpu->env, ARM_FEATURE_LPAE);
|
|
cpu->kvm_target = QEMU_KVM_ARM_TARGET_CORTEX_A15;
|
|
cpu->midr = 0x412fc0f1;
|
|
cpu->reset_fpsid = 0x410430f0;
|
|
cpu->mvfr0 = 0x10110222;
|
|
cpu->mvfr1 = 0x11111111;
|
|
cpu->ctr = 0x8444c004;
|
|
cpu->reset_sctlr = 0x00c50078;
|
|
cpu->id_pfr0 = 0x00001131;
|
|
cpu->id_pfr1 = 0x00011011;
|
|
cpu->id_dfr0 = 0x02010555;
|
|
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;
|
|
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 */
|
|
define_arm_cp_regs(cpu, cortexa15_cp_reginfo);
|
|
}
|
|
|
|
static void ti925t_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
set_feature(&cpu->env, ARM_FEATURE_V4T);
|
|
set_feature(&cpu->env, ARM_FEATURE_OMAPCP);
|
|
cpu->midr = ARM_CPUID_TI925T;
|
|
cpu->ctr = 0x5109149;
|
|
cpu->reset_sctlr = 0x00000070;
|
|
}
|
|
|
|
static void sa1100_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "intel,sa1100";
|
|
set_feature(&cpu->env, ARM_FEATURE_STRONGARM);
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
cpu->midr = 0x4401A11B;
|
|
cpu->reset_sctlr = 0x00000070;
|
|
}
|
|
|
|
static void sa1110_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
set_feature(&cpu->env, ARM_FEATURE_STRONGARM);
|
|
set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS);
|
|
cpu->midr = 0x6901B119;
|
|
cpu->reset_sctlr = 0x00000070;
|
|
}
|
|
|
|
static void pxa250_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
cpu->midr = 0x69052100;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void pxa255_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
cpu->midr = 0x69052d00;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void pxa260_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
cpu->midr = 0x69052903;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void pxa261_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
cpu->midr = 0x69052d05;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void pxa262_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
cpu->midr = 0x69052d06;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void pxa270a0_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
|
cpu->midr = 0x69054110;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void pxa270a1_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
|
cpu->midr = 0x69054111;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void pxa270b0_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
|
cpu->midr = 0x69054112;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void pxa270b1_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
|
cpu->midr = 0x69054113;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void pxa270c0_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
|
cpu->midr = 0x69054114;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
static void pxa270c5_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
|
|
cpu->dtb_compatible = "marvell,xscale";
|
|
set_feature(&cpu->env, ARM_FEATURE_V5);
|
|
set_feature(&cpu->env, ARM_FEATURE_XSCALE);
|
|
set_feature(&cpu->env, ARM_FEATURE_IWMMXT);
|
|
cpu->midr = 0x69054117;
|
|
cpu->ctr = 0xd172172;
|
|
cpu->reset_sctlr = 0x00000078;
|
|
}
|
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
static void arm_any_initfn(Object *obj)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(obj);
|
|
set_feature(&cpu->env, ARM_FEATURE_V8);
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP4);
|
|
set_feature(&cpu->env, ARM_FEATURE_VFP_FP16);
|
|
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_V7MP);
|
|
#ifdef TARGET_AARCH64
|
|
set_feature(&cpu->env, ARM_FEATURE_AARCH64);
|
|
#endif
|
|
cpu->midr = 0xffffffff;
|
|
}
|
|
#endif
|
|
|
|
#endif /* !defined(CONFIG_USER_ONLY) || !defined(TARGET_AARCH64) */
|
|
|
|
typedef struct ARMCPUInfo {
|
|
const char *name;
|
|
void (*initfn)(Object *obj);
|
|
void (*class_init)(ObjectClass *oc, void *data);
|
|
} ARMCPUInfo;
|
|
|
|
static const ARMCPUInfo arm_cpus[] = {
|
|
#if !defined(CONFIG_USER_ONLY) || !defined(TARGET_AARCH64)
|
|
{ .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 },
|
|
{ .name = "cortex-m3", .initfn = cortex_m3_initfn,
|
|
.class_init = arm_v7m_class_init },
|
|
{ .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 },
|
|
#ifdef CONFIG_USER_ONLY
|
|
{ .name = "any", .initfn = arm_any_initfn },
|
|
#endif
|
|
#endif
|
|
{ .name = NULL }
|
|
};
|
|
|
|
static Property arm_cpu_properties[] = {
|
|
DEFINE_PROP_BOOL("start-powered-off", ARMCPU, start_powered_off, false),
|
|
DEFINE_PROP_UINT32("midr", ARMCPU, midr, 0),
|
|
DEFINE_PROP_END_OF_LIST()
|
|
};
|
|
|
|
static void arm_cpu_class_init(ObjectClass *oc, void *data)
|
|
{
|
|
ARMCPUClass *acc = ARM_CPU_CLASS(oc);
|
|
CPUClass *cc = CPU_CLASS(acc);
|
|
DeviceClass *dc = DEVICE_CLASS(oc);
|
|
|
|
acc->parent_realize = dc->realize;
|
|
dc->realize = arm_cpu_realizefn;
|
|
dc->props = arm_cpu_properties;
|
|
|
|
acc->parent_reset = cc->reset;
|
|
cc->reset = arm_cpu_reset;
|
|
|
|
cc->class_by_name = arm_cpu_class_by_name;
|
|
cc->do_interrupt = arm_cpu_do_interrupt;
|
|
cc->dump_state = arm_cpu_dump_state;
|
|
cc->set_pc = arm_cpu_set_pc;
|
|
cc->gdb_read_register = arm_cpu_gdb_read_register;
|
|
cc->gdb_write_register = arm_cpu_gdb_write_register;
|
|
#ifndef CONFIG_USER_ONLY
|
|
cc->get_phys_page_debug = arm_cpu_get_phys_page_debug;
|
|
cc->vmsd = &vmstate_arm_cpu;
|
|
#endif
|
|
cc->gdb_num_core_regs = 26;
|
|
cc->gdb_core_xml_file = "arm-core.xml";
|
|
}
|
|
|
|
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),
|
|
.class_init = info->class_init,
|
|
};
|
|
|
|
type_info.name = g_strdup_printf("%s-" TYPE_ARM_CPU, info->name);
|
|
type_register(&type_info);
|
|
g_free((void *)type_info.name);
|
|
}
|
|
|
|
static const TypeInfo arm_cpu_type_info = {
|
|
.name = TYPE_ARM_CPU,
|
|
.parent = TYPE_CPU,
|
|
.instance_size = sizeof(ARMCPU),
|
|
.instance_init = arm_cpu_initfn,
|
|
.instance_post_init = arm_cpu_post_init,
|
|
.instance_finalize = arm_cpu_finalizefn,
|
|
.abstract = true,
|
|
.class_size = sizeof(ARMCPUClass),
|
|
.class_init = arm_cpu_class_init,
|
|
};
|
|
|
|
static void arm_cpu_register_types(void)
|
|
{
|
|
const ARMCPUInfo *info = arm_cpus;
|
|
|
|
type_register_static(&arm_cpu_type_info);
|
|
|
|
while (info->name) {
|
|
cpu_register(info);
|
|
info++;
|
|
}
|
|
}
|
|
|
|
type_init(arm_cpu_register_types)
|