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 "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 /* Ensure to exit the TB after this call! */ 25 void 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 /* env->int_pgm_ilen is already set, or will be set during unwinding */ 32 } 33 34 void 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) 46 void 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 54 void 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 62 void 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 73 int 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 88 void 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 101 void 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 * All of the following interrupts are floating, i.e. not per-vcpu. 116 * We just need a dummy cpustate in order to be able to inject in the 117 * non-kvm case. 118 */ 119 void 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 127 void 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 136 void 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 144 bool 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 /* for now we only support channel report machine checks (floating) */ 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 162 bool 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 204 bool 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 216 bool s390_cpu_has_restart_int(S390CPU *cpu) 217 { 218 CPUS390XState *env = &cpu->env; 219 220 return env->pending_int & INTERRUPT_RESTART; 221 } 222 223 bool 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 231 bool 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