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! */ 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 } 245