blob: ff4a6931bb8e680b4f429577fc81e481df4cd786 [file] [log] [blame]
Christian Borntraegere976a2b2008-03-25 18:47:46 +01001/*
2 * kvm_virtio.c - virtio for kvm on s390
3 *
4 * Copyright IBM Corp. 2008
5 *
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.
9 *
10 * Author(s): Christian Borntraeger <borntraeger@de.ibm.com>
11 */
12
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>
Christian Borntraegerfaeba8302008-06-20 15:24:18 +020018#include <linux/virtio_console.h>
Christian Borntraegere976a2b2008-03-25 18:47:46 +010019#include <linux/interrupt.h>
20#include <linux/virtio_ring.h>
Heiko Carstens17f34582008-04-30 13:38:47 +020021#include <linux/pfn.h>
Christian Borntraegere976a2b2008-03-25 18:47:46 +010022#include <asm/io.h>
23#include <asm/kvm_para.h>
24#include <asm/kvm_virtio.h>
25#include <asm/setup.h>
26#include <asm/s390_ext.h>
Cornelia Huck37f1c012008-10-10 21:33:12 +020027#include <asm/s390_rdev.h>
Christian Borntraegere976a2b2008-03-25 18:47:46 +010028
29#define VIRTIO_SUBCODE_64 0x0D00
30
31/*
32 * The pointer to our (page) of device descriptions.
33 */
34static void *kvm_devices;
35
Christian Borntraegere976a2b2008-03-25 18:47:46 +010036struct kvm_device {
37 struct virtio_device vdev;
38 struct kvm_device_desc *desc;
39};
40
41#define to_kvmdev(vd) container_of(vd, struct kvm_device, vdev)
42
43/*
44 * memory layout:
45 * - kvm_device_descriptor
46 * struct kvm_device_desc
47 * - configuration
48 * struct kvm_vqconfig
49 * - feature bits
50 * - config space
51 */
52static struct kvm_vqconfig *kvm_vq_config(const struct kvm_device_desc *desc)
53{
54 return (struct kvm_vqconfig *)(desc + 1);
55}
56
57static u8 *kvm_vq_features(const struct kvm_device_desc *desc)
58{
59 return (u8 *)(kvm_vq_config(desc) + desc->num_vq);
60}
61
62static u8 *kvm_vq_configspace(const struct kvm_device_desc *desc)
63{
64 return kvm_vq_features(desc) + desc->feature_len * 2;
65}
66
67/*
68 * The total size of the config page used by this device (incl. desc)
69 */
70static unsigned desc_size(const struct kvm_device_desc *desc)
71{
72 return sizeof(*desc)
73 + desc->num_vq * sizeof(struct kvm_vqconfig)
74 + desc->feature_len * 2
75 + desc->config_len;
76}
77
Heiko Carstens5ca9fd52008-05-06 17:38:30 +030078/* This gets the device's feature bits. */
79static u32 kvm_get_features(struct virtio_device *vdev)
Christian Borntraegere976a2b2008-03-25 18:47:46 +010080{
Heiko Carstens5ca9fd52008-05-06 17:38:30 +030081 unsigned int i;
82 u32 features = 0;
Christian Borntraegere976a2b2008-03-25 18:47:46 +010083 struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
Heiko Carstens5ca9fd52008-05-06 17:38:30 +030084 u8 *in_features = kvm_vq_features(desc);
Christian Borntraegere976a2b2008-03-25 18:47:46 +010085
Heiko Carstens5ca9fd52008-05-06 17:38:30 +030086 for (i = 0; i < min(desc->feature_len * 8, 32); i++)
87 if (in_features[i / 8] & (1 << (i % 8)))
88 features |= (1 << i);
89 return features;
90}
Christian Borntraegere976a2b2008-03-25 18:47:46 +010091
Rusty Russellc6248962008-07-25 12:06:07 -050092static void kvm_finalize_features(struct virtio_device *vdev)
Heiko Carstens5ca9fd52008-05-06 17:38:30 +030093{
Rusty Russellc6248962008-07-25 12:06:07 -050094 unsigned int i, bits;
Heiko Carstens5ca9fd52008-05-06 17:38:30 +030095 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;
Christian Borntraegere976a2b2008-03-25 18:47:46 +010098
Rusty Russelle34f8722008-07-25 12:06:13 -050099 /* Give virtio_ring a chance to accept features. */
100 vring_transport_features(vdev);
101
Heiko Carstens5ca9fd52008-05-06 17:38:30 +0300102 memset(out_features, 0, desc->feature_len);
Rusty Russellc6248962008-07-25 12:06:07 -0500103 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))
Heiko Carstens5ca9fd52008-05-06 17:38:30 +0300106 out_features[i / 8] |= (1 << (i % 8));
107 }
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100108}
109
110/*
111 * Reading and writing elements in config space
112 */
113static void kvm_get(struct virtio_device *vdev, unsigned int offset,
114 void *buf, unsigned len)
115{
116 struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
117
118 BUG_ON(offset + len > desc->config_len);
119 memcpy(buf, kvm_vq_configspace(desc) + offset, len);
120}
121
122static void kvm_set(struct virtio_device *vdev, unsigned int offset,
123 const void *buf, unsigned len)
124{
125 struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
126
127 BUG_ON(offset + len > desc->config_len);
128 memcpy(kvm_vq_configspace(desc) + offset, buf, len);
129}
130
131/*
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
135 */
136static u8 kvm_get_status(struct virtio_device *vdev)
137{
138 return to_kvmdev(vdev)->desc->status;
139}
140
141static void kvm_set_status(struct virtio_device *vdev, u8 status)
142{
143 BUG_ON(!status);
144 to_kvmdev(vdev)->desc->status = status;
145 kvm_hypercall1(KVM_S390_VIRTIO_SET_STATUS,
146 (unsigned long) to_kvmdev(vdev)->desc);
147}
148
149/*
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
152 * features.
153 */
154static void kvm_reset(struct virtio_device *vdev)
155{
156 kvm_hypercall1(KVM_S390_VIRTIO_RESET,
157 (unsigned long) to_kvmdev(vdev)->desc);
158}
159
160/*
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.
164 */
165static void kvm_notify(struct virtqueue *vq)
166{
167 struct kvm_vqconfig *config = vq->priv;
168
169 kvm_hypercall1(KVM_S390_VIRTIO_NOTIFY, config->address);
170}
171
172/*
173 * This routine finds the first virtqueue described in the configuration of
174 * this device and sets it up.
175 */
176static struct virtqueue *kvm_find_vq(struct virtio_device *vdev,
177 unsigned index,
178 void (*callback)(struct virtqueue *vq))
179{
180 struct kvm_device *kdev = to_kvmdev(vdev);
181 struct kvm_vqconfig *config;
182 struct virtqueue *vq;
183 int err;
184
185 if (index >= kdev->desc->num_vq)
186 return ERR_PTR(-ENOENT);
187
188 config = kvm_vq_config(kdev->desc)+index;
189
Heiko Carstens17f34582008-04-30 13:38:47 +0200190 err = vmem_add_mapping(config->address,
191 vring_size(config->num, PAGE_SIZE));
192 if (err)
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100193 goto out;
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100194
195 vq = vring_new_virtqueue(config->num, vdev, (void *) config->address,
196 kvm_notify, callback);
197 if (!vq) {
198 err = -ENOMEM;
199 goto unmap;
200 }
201
202 /*
203 * register a callback token
204 * The host will sent this via the external interrupt parameter
205 */
206 config->token = (u64) vq;
207
208 vq->priv = config;
209 return vq;
210unmap:
Heiko Carstens17f34582008-04-30 13:38:47 +0200211 vmem_remove_mapping(config->address,
212 vring_size(config->num, PAGE_SIZE));
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100213out:
214 return ERR_PTR(err);
215}
216
217static void kvm_del_vq(struct virtqueue *vq)
218{
219 struct kvm_vqconfig *config = vq->priv;
220
221 vring_del_virtqueue(vq);
Heiko Carstens17f34582008-04-30 13:38:47 +0200222 vmem_remove_mapping(config->address,
223 vring_size(config->num, PAGE_SIZE));
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100224}
225
226/*
227 * The config ops structure as defined by virtio config
228 */
229static struct virtio_config_ops kvm_vq_configspace_ops = {
Heiko Carstens5ca9fd52008-05-06 17:38:30 +0300230 .get_features = kvm_get_features,
Rusty Russellc6248962008-07-25 12:06:07 -0500231 .finalize_features = kvm_finalize_features,
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100232 .get = kvm_get,
233 .set = kvm_set,
234 .get_status = kvm_get_status,
235 .set_status = kvm_set_status,
236 .reset = kvm_reset,
237 .find_vq = kvm_find_vq,
238 .del_vq = kvm_del_vq,
239};
240
241/*
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.
244 */
Cornelia Huck37f1c012008-10-10 21:33:12 +0200245static struct device *kvm_root;
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100246
247/*
248 * adds a new device and register it with virtio
249 * appropriate drivers are loaded by the device model
250 */
Rusty Russellb769f572008-05-30 15:09:42 -0500251static void add_kvm_device(struct kvm_device_desc *d, unsigned int offset)
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100252{
253 struct kvm_device *kdev;
254
255 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
256 if (!kdev) {
Rusty Russellb769f572008-05-30 15:09:42 -0500257 printk(KERN_EMERG "Cannot allocate kvm dev %u type %u\n",
258 offset, d->type);
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100259 return;
260 }
261
Cornelia Huck37f1c012008-10-10 21:33:12 +0200262 kdev->vdev.dev.parent = kvm_root;
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100263 kdev->vdev.id.device = d->type;
264 kdev->vdev.config = &kvm_vq_configspace_ops;
265 kdev->desc = d;
266
267 if (register_virtio_device(&kdev->vdev) != 0) {
Rusty Russellb769f572008-05-30 15:09:42 -0500268 printk(KERN_ERR "Failed to register kvm device %u type %u\n",
269 offset, d->type);
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100270 kfree(kdev);
271 }
272}
273
274/*
275 * scan_devices() simply iterates through the device page.
276 * The type 0 is reserved to mean "end of devices".
277 */
278static void scan_devices(void)
279{
280 unsigned int i;
281 struct kvm_device_desc *d;
282
283 for (i = 0; i < PAGE_SIZE; i += desc_size(d)) {
284 d = kvm_devices + i;
285
286 if (d->type == 0)
287 break;
288
Rusty Russellb769f572008-05-30 15:09:42 -0500289 add_kvm_device(d, i);
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100290 }
291}
292
293/*
294 * we emulate the request_irq behaviour on top of s390 extints
295 */
296static void kvm_extint_handler(u16 code)
297{
298 void *data = (void *) *(long *) __LC_PFAULT_INTPARM;
299 u16 subcode = S390_lowcore.cpu_addr;
300
301 if ((subcode & 0xff00) != VIRTIO_SUBCODE_64)
302 return;
303
304 vring_interrupt(0, data);
305}
306
307/*
308 * Init function for virtio
309 * devices are in a single page above top of "normal" mem
310 */
311static int __init kvm_devices_init(void)
312{
313 int rc;
314
315 if (!MACHINE_IS_KVM)
316 return -ENODEV;
317
Cornelia Huck37f1c012008-10-10 21:33:12 +0200318 kvm_root = s390_root_dev_register("kvm_s390");
319 if (IS_ERR(kvm_root)) {
320 rc = PTR_ERR(kvm_root);
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100321 printk(KERN_ERR "Could not register kvm_s390 root device");
322 return rc;
323 }
324
Heiko Carstens17f34582008-04-30 13:38:47 +0200325 rc = vmem_add_mapping(PFN_PHYS(max_pfn), PAGE_SIZE);
326 if (rc) {
Cornelia Huck37f1c012008-10-10 21:33:12 +0200327 s390_root_dev_unregister(kvm_root);
Heiko Carstens17f34582008-04-30 13:38:47 +0200328 return rc;
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100329 }
330
Heiko Carstens17f34582008-04-30 13:38:47 +0200331 kvm_devices = (void *) PFN_PHYS(max_pfn);
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100332
333 ctl_set_bit(0, 9);
334 register_external_interrupt(0x2603, kvm_extint_handler);
335
336 scan_devices();
337 return 0;
338}
339
Christian Borntraegerfaeba8302008-06-20 15:24:18 +0200340/* code for early console output with virtio_console */
341static __init int early_put_chars(u32 vtermno, const char *buf, int count)
342{
343 char scratch[17];
344 unsigned int len = count;
345
346 if (len > sizeof(scratch) - 1)
347 len = sizeof(scratch) - 1;
348 scratch[len] = '\0';
349 memcpy(scratch, buf, len);
350 kvm_hypercall1(KVM_S390_VIRTIO_NOTIFY, __pa(scratch));
351 return len;
352}
353
Heiko Carstens26f746f2008-08-01 16:39:22 +0200354void __init s390_virtio_console_init(void)
Christian Borntraegerfaeba8302008-06-20 15:24:18 +0200355{
356 virtio_cons_early_init(early_put_chars);
357}
358
Christian Borntraegere976a2b2008-03-25 18:47:46 +0100359/*
360 * We do this after core stuff, but before the drivers.
361 */
362postcore_initcall(kvm_devices_init);