4 * Copyright 2012 IBM Corp.
5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
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
12 #include "hw/boards.h"
13 #include "exec/address-spaces.h"
14 #include "s390-virtio.h"
15 #include "hw/s390x/sclp.h"
16 #include "hw/s390x/s390_flic.h"
19 #include "virtio-ccw.h"
20 #include "qemu/config-file.h"
21 #include "s390-pci-bus.h"
23 #define TYPE_S390_CCW_MACHINE "s390-ccw-machine"
25 #define S390_CCW_MACHINE(obj) \
26 OBJECT_CHECK(S390CcwMachineState, (obj), TYPE_S390_CCW_MACHINE)
28 typedef struct S390CcwMachineState {
30 MachineState parent_obj;
35 } S390CcwMachineState;
37 void io_subsystem_reset(void)
39 DeviceState *css, *sclp, *flic, *diag288;
41 css = DEVICE(object_resolve_path_type("", "virtual-css-bridge", NULL));
45 sclp = DEVICE(object_resolve_path_type("",
46 "s390-sclp-event-facility", NULL));
50 flic = DEVICE(object_resolve_path_type("", "s390-flic", NULL));
54 diag288 = DEVICE(object_resolve_path_type("", "diag288", NULL));
56 qdev_reset_all(diag288);
60 static int virtio_ccw_hcall_notify(const uint64_t *args)
62 uint64_t subch_id = args[0];
63 uint64_t queue = args[1];
65 int cssid, ssid, schid, m;
67 if (ioinst_disassemble_sch_ident(subch_id, &m, &cssid, &ssid, &schid)) {
70 sch = css_find_subch(m, cssid, ssid, schid);
71 if (!sch || !css_subch_visible(sch)) {
74 if (queue >= VIRTIO_CCW_QUEUE_MAX) {
77 virtio_queue_notify(virtio_ccw_get_vdev(sch), queue);
82 static int virtio_ccw_hcall_early_printk(const uint64_t *args)
84 uint64_t mem = args[0];
93 static void virtio_ccw_register_hcalls(void)
95 s390_register_virtio_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY,
96 virtio_ccw_hcall_notify);
97 /* Tolerate early printk. */
98 s390_register_virtio_hypercall(KVM_S390_VIRTIO_NOTIFY,
99 virtio_ccw_hcall_early_printk);
102 static void ccw_init(MachineState *machine)
104 ram_addr_t my_ram_size = machine->ram_size;
105 MemoryRegion *sysmem = get_system_memory();
106 MemoryRegion *ram = g_new(MemoryRegion, 1);
107 sclpMemoryHotplugDev *mhd = init_sclp_memory_hotplug_dev();
108 uint8_t *storage_keys;
110 VirtualCssBus *css_bus;
112 QemuOpts *opts = qemu_opts_find(qemu_find_opts("memory"), NULL);
113 ram_addr_t pad_size = 0;
114 ram_addr_t maxmem = qemu_opt_get_size(opts, "maxmem", my_ram_size);
115 ram_addr_t standby_mem_size = maxmem - my_ram_size;
118 /* The storage increment size is a multiple of 1M and is a power of 2.
119 * The number of storage increments must be MAX_STORAGE_INCREMENTS or fewer.
120 * The variable 'mhd->increment_size' is an exponent of 2 that can be
121 * used to calculate the size (in bytes) of an increment. */
122 mhd->increment_size = 20;
123 while ((my_ram_size >> mhd->increment_size) > MAX_STORAGE_INCREMENTS) {
124 mhd->increment_size++;
126 while ((standby_mem_size >> mhd->increment_size) > MAX_STORAGE_INCREMENTS) {
127 mhd->increment_size++;
130 /* The core and standby memory areas need to be aligned with
131 * the increment size. In effect, this can cause the
132 * user-specified memory size to be rounded down to align
133 * with the nearest increment boundary. */
134 standby_mem_size = standby_mem_size >> mhd->increment_size
135 << mhd->increment_size;
136 my_ram_size = my_ram_size >> mhd->increment_size
137 << mhd->increment_size;
139 /* let's propagate the changed ram size into the global variable. */
140 ram_size = my_ram_size;
141 machine->maxram_size = my_ram_size + standby_mem_size;
143 ret = s390_set_memory_limit(machine->maxram_size, &kvm_limit);
145 hw_error("qemu: host supports a maximum of %" PRIu64 " GB",
148 hw_error("qemu: setting the guest size failed");
152 css_bus = virtual_css_bus_init();
154 s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline,
155 machine->initrd_filename, "s390-ccw.img", true);
158 dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE);
159 object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE,
161 qdev_init_nofail(dev);
163 /* register hypercalls */
164 virtio_ccw_register_hcalls();
166 /* allocate RAM for core */
167 memory_region_init_ram(ram, NULL, "s390.ram", my_ram_size, &error_abort);
168 vmstate_register_ram_global(ram);
169 memory_region_add_subregion(sysmem, 0, ram);
171 /* If the size of ram is not on a MEM_SECTION_SIZE boundary,
172 calculate the pad size necessary to force this boundary. */
173 if (standby_mem_size) {
174 if (my_ram_size % MEM_SECTION_SIZE) {
175 pad_size = MEM_SECTION_SIZE - my_ram_size % MEM_SECTION_SIZE;
177 my_ram_size += standby_mem_size + pad_size;
178 mhd->pad_size = pad_size;
179 mhd->standby_mem_size = standby_mem_size;
182 /* allocate storage keys */
183 storage_keys = g_malloc0(my_ram_size / TARGET_PAGE_SIZE);
186 s390_init_cpus(machine->cpu_model, storage_keys);
189 kvm_s390_enable_css_support(s390_cpu_addr2state(0));
192 * Create virtual css and set it as default so that non mcss-e
193 * enabled guests only see virtio devices.
195 ret = css_create_css_image(VIRTUAL_CSSID, true);
198 /* Create VirtIO network adapters */
199 s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw");
201 /* Register savevm handler for guest TOD clock */
202 register_savevm(NULL, "todclock", 0, 1,
203 gtod_save, gtod_load, kvm_state);
206 static void ccw_machine_class_init(ObjectClass *oc, void *data)
208 MachineClass *mc = MACHINE_CLASS(oc);
209 NMIClass *nc = NMI_CLASS(oc);
212 mc->block_default_type = IF_VIRTIO;
220 nc->nmi_monitor_handler = s390_nmi;
223 static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp)
225 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
227 return ms->aes_key_wrap;
230 static inline void machine_set_aes_key_wrap(Object *obj, bool value,
233 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
235 ms->aes_key_wrap = value;
238 static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp)
240 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
242 return ms->dea_key_wrap;
245 static inline void machine_set_dea_key_wrap(Object *obj, bool value,
248 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
250 ms->dea_key_wrap = value;
253 static inline void s390_machine_initfn(Object *obj)
255 object_property_add_bool(obj, "aes-key-wrap",
256 machine_get_aes_key_wrap,
257 machine_set_aes_key_wrap, NULL);
258 object_property_set_description(obj, "aes-key-wrap",
259 "enable/disable AES key wrapping using the CPACF wrapping key",
261 object_property_set_bool(obj, true, "aes-key-wrap", NULL);
263 object_property_add_bool(obj, "dea-key-wrap",
264 machine_get_dea_key_wrap,
265 machine_set_dea_key_wrap, NULL);
266 object_property_set_description(obj, "dea-key-wrap",
267 "enable/disable DEA key wrapping using the CPACF wrapping key",
269 object_property_set_bool(obj, true, "dea-key-wrap", NULL);
272 static const TypeInfo ccw_machine_info = {
273 .name = TYPE_S390_CCW_MACHINE,
274 .parent = TYPE_MACHINE,
276 .instance_size = sizeof(S390CcwMachineState),
277 .instance_init = s390_machine_initfn,
278 .class_init = ccw_machine_class_init,
279 .interfaces = (InterfaceInfo[]) {
285 static void ccw_machine_2_4_class_init(ObjectClass *oc, void *data)
287 MachineClass *mc = MACHINE_CLASS(oc);
289 mc->name = "s390-ccw-virtio-2.4";
290 mc->alias = "s390-ccw-virtio";
291 mc->desc = "VirtIO-ccw based S390 machine v2.4";
295 static const TypeInfo ccw_machine_2_4_info = {
296 .name = TYPE_S390_CCW_MACHINE "2.4",
297 .parent = TYPE_S390_CCW_MACHINE,
298 .class_init = ccw_machine_2_4_class_init,
301 static void ccw_machine_register_types(void)
303 type_register_static(&ccw_machine_info);
304 type_register_static(&ccw_machine_2_4_info);
307 type_init(ccw_machine_register_types)