1 files changed, 306 insertions, 17 deletions

diff --git a/drivers/s390/kvm/virtio_ccw.c b/drivers/s390/kvm/virtio_ccw.c
index 0fc584832001..1e1fc671f89a 100644
--- a/drivers/s390/kvm/virtio_ccw.c
+++ b/drivers/s390/kvm/virtio_ccw.c
@@ -1,7 +1,7 @@
 /*
  * ccw based virtio transport
  *
- * Copyright IBM Corp. 2012
+ * Copyright IBM Corp. 2012, 2014
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License (version 2 only)
@@ -32,6 +32,8 @@
 #include <asm/cio.h>
 #include <asm/ccwdev.h>
 #include <asm/virtio-ccw.h>
+#include <asm/isc.h>
+#include <asm/airq.h>
 
 /*
  * virtio related functions
@@ -58,6 +60,9 @@ struct virtio_ccw_device {
         unsigned long indicators;
         unsigned long indicators2;
         struct vq_config_block *config_block;
+        bool is_thinint;
+        bool going_away;
+        void *airq_info;
 };
 
 struct vq_info_block {
@@ -72,15 +77,38 @@ struct virtio_feature_desc {
         __u8 index;
 } __packed;
 
+struct virtio_thinint_area {
+        unsigned long summary_indicator;
+        unsigned long indicator;
+        u64 bit_nr;
+        u8 isc;
+} __packed;
+
 struct virtio_ccw_vq_info {
         struct virtqueue *vq;
         int num;
         void *queue;
         struct vq_info_block *info_block;
+        int bit_nr;
         struct list_head node;
         long cookie;
 };
 
+#define VIRTIO_AIRQ_ISC IO_SCH_ISC /* inherit from subchannel */
+
+#define VIRTIO_IV_BITS (L1_CACHE_BYTES * 8)
+#define MAX_AIRQ_AREAS 20
+
+static int virtio_ccw_use_airq = 1;
+
+struct airq_info {
+        rwlock_t lock;
+        u8 summary_indicator;
+        struct airq_struct airq;
+        struct airq_iv *aiv;
+};
+static struct airq_info *airq_areas[MAX_AIRQ_AREAS];
+
 #define CCW_CMD_SET_VQ 0x13
 #define CCW_CMD_VDEV_RESET 0x33
 #define CCW_CMD_SET_IND 0x43
@@ -91,6 +119,7 @@ struct virtio_ccw_vq_info {
 #define CCW_CMD_WRITE_CONF 0x21
 #define CCW_CMD_WRITE_STATUS 0x31
 #define CCW_CMD_READ_VQ_CONF 0x32
+#define CCW_CMD_SET_IND_ADAPTER 0x73
 
 #define VIRTIO_CCW_DOING_SET_VQ 0x00010000
 #define VIRTIO_CCW_DOING_RESET 0x00040000
@@ -102,6 +131,7 @@ struct virtio_ccw_vq_info {
 #define VIRTIO_CCW_DOING_SET_IND 0x01000000
 #define VIRTIO_CCW_DOING_READ_VQ_CONF 0x02000000
 #define VIRTIO_CCW_DOING_SET_CONF_IND 0x04000000
+#define VIRTIO_CCW_DOING_SET_IND_ADAPTER 0x08000000
 #define VIRTIO_CCW_INTPARM_MASK 0xffff0000
 
 static struct virtio_ccw_device *to_vc_device(struct virtio_device *vdev)
@@ -109,6 +139,125 @@ static struct virtio_ccw_device *to_vc_device(struct virtio_device *vdev)
         return container_of(vdev, struct virtio_ccw_device, vdev);
 }
 
+static void drop_airq_indicator(struct virtqueue *vq, struct airq_info *info)
+{
+        unsigned long i, flags;
+
+        write_lock_irqsave(&info->lock, flags);
+        for (i = 0; i < airq_iv_end(info->aiv); i++) {
+                if (vq == (void *)airq_iv_get_ptr(info->aiv, i)) {
+                        airq_iv_free_bit(info->aiv, i);
+                        airq_iv_set_ptr(info->aiv, i, 0);
+                        break;
+                }
+        }
+        write_unlock_irqrestore(&info->lock, flags);
+}
+
+static void virtio_airq_handler(struct airq_struct *airq)
+{
+        struct airq_info *info = container_of(airq, struct airq_info, airq);
+        unsigned long ai;
+
+        inc_irq_stat(IRQIO_VAI);
+        read_lock(&info->lock);
+        /* Walk through indicators field, summary indicator active. */
+        for (ai = 0;;) {
+                ai = airq_iv_scan(info->aiv, ai, airq_iv_end(info->aiv));
+                if (ai == -1UL)
+                        break;
+                vring_interrupt(0, (void *)airq_iv_get_ptr(info->aiv, ai));
+        }
+        info->summary_indicator = 0;
+        smp_wmb();
+        /* Walk through indicators field, summary indicator not active. */
+        for (ai = 0;;) {
+                ai = airq_iv_scan(info->aiv, ai, airq_iv_end(info->aiv));
+                if (ai == -1UL)
+                        break;
+                vring_interrupt(0, (void *)airq_iv_get_ptr(info->aiv, ai));
+        }
+        read_unlock(&info->lock);
+}
+
+static struct airq_info *new_airq_info(void)
+{
+        struct airq_info *info;
+        int rc;
+
+        info = kzalloc(sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return NULL;
+        rwlock_init(&info->lock);
+        info->aiv = airq_iv_create(VIRTIO_IV_BITS, AIRQ_IV_ALLOC | AIRQ_IV_PTR);
+        if (!info->aiv) {
+                kfree(info);
+                return NULL;
+        }
+        info->airq.handler = virtio_airq_handler;
+        info->airq.lsi_ptr = &info->summary_indicator;
+        info->airq.lsi_mask = 0xff;
+        info->airq.isc = VIRTIO_AIRQ_ISC;
+        rc = register_adapter_interrupt(&info->airq);
+        if (rc) {
+                airq_iv_release(info->aiv);
+                kfree(info);
+                return NULL;
+        }
+        return info;
+}
+
+static void destroy_airq_info(struct airq_info *info)
+{
+        if (!info)
+                return;
+
+        unregister_adapter_interrupt(&info->airq);
+        airq_iv_release(info->aiv);
+        kfree(info);
+}
+
+static unsigned long get_airq_indicator(struct virtqueue *vqs[], int nvqs,
+                                        u64 *first, void **airq_info)
+{
+        int i, j;
+        struct airq_info *info;
+        unsigned long indicator_addr = 0;
+        unsigned long bit, flags;
+
+        for (i = 0; i < MAX_AIRQ_AREAS && !indicator_addr; i++) {
+                if (!airq_areas[i])
+                        airq_areas[i] = new_airq_info();
+                info = airq_areas[i];
+                if (!info)
+                        return 0;
+                write_lock_irqsave(&info->lock, flags);
+                bit = airq_iv_alloc(info->aiv, nvqs);
+                if (bit == -1UL) {
+                        /* Not enough vacancies. */
+                        write_unlock_irqrestore(&info->lock, flags);
+                        continue;
+                }
+                *first = bit;
+                *airq_info = info;
+                indicator_addr = (unsigned long)info->aiv->vector;
+                for (j = 0; j < nvqs; j++) {
+                        airq_iv_set_ptr(info->aiv, bit + j,
+                                        (unsigned long)vqs[j]);
+                }
+                write_unlock_irqrestore(&info->lock, flags);
+        }
+        return indicator_addr;
+}
+
+static void virtio_ccw_drop_indicators(struct virtio_ccw_device *vcdev)
+{
+        struct virtio_ccw_vq_info *info;
+
+        list_for_each_entry(info, &vcdev->virtqueues, node)
+                drop_airq_indicator(info->vq, vcdev->airq_info);
+}
+
 static int doing_io(struct virtio_ccw_device *vcdev, __u32 flag)
 {
         unsigned long flags;
@@ -145,6 +294,51 @@ static int ccw_io_helper(struct virtio_ccw_device *vcdev,
         return ret ? ret : vcdev->err;
 }
 
+static void virtio_ccw_drop_indicator(struct virtio_ccw_device *vcdev,
+                                      struct ccw1 *ccw)
+{
+        int ret;
+        unsigned long *indicatorp = NULL;
+        struct virtio_thinint_area *thinint_area = NULL;
+        struct airq_info *airq_info = vcdev->airq_info;
+
+        if (vcdev->is_thinint) {
+                thinint_area = kzalloc(sizeof(*thinint_area),
+                                       GFP_DMA | GFP_KERNEL);
+                if (!thinint_area)
+                        return;
+                thinint_area->summary_indicator =
+                        (unsigned long) &airq_info->summary_indicator;
+                thinint_area->isc = VIRTIO_AIRQ_ISC;
+                ccw->cmd_code = CCW_CMD_SET_IND_ADAPTER;
+                ccw->count = sizeof(*thinint_area);
+                ccw->cda = (__u32)(unsigned long) thinint_area;
+        } else {
+                indicatorp = kmalloc(sizeof(&vcdev->indicators),
+                                     GFP_DMA | GFP_KERNEL);
+                if (!indicatorp)
+                        return;
+                *indicatorp = 0;
+                ccw->cmd_code = CCW_CMD_SET_IND;
+                ccw->count = sizeof(vcdev->indicators);
+                ccw->cda = (__u32)(unsigned long) indicatorp;
+        }
+        /* Deregister indicators from host. */
+        vcdev->indicators = 0;
+        ccw->flags = 0;
+        ret = ccw_io_helper(vcdev, ccw,
+                            vcdev->is_thinint ?
+                            VIRTIO_CCW_DOING_SET_IND_ADAPTER :
+                            VIRTIO_CCW_DOING_SET_IND);
+        if (ret && (ret != -ENODEV))
+                dev_info(&vcdev->cdev->dev,
+                         "Failed to deregister indicators (%d)\n", ret);
+        else if (vcdev->is_thinint)
+                virtio_ccw_drop_indicators(vcdev);
+        kfree(indicatorp);
+        kfree(thinint_area);
+}
+
 static inline long do_kvm_notify(struct subchannel_id schid,
                                  unsigned long queue_index,
                                  long cookie)
@@ -232,11 +426,13 @@ static void virtio_ccw_del_vqs(struct virtio_device *vdev)
 {
         struct virtqueue *vq, *n;
         struct ccw1 *ccw;
+        struct virtio_ccw_device *vcdev = to_vc_device(vdev);
 
         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
         if (!ccw)
                 return;
 
+        virtio_ccw_drop_indicator(vcdev, ccw);
 
         list_for_each_entry_safe(vq, n, &vdev->vqs, list)
                 virtio_ccw_del_vq(vq, ccw);
@@ -326,6 +522,54 @@ out_err:
         return ERR_PTR(err);
 }
 
+static int virtio_ccw_register_adapter_ind(struct virtio_ccw_device *vcdev,
+                                           struct virtqueue *vqs[], int nvqs,
+                                           struct ccw1 *ccw)
+{
+        int ret;
+        struct virtio_thinint_area *thinint_area = NULL;
+        struct airq_info *info;
+
+        thinint_area = kzalloc(sizeof(*thinint_area), GFP_DMA | GFP_KERNEL);
+        if (!thinint_area) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        /* Try to get an indicator. */
+        thinint_area->indicator = get_airq_indicator(vqs, nvqs,
+                                                     &thinint_area->bit_nr,
+                                                     &vcdev->airq_info);
+        if (!thinint_area->indicator) {
+                ret = -ENOSPC;
+                goto out;
+        }
+        info = vcdev->airq_info;
+        thinint_area->summary_indicator =
+                (unsigned long) &info->summary_indicator;
+        thinint_area->isc = VIRTIO_AIRQ_ISC;
+        ccw->cmd_code = CCW_CMD_SET_IND_ADAPTER;
+        ccw->flags = CCW_FLAG_SLI;
+        ccw->count = sizeof(*thinint_area);
+        ccw->cda = (__u32)(unsigned long)thinint_area;
+        ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_IND_ADAPTER);
+        if (ret) {
+                if (ret == -EOPNOTSUPP) {
+                        /*
+                         * The host does not support adapter interrupts
+                         * for virtio-ccw, stop trying.
+                         */
+                        virtio_ccw_use_airq = 0;
+                        pr_info("Adapter interrupts unsupported on host\n");
+                } else
+                        dev_warn(&vcdev->cdev->dev,
+                                 "enabling adapter interrupts = %d\n", ret);
+                virtio_ccw_drop_indicators(vcdev);
+        }
+out:
+        kfree(thinint_area);
+        return ret;
+}
+
 static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
                                struct virtqueue *vqs[],
                                vq_callback_t *callbacks[],
@@ -355,15 +599,23 @@ static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
         if (!indicatorp)
                 goto out;
         *indicatorp = (unsigned long) &vcdev->indicators;
-        /* Register queue indicators with host. */
-        vcdev->indicators = 0;
-        ccw->cmd_code = CCW_CMD_SET_IND;
-        ccw->flags = 0;
-        ccw->count = sizeof(vcdev->indicators);
-        ccw->cda = (__u32)(unsigned long) indicatorp;
-        ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_IND);
-        if (ret)
-                goto out;
+        if (vcdev->is_thinint) {
+                ret = virtio_ccw_register_adapter_ind(vcdev, vqs, nvqs, ccw);
+                if (ret)
+                        /* no error, just fall back to legacy interrupts */
+                        vcdev->is_thinint = 0;
+        }
+        if (!vcdev->is_thinint) {
+                /* Register queue indicators with host. */
+                vcdev->indicators = 0;
+                ccw->cmd_code = CCW_CMD_SET_IND;
+                ccw->flags = 0;
+                ccw->count = sizeof(vcdev->indicators);
+                ccw->cda = (__u32)(unsigned long) indicatorp;
+                ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_IND);
+                if (ret)
+                        goto out;
+        }
         /* Register indicators2 with host for config changes */
         *indicatorp = (unsigned long) &vcdev->indicators2;
         vcdev->indicators2 = 0;
@@ -636,6 +888,8 @@ static void virtio_ccw_int_handler(struct ccw_device *cdev,
         struct virtqueue *vq;
         struct virtio_driver *drv;
 
+        if (!vcdev)
+                return;
         /* Check if it's a notification from the host. */
         if ((intparm == 0) &&
             (scsw_stctl(&irb->scsw) ==
@@ -663,6 +917,7 @@ static void virtio_ccw_int_handler(struct ccw_device *cdev,
                 case VIRTIO_CCW_DOING_SET_CONF_IND:
                 case VIRTIO_CCW_DOING_RESET:
                 case VIRTIO_CCW_DOING_READ_VQ_CONF:
+                case VIRTIO_CCW_DOING_SET_IND_ADAPTER:
                         vcdev->curr_io &= ~activity;
                         wake_up(&vcdev->wait_q);
                         break;
@@ -734,23 +989,46 @@ static int virtio_ccw_probe(struct ccw_device *cdev)
         return 0;
 }
 
+static struct virtio_ccw_device *virtio_grab_drvdata(struct ccw_device *cdev)
+{
+        unsigned long flags;
+        struct virtio_ccw_device *vcdev;
+
+        spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
+        vcdev = dev_get_drvdata(&cdev->dev);
+        if (!vcdev || vcdev->going_away) {
+                spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
+                return NULL;
+        }
+        vcdev->going_away = true;
+        spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
+        return vcdev;
+}
+
 static void virtio_ccw_remove(struct ccw_device *cdev)
 {
-        struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
+        unsigned long flags;
+        struct virtio_ccw_device *vcdev = virtio_grab_drvdata(cdev);
 
-        if (cdev->online) {
+        if (vcdev && cdev->online)
                 unregister_virtio_device(&vcdev->vdev);
-                dev_set_drvdata(&cdev->dev, NULL);
-        }
+        spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
+        dev_set_drvdata(&cdev->dev, NULL);
+        spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
         cdev->handler = NULL;
 }
 
 static int virtio_ccw_offline(struct ccw_device *cdev)
 {
-        struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
+        unsigned long flags;
+        struct virtio_ccw_device *vcdev = virtio_grab_drvdata(cdev);
 
-        unregister_virtio_device(&vcdev->vdev);
-        dev_set_drvdata(&cdev->dev, NULL);
+        if (vcdev) {
+                unregister_virtio_device(&vcdev->vdev);
+                spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
+                dev_set_drvdata(&cdev->dev, NULL);
+                spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
+        }
         return 0;
 }
 
@@ -759,6 +1037,7 @@ static int virtio_ccw_online(struct ccw_device *cdev)
 {
         int ret;
         struct virtio_ccw_device *vcdev;
+        unsigned long flags;
 
         vcdev = kzalloc(sizeof(*vcdev), GFP_KERNEL);
         if (!vcdev) {
@@ -778,6 +1057,8 @@ static int virtio_ccw_online(struct ccw_device *cdev)
                 goto out_free;
         }
 
+        vcdev->is_thinint = virtio_ccw_use_airq; /* at least try */
+
         vcdev->vdev.dev.parent = &cdev->dev;
         vcdev->vdev.dev.release = virtio_ccw_release_dev;
         vcdev->vdev.config = &virtio_ccw_config_ops;
@@ -786,7 +1067,9 @@ static int virtio_ccw_online(struct ccw_device *cdev)
         INIT_LIST_HEAD(&vcdev->virtqueues);
         spin_lock_init(&vcdev->lock);
 
+        spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
         dev_set_drvdata(&cdev->dev, vcdev);
+        spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
         vcdev->vdev.id.vendor = cdev->id.cu_type;
         vcdev->vdev.id.device = cdev->id.cu_model;
         ret = register_virtio_device(&vcdev->vdev);
@@ -797,7 +1080,9 @@ static int virtio_ccw_online(struct ccw_device *cdev)
         }
         return 0;
 out_put:
+        spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
         dev_set_drvdata(&cdev->dev, NULL);
+        spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
         put_device(&vcdev->vdev.dev);
         return ret;
 out_free:
@@ -935,6 +1220,10 @@ module_init(virtio_ccw_init);
 
 static void __exit virtio_ccw_exit(void)
 {
+        int i;
+
         ccw_driver_unregister(&virtio_ccw_driver);
+        for (i = 0; i < MAX_AIRQ_AREAS; i++)
+                destroy_airq_info(airq_areas[i]);
 }
 module_exit(virtio_ccw_exit);