Revert "KVM: MMU: lazily drop large spte"
[linux-3.10.git] / drivers / s390 / kvm / virtio_ccw.c
1 /*
2  * ccw based virtio transport
3  *
4  * Copyright IBM Corp. 2012
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): Cornelia Huck <cornelia.huck@de.ibm.com>
11  */
12
13 #include <linux/kernel_stat.h>
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>
19 #include <linux/slab.h>
20 #include <linux/interrupt.h>
21 #include <linux/virtio_ring.h>
22 #include <linux/pfn.h>
23 #include <linux/async.h>
24 #include <linux/wait.h>
25 #include <linux/list.h>
26 #include <linux/bitops.h>
27 #include <linux/module.h>
28 #include <linux/io.h>
29 #include <linux/kvm_para.h>
30 #include <asm/setup.h>
31 #include <asm/irq.h>
32 #include <asm/cio.h>
33 #include <asm/ccwdev.h>
34
35 /*
36  * virtio related functions
37  */
38
39 struct vq_config_block {
40         __u16 index;
41         __u16 num;
42 } __packed;
43
44 #define VIRTIO_CCW_CONFIG_SIZE 0x100
45 /* same as PCI config space size, should be enough for all drivers */
46
47 struct virtio_ccw_device {
48         struct virtio_device vdev;
49         __u8 *status;
50         __u8 config[VIRTIO_CCW_CONFIG_SIZE];
51         struct ccw_device *cdev;
52         __u32 curr_io;
53         int err;
54         wait_queue_head_t wait_q;
55         spinlock_t lock;
56         struct list_head virtqueues;
57         unsigned long indicators;
58         unsigned long indicators2;
59         struct vq_config_block *config_block;
60 };
61
62 struct vq_info_block {
63         __u64 queue;
64         __u32 align;
65         __u16 index;
66         __u16 num;
67 } __packed;
68
69 struct virtio_feature_desc {
70         __u32 features;
71         __u8 index;
72 } __packed;
73
74 struct virtio_ccw_vq_info {
75         struct virtqueue *vq;
76         int num;
77         void *queue;
78         struct vq_info_block *info_block;
79         struct list_head node;
80 };
81
82 #define KVM_VIRTIO_CCW_RING_ALIGN 4096
83
84 #define KVM_S390_VIRTIO_CCW_NOTIFY 3
85
86 #define CCW_CMD_SET_VQ 0x13
87 #define CCW_CMD_VDEV_RESET 0x33
88 #define CCW_CMD_SET_IND 0x43
89 #define CCW_CMD_SET_CONF_IND 0x53
90 #define CCW_CMD_READ_FEAT 0x12
91 #define CCW_CMD_WRITE_FEAT 0x11
92 #define CCW_CMD_READ_CONF 0x22
93 #define CCW_CMD_WRITE_CONF 0x21
94 #define CCW_CMD_WRITE_STATUS 0x31
95 #define CCW_CMD_READ_VQ_CONF 0x32
96
97 #define VIRTIO_CCW_DOING_SET_VQ 0x00010000
98 #define VIRTIO_CCW_DOING_RESET 0x00040000
99 #define VIRTIO_CCW_DOING_READ_FEAT 0x00080000
100 #define VIRTIO_CCW_DOING_WRITE_FEAT 0x00100000
101 #define VIRTIO_CCW_DOING_READ_CONFIG 0x00200000
102 #define VIRTIO_CCW_DOING_WRITE_CONFIG 0x00400000
103 #define VIRTIO_CCW_DOING_WRITE_STATUS 0x00800000
104 #define VIRTIO_CCW_DOING_SET_IND 0x01000000
105 #define VIRTIO_CCW_DOING_READ_VQ_CONF 0x02000000
106 #define VIRTIO_CCW_DOING_SET_CONF_IND 0x04000000
107 #define VIRTIO_CCW_INTPARM_MASK 0xffff0000
108
109 static struct virtio_ccw_device *to_vc_device(struct virtio_device *vdev)
110 {
111         return container_of(vdev, struct virtio_ccw_device, vdev);
112 }
113
114 static int doing_io(struct virtio_ccw_device *vcdev, __u32 flag)
115 {
116         unsigned long flags;
117         __u32 ret;
118
119         spin_lock_irqsave(get_ccwdev_lock(vcdev->cdev), flags);
120         if (vcdev->err)
121                 ret = 0;
122         else
123                 ret = vcdev->curr_io & flag;
124         spin_unlock_irqrestore(get_ccwdev_lock(vcdev->cdev), flags);
125         return ret;
126 }
127
128 static int ccw_io_helper(struct virtio_ccw_device *vcdev,
129                          struct ccw1 *ccw, __u32 intparm)
130 {
131         int ret;
132         unsigned long flags;
133         int flag = intparm & VIRTIO_CCW_INTPARM_MASK;
134
135         do {
136                 spin_lock_irqsave(get_ccwdev_lock(vcdev->cdev), flags);
137                 ret = ccw_device_start(vcdev->cdev, ccw, intparm, 0, 0);
138                 if (!ret)
139                         vcdev->curr_io |= flag;
140                 spin_unlock_irqrestore(get_ccwdev_lock(vcdev->cdev), flags);
141                 cpu_relax();
142         } while (ret == -EBUSY);
143         wait_event(vcdev->wait_q, doing_io(vcdev, flag) == 0);
144         return ret ? ret : vcdev->err;
145 }
146
147 static inline long do_kvm_notify(struct subchannel_id schid,
148                                  unsigned long queue_index)
149 {
150         register unsigned long __nr asm("1") = KVM_S390_VIRTIO_CCW_NOTIFY;
151         register struct subchannel_id __schid asm("2") = schid;
152         register unsigned long __index asm("3") = queue_index;
153         register long __rc asm("2");
154
155         asm volatile ("diag 2,4,0x500\n"
156                       : "=d" (__rc) : "d" (__nr), "d" (__schid), "d" (__index)
157                       : "memory", "cc");
158         return __rc;
159 }
160
161 static void virtio_ccw_kvm_notify(struct virtqueue *vq)
162 {
163         struct virtio_ccw_vq_info *info = vq->priv;
164         struct virtio_ccw_device *vcdev;
165         struct subchannel_id schid;
166
167         vcdev = to_vc_device(info->vq->vdev);
168         ccw_device_get_schid(vcdev->cdev, &schid);
169         do_kvm_notify(schid, virtqueue_get_queue_index(vq));
170 }
171
172 static int virtio_ccw_read_vq_conf(struct virtio_ccw_device *vcdev,
173                                    struct ccw1 *ccw, int index)
174 {
175         vcdev->config_block->index = index;
176         ccw->cmd_code = CCW_CMD_READ_VQ_CONF;
177         ccw->flags = 0;
178         ccw->count = sizeof(struct vq_config_block);
179         ccw->cda = (__u32)(unsigned long)(vcdev->config_block);
180         ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_VQ_CONF);
181         return vcdev->config_block->num;
182 }
183
184 static void virtio_ccw_del_vq(struct virtqueue *vq, struct ccw1 *ccw)
185 {
186         struct virtio_ccw_device *vcdev = to_vc_device(vq->vdev);
187         struct virtio_ccw_vq_info *info = vq->priv;
188         unsigned long flags;
189         unsigned long size;
190         int ret;
191         unsigned int index = virtqueue_get_queue_index(vq);
192
193         /* Remove from our list. */
194         spin_lock_irqsave(&vcdev->lock, flags);
195         list_del(&info->node);
196         spin_unlock_irqrestore(&vcdev->lock, flags);
197
198         /* Release from host. */
199         info->info_block->queue = 0;
200         info->info_block->align = 0;
201         info->info_block->index = index;
202         info->info_block->num = 0;
203         ccw->cmd_code = CCW_CMD_SET_VQ;
204         ccw->flags = 0;
205         ccw->count = sizeof(*info->info_block);
206         ccw->cda = (__u32)(unsigned long)(info->info_block);
207         ret = ccw_io_helper(vcdev, ccw,
208                             VIRTIO_CCW_DOING_SET_VQ | index);
209         /*
210          * -ENODEV isn't considered an error: The device is gone anyway.
211          * This may happen on device detach.
212          */
213         if (ret && (ret != -ENODEV))
214                 dev_warn(&vq->vdev->dev, "Error %d while deleting queue %d",
215                          ret, index);
216
217         vring_del_virtqueue(vq);
218         size = PAGE_ALIGN(vring_size(info->num, KVM_VIRTIO_CCW_RING_ALIGN));
219         free_pages_exact(info->queue, size);
220         kfree(info->info_block);
221         kfree(info);
222 }
223
224 static void virtio_ccw_del_vqs(struct virtio_device *vdev)
225 {
226         struct virtqueue *vq, *n;
227         struct ccw1 *ccw;
228
229         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
230         if (!ccw)
231                 return;
232
233
234         list_for_each_entry_safe(vq, n, &vdev->vqs, list)
235                 virtio_ccw_del_vq(vq, ccw);
236
237         kfree(ccw);
238 }
239
240 static struct virtqueue *virtio_ccw_setup_vq(struct virtio_device *vdev,
241                                              int i, vq_callback_t *callback,
242                                              const char *name,
243                                              struct ccw1 *ccw)
244 {
245         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
246         int err;
247         struct virtqueue *vq = NULL;
248         struct virtio_ccw_vq_info *info;
249         unsigned long size = 0; /* silence the compiler */
250         unsigned long flags;
251
252         /* Allocate queue. */
253         info = kzalloc(sizeof(struct virtio_ccw_vq_info), GFP_KERNEL);
254         if (!info) {
255                 dev_warn(&vcdev->cdev->dev, "no info\n");
256                 err = -ENOMEM;
257                 goto out_err;
258         }
259         info->info_block = kzalloc(sizeof(*info->info_block),
260                                    GFP_DMA | GFP_KERNEL);
261         if (!info->info_block) {
262                 dev_warn(&vcdev->cdev->dev, "no info block\n");
263                 err = -ENOMEM;
264                 goto out_err;
265         }
266         info->num = virtio_ccw_read_vq_conf(vcdev, ccw, i);
267         size = PAGE_ALIGN(vring_size(info->num, KVM_VIRTIO_CCW_RING_ALIGN));
268         info->queue = alloc_pages_exact(size, GFP_KERNEL | __GFP_ZERO);
269         if (info->queue == NULL) {
270                 dev_warn(&vcdev->cdev->dev, "no queue\n");
271                 err = -ENOMEM;
272                 goto out_err;
273         }
274
275         vq = vring_new_virtqueue(i, info->num, KVM_VIRTIO_CCW_RING_ALIGN, vdev,
276                                  true, info->queue, virtio_ccw_kvm_notify,
277                                  callback, name);
278         if (!vq) {
279                 /* For now, we fail if we can't get the requested size. */
280                 dev_warn(&vcdev->cdev->dev, "no vq\n");
281                 err = -ENOMEM;
282                 goto out_err;
283         }
284
285         /* Register it with the host. */
286         info->info_block->queue = (__u64)info->queue;
287         info->info_block->align = KVM_VIRTIO_CCW_RING_ALIGN;
288         info->info_block->index = i;
289         info->info_block->num = info->num;
290         ccw->cmd_code = CCW_CMD_SET_VQ;
291         ccw->flags = 0;
292         ccw->count = sizeof(*info->info_block);
293         ccw->cda = (__u32)(unsigned long)(info->info_block);
294         err = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_VQ | i);
295         if (err) {
296                 dev_warn(&vcdev->cdev->dev, "SET_VQ failed\n");
297                 goto out_err;
298         }
299
300         info->vq = vq;
301         vq->priv = info;
302
303         /* Save it to our list. */
304         spin_lock_irqsave(&vcdev->lock, flags);
305         list_add(&info->node, &vcdev->virtqueues);
306         spin_unlock_irqrestore(&vcdev->lock, flags);
307
308         return vq;
309
310 out_err:
311         if (vq)
312                 vring_del_virtqueue(vq);
313         if (info) {
314                 if (info->queue)
315                         free_pages_exact(info->queue, size);
316                 kfree(info->info_block);
317         }
318         kfree(info);
319         return ERR_PTR(err);
320 }
321
322 static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
323                                struct virtqueue *vqs[],
324                                vq_callback_t *callbacks[],
325                                const char *names[])
326 {
327         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
328         unsigned long *indicatorp = NULL;
329         int ret, i;
330         struct ccw1 *ccw;
331
332         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
333         if (!ccw)
334                 return -ENOMEM;
335
336         for (i = 0; i < nvqs; ++i) {
337                 vqs[i] = virtio_ccw_setup_vq(vdev, i, callbacks[i], names[i],
338                                              ccw);
339                 if (IS_ERR(vqs[i])) {
340                         ret = PTR_ERR(vqs[i]);
341                         vqs[i] = NULL;
342                         goto out;
343                 }
344         }
345         ret = -ENOMEM;
346         /* We need a data area under 2G to communicate. */
347         indicatorp = kmalloc(sizeof(&vcdev->indicators), GFP_DMA | GFP_KERNEL);
348         if (!indicatorp)
349                 goto out;
350         *indicatorp = (unsigned long) &vcdev->indicators;
351         /* Register queue indicators with host. */
352         vcdev->indicators = 0;
353         ccw->cmd_code = CCW_CMD_SET_IND;
354         ccw->flags = 0;
355         ccw->count = sizeof(vcdev->indicators);
356         ccw->cda = (__u32)(unsigned long) indicatorp;
357         ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_IND);
358         if (ret)
359                 goto out;
360         /* Register indicators2 with host for config changes */
361         *indicatorp = (unsigned long) &vcdev->indicators2;
362         vcdev->indicators2 = 0;
363         ccw->cmd_code = CCW_CMD_SET_CONF_IND;
364         ccw->flags = 0;
365         ccw->count = sizeof(vcdev->indicators2);
366         ccw->cda = (__u32)(unsigned long) indicatorp;
367         ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_CONF_IND);
368         if (ret)
369                 goto out;
370
371         kfree(indicatorp);
372         kfree(ccw);
373         return 0;
374 out:
375         kfree(indicatorp);
376         kfree(ccw);
377         virtio_ccw_del_vqs(vdev);
378         return ret;
379 }
380
381 static void virtio_ccw_reset(struct virtio_device *vdev)
382 {
383         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
384         struct ccw1 *ccw;
385
386         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
387         if (!ccw)
388                 return;
389
390         /* Zero status bits. */
391         *vcdev->status = 0;
392
393         /* Send a reset ccw on device. */
394         ccw->cmd_code = CCW_CMD_VDEV_RESET;
395         ccw->flags = 0;
396         ccw->count = 0;
397         ccw->cda = 0;
398         ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_RESET);
399         kfree(ccw);
400 }
401
402 static u32 virtio_ccw_get_features(struct virtio_device *vdev)
403 {
404         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
405         struct virtio_feature_desc *features;
406         int ret, rc;
407         struct ccw1 *ccw;
408
409         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
410         if (!ccw)
411                 return 0;
412
413         features = kzalloc(sizeof(*features), GFP_DMA | GFP_KERNEL);
414         if (!features) {
415                 rc = 0;
416                 goto out_free;
417         }
418         /* Read the feature bits from the host. */
419         /* TODO: Features > 32 bits */
420         features->index = 0;
421         ccw->cmd_code = CCW_CMD_READ_FEAT;
422         ccw->flags = 0;
423         ccw->count = sizeof(*features);
424         ccw->cda = (__u32)(unsigned long)features;
425         ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_FEAT);
426         if (ret) {
427                 rc = 0;
428                 goto out_free;
429         }
430
431         rc = le32_to_cpu(features->features);
432
433 out_free:
434         kfree(features);
435         kfree(ccw);
436         return rc;
437 }
438
439 static void virtio_ccw_finalize_features(struct virtio_device *vdev)
440 {
441         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
442         struct virtio_feature_desc *features;
443         int i;
444         struct ccw1 *ccw;
445
446         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
447         if (!ccw)
448                 return;
449
450         features = kzalloc(sizeof(*features), GFP_DMA | GFP_KERNEL);
451         if (!features)
452                 goto out_free;
453
454         /* Give virtio_ring a chance to accept features. */
455         vring_transport_features(vdev);
456
457         for (i = 0; i < sizeof(*vdev->features) / sizeof(features->features);
458              i++) {
459                 int highbits = i % 2 ? 32 : 0;
460                 features->index = i;
461                 features->features = cpu_to_le32(vdev->features[i / 2]
462                                                  >> highbits);
463                 /* Write the feature bits to the host. */
464                 ccw->cmd_code = CCW_CMD_WRITE_FEAT;
465                 ccw->flags = 0;
466                 ccw->count = sizeof(*features);
467                 ccw->cda = (__u32)(unsigned long)features;
468                 ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_FEAT);
469         }
470 out_free:
471         kfree(features);
472         kfree(ccw);
473 }
474
475 static void virtio_ccw_get_config(struct virtio_device *vdev,
476                                   unsigned int offset, void *buf, unsigned len)
477 {
478         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
479         int ret;
480         struct ccw1 *ccw;
481         void *config_area;
482
483         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
484         if (!ccw)
485                 return;
486
487         config_area = kzalloc(VIRTIO_CCW_CONFIG_SIZE, GFP_DMA | GFP_KERNEL);
488         if (!config_area)
489                 goto out_free;
490
491         /* Read the config area from the host. */
492         ccw->cmd_code = CCW_CMD_READ_CONF;
493         ccw->flags = 0;
494         ccw->count = offset + len;
495         ccw->cda = (__u32)(unsigned long)config_area;
496         ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_CONFIG);
497         if (ret)
498                 goto out_free;
499
500         memcpy(vcdev->config, config_area, sizeof(vcdev->config));
501         memcpy(buf, &vcdev->config[offset], len);
502
503 out_free:
504         kfree(config_area);
505         kfree(ccw);
506 }
507
508 static void virtio_ccw_set_config(struct virtio_device *vdev,
509                                   unsigned int offset, const void *buf,
510                                   unsigned len)
511 {
512         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
513         struct ccw1 *ccw;
514         void *config_area;
515
516         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
517         if (!ccw)
518                 return;
519
520         config_area = kzalloc(VIRTIO_CCW_CONFIG_SIZE, GFP_DMA | GFP_KERNEL);
521         if (!config_area)
522                 goto out_free;
523
524         memcpy(&vcdev->config[offset], buf, len);
525         /* Write the config area to the host. */
526         memcpy(config_area, vcdev->config, sizeof(vcdev->config));
527         ccw->cmd_code = CCW_CMD_WRITE_CONF;
528         ccw->flags = 0;
529         ccw->count = offset + len;
530         ccw->cda = (__u32)(unsigned long)config_area;
531         ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_CONFIG);
532
533 out_free:
534         kfree(config_area);
535         kfree(ccw);
536 }
537
538 static u8 virtio_ccw_get_status(struct virtio_device *vdev)
539 {
540         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
541
542         return *vcdev->status;
543 }
544
545 static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)
546 {
547         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
548         struct ccw1 *ccw;
549
550         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
551         if (!ccw)
552                 return;
553
554         /* Write the status to the host. */
555         *vcdev->status = status;
556         ccw->cmd_code = CCW_CMD_WRITE_STATUS;
557         ccw->flags = 0;
558         ccw->count = sizeof(status);
559         ccw->cda = (__u32)(unsigned long)vcdev->status;
560         ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_STATUS);
561         kfree(ccw);
562 }
563
564 static struct virtio_config_ops virtio_ccw_config_ops = {
565         .get_features = virtio_ccw_get_features,
566         .finalize_features = virtio_ccw_finalize_features,
567         .get = virtio_ccw_get_config,
568         .set = virtio_ccw_set_config,
569         .get_status = virtio_ccw_get_status,
570         .set_status = virtio_ccw_set_status,
571         .reset = virtio_ccw_reset,
572         .find_vqs = virtio_ccw_find_vqs,
573         .del_vqs = virtio_ccw_del_vqs,
574 };
575
576
577 /*
578  * ccw bus driver related functions
579  */
580
581 static void virtio_ccw_release_dev(struct device *_d)
582 {
583         struct virtio_device *dev = container_of(_d, struct virtio_device,
584                                                  dev);
585         struct virtio_ccw_device *vcdev = to_vc_device(dev);
586
587         kfree(vcdev->status);
588         kfree(vcdev->config_block);
589         kfree(vcdev);
590 }
591
592 static int irb_is_error(struct irb *irb)
593 {
594         if (scsw_cstat(&irb->scsw) != 0)
595                 return 1;
596         if (scsw_dstat(&irb->scsw) & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END))
597                 return 1;
598         if (scsw_cc(&irb->scsw) != 0)
599                 return 1;
600         return 0;
601 }
602
603 static struct virtqueue *virtio_ccw_vq_by_ind(struct virtio_ccw_device *vcdev,
604                                               int index)
605 {
606         struct virtio_ccw_vq_info *info;
607         unsigned long flags;
608         struct virtqueue *vq;
609
610         vq = NULL;
611         spin_lock_irqsave(&vcdev->lock, flags);
612         list_for_each_entry(info, &vcdev->virtqueues, node) {
613                 if (virtqueue_get_queue_index(info->vq) == index) {
614                         vq = info->vq;
615                         break;
616                 }
617         }
618         spin_unlock_irqrestore(&vcdev->lock, flags);
619         return vq;
620 }
621
622 static void virtio_ccw_int_handler(struct ccw_device *cdev,
623                                    unsigned long intparm,
624                                    struct irb *irb)
625 {
626         __u32 activity = intparm & VIRTIO_CCW_INTPARM_MASK;
627         struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
628         int i;
629         struct virtqueue *vq;
630         struct virtio_driver *drv;
631
632         /* Check if it's a notification from the host. */
633         if ((intparm == 0) &&
634             (scsw_stctl(&irb->scsw) ==
635              (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND))) {
636                 /* OK */
637         }
638         if (irb_is_error(irb))
639                 vcdev->err = -EIO; /* XXX - use real error */
640         if (vcdev->curr_io & activity) {
641                 switch (activity) {
642                 case VIRTIO_CCW_DOING_READ_FEAT:
643                 case VIRTIO_CCW_DOING_WRITE_FEAT:
644                 case VIRTIO_CCW_DOING_READ_CONFIG:
645                 case VIRTIO_CCW_DOING_WRITE_CONFIG:
646                 case VIRTIO_CCW_DOING_WRITE_STATUS:
647                 case VIRTIO_CCW_DOING_SET_VQ:
648                 case VIRTIO_CCW_DOING_SET_IND:
649                 case VIRTIO_CCW_DOING_SET_CONF_IND:
650                 case VIRTIO_CCW_DOING_RESET:
651                 case VIRTIO_CCW_DOING_READ_VQ_CONF:
652                         vcdev->curr_io &= ~activity;
653                         wake_up(&vcdev->wait_q);
654                         break;
655                 default:
656                         /* don't know what to do... */
657                         dev_warn(&cdev->dev, "Suspicious activity '%08x'\n",
658                                  activity);
659                         WARN_ON(1);
660                         break;
661                 }
662         }
663         for_each_set_bit(i, &vcdev->indicators,
664                          sizeof(vcdev->indicators) * BITS_PER_BYTE) {
665                 /* The bit clear must happen before the vring kick. */
666                 clear_bit(i, &vcdev->indicators);
667                 barrier();
668                 vq = virtio_ccw_vq_by_ind(vcdev, i);
669                 vring_interrupt(0, vq);
670         }
671         if (test_bit(0, &vcdev->indicators2)) {
672                 drv = container_of(vcdev->vdev.dev.driver,
673                                    struct virtio_driver, driver);
674
675                 if (drv && drv->config_changed)
676                         drv->config_changed(&vcdev->vdev);
677                 clear_bit(0, &vcdev->indicators2);
678         }
679 }
680
681 /*
682  * We usually want to autoonline all devices, but give the admin
683  * a way to exempt devices from this.
684  */
685 #define __DEV_WORDS ((__MAX_SUBCHANNEL + (8*sizeof(long) - 1)) / \
686                      (8*sizeof(long)))
687 static unsigned long devs_no_auto[__MAX_SSID + 1][__DEV_WORDS];
688
689 static char *no_auto = "";
690
691 module_param(no_auto, charp, 0444);
692 MODULE_PARM_DESC(no_auto, "list of ccw bus id ranges not to be auto-onlined");
693
694 static int virtio_ccw_check_autoonline(struct ccw_device *cdev)
695 {
696         struct ccw_dev_id id;
697
698         ccw_device_get_id(cdev, &id);
699         if (test_bit(id.devno, devs_no_auto[id.ssid]))
700                 return 0;
701         return 1;
702 }
703
704 static void virtio_ccw_auto_online(void *data, async_cookie_t cookie)
705 {
706         struct ccw_device *cdev = data;
707         int ret;
708
709         ret = ccw_device_set_online(cdev);
710         if (ret)
711                 dev_warn(&cdev->dev, "Failed to set online: %d\n", ret);
712 }
713
714 static int virtio_ccw_probe(struct ccw_device *cdev)
715 {
716         cdev->handler = virtio_ccw_int_handler;
717
718         if (virtio_ccw_check_autoonline(cdev))
719                 async_schedule(virtio_ccw_auto_online, cdev);
720         return 0;
721 }
722
723 static void virtio_ccw_remove(struct ccw_device *cdev)
724 {
725         struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
726
727         if (cdev->online) {
728                 unregister_virtio_device(&vcdev->vdev);
729                 dev_set_drvdata(&cdev->dev, NULL);
730         }
731         cdev->handler = NULL;
732 }
733
734 static int virtio_ccw_offline(struct ccw_device *cdev)
735 {
736         struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
737
738         unregister_virtio_device(&vcdev->vdev);
739         dev_set_drvdata(&cdev->dev, NULL);
740         return 0;
741 }
742
743
744 static int virtio_ccw_online(struct ccw_device *cdev)
745 {
746         int ret;
747         struct virtio_ccw_device *vcdev;
748
749         vcdev = kzalloc(sizeof(*vcdev), GFP_KERNEL);
750         if (!vcdev) {
751                 dev_warn(&cdev->dev, "Could not get memory for virtio\n");
752                 ret = -ENOMEM;
753                 goto out_free;
754         }
755         vcdev->config_block = kzalloc(sizeof(*vcdev->config_block),
756                                    GFP_DMA | GFP_KERNEL);
757         if (!vcdev->config_block) {
758                 ret = -ENOMEM;
759                 goto out_free;
760         }
761         vcdev->status = kzalloc(sizeof(*vcdev->status), GFP_DMA | GFP_KERNEL);
762         if (!vcdev->status) {
763                 ret = -ENOMEM;
764                 goto out_free;
765         }
766
767         vcdev->vdev.dev.parent = &cdev->dev;
768         vcdev->vdev.dev.release = virtio_ccw_release_dev;
769         vcdev->vdev.config = &virtio_ccw_config_ops;
770         vcdev->cdev = cdev;
771         init_waitqueue_head(&vcdev->wait_q);
772         INIT_LIST_HEAD(&vcdev->virtqueues);
773         spin_lock_init(&vcdev->lock);
774
775         dev_set_drvdata(&cdev->dev, vcdev);
776         vcdev->vdev.id.vendor = cdev->id.cu_type;
777         vcdev->vdev.id.device = cdev->id.cu_model;
778         ret = register_virtio_device(&vcdev->vdev);
779         if (ret) {
780                 dev_warn(&cdev->dev, "Failed to register virtio device: %d\n",
781                          ret);
782                 goto out_put;
783         }
784         return 0;
785 out_put:
786         dev_set_drvdata(&cdev->dev, NULL);
787         put_device(&vcdev->vdev.dev);
788         return ret;
789 out_free:
790         if (vcdev) {
791                 kfree(vcdev->status);
792                 kfree(vcdev->config_block);
793         }
794         kfree(vcdev);
795         return ret;
796 }
797
798 static int virtio_ccw_cio_notify(struct ccw_device *cdev, int event)
799 {
800         /* TODO: Check whether we need special handling here. */
801         return 0;
802 }
803
804 static struct ccw_device_id virtio_ids[] = {
805         { CCW_DEVICE(0x3832, 0) },
806         {},
807 };
808 MODULE_DEVICE_TABLE(ccw, virtio_ids);
809
810 static struct ccw_driver virtio_ccw_driver = {
811         .driver = {
812                 .owner = THIS_MODULE,
813                 .name = "virtio_ccw",
814         },
815         .ids = virtio_ids,
816         .probe = virtio_ccw_probe,
817         .remove = virtio_ccw_remove,
818         .set_offline = virtio_ccw_offline,
819         .set_online = virtio_ccw_online,
820         .notify = virtio_ccw_cio_notify,
821         .int_class = IOINT_VIR,
822 };
823
824 static int __init pure_hex(char **cp, unsigned int *val, int min_digit,
825                            int max_digit, int max_val)
826 {
827         int diff;
828
829         diff = 0;
830         *val = 0;
831
832         while (diff <= max_digit) {
833                 int value = hex_to_bin(**cp);
834
835                 if (value < 0)
836                         break;
837                 *val = *val * 16 + value;
838                 (*cp)++;
839                 diff++;
840         }
841
842         if ((diff < min_digit) || (diff > max_digit) || (*val > max_val))
843                 return 1;
844
845         return 0;
846 }
847
848 static int __init parse_busid(char *str, unsigned int *cssid,
849                               unsigned int *ssid, unsigned int *devno)
850 {
851         char *str_work;
852         int rc, ret;
853
854         rc = 1;
855
856         if (*str == '\0')
857                 goto out;
858
859         str_work = str;
860         ret = pure_hex(&str_work, cssid, 1, 2, __MAX_CSSID);
861         if (ret || (str_work[0] != '.'))
862                 goto out;
863         str_work++;
864         ret = pure_hex(&str_work, ssid, 1, 1, __MAX_SSID);
865         if (ret || (str_work[0] != '.'))
866                 goto out;
867         str_work++;
868         ret = pure_hex(&str_work, devno, 4, 4, __MAX_SUBCHANNEL);
869         if (ret || (str_work[0] != '\0'))
870                 goto out;
871
872         rc = 0;
873 out:
874         return rc;
875 }
876
877 static void __init no_auto_parse(void)
878 {
879         unsigned int from_cssid, to_cssid, from_ssid, to_ssid, from, to;
880         char *parm, *str;
881         int rc;
882
883         str = no_auto;
884         while ((parm = strsep(&str, ","))) {
885                 rc = parse_busid(strsep(&parm, "-"), &from_cssid,
886                                  &from_ssid, &from);
887                 if (rc)
888                         continue;
889                 if (parm != NULL) {
890                         rc = parse_busid(parm, &to_cssid,
891                                          &to_ssid, &to);
892                         if ((from_ssid > to_ssid) ||
893                             ((from_ssid == to_ssid) && (from > to)))
894                                 rc = -EINVAL;
895                 } else {
896                         to_cssid = from_cssid;
897                         to_ssid = from_ssid;
898                         to = from;
899                 }
900                 if (rc)
901                         continue;
902                 while ((from_ssid < to_ssid) ||
903                        ((from_ssid == to_ssid) && (from <= to))) {
904                         set_bit(from, devs_no_auto[from_ssid]);
905                         from++;
906                         if (from > __MAX_SUBCHANNEL) {
907                                 from_ssid++;
908                                 from = 0;
909                         }
910                 }
911         }
912 }
913
914 static int __init virtio_ccw_init(void)
915 {
916         /* parse no_auto string before we do anything further */
917         no_auto_parse();
918         return ccw_driver_register(&virtio_ccw_driver);
919 }
920 module_init(virtio_ccw_init);
921
922 static void __exit virtio_ccw_exit(void)
923 {
924         ccw_driver_unregister(&virtio_ccw_driver);
925 }
926 module_exit(virtio_ccw_exit);