[qemu.git] / hw / s390-virtio.c

/*
 * QEMU S390 virtio target
 *
 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */

#include "hw.h"
#include "block.h"
#include "blockdev.h"
#include "sysemu.h"
#include "net.h"
#include "boards.h"
#include "monitor.h"
#include "loader.h"
#include "elf.h"
#include "hw/virtio.h"
#include "hw/sysbus.h"
#include "kvm.h"
#include "exec-memory.h"

#include "hw/s390-virtio-bus.h"

//#define DEBUG_S390

#ifdef DEBUG_S390
#define dprintf(fmt, ...) \
    do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
#else
#define dprintf(fmt, ...) \
    do { } while (0)
#endif

#define KVM_S390_VIRTIO_NOTIFY          0
#define KVM_S390_VIRTIO_RESET           1
#define KVM_S390_VIRTIO_SET_STATUS      2

#define KERN_IMAGE_START                0x010000UL
#define KERN_PARM_AREA                  0x010480UL
#define INITRD_START                    0x800000UL
#define INITRD_PARM_START               0x010408UL
#define INITRD_PARM_SIZE                0x010410UL
#define PARMFILE_START                  0x001000UL

#define ZIPL_START			0x009000UL
#define ZIPL_LOAD_ADDR			0x009000UL
#define ZIPL_FILENAME			"s390-zipl.rom"

#define MAX_BLK_DEVS                    10

static VirtIOS390Bus *s390_bus;
static S390CPU **ipi_states;

S390CPU *s390_cpu_addr2state(uint16_t cpu_addr)
{
    if (cpu_addr >= smp_cpus) {
        return NULL;
    }

    return ipi_states[cpu_addr];
}

int s390_virtio_hypercall(CPUS390XState *env, uint64_t mem, uint64_t hypercall)
{
    int r = 0, i;

    dprintf("KVM hypercall: %ld\n", hypercall);
    switch (hypercall) {
    case KVM_S390_VIRTIO_NOTIFY:
        if (mem > ram_size) {
            VirtIOS390Device *dev = s390_virtio_bus_find_vring(s390_bus,
                                                               mem, &i);
            if (dev) {
                virtio_queue_notify(dev->vdev, i);
            } else {
                r = -EINVAL;
            }
        } else {
            /* Early printk */
        }
        break;
    case KVM_S390_VIRTIO_RESET:
    {
        VirtIOS390Device *dev;

        dev = s390_virtio_bus_find_mem(s390_bus, mem);
        virtio_reset(dev->vdev);
        stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_STATUS, 0);
        s390_virtio_device_sync(dev);
        s390_virtio_reset_idx(dev);
        break;
    }
    case KVM_S390_VIRTIO_SET_STATUS:
    {
        VirtIOS390Device *dev;

        dev = s390_virtio_bus_find_mem(s390_bus, mem);
        if (dev) {
            s390_virtio_device_update_status(dev);
        } else {
            r = -EINVAL;
        }
        break;
    }
    default:
        r = -EINVAL;
        break;
    }

    return r;
}

/*
 * The number of running CPUs. On s390 a shutdown is the state of all CPUs
 * being either stopped or disabled (for interrupts) waiting. We have to
 * track this number to call the shutdown sequence accordingly. This
 * number is modified either on startup or while holding the big qemu lock.
 */
static unsigned s390_running_cpus;

void s390_add_running_cpu(CPUS390XState *env)
{
    if (env->halted) {
        s390_running_cpus++;
        env->halted = 0;
        env->exception_index = -1;
    }
}

unsigned s390_del_running_cpu(CPUS390XState *env)
{
    if (env->halted == 0) {
        assert(s390_running_cpus >= 1);
        s390_running_cpus--;
        env->halted = 1;
        env->exception_index = EXCP_HLT;
    }
    return s390_running_cpus;
}

/* PC hardware initialisation */
static void s390_init(QEMUMachineInitArgs *args)
{
    ram_addr_t my_ram_size = args->ram_size;
    ram_addr_t ram_size = args->ram_size;
    const char *cpu_model = args->cpu_model;
    const char *kernel_filename = args->kernel_filename;
    const char *kernel_cmdline = args->kernel_cmdline;
    const char *initrd_filename = args->initrd_filename;
    CPUS390XState *env = NULL;
    MemoryRegion *sysmem = get_system_memory();
    MemoryRegion *ram = g_new(MemoryRegion, 1);
    ram_addr_t kernel_size = 0;
    ram_addr_t initrd_offset;
    ram_addr_t initrd_size = 0;
    int shift = 0;
    uint8_t *storage_keys;
    void *virtio_region;
    target_phys_addr_t virtio_region_len;
    target_phys_addr_t virtio_region_start;
    int i;

    /* s390x ram size detection needs a 16bit multiplier + an increment. So
       guests > 64GB can be specified in 2MB steps etc. */
    while ((my_ram_size >> (20 + shift)) > 65535) {
        shift++;
    }
    my_ram_size = my_ram_size >> (20 + shift) << (20 + shift);

    /* lets propagate the changed ram size into the global variable. */
    ram_size = my_ram_size;

    /* get a BUS */
    s390_bus = s390_virtio_bus_init(&my_ram_size);

    /* allocate RAM */
    memory_region_init_ram(ram, "s390.ram", my_ram_size);
    vmstate_register_ram_global(ram);
    memory_region_add_subregion(sysmem, 0, ram);

    /* clear virtio region */
    virtio_region_len = my_ram_size - ram_size;
    virtio_region_start = ram_size;
    virtio_region = cpu_physical_memory_map(virtio_region_start,
                                            &virtio_region_len, true);
    memset(virtio_region, 0, virtio_region_len);
    cpu_physical_memory_unmap(virtio_region, virtio_region_len, 1,
                              virtio_region_len);

    /* allocate storage keys */
    storage_keys = g_malloc0(my_ram_size / TARGET_PAGE_SIZE);

    /* init CPUs */
    if (cpu_model == NULL) {
        cpu_model = "host";
    }

    ipi_states = g_malloc(sizeof(S390CPU *) * smp_cpus);

    for (i = 0; i < smp_cpus; i++) {
        S390CPU *cpu;
        CPUS390XState *tmp_env;

        cpu = cpu_s390x_init(cpu_model);
        tmp_env = &cpu->env;
        if (!env) {
            env = tmp_env;
        }
        ipi_states[i] = cpu;
        tmp_env->halted = 1;
        tmp_env->exception_index = EXCP_HLT;
        tmp_env->storage_keys = storage_keys;
    }

    /* One CPU has to run */
    s390_add_running_cpu(env);

    if (kernel_filename) {

        kernel_size = load_elf(kernel_filename, NULL, NULL, NULL, NULL,
                               NULL, 1, ELF_MACHINE, 0);
        if (kernel_size == -1UL) {
            kernel_size = load_image_targphys(kernel_filename, 0, ram_size);
        }
        if (kernel_size == -1UL) {
            fprintf(stderr, "qemu: could not load kernel '%s'\n",
                    kernel_filename);
            exit(1);
        }
        /*
         * we can not rely on the ELF entry point, since up to 3.2 this
         * value was 0x800 (the SALIPL loader) and it wont work. For
         * all (Linux) cases 0x10000 (KERN_IMAGE_START) should be fine.
         */
        env->psw.addr = KERN_IMAGE_START;
        env->psw.mask = 0x0000000180000000ULL;
    } else {
        ram_addr_t bios_size = 0;
        char *bios_filename;

        /* Load zipl bootloader */
        if (bios_name == NULL) {
            bios_name = ZIPL_FILENAME;
        }

        bios_filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
        bios_size = load_image_targphys(bios_filename, ZIPL_LOAD_ADDR, 4096);
        g_free(bios_filename);

        if ((long)bios_size < 0) {
            hw_error("could not load bootloader '%s'\n", bios_name);
        }

        if (bios_size > 4096) {
            hw_error("stage1 bootloader is > 4k\n");
        }

        env->psw.addr = ZIPL_START;
        env->psw.mask = 0x0000000180000000ULL;
    }

    if (initrd_filename) {
        initrd_offset = INITRD_START;
        while (kernel_size + 0x100000 > initrd_offset) {
            initrd_offset += 0x100000;
        }
        initrd_size = load_image_targphys(initrd_filename, initrd_offset,
                                          ram_size - initrd_offset);
        if (initrd_size == -1UL) {
            fprintf(stderr, "qemu: could not load initrd '%s'\n",
                    initrd_filename);
            exit(1);
        }

        /* we have to overwrite values in the kernel image, which are "rom" */
        memcpy(rom_ptr(INITRD_PARM_START), &initrd_offset, 8);
        memcpy(rom_ptr(INITRD_PARM_SIZE), &initrd_size, 8);
    }

    if (rom_ptr(KERN_PARM_AREA)) {
        /* we have to overwrite values in the kernel image, which are "rom" */
        memcpy(rom_ptr(KERN_PARM_AREA), kernel_cmdline,
               strlen(kernel_cmdline) + 1);
    }

    /* Create VirtIO network adapters */
    for(i = 0; i < nb_nics; i++) {
        NICInfo *nd = &nd_table[i];
        DeviceState *dev;

        if (!nd->model) {
            nd->model = g_strdup("virtio");
        }

        if (strcmp(nd->model, "virtio")) {
            fprintf(stderr, "S390 only supports VirtIO nics\n");
            exit(1);
        }

        dev = qdev_create((BusState *)s390_bus, "virtio-net-s390");
        qdev_set_nic_properties(dev, nd);
        qdev_init_nofail(dev);
    }

    /* Create VirtIO disk drives */
    for(i = 0; i < MAX_BLK_DEVS; i++) {
        DriveInfo *dinfo;
        DeviceState *dev;

        dinfo = drive_get(IF_IDE, 0, i);
        if (!dinfo) {
            continue;
        }

        dev = qdev_create((BusState *)s390_bus, "virtio-blk-s390");
        qdev_prop_set_drive_nofail(dev, "drive", dinfo->bdrv);
        qdev_init_nofail(dev);
    }
}

static QEMUMachine s390_machine = {
    .name = "s390-virtio",
    .alias = "s390",
    .desc = "VirtIO based S390 machine",
    .init = s390_init,
    .no_cdrom = 1,
    .no_floppy = 1,
    .no_serial = 1,
    .no_parallel = 1,
    .no_sdcard = 1,
    .use_virtcon = 1,
    .max_cpus = 255,
    .is_default = 1,
};

static void s390_machine_init(void)
{
    qemu_register_machine(&s390_machine);
}

machine_init(s390_machine_init);
Commit	Line	Data
8cb310e1 AG	1	/*
	2	* QEMU S390 virtio target
	3	*
	4	* Copyright (c) 2009 Alexander Graf <agraf@suse.de>
	5	*
	6	* This library is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2 of the License, or (at your option) any later version.
	10	*
	11	* This library is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include "hw.h"
	21	#include "block.h"
6c33286a	22	#include "blockdev.h"
8cb310e1 AG	23	#include "sysemu.h"
	24	#include "net.h"
	25	#include "boards.h"
	26	#include "monitor.h"
	27	#include "loader.h"
	28	#include "elf.h"
	29	#include "hw/virtio.h"
8cb310e1 AG	30	#include "hw/sysbus.h"
8cb310e1 AG	31	#include "kvm.h"
ca3dbc27	32	#include "exec-memory.h"
8cb310e1 AG	33
	34	#include "hw/s390-virtio-bus.h"
	35
	36	//#define DEBUG_S390
	37
	38	#ifdef DEBUG_S390
	39	#define dprintf(fmt, ...) \
	40	do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
	41	#else
	42	#define dprintf(fmt, ...) \
	43	do { } while (0)
	44	#endif
	45
	46	#define KVM_S390_VIRTIO_NOTIFY 0
	47	#define KVM_S390_VIRTIO_RESET 1
	48	#define KVM_S390_VIRTIO_SET_STATUS 2
	49
	50	#define KERN_IMAGE_START 0x010000UL
	51	#define KERN_PARM_AREA 0x010480UL
	52	#define INITRD_START 0x800000UL
	53	#define INITRD_PARM_START 0x010408UL
	54	#define INITRD_PARM_SIZE 0x010410UL
	55	#define PARMFILE_START 0x001000UL
	56
fe270d04 AG	57	#define ZIPL_START 0x009000UL
	58	#define ZIPL_LOAD_ADDR 0x009000UL
	59	#define ZIPL_FILENAME "s390-zipl.rom"
	60
8cb310e1 AG	61	#define MAX_BLK_DEVS 10
	62
	63	static VirtIOS390Bus *s390_bus;
45fa769b	64	static S390CPU **ipi_states;
8cb310e1	65
45fa769b	66	S390CPU *s390_cpu_addr2state(uint16_t cpu_addr)
8cb310e1 AG	67	{
	68	if (cpu_addr >= smp_cpus) {
	69	return NULL;
	70	}
	71
	72	return ipi_states[cpu_addr];
	73	}
	74
0e4213a7	75	int s390_virtio_hypercall(CPUS390XState *env, uint64_t mem, uint64_t hypercall)
8cb310e1 AG	76	{
8cb310e1 AG	77	int r = 0, i;
8cb310e1	78
8d5192ee AG	79	dprintf("KVM hypercall: %ld\n", hypercall);
8d5192ee AG	80	switch (hypercall) {
8cb310e1 AG	81	case KVM_S390_VIRTIO_NOTIFY:
	82	if (mem > ram_size) {
	83	VirtIOS390Device *dev = s390_virtio_bus_find_vring(s390_bus,
	84	mem, &i);
	85	if (dev) {
	86	virtio_queue_notify(dev->vdev, i);
	87	} else {
	88	r = -EINVAL;
	89	}
	90	} else {
	91	/* Early printk */
	92	}
	93	break;
	94	case KVM_S390_VIRTIO_RESET:
	95	{
baf0b55a AG	96	VirtIOS390Device *dev;
	97
	98	dev = s390_virtio_bus_find_mem(s390_bus, mem);
	99	virtio_reset(dev->vdev);
e9d86b76	100	stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_STATUS, 0);
baf0b55a	101	s390_virtio_device_sync(dev);
4170aea1	102	s390_virtio_reset_idx(dev);
8cb310e1 AG	103	break;
	104	}
	105	case KVM_S390_VIRTIO_SET_STATUS:
	106	{
	107	VirtIOS390Device *dev;
	108
	109	dev = s390_virtio_bus_find_mem(s390_bus, mem);
	110	if (dev) {
	111	s390_virtio_device_update_status(dev);
	112	} else {
	113	r = -EINVAL;
	114	}
	115	break;
	116	}
	117	default:
	118	r = -EINVAL;
	119	break;
	120	}
	121
8d5192ee	122	return r;
8cb310e1 AG	123	}
8cb310e1 AG	124
854e42f3 CB	125	/*
	126	* The number of running CPUs. On s390 a shutdown is the state of all CPUs
	127	* being either stopped or disabled (for interrupts) waiting. We have to
	128	* track this number to call the shutdown sequence accordingly. This
	129	* number is modified either on startup or while holding the big qemu lock.
	130	*/
	131	static unsigned s390_running_cpus;
	132
0e4213a7	133	void s390_add_running_cpu(CPUS390XState *env)
854e42f3 CB	134	{
	135	if (env->halted) {
	136	s390_running_cpus++;
	137	env->halted = 0;
	138	env->exception_index = -1;
	139	}
	140	}
	141
0e4213a7	142	unsigned s390_del_running_cpu(CPUS390XState *env)
854e42f3 CB	143	{
	144	if (env->halted == 0) {
	145	assert(s390_running_cpus >= 1);
	146	s390_running_cpus--;
	147	env->halted = 1;
	148	env->exception_index = EXCP_HLT;
	149	}
	150	return s390_running_cpus;
	151	}
	152
8cb310e1	153	/* PC hardware initialisation */
5f072e1f	154	static void s390_init(QEMUMachineInitArgs *args)
8cb310e1	155	{
5f072e1f EH	156	ram_addr_t my_ram_size = args->ram_size;
	157	ram_addr_t ram_size = args->ram_size;
	158	const char *cpu_model = args->cpu_model;
	159	const char *kernel_filename = args->kernel_filename;
	160	const char *kernel_cmdline = args->kernel_cmdline;
	161	const char *initrd_filename = args->initrd_filename;
0e4213a7	162	CPUS390XState *env = NULL;
ca3dbc27 AK	163	MemoryRegion *sysmem = get_system_memory();
ca3dbc27 AK	164	MemoryRegion *ram = g_new(MemoryRegion, 1);
8cb310e1 AG	165	ram_addr_t kernel_size = 0;
	166	ram_addr_t initrd_offset;
	167	ram_addr_t initrd_size = 0;
22486aa0	168	int shift = 0;
8d5192ee	169	uint8_t *storage_keys;
326384d5 AG	170	void *virtio_region;
	171	target_phys_addr_t virtio_region_len;
	172	target_phys_addr_t virtio_region_start;
8cb310e1 AG	173	int i;
8cb310e1 AG	174
22486aa0 CB	175	/* s390x ram size detection needs a 16bit multiplier + an increment. So
	176	guests > 64GB can be specified in 2MB steps etc. */
	177	while ((my_ram_size >> (20 + shift)) > 65535) {
	178	shift++;
	179	}
	180	my_ram_size = my_ram_size >> (20 + shift) << (20 + shift);
	181
	182	/* lets propagate the changed ram size into the global variable. */
	183	ram_size = my_ram_size;
e249651c	184
8cb310e1	185	/* get a BUS */
22486aa0	186	s390_bus = s390_virtio_bus_init(&my_ram_size);
8cb310e1 AG	187
8cb310e1 AG	188	/* allocate RAM */
c5705a77 AK	189	memory_region_init_ram(ram, "s390.ram", my_ram_size);
c5705a77 AK	190	vmstate_register_ram_global(ram);
ca3dbc27	191	memory_region_add_subregion(sysmem, 0, ram);
8cb310e1	192
326384d5 AG	193	/* clear virtio region */
	194	virtio_region_len = my_ram_size - ram_size;
	195	virtio_region_start = ram_size;
	196	virtio_region = cpu_physical_memory_map(virtio_region_start,
	197	&virtio_region_len, true);
	198	memset(virtio_region, 0, virtio_region_len);
	199	cpu_physical_memory_unmap(virtio_region, virtio_region_len, 1,
	200	virtio_region_len);
	201
8d5192ee	202	/* allocate storage keys */
7267c094	203	storage_keys = g_malloc0(my_ram_size / TARGET_PAGE_SIZE);
8d5192ee	204
8cb310e1 AG	205	/* init CPUs */
	206	if (cpu_model == NULL) {
	207	cpu_model = "host";
	208	}
	209
45fa769b	210	ipi_states = g_malloc(sizeof(S390CPU ) smp_cpus);
8cb310e1 AG	211
8cb310e1 AG	212	for (i = 0; i < smp_cpus; i++) {
6fc150de	213	S390CPU *cpu;
0e4213a7	214	CPUS390XState *tmp_env;
8cb310e1	215
6fc150de AF	216	cpu = cpu_s390x_init(cpu_model);
6fc150de AF	217	tmp_env = &cpu->env;
8cb310e1 AG	218	if (!env) {
	219	env = tmp_env;
	220	}
45fa769b	221	ipi_states[i] = cpu;
8cb310e1 AG	222	tmp_env->halted = 1;
8cb310e1 AG	223	tmp_env->exception_index = EXCP_HLT;
8d5192ee	224	tmp_env->storage_keys = storage_keys;
8cb310e1 AG	225	}
8cb310e1 AG	226
854e42f3 CB	227	/* One CPU has to run */
854e42f3 CB	228	s390_add_running_cpu(env);
8cb310e1 AG	229
8cb310e1 AG	230	if (kernel_filename) {
8cb310e1	231
1edb4934 CB	232	kernel_size = load_elf(kernel_filename, NULL, NULL, NULL, NULL,
	233	NULL, 1, ELF_MACHINE, 0);
	234	if (kernel_size == -1UL) {
	235	kernel_size = load_image_targphys(kernel_filename, 0, ram_size);
8cb310e1	236	}
118a8977 CB	237	if (kernel_size == -1UL) {
	238	fprintf(stderr, "qemu: could not load kernel '%s'\n",
	239	kernel_filename);
	240	exit(1);
	241	}
1edb4934 CB	242	/*
	243	* we can not rely on the ELF entry point, since up to 3.2 this
	244	* value was 0x800 (the SALIPL loader) and it wont work. For
	245	* all (Linux) cases 0x10000 (KERN_IMAGE_START) should be fine.
	246	*/
8cb310e1	247	env->psw.addr = KERN_IMAGE_START;
0435d393	248	env->psw.mask = 0x0000000180000000ULL;
fe270d04 AG	249	} else {
	250	ram_addr_t bios_size = 0;
	251	char *bios_filename;
	252
	253	/* Load zipl bootloader */
	254	if (bios_name == NULL) {
	255	bios_name = ZIPL_FILENAME;
	256	}
	257
	258	bios_filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
1edb4934	259	bios_size = load_image_targphys(bios_filename, ZIPL_LOAD_ADDR, 4096);
7267c094	260	g_free(bios_filename);
fe270d04 AG	261
	262	if ((long)bios_size < 0) {
	263	hw_error("could not load bootloader '%s'\n", bios_name);
	264	}
	265
	266	if (bios_size > 4096) {
	267	hw_error("stage1 bootloader is > 4k\n");
	268	}
	269
	270	env->psw.addr = ZIPL_START;
	271	env->psw.mask = 0x0000000180000000ULL;
8cb310e1 AG	272	}
	273
	274	if (initrd_filename) {
	275	initrd_offset = INITRD_START;
	276	while (kernel_size + 0x100000 > initrd_offset) {
	277	initrd_offset += 0x100000;
	278	}
1edb4934 CB	279	initrd_size = load_image_targphys(initrd_filename, initrd_offset,
1edb4934 CB	280	ram_size - initrd_offset);
118a8977 CB	281	if (initrd_size == -1UL) {
	282	fprintf(stderr, "qemu: could not load initrd '%s'\n",
	283	initrd_filename);
	284	exit(1);
	285	}
	286
1edb4934 CB	287	/* we have to overwrite values in the kernel image, which are "rom" */
	288	memcpy(rom_ptr(INITRD_PARM_START), &initrd_offset, 8);
	289	memcpy(rom_ptr(INITRD_PARM_SIZE), &initrd_size, 8);
8cb310e1 AG	290	}
8cb310e1 AG	291
cc3c7384	292	if (rom_ptr(KERN_PARM_AREA)) {
1edb4934 CB	293	/* we have to overwrite values in the kernel image, which are "rom" */
	294	memcpy(rom_ptr(KERN_PARM_AREA), kernel_cmdline,
	295	strlen(kernel_cmdline) + 1);
8cb310e1 AG	296	}
8cb310e1 AG	297
8cb310e1 AG	298	/* Create VirtIO network adapters */
	299	for(i = 0; i < nb_nics; i++) {
	300	NICInfo *nd = &nd_table[i];
	301	DeviceState *dev;
	302
	303	if (!nd->model) {
7267c094	304	nd->model = g_strdup("virtio");
8cb310e1 AG	305	}
	306
	307	if (strcmp(nd->model, "virtio")) {
	308	fprintf(stderr, "S390 only supports VirtIO nics\n");
	309	exit(1);
	310	}
	311
	312	dev = qdev_create((BusState *)s390_bus, "virtio-net-s390");
	313	qdev_set_nic_properties(dev, nd);
	314	qdev_init_nofail(dev);
	315	}
	316
	317	/* Create VirtIO disk drives */
	318	for(i = 0; i < MAX_BLK_DEVS; i++) {
	319	DriveInfo *dinfo;
	320	DeviceState *dev;
	321
	322	dinfo = drive_get(IF_IDE, 0, i);
	323	if (!dinfo) {
	324	continue;
	325	}
	326
	327	dev = qdev_create((BusState *)s390_bus, "virtio-blk-s390");
18846dee	328	qdev_prop_set_drive_nofail(dev, "drive", dinfo->bdrv);
8cb310e1 AG	329	qdev_init_nofail(dev);
	330	}
	331	}
	332
	333	static QEMUMachine s390_machine = {
	334	.name = "s390-virtio",
	335	.alias = "s390",
	336	.desc = "VirtIO based S390 machine",
	337	.init = s390_init,
ad0bbc56 EL	338	.no_cdrom = 1,
ad0bbc56 EL	339	.no_floppy = 1,
986c5f78 GH	340	.no_serial = 1,
986c5f78 GH	341	.no_parallel = 1,
ad0bbc56	342	.no_sdcard = 1,
cf708987	343	.use_virtcon = 1,
8cb310e1 AG	344	.max_cpus = 255,
	345	.is_default = 1,
	346	};
	347
	348	static void s390_machine_init(void)
	349	{
	350	qemu_register_machine(&s390_machine);
	351	}
	352
	353	machine_init(s390_machine_init);