2 * kvm_virtio.c - virtio for kvm on s390
4 * Copyright IBM Corp. 2008
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License (version 2 only)
8 * as published by the Free Software Foundation.
10 * Author(s): Christian Borntraeger <borntraeger@de.ibm.com>
13 #include <linux/init.h>
14 #include <linux/bootmem.h>
15 #include <linux/err.h>
16 #include <linux/virtio.h>
17 #include <linux/virtio_config.h>
18 #include <linux/interrupt.h>
19 #include <linux/virtio_ring.h>
20 #include <linux/pfn.h>
22 #include <asm/kvm_para.h>
23 #include <asm/kvm_virtio.h>
24 #include <asm/setup.h>
25 #include <asm/s390_ext.h>
27 #define VIRTIO_SUBCODE_64 0x0D00
30 * The pointer to our (page) of device descriptions.
32 static void *kvm_devices
;
35 struct virtio_device vdev
;
36 struct kvm_device_desc
*desc
;
39 #define to_kvmdev(vd) container_of(vd, struct kvm_device, vdev)
43 * - kvm_device_descriptor
44 * struct kvm_device_desc
50 static struct kvm_vqconfig
*kvm_vq_config(const struct kvm_device_desc
*desc
)
52 return (struct kvm_vqconfig
*)(desc
+ 1);
55 static u8
*kvm_vq_features(const struct kvm_device_desc
*desc
)
57 return (u8
*)(kvm_vq_config(desc
) + desc
->num_vq
);
60 static u8
*kvm_vq_configspace(const struct kvm_device_desc
*desc
)
62 return kvm_vq_features(desc
) + desc
->feature_len
* 2;
66 * The total size of the config page used by this device (incl. desc)
68 static unsigned desc_size(const struct kvm_device_desc
*desc
)
71 + desc
->num_vq
* sizeof(struct kvm_vqconfig
)
72 + desc
->feature_len
* 2
76 /* This gets the device's feature bits. */
77 static u32
kvm_get_features(struct virtio_device
*vdev
)
81 struct kvm_device_desc
*desc
= to_kvmdev(vdev
)->desc
;
82 u8
*in_features
= kvm_vq_features(desc
);
84 for (i
= 0; i
< min(desc
->feature_len
* 8, 32); i
++)
85 if (in_features
[i
/ 8] & (1 << (i
% 8)))
90 static void kvm_set_features(struct virtio_device
*vdev
, u32 features
)
93 struct kvm_device_desc
*desc
= to_kvmdev(vdev
)->desc
;
94 /* Second half of bitmap is features we accept. */
95 u8
*out_features
= kvm_vq_features(desc
) + desc
->feature_len
;
97 memset(out_features
, 0, desc
->feature_len
);
98 for (i
= 0; i
< min(desc
->feature_len
* 8, 32); i
++) {
99 if (features
& (1 << i
))
100 out_features
[i
/ 8] |= (1 << (i
% 8));
105 * Reading and writing elements in config space
107 static void kvm_get(struct virtio_device
*vdev
, unsigned int offset
,
108 void *buf
, unsigned len
)
110 struct kvm_device_desc
*desc
= to_kvmdev(vdev
)->desc
;
112 BUG_ON(offset
+ len
> desc
->config_len
);
113 memcpy(buf
, kvm_vq_configspace(desc
) + offset
, len
);
116 static void kvm_set(struct virtio_device
*vdev
, unsigned int offset
,
117 const void *buf
, unsigned len
)
119 struct kvm_device_desc
*desc
= to_kvmdev(vdev
)->desc
;
121 BUG_ON(offset
+ len
> desc
->config_len
);
122 memcpy(kvm_vq_configspace(desc
) + offset
, buf
, len
);
126 * The operations to get and set the status word just access
127 * the status field of the device descriptor. set_status will also
128 * make a hypercall to the host, to tell about status changes
130 static u8
kvm_get_status(struct virtio_device
*vdev
)
132 return to_kvmdev(vdev
)->desc
->status
;
135 static void kvm_set_status(struct virtio_device
*vdev
, u8 status
)
138 to_kvmdev(vdev
)->desc
->status
= status
;
139 kvm_hypercall1(KVM_S390_VIRTIO_SET_STATUS
,
140 (unsigned long) to_kvmdev(vdev
)->desc
);
144 * To reset the device, we use the KVM_VIRTIO_RESET hypercall, using the
145 * descriptor address. The Host will zero the status and all the
148 static void kvm_reset(struct virtio_device
*vdev
)
150 kvm_hypercall1(KVM_S390_VIRTIO_RESET
,
151 (unsigned long) to_kvmdev(vdev
)->desc
);
155 * When the virtio_ring code wants to notify the Host, it calls us here and we
156 * make a hypercall. We hand the address of the virtqueue so the Host
157 * knows which virtqueue we're talking about.
159 static void kvm_notify(struct virtqueue
*vq
)
161 struct kvm_vqconfig
*config
= vq
->priv
;
163 kvm_hypercall1(KVM_S390_VIRTIO_NOTIFY
, config
->address
);
167 * This routine finds the first virtqueue described in the configuration of
168 * this device and sets it up.
170 static struct virtqueue
*kvm_find_vq(struct virtio_device
*vdev
,
172 void (*callback
)(struct virtqueue
*vq
))
174 struct kvm_device
*kdev
= to_kvmdev(vdev
);
175 struct kvm_vqconfig
*config
;
176 struct virtqueue
*vq
;
179 if (index
>= kdev
->desc
->num_vq
)
180 return ERR_PTR(-ENOENT
);
182 config
= kvm_vq_config(kdev
->desc
)+index
;
184 err
= vmem_add_mapping(config
->address
,
185 vring_size(config
->num
, PAGE_SIZE
));
189 vq
= vring_new_virtqueue(config
->num
, vdev
, (void *) config
->address
,
190 kvm_notify
, callback
);
197 * register a callback token
198 * The host will sent this via the external interrupt parameter
200 config
->token
= (u64
) vq
;
205 vmem_remove_mapping(config
->address
,
206 vring_size(config
->num
, PAGE_SIZE
));
211 static void kvm_del_vq(struct virtqueue
*vq
)
213 struct kvm_vqconfig
*config
= vq
->priv
;
215 vring_del_virtqueue(vq
);
216 vmem_remove_mapping(config
->address
,
217 vring_size(config
->num
, PAGE_SIZE
));
221 * The config ops structure as defined by virtio config
223 static struct virtio_config_ops kvm_vq_configspace_ops
= {
224 .get_features
= kvm_get_features
,
225 .set_features
= kvm_set_features
,
228 .get_status
= kvm_get_status
,
229 .set_status
= kvm_set_status
,
231 .find_vq
= kvm_find_vq
,
232 .del_vq
= kvm_del_vq
,
236 * The root device for the kvm virtio devices.
237 * This makes them appear as /sys/devices/kvm_s390/0,1,2 not /sys/devices/0,1,2.
239 static struct device kvm_root
= {
241 .bus_id
= "kvm_s390",
245 * adds a new device and register it with virtio
246 * appropriate drivers are loaded by the device model
248 static void add_kvm_device(struct kvm_device_desc
*d
, unsigned int offset
)
250 struct kvm_device
*kdev
;
252 kdev
= kzalloc(sizeof(*kdev
), GFP_KERNEL
);
254 printk(KERN_EMERG
"Cannot allocate kvm dev %u type %u\n",
259 kdev
->vdev
.dev
.parent
= &kvm_root
;
260 kdev
->vdev
.id
.device
= d
->type
;
261 kdev
->vdev
.config
= &kvm_vq_configspace_ops
;
264 if (register_virtio_device(&kdev
->vdev
) != 0) {
265 printk(KERN_ERR
"Failed to register kvm device %u type %u\n",
272 * scan_devices() simply iterates through the device page.
273 * The type 0 is reserved to mean "end of devices".
275 static void scan_devices(void)
278 struct kvm_device_desc
*d
;
280 for (i
= 0; i
< PAGE_SIZE
; i
+= desc_size(d
)) {
286 add_kvm_device(d
, i
);
291 * we emulate the request_irq behaviour on top of s390 extints
293 static void kvm_extint_handler(u16 code
)
295 void *data
= (void *) *(long *) __LC_PFAULT_INTPARM
;
296 u16 subcode
= S390_lowcore
.cpu_addr
;
298 if ((subcode
& 0xff00) != VIRTIO_SUBCODE_64
)
301 vring_interrupt(0, data
);
305 * Init function for virtio
306 * devices are in a single page above top of "normal" mem
308 static int __init
kvm_devices_init(void)
315 rc
= device_register(&kvm_root
);
317 printk(KERN_ERR
"Could not register kvm_s390 root device");
321 rc
= vmem_add_mapping(PFN_PHYS(max_pfn
), PAGE_SIZE
);
323 device_unregister(&kvm_root
);
327 kvm_devices
= (void *) PFN_PHYS(max_pfn
);
330 register_external_interrupt(0x2603, kvm_extint_handler
);
337 * We do this after core stuff, but before the drivers.
339 postcore_initcall(kvm_devices_init
);