1
2
3
4
5
6
7
8
9
10#include "qemu/osdep.h"
11#include "qemu/log.h"
12#include "cpu.h"
13#include "kvm_s390x.h"
14#include "internal.h"
15#include "exec/exec-all.h"
16#include "sysemu/kvm.h"
17#include "sysemu/tcg.h"
18#include "hw/s390x/ioinst.h"
19#include "tcg_s390x.h"
20#if !defined(CONFIG_USER_ONLY)
21#include "hw/s390x/s390_flic.h"
22#endif
23
24
25void trigger_pgm_exception(CPUS390XState *env, uint32_t code)
26{
27 CPUState *cs = env_cpu(env);
28
29 cs->exception_index = EXCP_PGM;
30 env->int_pgm_code = code;
31
32}
33
34void s390_program_interrupt(CPUS390XState *env, uint32_t code, uintptr_t ra)
35{
36 if (kvm_enabled()) {
37 kvm_s390_program_interrupt(env_archcpu(env), code);
38 } else if (tcg_enabled()) {
39 tcg_s390_program_interrupt(env, code, ra);
40 } else {
41 g_assert_not_reached();
42 }
43}
44
45#if !defined(CONFIG_USER_ONLY)
46void cpu_inject_clock_comparator(S390CPU *cpu)
47{
48 CPUS390XState *env = &cpu->env;
49
50 env->pending_int |= INTERRUPT_EXT_CLOCK_COMPARATOR;
51 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
52}
53
54void cpu_inject_cpu_timer(S390CPU *cpu)
55{
56 CPUS390XState *env = &cpu->env;
57
58 env->pending_int |= INTERRUPT_EXT_CPU_TIMER;
59 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
60}
61
62void cpu_inject_emergency_signal(S390CPU *cpu, uint16_t src_cpu_addr)
63{
64 CPUS390XState *env = &cpu->env;
65
66 g_assert(src_cpu_addr < S390_MAX_CPUS);
67 set_bit(src_cpu_addr, env->emergency_signals);
68
69 env->pending_int |= INTERRUPT_EMERGENCY_SIGNAL;
70 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
71}
72
73int cpu_inject_external_call(S390CPU *cpu, uint16_t src_cpu_addr)
74{
75 CPUS390XState *env = &cpu->env;
76
77 g_assert(src_cpu_addr < S390_MAX_CPUS);
78 if (env->pending_int & INTERRUPT_EXTERNAL_CALL) {
79 return -EBUSY;
80 }
81 env->external_call_addr = src_cpu_addr;
82
83 env->pending_int |= INTERRUPT_EXTERNAL_CALL;
84 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
85 return 0;
86}
87
88void cpu_inject_restart(S390CPU *cpu)
89{
90 CPUS390XState *env = &cpu->env;
91
92 if (kvm_enabled()) {
93 kvm_s390_restart_interrupt(cpu);
94 return;
95 }
96
97 env->pending_int |= INTERRUPT_RESTART;
98 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
99}
100
101void cpu_inject_stop(S390CPU *cpu)
102{
103 CPUS390XState *env = &cpu->env;
104
105 if (kvm_enabled()) {
106 kvm_s390_stop_interrupt(cpu);
107 return;
108 }
109
110 env->pending_int |= INTERRUPT_STOP;
111 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
112}
113
114
115
116
117
118
119void s390_sclp_extint(uint32_t parm)
120{
121 S390FLICState *fs = s390_get_flic();
122 S390FLICStateClass *fsc = s390_get_flic_class(fs);
123
124 fsc->inject_service(fs, parm);
125}
126
127void s390_io_interrupt(uint16_t subchannel_id, uint16_t subchannel_nr,
128 uint32_t io_int_parm, uint32_t io_int_word)
129{
130 S390FLICState *fs = s390_get_flic();
131 S390FLICStateClass *fsc = s390_get_flic_class(fs);
132
133 fsc->inject_io(fs, subchannel_id, subchannel_nr, io_int_parm, io_int_word);
134}
135
136void s390_crw_mchk(void)
137{
138 S390FLICState *fs = s390_get_flic();
139 S390FLICStateClass *fsc = s390_get_flic_class(fs);
140
141 fsc->inject_crw_mchk(fs);
142}
143
144bool s390_cpu_has_mcck_int(S390CPU *cpu)
145{
146 QEMUS390FLICState *flic = s390_get_qemu_flic(s390_get_flic());
147 CPUS390XState *env = &cpu->env;
148
149 if (!(env->psw.mask & PSW_MASK_MCHECK)) {
150 return false;
151 }
152
153
154 if (qemu_s390_flic_has_crw_mchk(flic) &&
155 (env->cregs[14] & CR14_CHANNEL_REPORT_SC)) {
156 return true;
157 }
158
159 return false;
160}
161
162bool s390_cpu_has_ext_int(S390CPU *cpu)
163{
164 QEMUS390FLICState *flic = s390_get_qemu_flic(s390_get_flic());
165 CPUS390XState *env = &cpu->env;
166
167 if (!(env->psw.mask & PSW_MASK_EXT)) {
168 return false;
169 }
170
171 if ((env->pending_int & INTERRUPT_EMERGENCY_SIGNAL) &&
172 (env->cregs[0] & CR0_EMERGENCY_SIGNAL_SC)) {
173 return true;
174 }
175
176 if ((env->pending_int & INTERRUPT_EXTERNAL_CALL) &&
177 (env->cregs[0] & CR0_EXTERNAL_CALL_SC)) {
178 return true;
179 }
180
181 if ((env->pending_int & INTERRUPT_EXTERNAL_CALL) &&
182 (env->cregs[0] & CR0_EXTERNAL_CALL_SC)) {
183 return true;
184 }
185
186 if ((env->pending_int & INTERRUPT_EXT_CLOCK_COMPARATOR) &&
187 (env->cregs[0] & CR0_CKC_SC)) {
188 return true;
189 }
190
191 if ((env->pending_int & INTERRUPT_EXT_CPU_TIMER) &&
192 (env->cregs[0] & CR0_CPU_TIMER_SC)) {
193 return true;
194 }
195
196 if (qemu_s390_flic_has_service(flic) &&
197 (env->cregs[0] & CR0_SERVICE_SC)) {
198 return true;
199 }
200
201 return false;
202}
203
204bool s390_cpu_has_io_int(S390CPU *cpu)
205{
206 QEMUS390FLICState *flic = s390_get_qemu_flic(s390_get_flic());
207 CPUS390XState *env = &cpu->env;
208
209 if (!(env->psw.mask & PSW_MASK_IO)) {
210 return false;
211 }
212
213 return qemu_s390_flic_has_io(flic, env->cregs[6]);
214}
215
216bool s390_cpu_has_restart_int(S390CPU *cpu)
217{
218 CPUS390XState *env = &cpu->env;
219
220 return env->pending_int & INTERRUPT_RESTART;
221}
222
223bool s390_cpu_has_stop_int(S390CPU *cpu)
224{
225 CPUS390XState *env = &cpu->env;
226
227 return env->pending_int & INTERRUPT_STOP;
228}
229#endif
230
231bool s390_cpu_has_int(S390CPU *cpu)
232{
233#ifndef CONFIG_USER_ONLY
234 if (!tcg_enabled()) {
235 return false;
236 }
237 return s390_cpu_has_mcck_int(cpu) ||
238 s390_cpu_has_ext_int(cpu) ||
239 s390_cpu_has_io_int(cpu) ||
240 s390_cpu_has_restart_int(cpu) ||
241 s390_cpu_has_stop_int(cpu);
242#else
243 return false;
244#endif
245}
246