]>
Commit | Line | Data |
---|---|---|
e976a2b9 | 1 | /* |
a53c8fab | 2 | * virtio for kvm on s390 |
e976a2b9 CB |
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 | ||
052ff461 | 13 | #include <linux/kernel_stat.h> |
e976a2b9 CB |
14 | #include <linux/init.h> |
15 | #include <linux/bootmem.h> | |
16 | #include <linux/err.h> | |
17 | #include <linux/virtio.h> | |
18 | #include <linux/virtio_config.h> | |
5a0e3ad6 | 19 | #include <linux/slab.h> |
faeba830 | 20 | #include <linux/virtio_console.h> |
e976a2b9 CB |
21 | #include <linux/interrupt.h> |
22 | #include <linux/virtio_ring.h> | |
3a4c5d59 | 23 | #include <linux/export.h> |
17f34580 | 24 | #include <linux/pfn.h> |
e976a2b9 CB |
25 | #include <asm/io.h> |
26 | #include <asm/kvm_para.h> | |
27 | #include <asm/kvm_virtio.h> | |
cd183459 | 28 | #include <asm/sclp.h> |
e976a2b9 | 29 | #include <asm/setup.h> |
052ff461 | 30 | #include <asm/irq.h> |
e976a2b9 CB |
31 | |
32 | #define VIRTIO_SUBCODE_64 0x0D00 | |
33 | ||
34 | /* | |
35 | * The pointer to our (page) of device descriptions. | |
36 | */ | |
37 | static void *kvm_devices; | |
c4736d96 | 38 | static struct work_struct hotplug_work; |
e976a2b9 | 39 | |
e976a2b9 CB |
40 | struct kvm_device { |
41 | struct virtio_device vdev; | |
42 | struct kvm_device_desc *desc; | |
43 | }; | |
44 | ||
45 | #define to_kvmdev(vd) container_of(vd, struct kvm_device, vdev) | |
46 | ||
47 | /* | |
48 | * memory layout: | |
49 | * - kvm_device_descriptor | |
50 | * struct kvm_device_desc | |
51 | * - configuration | |
52 | * struct kvm_vqconfig | |
53 | * - feature bits | |
54 | * - config space | |
55 | */ | |
56 | static struct kvm_vqconfig *kvm_vq_config(const struct kvm_device_desc *desc) | |
57 | { | |
58 | return (struct kvm_vqconfig *)(desc + 1); | |
59 | } | |
60 | ||
61 | static u8 *kvm_vq_features(const struct kvm_device_desc *desc) | |
62 | { | |
63 | return (u8 *)(kvm_vq_config(desc) + desc->num_vq); | |
64 | } | |
65 | ||
66 | static u8 *kvm_vq_configspace(const struct kvm_device_desc *desc) | |
67 | { | |
68 | return kvm_vq_features(desc) + desc->feature_len * 2; | |
69 | } | |
70 | ||
71 | /* | |
72 | * The total size of the config page used by this device (incl. desc) | |
73 | */ | |
74 | static unsigned desc_size(const struct kvm_device_desc *desc) | |
75 | { | |
76 | return sizeof(*desc) | |
77 | + desc->num_vq * sizeof(struct kvm_vqconfig) | |
78 | + desc->feature_len * 2 | |
79 | + desc->config_len; | |
80 | } | |
81 | ||
5ca9fd54 | 82 | /* This gets the device's feature bits. */ |
d0254773 | 83 | static u64 kvm_get_features(struct virtio_device *vdev) |
e976a2b9 | 84 | { |
5ca9fd54 HC |
85 | unsigned int i; |
86 | u32 features = 0; | |
e976a2b9 | 87 | struct kvm_device_desc *desc = to_kvmdev(vdev)->desc; |
5ca9fd54 | 88 | u8 *in_features = kvm_vq_features(desc); |
e976a2b9 | 89 | |
5ca9fd54 HC |
90 | for (i = 0; i < min(desc->feature_len * 8, 32); i++) |
91 | if (in_features[i / 8] & (1 << (i % 8))) | |
92 | features |= (1 << i); | |
93 | return features; | |
94 | } | |
e976a2b9 | 95 | |
5c609a5e | 96 | static int kvm_finalize_features(struct virtio_device *vdev) |
5ca9fd54 | 97 | { |
c624896e | 98 | unsigned int i, bits; |
5ca9fd54 HC |
99 | struct kvm_device_desc *desc = to_kvmdev(vdev)->desc; |
100 | /* Second half of bitmap is features we accept. */ | |
101 | u8 *out_features = kvm_vq_features(desc) + desc->feature_len; | |
e976a2b9 | 102 | |
e34f8725 RR |
103 | /* Give virtio_ring a chance to accept features. */ |
104 | vring_transport_features(vdev); | |
105 | ||
93d389f8 MT |
106 | /* Make sure we don't have any features > 32 bits! */ |
107 | BUG_ON((u32)vdev->features != vdev->features); | |
108 | ||
5ca9fd54 | 109 | memset(out_features, 0, desc->feature_len); |
c624896e RR |
110 | bits = min_t(unsigned, desc->feature_len, sizeof(vdev->features)) * 8; |
111 | for (i = 0; i < bits; i++) { | |
e16e12be | 112 | if (__virtio_test_bit(vdev, i)) |
5ca9fd54 HC |
113 | out_features[i / 8] |= (1 << (i % 8)); |
114 | } | |
5c609a5e MT |
115 | |
116 | return 0; | |
e976a2b9 CB |
117 | } |
118 | ||
119 | /* | |
120 | * Reading and writing elements in config space | |
121 | */ | |
122 | static void kvm_get(struct virtio_device *vdev, unsigned int offset, | |
123 | 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(buf, kvm_vq_configspace(desc) + offset, len); | |
129 | } | |
130 | ||
131 | static void kvm_set(struct virtio_device *vdev, unsigned int offset, | |
132 | const void *buf, unsigned len) | |
133 | { | |
134 | struct kvm_device_desc *desc = to_kvmdev(vdev)->desc; | |
135 | ||
136 | BUG_ON(offset + len > desc->config_len); | |
137 | memcpy(kvm_vq_configspace(desc) + offset, buf, len); | |
138 | } | |
139 | ||
140 | /* | |
141 | * The operations to get and set the status word just access | |
142 | * the status field of the device descriptor. set_status will also | |
143 | * make a hypercall to the host, to tell about status changes | |
144 | */ | |
145 | static u8 kvm_get_status(struct virtio_device *vdev) | |
146 | { | |
147 | return to_kvmdev(vdev)->desc->status; | |
148 | } | |
149 | ||
150 | static void kvm_set_status(struct virtio_device *vdev, u8 status) | |
151 | { | |
152 | BUG_ON(!status); | |
153 | to_kvmdev(vdev)->desc->status = status; | |
154 | kvm_hypercall1(KVM_S390_VIRTIO_SET_STATUS, | |
155 | (unsigned long) to_kvmdev(vdev)->desc); | |
156 | } | |
157 | ||
158 | /* | |
159 | * To reset the device, we use the KVM_VIRTIO_RESET hypercall, using the | |
160 | * descriptor address. The Host will zero the status and all the | |
161 | * features. | |
162 | */ | |
163 | static void kvm_reset(struct virtio_device *vdev) | |
164 | { | |
165 | kvm_hypercall1(KVM_S390_VIRTIO_RESET, | |
166 | (unsigned long) to_kvmdev(vdev)->desc); | |
167 | } | |
168 | ||
169 | /* | |
170 | * When the virtio_ring code wants to notify the Host, it calls us here and we | |
171 | * make a hypercall. We hand the address of the virtqueue so the Host | |
172 | * knows which virtqueue we're talking about. | |
173 | */ | |
46f9c2b9 | 174 | static bool kvm_notify(struct virtqueue *vq) |
e976a2b9 | 175 | { |
46f9c2b9 | 176 | long rc; |
e976a2b9 CB |
177 | struct kvm_vqconfig *config = vq->priv; |
178 | ||
46f9c2b9 HG |
179 | rc = kvm_hypercall1(KVM_S390_VIRTIO_NOTIFY, config->address); |
180 | if (rc < 0) | |
181 | return false; | |
182 | return true; | |
e976a2b9 CB |
183 | } |
184 | ||
185 | /* | |
186 | * This routine finds the first virtqueue described in the configuration of | |
187 | * this device and sets it up. | |
188 | */ | |
189 | static struct virtqueue *kvm_find_vq(struct virtio_device *vdev, | |
9499f5e7 RR |
190 | unsigned index, |
191 | void (*callback)(struct virtqueue *vq), | |
f94682dd | 192 | const char *name, bool ctx) |
e976a2b9 CB |
193 | { |
194 | struct kvm_device *kdev = to_kvmdev(vdev); | |
195 | struct kvm_vqconfig *config; | |
196 | struct virtqueue *vq; | |
197 | int err; | |
198 | ||
199 | if (index >= kdev->desc->num_vq) | |
200 | return ERR_PTR(-ENOENT); | |
201 | ||
6457f126 MT |
202 | if (!name) |
203 | return NULL; | |
204 | ||
e976a2b9 CB |
205 | config = kvm_vq_config(kdev->desc)+index; |
206 | ||
17f34580 | 207 | err = vmem_add_mapping(config->address, |
db405988 RR |
208 | vring_size(config->num, |
209 | KVM_S390_VIRTIO_RING_ALIGN)); | |
17f34580 | 210 | if (err) |
e976a2b9 | 211 | goto out; |
e976a2b9 | 212 | |
17bb6d40 | 213 | vq = vring_new_virtqueue(index, config->num, KVM_S390_VIRTIO_RING_ALIGN, |
f94682dd | 214 | vdev, true, ctx, (void *) config->address, |
9499f5e7 | 215 | kvm_notify, callback, name); |
e976a2b9 CB |
216 | if (!vq) { |
217 | err = -ENOMEM; | |
218 | goto unmap; | |
219 | } | |
220 | ||
221 | /* | |
222 | * register a callback token | |
223 | * The host will sent this via the external interrupt parameter | |
224 | */ | |
225 | config->token = (u64) vq; | |
226 | ||
227 | vq->priv = config; | |
228 | return vq; | |
229 | unmap: | |
17f34580 | 230 | vmem_remove_mapping(config->address, |
db405988 RR |
231 | vring_size(config->num, |
232 | KVM_S390_VIRTIO_RING_ALIGN)); | |
e976a2b9 CB |
233 | out: |
234 | return ERR_PTR(err); | |
235 | } | |
236 | ||
237 | static void kvm_del_vq(struct virtqueue *vq) | |
238 | { | |
239 | struct kvm_vqconfig *config = vq->priv; | |
240 | ||
241 | vring_del_virtqueue(vq); | |
17f34580 | 242 | vmem_remove_mapping(config->address, |
db405988 RR |
243 | vring_size(config->num, |
244 | KVM_S390_VIRTIO_RING_ALIGN)); | |
e976a2b9 CB |
245 | } |
246 | ||
d2a7ddda MT |
247 | static void kvm_del_vqs(struct virtio_device *vdev) |
248 | { | |
249 | struct virtqueue *vq, *n; | |
250 | ||
251 | list_for_each_entry_safe(vq, n, &vdev->vqs, list) | |
252 | kvm_del_vq(vq); | |
253 | } | |
254 | ||
255 | static int kvm_find_vqs(struct virtio_device *vdev, unsigned nvqs, | |
256 | struct virtqueue *vqs[], | |
257 | vq_callback_t *callbacks[], | |
fb5e31d9 | 258 | const char * const names[], |
f94682dd | 259 | const bool *ctx, |
fb5e31d9 | 260 | struct irq_affinity *desc) |
d2a7ddda MT |
261 | { |
262 | struct kvm_device *kdev = to_kvmdev(vdev); | |
263 | int i; | |
264 | ||
265 | /* We must have this many virtqueues. */ | |
266 | if (nvqs > kdev->desc->num_vq) | |
267 | return -ENOENT; | |
268 | ||
269 | for (i = 0; i < nvqs; ++i) { | |
f94682dd MT |
270 | vqs[i] = kvm_find_vq(vdev, i, callbacks[i], names[i], |
271 | ctx ? ctx[i] : false); | |
d2a7ddda MT |
272 | if (IS_ERR(vqs[i])) |
273 | goto error; | |
274 | } | |
275 | return 0; | |
276 | ||
277 | error: | |
278 | kvm_del_vqs(vdev); | |
279 | return PTR_ERR(vqs[i]); | |
280 | } | |
281 | ||
66846048 RJ |
282 | static const char *kvm_bus_name(struct virtio_device *vdev) |
283 | { | |
284 | return ""; | |
285 | } | |
286 | ||
e976a2b9 CB |
287 | /* |
288 | * The config ops structure as defined by virtio config | |
289 | */ | |
93503932 | 290 | static const struct virtio_config_ops kvm_vq_configspace_ops = { |
5ca9fd54 | 291 | .get_features = kvm_get_features, |
c624896e | 292 | .finalize_features = kvm_finalize_features, |
e976a2b9 CB |
293 | .get = kvm_get, |
294 | .set = kvm_set, | |
295 | .get_status = kvm_get_status, | |
296 | .set_status = kvm_set_status, | |
297 | .reset = kvm_reset, | |
d2a7ddda MT |
298 | .find_vqs = kvm_find_vqs, |
299 | .del_vqs = kvm_del_vqs, | |
66846048 | 300 | .bus_name = kvm_bus_name, |
e976a2b9 CB |
301 | }; |
302 | ||
303 | /* | |
304 | * The root device for the kvm virtio devices. | |
305 | * This makes them appear as /sys/devices/kvm_s390/0,1,2 not /sys/devices/0,1,2. | |
306 | */ | |
37f1c012 | 307 | static struct device *kvm_root; |
e976a2b9 CB |
308 | |
309 | /* | |
310 | * adds a new device and register it with virtio | |
311 | * appropriate drivers are loaded by the device model | |
312 | */ | |
b769f579 | 313 | static void add_kvm_device(struct kvm_device_desc *d, unsigned int offset) |
e976a2b9 CB |
314 | { |
315 | struct kvm_device *kdev; | |
316 | ||
317 | kdev = kzalloc(sizeof(*kdev), GFP_KERNEL); | |
318 | if (!kdev) { | |
b769f579 RR |
319 | printk(KERN_EMERG "Cannot allocate kvm dev %u type %u\n", |
320 | offset, d->type); | |
e976a2b9 CB |
321 | return; |
322 | } | |
323 | ||
37f1c012 | 324 | kdev->vdev.dev.parent = kvm_root; |
e976a2b9 CB |
325 | kdev->vdev.id.device = d->type; |
326 | kdev->vdev.config = &kvm_vq_configspace_ops; | |
327 | kdev->desc = d; | |
328 | ||
329 | if (register_virtio_device(&kdev->vdev) != 0) { | |
b769f579 RR |
330 | printk(KERN_ERR "Failed to register kvm device %u type %u\n", |
331 | offset, d->type); | |
e976a2b9 CB |
332 | kfree(kdev); |
333 | } | |
334 | } | |
335 | ||
336 | /* | |
337 | * scan_devices() simply iterates through the device page. | |
338 | * The type 0 is reserved to mean "end of devices". | |
339 | */ | |
340 | static void scan_devices(void) | |
341 | { | |
342 | unsigned int i; | |
343 | struct kvm_device_desc *d; | |
344 | ||
345 | for (i = 0; i < PAGE_SIZE; i += desc_size(d)) { | |
346 | d = kvm_devices + i; | |
347 | ||
348 | if (d->type == 0) | |
349 | break; | |
350 | ||
b769f579 | 351 | add_kvm_device(d, i); |
e976a2b9 CB |
352 | } |
353 | } | |
354 | ||
cefa33e2 AG |
355 | /* |
356 | * match for a kvm device with a specific desc pointer | |
357 | */ | |
358 | static int match_desc(struct device *dev, void *data) | |
359 | { | |
7bf4074d MS |
360 | struct virtio_device *vdev = dev_to_virtio(dev); |
361 | struct kvm_device *kdev = to_kvmdev(vdev); | |
cefa33e2 | 362 | |
7bf4074d | 363 | return kdev->desc == data; |
cefa33e2 AG |
364 | } |
365 | ||
366 | /* | |
367 | * hotplug_device tries to find changes in the device page. | |
368 | */ | |
369 | static void hotplug_devices(struct work_struct *dummy) | |
370 | { | |
371 | unsigned int i; | |
372 | struct kvm_device_desc *d; | |
373 | struct device *dev; | |
374 | ||
375 | for (i = 0; i < PAGE_SIZE; i += desc_size(d)) { | |
376 | d = kvm_devices + i; | |
377 | ||
378 | /* end of list */ | |
379 | if (d->type == 0) | |
380 | break; | |
381 | ||
382 | /* device already exists */ | |
383 | dev = device_find_child(kvm_root, d, match_desc); | |
384 | if (dev) { | |
385 | /* XXX check for hotplug remove */ | |
386 | put_device(dev); | |
387 | continue; | |
388 | } | |
389 | ||
390 | /* new device */ | |
391 | printk(KERN_INFO "Adding new virtio device %p\n", d); | |
392 | add_kvm_device(d, i); | |
393 | } | |
394 | } | |
395 | ||
e976a2b9 CB |
396 | /* |
397 | * we emulate the request_irq behaviour on top of s390 extints | |
398 | */ | |
fde15c3a | 399 | static void kvm_extint_handler(struct ext_code ext_code, |
f6649a7e | 400 | unsigned int param32, unsigned long param64) |
e976a2b9 | 401 | { |
be3c5832 | 402 | struct virtqueue *vq; |
fc678d67 | 403 | u32 param; |
e976a2b9 | 404 | |
fde15c3a | 405 | if ((ext_code.subcode & 0xff00) != VIRTIO_SUBCODE_64) |
e976a2b9 | 406 | return; |
420f42ec | 407 | inc_irq_stat(IRQEXT_VRT); |
e976a2b9 | 408 | |
be3c5832 | 409 | /* The LSB might be overloaded, we have to mask it */ |
f6649a7e | 410 | vq = (struct virtqueue *)(param64 & ~1UL); |
be3c5832 | 411 | |
fc678d67 | 412 | /* We use ext_params to decide what this interrupt means */ |
f6649a7e | 413 | param = param32 & VIRTIO_PARAM_MASK; |
be3c5832 | 414 | |
fc678d67 AG |
415 | switch (param) { |
416 | case VIRTIO_PARAM_CONFIG_CHANGED: | |
016c98c6 | 417 | virtio_config_changed(vq->vdev); |
fc678d67 | 418 | break; |
cefa33e2 AG |
419 | case VIRTIO_PARAM_DEV_ADD: |
420 | schedule_work(&hotplug_work); | |
421 | break; | |
fc678d67 AG |
422 | case VIRTIO_PARAM_VRING_INTERRUPT: |
423 | default: | |
be3c5832 | 424 | vring_interrupt(0, vq); |
fc678d67 AG |
425 | break; |
426 | } | |
e976a2b9 CB |
427 | } |
428 | ||
55c171a6 CH |
429 | /* |
430 | * For s390-virtio, we expect a page above main storage containing | |
431 | * the virtio configuration. Try to actually load from this area | |
432 | * in order to figure out if the host provides this page. | |
433 | */ | |
434 | static int __init test_devices_support(unsigned long addr) | |
435 | { | |
436 | int ret = -EIO; | |
437 | ||
438 | asm volatile( | |
439 | "0: lura 0,%1\n" | |
440 | "1: xgr %0,%0\n" | |
441 | "2:\n" | |
442 | EX_TABLE(0b,2b) | |
443 | EX_TABLE(1b,2b) | |
444 | : "+d" (ret) | |
445 | : "a" (addr) | |
446 | : "0", "cc"); | |
447 | return ret; | |
448 | } | |
e976a2b9 CB |
449 | /* |
450 | * Init function for virtio | |
3188bf6b | 451 | * devices are in a single page above top of "normal" + standby mem |
e976a2b9 CB |
452 | */ |
453 | static int __init kvm_devices_init(void) | |
454 | { | |
455 | int rc; | |
37c5f6c8 | 456 | unsigned long total_memory_size = sclp.rzm * sclp.rnmax; |
e976a2b9 CB |
457 | |
458 | if (!MACHINE_IS_KVM) | |
459 | return -ENODEV; | |
460 | ||
3188bf6b | 461 | if (test_devices_support(total_memory_size) < 0) |
55c171a6 CH |
462 | return -ENODEV; |
463 | ||
3b2fbb3f CH |
464 | pr_warn("The s390-virtio transport is deprecated. Please switch to a modern host providing virtio-ccw.\n"); |
465 | ||
3188bf6b | 466 | rc = vmem_add_mapping(total_memory_size, PAGE_SIZE); |
55c171a6 CH |
467 | if (rc) |
468 | return rc; | |
469 | ||
3188bf6b | 470 | kvm_devices = (void *) total_memory_size; |
55c171a6 | 471 | |
035da16f | 472 | kvm_root = root_device_register("kvm_s390"); |
37f1c012 CH |
473 | if (IS_ERR(kvm_root)) { |
474 | rc = PTR_ERR(kvm_root); | |
e976a2b9 | 475 | printk(KERN_ERR "Could not register kvm_s390 root device"); |
3188bf6b | 476 | vmem_remove_mapping(total_memory_size, PAGE_SIZE); |
e976a2b9 CB |
477 | return rc; |
478 | } | |
479 | ||
cefa33e2 AG |
480 | INIT_WORK(&hotplug_work, hotplug_devices); |
481 | ||
82003c3e | 482 | irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL); |
1dad093b | 483 | register_external_irq(EXT_IRQ_CP_SERVICE, kvm_extint_handler); |
e976a2b9 CB |
484 | |
485 | scan_devices(); | |
486 | return 0; | |
487 | } | |
488 | ||
faeba830 | 489 | /* code for early console output with virtio_console */ |
2ab0d56a | 490 | static int early_put_chars(u32 vtermno, const char *buf, int count) |
faeba830 CB |
491 | { |
492 | char scratch[17]; | |
493 | unsigned int len = count; | |
494 | ||
495 | if (len > sizeof(scratch) - 1) | |
496 | len = sizeof(scratch) - 1; | |
497 | scratch[len] = '\0'; | |
498 | memcpy(scratch, buf, len); | |
499 | kvm_hypercall1(KVM_S390_VIRTIO_NOTIFY, __pa(scratch)); | |
500 | return len; | |
501 | } | |
502 | ||
c4de0c1a | 503 | static int __init s390_virtio_console_init(void) |
faeba830 | 504 | { |
37c5f6c8 | 505 | if (sclp.has_vt220 || sclp.has_linemode) |
c4de0c1a HB |
506 | return -ENODEV; |
507 | return virtio_cons_early_init(early_put_chars); | |
faeba830 | 508 | } |
c4de0c1a HB |
509 | console_initcall(s390_virtio_console_init); |
510 | ||
faeba830 | 511 | |
e976a2b9 CB |
512 | /* |
513 | * We do this after core stuff, but before the drivers. | |
514 | */ | |
515 | postcore_initcall(kvm_devices_init); |