Merge tag 'seabios-20211203-pull-request' of git://git.kraxel.org/qemu into staging
[qemu.git] / target / s390x / interrupt.c
1 /*
2 * QEMU S/390 Interrupt support
3 *
4 * Copyright IBM Corp. 2012, 2014
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2 or (at your
7 * option) any later version. See the COPYING file in the top-level directory.
8 */
9
10 #include "qemu/osdep.h"
11 #include "cpu.h"
12 #include "kvm_s390x.h"
13 #include "internal.h"
14 #include "exec/exec-all.h"
15 #include "sysemu/kvm.h"
16 #include "sysemu/tcg.h"
17 #include "hw/s390x/ioinst.h"
18 #include "tcg_s390x.h"
19 #if !defined(CONFIG_USER_ONLY)
20 #include "hw/s390x/s390_flic.h"
21 #endif
22
23 /* Ensure to exit the TB after this call! */
24 void trigger_pgm_exception(CPUS390XState *env, uint32_t code)
25 {
26 CPUState *cs = env_cpu(env);
27
28 cs->exception_index = EXCP_PGM;
29 env->int_pgm_code = code;
30 /* env->int_pgm_ilen is already set, or will be set during unwinding */
31 }
32
33 void s390_program_interrupt(CPUS390XState *env, uint32_t code, uintptr_t ra)
34 {
35 if (kvm_enabled()) {
36 kvm_s390_program_interrupt(env_archcpu(env), code);
37 } else if (tcg_enabled()) {
38 tcg_s390_program_interrupt(env, code, ra);
39 } else {
40 g_assert_not_reached();
41 }
42 }
43
44 #if !defined(CONFIG_USER_ONLY)
45 void cpu_inject_clock_comparator(S390CPU *cpu)
46 {
47 CPUS390XState *env = &cpu->env;
48
49 env->pending_int |= INTERRUPT_EXT_CLOCK_COMPARATOR;
50 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
51 }
52
53 void cpu_inject_cpu_timer(S390CPU *cpu)
54 {
55 CPUS390XState *env = &cpu->env;
56
57 env->pending_int |= INTERRUPT_EXT_CPU_TIMER;
58 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
59 }
60
61 void cpu_inject_emergency_signal(S390CPU *cpu, uint16_t src_cpu_addr)
62 {
63 CPUS390XState *env = &cpu->env;
64
65 g_assert(src_cpu_addr < S390_MAX_CPUS);
66 set_bit(src_cpu_addr, env->emergency_signals);
67
68 env->pending_int |= INTERRUPT_EMERGENCY_SIGNAL;
69 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
70 }
71
72 int cpu_inject_external_call(S390CPU *cpu, uint16_t src_cpu_addr)
73 {
74 CPUS390XState *env = &cpu->env;
75
76 g_assert(src_cpu_addr < S390_MAX_CPUS);
77 if (env->pending_int & INTERRUPT_EXTERNAL_CALL) {
78 return -EBUSY;
79 }
80 env->external_call_addr = src_cpu_addr;
81
82 env->pending_int |= INTERRUPT_EXTERNAL_CALL;
83 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
84 return 0;
85 }
86
87 void cpu_inject_restart(S390CPU *cpu)
88 {
89 CPUS390XState *env = &cpu->env;
90
91 if (kvm_enabled()) {
92 kvm_s390_restart_interrupt(cpu);
93 return;
94 }
95
96 env->pending_int |= INTERRUPT_RESTART;
97 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
98 }
99
100 void cpu_inject_stop(S390CPU *cpu)
101 {
102 CPUS390XState *env = &cpu->env;
103
104 if (kvm_enabled()) {
105 kvm_s390_stop_interrupt(cpu);
106 return;
107 }
108
109 env->pending_int |= INTERRUPT_STOP;
110 cpu_interrupt(CPU(cpu), CPU_INTERRUPT_HARD);
111 }
112
113 /*
114 * All of the following interrupts are floating, i.e. not per-vcpu.
115 * We just need a dummy cpustate in order to be able to inject in the
116 * non-kvm case.
117 */
118 void s390_sclp_extint(uint32_t parm)
119 {
120 S390FLICState *fs = s390_get_flic();
121 S390FLICStateClass *fsc = s390_get_flic_class(fs);
122
123 fsc->inject_service(fs, parm);
124 }
125
126 void s390_io_interrupt(uint16_t subchannel_id, uint16_t subchannel_nr,
127 uint32_t io_int_parm, uint32_t io_int_word)
128 {
129 S390FLICState *fs = s390_get_flic();
130 S390FLICStateClass *fsc = s390_get_flic_class(fs);
131
132 fsc->inject_io(fs, subchannel_id, subchannel_nr, io_int_parm, io_int_word);
133 }
134
135 void s390_crw_mchk(void)
136 {
137 S390FLICState *fs = s390_get_flic();
138 S390FLICStateClass *fsc = s390_get_flic_class(fs);
139
140 fsc->inject_crw_mchk(fs);
141 }
142
143 bool s390_cpu_has_mcck_int(S390CPU *cpu)
144 {
145 QEMUS390FLICState *flic = s390_get_qemu_flic(s390_get_flic());
146 CPUS390XState *env = &cpu->env;
147
148 if (!(env->psw.mask & PSW_MASK_MCHECK)) {
149 return false;
150 }
151
152 /* for now we only support channel report machine checks (floating) */
153 if (qemu_s390_flic_has_crw_mchk(flic) &&
154 (env->cregs[14] & CR14_CHANNEL_REPORT_SC)) {
155 return true;
156 }
157
158 return false;
159 }
160
161 bool s390_cpu_has_ext_int(S390CPU *cpu)
162 {
163 QEMUS390FLICState *flic = s390_get_qemu_flic(s390_get_flic());
164 CPUS390XState *env = &cpu->env;
165
166 if (!(env->psw.mask & PSW_MASK_EXT)) {
167 return false;
168 }
169
170 if ((env->pending_int & INTERRUPT_EMERGENCY_SIGNAL) &&
171 (env->cregs[0] & CR0_EMERGENCY_SIGNAL_SC)) {
172 return true;
173 }
174
175 if ((env->pending_int & INTERRUPT_EXTERNAL_CALL) &&
176 (env->cregs[0] & CR0_EXTERNAL_CALL_SC)) {
177 return true;
178 }
179
180 if ((env->pending_int & INTERRUPT_EXTERNAL_CALL) &&
181 (env->cregs[0] & CR0_EXTERNAL_CALL_SC)) {
182 return true;
183 }
184
185 if ((env->pending_int & INTERRUPT_EXT_CLOCK_COMPARATOR) &&
186 (env->cregs[0] & CR0_CKC_SC)) {
187 return true;
188 }
189
190 if ((env->pending_int & INTERRUPT_EXT_CPU_TIMER) &&
191 (env->cregs[0] & CR0_CPU_TIMER_SC)) {
192 return true;
193 }
194
195 if (qemu_s390_flic_has_service(flic) &&
196 (env->cregs[0] & CR0_SERVICE_SC)) {
197 return true;
198 }
199
200 return false;
201 }
202
203 bool s390_cpu_has_io_int(S390CPU *cpu)
204 {
205 QEMUS390FLICState *flic = s390_get_qemu_flic(s390_get_flic());
206 CPUS390XState *env = &cpu->env;
207
208 if (!(env->psw.mask & PSW_MASK_IO)) {
209 return false;
210 }
211
212 return qemu_s390_flic_has_io(flic, env->cregs[6]);
213 }
214
215 bool s390_cpu_has_restart_int(S390CPU *cpu)
216 {
217 CPUS390XState *env = &cpu->env;
218
219 return env->pending_int & INTERRUPT_RESTART;
220 }
221
222 bool s390_cpu_has_stop_int(S390CPU *cpu)
223 {
224 CPUS390XState *env = &cpu->env;
225
226 return env->pending_int & INTERRUPT_STOP;
227 }
228 #endif
229
230 bool s390_cpu_has_int(S390CPU *cpu)
231 {
232 #ifndef CONFIG_USER_ONLY
233 if (!tcg_enabled()) {
234 return false;
235 }
236 return s390_cpu_has_mcck_int(cpu) ||
237 s390_cpu_has_ext_int(cpu) ||
238 s390_cpu_has_io_int(cpu) ||
239 s390_cpu_has_restart_int(cpu) ||
240 s390_cpu_has_stop_int(cpu);
241 #else
242 return false;
243 #endif
244 }