Add feature bits as properties to virtio. This makes it possible to e.g. define machine without indirect buffer support, which is required for 0.10 compatibility, or without hardware checksum support, which is required for 0.11 compatibility. Since default values for optional features are now set by qdev, get_features callback has been modified: it sets non-optional bits, and clears bits not supported by host. Signed-off-by: Michael S. Tsirkin <mst@redhat.com> Acked-by: Gerd Hoffmann <kraxel@redhat.com> Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
402 lines
10 KiB
C
402 lines
10 KiB
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 "sysemu.h"
|
|
#include "net.h"
|
|
#include "boards.h"
|
|
#include "monitor.h"
|
|
#include "loader.h"
|
|
#include "elf.h"
|
|
#include "hw/virtio.h"
|
|
#include "hw/virtio-console.h"
|
|
#include "hw/sysbus.h"
|
|
#include "kvm.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
|
|
|
|
struct BusInfo s390_virtio_bus_info = {
|
|
.name = "s390-virtio",
|
|
.size = sizeof(VirtIOS390Bus),
|
|
};
|
|
|
|
typedef struct {
|
|
DeviceInfo qdev;
|
|
int (*init)(VirtIOS390Device *dev);
|
|
} VirtIOS390DeviceInfo;
|
|
|
|
|
|
static const VirtIOBindings virtio_s390_bindings;
|
|
|
|
static ram_addr_t s390_virtio_device_num_vq(VirtIOS390Device *dev);
|
|
static void s390_virtio_device_sync(VirtIOS390Device *dev);
|
|
|
|
VirtIOS390Bus *s390_virtio_bus_init(ram_addr_t *ram_size)
|
|
{
|
|
VirtIOS390Bus *bus;
|
|
BusState *_bus;
|
|
DeviceState *dev;
|
|
|
|
/* Create bridge device */
|
|
dev = qdev_create(NULL, "s390-virtio-bridge");
|
|
qdev_init_nofail(dev);
|
|
|
|
/* Create bus on bridge device */
|
|
|
|
_bus = qbus_create(&s390_virtio_bus_info, dev, "s390-virtio");
|
|
bus = DO_UPCAST(VirtIOS390Bus, bus, _bus);
|
|
|
|
bus->dev_page = *ram_size;
|
|
bus->dev_offs = bus->dev_page;
|
|
bus->next_ring = bus->dev_page + TARGET_PAGE_SIZE;
|
|
|
|
/* Allocate RAM for VirtIO device pages (descriptors, queues, rings) */
|
|
*ram_size += S390_DEVICE_PAGES * TARGET_PAGE_SIZE;
|
|
|
|
return bus;
|
|
}
|
|
|
|
static int s390_virtio_device_init(VirtIOS390Device *dev, VirtIODevice *vdev)
|
|
{
|
|
VirtIOS390Bus *bus;
|
|
int dev_len;
|
|
|
|
bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus);
|
|
dev->vdev = vdev;
|
|
dev->dev_offs = bus->dev_offs;
|
|
dev->feat_len = sizeof(uint32_t); /* always keep 32 bits features */
|
|
|
|
dev_len = VIRTIO_DEV_OFFS_CONFIG;
|
|
dev_len += s390_virtio_device_num_vq(dev) * VIRTIO_VQCONFIG_LEN;
|
|
dev_len += dev->feat_len * 2;
|
|
dev_len += vdev->config_len;
|
|
|
|
bus->dev_offs += dev_len;
|
|
|
|
virtio_bind_device(vdev, &virtio_s390_bindings, dev);
|
|
dev->host_features = vdev->get_features(vdev, dev->host_features);
|
|
s390_virtio_device_sync(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int s390_virtio_net_init(VirtIOS390Device *dev)
|
|
{
|
|
VirtIODevice *vdev;
|
|
|
|
vdev = virtio_net_init((DeviceState *)dev, &dev->nic);
|
|
if (!vdev) {
|
|
return -1;
|
|
}
|
|
|
|
return s390_virtio_device_init(dev, vdev);
|
|
}
|
|
|
|
static int s390_virtio_blk_init(VirtIOS390Device *dev)
|
|
{
|
|
VirtIODevice *vdev;
|
|
|
|
vdev = virtio_blk_init((DeviceState *)dev, dev->dinfo);
|
|
if (!vdev) {
|
|
return -1;
|
|
}
|
|
|
|
return s390_virtio_device_init(dev, vdev);
|
|
}
|
|
|
|
static int s390_virtio_console_init(VirtIOS390Device *dev)
|
|
{
|
|
VirtIOS390Bus *bus;
|
|
VirtIODevice *vdev;
|
|
int r;
|
|
|
|
bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus);
|
|
|
|
vdev = virtio_console_init((DeviceState *)dev);
|
|
if (!vdev) {
|
|
return -1;
|
|
}
|
|
|
|
r = s390_virtio_device_init(dev, vdev);
|
|
if (!r) {
|
|
bus->console = dev;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
static uint64_t s390_virtio_device_vq_token(VirtIOS390Device *dev, int vq)
|
|
{
|
|
ram_addr_t token_off;
|
|
|
|
token_off = (dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG) +
|
|
(vq * VIRTIO_VQCONFIG_LEN) +
|
|
VIRTIO_VQCONFIG_OFFS_TOKEN;
|
|
|
|
return ldq_phys(token_off);
|
|
}
|
|
|
|
static ram_addr_t s390_virtio_device_num_vq(VirtIOS390Device *dev)
|
|
{
|
|
VirtIODevice *vdev = dev->vdev;
|
|
int num_vq;
|
|
|
|
for (num_vq = 0; num_vq < VIRTIO_PCI_QUEUE_MAX; num_vq++) {
|
|
if (!virtio_queue_get_num(vdev, num_vq)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return num_vq;
|
|
}
|
|
|
|
static ram_addr_t s390_virtio_next_ring(VirtIOS390Bus *bus)
|
|
{
|
|
ram_addr_t r = bus->next_ring;
|
|
|
|
bus->next_ring += VIRTIO_RING_LEN;
|
|
return r;
|
|
}
|
|
|
|
static void s390_virtio_device_sync(VirtIOS390Device *dev)
|
|
{
|
|
VirtIOS390Bus *bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus);
|
|
ram_addr_t cur_offs;
|
|
uint8_t num_vq;
|
|
int i;
|
|
|
|
virtio_reset(dev->vdev);
|
|
|
|
/* Sync dev space */
|
|
stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_TYPE, dev->vdev->device_id);
|
|
|
|
stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_NUM_VQ, s390_virtio_device_num_vq(dev));
|
|
stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_FEATURE_LEN, dev->feat_len);
|
|
|
|
stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG_LEN, dev->vdev->config_len);
|
|
|
|
num_vq = s390_virtio_device_num_vq(dev);
|
|
stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_NUM_VQ, num_vq);
|
|
|
|
/* Sync virtqueues */
|
|
for (i = 0; i < num_vq; i++) {
|
|
ram_addr_t vq = (dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG) +
|
|
(i * VIRTIO_VQCONFIG_LEN);
|
|
ram_addr_t vring;
|
|
|
|
vring = s390_virtio_next_ring(bus);
|
|
virtio_queue_set_addr(dev->vdev, i, vring);
|
|
virtio_queue_set_vector(dev->vdev, i, i);
|
|
stq_phys(vq + VIRTIO_VQCONFIG_OFFS_ADDRESS, vring);
|
|
stw_phys(vq + VIRTIO_VQCONFIG_OFFS_NUM, virtio_queue_get_num(dev->vdev, i));
|
|
}
|
|
|
|
cur_offs = dev->dev_offs;
|
|
cur_offs += VIRTIO_DEV_OFFS_CONFIG;
|
|
cur_offs += num_vq * VIRTIO_VQCONFIG_LEN;
|
|
|
|
/* Sync feature bitmap */
|
|
stl_phys(cur_offs, dev->host_features);
|
|
|
|
dev->feat_offs = cur_offs + dev->feat_len;
|
|
cur_offs += dev->feat_len * 2;
|
|
|
|
/* Sync config space */
|
|
if (dev->vdev->get_config) {
|
|
dev->vdev->get_config(dev->vdev, dev->vdev->config);
|
|
}
|
|
|
|
cpu_physical_memory_rw(cur_offs, dev->vdev->config, dev->vdev->config_len, 1);
|
|
cur_offs += dev->vdev->config_len;
|
|
}
|
|
|
|
void s390_virtio_device_update_status(VirtIOS390Device *dev)
|
|
{
|
|
VirtIODevice *vdev = dev->vdev;
|
|
uint32_t features;
|
|
|
|
vdev->status = ldub_phys(dev->dev_offs + VIRTIO_DEV_OFFS_STATUS);
|
|
|
|
/* Update guest supported feature bitmap */
|
|
|
|
features = ldl_phys(dev->feat_offs);
|
|
if (vdev->set_features) {
|
|
vdev->set_features(vdev, features);
|
|
}
|
|
vdev->guest_features = features;
|
|
}
|
|
|
|
VirtIOS390Device *s390_virtio_bus_console(VirtIOS390Bus *bus)
|
|
{
|
|
return bus->console;
|
|
}
|
|
|
|
/* Find a device by vring address */
|
|
VirtIOS390Device *s390_virtio_bus_find_vring(VirtIOS390Bus *bus,
|
|
ram_addr_t mem,
|
|
int *vq_num)
|
|
{
|
|
VirtIOS390Device *_dev;
|
|
DeviceState *dev;
|
|
int i;
|
|
|
|
QLIST_FOREACH(dev, &bus->bus.children, sibling) {
|
|
_dev = (VirtIOS390Device *)dev;
|
|
for(i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) {
|
|
if (!virtio_queue_get_addr(_dev->vdev, i))
|
|
break;
|
|
if (virtio_queue_get_addr(_dev->vdev, i) == mem) {
|
|
if (vq_num) {
|
|
*vq_num = i;
|
|
}
|
|
return _dev;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Find a device by device descriptor location */
|
|
VirtIOS390Device *s390_virtio_bus_find_mem(VirtIOS390Bus *bus, ram_addr_t mem)
|
|
{
|
|
VirtIOS390Device *_dev;
|
|
DeviceState *dev;
|
|
|
|
QLIST_FOREACH(dev, &bus->bus.children, sibling) {
|
|
_dev = (VirtIOS390Device *)dev;
|
|
if (_dev->dev_offs == mem) {
|
|
return _dev;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void virtio_s390_notify(void *opaque, uint16_t vector)
|
|
{
|
|
VirtIOS390Device *dev = (VirtIOS390Device*)opaque;
|
|
uint64_t token = s390_virtio_device_vq_token(dev, vector);
|
|
|
|
/* XXX kvm dependency! */
|
|
kvm_s390_virtio_irq(s390_cpu_addr2state(0), 0, token);
|
|
}
|
|
|
|
static unsigned virtio_s390_get_features(void *opaque)
|
|
{
|
|
VirtIOS390Device *dev = (VirtIOS390Device*)opaque;
|
|
return dev->host_features;
|
|
}
|
|
|
|
/**************** S390 Virtio Bus Device Descriptions *******************/
|
|
|
|
static const VirtIOBindings virtio_s390_bindings = {
|
|
.notify = virtio_s390_notify,
|
|
.get_features = virtio_s390_get_features,
|
|
};
|
|
|
|
static VirtIOS390DeviceInfo s390_virtio_net = {
|
|
.init = s390_virtio_net_init,
|
|
.qdev.name = "virtio-net-s390",
|
|
.qdev.size = sizeof(VirtIOS390Device),
|
|
.qdev.props = (Property[]) {
|
|
DEFINE_NIC_PROPERTIES(VirtIOS390Device, nic),
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
},
|
|
};
|
|
|
|
static VirtIOS390DeviceInfo s390_virtio_blk = {
|
|
.init = s390_virtio_blk_init,
|
|
.qdev.name = "virtio-blk-s390",
|
|
.qdev.size = sizeof(VirtIOS390Device),
|
|
.qdev.props = (Property[]) {
|
|
DEFINE_PROP_DRIVE("drive", VirtIOS390Device, dinfo),
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
},
|
|
};
|
|
|
|
static VirtIOS390DeviceInfo s390_virtio_console = {
|
|
.init = s390_virtio_console_init,
|
|
.qdev.name = "virtio-console-s390",
|
|
.qdev.size = sizeof(VirtIOS390Device),
|
|
.qdev.props = (Property[]) {
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
},
|
|
};
|
|
|
|
static int s390_virtio_busdev_init(DeviceState *dev, DeviceInfo *info)
|
|
{
|
|
VirtIOS390DeviceInfo *_info = (VirtIOS390DeviceInfo *)info;
|
|
VirtIOS390Device *_dev = (VirtIOS390Device *)dev;
|
|
|
|
return _info->init(_dev);
|
|
}
|
|
|
|
static void s390_virtio_bus_register_withprop(VirtIOS390DeviceInfo *info)
|
|
{
|
|
info->qdev.init = s390_virtio_busdev_init;
|
|
info->qdev.bus_info = &s390_virtio_bus_info;
|
|
|
|
assert(info->qdev.size >= sizeof(VirtIOS390Device));
|
|
qdev_register(&info->qdev);
|
|
}
|
|
|
|
static void s390_virtio_register(void)
|
|
{
|
|
s390_virtio_bus_register_withprop(&s390_virtio_console);
|
|
s390_virtio_bus_register_withprop(&s390_virtio_blk);
|
|
s390_virtio_bus_register_withprop(&s390_virtio_net);
|
|
}
|
|
device_init(s390_virtio_register);
|
|
|
|
|
|
/***************** S390 Virtio Bus Bridge Device *******************/
|
|
/* Only required to have the virtio bus as child in the system bus */
|
|
|
|
static int s390_virtio_bridge_init(SysBusDevice *dev)
|
|
{
|
|
/* nothing */
|
|
return 0;
|
|
}
|
|
|
|
static SysBusDeviceInfo s390_virtio_bridge_info = {
|
|
.init = s390_virtio_bridge_init,
|
|
.qdev.name = "s390-virtio-bridge",
|
|
.qdev.size = sizeof(SysBusDevice),
|
|
.qdev.no_user = 1,
|
|
};
|
|
|
|
static void s390_virtio_register_devices(void)
|
|
{
|
|
sysbus_register_withprop(&s390_virtio_bridge_info);
|
|
}
|
|
|
|
device_init(s390_virtio_register_devices)
|