2 * S/390 misc helper routines
4 * Copyright (c) 2009 Ulrich Hecht
5 * Copyright (c) 2009 Alexander Graf
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
24 #include "host-utils.h"
28 #include "qemu-timer.h"
30 #include <linux/kvm.h>
33 #if !defined(CONFIG_USER_ONLY)
34 /* temporarily disabled due to wrapper use */
36 #include "softmmu_exec.h"
41 /* #define DEBUG_HELPER */
43 #define HELPER_LOG(x...) qemu_log(x)
45 #define HELPER_LOG(x...)
48 /* raise an exception */
49 void HELPER(exception
)(CPUS390XState
*env
, uint32_t excp
)
51 HELPER_LOG("%s: exception %d\n", __func__
, excp
);
52 env
->exception_index
= excp
;
56 #ifndef CONFIG_USER_ONLY
57 void program_interrupt(CPUS390XState
*env
, uint32_t code
, int ilc
)
59 qemu_log("program interrupt at %#" PRIx64
"\n", env
->psw
.addr
);
63 kvm_s390_interrupt(env
, KVM_S390_PROGRAM_INT
, code
);
66 env
->int_pgm_code
= code
;
67 env
->int_pgm_ilc
= ilc
;
68 env
->exception_index
= EXCP_PGM
;
74 * ret < 0 indicates program check, ret = 0, 1, 2, 3 -> cc
76 int sclp_service_call(CPUS390XState
*env
, uint32_t sccb
, uint64_t code
)
82 printf("sclp(0x%x, 0x%" PRIx64
")\n", sccb
, code
);
86 if (!memory_region_is_ram(phys_page_find(sccb
>> TARGET_PAGE_BITS
)->mr
)) {
87 return -PGM_ADDRESSING
;
89 if (sccb
& ~0x7ffffff8ul
) {
90 return -PGM_SPECIFICATION
;
94 case SCLP_CMDW_READ_SCP_INFO
:
95 case SCLP_CMDW_READ_SCP_INFO_FORCED
:
96 while ((ram_size
>> (20 + shift
)) > 65535) {
99 stw_phys(sccb
+ SCP_MEM_CODE
, ram_size
>> (20 + shift
));
100 stb_phys(sccb
+ SCP_INCREMENT
, 1 << shift
);
101 stw_phys(sccb
+ SCP_RESPONSE_CODE
, 0x10);
103 s390_sclp_extint(sccb
& ~3);
107 printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64
"x\n", sccb
, code
);
116 /* SCLP service call */
117 uint32_t HELPER(servc
)(CPUS390XState
*env
, uint32_t r1
, uint64_t r2
)
121 r
= sclp_service_call(env
, r1
, r2
);
123 program_interrupt(env
, -r
, 4);
130 uint64_t HELPER(diag
)(CPUS390XState
*env
, uint32_t num
, uint64_t mem
,
138 r
= s390_virtio_hypercall(env
, mem
, code
);
154 program_interrupt(env
, PGM_OPERATION
, ILC_LATER_INC
);
161 void HELPER(stidp
)(CPUS390XState
*env
, uint64_t a1
)
163 cpu_stq_data(env
, a1
, env
->cpu_num
);
167 void HELPER(spx
)(CPUS390XState
*env
, uint64_t a1
)
171 prefix
= cpu_ldl_data(env
, a1
);
172 env
->psa
= prefix
& 0xfffff000;
173 qemu_log("prefix: %#x\n", prefix
);
174 tlb_flush_page(env
, 0);
175 tlb_flush_page(env
, TARGET_PAGE_SIZE
);
179 uint32_t HELPER(sck
)(uint64_t a1
)
181 /* XXX not implemented - is it necessary? */
186 static inline uint64_t clock_value(CPUS390XState
*env
)
190 time
= env
->tod_offset
+
191 time2tod(qemu_get_clock_ns(vm_clock
) - env
->tod_basetime
);
197 uint32_t HELPER(stck
)(CPUS390XState
*env
, uint64_t a1
)
199 cpu_stq_data(env
, a1
, clock_value(env
));
204 /* Store Clock Extended */
205 uint32_t HELPER(stcke
)(CPUS390XState
*env
, uint64_t a1
)
207 cpu_stb_data(env
, a1
, 0);
208 /* basically the same value as stck */
209 cpu_stq_data(env
, a1
+ 1, clock_value(env
) | env
->cpu_num
);
210 /* more fine grained than stck */
211 cpu_stq_data(env
, a1
+ 9, 0);
212 /* XXX programmable fields */
213 cpu_stw_data(env
, a1
+ 17, 0);
218 /* Set Clock Comparator */
219 void HELPER(sckc
)(CPUS390XState
*env
, uint64_t a1
)
221 uint64_t time
= cpu_ldq_data(env
, a1
);
227 /* difference between now and then */
228 time
-= clock_value(env
);
230 time
= (time
* 125) >> 9;
232 qemu_mod_timer(env
->tod_timer
, qemu_get_clock_ns(vm_clock
) + time
);
235 /* Store Clock Comparator */
236 void HELPER(stckc
)(CPUS390XState
*env
, uint64_t a1
)
239 cpu_stq_data(env
, a1
, 0);
243 void HELPER(spt
)(CPUS390XState
*env
, uint64_t a1
)
245 uint64_t time
= cpu_ldq_data(env
, a1
);
252 time
= (time
* 125) >> 9;
254 qemu_mod_timer(env
->cpu_timer
, qemu_get_clock_ns(vm_clock
) + time
);
257 /* Store CPU Timer */
258 void HELPER(stpt
)(CPUS390XState
*env
, uint64_t a1
)
261 cpu_stq_data(env
, a1
, 0);
264 /* Store System Information */
265 uint32_t HELPER(stsi
)(CPUS390XState
*env
, uint64_t a0
, uint32_t r0
,
271 if ((r0
& STSI_LEVEL_MASK
) <= STSI_LEVEL_3
&&
272 ((r0
& STSI_R0_RESERVED_MASK
) || (r1
& STSI_R1_RESERVED_MASK
))) {
273 /* valid function code, invalid reserved bits */
274 program_interrupt(env
, PGM_SPECIFICATION
, 2);
277 sel1
= r0
& STSI_R0_SEL1_MASK
;
278 sel2
= r1
& STSI_R1_SEL2_MASK
;
280 /* XXX: spec exception if sysib is not 4k-aligned */
282 switch (r0
& STSI_LEVEL_MASK
) {
284 if ((sel1
== 1) && (sel2
== 1)) {
285 /* Basic Machine Configuration */
286 struct sysib_111 sysib
;
288 memset(&sysib
, 0, sizeof(sysib
));
289 ebcdic_put(sysib
.manuf
, "QEMU ", 16);
290 /* same as machine type number in STORE CPU ID */
291 ebcdic_put(sysib
.type
, "QEMU", 4);
292 /* same as model number in STORE CPU ID */
293 ebcdic_put(sysib
.model
, "QEMU ", 16);
294 ebcdic_put(sysib
.sequence
, "QEMU ", 16);
295 ebcdic_put(sysib
.plant
, "QEMU", 4);
296 cpu_physical_memory_rw(a0
, (uint8_t *)&sysib
, sizeof(sysib
), 1);
297 } else if ((sel1
== 2) && (sel2
== 1)) {
298 /* Basic Machine CPU */
299 struct sysib_121 sysib
;
301 memset(&sysib
, 0, sizeof(sysib
));
302 /* XXX make different for different CPUs? */
303 ebcdic_put(sysib
.sequence
, "QEMUQEMUQEMUQEMU", 16);
304 ebcdic_put(sysib
.plant
, "QEMU", 4);
305 stw_p(&sysib
.cpu_addr
, env
->cpu_num
);
306 cpu_physical_memory_rw(a0
, (uint8_t *)&sysib
, sizeof(sysib
), 1);
307 } else if ((sel1
== 2) && (sel2
== 2)) {
308 /* Basic Machine CPUs */
309 struct sysib_122 sysib
;
311 memset(&sysib
, 0, sizeof(sysib
));
312 stl_p(&sysib
.capability
, 0x443afc29);
313 /* XXX change when SMP comes */
314 stw_p(&sysib
.total_cpus
, 1);
315 stw_p(&sysib
.active_cpus
, 1);
316 stw_p(&sysib
.standby_cpus
, 0);
317 stw_p(&sysib
.reserved_cpus
, 0);
318 cpu_physical_memory_rw(a0
, (uint8_t *)&sysib
, sizeof(sysib
), 1);
325 if ((sel1
== 2) && (sel2
== 1)) {
327 struct sysib_221 sysib
;
329 memset(&sysib
, 0, sizeof(sysib
));
330 /* XXX make different for different CPUs? */
331 ebcdic_put(sysib
.sequence
, "QEMUQEMUQEMUQEMU", 16);
332 ebcdic_put(sysib
.plant
, "QEMU", 4);
333 stw_p(&sysib
.cpu_addr
, env
->cpu_num
);
334 stw_p(&sysib
.cpu_id
, 0);
335 cpu_physical_memory_rw(a0
, (uint8_t *)&sysib
, sizeof(sysib
), 1);
336 } else if ((sel1
== 2) && (sel2
== 2)) {
338 struct sysib_222 sysib
;
340 memset(&sysib
, 0, sizeof(sysib
));
341 stw_p(&sysib
.lpar_num
, 0);
343 /* XXX change when SMP comes */
344 stw_p(&sysib
.total_cpus
, 1);
345 stw_p(&sysib
.conf_cpus
, 1);
346 stw_p(&sysib
.standby_cpus
, 0);
347 stw_p(&sysib
.reserved_cpus
, 0);
348 ebcdic_put(sysib
.name
, "QEMU ", 8);
349 stl_p(&sysib
.caf
, 1000);
350 stw_p(&sysib
.dedicated_cpus
, 0);
351 stw_p(&sysib
.shared_cpus
, 0);
352 cpu_physical_memory_rw(a0
, (uint8_t *)&sysib
, sizeof(sysib
), 1);
360 if ((sel1
== 2) && (sel2
== 2)) {
362 struct sysib_322 sysib
;
364 memset(&sysib
, 0, sizeof(sysib
));
366 /* XXX change when SMP comes */
367 stw_p(&sysib
.vm
[0].total_cpus
, 1);
368 stw_p(&sysib
.vm
[0].conf_cpus
, 1);
369 stw_p(&sysib
.vm
[0].standby_cpus
, 0);
370 stw_p(&sysib
.vm
[0].reserved_cpus
, 0);
371 ebcdic_put(sysib
.vm
[0].name
, "KVMguest", 8);
372 stl_p(&sysib
.vm
[0].caf
, 1000);
373 ebcdic_put(sysib
.vm
[0].cpi
, "KVM/Linux ", 16);
374 cpu_physical_memory_rw(a0
, (uint8_t *)&sysib
, sizeof(sysib
), 1);
380 case STSI_LEVEL_CURRENT
:
381 env
->regs
[0] = STSI_LEVEL_3
;
391 uint32_t HELPER(sigp
)(CPUS390XState
*env
, uint64_t order_code
, uint32_t r1
,
396 HELPER_LOG("%s: %016" PRIx64
" %08x %016" PRIx64
"\n",
397 __func__
, order_code
, r1
, cpu_addr
);
399 /* Remember: Use "R1 or R1 + 1, whichever is the odd-numbered register"
400 as parameter (input). Status (output) is always R1. */
402 switch (order_code
) {
407 /* enumerate CPU status */
409 /* XXX implement when SMP comes */
412 env
->regs
[r1
] &= 0xffffffff00000000ULL
;
415 #if !defined(CONFIG_USER_ONLY)
417 qemu_system_reset_request();
421 qemu_system_shutdown_request();
427 fprintf(stderr
, "XXX unknown sigp: 0x%" PRIx64
"\n", order_code
);