4 * Copyright (c) 2009 Ulrich Hecht
5 * Copyright (c) 2011 Alexander Graf
6 * Copyright (c) 2012 SUSE LINUX Products GmbH
7 * Copyright (c) 2012 IBM Corp.
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, see
21 * <http://www.gnu.org/licenses/lgpl-2.1.html>
22 * Contributions after 2012-12-11 are licensed under the terms of the
23 * GNU GPL, version 2 or (at your option) any later version.
27 #include "qemu-common.h"
28 #include "qemu/timer.h"
29 #include "qemu/error-report.h"
32 #ifndef CONFIG_USER_ONLY
33 #include "sysemu/arch_init.h"
36 #define CR0_RESET 0xE0UL
37 #define CR14_RESET 0xC2000000UL;
39 /* generate CPU information for cpu -? */
40 void s390_cpu_list(FILE *f
, fprintf_function cpu_fprintf
)
43 (*cpu_fprintf
)(f
, "s390 %16s\n", "host");
47 #ifndef CONFIG_USER_ONLY
48 CpuDefinitionInfoList
*arch_query_cpu_definitions(Error
**errp
)
50 CpuDefinitionInfoList
*entry
;
51 CpuDefinitionInfo
*info
;
53 info
= g_malloc0(sizeof(*info
));
54 info
->name
= g_strdup("host");
56 entry
= g_malloc0(sizeof(*entry
));
63 static void s390_cpu_set_pc(CPUState
*cs
, vaddr value
)
65 S390CPU
*cpu
= S390_CPU(cs
);
67 cpu
->env
.psw
.addr
= value
;
70 static bool s390_cpu_has_work(CPUState
*cs
)
72 S390CPU
*cpu
= S390_CPU(cs
);
73 CPUS390XState
*env
= &cpu
->env
;
75 return (cs
->interrupt_request
& CPU_INTERRUPT_HARD
) &&
76 (env
->psw
.mask
& PSW_MASK_EXT
);
79 #if !defined(CONFIG_USER_ONLY)
80 /* S390CPUClass::load_normal() */
81 static void s390_cpu_load_normal(CPUState
*s
)
83 S390CPU
*cpu
= S390_CPU(s
);
84 cpu
->env
.psw
.addr
= ldl_phys(s
->as
, 4) & PSW_MASK_ESA_ADDR
;
85 cpu
->env
.psw
.mask
= PSW_MASK_32
| PSW_MASK_64
;
86 s390_cpu_set_state(CPU_STATE_OPERATING
, cpu
);
90 /* S390CPUClass::cpu_reset() */
91 static void s390_cpu_reset(CPUState
*s
)
93 S390CPU
*cpu
= S390_CPU(s
);
94 S390CPUClass
*scc
= S390_CPU_GET_CLASS(cpu
);
95 CPUS390XState
*env
= &cpu
->env
;
97 env
->pfault_token
= -1UL;
99 cpu
->env
.sigp_order
= 0;
100 s390_cpu_set_state(CPU_STATE_STOPPED
, cpu
);
104 /* S390CPUClass::initial_reset() */
105 static void s390_cpu_initial_reset(CPUState
*s
)
107 S390CPU
*cpu
= S390_CPU(s
);
108 CPUS390XState
*env
= &cpu
->env
;
111 /* initial reset does not touch regs,fregs and aregs */
112 memset(&env
->fpc
, 0, offsetof(CPUS390XState
, cpu_num
) -
113 offsetof(CPUS390XState
, fpc
));
115 /* architectured initial values for CR 0 and 14 */
116 env
->cregs
[0] = CR0_RESET
;
117 env
->cregs
[14] = CR14_RESET
;
119 env
->pfault_token
= -1UL;
121 /* Reset state inside the kernel that we cannot access yet from QEMU. */
123 kvm_s390_reset_vcpu(cpu
);
127 /* CPUClass:reset() */
128 static void s390_cpu_full_reset(CPUState
*s
)
130 S390CPU
*cpu
= S390_CPU(s
);
131 S390CPUClass
*scc
= S390_CPU_GET_CLASS(cpu
);
132 CPUS390XState
*env
= &cpu
->env
;
134 scc
->parent_reset(s
);
135 cpu
->env
.sigp_order
= 0;
136 s390_cpu_set_state(CPU_STATE_STOPPED
, cpu
);
138 memset(env
, 0, offsetof(CPUS390XState
, cpu_num
));
140 /* architectured initial values for CR 0 and 14 */
141 env
->cregs
[0] = CR0_RESET
;
142 env
->cregs
[14] = CR14_RESET
;
144 env
->pfault_token
= -1UL;
146 /* Reset state inside the kernel that we cannot access yet from QEMU. */
148 kvm_s390_reset_vcpu(cpu
);
153 #if !defined(CONFIG_USER_ONLY)
154 static void s390_cpu_machine_reset_cb(void *opaque
)
156 S390CPU
*cpu
= opaque
;
158 run_on_cpu(CPU(cpu
), s390_do_cpu_full_reset
, CPU(cpu
));
162 static void s390_cpu_realizefn(DeviceState
*dev
, Error
**errp
)
164 CPUState
*cs
= CPU(dev
);
165 S390CPUClass
*scc
= S390_CPU_GET_CLASS(dev
);
167 s390_cpu_gdb_init(cs
);
169 #if !defined(CONFIG_USER_ONLY)
170 run_on_cpu(cs
, s390_do_cpu_full_reset
, cs
);
175 scc
->parent_realize(dev
, errp
);
178 static void s390_cpu_initfn(Object
*obj
)
180 CPUState
*cs
= CPU(obj
);
181 S390CPU
*cpu
= S390_CPU(obj
);
182 CPUS390XState
*env
= &cpu
->env
;
184 static int cpu_num
= 0;
185 #if !defined(CONFIG_USER_ONLY)
191 #if !defined(CONFIG_USER_ONLY)
192 qemu_register_reset(s390_cpu_machine_reset_cb
, cpu
);
193 qemu_get_timedate(&tm
, 0);
194 env
->tod_offset
= TOD_UNIX_EPOCH
+
195 (time2tod(mktimegm(&tm
)) * 1000000000ULL);
196 env
->tod_basetime
= 0;
197 env
->tod_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, s390x_tod_timer
, cpu
);
198 env
->cpu_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, s390x_cpu_timer
, cpu
);
199 s390_cpu_set_state(CPU_STATE_STOPPED
, cpu
);
201 env
->cpu_num
= cpu_num
++;
204 if (tcg_enabled() && !inited
) {
206 s390x_translate_init();
210 static void s390_cpu_finalize(Object
*obj
)
212 #if !defined(CONFIG_USER_ONLY)
213 S390CPU
*cpu
= S390_CPU(obj
);
215 qemu_unregister_reset(s390_cpu_machine_reset_cb
, cpu
);
216 g_free(cpu
->irqstate
);
220 #if !defined(CONFIG_USER_ONLY)
221 static bool disabled_wait(CPUState
*cpu
)
223 return cpu
->halted
&& !(S390_CPU(cpu
)->env
.psw
.mask
&
224 (PSW_MASK_IO
| PSW_MASK_EXT
| PSW_MASK_MCHECK
));
227 static unsigned s390_count_running_cpus(void)
233 uint8_t state
= S390_CPU(cpu
)->env
.cpu_state
;
234 if (state
== CPU_STATE_OPERATING
||
235 state
== CPU_STATE_LOAD
) {
236 if (!disabled_wait(cpu
)) {
245 unsigned int s390_cpu_halt(S390CPU
*cpu
)
247 CPUState
*cs
= CPU(cpu
);
248 trace_cpu_halt(cs
->cpu_index
);
252 cs
->exception_index
= EXCP_HLT
;
255 return s390_count_running_cpus();
258 void s390_cpu_unhalt(S390CPU
*cpu
)
260 CPUState
*cs
= CPU(cpu
);
261 trace_cpu_unhalt(cs
->cpu_index
);
265 cs
->exception_index
= -1;
269 unsigned int s390_cpu_set_state(uint8_t cpu_state
, S390CPU
*cpu
)
271 trace_cpu_set_state(CPU(cpu
)->cpu_index
, cpu_state
);
274 case CPU_STATE_STOPPED
:
275 case CPU_STATE_CHECK_STOP
:
276 /* halt the cpu for common infrastructure */
279 case CPU_STATE_OPERATING
:
281 /* unhalt the cpu for common infrastructure */
282 s390_cpu_unhalt(cpu
);
285 error_report("Requested CPU state is not a valid S390 CPU state: %u",
289 if (kvm_enabled() && cpu
->env
.cpu_state
!= cpu_state
) {
290 kvm_s390_set_cpu_state(cpu
, cpu_state
);
292 cpu
->env
.cpu_state
= cpu_state
;
294 return s390_count_running_cpus();
298 static void s390_cpu_class_init(ObjectClass
*oc
, void *data
)
300 S390CPUClass
*scc
= S390_CPU_CLASS(oc
);
301 CPUClass
*cc
= CPU_CLASS(scc
);
302 DeviceClass
*dc
= DEVICE_CLASS(oc
);
304 scc
->parent_realize
= dc
->realize
;
305 dc
->realize
= s390_cpu_realizefn
;
307 scc
->parent_reset
= cc
->reset
;
308 #if !defined(CONFIG_USER_ONLY)
309 scc
->load_normal
= s390_cpu_load_normal
;
311 scc
->cpu_reset
= s390_cpu_reset
;
312 scc
->initial_cpu_reset
= s390_cpu_initial_reset
;
313 cc
->reset
= s390_cpu_full_reset
;
314 cc
->has_work
= s390_cpu_has_work
;
315 cc
->do_interrupt
= s390_cpu_do_interrupt
;
316 cc
->dump_state
= s390_cpu_dump_state
;
317 cc
->set_pc
= s390_cpu_set_pc
;
318 cc
->gdb_read_register
= s390_cpu_gdb_read_register
;
319 cc
->gdb_write_register
= s390_cpu_gdb_write_register
;
320 #ifdef CONFIG_USER_ONLY
321 cc
->handle_mmu_fault
= s390_cpu_handle_mmu_fault
;
323 cc
->get_phys_page_debug
= s390_cpu_get_phys_page_debug
;
324 cc
->vmsd
= &vmstate_s390_cpu
;
325 cc
->write_elf64_note
= s390_cpu_write_elf64_note
;
326 cc
->write_elf64_qemunote
= s390_cpu_write_elf64_qemunote
;
327 cc
->cpu_exec_interrupt
= s390_cpu_exec_interrupt
;
329 cc
->gdb_num_core_regs
= S390_NUM_CORE_REGS
;
330 cc
->gdb_core_xml_file
= "s390x-core64.xml";
333 static const TypeInfo s390_cpu_type_info
= {
334 .name
= TYPE_S390_CPU
,
336 .instance_size
= sizeof(S390CPU
),
337 .instance_init
= s390_cpu_initfn
,
338 .instance_finalize
= s390_cpu_finalize
,
340 .class_size
= sizeof(S390CPUClass
),
341 .class_init
= s390_cpu_class_init
,
344 static void s390_cpu_register_types(void)
346 type_register_static(&s390_cpu_type_info
);
349 type_init(s390_cpu_register_types
)