1
2
3
4
5
6
7
8
9
10
11
12
13#include "qemu/osdep.h"
14#include "qapi/error.h"
15#include "cpu.h"
16#include "hw/boards.h"
17#include "exec/address-spaces.h"
18#include "exec/ram_addr.h"
19#include "hw/s390x/s390-virtio-hcall.h"
20#include "hw/s390x/sclp.h"
21#include "hw/s390x/s390_flic.h"
22#include "hw/s390x/ioinst.h"
23#include "hw/s390x/css.h"
24#include "virtio-ccw.h"
25#include "qemu/config-file.h"
26#include "qemu/ctype.h"
27#include "qemu/error-report.h"
28#include "qemu/option.h"
29#include "s390-pci-bus.h"
30#include "sysemu/reset.h"
31#include "hw/s390x/storage-keys.h"
32#include "hw/s390x/storage-attributes.h"
33#include "hw/s390x/event-facility.h"
34#include "ipl.h"
35#include "hw/s390x/s390-virtio-ccw.h"
36#include "hw/s390x/css-bridge.h"
37#include "hw/s390x/ap-bridge.h"
38#include "migration/register.h"
39#include "cpu_models.h"
40#include "hw/nmi.h"
41#include "hw/qdev-properties.h"
42#include "hw/s390x/tod.h"
43#include "sysemu/sysemu.h"
44
45S390CPU *s390_cpu_addr2state(uint16_t cpu_addr)
46{
47 static MachineState *ms;
48
49 if (!ms) {
50 ms = MACHINE(qdev_get_machine());
51 g_assert(ms->possible_cpus);
52 }
53
54
55 if (cpu_addr >= ms->possible_cpus->len) {
56 return NULL;
57 }
58 return S390_CPU(ms->possible_cpus->cpus[cpu_addr].cpu);
59}
60
61static S390CPU *s390x_new_cpu(const char *typename, uint32_t core_id,
62 Error **errp)
63{
64 S390CPU *cpu = S390_CPU(object_new(typename));
65 Error *err = NULL;
66
67 object_property_set_int(OBJECT(cpu), core_id, "core-id", &err);
68 if (err != NULL) {
69 goto out;
70 }
71 object_property_set_bool(OBJECT(cpu), true, "realized", &err);
72
73out:
74 object_unref(OBJECT(cpu));
75 if (err) {
76 error_propagate(errp, err);
77 cpu = NULL;
78 }
79 return cpu;
80}
81
82static void s390_init_cpus(MachineState *machine)
83{
84 MachineClass *mc = MACHINE_GET_CLASS(machine);
85 int i;
86
87
88 mc->possible_cpu_arch_ids(machine);
89
90 for (i = 0; i < machine->smp.cpus; i++) {
91 s390x_new_cpu(machine->cpu_type, i, &error_fatal);
92 }
93}
94
95static const char *const reset_dev_types[] = {
96 TYPE_VIRTUAL_CSS_BRIDGE,
97 "s390-sclp-event-facility",
98 "s390-flic",
99 "diag288",
100};
101
102static void subsystem_reset(void)
103{
104 DeviceState *dev;
105 int i;
106
107 for (i = 0; i < ARRAY_SIZE(reset_dev_types); i++) {
108 dev = DEVICE(object_resolve_path_type("", reset_dev_types[i], NULL));
109 if (dev) {
110 qdev_reset_all(dev);
111 }
112 }
113}
114
115static int virtio_ccw_hcall_notify(const uint64_t *args)
116{
117 uint64_t subch_id = args[0];
118 uint64_t queue = args[1];
119 SubchDev *sch;
120 int cssid, ssid, schid, m;
121
122 if (ioinst_disassemble_sch_ident(subch_id, &m, &cssid, &ssid, &schid)) {
123 return -EINVAL;
124 }
125 sch = css_find_subch(m, cssid, ssid, schid);
126 if (!sch || !css_subch_visible(sch)) {
127 return -EINVAL;
128 }
129 if (queue >= VIRTIO_QUEUE_MAX) {
130 return -EINVAL;
131 }
132 virtio_queue_notify(virtio_ccw_get_vdev(sch), queue);
133 return 0;
134
135}
136
137static int virtio_ccw_hcall_early_printk(const uint64_t *args)
138{
139 uint64_t mem = args[0];
140
141 if (mem < ram_size) {
142
143 return 0;
144 }
145 return -EINVAL;
146}
147
148static void virtio_ccw_register_hcalls(void)
149{
150 s390_register_virtio_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY,
151 virtio_ccw_hcall_notify);
152
153 s390_register_virtio_hypercall(KVM_S390_VIRTIO_NOTIFY,
154 virtio_ccw_hcall_early_printk);
155}
156
157static void s390_memory_init(ram_addr_t mem_size)
158{
159 MemoryRegion *sysmem = get_system_memory();
160 MemoryRegion *ram = g_new(MemoryRegion, 1);
161 Error *local_err = NULL;
162
163
164 memory_region_allocate_system_memory(ram, NULL, "s390.ram", mem_size);
165 memory_region_add_subregion(sysmem, 0, ram);
166
167
168
169
170
171 s390_set_max_pagesize(qemu_maxrampagesize(), &local_err);
172 if (local_err) {
173 error_report_err(local_err);
174 exit(EXIT_FAILURE);
175 }
176
177 s390_skeys_init();
178
179 s390_stattrib_init();
180}
181
182static void s390_init_ipl_dev(const char *kernel_filename,
183 const char *kernel_cmdline,
184 const char *initrd_filename, const char *firmware,
185 const char *netboot_fw, bool enforce_bios)
186{
187 Object *new = object_new(TYPE_S390_IPL);
188 DeviceState *dev = DEVICE(new);
189 char *netboot_fw_prop;
190
191 if (kernel_filename) {
192 qdev_prop_set_string(dev, "kernel", kernel_filename);
193 }
194 if (initrd_filename) {
195 qdev_prop_set_string(dev, "initrd", initrd_filename);
196 }
197 qdev_prop_set_string(dev, "cmdline", kernel_cmdline);
198 qdev_prop_set_string(dev, "firmware", firmware);
199 qdev_prop_set_bit(dev, "enforce_bios", enforce_bios);
200 netboot_fw_prop = object_property_get_str(new, "netboot_fw", &error_abort);
201 if (!strlen(netboot_fw_prop)) {
202 qdev_prop_set_string(dev, "netboot_fw", netboot_fw);
203 }
204 g_free(netboot_fw_prop);
205 object_property_add_child(qdev_get_machine(), TYPE_S390_IPL,
206 new, NULL);
207 object_unref(new);
208 qdev_init_nofail(dev);
209}
210
211static void s390_create_virtio_net(BusState *bus, const char *name)
212{
213 int i;
214
215 for (i = 0; i < nb_nics; i++) {
216 NICInfo *nd = &nd_table[i];
217 DeviceState *dev;
218
219 if (!nd->model) {
220 nd->model = g_strdup("virtio");
221 }
222
223 qemu_check_nic_model(nd, "virtio");
224
225 dev = qdev_create(bus, name);
226 qdev_set_nic_properties(dev, nd);
227 qdev_init_nofail(dev);
228 }
229}
230
231static void s390_create_sclpconsole(const char *type, Chardev *chardev)
232{
233 DeviceState *dev;
234
235 dev = qdev_create(sclp_get_event_facility_bus(), type);
236 qdev_prop_set_chr(dev, "chardev", chardev);
237 qdev_init_nofail(dev);
238}
239
240static void ccw_init(MachineState *machine)
241{
242 int ret;
243 VirtualCssBus *css_bus;
244 DeviceState *dev;
245
246 s390_sclp_init();
247
248 s390_memory_init(machine->ram_size);
249
250
251 s390_init_cpus(machine);
252
253 s390_flic_init();
254
255
256 s390_init_sigp();
257
258
259 s390_init_ap();
260
261
262 css_bus = virtual_css_bus_init();
263 s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline,
264 machine->initrd_filename, "s390-ccw.img",
265 "s390-netboot.img", true);
266
267 dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE);
268 object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE,
269 OBJECT(dev), NULL);
270 qdev_init_nofail(dev);
271
272
273 virtio_ccw_register_hcalls();
274
275 s390_enable_css_support(s390_cpu_addr2state(0));
276
277 ret = css_create_css_image(VIRTUAL_CSSID, true);
278
279 assert(ret == 0);
280 if (css_migration_enabled()) {
281 css_register_vmstate();
282 }
283
284
285 s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw");
286
287
288 if (serial_hd(0)) {
289 s390_create_sclpconsole("sclpconsole", serial_hd(0));
290 }
291 if (serial_hd(1)) {
292 s390_create_sclpconsole("sclplmconsole", serial_hd(1));
293 }
294
295
296 s390_init_tod();
297}
298
299static void s390_cpu_plug(HotplugHandler *hotplug_dev,
300 DeviceState *dev, Error **errp)
301{
302 MachineState *ms = MACHINE(hotplug_dev);
303 S390CPU *cpu = S390_CPU(dev);
304
305 g_assert(!ms->possible_cpus->cpus[cpu->env.core_id].cpu);
306 ms->possible_cpus->cpus[cpu->env.core_id].cpu = OBJECT(dev);
307
308 if (dev->hotplugged) {
309 raise_irq_cpu_hotplug();
310 }
311}
312
313static inline void s390_do_cpu_ipl(CPUState *cs, run_on_cpu_data arg)
314{
315 S390CPU *cpu = S390_CPU(cs);
316
317 s390_ipl_prepare_cpu(cpu);
318 s390_cpu_set_state(S390_CPU_STATE_OPERATING, cpu);
319}
320
321static void s390_machine_reset(MachineState *machine)
322{
323 enum s390_reset reset_type;
324 CPUState *cs, *t;
325
326
327 s390_ipl_get_reset_request(&cs, &reset_type);
328
329
330 s390_cmma_reset();
331
332 switch (reset_type) {
333 case S390_RESET_EXTERNAL:
334 case S390_RESET_REIPL:
335 qemu_devices_reset();
336 s390_crypto_reset();
337
338
339 run_on_cpu(cs, s390_do_cpu_ipl, RUN_ON_CPU_NULL);
340 break;
341 case S390_RESET_MODIFIED_CLEAR:
342 CPU_FOREACH(t) {
343 run_on_cpu(t, s390_do_cpu_full_reset, RUN_ON_CPU_NULL);
344 }
345 subsystem_reset();
346 s390_crypto_reset();
347 run_on_cpu(cs, s390_do_cpu_load_normal, RUN_ON_CPU_NULL);
348 break;
349 case S390_RESET_LOAD_NORMAL:
350 CPU_FOREACH(t) {
351 run_on_cpu(t, s390_do_cpu_reset, RUN_ON_CPU_NULL);
352 }
353 subsystem_reset();
354 run_on_cpu(cs, s390_do_cpu_initial_reset, RUN_ON_CPU_NULL);
355 run_on_cpu(cs, s390_do_cpu_load_normal, RUN_ON_CPU_NULL);
356 break;
357 default:
358 g_assert_not_reached();
359 }
360 s390_ipl_clear_reset_request();
361}
362
363static void s390_machine_device_plug(HotplugHandler *hotplug_dev,
364 DeviceState *dev, Error **errp)
365{
366 if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
367 s390_cpu_plug(hotplug_dev, dev, errp);
368 }
369}
370
371static void s390_machine_device_unplug_request(HotplugHandler *hotplug_dev,
372 DeviceState *dev, Error **errp)
373{
374 if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
375 error_setg(errp, "CPU hot unplug not supported on this machine");
376 return;
377 }
378}
379
380static CpuInstanceProperties s390_cpu_index_to_props(MachineState *ms,
381 unsigned cpu_index)
382{
383 MachineClass *mc = MACHINE_GET_CLASS(ms);
384 const CPUArchIdList *possible_cpus = mc->possible_cpu_arch_ids(ms);
385
386 assert(cpu_index < possible_cpus->len);
387 return possible_cpus->cpus[cpu_index].props;
388}
389
390static const CPUArchIdList *s390_possible_cpu_arch_ids(MachineState *ms)
391{
392 int i;
393 unsigned int max_cpus = ms->smp.max_cpus;
394
395 if (ms->possible_cpus) {
396 g_assert(ms->possible_cpus && ms->possible_cpus->len == max_cpus);
397 return ms->possible_cpus;
398 }
399
400 ms->possible_cpus = g_malloc0(sizeof(CPUArchIdList) +
401 sizeof(CPUArchId) * max_cpus);
402 ms->possible_cpus->len = max_cpus;
403 for (i = 0; i < ms->possible_cpus->len; i++) {
404 ms->possible_cpus->cpus[i].type = ms->cpu_type;
405 ms->possible_cpus->cpus[i].vcpus_count = 1;
406 ms->possible_cpus->cpus[i].arch_id = i;
407 ms->possible_cpus->cpus[i].props.has_core_id = true;
408 ms->possible_cpus->cpus[i].props.core_id = i;
409 }
410
411 return ms->possible_cpus;
412}
413
414static HotplugHandler *s390_get_hotplug_handler(MachineState *machine,
415 DeviceState *dev)
416{
417 if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
418 return HOTPLUG_HANDLER(machine);
419 }
420 return NULL;
421}
422
423static void s390_hot_add_cpu(MachineState *machine,
424 const int64_t id, Error **errp)
425{
426 ObjectClass *oc;
427
428 g_assert(machine->possible_cpus->cpus[0].cpu);
429 oc = OBJECT_CLASS(CPU_GET_CLASS(machine->possible_cpus->cpus[0].cpu));
430
431 s390x_new_cpu(object_class_get_name(oc), id, errp);
432}
433
434static void s390_nmi(NMIState *n, int cpu_index, Error **errp)
435{
436 CPUState *cs = qemu_get_cpu(cpu_index);
437
438 s390_cpu_restart(S390_CPU(cs));
439}
440
441static void ccw_machine_class_init(ObjectClass *oc, void *data)
442{
443 MachineClass *mc = MACHINE_CLASS(oc);
444 NMIClass *nc = NMI_CLASS(oc);
445 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
446 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
447
448 s390mc->ri_allowed = true;
449 s390mc->cpu_model_allowed = true;
450 s390mc->css_migration_enabled = true;
451 s390mc->hpage_1m_allowed = true;
452 mc->init = ccw_init;
453 mc->reset = s390_machine_reset;
454 mc->hot_add_cpu = s390_hot_add_cpu;
455 mc->block_default_type = IF_VIRTIO;
456 mc->no_cdrom = 1;
457 mc->no_floppy = 1;
458 mc->no_parallel = 1;
459 mc->no_sdcard = 1;
460 mc->max_cpus = S390_MAX_CPUS;
461 mc->has_hotpluggable_cpus = true;
462 assert(!mc->get_hotplug_handler);
463 mc->get_hotplug_handler = s390_get_hotplug_handler;
464 mc->cpu_index_to_instance_props = s390_cpu_index_to_props;
465 mc->possible_cpu_arch_ids = s390_possible_cpu_arch_ids;
466
467 mc->default_cpu_type = S390_CPU_TYPE_NAME("qemu");
468 hc->plug = s390_machine_device_plug;
469 hc->unplug_request = s390_machine_device_unplug_request;
470 nc->nmi_monitor_handler = s390_nmi;
471}
472
473static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp)
474{
475 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
476
477 return ms->aes_key_wrap;
478}
479
480static inline void machine_set_aes_key_wrap(Object *obj, bool value,
481 Error **errp)
482{
483 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
484
485 ms->aes_key_wrap = value;
486}
487
488static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp)
489{
490 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
491
492 return ms->dea_key_wrap;
493}
494
495static inline void machine_set_dea_key_wrap(Object *obj, bool value,
496 Error **errp)
497{
498 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
499
500 ms->dea_key_wrap = value;
501}
502
503static S390CcwMachineClass *current_mc;
504
505static S390CcwMachineClass *get_machine_class(void)
506{
507 if (unlikely(!current_mc)) {
508
509
510
511
512
513 current_mc = S390_MACHINE_CLASS(
514 object_class_by_name(TYPE_S390_CCW_MACHINE));
515 }
516 return current_mc;
517}
518
519bool ri_allowed(void)
520{
521
522 return get_machine_class()->ri_allowed;
523}
524
525bool cpu_model_allowed(void)
526{
527
528 return get_machine_class()->cpu_model_allowed;
529}
530
531bool hpage_1m_allowed(void)
532{
533
534 return get_machine_class()->hpage_1m_allowed;
535}
536
537static char *machine_get_loadparm(Object *obj, Error **errp)
538{
539 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
540
541 return g_memdup(ms->loadparm, sizeof(ms->loadparm));
542}
543
544static void machine_set_loadparm(Object *obj, const char *val, Error **errp)
545{
546 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
547 int i;
548
549 for (i = 0; i < sizeof(ms->loadparm) && val[i]; i++) {
550 uint8_t c = qemu_toupper(val[i]);
551
552 if (('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || (c == '.') ||
553 (c == ' ')) {
554 ms->loadparm[i] = c;
555 } else {
556 error_setg(errp, "LOADPARM: invalid character '%c' (ASCII 0x%02x)",
557 c, c);
558 return;
559 }
560 }
561
562 for (; i < sizeof(ms->loadparm); i++) {
563 ms->loadparm[i] = ' ';
564 }
565}
566static inline void s390_machine_initfn(Object *obj)
567{
568 object_property_add_bool(obj, "aes-key-wrap",
569 machine_get_aes_key_wrap,
570 machine_set_aes_key_wrap, NULL);
571 object_property_set_description(obj, "aes-key-wrap",
572 "enable/disable AES key wrapping using the CPACF wrapping key",
573 NULL);
574 object_property_set_bool(obj, true, "aes-key-wrap", NULL);
575
576 object_property_add_bool(obj, "dea-key-wrap",
577 machine_get_dea_key_wrap,
578 machine_set_dea_key_wrap, NULL);
579 object_property_set_description(obj, "dea-key-wrap",
580 "enable/disable DEA key wrapping using the CPACF wrapping key",
581 NULL);
582 object_property_set_bool(obj, true, "dea-key-wrap", NULL);
583 object_property_add_str(obj, "loadparm",
584 machine_get_loadparm, machine_set_loadparm, NULL);
585 object_property_set_description(obj, "loadparm",
586 "Up to 8 chars in set of [A-Za-z0-9. ] (lower case chars converted"
587 " to upper case) to pass to machine loader, boot manager,"
588 " and guest kernel",
589 NULL);
590}
591
592static const TypeInfo ccw_machine_info = {
593 .name = TYPE_S390_CCW_MACHINE,
594 .parent = TYPE_MACHINE,
595 .abstract = true,
596 .instance_size = sizeof(S390CcwMachineState),
597 .instance_init = s390_machine_initfn,
598 .class_size = sizeof(S390CcwMachineClass),
599 .class_init = ccw_machine_class_init,
600 .interfaces = (InterfaceInfo[]) {
601 { TYPE_NMI },
602 { TYPE_HOTPLUG_HANDLER},
603 { }
604 },
605};
606
607bool css_migration_enabled(void)
608{
609 return get_machine_class()->css_migration_enabled;
610}
611
612#define DEFINE_CCW_MACHINE(suffix, verstr, latest) \
613 static void ccw_machine_##suffix##_class_init(ObjectClass *oc, \
614 void *data) \
615 { \
616 MachineClass *mc = MACHINE_CLASS(oc); \
617 ccw_machine_##suffix##_class_options(mc); \
618 mc->desc = "VirtIO-ccw based S390 machine v" verstr; \
619 if (latest) { \
620 mc->alias = "s390-ccw-virtio"; \
621 mc->is_default = 1; \
622 } \
623 } \
624 static void ccw_machine_##suffix##_instance_init(Object *obj) \
625 { \
626 MachineState *machine = MACHINE(obj); \
627 current_mc = S390_MACHINE_CLASS(MACHINE_GET_CLASS(machine)); \
628 ccw_machine_##suffix##_instance_options(machine); \
629 } \
630 static const TypeInfo ccw_machine_##suffix##_info = { \
631 .name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr), \
632 .parent = TYPE_S390_CCW_MACHINE, \
633 .class_init = ccw_machine_##suffix##_class_init, \
634 .instance_init = ccw_machine_##suffix##_instance_init, \
635 }; \
636 static void ccw_machine_register_##suffix(void) \
637 { \
638 type_register_static(&ccw_machine_##suffix##_info); \
639 } \
640 type_init(ccw_machine_register_##suffix)
641
642static void ccw_machine_4_2_instance_options(MachineState *machine)
643{
644}
645
646static void ccw_machine_4_2_class_options(MachineClass *mc)
647{
648}
649DEFINE_CCW_MACHINE(4_2, "4.2", true);
650
651static void ccw_machine_4_1_instance_options(MachineState *machine)
652{
653 static const S390FeatInit qemu_cpu_feat = { S390_FEAT_LIST_QEMU_V4_1 };
654 ccw_machine_4_2_instance_options(machine);
655 s390_set_qemu_cpu_model(0x2964, 13, 2, qemu_cpu_feat);
656}
657
658static void ccw_machine_4_1_class_options(MachineClass *mc)
659{
660 ccw_machine_4_2_class_options(mc);
661 compat_props_add(mc->compat_props, hw_compat_4_1, hw_compat_4_1_len);
662}
663DEFINE_CCW_MACHINE(4_1, "4.1", false);
664
665static void ccw_machine_4_0_instance_options(MachineState *machine)
666{
667 static const S390FeatInit qemu_cpu_feat = { S390_FEAT_LIST_QEMU_V4_0 };
668 ccw_machine_4_1_instance_options(machine);
669 s390_set_qemu_cpu_model(0x2827, 12, 2, qemu_cpu_feat);
670}
671
672static void ccw_machine_4_0_class_options(MachineClass *mc)
673{
674 ccw_machine_4_1_class_options(mc);
675 compat_props_add(mc->compat_props, hw_compat_4_0, hw_compat_4_0_len);
676}
677DEFINE_CCW_MACHINE(4_0, "4.0", false);
678
679static void ccw_machine_3_1_instance_options(MachineState *machine)
680{
681 static const S390FeatInit qemu_cpu_feat = { S390_FEAT_LIST_QEMU_V3_1 };
682 ccw_machine_4_0_instance_options(machine);
683 s390_cpudef_featoff_greater(14, 1, S390_FEAT_MULTIPLE_EPOCH);
684 s390_cpudef_group_featoff_greater(14, 1, S390_FEAT_GROUP_MULTIPLE_EPOCH_PTFF);
685 s390_set_qemu_cpu_model(0x2827, 12, 2, qemu_cpu_feat);
686}
687
688static void ccw_machine_3_1_class_options(MachineClass *mc)
689{
690 ccw_machine_4_0_class_options(mc);
691 compat_props_add(mc->compat_props, hw_compat_3_1, hw_compat_3_1_len);
692}
693DEFINE_CCW_MACHINE(3_1, "3.1", false);
694
695static void ccw_machine_3_0_instance_options(MachineState *machine)
696{
697 ccw_machine_3_1_instance_options(machine);
698}
699
700static void ccw_machine_3_0_class_options(MachineClass *mc)
701{
702 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
703
704 s390mc->hpage_1m_allowed = false;
705 ccw_machine_3_1_class_options(mc);
706 compat_props_add(mc->compat_props, hw_compat_3_0, hw_compat_3_0_len);
707}
708DEFINE_CCW_MACHINE(3_0, "3.0", false);
709
710static void ccw_machine_2_12_instance_options(MachineState *machine)
711{
712 ccw_machine_3_0_instance_options(machine);
713 s390_cpudef_featoff_greater(11, 1, S390_FEAT_PPA15);
714 s390_cpudef_featoff_greater(11, 1, S390_FEAT_BPB);
715}
716
717static void ccw_machine_2_12_class_options(MachineClass *mc)
718{
719 ccw_machine_3_0_class_options(mc);
720 compat_props_add(mc->compat_props, hw_compat_2_12, hw_compat_2_12_len);
721}
722DEFINE_CCW_MACHINE(2_12, "2.12", false);
723
724static void ccw_machine_2_11_instance_options(MachineState *machine)
725{
726 static const S390FeatInit qemu_cpu_feat = { S390_FEAT_LIST_QEMU_V2_11 };
727 ccw_machine_2_12_instance_options(machine);
728
729
730 s390_set_qemu_cpu_model(0x2064, 7, 1, qemu_cpu_feat);
731}
732
733static void ccw_machine_2_11_class_options(MachineClass *mc)
734{
735 static GlobalProperty compat[] = {
736 { TYPE_SCLP_EVENT_FACILITY, "allow_all_mask_sizes", "off", },
737 };
738
739 ccw_machine_2_12_class_options(mc);
740 compat_props_add(mc->compat_props, hw_compat_2_11, hw_compat_2_11_len);
741 compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
742}
743DEFINE_CCW_MACHINE(2_11, "2.11", false);
744
745static void ccw_machine_2_10_instance_options(MachineState *machine)
746{
747 ccw_machine_2_11_instance_options(machine);
748}
749
750static void ccw_machine_2_10_class_options(MachineClass *mc)
751{
752 ccw_machine_2_11_class_options(mc);
753 compat_props_add(mc->compat_props, hw_compat_2_10, hw_compat_2_10_len);
754}
755DEFINE_CCW_MACHINE(2_10, "2.10", false);
756
757static void ccw_machine_2_9_instance_options(MachineState *machine)
758{
759 ccw_machine_2_10_instance_options(machine);
760 s390_cpudef_featoff_greater(12, 1, S390_FEAT_ESOP);
761 s390_cpudef_featoff_greater(12, 1, S390_FEAT_SIDE_EFFECT_ACCESS_ESOP2);
762 s390_cpudef_featoff_greater(12, 1, S390_FEAT_ZPCI);
763 s390_cpudef_featoff_greater(12, 1, S390_FEAT_ADAPTER_INT_SUPPRESSION);
764 s390_cpudef_featoff_greater(12, 1, S390_FEAT_ADAPTER_EVENT_NOTIFICATION);
765}
766
767static void ccw_machine_2_9_class_options(MachineClass *mc)
768{
769 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
770 static GlobalProperty compat[] = {
771 { TYPE_S390_STATTRIB, "migration-enabled", "off", },
772 };
773
774 ccw_machine_2_10_class_options(mc);
775 compat_props_add(mc->compat_props, hw_compat_2_9, hw_compat_2_9_len);
776 compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
777 s390mc->css_migration_enabled = false;
778}
779DEFINE_CCW_MACHINE(2_9, "2.9", false);
780
781static void ccw_machine_2_8_instance_options(MachineState *machine)
782{
783 ccw_machine_2_9_instance_options(machine);
784}
785
786static void ccw_machine_2_8_class_options(MachineClass *mc)
787{
788 static GlobalProperty compat[] = {
789 { TYPE_S390_FLIC_COMMON, "adapter_routes_max_batch", "64", },
790 };
791
792 ccw_machine_2_9_class_options(mc);
793 compat_props_add(mc->compat_props, hw_compat_2_8, hw_compat_2_8_len);
794 compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
795}
796DEFINE_CCW_MACHINE(2_8, "2.8", false);
797
798static void ccw_machine_2_7_instance_options(MachineState *machine)
799{
800 ccw_machine_2_8_instance_options(machine);
801}
802
803static void ccw_machine_2_7_class_options(MachineClass *mc)
804{
805 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
806
807 s390mc->cpu_model_allowed = false;
808 ccw_machine_2_8_class_options(mc);
809 compat_props_add(mc->compat_props, hw_compat_2_7, hw_compat_2_7_len);
810}
811DEFINE_CCW_MACHINE(2_7, "2.7", false);
812
813static void ccw_machine_2_6_instance_options(MachineState *machine)
814{
815 ccw_machine_2_7_instance_options(machine);
816}
817
818static void ccw_machine_2_6_class_options(MachineClass *mc)
819{
820 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
821 static GlobalProperty compat[] = {
822 { TYPE_S390_IPL, "iplbext_migration", "off", },
823 { TYPE_VIRTUAL_CSS_BRIDGE, "css_dev_path", "off", },
824 };
825
826 s390mc->ri_allowed = false;
827 ccw_machine_2_7_class_options(mc);
828 compat_props_add(mc->compat_props, hw_compat_2_6, hw_compat_2_6_len);
829 compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
830}
831DEFINE_CCW_MACHINE(2_6, "2.6", false);
832
833static void ccw_machine_2_5_instance_options(MachineState *machine)
834{
835 ccw_machine_2_6_instance_options(machine);
836}
837
838static void ccw_machine_2_5_class_options(MachineClass *mc)
839{
840 ccw_machine_2_6_class_options(mc);
841 compat_props_add(mc->compat_props, hw_compat_2_5, hw_compat_2_5_len);
842}
843DEFINE_CCW_MACHINE(2_5, "2.5", false);
844
845static void ccw_machine_2_4_instance_options(MachineState *machine)
846{
847 ccw_machine_2_5_instance_options(machine);
848}
849
850static void ccw_machine_2_4_class_options(MachineClass *mc)
851{
852 static GlobalProperty compat[] = {
853 { TYPE_S390_SKEYS, "migration-enabled", "off", },
854 { "virtio-blk-ccw", "max_revision", "0", },
855 { "virtio-balloon-ccw", "max_revision", "0", },
856 { "virtio-serial-ccw", "max_revision", "0", },
857 { "virtio-9p-ccw", "max_revision", "0", },
858 { "virtio-rng-ccw", "max_revision", "0", },
859 { "virtio-net-ccw", "max_revision", "0", },
860 { "virtio-scsi-ccw", "max_revision", "0", },
861 { "vhost-scsi-ccw", "max_revision", "0", },
862 };
863
864 ccw_machine_2_5_class_options(mc);
865 compat_props_add(mc->compat_props, hw_compat_2_4, hw_compat_2_4_len);
866 compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
867}
868DEFINE_CCW_MACHINE(2_4, "2.4", false);
869
870static void ccw_machine_register_types(void)
871{
872 type_register_static(&ccw_machine_info);
873}
874
875type_init(ccw_machine_register_types)
876
