]>
Commit | Line | Data |
---|---|---|
a5c95808 CH |
1 | /* |
2 | * virtio ccw machine | |
3 | * | |
4 | * Copyright 2012 IBM Corp. | |
5 | * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com> | |
6 | * | |
7 | * This work is licensed under the terms of the GNU GPL, version 2 or (at | |
8 | * your option) any later version. See the COPYING file in the top-level | |
9 | * directory. | |
10 | */ | |
11 | ||
9615495a | 12 | #include "qemu/osdep.h" |
da34e65c | 13 | #include "qapi/error.h" |
4771d756 PB |
14 | #include "qemu-common.h" |
15 | #include "cpu.h" | |
a5c95808 CH |
16 | #include "hw/boards.h" |
17 | #include "exec/address-spaces.h" | |
18 | #include "s390-virtio.h" | |
83c9f4ca | 19 | #include "hw/s390x/sclp.h" |
3a553fc6 | 20 | #include "hw/s390x/s390_flic.h" |
bd3f16ac PB |
21 | #include "hw/s390x/ioinst.h" |
22 | #include "hw/s390x/css.h" | |
a5c95808 | 23 | #include "virtio-ccw.h" |
b6fe0124 | 24 | #include "qemu/config-file.h" |
8cba80c3 | 25 | #include "s390-pci-bus.h" |
0f5f6691 | 26 | #include "hw/s390x/storage-keys.h" |
54d8ec84 | 27 | #include "hw/compat.h" |
04ca4b92 | 28 | #include "ipl.h" |
8b8a61ad | 29 | #include "hw/s390x/s390-virtio-ccw.h" |
dd70bd0d | 30 | #include "hw/s390x/css-bridge.h" |
2eb1cd07 | 31 | |
09c7f58c | 32 | static const char *const reset_dev_types[] = { |
3f9e4859 | 33 | TYPE_VIRTUAL_CSS_BRIDGE, |
09c7f58c DH |
34 | "s390-sclp-event-facility", |
35 | "s390-flic", | |
36 | "diag288", | |
37 | }; | |
38 | ||
d9f090ec | 39 | void subsystem_reset(void) |
4e872a3f | 40 | { |
09c7f58c DH |
41 | DeviceState *dev; |
42 | int i; | |
4e872a3f | 43 | |
09c7f58c DH |
44 | for (i = 0; i < ARRAY_SIZE(reset_dev_types); i++) { |
45 | dev = DEVICE(object_resolve_path_type("", reset_dev_types[i], NULL)); | |
46 | if (dev) { | |
47 | qdev_reset_all(dev); | |
48 | } | |
0c7322cf | 49 | } |
4e872a3f CB |
50 | } |
51 | ||
a5c95808 CH |
52 | static int virtio_ccw_hcall_notify(const uint64_t *args) |
53 | { | |
54 | uint64_t subch_id = args[0]; | |
55 | uint64_t queue = args[1]; | |
56 | SubchDev *sch; | |
57 | int cssid, ssid, schid, m; | |
58 | ||
59 | if (ioinst_disassemble_sch_ident(subch_id, &m, &cssid, &ssid, &schid)) { | |
60 | return -EINVAL; | |
61 | } | |
62 | sch = css_find_subch(m, cssid, ssid, schid); | |
63 | if (!sch || !css_subch_visible(sch)) { | |
64 | return -EINVAL; | |
65 | } | |
b1914b82 | 66 | if (queue >= VIRTIO_QUEUE_MAX) { |
b57ed9bf CH |
67 | return -EINVAL; |
68 | } | |
a5c95808 CH |
69 | virtio_queue_notify(virtio_ccw_get_vdev(sch), queue); |
70 | return 0; | |
71 | ||
72 | } | |
73 | ||
74 | static int virtio_ccw_hcall_early_printk(const uint64_t *args) | |
75 | { | |
76 | uint64_t mem = args[0]; | |
77 | ||
78 | if (mem < ram_size) { | |
79 | /* Early printk */ | |
80 | return 0; | |
81 | } | |
82 | return -EINVAL; | |
83 | } | |
84 | ||
85 | static void virtio_ccw_register_hcalls(void) | |
86 | { | |
87 | s390_register_virtio_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY, | |
88 | virtio_ccw_hcall_notify); | |
89 | /* Tolerate early printk. */ | |
90 | s390_register_virtio_hypercall(KVM_S390_VIRTIO_NOTIFY, | |
91 | virtio_ccw_hcall_early_printk); | |
92 | } | |
93 | ||
80d23275 | 94 | void s390_memory_init(ram_addr_t mem_size) |
a5c95808 | 95 | { |
a5c95808 CH |
96 | MemoryRegion *sysmem = get_system_memory(); |
97 | MemoryRegion *ram = g_new(MemoryRegion, 1); | |
80d23275 DH |
98 | |
99 | /* allocate RAM for core */ | |
ae23a335 | 100 | memory_region_allocate_system_memory(ram, NULL, "s390.ram", mem_size); |
80d23275 DH |
101 | memory_region_add_subregion(sysmem, 0, ram); |
102 | ||
103 | /* Initialize storage key device */ | |
104 | s390_skeys_init(); | |
105 | } | |
106 | ||
1b6e7482 LV |
107 | static SaveVMHandlers savevm_gtod = { |
108 | .save_state = gtod_save, | |
109 | .load_state = gtod_load, | |
110 | }; | |
111 | ||
80d23275 DH |
112 | static void ccw_init(MachineState *machine) |
113 | { | |
a5c95808 CH |
114 | int ret; |
115 | VirtualCssBus *css_bus; | |
8cba80c3 | 116 | DeviceState *dev; |
b6fe0124 | 117 | |
1cf065fb | 118 | s390_sclp_init(); |
80d23275 | 119 | s390_memory_init(machine->ram_size); |
a5c95808 | 120 | |
c572d3f3 FL |
121 | s390_flic_init(); |
122 | ||
a5c95808 CH |
123 | /* get a BUS */ |
124 | css_bus = virtual_css_bus_init(); | |
3ef96221 | 125 | s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline, |
5f31ade0 FA |
126 | machine->initrd_filename, "s390-ccw.img", |
127 | "s390-netboot.img", true); | |
a5c95808 | 128 | |
8cba80c3 FB |
129 | dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE); |
130 | object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE, | |
131 | OBJECT(dev), NULL); | |
132 | qdev_init_nofail(dev); | |
133 | ||
a5c95808 CH |
134 | /* register hypercalls */ |
135 | virtio_ccw_register_hcalls(); | |
136 | ||
a5c95808 | 137 | /* init CPUs */ |
d2eae207 | 138 | s390_init_cpus(machine); |
a5c95808 CH |
139 | |
140 | if (kvm_enabled()) { | |
141 | kvm_s390_enable_css_support(s390_cpu_addr2state(0)); | |
142 | } | |
143 | /* | |
817d4a6b DJS |
144 | * Non mcss-e enabled guests only see the devices from the default |
145 | * css, which is determined by the value of the squash_mcss property. | |
146 | * Note: we must not squash non virtual devices to css 0xFE. | |
a5c95808 | 147 | */ |
817d4a6b DJS |
148 | if (css_bus->squash_mcss) { |
149 | ret = css_create_css_image(0, true); | |
150 | } else { | |
151 | ret = css_create_css_image(VIRTUAL_CSSID, true); | |
152 | } | |
a5c95808 CH |
153 | assert(ret == 0); |
154 | ||
155 | /* Create VirtIO network adapters */ | |
156 | s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw"); | |
3f9e59bb JH |
157 | |
158 | /* Register savevm handler for guest TOD clock */ | |
1b6e7482 | 159 | register_savevm_live(NULL, "todclock", 0, 1, &savevm_gtod, kvm_state); |
a5c95808 CH |
160 | } |
161 | ||
502edbf8 MR |
162 | static void s390_cpu_plug(HotplugHandler *hotplug_dev, |
163 | DeviceState *dev, Error **errp) | |
164 | { | |
165 | gchar *name; | |
166 | S390CPU *cpu = S390_CPU(dev); | |
167 | CPUState *cs = CPU(dev); | |
168 | ||
169 | name = g_strdup_printf("cpu[%i]", cpu->env.cpu_num); | |
170 | object_property_set_link(OBJECT(hotplug_dev), OBJECT(cs), name, | |
171 | errp); | |
172 | g_free(name); | |
173 | } | |
174 | ||
175 | static void s390_machine_device_plug(HotplugHandler *hotplug_dev, | |
176 | DeviceState *dev, Error **errp) | |
177 | { | |
178 | if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) { | |
179 | s390_cpu_plug(hotplug_dev, dev, errp); | |
180 | } | |
181 | } | |
182 | ||
183 | static HotplugHandler *s390_get_hotplug_handler(MachineState *machine, | |
184 | DeviceState *dev) | |
185 | { | |
186 | if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) { | |
187 | return HOTPLUG_HANDLER(machine); | |
188 | } | |
189 | return NULL; | |
190 | } | |
191 | ||
a006b67f MR |
192 | static void s390_hot_add_cpu(const int64_t id, Error **errp) |
193 | { | |
194 | MachineState *machine = MACHINE(qdev_get_machine()); | |
a006b67f | 195 | |
6b62d961 | 196 | s390x_new_cpu(machine->cpu_model, id, errp); |
a006b67f MR |
197 | } |
198 | ||
d07aa7c7 AK |
199 | static void ccw_machine_class_init(ObjectClass *oc, void *data) |
200 | { | |
201 | MachineClass *mc = MACHINE_CLASS(oc); | |
3dd7852f | 202 | NMIClass *nc = NMI_CLASS(oc); |
502edbf8 | 203 | HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); |
9700230b | 204 | S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); |
d07aa7c7 | 205 | |
9700230b | 206 | s390mc->ri_allowed = true; |
e73316d5 | 207 | s390mc->cpu_model_allowed = true; |
d07aa7c7 | 208 | mc->init = ccw_init; |
db3b2566 | 209 | mc->reset = s390_machine_reset; |
a006b67f | 210 | mc->hot_add_cpu = s390_hot_add_cpu; |
d07aa7c7 AK |
211 | mc->block_default_type = IF_VIRTIO; |
212 | mc->no_cdrom = 1; | |
213 | mc->no_floppy = 1; | |
214 | mc->no_serial = 1; | |
215 | mc->no_parallel = 1; | |
216 | mc->no_sdcard = 1; | |
fb85b34d | 217 | mc->use_sclp = 1; |
dcddc75e | 218 | mc->max_cpus = 248; |
502edbf8 MR |
219 | mc->get_hotplug_handler = s390_get_hotplug_handler; |
220 | hc->plug = s390_machine_device_plug; | |
3dd7852f | 221 | nc->nmi_monitor_handler = s390_nmi; |
d07aa7c7 AK |
222 | } |
223 | ||
2eb1cd07 TK |
224 | static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp) |
225 | { | |
226 | S390CcwMachineState *ms = S390_CCW_MACHINE(obj); | |
227 | ||
228 | return ms->aes_key_wrap; | |
229 | } | |
230 | ||
231 | static inline void machine_set_aes_key_wrap(Object *obj, bool value, | |
232 | Error **errp) | |
233 | { | |
234 | S390CcwMachineState *ms = S390_CCW_MACHINE(obj); | |
235 | ||
236 | ms->aes_key_wrap = value; | |
237 | } | |
238 | ||
239 | static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp) | |
240 | { | |
241 | S390CcwMachineState *ms = S390_CCW_MACHINE(obj); | |
242 | ||
243 | return ms->dea_key_wrap; | |
244 | } | |
245 | ||
246 | static inline void machine_set_dea_key_wrap(Object *obj, bool value, | |
247 | Error **errp) | |
248 | { | |
249 | S390CcwMachineState *ms = S390_CCW_MACHINE(obj); | |
250 | ||
251 | ms->dea_key_wrap = value; | |
252 | } | |
253 | ||
9700230b FZ |
254 | bool ri_allowed(void) |
255 | { | |
256 | if (kvm_enabled()) { | |
257 | MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); | |
258 | if (object_class_dynamic_cast(OBJECT_CLASS(mc), | |
259 | TYPE_S390_CCW_MACHINE)) { | |
260 | S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); | |
261 | ||
262 | return s390mc->ri_allowed; | |
263 | } | |
392529cb DH |
264 | /* |
265 | * Make sure the "none" machine can have ri, otherwise it won't * be | |
266 | * unlocked in KVM and therefore the host CPU model might be wrong. | |
267 | */ | |
268 | return true; | |
9700230b FZ |
269 | } |
270 | return 0; | |
271 | } | |
272 | ||
e73316d5 CB |
273 | bool cpu_model_allowed(void) |
274 | { | |
275 | MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); | |
276 | if (object_class_dynamic_cast(OBJECT_CLASS(mc), | |
277 | TYPE_S390_CCW_MACHINE)) { | |
278 | S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); | |
279 | ||
280 | return s390mc->cpu_model_allowed; | |
281 | } | |
282 | /* allow CPU model qmp queries with the "none" machine */ | |
283 | return true; | |
284 | } | |
285 | ||
7104bae9 FA |
286 | static char *machine_get_loadparm(Object *obj, Error **errp) |
287 | { | |
288 | S390CcwMachineState *ms = S390_CCW_MACHINE(obj); | |
289 | ||
290 | return g_memdup(ms->loadparm, sizeof(ms->loadparm)); | |
291 | } | |
292 | ||
293 | static void machine_set_loadparm(Object *obj, const char *val, Error **errp) | |
294 | { | |
295 | S390CcwMachineState *ms = S390_CCW_MACHINE(obj); | |
296 | int i; | |
297 | ||
298 | for (i = 0; i < sizeof(ms->loadparm) && val[i]; i++) { | |
299 | uint8_t c = toupper(val[i]); /* mimic HMC */ | |
300 | ||
301 | if (('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || (c == '.') || | |
302 | (c == ' ')) { | |
303 | ms->loadparm[i] = c; | |
304 | } else { | |
305 | error_setg(errp, "LOADPARM: invalid character '%c' (ASCII 0x%02x)", | |
306 | c, c); | |
307 | return; | |
308 | } | |
309 | } | |
310 | ||
311 | for (; i < sizeof(ms->loadparm); i++) { | |
312 | ms->loadparm[i] = ' '; /* pad right with spaces */ | |
313 | } | |
314 | } | |
274250c3 XFR |
315 | static inline bool machine_get_squash_mcss(Object *obj, Error **errp) |
316 | { | |
317 | S390CcwMachineState *ms = S390_CCW_MACHINE(obj); | |
318 | ||
319 | return ms->s390_squash_mcss; | |
320 | } | |
321 | ||
322 | static inline void machine_set_squash_mcss(Object *obj, bool value, | |
323 | Error **errp) | |
324 | { | |
325 | S390CcwMachineState *ms = S390_CCW_MACHINE(obj); | |
326 | ||
327 | ms->s390_squash_mcss = value; | |
328 | } | |
7104bae9 | 329 | |
2eb1cd07 TK |
330 | static inline void s390_machine_initfn(Object *obj) |
331 | { | |
332 | object_property_add_bool(obj, "aes-key-wrap", | |
333 | machine_get_aes_key_wrap, | |
334 | machine_set_aes_key_wrap, NULL); | |
335 | object_property_set_description(obj, "aes-key-wrap", | |
336 | "enable/disable AES key wrapping using the CPACF wrapping key", | |
337 | NULL); | |
338 | object_property_set_bool(obj, true, "aes-key-wrap", NULL); | |
339 | ||
340 | object_property_add_bool(obj, "dea-key-wrap", | |
341 | machine_get_dea_key_wrap, | |
342 | machine_set_dea_key_wrap, NULL); | |
343 | object_property_set_description(obj, "dea-key-wrap", | |
344 | "enable/disable DEA key wrapping using the CPACF wrapping key", | |
345 | NULL); | |
346 | object_property_set_bool(obj, true, "dea-key-wrap", NULL); | |
7104bae9 FA |
347 | object_property_add_str(obj, "loadparm", |
348 | machine_get_loadparm, machine_set_loadparm, NULL); | |
349 | object_property_set_description(obj, "loadparm", | |
350 | "Up to 8 chars in set of [A-Za-z0-9. ] (lower case chars converted" | |
351 | " to upper case) to pass to machine loader, boot manager," | |
352 | " and guest kernel", | |
353 | NULL); | |
274250c3 XFR |
354 | object_property_add_bool(obj, "s390-squash-mcss", |
355 | machine_get_squash_mcss, | |
356 | machine_set_squash_mcss, NULL); | |
357 | object_property_set_description(obj, "s390-squash-mcss", | |
358 | "enable/disable squashing subchannels into the default css", | |
359 | NULL); | |
360 | object_property_set_bool(obj, false, "s390-squash-mcss", NULL); | |
2eb1cd07 TK |
361 | } |
362 | ||
d07aa7c7 AK |
363 | static const TypeInfo ccw_machine_info = { |
364 | .name = TYPE_S390_CCW_MACHINE, | |
365 | .parent = TYPE_MACHINE, | |
c4d3c0a2 | 366 | .abstract = true, |
2eb1cd07 TK |
367 | .instance_size = sizeof(S390CcwMachineState), |
368 | .instance_init = s390_machine_initfn, | |
9700230b | 369 | .class_size = sizeof(S390CcwMachineClass), |
d07aa7c7 | 370 | .class_init = ccw_machine_class_init, |
3dd7852f AK |
371 | .interfaces = (InterfaceInfo[]) { |
372 | { TYPE_NMI }, | |
502edbf8 | 373 | { TYPE_HOTPLUG_HANDLER}, |
3dd7852f AK |
374 | { } |
375 | }, | |
a5c95808 CH |
376 | }; |
377 | ||
4fca6548 JF |
378 | #define DEFINE_CCW_MACHINE(suffix, verstr, latest) \ |
379 | static void ccw_machine_##suffix##_class_init(ObjectClass *oc, \ | |
380 | void *data) \ | |
381 | { \ | |
382 | MachineClass *mc = MACHINE_CLASS(oc); \ | |
383 | ccw_machine_##suffix##_class_options(mc); \ | |
384 | mc->desc = "VirtIO-ccw based S390 machine v" verstr; \ | |
385 | if (latest) { \ | |
386 | mc->alias = "s390-ccw-virtio"; \ | |
387 | mc->is_default = 1; \ | |
388 | } \ | |
389 | } \ | |
390 | static void ccw_machine_##suffix##_instance_init(Object *obj) \ | |
391 | { \ | |
392 | MachineState *machine = MACHINE(obj); \ | |
393 | ccw_machine_##suffix##_instance_options(machine); \ | |
394 | } \ | |
395 | static const TypeInfo ccw_machine_##suffix##_info = { \ | |
396 | .name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr), \ | |
397 | .parent = TYPE_S390_CCW_MACHINE, \ | |
398 | .class_init = ccw_machine_##suffix##_class_init, \ | |
399 | .instance_init = ccw_machine_##suffix##_instance_init, \ | |
400 | }; \ | |
401 | static void ccw_machine_register_##suffix(void) \ | |
402 | { \ | |
403 | type_register_static(&ccw_machine_##suffix##_info); \ | |
404 | } \ | |
0e6aac87 | 405 | type_init(ccw_machine_register_##suffix) |
4fca6548 | 406 | |
10890873 CH |
407 | #define CCW_COMPAT_2_9 \ |
408 | HW_COMPAT_2_9 | |
409 | ||
113725a6 | 410 | #define CCW_COMPAT_2_8 \ |
069097da HP |
411 | HW_COMPAT_2_8 \ |
412 | {\ | |
413 | .driver = TYPE_S390_FLIC_COMMON,\ | |
414 | .property = "adapter_routes_max_batch",\ | |
415 | .value = "64",\ | |
416 | }, | |
113725a6 | 417 | |
61823988 CH |
418 | #define CCW_COMPAT_2_7 \ |
419 | HW_COMPAT_2_7 | |
420 | ||
946e55f3 | 421 | #define CCW_COMPAT_2_6 \ |
04ca4b92 AY |
422 | HW_COMPAT_2_6 \ |
423 | {\ | |
424 | .driver = TYPE_S390_IPL,\ | |
425 | .property = "iplbext_migration",\ | |
426 | .value = "off",\ | |
2a79eb1a CH |
427 | }, {\ |
428 | .driver = TYPE_VIRTUAL_CSS_BRIDGE,\ | |
429 | .property = "css_dev_path",\ | |
430 | .value = "off",\ | |
04ca4b92 | 431 | }, |
946e55f3 | 432 | |
cf87e0a3 SL |
433 | #define CCW_COMPAT_2_5 \ |
434 | HW_COMPAT_2_5 | |
435 | ||
9ef40173 | 436 | #define CCW_COMPAT_2_4 \ |
54d8ec84 | 437 | HW_COMPAT_2_4 \ |
9ef40173 JH |
438 | {\ |
439 | .driver = TYPE_S390_SKEYS,\ | |
440 | .property = "migration-enabled",\ | |
441 | .value = "off",\ | |
542571d5 CH |
442 | },{\ |
443 | .driver = "virtio-blk-ccw",\ | |
444 | .property = "max_revision",\ | |
445 | .value = "0",\ | |
446 | },{\ | |
447 | .driver = "virtio-balloon-ccw",\ | |
448 | .property = "max_revision",\ | |
449 | .value = "0",\ | |
450 | },{\ | |
451 | .driver = "virtio-serial-ccw",\ | |
452 | .property = "max_revision",\ | |
453 | .value = "0",\ | |
454 | },{\ | |
455 | .driver = "virtio-9p-ccw",\ | |
456 | .property = "max_revision",\ | |
457 | .value = "0",\ | |
458 | },{\ | |
459 | .driver = "virtio-rng-ccw",\ | |
460 | .property = "max_revision",\ | |
461 | .value = "0",\ | |
085b0b05 CH |
462 | },{\ |
463 | .driver = "virtio-net-ccw",\ | |
464 | .property = "max_revision",\ | |
465 | .value = "0",\ | |
466 | },{\ | |
467 | .driver = "virtio-scsi-ccw",\ | |
468 | .property = "max_revision",\ | |
469 | .value = "0",\ | |
470 | },{\ | |
471 | .driver = "vhost-scsi-ccw",\ | |
472 | .property = "max_revision",\ | |
473 | .value = "0",\ | |
9ef40173 JH |
474 | }, |
475 | ||
10890873 CH |
476 | static void ccw_machine_2_10_instance_options(MachineState *machine) |
477 | { | |
478 | } | |
479 | ||
480 | static void ccw_machine_2_10_class_options(MachineClass *mc) | |
481 | { | |
482 | } | |
483 | DEFINE_CCW_MACHINE(2_10, "2.10", true); | |
484 | ||
113725a6 CH |
485 | static void ccw_machine_2_9_instance_options(MachineState *machine) |
486 | { | |
10890873 | 487 | ccw_machine_2_10_instance_options(machine); |
113725a6 CH |
488 | } |
489 | ||
490 | static void ccw_machine_2_9_class_options(MachineClass *mc) | |
491 | { | |
10890873 CH |
492 | ccw_machine_2_10_class_options(mc); |
493 | SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_9); | |
113725a6 | 494 | } |
10890873 | 495 | DEFINE_CCW_MACHINE(2_9, "2.9", false); |
113725a6 | 496 | |
61823988 CH |
497 | static void ccw_machine_2_8_instance_options(MachineState *machine) |
498 | { | |
113725a6 | 499 | ccw_machine_2_9_instance_options(machine); |
61823988 CH |
500 | } |
501 | ||
502 | static void ccw_machine_2_8_class_options(MachineClass *mc) | |
503 | { | |
113725a6 CH |
504 | ccw_machine_2_9_class_options(mc); |
505 | SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_8); | |
61823988 | 506 | } |
113725a6 | 507 | DEFINE_CCW_MACHINE(2_8, "2.8", false); |
61823988 | 508 | |
946e55f3 CH |
509 | static void ccw_machine_2_7_instance_options(MachineState *machine) |
510 | { | |
61823988 | 511 | ccw_machine_2_8_instance_options(machine); |
946e55f3 CH |
512 | } |
513 | ||
514 | static void ccw_machine_2_7_class_options(MachineClass *mc) | |
515 | { | |
e73316d5 CB |
516 | S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); |
517 | ||
518 | s390mc->cpu_model_allowed = false; | |
61823988 CH |
519 | ccw_machine_2_8_class_options(mc); |
520 | SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_7); | |
946e55f3 | 521 | } |
61823988 | 522 | DEFINE_CCW_MACHINE(2_7, "2.7", false); |
946e55f3 | 523 | |
4fca6548 | 524 | static void ccw_machine_2_6_instance_options(MachineState *machine) |
c4d3c0a2 | 525 | { |
946e55f3 | 526 | ccw_machine_2_7_instance_options(machine); |
c4d3c0a2 CB |
527 | } |
528 | ||
4fca6548 | 529 | static void ccw_machine_2_6_class_options(MachineClass *mc) |
84b48ad6 | 530 | { |
9700230b FZ |
531 | S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); |
532 | ||
533 | s390mc->ri_allowed = false; | |
946e55f3 CH |
534 | ccw_machine_2_7_class_options(mc); |
535 | SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_6); | |
84b48ad6 | 536 | } |
946e55f3 | 537 | DEFINE_CCW_MACHINE(2_6, "2.6", false); |
84b48ad6 | 538 | |
4fca6548 JF |
539 | static void ccw_machine_2_5_instance_options(MachineState *machine) |
540 | { | |
946e55f3 | 541 | ccw_machine_2_6_instance_options(machine); |
4fca6548 | 542 | } |
84b48ad6 | 543 | |
4fca6548 | 544 | static void ccw_machine_2_5_class_options(MachineClass *mc) |
b21b7598 | 545 | { |
946e55f3 | 546 | ccw_machine_2_6_class_options(mc); |
4fca6548 JF |
547 | SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_5); |
548 | } | |
549 | DEFINE_CCW_MACHINE(2_5, "2.5", false); | |
b21b7598 | 550 | |
4fca6548 JF |
551 | static void ccw_machine_2_4_instance_options(MachineState *machine) |
552 | { | |
553 | ccw_machine_2_5_instance_options(machine); | |
b21b7598 CH |
554 | } |
555 | ||
4fca6548 JF |
556 | static void ccw_machine_2_4_class_options(MachineClass *mc) |
557 | { | |
946e55f3 | 558 | ccw_machine_2_5_class_options(mc); |
4fca6548 JF |
559 | SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_4); |
560 | } | |
561 | DEFINE_CCW_MACHINE(2_4, "2.4", false); | |
b21b7598 | 562 | |
d07aa7c7 | 563 | static void ccw_machine_register_types(void) |
a5c95808 | 564 | { |
d07aa7c7 | 565 | type_register_static(&ccw_machine_info); |
a5c95808 CH |
566 | } |
567 | ||
d07aa7c7 | 568 | type_init(ccw_machine_register_types) |