[thirdparty/qemu.git] / target-sparc / machine.c

#include "qemu/osdep.h"
#include "qemu-common.h"
#include "cpu.h"
#include "exec/exec-all.h"
#include "hw/hw.h"
#include "hw/boards.h"
#include "qemu/timer.h"

#include "cpu.h"
#include "exec/exec-all.h"
#include "migration/cpu.h"
#include "exec/exec-all.h"

#ifdef TARGET_SPARC64
static const VMStateDescription vmstate_cpu_timer = {
    .name = "cpu_timer",
    .version_id = 1,
    .minimum_version_id = 1,
    .minimum_version_id_old = 1,
    .fields = (VMStateField[]) {
        VMSTATE_UINT32(frequency, CPUTimer),
        VMSTATE_UINT32(disabled, CPUTimer),
        VMSTATE_UINT64(disabled_mask, CPUTimer),
        VMSTATE_UINT32(npt, CPUTimer),
        VMSTATE_UINT64(npt_mask, CPUTimer),
        VMSTATE_INT64(clock_offset, CPUTimer),
        VMSTATE_TIMER_PTR(qtimer, CPUTimer),
        VMSTATE_END_OF_LIST()
    }
};

#define VMSTATE_CPU_TIMER(_f, _s)                             \
    VMSTATE_STRUCT_POINTER(_f, _s, vmstate_cpu_timer, CPUTimer)

static const VMStateDescription vmstate_trap_state = {
    .name = "trap_state",
    .version_id = 1,
    .minimum_version_id = 1,
    .minimum_version_id_old = 1,
    .fields = (VMStateField[]) {
        VMSTATE_UINT64(tpc, trap_state),
        VMSTATE_UINT64(tnpc, trap_state),
        VMSTATE_UINT64(tstate, trap_state),
        VMSTATE_UINT32(tt, trap_state),
        VMSTATE_END_OF_LIST()
    }
};

static const VMStateDescription vmstate_tlb_entry = {
    .name = "tlb_entry",
    .version_id = 1,
    .minimum_version_id = 1,
    .minimum_version_id_old = 1,
    .fields = (VMStateField[]) {
        VMSTATE_UINT64(tag, SparcTLBEntry),
        VMSTATE_UINT64(tte, SparcTLBEntry),
        VMSTATE_END_OF_LIST()
    }
};
#endif

static int get_psr(QEMUFile *f, void *opaque, size_t size)
{
    SPARCCPU *cpu = opaque;
    CPUSPARCState *env = &cpu->env;
    uint32_t val = qemu_get_be32(f);

    /* needed to ensure that the wrapping registers are correctly updated */
    env->cwp = 0;
    cpu_put_psr_raw(env, val);

    return 0;
}

static void put_psr(QEMUFile *f, void *opaque, size_t size)
{
    SPARCCPU *cpu = opaque;
    CPUSPARCState *env = &cpu->env;
    uint32_t val;

    val = cpu_get_psr(env);

    qemu_put_be32(f, val);
}

static const VMStateInfo vmstate_psr = {
    .name = "psr",
    .get = get_psr,
    .put = put_psr,
};

static void cpu_pre_save(void *opaque)
{
    SPARCCPU *cpu = opaque;
    CPUSPARCState *env = &cpu->env;

    /* if env->cwp == env->nwindows - 1, this will set the ins of the last
     * window as the outs of the first window
     */
    cpu_set_cwp(env, env->cwp);
}

/* 32-bit SPARC retains migration compatibility with older versions
 * of QEMU; 64-bit SPARC has had a migration break since then, so the
 * versions are different.
 */
#ifndef TARGET_SPARC64
#define SPARC_VMSTATE_VER 7
#else
#define SPARC_VMSTATE_VER 9
#endif

const VMStateDescription vmstate_sparc_cpu = {
    .name = "cpu",
    .version_id = SPARC_VMSTATE_VER,
    .minimum_version_id = SPARC_VMSTATE_VER,
    .minimum_version_id_old = SPARC_VMSTATE_VER,
    .pre_save = cpu_pre_save,
    .fields = (VMStateField[]) {
        VMSTATE_UINTTL_ARRAY(env.gregs, SPARCCPU, 8),
        VMSTATE_UINT32(env.nwindows, SPARCCPU),
        VMSTATE_VARRAY_MULTIPLY(env.regbase, SPARCCPU, env.nwindows, 16,
                                vmstate_info_uinttl, target_ulong),
        VMSTATE_CPUDOUBLE_ARRAY(env.fpr, SPARCCPU, TARGET_DPREGS),
        VMSTATE_UINTTL(env.pc, SPARCCPU),
        VMSTATE_UINTTL(env.npc, SPARCCPU),
        VMSTATE_UINTTL(env.y, SPARCCPU),
        {

            .name = "psr",
            .version_id = 0,
            .size = sizeof(uint32_t),
            .info = &vmstate_psr,
            .flags = VMS_SINGLE,
            .offset = 0,
        },
        VMSTATE_UINTTL(env.fsr, SPARCCPU),
        VMSTATE_UINTTL(env.tbr, SPARCCPU),
        VMSTATE_INT32(env.interrupt_index, SPARCCPU),
        VMSTATE_UINT32(env.pil_in, SPARCCPU),
#ifndef TARGET_SPARC64
        /* MMU */
        VMSTATE_UINT32(env.wim, SPARCCPU),
        VMSTATE_UINT32_ARRAY(env.mmuregs, SPARCCPU, 32),
        VMSTATE_UINT64_ARRAY(env.mxccdata, SPARCCPU, 4),
        VMSTATE_UINT64_ARRAY(env.mxccregs, SPARCCPU, 8),
        VMSTATE_UINT32(env.mmubpctrv, SPARCCPU),
        VMSTATE_UINT32(env.mmubpctrc, SPARCCPU),
        VMSTATE_UINT32(env.mmubpctrs, SPARCCPU),
        VMSTATE_UINT64(env.mmubpaction, SPARCCPU),
        VMSTATE_UINT64_ARRAY(env.mmubpregs, SPARCCPU, 4),
#else
        VMSTATE_UINT64(env.lsu, SPARCCPU),
        VMSTATE_UINT64_ARRAY(env.immuregs, SPARCCPU, 16),
        VMSTATE_UINT64_ARRAY(env.dmmuregs, SPARCCPU, 16),
        VMSTATE_STRUCT_ARRAY(env.itlb, SPARCCPU, 64, 0,
                             vmstate_tlb_entry, SparcTLBEntry),
        VMSTATE_STRUCT_ARRAY(env.dtlb, SPARCCPU, 64, 0,
                             vmstate_tlb_entry, SparcTLBEntry),
        VMSTATE_UINT32(env.mmu_version, SPARCCPU),
        VMSTATE_STRUCT_ARRAY(env.ts, SPARCCPU, MAXTL_MAX, 0,
                             vmstate_trap_state, trap_state),
        VMSTATE_UINT32(env.xcc, SPARCCPU),
        VMSTATE_UINT32(env.asi, SPARCCPU),
        VMSTATE_UINT32(env.pstate, SPARCCPU),
        VMSTATE_UINT32(env.tl, SPARCCPU),
        VMSTATE_UINT32(env.cansave, SPARCCPU),
        VMSTATE_UINT32(env.canrestore, SPARCCPU),
        VMSTATE_UINT32(env.otherwin, SPARCCPU),
        VMSTATE_UINT32(env.wstate, SPARCCPU),
        VMSTATE_UINT32(env.cleanwin, SPARCCPU),
        VMSTATE_UINT64_ARRAY(env.agregs, SPARCCPU, 8),
        VMSTATE_UINT64_ARRAY(env.bgregs, SPARCCPU, 8),
        VMSTATE_UINT64_ARRAY(env.igregs, SPARCCPU, 8),
        VMSTATE_UINT64_ARRAY(env.mgregs, SPARCCPU, 8),
        VMSTATE_UINT64(env.fprs, SPARCCPU),
        VMSTATE_UINT64(env.tick_cmpr, SPARCCPU),
        VMSTATE_UINT64(env.stick_cmpr, SPARCCPU),
        VMSTATE_CPU_TIMER(env.tick, SPARCCPU),
        VMSTATE_CPU_TIMER(env.stick, SPARCCPU),
        VMSTATE_UINT64(env.gsr, SPARCCPU),
        VMSTATE_UINT32(env.gl, SPARCCPU),
        VMSTATE_UINT64(env.hpstate, SPARCCPU),
        VMSTATE_UINT64_ARRAY(env.htstate, SPARCCPU, MAXTL_MAX),
        VMSTATE_UINT64(env.hintp, SPARCCPU),
        VMSTATE_UINT64(env.htba, SPARCCPU),
        VMSTATE_UINT64(env.hver, SPARCCPU),
        VMSTATE_UINT64(env.hstick_cmpr, SPARCCPU),
        VMSTATE_UINT64(env.ssr, SPARCCPU),
        VMSTATE_CPU_TIMER(env.hstick, SPARCCPU),
        /* On SPARC32 env.psrpil and env.cwp are migrated as part of the PSR */
        VMSTATE_UINT32(env.psrpil, SPARCCPU),
        VMSTATE_UINT32(env.cwp, SPARCCPU),
#endif
        VMSTATE_END_OF_LIST()
    },
};
Commit	Line	Data
db5ebe5f	1	#include "qemu/osdep.h"
33c11879 PB	2	#include "qemu-common.h"
33c11879 PB	3	#include "cpu.h"
63c91552	4	#include "exec/exec-all.h"
8dd3dca3 AJ	5	#include "hw/hw.h"
8dd3dca3 AJ	6	#include "hw/boards.h"
1de7afc9	7	#include "qemu/timer.h"
8dd3dca3	8
2b41f10e	9	#include "cpu.h"
63c91552	10	#include "exec/exec-all.h"
1e00b8d5	11	#include "migration/cpu.h"
63c91552	12	#include "exec/exec-all.h"
8dd3dca3	13
df32c8d4 JQ	14	#ifdef TARGET_SPARC64
	15	static const VMStateDescription vmstate_cpu_timer = {
	16	.name = "cpu_timer",
	17	.version_id = 1,
	18	.minimum_version_id = 1,
	19	.minimum_version_id_old = 1,
	20	.fields = (VMStateField[]) {
	21	VMSTATE_UINT32(frequency, CPUTimer),
	22	VMSTATE_UINT32(disabled, CPUTimer),
	23	VMSTATE_UINT64(disabled_mask, CPUTimer),
	24	VMSTATE_UINT32(npt, CPUTimer),
	25	VMSTATE_UINT64(npt_mask, CPUTimer),
	26	VMSTATE_INT64(clock_offset, CPUTimer),
	27	VMSTATE_TIMER_PTR(qtimer, CPUTimer),
	28	VMSTATE_END_OF_LIST()
	29	}
	30	};
a7a044f2	31
df32c8d4 JQ	32	#define VMSTATE_CPU_TIMER(_f, _s) \
df32c8d4 JQ	33	VMSTATE_STRUCT_POINTER(_f, _s, vmstate_cpu_timer, CPUTimer)
8dd3dca3	34
df32c8d4 JQ	35	static const VMStateDescription vmstate_trap_state = {
	36	.name = "trap_state",
	37	.version_id = 1,
	38	.minimum_version_id = 1,
	39	.minimum_version_id_old = 1,
	40	.fields = (VMStateField[]) {
	41	VMSTATE_UINT64(tpc, trap_state),
	42	VMSTATE_UINT64(tnpc, trap_state),
	43	VMSTATE_UINT64(tstate, trap_state),
	44	VMSTATE_UINT32(tt, trap_state),
	45	VMSTATE_END_OF_LIST()
8dd3dca3	46	}
df32c8d4	47	};
8dd3dca3	48
df32c8d4 JQ	49	static const VMStateDescription vmstate_tlb_entry = {
	50	.name = "tlb_entry",
	51	.version_id = 1,
	52	.minimum_version_id = 1,
	53	.minimum_version_id_old = 1,
	54	.fields = (VMStateField[]) {
	55	VMSTATE_UINT64(tag, SparcTLBEntry),
	56	VMSTATE_UINT64(tte, SparcTLBEntry),
	57	VMSTATE_END_OF_LIST()
0b8f1b10	58	}
df32c8d4	59	};
8dd3dca3	60	#endif
df32c8d4 JQ	61
	62	static int get_psr(QEMUFile f, void opaque, size_t size)
	63	{
	64	SPARCCPU *cpu = opaque;
	65	CPUSPARCState *env = &cpu->env;
	66	uint32_t val = qemu_get_be32(f);
	67
	68	/* needed to ensure that the wrapping registers are correctly updated */
	69	env->cwp = 0;
	70	cpu_put_psr_raw(env, val);
	71
	72	return 0;
8dd3dca3 AJ	73	}
8dd3dca3 AJ	74
df32c8d4	75	static void put_psr(QEMUFile f, void opaque, size_t size)
8dd3dca3	76	{
df32c8d4 JQ	77	SPARCCPU *cpu = opaque;
	78	CPUSPARCState *env = &cpu->env;
	79	uint32_t val;
	80
	81	val = cpu_get_psr(env);
8dd3dca3	82
df32c8d4 JQ	83	qemu_put_be32(f, val);
	84	}
	85
	86	static const VMStateInfo vmstate_psr = {
	87	.name = "psr",
	88	.get = get_psr,
	89	.put = put_psr,
	90	};
	91
	92	static void cpu_pre_save(void *opaque)
	93	{
	94	SPARCCPU *cpu = opaque;
	95	CPUSPARCState *env = &cpu->env;
	96
	97	/* if env->cwp == env->nwindows - 1, this will set the ins of the last
	98	* window as the outs of the first window
	99	*/
	100	cpu_set_cwp(env, env->cwp);
	101	}
	102
0e88d45a PM	103	/* 32-bit SPARC retains migration compatibility with older versions
	104	* of QEMU; 64-bit SPARC has had a migration break since then, so the
	105	* versions are different.
	106	*/
	107	#ifndef TARGET_SPARC64
	108	#define SPARC_VMSTATE_VER 7
	109	#else
6d532244	110	#define SPARC_VMSTATE_VER 9
0e88d45a PM	111	#endif
0e88d45a PM	112
df32c8d4 JQ	113	const VMStateDescription vmstate_sparc_cpu = {
df32c8d4 JQ	114	.name = "cpu",
0e88d45a PM	115	.version_id = SPARC_VMSTATE_VER,
	116	.minimum_version_id = SPARC_VMSTATE_VER,
	117	.minimum_version_id_old = SPARC_VMSTATE_VER,
df32c8d4 JQ	118	.pre_save = cpu_pre_save,
	119	.fields = (VMStateField[]) {
	120	VMSTATE_UINTTL_ARRAY(env.gregs, SPARCCPU, 8),
	121	VMSTATE_UINT32(env.nwindows, SPARCCPU),
	122	VMSTATE_VARRAY_MULTIPLY(env.regbase, SPARCCPU, env.nwindows, 16,
	123	vmstate_info_uinttl, target_ulong),
	124	VMSTATE_CPUDOUBLE_ARRAY(env.fpr, SPARCCPU, TARGET_DPREGS),
	125	VMSTATE_UINTTL(env.pc, SPARCCPU),
	126	VMSTATE_UINTTL(env.npc, SPARCCPU),
	127	VMSTATE_UINTTL(env.y, SPARCCPU),
	128	{
	129
	130	.name = "psr",
	131	.version_id = 0,
	132	.size = sizeof(uint32_t),
	133	.info = &vmstate_psr,
	134	.flags = VMS_SINGLE,
	135	.offset = 0,
	136	},
	137	VMSTATE_UINTTL(env.fsr, SPARCCPU),
	138	VMSTATE_UINTTL(env.tbr, SPARCCPU),
	139	VMSTATE_INT32(env.interrupt_index, SPARCCPU),
	140	VMSTATE_UINT32(env.pil_in, SPARCCPU),
8dd3dca3	141	#ifndef TARGET_SPARC64
df32c8d4 JQ	142	/* MMU */
	143	VMSTATE_UINT32(env.wim, SPARCCPU),
	144	VMSTATE_UINT32_ARRAY(env.mmuregs, SPARCCPU, 32),
	145	VMSTATE_UINT64_ARRAY(env.mxccdata, SPARCCPU, 4),
	146	VMSTATE_UINT64_ARRAY(env.mxccregs, SPARCCPU, 8),
	147	VMSTATE_UINT32(env.mmubpctrv, SPARCCPU),
	148	VMSTATE_UINT32(env.mmubpctrc, SPARCCPU),
	149	VMSTATE_UINT32(env.mmubpctrs, SPARCCPU),
	150	VMSTATE_UINT64(env.mmubpaction, SPARCCPU),
	151	VMSTATE_UINT64_ARRAY(env.mmubpregs, SPARCCPU, 4),
0b8f1b10	152	#else
df32c8d4	153	VMSTATE_UINT64(env.lsu, SPARCCPU),
0e88d45a PM	154	VMSTATE_UINT64_ARRAY(env.immuregs, SPARCCPU, 16),
	155	VMSTATE_UINT64_ARRAY(env.dmmuregs, SPARCCPU, 16),
	156	VMSTATE_STRUCT_ARRAY(env.itlb, SPARCCPU, 64, 0,
	157	vmstate_tlb_entry, SparcTLBEntry),
	158	VMSTATE_STRUCT_ARRAY(env.dtlb, SPARCCPU, 64, 0,
	159	vmstate_tlb_entry, SparcTLBEntry),
df32c8d4 JQ	160	VMSTATE_UINT32(env.mmu_version, SPARCCPU),
	161	VMSTATE_STRUCT_ARRAY(env.ts, SPARCCPU, MAXTL_MAX, 0,
	162	vmstate_trap_state, trap_state),
	163	VMSTATE_UINT32(env.xcc, SPARCCPU),
	164	VMSTATE_UINT32(env.asi, SPARCCPU),
	165	VMSTATE_UINT32(env.pstate, SPARCCPU),
	166	VMSTATE_UINT32(env.tl, SPARCCPU),
	167	VMSTATE_UINT32(env.cansave, SPARCCPU),
	168	VMSTATE_UINT32(env.canrestore, SPARCCPU),
	169	VMSTATE_UINT32(env.otherwin, SPARCCPU),
	170	VMSTATE_UINT32(env.wstate, SPARCCPU),
	171	VMSTATE_UINT32(env.cleanwin, SPARCCPU),
	172	VMSTATE_UINT64_ARRAY(env.agregs, SPARCCPU, 8),
	173	VMSTATE_UINT64_ARRAY(env.bgregs, SPARCCPU, 8),
	174	VMSTATE_UINT64_ARRAY(env.igregs, SPARCCPU, 8),
	175	VMSTATE_UINT64_ARRAY(env.mgregs, SPARCCPU, 8),
	176	VMSTATE_UINT64(env.fprs, SPARCCPU),
	177	VMSTATE_UINT64(env.tick_cmpr, SPARCCPU),
	178	VMSTATE_UINT64(env.stick_cmpr, SPARCCPU),
	179	VMSTATE_CPU_TIMER(env.tick, SPARCCPU),
	180	VMSTATE_CPU_TIMER(env.stick, SPARCCPU),
	181	VMSTATE_UINT64(env.gsr, SPARCCPU),
	182	VMSTATE_UINT32(env.gl, SPARCCPU),
	183	VMSTATE_UINT64(env.hpstate, SPARCCPU),
	184	VMSTATE_UINT64_ARRAY(env.htstate, SPARCCPU, MAXTL_MAX),
	185	VMSTATE_UINT64(env.hintp, SPARCCPU),
	186	VMSTATE_UINT64(env.htba, SPARCCPU),
	187	VMSTATE_UINT64(env.hver, SPARCCPU),
	188	VMSTATE_UINT64(env.hstick_cmpr, SPARCCPU),
	189	VMSTATE_UINT64(env.ssr, SPARCCPU),
	190	VMSTATE_CPU_TIMER(env.hstick, SPARCCPU),
6d532244 PM	191	/* On SPARC32 env.psrpil and env.cwp are migrated as part of the PSR */
	192	VMSTATE_UINT32(env.psrpil, SPARCCPU),
	193	VMSTATE_UINT32(env.cwp, SPARCCPU),
8dd3dca3	194	#endif
df32c8d4 JQ	195	VMSTATE_END_OF_LIST()
	196	},
	197	};