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/virtio_console.h>
19 #include <linux/interrupt.h>
20 #include <linux/virtio_ring.h>
21 #include <linux/pfn.h>
23 #include <asm/kvm_para.h>
24 #include <asm/kvm_virtio.h>
25 #include <asm/setup.h>
26 #include <asm/s390_ext.h>
27 #include <asm/s390_rdev.h>
29 #define VIRTIO_SUBCODE_64 0x0D00
32 * The pointer to our (page) of device descriptions.
34 static void *kvm_devices
;
37 struct virtio_device vdev
;
38 struct kvm_device_desc
*desc
;
41 #define to_kvmdev(vd) container_of(vd, struct kvm_device, vdev)
45 * - kvm_device_descriptor
46 * struct kvm_device_desc
52 static struct kvm_vqconfig
*kvm_vq_config(const struct kvm_device_desc
*desc
)
54 return (struct kvm_vqconfig
*)(desc
+ 1);
57 static u8
*kvm_vq_features(const struct kvm_device_desc
*desc
)
59 return (u8
*)(kvm_vq_config(desc
) + desc
->num_vq
);
62 static u8
*kvm_vq_configspace(const struct kvm_device_desc
*desc
)
64 return kvm_vq_features(desc
) + desc
->feature_len
* 2;
68 * The total size of the config page used by this device (incl. desc)
70 static unsigned desc_size(const struct kvm_device_desc
*desc
)
73 + desc
->num_vq
* sizeof(struct kvm_vqconfig
)
74 + desc
->feature_len
* 2
78 /* This gets the device's feature bits. */
79 static u32
kvm_get_features(struct virtio_device
*vdev
)
83 struct kvm_device_desc
*desc
= to_kvmdev(vdev
)->desc
;
84 u8
*in_features
= kvm_vq_features(desc
);
86 for (i
= 0; i
< min(desc
->feature_len
* 8, 32); i
++)
87 if (in_features
[i
/ 8] & (1 << (i
% 8)))
92 static void kvm_finalize_features(struct virtio_device
*vdev
)
95 struct kvm_device_desc
*desc
= to_kvmdev(vdev
)->desc
;
96 /* Second half of bitmap is features we accept. */
97 u8
*out_features
= kvm_vq_features(desc
) + desc
->feature_len
;
99 /* Give virtio_ring a chance to accept features. */
100 vring_transport_features(vdev
);
102 memset(out_features
, 0, desc
->feature_len
);
103 bits
= min_t(unsigned, desc
->feature_len
, sizeof(vdev
->features
)) * 8;
104 for (i
= 0; i
< bits
; i
++) {
105 if (test_bit(i
, vdev
->features
))
106 out_features
[i
/ 8] |= (1 << (i
% 8));
111 * Reading and writing elements in config space
113 static void kvm_get(struct virtio_device
*vdev
, unsigned int offset
,
114 void *buf
, unsigned len
)
116 struct kvm_device_desc
*desc
= to_kvmdev(vdev
)->desc
;
118 BUG_ON(offset
+ len
> desc
->config_len
);
119 memcpy(buf
, kvm_vq_configspace(desc
) + offset
, len
);
122 static void kvm_set(struct virtio_device
*vdev
, unsigned int offset
,
123 const void *buf
, unsigned len
)
125 struct kvm_device_desc
*desc
= to_kvmdev(vdev
)->desc
;
127 BUG_ON(offset
+ len
> desc
->config_len
);
128 memcpy(kvm_vq_configspace(desc
) + offset
, buf
, len
);
132 * The operations to get and set the status word just access
133 * the status field of the device descriptor. set_status will also
134 * make a hypercall to the host, to tell about status changes
136 static u8
kvm_get_status(struct virtio_device
*vdev
)
138 return to_kvmdev(vdev
)->desc
->status
;
141 static void kvm_set_status(struct virtio_device
*vdev
, u8 status
)
144 to_kvmdev(vdev
)->desc
->status
= status
;
145 kvm_hypercall1(KVM_S390_VIRTIO_SET_STATUS
,
146 (unsigned long) to_kvmdev(vdev
)->desc
);
150 * To reset the device, we use the KVM_VIRTIO_RESET hypercall, using the
151 * descriptor address. The Host will zero the status and all the
154 static void kvm_reset(struct virtio_device
*vdev
)
156 kvm_hypercall1(KVM_S390_VIRTIO_RESET
,
157 (unsigned long) to_kvmdev(vdev
)->desc
);
161 * When the virtio_ring code wants to notify the Host, it calls us here and we
162 * make a hypercall. We hand the address of the virtqueue so the Host
163 * knows which virtqueue we're talking about.
165 static void kvm_notify(struct virtqueue
*vq
)
167 struct kvm_vqconfig
*config
= vq
->priv
;
169 kvm_hypercall1(KVM_S390_VIRTIO_NOTIFY
, config
->address
);
173 * This routine finds the first virtqueue described in the configuration of
174 * this device and sets it up.
176 static struct virtqueue
*kvm_find_vq(struct virtio_device
*vdev
,
178 void (*callback
)(struct virtqueue
*vq
))
180 struct kvm_device
*kdev
= to_kvmdev(vdev
);
181 struct kvm_vqconfig
*config
;
182 struct virtqueue
*vq
;
185 if (index
>= kdev
->desc
->num_vq
)
186 return ERR_PTR(-ENOENT
);
188 config
= kvm_vq_config(kdev
->desc
)+index
;
190 err
= vmem_add_mapping(config
->address
,
191 vring_size(config
->num
, PAGE_SIZE
));
195 vq
= vring_new_virtqueue(config
->num
, vdev
, (void *) config
->address
,
196 kvm_notify
, callback
);
203 * register a callback token
204 * The host will sent this via the external interrupt parameter
206 config
->token
= (u64
) vq
;
211 vmem_remove_mapping(config
->address
,
212 vring_size(config
->num
, PAGE_SIZE
));
217 static void kvm_del_vq(struct virtqueue
*vq
)
219 struct kvm_vqconfig
*config
= vq
->priv
;
221 vring_del_virtqueue(vq
);
222 vmem_remove_mapping(config
->address
,
223 vring_size(config
->num
, PAGE_SIZE
));
227 * The config ops structure as defined by virtio config
229 static struct virtio_config_ops kvm_vq_configspace_ops
= {
230 .get_features
= kvm_get_features
,
231 .finalize_features
= kvm_finalize_features
,
234 .get_status
= kvm_get_status
,
235 .set_status
= kvm_set_status
,
237 .find_vq
= kvm_find_vq
,
238 .del_vq
= kvm_del_vq
,
242 * The root device for the kvm virtio devices.
243 * This makes them appear as /sys/devices/kvm_s390/0,1,2 not /sys/devices/0,1,2.
245 static struct device
*kvm_root
;
248 * adds a new device and register it with virtio
249 * appropriate drivers are loaded by the device model
251 static void add_kvm_device(struct kvm_device_desc
*d
, unsigned int offset
)
253 struct kvm_device
*kdev
;
255 kdev
= kzalloc(sizeof(*kdev
), GFP_KERNEL
);
257 printk(KERN_EMERG
"Cannot allocate kvm dev %u type %u\n",
262 kdev
->vdev
.dev
.parent
= kvm_root
;
263 kdev
->vdev
.id
.device
= d
->type
;
264 kdev
->vdev
.config
= &kvm_vq_configspace_ops
;
267 if (register_virtio_device(&kdev
->vdev
) != 0) {
268 printk(KERN_ERR
"Failed to register kvm device %u type %u\n",
275 * scan_devices() simply iterates through the device page.
276 * The type 0 is reserved to mean "end of devices".
278 static void scan_devices(void)
281 struct kvm_device_desc
*d
;
283 for (i
= 0; i
< PAGE_SIZE
; i
+= desc_size(d
)) {
289 add_kvm_device(d
, i
);
294 * we emulate the request_irq behaviour on top of s390 extints
296 static void kvm_extint_handler(u16 code
)
298 void *data
= (void *) *(long *) __LC_PFAULT_INTPARM
;
299 u16 subcode
= S390_lowcore
.cpu_addr
;
301 if ((subcode
& 0xff00) != VIRTIO_SUBCODE_64
)
304 vring_interrupt(0, data
);
308 * Init function for virtio
309 * devices are in a single page above top of "normal" mem
311 static int __init
kvm_devices_init(void)
318 kvm_root
= s390_root_dev_register("kvm_s390");
319 if (IS_ERR(kvm_root
)) {
320 rc
= PTR_ERR(kvm_root
);
321 printk(KERN_ERR
"Could not register kvm_s390 root device");
325 rc
= vmem_add_mapping(PFN_PHYS(max_pfn
), PAGE_SIZE
);
327 s390_root_dev_unregister(kvm_root
);
331 kvm_devices
= (void *) PFN_PHYS(max_pfn
);
334 register_external_interrupt(0x2603, kvm_extint_handler
);
340 /* code for early console output with virtio_console */
341 static __init
int early_put_chars(u32 vtermno
, const char *buf
, int count
)
344 unsigned int len
= count
;
346 if (len
> sizeof(scratch
) - 1)
347 len
= sizeof(scratch
) - 1;
349 memcpy(scratch
, buf
, len
);
350 kvm_hypercall1(KVM_S390_VIRTIO_NOTIFY
, __pa(scratch
));
354 void __init
s390_virtio_console_init(void)
356 virtio_cons_early_init(early_put_chars
);
360 * We do this after core stuff, but before the drivers.
362 postcore_initcall(kvm_devices_init
);