xref: /openbmc/qemu/target/s390x/interrupt.c (revision 1f966c7c)
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/kvm_s390x.h"
13 #include "s390x-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/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! */
trigger_pgm_exception(CPUS390XState * env,uint32_t code)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 
s390_program_interrupt(CPUS390XState * env,uint32_t code,uintptr_t ra)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)
cpu_inject_clock_comparator(S390CPU * cpu)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 
cpu_inject_cpu_timer(S390CPU * cpu)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 
cpu_inject_emergency_signal(S390CPU * cpu,uint16_t src_cpu_addr)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 
cpu_inject_external_call(S390CPU * cpu,uint16_t src_cpu_addr)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 
cpu_inject_restart(S390CPU * cpu)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 
cpu_inject_stop(S390CPU * cpu)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  */
s390_sclp_extint(uint32_t parm)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 
s390_io_interrupt(uint16_t subchannel_id,uint16_t subchannel_nr,uint32_t io_int_parm,uint32_t io_int_word)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 
s390_crw_mchk(void)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 
s390_cpu_has_mcck_int(S390CPU * cpu)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 
s390_cpu_has_ext_int(S390CPU * cpu)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 
s390_cpu_has_io_int(S390CPU * cpu)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 
s390_cpu_has_restart_int(S390CPU * cpu)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 
s390_cpu_has_stop_int(S390CPU * cpu)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 
s390_cpu_has_int(S390CPU * cpu)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 }
245